CodePolicy 11.0.3 Rother OSS GmbH https://otobo.io/ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Added eslint (#129), improved output coloring (#140); change handling of package markers (#134), several smaller improvements and tidying. Fix support for ESLint (#24), set url only for specific vendors (us #116), allow empty xml files (#122), enforce Location in sopm file list to be unique (#123), check used perl versions (#125), small sopm definition improvement (#126). Various improvements and changes. - Issue #114: do not filter out Test2::Tools::Spec - Issue #112: Acme modules are just for fun - Issue #109: prohibit $DB::single in production code - Issue #66: there is no WebApp in OTOBO - Issue #106: accept object manager creation - Issue #104: eliminate TidyAll::Plugin::OTOBO::Perl::Dumper - Issue #102: prohibit usage of the pragma 'vars' - Issue #99: activate Variables::RequireInitializationForLocalVars - Issue #97: activate Modules::ProhibitConditionalUseStatements - Issue #95: activate Subroutines::ProhibitAmpersandSigils - Issue #91: enable Perl::Critic policies - Issue #92: add PUTDATA, POSTDATA, PATCHDATE to whitelist - Issue #89: activate BuiltinFunctions::ProhibitStringySplit - Issue #86: add 'iCalendar' to the white list OTOBO code quality checks. OTOBO kódminőség ellenőrzések. 11.0.x Code::TidyAll Perl::Critic 5a39c5954078044ff6e5896b9361bb6fbbaae244 2026-10-29 11:11:19 opms.rother-oss.com #!/usr/bin/env perl
# --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --
use strict;
use warnings;
use v5.24;
use utf8;
use open IO => ':encoding(UTF-8)';

use File::Basename qw(dirname);
use FindBin        qw($RealBin);
use lib dirname($RealBin);
use lib dirname($RealBin) . '/Kernel';    # Find TidyAll
use lib dirname($RealBin) . '/Kernel/cpan-lib';

# core modules
use Cwd;
use File::Basename;
use File::Spec;
use Getopt::Long;
use File::Find;
use File::Path qw();

# CPAN modules
use Code::TidyAll;
use IPC::System::Simple qw(capturex);

# OTOBO modules
use TidyAll::OTOBO;

# avoid managling of output
STDOUT->autoflush();

my ( $Verbose, $Directory, $File, $Mode, $Cached, $All, $Help, $Processes, @FileList );
my $Plugins = [];
GetOptions(
    'verbose'     => \$Verbose,
    'all'         => \$All,
    'cached'      => \$Cached,
    'directory=s' => \$Directory,
    'file=s'      => \$File,
    'mode=s'      => \$Mode,
    'help'        => \$Help,
    'processes=s' => \$Processes,
    'plugins=s@'  => \$Plugins,
    'list=s{1,}'  => \@FileList,
);

if ($Help) {
    print <<"END_MSG";
Usage: OTOBOCodePolicy/bin/otobo.CodePolicy.pl [options]

    Performs OTOBO code policy checks. Run this script from the toplevel directory
    of your module. By default it will only process files which are staged for
    git commit. Use --all or --directory to check all files or just one directory
    instead.

Options:
    -a, --all           Check all files recursively
    -d, --directory     Check only subdirectory
    -c, --cached        Check only cached (staged files in git directory)
    -f, --file          Check only one file
    -l, --list          Check several files
    -m, --mode          Use custom Code::TidyAll mode (default: cli)
    -v, --verbose       Activate diagnostics
    -p, --processes     The number of processes to use (default: env var OTOBOCODEPOLICY_PROCESSES if set, otherwise "6")
    --plugins           Restrict to specific plugin that should be used. Pass the option multiple time for multiple plugins.
    -h, --help          Show this usage message

Example usage:

    # run Perl::Critic on a source tree
    ../CodePolicy/bin/otobo.CodePolicy.pl --plugins +TidyAll::Plugin::OTOBO::Perl::PerlCritic -a --processes 1 1>critic.out

    # run only the syntax check on changed files
    ../CodePolicy/bin/otobo.CodePolicy.pl --plugins +TidyAll::Plugin::OTOBO::Perl::SyntaxCheck

    # only update the copyright year for all files
    ../CodePolicy/bin/otobo.CodePolicy.pl --plugins +TidyAll::Plugin::OTOBO::Legal::ReplaceCopyright -a

END_MSG

    exit 0;
}

my $ConfigurationFile = dirname($0) . '/../Kernel/TidyAll/tidyallrc';

my $RootDir = getcwd();

my $TidyAll = TidyAll::OTOBO->new_from_conf_file(
    $ConfigurationFile,
    check_only       => 0,
    mode             => $Mode // 'cli',
    root_dir         => $RootDir,
    data_dir         => File::Spec->tmpdir(),
    verbose          => $Verbose ? 1 : 0,
    selected_plugins => $Plugins,
);

$TidyAll->DetermineFrameworkVersionFromDirectory();
$TidyAll->GetFileListFromDirectory();

my @Files;

if ($All) {

    # Don't use TidyAll::process_all() or TidyAll::find_matched_files() as it is too slow on large code bases.
    @Files = @TidyAll::OTOBO::FileList;
    @Files = $TidyAll->FilterMatchedFiles( Files => \@Files );
    @Files = map { File::Spec->catfile( $RootDir, $_ ) } @Files;
}
elsif ( defined $Directory && length $Directory ) {
    @Files = $TidyAll->FindFilesInDirectory( Directory => File::Spec->catfile( $RootDir, $Directory ) );
    @Files = $TidyAll->FilterMatchedFiles( Files => \@Files );
    @Files = map { File::Spec->catfile( $RootDir, $_ ) } @Files;
}
elsif ( defined $File && length $File ) {
    @Files = ( File::Spec->catfile( $RootDir, $File ) );
}
elsif (@FileList) {
    @Files = map { File::Spec->catfile( $RootDir, $_ ) } @FileList;
}
elsif ( defined $Cached && length $Cached ) {
    my @StagedFiles = `git diff --name-only --cached`;
    for my $StagedFile (@StagedFiles) {
        chomp $StagedFile;
        push @Files, ( File::Spec->catfile( $RootDir, $StagedFile ) );
    }
}
else {
    my $Output = capturex( 'git', "status", "--porcelain" );

    # Fetch all changed files, staged and unstaged
    my @ChangedFiles = grep { -f && !-l } ( $Output =~ /^\s*[MA]+\s+(.*)/gm );
    push @ChangedFiles, grep { -f && !-l } ( $Output =~ /^\s*RM?+\s+(.*?)\s+->\s+(.*)/gm );
    for my $ChangedFile (@ChangedFiles) {
        chomp $ChangedFile;
        push @Files, ( File::Spec->catfile( $RootDir, $ChangedFile ) );
    }

    # Always include all SOPM files to verify the file list.
    for my $SOPMFile ( map { File::Spec->abs2rel( $_, $RootDir ) } glob("$RootDir/*.sopm") ) {
        if ( !grep { $_ eq $SOPMFile } @ChangedFiles ) {
            push @Files, ( File::Spec->catfile( $RootDir, $SOPMFile ) );
        }
    }
}

# Safeguard: ignore non-regular files and symlinks (causes TidyAll errors).
@Files = grep { -f && !-l } @Files;

# sort the files alphabetically, but be aware the parallel processing
# will mess up the ordering again.
@Files = sort @Files;

my @GlobalResults = $TidyAll->ProcessPathsParallel(
    Processes => $Processes,
    FilePaths => \@Files,
);

$TidyAll->HandleResults(
    Results => \@GlobalResults
);
 package Locale::PO;
use strict;
use warnings;
our $VERSION = '0.27';

use Carp;

sub new {
    my $this    = shift;
    my %options = @_;
    my $class   = ref($this) || $this;
    my $self    = {};
    bless $self, $class;
    $self->_flags([]);
    $self->fuzzy_msgid($options{'-fuzzy_msgid'}) if defined($options{'-fuzzy_msgid'});
    $self->fuzzy_msgid_plural($options{'-fuzzy_msgid_plural'})
        if defined($options{'-fuzzy_msgid_plural'});
    $self->msgid($options{'-msgid'}) if defined($options{'-msgid'});
    $self->msgid_plural($options{'-msgid_plural'})
        if defined($options{'-msgid_plural'});
    $self->msgstr($options{'-msgstr'}) if defined($options{'-msgstr'});
    $self->msgstr_n($options{'-msgstr_n'})
        if defined($options{'-msgstr_n'});
    $self->msgctxt($options{'-msgctxt'}) if defined($options{'-msgctxt'});
    $self->fuzzy_msgctxt($options{'-fuzzy_msgctxt'})
        if defined($options{'-fuzzy_msgctxt'});
    $self->comment($options{'-comment'}) if defined($options{'-comment'});
    $self->fuzzy($options{'-fuzzy'})     if defined($options{'-fuzzy'});
    $self->automatic($options{'-automatic'})
        if defined($options{'-automatic'});
    $self->reference($options{'-reference'})
        if defined($options{'-reference'});
    $self->c_format(1) if defined($options{'-c-format'});
    $self->c_format(1) if defined($options{'-c_format'});
    $self->c_format(0) if defined($options{'-no-c-format'});
    $self->c_format(0) if defined($options{'-no_c_format'});
    $self->loaded_line_number($options{'-loaded_line_number'})
        if defined($options{'-loaded_line_number'});
    return $self;
}

sub fuzzy_msgctxt {
    my $self = shift;
    @_ ? $self->{'fuzzy_msgctxt'} = $self->quote(shift) : $self->{'fuzzy_msgctxt'};
}

sub fuzzy_msgid {
    my $self = shift;
    @_ ? $self->{'fuzzy_msgid'} = $self->quote(shift) : $self->{'fuzzy_msgid'};
}

sub fuzzy_msgid_plural {
    my $self = shift;
    @_
        ? $self->{'fuzzy_msgid_plural'} = $self->quote(shift)
        : $self->{'fuzzy_msgid_plural'};
}

sub msgctxt {
    my $self = shift;
    @_ ? $self->{'msgctxt'} = $self->quote(shift) : $self->{'msgctxt'};
}

sub msgid {
    my $self = shift;
    @_ ? $self->{'msgid'} = $self->quote(shift) : $self->{'msgid'};
}

sub msgid_plural {
    my $self = shift;
    @_
        ? $self->{'msgid_plural'} = $self->quote(shift)
        : $self->{'msgid_plural'};
}

sub msgstr {
    my $self = shift;
    @_ ? $self->{'msgstr'} = $self->quote(shift) : $self->{'msgstr'};
}

sub msgstr_n {
    my $self = shift;
    if (@_) {
        my $hashref = shift;

        # check that we have a hashref.
        croak 'Argument to msgstr_n must be a hashref: { n => "string n", ... }.'
            unless ref($hashref) eq 'HASH';

        # Check that the keys are all numbers.
        croak 'Keys to msgstr_n hashref must be numbers'
            if grep {m/\D/} keys %$hashref;

        # Quote all the values in the hashref.
        $self->{'msgstr_n'}{$_} = $self->quote($$hashref{$_}) for keys %$hashref;

    }

    return $self->{'msgstr_n'};
}

sub comment {
    my $self = shift;
    @_ ? $self->{'comment'} = shift : $self->{'comment'};
}

sub automatic {
    my $self = shift;
    @_ ? $self->{'automatic'} = shift : $self->{'automatic'};
}

sub reference {
    my $self = shift;
    @_ ? $self->{'reference'} = shift : $self->{'reference'};
}

sub obsolete {
    my $self = shift;
    @_ ? $self->{'obsolete'} = shift : $self->{'obsolete'};
}

sub fuzzy {
    my $self = shift;

    if (@_) {
        my $value = shift;
        $value ? $self->add_flag('fuzzy') : $self->remove_flag('fuzzy');
    }

    return $self->has_flag('fuzzy');
}

sub c_format {
    my $self = shift;

    return $self->_tri_value_flag('c-format', @_);
}

sub php_format {
    my $self = shift;

    return $self->_tri_value_flag('php-format', @_);
}

sub _flags {
    my $self = shift;
    @_ ? $self->{'_flags'} = shift : $self->{'_flags'};
}

sub _tri_value_flag {
    my $self      = shift;
    my $flag_name = shift;
    if (@_) {    # set or clear the flags
        my $value = shift;
        if (!defined($value) || $value eq "") {
            $self->remove_flag("$flag_name");
            $self->remove_flag("no-$flag_name");
            return undef;
        }
        elsif ($value) {
            $self->add_flag("$flag_name");
            $self->remove_flag("no-$flag_name");
            return 1;
        }
        else {
            $self->add_flag("no-$flag_name");
            $self->remove_flag("$flag_name");
            return 0;
        }
    }
    else {    # check the flags
        return 1 if $self->has_flag("$flag_name");
        return 0 if $self->has_flag("no-$flag_name");
        return undef;
    }
}

sub add_flag {
    my ($self, $flag_name) = @_;
    if (! $self->has_flag($flag_name)) {
        push @{$self->_flags}, $flag_name;
    }
    return;
}

sub remove_flag {
    my ($self, $flag_name) = @_;
    my @new_flags;
    foreach my $flag (@{$self->_flags}) {
        push @new_flags, $flag unless $flag eq $flag_name;
    }
    $self->_flags(\@new_flags);
    return;
}

sub has_flag {
    my ($self, $flag_name) = @_;
    foreach my $flag (@{$self->_flags}) {
        return 1 if $flag eq $flag_name;
    }
    return;
}

sub loaded_line_number {
    my $self = shift;
    @_ ? $self->{'loaded_line_number'} = shift : $self->{'loaded_line_number'};
}

sub _normalize_str {
    my $self     = shift;
    my $string   = shift;
    my $dequoted = $self->dequote($string);

    # Multiline: this isn't quite perfect, but fast and easy
    if (defined $dequoted && $dequoted =~ /\n/) {
        my $output;
        my @lines;
        @lines = split(/\n/, $dequoted, -1);
        my $lastline = pop @lines;    # special treatment for this one
        $output = qq{""\n} if ($#lines != 0);
        foreach (@lines) {
            $output .= $self->quote("$_\n") . "\n";
        }
        $output .= $self->quote($lastline) . "\n" if $lastline ne "";
        return $output;
    }
    # Single line
    else {
        return ($string || "") . "\n";
    }
}

sub _fuzzy_normalize_str {
    my $self   = shift;
    my $string = shift;
    my $prefix = shift;

    my $normalized = $self->_normalize_str($string);

    # on newlines, start them with "#| " or "#~| "
    $normalized =~ s/\n"/\n$prefix"/g;

    return $normalized;
}

sub dump {
    my $self         = shift;
    my $obsolete     = $self->obsolete ? '#~ ' : '';
    my $fuzzy_prefix = $self->obsolete ? '#~| ' : '#| ';
    my $dump;

    $dump = $self->_dump_multi_comment($self->comment, "# ")
        if ($self->comment);
    $dump .= $self->_dump_multi_comment($self->automatic, "#. ")
        if ($self->automatic);
    $dump .= $self->_dump_multi_comment($self->reference, "#: ")
        if ($self->reference);

    my $flags = '';

    foreach my $flag (@{$self->_flags}) {
        $flags .= ", $flag";
    }

    $dump .= "#$flags\n"
        if length $flags;

    $dump
        .= "${fuzzy_prefix}msgctxt "
        . $self->_fuzzy_normalize_str($self->fuzzy_msgctxt, $fuzzy_prefix)
        if $self->fuzzy_msgctxt;
    $dump
        .= "${fuzzy_prefix}msgid "
        . $self->_fuzzy_normalize_str($self->fuzzy_msgid, $fuzzy_prefix)
        if $self->fuzzy_msgid;
    $dump
        .= "${fuzzy_prefix}msgid_plural "
        . $self->_fuzzy_normalize_str($self->fuzzy_msgid_plural, $fuzzy_prefix)
        if $self->fuzzy_msgid_plural;

    $dump .= "${obsolete}msgctxt " . $self->_normalize_str($self->msgctxt)
        if $self->msgctxt;
    $dump .= "${obsolete}msgid " . $self->_normalize_str($self->msgid);
    $dump .= "${obsolete}msgid_plural " . $self->_normalize_str($self->msgid_plural)
        if $self->msgid_plural;

    $dump .= "${obsolete}msgstr " . $self->_normalize_str($self->msgstr) if $self->msgstr;

    if (my $msgstr_n = $self->msgstr_n) {
        $dump .= "${obsolete}msgstr[$_] " . $self->_normalize_str($$msgstr_n{$_})
            for sort { $a <=> $b } keys %$msgstr_n;
    }

    $dump .= "\n";
    return $dump;
}

sub _dump_multi_comment {
    my $self    = shift;
    my $comment = shift;
    my $leader  = shift;
    my $chopped = $leader;
    chop($chopped);
    my $result = $leader . $comment;
    $result =~ s/\n/\n$leader/g;
    $result =~ s/^$leader$/$chopped/gm;
    $result .= "\n";
    return $result;
}

# Quote a string properly
sub quote {
    my $self   = shift;
    my $string = shift;

    return undef
        unless defined $string;

    $string =~ s/\\(?!t)/\\\\/g;           # \t is a tab
    $string =~ s/"/\\"/g;
    $string =~ s/\n/\\n/g;
    return "\"$string\"";
}

sub dequote {
    my $self   = shift;
    my $string = shift;

    return undef
        unless defined $string;

    $string =~ s/^"(.*)"/$1/;
    $string =~ s/\\"/"/g;
    $string =~ s/(?<!(\\))\\n/\n/g;        # newline
    $string =~ s/(?<!(\\))\\{2}n/\\n/g;    # inline newline
    $string =~ s/(?<!(\\))\\{3}n/\\\n/g;   # \ followed by newline
    $string =~ s/\\{4}n/\\\\n/g;           # \ followed by inline newline
    $string =~ s/\\\\(?!n)/\\/g;           # all slashes not related to a newline
    return $string;
}

sub save_file_fromarray {
    my $self = shift;
    $self->_save_file(0, @_);
}

sub save_file_fromhash {
    my $self = shift;
    $self->_save_file(1, @_);
}

sub _save_file {
    my $self     = shift;
    my $ashash   = shift;
    my $file     = shift;
    my $entries  = shift;
    my $encoding = shift;

    open(OUT, defined($encoding) ? ">:encoding($encoding)" : ">", $file)
        or return undef;
    if ($ashash) {
        foreach (sort keys %$entries) {
            print OUT $entries->{$_}->dump;
        }
    }
    else {
        foreach (@$entries) {
            print OUT $_->dump;
        }
    }

    close OUT;
}

sub load_file_asarray {
    my $self = shift;
    $self->_load_file(0, @_);
}

sub load_file_ashash {
    my $self = shift;
    $self->_load_file(1, @_);
}

sub _load_file {
    my $self     = shift;
    my $ashash   = shift;
    my $file     = shift;
    my $encoding = shift;
    my $class    = ref $self || $self;
    my (@entries, %entries);
    my $line_number = 0;
    my $po;
    my %buffer;
    my $last_buffer;

    open(IN, defined($encoding) ? "<:encoding($encoding)" : "<", $file)
        or return undef;

    while (<IN>) {
        chomp;
        $line_number++;

        #
        # Strip trailing \r\n chars
        #
        # This can possibly have an effect only on msys (on which chomp
        # seems to leave some trailing \r chars) and on MacOS that has
        # reversed newline (\n\r).
        # Note that our stripping of those trailing chars is only going to be
        # useful when writing from one platform and reading on another.
        s{[\r\n]*$}{};

        if (/^$/) {

            # Empty line. End of an entry.

            if (defined($po)) {
                $po->fuzzy_msgctxt($buffer{fuzzy_msgctxt})
                    if defined $buffer{fuzzy_msgctxt};
                $po->fuzzy_msgid($buffer{fuzzy_msgid}) if defined $buffer{fuzzy_msgid};
                $po->fuzzy_msgid_plural($buffer{fuzzy_msgid_plural})
                    if defined $buffer{fuzzy_msgid_plural};
                $po->msgctxt($buffer{msgctxt})           if defined $buffer{msgctxt};
                $po->msgid($buffer{msgid})               if defined $buffer{msgid};
                $po->msgid_plural($buffer{msgid_plural}) if defined $buffer{msgid_plural};
                $po->msgstr($buffer{msgstr})             if defined $buffer{msgstr};
                $po->msgstr_n($buffer{msgstr_n})         if defined $buffer{msgstr_n};


                # ashash
                if ($ashash) {
                    $entries{$po->msgid} = $po
                        if ($po->_hash_key_ok(\%entries));
                }

                # asarray
                else {
                    push(@entries, $po);
                }

                undef $po;
                undef $last_buffer;
                %buffer = ();
            }
        }
        elsif (/^#\s+(.*)/ or /^#()$/) {

            # Translator comments
            $po = $class->new(-loaded_line_number => $line_number) unless defined($po);
            if (defined($po->comment)) {
                $po->comment($po->comment . "\n$1");
            }
            else {
                $po->comment($1);
            }
        }
        elsif (/^#\.\s*(.*)/) {

            # Automatic comments
            $po = $class->new(-loaded_line_number => $line_number) unless defined($po);
            if (defined($po->automatic)) {
                $po->automatic($po->automatic . "\n$1");
            }
            else {
                $po->automatic($1);
            }
        }
        elsif (/^#:\s+(.*)/) {

            # reference
            $po = $class->new(-loaded_line_number => $line_number) unless defined($po);
            if (defined($po->reference)) {
                $po->reference($po->reference . "\n$1");
            }
            else {
                $po->reference($1);
            }
        }
        elsif (/^#,\s+(.*)/) {

            # flags
            my @flags = split /\s*[,]\s*/, $1;
            $po = $class->new(-loaded_line_number => $line_number) unless defined($po);
            foreach my $flag (@flags) {
                $po->add_flag($flag);
            }
        }
        elsif (/^#(~)?\|\s+msgctxt\s+(.*)/) {
            $po = $class->new(-loaded_line_number => $line_number) unless defined($po);
            $buffer{fuzzy_msgctxt} = $self->dequote($2);
            $last_buffer = \$buffer{fuzzy_msgctxt};
            $po->obsolete(1) if $1;
        }
        elsif (/^#(~)?\|\s+msgid\s+(.*)/) {
            $po = $class->new(-loaded_line_number => $line_number) unless defined($po);
            $buffer{fuzzy_msgid} = $self->dequote($2);
            $last_buffer = \$buffer{fuzzy_msgid};
            $po->obsolete(1) if $1;
        }
        elsif (/^#(~)?\|\s+msgid_plural\s+(.*)/) {
            $po = $class->new(-loaded_line_number => $line_number) unless defined($po);
            $buffer{fuzzy_msgid_plural} = $self->dequote($2);
            $last_buffer = \$buffer{fuzzy_msgid_plural};
            $po->obsolete(1) if $1;
        }
        elsif (/^(#~\s+)?msgctxt\s+(.*)/) {
            $po = $class->new(-loaded_line_number => $line_number) unless defined($po);
            $buffer{msgctxt} = $self->dequote($2);
            $last_buffer = \$buffer{msgctxt};
            $po->obsolete(1) if $1;
        }
        elsif (/^(#~\s+)?msgid\s+(.*)/) {
            $po = $class->new(-loaded_line_number => $line_number) unless defined($po);
            $buffer{msgid} = $self->dequote($2);
            $last_buffer = \$buffer{msgid};
            $po->obsolete(1) if $1;
        }
        elsif (/^(#~\s+)?msgid_plural\s+(.*)/) {
            $po = $class->new(-loaded_line_number => $line_number) unless defined($po);
            $buffer{msgid_plural} = $self->dequote($2);
            $last_buffer = \$buffer{msgid_plural};
            $po->obsolete(1) if $1;
        }
        elsif (/^(?:#~\s+)?msgstr\s+(.*)/) {

            # translated string
            $buffer{msgstr} = $self->dequote($1);
            $last_buffer = \$buffer{msgstr};
        }
        elsif (/^(?:#~\s+)?msgstr\[(\d+)\]\s+(.*)/) {

            # translated string
            $buffer{msgstr_n}{$1} = $self->dequote($2);
            $last_buffer = \$buffer{msgstr_n}{$1};
        }
        elsif (/^(?:#(?:~|~\||\|)\s+)?(".*)/) {

            # continued string. Accounts for:
            #   normal          : "string"
            #   obsolete        : #~ "string"
            #   fuzzy           : #| "string"
            #   fuzzy+obsolete  : #~| "string"
            $$last_buffer .= $self->dequote($1);
        }
        else {
            warn "Strange line at $file line $line_number: [$_]\n";
        }
    }
    if (defined($po)) {

        $po->msgctxt($buffer{msgctxt})
            if defined $buffer{msgctxt};
        $po->msgid($buffer{msgid})
            if defined $buffer{msgid};
        $po->msgid_plural($buffer{msgid_plural})
            if defined $buffer{msgid_plural};
        $po->msgstr($buffer{msgstr})
            if defined $buffer{msgstr};
        $po->msgstr_n($buffer{msgstr_n})
            if defined $buffer{msgstr_n};

        # ashash
        if ($ashash) {
            if ($po->_hash_key_ok(\%entries)) {
                $entries{$po->msgid} = $po;
            }
        }

        # asarray
        else {
            push(@entries, $po);
        }
    }
    close IN;
    return ($ashash ? \%entries : \@entries);
}

sub _hash_key_ok {
    my ($self, $entries) = @_;

    my $key = $self->msgid;

    if ($entries->{$key}) {

        # don't overwrite non-obsolete entries with obsolete ones
        return if (($self->obsolete) && (not $entries->{$key}->obsolete));

        # don't overwrite translated entries with untranslated ones
        return if (($self->msgstr !~ /\w/) && ($entries->{$key}->msgstr =~ /\w/));
    }

    return 1;
}

# Autoload methods go after =cut, and are processed by the autosplit program.

1;
__END__

# Below is the stub of documentation for your module. You better edit it!

=head1 NAME

Locale::PO - Perl module for manipulating .po entries from GNU gettext

=head1 SYNOPSIS

    use Locale::PO;

    $po = new Locale::PO([-option=>value,...])
    [$string =] $po->msgid([new string]);
    [$string =] $po->msgstr([new string]);
    [$string =] $po->comment([new string]);
    [$string =] $po->automatic([new string]);
    [$string =] $po->reference([new string]);
    [$value =] $po->fuzzy([value]);
    [$value =] $po->add_flag('c-format');
    print $po->dump;

    $quoted_string = $po->quote($string);
    $string = $po->dequote($quoted_string);

    $aref = Locale::PO->load_file_asarray(<filename>,[encoding]);
    $href = Locale::PO->load_file_ashash(<filename>,[encoding]);
    Locale::PO->save_file_fromarray(<filename>,$aref,[encoding]);
    Locale::PO->save_file_fromhash(<filename>,$href,[encoding]);

=head1 DESCRIPTION

This module simplifies management of GNU gettext .po files and is an
alternative to using emacs po-mode. It provides an object-oriented
interface in which each entry in a .po file is a Locale::PO object.

=head1 METHODS

=over 4

=item new

    my Locale::PO $po = new Locale::PO;
    my Locale::PO $po = new Locale::PO(%options);

Create a new Locale::PO object to represent a po entry.
You can optionally set the attributes of the entry by passing
a list/hash of the form:

    -option=>value, -option=>value, etc.

Where options are msgid, msgid_plural, msgstr, msgctxt, comment, automatic,
reference, fuzzy_msgctxt, fuzzy_msgid, fuzzy_msgid_plural,
fuzzy, and c-format. See accessor methods below.

To generate a po file header, add an entry with an empty
msgid, like this:

    $po = new Locale::PO(-msgid=>'', -msgstr=>
        "Project-Id-Version: PACKAGE VERSION\\n" .
        "PO-Revision-Date: YEAR-MO-DA HO:MI +ZONE\\n" .
        "Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n" .
        "Language-Team: LANGUAGE <LL@li.org>\\n" .
        "MIME-Version: 1.0\\n" .
        "Content-Type: text/plain; charset=CHARSET\\n" .
        "Content-Transfer-Encoding: ENCODING\\n");

=item msgid

Set or get the untranslated string from the object.

This method expects the new string in unquoted form but returns the current string in quoted form.

=item msgid_plural

Set or get the untranslated plural string from the object.

This method expects the new string in unquoted form but returns the current string in quoted form.

=item msgstr

Set or get the translated string from the object.

This method expects the new string in unquoted form but returns the current string in quoted form.

=item msgstr_n

Get or set the translations if there are purals involved. Takes and
returns a hashref where the keys are the 'N' case and the values are
the strings. eg:

    $po->msgstr_n(
    {
        0 => 'found %d plural translations',
        1 => 'found %d singular translation',
    }
    );

This method expects the new strings in unquoted form but returns the current strings in quoted form.

=item msgctxt

Set or get the translation context string from the object.

This method expects the new string in unquoted form but returns the current string in quoted form.

=item fuzzy_msgid

Set or get the outdated untranslated string from the object.

This method expects the new string in unquoted form but returns the current string in quoted form.

=item fuzzy_msgid_plural

Set or get the outdated untranslated plural string from the object.

This method expects the new string in unquoted form but returns the current string in quoted form.

=item fuzzy_msgctxt

Set or get the outdated translation context string from the object.

This method expects the new string in unquoted form but returns the current string in quoted form.

=item obsolete

Returns 1 if the entry is obsolete.
Obsolete entries have their msgid, msgid_plural, msgstr, msgstr_n and msgctxt lines commented out with "#~"

When using load_file_ashash, non-obsolete entries will always replace obsolete entries with the same msgid.

=item comment

Set or get translator comments from the object.

If there are no such comments, then the value is undef.  Otherwise,
the value is a string that contains the comment lines delimited with
"\n".  The string includes neither the S<"# "> at the beginning of
each comment line nor the newline at the end of the last comment line.

=item automatic

Set or get automatic comments from the object (inserted by
emacs po-mode or xgettext).

If there are no such comments, then the value is undef.  Otherwise,
the value is a string that contains the comment lines delimited with
"\n".  The string includes neither the S<"#. "> at the beginning of
each comment line nor the newline at the end of the last comment line.

=item reference

Set or get reference marking comments from the object (inserted
by emacs po-mode or gettext).

=item fuzzy

Set or get the fuzzy flag on the object ("check this translation").
When setting, use 1 to turn on fuzzy, and 0 to turn it off.

=item c_format

Set or get the c-format or no-c-format flag on the object.

This can take 3 values:
1 implies c-format, 0 implies no-c-format, and undefined implies neither.

=item php_format

Set or get the php-format or no-php-format flag on the object.

This can take 3 values:
1 implies php-format, 0 implies no-php-format, and undefined implies neither.

=item has_flag

    if ($po->has_flag('perl-format')) {
        ...
    }

Returns true if the flag exists in the entry's #~ comment

=item add_flag

    $po->add_flag('perl-format');

Adds the flag to the #~ comment

=item remove_flag

    $po->remove_flag('perl-format');

Removes the flag from the #~ comment

=item loaded_line_number

When using one of the load_file_as* methods,
this will return the line number that the entry started at in the file.

=item dump

Returns the entry as a string, suitable for output to a po file.

=item quote

Applies po quotation rules to a string, and returns the quoted
string. The quoted string will have all existing double-quote
characters escaped by backslashes, and will be enclosed in double
quotes.

=item dequote

Returns a quoted po string to its natural form.

=item load_file_asarray

Given the filename of a po-file, reads the file and returns a
reference to a list of Locale::PO objects corresponding to the contents of
the file, in the same order.  Accepts an optional encoding parameter (e.g.
"utf8") which defines how the po-file's input stream will be configured.

=item load_file_ashash

Given the filename of a po-file, reads the file and returns a
reference to a hash of Locale::PO objects corresponding to the contents of
the file. The hash keys are the untranslated strings, so this is a cheap
way to remove duplicates. The method will prefer to keep entries that
have been translated.  Accepts an optional encoding parameter (e.g.
"utf8") which defines how the po-file's input stream will be configured.

=item save_file_fromarray

Given a filename and a reference to a list of Locale::PO objects,
saves those objects to the file, creating a po-file.  Accepts an optional
encoding parameter (e.g. "utf8") which defines how the po-file's output
stream will be configured.

=item save_file_fromhash

Given a filename and a reference to a hash of Locale::PO objects,
saves those objects to the file, creating a po-file. The entries
are sorted alphabetically by untranslated string.  Accepts an optional
encoding parameter (e.g. "utf8") which defines how the po-file's output
stream will be configured.

=back

=head1 AUTHOR

Maintainer: Ken Prows, perl@xev.net

Original version by: Alan Schwartz, alansz@pennmush.org

=head1 BUGS

If you load_file_as* then save_file_from*, the output file may have slight
cosmetic differences from the input file (an extra blank line here or there).

msgid, msgid_plural, msgstr, msgstr_n and msgctxt expect a non-quoted string as input, but return quoted strings.
I'm hesitant to change this in fear of breaking the modules/scripts of people already using Locale::PO.

Locale::PO requires blank lines between entries, but Uniforum style PO
files don't have any.

Please submit all bug requests using CPAN's ticketing system.

=head1 SEE ALSO

xgettext(1).

=cut
 
=head1 NAME

Perl::Tidy - Parses and beautifies perl source

=head1 SYNOPSIS

    use Perl::Tidy;

    my $error_flag = Perl::Tidy::perltidy(
        source            => $source,
        destination       => $destination,
        stderr            => $stderr,
        argv              => $argv,
        perltidyrc        => $perltidyrc,
        logfile           => $logfile,
        errorfile         => $errorfile,
        teefile           => $teefile,
        debugfile         => $debugfile,
        formatter         => $formatter,    # callback object (see below)
        dump_options      => $dump_options,
        dump_options_type => $dump_options_type,
        prefilter         => $prefilter_coderef,
        postfilter        => $postfilter_coderef,
    );

=head1 DESCRIPTION

This module makes the functionality of the perltidy utility available to perl
scripts.  Any or all of the input parameters may be omitted, in which case the
@ARGV array will be used to provide input parameters as described
in the perltidy(1) man page.

For example, the perltidy script is basically just this:

    use Perl::Tidy;
    Perl::Tidy::perltidy();

The call to B<perltidy> returns a scalar B<$error_flag> which is TRUE if an
error caused premature termination, and FALSE if the process ran to normal
completion.  Additional discuss of errors is contained below in the
L<ERROR HANDLING|"ERROR HANDLING"> section.

The module accepts input and output streams by a variety of methods.
The following list of parameters may be any of the following: a
filename, an ARRAY reference, a SCALAR reference, or an object with
either a B<getline> or B<print> method, as appropriate.

    source            - the source of the script to be formatted
    destination       - the destination of the formatted output
    stderr            - standard error output
    perltidyrc        - the .perltidyrc file
    logfile           - the .LOG file stream, if any
    errorfile         - the .ERR file stream, if any
    dump_options      - ref to a hash to receive parameters (see below),
    dump_options_type - controls contents of dump_options
    dump_getopt_flags - ref to a hash to receive Getopt flags
    dump_options_category - ref to a hash giving category of options
    dump_abbreviations    - ref to a hash giving all abbreviations

The following chart illustrates the logic used to decide how to
treat a parameter.

   ref($param)  $param is assumed to be:
   -----------  ---------------------
   undef        a filename
   SCALAR       ref to string
   ARRAY        ref to array
   (other)      object with getline (if source) or print method

If the parameter is an object, and the object has a B<close> method, that
close method will be called at the end of the stream.

=over 4

=item B<source>

If the B<source> parameter is given, it defines the source of the input stream.
If an input stream is defined with the B<source> parameter then no other source
filenames may be specified in the @ARGV array or B<argv> parameter.

=item B<destination>

If the B<destination> parameter is given, it will be used to define the
file or memory location to receive output of perltidy.

B<Important note if destination is a string or array reference>.  Perl strings
of characters which are decoded as utf8 by Perl::Tidy can be returned in either
of two possible states, decoded or encoded, and it is important that the
calling program and Perl::Tidy are in agreement regarding the state to be
returned.  A flag B<--encode-output-strings>, or simply B<-eos>, was added in
Perl::Tidy version 20220217 for this purpose.

=over 4

=item *

Use B<-eos> if Perl::Tidy should encode any string which it decodes.  This is
the current default because it makes perltidy behave well as a filter, and is
the correct setting for most programs.  But do not use this setting if the
calling program will encode the data too, because double encoding will corrupt
data.

=item *

Use B<-neos> if a string should remain decoded if it was decoded by Perl::Tidy.
This is only appropriate if the calling program will handle any needed encoding
before outputting the string.  If needed, this flag can be added to the end of
the B<argv> parameter passed to Perl::Tidy.

=back

For some background information see
L<https://github.com/perltidy/perltidy/blob/master/docs/eos_flag.md>.

This change in default behavior was made over a period of time as follows:

=over 4

=item *

For versions before 20220217 the B<-eos> flag was not available and the behavior was equivalent to B<-neos>.

=item *

In version 20220217 the B<-eos> flag was added but the default remained B<-neos>.

=item *

For versions after 20220217 the default was set to B<-eos>.

=back

=item B<stderr>

The B<stderr> parameter allows the calling program to redirect the stream that
would otherwise go to the standard error output device to any of the stream
types listed above.  This stream contains important warnings and errors
related to the parameters passed to perltidy.

=item B<perltidyrc>

If the B<perltidyrc> file is given, it will be used instead of any
F<.perltidyrc> configuration file that would otherwise be used.

=item B<errorfile>

The B<errorfile> parameter allows the calling program to capture
the stream that would otherwise go to either a .ERR file.  This
stream contains warnings or errors related to the contents of one
source file or stream.

The reason that this is different from the stderr stream is that when perltidy
is called to process multiple files there will be up to one .ERR file created
for each file and it would be very confusing if they were combined.

However if perltidy is called to process just a single perl script then it may
be more convenient to combine the B<errorfile> stream with the B<stderr>
stream.  This can be done by setting the B<-se> parameter, in which case this
parameter is ignored.

=item B<logfile>

The B<logfile> parameter allows the calling program to capture the log stream.
This stream is only created if requested with a B<-g> parameter.  It contains
detailed diagnostic information about a script which may be useful for
debugging.

=item B<teefile>

The B<teefile> parameter allows the calling program to capture the tee stream.
This stream is only created if requested with one of the 'tee' parameters,
a B<--tee-pod> , B<--tee-block-comments>, B<--tee-side-commnts>, or B<--tee-all-comments>.

=item B<debugfile>

The B<debugfile> parameter allows the calling program to capture the stream
produced by the B<--DEBUG> parameter.  This parameter is mainly used for
debugging perltidy itself.

=item B<argv>

If the B<argv> parameter is given, it will be used instead of the
B<@ARGV> array.  The B<argv> parameter may be a string, a reference to a
string, or a reference to an array.  If it is a string or reference to a
string, it will be parsed into an array of items just as if it were a
command line string.

=item B<dump_options>

If the B<dump_options> parameter is given, it must be the reference to a hash.
In this case, the parameters contained in any perltidyrc configuration file
will be placed in this hash and perltidy will return immediately.  This is
equivalent to running perltidy with --dump-options, except that the parameters
are returned in a hash rather than dumped to standard output.  Also, by default
only the parameters in the perltidyrc file are returned, but this can be
changed (see the next parameter).  This parameter provides a convenient method
for external programs to read a perltidyrc file.  An example program using
this feature, F<perltidyrc_dump.pl>, is included in the distribution.

Any combination of the B<dump_> parameters may be used together.

=item B<dump_options_type>

This parameter is a string which can be used to control the parameters placed
in the hash reference supplied by B<dump_options>.  The possible values are
'perltidyrc' (default) and 'full'.  The 'full' parameter causes both the
default options plus any options found in a perltidyrc file to be returned.

=item B<dump_getopt_flags>

If the B<dump_getopt_flags> parameter is given, it must be the reference to a
hash.  This hash will receive all of the parameters that perltidy understands
and flags that are passed to Getopt::Long.  This parameter may be
used alone or with the B<dump_options> flag.  Perltidy will
exit immediately after filling this hash.  See the demo program
F<perltidyrc_dump.pl> for example usage.

=item B<dump_options_category>

If the B<dump_options_category> parameter is given, it must be the reference to a
hash.  This hash will receive a hash with keys equal to all long parameter names
and values equal to the title of the corresponding section of the perltidy manual.
See the demo program F<perltidyrc_dump.pl> for example usage.

=item B<dump_abbreviations>

If the B<dump_abbreviations> parameter is given, it must be the reference to a
hash.  This hash will receive all abbreviations used by Perl::Tidy.  See the
demo program F<perltidyrc_dump.pl> for example usage.

=item B<prefilter>

A code reference that will be applied to the source before tidying. It is
expected to take the full content as a string in its input, and output the
transformed content.

=item B<postfilter>

A code reference that will be applied to the tidied result before outputting.
It is expected to take the full content as a string in its input, and output
the transformed content.

Note: A convenient way to check the function of your custom prefilter and
postfilter code is to use the --notidy option, first with just the prefilter
and then with both the prefilter and postfilter.  See also the file
B<filter_example.pl> in the perltidy distribution.

=back

=head1 ERROR HANDLING

An exit value of 0, 1, or 2 is returned by perltidy to indicate the status of the result.

A exit value of 0 indicates that perltidy ran to completion with no error messages.

An exit value of 1 indicates that the process had to be terminated early due to
errors in the input parameters.  This can happen for example if a parameter is
misspelled or given an invalid value.  The calling program should check for
this flag because if it is set the destination stream will be empty or
incomplete and should be ignored.  Error messages in the B<stderr> stream will
indicate the cause of any problem.

An exit value of 2 indicates that perltidy ran to completion but there
are warning messages in the B<stderr> stream related to parameter errors or
conflicts and/or warning messages in the B<errorfile> stream relating to
possible syntax errors in the source code being tidied.

In the event of a catastrophic error for which recovery is not possible
B<perltidy> terminates by making calls to B<croak> or B<confess> to help the
programmer localize the problem.  These should normally only occur during
program development.

=head1 NOTES ON FORMATTING PARAMETERS

Parameters which control formatting may be passed in several ways: in a
F<.perltidyrc> configuration file, in the B<perltidyrc> parameter, and in the
B<argv> parameter.

If the B<-pbp> style is used it will typically be necessary to also
specify a B<-nst> flag.  This is necessary to turn off the B<-st> flag
contained in the B<-pbp> parameter set which otherwise would direct
the output stream to the standard output.

=head1 EXAMPLES

The following example uses string references to hold the input and output
code and error streams, and illustrates checking for errors.

  use Perl::Tidy;

  my $source_string = <<'EOT';
  my$error=Perl::Tidy::perltidy(argv=>$argv,source=>\$source_string,
    destination=>\$dest_string,stderr=>\$stderr_string,
  errorfile=>\$errorfile_string,);
  EOT

  my $dest_string;
  my $stderr_string;
  my $errorfile_string;
  my $argv = "-npro";   # Ignore any .perltidyrc at this site
  $argv .= " -pbp";     # Format according to perl best practices
  $argv .= " -nst";     # Must turn off -st in case -pbp is specified
  $argv .= " -se";      # -se appends the errorfile to stderr
  ## $argv .= " --spell-check";  # uncomment to trigger an error

  print "<<RAW SOURCE>>\n$source_string\n";

  my $error = Perl::Tidy::perltidy(
      argv        => $argv,
      source      => \$source_string,
      destination => \$dest_string,
      stderr      => \$stderr_string,
      errorfile   => \$errorfile_string,  # ignored when -se flag is set
      ##phasers   => 'stun',              # uncomment to trigger an error
  );

  if ($error) {

      # serious error in input parameters, no tidied output
      print "<<STDERR>>\n$stderr_string\n";
      die "Exiting because of serious errors\n";
  }

  if ($dest_string)      { print "<<TIDIED SOURCE>>\n$dest_string\n" }
  if ($stderr_string)    { print "<<STDERR>>\n$stderr_string\n" }
  if ($errorfile_string) { print "<<.ERR file>>\n$errorfile_string\n" }

Additional examples are given in examples section of the perltidy distribution.

=head1 Using the B<formatter> Callback Object

The B<formatter> parameter is an optional callback object which allows
the calling program to receive tokenized lines directly from perltidy for
further specialized processing.  When this parameter is used, the two
formatting options which are built into perltidy (beautification or
html) are ignored.  The following diagram illustrates the logical flow:

                    |-- (normal route)   -> code beautification
  caller->perltidy->|-- (-html flag )    -> create html
                    |-- (formatter given)-> callback to write_line

This can be useful for processing perl scripts in some way.  The
parameter C<$formatter> in the perltidy call,

        formatter   => $formatter,

is an object created by the caller with a C<write_line> method which
will accept and process tokenized lines, one line per call.  Here is
a simple example of a C<write_line> which merely prints the line number,
the line type (as determined by perltidy), and the text of the line:

 sub write_line {

     # This is called from perltidy line-by-line
     my $self              = shift;
     my $line_of_tokens    = shift;
     my $line_type         = $line_of_tokens->{_line_type};
     my $input_line_number = $line_of_tokens->{_line_number};
     my $input_line        = $line_of_tokens->{_line_text};
     print "$input_line_number:$line_type:$input_line";
 }

The complete program, B<perllinetype>, is contained in the examples section of
the source distribution.  As this example shows, the callback method
receives a parameter B<$line_of_tokens>, which is a reference to a hash
of other useful information.  This example uses these hash entries:

 $line_of_tokens->{_line_number} - the line number (1,2,...)
 $line_of_tokens->{_line_text}   - the text of the line
 $line_of_tokens->{_line_type}   - the type of the line, one of:

    SYSTEM         - system-specific code before hash-bang line
    CODE           - line of perl code (including comments)
    POD_START      - line starting pod, such as '=head'
    POD            - pod documentation text
    POD_END        - last line of pod section, '=cut'
    HERE           - text of here-document
    HERE_END       - last line of here-doc (target word)
    FORMAT         - format section
    FORMAT_END     - last line of format section, '.'
    DATA_START     - __DATA__ line
    DATA           - unidentified text following __DATA__
    END_START      - __END__ line
    END            - unidentified text following __END__
    ERROR          - we are in big trouble, probably not a perl script

Most applications will be only interested in lines of type B<CODE>.  For
another example, let's write a program which checks for one of the
so-called I<naughty matching variables> C<&`>, C<$&>, and C<$'>, which
can slow down processing.  Here is a B<write_line>, from the example
program B<find_naughty.pl>, which does that:

 sub write_line {

     # This is called back from perltidy line-by-line
     # We're looking for $`, $&, and $'
     my ( $self, $line_of_tokens ) = @_;

     # pull out some stuff we might need
     my $line_type         = $line_of_tokens->{_line_type};
     my $input_line_number = $line_of_tokens->{_line_number};
     my $input_line        = $line_of_tokens->{_line_text};
     my $rtoken_type       = $line_of_tokens->{_rtoken_type};
     my $rtokens           = $line_of_tokens->{_rtokens};
     chomp $input_line;

     # skip comments, pod, etc
     return if ( $line_type ne 'CODE' );

     # loop over tokens looking for $`, $&, and $'
     for ( my $j = 0 ; $j < @$rtoken_type ; $j++ ) {

         # we only want to examine token types 'i' (identifier)
         next unless $$rtoken_type[$j] eq 'i';

         # pull out the actual token text
         my $token = $$rtokens[$j];

         # and check it
         if ( $token =~ /^\$[\`\&\']$/ ) {
             print STDERR
               "$input_line_number: $token\n";
         }
     }
 }

This example pulls out these tokenization variables from the $line_of_tokens
hash reference:

     $rtoken_type = $line_of_tokens->{_rtoken_type};
     $rtokens     = $line_of_tokens->{_rtokens};

The variable C<$rtoken_type> is a reference to an array of token type codes,
and C<$rtokens> is a reference to a corresponding array of token text.
These are obviously only defined for lines of type B<CODE>.
Perltidy classifies tokens into types, and has a brief code for each type.
You can get a complete list at any time by running perltidy from the
command line with

     perltidy --dump-token-types

In the present example, we are only looking for tokens of type B<i>
(identifiers), so the for loop skips past all other types.  When an
identifier is found, its actual text is checked to see if it is one
being sought.  If so, the above write_line prints the token and its
line number.

The B<examples> section of the source distribution has some examples of programs which use the B<formatter> option.

For help with perltidy's peculiar way of breaking lines into tokens, you
might run, from the command line,

 perltidy -D filename

where F<filename> is a short script of interest.  This will produce
F<filename.DEBUG> with interleaved lines of text and their token types.
The B<-D> flag has been in perltidy from the beginning for this purpose.
If you want to see the code which creates this file, it is
C<sub Perl::Tidy::Debugger::write_debug_entry>

=head1 EXPORT

  &perltidy

=head1 INSTALLATION

The module 'Perl::Tidy' comes with a binary 'perltidy' which is installed when the module is installed.  The module name is case-sensitive.  For example, the basic command for installing with cpanm is 'cpanm Perl::Tidy'.

=head1 VERSION

This man page documents Perl::Tidy version 20250105

=head1 LICENSE

This package is free software; you can redistribute it and/or modify it
under the terms of the "GNU General Public License".

Please refer to the file "COPYING" for details.

=head1 BUG REPORTS

The source code repository is at L<https://github.com/perltidy/perltidy>.

To report a new bug or problem, use the "issues" link on this page.

=head1 SEE ALSO

The perltidy(1) man page describes all of the features of perltidy.  It
can be found at http://perltidy.sourceforge.net.

=cut
 #
###########################################################
#
#    perltidy - a perl script indenter and formatter
#
#    Copyright (c) 2000-2025 by Steve Hancock
#    Distributed under the GPL license agreement; see file COPYING
#
#    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 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, write to the Free Software Foundation, Inc.,
#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
#    For brief instructions, try 'perltidy -h'.
#    For more complete documentation, try 'man perltidy'
#    or visit the GitHub site https://perltidy.github.io/perltidy/
#
#    This script is an example of the default style.  It was formatted with:
#
#      perltidy Tidy.pm
#
#    Code Contributions: See ChangeLog.html for a complete history.
#      Michael Cartmell supplied code for adaptation to VMS and helped with
#        v-strings.
#      Hugh S. Myers supplied sub streamhandle and the supporting code to
#        create a Perl::Tidy module which can operate on strings, arrays, etc.
#      Yves Orton supplied coding to help detect Windows versions.
#      Axel Rose supplied a patch for MacPerl.
#      Sebastien Aperghis-Tramoni supplied a patch for the defined or operator.
#      Dan Tyrell contributed a patch for binary I/O.
#      Ueli Hugenschmidt contributed a patch for -fpsc
#      Sam Kington supplied a patch to identify the initial indentation of
#      entabbed code.
#      jonathan swartz supplied patches for:
#      * .../ pattern, which looks upwards from directory
#      * --notidy, to be used in directories where we want to avoid
#        accidentally tidying
#      * prefilter and postfilter
#      * iterations option
#
#      Many others have supplied key ideas, suggestions, and bug reports;
#        see the CHANGES file.
#
############################################################

package Perl::Tidy;

# perlver reports minimum version needed is 5.8.1
# 5.004 needed for IO::File
# 5.008 needed for wide characters
# 5.008001 needed for utf8::is_utf8
# 5.008001 needed for Scalar::Util::refaddr
use 5.008001;
use warnings;
use strict;
use Exporter;
use Carp;
use English     qw( -no_match_vars );
use Digest::MD5 qw(md5_hex);
use Perl::Tidy::Debugger;
use Perl::Tidy::Diagnostics;
use Perl::Tidy::FileWriter;
use Perl::Tidy::Formatter;
use Perl::Tidy::HtmlWriter;
use Perl::Tidy::IOScalar;
use Perl::Tidy::IOScalarArray;
use Perl::Tidy::IndentationItem;
use Perl::Tidy::Logger;
use Perl::Tidy::Tokenizer;
use Perl::Tidy::VerticalAligner;
local $OUTPUT_AUTOFLUSH = 1;

# DEVEL_MODE can be turned on for extra checking during development
use constant DEVEL_MODE   => 0;
use constant DIAGNOSTICS  => 0;
use constant EMPTY_STRING => q{};
use constant SPACE        => q{ };
use constant CONST_1024   => 1024;    # bytes per kb; 2**10

use vars qw{
  $VERSION
  @ISA
  @EXPORT
};

@ISA    = qw( Exporter );
@EXPORT = qw( &perltidy );

use Cwd;
use Encode ();
use Encode::Guess;
use IO::File;
use File::Basename;
use File::Copy;
use File::Spec ();

# perl stat function index names, based on
#    https://perldoc.perl.org/functions/stat
use constant {

    _mode_  => 2,    # file mode  (type and permissions)
    _uid_   => 4,    # numeric user ID of file's owner
    _gid_   => 5,    # numeric group ID of file's owner
    _atime_ => 8,    # last access time in seconds since the epoch
    _mtime_ => 9,    # last modify time in seconds since the epoch

##  _dev_     => 0,     # device number of filesystem
##  _ino_     => 1,     # inode number
##  _nlink_   => 3,     # number of (hard) links to the file
##  _rdev_    => 6,     # the device identifier (special files only)
##  _size_    => 7,     # total size of file, in bytes
##  _ctime_   => 10,    # inode change time in seconds since the epoch (*)
##  _blksize_ => 11,    # preferred I/O size in bytes for interacting with
##                      # the file (may vary from file to file)
##  _blocks_  => 12,    # actual number of system-specific blocks allocated
##                      # on disk (often, but not always, 512 bytes each)
};

BEGIN {

    # Release version is the approximate YYYYMMDD of the release.
    # Development version is (Last Release).(Development Number)

    # To make the number continually increasing, the Development Number is a 2
    # digit number starting at 01 after a release. It is continually bumped
    # along at significant points during development. If it ever reaches 99
    # then the Release version must be bumped, and it is probably past time for
    # a release anyway.

    $VERSION = '20250105';
} ## end BEGIN

sub DESTROY {
    my $self = shift;

    # required to avoid call to AUTOLOAD in some versions of perl
    return;
} ## end sub DESTROY

sub AUTOLOAD {

    # Catch any undefined sub calls so that we are sure to get
    # some diagnostic information.  This sub should never be called
    # except for a programming error.
    our $AUTOLOAD;
    return if ( $AUTOLOAD =~ /\bDESTROY$/ );
    my ( $pkg, $fname, $lno ) = caller();
    print {*STDERR} <<EOM;
======================================================================
Unexpected call to Autoload looking for sub $AUTOLOAD
Called from package: '$pkg'
Called from File '$fname'  at line '$lno'
This error is probably due to a recent programming change
======================================================================
EOM
    exit 1;
} ## end sub AUTOLOAD

sub streamhandle {

    my ( $filename, $mode, ($is_encoded_data) ) = @_;

    # Given:
    #   $filename
    #   $mode = 'r' or 'w' (only 'w' is used now, see note below)
    #   $is_encoded_data (optional flag)

    # Create an object which:
    #   has a 'getline' method if mode='r', and
    #   has a 'print' method if mode='w'.
    # The objects also need a 'close' method.
    #
    # How the object is made:
    #
    # if $filename is:     Make object using:
    # ----------------     -----------------
    # '-'                  (STDIN if mode = 'r', STDOUT if mode='w')
    # string               IO::File
    # ARRAY  ref           Perl::Tidy::IOScalarArray (formerly IO::ScalarArray)
    # STRING ref           Perl::Tidy::IOScalar      (formerly IO::Scalar)
    # object               object
    #                      (check for 'print' method for 'w' mode)
    #                      (check for 'getline' method for 'r' mode)

    # An optional flag '$is_encoded_data' may be given, as follows:
    # - true: encoded data is being transferred,
    #    set encoding to be utf8 for files and for stdin.
    # - false: unencoded binary data is being transferred,
    #    set binary mode for files and for stdin.

    # NOTE: mode 'r' works but is no longer used.
    # Use sub stream_slurp instead for mode 'r', for efficiency.
    $mode = lc($mode);
    if ( $mode ne 'w' ) {
        if ( DEVEL_MODE || $mode ne 'r' ) {
            Fault("streamhandle called in unexpected mode '$mode'\n");
        }
    }

    my $ref = ref($filename);
    my $New;
    my $fh;

    #-------------------
    # handle a reference
    #-------------------
    if ($ref) {
        if ( $ref eq 'ARRAY' ) {
            $New = sub { Perl::Tidy::IOScalarArray->new( $filename, $mode ) };
        }
        elsif ( $ref eq 'SCALAR' ) {
            $New = sub { Perl::Tidy::IOScalar->new( $filename, $mode ) };
        }
        else {

            # Accept an object with a getline method for reading. Note:
            # IO::File is built-in and does not respond to the defined
            # operator.  If this causes trouble, the check can be
            # skipped and we can just let it crash if there is no
            # getline.
            if ( $mode eq 'r' ) {

                # RT#97159; part 1 of 2: updated to use 'can'
                if ( $ref->can('getline') ) {
                    $New = sub { $filename };
                }
                else {
                    $New = sub { undef };
                    confess <<EOM;
------------------------------------------------------------------------
No 'getline' method is defined for object of class '$ref'
Please check your call to Perl::Tidy::perltidy.  Trace follows.
------------------------------------------------------------------------
EOM
                }
            }

            # Accept an object with a print method for writing.
            # See note above about IO::File
            if ( $mode eq 'w' ) {

                # RT#97159; part 2 of 2: updated to use 'can'
                if ( $ref->can('print') ) {
                    $New = sub { $filename };
                }
                else {
                    $New = sub { undef };
                    confess <<EOM;
------------------------------------------------------------------------
No 'print' method is defined for object of class '$ref'
Please check your call to Perl::Tidy::perltidy. Trace follows.
------------------------------------------------------------------------
EOM
                }
            }
        }
    }

    #----------------
    # handle a string
    #----------------
    else {
        if ( $filename eq '-' ) {
            $New = sub { $mode eq 'w' ? *STDOUT : *STDIN }
        }
        else {
            $New = sub { IO::File->new( $filename, $mode ) };
        }
    }

    #--------------
    # Open the file
    #--------------
    $fh = $New->( $filename, $mode );

    if ( !$fh ) {
        Warn("Couldn't open file:'$filename' in mode:$mode : $OS_ERROR\n");
    }

    #------------
    # Set binmode
    #------------
    else {
        if ( ref($fh) eq 'IO::File' ) {
            ## binmode object call not available in older perl versions
            ## $fh->binmode(":raw:encoding(UTF-8)");
            if ($is_encoded_data) { binmode $fh, ":raw:encoding(UTF-8)"; }
            else                  { binmode $fh }
        }
        elsif ( $filename eq '-' ) {
            if ($is_encoded_data) { binmode STDOUT, ":raw:encoding(UTF-8)"; }
            else                  { binmode STDOUT }
        }
        else {

            # shouldn't get here
            if (DEVEL_MODE) {
                my $ref_fh = ref($fh);
                Fault(<<EOM);
unexpected streamhandle state for file='$filename' mode='$mode' ref(fh)=$ref_fh
EOM
            }
        }
    }

    return $fh;
} ## end sub streamhandle

sub stream_slurp {

    my ( $filename, ($timeout_in_seconds) ) = @_;

    # Given:
    #   $filename
    #   $timeout_in_seconds (optional timeout, in seconds)

    # Read the text in $filename and
    # return:
    #    undef if read error, or
    #    $rinput_string = ref to string of text

    # if $filename is:     Read
    # ----------------     -----------------
    # ARRAY  ref           array ref
    # SCALAR ref           string ref
    # object ref           object with 'getline' method (exit if no 'getline')
    # '-'                  STDIN
    # string               file named $filename

    # Note that any decoding from utf8 must be done by the caller

    my $ref = ref($filename);
    my $rinput_string;

    # handle a reference
    if ($ref) {
        if ( $ref eq 'ARRAY' ) {
            my $buf = join EMPTY_STRING, @{$filename};
            $rinput_string = \$buf;
        }
        elsif ( $ref eq 'SCALAR' ) {
            $rinput_string = $filename;
        }
        else {
            if ( $ref->can('getline') ) {
                my $buf = EMPTY_STRING;
                while ( defined( my $line = $filename->getline() ) ) {
                    $buf .= $line;
                }
                $rinput_string = \$buf;
            }
            else {
                confess <<EOM;
------------------------------------------------------------------------
No 'getline' method is defined for object of class '$ref'
Please check your call to Perl::Tidy::perltidy.  Trace follows.
------------------------------------------------------------------------
EOM
            }
        }
    }

    # handle a string
    else {
        if ( $filename eq '-' ) {
            local $INPUT_RECORD_SEPARATOR = undef;
            my $buf;
            if ( $timeout_in_seconds && $timeout_in_seconds > 0 ) {
                eval {
                    local $SIG{ALRM} = sub { die "alarm\n" };
                    alarm($timeout_in_seconds);
                    $buf = <>;
                    alarm(0);
                    1;
                }
                  or Die(
"Timeout reading stdin using -tos=$timeout_in_seconds seconds. Use -tos=0 to skip timeout check.\n"
                  );
            }
            else {
                $buf = <>;
            }
            $rinput_string = \$buf;
        }
        else {
            if ( open( my $fh, '<', $filename ) ) {
                local $INPUT_RECORD_SEPARATOR = undef;
                my $buf = <$fh>;
                $fh->close() or Warn("Cannot close $filename\n");
                $rinput_string = \$buf;
            }
            else {
                Warn("Cannot open $filename: $OS_ERROR\n");
                return;
            }
        }
    }

    return $rinput_string;
} ## end sub stream_slurp

# Here is a map of the flow of data from the input source to the output
# line sink:
#
#             -->Tokenizer-->Formatter-->VerticalAligner-->FileWriter-->
#       input                         groups                 output
#       lines   tokens      lines       of          lines    lines
#                                      lines
#
# The names correspond to the package names responsible for the unit processes.
#
# The overall process is controlled by the "main" package.
#
# Tokenizer analyzes a line and breaks it into tokens, peeking ahead
# if necessary.  A token is any section of the input line which should be
# manipulated as a single entity during formatting.  For example, a single
# ',' character is a token, and so is an entire side comment.  It handles
# the complexities of Perl syntax, such as distinguishing between '<<' as
# a shift operator and as a here-document, or distinguishing between '/'
# as a divide symbol and as a pattern delimiter.
#
# Formatter inserts and deletes whitespace between tokens, and breaks
# sequences of tokens at appropriate points as output lines.  It bases its
# decisions on the default rules as modified by any command-line options.
#
# VerticalAligner collects groups of lines together and tries to line up
# certain tokens, such as '=>', '#', and '=' by adding whitespace.
#
# FileWriter simply writes lines to the output stream.
#
# The Logger package, not shown, records significant events and warning
# messages.  It writes a .LOG file, which may be saved with a
# '-log' or a '-g' flag.

{ #<<<  (this side comment avoids excessive indentation in a closure)

my $Warn_count;
my $fh_stderr;
my $loaded_unicode_gcstring;
my $rstatus;

# Bump Warn_count only: it is essential to bump the count on all warnings, even
# if no message goes out, so that the correct exit status is set.
sub Warn_count_bump { $Warn_count++; return }

# Output Warn message only
sub Warn_msg { my $msg = shift; $fh_stderr->print($msg); return }

# Output Warn message and bump Warn count
sub Warn { my $msg = shift; $fh_stderr->print($msg); $Warn_count++; return }

sub is_char_mode {

    my ($string) = @_;

    # Returns:
    #   true  if $string is in Perl's internal character mode
    #         (also called the 'upgraded form', or UTF8=1)
    #   false if $string is in Perl's internal byte mode

    # This function isolates the call to Perl's internal function
    # utf8::is_utf8() which is true for strings represented in an 'upgraded
    # form'. It is available AFTER Perl version 5.8.
    # See https://perldoc.perl.org/Encode.
    # See also comments in Carp.pm and other modules using this function

    return 1 if ( utf8::is_utf8($string) );
    return;
} ## end sub is_char_mode

my $md5_hex = sub {
    my ($buf) = @_;

    # Evaluate the MD5 sum for a string:
    # Given:
    #   $buf = a string
    # Return:
    #   $digest = its MD5 sum

    # Patch for [rt.cpan.org #88020]
    # Use utf8::encode since md5_hex() only operates on bytes.
    # my $digest = md5_hex( utf8::encode($sink_buffer) );

    # Note added 20180114: the above patch did not work correctly.  I'm not
    # sure why.  But switching to the method recommended in the Perl 5
    # documentation for Encode worked.  According to this we can either use
    #    $octets = encode_utf8($string)  or equivalently
    #    $octets = encode("utf8",$string)
    # and then calculate the checksum.  So:
    my $octets = Encode::encode( "utf8", $buf );
    my $digest = md5_hex($octets);
    return $digest;
}; ## end $md5_hex = sub

sub get_iteration_count {
    return $rstatus->{iteration_count};
}

BEGIN {

    # Array index names for $self.
    # Do not combine with other BEGIN blocks (c101).
    my $i = 0;
    use constant {
        _actual_output_extension_  => $i++,
        _debugfile_stream_         => $i++,
        _decoded_input_as_         => $i++,
        _destination_stream_       => $i++,
        _diagnostics_object_       => $i++,
        _display_name_             => $i++,
        _file_extension_separator_ => $i++,
        _fileroot_                 => $i++,
        _is_encoded_data_          => $i++,
        _length_function_          => $i++,
        _line_separator_default_   => $i++,
        _line_separator_           => $i++,
        _line_tidy_begin_          => $i++,
        _line_tidy_end_            => $i++,
        _logger_object_            => $i++,
        _output_file_              => $i++,
        _postfilter_               => $i++,
        _prefilter_                => $i++,
        _rOpts_                    => $i++,
        _saw_pbp_                  => $i++,
        _teefile_stream_           => $i++,
        _user_formatter_           => $i++,
        _input_copied_verbatim_    => $i++,
        _input_output_difference_  => $i++,
        _dump_to_stdout_           => $i++,
    };
} ## end BEGIN

sub perltidy {

    my %input_hash = @_;

    # This is the main perltidy routine

    my %defaults = (
        argv                  => undef,
        destination           => undef,
        formatter             => undef,
        logfile               => undef,
        errorfile             => undef,
        teefile               => undef,
        debugfile             => undef,
        perltidyrc            => undef,
        source                => undef,
        stderr                => undef,
        dump_options          => undef,
        dump_options_type     => undef,
        dump_getopt_flags     => undef,
        dump_options_category => undef,
        dump_options_range    => undef,
        dump_abbreviations    => undef,
        prefilter             => undef,
        postfilter            => undef,
    );

    # Status information which can be returned for diagnostic purposes.
    # NOTE: This is intended only for testing and subject to change.

    # List of "key => value" hash entries:

    # Some relevant user input parameters for convenience:
    # opt_format         => value of --format: 'tidy', 'html', or 'user'
    # opt_encoding       => value of -enc flag: 'utf8', 'none', or 'guess'
    # opt_encode_output  => value of -eos flag: 'eos' or 'neos'
    # opt_max_iterations => value of --iterations=n

    # file_count         => number of files processed in this call

    # If multiple files are processed, then the following values will be for
    # the last file only:

    # input_name         => name of the input stream
    # output_name        => name of the output stream

    # The following two variables refer to Perl's two internal string modes,
    # and have the values 0 for 'byte' mode and 1 for 'char' mode:
    # char_mode_source   => true if source is in 'char' mode. Will be false
    #      unless we received a source string ref with utf8::is_utf8() set.
    # char_mode_used     => true if text processed by perltidy in 'char' mode.
    #      Normally true for text identified as utf8, otherwise false.

    # This tells if Unicode::GCString was used
    # gcs_used           => true if -gcs and Unicode::GCString found & used

    # These variables tell what utf8 decoding/encoding was done:
    # input_decoded_as   => non-blank if perltidy decoded the source text
    # output_encoded_as  => non-blank if perltidy encoded before return

    # These variables are related to iterations and convergence testing:
    # iteration_count    => number of iterations done
    #                       ( can be from 1 to opt_max_iterations )
    # converged          => true if stopped on convergence
    #                       ( can only happen if opt_max_iterations > 1 )
    # blinking           => true if stopped on blinking states
    #                       ( i.e., unstable formatting, should not happen )

    $rstatus = {

        file_count         => 0,
        opt_format         => EMPTY_STRING,
        opt_encoding       => EMPTY_STRING,
        opt_encode_output  => EMPTY_STRING,
        opt_max_iterations => EMPTY_STRING,

        input_name        => EMPTY_STRING,
        output_name       => EMPTY_STRING,
        char_mode_source  => 0,
        char_mode_used    => 0,
        input_decoded_as  => EMPTY_STRING,
        output_encoded_as => EMPTY_STRING,
        gcs_used          => 0,
        iteration_count   => 0,
        converged         => 0,
        blinking          => 0,
    };

    # Fix for issue git #57
    $Warn_count = 0;

    # don't overwrite callers ARGV
    # Localization of @ARGV could be avoided by calling GetOptionsFromArray
    # instead of GetOptions, but that is not available before perl 5.10
    local @ARGV   = @ARGV;
    local *STDERR = *STDERR;

    if ( my @bad_keys = grep { !exists $defaults{$_} } keys %input_hash ) {
        local $LIST_SEPARATOR = ')(';
        my @good_keys = sort keys %defaults;
        @bad_keys = sort @bad_keys;
        confess <<EOM;
------------------------------------------------------------------------
Unknown perltidy parameter : (@bad_keys)
perltidy only understands : (@good_keys)
------------------------------------------------------------------------

EOM
    }

    my $get_hash_ref = sub {
        my ($key) = @_;
        my $hash_ref = $input_hash{$key};
        if ( defined($hash_ref) ) {
            if ( ref($hash_ref) ne 'HASH' ) {
                my $what = ref($hash_ref);
                my $but_is =
                  $what ? "but is ref to $what" : "but is not a reference";
                croak <<EOM;
------------------------------------------------------------------------
error in call to perltidy:
-$key must be reference to HASH $but_is
------------------------------------------------------------------------
EOM
            }
        }
        return $hash_ref;
    }; ## end $get_hash_ref = sub

    %input_hash = ( %defaults, %input_hash );
    my $argv               = $input_hash{'argv'};
    my $destination_stream = $input_hash{'destination'};
    my $perltidyrc_stream  = $input_hash{'perltidyrc'};
    my $source_stream      = $input_hash{'source'};
    my $stderr_stream      = $input_hash{'stderr'};
    my $user_formatter     = $input_hash{'formatter'};
    my $prefilter          = $input_hash{'prefilter'};
    my $postfilter         = $input_hash{'postfilter'};

    if ($stderr_stream) {
        $fh_stderr = Perl::Tidy::streamhandle( $stderr_stream, 'w' );
        if ( !$fh_stderr ) {
            croak <<EOM;
------------------------------------------------------------------------
Unable to redirect STDERR to $stderr_stream
Please check value of -stderr in call to perltidy
------------------------------------------------------------------------
EOM
        }
    }
    else {
        $fh_stderr = *STDERR;
    }

    my $self = [];
    bless $self, __PACKAGE__;

    sub Exit {
        my $flag = shift;
        if   ($flag) { goto ERROR_EXIT }
        else         { goto NORMAL_EXIT }
        croak "unexpected return to sub Exit";
    } ## end sub Exit

    sub Die {
        my $msg = shift;
        Warn($msg);
        Exit(1);
        croak "unexpected return from sub Exit";
    } ## end sub Die

    sub Fault {
        my ($msg) = @_;

        # This routine is called for errors that really should not occur
        # except if there has been a bug introduced by a recent program change.
        # Please add comments at calls to Fault to explain why the call
        # should not occur, and where to look to fix it.
        my ( $package0_uu, $filename0_uu, $line0, $subroutine0_uu ) = caller(0);
        my ( $package1_uu, $filename1,    $line1, $subroutine1 )    = caller(1);
        my ( $package2_uu, $filename2_uu, $line2_uu, $subroutine2 ) = caller(2);
        my $pkg = __PACKAGE__;

        my $input_stream_name = $rstatus->{'input_name'};
        $input_stream_name = '(unknown)' unless ($input_stream_name);
        Die(<<EOM);
==============================================================================
While operating on input stream with name: '$input_stream_name'
A fault was detected at line $line0 of sub '$subroutine1'
in file '$filename1'
which was called from line $line1 of sub '$subroutine2'
Message: '$msg'
This is probably an error introduced by a recent programming change.
$pkg reports VERSION='$VERSION'.
==============================================================================
EOM

        croak "unexpected return from sub Die";
    } ## end sub Fault

    # extract various dump parameters
    my $dump_options_type     = $input_hash{'dump_options_type'};
    my $dump_options          = $get_hash_ref->('dump_options');
    my $dump_getopt_flags     = $get_hash_ref->('dump_getopt_flags');
    my $dump_options_category = $get_hash_ref->('dump_options_category');
    my $dump_abbreviations    = $get_hash_ref->('dump_abbreviations');
    my $dump_options_range    = $get_hash_ref->('dump_options_range');

    # validate dump_options_type
    if ( defined($dump_options) ) {
        if ( !defined($dump_options_type) ) {
            $dump_options_type = 'perltidyrc';
        }
        if (   $dump_options_type ne 'perltidyrc'
            && $dump_options_type ne 'full' )
        {
            croak <<EOM;
------------------------------------------------------------------------
Please check value of -dump_options_type in call to perltidy;
saw: '$dump_options_type'
expecting: 'perltidyrc' or 'full'
------------------------------------------------------------------------
EOM

        }
    }
    else {
        $dump_options_type = EMPTY_STRING;
    }

    if ($user_formatter) {

        # if the user defines a formatter, there is no output stream,
        # but we need a null stream to keep coding simple
        $destination_stream = \my $tmp;
    }

    # see if ARGV is overridden
    if ( defined($argv) ) {

        my $rargv = ref($argv);
        if ( $rargv eq 'SCALAR' ) { $argv = ${$argv}; $rargv = undef }

        # ref to ARRAY
        if ($rargv) {
            if ( $rargv eq 'ARRAY' ) {
                @ARGV = @{$argv};
            }
            else {
                croak <<EOM;
------------------------------------------------------------------------
Please check value of -argv in call to perltidy;
it must be a string or ref to ARRAY but is: $rargv
------------------------------------------------------------------------
EOM
            }
        }

        # string
        else {
            my ( $rargv_str, $msg ) = parse_args($argv);
            if ($msg) {
                Die(<<EOM);
Error parsing this string passed to to perltidy with 'argv':
$msg
EOM
            }
            @ARGV = @{$rargv_str};
        }
    }

    # These string refs will hold any warnings and error messages to be written
    # to the logfile object when it eventually gets created.
    my $rpending_complaint;
    ${$rpending_complaint} = EMPTY_STRING;

    my $rpending_logfile_message;
    ${$rpending_logfile_message} = EMPTY_STRING;

    my ( $is_Windows, $Windows_type ) = look_for_Windows($rpending_complaint);

    # VMS file names are restricted to a 40.40 format, so we append _tdy
    # instead of .tdy, etc. (but see also sub check_vms_filename)
    my $dot;
    my $dot_pattern;
    if ( $OSNAME eq 'VMS' ) {
        $dot         = '_';
        $dot_pattern = '_';
    }
    else {
        $dot         = '.';
        $dot_pattern = '\.';    # must escape for use in regex
    }
    $self->[_file_extension_separator_] = $dot;

    # save a copy of the last two input args for error checking later
    my @ARGV_saved;
    if ( @ARGV > 1 ) {
        @ARGV_saved = ( $ARGV[-2], $ARGV[-1] );
    }

    # see if -wvt was entered on the command line before @ARGV is changed
    my $wvt_in_args = grep { /-(wvt|warn-variable-types)=/ } @ARGV;

    #-------------------------
    # get command line options
    #-------------------------
    my ( $rOpts, $config_file, $rraw_options, $roption_string,
        $rexpansion, $roption_category, $roption_range, $rinteger_option_range )
      = process_command_line(
        $perltidyrc_stream,  $is_Windows, $Windows_type,
        $rpending_complaint, $dump_options_type,
      );

    # Only filenames should remain in @ARGV
    my @Arg_files = @ARGV;

    $self->[_rOpts_] = $rOpts;

    my $saw_pbp =
      grep { $_ eq '-pbp' || $_ eq '-perl-best-practices' } @{$rraw_options};
    $self->[_saw_pbp_] = $saw_pbp;

    #------------------------------------
    # Handle requests to dump information
    #------------------------------------

    # return or exit immediately after all dumps
    my $quit_now = 0;

    # Getopt parameters and their flags
    if ( defined($dump_getopt_flags) ) {
        $quit_now = 1;
        foreach my $op ( @{$roption_string} ) {
            my $opt  = $op;
            my $flag = EMPTY_STRING;

            # Examples:
            #  some-option=s
            #  some-option=i
            #  some-option:i
            #  some-option!
            if ( $opt =~ /(.*)(!|=.*|:.*)$/ ) {
                $opt  = $1;
                $flag = $2;
            }
            $dump_getopt_flags->{$opt} = $flag;
        }
    }

    if ( defined($dump_options_category) ) {
        $quit_now = 1;
        %{$dump_options_category} = %{$roption_category};
    }

    if ( defined($dump_options_range) ) {
        $quit_now = 1;
        %{$dump_options_range} = %{$roption_range};
    }

    if ( defined($dump_abbreviations) ) {
        $quit_now = 1;
        %{$dump_abbreviations} = %{$rexpansion};
    }

    if ( defined($dump_options) ) {
        $quit_now = 1;
        %{$dump_options} = %{$rOpts};
    }

    Exit(0) if ($quit_now);

    # make printable string of options for this run as possible diagnostic
    my $readable_options = readable_options( $rOpts, $roption_string );

    # dump from command line
    if ( $rOpts->{'dump-options'} ) {
        print {*STDOUT} $readable_options;
        Exit(0);
    }

    # some dump options require one filename in the arg list.  This is a safety
    # precaution in case a user accidentally adds such an option to the command
    # line parameters and is expecting formatted output to stdout.  Another
    # precaution, added elsewhere, is to ignore these in a .perltidyrc
    my $num_files = @Arg_files;
    foreach my $opt_name (
        qw(
        dump-block-summary
        dump-unusual-variables
        dump-mixed-call-parens
        dump-mismatched-args
        dump-mismatched-returns
        dump-unique-keys
        )
      )
    {
        if ( $rOpts->{$opt_name} ) {
            $self->[_dump_to_stdout_] = 1;
            if ( $num_files != 1 ) {
                Die(<<EOM);
--$opt_name expects 1 filename in the arg list but saw $num_files filenames
EOM
            }
        }
    }

    #----------------------------------------
    # check parameters and their interactions
    #----------------------------------------
    $self->check_options( $num_files, $rinteger_option_range );

    if ($user_formatter) {
        $rOpts->{'format'} = 'user';
    }

    # there must be one entry here for every possible format
    my %default_file_extension = (
        tidy => 'tdy',
        html => 'html',
        user => EMPTY_STRING,
    );

    $rstatus->{'opt_format'}         = $rOpts->{'format'};
    $rstatus->{'opt_max_iterations'} = $rOpts->{'iterations'};
    $rstatus->{'opt_encode_output'} =
      $rOpts->{'encode-output-strings'} ? 'eos' : 'neos';

    # be sure we have a valid output format
    if ( !exists $default_file_extension{ $rOpts->{'format'} } ) {
        my $formats = join SPACE,
          sort map { "'" . $_ . "'" } keys %default_file_extension;
        my $fmt = $rOpts->{'format'};
        Die("-format='$fmt' but must be one of: $formats\n");
    }

    my $output_extension =
      $self->make_file_extension( $rOpts->{'output-file-extension'},
        $default_file_extension{ $rOpts->{'format'} } );

    # get parameters associated with the -b option
    my ( $in_place_modify, $backup_extension, $delete_backup ) =
      $self->check_in_place_modify( $source_stream, $destination_stream );

    my $line_range_clipped = $rOpts->{'line-range-tidy'}
      && ( $self->[_line_tidy_begin_] > 1
        || defined( $self->[_line_tidy_end_] ) );

    Perl::Tidy::Formatter::check_options( $rOpts, $wvt_in_args, $num_files,
        $line_range_clipped );
    Perl::Tidy::Tokenizer::check_options($rOpts);
    Perl::Tidy::VerticalAligner::check_options($rOpts);
    if ( $rOpts->{'format'} eq 'html' ) {
        Perl::Tidy::HtmlWriter->check_options($rOpts);
    }

    # Try to catch an unusual missing string parameter error, like this:
    #    perltidy -wvt perltidy.pl
    # The problem is that -wvt wants a string, so it grabs 'perltidy.pl'.
    # Then there is no output filename, so input is assumed to be stdin.
    # This make perltidy unexpectedly wait for input. To the user, it
    # appears that perltidy has gone into an infinite loop. Issue c312.
    # To avoid getting this far, it is best for parameters which take a
    # string to check the strings in one of the 'check_options' subs, and
    # exit if there is an obvious error. This has been done for -wvt,
    # but are undoubtedly other parameters where this problem might occur.
    if ( !$num_files && @ARGV_saved > 1 ) {
        my $opt_test  = $ARGV_saved[-2];
        my $file_test = $ARGV_saved[-1];
        if (   $opt_test =~ s/^[-]+//
            && $file_test !~ /^[-]/
            && $file_test !~ /^\d+$/
            && -e $file_test )
        {

            # These options can take filenames, so we will ignore them here
            my %is_option_with_file_parameter;
            my @qf = qw( outfile profile );
            @is_option_with_file_parameter{@qf} = (1) x scalar(@qf);

            # Expand an abbreviation into a long name
            my $long_name;
            my $exp = $rexpansion->{$opt_test};
            if    ( !$exp )        { $long_name = $opt_test }
            elsif ( @{$exp} == 1 ) { $long_name = $exp->[0] }
            else                   { }

            # If this arg grabbed the file, then it must take a string arg
            if (   $long_name
                && defined( $rOpts->{$long_name} )
                && $rOpts->{$long_name} eq $file_test
                && !$is_option_with_file_parameter{$long_name} )
            {
                Die(<<EOM);
Stopping on possible missing string parameter for '-$opt_test':
This parameter takes a string and has been set equal to file '$file_test',
and formatted output will go to standard output. If this is actually correct,
you can skip this message by entering this as '-$opt_test=$file_test'.
EOM
            }
        }
    }

    # make the pattern of file extensions that we shouldn't touch
    my $forbidden_file_extensions = "(($dot_pattern)(LOG|DEBUG|ERR|TEE)";
    if ($output_extension) {
        my $ext = quotemeta($output_extension);
        $forbidden_file_extensions .= "|$ext";
    }
    if ( $in_place_modify && $backup_extension ) {
        my $ext = quotemeta($backup_extension);
        $forbidden_file_extensions .= "|$ext";
    }
    $forbidden_file_extensions .= ')$';

    # Create a diagnostics object if requested;
    # This is only useful for code development
    my $diagnostics_object = undef;
    if (DIAGNOSTICS) {
        $diagnostics_object = Perl::Tidy::Diagnostics->new();
    }

    # no filenames should be given if input is from an array
    if ($source_stream) {
        if ( @Arg_files > 0 ) {
            Die(
"You may not specify any filenames when a source array is given\n"
            );
        }

        # we'll stuff the source array into Arg_files
        unshift( @Arg_files, $source_stream );

        # No special treatment for source stream which is a filename.
        # This will enable checks for binary files and other bad stuff.
        $source_stream = undef unless ref($source_stream);
    }

    # use stdin by default if no source array and no args
    elsif ( !@Arg_files ) {
        unshift( @Arg_files, '-' );
    }

    # check file existence and expand any globs
    else {
        my @updated_files;
        foreach my $input_file (@Arg_files) {
            if ( -e $input_file ) {
                push @updated_files, $input_file;
            }
            else {

                # file doesn't exist - check for a file glob
                if ( $input_file =~ /([\?\*\[\{])/ ) {

                    # Windows shell may not remove quotes, so do it
                    my $ifile = $input_file;
                    if ( $ifile =~ /^\'(.+)\'$/ ) { $ifile = $1 }
                    if ( $ifile =~ /^\"(.+)\"$/ ) { $ifile = $1 }
                    my $pattern = fileglob_to_re($ifile);
                    my $dh;
                    if ( opendir( $dh, './' ) ) {
                        my @files =
                          grep { /$pattern/ && !-d } readdir($dh);
                        closedir($dh);
                        next unless (@files);
                        push @updated_files, @files;
                        next;
                    }
                }
                Warn("skipping file: '$input_file': no matches found\n");
                next;
            }
        } ## end loop over input filenames

        @Arg_files = @updated_files;
        if ( !@Arg_files ) {
            Die("no matching input files found\n");
        }
    }

    # Flag for loading module Unicode::GCString for evaluating text width:
    #   undef = ok to use but not yet loaded
    #       0 = do not use; failed to load or not wanted
    #       1 = successfully loaded and ok to use
    # The module is not actually loaded unless/until it is needed
    if ( !$rOpts->{'use-unicode-gcstring'} ) {
        $loaded_unicode_gcstring = 0;
    }

    # Remove duplicate filenames.  Otherwise, for example if the user entered
    #     perltidy -b myfile.pl myfile.pl
    # the backup version of the original would be lost.
    if ( @Arg_files > 1 ) {
        my %seen = ();
        @Arg_files = grep { !$seen{$_}++ } @Arg_files;
    }

    # If requested, process in order of increasing file size
    # This can significantly reduce perl's virtual memory usage during testing.
    if ( @Arg_files > 1 && $rOpts->{'file-size-order'} ) {
        @Arg_files =
          map  { $_->[0] }
          sort { $a->[1] <=> $b->[1] }
          map  { [ $_, -e $_ ? -s $_ : 0 ] } @Arg_files;
    }

    my $logfile_header = make_logfile_header( $rOpts, $config_file,
        $rraw_options, $Windows_type, $readable_options );

    # Store some values needed by lower level routines
    $self->[_diagnostics_object_] = $diagnostics_object;
    $self->[_postfilter_]         = $postfilter;
    $self->[_prefilter_]          = $prefilter;
    $self->[_user_formatter_]     = $user_formatter;

    #--------------------------
    # loop to process all files
    #--------------------------
    $self->process_all_files(
        {
            rinput_hash => \%input_hash,
            rfiles      => \@Arg_files,

            # filename stuff...
            source_stream             => $source_stream,
            output_extension          => $output_extension,
            forbidden_file_extensions => $forbidden_file_extensions,
            in_place_modify           => $in_place_modify,
            backup_extension          => $backup_extension,
            delete_backup             => $delete_backup,

            # logfile stuff...
            logfile_header           => $logfile_header,
            rpending_complaint       => $rpending_complaint,
            rpending_logfile_message => $rpending_logfile_message,
        }
    );

    #-----
    # Exit
    #-----

    # Fix for RT #130297: return a true value if anything was written to the
    # standard error output, even non-fatal warning messages, otherwise return
    # false.

    # These exit codes are returned:
    #  0 = perltidy ran to completion with no errors
    #  1 = perltidy could not run to completion due to errors
    #  2 = perltidy ran to completion with error messages

    # Note that if perltidy is run with multiple files, any single file with
    # errors or warnings will write a line like
    #        '## Please see file testing.t.ERR'
    # to standard output for each file with errors, so the flag will be true,
    # even if only some of the multiple files may have had errors.

  NORMAL_EXIT:
    my $ret = $Warn_count ? 2 : 0;
    return wantarray ? ( $ret, $rstatus ) : $ret;

  ERROR_EXIT:
    return wantarray ? ( 1, $rstatus ) : 1;

} ## end sub perltidy

sub make_file_extension {

    # Make a file extension, adding any leading '.' if necessary.
    # (the '.' may actually be an '_' under VMS).
    my ( $self, $extension, ($default) ) = @_;

    # Given:
    #  $extension = the first choice (usually a user entry)
    #  $default   = an optional backup extension
    # Return:
    #  $extension = the actual file extension

    $extension = EMPTY_STRING unless defined($extension);
    $extension =~ s/^\s+//;
    $extension =~ s/\s+$//;

    # Use default extension if nothing remains of the first choice
    if ( length($extension) == 0 ) {
        $extension = $default;
        $extension = EMPTY_STRING unless defined($extension);
        $extension =~ s/^\s+//;
        $extension =~ s/\s+$//;
    }

    # Only extensions with these leading characters get a '.'
    # This rule gives the user some freedom.
    if ( $extension =~ /^[a-zA-Z0-9]/ ) {
        my $dot = $self->[_file_extension_separator_];
        $extension = $dot . $extension;
    }
    return $extension;
} ## end sub make_file_extension

sub check_in_place_modify {

    my ( $self, $source_stream, $destination_stream ) = @_;

    # See if --backup-and-modify-in-place (-b) is set, and if so,
    # return its associated parameters
    my $rOpts = $self->[_rOpts_];

    # check for -b option;
    # silently ignore unless beautify mode
    my $in_place_modify = $rOpts->{'backup-and-modify-in-place'}
      && $rOpts->{'format'} eq 'tidy';

    my ( $backup_extension, $delete_backup );

    # Turn off -b with warnings in case of conflicts with other options.
    # NOTE: Do this silently, without warnings, if there is a source or
    # destination stream, or standard output is used.  This is because the -b
    # flag may have been in a .perltidyrc file and warnings break
    # Test::NoWarnings.  See email discussion with Merijn Brand 26 Feb 2014.
    if ($in_place_modify) {
        if (   $rOpts->{'standard-output'}
            || $destination_stream
            || ref($source_stream)
            || $rOpts->{'outfile'}
            || defined( $rOpts->{'output-path'} ) )
        {
            $in_place_modify = 0;
        }
    }

    if ($in_place_modify) {

        # If the backup extension contains a / character then the backup should
        # be deleted when the -b option is used.   On older versions of
        # perltidy this will generate an error message due to an illegal
        # file name.
        #
        # A backup file will still be generated but will be deleted
        # at the end.  If -bext='/' then this extension will be
        # the default 'bak'.  Otherwise it will be whatever characters
        # remains after all '/' characters are removed.  For example:
        # -bext         extension     slashes
        #  '/'          bak           1
        #  '/delete'    delete        1
        #  'delete/'    delete        1
        #  '/dev/null'  devnull       2    (Currently not allowed)
        my $bext = $rOpts->{'backup-file-extension'};
        $delete_backup = ( $rOpts->{'backup-file-extension'} =~ s/\///g );

        # At present only one forward slash is allowed.  In the future multiple
        # slashes may be allowed to allow for other options
        if ( $delete_backup > 1 ) {
            Die("-bext=$bext contains more than one '/'\n");
        }

        $backup_extension =
          $self->make_file_extension( $rOpts->{'backup-file-extension'},
            'bak' );
    }

    my $backup_method = $rOpts->{'backup-method'};
    if (   defined($backup_method)
        && $backup_method ne 'copy'
        && $backup_method ne 'move' )
    {
        Die(
"Unexpected --backup-method='$backup_method'; must be one of: 'move', 'copy'\n"
        );
    }

    return ( $in_place_modify, $backup_extension, $delete_backup );
} ## end sub check_in_place_modify

sub backup_method_copy {

    my ( $self, $input_file, $routput_string, $backup_extension,
        $delete_backup )
      = @_;

    # Handle the -b (--backup-and-modify-in-place) option with -bm='copy':
    # - First copy $input file to $backup_name.
    # - Then open input file and rewrite with contents of $routput_string
    # - Then delete the backup if requested

    # NOTES:
    # - Die immediately on any error.
    # - $routput_string is a SCALAR ref

    my $backup_file = $input_file . $backup_extension;

    if ( !-f $input_file ) {

        # no real file to backup ..
        # This shouldn't happen because of numerous preliminary checks
        Die(
            "problem with -b backing up input file '$input_file': not a file\n"
        );
    }

    if ( -f $backup_file ) {
        unlink($backup_file)
          or Die(
"unable to remove previous '$backup_file' for -b option; check permissions: $OS_ERROR\n"
          );
    }

    # Copy input file to backup
    File::Copy::copy( $input_file, $backup_file )
      or Die("File::Copy failed trying to backup source: $OS_ERROR");

    # set permissions of the backup file to match the input file
    my @input_file_stat = stat($input_file);
    my $in_place_modify = 1;
    $self->set_output_file_permissions( $backup_file, \@input_file_stat,
        $in_place_modify );

    # set the modification time of the copy to the original value (rt#145999)
    my ( $read_time, $write_time ) = @input_file_stat[ _atime_, _mtime_ ];
    if ( defined($write_time) ) {
        utime( $read_time, $write_time, $backup_file )
          || Warn("error setting times for backup file '$backup_file'\n");
    }

    # Open the original input file for writing ... opening with ">" will
    # truncate the existing data.
    open( my $fout, ">", $input_file )
      or Die(
"problem re-opening $input_file for write for -b option; check file and directory permissions: $OS_ERROR\n"
      );

    if ( $self->[_is_encoded_data_] ) { binmode $fout, ":raw:encoding(UTF-8)" }
    else                              { binmode $fout }

    # Now copy the formatted output to it..
    # output must be SCALAR ref..
    if ( ref($routput_string) eq 'SCALAR' ) {
        $fout->print( ${$routput_string} )
          or Die("cannot print to '$input_file' with -b option: $OS_ERROR\n");
    }

    # Error if anything else ...
    else {
        my $ref = ref($routput_string);
        Die(<<EOM);
Programming error: unable to print to '$input_file' with -b option:
unexpected ref type '$ref'; expecting 'ARRAY' or 'SCALAR'
EOM
    }

    $fout->close()
      or Die("cannot close '$input_file' with -b option: $OS_ERROR\n");

    # Set permissions of the output file to match the input file. This is
    # necessary even if the inode remains unchanged because suid/sgid bits may
    # have been reset.
    $self->set_output_file_permissions( $input_file, \@input_file_stat,
        $in_place_modify );

    # Keep original modification time if no change (rt#145999)
    if ( !$self->[_input_output_difference_] && defined($write_time) ) {
        utime( $read_time, $write_time, $input_file )
          || Warn("error setting times for '$input_file'\n");
    }

    #---------------------------------------------------------
    # remove the original file for in-place modify as follows:
    #   $delete_backup=0 never
    #   $delete_backup=1 only if no errors
    #   $delete_backup>1 always  : NOT ALLOWED, too risky
    #---------------------------------------------------------
    if ( $delete_backup && -f $backup_file ) {

        # Currently, $delete_backup may only be 1. But if a future update
        # allows a value > 1, then reduce it to 1 if there were warnings.
        if (   $delete_backup > 1
            && $self->[_logger_object_]->get_warning_count() )
        {
            $delete_backup = 1;
        }

        # As an added safety precaution, do not delete the source file
        # if its size has dropped from positive to zero, since this
        # could indicate a disaster of some kind, including a hardware
        # failure.  Actually, this could happen if you had a file of
        # all comments (or pod) and deleted everything with -dac (-dap)
        # for some reason.
        if ( !-s $input_file && -s $backup_file && $delete_backup == 1 ) {
            Warn(
"output file '$input_file' missing or zero length; original '$backup_file' not deleted\n"
            );
        }
        else {
            unlink($backup_file)
              or Die(
"unable to remove backup file '$backup_file' for -b option; check permissions: $OS_ERROR\n"
              );
        }
    }

    # Verify that inode is unchanged during development
    if (DEVEL_MODE) {
        my @output_file_stat = stat($input_file);
        my $inode_input      = $input_file_stat[1];
        my $inode_output     = $output_file_stat[1];
        if ( $inode_input != $inode_output ) {
            Fault(<<EOM);
inode changed with -bm=copy for file '$input_file': inode_input=$inode_input inode_output=$inode_output
EOM
        }
    }

    return;
} ## end sub backup_method_copy

sub backup_method_move {

    my ( $self, $input_file, $routput_string, $backup_extension,
        $delete_backup )
      = @_;

    # Handle the -b (--backup-and-modify-in-place) option with -bm='move':
    # - First move $input file to $backup_name.
    # - Then copy $routput_string to $input_file.
    # - Then delete the backup if requested

    # NOTES:
    # - Die immediately on any error.
    # - $routput_string is a SCALAR ref
    # - $input_file permissions will be set by sub set_output_file_permissions

    my $backup_name = $input_file . $backup_extension;

    if ( !-f $input_file ) {

        # oh, oh, no real file to backup ..
        # shouldn't happen because of numerous preliminary checks
        Die(
            "problem with -b backing up input file '$input_file': not a file\n"
        );
    }
    if ( -f $backup_name ) {
        unlink($backup_name)
          or Die(
"unable to remove previous '$backup_name' for -b option; check permissions: $OS_ERROR\n"
          );
    }

    my @input_file_stat = stat($input_file);

    # backup the input file
    # we use copy for symlinks, move for regular files
    if ( -l $input_file ) {
        File::Copy::copy( $input_file, $backup_name )
          or Die("File::Copy failed trying to backup source: $OS_ERROR");
    }
    else {
        rename( $input_file, $backup_name )
          or Die(
"problem renaming $input_file to $backup_name for -b option: $OS_ERROR\n"
          );
    }

    # Open a file with the original input file name for writing ...
    open( my $fout, ">", $input_file )
      or Die(
"problem re-opening $input_file for write for -b option; check file and directory permissions: $OS_ERROR\n"
      );

    if ( $self->[_is_encoded_data_] ) { binmode $fout, ":raw:encoding(UTF-8)" }
    else                              { binmode $fout }

    # Now copy the formatted output to it..
    # output must be SCALAR ref..
    if ( ref($routput_string) eq 'SCALAR' ) {
        $fout->print( ${$routput_string} )
          or Die("cannot print to '$input_file' with -b option: $OS_ERROR\n");
    }

    # Error if anything else ...
    else {
        my $ref = ref($routput_string);
        Die(<<EOM);
Programming error: unable to print to '$input_file' with -b option:
unexpected ref type '$ref'; expecting 'ARRAY' or 'SCALAR'
EOM
    }

    $fout->close()
      or Die("cannot close '$input_file' with -b option: $OS_ERROR\n");

    # set permissions of the output file to match the input file
    my $in_place_modify = 1;
    $self->set_output_file_permissions( $input_file, \@input_file_stat,
        $in_place_modify );

    # Keep original modification time if no change (rt#145999)
    my ( $read_time, $write_time ) = @input_file_stat[ _atime_, _mtime_ ];
    if ( !$self->[_input_output_difference_] && defined($write_time) ) {
        utime( $read_time, $write_time, $input_file )
          || Warn("error setting times for '$input_file'\n");
    }

    #---------------------------------------------------------
    # remove the original file for in-place modify as follows:
    #   $delete_backup=0 never
    #   $delete_backup=1 only if no errors
    #   $delete_backup>1 always  : NOT ALLOWED, too risky
    #---------------------------------------------------------
    if ( $delete_backup && -f $backup_name ) {

        # Currently, $delete_backup may only be 1. But if a future update
        # allows a value > 1, then reduce it to 1 if there were warnings.
        if (   $delete_backup > 1
            && $self->[_logger_object_]->get_warning_count() )
        {
            $delete_backup = 1;
        }

        # As an added safety precaution, do not delete the source file
        # if its size has dropped from positive to zero, since this
        # could indicate a disaster of some kind, including a hardware
        # failure.  Actually, this could happen if you had a file of
        # all comments (or pod) and deleted everything with -dac (-dap)
        # for some reason.
        if ( !-s $input_file && -s $backup_name && $delete_backup == 1 ) {
            Warn(
"output file '$input_file' missing or zero length; original '$backup_name' not deleted\n"
            );
        }
        else {
            unlink($backup_name)
              or Die(
"unable to remove previous '$backup_name' for -b option; check permissions: $OS_ERROR\n"
              );
        }
    }

    return;

} ## end sub backup_method_move

# masks for file permissions
use constant OCT_777  => oct(777);     # All users (O+G+W) + r/w/x bits
use constant OCT_7777 => oct(7777);    # Same + suid/sgid/sbit
use constant OCT_600  => oct(600);     # Owner RW permission

sub set_output_file_permissions {

    my ( $self, $output_file, $rinput_file_stat, $in_place_modify ) = @_;

    # Set the permissions for the output file

    # Given:
    #  $output_file      = the file whose permissions we will set
    #  $rinput_file_stat = the result of stat($input_file)
    #  $in_place_modify  = true if --backup-and-modify-in-place is set

    my ( $mode_i, $uid_i, $gid_i ) =
      @{$rinput_file_stat}[ _mode_, _uid_, _gid_ ];
    my ( $uid_o, $gid_o ) = ( stat($output_file) )[ _uid_, _gid_ ];
    my $input_file_permissions  = $mode_i & OCT_7777;
    my $output_file_permissions = $input_file_permissions;

    #rt128477: avoid inconsistent owner/group and suid/sgid
    if ( $uid_i != $uid_o || $gid_i != $gid_o ) {

        # try to change owner and group to match input file if
        # in -b mode.  Note: chown returns number of files
        # successfully changed.
        if ( $in_place_modify
            && chown( $uid_i, $gid_i, $output_file ) )
        {
            # owner/group successfully changed
        }
        else {

            # owner or group differ: do not copy suid and sgid
            $output_file_permissions = $mode_i & OCT_777;
            if ( $input_file_permissions != $output_file_permissions ) {
                Warn(
"Unable to copy setuid and/or setgid bits for output file '$output_file'\n"
                );
            }
        }
    }

    # Mark the output file for rw unless we are in -b mode.
    # Explanation: perltidy does not unlink existing output
    # files before writing to them, for safety.  If a
    # designated output file exists and is not writable,
    # perltidy will halt.  This can prevent a data loss if a
    # user accidentally enters "perltidy infile -o
    # important_ro_file", or "perltidy infile -st
    # >important_ro_file". But it also means that perltidy can
    # get locked out of rerunning unless it marks its own
    # output files writable. The alternative, of always
    # unlinking the designated output file, is less safe and
    # not always possible, except in -b mode, where there is an
    # assumption that a previous backup can be unlinked even if
    # not writable.
    if ( !$in_place_modify ) {
        $output_file_permissions |= OCT_600;
    }

    if ( !chmod( $output_file_permissions, $output_file ) ) {

        # couldn't change file permissions
        my $operm = sprintf "%04o", $output_file_permissions;
        Warn(
"Unable to set permissions for output file '$output_file' to $operm\n"
        );
    }
    return;
} ## end sub set_output_file_permissions

sub get_decoded_string_buffer {

    my ( $self, $input_file, $display_name ) = @_;

    # Decode the input buffer from utf8 if necessary or requested

    # Given:
    #   $input_file   = the input file or stream
    #   $display_name = its name to use in error messages

    # Set $self->[_line_separator_], and

    # Return:
    #   $rinput_string = ref to input string, decoded from utf8 if necessary
    #   $is_encoded_data  = true if $buf is decoded from utf8
    #   $decoded_input_as = true if perltidy decoded input buf
    #   $encoding_log_message = messages for log file,
    #   $length_function  = function to use for measuring string width

    # Return nothing on any error; this is a signal to skip this file

    my $rOpts = $self->[_rOpts_];

    my $rinput_string =
      stream_slurp( $input_file, $rOpts->{'timeout-in-seconds'} );
    return unless ( defined($rinput_string) );

    # Note that we could have a zero size input string here if it
    # arrived from standard input or from a string ref. For example
    # 'perltidy <null.pl'.  If we issue a warning and stop, as we would
    # for a zero length file ('perltidy null.pl'), then we could cause
    # a call to the perltidy module to misbehave as a filter. So we will
    # process this as any other file in this case without any warning (c286).
    if ( !length( ${$rinput_string} ) ) {

        # zero length, but keep going
    }

    # Check size of strings arriving from the standard input. These
    # could not be checked until now.
    if ( $input_file eq '-' ) {
        my $size_in_mb =
          length( ${$rinput_string} ) / ( CONST_1024 * CONST_1024 );
        my $maximum_file_size_mb = $rOpts->{'maximum-file-size-mb'};
        if ( $size_in_mb > $maximum_file_size_mb ) {
            $size_in_mb = sprintf( "%0.1f", $size_in_mb );
            Warn(
"skipping file: <stdin>: size $size_in_mb MB exceeds limit $maximum_file_size_mb; use -maxfs=i to change\n"
            );
            return;
        }
    }

    $rinput_string = $self->set_line_separator($rinput_string);

    my $encoding_in              = EMPTY_STRING;
    my $rOpts_character_encoding = $rOpts->{'character-encoding'};
    my $encoding_log_message;
    my $decoded_input_as = EMPTY_STRING;
    $rstatus->{'char_mode_source'} = 0;

    # Case 1: If Perl is already in a character-oriented mode for this
    # string rather than a byte-oriented mode.  Normally, this happens if
    # the caller has decoded a utf8 string before calling perltidy.  But it
    # could also happen if the user has done some unusual manipulations of
    # the source.  In any case, we will not attempt to decode it because
    # that could result in an output string in a different mode.
    if ( is_char_mode( ${$rinput_string} ) ) {
        $encoding_in = "utf8";
        $rstatus->{'char_mode_source'} = 1;
    }

    # Case 2. No input stream encoding requested.  This is appropriate
    # for single-byte encodings like ascii, latin-1, etc
    elsif ( !$rOpts_character_encoding
        || $rOpts_character_encoding eq 'none' )
    {

        # nothing to do
    }

    # Case 3. guess input stream encoding if requested
    elsif ( lc($rOpts_character_encoding) eq 'guess' ) {

        # The guessing strategy is simple: use Encode::Guess to guess
        # an encoding.  If and only if the guess is utf8, try decoding and
        # use it if successful.  Otherwise, we proceed assuming the
        # characters are encoded as single bytes (same as if 'none' had
        # been specified as the encoding).

        # In testing I have found that including additional guess 'suspect'
        # encodings sometimes works but can sometimes lead to disaster by
        # using an incorrect decoding.

        my $decoder;
        if ( ${$rinput_string} =~ /[^[:ascii:]]/ ) {
            $decoder = guess_encoding( ${$rinput_string}, 'utf8' );
        }
        if ( $decoder && ref($decoder) ) {
            $encoding_in = $decoder->name;
            if ( $encoding_in ne 'UTF-8' && $encoding_in ne 'utf8' ) {
                $encoding_in = EMPTY_STRING;
                $encoding_log_message .= <<EOM;
Guessed encoding '$encoding_in' is not utf8; no encoding will be used
EOM
            }
            else {

                my $buf;
                if ( !eval { $buf = $decoder->decode( ${$rinput_string} ); 1 } )
                {

                    $encoding_log_message .= <<EOM;
Guessed encoding '$encoding_in' but decoding was unsuccessful; no encoding is used
EOM

                    # Note that a guess failed, but keep going
                    # This warning can eventually be removed
                    Warn(
"file: $display_name: bad guess to decode source as $encoding_in\n"
                    );
                    $encoding_in = EMPTY_STRING;
                }
                else {
                    $encoding_log_message .= <<EOM;
Guessed encoding '$encoding_in' successfully decoded
EOM
                    $decoded_input_as = $encoding_in;
                    $rinput_string    = \$buf;
                }
            }
        }
        else {
            $encoding_log_message .= <<EOM;
Does not look like utf8 encoded text so processing as raw bytes
EOM
        }
    }

    # Case 4. Decode with a specific encoding
    else {
        $encoding_in = $rOpts_character_encoding;
        my $buf;
        if (
            !eval {
                $buf = Encode::decode( $encoding_in, ${$rinput_string},
                    Encode::FB_CROAK | Encode::LEAVE_SRC );
                1;
            }
          )
        {

            # Quit if we cannot decode by the requested encoding;
            # Something is not right.
            Warn(
"skipping file: $display_name: Unable to decode source as $encoding_in\n"
            );

            # return nothing on error
            return;
        }
        else {
            $encoding_log_message .= <<EOM;
Specified encoding '$encoding_in' successfully decoded
EOM
            $decoded_input_as = $encoding_in;
            $rinput_string    = \$buf;
        }
    }

    # Set the encoding to be used for all further i/o: If we have
    # decoded the data with any format, then we must continue to
    # read and write it as encoded data, and we will normalize these
    # operations with utf8.  If we have not decoded the data, then
    # we must not treat it as encoded data.
    my $is_encoded_data = $encoding_in ? 'utf8' : EMPTY_STRING;
    $self->[_is_encoded_data_] = $is_encoded_data;

    # Delete any Byte Order Mark (BOM), which can cause trouble
    if ($is_encoded_data) {
        ${$rinput_string} =~ s/^\x{FEFF}//;
    }

    $rstatus->{'input_name'}       = $display_name;
    $rstatus->{'opt_encoding'}     = $rOpts_character_encoding;
    $rstatus->{'char_mode_used'}   = $encoding_in ? 1 : 0;
    $rstatus->{'input_decoded_as'} = $decoded_input_as;

    # Define the function to determine the display width of character
    # strings
    my $length_function;
    if ($is_encoded_data) {

        # Try to load Unicode::GCString for defining text display width, if
        # requested, when the first encoded file is encountered
        if ( !defined($loaded_unicode_gcstring) ) {
            if ( eval { require Unicode::GCString; 1 } ) {
                $loaded_unicode_gcstring = 1;
            }
            else {
                $loaded_unicode_gcstring = 0;
                if ( $rOpts->{'use-unicode-gcstring'} ) {
                    Warn(<<EOM);
----------------------
Unable to load Unicode::GCString: $EVAL_ERROR
Processing continues but some vertical alignment may be poor
To prevent this warning message, you can either:
- install module Unicode::GCString, or
- remove '--use-unicode-gcstring' or '-gcs' from your perltidyrc or command line
----------------------
EOM
                }
            }
        }
        if ($loaded_unicode_gcstring) {
            $length_function = sub {
                return Unicode::GCString->new( $_[0] )->columns;
            };
            $encoding_log_message .= <<EOM;
Using 'Unicode::GCString' to measure horizontal character widths
EOM
            $rstatus->{'gcs_used'} = 1;
        }
    }
    return (
        $rinput_string,
        $is_encoded_data,
        $decoded_input_as,
        $encoding_log_message,
        $length_function,

    );
} ## end sub get_decoded_string_buffer

{ #<<<

my $LF;
my $CR;
my $CRLF;

BEGIN {
    $LF   = chr(10);
    $CR   = chr(13);
    $CRLF = $CR . $LF;
}

sub get_line_separator_default {

    my ($rOpts) = @_;

    # Get the line separator that will apply unless overridden by a
    # --preserve-line-endings flag for a specific file

    my $line_separator_default = "\n";

    my $ole = $rOpts->{'output-line-ending'};
    if ($ole) {
        my %endings = (
            dos  => $CRLF,
            win  => $CRLF,
            mac  => $CR,
            unix => $LF,
        );

        $line_separator_default = $endings{ lc $ole };

        if ( !$line_separator_default ) {
            my $str = join SPACE, keys %endings;
            Die(<<EOM);
Unrecognized line ending '$ole'; expecting one of: $str
EOM
        }

        # Check for conflict with -ple
        if ( $rOpts->{'preserve-line-endings'} ) {
            Warn("Ignoring -ple; conflicts with -ole\n");
            $rOpts->{'preserve-line-endings'} = undef;
        }
    }

    return $line_separator_default;

} ## end sub get_line_separator_default

sub set_line_separator {

    my ( $self, $rinput_string ) = @_;

    # Set the (output) line separator as requested or necessary

    my $rOpts = $self->[_rOpts_];

    # Start with the default (output) line separator
    my $line_separator = $self->[_line_separator_default_];

    # First try to find the line separator of the input stream
    my $input_line_separator;

    # Limit the search to a reasonable number of characters, in case we
    # have a weird file
    my $str = substr( ${$rinput_string}, 0, CONST_1024 );
    if ($str) {

        if ( $str =~ m/(($CR|$LF)+)/ ) {

            my $test = $1;

            # dos
            if ( $test =~ /^($CRLF)+\z/ ) {
                $input_line_separator = $CRLF;
            }

            # mac
            elsif ( $test =~ /^($CR)+\z/ ) {
                $input_line_separator = $CR;
            }

            # unix
            elsif ( $test =~ /^($LF)+\z/ ) {
                $input_line_separator = $LF;
            }

            # unknown
            else { }
        }

        # no ending seen
        else { }
    }

    if ( defined($input_line_separator) ) {

        # Remember the input line separator if needed
        if ( $rOpts->{'preserve-line-endings'} ) {
            $line_separator = $input_line_separator;
        }

        # Convert line endings to "\n" for processing if necessary.
        if ( $input_line_separator ne "\n" ) {
            my @lines = split /^/, ${$rinput_string};

            # try to convert CR to \n
            if ( $input_line_separator eq $CR ) {

                # if this file is currently a single line ..
                if ( @lines == 1 ) {

                    # and becomes multiple lines with the change ..
                    @lines = map { $_ . "\n" } split /$CR/, ${$rinput_string};
                    if ( @lines > 1 ) {

                        # then make the change
                        my $buf = join EMPTY_STRING, @lines;
                        $rinput_string = \$buf;
                    }
                }
            }

            # convert CR-LF to LF
            elsif ( ( $input_line_separator eq $CRLF ) && ( "\n" eq $LF ) ) {
                foreach my $line (@lines) { $line =~ s/$CRLF$/\n/ }
                my $buf = join EMPTY_STRING, @lines;
                $rinput_string = \$buf;
            }

            # unknown line ending scheme - leave it alone and let the tokenizer
            # deal with it
            else {
            }
        }
    }

    $self->[_line_separator_] = $line_separator;
    return $rinput_string;
} ## end sub set_line_separator
}

sub process_all_files {

    my ( $self, $rcall_hash ) = @_;

    # This routine is the main loop to process all files.
    # Total formatting is done with these layers of subroutines:
    #   perltidy                - main routine; checks run parameters
    #  *process_all_files       - main loop to process all files; *THIS LAYER
    #   process_filter_layer    - do any pre and post processing;
    #   process_iteration_layer - handle any iterations on formatting
    #   process_single_case     - solves one formatting problem

    my $rinput_hash               = $rcall_hash->{rinput_hash};
    my $rfiles                    = $rcall_hash->{rfiles};
    my $source_stream             = $rcall_hash->{source_stream};
    my $output_extension          = $rcall_hash->{output_extension};
    my $forbidden_file_extensions = $rcall_hash->{forbidden_file_extensions};
    my $in_place_modify           = $rcall_hash->{in_place_modify};
    my $backup_extension          = $rcall_hash->{backup_extension};
    my $delete_backup             = $rcall_hash->{delete_backup};
    my $logfile_header            = $rcall_hash->{logfile_header};
    my $rpending_complaint        = $rcall_hash->{rpending_complaint};
    my $rpending_logfile_message  = $rcall_hash->{rpending_logfile_message};

    my $rOpts              = $self->[_rOpts_];
    my $dot                = $self->[_file_extension_separator_];
    my $diagnostics_object = $self->[_diagnostics_object_];

    my $destination_stream = $rinput_hash->{'destination'};
    my $errorfile_stream   = $rinput_hash->{'errorfile'};
    my $logfile_stream     = $rinput_hash->{'logfile'};
    my $teefile_stream     = $rinput_hash->{'teefile'};
    my $debugfile_stream   = $rinput_hash->{'debugfile'};

    my $number_of_files = @{$rfiles};
    foreach my $input_file ( @{$rfiles} ) {
        my $fileroot;
        my @input_file_stat;
        my $display_name;

        #--------------------------
        # prepare this input stream
        #--------------------------
        if ($source_stream) {
            $fileroot     = "perltidy";
            $display_name = "<source_stream>";

            # If the source is from an array or string, then .LOG output
            # is only possible if a logfile stream is specified.  This prevents
            # unexpected perltidy.LOG files.  If the stream is not defined
            # then we will capture it in a string ref but it will not be
            # accessible. Previously by Perl::Tidy::DevNull (fix c255);
            if ( !defined($logfile_stream) ) {
                $logfile_stream = \my $tmp;

                # Likewise for .TEE and .DEBUG output
            }
            if ( !defined($teefile_stream) ) {
                $teefile_stream = \my $tmp;
            }
            if ( !defined($debugfile_stream) ) {
                $debugfile_stream = \my $tmp;
            }
        }
        elsif ( $input_file eq '-' ) {    # '-' indicates input from STDIN
            $fileroot     = "perltidy";   # root name to use for .ERR, .LOG, etc
            $display_name = "<stdin>";
            $in_place_modify = 0;
        }
        else {
            $fileroot     = $input_file;
            $display_name = $input_file;
            if ( !-e $input_file ) {
                Warn("skipping file: '$input_file': no matches found\n");
                next;
            }

            if ( !-f $input_file ) {
                Warn("skipping file: $input_file: not a regular file\n");
                next;
            }

            # As a safety precaution, skip zero length files.
            # If for example a source file got clobbered somehow,
            # the old .tdy or .bak files might still exist so we
            # shouldn't overwrite them with zero length files.
            if ( !-s $input_file ) {
                Warn("skipping file: $input_file: Zero size\n");
                next;
            }

            # And avoid formatting extremely large files. Since perltidy reads
            # files into memory, trying to process an extremely large file
            # could cause system problems.
            my $size_in_mb = ( -s $input_file ) / ( CONST_1024 * CONST_1024 );
            my $maximum_file_size_mb = $rOpts->{'maximum-file-size-mb'};
            if ( $size_in_mb > $maximum_file_size_mb ) {
                $size_in_mb = sprintf( "%0.1f", $size_in_mb );
                Warn(
"skipping file: $input_file: size $size_in_mb MB exceeds limit $maximum_file_size_mb; use -maxfs=i to change\n"
                );
                next;
            }

            if ( !-T $input_file && !$rOpts->{'force-read-binary'} ) {
                Warn("skipping file: $input_file: Non-text (override with -f)\n"
                );
                next;
            }

            # Input file must be writable for -b -bm='copy'.  We must catch
            # this early to prevent encountering trouble after unlinking the
            # previous backup.
            if ( $in_place_modify && !-w $input_file ) {
                my $backup_method = $rOpts->{'backup-method'};
                if ( defined($backup_method) && $backup_method eq 'copy' ) {
                    Warn(
"skipping file '$input_file' for -b option: file reported as non-writable\n"
                    );
                    next;
                }
            }

            # we should have a valid filename now
            $fileroot        = $input_file;
            @input_file_stat = stat($input_file);

            if ( $OSNAME eq 'VMS' ) {
                ( $fileroot, $dot ) = check_vms_filename($fileroot);
                $self->[_file_extension_separator_] = $dot;
            }

            # add option to change path here
            if ( defined( $rOpts->{'output-path'} ) ) {

                my ( $base, $old_path_uu ) = fileparse($fileroot);
                my $new_path = $rOpts->{'output-path'};
                if ( !-d $new_path ) {
                    mkdir($new_path)    # Default MODE is 0777
                      or
                      Die("unable to create directory $new_path: $OS_ERROR\n");
                }
                my $path = $new_path;
                $fileroot = File::Spec->catfile( $path, $base );
                if ( !$fileroot ) {
                    Die(<<EOM);
------------------------------------------------------------------------
Problem combining $new_path and $base to make a filename; check -opath
------------------------------------------------------------------------
EOM
                }
            }
        }

        # Skip files with same extension as the output files because
        # this can lead to a messy situation with files like
        # script.tdy.tdy.tdy ... or worse problems ...  when you
        # rerun perltidy over and over with wildcard input.
        if (
            !$source_stream
            && (   $input_file =~ /$forbidden_file_extensions/
                || $input_file eq 'DIAGNOSTICS' )
          )
        {
            Warn("skipping file: $input_file: wrong extension\n");
            next;
        }

        # copy source to a string buffer, decoding from utf8 if necessary
        my (
            $rinput_string,
            $is_encoded_data,
            $decoded_input_as,
            $encoding_log_message,
            $length_function,

        ) = $self->get_decoded_string_buffer( $input_file, $display_name );

        # Skip this file on any error
        next if ( !defined($rinput_string) );

        # Register this file name with the Diagnostics package, if any.
        $diagnostics_object->set_input_file($input_file)
          if $diagnostics_object;

        # The (possibly decoded) input is now in string ref $rinput_string.
        # Now prepare the output stream and error logger.

        #--------------------------
        # prepare the output stream
        #--------------------------
        my $output_file;
        my $output_name = EMPTY_STRING;
        my $actual_output_extension;

        if ( $rOpts->{'outfile'} ) {

            if ( $number_of_files <= 1 ) {

                if ( $rOpts->{'standard-output'} ) {
                    my $saw_pbp = $self->[_saw_pbp_];
                    my $msg     = "You may not use -o and -st together";
                    $msg .= " (-pbp contains -st; see manual)" if ($saw_pbp);
                    Die("$msg\n");
                }

                if ($destination_stream) {
                    Die(
"You may not specify a destination array and -o together\n"
                    );
                }

                if ( defined( $rOpts->{'output-path'} ) ) {
                    Die("You may not specify -o and -opath together\n");
                }

                if ( defined( $rOpts->{'output-file-extension'} ) ) {
                    Die("You may not specify -o and -oext together\n");
                }

                $output_file = $rOpts->{outfile};
                $output_name = $output_file;

                # make sure user gives a file name after -o
                if ( $output_file =~ /^-/ ) {
                    Die("You must specify a valid filename after -o\n");
                }

                # do not overwrite input file with -o
                if ( @input_file_stat && ( $output_file eq $input_file ) ) {
                    Die("Use 'perltidy -b $input_file' to modify in-place\n");
                }
            }
            else {
                Die("You may not use -o with more than one input file\n");
            }
        }
        elsif ( $rOpts->{'standard-output'} ) {
            if ($destination_stream) {
                my $saw_pbp = $self->[_saw_pbp_];
                my $msg =
                  "You may not specify a destination array and -st together\n";
                $msg .= " (-pbp contains -st; see manual)" if ($saw_pbp);
                Die("$msg\n");
            }
            $output_file = '-';
            $output_name = "<stdout>";

            if ( $number_of_files <= 1 ) {
            }
            else {
                Die("You may not use -st with more than one input file\n");
            }
        }
        elsif ($destination_stream) {

            $output_file = $destination_stream;
            $output_name = "<destination_stream>";
        }
        elsif ($source_stream) {    # source but no destination goes to stdout
            $output_file = '-';
            $output_name = "<stdout>";
        }
        elsif ( $input_file eq '-' ) {
            $output_file = '-';
            $output_name = "<stdout>";
        }
        else {
            if ($in_place_modify) {
                $output_name = $display_name;
            }
            else {
                $actual_output_extension = $output_extension;
                $output_file             = $fileroot . $output_extension;
                $output_name             = $output_file;
            }
        }

        # prepare standard output in case of a dump to stdout
        if ( $is_encoded_data && $self->[_dump_to_stdout_] ) {
            binmode *STDOUT, ':encoding(UTF-8)';
        }

        $rstatus->{'file_count'} += 1;
        $rstatus->{'output_name'}     = $output_name;
        $rstatus->{'iteration_count'} = 0;
        $rstatus->{'converged'}       = 0;

        #------------------------------------------
        # initialize the error logger for this file
        #------------------------------------------
        my $warning_file = $fileroot . $dot . "ERR";
        if ($errorfile_stream) { $warning_file = $errorfile_stream }
        my $log_file = $fileroot . $dot . "LOG";
        if ($logfile_stream) { $log_file = $logfile_stream }

        # The logger object handles warning messages, logfile messages,
        # and can supply basic run information to lower level routines.
        my $logger_object = Perl::Tidy::Logger->new(
            rOpts           => $rOpts,
            log_file        => $log_file,
            warning_file    => $warning_file,
            fh_stderr       => $fh_stderr,
            display_name    => $display_name,
            is_encoded_data => $is_encoded_data,
        );
        $logger_object->write_logfile_entry($logfile_header);
        $logger_object->write_logfile_entry($encoding_log_message)
          if $encoding_log_message;

        # Now we can add any pending messages to the log
        if ( ${$rpending_logfile_message} ) {
            $logger_object->write_logfile_entry( ${$rpending_logfile_message} );
        }
        if ( ${$rpending_complaint} ) {
            $logger_object->complain( ${$rpending_complaint} );
        }

        # additional parameters needed by lower level routines
        $self->[_actual_output_extension_] = $actual_output_extension;
        $self->[_debugfile_stream_]        = $debugfile_stream;
        $self->[_decoded_input_as_]        = $decoded_input_as;
        $self->[_destination_stream_]      = $destination_stream;
        $self->[_display_name_]            = $display_name;
        $self->[_fileroot_]                = $fileroot;
        $self->[_is_encoded_data_]         = $is_encoded_data;
        $self->[_length_function_]         = $length_function;
        $self->[_logger_object_]           = $logger_object;
        $self->[_output_file_]             = $output_file;
        $self->[_teefile_stream_]          = $teefile_stream;
        $self->[_input_copied_verbatim_]   = 0;
        $self->[_input_output_difference_] = 1;    ## updated later if -b used

        #--------------------
        # process this buffer
        #--------------------
        my $routput_string = $self->process_filter_layer($rinput_string);

        #------------------------------------------------
        # send the tidied output to its final destination
        #------------------------------------------------
        if ( $rOpts->{'format'} eq 'tidy' && defined($routput_string) ) {

            $self->write_tidy_output(
                {
                    routput_string   => $routput_string,
                    rinput_file_stat => \@input_file_stat,
                    in_place_modify  => $in_place_modify,
                    input_file       => $input_file,
                    backup_extension => $backup_extension,
                    delete_backup    => $delete_backup,
                }
            );
        }

        $logger_object->finish()
          if $logger_object;
    } ## end loop over files

    return;
} ## end sub process_all_files

sub write_tidy_output {

    my ( $self, $rcall_hash ) = @_;

    # Write tidied output in '$routput_string' to its final destination

    my $routput_string   = $rcall_hash->{routput_string};
    my $rinput_file_stat = $rcall_hash->{rinput_file_stat};
    my $in_place_modify  = $rcall_hash->{in_place_modify};
    my $input_file       = $rcall_hash->{input_file};
    my $backup_extension = $rcall_hash->{backup_extension};
    my $delete_backup    = $rcall_hash->{delete_backup};

    my $rOpts           = $self->[_rOpts_];
    my $is_encoded_data = $self->[_is_encoded_data_];
    my $output_file     = $self->[_output_file_];

    # There are three main output paths:

    #-------------------------------------------------------------------------
    # PATH 1: $output_file is not defined: --backup and modify in-place option
    #-------------------------------------------------------------------------
    if ($in_place_modify) {

        # For -b option, leave the file unchanged if a severe error caused
        # formatting to be skipped. Otherwise we will overwrite any backup.
        if ( !$self->[_input_copied_verbatim_] ) {

            my $backup_method = $rOpts->{'backup-method'};

            #-------------------------------------------------------------
            # PATH 1a: -bm='copy': uses newer version in which original is
            # copied to the backup and rewritten; see git #103.
            #-------------------------------------------------------------
            if ( defined($backup_method) && $backup_method eq 'copy' ) {
                $self->backup_method_copy(
                    $input_file,       $routput_string,
                    $backup_extension, $delete_backup
                );
            }

            #-------------------------------------------------------------
            # PATH 1b: -bm='move': uses older version, where original is
            # moved to the backup and formatted output goes to a new file.
            #-------------------------------------------------------------
            else {
                $self->backup_method_move(
                    $input_file,       $routput_string,
                    $backup_extension, $delete_backup
                );
            }
        }
    }

    #--------------------------------------------------------------------------
    # PATH 2: $output_file is a reference (=destination_stream): send output to
    # a destination stream ref received from an external perl program. We use
    # a sub to do this because the encoding rules are a bit tricky.
    #--------------------------------------------------------------------------
    elsif ( ref($output_file) ) {
        $self->copy_buffer_to_external_ref( $routput_string, $output_file );
    }

    #--------------------------------------------------------------------------
    # PATH 3: $output_file is named file or '-'; send output to the file system
    #--------------------------------------------------------------------------
    else {

        #--------------------------
        # PATH 3a: output to STDOUT
        #--------------------------
        if ( $output_file eq '-' ) {
            my $fh = *STDOUT;
            if ($is_encoded_data) { binmode $fh, ":raw:encoding(UTF-8)" }
            else                  { binmode $fh }
            $fh->print( ${$routput_string} );
        }

        #--------------------------------
        # PATH 3b: output to a named file
        #--------------------------------
        else {
            if ( open( my $fh, '>', $output_file ) ) {
                if ($is_encoded_data) { binmode $fh, ":raw:encoding(UTF-8)" }
                else                  { binmode $fh }
                $fh->print( ${$routput_string} );
                $fh->close() or Die("Cannot close '$output_file': $OS_ERROR\n");
            }
            else {
                Die("Cannot open $output_file to write: $OS_ERROR\n");
            }

            # set output file ownership and permissions if appropriate
            if ( $output_file && -f $output_file && !-l $output_file ) {
                if ( @{$rinput_file_stat} ) {
                    $self->set_output_file_permissions( $output_file,
                        \@{$rinput_file_stat}, $in_place_modify );
                }
            }
        }

        # Save diagnostic info
        if ($is_encoded_data) {
            $rstatus->{'output_encoded_as'} = 'UTF-8';
        }
    }

    return;

} ## end sub write_tidy_output

sub process_filter_layer {

    my ( $self, $rinput_string ) = @_;

    # This is the filter layer of processing.
    # Do all requested formatting on the string ref '$rinput_string', including
    # any pre- and post-processing with filters.
    # Returns:
    #   $routput_string = ref to tidied output if in 'tidy' mode
    #   (nothing) if not in 'tidy' mode [these modes handle output separately]

    # Total formatting is done with these layers of subroutines:
    #   perltidy                - main routine; checks run parameters
    #   process_all_files       - main loop to process all files;
    #  *process_filter_layer    - do any pre and post processing; *THIS LAYER
    #   process_iteration_layer - handle any iterations on formatting
    #   process_single_case     - solves one formatting problem

    # Data Flow in this layer:
    #  $rinput_string
    #   -> optional prefilter operations
    #     -> [ formatting by sub process_iteration_layer ]
    #       -> return if not in 'tidy' mode
    #         -> optional postfilter operations
    #           -> $routput_string

    # What is done based on format type:
    #  utf8 decoding is done for all format types
    #  prefiltering is applied to all format types
    #   - because it may be needed to get through the tokenizer
    #  postfiltering is only done for format='tidy'
    #   - not appropriate for html text, which has already been output
    #  encoding of decoded output is only done for format='tidy'
    #   - because html does its own encoding; user formatter does what it wants

    # Be sure the string we received is defined
    if ( !defined($rinput_string) ) {
        Fault("bad call: the source string ref \$rinput_string is undefined\n");
    }
    if ( ref($rinput_string) ne 'SCALAR' ) {
        Fault("bad call: the source string ref is not SCALAR\n");
    }

    my $rOpts         = $self->[_rOpts_];
    my $logger_object = $self->[_logger_object_];

    # vars for --line-range-tidy filter, if needed
    my @input_lines_pre;
    my @input_lines_post;

    # vars for checking assertions, if needed
    my $digest_input;
    my $saved_input_buf;

    # var for checking --noadd-terminal-newline
    my $chomp_terminal_newline;

    # Setup post-filter vars; these apply to 'tidy' mode only
    if ( $rOpts->{'format'} eq 'tidy' ) {

        #---------------------------------------------------------------------
        # for --line-range-tidy, clip '$rinput_string' to a limited line range
        #---------------------------------------------------------------------
        my $line_tidy_begin = $self->[_line_tidy_begin_];
        if ($line_tidy_begin) {

            my @input_lines = split /^/, ${$rinput_string};

            my $num = @input_lines;
            if ( $line_tidy_begin > $num ) {
                Die(<<EOM);
#--line-range-tidy=n1:n2 has n1=$line_tidy_begin which exceeds max line number of $num
EOM
            }
            else {
                my $line_tidy_end = $self->[_line_tidy_end_];
                if ( !defined($line_tidy_end) || $line_tidy_end > $num ) {
                    $line_tidy_end = $num;
                }
                my $input_string = join EMPTY_STRING,
                  @input_lines[ $line_tidy_begin - 1 .. $line_tidy_end - 1 ];
                $rinput_string = \$input_string;

                @input_lines_pre  = @input_lines[ 0 .. $line_tidy_begin - 2 ];
                @input_lines_post = @input_lines[ $line_tidy_end .. $num - 1 ];
            }
        }

        #------------------------------------------
        # evaluate MD5 sum of input file, if needed
        #------------------------------------------
        if (   $rOpts->{'assert-tidy'}
            || $rOpts->{'assert-untidy'}
            || $rOpts->{'backup-and-modify-in-place'} )
        {
            $digest_input    = $md5_hex->( ${$rinput_string} );
            $saved_input_buf = ${$rinput_string};
        }

        # When -noadd-terminal-newline is set, and the input does not
        # have a newline, then we remove the final newline of the output
        $chomp_terminal_newline = !$rOpts->{'add-terminal-newline'}
          && substr( ${$rinput_string}, -1, 1 ) !~ /\n/;

    }

    #-----------------------------------------------------------------------
    # Apply any prefilter. The prefilter is a code reference that will be
    # applied to the source before tokenizing.  Note that we are doing this
    # for all format types ('tidy', 'html', 'user') because it may be needed
    # to avoid tokenization errors.
    #-----------------------------------------------------------------------
    my $prefilter = $self->[_prefilter_];
    if ($prefilter) {
        my $input_string = $prefilter->( ${$rinput_string} );
        $rinput_string = \$input_string;
    }

    #-------------------------------------------
    # Format contents of string '$rinput_string'
    #-------------------------------------------
    my $routput_string = $self->process_iteration_layer($rinput_string);

    #-------------------------------
    # All done if not in 'tidy' mode
    #-------------------------------
    if ( $rOpts->{'format'} ne 'tidy' ) {
        return;
    }

    #---------------------
    # apply any postfilter
    #---------------------
    my $postfilter = $self->[_postfilter_];
    if ($postfilter) {
        my $output_string = $postfilter->( ${$routput_string} );
        $routput_string = \$output_string;
    }

    if ( defined($digest_input) ) {
        my $digest_output = $md5_hex->( ${$routput_string} );
        $self->[_input_output_difference_] = $digest_output ne $digest_input;
    }

    #-----------------------------------------------------
    # check for changes if requested by 'assert-...' flags
    #-----------------------------------------------------
    if ( $rOpts->{'assert-tidy'} ) {
        if ( $self->[_input_output_difference_] ) {
            my $diff_msg =
              compare_string_buffers( \$saved_input_buf, $routput_string );
            $logger_object->warning(<<EOM);
assertion failure: '--assert-tidy' is set but output differs from input
EOM
            $logger_object->interrupt_logfile();
            $logger_object->warning( $diff_msg . "\n" );
            $logger_object->resume_logfile();
        }
    }

    if ( $rOpts->{'assert-untidy'} ) {
        if ( !$self->[_input_output_difference_] ) {
            $logger_object->warning(
"assertion failure: '--assert-untidy' is set but output equals input\n"
            );
        }
    }

    #----------------------------------------
    # do --line-range-tidy line recombination
    #----------------------------------------
    if ( @input_lines_pre || @input_lines_post ) {
        my $str_pre       = join EMPTY_STRING, @input_lines_pre;
        my $str_post      = join EMPTY_STRING, @input_lines_post;
        my $output_string = $str_pre . ${$routput_string} . $str_post;
        $routput_string = \$output_string;
    }

    #-----------------------------------------
    # handle a '--noadd-terminal-newline' flag
    #-----------------------------------------
    if ($chomp_terminal_newline) {
        chomp ${$routput_string};
    }

    #-------------------------------------------------------------
    # handle --preserve-line-endings or -output-line-endings flags
    #-------------------------------------------------------------
    # The native line separator has been used in all intermediate
    # iterations and filter operations until here so that string
    # operations work ok.
    if ( $self->[_line_separator_] ne "\n" ) {
        my $line_separator = $self->[_line_separator_];
        my @output_lines   = split /^/, ${$routput_string};
        foreach my $line (@output_lines) {

            # must check chomp because last line might not have a newline
            # if --noadd-terminal-newline is also set (c283)
            if ( chomp $line ) {
                $line .= $line_separator;
            }
        }
        my $output_string = join EMPTY_STRING, @output_lines;
        $routput_string = \$output_string;
    }

    return $routput_string;
} ## end sub process_filter_layer

# For safety, set an upper bound on number of iterations before stopping.
# The average number of iterations is 2. No known cases exceed 4.
use constant ITERATION_LIMIT => 6;

sub process_iteration_layer {

    my ( $self, $rinput_string ) = @_;

    # This is the iteration layer of processing.
    # Do all formatting, iterating if requested, on the source $rinput_string
    # Output depends on format type:
    #   For 'tidy' formatting, output goes to sink object
    #   For 'html' formatting, output goes to the ultimate destination
    #   For 'user' formatting, user formatter handles output

    # Total formatting is done with these layers of subroutines:
    #   perltidy                - main routine; checks run parameters
    #   process_all_files       - main loop to process all files;
    #   process_filter_layer    - do any pre and post processing
    #  *process_iteration_layer - do any iterations on formatting; *THIS LAYER
    #   process_single_case     - solves one formatting problem

    # Data Flow in this layer:
    #      $rinput_string -> [ loop over iterations ] -> $routput_string

    my $diagnostics_object = $self->[_diagnostics_object_];
    my $display_name       = $self->[_display_name_];
    my $fileroot           = $self->[_fileroot_];
    my $is_encoded_data    = $self->[_is_encoded_data_];
    my $length_function    = $self->[_length_function_];
    my $logger_object      = $self->[_logger_object_];
    my $rOpts              = $self->[_rOpts_];
    my $user_formatter     = $self->[_user_formatter_];

    # make a debugger object if requested
    my $debugger_object;
    if ( $rOpts->{DEBUG} ) {
        my $debug_file = $self->[_debugfile_stream_]
          || $fileroot . $self->make_file_extension('DEBUG');
        $debugger_object =
          Perl::Tidy::Debugger->new( $debug_file, $is_encoded_data );
    }

    # make a tee file handle if requested
    my $fh_tee;
    my $tee_file;
    if (   $rOpts->{'tee-pod'}
        || $rOpts->{'tee-block-comments'}
        || $rOpts->{'tee-side-comments'} )
    {
        $tee_file = $self->[_teefile_stream_]
          || $fileroot . $self->make_file_extension('TEE');
        $fh_tee = Perl::Tidy::streamhandle( $tee_file, 'w', $is_encoded_data );
        if ( !$fh_tee ) {
            Warn("couldn't open TEE file $tee_file: $OS_ERROR\n");
        }
    }

    # vars for iterations and convergence test
    my $max_iterations = 1;
    my $convergence_log_message;
    my %saw_md5;

    # Only 'tidy' formatting can use multiple iterations
    if ( $rOpts->{'format'} eq 'tidy' ) {

        # check iteration count and quietly fix if necessary:
        # - iterations option only applies to code beautification mode
        # - the convergence check should stop most runs on iteration 2, and
        #   virtually all on iteration 3.  We allow up to ITERATION_LIMIT.
        $max_iterations = $rOpts->{'iterations'};
        if ( !defined($max_iterations)
            || $max_iterations <= 0 )
        {
            $max_iterations = 1;
        }

        if ( $max_iterations > ITERATION_LIMIT ) {
            $max_iterations = ITERATION_LIMIT;
        }

        # get starting MD5 sum for convergence test
        if ( $max_iterations > 1 ) {
            my $digest = $md5_hex->( ${$rinput_string} );
            $saw_md5{$digest} = 0;
        }
    }

    # save objects to allow redirecting output during iterations
    my $logger_object_final = $logger_object;
    my $iteration_of_formatter_convergence;
    my $routput_string;

    #---------------------
    # Loop over iterations
    #---------------------
    foreach my $iter ( 1 .. $max_iterations ) {

        $rstatus->{'iteration_count'} += 1;

        # create a string to capture the output
        my $sink_buffer = EMPTY_STRING;
        $routput_string = \$sink_buffer;

        # Save logger, debugger and tee output only on pass 1 because:
        # (1) line number references must be to the starting
        # source, not an intermediate result, and
        # (2) we need to know if there are errors so we can stop the
        # iterations early if necessary.
        # (3) the tee option only works on first pass if comments are also
        # being deleted.
        if ( $iter > 1 ) {

            $debugger_object->close_debug_file()
              if ($debugger_object);

            if (   $fh_tee
                && $fh_tee->can('close')
                && !ref($tee_file)
                && $tee_file ne '-' )
            {
                $fh_tee->close()
                  or Warn("couldn't close TEE file $tee_file: $OS_ERROR\n");
            }

            $debugger_object = undef;
            $logger_object   = undef;
            $fh_tee          = undef;
        }

        #---------------------------------
        # create a formatter for this file
        #---------------------------------

        my $formatter;

        if ($user_formatter) {
            $formatter = $user_formatter;
        }
        elsif ( $rOpts->{'format'} eq 'html' ) {

            my $html_toc_extension =
              $self->make_file_extension( $rOpts->{'html-toc-extension'},
                'toc' );

            my $html_src_extension =
              $self->make_file_extension( $rOpts->{'html-src-extension'},
                'src' );

            $formatter = Perl::Tidy::HtmlWriter->new(
                input_file         => $fileroot,
                html_file          => $self->[_output_file_],
                extension          => $self->[_actual_output_extension_],
                html_toc_extension => $html_toc_extension,
                html_src_extension => $html_src_extension,
            );
        }
        elsif ( $rOpts->{'format'} eq 'tidy' ) {
            $formatter = Perl::Tidy::Formatter->new(
                logger_object      => $logger_object,
                diagnostics_object => $diagnostics_object,
                sink_object        => $routput_string,
                length_function    => $length_function,
                is_encoded_data    => $is_encoded_data,
                fh_tee             => $fh_tee,
            );
        }
        else {
            Die("I don't know how to do -format=$rOpts->{'format'}\n");
        }

        if ( !$formatter ) {
            Die("Unable to continue with $rOpts->{'format'} formatting\n");
        }

        #-----------------------------------
        # create the tokenizer for this file
        #-----------------------------------
        my $tokenizer = Perl::Tidy::Tokenizer->new(
            source_object      => $rinput_string,
            logger_object      => $logger_object,
            debugger_object    => $debugger_object,
            diagnostics_object => $diagnostics_object,
            rOpts              => $rOpts,
            starting_level     => $rOpts->{'starting-indentation-level'},
        );

        #---------------------------------
        # do processing for this iteration
        #---------------------------------
        $self->process_single_case( $tokenizer, $formatter );

        #--------------
        # report errors
        #--------------

        # see if the formatter is converged
        if (   $max_iterations > 1
            && !defined($iteration_of_formatter_convergence)
            && $formatter->can('get_convergence_check') )
        {
            if ( $formatter->get_convergence_check() ) {
                $iteration_of_formatter_convergence = $iter;
                $rstatus->{'converged'} = 1;
            }
        }

        # line source for next iteration (if any) comes from the current
        # temporary output buffer
        if ( $iter < $max_iterations ) {

            $rinput_string = \$sink_buffer;

            # stop iterations if errors or converged
            my $stop_now = $self->[_input_copied_verbatim_];
            $stop_now ||= $tokenizer->get_unexpected_error_count();
            my $stopping_on_error = $stop_now;
            if ($stop_now) {
                $convergence_log_message = <<EOM;
Stopping iterations because of severe errors.
EOM
            }

            # or do convergence test
            else {

                # stop if the formatter has converged
                $stop_now ||= defined($iteration_of_formatter_convergence);

                my $digest = $md5_hex->($sink_buffer);
                if ( !defined( $saw_md5{$digest} ) ) {
                    $saw_md5{$digest} = $iter;
                }

                # do a second iteration if all ok and requested by formatter
                # to allow delayed adding/deleting of commas (git156, git143)
                elsif ( $iter == 1
                    && !$stop_now
                    && $formatter->can('want_second_iteration')
                    && $formatter->want_second_iteration() )
                {
                    ## deja vu, but do not set $stop_now
                    $saw_md5{$digest} = $iter;
                }
                else {

                    # Deja vu, stop iterating

                    $stop_now = 1;
                    my $iterm = $iter - 1;
                    if ( $saw_md5{$digest} != $iterm ) {

                        # Blinking (oscillating) between two or more stable
                        # end states.  This is unlikely to occur with normal
                        # parameters, but it can occur in stress testing
                        # with extreme parameter values, such as very short
                        # maximum line lengths.  We want to catch and fix
                        # them when they happen.
                        $rstatus->{'blinking'} = 1;
                        $convergence_log_message = <<EOM;
BLINKER. Output for iteration $iter same as for $saw_md5{$digest}.
EOM
                        $stopping_on_error ||= $convergence_log_message;
                        DEVEL_MODE
                          && print {*STDERR} $convergence_log_message;
                        $diagnostics_object->write_diagnostics(
                            $convergence_log_message)
                          if $diagnostics_object;

# Uncomment to search for blinking states
# Warn( "$display_name: blinking; iter $iter same as for $saw_md5{$digest}\n" );

                    }
                    else {
                        $convergence_log_message = <<EOM;
Converged.  Output for iteration $iter same as for iter $iterm.
EOM
                        $diagnostics_object->write_diagnostics(
                            $convergence_log_message)
                          if $diagnostics_object && $iterm > 2;
                        $rstatus->{'converged'} = 1;
                    }
                }
            }

            if ($stop_now) {

                if (DEVEL_MODE) {

                    if ( defined($iteration_of_formatter_convergence) ) {

                        # This message cannot appear unless the formatter
                        # convergence test above is temporarily skipped for
                        # testing.
                        if ( $iteration_of_formatter_convergence < $iter - 1 ) {
                            print {*STDERR}
"STRANGE Early conv in $display_name: Stopping on it=$iter, converged in formatter on $iteration_of_formatter_convergence\n";
                        }
                    }
                    elsif ( !$stopping_on_error ) {

                        # The md5 sum implies convergence but the convergence
                        # was not detected by the Formatter.  This is not
                        # critical but should be investigated.  It happened
                        # once when a line break was placed before a phantom
                        # comma under -qwaf, and has been fixed.
                        print {*STDERR}
"STRANGE no conv in $display_name: stopping on it=$iter, but not converged in formatter\n";
                    }
                    else {
                        ## looks ok
                    }
                }

                # we are stopping the iterations early;
                last;
            }
        } ## end if ( $iter < $max_iterations)
    } ## end loop over iterations for one source file

    $debugger_object->close_debug_file()
      if $debugger_object;

    if (   $fh_tee
        && $fh_tee->can('close')
        && !ref($tee_file)
        && $tee_file ne '-' )
    {
        $fh_tee->close()
          or Warn("couldn't close TEE file $tee_file: $OS_ERROR\n");
    }

    # leave logger object open for additional messages
    $logger_object = $logger_object_final;
    $logger_object->write_logfile_entry($convergence_log_message)
      if $convergence_log_message;

    return $routput_string;

} ## end sub process_iteration_layer

sub process_single_case {

    my ( $self, $tokenizer, $formatter ) = @_;

    # Run the formatter on a single defined case

    # Total formatting is done with these layers of subroutines:
    #   perltidy                - main routine; checks run parameters
    #   process_all_files       - main loop to process all files;
    #   process_filter_layer    - do any pre and post processing;
    #   process_iteration_layer - do any iterations on formatting
    #  *process_single_case     - solve one formatting problem; *THIS LAYER

    while ( my $line = $tokenizer->get_line() ) {
        $formatter->write_line($line);
    }

    # user-defined formatters are possible, and may not have a
    # sub 'finish_formatting', so we have to check
    if ( $formatter->can('finish_formatting') ) {
        my $severe_error = $tokenizer->report_tokenization_errors();
        my $verbatim     = $formatter->finish_formatting($severe_error);
        $self->[_input_copied_verbatim_] = $verbatim;
    }

    return;
} ## end sub process_single_case

sub copy_buffer_to_external_ref {

    my ( $self, $routput, $destination_stream ) = @_;

    # Copy $routput to the final $destination_stream,
    # encoding if the flag $encode_destination_buffer is true.

    # Data Flow:
    #    $destination_buffer -> [ encode? ] -> $destination_stream

    my $destination_buffer = EMPTY_STRING;
    if ( ref($routput) eq 'ARRAY' ) {
        $destination_buffer = join EMPTY_STRING, @{$routput};
    }
    elsif ( ref($routput) eq 'SCALAR' ) {
        $destination_buffer = ${$routput};
    }
    else {
        Fatal(
            "'copy_buffer_to_external_ref' expecting ref to ARRAY or SCALAR\n");
    }

    $rstatus->{'output_encoded_as'} = EMPTY_STRING;
    my $ref_destination_stream = ref($destination_stream);

    # Encode output? Strings and arrays use special encoding rules; see:
    #   https://github.com/perltidy/perltidy/blob/master/docs/eos_flag.md
    my $encode_destination_buffer;
    if (   $ref_destination_stream eq 'SCALAR'
        || $ref_destination_stream eq 'ARRAY' )
    {
        my $rOpts = $self->[_rOpts_];
        $encode_destination_buffer =
          $rOpts->{'encode-output-strings'} && $self->[_decoded_input_as_];
    }

    # An object with a print method will use file encoding rules
    elsif ( $ref_destination_stream->can('print') ) {
        $encode_destination_buffer = $self->[_is_encoded_data_];
    }
    else {
        confess <<EOM;
------------------------------------------------------------------------
No 'print' method is defined for object of class '$ref_destination_stream'
Please check your call to Perl::Tidy::perltidy. Trace follows.
------------------------------------------------------------------------
EOM
    }

    if ($encode_destination_buffer) {
        my $encoded_buffer;
        if (
            !eval {
                $encoded_buffer =
                  Encode::encode( "UTF-8", $destination_buffer,
                    Encode::FB_CROAK | Encode::LEAVE_SRC );
                1;
            }
          )
        {

            Warn(
"Error attempting to encode output string ref; encoding not done\n"
            );
        }
        else {
            $destination_buffer = $encoded_buffer;
            $rstatus->{'output_encoded_as'} = 'UTF-8';
        }
    }

    # Send data for SCALAR, ARRAY & OBJ refs to its final destination
    if ( $ref_destination_stream eq 'SCALAR' ) {
        ${$destination_stream} = $destination_buffer;
    }
    elsif ( defined($destination_buffer) ) {
        my @lines = split /^/, $destination_buffer;
        if ( $ref_destination_stream eq 'ARRAY' ) {
            @{$destination_stream} = @lines;
        }

        # destination stream must be an object with print method
        else {
            foreach my $line (@lines) {
                $destination_stream->print($line);
            }
            if ( $ref_destination_stream->can('close') ) {
                $destination_stream->close();
            }
        }
    }
    else {

        # Empty destination buffer not going to a string ... could
        # happen for example if user deleted all pod or comments
    }
    return;
} ## end sub copy_buffer_to_external_ref

} ## end of closure for sub perltidy

sub line_diff {

    my ( $s1, $s2 ) = @_;

    # Given two strings, Return
    #  $diff_marker = a string with caret (^) symbols indicating differences
    #  $pos1 = character position of first difference; pos1=-1 if no difference

    # Form exclusive or of the strings, which has null characters where strings
    # have same common characters so non-null characters indicate character
    # differences.
    my $diff_marker = EMPTY_STRING;
    my $pos         = -1;
    my $pos1        = -1;
    if ( defined($s1) && defined($s2) ) {
        my $mask = $s1 ^ $s2;

        while ( $mask =~ /[^\0]/g ) {
            my $pos_last = $pos;
            $pos = $LAST_MATCH_START[0];
            if ( $pos1 < 0 ) { $pos1 = $pos; }
            $diff_marker .= SPACE x ( $pos - $pos_last - 1 ) . '^';

            # we could continue to mark all differences, but there is no point
            last;
        } ## end while ( $mask =~ /[^\0]/g)
    }
    return ( $diff_marker, $pos1 );
} ## end sub line_diff

sub compare_string_buffers {

    my ( $string_i, $string_o, ($max_diff_count) ) = @_;

    # Compare input and output string buffers and return a brief text
    # description of the first difference.

    # Given:
    #   $string_i = input string, or ref to input string
    #   $string_o = output string, or ref to output string
    #   $max_diff_count = optional maximum number of differences to show,
    #       default=1
    # Return:
    #   a string showing differences

    my $rbufi = ref($string_i) ? $string_i : \$string_i;
    my $rbufo = ref($string_o) ? $string_o : \$string_o;

    if ( !defined($max_diff_count) ) { $max_diff_count = 1 }

    my ( @aryi, @aryo );
    my ( $leni, $leno ) = ( 0, 0 );
    if ( defined($rbufi) ) {
        $leni = length( ${$rbufi} );
        @aryi = split /^/, ${$rbufi};
    }
    if ( defined($rbufo) ) {
        $leno = length( ${$rbufo} );
        @aryo = split /^/, ${$rbufo};
    }
    my $nlines_i = @aryi;
    my $nlines_o = @aryo;
    my $msg      = <<EOM;
Input   file length has $leni chars in $nlines_i lines
Output  file length has $leno chars in $nlines_o lines
EOM
    return $msg unless ( $leni && $leno );

    my $truncate = sub {
        my ( $str, $lenmax ) = @_;
        if ( length($str) > $lenmax ) {
            $str = substr( $str, 0, $lenmax ) . "...";
        }
        return $str;
    }; ## end $truncate = sub

    my $last_nonblank_line  = EMPTY_STRING;
    my $last_nonblank_count = 0;

    # loop over lines until we find a difference
    my $count      = 0;
    my $diff_count = 0;
    while ( @aryi && @aryo ) {
        $count++;
        my $linei = shift @aryi;
        my $lineo = shift @aryo;
        chomp $linei;
        chomp $lineo;
        if ( $linei eq $lineo ) {
            if ( length($linei) ) {
                $last_nonblank_line  = $linei;
                $last_nonblank_count = $count;
            }
            next;
        }

        #---------------------------
        # lines differ ... finish up
        #---------------------------
        my ( $line_diff, $pos1 ) = line_diff( $linei, $lineo );
        my $ch1    = $pos1 + 1;
        my $reason = "Files first differ at character $ch1 of line $count";

        my ( $leading_ws_i, $leading_ws_o ) = ( EMPTY_STRING, EMPTY_STRING );
        if ( $linei =~ /^(\s+)/ ) { $leading_ws_i = $1; }
        if ( $lineo =~ /^(\s+)/ ) { $leading_ws_o = $1; }
        if ( $leading_ws_i ne $leading_ws_o ) {
            $reason .= "; leading whitespace differs";
            if ( $leading_ws_i =~ /\t/ ) {
                $reason .= "; input has tab char";
            }
        }
        else {
            my ( $trailing_ws_i, $trailing_ws_o ) =
              ( EMPTY_STRING, EMPTY_STRING );
            if ( $linei =~ /(\s+)$/ ) { $trailing_ws_i = $1; }
            if ( $lineo =~ /(\s+)$/ ) { $trailing_ws_o = $1; }
            if ( $trailing_ws_i ne $trailing_ws_o ) {
                $reason .= "; trailing whitespace differs";
            }
        }
        $msg .= $reason . "\n";

        # limit string display length
        if ( $pos1 > 60 ) {
            my $drop = $pos1 - 40;
            $linei     = "..." . substr( $linei, $drop );
            $lineo     = "..." . substr( $lineo, $drop );
            $line_diff = SPACE x 3 . substr( $line_diff, $drop );
        }
        $linei              = $truncate->( $linei,              72 );
        $lineo              = $truncate->( $lineo,              72 );
        $last_nonblank_line = $truncate->( $last_nonblank_line, 72 );

        if ($last_nonblank_line) {
            $msg .= <<EOM;
 $last_nonblank_count:$last_nonblank_line
EOM
        }
        $line_diff = SPACE x ( 2 + length($count) ) . $line_diff;
        $msg .= <<EOM;
<$count:$linei
>$count:$lineo
$line_diff
EOM
        $diff_count++;
        last if ( $diff_count >= $max_diff_count );
    } ## end while ( @aryi && @aryo )

    if ($diff_count) { return $msg }

    #------------------------------------------------------
    # no differences found, see if one file has fewer lines
    #------------------------------------------------------
    if ( $nlines_i > $nlines_o ) {
        $msg .= <<EOM;
Files initially match file but output file has fewer lines
EOM
    }
    elsif ( $nlines_i < $nlines_o ) {
        $msg .= <<EOM;
Files initially match file but input file has fewer lines
EOM
    }
    else {
        $msg .= <<EOM;
Text in lines of file match but checksums differ. Perhaps line endings differ.
EOM
    }
    return $msg;
} ## end sub compare_string_buffers

sub fileglob_to_re {

    # modified (corrected) from version in find2perl
    my $x = shift;
    $x =~ s/([.\/^\$()])/\\$1/g;    # escape special characters
    $x =~ s/\*/.*/g;                # '*' -> '.*'
    $x =~ s/\?/./g;                 # '?' -> '.'
    return "^$x\\z";                # match whole word
} ## end sub fileglob_to_re

sub make_logfile_header {
    my ( $rOpts, $config_file, $rraw_options, $Windows_type, $readable_options )
      = @_;

    # Note: the punctuation variable '$]' is not in older versions of
    # English.pm so leave it as is to avoid failing installation tests.
    my $msg =
"perltidy version $VERSION log file on a $OSNAME system, OLD_PERL_VERSION=$]\n";
    if ($Windows_type) {
        $msg .= "Windows type is $Windows_type\n";
    }
    my $options_string = join( SPACE, @{$rraw_options} );

    if ( defined($config_file) ) {
        $msg .= "Found Configuration File >>> $config_file \n";
    }
    $msg .= "Configuration and command line parameters for this run:\n";
    $msg .= "$options_string\n";

    if ( $rOpts->{'show-options'} ) {
        $rOpts->{'logfile'} = 1;    # force logfile to be saved
        $msg .= "Final parameter set for this run\n";
        $msg .= "------------------------------------\n";

        $msg .= $readable_options;

        $msg .= "------------------------------------\n";
    }
    $msg .= "To find error messages search for 'WARNING' with your editor\n";
    return $msg;
} ## end sub make_logfile_header

sub generate_options {

    ######################################################################
    # Generate and return references to:
    #  @option_string - the list of options to be passed to Getopt::Long
    #  @defaults - the list of default options
    #  %expansion - a hash showing how all abbreviations are expanded
    #  %category - a hash giving the general category of each option
    #  %option_range - a hash giving the valid ranges of certain options

    # Note: a few options are not documented in the man page and usage
    # message. This is because these are deprecated, experimental or debug
    # options and may or may not be retained in future versions:

    # These undocumented flags are accepted but not used:
    # --check-syntax
    # --fuzzy-line-length
    #
    # These undocumented flags are for debugging:
    # --recombine                           # used to debug line breaks
    # --short-concatenation-item-length     # used to break a '.' chain
    #
    ######################################################################

    # here is a summary of the Getopt codes:
    # <none> does not take an argument
    # =s takes a mandatory string
    # :s takes an optional string  (DO NOT USE - filenames will get eaten up)
    # =i takes a mandatory integer
    # :i takes an optional integer (NOT RECOMMENDED - can cause trouble)
    # ! does not take an argument and may be negated
    #  i.e., -foo and -nofoo are allowed
    # a double dash signals the end of the options list
    #
    #-----------------------------------------------
    # Define the option string passed to GetOptions.
    #-----------------------------------------------

    my @option_string   = ();
    my %expansion       = ();
    my %option_category = ();
    my %option_range    = ();
    my %integer_option_range;

    # names of categories in manual
    # leading integers will allow sorting
    my @category_name = (
        '0. I/O control',
        '1. Basic formatting options',
        '2. Code indentation control',
        '3. Whitespace control',
        '4. Comment controls',
        '5. Linebreak controls',
        '6. Controlling list formatting',
        '7. Retaining or ignoring existing line breaks',
        '8. Blank line control',
        '9. Other controls',
        '10. HTML options',
        '11. pod2html options',
        '12. Controlling HTML properties',
        '13. Debugging',
    );

    #  These options are parsed directly by perltidy:
    #    help h
    #    version v
    #  However, they are included in the option set so that they will
    #  be seen in the options dump.

    # These long option names have no abbreviations or are treated specially
    @option_string = qw(
      html!
      noprofile
      no-profile
      npro
      recombine!
      notidy
    );

    my $category = 13;    # Debugging
    foreach (@option_string) {
        my $opt = $_;     # must avoid changing the actual flag
        $opt =~ s/!$//;
        $option_category{$opt} = $category_name[$category];
    }

    $category = 11;                                       # HTML
    $option_category{html} = $category_name[$category];

    # routine to install and check options
    my $add_option = sub {
        my ( $long_name, $short_name, $flag ) = @_;
        push @option_string, $long_name . $flag;
        $option_category{$long_name} = $category_name[$category];
        if ($short_name) {
            if ( $expansion{$short_name} ) {
                my $existing_name = $expansion{$short_name}->[0];
                Die(
"redefining abbreviation $short_name for $long_name; already used for $existing_name\n"
                );
            }
            $expansion{$short_name} = [$long_name];
            if ( $flag eq '!' ) {
                my $nshort_name = 'n' . $short_name;
                my $nolong_name = 'no' . $long_name;
                if ( $expansion{$nshort_name} ) {
                    my $existing_name = $expansion{$nshort_name}->[0];
                    Die(
"attempting to redefine abbreviation $nshort_name for $nolong_name; already used for $existing_name\n"
                    );
                }
                $expansion{$nshort_name} = [$nolong_name];
            }
        }
        return;
    }; ## end $add_option = sub

    # Install long option names which have a simple abbreviation.
    # Options with code '!' get standard negation ('no' for long names,
    # 'n' for abbreviations).  Categories follow the manual.

    ###########################
    $category = 0;    # I/O_Control
    ###########################
    $add_option->( 'backup-and-modify-in-place', 'b',     '!' );
    $add_option->( 'backup-file-extension',      'bext',  '=s' );
    $add_option->( 'backup-method',              'bm',    '=s' );
    $add_option->( 'character-encoding',         'enc',   '=s' );
    $add_option->( 'force-read-binary',          'f',     '!' );
    $add_option->( 'format',                     'fmt',   '=s' );
    $add_option->( 'iterations',                 'it',    '=i' );
    $add_option->( 'logfile',                    'log',   '!' );
    $add_option->( 'logfile-gap',                'g',     ':i' );
    $add_option->( 'outfile',                    'o',     '=s' );
    $add_option->( 'output-file-extension',      'oext',  '=s' );
    $add_option->( 'output-path',                'opath', '=s' );
    $add_option->( 'profile',                    'pro',   '=s' );
    $add_option->( 'quiet',                      'q',     '!' );
    $add_option->( 'standard-error-output',      'se',    '!' );
    $add_option->( 'standard-output',            'st',    '!' );
    $add_option->( 'use-unicode-gcstring',       'gcs',   '!' );
    $add_option->( 'warning-output',             'w',     '!' );
    $add_option->( 'add-terminal-newline',       'atnl',  '!' );
    $add_option->( 'line-range-tidy',            'lrt',   '=s' );
    $add_option->( 'timeout-in-seconds',         'tos',   '=i' );

    # options which are both toggle switches and values moved here
    # to hide from tidyview (which does not show category 0 flags):
    # -ole moved here from category 1
    # -sil moved here from category 2
    $add_option->( 'output-line-ending',         'ole', '=s' );
    $add_option->( 'starting-indentation-level', 'sil', '=i' );

    ########################################
    $category = 1;    # Basic formatting options
    ########################################
    $add_option->( 'check-syntax',                 'syn',  '!' );
    $add_option->( 'entab-leading-whitespace',     'et',   '=i' );
    $add_option->( 'indent-columns',               'i',    '=i' );
    $add_option->( 'maximum-line-length',          'l',    '=i' );
    $add_option->( 'variable-maximum-line-length', 'vmll', '!' );
    $add_option->( 'whitespace-cycle',             'wc',   '=i' );
    $add_option->( 'perl-syntax-check-flags',      'pscf', '=s' );
    $add_option->( 'preserve-line-endings',        'ple',  '!' );
    $add_option->( 'tabs',                         't',    '!' );
    $add_option->( 'default-tabsize',              'dt',   '=i' );
    $add_option->( 'extended-syntax',              'xs',   '!' );
    $add_option->( 'assert-tidy',                  'ast',  '!' );
    $add_option->( 'assert-untidy',                'asu',  '!' );
    $add_option->( 'encode-output-strings',        'eos',  '!' );
    $add_option->( 'sub-alias-list',               'sal',  '=s' );
    $add_option->( 'grep-alias-list',              'gal',  '=s' );
    $add_option->( 'grep-alias-exclusion-list',    'gaxl', '=s' );
    $add_option->( 'use-feature',                  'uf',   '=s' );

    ########################################
    $category = 2;    # Code indentation control
    ########################################
    $add_option->( 'continuation-indentation',             'ci',    '=i' );
    $add_option->( 'extended-continuation-indentation',    'xci',   '!' );
    $add_option->( 'minimize-continuation-indentation',    'mci',   '!' );
    $add_option->( 'line-up-parentheses',                  'lp',    '!' );
    $add_option->( 'extended-line-up-parentheses',         'xlp',   '!' );
    $add_option->( 'line-up-parentheses-exclusion-list',   'lpxl',  '=s' );
    $add_option->( 'line-up-parentheses-inclusion-list',   'lpil',  '=s' );
    $add_option->( 'outdent-keyword-list',                 'okwl',  '=s' );
    $add_option->( 'outdent-keywords',                     'okw',   '!' );
    $add_option->( 'outdent-labels',                       'ola',   '!' );
    $add_option->( 'outdent-long-quotes',                  'olq',   '!' );
    $add_option->( 'indent-closing-brace',                 'icb',   '!' );
    $add_option->( 'indent-leading-semicolon',             'ils',   '!' );
    $add_option->( 'closing-token-indentation',            'cti',   '=i' );
    $add_option->( 'closing-paren-indentation',            'cpi',   '=i' );
    $add_option->( 'closing-brace-indentation',            'cbi',   '=i' );
    $add_option->( 'closing-square-bracket-indentation',   'csbi',  '=i' );
    $add_option->( 'brace-left-and-indent',                'bli',   '!' );
    $add_option->( 'brace-left-and-indent-list',           'blil',  '=s' );
    $add_option->( 'brace-left-and-indent-exclusion-list', 'blixl', '=s' );

    ########################################
    $category = 3;    # Whitespace control
    ########################################
    $add_option->( 'add-trailing-commas',                       'atc',   '!' );
    $add_option->( 'add-lone-trailing-commas',                  'altc',  '!' );
    $add_option->( 'add-semicolons',                            'asc',   '!' );
    $add_option->( 'add-whitespace',                            'aws',   '!' );
    $add_option->( 'block-brace-tightness',                     'bbt',   '=i' );
    $add_option->( 'brace-tightness',                           'bt',    '=i' );
    $add_option->( 'delete-old-whitespace',                     'dws',   '!' );
    $add_option->( 'delete-repeated-commas',                    'drc',   '!' );
    $add_option->( 'delete-trailing-commas',                    'dtc',   '!' );
    $add_option->( 'delete-lone-trailing-commas',               'dltc',  '!' );
    $add_option->( 'delete-weld-interfering-commas',            'dwic',  '!' );
    $add_option->( 'delete-semicolons',                         'dsm',   '!' );
    $add_option->( 'function-paren-vertical-alignment',         'fpva',  '!' );
    $add_option->( 'delay-trailing-comma-operations',           'dtco',  '!' );
    $add_option->( 'keyword-paren-inner-tightness',             'kpit',  '=i' );
    $add_option->( 'keyword-paren-inner-tightness-list',        'kpitl', '=s' );
    $add_option->( 'logical-padding',                           'lop',   '!' );
    $add_option->( 'multiple-token-tightness',                  'mutt',  '=s' );
    $add_option->( 'nospace-after-keyword',                     'nsak',  '=s' );
    $add_option->( 'nowant-left-space',                         'nwls',  '=s' );
    $add_option->( 'nowant-right-space',                        'nwrs',  '=s' );
    $add_option->( 'paren-tightness',                           'pt',    '=i' );
    $add_option->( 'space-after-keyword',                       'sak',   '=s' );
    $add_option->( 'space-for-semicolon',                       'sfs',   '!' );
    $add_option->( 'space-function-paren',                      'sfp',   '!' );
    $add_option->( 'space-keyword-paren',                       'skp',   '!' );
    $add_option->( 'space-terminal-semicolon',                  'sts',   '!' );
    $add_option->( 'square-bracket-tightness',                  'sbt',   '=i' );
    $add_option->( 'square-bracket-vertical-tightness',         'sbvt',  '=i' );
    $add_option->( 'square-bracket-vertical-tightness-closing', 'sbvtc', '=i' );
    $add_option->( 'tight-secret-operators',                    'tso',   '!' );
    $add_option->( 'trim-qw',                                   'tqw',   '!' );
    $add_option->( 'trim-pod',                                  'trp',   '!' );
    $add_option->( 'want-left-space',                           'wls',   '=s' );
    $add_option->( 'want-right-space',                          'wrs',   '=s' );
    $add_option->( 'want-trailing-commas',                      'wtc',   '=s' );
    $add_option->( 'space-prototype-paren',                     'spp',   '=i' );
    $add_option->( 'space-signature-paren',                     'ssp',   '=i' );
    $add_option->( 'valign-code',                               'vc',    '!' );
    $add_option->( 'valign-block-comments',                     'vbc',   '!' );
    $add_option->( 'valign-side-comments',                      'vsc',   '!' );
    $add_option->( 'valign-exclusion-list',                     'vxl',   '=s' );
    $add_option->( 'valign-inclusion-list',                     'vil',   '=s' );
    $add_option->( 'valign-if-unless',                          'viu',   '!' );
    $add_option->( 'valign-signed-numbers',                     'vsn',   '!' );
    $add_option->( 'valign-signed-numbers-limit',               'vsnl',  '=i' );
    $add_option->( 'valign-wide-equals',                        'vwe',   '!' );
    $add_option->( 'extended-block-tightness',                  'xbt',   '!' );
    $add_option->( 'extended-block-tightness-list',             'xbtl',  '=s' );
    $add_option->( 'qw-as-function',                            'qwaf',  '!' );

    ########################################
    $category = 4;    # Comment controls
    ########################################
    $add_option->( 'closing-side-comment-else-flag',      'csce',  '=i' );
    $add_option->( 'closing-side-comment-interval',       'csci',  '=i' );
    $add_option->( 'closing-side-comment-list',           'cscl',  '=s' );
    $add_option->( 'closing-side-comment-exclusion-list', 'cscxl', '=s' );
    $add_option->( 'closing-side-comment-maximum-text',   'csct',  '=i' );
    $add_option->( 'closing-side-comment-prefix',         'cscp',  '=s' );
    $add_option->( 'closing-side-comment-warnings',       'cscw',  '!' );
    $add_option->( 'closing-side-comments',               'csc',   '!' );
    $add_option->( 'closing-side-comments-balanced',      'cscb',  '!' );
    $add_option->( 'code-skipping',                       'cs',    '!' );
    $add_option->( 'code-skipping-begin',                 'csb',   '=s' );
    $add_option->( 'code-skipping-end',                   'cse',   '=s' );
    $add_option->( 'format-skipping',                     'fs',    '!' );
    $add_option->( 'format-skipping-begin',               'fsb',   '=s' );
    $add_option->( 'format-skipping-end',                 'fse',   '=s' );
    $add_option->( 'hanging-side-comments',               'hsc',   '!' );
    $add_option->( 'indent-block-comments',               'ibc',   '!' );
    $add_option->( 'indent-spaced-block-comments',        'isbc',  '!' );
    $add_option->( 'fixed-position-side-comment',         'fpsc',  '=i' );
    $add_option->( 'minimum-space-to-comment',            'msc',   '=i' );
    $add_option->( 'non-indenting-braces',                'nib',   '!' );
    $add_option->( 'non-indenting-brace-prefix',          'nibp',  '=s' );
    $add_option->( 'outdent-long-comments',               'olc',   '!' );
    $add_option->( 'outdent-static-block-comments',       'osbc',  '!' );
    $add_option->( 'static-block-comment-prefix',         'sbcp',  '=s' );
    $add_option->( 'static-block-comments',               'sbc',   '!' );
    $add_option->( 'static-side-comment-prefix',          'sscp',  '=s' );
    $add_option->( 'static-side-comments',                'ssc',   '!' );
    $add_option->( 'ignore-side-comment-lengths',         'iscl',  '!' );
    $add_option->( 'ignore-perlcritic-comments',          'ipc',   '!' );

    ########################################
    $category = 5;    # Linebreak controls
    ########################################
    $add_option->( 'add-newlines',                            'anl',   '!' );
    $add_option->( 'block-brace-vertical-tightness',          'bbvt',  '=i' );
    $add_option->( 'block-brace-vertical-tightness-list',     'bbvtl', '=s' );
    $add_option->( 'brace-follower-vertical-tightness',       'bfvt',  '=i' );
    $add_option->( 'brace-vertical-tightness',                'bvt',   '=i' );
    $add_option->( 'brace-vertical-tightness-closing',        'bvtc',  '=i' );
    $add_option->( 'cuddled-else',                            'ce',    '!' );
    $add_option->( 'cuddled-block-list',                      'cbl',   '=s' );
    $add_option->( 'cuddled-block-list-exclusive',            'cblx',  '!' );
    $add_option->( 'cuddled-break-option',                    'cbo',   '=i' );
    $add_option->( 'cuddled-paren-brace',                     'cpb',   '!' );
    $add_option->( 'delete-old-newlines',                     'dnl',   '!' );
    $add_option->( 'opening-brace-always-on-right',           'bar',   '!' );
    $add_option->( 'opening-brace-on-new-line',               'bl',    '!' );
    $add_option->( 'opening-hash-brace-right',                'ohbr',  '!' );
    $add_option->( 'opening-paren-right',                     'opr',   '!' );
    $add_option->( 'opening-square-bracket-right',            'osbr',  '!' );
    $add_option->( 'opening-anonymous-sub-brace-on-new-line', 'asbl',  '!' );
    $add_option->( 'opening-sub-brace-on-new-line',           'sbl',   '!' );
    $add_option->( 'paren-vertical-tightness',                'pvt',   '=i' );
    $add_option->( 'paren-vertical-tightness-closing',        'pvtc',  '=i' );
    $add_option->( 'weld-nested-containers',                  'wn',    '!' );
    $add_option->( 'weld-nested-exclusion-list',              'wnxl',  '=s' );
    $add_option->( 'weld-fat-comma',                          'wfc',   '!' );
    $add_option->( 'space-backslash-quote',                   'sbq',   '=i' );
    $add_option->( 'stack-closing-block-brace',               'scbb',  '!' );
    $add_option->( 'stack-closing-hash-brace',                'schb',  '!' );
    $add_option->( 'stack-closing-paren',                     'scp',   '!' );
    $add_option->( 'stack-closing-square-bracket',            'scsb',  '!' );
    $add_option->( 'stack-opening-hash-brace',                'sohb',  '!' );
    $add_option->( 'stack-opening-paren',                     'sop',   '!' );
    $add_option->( 'stack-opening-square-bracket',            'sosb',  '!' );

    # FIXME: --vt and --vtc are actually expansions now, so these two lines
    # should eventually be removed.
    $add_option->( 'vertical-tightness',         'vt',  '=i' );
    $add_option->( 'vertical-tightness-closing', 'vtc', '=i' );

    $add_option->( 'want-break-after',                       'wba',   '=s' );
    $add_option->( 'want-break-before',                      'wbb',   '=s' );
    $add_option->( 'break-after-all-operators',              'baao',  '!' );
    $add_option->( 'break-before-all-operators',             'bbao',  '!' );
    $add_option->( 'keep-interior-semicolons',               'kis',   '!' );
    $add_option->( 'one-line-block-semicolons',              'olbs',  '=i' );
    $add_option->( 'one-line-block-nesting',                 'olbn',  '=i' );
    $add_option->( 'one-line-block-exclusion-list',          'olbxl', '=s' );
    $add_option->( 'break-before-hash-brace',                'bbhb',  '=i' );
    $add_option->( 'break-before-hash-brace-and-indent',     'bbhbi', '=i' );
    $add_option->( 'break-before-square-bracket',            'bbsb',  '=i' );
    $add_option->( 'break-before-square-bracket-and-indent', 'bbsbi', '=i' );
    $add_option->( 'break-before-paren',                     'bbp',   '=i' );
    $add_option->( 'break-before-paren-and-indent',          'bbpi',  '=i' );
    $add_option->( 'brace-left-list',                        'bll',   '=s' );
    $add_option->( 'brace-left-exclusion-list',              'blxl',  '=s' );
    $add_option->( 'break-after-labels',                     'bal',   '=i' );

    # This was an experiment mentioned in git #78, originally named -bopl. I
    # expanded it to also open logical blocks, based on git discussion #100,
    # and renamed it -bocp. It works, but will remain commented out due to
    # apparent lack of interest.
    # $add_option->( 'break-open-compact-parens', 'bocp', '=s' );

    ########################################
    $category = 6;    # Controlling list formatting
    ########################################
    $add_option->( 'break-at-old-comma-breakpoints', 'boc',  '!' );
    $add_option->( 'break-at-trailing-comma-types',  'btct', '=s' );
    $add_option->( 'comma-arrow-breakpoints',        'cab',  '=i' );
    $add_option->( 'maximum-fields-per-table',       'mft',  '=i' );

    ########################################
    $category = 7;    # Retaining or ignoring existing line breaks
    ########################################
    $add_option->( 'break-at-old-keyword-breakpoints',   'bok', '!' );
    $add_option->( 'break-at-old-logical-breakpoints',   'bol', '!' );
    $add_option->( 'break-at-old-method-breakpoints',    'bom', '!' );
    $add_option->( 'break-at-old-semicolon-breakpoints', 'bos', '!' );
    $add_option->( 'break-at-old-ternary-breakpoints',   'bot', '!' );
    $add_option->( 'break-at-old-attribute-breakpoints', 'boa', '!' );
    $add_option->( 'keep-old-breakpoints-before',        'kbb', '=s' );
    $add_option->( 'keep-old-breakpoints-after',         'kba', '=s' );
    $add_option->( 'ignore-old-breakpoints',             'iob', '!' );

    ########################################
    $category = 8;    # Blank line control
    ########################################
    $add_option->( 'blanks-before-blocks',            'bbb',  '!' );
    $add_option->( 'blanks-before-comments',          'bbc',  '!' );
    $add_option->( 'blank-lines-before-subs',         'blbs', '=i' );
    $add_option->( 'blank-lines-before-packages',     'blbp', '=i' );
    $add_option->( 'long-block-line-count',           'lbl',  '=i' );
    $add_option->( 'maximum-consecutive-blank-lines', 'mbl',  '=i' );
    $add_option->( 'keep-old-blank-lines',            'kbl',  '=i' );

    $add_option->( 'keyword-group-blanks-list',         'kgbl', '=s' );
    $add_option->( 'keyword-group-blanks-size',         'kgbs', '=s' );
    $add_option->( 'keyword-group-blanks-repeat-count', 'kgbr', '=i' );
    $add_option->( 'keyword-group-blanks-before',       'kgbb', '=i' );
    $add_option->( 'keyword-group-blanks-after',        'kgba', '=i' );
    $add_option->( 'keyword-group-blanks-inside',       'kgbi', '!' );
    $add_option->( 'keyword-group-blanks-delete',       'kgbd', '!' );

    $add_option->( 'blank-lines-after-opening-block',       'blao',  '=i' );
    $add_option->( 'blank-lines-before-closing-block',      'blbc',  '=i' );
    $add_option->( 'blank-lines-after-opening-block-list',  'blaol', '=s' );
    $add_option->( 'blank-lines-before-closing-block-list', 'blbcl', '=s' );

    ########################################
    $category = 9;    # Other controls
    ########################################
    $add_option->( 'warn-missing-else',            'wme',  '!' );
    $add_option->( 'add-missing-else',             'ame',  '!' );
    $add_option->( 'add-missing-else-comment',     'amec', '=s' );
    $add_option->( 'delete-block-comments',        'dbc',  '!' );
    $add_option->( 'delete-closing-side-comments', 'dcsc', '!' );
    $add_option->( 'delete-pod',                   'dp',   '!' );
    $add_option->( 'delete-side-comments',         'dsc',  '!' );
    $add_option->( 'tee-block-comments',           'tbc',  '!' );
    $add_option->( 'tee-pod',                      'tp',   '!' );
    $add_option->( 'tee-side-comments',            'tsc',  '!' );
    $add_option->( 'look-for-autoloader',          'lal',  '!' );
    $add_option->( 'look-for-hash-bang',           'x',    '!' );
    $add_option->( 'look-for-selfloader',          'lsl',  '!' );
    $add_option->( 'pass-version-line',            'pvl',  '!' );
    $add_option->( 'warn-variable-types',          'wvt',  '=s' );
    $add_option->( 'warn-variable-exclusion-list', 'wvxl', '=s' );
    $add_option->( 'want-call-parens',             'wcp',  '=s' );
    $add_option->( 'nowant-call-parens',           'nwcp', '=s' );

    $add_option->( 'warn-mismatched-args',                  'wma',   '!' );
    $add_option->( 'warn-mismatched-arg-types',             'wmat',  '=s' );
    $add_option->( 'warn-mismatched-arg-undercount-cutoff', 'wmauc', '=i' );
    $add_option->( 'warn-mismatched-arg-overcount-cutoff',  'wmaoc', '=i' );
    $add_option->( 'warn-mismatched-arg-exclusion-list',    'wmaxl', '=s' );
    $add_option->( 'warn-mismatched-returns',               'wmr',   '!' );
    $add_option->( 'warn-mismatched-return-types',          'wmrt',  '=s' );
    $add_option->( 'warn-mismatched-return-exclusion-list', 'wmrxl', '=s' );

    $add_option->( 'add-interbracket-arrows',       'aia', '!' );
    $add_option->( 'delete-interbracket-arrows',    'dia', '!' );
    $add_option->( 'warn-interbracket-arrows',      'wia', '!' );
    $add_option->( 'interbracket-arrow-style',      'ias', '=s' );
    $add_option->( 'interbracket-arrow-complexity', 'iac', '=i' );

    ########################################
    $category = 13;    # Debugging
    ########################################
    $add_option->( 'DEBUG',                           'D',     '!' );
    $add_option->( 'dump-block-summary',              'dbs',   '!' );
    $add_option->( 'dump-block-minimum-lines',        'dbl',   '=i' );
    $add_option->( 'dump-block-types',                'dbt',   '=s' );
    $add_option->( 'dump-cuddled-block-list',         'dcbl',  '!' );
    $add_option->( 'dump-defaults',                   'ddf',   '!' );
    $add_option->( 'dump-integer-option-range',       'dior',  '!' );
    $add_option->( 'dump-long-names',                 'dln',   '!' );
    $add_option->( 'dump-mismatched-args',            'dma',   '!' );
    $add_option->( 'dump-mismatched-returns',         'dmr',   '!' );
    $add_option->( 'dump-mixed-call-parens',          'dmcp',  '!' );
    $add_option->( 'dump-options',                    'dop',   '!' );
    $add_option->( 'dump-profile',                    'dpro',  '!' );
    $add_option->( 'dump-short-names',                'dsn',   '!' );
    $add_option->( 'dump-token-types',                'dtt',   '!' );
    $add_option->( 'dump-unusual-variables',          'duv',   '!' );
    $add_option->( 'dump-unique-keys',                'duk',   '!' );
    $add_option->( 'dump-want-left-space',            'dwls',  '!' );
    $add_option->( 'dump-want-right-space',           'dwrs',  '!' );
    $add_option->( 'fuzzy-line-length',               'fll',   '!' );
    $add_option->( 'help',                            'h',     EMPTY_STRING );
    $add_option->( 'short-concatenation-item-length', 'scl',   '=i' );
    $add_option->( 'show-options',                    'opt',   '!' );
    $add_option->( 'timestamp',                       'ts',    '!' );
    $add_option->( 'version',                         'v',     EMPTY_STRING );
    $add_option->( 'memoize',                         'mem',   '!' );
    $add_option->( 'file-size-order',                 'fso',   '!' );
    $add_option->( 'maximum-file-size-mb',            'maxfs', '=i' );
    $add_option->( 'maximum-level-errors',            'maxle', '=i' );
    $add_option->( 'maximum-unexpected-errors',       'maxue', '=i' );
    $add_option->( 'integer-range-check',             'irc',   '=i' );

    #---------------------------------------------------------------------

    # The Perl::Tidy::HtmlWriter will add its own options to the string
    Perl::Tidy::HtmlWriter->make_getopt_long_names( \@option_string );

    ########################################
    # Set categories 10, 11, 12
    ########################################
    # Based on their known order
    $category = 12;    # HTML properties
    foreach my $opt (@option_string) {
        my $long_name = $opt;
        $long_name =~ s/(!|=.*|:.*)$//;
        if ( !defined( $option_category{$long_name} ) ) {
            if ( $long_name =~ /^html-linked/ ) {
                $category = 10;    # HTML options
            }
            elsif ( $long_name =~ /^pod2html/ ) {
                $category = 11;    # Pod2html
            }
            else {
                $category = 12;    # HTML properties
            }
            $option_category{$long_name} = $category_name[$category];
        }
    }

    #------------------------------------------------------------------
    # DEFAULTS: Assign default values to the above options here, except
    # for 'outfile' and 'help'.
    # These settings should approximate the perlstyle(1) suggestions.
    #------------------------------------------------------------------
    my @defaults = qw(
      add-lone-trailing-commas
      add-newlines
      add-terminal-newline
      add-semicolons
      add-whitespace
      blanks-before-blocks
      blanks-before-comments
      blank-lines-before-subs=1
      blank-lines-before-packages=1

      keyword-group-blanks-size=5
      keyword-group-blanks-repeat-count=0
      keyword-group-blanks-before=1
      keyword-group-blanks-after=1
      nokeyword-group-blanks-inside
      nokeyword-group-blanks-delete

      block-brace-tightness=0
      block-brace-vertical-tightness=0
      brace-follower-vertical-tightness=1
      brace-tightness=1
      brace-vertical-tightness-closing=0
      brace-vertical-tightness=0
      break-after-labels=0
      break-at-old-logical-breakpoints
      break-at-old-ternary-breakpoints
      break-at-old-attribute-breakpoints
      break-at-old-keyword-breakpoints
      break-before-hash-brace=0
      break-before-hash-brace-and-indent=0
      break-before-square-bracket=0
      break-before-square-bracket-and-indent=0
      break-before-paren=0
      break-before-paren-and-indent=0
      comma-arrow-breakpoints=5
      nocheck-syntax
      character-encoding=guess
      closing-side-comment-interval=6
      closing-side-comment-maximum-text=20
      closing-side-comment-else-flag=0
      closing-side-comments-balanced
      closing-paren-indentation=0
      closing-brace-indentation=0
      closing-square-bracket-indentation=0
      continuation-indentation=2
      noextended-continuation-indentation
      cuddled-break-option=1
      delete-old-newlines
      delete-repeated-commas
      delete-lone-trailing-commas
      delete-semicolons
      dump-block-minimum-lines=20
      dump-block-types=sub
      extended-syntax
      encode-output-strings
      file-size-order
      function-paren-vertical-alignment
      fuzzy-line-length
      hanging-side-comments
      indent-block-comments
      indent-columns=4
      indent-leading-semicolon
      integer-range-check=2
      interbracket-arrow-complexity=1
      iterations=1
      keep-old-blank-lines=1
      keyword-paren-inner-tightness=1
      logical-padding
      long-block-line-count=8
      look-for-autoloader
      look-for-selfloader
      maximum-consecutive-blank-lines=1
      maximum-fields-per-table=0
      maximum-line-length=80
      maximum-file-size-mb=10
      maximum-level-errors=1
      maximum-unexpected-errors=0
      memoize
      minimum-space-to-comment=4
      warn-mismatched-arg-undercount-cutoff=4
      warn-mismatched-arg-overcount-cutoff=1
      nobrace-left-and-indent
      nocuddled-else
      nodelete-old-whitespace
      nohtml
      nologfile
      non-indenting-braces
      noquiet
      noshow-options
      nostatic-side-comments
      notabs
      nowarning-output
      one-line-block-semicolons=1
      one-line-block-nesting=0
      outdent-labels
      outdent-long-quotes
      outdent-long-comments
      paren-tightness=1
      paren-vertical-tightness-closing=0
      paren-vertical-tightness=0
      pass-version-line
      noweld-nested-containers
      recombine
      nouse-unicode-gcstring
      valign-code
      valign-block-comments
      valign-side-comments
      valign-signed-numbers
      valign-signed-numbers-limit=20
      short-concatenation-item-length=8
      space-for-semicolon
      space-backslash-quote=1
      space-prototype-paren=1
      space-signature-paren=1
      square-bracket-tightness=1
      square-bracket-vertical-tightness-closing=0
      square-bracket-vertical-tightness=0
      static-block-comments
      timestamp
      trim-qw
      format=tidy
      backup-method=copy
      backup-file-extension=bak
      code-skipping
      format-skipping
      default-tabsize=8
      timeout-in-seconds=10

      whitespace-cycle=0
      entab-leading-whitespace=0
      blank-lines-before-closing-block=0
      blank-lines-after-opening-block=0

      pod2html
      html-table-of-contents
      html-entities
    );

    #---------------------------------------
    # Assign valid ranges to certain options
    #---------------------------------------
    # In the future, these may be used to make preliminary checks
    # hash keys are long names
    # If key or value is undefined:
    #   strings may have any value
    #   integer ranges are >=0
    # If value is defined:
    #   value is [qw(any valid words)] for strings
    #   value is [min, max] for integers
    #   if min is undefined, there is no lower limit
    #   if max is undefined, there is no upper limit
    # Parameters not listed here have defaults
    %option_range = (
        'format'                        => [ 'tidy', 'html', 'user' ],
        'output-line-ending'            => [ 'dos',  'win',  'mac', 'unix' ],
        'space-backslash-quote'         => [ 0,      2 ],
        'block-brace-tightness'         => [ 0,      2 ],
        'keyword-paren-inner-tightness' => [ 0,      2 ],
        'brace-tightness'               => [ 0,      2 ],
        'paren-tightness'               => [ 0,      2 ],
        'square-bracket-tightness'      => [ 0,      2 ],

        'block-brace-vertical-tightness'            => [ 0, 2 ],
        'brace-follower-vertical-tightness'         => [ 0, 2 ],
        'brace-vertical-tightness'                  => [ 0, 2 ],
        'brace-vertical-tightness-closing'          => [ 0, 3 ],
        'paren-vertical-tightness'                  => [ 0, 2 ],
        'paren-vertical-tightness-closing'          => [ 0, 3 ],
        'square-bracket-vertical-tightness'         => [ 0, 2 ],
        'square-bracket-vertical-tightness-closing' => [ 0, 3 ],
        'vertical-tightness'                        => [ 0, 2 ],
        'vertical-tightness-closing'                => [ 0, 3 ],

        'closing-brace-indentation'          => [ 0, 3 ],
        'closing-paren-indentation'          => [ 0, 3 ],
        'closing-square-bracket-indentation' => [ 0, 3 ],
        'closing-token-indentation'          => [ 0, 3 ],

        'closing-side-comment-else-flag' => [ 0, 2 ],
        'comma-arrow-breakpoints'        => [ 0, 5 ],

        'keyword-group-blanks-before' => [ 0, 2 ],
        'keyword-group-blanks-after'  => [ 0, 2 ],

        'space-prototype-paren' => [ 0, 2 ],
        'space-signature-paren' => [ 0, 2 ],
        'break-after-labels'    => [ 0, 2 ],
    );

    # Valid [min,max] ranges of all integer options (type '=i').  This hash is
    # replacing %option_range, above, for use by sub 'check_options'
    %integer_option_range = (
        'blank-lines-after-opening-block'           => [ 0, undef ],
        'blank-lines-before-closing-block'          => [ 0, undef ],
        'blank-lines-before-packages'               => [ 0, undef ],
        'blank-lines-before-subs'                   => [ 0, undef ],
        'block-brace-tightness'                     => [ 0, 2 ],
        'block-brace-vertical-tightness'            => [ 0, 2 ],
        'brace-follower-vertical-tightness'         => [ 0, 2 ],
        'brace-tightness'                           => [ 0, 2 ],
        'brace-vertical-tightness'                  => [ 0, 2 ],
        'brace-vertical-tightness-closing'          => [ 0, 3 ],
        'break-after-labels'                        => [ 0, 2 ],
        'break-before-hash-brace'                   => [ 0, 3 ],
        'break-before-hash-brace-and-indent'        => [ 0, 2 ],
        'break-before-paren'                        => [ 0, 3 ],
        'break-before-paren-and-indent'             => [ 0, 2 ],
        'break-before-square-bracket'               => [ 0, 3 ],
        'break-before-square-bracket-and-indent'    => [ 0, 2 ],
        'closing-brace-indentation'                 => [ 0, 3 ],
        'closing-paren-indentation'                 => [ 0, 3 ],
        'closing-side-comment-else-flag'            => [ 0, 2 ],
        'closing-side-comment-interval'             => [ 0, undef ],
        'closing-side-comment-maximum-text'         => [ 0, undef ],
        'closing-square-bracket-indentation'        => [ 0, 3 ],
        'closing-token-indentation'                 => [ 0, 3 ],
        'comma-arrow-breakpoints'                   => [ 0, 5 ],
        'continuation-indentation'                  => [ 0, undef ],
        'cuddled-break-option'                      => [ 0, 2 ],
        'default-tabsize'                           => [ 0, undef ],
        'dump-block-minimum-lines'                  => [ 0, undef ],
        'entab-leading-whitespace'                  => [ 0, undef ],
        'fixed-position-side-comment'               => [ 0, undef ],
        'indent-columns'                            => [ 0, undef ],
        'interbracket-arrow-complexity'             => [ 0, 2 ],
        'integer-range-check'                       => [ 0, 3 ],
        'iterations'                                => [ 0, undef ],
        'keep-old-blank-lines'                      => [ 0, 2 ],
        'keyword-group-blanks-after'                => [ 0, 2 ],
        'keyword-group-blanks-before'               => [ 0, 2 ],
        'keyword-group-blanks-repeat-count'         => [ 0, undef ],
        'keyword-paren-inner-tightness'             => [ 0, 2 ],
        'long-block-line-count'                     => [ 0, undef ],
        'maximum-consecutive-blank-lines'           => [ 0, undef ],
        'maximum-fields-per-table'                  => [ 0, undef ],
        'maximum-file-size-mb'                      => [ 0, undef ],
        'maximum-level-errors'                      => [ 0, undef ],
        'maximum-line-length'                       => [ 0, undef ],
        'maximum-unexpected-errors'                 => [ 0, undef ],
        'minimum-space-to-comment'                  => [ 0, undef ],
        'warn-mismatched-arg-undercount-cutoff'     => [ 0, undef ],
        'warn-mismatched-arg-overcount-cutoff'      => [ 0, undef ],
        'one-line-block-nesting'                    => [ 0, 1 ],
        'one-line-block-semicolons'                 => [ 0, 2 ],
        'paren-tightness'                           => [ 0, 2 ],
        'paren-vertical-tightness'                  => [ 0, 2 ],
        'paren-vertical-tightness-closing'          => [ 0, 3 ],
        'short-concatenation-item-length'           => [ 0, undef ],
        'space-backslash-quote'                     => [ 0, 2 ],
        'space-prototype-paren'                     => [ 0, 2 ],
        'space-signature-paren'                     => [ 0, 2 ],
        'square-bracket-tightness'                  => [ 0, 2 ],
        'square-bracket-vertical-tightness'         => [ 0, 2 ],
        'square-bracket-vertical-tightness-closing' => [ 0, 3 ],
        'starting-indentation-level'                => [ 0, undef ],
        'timeout-in-seconds'                        => [ 0, undef ],
        'vertical-tightness'                        => [ 0, 2 ],
        'vertical-tightness-closing'                => [ 0, 3 ],
        'valign-signed-numbers-limit'               => [ 0, undef ],
        'whitespace-cycle'                          => [ 0, undef ],
    );

    # Enter default values into the integer option range table
    foreach my $opt (@defaults) {
        if ( $opt =~ /^(.*)=(\d+)$/ ) {
            my $key = $1;
            my $def = $2;
            if ( defined( $integer_option_range{$key} ) ) {
                $integer_option_range{$key}->[2] = $def;
            }
        }
    }

    # Enter special values which have undef as the default.
    # Note that cti, vt, and vtc are aliases which are included to work
    # around an old problem with msdos (see note in check_options).
    foreach my $key (
        qw(
        closing-token-indentation
        vertical-tightness
        vertical-tightness-closing
        fixed-position-side-comment
        starting-indentation-level
        )
      )
    {
        if ( defined( $integer_option_range{$key} )
            && @{ $integer_option_range{$key} } < 3 )
        {
            $integer_option_range{$key}->[2] = undef;
        }
    }

    # Verify that only integers of type =i are in the above list during
    # development. This will guard against spelling errors.
    if (DEVEL_MODE) {
        my %option_flag;
        my $msg = EMPTY_STRING;
        foreach my $opt (@option_string) {
            my $key  = $opt;
            my $flag = EMPTY_STRING;
            if ( $key =~ /(.*)(!|=.*|:.*)$/ ) {
                $key  = $1;
                $flag = $2;
            }
            $option_flag{$key} = $flag;
        }

        # Be sure all keys of %integer_option_range have option type '=i'
        foreach my $opt ( keys %integer_option_range ) {
            my $flag = $option_flag{$opt};
            if ( !defined($flag) ) { $flag = EMPTY_STRING }
            if ( $flag ne '=i' ) {

                # If this fault occurs, one of the items in the previous hash
                # is not type =i, possibly due to incorrect spelling.
                $msg .=
"Option '$opt' has an entry in '%integer_option_range' but is not an integer\n";
            }
        }

        # Be sure all '=i' options are in %integer_option_range. This is not
        # strictly necessary but helps insure that nothing was missed.
        foreach my $opt ( keys %option_flag ) {
            my $flag = $option_flag{$opt};
            next if ( $flag ne '=i' );
            if ( !defined( $integer_option_range{$opt} ) ) {
                $msg .=
"Integer option '$opt' is needs an entry in '%integer_option_range'\n";
            }
        }

        # look for integer options without default values
        foreach my $opt ( keys %integer_option_range ) {
            if ( @{ $integer_option_range{$opt} } < 3 ) {
                $msg .= "Integer option '$opt' does not have a default value\n";
            }
        }

        if ($msg) {
            Fault($msg);
        }
    }

    #-----------------------------------------------------------------------
    # Define abbreviations which will be expanded into the above primitives.
    # These may be defined recursively.
    #-----------------------------------------------------------------------
    %expansion = (
        %expansion,
        'freeze-newlines'    => [qw(noadd-newlines nodelete-old-newlines)],
        'fnl'                => [qw(freeze-newlines)],
        'freeze-whitespace'  => [qw(noadd-whitespace nodelete-old-whitespace)],
        'fws'                => [qw(freeze-whitespace)],
        'freeze-blank-lines' =>
          [qw(maximum-consecutive-blank-lines=0 keep-old-blank-lines=2)],
        'fbl'                => [qw(freeze-blank-lines)],
        'indent-only'        => [qw(freeze-newlines freeze-whitespace)],
        'outdent-long-lines' => [qw(outdent-long-quotes outdent-long-comments)],
        'nooutdent-long-lines' =>
          [qw(nooutdent-long-quotes nooutdent-long-comments)],
        'oll'                 => [qw(outdent-long-lines)],
        'noll'                => [qw(nooutdent-long-lines)],
        'io'                  => [qw(indent-only)],
        'delete-all-comments' =>
          [qw(delete-block-comments delete-side-comments delete-pod)],
        'nodelete-all-comments' =>
          [qw(nodelete-block-comments nodelete-side-comments nodelete-pod)],
        'dac'              => [qw(delete-all-comments)],
        'ndac'             => [qw(nodelete-all-comments)],
        'gnu'              => [qw(gnu-style)],
        'pbp'              => [qw(perl-best-practices)],
        'tee-all-comments' =>
          [qw(tee-block-comments tee-side-comments tee-pod)],
        'notee-all-comments' =>
          [qw(notee-block-comments notee-side-comments notee-pod)],
        'tac'   => [qw(tee-all-comments)],
        'ntac'  => [qw(notee-all-comments)],
        'html'  => [qw(format=html)],
        'nhtml' => [qw(format=tidy)],
        'tidy'  => [qw(format=tidy)],

        'brace-left' => [qw(opening-brace-on-new-line)],

        # -cb is now a synonym for -ce
        'cb'             => [qw(cuddled-else)],
        'cuddled-blocks' => [qw(cuddled-else)],

        'utf8'  => [qw(character-encoding=utf8)],
        'UTF8'  => [qw(character-encoding=utf8)],
        'guess' => [qw(character-encoding=guess)],

        'swallow-optional-blank-lines'   => [qw(kbl=0)],
        'noswallow-optional-blank-lines' => [qw(kbl=1)],
        'sob'                            => [qw(kbl=0)],
        'nsob'                           => [qw(kbl=1)],

        'break-after-comma-arrows'   => [qw(cab=0)],
        'nobreak-after-comma-arrows' => [qw(cab=1)],
        'baa'                        => [qw(cab=0)],
        'nbaa'                       => [qw(cab=1)],

        'blanks-before-subs'   => [qw(blbs=1 blbp=1)],
        'bbs'                  => [qw(blbs=1 blbp=1)],
        'noblanks-before-subs' => [qw(blbs=0 blbp=0)],
        'nbbs'                 => [qw(blbs=0 blbp=0)],

        'keyword-group-blanks'   => [qw(kgbb=2 kgbi kgba=2)],
        'kgb'                    => [qw(kgbb=2 kgbi kgba=2)],
        'nokeyword-group-blanks' => [qw(kgbb=1 nkgbi kgba=1)],
        'nkgb'                   => [qw(kgbb=1 nkgbi kgba=1)],

        'break-at-old-trinary-breakpoints' => [qw(bot)],

        'cti=0' => [qw(cpi=0 cbi=0 csbi=0)],
        'cti=1' => [qw(cpi=1 cbi=1 csbi=1)],
        'cti=2' => [qw(cpi=2 cbi=2 csbi=2)],
        'icp'   => [qw(cpi=2 cbi=2 csbi=2)],
        'nicp'  => [qw(cpi=0 cbi=0 csbi=0)],

        'closing-token-indentation=0' => [qw(cpi=0 cbi=0 csbi=0)],
        'closing-token-indentation=1' => [qw(cpi=1 cbi=1 csbi=1)],
        'closing-token-indentation=2' => [qw(cpi=2 cbi=2 csbi=2)],
        'indent-closing-paren'        => [qw(cpi=2 cbi=2 csbi=2)],
        'noindent-closing-paren'      => [qw(cpi=0 cbi=0 csbi=0)],

        'vt=0' => [qw(pvt=0 bvt=0 sbvt=0)],
        'vt=1' => [qw(pvt=1 bvt=1 sbvt=1)],
        'vt=2' => [qw(pvt=2 bvt=2 sbvt=2)],

        'vertical-tightness=0' => [qw(pvt=0 bvt=0 sbvt=0)],
        'vertical-tightness=1' => [qw(pvt=1 bvt=1 sbvt=1)],
        'vertical-tightness=2' => [qw(pvt=2 bvt=2 sbvt=2)],

        'vtc=0' => [qw(pvtc=0 bvtc=0 sbvtc=0)],
        'vtc=1' => [qw(pvtc=1 bvtc=1 sbvtc=1)],
        'vtc=2' => [qw(pvtc=2 bvtc=2 sbvtc=2)],

        'vertical-tightness-closing=0' => [qw(pvtc=0 bvtc=0 sbvtc=0)],
        'vertical-tightness-closing=1' => [qw(pvtc=1 bvtc=1 sbvtc=1)],
        'vertical-tightness-closing=2' => [qw(pvtc=2 bvtc=2 sbvtc=2)],

        'otr'                   => [qw(opr ohbr osbr)],
        'opening-token-right'   => [qw(opr ohbr osbr)],
        'notr'                  => [qw(nopr nohbr nosbr)],
        'noopening-token-right' => [qw(nopr nohbr nosbr)],

        'sot'                    => [qw(sop sohb sosb)],
        'nsot'                   => [qw(nsop nsohb nsosb)],
        'stack-opening-tokens'   => [qw(sop sohb sosb)],
        'nostack-opening-tokens' => [qw(nsop nsohb nsosb)],

        'sct'                    => [qw(scp schb scsb)],
        'stack-closing-tokens'   => [qw(scp schb scsb)],
        'nsct'                   => [qw(nscp nschb nscsb)],
        'nostack-closing-tokens' => [qw(nscp nschb nscsb)],

        'sac'                    => [qw(sot sct)],
        'nsac'                   => [qw(nsot nsct)],
        'stack-all-containers'   => [qw(sot sct)],
        'nostack-all-containers' => [qw(nsot nsct)],

        'act=0'                      => [qw(pt=0 sbt=0 bt=0 bbt=0)],
        'act=1'                      => [qw(pt=1 sbt=1 bt=1 bbt=1)],
        'act=2'                      => [qw(pt=2 sbt=2 bt=2 bbt=2)],
        'all-containers-tightness=0' => [qw(pt=0 sbt=0 bt=0 bbt=0)],
        'all-containers-tightness=1' => [qw(pt=1 sbt=1 bt=1 bbt=1)],
        'all-containers-tightness=2' => [qw(pt=2 sbt=2 bt=2 bbt=2)],

        'stack-opening-block-brace'   => [qw(bbvt=2 bbvtl=*)],
        'sobb'                        => [qw(bbvt=2 bbvtl=*)],
        'nostack-opening-block-brace' => [qw(bbvt=0)],
        'nsobb'                       => [qw(bbvt=0)],

        'converge'   => [qw(it=4)],
        'noconverge' => [qw(it=1)],
        'conv'       => [qw(it=4)],
        'nconv'      => [qw(it=1)],

        'valign'   => [qw(vc vsc vbc)],
        'novalign' => [qw(nvc nvsc nvbc)],

        # NOTE: This is a possible future shortcut.  But it will remain
        # deactivated until the -lpxl flag is no longer experimental.
        # 'line-up-function-parentheses' => [ qw(lp), q#lpxl=[ { F(2# ],
        # 'lfp'                          => [qw(line-up-function-parentheses)],

        # 'mangle' originally deleted pod and comments, but to keep it
        # reversible, it no longer does.  But if you really want to
        # delete them, just use:
        #   -mangle -dac

        # An interesting use for 'mangle' is to do this:
        #    perltidy -mangle myfile.pl -st | perltidy -o myfile.pl.new
        # which will form as many one-line blocks as possible

        'mangle' => [
            qw(
              keep-old-blank-lines=0
              delete-old-newlines
              delete-old-whitespace
              delete-semicolons
              indent-columns=0
              maximum-consecutive-blank-lines=0
              maximum-line-length=100000
              noadd-newlines
              noadd-semicolons
              noadd-whitespace
              noblanks-before-blocks
              blank-lines-before-subs=0
              blank-lines-before-packages=0
              notabs
            )
        ],

        # 'extrude' originally deleted pod and comments, but to keep it
        # reversible, it no longer does.  But if you really want to
        # delete them, just use
        #   extrude -dac
        #
        # An interesting use for 'extrude' is to do this:
        #    perltidy -extrude myfile.pl -st | perltidy -o myfile.pl.new
        # which will break up all one-line blocks.
        'extrude' => [
            qw(
              ci=0
              delete-old-newlines
              delete-old-whitespace
              delete-semicolons
              indent-columns=0
              maximum-consecutive-blank-lines=0
              maximum-line-length=1
              noadd-semicolons
              noadd-whitespace
              noblanks-before-blocks
              blank-lines-before-subs=0
              blank-lines-before-packages=0
              nofuzzy-line-length
              notabs
              norecombine
            )
        ],

        # this style tries to follow the GNU Coding Standards (which do
        # not really apply to perl but which are followed by some perl
        # programmers).
        'gnu-style' => [
            qw(
              lp bl noll pt=2 bt=2 sbt=2 cpi=1 csbi=1 cbi=1
            )
        ],

        # Style suggested in Damian Conway's Perl Best Practices
        'perl-best-practices' => [
            qw(l=78 i=4 ci=4 st se vt=2 cti=0 pt=1 bt=1 sbt=1 bbt=1 nsfs nolq),
q(wbb=% + - * / x != == >= <= =~ !~ < > | & = **= += *= &= <<= &&= -= /= |= >>= ||= //= .= %= ^= x=)
        ],

        # Additional styles can be added here
    );

    Perl::Tidy::HtmlWriter->make_abbreviated_names( \%expansion );

    # Uncomment next line to dump all expansions for debugging:
    # dump_short_names(\%expansion);
    return ( \@option_string, \@defaults, \%expansion, \%option_category,
        \%option_range, \%integer_option_range );

} ## end sub generate_options

{ #<<< closure process_command_line

# Memoize process_command_line. Given same @ARGV passed in, return same
# values and same @ARGV back.
# This patch was supplied by Jonathan Swartz Nov 2012 and significantly speeds
# up masontidy (https://metacpan.org/module/masontidy)

my %process_command_line_cache;

sub process_command_line {

    my @q = @_;
    my (
        $perltidyrc_stream,     $is_Windows_uu, $Windows_type_uu,
        $rpending_complaint_uu, $dump_options_type
    ) = @q;

    # This is the outer sub which handles memoization

    my $use_cache = !defined($perltidyrc_stream) && !$dump_options_type;
    if ($use_cache) {
        my $cache_key = join( chr(28), @ARGV );
        if ( my $result = $process_command_line_cache{$cache_key} ) {
            my ( $argv, @retvals ) = @{$result};
            @ARGV = @{$argv};
            return @retvals;
        }
        else {
            my @retvals = _process_command_line(@q);
            $process_command_line_cache{$cache_key} = [ \@ARGV, @retvals ]
              if $retvals[0]->{'memoize'};
            return @retvals;
        }
    }
    else {
        return _process_command_line(@q);
    }
} ## end sub process_command_line
} ## end closure process_command_line

# (note the underscore here)
sub _process_command_line {

    my (
        $perltidyrc_stream,  $is_Windows, $Windows_type,
        $rpending_complaint, $dump_options_type
    ) = @_;

    # This is the inner sub which actually processes the command line

    use Getopt::Long;

    # Save any current Getopt::Long configuration
    # and set to Getopt::Long defaults.  Use eval to avoid
    # breaking old versions of Perl without these routines.
    # Previous configuration is reset at the exit of this routine.
    my $glc;
    if ( eval { $glc = Getopt::Long::Configure(); 1 } ) {
        my $ok = eval { Getopt::Long::ConfigDefaults(); 1 };
        if ( !$ok && DEVEL_MODE ) {
            Fault("Failed call to Getopt::Long::ConfigDefaults: $EVAL_ERROR\n");
        }
    }
    else { $glc = undef }

    my ( $roption_string, $rdefaults, $rexpansion,
        $roption_category, $roption_range, $rinteger_option_range )
      = generate_options();

    #--------------------------------------------------------------
    # set the defaults by passing the above list through GetOptions
    #--------------------------------------------------------------
    my %Opts = ();
    {
        local @ARGV = ();

        # do not load the defaults if we are just dumping perltidyrc
        if ( $dump_options_type ne 'perltidyrc' ) {
            for my $i ( @{$rdefaults} ) { push @ARGV, "--" . $i }
        }
        if ( !GetOptions( \%Opts, @{$roption_string} ) ) {
            Die(
"Programming Bug reported by 'GetOptions': error in setting default options"
            );
        }
    }

    my @raw_options        = ();
    my $saw_ignore_profile = 0;
    my $saw_dump_profile   = 0;
    my $config_file;

    #--------------------------------------------------------------
    # Take a first look at the command-line parameters.  Do as many
    # immediate dumps as possible, which can avoid confusion if the
    # perltidyrc file has an error.
    #--------------------------------------------------------------
    foreach my $i (@ARGV) {

        $i =~ s/^--/-/;
        if ( $i =~ /^-(npro|noprofile|no-profile)$/ ) {
            $saw_ignore_profile = 1;
        }

        # note: this must come before -pro and -profile, below:
        elsif ( $i =~ /^-(dump-profile|dpro)$/ ) {
            $saw_dump_profile = 1;
        }
        elsif ( $i =~ /^-(pro|profile)=(.+)/ ) {
            if ( defined($config_file) ) {
                Warn(
"Only one -pro=filename allowed, using '$2' instead of '$config_file'\n"
                );
            }
            $config_file = $2;

            # resolve <dir>/.../<file>, meaning look upwards from directory
            if ( defined($config_file) ) {
                if ( my ( $start_dir, $search_file ) =
                    ( $config_file =~ m{^(.*)\.\.\./(.*)$} ) )
                {
                    $start_dir = '.' if !$start_dir;
                    $start_dir = Cwd::realpath($start_dir);
                    my $found_file =
                      find_file_upwards( $start_dir, $search_file );
                    if ( defined($found_file) ) {
                        $config_file = $found_file;
                    }
                }
            }
            if ( !-e $config_file ) {
                Die(
                    "cannot find file given with -pro=$config_file: $OS_ERROR\n"
                );
            }
        }
        elsif ( $i =~ /^-(pro|profile)=?$/ ) {
            Die("usage: -pro=filename or --profile=filename, no spaces\n");
        }
        elsif ( $i =~ /^-(?: help | [ h \? ] )$/xi ) {
            usage();
            Exit(0);
        }
        elsif ( $i =~ /^-(version|v)$/ ) {
            show_version();
            Exit(0);
        }
        elsif ( $i =~ /^-(dump-defaults|ddf)$/ ) {
            dump_defaults( @{$rdefaults} );
            Exit(0);
        }
        elsif ( $i =~ /^-(dump-integer-option-range|dior)$/ ) {
            dump_integer_option_range($rinteger_option_range);
            Exit(0);
        }
        elsif ( $i =~ /^-(dump-long-names|dln)$/ ) {
            dump_long_names( @{$roption_string} );
            Exit(0);
        }
        elsif ( $i =~ /^-(dump-short-names|dsn)$/ ) {
            dump_short_names($rexpansion);
            Exit(0);
        }
        elsif ( $i =~ /^-(dump-token-types|dtt)$/ ) {
            Perl::Tidy::Tokenizer->dump_token_types(*STDOUT);
            Exit(0);
        }
        else {
            ## no more special cases
        }
    }

    # The above commands processed before disambiguation and then Exited.  So
    # we need to check below to see if the user entered something like
    # '-dump-t' or '-he'. This will slip past here and not get processed.
    my %early_exit_commands = (
        'help'                      => 'h',
        'version'                   => 'v',
        'dump-defaults'             => 'ddf',
        'dump-integer-option-range' => 'dior',
        'dump-long-names'           => 'dln',
        'dump-short-names'          => 'dsn',
        'dump-token-types'          => 'dtt',
    );

    if ( $saw_dump_profile && $saw_ignore_profile ) {
        Warn("No profile to dump because of -npro\n");
        Exit(1);
    }

    #----------------------------------------
    # read any .perltidyrc configuration file
    #----------------------------------------
    if ( !$saw_ignore_profile ) {

        # resolve possible conflict between $perltidyrc_stream passed
        # as call parameter to perltidy and -pro=filename on command
        # line.
        if ($perltidyrc_stream) {
            if ( defined($config_file) ) {
                Warn(<<EOM);
 Conflict: a perltidyrc configuration file was specified both as this
 perltidy call parameter: $perltidyrc_stream
 and with this -profile=$config_file.
 Using -profile=$config_file.
EOM
            }
            else {
                $config_file = $perltidyrc_stream;
            }
        }

        # look for a config file if we don't have one yet
        my $rconfig_file_chatter;
        ${$rconfig_file_chatter} = EMPTY_STRING;
        if ( !defined($config_file) ) {
            $config_file =
              find_config_file( $is_Windows, $Windows_type,
                $rconfig_file_chatter, $rpending_complaint );
        }

        # open any config file
        my $rconfig_string;
        if ( defined($config_file) ) {
            $rconfig_string = stream_slurp($config_file);
            if ( !defined($rconfig_string) ) {
                Die(
"exiting because profile '$config_file' could not be opened\n"
                );
            }
            filter_unknown_options(
                $rconfig_string, $roption_category,
                $rexpansion,     $rconfig_file_chatter
            );
        }
        if ($saw_dump_profile) {
            dump_config_file( $rconfig_string, $config_file,
                $rconfig_file_chatter );
            Exit(0);
        }

        if ( defined($rconfig_string) ) {

            my ( $rconfig_list, $death_message ) =
              read_config_file( $rconfig_string, $config_file, $rexpansion );
            Die($death_message) if ($death_message);

            # process any .perltidyrc parameters right now so we can
            # localize errors
            if ( @{$rconfig_list} ) {
                local @ARGV = @{$rconfig_list};

                expand_command_abbreviations( $rexpansion, \@raw_options,
                    $config_file );

                if ( !GetOptions( \%Opts, @{$roption_string} ) ) {
                    Die(
"Error in this config file: $config_file  \nUse -npro to ignore this file, -dpro to dump it, -h for help'\n"
                    );
                }

                # Anything left in this local @ARGV is an error and must be
                # invalid bare words from the configuration file.  We cannot
                # check this earlier because bare words may have been valid
                # values for parameters.  We had to wait for GetOptions to have
                # a look at @ARGV.
                if (@ARGV) {
                    my $count = @ARGV;
                    my $str   = EMPTY_STRING;
                    foreach my $param (@ARGV) {
                        if ( length($str) < 70 ) {
                            if ($str) { $str .= ', ' }
                            $str .= "'$param'";
                        }
                        else {
                            $str .= ", ...";
                            last;
                        }
                    }
                    Die(<<EOM);
There are $count unrecognized values in the configuration file '$config_file':
$str
Use leading dashes for parameters.  Use -npro to ignore this file.
EOM
                }

                # Undo any options which cause premature exit.  They are not
                # appropriate for a config file, and it could be hard to
                # diagnose the cause of the premature exit.

                # These are options include dump switches of the form
                # '--dump-xxx-xxx!'.
                my @dump_commands =
                  grep { /^(dump-.*)!$/ } @{$roption_string};
                foreach (@dump_commands) { s/!$// }

                # Here is a current list of these @dump_commands:
                #  dump-block-summary
                #  dump-cuddled-block-list
                #  dump-defaults
                #  dump-integer-option-range
                #  dump-long-names
                #  dump-mismatched-args
                #  dump-mismatched-returns
                #  dump-mixed-call-parens
                #  dump-options
                #  dump-profile
                #  dump-short-names
                #  dump-token-types
                #  dump-unusual-variables
                #  dump-want-left-space
                #  dump-want-right-space

                # The following two dump configuration parameters which
                # take =i or =s would still be allowed:
                #  dump-block-minimum-lines',        'dbl',   '=i' );
                #  dump-block-types',                'dbt',   '=s' );

                foreach my $cmd (
                    @dump_commands,
                    qw{
                    help
                    stylesheet
                    version
                    }
                  )
                {
                    if ( defined( $Opts{$cmd} ) ) {
                        delete $Opts{$cmd};
                        Warn("ignoring --$cmd in config file: $config_file\n");
                    }
                }
            }
        }
    }

    #----------------------------------------
    # now process the command line parameters
    #----------------------------------------
    expand_command_abbreviations( $rexpansion, \@raw_options, $config_file );

    local $SIG{'__WARN__'} = sub { Warn( $_[0] ) };
    if ( !GetOptions( \%Opts, @{$roption_string} ) ) {
        Die("Error on command line; for help try 'perltidy -h'\n");
    }

    # Catch ambiguous entries which should have exited above (c333)
    foreach my $long_name ( keys %early_exit_commands ) {
        if ( $Opts{$long_name} ) {
            my $short_name = $early_exit_commands{$long_name};
            Die(<<EOM);
Ambiguous entry; please enter '--$long_name' or '-$short_name'
EOM
        }
    }

    # reset Getopt::Long configuration back to its previous value
    if ( defined($glc) ) {
        my $ok = eval { Getopt::Long::Configure($glc); 1 };
        if ( !$ok && DEVEL_MODE ) {
            Fault("Could not reset Getopt::Long configuration: $EVAL_ERROR\n");
        }
    }

    return ( \%Opts, $config_file, \@raw_options, $roption_string,
        $rexpansion, $roption_category, $roption_range,
        $rinteger_option_range );
} ## end sub _process_command_line

sub make_grep_alias_string {

    my ($rOpts) = @_;

    # pre-process the --grep-alias-list parameter

    # Defaults: list operators in List::Util
    # Possible future additions:  pairfirst pairgrep pairmap
    my $default_string = join SPACE,
      qw( all any first none notall reduce reductions );

    # make a hash of any excluded words
    my %is_excluded_word;
    my $exclude_string = $rOpts->{'grep-alias-exclusion-list'};
    if ($exclude_string) {
        $exclude_string =~ s/,/ /g;    # allow commas
        $exclude_string =~ s/^\s+//;
        $exclude_string =~ s/\s+$//;
        my @q = split /\s+/, $exclude_string;
        @is_excluded_word{@q} = (1) x scalar(@q);
    }

    # The special option -gaxl='*' removes all defaults
    if ( $is_excluded_word{'*'} ) { $default_string = EMPTY_STRING }

    # combine the defaults and any input list
    my $input_string = $rOpts->{'grep-alias-list'};
    if ($input_string) { $input_string .= SPACE . $default_string }
    else               { $input_string = $default_string }

    # Now make the final list of unique grep alias words
    $input_string =~ s/,/ /g;    # allow commas
    $input_string =~ s/^\s+//;
    $input_string =~ s/\s+$//;
    my @word_list = split /\s+/, $input_string;
    my @filtered_word_list;
    my %seen;

    foreach my $word (@word_list) {
        if ($word) {
            if ( $word !~ /^\w[\w\d]*$/ ) {
                Warn(
                    "unexpected word in --grep-alias-list: '$word' - ignoring\n"
                );
            }
            if ( !$seen{$word} && !$is_excluded_word{$word} ) {
                $seen{$word}++;
                push @filtered_word_list, $word;
            }
        }
    }
    my $joined_words = join SPACE, @filtered_word_list;
    $rOpts->{'grep-alias-list'} = $joined_words;
    return;
} ## end sub make_grep_alias_string

sub cleanup_word_list {

    my ( $rOpts, $option_name, $rforced_words ) = @_;

    # Clean up the list of words in a user option to simplify use by
    # later routines (delete repeats, replace commas with single space,
    # remove non-words)

    # Given:
    #   $rOpts - the global option hash
    #   $option_name - hash key of this option
    #   $rforced_words - ref to list of any words to be added

    # Returns:
    #   \%seen - hash of the final list of words

    my %seen;
    my @input_list;

    my $input_string = $rOpts->{$option_name};
    if ( defined($input_string) && length($input_string) ) {
        $input_string =~ s/,/ /g;    # allow commas
        $input_string =~ s/^\s+//;
        $input_string =~ s/\s+$//;
        @input_list = split /\s+/, $input_string;
    }

    if ($rforced_words) {
        push @input_list, @{$rforced_words};
    }

    my @filtered_word_list;
    foreach my $word (@input_list) {
        if ($word) {

            # look for obviously bad words
            if ( $word =~ /^\d/ || $word !~ /^\w[\w\d]*$/ ) {
                Warn("unexpected '$option_name' word '$word' - ignoring\n");
            }
            if ( !$seen{$word} ) {
                $seen{$word}++;
                push @filtered_word_list, $word;
            }
        }
    }
    $rOpts->{$option_name} = join SPACE, @filtered_word_list;
    return \%seen;
} ## end sub cleanup_word_list

sub check_options {

    my ( $self, $num_files, $rinteger_option_range ) = @_;

    # Check options at a high level. Note that other modules have their
    # own sub 'check_options' for lower level checking.

    # Input parameters:
    #  $num_files = the number of files to be processed in this call to
    #     perltidy, needed for error checks.
    #  $rinteger_option-range = hash with valid ranges of parameters which
    #     take an integer

    my $rOpts = $self->[_rOpts_];

    #------------------------------------------------------------
    # check and handle any interactions among the basic options..
    #------------------------------------------------------------

    # Since perltidy only encodes in utf8, problems can occur if we let it
    # decode anything else.  See discussions for issue git #83.
    my $encoding = $rOpts->{'character-encoding'};
    if ( $encoding !~ /^\s*(?:guess|none|utf8|utf-8)\s*$/i ) {
        Die(<<EOM);
--character-encoding = '$encoding' is not allowed; the options are: 'none', 'guess', 'utf8'
EOM
    }

    my $integer_range_check = $rOpts->{'integer-range-check'};
    if (   !defined($integer_range_check)
        || $integer_range_check < 0
        || $integer_range_check > 3 )
    {
        $integer_range_check = 2;
    }

    # Check for integer values out of bounds as follows:
    #  $integer_range_check=
    #    0 => skip check completely (for stress-testing perltidy only)
    #    1 => quietly reset bad values to defaults
    #    2 => issue warning and reset bad values defaults [DEFAULT]
    #    3 => stop if any values are out of bounds
    if ($integer_range_check) {
        my $Error_message;
        foreach my $opt ( keys %{$rinteger_option_range} ) {
            my $range = $rinteger_option_range->{$opt};
            next unless defined($range);
            my ( $min, $max, $default ) = @{$range};

            my $val = $rOpts->{$opt};
            if ( defined($min) && defined($val) && $val < $min ) {
                $Error_message .= "--$opt=$val but should be >= $min";
                if ( $integer_range_check < 3 ) {
                    $rOpts->{$opt} = $default;
                    my $def = defined($default) ? $default : 'undef';
                    $Error_message .= "; using default $def";
                }
                $Error_message .= "\n";
            }
            if ( defined($max) && defined($val) && $val > $max ) {
                $Error_message .= "--$opt=$val but should be <= $max";
                if ( $integer_range_check < 3 ) {
                    $rOpts->{$opt} = $default;
                    my $def = defined($default) ? $default : 'undef';
                    $Error_message .= "; using default $def";
                }
                $Error_message .= "\n";
            }
        }
        if ($Error_message) {
            if ( $integer_range_check == 1 ) {
                ## no warning
            }
            elsif ( $integer_range_check == 2 ) {
                Warn($Error_message);
            }
            else {
                Die($Error_message);
            }
        }
    }

    # Note that -vt, -vtc, and -cti are abbreviations. But under
    # msdos, an unquoted input parameter like vtc=1 will be
    # seen as 2 parameters, vtc and 1, so the abbreviations
    # won't be seen.  Therefore, we will catch them here if
    # they get through.
    if ( defined( $rOpts->{'vertical-tightness'} ) ) {
        my $vt = $rOpts->{'vertical-tightness'};
        $rOpts->{'paren-vertical-tightness'}          = $vt;
        $rOpts->{'square-bracket-vertical-tightness'} = $vt;
        $rOpts->{'brace-vertical-tightness'}          = $vt;
    }

    if ( defined( $rOpts->{'vertical-tightness-closing'} ) ) {
        my $vtc = $rOpts->{'vertical-tightness-closing'};
        $rOpts->{'paren-vertical-tightness-closing'}          = $vtc;
        $rOpts->{'square-bracket-vertical-tightness-closing'} = $vtc;
        $rOpts->{'brace-vertical-tightness-closing'}          = $vtc;
    }

    if ( defined( $rOpts->{'closing-token-indentation'} ) ) {
        my $cti = $rOpts->{'closing-token-indentation'};
        $rOpts->{'closing-square-bracket-indentation'} = $cti;
        $rOpts->{'closing-brace-indentation'}          = $cti;
        $rOpts->{'closing-paren-indentation'}          = $cti;
    }

    # Syntax checking is no longer supported due to concerns about executing
    # code in BEGIN blocks.  The flag is still accepted for backwards
    # compatibility but is ignored if set.
    $rOpts->{'check-syntax'} = 0;

    my $check_blank_count = sub {
        my ( $key, $abbrev ) = @_;
        if ( $rOpts->{$key} ) {
            if ( $rOpts->{$key} < 0 ) {
                $rOpts->{$key} = 0;
                Warn("negative value of $abbrev, setting 0\n");
            }
            if ( $rOpts->{$key} > 100 ) {
                Warn("unreasonably large value of $abbrev, reducing\n");
                $rOpts->{$key} = 100;
            }
        }
        return;
    }; ## end $check_blank_count = sub

    # check for reasonable number of blank lines and fix to avoid problems
    $check_blank_count->( 'blank-lines-before-subs',          '-blbs' );
    $check_blank_count->( 'blank-lines-before-packages',      '-blbp' );
    $check_blank_count->( 'blank-lines-after-block-opening',  '-blao' );
    $check_blank_count->( 'blank-lines-before-block-closing', '-blbc' );

    # setting a non-negative logfile gap causes logfile to be saved
    if ( defined( $rOpts->{'logfile-gap'} ) && $rOpts->{'logfile-gap'} >= 0 ) {
        $rOpts->{'logfile'} = 1;
    }

    # set short-cut flag when only indentation is to be done.
    # Note that the user may or may not have already set the
    # indent-only flag.
    if (   !$rOpts->{'add-whitespace'}
        && !$rOpts->{'delete-old-whitespace'}
        && !$rOpts->{'add-newlines'}
        && !$rOpts->{'delete-old-newlines'} )
    {
        $rOpts->{'indent-only'} = 1;
    }

    # -isbc implies -ibc
    if ( $rOpts->{'indent-spaced-block-comments'} ) {
        $rOpts->{'indent-block-comments'} = 1;
    }

    # -bar cannot be used with -bl or -bli; arbitrarily keep -bar
    if ( $rOpts->{'opening-brace-always-on-right'} ) {

        if ( $rOpts->{'opening-brace-on-new-line'} ) {
            Warn(<<EOM);
 Conflict: you specified both 'opening-brace-always-on-right' (-bar) and
  'opening-brace-on-new-line' (-bl).  Ignoring -bl.
EOM
            $rOpts->{'opening-brace-on-new-line'} = 0;
        }
        if ( $rOpts->{'brace-left-and-indent'} ) {
            Warn(<<EOM);
 Conflict: you specified both 'opening-brace-always-on-right' (-bar) and
  '--brace-left-and-indent' (-bli).  Ignoring -bli.
EOM
            $rOpts->{'brace-left-and-indent'} = 0;
        }
    }

    # it simplifies things if -bl is 0 rather than undefined
    if ( !defined( $rOpts->{'opening-brace-on-new-line'} ) ) {
        $rOpts->{'opening-brace-on-new-line'} = 0;
    }

    if ( $rOpts->{'entab-leading-whitespace'} ) {
        if ( $rOpts->{'entab-leading-whitespace'} < 0 ) {
            Warn("-et=n must use a positive integer; ignoring -et\n");
            $rOpts->{'entab-leading-whitespace'} = undef;
        }

        # entab leading whitespace has priority over the older 'tabs' option
        if ( $rOpts->{'tabs'} ) {

            # The following warning could be added but would annoy a lot of
            # users who have a perltidyrc with both -t and -et=n.  So instead
            # there is a note in the manual that -et overrides -t.
            ##Warn("-tabs and -et=n conflict; ignoring -tabs\n");
            $rOpts->{'tabs'} = 0;
        }
    }

    # set a default tabsize to be used in guessing the starting indentation
    # level if and only if this run does not use tabs and the old code does
    # use tabs
    if ( $rOpts->{'default-tabsize'} ) {
        if ( $rOpts->{'default-tabsize'} < 0 ) {
            Warn("negative value of -dt, setting 0\n");
            $rOpts->{'default-tabsize'} = 0;
        }
        if ( $rOpts->{'default-tabsize'} > 20 ) {
            Warn("unreasonably large value of -dt, reducing\n");
            $rOpts->{'default-tabsize'} = 20;
        }
    }
    else {
        $rOpts->{'default-tabsize'} = 8;
    }

    # Check and clean up any sub-alias-list
    if ( defined( $rOpts->{'sub-alias-list'} )
        && length( $rOpts->{'sub-alias-list'} ) )
    {
        my @forced_words;

        # include 'sub' for convenience if this option is used
        push @forced_words, 'sub';

        cleanup_word_list( $rOpts, 'sub-alias-list', \@forced_words );
    }

    make_grep_alias_string($rOpts);

    # Turn on fuzzy-line-length unless this is an extrude run, as determined
    # by the -i and -ci settings. Otherwise blinkers can form (case b935).
    # This is an undocumented parameter used only for stress-testing when
    # --extrude is set.
    if ( !$rOpts->{'fuzzy-line-length'} ) {
        if (   $rOpts->{'maximum-line-length'} != 1
            || $rOpts->{'continuation-indentation'} != 0 )
        {
            $rOpts->{'fuzzy-line-length'} = 1;
        }
    }

    # Large values of -scl can cause convergence problems, issue c167
    if ( $rOpts->{'short-concatenation-item-length'} > 12 ) {
        $rOpts->{'short-concatenation-item-length'} = 12;
    }

    # The freeze-whitespace option is currently a derived option which has its
    # own key
    $rOpts->{'freeze-whitespace'} = !$rOpts->{'add-whitespace'}
      && !$rOpts->{'delete-old-whitespace'};

    # Turn off certain options if whitespace is frozen
    # Note: vertical alignment will be automatically shut off
    if ( $rOpts->{'freeze-whitespace'} ) {
        $rOpts->{'logical-padding'} = 0;
    }

    # Define the default line ending, before any -ple option is applied
    $self->[_line_separator_default_] = get_line_separator_default($rOpts);

    $self->[_line_tidy_begin_] = undef;
    $self->[_line_tidy_end_]   = undef;
    my $line_range_tidy = $rOpts->{'line-range-tidy'};
    if ($line_range_tidy) {

        if ( $num_files > 1 ) {
            Die(<<EOM);
--line-range-tidy expects no more than 1 filename in the arg list but saw $num_files filenames
EOM
        }

        $line_range_tidy =~ s/\s+//g;
        if ( $line_range_tidy =~ /^(\d+):(\d+)?$/ ) {
            my $n1 = $1;
            my $n2 = $2;
            if ( $n1 < 1 ) {
                Die(<<EOM);
--line-range-tidy=n1:n2 expects starting line number n1>=1 but n1=$n1
EOM
            }
            if ( defined($n2) && $n2 < $n1 ) {
                Die(<<EOM);
--line-range-tidy=n1:n2 expects ending line number n2>=n1 but n1=$n1 and n2=$n2
EOM
            }
            $self->[_line_tidy_begin_] = $n1;
            $self->[_line_tidy_end_]   = $n2;
        }
        else {
            Die(
"unrecognized 'line-range-tidy'; expecting format '-lrt=n1:n2'\n"
            );
        }
    }

    return;
} ## end sub check_options

sub find_file_upwards {

    my ( $search_dir, $search_file ) = @_;

    # This implements the ... upward search for a file

    $search_dir  =~ s{/+$}{};
    $search_file =~ s{^/+}{};

    while (1) {
        my $try_path = "$search_dir/$search_file";
        if ( -f $try_path ) {
            return $try_path;
        }
        elsif ( $search_dir eq '/' ) {
            return;
        }
        else {
            $search_dir = dirname($search_dir);
        }
    } ## end while (1)

    # This return is for Perl-Critic.
    # We shouldn't get out of the while loop without a return
    return;
} ## end sub find_file_upwards

sub expand_command_abbreviations {

    # go through @ARGV and expand any abbreviations
    # note that @ARGV has been localized

    my ( $rexpansion, $rraw_options, $config_file ) = @_;

    # set a pass limit to prevent an infinite loop;
    # 10 should be plenty, but it may be increased to allow deeply
    # nested expansions.
    my $max_passes = 10;

    # keep looping until all expansions have been converted into actual
    # dash parameters..
    foreach my $pass_count ( 0 .. $max_passes ) {
        my @new_argv     = ();
        my $abbrev_count = 0;

        # loop over each item in @ARGV..
        foreach my $word (@ARGV) {

            # convert any leading 'no-' to just 'no'
            if ( $word =~ /^(-[-]?no)-(.*)/ ) { $word = $1 . $2 }

            # if it is a dash flag (instead of a file name)..
            if ( $word =~ /^-[-]?([\w\-]+)(.*)/ ) {

                my $abr   = $1;
                my $flags = $2;

                # save the raw input for debug output in case of circular refs
                if ( $pass_count == 0 ) {
                    push( @{$rraw_options}, $word );
                }

                # recombine abbreviation and flag, if necessary,
                # to allow abbreviations with arguments such as '-vt=1'
                if ( $rexpansion->{ $abr . $flags } ) {
                    $abr   = $abr . $flags;
                    $flags = EMPTY_STRING;
                }

                # if we see this dash item in the expansion hash..
                if ( $rexpansion->{$abr} ) {
                    $abbrev_count++;

                    # stuff all of the words that it expands to into the
                    # new arg list for the next pass
                    foreach my $abbrev ( @{ $rexpansion->{$abr} } ) {
                        next unless $abbrev;    # for safety; shouldn't happen
                        push( @new_argv, '--' . $abbrev . $flags );
                    }
                }

                # not in expansion hash, must be actual long name
                else {
                    push( @new_argv, $word );
                }
            }

            # not a dash item, so just save it for the next pass
            else {
                push( @new_argv, $word );
            }
        } ## end of this pass

        # update parameter list @ARGV to the new one
        @ARGV = @new_argv;
        last if ( !$abbrev_count );

        # make sure we are not in an infinite loop
        if ( $pass_count == $max_passes ) {
            local $LIST_SEPARATOR = ')(';
            Warn(<<EOM);
I'm tired. We seem to be in an infinite loop trying to expand aliases.
Here are the raw options;
(rraw_options)
EOM
            my $num = @new_argv;
            if ( $num < 50 ) {
                Warn(<<EOM);
After $max_passes passes here is ARGV
(@new_argv)
EOM
            }
            else {
                Warn(<<EOM);
After $max_passes passes ARGV has $num entries
EOM
            }

            if ( defined($config_file) ) {
                Die(<<"DIE");
Please check your configuration file $config_file for circular-references.
To deactivate it, use -npro.
DIE
            }
            else {
                Die(<<'DIE');
Program bug - circular-references in the %expansion hash, probably due to
a recent program change.
DIE
            }
        } ## end of check for circular references
    } ## end of loop over all passes
    return;
} ## end sub expand_command_abbreviations

# Debug routine -- this will dump the expansion hash
sub dump_short_names {
    my $rexpansion = shift;
    print {*STDOUT} <<EOM;
List of short names.  This list shows how all abbreviations are
translated into other abbreviations and, eventually, into long names.
New abbreviations may be defined in a .perltidyrc file.
For a list of all long names, use perltidy --dump-long-names (-dln).
--------------------------------------------------------------------------
EOM
    foreach my $abbrev ( sort keys %{$rexpansion} ) {
        my @list = @{ $rexpansion->{$abbrev} };
        print {*STDOUT} "$abbrev --> @list\n";
    }
    return;
} ## end sub dump_short_names

sub check_vms_filename {

    # given a valid filename (the perltidy input file)
    # create a modified filename and separator character
    # suitable for VMS.
    #
    # Contributed by Michael Cartmell
    #
    my $filename = shift;
    my ( $base, $path ) = fileparse($filename);

    # remove explicit ; version
    $base =~ s/;-?\d*$//

      # remove explicit . version ie two dots in filename NB ^ escapes a dot
      or $base =~ s{(          # begin capture $1
                  (?:^|[^^])\. # match a dot not preceded by a caret
                  (?:          # followed by nothing
                    |          # or
                    .*[^^]     # anything ending in a non caret
                  )
                )              # end capture $1
                \.-?\d*$       # match . version number
              }{$1}x;

    # normalize filename, if there are no unescaped dots then append one
    $base .= '.' unless ( $base =~ /(?:^|[^^])\./ );

    # if we don't already have an extension then we just append the extension
    my $separator = ( $base =~ /\.$/ ) ? EMPTY_STRING : "_";
    return ( $path . $base, $separator );
} ## end sub check_vms_filename

sub Win_OS_Type {

    my $rpending_complaint = shift;

    # Returns a string that determines what MS OS we are on.
    # Returns win32s,95,98,Me,NT3.51,NT4,2000,XP/.Net,Win2003
    # Returns blank string if not an MS system.
    # Original code contributed by: Yves Orton
    # We need to know this to decide where to look for config files

    # TODO: are these more standard names?
    # Win32s Win95 Win98 WinMe WinNT3.51 WinNT4 Win2000 WinXP/.Net Win2003

    my $os = EMPTY_STRING;
    return $os unless ( $OSNAME =~ /win32|dos/i );    # is it a MS box?

    # Systems built from Perl source may not have Win32.pm
    # But probably have Win32::GetOSVersion() anyway so the
    # following line is not 'required':
    # return $os unless eval('require Win32');

    # Use the standard API call to determine the version
    my ( $undef, $major, $minor, $build, $id );
    my $ok = eval {
        ( $undef, $major, $minor, $build, $id ) = Win32::GetOSVersion();
        1;
    };
    if ( !$ok && DEVEL_MODE ) {
        Fault("Could not cal Win32::GetOSVersion(): $EVAL_ERROR\n");
    }

    #
    #    NAME                   ID   MAJOR  MINOR
    #    Windows NT 4           2      4       0
    #    Windows 2000           2      5       0
    #    Windows XP             2      5       1
    #    Windows Server 2003    2      5       2

    return "win32s" unless $id;    # If id==0 then its a win32s box.
    $os = {                        # Magic numbers from MSDN
                                   # documentation of GetOSVersion
        1 => {
            0  => "95",
            10 => "98",
            90 => "Me",
        },
        2 => {
            0  => "2000",      # or NT 4, see below
            1  => "XP/.Net",
            2  => "Win2003",
            51 => "NT3.51",
        },
    }->{$id}->{$minor};

    # If $os is undefined, the above code is out of date.  Suggested updates
    # are welcome.
    if ( !defined($os) ) {
        $os = EMPTY_STRING;

        # Deactivated this message 20180322 because it was needlessly
        # causing some test scripts to fail.  Need help from someone
        # with expertise in Windows to decide what is possible with windows.
        ${$rpending_complaint} .= <<EOS if (0);
Error trying to discover Win_OS_Type: $id:$major:$minor Has no name of record!
We won't be able to look for a system-wide config file.
EOS
    }

    # Unfortunately the logic used for the various versions isn't so clever..
    # so we have to handle an outside case.
    return ( $os eq "2000" && $major != 5 ) ? "NT4" : $os;
} ## end sub Win_OS_Type

sub look_for_Windows {

    # determine Windows sub-type and location of
    # system-wide configuration files
    my $rpending_complaint = shift;
    my $is_Windows         = ( $OSNAME =~ /win32|dos/i );
    my $Windows_type;
    $Windows_type = Win_OS_Type($rpending_complaint) if $is_Windows;
    return ( $is_Windows, $Windows_type );
} ## end sub look_for_Windows

sub find_config_file {

    # look for a .perltidyrc configuration file
    # For Windows also look for a file named perltidy.ini
    my ( $is_Windows, $Windows_type, $rconfig_file_chatter,
        $rpending_complaint )
      = @_;

    ${$rconfig_file_chatter} .= "# Config file search...system reported as:";
    if ($is_Windows) {
        ${$rconfig_file_chatter} .= "Windows $Windows_type\n";
    }
    else {
        ${$rconfig_file_chatter} .= " $OSNAME\n";
    }

    # sub to check file existence and record all tests
    my $exists_config_file = sub {
        my $config_file = shift;
        return 0 unless defined($config_file);
        ${$rconfig_file_chatter} .= "# Testing: $config_file\n";
        return -f $config_file;
    }; ## end $exists_config_file = sub

    # Sub to search upward for config file
    my $resolve_config_file = sub {

        # resolve <dir>/.../<file>, meaning look upwards from directory
        my $config_file = shift;
        if ( defined($config_file) ) {
            if ( my ( $start_dir, $search_file ) =
                ( $config_file =~ m{^(.*)\.\.\./(.*)$} ) )
            {
                ${$rconfig_file_chatter} .=
                  "# Searching Upward: $config_file\n";
                $start_dir = '.' if !$start_dir;
                $start_dir = Cwd::realpath($start_dir);
                my $found_file = find_file_upwards( $start_dir, $search_file );
                if ( defined($found_file) ) {
                    $config_file = $found_file;
                    ${$rconfig_file_chatter} .= "# Found: $config_file\n";
                }
            }
        }
        return $config_file;
    }; ## end $resolve_config_file = sub

    my $config_file;

    # look in current directory first
    $config_file = ".perltidyrc";
    return $config_file if $exists_config_file->($config_file);
    if ($is_Windows) {
        $config_file = "perltidy.ini";
        return $config_file if $exists_config_file->($config_file);
    }

    # Default environment vars.
    my @envs = qw( PERLTIDY HOME );

    # Check the NT/2k/XP locations, first a local machine def, then a
    # network def
    push @envs, qw( USERPROFILE HOMESHARE ) if $OSNAME =~ /win32/i;

    # Now go through the environment ...
    foreach my $var (@envs) {
        ${$rconfig_file_chatter} .= "# Examining: \$ENV{$var}";
        if ( defined( $ENV{$var} ) ) {
            ${$rconfig_file_chatter} .= " = $ENV{$var}\n";

            # test ENV{ PERLTIDY } as file:
            if ( $var eq 'PERLTIDY' ) {
                $config_file = "$ENV{$var}";
                $config_file = $resolve_config_file->($config_file);
                return $config_file if $exists_config_file->($config_file);
            }

            # test ENV as directory:
            $config_file = File::Spec->catfile( $ENV{$var}, ".perltidyrc" );
            $config_file = $resolve_config_file->($config_file);
            return $config_file if $exists_config_file->($config_file);

            if ($is_Windows) {
                $config_file =
                  File::Spec->catfile( $ENV{$var}, "perltidy.ini" );
                $config_file = $resolve_config_file->($config_file);
                return $config_file if $exists_config_file->($config_file);
            }
        }
        else {
            ${$rconfig_file_chatter} .= "\n";
        }
    }

    # then look for a system-wide definition
    # where to look varies with OS
    if ($is_Windows) {

        if ($Windows_type) {
            my ( $os_uu, $system, $allusers ) =
              Win_Config_Locs( $rpending_complaint, $Windows_type );

            # Check All Users directory, if there is one.
            # i.e. C:\Documents and Settings\User\perltidy.ini
            if ($allusers) {

                $config_file = File::Spec->catfile( $allusers, ".perltidyrc" );
                return $config_file if $exists_config_file->($config_file);

                $config_file = File::Spec->catfile( $allusers, "perltidy.ini" );
                return $config_file if $exists_config_file->($config_file);
            }

            # Check system directory.
            # retain old code in case someone has been able to create
            # a file with a leading period.
            $config_file = File::Spec->catfile( $system, ".perltidyrc" );
            return $config_file if $exists_config_file->($config_file);

            $config_file = File::Spec->catfile( $system, "perltidy.ini" );
            return $config_file if $exists_config_file->($config_file);
        }
    }

    # Place to add customization code for other systems
    elsif ( $OSNAME eq 'OS2' ) {
    }
    elsif ( $OSNAME eq 'MacOS' ) {
    }
    elsif ( $OSNAME eq 'VMS' ) {
    }

    # Assume some kind of Unix
    else {

        $config_file = "/usr/local/etc/perltidyrc";
        return $config_file if $exists_config_file->($config_file);

        $config_file = "/etc/perltidyrc";
        return $config_file if $exists_config_file->($config_file);
    }

    # Couldn't find a config file
    return;
} ## end sub find_config_file

sub Win_Config_Locs {

    # In scalar context returns the OS name (95 98 ME NT3.51 NT4 2000 XP),
    # or undef if its not a win32 OS.  In list context returns OS, System
    # Directory, and All Users Directory.  All Users will be empty on a
    # 9x/Me box.  Contributed by: Yves Orton.

    my ( $rpending_complaint, $os ) = @_;
    if ( !$os ) { $os = Win_OS_Type($rpending_complaint) }

    return unless $os;

    my $system   = EMPTY_STRING;
    my $allusers = EMPTY_STRING;

    if ( $os =~ /9[58]|Me/ ) {
        $system = "C:/Windows";
    }
    elsif ( $os =~ /NT|XP|200?/ ) {
        $system = ( $os =~ /XP/ ) ? "C:/Windows/" : "C:/WinNT/";
        $allusers =
          ( $os =~ /NT/ )
          ? "C:/WinNT/profiles/All Users/"
          : "C:/Documents and Settings/All Users/";
    }
    else {

        # This currently would only happen on a win32s computer.  I don't have
        # one to test, so I am unsure how to proceed.  Suggestions welcome!
        ${$rpending_complaint} .=
"I dont know a sensible place to look for config files on an $os system.\n";
        return;
    }
    return ( $os, $system, $allusers );
} ## end sub Win_Config_Locs

sub dump_config_file {
    my ( $rconfig_string, $config_file, $rconfig_file_chatter ) = @_;
    print {*STDOUT} "${$rconfig_file_chatter}";
    if ($rconfig_string) {
        my @lines = split /^/, ${$rconfig_string};
        print {*STDOUT} "# Dump of file: '$config_file'\n";
        foreach my $line (@lines) { print {*STDOUT} $line }
    }
    else {
        print {*STDOUT} "# ...no config file found\n";
    }
    return;
} ## end sub dump_config_file

sub filter_unknown_options {

    my (
        $rconfig_string, $roption_category,
        $rexpansion,     $rconfig_file_chatter
    ) = @_;

    # Look through the configuration file for lines beginning with '---' and
    # - remove the line if the option is unknown, or
    # - remove the extra dash if the option is known
    # See git #146 for discussion

    # Given:
    #   $rconfig_string = string ref to a .perltidyrc configuration file
    #   $roption_category = ref to hash with long_names as key
    #   $rexpansion = ref to hash with abbreviations as key
    #   $rconfig_file_chatter = messages displayed in --dump-profile
    #
    # Update:
    #   $rconfig_string and $rconfig_file_chatter

    # quick check to skip most files
    if ( ${$rconfig_string} !~ /^\s*---\w/m ) { return }

    my $new_config_string;
    my $change_notices = EMPTY_STRING;
    my @lines          = split /^/, ${$rconfig_string};
    foreach my $line (@lines) {
        chomp $line;

        # look for lines beginning with '---'
        if ( $line && $line =~ /^\s*---(\w[\w-]*)/ ) {
            my $word = $1;

            # first look for a long name or an abbreviation
            my $is_known = $roption_category->{$word} || $rexpansion->{$word};

            # then look for prefix 'no' or 'no-' on a long name
            if ( !$is_known && $word =~ s/^no-?// ) {
                $is_known = $roption_category->{$word};
            }

            if ( !$is_known ) {
                $change_notices .= "#  removing unknown option line $line\n";
                next;
            }
            else {
                $change_notices .= "#  accepting and fixing line $line\n";
                $line =~ s/-//;
            }
        }
        $new_config_string .= $line . "\n";
    }

    if ($change_notices) {
        ${$rconfig_file_chatter} .= "# Filter operations:\n" . $change_notices;
        ${$rconfig_string} = $new_config_string;
    }
    return;
} ## end sub filter_unknown_options

sub read_config_file {

    my ( $rconfig_string, $config_file, $rexpansion ) = @_;

    # Read and process the contents of a perltidyrc command file

    # Given:
    #   $rconfig_string = ref to the file as a string
    #   $config_file = name of the file, for error reporting
    #   $rexpansion = ref to hash of abbreviations; if this config file defines
    #                 any abbreviations they will be added to it

    # Return:
    #   \@config_list = ref to final parameters and values which will be
    #     placed in @ARGV for processing by GetOptions
    #   $death_message = error message returned if a fatal error occurs
    my @config_list = ();

    # remove side comments and join multiline quotes
    my ( $rline_hash, $death_message ) =
      strip_comments_and_join_quotes( $rconfig_string, $config_file );

    # file is bad if non-empty $death_message is returned
    if ($death_message) {
        return ( \@config_list, $death_message );
    }

    my $name = undef;
    my $opening_brace_line;
    foreach my $item ( @{$rline_hash} ) {
        my $line    = $item->{line};
        my $line_no = $item->{line_no};
        $line =~ s/^\s+//;
        $line =~ s/\s+$//;
        next unless ( length($line) );

        my $body = $line;

        # Look for complete or partial abbreviation definition of the form
        #     name { body }   or  name {   or    name { body
        # See rules in perltidy's perldoc page
        # Section: Other Controls - Creating a new abbreviation
        if ( $line =~ /^(?: (\w+) \s* \{ ) (.*)? $/x ) {
            ( $name, $body ) = ( $1, $2 );

            # Cannot start new abbreviation unless old abbreviation is complete
            last if ($opening_brace_line);

            $opening_brace_line = $line_no unless ( $body && $body =~ s/\}$// );

            # handle a new alias definition
            if ( $rexpansion->{$name} ) {
                local $LIST_SEPARATOR = ')(';
                my @names = sort keys %{$rexpansion};
                $death_message =
                    "Here is a list of all installed aliases\n(@names)\n"
                  . "Attempting to redefine alias ($name) in config file $config_file line $INPUT_LINE_NUMBER\n";
                last;
            }
            $rexpansion->{$name} = [];
        }

        # leading opening braces not allowed
        elsif ( $line =~ /^{/ ) {
            $opening_brace_line = undef;
            $death_message =
              "Unexpected '{' at line $line_no in config file '$config_file'\n";
            last;
        }

        # Look for abbreviation closing:    body }   or    }
        elsif ( $line =~ /^(.*)?\}$/ ) {
            $body = $1;
            if ($opening_brace_line) {
                $opening_brace_line = undef;
            }
            else {
                $death_message =
"Unexpected '}' at line $line_no in config file '$config_file'\n";
                last;
            }
        }
        else {
            # no abbreviations to untangle
        }

        # Now store any parameters
        if ($body) {

            my ( $rbody_parts, $msg ) = parse_args($body);
            if ($msg) {
                $death_message = <<EOM;
Error reading file '$config_file' at line number $line_no.
$msg
Please fix this line or use -npro to avoid reading this file
EOM
                last;
            }

            if ($name) {

                # remove leading dashes if this is an alias
                foreach ( @{$rbody_parts} ) { s/^\-+//; }
                push @{ $rexpansion->{$name} }, @{$rbody_parts};
            }
            else {
                push( @config_list, @{$rbody_parts} );
            }
        }
    }

    if ($opening_brace_line) {
        $death_message =
"Didn't see a '}' to match the '{' at line $opening_brace_line in config file '$config_file'\n";
    }
    return ( \@config_list, $death_message );
} ## end sub read_config_file

sub strip_comments_and_join_quotes {

    my ( $rconfig_string, $config_file ) = @_;

    # Tasks:
    # 1. Strip comments from .perltidyrc lines
    # 2. Join lines which are spanned by a quote

    # Given:
    #   $rconfig_string = the configuration file
    #   $config_file = filename, for error messages
    # Return:
    #   $rline_hash = hash with modified lines and their input numbers
    #   $msg = any error message; code will die on any message.

    # return variables
    my $msg        = EMPTY_STRING;
    my $rline_hash = [];

    # quote state variables
    my $quote_char          = EMPTY_STRING;
    my $quote_start_line    = EMPTY_STRING;
    my $quote_start_line_no = -1;
    my $in_string           = EMPTY_STRING;
    my $out_string          = EMPTY_STRING;

    my @lines   = split /^/, ${$rconfig_string};
    my $line_no = 0;

    # loop over lines
    foreach my $line (@lines) {
        $line_no++;
        $line =~ s/^\s+//;
        $line =~ s/\s+$//;
        next unless ( length($line) );

        if ( !$quote_char ) {

            # skip a full-line comment
            if ( substr( $line, 0, 1 ) eq '#' ) {
                next;
            }
            $in_string  = $line;
            $out_string = EMPTY_STRING;
        }
        else {

            # treat previous newline as a space
            $in_string = SPACE . $line;
        }

        # loop over string characters
        #  $in_string  = the input string
        #  $out_string = the output string
        #  $quote_char = quote character being sought
        while (1) {

            # accumulating characters not in quote
            if ( !$quote_char ) {

                if ( $in_string =~ /\G([\"\'])/gc ) {

                    # starting new quote..
                    $out_string .= $1;
                    $quote_char          = $1;
                    $quote_start_line_no = $line_no;
                    $quote_start_line    = $line;
                }
                elsif ( $in_string =~ /\G#/gc ) {

                    # A space is required before the # of a side comment
                    # This allows something like:
                    #    -sbcp=#
                    # Otherwise, it would have to be quoted:
                    #    -sbcp='#'
                    if ( !length($out_string) || $out_string =~ s/\s+$// ) {
                        last;
                    }
                    $out_string .= '#';
                }
                elsif ( $in_string =~ /\G([^\#\'\"]+)/gc ) {

                    # neither quote nor side comment
                    $out_string .= $1;
                }
                else {

                    # end of line
                    last;
                }
            }

            # looking for ending quote character
            else {
                if ( $in_string =~ /\G($quote_char)/gc ) {

                    # end of quote
                    $out_string .= $1;
                    $quote_char = EMPTY_STRING;
                }
                elsif ( $in_string =~ /\G([^$quote_char]+)/gc ) {

                    # accumulate quoted text
                    $out_string .= $1;
                }
                else {

                    # end of line
                    last;
                }
            }
        } ## end while (1)

        if ( !$quote_char ) {
            push @{$rline_hash},
              {
                line    => $out_string,
                line_no => $line_no,
              };
        }

    } ## end loop over lines

    if ($quote_char) {
        my $max_len = 80;
        if ( length($quote_start_line) > $max_len ) {
            $quote_start_line =
              substr( $quote_start_line, 0, $max_len - 3 ) . '...';
        }
        $msg = <<EOM;
Error: hit EOF reading file '$config_file' looking for end of quoted text
which started at line $quote_start_line_no with quote character <$quote_char>:
$quote_start_line
Please fix or use -npro to avoid reading this file
EOM
    }
    return ( $rline_hash, $msg );
} ## end sub strip_comments_and_join_quotes

sub parse_args {

    # Parse a command string containing multiple string with possible
    # quotes, into individual commands.  It might look like this, for example:
    #
    #    -wba=" + - "  -some-thing -wbb='. && ||'
    #
    # There is no need, at present, to handle escaped quote characters.
    # (They are not perltidy tokens, so needn't be in strings).

    my ($body)     = @_;
    my @body_parts = ();
    my $quote_char = EMPTY_STRING;
    my $part       = EMPTY_STRING;
    my $msg        = EMPTY_STRING;

    # Check for external call with undefined $body - added to fix
    # github issue Perl-Tidy-Sweetened issue #23
    if ( !defined($body) ) { $body = EMPTY_STRING }

    while (1) {

        # looking for ending quote character
        if ($quote_char) {
            if ( $body =~ /\G($quote_char)/gc ) {
                $quote_char = EMPTY_STRING;
            }
            elsif ( $body =~ /\G(.)/gc ) {
                $part .= $1;
            }

            # error..we reached the end without seeing the ending quote char
            else {
                if ( length($part) ) { push @body_parts, $part; }
                $msg = <<EOM;
Did not see ending quote character <$quote_char> in this text:
$body
EOM
                last;
            }
        }

        # accumulating characters and looking for start of a quoted string
        else {
            if ( $body =~ /\G([\"\'])/gc ) {
                $quote_char = $1;
            }
            elsif ( $body =~ /\G(\s+)/gc ) {
                if ( length($part) ) { push @body_parts, $part; }
                $part = EMPTY_STRING;
            }
            elsif ( $body =~ /\G(.)/gc ) {
                $part .= $1;
            }
            else {
                if ( length($part) ) { push @body_parts, $part; }
                last;
            }
        }
    } ## end while (1)
    return ( \@body_parts, $msg );
} ## end sub parse_args

sub dump_long_names {

    my @names = @_;
    print {*STDOUT} <<EOM;
# Command line long names (passed to GetOptions)
#--------------------------------------------------
# here is a summary of the Getopt codes:
# <none> does not take an argument
# =s takes a mandatory string
# :s takes an optional string
# =i takes a mandatory integer
# :i takes an optional integer
# ! does not take an argument and may be negated
#  i.e., -foo and -nofoo are allowed
# a double dash signals the end of the options list
#
#--------------------------------------------------
EOM

    foreach my $name ( sort @names ) { print {*STDOUT} "$name\n" }
    return;
} ## end sub dump_long_names

sub dump_integer_option_range {
    my ($rinteger_option_range) = @_;
    print {*STDOUT} "Option, min, max, default\n";
    foreach my $key ( sort keys %{$rinteger_option_range} ) {
        my ( $min, $max, $default ) = @{ $rinteger_option_range->{$key} };
        foreach ( $min, $max, $default ) {
            $_ = 'undef' unless defined($_);
        }
        print {*STDOUT} "$key, $min, $max, $default\n";
    }
    return;
} ## end sub dump_integer_option_range

sub dump_defaults {
    my @defaults = @_;
    print {*STDOUT} "Default command line options:\n";
    foreach my $line ( sort @defaults ) { print {*STDOUT} "$line\n" }
    return;
} ## end sub dump_defaults

sub readable_options {

    # return options for this run as a string which could be
    # put in a perltidyrc file
    my ( $rOpts, $roption_string ) = @_;
    my %Getopt_flags;
    my $rGetopt_flags    = \%Getopt_flags;
    my $readable_options = "# Final parameter set for this run.\n";
    $readable_options .=
      "# See utility 'perltidyrc_dump.pl' for nicer formatting.\n";
    foreach my $opt ( @{$roption_string} ) {
        my $flag = EMPTY_STRING;
        if ( $opt =~ /(.*)(!|=.*)$/ ) {
            $opt  = $1;
            $flag = $2;
        }
        if ( defined( $rOpts->{$opt} ) ) {
            $rGetopt_flags->{$opt} = $flag;
        }
    }
    foreach my $key ( sort keys %{$rOpts} ) {
        my $flag   = $rGetopt_flags->{$key};
        my $value  = $rOpts->{$key};
        my $prefix = '--';
        my $suffix = EMPTY_STRING;
        if ($flag) {
            if ( $flag =~ /^=/ ) {
                if ( $value !~ /^\d+$/ ) { $value = '"' . $value . '"' }
                $suffix = "=" . $value;
            }
            elsif ( $flag =~ /^!/ ) {
                $prefix .= "no" unless ($value);
            }
            else {

                # shouldn't happen
                $readable_options .=
                  "# ERROR in dump_options: unrecognized flag $flag for $key\n";
            }
        }
        $readable_options .= $prefix . $key . $suffix . "\n";
    }
    return $readable_options;
} ## end sub readable_options

sub show_version {
    print {*STDOUT} <<"EOM";
This is perltidy, v$VERSION

Copyright 2000-2025 by Steve Hancock

Perltidy is free software and may be copied under the terms of the GNU
General Public License, which is included in the distribution files.

Documentation can be found using 'man perltidy'
or at GitHub      https://perltidy.github.io/perltidy/
or at metacpan    https://metacpan.org/pod/distribution/Perl-Tidy/bin/perltidy
or at Sourceforge https://perltidy.sourceforge.net
EOM
    return;
} ## end sub show_version

sub usage {

    print {*STDOUT} <<EOF;
This is perltidy version $VERSION, a perl script indenter.  Usage:

    perltidy [ options ] file1 file2 file3 ...
            (output goes to file1.tdy, file2.tdy, file3.tdy, ...)
    perltidy [ options ] file1 -o outfile
    perltidy [ options ] file1 -st >outfile
    perltidy [ options ] <infile >outfile

Options have short and long forms. Short forms are shown; see
man pages for long forms.  Note: '=s' indicates a required string,
and '=n' indicates a required integer.

I/O control
 -h      show this help
 -o=file name of the output file (only if single input file)
 -oext=s change output extension from 'tdy' to s
 -opath=path  change path to be 'path' for output files
 -b      backup original to .bak and modify file in-place
 -bext=s change default backup extension from 'bak' to s
 -q      deactivate error messages (for running under editor)
 -w      include non-critical warning messages in the .ERR error output
 -log    save .LOG file, which has useful diagnostics
 -f      force perltidy to read a binary file
 -g      like -log but writes more detailed .LOG file, for debugging scripts
 -opt    write the set of options actually used to a .LOG file
 -npro   ignore .perltidyrc configuration command file
 -pro=file   read configuration commands from file instead of .perltidyrc
 -st     send output to standard output, STDOUT
 -se     send all error output to standard error output, STDERR
 -v      display version number to standard output and quit

Basic Options:
 -i=n    use n columns per indentation level (default n=4)
 -t      tabs: use one tab character per indentation level, not recommended
 -nt     no tabs: use n spaces per indentation level (default)
 -et=n   entab leading whitespace n spaces per tab; not recommended
 -io     "indent only": just do indentation, no other formatting.
 -sil=n  set starting indentation level to n;  use if auto detection fails
 -ole=s  specify output line ending (s=dos or win, mac, unix)
 -ple    keep output line endings same as input (input must be filename)

Whitespace Control
 -fws    freeze whitespace; this disables all whitespace changes
           and disables the following switches:
 -bt=n   sets brace tightness,  n= (0 = loose, 1=default, 2 = tight)
 -bbt    same as -bt but for code block braces; same as -bt if not given
 -bbvt   block braces vertically tight; use with -bl or -bli
 -bbvtl=s  make -bbvt to apply to selected list of block types
 -pt=n   paren tightness (n=0, 1 or 2)
 -sbt=n  square bracket tightness (n=0, 1, or 2)
 -bvt=n  brace vertical tightness,
         n=(0=open, 1=close unless multiple steps on a line, 2=always close)
 -pvt=n  paren vertical tightness (see -bvt for n)
 -sbvt=n square bracket vertical tightness (see -bvt for n)
 -bvtc=n closing brace vertical tightness:
         n=(0=open, 1=sometimes close, 2=always close)
 -pvtc=n closing paren vertical tightness, see -bvtc for n.
 -sbvtc=n closing square bracket vertical tightness, see -bvtc for n.
 -ci=n   sets continuation indentation=n,  default is n=2 spaces
 -lp     line up parentheses, brackets, and non-BLOCK braces
 -sfs    add space before semicolon in for( ; ; )
 -aws    allow perltidy to add whitespace (default)
 -dws    delete all old non-essential whitespace
 -icb    indent closing brace of a code block
 -cti=n  closing indentation of paren, square bracket, or non-block brace:
         n=0 none, =1 align with opening, =2 one full indentation level
 -icp    equivalent to -cti=2
 -wls=s  want space left of tokens in string; i.e. -nwls='+ - * /'
 -wrs=s  want space right of tokens in string;
 -sts    put space before terminal semicolon of a statement
 -sak=s  put space between keywords given in s and '(';
 -nsak=s no space between keywords in s and '('; i.e. -nsak='my our local'

Line Break Control
 -fnl    freeze newlines; this disables all line break changes
            and disables the following switches:
 -anl    add newlines;  ok to introduce new line breaks
 -bbs    add blank line before subs and packages
 -bbc    add blank line before block comments
 -bbb    add blank line between major blocks
 -kbl=n  keep old blank lines? 0=no, 1=some, 2=all
 -mbl=n  maximum consecutive blank lines to output (default=1)
 -ce     cuddled else; use this style: '} else {'
 -cb     cuddled blocks (other than 'if-elsif-else')
 -cbl=s  list of blocks to cuddled, default 'try-catch-finally'
 -dnl    delete old newlines (default)
 -l=n    maximum line length;  default n=80
 -bl     opening brace on new line
 -sbl    opening sub brace on new line.  value of -bl is used if not given.
 -bli    opening brace on new line and indented
 -bar    opening brace always on right, even for long clauses
 -vt=n   vertical tightness (requires -lp); n controls break after opening
         token: 0=never  1=no break if next line balanced   2=no break
 -vtc=n  vertical tightness of closing container; n controls if closing
         token starts new line: 0=always  1=not unless list  1=never
 -wba=s  want break after tokens in string; i.e. wba=': .'
 -wbb=s  want break before tokens in string
 -wn     weld nested: combines opening and closing tokens when both are adjacent
 -wnxl=s weld nested exclusion list: provides some control over the types of
         containers which can be welded

Following Old Breakpoints
 -kis    keep interior semicolons.  Allows multiple statements per line.
 -boc    break at old comma breaks: turns off all automatic list formatting
 -bol    break at old logical breakpoints: or, and, ||, && (default)
 -bom    break at old method call breakpoints: ->
 -bok    break at old list keyword breakpoints such as map, sort (default)
 -bot    break at old conditional (ternary ?:) operator breakpoints (default)
 -boa    break at old attribute breakpoints
 -cab=n  break at commas after a comma-arrow (=>):
         n=0 break at all commas after =>
         n=1 stable: break unless this breaks an existing one-line container
         n=2 break only if a one-line container cannot be formed
         n=3 do not treat commas after => specially at all

Comment controls
 -ibc    indent block comments (default)
 -isbc   indent spaced block comments; may indent unless no leading space
 -msc=n  minimum desired spaces to side comment, default 4
 -fpsc=n fix position for side comments; default 0;
 -csc    add or update closing side comments after closing BLOCK brace
 -dcsc   delete closing side comments created by a -csc command
 -cscp=s change closing side comment prefix to be other than '## end'
 -cscl=s change closing side comment to apply to selected list of blocks
 -csci=n minimum number of lines needed to apply a -csc tag, default n=6
 -csct=n maximum number of columns of appended text, default n=20
 -cscw   causes warning if old side comment is overwritten with -csc

 -sbc    use 'static block comments' identified by leading '##' (default)
 -sbcp=s change static block comment identifier to be other than '##'
 -osbc   outdent static block comments

 -ssc    use 'static side comments' identified by leading '##' (default)
 -sscp=s change static side comment identifier to be other than '##'

Delete selected text
 -dac    delete all comments AND pod
 -dbc    delete block comments
 -dsc    delete side comments
 -dp     delete pod

Send selected text to a '.TEE' file
 -tac    tee all comments AND pod
 -tbc    tee block comments
 -tsc    tee side comments
 -tp     tee pod

Outdenting
 -olq    outdent long quoted strings (default)
 -olc    outdent a long block comment line
 -ola    outdent statement labels
 -okw    outdent control keywords (redo, next, last, goto, return)
 -okwl=s specify alternative keywords for -okw command

Other controls
 -mft=n  maximum fields per table; default n=0 (no limit)
 -x      do not format lines before hash-bang line (i.e., for VMS)
 -asc    allows perltidy to add a ';' when missing (default)
 -dsm    allows perltidy to delete an unnecessary ';'  (default)

Combinations of other parameters
 -gnu     attempt to follow GNU Coding Standards as applied to perl
 -mangle  remove as many newlines as possible (but keep comments and pods)
 -extrude  insert as many newlines as possible

Dump and die, debugging
 -dop    dump options used in this run to standard output and quit
 -ddf    dump default options to standard output and quit
 -dsn    dump all option short names to standard output and quit
 -dln    dump option long names to standard output and quit
 -dpro   dump whatever configuration file is in effect to standard output
 -dtt    dump all token types to standard output and quit

HTML
 -html write an html file (see 'man perl2web' for many options)
       Note: when -html is used, no indentation or formatting are done.
       Hint: try perltidy -html -css=mystyle.css filename.pl
       and edit mystyle.css to change the appearance of filename.html.
       -nnn gives line numbers
       -pre only writes out <pre>..</pre> code section
       -toc places a table of contents to subs at the top (default)
       -pod passes pod text through pod2html (default)
       -frm write html as a frame (3 files)
       -text=s extra extension for table of contents if -frm, default='toc'
       -sext=s extra extension for file content if -frm, default='src'

A prefix of "n" negates short form toggle switches, and a prefix of "no"
negates the long forms.  For example, -nasc means don't add missing
semicolons.

If you are unable to see this entire text, try "perltidy -h | more"
For more detailed information, and additional options, try "man perltidy",
or see https://metacpan.org/pod/distribution/Perl-Tidy/bin/perltidy
EOF

    return;
} ## end sub usage

1;
 ####################################################################
#
# The Perl::Tidy::Formatter package adds indentation, whitespace, and
# line breaks to the token stream

# Usage Outline:
#
#   STEP 1: initialize or re-initialize Formatter with user options
#     Perl::Tidy::Formatter::check_options($rOpts);
#
#   STEP 2: crate a tokenizer for the source stream
#
#   STEP 3: create a formatter for the destination stream
#     my $formatter = Perl::Tidy::Formatter->new(
#         ...
#         sink_object        => $destination,
#         ...
#     );
#
#   STEP 4: process each input line (see sub Perl::Tidy::process_single_case)
#     while ( my $line = $tokenizer->get_line() ) {
#       $formatter->write_line($line);
#     }
#
#   STEP 4: finish formatting
#     $formatter->finish_formatting($severe_error);
#
#####################################################################

# Index...
# CODE SECTION 1: Preliminary code, global definitions and sub new
#                 sub new
# CODE SECTION 2: Some Basic Utilities
# CODE SECTION 3: Check and process options
#                 sub check_options
# CODE SECTION 4: Receive lines from the tokenizer
#                 sub write_line
# CODE SECTION 5: Pre-process the entire file
#                 sub finish_formatting
# CODE SECTION 6: Process line-by-line
#                 sub process_all_lines
# CODE SECTION 7: Process lines of code
#                 process_line_of_CODE
# CODE SECTION 8: Utilities for setting breakpoints
#                 sub set_forced_breakpoint
# CODE SECTION 9: Process batches of code
#                 sub grind_batch_of_CODE
# CODE SECTION 10: Code to break long statements
#                  sub break_long_lines
# CODE SECTION 11: Code to break long lists
#                  sub break_lists
# CODE SECTION 12: Code for setting indentation
# CODE SECTION 13: Preparing batch of lines for vertical alignment
#                  sub convey_batch_to_vertical_aligner
# CODE SECTION 14: Code for creating closing side comments
#                  sub add_closing_side_comment
# CODE SECTION 15: Summarize
#                  sub wrapup

#######################################################################
# CODE SECTION 1: Preliminary code and global definitions up to sub new
#######################################################################

package Perl::Tidy::Formatter;
use strict;
use warnings;

# DEVEL_MODE gets switched on during automated testing for extra checking
use constant DEVEL_MODE   => 0;
use constant EMPTY_STRING => q{};
use constant SPACE        => q{ };
use constant BACKSLASH    => q{\\};

{ #<<< A non-indenting brace to contain all lexical variables

use Carp;
use English    qw( -no_match_vars );
use List::Util qw( min max first );    # min, max first are in Perl 5.8
our $VERSION = '20250105';

# The Tokenizer will be loaded with the Formatter
##use Perl::Tidy::Tokenizer;    # for is_keyword()

sub AUTOLOAD {

    # Catch any undefined sub calls so that we are sure to get
    # some diagnostic information.  This sub should never be called
    # except for a programming error.
    our $AUTOLOAD;
    return if ( $AUTOLOAD =~ /\bDESTROY$/ );
    my ( $pkg, $fname, $lno ) = caller();
    my $my_package = __PACKAGE__;
    print {*STDERR} <<EOM;
======================================================================
Error detected in package '$my_package', version $VERSION
Received unexpected AUTOLOAD call for sub '$AUTOLOAD'
Called from package: '$pkg'
Called from File '$fname'  at line '$lno'
This error is probably due to a recent programming change
======================================================================
EOM
    exit 1;
} ## end sub AUTOLOAD

sub DESTROY {
    my $self = shift;
    _decrement_count();
    return;
}

sub Die {
    my ($msg) = @_;
    Perl::Tidy::Die($msg);
    croak "unexpected return from Perl::Tidy::Die";
}

sub Warn {
    my ($msg) = @_;
    Perl::Tidy::Warn($msg);
    return;
}

sub Fault {
    my ($msg) = @_;

    # This routine is called for errors that really should not occur
    # except if there has been a bug introduced by a recent program change.
    # Please add comments at calls to Fault to explain why the call
    # should not occur, and where to look to fix it.
    my ( $package0_uu, $filename0_uu, $line0,    $subroutine0_uu ) = caller(0);
    my ( $package1_uu, $filename1,    $line1,    $subroutine1 )    = caller(1);
    my ( $package2_uu, $filename2_uu, $line2_uu, $subroutine2 )    = caller(2);
    my $pkg = __PACKAGE__;

    my $input_stream_name = get_input_stream_name();

    Die(<<EOM);
==============================================================================
While operating on input stream with name: '$input_stream_name'
A fault was detected at line $line0 of sub '$subroutine1'
in file '$filename1'
which was called from line $line1 of sub '$subroutine2'
Message: '$msg'
This is probably an error introduced by a recent programming change.
$pkg reports VERSION='$VERSION'.
==============================================================================
EOM
    croak "unexpected return from sub Die";
} ## end sub Fault

sub Fault_Warn {
    my ($msg) = @_;

    # This is the same as Fault except that it calls Warn instead of Die
    # and returns.
    my ( $package0_uu, $filename0_uu, $line0,    $subroutine0_uu ) = caller(0);
    my ( $package1_uu, $filename1,    $line1,    $subroutine1 )    = caller(1);
    my ( $package2_uu, $filename2_uu, $line2_uu, $subroutine2 )    = caller(2);
    my $input_stream_name = get_input_stream_name();

    Warn(<<EOM);
==============================================================================
While operating on input stream with name: '$input_stream_name'
A fault was detected at line $line0 of sub '$subroutine1'
in file '$filename1'
which was called from line $line1 of sub '$subroutine2'
Message: '$msg'
This is probably an error introduced by a recent programming change.
Perl::Tidy::Formatter.pm reports VERSION='$VERSION'.
==============================================================================
EOM

    return;
} ## end sub Fault_Warn

sub Exit {
    my ($msg) = @_;
    Perl::Tidy::Exit($msg);
    croak "unexpected return from Perl::Tidy::Exit";
}

# Global variables ...
my (

    #-----------------------------------------------------------------
    # Section 1: Global variables which are either always constant or
    # are constant after being configured by user-supplied
    # parameters.  They remain constant as a file is being processed.
    # The INITIALIZER comment tells the sub responsible for initializing
    # each variable. Failure to initialize or re-initialize a global
    # variable can cause bugs which are hard to locate.
    #-----------------------------------------------------------------

    # INITIALIZER: sub check_options
    $rOpts,

    # short-cut option variables
    # INITIALIZER: sub initialize_global_option_vars
    $rOpts_add_newlines,
    $rOpts_add_whitespace,
    $rOpts_add_trailing_commas,
    $rOpts_add_lone_trailing_commas,
    $rOpts_blank_lines_after_opening_block,
    $rOpts_block_brace_tightness,
    $rOpts_block_brace_vertical_tightness,
    $rOpts_brace_follower_vertical_tightness,
    $rOpts_break_after_labels,
    $rOpts_break_at_old_attribute_breakpoints,
    $rOpts_break_at_old_comma_breakpoints,
    $rOpts_break_at_old_keyword_breakpoints,
    $rOpts_break_at_old_logical_breakpoints,
    $rOpts_break_at_old_semicolon_breakpoints,
    $rOpts_break_at_old_ternary_breakpoints,
    $rOpts_break_open_compact_parens,
    $rOpts_closing_side_comments,
    $rOpts_closing_side_comment_else_flag,
    $rOpts_closing_side_comment_maximum_text,
    $rOpts_comma_arrow_breakpoints,
    $rOpts_continuation_indentation,
    $rOpts_cuddled_paren_brace,
    $rOpts_delete_closing_side_comments,
    $rOpts_delete_old_whitespace,
    $rOpts_delete_side_comments,
    $rOpts_delete_trailing_commas,
    $rOpts_delete_lone_trailing_commas,
    $rOpts_delete_weld_interfering_commas,
    $rOpts_extended_continuation_indentation,
    $rOpts_format_skipping,
    $rOpts_freeze_whitespace,
    $rOpts_function_paren_vertical_alignment,
    $rOpts_fuzzy_line_length,
    $rOpts_ignore_old_breakpoints,
    $rOpts_ignore_side_comment_lengths,
    $rOpts_ignore_perlcritic_comments,
    $rOpts_indent_closing_brace,
    $rOpts_indent_columns,
    $rOpts_indent_leading_semicolon,
    $rOpts_indent_only,
    $rOpts_keep_interior_semicolons,
    $rOpts_line_up_parentheses,
    $rOpts_logical_padding,
    $rOpts_maximum_consecutive_blank_lines,
    $rOpts_maximum_fields_per_table,
    $rOpts_maximum_line_length,
    $rOpts_minimize_continuation_indentation,
    $rOpts_one_line_block_semicolons,
    $rOpts_opening_brace_always_on_right,
    $rOpts_outdent_keywords,
    $rOpts_outdent_labels,
    $rOpts_outdent_long_comments,
    $rOpts_outdent_long_quotes,
    $rOpts_outdent_static_block_comments,
    $rOpts_recombine,
    $rOpts_qw_as_function,
    $rOpts_short_concatenation_item_length,
    $rOpts_space_prototype_paren,
    $rOpts_space_signature_paren,
    $rOpts_stack_closing_block_brace,
    $rOpts_static_block_comments,
    $rOpts_add_missing_else,
    $rOpts_warn_missing_else,
    $rOpts_tee_block_comments,
    $rOpts_tee_pod,
    $rOpts_tee_side_comments,
    $rOpts_variable_maximum_line_length,
    $rOpts_valign_code,
    $rOpts_valign_side_comments,
    $rOpts_valign_if_unless,
    $rOpts_valign_wide_equals,
    $rOpts_whitespace_cycle,
    $rOpts_extended_block_tightness,
    $rOpts_extended_line_up_parentheses,

    # Static hashes
    # INITIALIZER: BEGIN block
    %is_assignment,
    %is_non_list_type,
    %is_if_unless_and_or_last_next_redo_return,
    %is_if_elsif_else_unless_while_until_for_foreach,
    %is_if_unless_while_until_for_foreach,
    %is_for_foreach,
    %is_last_next_redo_return,
    %is_if_unless,
    %is_if_elsif,
    %is_if_unless_elsif,
    %is_if_unless_elsif_else,
    %is_elsif_else,
    %is_and_or,
    %is_chain_operator,
    %is_block_without_semicolon,
    %ok_to_add_semicolon_for_block_type,
    %is_opening_type,
    %is_closing_type,
    %is_opening_token,
    %is_closing_token,
    %is_ternary,
    %is_equal_or_fat_comma,
    %is_counted_type,
    %is_opening_sequence_token,
    %is_closing_sequence_token,
    %matching_token,
    %is_container_label_type,
    %is_die_confess_croak_warn,
    %is_my_our_local,
    %is_soft_keep_break_type,
    %is_indirect_object_taker,
    @all_operators,
    %is_do_follower,
    %is_anon_sub_brace_follower,
    %is_anon_sub_1_brace_follower,
    %is_other_brace_follower,
    %is_kwU,
    %is_re_match_op,
    %is_my_state_our,
    %is_keyword_with_special_leading_term,

    # INITIALIZER: sub check_options
    $controlled_comma_style,

    # INITIALIZER: sub initialize_tightness_vars
    %tightness,

    # INITIALIZER: sub initialize_multiple_token_tightness
    %multiple_token_tightness,

    #  INITIALIZER: initialize_old_breakpoint_controls
    %keep_break_before_type,
    %keep_break_after_type,

    # INITIALIZER: initialize_container_indentation_options
    %container_indentation_options,

    # INITIALIZER: sub initialize_lpxl_lpil
    %line_up_parentheses_control_hash,
    $line_up_parentheses_control_is_lpxl,

    # INITIALIZER: sub outdent_keyword
    %outdent_keyword,

    # INITIALIZER: sub initialize_keyword_paren_inner_tightness
    %keyword_paren_inner_tightness,

    # These can be modified by grep-alias-list
    # INITIALIZER: sub initialize_grep_and_friends
    %is_sort_map_grep,
    %is_sort_map_grep_eval,
    %is_sort_map_grep_eval_do,
    %is_block_with_ci,
    %is_keyword_returning_list,
    %block_type_map,         # initialized in BEGIN, but may be changed
    %want_one_line_block,    # may be changed in prepare_cuddled_block_types

    # INITIALIZER: sub prepare_cuddled_block_types
    $rcuddled_block_types,

    # INITIALIZER: sub initialize_whitespace_hashes
    %binary_ws_rules,
    %want_left_space,
    %want_right_space,

    # INITIALIZER: sub initialize_bond_strength_hashes
    %right_bond_strength,
    %left_bond_strength,

    # INITIALIZER: sub initialize_token_break_preferences
    %want_break_before,
    %break_before_container_types,

    # INITIALIZER: sub initialize_space_after_keyword
    %space_after_keyword,

    # INITIALIZER: sub initialize_extended_block_tightness_list
    %extended_block_tightness_list,

    # INITIALIZED BY initialize_global_option_vars
    %opening_vertical_tightness,
    %closing_vertical_tightness,
    %closing_token_indentation,
    $some_closing_token_indentation,
    %opening_token_right,
    %stack_opening_token,
    %stack_closing_token,

    # INITIALIZER: sub initialize_weld_nested_exclusion_rules
    %weld_nested_exclusion_rules,

    # INITIALIZER: sub initialize_weld_fat_comma_rules
    %weld_fat_comma_rules,

    # INITIALIZER: sub initialize_trailing_comma_rules
    %trailing_comma_rules,

    # INITIALIZER: sub initialize_trailing_comma_break_rules
    %trailing_comma_break_rules,

    # INITIALIZER: sub initialize_interbracket_arrow_style
    %interbracket_arrow_style,

    # INITIALIZER: sub initialize_call_paren_style
    %call_paren_style,

    # INITIALIZER: sub initialize_warn_variable_types
    $rwarn_variable_types,
    $ris_warn_variable_excluded_name,

    # INITIALIZER: sub initialize_warn_mismatched_args
    $rwarn_mismatched_arg_types,
    $ris_warn_mismatched_arg_excluded_name,

    # INITIALIZER: sub initialize_warn_mismatched_returns
    $rwarn_mismatched_return_types,
    $ris_warn_mismatched_return_excluded_name,

    # regex patterns for text identification.
    # Most can be configured by user parameters.
    # Most are initialized in a sub make_**_pattern during configuration.

    # INITIALIZER: sub make_sub_matching_pattern
    $SUB_PATTERN,
    $ASUB_PATTERN,
    %matches_ASUB,

    # INITIALIZER: make_static_block_comment_pattern
    $static_block_comment_pattern,

    # INITIALIZER: sub make_static_side_comment_pattern
    $static_side_comment_pattern,

    # INITIALIZER: make_format_skipping_pattern
    $format_skipping_pattern_begin,
    $format_skipping_pattern_end,

    # INITIALIZER: sub make_non_indenting_brace_pattern
    $non_indenting_brace_pattern,

    # INITIALIZER: sub make_bl_pattern
    $bl_exclusion_pattern,

    # INITIALIZER: make_bl_pattern
    $bl_pattern,

    # INITIALIZER: sub make_bli_pattern
    $bli_exclusion_pattern,

    # INITIALIZER: sub make_bli_pattern
    $bli_pattern,

    # INITIALIZER: sub make_block_brace_vertical_tightness_pattern
    $block_brace_vertical_tightness_pattern,

    # INITIALIZER: sub make_blank_line_pattern
    $blank_lines_after_opening_block_pattern,
    $blank_lines_before_closing_block_pattern,

    # INITIALIZER: sub make_keyword_group_list_pattern
    $keyword_group_list_pattern,
    $keyword_group_list_comment_pattern,

    # INITIALIZER: sub make_closing_side_comment_prefix
    $closing_side_comment_prefix_pattern,

    # INITIALIZER: sub make_closing_side_comment_list_pattern
    $closing_side_comment_list_pattern,
    $closing_side_comment_want_asub,
    $closing_side_comment_exclusion_pattern,

    # Table to efficiently find indentation and max line length
    # from level.
    # INITIALIZER: sub initialize_line_length_vars
    @maximum_line_length_at_level,
    @maximum_text_length_at_level,
    $stress_level_alpha,
    $stress_level_beta,
    $high_stress_level,

    # Total number of sequence items in a weld, for quick checks
    # INITIALIZER: weld_containers
    $total_weld_count,

    #--------------------------------------------------------
    # Section 2: Work arrays for the current batch of tokens.
    #--------------------------------------------------------

    # These are re-initialized for each batch of code
    # INITIALIZER: sub initialize_batch_variables
    $max_index_to_go,
    @block_type_to_go,
    @type_sequence_to_go,
    @forced_breakpoint_to_go,
    @token_lengths_to_go,
    @summed_lengths_to_go,
    @levels_to_go,
    @leading_spaces_to_go,
    @reduced_spaces_to_go,
    @mate_index_to_go,
    @ci_levels_to_go,
    @nesting_depth_to_go,
    @nobreak_to_go,
    @old_breakpoint_to_go,
    @tokens_to_go,
    @K_to_go,
    @types_to_go,
    @inext_to_go,
    @parent_seqno_to_go,

    # forced breakpoint variables associated with each batch of code
    $forced_breakpoint_count,
    $forced_breakpoint_undo_count,
    $index_max_forced_break,
);

BEGIN {

    # Index names for token variables.
    # Do not combine with other BEGIN blocks (c101).
    my $i = 0;
    use constant {
        _CI_LEVEL_          => $i++,
        _CUMULATIVE_LENGTH_ => $i++,
        _LINE_INDEX_        => $i++,
        _LEVEL_             => $i++,
        _TOKEN_             => $i++,
        _TOKEN_LENGTH_      => $i++,
        _TYPE_              => $i++,
        _TYPE_SEQUENCE_     => $i++,

        # Number of token variables; must be last in list:
        _NVARS => $i++,
    };
} ## end BEGIN

BEGIN {

    # Index names for $self variables.
    # Do not combine with other BEGIN blocks (c101).
    my $i = 0;
    use constant {
        _rlines_                    => $i++,
        _rLL_                       => $i++,
        _Klimit_                    => $i++,
        _rdepth_of_opening_seqno_   => $i++,
        _rSS_                       => $i++,
        _rI_opening_                => $i++,
        _rI_closing_                => $i++,
        _rK_next_seqno_by_K_        => $i++,
        _rblock_type_of_seqno_      => $i++,
        _ris_asub_block_            => $i++,
        _ris_sub_block_             => $i++,
        _K_opening_container_       => $i++,
        _K_closing_container_       => $i++,
        _K_opening_ternary_         => $i++,
        _K_closing_ternary_         => $i++,
        _rK_sequenced_token_list_   => $i++,
        _rtype_count_by_seqno_      => $i++,
        _ris_function_call_paren_   => $i++,
        _rlec_count_by_seqno_       => $i++,
        _ris_broken_container_      => $i++,
        _ris_permanently_broken_    => $i++,
        _rblank_and_comment_count_  => $i++,
        _rhas_list_                 => $i++,
        _rhas_broken_list_          => $i++,
        _rhas_broken_list_with_lec_ => $i++,
        _rfirst_comma_line_index_   => $i++,
        _rhas_code_block_           => $i++,
        _rhas_broken_code_block_    => $i++,
        _rhas_ternary_              => $i++,
        _ris_excluded_lp_container_ => $i++,
        _rlp_object_by_seqno_       => $i++,
        _rwant_reduced_ci_          => $i++,
        _rno_xci_by_seqno_          => $i++,
        _rbrace_left_               => $i++,
        _ris_bli_container_         => $i++,
        _rparent_of_seqno_          => $i++,
        _rchildren_of_seqno_        => $i++,
        _ris_list_by_seqno_         => $i++,
        _ris_cuddled_closing_brace_ => $i++,
        _rbreak_container_          => $i++,
        _rshort_nested_             => $i++,
        _length_function_           => $i++,
        _is_encoded_data_           => $i++,
        _fh_tee_                    => $i++,
        _sink_object_               => $i++,
        _file_writer_object_        => $i++,
        _vertical_aligner_object_   => $i++,
        _logger_object_             => $i++,
        _radjusted_levels_          => $i++,

        _ris_special_identifier_token_    => $i++,
        _last_output_short_opening_token_ => $i++,

        _last_line_leading_type_  => $i++,
        _last_line_leading_level_ => $i++,

        _added_semicolon_count_    => $i++,
        _first_added_semicolon_at_ => $i++,
        _last_added_semicolon_at_  => $i++,

        _deleted_semicolon_count_    => $i++,
        _first_deleted_semicolon_at_ => $i++,
        _last_deleted_semicolon_at_  => $i++,

        _embedded_tab_count_    => $i++,
        _first_embedded_tab_at_ => $i++,
        _last_embedded_tab_at_  => $i++,

        _first_tabbing_disagreement_       => $i++,
        _last_tabbing_disagreement_        => $i++,
        _tabbing_disagreement_count_       => $i++,
        _in_tabbing_disagreement_          => $i++,
        _first_brace_tabbing_disagreement_ => $i++,
        _in_brace_tabbing_disagreement_    => $i++,

        _saw_VERSION_in_this_file_ => $i++,
        _saw_use_strict_           => $i++,
        _saw_END_or_DATA_          => $i++,

        _rK_weld_left_         => $i++,
        _rK_weld_right_        => $i++,
        _rweld_len_right_at_K_ => $i++,

        _rspecial_side_comment_type_ => $i++,

        _rseqno_controlling_my_ci_    => $i++,
        _ris_seqno_controlling_ci_    => $i++,
        _save_logfile_                => $i++,
        _maximum_level_               => $i++,
        _maximum_level_at_line_       => $i++,
        _maximum_BLOCK_level_         => $i++,
        _maximum_BLOCK_level_at_line_ => $i++,

        _rKrange_code_without_comments_ => $i++,
        _rbreak_before_Kfirst_          => $i++,
        _rbreak_after_Klast_            => $i++,
        _converged_                     => $i++,
        _want_second_iteration_         => $i++,

        _rstarting_multiline_qw_seqno_by_K_ => $i++,
        _rending_multiline_qw_seqno_by_K_   => $i++,
        _rKrange_multiline_qw_by_seqno_     => $i++,
        _rmultiline_qw_has_extra_level_     => $i++,

        _rcollapsed_length_by_seqno_       => $i++,
        _rbreak_before_container_by_seqno_ => $i++,
        _roverride_cab3_                   => $i++,
        _ris_assigned_structure_           => $i++,
        _ris_short_broken_eval_block_      => $i++,
        _ris_bare_trailing_comma_by_seqno_ => $i++,

        _rseqno_non_indenting_brace_by_ix_ => $i++,
        _rmax_vertical_tightness_          => $i++,

        _no_vertical_tightness_flags_ => $i++,
        _last_vt_type_                => $i++,
        _rwant_arrow_before_seqno_    => $i++,

        _rseqno_arrow_call_chain_start_ => $i++,
        _rarrow_call_chain_             => $i++,

        # these vars are defined after call to respace tokens:
        _rK_package_list_                 => $i++,
        _rK_AT_underscore_by_sub_seqno_   => $i++,
        _rK_first_self_by_sub_seqno_      => $i++,
        _rK_bless_by_sub_seqno_           => $i++,
        _rK_return_by_sub_seqno_          => $i++,
        _rK_wantarray_by_sub_seqno_       => $i++,
        _rK_sub_by_seqno_                 => $i++,
        _ris_my_sub_by_seqno_             => $i++,
        _rsub_call_paren_info_by_seqno_   => $i++,
        _rDOLLAR_underscore_by_sub_seqno_ => $i++,
        _this_batch_                      => $i++,

        _LAST_SELF_INDEX_ => $i - 1,
    };
} ## end BEGIN

BEGIN {

    # Index names for variables stored in _this_batch_.
    # Do not combine with other BEGIN blocks (c101).
    my $i = 0;
    use constant {
        _starting_in_quote_          => $i++,
        _ending_in_quote_            => $i++,
        _is_static_block_comment_    => $i++,
        _ri_first_                   => $i++,
        _ri_last_                    => $i++,
        _do_not_pad_                 => $i++,
        _peak_batch_size_            => $i++,
        _batch_count_                => $i++,
        _rix_seqno_controlling_ci_   => $i++,
        _batch_CODE_type_            => $i++,
        _ri_starting_one_line_block_ => $i++,
        _runmatched_opening_indexes_ => $i++,
    };
} ## end BEGIN

BEGIN {

    # Sequence number assigned to the root of sequence tree.
    # The minimum of the actual sequences numbers is 4, so we can use 1
    use constant SEQ_ROOT => 1;

    # Codes for insertion and deletion of blanks
    use constant DELETE => 0;
    use constant STABLE => 1;
    use constant INSERT => 2;

    # whitespace codes
    use constant WS_YES      => 1;
    use constant WS_OPTIONAL => 0;
    use constant WS_NO       => -1;

    # Token bond strengths.
    use constant NO_BREAK    => 10_000;
    use constant VERY_STRONG => 100;
    use constant STRONG      => 2.1;
    use constant NOMINAL     => 1.1;
    use constant WEAK        => 0.8;
    use constant VERY_WEAK   => 0.55;

    # values for testing indexes in output array
    use constant UNDEFINED_INDEX => -1;

    # Maximum number of little messages; probably need not be changed.
    use constant MAX_NAG_MESSAGES => 6;

    # This is the decimal range of printable characters in ASCII.  It is used to
    # make quick preliminary checks before resorting to using a regex.
    use constant ORD_PRINTABLE_MIN => 33;
    use constant ORD_PRINTABLE_MAX => 126;

    # Initialize constant hashes ...
    my @q;

    @q = qw( = **= += *= &= <<= &&= -= /= |= >>= ||= //= .= %= ^= x= );
    @is_assignment{@q} = (1) x scalar(@q);

    # a hash needed by break_lists for efficiency:
    push @q, qw{ ; < > ~ f };
    @is_non_list_type{@q} = (1) x scalar(@q);

    @q = qw( is if unless and or err last next redo return );
    @is_if_unless_and_or_last_next_redo_return{@q} = (1) x scalar(@q);

    # These block types may have text between the keyword and opening
    # curly.  Note: 'else' does not, but must be included to allow trailing
    # if/elsif text to be appended.
    # patch for SWITCH/CASE: added 'case' and 'when'
    @q = qw( if elsif else unless while until for foreach case when catch );
    @is_if_elsif_else_unless_while_until_for_foreach{@q} =
      (1) x scalar(@q);

    # These can either have the BLOCK form or trailing modifier form:
    @q = qw( if unless while until for foreach );
    @is_if_unless_while_until_for_foreach{@q} =
      (1) x scalar(@q);

    # These can have several forms
    @q = qw( for foreach );
    @is_for_foreach{@q} = (1) x scalar(@q);

    @q = qw( last next redo return );
    @is_last_next_redo_return{@q} = (1) x scalar(@q);

    # Map related block names into a common name to allow vertical alignment
    # used by sub make_alignment_patterns. Note: this is normally unchanged,
    # but it contains 'grep' and can be re-initialized in
    # sub initialize_grep_and_friends in a testing mode.
    %block_type_map = (
        'unless'  => 'if',
        'else'    => 'if',
        'elsif'   => 'if',
        'when'    => 'if',
        'default' => 'if',
        'case'    => 'if',
        'sort'    => 'map',
        'grep'    => 'map',
    );

    @q = qw( if unless );
    @is_if_unless{@q} = (1) x scalar(@q);

    @q = qw( if elsif );
    @is_if_elsif{@q} = (1) x scalar(@q);

    @q = qw( if unless elsif );
    @is_if_unless_elsif{@q} = (1) x scalar(@q);

    @q = qw( if unless elsif else );
    @is_if_unless_elsif_else{@q} = (1) x scalar(@q);

    @q = qw( elsif else );
    @is_elsif_else{@q} = (1) x scalar(@q);

    @q = qw( and or err );
    @is_and_or{@q} = (1) x scalar(@q);

    # Identify certain operators which often occur in chains.
    # Note: the minus (-) causes a side effect of padding of the first line in
    # something like this (by sub set_logical_padding):
    #    Checkbutton => 'Transmission checked',
    #   -variable    => \$TRANS
    # This usually improves appearance so it seems ok.
    @q = qw( && || and or : ? . + - * / );
    @is_chain_operator{@q} = (1) x scalar(@q);

    # Operators that the user can request break before or after.
    # Note that some are keywords
    @all_operators = qw{
      % + - * / x != == >= <= =~ !~ < > | &
      = **= += *= &= <<= &&= -= /= |= >>= ||= //= .= %= ^= x=
      . : ? && || and or err xor
    };

    # We can remove semicolons after blocks preceded by these keywords
    @q = qw(
      BEGIN     END      CHECK INIT    AUTOLOAD DESTROY
      UNITCHECK continue if    elsif   else     unless
      while     until    for   foreach given    when
      default
    );
    @is_block_without_semicolon{@q} = (1) x scalar(@q);

    # We will allow semicolons to be added within these block types
    # as well as sub and package blocks.
    # NOTES:
    # 1. Note that these keywords are omitted:
    #     switch case given when default sort map grep
    # 2. It is also ok to add for sub and package blocks and a labeled block
    # 3. But not okay for other perltidy types including:
    #     { } ; G t
    # 4. Test files: blktype.t, blktype1.t, semicolon.t
    @q = qw( BEGIN END CHECK INIT AUTOLOAD DESTROY UNITCHECK continue if elsif
      else unless do while until eval for foreach );
    @ok_to_add_semicolon_for_block_type{@q} = (1) x scalar(@q);

    # 'L' is token for opening { at hash key
    @q = qw< L { ( [ >;
    @is_opening_type{@q} = (1) x scalar(@q);

    # 'R' is token for closing } at hash key
    @q = qw< R } ) ] >;
    @is_closing_type{@q} = (1) x scalar(@q);

    @q = qw< { ( [ >;
    @is_opening_token{@q} = (1) x scalar(@q);

    @q = qw< } ) ] >;
    @is_closing_token{@q} = (1) x scalar(@q);

    @q = qw( ? : );
    @is_ternary{@q} = (1) x scalar(@q);

    @q = qw< { ( [ ? >;
    @is_opening_sequence_token{@q} = (1) x scalar(@q);

    @q = qw< } ) ] : >;
    @is_closing_sequence_token{@q} = (1) x scalar(@q);

    %matching_token = (
        '{' => '}',
        '(' => ')',
        '[' => ']',
        '?' => ':',

        '}' => '{',
        ')' => '(',
        ']' => '[',
        ':' => '?',
    );

    # a hash needed by sub break_lists for labeling containers
    @q = qw( k => && || ? : . );
    @is_container_label_type{@q} = (1) x scalar(@q);

    @q = qw( die confess croak warn );
    @is_die_confess_croak_warn{@q} = (1) x scalar(@q);

    @q = qw( my our local );
    @is_my_our_local{@q} = (1) x scalar(@q);

    # Braces -bbht etc must follow these. Note: experimentation with
    # including a simple comma shows that it adds little and can lead
    # to poor formatting in complex lists.
    @q = qw( = => );
    @is_equal_or_fat_comma{@q} = (1) x scalar(@q);

    @q = qw( => ; h f );
    push @q, ',';
    @is_counted_type{@q} = (1) x scalar(@q);

    # Tokens where --keep-old-break-xxx flags make soft breaks instead
    # of hard breaks.  See b1433 and b1436.
    # NOTE: $type is used as the hash key for now; if other container tokens
    # are added it might be necessary to use a token/type mixture.
    @q = qw# -> ? : && || + - / * #;
    @is_soft_keep_break_type{@q} = (1) x scalar(@q);

    # these functions allow an identifier in the indirect object slot
    @q = qw( print printf sort exec system say );
    @is_indirect_object_taker{@q} = (1) x scalar(@q);

    # Define here tokens which may follow the closing brace of a do statement
    # on the same line, as in:
    #   } while ( $something);
    my @dof = qw( until while unless if ; : );
    push @dof, ',';
    @is_do_follower{@dof} = (1) x scalar(@dof);

    # what can follow a multi-line anonymous sub definition closing curly:
    my @asf = qw# ; : => or and  && || ~~ !~~ ) #;
    push @asf, ',';
    @is_anon_sub_brace_follower{@asf} = (1) x scalar(@asf);

    # what can follow a one-line anonymous sub closing curly:
    # one-line anonymous subs also have ']' here...
    # see tk3.t and PP.pm
    my @asf1 = qw#  ; : => or and  && || ) ] ~~ !~~ #;
    push @asf1, ',';
    @is_anon_sub_1_brace_follower{@asf1} = (1) x scalar(@asf1);

    # What can follow a closing curly of a block
    # which is not an if/elsif/else/do/sort/map/grep/eval/sub
    # Testfiles: 'Toolbar.pm', 'Menubar.pm', bless.t, '3rules.pl'
    my @obf = qw#  ; : => or and  && || ) #;
    push @obf, ',';
    @is_other_brace_follower{@obf} = (1) x scalar(@obf);

    # 'k'=builtin keyword, 'U'=user defined sub, 'w'=unknown bareword
    @q = qw( k w U );
    @is_kwU{@q} = (1) x scalar(@q);

    # regular expression match operators
    @q = qw( =~ !~);
    @is_re_match_op{@q} = (1) x scalar(@q);

    @q = qw ( my state our );
    @is_my_state_our{@q} = (1) x scalar(@q);

    # These keywords have prototypes which allow a special leading item
    # followed by a list
    @q =
      qw( chmod formline grep join kill map pack printf push sprintf unshift );
    @is_keyword_with_special_leading_term{@q} = (1) x scalar(@q);

} ## end BEGIN

{    ## begin closure to count instances

    # methods to count instances
    my $_count = 0;
    sub _increment_count { return ++$_count }
    sub _decrement_count { return --$_count }
} ## end closure to count instances

sub new {

    my ( $class, @arglist ) = @_;
    if ( @arglist % 2 ) { croak "Odd number of items in arg hash list\n" }

    # we are given an object with a write_line() method to take lines
    my %defaults = (
        sink_object        => undef,
        diagnostics_object => undef,
        logger_object      => undef,
        length_function    => undef,
        is_encoded_data    => EMPTY_STRING,
        fh_tee             => undef,
    );
    my %args = ( %defaults, @arglist );

    my $length_function    = $args{length_function};
    my $is_encoded_data    = $args{is_encoded_data};
    my $fh_tee             = $args{fh_tee};
    my $logger_object      = $args{logger_object};
    my $diagnostics_object = $args{diagnostics_object};

    # we create another object with a get_line() and peek_ahead() method
    my $sink_object = $args{sink_object};
    my $file_writer_object =
      Perl::Tidy::FileWriter->new( $sink_object, $rOpts, $logger_object );

    # initialize closure variables...
    set_logger_object($logger_object);
    set_diagnostics_object($diagnostics_object);
    initialize_lp_vars();
    initialize_csc_vars();
    initialize_break_lists();
    initialize_undo_ci();
    initialize_process_line_of_CODE();
    initialize_grind_batch_of_CODE();
    initialize_get_final_indentation();
    initialize_postponed_breakpoint();
    initialize_batch_variables();
    initialize_write_line();

    my $vertical_aligner_object = Perl::Tidy::VerticalAligner->new(
        rOpts              => $rOpts,
        file_writer_object => $file_writer_object,
        logger_object      => $logger_object,
        diagnostics_object => $diagnostics_object,
    );

    write_logfile_entry("\nStarting tokenization pass...\n");

    if ( $rOpts->{'entab-leading-whitespace'} ) {
        write_logfile_entry(
"Leading whitespace will be entabbed with $rOpts->{'entab-leading-whitespace'} spaces per tab\n"
        );
    }
    elsif ( $rOpts->{'tabs'} ) {
        write_logfile_entry("Indentation will be with a tab character\n");
    }
    else {
        write_logfile_entry(
            "Indentation will be with $rOpts->{'indent-columns'} spaces\n");
    }

    # Initialize the $self array reference.
    # To add an item, first add a constant index in the BEGIN block above.
    my $self = [];
    bless $self, $class;

    # Basic data structures...
    $self->[_rlines_] = [];    # = ref to array of lines of the file

    # 'rLL' = reference to the continuous liner array of all tokens in a file.
    # 'LL' stands for 'Linked List'. Using a linked list was a disaster, but
    # 'LL' stuck because it is easy to type.  The 'rLL' array is updated
    # by sub 'respace_tokens' during reformatting.  The indexes in 'rLL' begin
    # with '$K' by convention.
    $self->[_rLL_]    = [];
    $self->[_Klimit_] = undef;    # = maximum K index for rLL.

    # Indexes into the rLL list
    $self->[_K_opening_container_] = {};
    $self->[_K_closing_container_] = {};
    $self->[_K_opening_ternary_]   = {};
    $self->[_K_closing_ternary_]   = {};

    # A list of index K of sequenced tokens to allow loops over them all
    $self->[_rK_sequenced_token_list_] = [];

    # 'rSS' is the 'Signed Sequence' list, a continuous list of all sequence
    # numbers with + or - indicating opening or closing. This list represents
    # the entire container tree and is invariant under reformatting.  It can be
    # used to quickly travel through the tree.  Indexes in the rSS array begin
    # with '$I' by convention.
    $self->[_rSS_]                = [];
    $self->[_rI_opening_]         = [];
    $self->[_rI_closing_]         = [];
    $self->[_rK_next_seqno_by_K_] = [];

    # Arrays to help traverse the tree
    $self->[_rdepth_of_opening_seqno_] = [];
    $self->[_rblock_type_of_seqno_]    = {};
    $self->[_ris_asub_block_]          = {};
    $self->[_ris_sub_block_]           = {};

    # Variables for --warn-mismatched-args and
    #               --dump-mismatched-args
    #               --dump-mismatched-returns
    #               --warn-mismatched-returns
    $self->[_rK_package_list_]                 = [];
    $self->[_rK_AT_underscore_by_sub_seqno_]   = {};
    $self->[_rK_first_self_by_sub_seqno_]      = {};
    $self->[_rK_bless_by_sub_seqno_]           = {};
    $self->[_rK_return_by_sub_seqno_]          = {};
    $self->[_rK_wantarray_by_sub_seqno_]       = {};
    $self->[_rsub_call_paren_info_by_seqno_]   = {};
    $self->[_rDOLLAR_underscore_by_sub_seqno_] = {};
    $self->[_rK_sub_by_seqno_]                 = {};
    $self->[_ris_my_sub_by_seqno_]             = {};
    $self->[_this_batch_]                      = [];

    # Mostly list characteristics and processing flags
    $self->[_rtype_count_by_seqno_]      = {};
    $self->[_ris_function_call_paren_]   = {};
    $self->[_rlec_count_by_seqno_]       = {};
    $self->[_ris_broken_container_]      = {};
    $self->[_ris_permanently_broken_]    = {};
    $self->[_rblank_and_comment_count_]  = {};
    $self->[_rhas_list_]                 = {};
    $self->[_rhas_broken_list_]          = {};
    $self->[_rhas_broken_list_with_lec_] = {};
    $self->[_rfirst_comma_line_index_]   = {};
    $self->[_rhas_code_block_]           = {};
    $self->[_rhas_broken_code_block_]    = {};
    $self->[_rhas_ternary_]              = {};
    $self->[_ris_excluded_lp_container_] = {};
    $self->[_rlp_object_by_seqno_]       = {};
    $self->[_rwant_reduced_ci_]          = {};
    $self->[_rno_xci_by_seqno_]          = {};
    $self->[_rbrace_left_]               = {};
    $self->[_ris_bli_container_]         = {};
    $self->[_rparent_of_seqno_]          = {};
    $self->[_rchildren_of_seqno_]        = {};
    $self->[_ris_list_by_seqno_]         = {};
    $self->[_ris_cuddled_closing_brace_] = {};

    $self->[_rbreak_container_] = {};                 # prevent one-line blocks
    $self->[_rshort_nested_]    = {};                 # blocks not forced open
    $self->[_length_function_]  = $length_function;
    $self->[_is_encoded_data_]  = $is_encoded_data;

    # Some objects...
    $self->[_fh_tee_]                  = $fh_tee;
    $self->[_sink_object_]             = $sink_object;
    $self->[_file_writer_object_]      = $file_writer_object;
    $self->[_vertical_aligner_object_] = $vertical_aligner_object;
    $self->[_logger_object_]           = $logger_object;

    # Memory of processed text...
    $self->[_ris_special_identifier_token_]    = {};
    $self->[_last_line_leading_level_]         = 0;
    $self->[_last_line_leading_type_]          = '#';
    $self->[_last_output_short_opening_token_] = 0;
    $self->[_added_semicolon_count_]           = 0;
    $self->[_first_added_semicolon_at_]        = 0;
    $self->[_last_added_semicolon_at_]         = 0;
    $self->[_deleted_semicolon_count_]         = 0;
    $self->[_first_deleted_semicolon_at_]      = 0;
    $self->[_last_deleted_semicolon_at_]       = 0;
    $self->[_embedded_tab_count_]              = 0;
    $self->[_first_embedded_tab_at_]           = 0;
    $self->[_last_embedded_tab_at_]            = 0;
    $self->[_first_tabbing_disagreement_]      = 0;
    $self->[_last_tabbing_disagreement_]       = 0;
    $self->[_tabbing_disagreement_count_]      = 0;
    $self->[_in_tabbing_disagreement_]         = 0;
    $self->[_saw_VERSION_in_this_file_]        = !$rOpts->{'pass-version-line'};
    $self->[_saw_use_strict_]                  = 0;
    $self->[_saw_END_or_DATA_]                 = 0;
    $self->[_first_brace_tabbing_disagreement_] = undef;
    $self->[_in_brace_tabbing_disagreement_]    = undef;

    # Hashes related to container welding...
    $self->[_radjusted_levels_] = [];

    # Weld data structures
    $self->[_rK_weld_left_]         = {};
    $self->[_rK_weld_right_]        = {};
    $self->[_rweld_len_right_at_K_] = {};

    # -xci stuff
    $self->[_rseqno_controlling_my_ci_] = {};
    $self->[_ris_seqno_controlling_ci_] = {};

    $self->[_rspecial_side_comment_type_]  = {};
    $self->[_maximum_level_]               = 0;
    $self->[_maximum_level_at_line_]       = 0;
    $self->[_maximum_BLOCK_level_]         = 0;
    $self->[_maximum_BLOCK_level_at_line_] = 0;

    $self->[_rKrange_code_without_comments_] = [];
    $self->[_rbreak_before_Kfirst_]          = {};
    $self->[_rbreak_after_Klast_]            = {};
    $self->[_converged_]                     = 0;
    $self->[_want_second_iteration_]         = 0;

    # qw stuff
    $self->[_rstarting_multiline_qw_seqno_by_K_] = {};
    $self->[_rending_multiline_qw_seqno_by_K_]   = {};
    $self->[_rKrange_multiline_qw_by_seqno_]     = {};
    $self->[_rmultiline_qw_has_extra_level_]     = {};

    $self->[_rcollapsed_length_by_seqno_]       = {};
    $self->[_rbreak_before_container_by_seqno_] = {};
    $self->[_roverride_cab3_]                   = {};
    $self->[_ris_assigned_structure_]           = {};
    $self->[_ris_short_broken_eval_block_]      = {};
    $self->[_ris_bare_trailing_comma_by_seqno_] = {};

    $self->[_rseqno_non_indenting_brace_by_ix_] = {};
    $self->[_rmax_vertical_tightness_]          = {};

    $self->[_no_vertical_tightness_flags_] = 0;
    $self->[_last_vt_type_]                = 0;
    $self->[_rwant_arrow_before_seqno_]    = {};

    $self->[_rseqno_arrow_call_chain_start_] = {};
    $self->[_rarrow_call_chain_]             = {};

    $self->[_save_logfile_] =
      defined($logger_object) && $logger_object->get_save_logfile();

    # Be sure all variables in $self have been initialized above.  To find the
    # correspondence of index numbers and array names, copy a list to a file
    # and use the unix 'nl' command to number lines 1..
    if (DEVEL_MODE) {
        my @non_existant;
        foreach ( 0 .. _LAST_SELF_INDEX_ ) {
            if ( !exists $self->[$_] ) {
                push @non_existant, $_;
            }
        }
        if (@non_existant) {
            Fault("These indexes in self not initialized: (@non_existant)\n");
        }
    }

    # Safety check..this is not a class yet
    if ( _increment_count() > 1 ) {
        confess
"Attempt to create more than 1 object in $class, which is not a true class yet\n";
    }
    return $self;
} ## end sub new

######################################
# CODE SECTION 2: Some Basic Utilities
######################################

sub check_rLL {

    # Verify that the rLL array has not been auto-vivified
    my ( $self, $msg ) = @_;
    my $rLL    = $self->[_rLL_];
    my $Klimit = $self->[_Klimit_];
    my $num    = @{$rLL};
    if (   ( defined($Klimit) && $Klimit != $num - 1 )
        || ( !defined($Klimit) && $num > 0 ) )
    {

        # This fault can occur if the array has been accessed for an index
        # greater than $Klimit, which is the last token index.  Just accessing
        # the array above index $Klimit, not setting a value, can cause @rLL to
        # increase beyond $Klimit.  If this occurs, the problem can be located
        # by making calls to this routine at different locations in
        # sub 'finish_formatting'.
        $Klimit = 'undef' if ( !defined($Klimit) );
        $msg    = EMPTY_STRING unless $msg;
        Fault("$msg ERROR: rLL has num=$num but Klimit='$Klimit'\n");
    }
    return;
} ## end sub check_rLL

sub check_keys {
    my ( $rtest, $rvalid, $msg, $exact_match ) = @_;

    # Check the keys of a hash:
    # $rtest   = ref to hash to test
    # $rvalid  = ref to hash with valid keys

    # $msg = a message to write in case of error
    # $exact_match defines the type of check:
    #     = false: test hash must not have unknown key
    #     = true:  test hash must have exactly same keys as known hash
    my @unknown_keys =
      grep { !exists $rvalid->{$_} } keys %{$rtest};
    my @missing_keys =
      grep { !exists $rtest->{$_} } keys %{$rvalid};
    my $error = @unknown_keys;
    if ($exact_match) { $error ||= @missing_keys }
    if ($error) {
        local $LIST_SEPARATOR = ')(';
        my @expected_keys = sort keys %{$rvalid};
        @unknown_keys = sort @unknown_keys;
        Fault(<<EOM);
------------------------------------------------------------------------
Program error detected checking hash keys
Message is: '$msg'
Expected keys: (@expected_keys)
Unknown key(s): (@unknown_keys)
Missing key(s): (@missing_keys)
------------------------------------------------------------------------
EOM
    }
    return;
} ## end sub check_keys

sub check_token_array {
    my $self = shift;

    #--------------
    # Check @{$rLL}
    #--------------
    # Check for errors in the array of tokens. This is only called
    # when the DEVEL_MODE flag is set, so this Fault will only occur
    # during code development.
    my $rLL = $self->[_rLL_];
    foreach my $KK ( 0 .. @{$rLL} - 1 ) {
        my $nvars = @{ $rLL->[$KK] };
        if ( $nvars != _NVARS ) {
            my $NVARS = _NVARS;
            my $type  = $rLL->[$KK]->[_TYPE_];
            $type = '*' unless defined($type);

            # The number of variables per token node is _NVARS and was set when
            # the array indexes were generated. So if the number of variables
            # is different we have done something wrong, like not store all of
            # them in sub 'write_line' when they were received from the
            # tokenizer.
            Fault(
"number of vars for node $KK, type '$type', is $nvars but should be $NVARS"
            );
        }
        foreach my $var ( _TOKEN_, _TYPE_ ) {
            if ( !defined( $rLL->[$KK]->[$var] ) ) {
                my $iline = $rLL->[$KK]->[_LINE_INDEX_];

                # This is a simple check that each token has some basic
                # variables.  In other words, that there are no holes in the
                # array of tokens.  Sub 'write_line' pushes tokens into the
                # $rLL array, so this should guarantee no gaps.
                Fault("Undefined variable $var for K=$KK, line=$iline\n");
            }
        }
    }

    #---------------------------------
    # Check $rK_next_seqno_by_K->[$KK]
    #---------------------------------
    my $Klimit = @{$rLL} - 1;
    my $K_last_seqno;
    my $rK_next_seqno_by_K = $self->[_rK_next_seqno_by_K_];
    foreach my $KK ( 0 .. $Klimit ) {
        my $K_next_seqno = $rK_next_seqno_by_K->[$KK];
        if ( !defined($K_next_seqno) ) { $K_last_seqno = $KK; last }
        if ( $K_next_seqno <= $KK || $K_next_seqno > $Klimit ) {
            Fault(<<EOM);
Error detected in array rK_next_seqno_by_K with limit K=$Klimit:
at K=$KK the next seqno is $K_next_seqno
K_next_seqno = $K_next_seqno is Out of bounds
EOM
        }
        if ( !$rLL->[$K_next_seqno]->[_TYPE_SEQUENCE_] ) {
            Fault(<<EOM);
Error detected in array rK_next_seqno_by_K with limit K=$Klimit:
at K=$KK the next seqno is $K_next_seqno:
K_next_seqno = $K_next_seqno does not have a sequence number
EOM
        }
    }

    # upon hitting an undef, the remaining values should also be undef
    if ( defined($K_last_seqno) ) {
        foreach my $KK ( $K_last_seqno + 1 .. $Klimit ) {
            my $Ktest = $rK_next_seqno_by_K->[$KK];
            next if ( !defined($Ktest) );
            Fault(<<EOM);
Error detected in array rK_next_seqno_by_K with limit K=$Klimit
with first undef at $K_last_seqno
at K=$KK the next seqno is defined and is $Ktest
EOM
        }
    }

    #-----------------------------
    # Check hash $rparent_of_seqno
    #-----------------------------
    my $rparent_of_seqno = $self->[_rparent_of_seqno_];
    foreach my $seqno ( keys %{$rparent_of_seqno} ) {

        # parent sequence numbers must always be less
        my $seqno_parent = $rparent_of_seqno->{$seqno};
        if ( $seqno_parent >= $seqno ) {
            Fault(<<EOM);
Error detected in hash rparent_of_seqno:
The parent of seqno=$seqno is $seqno_parent but it should be less
EOM
        }
    }
    return;
} ## end sub check_token_array

{    ## begin closure check_line_hashes

    # This code checks that no auto-vivification occurs in the 'line' hash

    my %valid_line_hash;

    BEGIN {

        # These keys are defined for each line in the formatter
        # Each line must have exactly these quantities
        my @valid_line_keys = qw(
          _curly_brace_depth
          _ending_in_quote
          _guessed_indentation_level
          _line_number
          _line_text
          _line_type
          _paren_depth
          _rK_range
          _square_bracket_depth
          _starting_in_quote
          _ended_in_blank_token
          _code_type

          _ci_level_0
          _level_0
          _nesting_blocks_0
          _nesting_tokens_0
        );

        @valid_line_hash{@valid_line_keys} = (1) x scalar(@valid_line_keys);
    } ## end BEGIN

    sub check_line_hashes {
        my $self   = shift;
        my $rlines = $self->[_rlines_];

        # Note that the keys ending in _0 are only required when a logfile
        # is being saved, so we will just check for unknown keys, but not
        # require an exact match.
        foreach my $rline ( @{$rlines} ) {
            my $iline     = $rline->{_line_number};
            my $line_type = $rline->{_line_type};
            check_keys( $rline, \%valid_line_hash,
                "Checkpoint: line number =$iline,  line_type=$line_type", 0 );
        }
        return;
    } ## end sub check_line_hashes
} ## end closure check_line_hashes

{    ## begin closure for logger routines
    my $logger_object;

    # Called once per file to initialize the logger object
    sub set_logger_object {
        $logger_object = shift;
        return;
    }

    sub get_input_stream_name {
        my $input_stream_name = EMPTY_STRING;
        if ($logger_object) {
            $input_stream_name = $logger_object->get_input_stream_name();
        }
        return $input_stream_name;
    } ## end sub get_input_stream_name

    # interface to Perl::Tidy::Logger routines
    sub warning {
        my ( $msg, ($msg_line_number) ) = @_;

        # Issue a warning message
        # Given:
        #   $msg = text of warning
        #   $msg_line_number = optional line number prefix
        if ($logger_object) {
            $logger_object->warning( $msg, $msg_line_number );
        }
        return;
    } ## end sub warning

    sub complain {
        my ( $msg, ($msg_line_number) ) = @_;

        # Issue a complaint message
        # Given:
        #   $msg = text of complaint
        #   $msg_line_number = optional line number prefix
        if ($logger_object) {
            $logger_object->complain( $msg, $msg_line_number );
        }
        return;
    } ## end sub complain

    sub write_logfile_entry {
        my @msg = @_;
        if ($logger_object) {
            $logger_object->write_logfile_entry(@msg);
        }
        return;
    } ## end sub write_logfile_entry

    sub get_saw_brace_error {
        if ($logger_object) {
            return $logger_object->get_saw_brace_error();
        }
        return;
    } ## end sub get_saw_brace_error

    sub we_are_at_the_last_line {
        if ($logger_object) {
            $logger_object->we_are_at_the_last_line();
        }
        return;
    } ## end sub we_are_at_the_last_line

} ## end closure for logger routines

{    ## begin closure for diagnostics routines
    my $diagnostics_object;

    # Called once per file to initialize the diagnostics object
    sub set_diagnostics_object {
        $diagnostics_object = shift;
        return;
    }

    # Available for debugging but not currently used:
    sub write_diagnostics {
        my ( $msg, $line_number ) = @_;
        if ($diagnostics_object) {
            $diagnostics_object->write_diagnostics( $msg, $line_number );
        }
        return;
    } ## end sub write_diagnostics
} ## end closure for diagnostics routines

sub get_convergence_check {
    my ($self) = @_;
    return $self->[_converged_];
}

sub want_second_iteration {
    my ($self) = @_;
    return $self->[_want_second_iteration_];
}

sub get_output_line_number {
    my ($self) = @_;
    my $vao = $self->[_vertical_aligner_object_];
    return $vao->get_output_line_number();
}

sub want_blank_line {
    my $self = shift;
    $self->flush();
    my $file_writer_object = $self->[_file_writer_object_];
    $file_writer_object->want_blank_line();
    return;
} ## end sub want_blank_line

sub write_unindented_line {
    my ( $self, $line ) = @_;
    $self->flush();
    my $file_writer_object = $self->[_file_writer_object_];
    $file_writer_object->write_line($line);
    return;
} ## end sub write_unindented_line

sub dump_verbatim {
    my $self = shift;

    # Dump the input file to the output verbatim. This is called when
    # there is a severe error and formatted output cannot be made.
    my $rlines = $self->[_rlines_];
    foreach my $line ( @{$rlines} ) {
        my $input_line = $line->{_line_text};
        $self->write_unindented_line($input_line);
    }
    return;
} ## end sub dump_verbatim

sub consecutive_nonblank_lines {
    my ($self)             = @_;
    my $file_writer_object = $self->[_file_writer_object_];
    my $vao                = $self->[_vertical_aligner_object_];
    return $file_writer_object->get_consecutive_nonblank_lines() +
      $vao->get_cached_line_count();
} ## end sub consecutive_nonblank_lines

sub split_words {

    # Given: a string containing words separated by whitespace,
    # Return: the corresponding list of words
    my ($str) = @_;
    return unless defined($str);
    $str =~ s/\s+$//;
    $str =~ s/^\s+//;
    return unless length($str);
    return split /\s+/, $str;
} ## end sub split_words

sub K_next_code {
    my ( $self, $KK, ($rLL) ) = @_;

    # Given:
    #   $KK  = index of a token in $rLL
    #   $rLL = optional token array to use (default is $self->[_rLL_])
    # Return:
    #   The index of the next nonblank, non-comment token after $KK, or
    #   undef if none

    return if ( !defined($KK) );
    return if ( $KK < 0 );

    # The optional third arg is useful when we are copying tokens from an old
    # $rLL to a new $rLL array.
    $rLL = $self->[_rLL_] if ( !defined($rLL) );

    my $Num = @{$rLL};
    while ( ++$KK < $Num ) {
        my $type = $rLL->[$KK]->[_TYPE_];
        if ( $type ne 'b' && $type ne '#' ) {
            return $KK;
        }
    } ## end while ( ++$KK < $Num )

    return;
} ## end sub K_next_code

sub K_next_nonblank {
    my ( $self, $KK, ($rLL) ) = @_;

    # Given:
    #   $KK  = index of a token in $rLL
    #   $rLL = optional token array to use (default is $self->[_rLL_])
    # Return:
    #   The index of the next nonblank token after $KK, or
    #   undef if none

    # NOTE: does not skip over the leading type 'q' of a hanging side comment
    # (use K_next_code)
    return if ( !defined($KK) );
    return if ( $KK < 0 );

    # use the standard array unless given otherwise
    $rLL = $self->[_rLL_] if ( !defined($rLL) );

    # Normally, consecutive blanks do not occur. We could test for that
    # here, but there are checks in the 'store_token' subs.
    my $Num = @{$rLL};
    while ( ++$KK < $Num ) {
        if ( $rLL->[$KK]->[_TYPE_] ne 'b' ) { return $KK }
    }

    return;
} ## end sub K_next_nonblank

sub K_previous_code {

    my ( $self, $KK, ($rLL) ) = @_;

    # Given:
    #   $KK  = index of a token in $rLL
    #   $rLL = optional token array to use (default is $self->[_rLL_])
    # Return:
    #   The index of the previous nonblank, non-comment token after $KK, or
    #   undef if none
    # Call with $KK=undef to start search at the top of the array

    # The optional third arg is useful when we are copying tokens from an old
    # $rLL to a new $rLL array.
    $rLL = $self->[_rLL_] unless ( defined($rLL) );

    my $Num = @{$rLL};
    if ( !defined($KK) ) { $KK = $Num }

    if ( $KK > $Num ) {

        # This fault can be caused by a programming error in which a bad $KK is
        # given.  The caller should make the first call with KK_new=undef to
        # avoid this error.
        if (DEVEL_MODE) {
            Fault(<<EOM);
Program Bug: K_previous_nonblank_new called with K=$KK which exceeds $Num
EOM
        }
        return;
    }

    while ( --$KK >= 0 ) {
        my $type = $rLL->[$KK]->[_TYPE_];
        if ( $type ne 'b' && $type ne '#' ) { return $KK }
    }
    return;
} ## end sub K_previous_code

sub K_previous_nonblank {

    my ( $self, $KK, ($rLL) ) = @_;

    # Given:
    #   $KK  = index of a token in $rLL
    #   $rLL = optional token array to use (default is $self->[_rLL_])
    # Return:
    #   The index of the previous nonblank token after $KK, or
    #   undef if none
    # Call with $KK=undef to start search at the top of the array

    # NOTE: does not skip over the leading type 'q' of a hanging side comment
    # (use K_previous_code)

    # use the standard array unless given otherwise
    $rLL = $self->[_rLL_] unless ( defined($rLL) );
    my $Num = @{$rLL};
    if ( !defined($KK) ) { $KK = $Num }

    if ( $KK > $Num ) {

        # This fault can be caused by a programming error in which a bad $KK is
        # given.  The caller should make the first call with KK_new=undef to
        # avoid this error.
        if (DEVEL_MODE) {
            Fault(<<EOM);
Program Bug: K_previous_nonblank_new called with K=$KK which exceeds $Num
EOM
        }
        return;
    }

    # Normally, consecutive blanks do not occur. We could test for that
    # here, but there are checks in the 'store_token' subs.
    while ( --$KK >= 0 ) {
        if ( $rLL->[$KK]->[_TYPE_] ne 'b' ) { return $KK }
    }

    return;
} ## end sub K_previous_nonblank

sub K_first_code {

    my ( $self, ($rLL) ) = @_;

    # Given:
    #   $rLL = optional token array to override default
    # Return:
    #   index $K of first non-blank, non-comment code token, or
    #   undef if none (no tokens in the file)

    $rLL = $self->[_rLL_] unless ( defined($rLL) );

    return unless @{$rLL};
    my $KK   = 0;
    my $type = $rLL->[$KK]->[_TYPE_];
    if ( $type ne 'b' && $type ne '#' ) { return $KK }
    return $self->K_next_code($KK);
} ## end sub K_first_code

sub K_last_code {

    my ( $self, ($rLL) ) = @_;

    # Given:
    #   $rLL = optional token array to override default
    # Return:
    #   index of last non-blank, non-comment code token, or
    #   undef if none (no tokens in the file)

    $rLL = $self->[_rLL_] unless ( defined($rLL) );

    return unless @{$rLL};
    my $KK   = @{$rLL} - 1;
    my $type = $rLL->[$KK]->[_TYPE_];
    if ( $type ne 'b' && $type ne '#' ) { return $KK }
    return $self->K_previous_code($KK);
} ## end sub K_last_code

sub get_parent_containers {
    my ( $self, $seqno ) = @_;

    # Given:
    #   $seqno = sequence number of a container
    # Return:
    #   ref to a list of parent container sequence numbers
    my @list;
    if ($seqno) {
        my $rparent_of_seqno = $self->[_rparent_of_seqno_];
        my $seqno_last       = $seqno;
        while ( $seqno = $rparent_of_seqno->{$seqno} ) {
            last if ( $seqno == SEQ_ROOT );
            if ( $seqno >= $seqno_last ) {
                ## shouldn't happen - parent containers have lower seq numbers
                DEVEL_MODE && Fault(<<EOM);
Error in 'rparent_of_seqno': expecting seqno=$seqno < last seqno=$seqno_last
EOM
                last;
            }
            $seqno_last = $seqno;
            push @list, $seqno;
        } ## end while ( $seqno = $rparent_of_seqno...)
    }
    return \@list;
} ## end sub get_parent_containers

sub mark_parent_containers {
    my ( $self, $seqno, $rhash, ($value) ) = @_;

    # Task:
    #   set $rhash->{$seqno}=$value for all parent containers
    #       but not for $seqno itself

    # Given:
    #   $seqno = sequence number of a container
    #   $rhash = ref to a hash with seqno as key
    #   $value = value for setting $rhash->{$seqno}=$value
    #            default = 1

    return unless ($seqno);
    if ( !defined($value) ) { $value = 1 }
    my $rparent_of_seqno = $self->[_rparent_of_seqno_];
    my $seqno_last       = $seqno;
    while ( $seqno = $rparent_of_seqno->{$seqno} ) {
        last if ( $seqno == SEQ_ROOT );
        if ( $seqno >= $seqno_last ) {
            ## shouldn't happen - parent containers have lower sequence numbers
            DEVEL_MODE && Fault(<<EOM);
Error in 'rparent_of_seqno': expecting seqno=$seqno < last seqno=$seqno_last
EOM
            last;
        }
        $seqno_last = $seqno;
        $rhash->{$seqno} = $value;
    } ## end while ( $seqno = $rparent_of_seqno...)
    return;
} ## end sub mark_parent_containers

sub copy_token_as_type {

    # This provides a quick way to create a new token by
    # slightly modifying an existing token.
    my ( $rold_token, $type, $token ) = @_;

    my @rnew_token = @{$rold_token};
    $rnew_token[_TYPE_]          = $type;
    $rnew_token[_TOKEN_]         = $token;
    $rnew_token[_TYPE_SEQUENCE_] = EMPTY_STRING;
    return \@rnew_token;
} ## end sub copy_token_as_type

sub parent_seqno_by_K {

    # Return the sequence number of the parent container of token K, if any.

    my ( $self, $KK ) = @_;
    my $rLL = $self->[_rLL_];

    # The task is to jump forward to the next container token
    # and use the sequence number of either it or its parent.

    # For example, consider the following with seqno=5 of the '[' and ']'
    # being called with index K of the first token of each line:

    #                                              # result
    #    push @tests,                              # -
    #      [                                       # -
    #        sub { 99 },   'do {&{%s} for 1,2}',   # 5
    #        '(&{})(&{})', undef,                  # 5
    #        [ 2, 2, 0 ],  0                       # 5
    #      ];                                      # -

    # NOTE: The ending parent will be SEQ_ROOT for a balanced file.  For
    # unbalanced files, last sequence number will either be undefined or it may
    # be at a deeper level.  In either case we will just return SEQ_ROOT to
    # have a defined value and allow formatting to proceed.
    my $parent_seqno = SEQ_ROOT;
    return $parent_seqno if ( !defined($KK) );
    my $type_sequence = $rLL->[$KK]->[_TYPE_SEQUENCE_];
    if ($type_sequence) {
        $parent_seqno = $self->[_rparent_of_seqno_]->{$type_sequence};
    }
    else {
        my $Kt = $self->[_rK_next_seqno_by_K_]->[$KK];
        if ( defined($Kt) ) {
            $type_sequence = $rLL->[$Kt]->[_TYPE_SEQUENCE_];
            my $type = $rLL->[$Kt]->[_TYPE_];

            # if next container token is closing, it is the parent seqno
            if ( $is_closing_type{$type} ) {
                $parent_seqno = $type_sequence;
            }

            # otherwise we want its parent container
            else {
                $parent_seqno = $self->[_rparent_of_seqno_]->{$type_sequence};
            }
        }
    }
    $parent_seqno = SEQ_ROOT if ( !defined($parent_seqno) );
    return $parent_seqno;
} ## end sub parent_seqno_by_K

sub parent_sub_seqno {
    my ( $self, $seqno_paren ) = @_;

    # Find sequence number of the named sub (not asub) which contains a given
    # sequenced item

    # Given:
    #  $seqno_paren = sequence number of a token within the sub
    # Returns:
    #  $seqno of the sub, or
    #  nothing if no sub found
    return unless defined($seqno_paren);

    # Search upward
    my $seqno      = $seqno_paren;
    my $seqno_last = $seqno_paren;
    while ( $seqno = $self->[_rparent_of_seqno_]->{$seqno} ) {
        last if ( $seqno == SEQ_ROOT );
        if ( $self->[_ris_sub_block_]->{$seqno} ) {
            return $seqno;
        }
        if ( $seqno >= $seqno_last ) {
            ## shouldn't happen - parent containers have lower sequence numbers
            DEVEL_MODE && Fault(<<EOM);
Error in 'rparent_of_seqno': expecting seqno=$seqno < last seqno=$seqno_last
EOM
            last;
        }
        $seqno_last = $seqno;
    } ## end while ( $seqno = $self->[...])
    return;
} ## end sub parent_sub_seqno

sub parent_sub_seqno_by_K {
    my ( $self, $KK ) = @_;

    #--------------------------------------------------------------------
    # NOTE: not currently called but keep for possible future development
    #--------------------------------------------------------------------

    # Find sequence number of the named sub which contains a given token
    # Given:
    #  $K = index K of a token
    # Returns:
    #  $seqno of the sub, or
    #  nothing if no sub found

    return unless defined($KK);

    my $seqno_sub;
    my $parent_seqno = $self->parent_seqno_by_K($KK);
    if ( $self->[_ris_sub_block_]->{$parent_seqno} ) {
        $seqno_sub = $parent_seqno;
    }
    else {
        $seqno_sub = $self->parent_sub_seqno($parent_seqno);
    }
    return $seqno_sub;
} ## end sub parent_sub_seqno_by_K

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

    # Return true if
    #     token at i is contained in a BLOCK
    #     or is at root level
    #     or there is some kind of error (i.e. unbalanced file)
    # Return false otherwise

    if ( $i < 0 ) {
        DEVEL_MODE && Fault("Bad call, i='$i'\n");
        return 1;
    }

    my $seqno = $parent_seqno_to_go[$i];
    return 1 if ( !$seqno || $seqno == SEQ_ROOT );
    return 1 if ( $self->[_rblock_type_of_seqno_]->{$seqno} );
    return;
} ## end sub is_in_block_by_i

sub is_in_block_by_K {
    my ( $self, $KK ) = @_;

    # Return true if
    #     token at $KK is contained in a BLOCK
    #     or is at root level
    #     or there is some kind of error (i.e. unbalanced file)
    # Return false otherwise

    my $parent_seqno = $self->parent_seqno_by_K($KK);
    return SEQ_ROOT if ( !$parent_seqno || $parent_seqno == SEQ_ROOT );
    return $self->[_rblock_type_of_seqno_]->{$parent_seqno};
} ## end sub is_in_block_by_K

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

    # Return true if token at i is contained in a LIST
    # Return false otherwise
    my $seqno = $parent_seqno_to_go[$i];
    return if ( !$seqno );
    return if ( $seqno == SEQ_ROOT );
    if ( $self->[_ris_list_by_seqno_]->{$seqno} ) {
        return 1;
    }
    return;
} ## end sub is_in_list_by_i

sub is_list_by_seqno {

    # Return true if the immediate contents of a container appears to be a
    # list.
    my ( $self, $seqno ) = @_;
    return unless defined($seqno);
    return $self->[_ris_list_by_seqno_]->{$seqno};
} ## end sub is_list_by_seqno

sub is_interpolated_here_doc {
    my ($token) = @_;

    # Given:
    #  $token = the token text of a type 'h' token
    # Return:
    #  true if the here doc is interpolated
    #  false if not

    # Examples:
    #  <<EOM          <-- interpolated
    #  <<"EOM"        <-- interpolated
    #  <<'EOM'        <-- not interpolated
    return $token !~ /^ [^<]* << [~]? \' /x;
} ## end sub is_interpolated_here_doc

sub get_here_text {
    my ( $self, $ix_HERE_BEG ) = @_;

    # Collect the text of a here-doc
    # Given:
    #   $ix_HERE_BEG = index of the line BEFORE the start of this here-doc
    # Returns:
    #   $ix_HERE_END = line index of the last line of this here-doc
    #   $here_text = the here-doc text

    # Example of $here_text with 2 lines:

    # my $str=<<EOM;     <--this line has index $ix_HERE_BEG
    # here text line 1
    # here text line 2
    # EOM                <--this line has index $ix_HERE_END

    # If here-docs are stacked, then caller will use $ix_HERE_END as
    # the beginning of the next here-doc.

    my $rlines = $self->[_rlines_];

    # Loop to collect the here doc text
    my $ix_max = @{$rlines} - 1;
    my $ix     = $ix_HERE_BEG;
    my $ix_HERE_END;
    my $here_text = EMPTY_STRING;
    while ( ++$ix <= $ix_max ) {
        my $lhash = $rlines->[$ix];
        my $ltype = $lhash->{_line_type};
        if ( $ltype eq 'HERE' ) {
            $here_text .= $lhash->{_line_text};
            next;
        }
        elsif ( $ltype eq 'HERE_END' ) {
            $ix_HERE_END = $ix;
            last;
        }
        else {
            DEVEL_MODE
              && Fault("line_type=$ltype should be HERE..\n");
            $ix_HERE_END = $ix;
            last;
        }
    } ## end while ( ++$ix <= $ix_max )
    return ( $ix_HERE_END, $here_text );
} ## end sub get_here_text

sub is_trailing_comma {
    my ( $self, $KK ) = @_;

    # Given:
    #   $KK - index of a comma in token list
    # Return:
    #   true if the comma at index $KK is a trailing comma
    #   false if not

    my $rLL     = $self->[_rLL_];
    my $type_KK = $rLL->[$KK]->[_TYPE_];
    if ( $type_KK ne ',' ) {
        DEVEL_MODE
          && Fault("Bad call: expected type ',' but received '$type_KK'\n");
        return;
    }
    my $Knnb = $self->K_next_nonblank($KK);
    if ( defined($Knnb) ) {
        my $type_sequence = $rLL->[$Knnb]->[_TYPE_SEQUENCE_];
        my $type_Knnb     = $rLL->[$Knnb]->[_TYPE_];
        if ( $type_sequence && $is_closing_type{$type_Knnb} ) {
            return 1;
        }
    }
    return;
} ## end sub is_trailing_comma

sub cumulative_length_before_K {
    my ( $self, $KK ) = @_;

    # Returns the cumulative character length from the first token to
    # token before the token at index $KK.
    my $rLL = $self->[_rLL_];
    return ( $KK <= 0 ) ? 0 : $rLL->[ $KK - 1 ]->[_CUMULATIVE_LENGTH_];
} ## end sub cumulative_length_before_K

###########################################
# CODE SECTION 3: Check and process options
###########################################

sub check_options {

    # This routine is called to check the user-supplied run parameters
    # and to configure the control hashes to them.
    ( $rOpts, my $wvt_in_args, my $num_files, my $line_range_clipped ) = @_;

    initialize_whitespace_hashes();

    if ( $rOpts->{'dump-want-left-space'} ) {
        dump_want_left_space(*STDOUT);
        Exit(0);
    }

    if ( $rOpts->{'dump-want-right-space'} ) {
        dump_want_right_space(*STDOUT);
        Exit(0);
    }

    initialize_bond_strength_hashes();

    # This function must be called early to get hashes with grep initialized
    initialize_grep_and_friends();

    # Make needed regex patterns for matching text.
    # NOTE: sub_matching_patterns must be made first because later patterns use
    # them; see RT #133130.
    make_sub_matching_pattern();    # MUST BE FIRST pattern made
    make_static_block_comment_pattern();
    make_static_side_comment_pattern();
    $format_skipping_pattern_begin =
      make_format_skipping_pattern( 'format-skipping-begin', '#<<<' );
    $format_skipping_pattern_end =
      make_format_skipping_pattern( 'format-skipping-end', '#>>>' );
    make_non_indenting_brace_pattern();

    initialize_closing_side_comments();

    initialize_missing_else_comment();

    initialize_call_paren_style();

    initialize_warn_variable_types( $wvt_in_args, $num_files,
        $line_range_clipped );

    initialize_warn_mismatched();

    make_bli_pattern();

    make_bl_pattern();

    make_block_brace_vertical_tightness_pattern();

    make_blank_line_pattern();

    make_keyword_group_list_pattern();

    prepare_cuddled_block_types();

    if ( $rOpts->{'dump-cuddled-block-list'} ) {
        dump_cuddled_block_list(*STDOUT);
        Exit(0);
    }

    # --indent-only skips the call to sub respace_tokens, which defines
    # some essential data structures needed by some dump routines,
    # or might be in the future. Since there is an immediate exit after a
    # dump, we can turn off indent-only to get these structures for a -dump.
    if ( $rOpts->{'indent-only'} ) {

        if (   $rOpts->{'dump-mismatched-args'}
            || $rOpts->{'dump-mismatched-returns'} )
        {
            $rOpts->{'indent-only'} = 0;
        }

        if ( $rOpts->{'dump-block-summary'} ) {
            $rOpts->{'indent-only'} = 0;
        }
    }

    initialize_line_up_parentheses();

    check_tabs();

    # We should put an upper bound on any -sil=n value. Otherwise enormous
    # files could be created by mistake.
    for ( $rOpts->{'starting-indentation-level'} ) {
        if ( $_ && $_ > 100 ) {
            Warn(<<EOM);
The value --starting-indentation-level=$_ is very large; a mistake? resetting to 0;
EOM
            $_ = 0;
        }
    }

    # Require -msp > 0 to avoid future parsing problems (issue c147)
    for ( $rOpts->{'minimum-space-to-comment'} ) {
        if ( !$_ || $_ <= 0 ) { $_ = 1 }
    }

    initialize_outdent_keyword();

    initialize_keyword_paren_inner_tightness();

    initialize_space_after_keyword();

    initialize_extended_block_tightness_list();

    # The flag '$controlled_comma_style' will be set if the user
    # entered any of -wbb=',' -wba=',' -kbb=',' -kba=','
    # see sub 'initialize_token_break_preferences',
    # and sub 'initialize_old_breakpoint_controls'
    $controlled_comma_style = 0;
    initialize_token_break_preferences();
    initialize_old_breakpoint_controls();

    initialize_container_indentation_options();

    # make -l=0 equal to -l=infinite
    if ( !$rOpts->{'maximum-line-length'} ) {
        $rOpts->{'maximum-line-length'} = 1_000_000;
    }

    # make -lbl=0 equal to -lbl=infinite
    if ( !$rOpts->{'long-block-line-count'} ) {
        $rOpts->{'long-block-line-count'} = 1_000_000;
    }

    initialize_tightness_vars();

    initialize_multiple_token_tightness();

    initialize_global_option_vars();

    initialize_line_length_vars();    # after 'initialize_global_option_vars'

    initialize_trailing_comma_break_rules();

    initialize_trailing_comma_rules();    # after 'initialize_line_length_vars'
                                          # and '_trailing_comma_break_rules'

    initialize_interbracket_arrow_style();

    initialize_weld_nested_exclusion_rules();

    initialize_weld_fat_comma_rules();

    initialize_lpxl_lpil();

    return;
} ## end sub check_options

use constant ALIGN_GREP_ALIASES => 0;

sub initialize_grep_and_friends {

    # Initialize or re-initialize hashes with 'grep' and grep aliases. This
    # must be done after each set of options because new grep aliases may be
    # used.

    # re-initialize the hashes ... this is critical!
    %is_sort_map_grep = ();

    my @q = qw( sort map grep );
    @is_sort_map_grep{@q} = (1) x scalar(@q);

    my $olbxl = $rOpts->{'one-line-block-exclusion-list'};
    my %is_olb_exclusion_word;
    if ( defined($olbxl) ) {
        my @list = split_words($olbxl);
        if (@list) {
            @is_olb_exclusion_word{@list} = (1) x scalar(@list);
        }
    }

    # Make the list of block types which may be re-formed into one line.
    # They will be modified with the grep-alias-list below and
    # by sub 'prepare_cuddled_block_types'.
    # Note that it is essential to always re-initialize the hash here:
    %want_one_line_block = ();
    if ( !$is_olb_exclusion_word{'*'} ) {
        foreach (qw( sort map grep eval )) {
            if ( !$is_olb_exclusion_word{$_} ) { $want_one_line_block{$_} = 1 }
        }
    }

    # Note that any 'grep-alias-list' string has been preprocessed to be a
    # trimmed, space-separated list.
    my $str = $rOpts->{'grep-alias-list'};
    my @grep_aliases = split /\s+/, $str;

    if (@grep_aliases) {

        @is_sort_map_grep{@grep_aliases} = (1) x scalar(@grep_aliases);

        if ( $want_one_line_block{'grep'} ) {
            @want_one_line_block{@grep_aliases} = (1) x scalar(@grep_aliases);
        }
    }

    %is_sort_map_grep_eval = %is_sort_map_grep;
    $is_sort_map_grep_eval{'eval'} = 1;

    %is_sort_map_grep_eval_do = %is_sort_map_grep_eval;
    $is_sort_map_grep_eval_do{'do'} = 1;

    # These block types can take ci.  This is used by the -xci option.
    # Note that the 'sub' in this list is an anonymous sub.  To be more correct
    # we could remove sub and use ASUB pattern to also handle a
    # prototype/signature.  But that would slow things down and would probably
    # never be useful.
    %is_block_with_ci = %is_sort_map_grep_eval_do;
    $is_block_with_ci{'sub'} = 1;

    @q = qw( grep keys map reverse sort split );
    push @q, @grep_aliases;
    %is_keyword_returning_list = ();
    @is_keyword_returning_list{@q} = (1) x scalar(@q);

    # This code enables vertical alignment of grep aliases for testing.  It has
    # not been found to be beneficial, so it is off by default.  But it is
    # useful for precise testing of the grep alias coding.
    if (ALIGN_GREP_ALIASES) {
        %block_type_map = (
            'unless'  => 'if',
            'else'    => 'if',
            'elsif'   => 'if',
            'when'    => 'if',
            'default' => 'if',
            'case'    => 'if',
            'sort'    => 'map',
            'grep'    => 'map',
        );
        foreach (@q) {
            $block_type_map{$_} = 'map' unless ( $_ eq 'map' );
        }
    }
    return;
} ## end sub initialize_grep_and_friends

sub initialize_weld_nested_exclusion_rules {
    %weld_nested_exclusion_rules = ();

    my $opt_name = 'weld-nested-exclusion-list';
    my $str      = $rOpts->{$opt_name};

    # let a '0' be the same as not defined
    return unless ($str);
    $str =~ s/^\s+//;
    $str =~ s/\s+$//;
    return unless ($str);

    # There are four container tokens.
    my %token_keys = (
        '(' => '(',
        '[' => '[',
        '{' => '{',
        'q' => 'q',
    );

    # We are parsing an exclusion list for nested welds. The list is a string
    # with spaces separating any number of items.  Each item consists of three
    # pieces of information:
    # <optional position> <optional type> <type of container>
    # <     ^ or .      > <    k or K   > <     ( [ {       >

    # The last character is the required container type and must be one of:
    # ( = paren
    # [ = square bracket
    # { = brace

    # An optional leading position indicator:
    # ^ means the leading token position in the weld
    # . means a secondary token position in the weld
    #   no position indicator means all positions match

    # An optional alphanumeric character between the position and container
    # token selects to which the rule applies:
    # k = any keyword
    # K = any non-keyword
    # f = function call
    # F = not a function call
    # w = function or keyword
    # W = not a function or keyword
    #     no letter means any preceding type matches

    # Examples:
    # ^(  - the weld must not start with a paren
    # .(  - the second and later tokens may not be parens
    # (   - no parens in weld
    # ^K(  - exclude a leading paren not preceded by a keyword
    # .k(  - exclude a secondary paren preceded by a keyword
    # [ {  - exclude all brackets and braces

    my @items = split /\s+/, $str;
    my $msg1;
    my $msg2;
    foreach my $item (@items) {
        my $item_save = $item;
        my $tok       = chop $item;
        my $key       = $token_keys{$tok};
        if ( !defined($key) ) {
            $msg1 .= " '$item_save'";
            next;
        }
        if ( !defined( $weld_nested_exclusion_rules{$key} ) ) {
            $weld_nested_exclusion_rules{$key} = [];
        }
        my $rflags = $weld_nested_exclusion_rules{$key};

        # A 'q' means do not weld quotes
        if ( $tok eq 'q' ) {
            $rflags->[0] = '*';
            $rflags->[1] = '*';
            next;
        }

        my $pos    = '*';
        my $select = '*';
        if ($item) {
            if ( $item =~ /^([\^\.])?([kKfFwW])?$/ ) {
                $pos    = $1 if ($1);
                $select = $2 if ($2);
            }
            else {
                $msg1 .= " '$item_save'";
                next;
            }
        }

        my $err;
        if ( $pos eq '^' || $pos eq '*' ) {
            if ( defined( $rflags->[0] ) && $rflags->[0] ne $select ) {
                $err = 1;
            }
            $rflags->[0] = $select;
        }
        if ( $pos eq '.' || $pos eq '*' ) {
            if ( defined( $rflags->[1] ) && $rflags->[1] ne $select ) {
                $err = 1;
            }
            $rflags->[1] = $select;
        }
        if ($err) { $msg2 .= " '$item_save'"; }
    }
    if ($msg1) {
        Warn(<<EOM);
Unexpecting symbol(s) encountered in --$opt_name will be ignored:
$msg1
EOM
    }
    if ($msg2) {
        Warn(<<EOM);
Multiple specifications were encountered in the --weld-nested-exclusion-list for:
$msg2
Only the last will be used.
EOM
    }
    return;
} ## end sub initialize_weld_nested_exclusion_rules

sub initialize_weld_fat_comma_rules {

    # Initialize a hash controlling which opening token types can be
    # welded around a fat comma
    %weld_fat_comma_rules = ();

    # The -wfc flag turns on welding of '=>' after an opening paren
    if ( $rOpts->{'weld-fat-comma'} ) { $weld_fat_comma_rules{'('} = 1 }

    # This could be generalized in the future by introducing a parameter
    # -weld-fat-comma-after=str (-wfca=str), where str contains any of:
    #    * { [ (
    # to indicate which opening parens may weld to a subsequent '=>'

    # The flag -wfc would then be equivalent to -wfca='('

    # This has not been done because it is not yet clear how useful
    # this generalization would be.
    return;
} ## end sub initialize_weld_fat_comma_rules

sub initialize_lpxl_lpil {

    %line_up_parentheses_control_hash    = ();
    $line_up_parentheses_control_is_lpxl = 1;
    my $lpxl = $rOpts->{'line-up-parentheses-exclusion-list'};
    my $lpil = $rOpts->{'line-up-parentheses-inclusion-list'};
    if ( $lpxl && $lpil ) {
        Warn(<<EOM);
You entered values for both -lpxl=s and -lpil=s; the -lpil list will be ignored
EOM
    }
    if ($lpxl) {
        $line_up_parentheses_control_is_lpxl = 1;
        initialize_line_up_parentheses_control_hash(
            $rOpts->{'line-up-parentheses-exclusion-list'}, 'lpxl' );
    }
    elsif ($lpil) {
        $line_up_parentheses_control_is_lpxl = 0;
        initialize_line_up_parentheses_control_hash(
            $rOpts->{'line-up-parentheses-inclusion-list'}, 'lpil' );
    }
    else {
        # neither -lpxl nor -lpil specified
    }
    return;
} ## end sub initialize_lpxl_lpil

sub initialize_line_up_parentheses_control_hash {
    my ( $str, $opt_name ) = @_;

    # let a 0 be the same as not defined
    return unless ($str);
    $str =~ s/^\s+//;
    $str =~ s/\s+$//;
    return unless ($str);

    # The format is space separated items, where each item must consist of a
    # string with a token type preceded by an optional text token and followed
    # by an integer:
    # For example:
    #    W(1
    #  = (flag1)(key)(flag2), where
    #    flag1 = 'W'
    #    key = '('
    #    flag2 = '1'

    my @items = split /\s+/, $str;
    my $msg1;
    my $msg2;
    foreach my $item (@items) {
        my $item_save = $item;
        my ( $flag1, $key, $flag2 );
        if ( $item =~ /^ ([^\(\[\{]*)?  ([\(\{\[])  (\d)? $/x ) {
            ##             $flag1          $key     $flag2
            $flag1 = $1 if $1;
            $key   = $2 if $2;
            $flag2 = $3 if defined($3);
        }
        else {
            $msg1 .= " '$item_save'";
            next;
        }

        if ( !defined($key) ) {
            $msg1 .= " '$item_save'";
            next;
        }

        # Check for valid flag1
        if ( !defined($flag1) ) { $flag1 = '*' }

        if ( $flag1 !~ /^[kKfFwW\*]$/ ) {
            $msg1 .= " '$item_save'";
            next;
        }

        # Check for valid flag2
        # 0 or blank: ignore container contents
        # 1 all containers with sublists match
        # 2 all containers with sublists, code blocks or ternary operators match
        # ... this could be extended in the future
        if ( !defined($flag2) ) { $flag2 = 0 }

        if ( $flag2 !~ /^[012]$/ ) {
            $msg1 .= " '$item_save'";
            next;
        }

        if ( !defined( $line_up_parentheses_control_hash{$key} ) ) {
            $line_up_parentheses_control_hash{$key} = [ $flag1, $flag2 ];
            next;
        }

        # check for multiple conflicting specifications
        my $rflags = $line_up_parentheses_control_hash{$key};
        my $err;
        if ( defined( $rflags->[0] ) && $rflags->[0] ne $flag1 ) {
            $err = 1;
            $rflags->[0] = $flag1;
        }
        if ( defined( $rflags->[1] ) && $rflags->[1] ne $flag2 ) {
            $err = 1;
            $rflags->[1] = $flag2;
        }
        $msg2 .= " '$item_save'" if ($err);
        next;
    }
    if ($msg1) {
        Warn(<<EOM);
Unexpecting symbol(s) encountered in --$opt_name will be ignored:
$msg1
EOM
    }
    if ($msg2) {
        Warn(<<EOM);
Multiple specifications were encountered in the $opt_name at:
$msg2
Only the last will be used.
EOM
    }

    # Speedup: we can turn off -lp if it is not actually used
    if ($line_up_parentheses_control_is_lpxl) {
        my $all_off = 1;
        foreach my $key (qw# ( { [ #) {
            my $rflags = $line_up_parentheses_control_hash{$key};
            if ( defined($rflags) ) {
                my ( $flag1, $flag2 ) = @{$rflags};
                if ( $flag1 && $flag1 ne '*' ) { $all_off = 0; last }
                if ($flag2)                    { $all_off = 0; last }
            }
        }
        if ($all_off) {
            $rOpts->{'line-up-parentheses'} = EMPTY_STRING;
        }
    }

    return;
} ## end sub initialize_line_up_parentheses_control_hash

sub initialize_space_after_keyword {

    # Default keywords for which space is introduced before an opening paren:
    # (at present, including them messes up vertical alignment)
    my @sak = qw( my local our state and or xor err eq ne if else elsif until
      unless while for foreach return switch case given when catch );
    %space_after_keyword = map { $_ => 1 } @sak;

    # first remove any or all of these if desired
    if ( my @q = split_words( $rOpts->{'nospace-after-keyword'} ) ) {

        # -nsak='*' selects all the above keywords
        if ( @q == 1 && $q[0] eq '*' ) { @q = keys %space_after_keyword }
        @space_after_keyword{@q} = (0) x scalar(@q);
    }

    # then allow user to add to these defaults
    if ( my @q = split_words( $rOpts->{'space-after-keyword'} ) ) {
        @space_after_keyword{@q} = (1) x scalar(@q);
    }

    return;
} ## end sub initialize_space_after_keyword

sub initialize_outdent_keyword {

    # Implement outdenting preferences for keywords
    %outdent_keyword = ();
    my @okw = split_words( $rOpts->{'outdent-keyword-list'} );
    if ( !@okw ) {
        @okw = qw( next last redo goto return );    # defaults
    }

    # FUTURE: if not a keyword, assume that it is an identifier
    foreach (@okw) {
        if ( Perl::Tidy::Tokenizer::is_keyword($_) ) {
            $outdent_keyword{$_} = 1;
        }
        else {
            Warn("ignoring '$_' in -okwl list; not a perl keyword");
        }
    }
    return;
} ## end sub initialize_outdent_keyword

sub initialize_keyword_paren_inner_tightness {

    # Setup hash for -kpit option
    %keyword_paren_inner_tightness = ();
    my $kpit_value = $rOpts->{'keyword-paren-inner-tightness'};
    if ( defined($kpit_value) && $kpit_value != 1 ) {
        my @kpit =
          split_words( $rOpts->{'keyword-paren-inner-tightness-list'} );
        if ( !@kpit ) {
            @kpit = qw( if elsif unless while until for foreach );    # defaults
        }

        # we will allow keywords and user-defined identifiers
        foreach (@kpit) {
            $keyword_paren_inner_tightness{$_} = $kpit_value;
        }
    }
    return;
} ## end sub initialize_keyword_paren_inner_tightness

sub initialize_extended_block_tightness_list {

    # Setup the control hash for --extended-block-tightness

    # keywords taking indirect objects:
    my @k_list = keys %is_indirect_object_taker;

    # type symbols which may precede an opening block brace
    my @t_list = qw( $ @ % & * );
    push @t_list, '$#';

    my @all = ( @k_list, @t_list );

    # We will build the selection in %hash
    # By default the option is 'on' for keywords only (-xbtl='k')
    my %hash;
    @hash{@k_list} = (1) x scalar(@k_list);
    @hash{@t_list} = (0) x scalar(@t_list);

    # This can be overridden with -xbtl="..."
    my $long_name = 'extended-block-tightness-list';
    if ( $rOpts->{$long_name} ) {
        my @words = split_words( $rOpts->{$long_name} );
        my @unknown;

        # Turn everything off
        @hash{@all} = (0) x scalar(@all);

        # Then turn on selections
        foreach my $word (@words) {

            # 'print' etc turns on a specific word or symbol
            if ( defined( $hash{$word} ) ) { $hash{$word} = 1; }

            # 'k' turns on all keywords
            elsif ( $word eq 'k' ) {
                @hash{@k_list} = (1) x scalar(@k_list);
            }

            # 't' turns on all symbols
            elsif ( $word eq 't' ) {
                @hash{@t_list} = (1) x scalar(@t_list);
            }

            # 'kt' same as 'k' and 't' for convenience
            elsif ( $word eq 'kt' ) {
                @hash{@all} = (1) x scalar(@all);
            }

            # Anything else is an error
            else { push @unknown, $word }
        }
        if (@unknown) {
            my $num = @unknown;
            local $LIST_SEPARATOR = SPACE;
            Warn(<<EOM);
$num unrecognized keyword(s) were input with --$long_name :
@unknown
EOM
        }
    }

    # Transfer the result to the global hash
    %extended_block_tightness_list = %hash;

    return;
} ## end sub initialize_extended_block_tightness_list

sub initialize_token_break_preferences {

    # Initialize these global hashes defining break preferences:
    # %want_break_before
    # %break_before_container_types

    my $break_after = sub {
        my @toks = @_;
        foreach my $tok (@toks) {
            if ( $tok eq '?' ) { $tok = ':' }    # patch to coordinate ?/:
            if ( $tok eq ',' ) { $controlled_comma_style = 1 }
            my $lbs = $left_bond_strength{$tok};
            my $rbs = $right_bond_strength{$tok};
            if ( defined($lbs) && defined($rbs) && $lbs < $rbs ) {
                ( $right_bond_strength{$tok}, $left_bond_strength{$tok} ) =
                  ( $lbs, $rbs );
            }
        }
        return;
    }; ## end $break_after = sub

    my $break_before = sub {
        my @toks = @_;
        foreach my $tok (@toks) {
            if ( $tok eq ',' ) { $controlled_comma_style = 1 }
            my $lbs = $left_bond_strength{$tok};
            my $rbs = $right_bond_strength{$tok};
            if ( defined($lbs) && defined($rbs) && $rbs < $lbs ) {
                ( $right_bond_strength{$tok}, $left_bond_strength{$tok} ) =
                  ( $lbs, $rbs );
            }
        }
        return;
    }; ## end $break_before = sub

    $break_after->(@all_operators) if ( $rOpts->{'break-after-all-operators'} );
    $break_before->(@all_operators)
      if ( $rOpts->{'break-before-all-operators'} );

    $break_after->( split_words( $rOpts->{'want-break-after'} ) );
    $break_before->( split_words( $rOpts->{'want-break-before'} ) );

    # Make note if breaks are before certain key types
    # Added '->' for git #171.
    %want_break_before = ();
    foreach my $tok ( @all_operators, ',', '->' ) {
        $want_break_before{$tok} =
          $left_bond_strength{$tok} < $right_bond_strength{$tok};
    }

    # Coordinate ?/: breaks, which must be similar
    # The small strength 0.01 which is added is 1% of the strength of one
    # indentation level and seems to work okay.
    if ( !$want_break_before{':'} ) {
        $want_break_before{'?'}   = $want_break_before{':'};
        $right_bond_strength{'?'} = $right_bond_strength{':'} + 0.01;
        $left_bond_strength{'?'}  = NO_BREAK;
    }

    # Only make a hash entry for the next parameters if values are defined.
    # That allows a quick check to be made later.
    %break_before_container_types = ();
    for ( $rOpts->{'break-before-hash-brace'} ) {
        $break_before_container_types{'{'} = $_ if $_ && $_ > 0;
    }
    for ( $rOpts->{'break-before-square-bracket'} ) {
        $break_before_container_types{'['} = $_ if $_ && $_ > 0;
    }
    for ( $rOpts->{'break-before-paren'} ) {
        $break_before_container_types{'('} = $_ if $_ && $_ > 0;
    }

    # Note: a fix for b1266 previously here is now covered by the
    # updates for b1470, b1474, so it has been removed.

    return;
} ## end sub initialize_token_break_preferences

sub initialize_line_up_parentheses {

    # -xlp implies -lp
    if ( $rOpts->{'extended-line-up-parentheses'} ) {
        $rOpts->{'line-up-parentheses'} ||= 1;
    }

    if ( $rOpts->{'line-up-parentheses'} ) {

        if (   $rOpts->{'indent-only'}
            || !$rOpts->{'add-newlines'}
            || !$rOpts->{'delete-old-newlines'} )
        {
            Warn(<<EOM);
-----------------------------------------------------------------------
Conflict: -lp  conflicts with -io, -fnl, -nanl, or -ndnl; ignoring -lp

The -lp indentation logic requires that perltidy be able to coordinate
arbitrarily large numbers of line breakpoints.  This isn't possible
with these flags.
-----------------------------------------------------------------------
EOM
            $rOpts->{'line-up-parentheses'}          = 0;
            $rOpts->{'extended-line-up-parentheses'} = 0;
        }

        if ( $rOpts->{'whitespace-cycle'} ) {
            Warn(<<EOM);
Conflict: -wc cannot currently be used with the -lp option; ignoring -wc
EOM
            $rOpts->{'whitespace-cycle'} = 0;
        }
    }

    #-----------------------------------------------------------
    # The combination -lp -vmll can be unstable if -ci<2 (b1267)
    #-----------------------------------------------------------
    # The -vmll and -lp parameters do not really work well together.
    # This is a very crude fix for an unusual parameter combination.
    if (   $rOpts->{'variable-maximum-line-length'}
        && $rOpts->{'line-up-parentheses'}
        && $rOpts->{'continuation-indentation'} < 2 )
    {
        $rOpts->{'continuation-indentation'} = 2;
        ##Warn("Increased -ci=n to n=2 for stability with -lp and -vmll\n");
    }

    #-----------------------------------------------------------
    # The combination -lp -vmll -atc -dtc can be unstable
    #-----------------------------------------------------------
    # This fixes b1386 b1387 b1388 which had -wtc='b'
    # Updated to to include any -wtc to fix b1426
    if (   $rOpts->{'variable-maximum-line-length'}
        && $rOpts->{'line-up-parentheses'}
        && $rOpts->{'add-trailing-commas'}
        && $rOpts->{'delete-trailing-commas'}
        && $rOpts->{'want-trailing-commas'} )
    {
        $rOpts->{'delete-trailing-commas'} = 0;
## Issuing a warning message causes trouble with test cases, and this combo is
## so rare that it is unlikely to not occur in practice. So skip warning.
##        Warn(
##"The combination -vmll -lp -atc -dtc can be unstable; turning off -dtc\n"
##        );
    }

    #-----------------------------------------------------------
    # The combination -xlp -xci and ci>i can be unstable (b1466)
    #-----------------------------------------------------------
    # Deactivated: the fix for b1501 also fixed b1466 in a simpler way.
    # So this block can eventually be removed.
    if (   0
        && $rOpts->{'extended-line-up-parentheses'}
        && $rOpts->{'extended-continuation-indentation'}
        && $rOpts->{'continuation-indentation'} > $rOpts->{'indent-columns'}
        && $rOpts->{'indent-columns'} > 1 )
    {
        $rOpts->{'continuation-indentation'} = $rOpts->{'indent-columns'};
        ## This combination is only likely to occur during random testing, so
        ## skip the warning.
        ##Warn("The combination -xlp -xci -ci>-i can be unstable; reducing ci\n");
    }

    return;
} ## end sub initialize_line_up_parentheses

sub check_tabs {

    # At present, tabs are not compatible with the line-up-parentheses style
    # (it would be possible to entab the total leading whitespace
    # just prior to writing the line, if desired).
    if ( $rOpts->{'line-up-parentheses'} && $rOpts->{'tabs'} ) {
        Warn(<<EOM);
Conflict: -t (tabs) cannot be used with the -lp  option; ignoring -t; see -et.
EOM
        $rOpts->{'tabs'} = 0;
    }

    # tabs are not compatible with outdenting..
    if ( $rOpts->{'outdent-keywords'} && $rOpts->{'tabs'} ) {
        Warn(<<EOM);
Conflict: -t (tabs) cannot be used with the -okw options; ignoring -t; see -et.
EOM
        $rOpts->{'tabs'} = 0;
    }

    if ( $rOpts->{'outdent-labels'} && $rOpts->{'tabs'} ) {
        Warn(<<EOM);
Conflict: -t (tabs) cannot be used with the -ola  option; ignoring -t; see -et.
EOM
        $rOpts->{'tabs'} = 0;
    }

    return;
} ## end sub check_tabs

sub initialize_container_indentation_options {

    %container_indentation_options = ();
    foreach my $pair (
        [ 'break-before-hash-brace-and-indent',     '{' ],
        [ 'break-before-square-bracket-and-indent', '[' ],
        [ 'break-before-paren-and-indent',          '(' ],
      )
    {
        my ( $key, $tok ) = @{$pair};
        my $opt = $rOpts->{$key};
        if ( defined($opt) && $opt > 0 && $break_before_container_types{$tok} )
        {

            # (1) -lp is not compatible with opt=2, silently set to opt=0
            # (2) opt=0 and 2 give same result if -i=-ci; but opt=0 is faster
            # (3) set opt=0 if -i < -ci (can be unstable, case b1355)
            if ( $opt == 2 ) {
                if (
                    $rOpts->{'line-up-parentheses'}
                    || ( $rOpts->{'indent-columns'} <=
                        $rOpts->{'continuation-indentation'} )
                  )
                {
                    $opt = 0;
                }
            }
            $container_indentation_options{$tok} = $opt;
        }
    }
    return;
} ## end sub initialize_container_indentation_options

sub initialize_old_breakpoint_controls {

    if ( $rOpts->{'ignore-old-breakpoints'} ) {

        my @conflicts;
        if ( $rOpts->{'break-at-old-method-breakpoints'} ) {
            $rOpts->{'break-at-old-method-breakpoints'} = 0;
            push @conflicts, '--break-at-old-method-breakpoints (-bom)';
        }
        if ( $rOpts->{'break-at-old-comma-breakpoints'} ) {
            $rOpts->{'break-at-old-comma-breakpoints'} = 0;
            push @conflicts, '--break-at-old-comma-breakpoints (-boc)';
        }
        if ( $rOpts->{'break-at-old-semicolon-breakpoints'} ) {
            $rOpts->{'break-at-old-semicolon-breakpoints'} = 0;
            push @conflicts, '--break-at-old-semicolon-breakpoints (-bos)';
        }
        if ( $rOpts->{'keep-old-breakpoints-before'} ) {
            $rOpts->{'keep-old-breakpoints-before'} = EMPTY_STRING;
            push @conflicts, '--keep-old-breakpoints-before (-kbb)';
        }
        if ( $rOpts->{'keep-old-breakpoints-after'} ) {
            $rOpts->{'keep-old-breakpoints-after'} = EMPTY_STRING;
            push @conflicts, '--keep-old-breakpoints-after (-kba)';
        }

        if (@conflicts) {
            my $msg = join( "\n  ",
" Conflict: These conflicts with --ignore-old-breakponts (-iob) will be turned off:",
                @conflicts ) . "\n";
            Warn($msg);
        }

        # Note: These additional parameters are made inactive by -iob.
        # They are silently turned off here because they are on by default.
        # We would generate unexpected warnings if we issued a warning.
        $rOpts->{'break-at-old-keyword-breakpoints'}   = 0;
        $rOpts->{'break-at-old-logical-breakpoints'}   = 0;
        $rOpts->{'break-at-old-ternary-breakpoints'}   = 0;
        $rOpts->{'break-at-old-attribute-breakpoints'} = 0;
    }

    %keep_break_before_type = ();
    initialize_keep_old_breakpoints( $rOpts->{'keep-old-breakpoints-before'},
        'kbb', \%keep_break_before_type );

    %keep_break_after_type = ();
    initialize_keep_old_breakpoints( $rOpts->{'keep-old-breakpoints-after'},
        'kba', \%keep_break_after_type );

    # Modify %keep_break_before and %keep_break_after to avoid conflicts
    # with %want_break_before; fixes b1436.
    # This became necessary after breaks for some tokens were converted
    # from hard to soft (see b1433).
    # We could do this for all tokens, but to minimize changes to existing
    # code we currently only do this for the soft break tokens.
    foreach my $key ( keys %keep_break_before_type ) {
        if (   defined( $want_break_before{$key} )
            && !$want_break_before{$key}
            && $is_soft_keep_break_type{$key} )
        {
            $keep_break_after_type{$key} = $keep_break_before_type{$key};
            delete $keep_break_before_type{$key};
        }
    }
    foreach my $key ( keys %keep_break_after_type ) {
        if (   defined( $want_break_before{$key} )
            && $want_break_before{$key}
            && $is_soft_keep_break_type{$key} )
        {
            $keep_break_before_type{$key} = $keep_break_after_type{$key};
            delete $keep_break_after_type{$key};
        }
    }

    $controlled_comma_style ||= $keep_break_before_type{','};
    $controlled_comma_style ||= $keep_break_after_type{','};

    return;
} ## end sub initialize_old_breakpoint_controls

use constant DEBUG_KB => 0;

sub initialize_keep_old_breakpoints {
    my ( $str, $short_name, $rkeep_break_hash ) = @_;

    # 0 will be treated same as not defined
    return unless $str;

    my %flags = ();
    my @list  = split_words($str);
    if ( DEBUG_KB && @list ) {
        local $LIST_SEPARATOR = SPACE;
        print <<EOM;
DEBUG_KB entering for '$short_name' with str=$str\n";
list is: @list;
EOM
    }

    # Ignore kbb='(' and '[' and '{': can cause unstable math formatting
    # (issues b1346, b1347, b1348) and likewise ignore kba=')' and ']' and '}'
    # Also always ignore ? and : (b1440 and b1433-b1439)
    if ( $short_name eq 'kbb' ) {
        @list = grep { !m/[\(\[\{\?\:]/ } @list;
    }
    elsif ( $short_name eq 'kba' ) {
        @list = grep { !m/[\)\]\}\?\:]/ } @list;
    }
    else {
        Fault(<<EOM);
Bad call arg - received short name '$short_name' but expecting 'kbb' or 'kba'
EOM
    }

    # pull out any any leading container code, like f( or *{
    # For example: 'f(' becomes flags hash entry '(' => 'f'
    foreach my $item (@list) {
        if ( $item =~ /^( [ \w\* ] )( [ \{\(\[\}\)\] ] )$/x ) {
            $item = $2;
            $flags{$2} = $1;
        }
    }

    my @unknown_types;
    foreach my $type (@list) {
        if ( !Perl::Tidy::Tokenizer::is_valid_token_type($type) ) {
            push @unknown_types, $type;
        }
    }

    if (@unknown_types) {
        my $num = @unknown_types;
        local $LIST_SEPARATOR = SPACE;
        Warn(<<EOM);
$num unrecognized token types were input with --$short_name :
@unknown_types
EOM
    }

    @{$rkeep_break_hash}{@list} = (1) x scalar(@list);

    foreach my $key ( keys %flags ) {
        my $flag = $flags{$key};

        if ( length($flag) != 1 ) {
            Warn(<<EOM);
Multiple entries given for '$key' in '$short_name'
EOM
        }
        elsif ( ( $key eq '(' || $key eq ')' ) && $flag !~ /^[kKfFwW\*]$/ ) {
            Warn(<<EOM);
Unknown flag '$flag' given for '$key' in '$short_name'
EOM
        }
        elsif ( ( $key eq '}' || $key eq '}' ) && $flag !~ /^[bB\*]$/ ) {
            Warn(<<EOM);
Unknown flag '$flag' given for '$key' in '$short_name'
EOM
        }
        else {
            # no error seen
        }

        $rkeep_break_hash->{$key} = $flag;
    }

    if ( DEBUG_KB && @list ) {
        my @tmp = %flags;
        local $LIST_SEPARATOR = SPACE;
        print <<EOM;

DEBUG_KB -$short_name flag: $str
final keys:  @list
special flags:  @tmp
EOM

    }

    return;

} ## end sub initialize_keep_old_breakpoints

sub initialize_tightness_vars {

    # hashes used to simplify setting whitespace
    %tightness = (
        '{' => $rOpts->{'brace-tightness'},
        '}' => $rOpts->{'brace-tightness'},
        '(' => $rOpts->{'paren-tightness'},
        ')' => $rOpts->{'paren-tightness'},
        '[' => $rOpts->{'square-bracket-tightness'},
        ']' => $rOpts->{'square-bracket-tightness'},
    );

    return;
} ## end sub initialize_tightness_vars

sub initialize_multiple_token_tightness {

    # Initialization for --multiple-token-tightness
    %multiple_token_tightness = ();

    my $opt_name = 'multiple-token-tightness';
    my $opt      = $rOpts->{$opt_name};

    # The default is to add spaces for the double diamond
    if ( !$opt ) {
        $multiple_token_tightness{'<<>>'} = 1;
        return;
    }

    # These are valid input words for perltidy token types
    # Note that 'qw' will be translated into the actual token type 'q'
    my %is_type_option;
    my @type_options = qw( <<>> qw Q h );
    @is_type_option{@type_options} = (1) x scalar(@type_options);

    # These are valid input words subtypes of token type 'Q'.
    # Note qw must be treated specially and is in the previous list.
    my %is_Q_subtype_option;
    my @Q_subtype_options = qw( q qq qx qr s y tr m );
    @is_Q_subtype_option{@Q_subtype_options} =
      (1) x scalar(@Q_subtype_options);

    my %is_valid_term = ( %is_type_option, %is_Q_subtype_option );

    # Words can be negated by prefixing with the following character:
    my $neg_char = '^';

    # Scan the input
    my %positive_input;
    my %negative_input;
    my $error_string = EMPTY_STRING;
    if ( defined($opt) ) {
        my @list = split_words($opt);
        foreach my $word (@list) {

            # The special word 'q*' means all of the Q_subtypes plus 'qw'
            if ( $word eq 'q*' ) {
                foreach (@Q_subtype_options) { $positive_input{$_} = 1 }
                $positive_input{'qw'} = 1;
            }
            elsif ( $word eq $neg_char . 'q*' ) {
                foreach (@Q_subtype_options) { $negative_input{$_} = 1 }
                $negative_input{'qw'} = 1;
            }
            elsif ( $is_valid_term{$word} ) {
                $positive_input{$word} = 1;
            }
            elsif ( substr( $word, 0, 1 ) eq $neg_char
                && $is_valid_term{ substr( $word, 1 ) } )
            {
                $negative_input{ substr( $word, 1 ) } = 1;
            }
            else {
                $error_string .= "$word ";
            }
        }
    }

    if ($error_string) {
        $error_string =~ s/\s+$//;
        Warn(<<EOM);
Ignoring these unknown terms in --$opt_name: '$error_string'
EOM
    }

    # The token '<<>>' is always a default unless rejected
    if ( !$negative_input{'<<>>'} ) {
        $positive_input{'<<>>'} = 1;
    }

    # Now construct the control hash
    my @Q_subtype_list;
    foreach my $word ( keys %positive_input ) {

        # negative has priority over positive
        next if ( $negative_input{$word} );

        if ( $is_type_option{$word} ) {
            if ( $word eq 'qw' ) { $word = 'q' }
            $multiple_token_tightness{$word} = 1;
        }
        elsif ( $is_Q_subtype_option{$word} ) {
            push @Q_subtype_list, $word;
        }
        else {
            # something is wrong; previous checks should prevent arriving here
            DEVEL_MODE
              && Fault(
                "unexpected word '$word' while initializing -mutt=$opt\n");
            %multiple_token_tightness = ();
            return;
        }
    }

    # Construct a regex for the selected Q subtypes, in the form
    #    ^(?:qq|qx|qr|q|s|y|tr|m)\b
    if (@Q_subtype_list) {
        my $regex = q{^(?:} . join( '|', @Q_subtype_list ) . q{)\b};
        if ( bad_pattern($regex) ) {

            # shouldn't happen; there must be a coding error
            my $msg =
              "ERROR: the --$opt_name input caused an invalid regex '$regex'\n";
            DEVEL_MODE && Fault($msg);
            Warn($msg);
            %multiple_token_tightness = ();
            return;
        }
        $multiple_token_tightness{'Q'} = $regex;
    }
    return;
} ## end sub initialize_multiple_token_tightness

sub initialize_global_option_vars {

    #------------------------------------------------------------
    # Make global vars for frequently used options for efficiency
    #------------------------------------------------------------

    $rOpts_add_newlines             = $rOpts->{'add-newlines'};
    $rOpts_add_trailing_commas      = $rOpts->{'add-trailing-commas'};
    $rOpts_add_lone_trailing_commas = $rOpts->{'add-lone-trailing-commas'};
    $rOpts_add_whitespace           = $rOpts->{'add-whitespace'};
    $rOpts_blank_lines_after_opening_block =
      $rOpts->{'blank-lines-after-opening-block'};
    $rOpts_block_brace_tightness = $rOpts->{'block-brace-tightness'};
    $rOpts_block_brace_vertical_tightness =
      $rOpts->{'block-brace-vertical-tightness'};
    $rOpts_brace_follower_vertical_tightness =
      $rOpts->{'brace-follower-vertical-tightness'};
    $rOpts_break_after_labels = $rOpts->{'break-after-labels'};
    $rOpts_break_at_old_attribute_breakpoints =
      $rOpts->{'break-at-old-attribute-breakpoints'};
    $rOpts_break_at_old_comma_breakpoints =
      $rOpts->{'break-at-old-comma-breakpoints'};
    $rOpts_break_at_old_keyword_breakpoints =
      $rOpts->{'break-at-old-keyword-breakpoints'};
    $rOpts_break_at_old_logical_breakpoints =
      $rOpts->{'break-at-old-logical-breakpoints'};
    $rOpts_break_at_old_semicolon_breakpoints =
      $rOpts->{'break-at-old-semicolon-breakpoints'};
    $rOpts_break_at_old_ternary_breakpoints =
      $rOpts->{'break-at-old-ternary-breakpoints'};
    $rOpts_break_open_compact_parens = $rOpts->{'break-open-compact-parens'};
    $rOpts_closing_side_comments     = $rOpts->{'closing-side-comments'};
    $rOpts_closing_side_comment_else_flag =
      $rOpts->{'closing-side-comment-else-flag'};
    $rOpts_closing_side_comment_maximum_text =
      $rOpts->{'closing-side-comment-maximum-text'};
    $rOpts_comma_arrow_breakpoints  = $rOpts->{'comma-arrow-breakpoints'};
    $rOpts_continuation_indentation = $rOpts->{'continuation-indentation'};
    $rOpts_cuddled_paren_brace      = $rOpts->{'cuddled-paren-brace'};
    $rOpts_delete_closing_side_comments =
      $rOpts->{'delete-closing-side-comments'};
    $rOpts_delete_old_whitespace = $rOpts->{'delete-old-whitespace'};
    $rOpts_extended_continuation_indentation =
      $rOpts->{'extended-continuation-indentation'};
    $rOpts_delete_side_comments   = $rOpts->{'delete-side-comments'};
    $rOpts_delete_trailing_commas = $rOpts->{'delete-trailing-commas'};
    $rOpts_delete_lone_trailing_commas =
      $rOpts->{'delete-lone-trailing-commas'};
    $rOpts_delete_weld_interfering_commas =
      $rOpts->{'delete-weld-interfering-commas'};
    $rOpts_format_skipping   = $rOpts->{'format-skipping'};
    $rOpts_freeze_whitespace = $rOpts->{'freeze-whitespace'};
    $rOpts_function_paren_vertical_alignment =
      $rOpts->{'function-paren-vertical-alignment'};
    $rOpts_fuzzy_line_length      = $rOpts->{'fuzzy-line-length'};
    $rOpts_ignore_old_breakpoints = $rOpts->{'ignore-old-breakpoints'};
    $rOpts_ignore_side_comment_lengths =
      $rOpts->{'ignore-side-comment-lengths'};
    $rOpts_ignore_perlcritic_comments = $rOpts->{'ignore-perlcritic-comments'};
    $rOpts_indent_closing_brace       = $rOpts->{'indent-closing-brace'};
    $rOpts_indent_columns             = $rOpts->{'indent-columns'};
    $rOpts_indent_leading_semicolon   = $rOpts->{'indent-leading-semicolon'};
    $rOpts_indent_only                = $rOpts->{'indent-only'};
    $rOpts_keep_interior_semicolons   = $rOpts->{'keep-interior-semicolons'};
    $rOpts_line_up_parentheses        = $rOpts->{'line-up-parentheses'};
    $rOpts_extended_block_tightness   = $rOpts->{'extended-block-tightness'};
    $rOpts_extended_line_up_parentheses =
      $rOpts->{'extended-line-up-parentheses'};
    $rOpts_logical_padding = $rOpts->{'logical-padding'};
    $rOpts_maximum_consecutive_blank_lines =
      $rOpts->{'maximum-consecutive-blank-lines'};
    $rOpts_maximum_fields_per_table = $rOpts->{'maximum-fields-per-table'};
    $rOpts_maximum_line_length      = $rOpts->{'maximum-line-length'};
    $rOpts_minimize_continuation_indentation =
      $rOpts->{'minimize-continuation-indentation'};
    $rOpts_one_line_block_semicolons = $rOpts->{'one-line-block-semicolons'};
    $rOpts_opening_brace_always_on_right =
      $rOpts->{'opening-brace-always-on-right'};
    $rOpts_outdent_keywords      = $rOpts->{'outdent-keywords'};
    $rOpts_outdent_labels        = $rOpts->{'outdent-labels'};
    $rOpts_outdent_long_comments = $rOpts->{'outdent-long-comments'};
    $rOpts_outdent_long_quotes   = $rOpts->{'outdent-long-quotes'};
    $rOpts_outdent_static_block_comments =
      $rOpts->{'outdent-static-block-comments'};
    $rOpts_recombine      = $rOpts->{'recombine'};
    $rOpts_qw_as_function = $rOpts->{'qw-as-function'};
    $rOpts_short_concatenation_item_length =
      $rOpts->{'short-concatenation-item-length'};
    $rOpts_space_prototype_paren     = $rOpts->{'space-prototype-paren'};
    $rOpts_space_signature_paren     = $rOpts->{'space-signature-paren'};
    $rOpts_stack_closing_block_brace = $rOpts->{'stack-closing-block-brace'};
    $rOpts_static_block_comments     = $rOpts->{'static-block-comments'};
    $rOpts_add_missing_else          = $rOpts->{'add-missing-else'};
    $rOpts_warn_missing_else         = $rOpts->{'warn-missing-else'};
    $rOpts_tee_block_comments        = $rOpts->{'tee-block-comments'};
    $rOpts_tee_pod                   = $rOpts->{'tee-pod'};
    $rOpts_tee_side_comments         = $rOpts->{'tee-side-comments'};
    $rOpts_valign_code               = $rOpts->{'valign-code'};
    $rOpts_valign_side_comments      = $rOpts->{'valign-side-comments'};
    $rOpts_valign_if_unless          = $rOpts->{'valign-if-unless'};
    $rOpts_valign_wide_equals        = $rOpts->{'valign-wide-equals'};
    $rOpts_variable_maximum_line_length =
      $rOpts->{'variable-maximum-line-length'};

    # Note that both opening and closing tokens can access the opening
    # and closing flags of their container types.
    %opening_vertical_tightness = (
        '(' => $rOpts->{'paren-vertical-tightness'},
        '{' => $rOpts->{'brace-vertical-tightness'},
        '[' => $rOpts->{'square-bracket-vertical-tightness'},
        ')' => $rOpts->{'paren-vertical-tightness'},
        '}' => $rOpts->{'brace-vertical-tightness'},
        ']' => $rOpts->{'square-bracket-vertical-tightness'},
    );

    %closing_vertical_tightness = (
        '(' => $rOpts->{'paren-vertical-tightness-closing'},
        '{' => $rOpts->{'brace-vertical-tightness-closing'},
        '[' => $rOpts->{'square-bracket-vertical-tightness-closing'},
        ')' => $rOpts->{'paren-vertical-tightness-closing'},
        '}' => $rOpts->{'brace-vertical-tightness-closing'},
        ']' => $rOpts->{'square-bracket-vertical-tightness-closing'},
    );

    # assume flag for '>' same as ')' for closing qw quotes
    %closing_token_indentation = (
        ')' => $rOpts->{'closing-paren-indentation'},
        '}' => $rOpts->{'closing-brace-indentation'},
        ']' => $rOpts->{'closing-square-bracket-indentation'},
        '>' => $rOpts->{'closing-paren-indentation'},
    );

    # flag indicating if any closing tokens are indented
    $some_closing_token_indentation =
         $rOpts->{'closing-paren-indentation'}
      || $rOpts->{'closing-brace-indentation'}
      || $rOpts->{'closing-square-bracket-indentation'}
      || $rOpts->{'indent-closing-brace'};

    %opening_token_right = (
        '(' => $rOpts->{'opening-paren-right'},
        '{' => $rOpts->{'opening-hash-brace-right'},
        '[' => $rOpts->{'opening-square-bracket-right'},
    );

    %stack_opening_token = (
        '(' => $rOpts->{'stack-opening-paren'},
        '{' => $rOpts->{'stack-opening-hash-brace'},
        '[' => $rOpts->{'stack-opening-square-bracket'},
    );

    %stack_closing_token = (
        ')' => $rOpts->{'stack-closing-paren'},
        '}' => $rOpts->{'stack-closing-hash-brace'},
        ']' => $rOpts->{'stack-closing-square-bracket'},
    );
    return;
} ## end sub initialize_global_option_vars

sub initialize_line_length_vars {

    # Create a table of maximum line length vs level for later efficient use.
    # We will make the tables very long to be sure it will not be exceeded.
    # But we have to choose a fixed length.  A check will be made at the start
    # of sub 'finish_formatting' to be sure it is not exceeded.  Note, some of
    # my standard test problems have indentation levels of about 150, so this
    # should be fairly large.  If the choice of a maximum level ever becomes
    # an issue then these table values could be returned in a sub with a simple
    # memoization scheme.

    # Also create a table of the maximum spaces available for text due to the
    # level only.  If a line has continuation indentation, then that space must
    # be subtracted from the table value.  This table is used for preliminary
    # estimates in welding, extended_ci, BBX, and marking short blocks.
    use constant LEVEL_TABLE_MAX => 1000;

    # The basic scheme:
    foreach my $level ( 0 .. LEVEL_TABLE_MAX ) {
        my $indent = $level * $rOpts_indent_columns;
        $maximum_line_length_at_level[$level] = $rOpts_maximum_line_length;
        $maximum_text_length_at_level[$level] =
          $rOpts_maximum_line_length - $indent;
    }

    # Correct the maximum_text_length table if the -wc=n flag is used
    $rOpts_whitespace_cycle = $rOpts->{'whitespace-cycle'};
    if ($rOpts_whitespace_cycle) {
        if ( $rOpts_whitespace_cycle > 0 ) {
            foreach my $level ( 0 .. LEVEL_TABLE_MAX ) {
                my $level_mod = $level % $rOpts_whitespace_cycle;
                my $indent    = $level_mod * $rOpts_indent_columns;
                $maximum_text_length_at_level[$level] =
                  $rOpts_maximum_line_length - $indent;
            }
        }
        else {
            $rOpts_whitespace_cycle = $rOpts->{'whitespace-cycle'} = 0;
        }
    }

    # Correct the tables if the -vmll flag is used.  These values override the
    # previous values.
    if ($rOpts_variable_maximum_line_length) {
        foreach my $level ( 0 .. LEVEL_TABLE_MAX ) {
            $maximum_text_length_at_level[$level] = $rOpts_maximum_line_length;
            $maximum_line_length_at_level[$level] =
              $rOpts_maximum_line_length + $level * $rOpts_indent_columns;
        }
    }

    # Define two measures of indentation level, alpha and beta, at which some
    # formatting features come under stress and need to start shutting down.
    # Some combination of the two will be used to shut down different
    # formatting features.
    # Put a reasonable upper limit on stress level (say 100) in case the
    # whitespace-cycle variable is used.
    my $stress_level_limit = min( 100, LEVEL_TABLE_MAX );

    # Find stress_level_alpha, targeted at very short maximum line lengths.
    $stress_level_alpha = $stress_level_limit + 1;
    foreach my $level_test ( 0 .. $stress_level_limit ) {
        my $max_len = $maximum_text_length_at_level[ $level_test + 1 ];
        my $excess_inside_space =
          $max_len -
          $rOpts_continuation_indentation -
          $rOpts_indent_columns - 8;
        if ( $excess_inside_space <= 0 ) {
            $stress_level_alpha = $level_test;
            last;
        }
    }

    # Find stress level beta, a stress level targeted at formatting
    # at deep levels near the maximum line length.  We start increasing
    # from zero and stop at the first level which shows no more space.

    # 'const' is a fixed number of spaces for a typical variable.
    # Cases b1197-b1204 work ok with const=12 but not with const=8
    my $const = 16;
    my $denom = max( 1, $rOpts_indent_columns );
    $stress_level_beta = 0;
    foreach my $level ( 0 .. $stress_level_limit ) {
        my $remaining_cycles = max(
            0,
            (
                $maximum_text_length_at_level[$level] -
                  $rOpts_continuation_indentation - $const
            ) / $denom
        );
        last if ( $remaining_cycles <= 3 );    # 2 does not work
        $stress_level_beta = $level;
    }

    # This is a combined level which works well for turning off formatting
    # features in most cases:
    $high_stress_level = min( $stress_level_alpha, $stress_level_beta + 2 );

    return;
} ## end sub initialize_line_length_vars

sub initialize_trailing_comma_break_rules {

    # Setup control hash for making trailing comma breaks. Update c416.
    # This sub is similar to 'sub initialize_trailing_comma_rules' but
    # simpler.

    # -btct=s, where s
    #
    #  =" " none
    #  =0 : none
    #  =1 or * : all
    #  =m : break at trailing commas in multiline lists
    #  =b : break at bare trailing commas

    %trailing_comma_break_rules = ();

    my $rvalid_flags = [qw( 0 1 * m b )];

    # Note that the hash keys are the CLOSING tokens but the input
    # uses OPENING tokens.
    my @all_keys = qw< ) ] } >;

    my $option = $rOpts->{'break-at-trailing-comma-types'};

    if ($option) {
        $option =~ s/^\s+//;
        $option =~ s/\s+$//;
    }

    # We need to use length() here because '0' is a possible option
    if ( defined($option) && length($option) ) {
        my $error_message;
        my %rule_hash;
        my @q = @{$rvalid_flags};
        my %is_valid_flag;
        @is_valid_flag{@q} = (1) x scalar(@q);

        # handle the common case of a single control character, like -btct='b'
        if ( length($option) == 1 ) {

            # skip 0
            if ($option) {
                foreach my $key (@all_keys) {
                    $rule_hash{$key} = [ $option, EMPTY_STRING ];
                }
            }
        }

        # handle multi-character control(s), such as -btct='[m' or -btct='k(m'
        else {
            my @parts = split /\s+/, $option;
            foreach my $part (@parts) {
                my $part_input = $part;

                # examples: b -b [b 0 * +f(b

                # the letter value is the rightmost character
                my $val = substr( $part, -1, 1 );

                # skip 0
                next unless ($val);
                $part = substr( $part, 0, -1 );
                if ( $val && !$is_valid_flag{$val} ) {
                    my $valid_str = join( SPACE, @{$rvalid_flags} );
                    $error_message .=
"In '$part_input': unexpected value '$val'; must be one of: $valid_str\n";
                    next;
                }

                # set defaults for this item
                my @keys       = @all_keys;
                my $paren_flag = EMPTY_STRING;

                # look for opening container bracket
                my $is_paren;
                if ( length($part) ) {
                    my $token = substr( $part, -1, 1 );
                    if ( $is_opening_token{$token} ) {

                        # note that the hash key is the closing token
                        my $key = $matching_token{$token};
                        @keys     = ($key);
                        $part     = substr( $part, 0, -1 );
                        $is_paren = $token eq '(';
                    }
                }

                # anything left must be a paren modifier
                if ( length($part) ) {
                    $paren_flag = substr( $part, -1,  1 );
                    $part       = substr( $part,  0, -1 );
                    if ( $paren_flag !~ /^[kKfFwW]$/ ) {
                        $error_message .=
"In '$part_input': Unexpected paren flag '$paren_flag'; must be one of: k K f F w W\n";
                        next;
                    }
                    if ( !$is_paren ) {
                        $error_message .=
"In '$part_input': paren flag '$paren_flag' is only allowed before a '('\n";
                        next;
                    }
                }

                if ( length($part) ) {
                    $error_message .= "Unrecognized term: '$part_input'\n";
                    next;
                }

                my $duplicate;
                foreach my $key (@keys) {
                    if ( defined( $rule_hash{$key} ) ) {
                        $duplicate = 1;
                    }
                    $rule_hash{$key} = [ $val, $paren_flag ];
                }
                if ($duplicate) {
                    $error_message .=
                      "This term overlaps a previous term: '$part_input'\n";
                }
            }
        }

        # check for conflicting signed options
        if ($error_message) {
            Warn(<<EOM);
Error parsing --want-trailing-commas='$option':
$error_message
EOM
        }

        # Set the control hash if no errors
        else {
            %trailing_comma_break_rules = %rule_hash;
        }
    }

    return;
} ## end sub initialize_trailing_comma_break_rules

sub initialize_trailing_comma_rules {

    # Setup control hash for trailing commas

    # -wtc=s defines desired trailing comma policy:
    #
    #  =" "  stable
    #        [ both -atc  and -dtc ignored ]
    #  =0 : none
    #        [requires -dtc; -atc ignored]
    #  =1 or * : all
    #        [requires -atc; -dtc ignored]
    #  =m : multiline lists require trailing comma
    #        if -atc set => will add missing multiline trailing commas
    #        if -dtc set => will delete trailing single line commas
    #  =b or 'bare' (multiline) lists require trailing comma
    #        if -atc set => will add missing bare trailing commas
    #        if -dtc set => will delete non-bare trailing commas
    #  =h or 'hash': single column stable bare lists require trailing comma
    #        if -atc set will add these
    #        if -dtc set will delete other trailing commas

    #-------------------------------------------------------------------
    # Important:
    # - This routine must be called after the alpha and beta stress levels
    #   have been defined in sub 'initialize_line_length_vars'.
    # - and it must be called after sub 'initialize_trailing_comma_break_rules'
    #-------------------------------------------------------------------

    %trailing_comma_rules = ();

    my $rvalid_flags = [qw( 0 1 * m b h i )];

    # This hash shows i.e. that 'm' includes all 'b' includes all 'i' ...etc
    # It is used to check for overlap when both + and - signs are used to
    # cause adding and deleting of different types of trailing commas.
    my %match_order = (
        '1' => 0,
        '*' => 0,
        'm' => 1,
        'b' => 2,
        'i' => 3,
        'h' => 4,
        '0' => 5,
    );

    # Note that the hash keys are the CLOSING tokens but the input
    # uses OPENING tokens.
    my @all_keys = qw< ) ] } >;

    my $option = $rOpts->{'want-trailing-commas'};

    if ($option) {
        $option =~ s/^\s+//;
        $option =~ s/\s+$//;
    }

    # Pull out -btct paren flag for use in checking stability in marginal cases
    my ( $tc_letter, $tc_paren_flag );
    my $tc_paren_rule = $trailing_comma_break_rules{')'};
    if ( defined($tc_paren_rule) ) {
        ( $tc_letter, $tc_paren_flag ) = @{$tc_paren_rule};
    }

    # We need to use length() here because '0' is a possible option
    if ( defined($option) && length($option) ) {
        my $error_message;
        my %rule_hash;
        my @q = @{$rvalid_flags};
        my %is_valid_flag;
        @is_valid_flag{@q} = (1) x scalar(@q);

        # handle the common case of a single control character, like -wtc='b'
        if ( length($option) == 1 ) {
            foreach my $key (@all_keys) {
                my $paren_flag = EMPTY_STRING;
                my $stable     = defined( $trailing_comma_break_rules{$key} );
                if ( $key eq ')' ) { $stable &&= $paren_flag eq $tc_paren_flag }
                $rule_hash{add}->{$key}    = [ $option, $paren_flag, $stable ];
                $rule_hash{delete}->{$key} = [ $option, $paren_flag, $stable ];
            }
        }

        # handle multi-character control(s), such as -wtc='[m' or -wtc='k(m'
        else {
            my @parts = split /\s+/, $option;
            foreach my $part (@parts) {
                my $part_input = $part;

                # examples: b -b [b 0 * +f(b

                # the letter value is the rightmost character
                my $val = substr( $part, -1, 1 );
                $part = substr( $part, 0, -1 );
                if ( $val && !$is_valid_flag{$val} ) {
                    my $valid_str = join( SPACE, @{$rvalid_flags} );
                    $error_message .=
"In '$part_input': unexpected value '$val'; must be one of: $valid_str\n";
                    next;
                }

                # set defaults for this item
                my @signs      = qw( add delete );
                my @keys       = @all_keys;
                my $paren_flag = EMPTY_STRING;

                # look for opening container bracket
                my $is_paren;
                if ( length($part) ) {
                    my $token = substr( $part, -1, 1 );
                    if ( $is_opening_token{$token} ) {

                        # note that the hash key is the closing token
                        my $key = $matching_token{$token};
                        @keys     = ($key);
                        $part     = substr( $part, 0, -1 );
                        $is_paren = $token eq '(';
                    }
                }

                # look for a leading sign, + or -
                if ( length($part) ) {
                    my $sign = substr( $part, 0, 1 );
                    if ( $sign eq '+' ) {
                        @signs = qw(add);
                        $part  = substr( $part, 1 );
                    }
                    elsif ( $sign eq '-' ) {
                        @signs = qw(delete);
                        $part  = substr( $part, 1 );
                    }
                    else {
                        ## keep defaults
                    }
                }

                # anything left must be a paren modifier
                if ( length($part) ) {
                    $paren_flag = substr( $part, -1,  1 );
                    $part       = substr( $part,  0, -1 );
                    if ( $paren_flag !~ /^[kKfFwW]$/ ) {
                        $error_message .=
"In '$part_input': Unexpected paren flag '$paren_flag'; must be one of: k K f F w W\n";
                        next;
                    }
                    if ( !$is_paren ) {
                        $error_message .=
"In '$part_input': paren flag '$paren_flag' is only allowed before a '('\n";
                        next;
                    }
                }

                if ( length($part) ) {
                    $error_message .= "Unrecognized term: '$part_input'\n";
                    next;
                }

                my $duplicate;
                foreach my $sign (@signs) {
                    foreach my $key (@keys) {

                        # New bare commas are stable if -bctc is set, and
                        # also paren flags do not disagree
                        my $stable =
                          defined( $trailing_comma_break_rules{$key} );
                        if ( $key eq ')' ) {
                            $stable &&= $paren_flag eq $tc_paren_flag;
                        }

                        if ( defined( $rule_hash{$sign}->{$key} ) ) {
                            $duplicate &&= 1;
                        }
                        $rule_hash{$sign}->{$key} =
                          [ $val, $paren_flag, $stable ];
                    }
                }

                if ($duplicate) {
                    $error_message .=
                      "This term overlaps a previous term: '$part_input'\n";
                }
            }
        }

        # check for conflicting signed options
        if ( !$error_message ) {
            my $radd    = $rule_hash{add};
            my $rdelete = $rule_hash{delete};
            if ( defined($radd) && defined($rdelete) ) {
                foreach my $key (@all_keys) {
                    my $radd_info    = $radd->{$key};
                    my $rdelete_info = $rdelete->{$key};
                    if ( defined($radd_info) && defined($rdelete_info) ) {
                        my $add_val    = $radd_info->[0];
                        my $delete_val = $rdelete_info->[0];
                        next if ( $add_val eq $delete_val );
                        my $add_order    = $match_order{$add_val};
                        my $delete_order = $match_order{$delete_val};
                        if ( !defined($add_order) ) {
                            ## should have been caught earlier
                            DEVEL_MODE
                              && Fault("unexpected + value $add_val\n");
                            next;
                        }
                        if ( !defined($delete_order) ) {
                            ## should have been caught earlier
                            DEVEL_MODE
                              && Fault("unexpected - value $delete_val\n");
                            next;
                        }
                        if ( $add_order <= $delete_order ) {
                            my $token = $matching_token{$key};
                            $error_message .=
"For token '$token': the range for '+$add_val' overlaps the range for '-$delete_val'\n";
                        }
                    }
                }
            }
        }

        if ($error_message) {
            Warn(<<EOM);
Error parsing --want-trailing-commas='$option':
$error_message
EOM
        }

        # Set the control hash if no errors
        else {
            %trailing_comma_rules = %rule_hash;
        }
    }

    # Both adding and deleting commas can lead to instability in extreme cases
    if ( $rOpts_add_trailing_commas && $rOpts_delete_trailing_commas ) {

        # If the possible instability is significant, then we can turn off
        # -dtc as a defensive measure to prevent it.

        # We must turn off -dtc for very small values of --whitespace-cycle
        # to avoid instability.  A minimum value of -wc=3 fixes b1393, but a
        # value of 4 is used here for safety.  This parameter is seldom used,
        # and much larger than this when used, so the cutoff value is not
        # critical.
        if ( $rOpts_whitespace_cycle && $rOpts_whitespace_cycle <= 4 ) {
            $rOpts_delete_trailing_commas = 0;
        }
    }

    return;
} ## end sub initialize_trailing_comma_rules

sub initialize_interbracket_arrow_style {

    # Setup hash for desired arrow style
    %interbracket_arrow_style = ();

    # and check other parameters for conflicts
    my $name_add    = 'add-interbracket-arrows';
    my $name_delete = 'delete-interbracket-arrows';
    my $name_style  = 'interbracket-arrow-style';

    my $opt_add    = $rOpts->{$name_add};
    my $opt_delete = $rOpts->{$name_delete};
    my $opt_style  = $rOpts->{$name_style};

    if ( $opt_add && $opt_delete && !$opt_style ) {
        Die(<<EOM);
Cannot use both --$name_add and --$name_delete
  unless --$name_style is defined
EOM
    }

    return unless defined($opt_style);
    $opt_style =~ tr/,/ /;
    $opt_style =~ s/^\s+//;
    $opt_style =~ s/\s+$//;
    return unless length($opt_style);

    if    ( $opt_style eq '0' ) { $opt_style = ']  [ ]  { }  [ }  {' }
    elsif ( $opt_style eq '1' ) { $opt_style = ']->[ ]->{ }->[ }->{' }
    elsif ( $opt_style eq '*' ) { $opt_style = ']->[ ]->{ }->[ }->{' }
    else                        { }

    # We are walking along a string such as
    #     $opt_style=" ][  ]->{   }->[  }{ ";
    # ignoring spaces and looking for bracket pairs with optional
    # arrow like:   ']['  or ]->{  or }->[  or  }{
    # The two bracket characters are the hash key and the hash value
    # is 1 for an arrow and -1 for no arrow.

    # $ch1 will hold most recent closing bracket
    # $ch2 will hold a '->' if seen
    my %rule_hash;
    my ( $ch1, $ch2 );
    my $err_msg;
    my $pos_last;
    while (1) {
        $pos_last = pos($opt_style);
        if (
            $opt_style =~ m{
             \G(?:      #    fix git #142
               (\s+)    # 1. whitespace
             | ([\}\]]) # 2. closing bracket
             | (->)     # 3. arrow
             | ([\[\{]) # 4. opening bracket
             | (.*)     # 5. something else, error
             )
            }gcx
          )
        {
            if ($1) { next }
            if ($2) {
                if   ( !$ch1 ) { $ch1     = $2 }
                else           { $err_msg = "unexpected '$2'"; last }
                next;
            }
            if ($3) {
                if   ($ch1) { $ch2     = $3 }
                else        { $err_msg = "unexpected '$3'"; last }
                next;
            }
            if ($4) {
                if ( $ch1 || $ch2 ) {
                    my $key = $ch1 . $4;
                    if ( !defined( $rule_hash{$key} ) ) {
                        $rule_hash{$key} = $ch2 ? 1 : -1;
                    }
                    else { $err_msg = "multiple copies for '$key'"; last; }
                    $ch1 = $ch2 = undef;
                }
                else { $err_msg = "unexpected '$4'"; last }
                next;
            }
            if ($5) {
                my $bad = $5;
                if ( length($bad) > 10 ) {
                    $bad = substr( $bad, 0, 10 ) . '...';
                }
                $err_msg = "confused at: '$bad'\n";
                last;
            }
        }

        # that's all..
        else {
            last;
        }
    } ## end while (1)

    if ($err_msg) {
        my $msg;
        if ( $pos_last && length($opt_style) < 20 ) {
            $msg = $opt_style . "\n" . SPACE x $pos_last . '^' . "\n";
        }
        $msg .= "Error parsing --$name_style: $err_msg";
        Die($msg);
    }

    # Copy the rule hash, converting braces to token types
    foreach my $key ( keys %rule_hash ) {
        my $key_fix = $key;
        $key_fix =~ tr/{}/LR/;
        $interbracket_arrow_style{$key_fix} = $rule_hash{$key};
    }

    return;
} ## end sub initialize_interbracket_arrow_style

sub initialize_whitespace_hashes {

    # This is called once before formatting begins to initialize these global
    # hashes, which control the use of whitespace around tokens:
    #
    # %binary_ws_rules
    # %want_left_space
    # %want_right_space
    # %space_after_keyword
    #
    # Many token types are identical to the tokens themselves.
    # See the tokenizer for a complete list. Here are some special types:
    #   k = perl keyword
    #   f = semicolon in for statement
    #   m = unary minus
    #   p = unary plus
    # Note that :: is excluded since it should be contained in an identifier
    # Note that '->' is excluded because it never gets space
    # parentheses and brackets are excluded since they are handled specially
    # curly braces are included but may be overridden by logic, such as
    # newline logic.

    # NEW_TOKENS: create a whitespace rule here.  This can be as
    # simple as adding your new letter to @spaces_both_sides, for
    # example.

    # fix for c250: added space rules new package type 'P' and sub type 'S'
    my @spaces_both_sides = qw#
      + - * / % ? = . : x < > | & ^ .. << >> ** && .. || // => += -=
      .= %= x= &= |= ^= *= <> <= >= == =~ !~ /= != ... <<= >>= ~~ !~~
      **= &&= ||= //= <=> A k f w F n C Y U G v P S ^^
      #;

    my @spaces_left_side = qw< t ! ~ m p { \ h pp mm Z j >;
    push( @spaces_left_side, '#' );    # avoids warning message

    # c349: moved **= from @spaces_right_side to @spaces_both_sides
    my @spaces_right_side = qw< ; } ) ] R J ++ -- >;
    push( @spaces_right_side, ',' );    # avoids warning message

    %want_left_space  = ();
    %want_right_space = ();
    %binary_ws_rules  = ();

    # Note that we setting defaults here.  Later in processing
    # the values of %want_left_space and  %want_right_space
    # may be overridden by any user settings specified by the
    # -wls and -wrs parameters.  However the binary_whitespace_rules
    # are hardwired and have priority.
    @want_left_space{@spaces_both_sides} =
      (1) x scalar(@spaces_both_sides);
    @want_right_space{@spaces_both_sides} =
      (1) x scalar(@spaces_both_sides);
    @want_left_space{@spaces_left_side} =
      (1) x scalar(@spaces_left_side);
    @want_right_space{@spaces_left_side} =
      (-1) x scalar(@spaces_left_side);
    @want_left_space{@spaces_right_side} =
      (-1) x scalar(@spaces_right_side);
    @want_right_space{@spaces_right_side} =
      (1) x scalar(@spaces_right_side);
    $want_left_space{'->'}      = WS_NO;
    $want_right_space{'->'}     = WS_NO;
    $want_left_space{'**'}      = WS_NO;
    $want_right_space{'**'}     = WS_NO;
    $want_right_space{'CORE::'} = WS_NO;

    # These binary_ws_rules are hardwired and have priority over the above
    # settings.  It would be nice to allow adjustment by the user,
    # but it would be complicated to specify.
    #
    # hash type information must stay tightly bound
    # as in :  ${xxxx}
    $binary_ws_rules{'i'}{'L'} = WS_NO;
    $binary_ws_rules{'i'}{'{'} = WS_YES;
    $binary_ws_rules{'k'}{'{'} = WS_YES;
    $binary_ws_rules{'U'}{'{'} = WS_YES;
    $binary_ws_rules{'i'}{'['} = WS_NO;
    $binary_ws_rules{'R'}{'L'} = WS_NO;
    $binary_ws_rules{'R'}{'{'} = WS_NO;
    $binary_ws_rules{'t'}{'L'} = WS_NO;
    $binary_ws_rules{'t'}{'{'} = WS_NO;
    $binary_ws_rules{'t'}{'='} = WS_OPTIONAL;    # for signatures; fixes b1123
    $binary_ws_rules{'}'}{'L'} = WS_NO;
    $binary_ws_rules{'}'}{'{'} = WS_OPTIONAL;    # RT#129850; was WS_NO
    $binary_ws_rules{'$'}{'L'} = WS_NO;
    $binary_ws_rules{'$'}{'{'} = WS_NO;
    $binary_ws_rules{'@'}{'L'} = WS_NO;
    $binary_ws_rules{'@'}{'{'} = WS_NO;
    $binary_ws_rules{'='}{'L'} = WS_YES;
    $binary_ws_rules{'J'}{'J'} = WS_YES;

    # the following includes ') {'
    # as in :    if ( xxx ) { yyy }
    $binary_ws_rules{']'}{'L'} = WS_NO;
    $binary_ws_rules{']'}{'{'} = WS_NO;
    $binary_ws_rules{')'}{'{'} = WS_YES;
    $binary_ws_rules{')'}{'['} = WS_NO;
    $binary_ws_rules{']'}{'['} = WS_NO;
    $binary_ws_rules{']'}{'{'} = WS_NO;
    $binary_ws_rules{'}'}{'['} = WS_NO;
    $binary_ws_rules{'R'}{'['} = WS_NO;

    $binary_ws_rules{']'}{'++'} = WS_NO;
    $binary_ws_rules{']'}{'--'} = WS_NO;
    $binary_ws_rules{')'}{'++'} = WS_NO;
    $binary_ws_rules{')'}{'--'} = WS_NO;

    $binary_ws_rules{'R'}{'++'} = WS_NO;
    $binary_ws_rules{'R'}{'--'} = WS_NO;

    $binary_ws_rules{'i'}{'Q'} = WS_YES;
    $binary_ws_rules{'n'}{'('} = WS_YES;    # occurs in 'use package n ()'

    $binary_ws_rules{'i'}{'('} = WS_NO;

    $binary_ws_rules{'w'}{'('} = WS_NO;
    $binary_ws_rules{'w'}{'{'} = WS_YES;

    # user controls
    if ( !$rOpts->{'space-for-semicolon'} ) {
        $want_left_space{'f'} = -1;
    }

    if ( $rOpts->{'space-terminal-semicolon'} ) {
        $want_left_space{';'} = 1;
    }

    # implement user whitespace preferences
    if ( my @q = split_words( $rOpts->{'want-left-space'} ) ) {
        @want_left_space{@q} = (1) x scalar(@q);
    }

    if ( my @q = split_words( $rOpts->{'want-right-space'} ) ) {
        @want_right_space{@q} = (1) x scalar(@q);
    }

    if ( my @q = split_words( $rOpts->{'nowant-left-space'} ) ) {
        @want_left_space{@q} = (-1) x scalar(@q);
    }

    if ( my @q = split_words( $rOpts->{'nowant-right-space'} ) ) {
        @want_right_space{@q} = (-1) x scalar(@q);
    }

    return;

} ## end sub initialize_whitespace_hashes

{ #<<< begin closure set_whitespace_flags

my %is_special_ws_type;
my %is_wCUG;
my %is_wi;

BEGIN {

    # The following hash is used to skip over needless if tests.
    # Be sure to update it when adding new checks in its block.
    my @q = qw( k w C m - Q );
    push @q, '#';
    @is_special_ws_type{@q} = (1) x scalar(@q);

    # These hashes replace slower regex tests
    @q = qw( w C U G );
    @is_wCUG{@q} = (1) x scalar(@q);

    @q = qw( w i );
    @is_wi{@q} = (1) x scalar(@q);

} ## end BEGIN

use constant DEBUG_WHITE => 0;

# Hashes to set spaces around container tokens according to their
# sequence numbers.  These are set as keywords are examined.
# They are controlled by the -kpit and -kpitl flags.
my %opening_container_inside_ws;
my %closing_container_inside_ws;

sub set_whitespace_flags {

    my $self = shift;

    # This routine is called once per file to set whitespace flags for that
    # file.  This routine examines each pair of nonblank tokens and sets a flag
    # indicating if they should be separated by white space.
    #
    # $rwhitespace_flags->[$j] is a flag indicating whether a white space
    # BEFORE token $j is needed, with the following values:
    #
    #             WS_NO      = -1 do not want a space BEFORE token $j
    #             WS_OPTIONAL=  0 optional space or $j is a whitespace
    #             WS_YES     =  1 want a space BEFORE token $j
    #

    my $j_tight_closing_paren = -1;
    my $rLL                   = $self->[_rLL_];
    my $K_closing_container   = $self->[_K_closing_container_];
    my $jmax                  = @{$rLL} - 1;

    %opening_container_inside_ws = ();
    %closing_container_inside_ws = ();

    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];

    my $rOpts_space_keyword_paren   = $rOpts->{'space-keyword-paren'};
    my $rOpts_space_backslash_quote = $rOpts->{'space-backslash-quote'};
    my $rOpts_space_function_paren  = $rOpts->{'space-function-paren'};

    my $rwhitespace_flags       = [];
    my $ris_function_call_paren = {};

    return $rwhitespace_flags if ( $jmax < 0 );

    # function to return $ws for a signature paren following a sub
    my $ws_signature_paren = sub {
        my ($jj) = @_;
        my $ws;
        if ( $rOpts_space_signature_paren == 1 ) {

            # is the previous token a blank?
            my $have_blank = $rLL->[ $jj - 1 ]->[_TYPE_] eq 'b';

            # or a newline?
            $have_blank ||=
              $rLL->[$jj]->[_LINE_INDEX_] != $rLL->[ $jj - 1 ]->[_LINE_INDEX_];

            $ws = $have_blank ? WS_YES : WS_NO;
        }
        else {
            $ws = $rOpts_space_signature_paren == 0 ? WS_NO : WS_YES;
        }
        return $ws;
    }; ## end $ws_signature_paren = sub

    my $last_token = SPACE;
    my $last_type  = 'b';

    my $last_token_dbg = SPACE;
    my $last_type_dbg  = 'b';

    my $rtokh_last = [ @{ $rLL->[0] } ];
    $rtokh_last->[_TOKEN_]         = $last_token;
    $rtokh_last->[_TYPE_]          = $last_type;
    $rtokh_last->[_TYPE_SEQUENCE_] = EMPTY_STRING;
    $rtokh_last->[_LINE_INDEX_]    = 0;

    my $rtokh_last_last = $rtokh_last;

    # This will identify braces to be treated as blocks for the -xbt flag
    my %block_type_for_tightness;

    my ( $ws_1, $ws_2, $ws_3, $ws_4 );

    # main loop over all tokens to define the whitespace flags
    my $last_type_is_opening;
    my $j = -1;
    my $type;
    foreach my $rtokh ( @{$rLL} ) {

        $j++;

        if ( ( $type = $rtokh->[_TYPE_] ) eq 'b' ) {
            $rwhitespace_flags->[$j] = WS_OPTIONAL;
            next;
        }

        my $token = $rtokh->[_TOKEN_];

        my $ws;

        #---------------------------------------------------------------
        # Whitespace Rules Section 1:
        # Handle space on the inside of opening braces.
        #---------------------------------------------------------------

        if ($last_type_is_opening) {

            $last_type_is_opening = 0;

            my $seqno           = $rtokh->[_TYPE_SEQUENCE_];
            my $block_type      = $rblock_type_of_seqno->{$seqno};
            my $last_seqno      = $rtokh_last->[_TYPE_SEQUENCE_];
            my $last_block_type = $rblock_type_of_seqno->{$last_seqno}
              || $block_type_for_tightness{$last_seqno};

            $j_tight_closing_paren = -1;

            # let us keep empty matched braces together: () {} []
            # except for BLOCKS
            if ( $token eq $matching_token{$last_token} ) {
                if ($block_type) {
                    $ws = WS_YES;
                }
                else {
                    $ws = WS_NO;
                }
            }
            else {

                # we're considering the right of an opening brace
                # tightness = 0 means always pad inside with space
                # tightness = 1 means pad inside if "complex"
                # tightness = 2 means never pad inside with space

                my $tightness_here;
                if ( $last_block_type && $last_token eq '{' ) {
                    $tightness_here = $rOpts_block_brace_tightness;
                }
                else { $tightness_here = $tightness{$last_token} }

                #=============================================================
                # Patch for test problem <<snippets/fabrice_bug.in>>
                # We must always avoid spaces around a bare word beginning
                # with ^ as in:
                #    my $before = ${^PREMATCH};
                # Because all of the following cause an error in perl:
                #    my $before = ${ ^PREMATCH };
                #    my $before = ${ ^PREMATCH};
                #    my $before = ${^PREMATCH };
                # So if brace tightness flag is -bt=0 we must temporarily reset
                # to bt=1.  Note that here we must set tightness=1 and not 2 so
                # that the closing space is also avoided
                # (via the $j_tight_closing_paren flag in coding)
                if ( $type eq 'w' && substr( $token, 0, 1 ) eq '^' ) {
                    $tightness_here = 1;
                }

                #=============================================================

                if ( $tightness_here <= 0 ) {
                    $ws = WS_YES;
                }
                elsif ( $tightness_here > 1 ) {
                    $ws = WS_NO;
                }

                # Default (tightness = 1) depends on the container token count
                else {

                    # Find the index of the closing token
                    my $j_closing = $K_closing_container->{$last_seqno};

                    # Certain token types can be counted as multiple tokens for
                    # the default tightness.  The meaning of hash values is:
                    #   1 => match this token type
                    #   otherwise it is a regex; match if token matches regex
                    my $regex = $multiple_token_tightness{$type};
                    if ( $regex
                        && ( length($regex) == 1 || $token =~ /$regex/ ) )
                    {
                        $ws = WS_YES;
                    }

                    # If the closing token is less than five characters ahead
                    # we must take a closer look
                    elsif ( defined($j_closing)
                        && $j_closing - $j < 5
                        && $rLL->[$j_closing]->[_TYPE_SEQUENCE_] eq
                        $last_seqno )
                    {
                        # quick check
                        if ( $j + 1 >= $j_closing ) {
                            $ws                    = WS_NO;
                            $j_tight_closing_paren = $j_closing;
                        }

                        # slow check
                        else {
                            $ws =
                              ws_in_container( $j, $j_closing, $rLL, $type,
                                $token, $last_token );
                            if ( $ws == WS_NO ) {
                                $j_tight_closing_paren = $j_closing;
                            }
                        }
                    }
                    else {
                        $ws = WS_YES;
                    }
                }
            }

            # check for special cases which override the above rules
            if ( %opening_container_inside_ws && $last_seqno ) {
                my $ws_override = $opening_container_inside_ws{$last_seqno};
                if ($ws_override) { $ws = $ws_override }
            }

            $ws_4 = $ws_3 = $ws_2 = $ws_1 = $ws
              if DEBUG_WHITE;

        } ## end setting space flag inside opening tokens

        #---------------------------------------------------------------
        # Whitespace Rules Section 2:
        # Special checks for certain types ...
        #---------------------------------------------------------------
        # The hash '%is_special_ws_type' significantly speeds up this routine,
        # but be sure to update it if a new check is added.
        # Currently has types: qw(k w C m - Q #)
        if ( $is_special_ws_type{$type} ) {

            if ( $type eq 'k' ) {

                # Keywords 'for', 'foreach' are special cases for -kpit since
                # the opening paren does not always immediately follow the
                # keyword. So we have to search forward for the paren in this
                # case.  I have limited the search to 10 tokens ahead, just in
                # case somebody has a big file and no opening paren.  This
                # should be enough for all normal code. Added the level check
                # to fix b1236.
                if (   $is_for_foreach{$token}
                    && %keyword_paren_inner_tightness
                    && defined( $keyword_paren_inner_tightness{$token} )
                    && $j < $jmax )
                {
                    my $level = $rLL->[$j]->[_LEVEL_];
                    ## NOTE: we might use the KNEXT variable to avoid this loop
                    ## but profiling shows that little would be saved
                    foreach my $jp ( $j + 1 .. $j + 9 ) {
                        last if ( $jp > $jmax );
                        last if ( $rLL->[$jp]->[_LEVEL_] != $level );    # b1236
                        next unless ( $rLL->[$jp]->[_TOKEN_] eq '(' );
                        my $seqno_p = $rLL->[$jp]->[_TYPE_SEQUENCE_];
                        set_container_ws_by_keyword( $token, $seqno_p );
                        last;
                    }
                }
            }

            # handle a comment
            elsif ( $type eq '#' ) {

                # newline before block comment ($j==0), and
                # space before side comment    ($j>0), so ..
                $ws = WS_YES;

                #---------------------------------
                # Nothing more to do for a comment
                #---------------------------------
                $rwhitespace_flags->[$j] = $ws;
                next;
            }

            # space_backslash_quote; RT #123774  <<snippets/rt123774.in>>
            # allow a space between a backslash and single or double quote
            # to avoid fooling html formatters
            elsif ( $type eq 'Q' ) {
                if ( $last_type eq '\\' && $token =~ /^[\"\']/ ) {
                    $ws =
                       !$rOpts_space_backslash_quote      ? WS_NO
                      : $rOpts_space_backslash_quote == 1 ? WS_OPTIONAL
                      : $rOpts_space_backslash_quote == 2 ? WS_YES
                      :                                     WS_YES;
                }
            }

            # retain any space between '-' and bare word
            elsif ( $type eq 'w' || $type eq 'C' ) {
                $ws = WS_OPTIONAL if $last_type eq '-';
            }

            # retain any space between '-' and bare word; for example
            # avoid space between 'USER' and '-' here: <<snippets/space2.in>>
            #   $myhash{USER-NAME}='steve';
            elsif ( $type eq 'm' || $type eq '-' ) {
                $ws = WS_OPTIONAL if ( $last_type eq 'w' );
            }

            else {
                # A type $type was entered in %is_special_ws_type but
                # there is no code block to handle it. Either remove it
                # from the hash or add a code block to handle it.
                DEVEL_MODE && Fault("no code to handle type $type\n");
            }
        } ## end elsif ( $is_special_ws_type{$type} ...

        #---------------------------------------------------------------
        # Whitespace Rules Section 3:
        # Handle space on inside of closing brace pairs.
        #---------------------------------------------------------------

        #   /[\}\)\]R]/
        elsif ( $is_closing_type{$type} ) {

            my $seqno = $rtokh->[_TYPE_SEQUENCE_];
            if ( $j == $j_tight_closing_paren ) {

                $j_tight_closing_paren = -1;
                $ws                    = WS_NO;
            }
            else {

                if ( !defined($ws) ) {

                    my $tightness_here;
                    my $block_type = $rblock_type_of_seqno->{$seqno}
                      || $block_type_for_tightness{$seqno};

                    if ( $block_type && $token eq '}' ) {
                        $tightness_here = $rOpts_block_brace_tightness;
                    }
                    else { $tightness_here = $tightness{$token} }

                    $ws = ( $tightness_here > 1 ) ? WS_NO : WS_YES;
                }
            }

            # check for special cases which override the above rules
            if ( %closing_container_inside_ws && $seqno ) {
                my $ws_override = $closing_container_inside_ws{$seqno};
                if ($ws_override) { $ws = $ws_override }
            }

            $ws_4 = $ws_3 = $ws_2 = $ws
              if DEBUG_WHITE;
        } ## end setting space flag inside closing tokens

        #---------------------------------------------------------------
        # Whitespace Rules Section 4:
        #---------------------------------------------------------------
        elsif ( $is_opening_type{$type} ) {

            $last_type_is_opening = 1;

            if ( $token eq '(' ) {

                my $seqno = $rtokh->[_TYPE_SEQUENCE_];

                # This will have to be tweaked as tokenization changes.
                # We usually want a space at '} (', for example:
                # <<snippets/space1.in>>
                #     map { 1 * $_; } ( $y, $M, $w, $d, $h, $m, $s );
                #
                # But not others:
                #     &{ $_->[1] }( delete $_[$#_]{ $_->[0] } );
                # At present, the above & block is marked as type L/R so this
                # case won't go through here.
                if ( $last_type eq '}' && $last_token ne ')' ) { $ws = WS_YES }

                # NOTE: some older versions of Perl had occasional problems if
                # spaces are introduced between keywords or functions and
                # opening parens.  So the default is not to do this except is
                # certain cases.  The current Perl seems to tolerate spaces.

                # Space between keyword and '('
                elsif ( $last_type eq 'k' ) {

                    if ( $last_token eq 'sub' ) {
                        $ws = $ws_signature_paren->($j);
                    }
                    else {
                        $ws = WS_NO
                          unless ( $rOpts_space_keyword_paren
                            || $space_after_keyword{$last_token} );

                        # Set inside space flag if requested
                        set_container_ws_by_keyword( $last_token, $seqno );
                    }
                }

                # Space between function and '('
                # -----------------------------------------------------
                # 'w' and 'i' checks for something like:
                #   myfun(    &myfun(   ->myfun(
                # -----------------------------------------------------

                # Note that at this point an identifier may still have a
                # leading arrow, but the arrow will be split off during token
                # respacing.  After that, the token may become a bare word
                # without leading arrow.  The point is, it is best to mark
                # function call parens right here before that happens.
                # Patch: added 'C' to prevent blinker, case b934, i.e. 'pi()'
                # NOTE: this would be the place to allow spaces between
                # repeated parens, like () () (), as in case c017, but I
                # decided that would not be a good idea.

                # Updated to allow detached '->' from tokenizer (issue c140)
                elsif (

                    #        /^[wCUG]$/
                    $is_wCUG{$last_type}

                    || (

                        #      /^[wi]$/
                        $is_wi{$last_type}

                        && (

                            # with prefix '->' or '&'
                            $last_token =~ /^([\&]|->)/

                            # or preceding token '->' (see b1337; c140)
                            || $rtokh_last_last->[_TYPE_] eq '->'

                            # or preceding sub call operator token '&'
                            || (   $rtokh_last_last->[_TYPE_] eq 't'
                                && $rtokh_last_last->[_TOKEN_] =~ /^\&\s*$/ )
                        )
                    )
                  )
                {
                    $ws =
                      $rOpts_space_function_paren
                      ? $self->ws_space_function_paren( $rtokh_last,
                        $rtokh_last_last )
                      : WS_NO;

                    # Note that this does not include functions called
                    # with '->(', so that case has to be handled separately
                    set_container_ws_by_keyword( $last_token, $seqno );
                    $ris_function_call_paren->{$seqno} = 1;
                }

                # space between something like $i and ( in 'snippets/space2.in'
                # for $i ( 0 .. 20 ) {
                elsif ( $last_type eq 'i' && $last_token =~ /^[\$\%\@]/ ) {
                    $ws = WS_YES;
                }

                # allow constant function followed by '()' to retain no space
                elsif ($last_type eq 'C'
                    && $rLL->[ $j + 1 ]->[_TOKEN_] eq ')' )
                {
                    $ws = WS_NO;
                }

                # a paren after a sub definition starts signature
                elsif ( $last_type eq 'S' ) {
                    $ws = $ws_signature_paren->($j);
                }

                else {
                    # no special rule for this opening paren type
                }
            }

            # patch for SWITCH/CASE: make space at ']{' optional
            # since the '{' might begin a case or when block
            elsif ( ( $token eq '{' && $type ne 'L' ) && $last_token eq ']' ) {
                $ws = WS_OPTIONAL;
            }
            else {
                # opening type not covered by a special rule
            }

            # keep space between 'sub' and '{' for anonymous sub definition,
            # be sure type = 'k' (added for c140)
            if ( $type eq '{' ) {
                if (   $last_token eq 'sub'
                    && $last_type eq 'k'
                    && $token ne '(' )
                {
                    $ws = WS_YES;
                }

                # this is needed to avoid no space in '){'
                if ( $last_token eq ')' && $token eq '{' ) { $ws = WS_YES }

                # avoid any space before the brace or bracket in something like
                #  @opts{'a','b',...}
                if ( $last_type eq 'i' && $last_token =~ /^\@/ ) {
                    $ws = WS_NO;
                }
            }

            # The --extended-block-tightness option allows certain braces
            # to be treated as blocks just for setting inner whitespace
            if ( $rOpts_extended_block_tightness && $token eq '{' ) {
                my $seqno = $rtokh->[_TYPE_SEQUENCE_];
                if (  !$rblock_type_of_seqno->{$seqno}
                    && $extended_block_tightness_list{$last_token} )
                {

                    # Ok - make this brace a block type for tightness only
                    $block_type_for_tightness{$seqno} = $last_token;
                }
            }
        } ## end elsif ( $is_opening_type{$type} ) {

        else {
            # $type not opening, closing, or covered by a special rule
        }

        # always preserve whatever space was used after a possible
        # filehandle (except _)
        if ( $last_type eq 'Z' && $last_token ne '_' ) {

            # no space for '$ {' even if '$' is marked as type 'Z', issue c221
            # note: redundant check on type 'h' here removed for c419 part 2b
            if ( $last_type eq 'Z' && $last_token eq '$' && $token eq '{' ) {
                $ws = WS_NO;
            }
            else {
                $ws = WS_OPTIONAL;
            }
        }

        $ws_4 = $ws_3 = $ws
          if DEBUG_WHITE;

        if ( !defined($ws) ) {

            #---------------------------------------------------------------
            # Whitespace Rules Section 4:
            # Use the binary rule table.
            #---------------------------------------------------------------
            if ( defined( $binary_ws_rules{$last_type}{$type} ) ) {
                $ws   = $binary_ws_rules{$last_type}{$type};
                $ws_4 = $ws if DEBUG_WHITE;
            }

            #---------------------------------------------------------------
            # Whitespace Rules Section 5:
            # Apply default rules not covered above.
            #---------------------------------------------------------------

            # If we fall through to here, look at the pre-defined hash tables
            # for the two tokens, and:
            #  if (they are equal) use the common value
            #  if (either is zero or undef) use the other
            #  if (either is -1) use it
            # That is,
            # left  vs right
            #  1    vs    1     -->  1
            #  0    vs    0     -->  0
            # -1    vs   -1     --> -1
            #
            #  0    vs   -1     --> -1
            #  0    vs    1     -->  1
            #  1    vs    0     -->  1
            # -1    vs    0     --> -1
            #
            # -1    vs    1     --> -1
            #  1    vs   -1     --> -1
            else {
                my $wl = $want_left_space{$type};
                my $wr = $want_right_space{$last_type};
                if ( !defined($wl) ) {
                    $ws = defined($wr) ? $wr : 0;
                }
                elsif ( !defined($wr) ) {
                    $ws = $wl;
                }
                else {
                    $ws =
                      ( ( $wl == $wr ) || ( $wl == -1 ) || !$wr ) ? $wl : $wr;
                }
            }
        }

        # Treat newline as a whitespace. Otherwise, we might combine
        # 'Send' and '-recipients' here according to the above rules:
        # <<snippets/space3.in>>
        #    my $msg = new Fax::Send
        #      -recipients => $to,
        #      -data => $data;
        if (  !$ws
            && $rtokh->[_LINE_INDEX_] != $rtokh_last->[_LINE_INDEX_] )
        {
            $ws = WS_YES;
        }

        # -qwaf phantom commas require space before type 'Q'
        # See similar patch in sub is_essential_whitespace
        if (  !$last_token
            && $last_type eq ','
            && $type eq 'Q'
            && $rOpts_qw_as_function )
        {
            $ws = 1;
        }

        $rwhitespace_flags->[$j] = $ws;

        # remember non-blank, non-comment tokens
        $last_token      = $token;
        $last_type       = $type;
        $rtokh_last_last = $rtokh_last;
        $rtokh_last      = $rtokh;

        # Programming note: for some reason, it is very much faster to 'next'
        # out of this loop here than to put the DEBUG coding in a block.
        # But note that the debug code must then update its own copies
        # of $last_token and $last_type.
        next if ( !DEBUG_WHITE );

        my $str = substr( $last_token_dbg, 0, 15 );
        $str .= SPACE x ( 16 - length($str) );
        if ( !defined($ws_1) ) { $ws_1 = "*" }
        if ( !defined($ws_2) ) { $ws_2 = "*" }
        if ( !defined($ws_3) ) { $ws_3 = "*" }
        if ( !defined($ws_4) ) { $ws_4 = "*" }
        print {*STDOUT}
"NEW WHITE:  i=$j $str $last_type_dbg $type $ws_1 : $ws_2 : $ws_3 : $ws_4 : $ws \n";

        # reset for next pass
        $ws_1 = $ws_2 = $ws_3 = $ws_4 = undef;

        $last_token_dbg = $token;
        $last_type_dbg  = $type;

    } ## end main loop

    if ( $rOpts->{'tight-secret-operators'} ) {
        $self->new_secret_operator_whitespace($rwhitespace_flags);
    }
    $self->[_ris_function_call_paren_] = $ris_function_call_paren;
    return $rwhitespace_flags;

} ## end sub set_whitespace_flags

sub set_container_ws_by_keyword {

    my ( $word, $sequence_number ) = @_;
    return unless (%keyword_paren_inner_tightness);

    # We just saw a keyword (or other function name) followed by an opening
    # paren. Now check to see if the following paren should have special
    # treatment for its inside space.  If so we set a hash value using the
    # sequence number as key.
    if ( $word && $sequence_number ) {
        my $tightness_here = $keyword_paren_inner_tightness{$word};
        if ( defined($tightness_here) && $tightness_here != 1 ) {
            my $ws_flag = $tightness_here == 0 ? WS_YES : WS_NO;
            $opening_container_inside_ws{$sequence_number} = $ws_flag;
            $closing_container_inside_ws{$sequence_number} = $ws_flag;
        }
    }
    else {
        DEVEL_MODE
          && Fault("unexpected token='$word' and seqno='$sequence_number'\n");
    }
    return;
} ## end sub set_container_ws_by_keyword

sub ws_in_container {

    my ( $j, $j_closing, $rLL, $type, $token, $last_token ) = @_;

    # Given:
    #  $j = index of token following an opening container token
    #  $type, $token = the type and token at index $j
    #  $j_closing = closing token of the container
    #  $last_token = the opening token of the container
    # Return:
    #  WS_NO  if there is just one token in the container (with exceptions)
    #  WS_YES otherwise

    # quick check
    if ( $j + 1 >= $j_closing ) { return WS_NO }

    # special cases...

    # Count '-foo' as single token so that each of
    #    $a{-foo} and $a{foo} and $a{'foo'}
    # do not get spaces with default formatting.
    my $j_here = $j;
    ++$j_here
      if ( $token eq '-'
        && $last_token eq '{'
        && $rLL->[ $j + 1 ]->[_TYPE_] eq 'w' );

    # Count a sign separated from a number as a single token, as in the
    # following line. Otherwise, it takes two steps to converge:
    #    deg2rad(-  0.5)
    if (   ( $type eq 'm' || $type eq 'p' )
        && $j < $j_closing + 1
        && $rLL->[ $j + 1 ]->[_TYPE_] eq 'b'
        && $rLL->[ $j + 2 ]->[_TYPE_] eq 'n'
        && $rLL->[ $j + 2 ]->[_TOKEN_] =~ /^\d/ )
    {
        $j_here = $j + 2;
    }

    # recheck..
    if ( $j_here + 1 >= $j_closing ) { return WS_NO }

    # check for a blank after the first token
    my $j_next =
      ( $rLL->[ $j_here + 1 ]->[_TYPE_] eq 'b' )
      ? $j_here + 2
      : $j_here + 1;

    return $j_next == $j_closing ? WS_NO : WS_YES;

} ## end sub ws_in_container

sub ws_space_function_paren {

    my ( $self, $rtokh_last, $rtokh_last_last ) = @_;

    # Called if --space-function-paren is set to see if it might cause
    # a problem.  The manual warns the user about potential problems with
    # this flag. Here we just try to catch one common problem.

    # Given:
    #  $j = index of '(' after function name
    # Return:
    #  WS_NO  if no space
    #  WS_YES otherwise

    # This was added to fix for issue c166. Ignore -sfp at a possible indirect
    # object location. For example, do not convert this:
    #   print header() ...
    # to this:
    #   print header () ...
    # because in this latter form, header may be taken to be a file handle
    # instead of a function call.

    # Start with the normal value for -sfp:
    my $ws = WS_YES;

    # now check to be sure we don't cause a problem:
    my $type_ll = $rtokh_last_last->[_TYPE_];
    my $tok_ll  = $rtokh_last_last->[_TOKEN_];

    # NOTE: this is just a minimal check. For example, we might also check
    # for something like this:
    #   print ( header ( ..
    if ( $type_ll eq 'k' && $is_indirect_object_taker{$tok_ll} ) {
        $ws = WS_NO;
    }

    # do not let -sfp add space for qw's converted to functions by -qwaf
    if (   $rOpts_qw_as_function
        && $rtokh_last->[_TYPE_] eq 'U'
        && $rtokh_last->[_TOKEN_] eq 'qw' )
    {
        $ws = WS_NO;
    }

    return $ws;

} ## end sub ws_space_function_paren

} ## end closure set_whitespace_flags

sub dump_want_left_space {
    my $fh = shift;
    local $LIST_SEPARATOR = "\n";
    $fh->print(<<EOM);
These values are the main control of whitespace to the left of a token type;
They may be altered with the -wls parameter.
For a list of token types, use perltidy --dump-token-types (-dtt)
 1 means the token wants a space to its left
-1 means the token does not want a space to its left
------------------------------------------------------------------------
EOM
    foreach my $key ( sort keys %want_left_space ) {
        $fh->print("$key\t$want_left_space{$key}\n");
    }
    return;
} ## end sub dump_want_left_space

sub dump_want_right_space {
    my $fh = shift;
    local $LIST_SEPARATOR = "\n";
    $fh->print(<<EOM);
These values are the main control of whitespace to the right of a token type;
They may be altered with the -wrs parameter.
For a list of token types, use perltidy --dump-token-types (-dtt)
 1 means the token wants a space to its right
-1 means the token does not want a space to its right
------------------------------------------------------------------------
EOM
    foreach my $key ( sort keys %want_right_space ) {
        $fh->print("$key\t$want_right_space{$key}\n");
    }
    return;
} ## end sub dump_want_right_space

{    ## begin closure is_essential_whitespace

    my %is_sort_grep_map;
    my %is_digraph;
    my %is_trigraph;
    my %essential_whitespace_filter_l1;
    my %essential_whitespace_filter_r1;
    my %essential_whitespace_filter_l2;
    my %essential_whitespace_filter_r2;
    my %is_type_with_space_before_bareword;
    my %is_special_variable_char;
    my %is_digit_char;

    BEGIN {

        my @q;

        # NOTE: This hash is like the global %is_sort_map_grep, but it ignores
        # grep aliases on purpose, since here we are looking parens, not braces
        @q = qw( sort grep map );
        @is_sort_grep_map{@q} = (1) x scalar(@q);

        @q = qw{
          .. :: << >> ** && || // -> => += -=
          .= %= &= |= ^= *= <> <= >= == =~ !~
          != ++ -- /= x= ~~ ~. |. &. ^. ^^
        };
        @is_digraph{@q} = (1) x scalar(@q);

        @q = qw( ... **= <<= >>= &&= ||= //= <=> !~~ &.= |.= ^.= <<~ );
        @is_trigraph{@q} = (1) x scalar(@q);

        # These are used as a speedup filters for sub is_essential_whitespace.

        # Filter 1:
        # These left side token types USUALLY do not require a space:
        @q = qw( ; { } [ ] L R );
        push @q, ',';
        push @q, ')';
        push @q, '(';
        @essential_whitespace_filter_l1{@q} = (1) x scalar(@q);

        # BUT some might if followed by these right token types
        @q = qw( pp mm << <<= h );
        @essential_whitespace_filter_r1{@q} = (1) x scalar(@q);

        # Filter 2:
        # These right side filters usually do not require a space
        @q = qw( ; ] R } );
        push @q, ',';
        push @q, ')';
        @essential_whitespace_filter_r2{@q} = (1) x scalar(@q);

        # BUT some might if followed by these left token types
        @q = qw( h Z );
        @essential_whitespace_filter_l2{@q} = (1) x scalar(@q);

        # Keep a space between certain types and any bareword:
        # Q: keep a space between a quote and a bareword to prevent the
        #    bareword from becoming a quote modifier.
        # &: do not remove space between an '&' and a bare word because
        #    it may turn into a function evaluation, like here
        #    between '&' and 'O_ACCMODE', producing a syntax error [File.pm]
        #      $opts{rdonly} = (($opts{mode} & O_ACCMODE) == O_RDONLY);
        @q = qw( Q & );
        @is_type_with_space_before_bareword{@q} = (1) x scalar(@q);

        # These are the only characters which can (currently) form special
        # variables, like $^W: (issue c066, c068).
        @q =
          qw{ ? A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ };
        @is_special_variable_char{@q} = (1) x scalar(@q);

        @q = qw( 0 1 2 3 4 5 6 7 8 9 );
        @is_digit_char{@q} = (1) x scalar(@q);

    } ## end BEGIN

    sub is_essential_whitespace {

        my ( $tokenll, $typell, $tokenl, $typel, $tokenr, $typer ) = @_;

        # Essential whitespace means whitespace which cannot be safely deleted
        # without risking the introduction of a syntax error.

        # Given: three tokens and their types:
        # ($tokenll, $typell) = previous nonblank token to the left of $tokenl
        # ($tokenl, $typel)   = the token to the left of the space in question
        # ($tokenr, $typer)   = the token to the right of the space in question

        # Return:
        #   true  if whitespace is needed
        #   false if whitespace may be deleted
        #
        # Note1: This routine should almost never need to be changed.  It is
        # for avoiding syntax problems rather than for formatting.

        # Note2: The -mangle option causes large numbers of calls to this
        # routine and therefore is a good test. So if a change is made, be sure
        # to use nytprof to profile with both old and revised coding using the
        # -mangle option and check differences.

        # This is potentially a very slow routine but the following quick
        # filters typically catch and handle over 90% of the calls.

        # -qwaf phantom commas require space before type 'Q'
        # See similar patch in sub set_whitespace_flags
        if (  !$tokenl
            && $typel eq ','
            && $typer eq 'Q'
            && $rOpts_qw_as_function )
        {
            return 1;
        }

        # Filter 1: usually no space required after common types ; , [ ] { } ( )
        return
          if ( $essential_whitespace_filter_l1{$typel}
            && !$essential_whitespace_filter_r1{$typer} );

        # Filter 2: usually no space before common types ; ,
        return
          if ( $essential_whitespace_filter_r2{$typer}
            && !$essential_whitespace_filter_l2{$typel} );

        # Filter 3: Handle side comments: a space is only essential if the left
        # token ends in '$' For example, we do not want to create $#foo below:

        #   sub t086
        #       ( #foo)))
        #       $ #foo)))
        #       a #foo)))
        #       ) #foo)))
        #       { ... }

        # Also, I prefer not to put a ? and # together because ? used to be
        # a pattern delimiter and spacing was used if guessing was needed.

        if ( $typer eq '#' ) {

            return 1
              if ( $tokenl
                && ( $typel eq '?' || substr( $tokenl, -1 ) eq '$' ) );
            return;
        }

        my $tokenr_leading_ch    = substr( $tokenr, 0, 1 );
        my $tokenr_leading_ch2   = substr( $tokenr, 0, 2 );
        my $tokenr_is_open_paren = $tokenr eq '(';
        my $token_joined         = $tokenl . $tokenr;
        my $tokenl_is_dash       = $tokenl eq '-';
        my $tokenr_is_bareword   = ord($tokenr_leading_ch) > ORD_PRINTABLE_MAX

          # always correct but slow
          ? $tokenr =~ /^[^\d\W]/

          # fast but ascii only
          : ( $tokenr_leading_ch =~ tr/a-zA-Z_/a-zA-Z_/ );

        #-------------------
        # Must do full check
        #-------------------

        # This long logical expression gives the result
        my $result =

          # never combine two bare words or numbers
          # examples:  and ::ok(1)
          #            return ::spw(...)
          #            for bla::bla:: abc
          # example is "%overload:: and" in files Dumpvalue.pm or colonbug.pl
          #            $input eq"quit" to make $inputeq"quit"
          #            my $size=-s::SINK if $file;  <==OK but we won't do it
          # don't join something like: for bla::bla:: abc
          # example is "%overload:: and" in files Dumpvalue.pm or colonbug.pl
          (
            (
                ## ( $tokenr =~ /^([\'\w]|\:\:)/ )
                     $tokenr_is_bareword
                  || $is_digit_char{$tokenr_leading_ch}
                  || $tokenr_leading_ch eq "'"
                  || $tokenr_leading_ch2 eq '::'
            )

              && ( $tokenl =~ /([\'\w]|\:\:)$/ && $typel ne 'CORE::' )
          )

          # do not combine a number with a concatenation dot
          # example: pom.caputo:
          # $vt100_compatible ? "\e[0;0H" : ('-' x 78 . "\n");
          || $typel eq 'n' && $tokenr eq '.'
          || $typer eq 'n' && $tokenl eq '.'

          # cases of a space before a bareword...
          || (
            $tokenr_is_bareword && (

                # do not join a minus with a bare word, because you might form
                # a file test operator.  Example from Complex.pm:
                # if (CORE::abs($z - i) < $eps);
                # "z-i" would be taken as a file test.
                $tokenl_is_dash && length($tokenr) == 1

                # and something like this could become ambiguous without space
                # after the '-':
                #   use constant III=>1;
                #   $a = $b - III;
                # and even this:
                #   $a = - III;
                || $tokenl_is_dash && $typer =~ /^[wC]$/

                # keep space between types Q & and a bareword
                || $is_type_with_space_before_bareword{$typel}

                # +-: binary plus and minus before a bareword could get
                # converted into unary plus and minus on next pass through the
                # tokenizer. This can lead to blinkers: cases b660 b670 b780
                # b781 b787 b788 b790 So we keep a space unless the +/- clearly
                # follows an operator
                || ( ( $typel eq '+' || $typel eq '-' )
                    && $typell !~ /^[niC\)\}\]R]$/ )

                # keep a space between a token ending in '$' and any word;
                # this caused trouble:  "die @$ if $@"
                || $typel eq 'i' && substr( $tokenl, -1, 1 ) eq '$'

                # don't combine $$ or $# with any alphanumeric
                # (testfile mangle.t with --mangle)
                || $tokenl eq '$$'
                || $tokenl eq '$#'

            )
          )    ## end $tokenr_is_bareword

          # OLD, not used
          # '= -' should not become =- or you will get a warning
          # about reversed -=
          # || ($tokenr eq '-')

          # do not join a bare word with a minus, like between 'Send' and
          # '-recipients' here <<snippets/space3.in>>
          #   my $msg = new Fax::Send
          #     -recipients => $to,
          #     -data => $data;
          # This is the safest thing to do. If we had the token to the right of
          # the minus we could do a better check.
          #
          # And do not combine a bareword and a quote, like this:
          #    oops "Your login, $Bad_Login, is not valid";
          # It can cause a syntax error if oops is a sub
          || $typel eq 'w' && ( $tokenr eq '-' || $typer eq 'Q' )

          # perl is very fussy about spaces before <<; c419 part 1
          || $tokenr_leading_ch2 eq '<<' && $typel ne '{' && $typel ne ','

          # avoid combining tokens to create new meanings. Example:
          #     $a+ +$b must not become $a++$b
          || ( $is_digraph{$token_joined} )
          || $is_trigraph{$token_joined}

          # another example: do not combine these two &'s:
          #     allow_options & &OPT_EXECCGI
          || $is_digraph{ $tokenl . $tokenr_leading_ch }

          # retain any space after possible filehandle
          # (testfiles prnterr1.t with --extrude and mangle.t with --mangle)
          # but no space for '$ {' even if '$' is marked as type 'Z', issue c221
          || ( $typel eq 'Z' && !( $tokenl eq '$' && $tokenr eq '{' ) )

          # Added 'Y' here 16 Jan 2021 to prevent -mangle option from removing
          # space after type Y. Otherwise, it will get parsed as type 'Z' later
          # and any space would have to be added back manually if desired.
          || $typel eq 'Y'

          # Perl is sensitive to whitespace after the + here:
          #  $b = xvals $a + 0.1 * yvals $a;
          || $typell eq 'Z' && $typel =~ /^[\/\?\+\-\*]$/

          || (
            $tokenr_is_open_paren && (

                # keep paren separate in 'use Foo::Bar ()'
                ( $typel eq 'w' && $typell eq 'k' && $tokenll eq 'use' )

                # OLD: keep any space between filehandle and paren:
                # file mangle.t with --mangle:
                # NEW: this test is no longer necessary here (moved above)
                ## || $typel eq 'Y'

                # must have space between grep and left paren; "grep(" will fail
                || $is_sort_grep_map{$tokenl}

                # don't stick numbers next to left parens, as in:
                #use Mail::Internet 1.28 (); (see Entity.pm, Head.pm, Test.pm)
                || $typel eq 'n'
            )
          )    ## end $tokenr_is_open_paren

          # retain any space after here doc operator ( see hereerr.t)
          # c419, part 2a: unless followed by '}' or ','. See also part 2b.
          # or ; (git174)
          || $typel eq 'h' && $typer ne '}' && $typer ne ',' && $typer ne ';'

          # Be careful with a space around ++ and --, to avoid ambiguity as to
          # which token it applies
          || ( $typer eq 'pp' || $typer eq 'mm' ) && $tokenl !~ /^[\;\{\(\[]/
          || ( $typel eq '++' || $typel eq '--' )
          && $tokenr !~ /^[\;\}\)\]]/

          # Need space after 'for my' or 'foreach my';
          # for example, this will fail in older versions of Perl:
          # foreach my$ft(@filetypes)...
          || ( $tokenl eq 'my'
            && $tokenr_leading_ch eq '$'
            && $is_for_foreach{$tokenll} )

          # Keep space after $^ if needed to avoid forming a different
          # special variable (issue c068). For example:
          #       my $aa = $^ ? "none" : "ok";
          # The problem is that '$^?' is a valid special variable
          || ( $typel eq 'i'
            && length($tokenl) == 2
            && substr( $tokenl, 1, 1 ) eq '^'
            && $is_special_variable_char{$tokenr_leading_ch} )

          # We must be sure that a space between a ? and a quoted string
          # remains if the space before the ? remains.  [Loca.pm, lockarea]
          # ie,
          #    $b=join $comma ? ',' : ':', @_;  # ok
          #    $b=join $comma?',' : ':', @_;    # ok!
          #    $b=join $comma ?',' : ':', @_;   # error!
          # Not really required:
          ## || ( ( $typel eq '?' ) && ( $typer eq 'Q' ) )

          # Space stacked labels...
          # Not really required: Perl seems to accept non-spaced labels.
          ## || $typel eq 'J' && $typer eq 'J'

          ;    # the value of this long logic sequence is the result we want
        return $result;
    } ## end sub is_essential_whitespace
} ## end closure is_essential_whitespace

{    ## begin closure new_secret_operator_whitespace

    my %secret_operators;
    my %is_leading_secret_token;

    BEGIN {

        # token lists for perl secret operators as compiled by Philippe Bruhat
        # at: https://metacpan.org/module/perlsecret
        %secret_operators = (
            'Goatse'            => [qw#= ( ) =#],        #=( )=
            'Venus1'            => [qw#0 +#],            # 0+
            'Venus2'            => [qw#+ 0#],            # +0
            'Enterprise'        => [qw#) x ! !#],        # ()x!!
            'Kite1'             => [qw#~ ~ <>#],         # ~~<>
            'Kite2'             => [qw#~~ <>#],          # ~~<>
            'Winking Fat Comma' => [ ( ',', '=>' ) ],    # ,=>
            'Bang bang'         => [qw#! !#],            # !!
        );

        # The following operators and constants are not included because they
        # are normally kept tight by perltidy:
        # ~~ <~>
        #

        # Make a lookup table indexed by the first token of each operator:
        # first token => [list, list, ...]
        foreach my $value ( values(%secret_operators) ) {
            my $tok = $value->[0];
            push @{ $is_leading_secret_token{$tok} }, $value;
        }
    } ## end BEGIN

    sub new_secret_operator_whitespace {

        my ( $self, $rwhitespace_flags ) = @_;

        # Implement --tight-secret-operators
        # Given:
        #   $rwhitespace_flags = whitespase flags, to be updated

        # Loop over all tokens in this line
        my $rLL  = $self->[_rLL_];
        my $jmax = @{$rLL} - 1;
        foreach my $j ( 0 .. $jmax ) {

            # Skip unless this token might start a secret operator
            my $type = $rLL->[$j]->[_TYPE_];
            next if ( $type eq 'b' );

            my $token = $rLL->[$j]->[_TOKEN_];
            next unless ( $is_leading_secret_token{$token} );

            # Loop over all secret operators with this leading token
            foreach my $rpattern ( @{ $is_leading_secret_token{$token} } ) {
                my $jend = $j - 1;
                foreach my $tok ( @{$rpattern} ) {
                    $jend++;

                    $jend++
                      if ( $jend <= $jmax
                        && $rLL->[$jend]->[_TYPE_] eq 'b' );

                    if (   $jend > $jmax
                        || $tok ne $rLL->[$jend]->[_TOKEN_] )
                    {
                        $jend = undef;
                        last;
                    }
                }

                if ($jend) {

                    # set flags to prevent spaces within this operator
                    foreach my $jj ( $j + 1 .. $jend ) {
                        $rwhitespace_flags->[$jj] = WS_NO;
                    }
                    $j = $jend;
                    last;
                }
            }    ## End Loop over all operators
        }    ## End loop over all tokens
        return;
    } ## end sub new_secret_operator_whitespace
} ## end closure new_secret_operator_whitespace

{    ## begin closure set_bond_strengths

    # These routines and variables are involved in deciding where to break very
    # long lines.

    # NEW_TOKENS must add bond strength rules

    my %is_good_keyword_breakpoint;
    my %is_container_token;

    my %binary_bond_strength_nospace;
    my %binary_bond_strength;
    my %nobreak_lhs;
    my %nobreak_rhs;

    my @bias_tokens;
    my %bias_hash;
    my %bias;
    my $delta_bias;

    sub initialize_bond_strength_hashes {

        my @q;
        @q = qw( if unless while until for foreach );
        @is_good_keyword_breakpoint{@q} = (1) x scalar(@q);

        @q = qw/ ( [ { } ] ) /;
        @is_container_token{@q} = (1) x scalar(@q);

        # The decision about where to break a line depends upon a "bond
        # strength" between tokens.  The LOWER the bond strength, the MORE
        # likely a break.  A bond strength may be any value but to simplify
        # things there are several pre-defined strength levels:

        #    NO_BREAK    => 10000;
        #    VERY_STRONG => 100;
        #    STRONG      => 2.1;
        #    NOMINAL     => 1.1;
        #    WEAK        => 0.8;
        #    VERY_WEAK   => 0.55;

        # The strength values are based on trial-and-error, and need to be
        # tweaked occasionally to get desired results.  Some comments:
        #
        #   1. Only relative strengths are important.  small differences
        #      in strengths can make big formatting differences.
        #   2. Each indentation level adds one unit of bond strength.
        #   3. A value of NO_BREAK makes an unbreakable bond
        #   4. A value of VERY_WEAK is the strength of a ','
        #   5. Values below NOMINAL are considered ok break points.
        #   6. Values above NOMINAL are considered poor break points.
        #
        # The bond strengths should roughly follow precedence order where
        # possible.  If you make changes, please check the results very
        # carefully on a variety of scripts.  Testing with the -extrude
        # options is particularly helpful in exercising all of the rules.

        # Wherever possible, bond strengths are defined in the following
        # tables.  There are two main stages to setting bond strengths and
        # two types of tables:
        #
        # The first stage involves looking at each token individually and
        # defining left and right bond strengths, according to if we want
        # to break to the left or right side, and how good a break point it
        # is.  For example tokens like =, ||, && make good break points and
        # will have low strengths, but one might want to break on either
        # side to put them at the end of one line or beginning of the next.
        #
        # The second stage involves looking at certain pairs of tokens and
        # defining a bond strength for that particular pair.  This second
        # stage has priority.

        #---------------------------------------------------------------
        # Bond Strength BEGIN Section 1.
        # Set left and right bond strengths of individual tokens.
        #---------------------------------------------------------------

        # NOTE: NO_BREAK's set in this section first are HINTS which will
        # probably not be honored. Essential NO_BREAKS's should be set in
        # BEGIN Section 2 or hardwired in the NO_BREAK coding near the end
        # of this subroutine.

        # Note that we are setting defaults in this section.  The user
        # cannot change bond strengths but can cause the left and right
        # bond strengths of any token type to be swapped through the use of
        # the -wba and -wbb flags. In this way the user can determine if a
        # breakpoint token should appear at the end of one line or the
        # beginning of the next line.

        %right_bond_strength          = ();
        %left_bond_strength           = ();
        %binary_bond_strength_nospace = ();
        %binary_bond_strength         = ();
        %nobreak_lhs                  = ();
        %nobreak_rhs                  = ();

        # The hash keys in this section are token types, plus the text of
        # certain keywords like 'or', 'and'.

        # no break around possible filehandle
        $left_bond_strength{'Z'}  = NO_BREAK;
        $right_bond_strength{'Z'} = NO_BREAK;

        # never put a bare word on a new line:
        # example print (STDERR, "bla"); will fail with break after (
        $left_bond_strength{'w'} = NO_BREAK;

        # blanks always have infinite strength to force breaks after
        # real tokens
        $right_bond_strength{'b'} = NO_BREAK;

        # try not to break on exponentiation
        @q                       = qw# ** .. ... <=> #;
        @left_bond_strength{@q}  = (STRONG) x scalar(@q);
        @right_bond_strength{@q} = (STRONG) x scalar(@q);

        # The comma-arrow has very low precedence but not a good break point
        $left_bond_strength{'=>'}  = NO_BREAK;
        $right_bond_strength{'=>'} = NOMINAL;

        # ok to break after label
        $left_bond_strength{'J'}  = NO_BREAK;
        $right_bond_strength{'J'} = NOMINAL;
        $left_bond_strength{'j'}  = STRONG;
        $right_bond_strength{'j'} = STRONG;
        $left_bond_strength{'A'}  = STRONG;
        $right_bond_strength{'A'} = STRONG;

        $left_bond_strength{'->'}  = STRONG;
        $right_bond_strength{'->'} = VERY_STRONG;

        $left_bond_strength{'CORE::'}  = NOMINAL;
        $right_bond_strength{'CORE::'} = NO_BREAK;

        # Fix for c250: added strengths for new type 'P'
        # Note: these are working okay, but may eventually need to be
        # adjusted or even removed.
        $left_bond_strength{'P'}  = NOMINAL;
        $right_bond_strength{'P'} = NOMINAL;

        # breaking AFTER modulus operator is ok:
        @q = qw< % >;
        @left_bond_strength{@q} = (STRONG) x scalar(@q);
        @right_bond_strength{@q} =
          ( 0.1 * NOMINAL + 0.9 * STRONG ) x scalar(@q);

        # Break AFTER math operators * and /
        @q                       = qw< * / x  >;
        @left_bond_strength{@q}  = (STRONG) x scalar(@q);
        @right_bond_strength{@q} = (NOMINAL) x scalar(@q);

        # Break AFTER weakest math operators + and -
        # Make them weaker than * but a bit stronger than '.'
        @q = qw< + - >;
        @left_bond_strength{@q} = (STRONG) x scalar(@q);
        @right_bond_strength{@q} =
          ( 0.91 * NOMINAL + 0.09 * WEAK ) x scalar(@q);

        # Define left strength of unary plus and minus (fixes case b511)
        $left_bond_strength{p} = $left_bond_strength{'+'};
        $left_bond_strength{m} = $left_bond_strength{'-'};

        # And make right strength of unary plus and minus very high.
        # Fixes cases b670 b790
        $right_bond_strength{p} = NO_BREAK;
        $right_bond_strength{m} = NO_BREAK;

        # breaking BEFORE these is just ok:
        @q                       = qw# >> << #;
        @right_bond_strength{@q} = (STRONG) x scalar(@q);
        @left_bond_strength{@q}  = (NOMINAL) x scalar(@q);

        # breaking before the string concatenation operator seems best
        # because it can be hard to see at the end of a line
        $right_bond_strength{'.'} = STRONG;
        $left_bond_strength{'.'}  = 0.9 * NOMINAL + 0.1 * WEAK;

        @q                       = qw< } ] ) R >;
        @left_bond_strength{@q}  = (STRONG) x scalar(@q);
        @right_bond_strength{@q} = (NOMINAL) x scalar(@q);

        # make these a little weaker than nominal so that they get
        # favored for end-of-line characters
        @q = qw< != == =~ !~ ~~ !~~ >;
        @left_bond_strength{@q} = (STRONG) x scalar(@q);
        @right_bond_strength{@q} =
          ( 0.9 * NOMINAL + 0.1 * WEAK ) x scalar(@q);

        # break AFTER these
        @q = qw# < >  | & >= <= #;
        @left_bond_strength{@q} = (VERY_STRONG) x scalar(@q);
        @right_bond_strength{@q} =
          ( 0.8 * NOMINAL + 0.2 * WEAK ) x scalar(@q);

        # breaking either before or after a quote is ok
        # but bias for breaking before a quote
        $left_bond_strength{'Q'}  = NOMINAL;
        $right_bond_strength{'Q'} = NOMINAL + 0.02;
        $left_bond_strength{'q'}  = NOMINAL;
        $right_bond_strength{'q'} = NOMINAL;

        # starting a line with a keyword is usually ok
        $left_bond_strength{'k'} = NOMINAL;

        # we usually want to bond a keyword strongly to what immediately
        # follows, rather than leaving it stranded at the end of a line
        $right_bond_strength{'k'} = STRONG;

        $left_bond_strength{'G'}  = NOMINAL;
        $right_bond_strength{'G'} = STRONG;

        # assignment operators
        @q = qw( = **= += *= &= <<= &&= -= /= |= >>= ||= //= .= %= ^= x= );

        # Default is to break AFTER various assignment operators
        @left_bond_strength{@q} = (STRONG) x scalar(@q);
        @right_bond_strength{@q} =
          ( 0.4 * WEAK + 0.6 * VERY_WEAK ) x scalar(@q);

        # Default is to break BEFORE '&&' and '||' and '//'
        # set strength of '||' to same as '=' so that chains like
        # $a = $b || $c || $d   will break before the first '||'
        $right_bond_strength{'||'} = NOMINAL;
        $left_bond_strength{'||'}  = $right_bond_strength{'='};

        # same thing for '//'
        $right_bond_strength{'//'} = NOMINAL;
        $left_bond_strength{'//'}  = $right_bond_strength{'='};

        # set strength of && a little higher than ||
        $right_bond_strength{'&&'} = NOMINAL;
        $left_bond_strength{'&&'}  = $left_bond_strength{'||'} + 0.1;

        # set strength of ^^ between && and ||. See git157.
        # "1 || 0 ^^ 0 || 1" = true, so ^^ is stronger than ||
        # "1 ^^ 1 && 0" = true,      so && is stronger than ^^
        $right_bond_strength{'^^'} = NOMINAL;
        $left_bond_strength{'^^'}  = $left_bond_strength{'||'} + 0.05;

        $left_bond_strength{';'}  = VERY_STRONG;
        $right_bond_strength{';'} = VERY_WEAK;
        $left_bond_strength{'f'}  = VERY_STRONG;

        # make right strength of for ';' a little less than '='
        # to make for contents break after the ';' to avoid this:
        #   for ( $j = $number_of_fields - 1 ; $j < $item_count ; $j +=
        #     $number_of_fields )
        # and make it weaker than ',' and 'and' too
        $right_bond_strength{'f'} = VERY_WEAK - 0.03;

        # The strengths of ?/: should be somewhere between
        # an '=' and a quote (NOMINAL),
        # make strength of ':' slightly less than '?' to help
        # break long chains of ? : after the colons
        $left_bond_strength{':'}  = 0.4 * WEAK + 0.6 * NOMINAL;
        $right_bond_strength{':'} = NO_BREAK;
        $left_bond_strength{'?'}  = $left_bond_strength{':'} + 0.01;
        $right_bond_strength{'?'} = NO_BREAK;

        $left_bond_strength{','}  = VERY_STRONG;
        $right_bond_strength{','} = VERY_WEAK;

        # remaining digraphs and trigraphs not defined above
        @q                       = qw( :: <> ++ -- );
        @left_bond_strength{@q}  = (WEAK) x scalar(@q);
        @right_bond_strength{@q} = (STRONG) x scalar(@q);

        # Set bond strengths of certain keywords
        # make 'or', 'err', 'and' slightly weaker than a ','
        $left_bond_strength{'and'} = VERY_WEAK - 0.01;
        $left_bond_strength{'or'}  = VERY_WEAK - 0.02;
        $left_bond_strength{'err'} = VERY_WEAK - 0.02;
        $left_bond_strength{'xor'} = VERY_WEAK - 0.01;

        @q = qw( ne eq );
        @left_bond_strength{@q} = (NOMINAL) x scalar(@q);

        @q = qw( lt gt le ge );
        @left_bond_strength{@q} = ( 0.9 * NOMINAL + 0.1 * STRONG ) x scalar(@q);

        @q = qw( and or err xor ne eq );
        @right_bond_strength{@q} = (NOMINAL) x scalar(@q);

        $right_bond_strength{'{'} = WEAK;
        $left_bond_strength{'{'}  = VERY_STRONG;

        #---------------------------------------------------------------
        # Bond Strength BEGIN Section 2.
        # Set binary rules for bond strengths between certain token types.
        #---------------------------------------------------------------

        #  We have a little problem making tables which apply to the
        #  container tokens.  Here is a list of container tokens and
        #  their types:
        #
        #   type    tokens // meaning
        #      {    {, [, ( // indent
        #      }    }, ], ) // outdent
        #      [    [ // left non-structural [ (enclosing an array index)
        #      ]    ] // right non-structural square bracket
        #      (    ( // left non-structural paren
        #      )    ) // right non-structural paren
        #      L    { // left non-structural curly brace (enclosing a key)
        #      R    } // right non-structural curly brace
        #
        #  Some rules apply to token types and some to just the token
        #  itself.  We solve the problem by combining type and token into a
        #  new hash key for the container types.
        #
        #  If a rule applies to a token 'type' then we need to make rules
        #  for each of these 'type.token' combinations:
        #  Type    Type.Token
        #  {       {{, {[, {(
        #  [       [[
        #  (       ((
        #  L       L{
        #  }       }}, }], })
        #  ]       ]]
        #  )       ))
        #  R       R}
        #
        #  If a rule applies to a token then we need to make rules for
        #  these 'type.token' combinations:
        #  Token   Type.Token
        #  {       {{, L{
        #  [       {[, [[
        #  (       {(, ((
        #  }       }}, R}
        #  ]       }], ]]
        #  )       }), ))

        # allow long lines before final { in an if statement, as in:
        #    if (..........
        #      ..........)
        #    {
        #
        # Otherwise, the line before the { tends to be too short.

        $binary_bond_strength{'))'}{'{{'} = VERY_WEAK + 0.03;
        $binary_bond_strength{'(('}{'{{'} = NOMINAL;

        # break on something like '} (', but keep this stronger than a ','
        # example is in 'howe.pl'
        $binary_bond_strength{'R}'}{'(('} = 0.8 * VERY_WEAK + 0.2 * WEAK;
        $binary_bond_strength{'}}'}{'(('} = 0.8 * VERY_WEAK + 0.2 * WEAK;

        # keep matrix and hash indices together
        # but make them a little below STRONG to allow breaking open
        # something like {'some-word'}{'some-very-long-word'} at the }{
        # (bracebrk.t)
        $binary_bond_strength{']]'}{'[['} = 0.9 * STRONG + 0.1 * NOMINAL;
        $binary_bond_strength{']]'}{'L{'} = 0.9 * STRONG + 0.1 * NOMINAL;
        $binary_bond_strength{'R}'}{'[['} = 0.9 * STRONG + 0.1 * NOMINAL;
        $binary_bond_strength{'R}'}{'L{'} = 0.9 * STRONG + 0.1 * NOMINAL;

        # increase strength to the point where a break in the following
        # will be after the opening paren rather than at the arrow:
        #    $a->$b($c);
        $binary_bond_strength{'i'}{'->'} = 1.45 * STRONG;

        # Added for c140 to make 'w ->' and 'i ->' behave the same
        $binary_bond_strength{'w'}{'->'} = 1.45 * STRONG;

        # Note that the following alternative strength would make the break at
        # the '->' rather than opening the '('.  Both have advantages and
        # disadvantages.
        # $binary_bond_strength{'i'}{'->'} = 0.5*STRONG + 0.5 * NOMINAL; #

        $binary_bond_strength{'))'}{'->'} = 0.1 * STRONG + 0.9 * NOMINAL;
        $binary_bond_strength{']]'}{'->'} = 0.1 * STRONG + 0.9 * NOMINAL;
        $binary_bond_strength{'})'}{'->'} = 0.1 * STRONG + 0.9 * NOMINAL;
        $binary_bond_strength{'}]'}{'->'} = 0.1 * STRONG + 0.9 * NOMINAL;
        $binary_bond_strength{'}}'}{'->'} = 0.1 * STRONG + 0.9 * NOMINAL;
        $binary_bond_strength{'R}'}{'->'} = 0.1 * STRONG + 0.9 * NOMINAL;

        $binary_bond_strength{'))'}{'[['} = 0.2 * STRONG + 0.8 * NOMINAL;
        $binary_bond_strength{'})'}{'[['} = 0.2 * STRONG + 0.8 * NOMINAL;
        $binary_bond_strength{'))'}{'{['} = 0.2 * STRONG + 0.8 * NOMINAL;
        $binary_bond_strength{'})'}{'{['} = 0.2 * STRONG + 0.8 * NOMINAL;

        #---------------------------------------------------------------
        # Binary NO_BREAK rules
        #---------------------------------------------------------------

        # use strict requires that bare word and => not be separated
        $binary_bond_strength{'C'}{'=>'} = NO_BREAK;
        $binary_bond_strength{'U'}{'=>'} = NO_BREAK;

        # Never break between a bareword and a following paren because
        # perl may give an error.  For example, if a break is placed
        # between 'to_filehandle' and its '(' the following line will
        # give a syntax error [Carp.pm]: my( $no) =fileno(
        # to_filehandle( $in)) ;
        $binary_bond_strength{'C'}{'(('} = NO_BREAK;
        $binary_bond_strength{'C'}{'{('} = NO_BREAK;
        $binary_bond_strength{'U'}{'(('} = NO_BREAK;
        $binary_bond_strength{'U'}{'{('} = NO_BREAK;

        # use strict requires that bare word within braces not start new
        # line
        $binary_bond_strength{'L{'}{'w'} = NO_BREAK;

        $binary_bond_strength{'w'}{'R}'} = NO_BREAK;

        # The following two rules prevent a syntax error caused by breaking up
        # a construction like '{-y}'.  The '-' quotes the 'y' and prevents
        # it from being taken as a transliteration. We have to keep
        # token types 'L m w' together to prevent this error.
        $binary_bond_strength{'L{'}{'m'}        = NO_BREAK;
        $binary_bond_strength_nospace{'m'}{'w'} = NO_BREAK;

        # keep 'bareword-' together, but only if there is no space between
        # the word and dash. Do not keep together if there is a space.
        # example 'use perl6-alpha'
        $binary_bond_strength_nospace{'w'}{'m'} = NO_BREAK;

        # use strict requires that bare word and => not be separated
        $binary_bond_strength{'w'}{'=>'} = NO_BREAK;

        # use strict does not allow separating type info from trailing { }
        # testfile is readmail.pl
        $binary_bond_strength{'t'}{'L{'} = NO_BREAK;
        $binary_bond_strength{'i'}{'L{'} = NO_BREAK;

        # Fix for c250: set strength for new 'S' to be same as 'i'
        # testfile is test11/Hub.pm
        $binary_bond_strength{'S'}{'L{'} = NO_BREAK;

        # As a defensive measure, do not break between a '(' and a
        # filehandle.  In some cases, this can cause an error.  For
        # example, the following program works:
        #    my $msg="hi!\n";
        #    print
        #    ( STDOUT
        #    $msg
        #    );
        #
        # But this program fails:
        #    my $msg="hi!\n";
        #    print
        #    (
        #    STDOUT
        #    $msg
        #    );
        #
        # This is normally only a problem with the 'extrude' option
        $binary_bond_strength{'(('}{'Y'} = NO_BREAK;
        $binary_bond_strength{'{('}{'Y'} = NO_BREAK;

        # never break between sub name and opening paren
        $binary_bond_strength{'w'}{'(('} = NO_BREAK;
        $binary_bond_strength{'w'}{'{('} = NO_BREAK;

        # keep '}' together with ';'
        $binary_bond_strength{'}}'}{';'} = NO_BREAK;

        # Breaking before a ++ can cause perl to guess wrong. For
        # example the following line will cause a syntax error
        # with -extrude if we break between '$i' and '++' [fixstyle2]
        #   print( ( $i++ & 1 ) ? $_ : ( $change{$_} || $_ ) );
        $nobreak_lhs{'++'} = NO_BREAK;

        # Do not break before a possible file handle
        $nobreak_lhs{'Z'} = NO_BREAK;

        # use strict hates bare words on any new line.  For
        # example, a break before the underscore here provokes the
        # wrath of use strict:
        # if ( -r $fn && ( -s _ || $AllowZeroFilesize)) {
        $nobreak_rhs{'F'}      = NO_BREAK;
        $nobreak_rhs{'CORE::'} = NO_BREAK;

        # To prevent the tokenizer from switching between types 'w' and 'G' we
        # need to avoid breaking between type 'G' and the following code block
        # brace. Fixes case b929.
        $nobreak_rhs{G} = NO_BREAK;

        #---------------------------------------------------------------
        # Bond Strength BEGIN Section 3.
        # Define tables and values for applying a small bias to the above
        # values.
        #---------------------------------------------------------------
        # Adding a small 'bias' to strengths is a simple way to make a line
        # break at the first of a sequence of identical terms.  For
        # example, to force long string of conditional operators to break
        # with each line ending in a ':', we can add a small number to the
        # bond strength of each ':' (colon.t)
        @bias_tokens = qw( : && || f and or . );       # tokens which get bias
        %bias_hash   = map { $_ => 0 } @bias_tokens;
        $delta_bias  = 0.0001;    # a very small strength level
        return;

    } ## end sub initialize_bond_strength_hashes

    use constant DEBUG_BOND => 0;

    sub set_bond_strengths {

        my ($self) = @_;

        # Define a 'bond strength' for each token pair in an output batch.
        # See comments above for definition of bond strength.

        my $rbond_strength_to_go = [];

        my $rLL               = $self->[_rLL_];
        my $rK_weld_right     = $self->[_rK_weld_right_];
        my $rK_weld_left      = $self->[_rK_weld_left_];
        my $ris_list_by_seqno = $self->[_ris_list_by_seqno_];

        # patch-its always ok to break at end of line
        $nobreak_to_go[$max_index_to_go] = 0;

        # we start a new set of bias values for each line
        %bias = %bias_hash;

        my $code_bias = -.01;    # bias for closing block braces

        my $type         = 'b';
        my $token        = SPACE;
        my $token_length = 1;
        my $last_type;
        my $last_nonblank_type  = $type;
        my $last_nonblank_token = $token;
        my $list_str            = $left_bond_strength{'?'};

        my ( $bond_str_1, $bond_str_2, $bond_str_3, $bond_str_4 );

        my ( $block_type, $i_next, $i_next_nonblank, $next_nonblank_token,
            $next_nonblank_type, $next_token, $next_type,
            $total_nesting_depth );

        # main loop to compute bond strengths between each pair of tokens
        foreach my $i ( 0 .. $max_index_to_go ) {
            $last_type = $type;
            if ( $type ne 'b' ) {
                $last_nonblank_type  = $type;
                $last_nonblank_token = $token;
            }
            $type = $types_to_go[$i];

            # strength on both sides of a blank is the same
            if ( $type eq 'b' && $last_type ne 'b' ) {
                $rbond_strength_to_go->[$i] = $rbond_strength_to_go->[ $i - 1 ];
                $nobreak_to_go[$i] ||= $nobreak_to_go[ $i - 1 ]; # fix for b1257
                next;
            }

            $token               = $tokens_to_go[$i];
            $token_length        = $token_lengths_to_go[$i];
            $block_type          = $block_type_to_go[$i];
            $i_next              = $i + 1;
            $next_type           = $types_to_go[$i_next];
            $next_token          = $tokens_to_go[$i_next];
            $total_nesting_depth = $nesting_depth_to_go[$i_next];
            $i_next_nonblank     = ( ( $next_type eq 'b' ) ? $i + 2 : $i + 1 );
            $next_nonblank_type  = $types_to_go[$i_next_nonblank];
            $next_nonblank_token = $tokens_to_go[$i_next_nonblank];

            my $seqno               = $type_sequence_to_go[$i];
            my $next_nonblank_seqno = $type_sequence_to_go[$i_next_nonblank];

            # We are computing the strength of the bond between the current
            # token and the NEXT token.

            #---------------------------------------------------------------
            # Bond Strength Section 1:
            # First Approximation.
            # Use minimum of individual left and right tabulated bond
            # strengths.
            #---------------------------------------------------------------
            my $bsr = $right_bond_strength{$type};
            my $bsl = $left_bond_strength{$next_nonblank_type};

            # define right bond strengths of certain keywords
            if ( $type eq 'k' ) {
                if ( defined( $right_bond_strength{$token} ) ) {
                    $bsr = $right_bond_strength{$token};
                }
            }

            # set terminal bond strength to the nominal value
            # this will cause good preceding breaks to be retained
            if ( $i_next_nonblank > $max_index_to_go ) {
                $bsl = NOMINAL;

                # But weaken the bond at a 'missing terminal comma'.  If an
                # optional comma is missing at the end of a broken list, use
                # the strength of a comma anyway to make formatting the same as
                # if it were there. Fixes issue c133.
                if ( !defined($bsr) || $bsr > VERY_WEAK ) {
                    my $seqno_px = $parent_seqno_to_go[$max_index_to_go];
                    if ( $ris_list_by_seqno->{$seqno_px} ) {
                        my $KK      = $K_to_go[$max_index_to_go];
                        my $Kn      = $self->K_next_nonblank($KK);
                        my $seqno_n = $rLL->[$Kn]->[_TYPE_SEQUENCE_];
                        if ( $seqno_n && $seqno_n eq $seqno_px ) {
                            $bsl = VERY_WEAK;
                        }
                    }
                }
            }

            # define left bond strengths of certain keywords
            if ( $next_nonblank_type eq 'k' ) {
                if ( defined( $left_bond_strength{$next_nonblank_token} ) ) {
                    $bsl = $left_bond_strength{$next_nonblank_token};
                }
            }

            # Use the minimum of the left and right strengths.  Note: it might
            # seem that we would want to keep a NO_BREAK if either token has
            # this value.  This didn't work, for example because in an arrow
            # list, it prevents the comma from separating from the following
            # bare word (which is probably quoted by its arrow).  So necessary
            # NO_BREAK's have to be handled as special cases in the final
            # section.
            if ( !defined($bsr) ) { $bsr = VERY_STRONG }
            if ( !defined($bsl) ) { $bsl = VERY_STRONG }
            my $bond_str = ( $bsr < $bsl ) ? $bsr : $bsl;
            $bond_str_1 = $bond_str if (DEBUG_BOND);

            #---------------------------------------------------------------
            # Bond Strength Section 2:
            # Apply hardwired rules..
            #---------------------------------------------------------------

            # Patch to put terminal or clauses on a new line: Weaken the bond
            # at an || followed by die or similar keyword to make the terminal
            # or clause fall on a new line, like this:
            #
            #   my $class = shift
            #     || die "Cannot add broadcast:  No class identifier found";
            #
            # Otherwise the break will be at the previous '=' since the || and
            # = have the same starting strength and the or is biased, like
            # this:
            #
            # my $class =
            #   shift || die "Cannot add broadcast:  No class identifier found";
            #
            # In any case if the user places a break at either the = or the ||
            # it should remain there.
            if ( $type eq '||' || $type eq 'k' && $token eq 'or' ) {

                #    /^(die|confess|croak|warn)$/
                if ( $is_die_confess_croak_warn{$next_nonblank_token} ) {
                    if ( $want_break_before{$token} && $i > 0 ) {
                        $rbond_strength_to_go->[ $i - 1 ] -= $delta_bias;

                        # keep bond strength of a token and its following blank
                        # the same
                        if ( $types_to_go[ $i - 1 ] eq 'b' && $i > 2 ) {
                            $rbond_strength_to_go->[ $i - 2 ] -= $delta_bias;
                        }
                    }
                    else {
                        $bond_str -= $delta_bias;
                    }
                }
            }

            # good to break after end of code blocks
            if ( $type eq '}' && $block_type && $next_nonblank_type ne ';' ) {

                $bond_str = 0.5 * WEAK + 0.5 * VERY_WEAK + $code_bias;
                $code_bias += $delta_bias;
            }

            if ( $type eq 'k' ) {

                # allow certain control keywords to stand out
                if (   $next_nonblank_type eq 'k'
                    && $is_last_next_redo_return{$token} )
                {
                    $bond_str = 0.45 * WEAK + 0.55 * VERY_WEAK;
                }

                # Don't break after keyword my.  This is a quick fix for a
                # rare problem with perl. An example is this line from file
                # Container.pm:

                # foreach my $question( Debian::DebConf::ConfigDb::gettree(
                # $this->{'question'} ) )

                if ( $token eq 'my' ) {
                    $bond_str = NO_BREAK;
                }

            }

            if ( $next_nonblank_type eq 'k' && $type ne 'CORE::' ) {

                if ( $is_keyword_returning_list{$next_nonblank_token} ) {
                    $bond_str = $list_str if ( $bond_str > $list_str );
                }

                # keywords like 'unless', 'if', etc, within statements
                # make good breaks
                if ( $is_good_keyword_breakpoint{$next_nonblank_token} ) {
                    $bond_str = VERY_WEAK / 1.05;
                }
            }

            # try not to break before a comma-arrow
            elsif ( $next_nonblank_type eq '=>' ) {
                if ( $bond_str < STRONG ) { $bond_str = STRONG }
            }
            else {
                # no applicable hardwired change
            }

            #---------------------------------------------------------------
            # Additional hardwired NOBREAK rules
            #---------------------------------------------------------------

            # map1.t -- correct for a quirk in perl
            if (   $token eq '('
                && $next_nonblank_type eq 'i'
                && $last_nonblank_type eq 'k'
                && $is_sort_map_grep{$last_nonblank_token} )

              #     /^(sort|map|grep)$/ )
            {
                $bond_str = NO_BREAK;
            }

            # extrude.t: do not break before paren at:
            #    -l pid_filename(
            if ( $last_nonblank_type eq 'F' && $next_nonblank_token eq '(' ) {
                $bond_str = NO_BREAK;
            }

            # OLD COMMENT: In older version of perl, use strict can cause
            # problems with breaks before bare words following opening parens.
            # For example, this will fail under older versions if a break is
            # made between '(' and 'MAIL':

            # use strict; open( MAIL, "a long filename or command"); close MAIL;

            # NEW COMMENT: Third fix for b1213:
            # This option does not seem to be needed any longer, and it can
            # cause instabilities.  It can be turned off, but to minimize
            # changes to existing formatting it is retained only in the case
            # where the previous token was 'open' and there was no line break.
            # Even this could eventually be removed if it causes instability.
            if ( $type eq '{' ) {

                if (   $token eq '('
                    && $next_nonblank_type eq 'w'
                    && $last_nonblank_type eq 'k'
                    && $last_nonblank_token eq 'open'
                    && !$old_breakpoint_to_go[$i] )
                {
                    $bond_str = NO_BREAK;
                }
            }

            # Do not break between a possible filehandle and a ? or / and do
            # not introduce a break after it if there is no blank
            # (extrude.t)
            elsif ( $type eq 'Z' ) {

                # don't break..
                if (

                    # if there is no blank and we do not want one. Examples:
                    #    print $x++    # do not break after $x
                    #    print HTML"HELLO"   # break ok after HTML
                    (
                           $next_type ne 'b'
                        && defined( $want_left_space{$next_type} )
                        && $want_left_space{$next_type} == WS_NO
                    )

                    # or we might be followed by the start of a quote,
                    # and this is not an existing breakpoint; fixes c039.
                    || !$old_breakpoint_to_go[$i]
                    && substr( $next_nonblank_token, 0, 1 ) eq '/'

                  )
                {
                    $bond_str = NO_BREAK;
                }
            }

            # Fix for c039
            elsif ( $type eq 'w' ) {
                $bond_str = NO_BREAK
                  if ( !$old_breakpoint_to_go[$i]
                    && substr( $next_nonblank_token, 0, 1 ) eq '/'
                    && $next_nonblank_type ne '//' );
            }
            else {
                # no hardwired rule applies
            }

            # Breaking before a ? before a quote can cause trouble if
            # they are not separated by a blank.
            # Example: a syntax error occurs if you break before the ? here
            #  my$logic=join$all?' && ':' || ',@regexps;
            # From: Professional_Perl_Programming_Code/multifind.pl
            if ( $next_nonblank_type eq '?' ) {
                $bond_str = NO_BREAK
                  if ( $types_to_go[ $i_next_nonblank + 1 ] eq 'Q' );
            }

            # Breaking before a . followed by a number
            # can cause trouble if there is no intervening space
            # Example: a syntax error occurs if you break before the .2 here
            #  $str .= pack($endian.2, ensurrogate($ord));
            # From: perl58/Unicode.pm
            elsif ( $next_nonblank_type eq '.' ) {
                $bond_str = NO_BREAK
                  if ( $types_to_go[ $i_next_nonblank + 1 ] eq 'n' );
            }

            # Do not break before a phantom comma because it will confuse
            # the convergence test (STRANGE message is emitted)
            elsif ( $next_nonblank_type eq ',' ) {
                if ( !length($next_nonblank_token) ) {
                    $bond_str = NO_BREAK;
                }
            }
            else {
                # no special NO_BREAK rule applies
            }

            $bond_str_2 = $bond_str if (DEBUG_BOND);

            #---------------------------------------------------------------
            # End of hardwired rules
            #---------------------------------------------------------------

            #---------------------------------------------------------------
            # Bond Strength Section 3:
            # Apply table rules. These have priority over the above
            # hardwired rules.
            #---------------------------------------------------------------

            my $tabulated_bond_str;
            my $ltype = $type;
            my $rtype = $next_nonblank_type;
            if ( $seqno && $is_container_token{$token} ) {
                $ltype = $type . $token;
            }

            if (   $next_nonblank_seqno
                && $is_container_token{$next_nonblank_token} )
            {
                $rtype = $next_nonblank_type . $next_nonblank_token;

                # Alternate Fix #1 for issue b1299.  This version makes the
                # decision as soon as possible.  See Alternate Fix #2 also.
                # Do not separate a bareword identifier from its paren: b1299
                # This is currently needed for stability because if the bareword
                # gets separated from a preceding '->' and following '(' then
                # the tokenizer may switch from type 'i' to type 'w'.  This
                # patch will prevent this by keeping it adjacent to its '('.
##              if (   $next_nonblank_token eq '('
##                  && $ltype eq 'i'
##                  && substr( $token, 0, 1 ) =~ /^\w$/ )
##              {
##                  $ltype = 'w';
##              }
            }

            # apply binary rules which apply regardless of space between tokens
            if ( $binary_bond_strength{$ltype}{$rtype} ) {
                $bond_str           = $binary_bond_strength{$ltype}{$rtype};
                $tabulated_bond_str = $bond_str;
            }

            # apply binary rules which apply only if no space between tokens
            if ( $binary_bond_strength_nospace{$ltype}{$next_type} ) {
                $bond_str           = $binary_bond_strength{$ltype}{$next_type};
                $tabulated_bond_str = $bond_str;
            }

            if ( $nobreak_rhs{$ltype} || $nobreak_lhs{$rtype} ) {
                $bond_str           = NO_BREAK;
                $tabulated_bond_str = $bond_str;
            }

            $bond_str_3 = $bond_str if (DEBUG_BOND);

            # If the hardwired rules conflict with the tabulated bond
            # strength then there is an inconsistency that should be fixed
            DEBUG_BOND
              && $tabulated_bond_str
              && $bond_str_1
              && $bond_str_1 != $bond_str_2
              && $bond_str_2 != $tabulated_bond_str
              && do {
                print {*STDOUT}
"BOND_TABLES: ltype=$ltype rtype=$rtype $bond_str_1->$bond_str_2->$bond_str_3\n";
              };

           #-----------------------------------------------------------------
           # Bond Strength Section 4:
           # Modify strengths of certain tokens which often occur in sequence
           # by adding a small bias to each one in turn so that the breaks
           # occur from left to right.
           #
           # Note that we only changing strengths by small amounts here,
           # and usually increasing, so we should not be altering any NO_BREAKs.
           # Other routines which check for NO_BREAKs will use a tolerance
           # of one to avoid any problem.
           #-----------------------------------------------------------------

            # The bias tables use special keys:
            #   $type - if not keyword
            #   $token - if keyword, but map some keywords together
            my $left_key =
              $type eq 'k' ? $token eq 'err' ? 'or' : $token : $type;
            my $right_key =
                $next_nonblank_type eq 'k'
              ? $next_nonblank_token eq 'err'
                  ? 'or'
                  : $next_nonblank_token
              : $next_nonblank_type;

            # bias left token
            if ( defined( $bias{$left_key} ) ) {
                if ( !$want_break_before{$left_key} ) {
                    $bias{$left_key} += $delta_bias;
                    $bond_str += $bias{$left_key};
                }
            }

            # bias right token
            if ( defined( $bias{$right_key} ) ) {
                if ( $want_break_before{$right_key} ) {

                    # for leading '.' align all but 'short' quotes; the idea
                    # is to not place something like "\n" on a single line.
                    if ( $right_key eq '.' ) {

                        my $is_short_quote = $last_nonblank_type eq '.'
                          && ( $token_length <=
                            $rOpts_short_concatenation_item_length )
                          && !$is_closing_token{$token};

                        if ( !$is_short_quote ) {
                            $bias{$right_key} += $delta_bias;
                        }
                    }
                    else {
                        $bias{$right_key} += $delta_bias;
                    }
                    $bond_str += $bias{$right_key};
                }
            }

            $bond_str_4 = $bond_str if (DEBUG_BOND);

            #---------------------------------------------------------------
            # Bond Strength Section 5:
            # Fifth Approximation.
            # Take nesting depth into account by adding the nesting depth
            # to the bond strength.
            #---------------------------------------------------------------
            my $strength;

            if ( defined($bond_str) && !$nobreak_to_go[$i] ) {
                if ( $total_nesting_depth > 0 ) {
                    $strength = $bond_str + $total_nesting_depth;
                }
                else {
                    $strength = $bond_str;
                }
            }
            else {
                $strength = NO_BREAK;

                # For critical code such as lines with here targets we must
                # be absolutely sure that we do not allow a break.  So for
                # these the nobreak flag exceeds 1 as a signal. Otherwise we
                # can run into trouble when small tolerances are added.
                $strength += 1
                  if ( $nobreak_to_go[$i] && $nobreak_to_go[$i] > 1 );
            }

            #---------------------------------------------------------------
            # Bond Strength Section 6:
            # Sixth Approximation. Welds.
            #---------------------------------------------------------------

            # Do not allow a break within welds
            if ( $total_weld_count && $seqno ) {
                my $KK = $K_to_go[$i];
                if ( $rK_weld_right->{$KK} ) {
                    $strength = NO_BREAK;
                }

                # But encourage breaking after opening welded tokens
                elsif ($rK_weld_left->{$KK}
                    && $is_opening_token{$token} )
                {
                    $strength -= 1;
                }
                else {
                    # not welded left or right
                }
            }

            # always break after side comment
            if ( $type eq '#' ) { $strength = 0 }

            $rbond_strength_to_go->[$i] = $strength;

            # Fix for case c001: be sure NO_BREAK's are enforced by later
            # routines, except at a '?' because '?' as quote delimiter is
            # deprecated.
            if ( $strength >= NO_BREAK && $next_nonblank_type ne '?' ) {
                $nobreak_to_go[$i] ||= 1;
            }

            DEBUG_BOND && do {
                my $str = substr( $token, 0, 15 );
                $str .= SPACE x ( 16 - length($str) );
                print {*STDOUT}
"BOND:  i=$i $str $type $next_nonblank_type depth=$total_nesting_depth strength=$bond_str_1 -> $bond_str_2 -> $bond_str_3 -> $bond_str_4 $bond_str -> $strength \n";

                # reset for next pass
                $bond_str_1 = $bond_str_2 = $bond_str_3 = $bond_str_4 = undef;
            };

        } ## end main loop
        return $rbond_strength_to_go;
    } ## end sub set_bond_strengths
} ## end closure set_bond_strengths

sub bad_pattern {
    my ($pattern) = @_;

    # Return true if a regex pattern has an error
    # Note: Tokenizer.pm also has a copy of this
    my $regex_uu = eval { qr/$pattern/ };
    return $EVAL_ERROR;
} ## end sub bad_pattern

{    ## begin closure prepare_cuddled_block_types

    my %no_cuddle;

    # Add keywords here which really should not be cuddled
    BEGIN {
        my @q = qw( if unless for foreach while );
        @no_cuddle{@q} = (1) x scalar(@q);
    }

    sub prepare_cuddled_block_types {

        # Construct a hash needed by the cuddled-else style

        my $cuddled_string = EMPTY_STRING;
        if ( $rOpts->{'cuddled-else'} ) {

            # set the default
            $cuddled_string = 'elsif else continue catch finally'
              unless ( $rOpts->{'cuddled-block-list-exclusive'} );

            # This is the old equivalent but more complex version
            # $cuddled_string = 'if-elsif-else unless-elsif-else -continue ';

            # Add users other blocks to be cuddled
            my $cuddled_block_list = $rOpts->{'cuddled-block-list'};
            if ($cuddled_block_list) {
                $cuddled_string .= SPACE . $cuddled_block_list;
            }
        }

        # If we have a cuddled string of the form
        #  'try-catch-finally'

        # we want to prepare a hash of the form

        # $rcuddled_block_types = {
        #    'try' => {
        #        'catch'   => 1,
        #        'finally' => 1
        #    },
        # };

        # use -dcbl to dump this hash

        # Multiple such strings are input as a space or comma separated list

        # If we get two lists with the same leading type, such as
        #   -cbl = "-try-catch-finally  -try-catch-otherwise"
        # then they will get merged as follows:
        # $rcuddled_block_types = {
        #    'try' => {
        #        'catch'     => 1,
        #        'finally'   => 2,
        #        'otherwise' => 1,
        #    },
        # };
        # This will allow either type of chain to be followed.

        $cuddled_string =~ s/,/ /g;    # allow space or comma separated lists
        my @cuddled_strings = split /\s+/, $cuddled_string;

        $rcuddled_block_types = {};

        # process each dash-separated string...
        my $string_count = 0;
        foreach my $string (@cuddled_strings) {
            next unless $string;
            my @words = split /-+/, $string;    # allow multiple dashes

            # we could look for and report possible errors here...
            next if ( @words <= 0 );

           # allow either '-continue' or *-continue' for arbitrary starting type
            my $start = '*';

            # a single word without dashes is a secondary block type
            if ( @words > 1 ) {
                $start = shift @words;
            }

            # always make an entry for the leading word. If none follow, this
            # will still prevent a wildcard from matching this word.
            if ( !defined( $rcuddled_block_types->{$start} ) ) {
                $rcuddled_block_types->{$start} = {};
            }

            # The count gives the original word order in case we ever want it.
            $string_count++;
            my $word_count = 0;
            foreach my $word (@words) {
                next unless $word;
                if ( $no_cuddle{$word} ) {
                    Warn(
"## Ignoring keyword '$word' in -cbl; does not seem right\n"
                    );
                    next;
                }
                $word_count++;
                $rcuddled_block_types->{$start}->{$word} =
                  1;    #"$string_count.$word_count";

                # git#9: Remove this word from the list of desired one-line
                # blocks
                $want_one_line_block{$word} = 0;
            }
        }
        return;
    } ## end sub prepare_cuddled_block_types
} ## end closure prepare_cuddled_block_types

sub dump_cuddled_block_list {
    my ($fh) = @_;

    # ORIGINAL METHOD: Here is the format of the cuddled block type hash
    # which controls this routine
    #    my $rcuddled_block_types = {
    #        'if' => {
    #            'else'  => 1,
    #            'elsif' => 1
    #        },
    #        'try' => {
    #            'catch'   => 1,
    #            'finally' => 1
    #        },
    #    };

    # SIMPLIFIED METHOD: the simplified method uses a wildcard for
    # the starting block type and puts all cuddled blocks together:
    #    my $rcuddled_block_types = {
    #        '*' => {
    #            'else'  => 1,
    #            'elsif' => 1
    #            'catch'   => 1,
    #            'finally' => 1
    #        },
    #    };

    # Both methods work, but the simplified method has proven to be adequate and
    # easier to manage.

    my $cuddled_string = $rOpts->{'cuddled-block-list'};
    $cuddled_string = EMPTY_STRING unless $cuddled_string;

    my $flags = EMPTY_STRING;
    $flags .= "-ce" if ( $rOpts->{'cuddled-else'} );
    $flags .= " -cbl='$cuddled_string'";

    if ( !$rOpts->{'cuddled-else'} ) {
        $flags .= "\nNote: You must specify -ce to generate a cuddled hash";
    }

    $fh->print(<<EOM);
------------------------------------------------------------------------
Hash of cuddled block types prepared for a run with these parameters:
  $flags
------------------------------------------------------------------------
EOM

    use Data::Dumper;
    $fh->print( Dumper($rcuddled_block_types) );

    $fh->print(<<EOM);
------------------------------------------------------------------------
EOM
    return;
} ## end sub dump_cuddled_block_list

sub make_static_block_comment_pattern {

    # create the pattern used to identify static block comments
    $static_block_comment_pattern = '^\s*##';

    # allow the user to change it
    if ( $rOpts->{'static-block-comment-prefix'} ) {
        my $prefix = $rOpts->{'static-block-comment-prefix'};
        $prefix =~ s/^\s+//;
        my $pattern = $prefix;

        # user may give leading caret to force matching left comments only
        if ( $prefix !~ /^\^#/ ) {
            if ( $prefix !~ /^#/ ) {
                Die(
"ERROR: the -sbcp prefix is '$prefix' but must begin with '#' or '^#'\n"
                );
            }
            $pattern = '^\s*' . $prefix;
        }
        if ( bad_pattern($pattern) ) {
            Die(
"ERROR: the -sbc prefix '$prefix' causes the invalid regex '$pattern'\n"
            );
        }
        $static_block_comment_pattern = $pattern;
    }
    return;
} ## end sub make_static_block_comment_pattern

sub make_format_skipping_pattern {
    my ( $opt_name, $default ) = @_;
    my $param = $rOpts->{$opt_name};
    if ( !$param ) { $param = $default }
    $param =~ s/^\s+//;
    if ( $param !~ /^#/ ) {
        Die("ERROR: the $opt_name parameter '$param' must begin with '#'\n");
    }
    my $pattern = '^' . $param . '\s';
    if ( bad_pattern($pattern) ) {
        Die(
"ERROR: the $opt_name parameter '$param' causes the invalid regex '$pattern'\n"
        );
    }
    return $pattern;
} ## end sub make_format_skipping_pattern

sub make_non_indenting_brace_pattern {

    # Create the pattern used to identify static side comments.
    # Note that we are ending the pattern in a \s. This will allow
    # the pattern to be followed by a space and some text, or a newline.
    # The pattern is used in sub 'non_indenting_braces'
    $non_indenting_brace_pattern = '^#<<<\s';

    # allow the user to change it
    if ( $rOpts->{'non-indenting-brace-prefix'} ) {
        my $prefix = $rOpts->{'non-indenting-brace-prefix'};
        $prefix =~ s/^\s+//;
        if ( $prefix !~ /^#/ ) {
            Die("ERROR: the -nibp parameter '$prefix' must begin with '#'\n");
        }
        my $pattern = '^' . $prefix . '\s';
        if ( bad_pattern($pattern) ) {
            Die(
"ERROR: the -nibp prefix '$prefix' causes the invalid regex '$pattern'\n"
            );
        }
        $non_indenting_brace_pattern = $pattern;
    }
    return;
} ## end sub make_non_indenting_brace_pattern

sub make_closing_side_comment_list_pattern {

    # turn any input list into a regex for recognizing selected block types
    $closing_side_comment_list_pattern = '^\w+';

    # '1' is an impossible block name
    $closing_side_comment_exclusion_pattern = '^1';

    # Need a separate flag for anonymous subs because they are the only
    # types where the side comment might follow a ';'
    $closing_side_comment_want_asub = 1;

    my $cscl = $rOpts->{'closing-side-comment-list'};
    if ( defined($cscl) && $cscl ) {
        $closing_side_comment_list_pattern =
          make_block_pattern( '-cscl', $cscl );
        $closing_side_comment_want_asub = $cscl =~ /\basub\b/;
    }

    my $cscxl = $rOpts->{'closing-side-comment-exclusion-list'};
    if ( defined($cscxl) && $cscxl ) {
        $closing_side_comment_exclusion_pattern =
          make_block_pattern( '-cscxl', $cscxl );
        if ( $cscxl =~ /\basub\b/ ) {
            $closing_side_comment_want_asub = 0;
        }
    }
    return;
} ## end sub make_closing_side_comment_list_pattern

sub initialize_closing_side_comments {

    make_closing_side_comment_prefix();
    make_closing_side_comment_list_pattern();

    # If closing side comments ARE selected, then we can safely
    # delete old closing side comments unless closing side comment
    # warnings are requested.  This is a good idea because it will
    # eliminate any old csc's which fall below the line count threshold.
    # We cannot do this if warnings are turned on, though, because we
    # might delete some text which has been added.  So that must
    # be handled when comments are created.  And we cannot do this
    # with -io because -csc will be skipped altogether.
    if ( $rOpts->{'closing-side-comments'} ) {
        if (   !$rOpts->{'closing-side-comment-warnings'}
            && !$rOpts->{'indent-only'} )
        {
            $rOpts->{'delete-closing-side-comments'} = 1;
        }
    }

    # If closing side comments ARE NOT selected, but warnings ARE
    # selected and we ARE DELETING csc's, then we will pretend to be
    # adding with a huge interval.  This will force the comments to be
    # generated for comparison with the old comments, but not added.
    elsif ( $rOpts->{'closing-side-comment-warnings'} ) {
        if ( $rOpts->{'delete-closing-side-comments'} ) {
            $rOpts->{'delete-closing-side-comments'}  = 0;
            $rOpts->{'closing-side-comments'}         = 1;
            $rOpts->{'closing-side-comment-interval'} = 100_000_000;
        }
    }
    else {
        # no -csc flags
    }

    return;
} ## end sub initialize_closing_side_comments

sub initialize_missing_else_comment {

    my $comment = $rOpts->{'add-missing-else-comment'};
    if ( !$comment ) {
        $comment = '##FIX' . 'ME - added with perltidy -ame';
    }
    else {
        $comment = substr( $comment, 0, 60 );
        $comment =~ s/^\s+//;
        $comment =~ s/\s+$//;
        $comment =~ s/\n/ /g;
        if ( substr( $comment, 0, 1 ) ne '#' ) {
            $comment = '#' . $comment;
        }
    }
    $rOpts->{'add-missing-else-comment'} = $comment;

    return;
} ## end sub initialize_missing_else_comment

sub make_sub_matching_pattern {

    # Patterns for standardizing matches to block types for regular subs and
    # anonymous subs. Examples
    #  'sub process' is a named sub
    #  'sub ::m' is a named sub
    #  'sub' is an anonymous sub
    #  'sub:' is a label, not a sub
    #  'sub :' is a label, not a sub   ( block type will be <sub:> )
    #   sub'_ is a named sub           ( block type will be <sub '_> )
    #  'substr' is a keyword
    # So note that named subs always have a space after 'sub'
    $SUB_PATTERN  = '^sub\s';         # match normal sub
    $ASUB_PATTERN = '^sub$';          # match anonymous sub
    %matches_ASUB = ( 'sub' => 1 );

    # Fix the patterns to include any sub aliases:
    # Note that any 'sub-alias-list' has been preprocessed to
    # be a trimmed, space-separated list which includes 'sub'
    # for example, it might be 'sub method fun'
    my @words;
    my $sub_alias_list = $rOpts->{'sub-alias-list'};
    if ($sub_alias_list) {
        @words = split /\s+/, $sub_alias_list;
    }
    else {
        push @words, 'sub';
    }

    #   add 'method' unless use-feature='noclass' is set.
    if ( !defined( $rOpts->{'use-feature'} )
        || $rOpts->{'use-feature'} !~ /\bnoclass\b/ )
    {
        push @words, 'method';
    }

    # Note (see also RT #133130): These patterns are used by
    # sub make_block_pattern, which is used for making most patterns.
    # So this sub needs to be called before other pattern-making routines.
    if ( @words > 1 ) {

        # Two ways are provided to match an anonymous sub:
        # $ASUB_PATTERN - with a regex (old method, slow)
        # %matches_ASUB - with a hash lookup (new method, faster)

        @matches_ASUB{@words} = (1) x scalar(@words);
        my $alias_list = join '|', keys %matches_ASUB;
        $SUB_PATTERN  =~ s/sub/\($alias_list\)/;
        $ASUB_PATTERN =~ s/sub/\($alias_list\)/;
    }
    return;
} ## end sub make_sub_matching_pattern

sub make_bl_pattern {

    # Set defaults lists to retain historical default behavior for -bl:
    my $bl_list_string           = '*';
    my $bl_exclusion_list_string = 'sort map grep eval asub';

    my $bl_long_name   = 'opening-brace-on-new-line';
    my $bll_long_name  = 'brace-left-list';
    my $blxl_long_name = 'brace-left-exclusion-list';
    my $sbl_long_name  = 'opening-sub-brace-on-new-line';
    my $asbl_long_name = 'opening-anonymous-sub-brace-on-new-line';

    if ( defined( $rOpts->{$bll_long_name} ) && $rOpts->{$bll_long_name} ) {
        $bl_list_string = $rOpts->{$bll_long_name};
    }
    if ( $bl_list_string =~ /\bsub\b/ ) {
        $rOpts->{$sbl_long_name} ||= $rOpts->{$bl_long_name};
    }
    if ( $bl_list_string =~ /\basub\b/ ) {
        $rOpts->{$asbl_long_name} ||= $rOpts->{$bl_long_name};
    }

    $bl_pattern = make_block_pattern( '-bll', $bl_list_string );

    # for -bl, a list with '*' turns on -sbl and -asbl
    if ( $bl_pattern =~ /\.\*/ ) {

        if ( !defined( $rOpts->{$sbl_long_name} ) ) {
            $rOpts->{$sbl_long_name} = $rOpts->{$bl_long_name};
        }

        if (  !defined( $rOpts->{$asbl_long_name} )
            && defined( $rOpts->{$bll_long_name} ) )
        {
            $rOpts->{$asbl_long_name} = $rOpts->{$bl_long_name};
        }
    }

    if ( defined( $rOpts->{$blxl_long_name} )
        && $rOpts->{$blxl_long_name} )
    {
        $bl_exclusion_list_string = $rOpts->{$blxl_long_name};
        if ( $bl_exclusion_list_string =~ /\bsub\b/ ) {
            $rOpts->{$sbl_long_name} = 0;
        }
        if ( $bl_exclusion_list_string =~ /\basub\b/ ) {
            $rOpts->{$asbl_long_name} = 0;
        }
    }

    $bl_exclusion_pattern =
      make_block_pattern( '-blxl', $bl_exclusion_list_string );
    return;
} ## end sub make_bl_pattern

sub make_bli_pattern {

    # Default list of block types for which -bli would apply:
    my $bli_list_string = 'if else elsif unless while for foreach do : sub';
    my $bli_exclusion_list_string = SPACE;

    if ( defined( $rOpts->{'brace-left-and-indent-list'} )
        && $rOpts->{'brace-left-and-indent-list'} )
    {
        $bli_list_string = $rOpts->{'brace-left-and-indent-list'};
    }

    $bli_pattern = make_block_pattern( '-blil', $bli_list_string );

    if ( defined( $rOpts->{'brace-left-and-indent-exclusion-list'} )
        && $rOpts->{'brace-left-and-indent-exclusion-list'} )
    {
        $bli_exclusion_list_string =
          $rOpts->{'brace-left-and-indent-exclusion-list'};
    }
    $bli_exclusion_pattern =
      make_block_pattern( '-blixl', $bli_exclusion_list_string );
    return;
} ## end sub make_bli_pattern

sub make_keyword_group_list_pattern {

    # Turn any input list into a regex for recognizing selected block types.
    # Here are the defaults:
    $keyword_group_list_pattern         = '^(our|local|my|use|require|)$';
    $keyword_group_list_comment_pattern = EMPTY_STRING;
    if ( defined( $rOpts->{'keyword-group-blanks-list'} )
        && $rOpts->{'keyword-group-blanks-list'} )
    {
        my @words = split /\s+/, $rOpts->{'keyword-group-blanks-list'};
        my @keyword_list;
        my @comment_list;
        foreach my $word (@words) {
            if ( $word eq 'BC' || $word eq 'SBC' ) {
                push @comment_list, $word;
                if ( $word eq 'SBC' ) { push @comment_list, 'SBCX' }
            }
            else {
                push @keyword_list, $word;
            }
        }
        $keyword_group_list_pattern =
          make_block_pattern( '-kgbl', $rOpts->{'keyword-group-blanks-list'} );
        $keyword_group_list_comment_pattern =
          make_block_pattern( '-kgbl', join( SPACE, @comment_list ) );
    }
    return;
} ## end sub make_keyword_group_list_pattern

sub make_block_brace_vertical_tightness_pattern {

    # Turn any input list into a regex for recognizing selected block types
    $block_brace_vertical_tightness_pattern =
      '^((if|else|elsif|unless|while|for|foreach|do|\w+:)$|sub)';
    if ( defined( $rOpts->{'block-brace-vertical-tightness-list'} )
        && $rOpts->{'block-brace-vertical-tightness-list'} )
    {
        $block_brace_vertical_tightness_pattern =
          make_block_pattern( '-bbvtl',
            $rOpts->{'block-brace-vertical-tightness-list'} );
    }
    return;
} ## end sub make_block_brace_vertical_tightness_pattern

sub make_blank_line_pattern {

    $blank_lines_before_closing_block_pattern = $SUB_PATTERN;
    my $key = 'blank-lines-before-closing-block-list';
    if ( defined( $rOpts->{$key} ) && $rOpts->{$key} ) {
        $blank_lines_before_closing_block_pattern =
          make_block_pattern( '-blbcl', $rOpts->{$key} );
    }

    $blank_lines_after_opening_block_pattern = $SUB_PATTERN;
    $key = 'blank-lines-after-opening-block-list';
    if ( defined( $rOpts->{$key} ) && $rOpts->{$key} ) {
        $blank_lines_after_opening_block_pattern =
          make_block_pattern( '-blaol', $rOpts->{$key} );
    }
    return;
} ## end sub make_blank_line_pattern

sub make_block_pattern {

    #  Given a string of block-type keywords, return a regex to match them
    #  The only tricky part is that labels are indicated with a single ':'
    #  and the 'sub' token text may have additional text after it (name of
    #  sub).
    #
    #  Example:
    #
    #   input string: "if else elsif unless while for foreach do : sub";
    #   pattern:  '^((if|else|elsif|unless|while|for|foreach|do|\w+:)$|sub)';

    #  Minor Update:
    #
    #  To distinguish between anonymous subs and named subs, use 'sub' to
    #   indicate a named sub, and 'asub' to indicate an anonymous sub

    my ( $abbrev, $string ) = @_;
    my @list  = split_words($string);
    my @words = ();
    my %seen;
    for my $i (@list) {
        if ( $i eq '*' ) { my $pattern = '^.*'; return $pattern }
        next if $seen{$i};
        $seen{$i} = 1;
        if ( $i eq 'sub' ) {
        }
        elsif ( $i eq 'asub' ) {
        }
        elsif ( $i eq ';' ) {
            push @words, ';';
        }
        elsif ( $i eq '{' ) {
            push @words, '\{';
        }
        elsif ( $i eq ':' ) {
            push @words, '\w+:';
        }
        elsif ( $i =~ /^\w/ ) {
            push @words, $i;
        }
        else {
            Warn("unrecognized block type $i after $abbrev, ignoring\n");
        }
    }

    # Fix 2 for c091, prevent the pattern from matching an empty string
    # '1 ' is an impossible block name.
    if ( !@words ) { push @words, "1 " }

    my $pattern      = '(' . join( '|', @words ) . ')$';
    my $sub_patterns = EMPTY_STRING;
    if ( $seen{'sub'} ) {
        $sub_patterns .= '|' . $SUB_PATTERN;
    }
    if ( $seen{'asub'} ) {
        $sub_patterns .= '|' . $ASUB_PATTERN;
    }
    if ($sub_patterns) {
        $pattern = '(' . $pattern . $sub_patterns . ')';
    }
    $pattern = '^' . $pattern;
    return $pattern;
} ## end sub make_block_pattern

sub make_static_side_comment_pattern {

    # Create the pattern used to identify static side comments
    $static_side_comment_pattern = '^##';

    # allow the user to change it
    if ( $rOpts->{'static-side-comment-prefix'} ) {
        my $prefix = $rOpts->{'static-side-comment-prefix'};
        $prefix =~ s/^\s+//;
        my $pattern = '^' . $prefix;
        if ( bad_pattern($pattern) ) {
            Die(
"ERROR: the -sscp prefix '$prefix' causes the invalid regex '$pattern'\n"
            );
        }
        $static_side_comment_pattern = $pattern;
    }
    return;
} ## end sub make_static_side_comment_pattern

sub make_closing_side_comment_prefix {

    # Be sure we have a valid closing side comment prefix
    my $csc_prefix = $rOpts->{'closing-side-comment-prefix'};
    my $csc_prefix_pattern;
    if ( !defined($csc_prefix) ) {
        $csc_prefix         = '## end';
        $csc_prefix_pattern = '^##\s+end';
    }
    else {
        my $test_csc_prefix = $csc_prefix;
        if ( $test_csc_prefix !~ /^#/ ) {
            $test_csc_prefix = '#' . $test_csc_prefix;
        }

        # make a regex to recognize the prefix
        my $test_csc_prefix_pattern = $test_csc_prefix;

        # escape any special characters
        $test_csc_prefix_pattern =~ s/([^#\s\w])/\\$1/g;

        $test_csc_prefix_pattern = '^' . $test_csc_prefix_pattern;

        # allow exact number of intermediate spaces to vary
        $test_csc_prefix_pattern =~ s/\s+/\\s\+/g;

        # make sure we have a good pattern
        # if we fail this we probably have an error in escaping
        # characters.

        if ( bad_pattern($test_csc_prefix_pattern) ) {

            # shouldn't happen..must have screwed up escaping, above
            if (DEVEL_MODE) {
                Fault(<<EOM);
Program Error: the -cscp prefix '$csc_prefix' caused the invalid regex '$csc_prefix_pattern'
EOM
            }

            # just warn and keep going with defaults
            Warn(
"Error: the -cscp prefix '$csc_prefix' caused the invalid regex '$csc_prefix_pattern'\n"
            );
            Warn("Please consider using a simpler -cscp prefix\n");
            Warn("Using default -cscp instead; please check output\n");
        }
        else {
            $csc_prefix         = $test_csc_prefix;
            $csc_prefix_pattern = $test_csc_prefix_pattern;
        }
    }
    $rOpts->{'closing-side-comment-prefix'} = $csc_prefix;
    $closing_side_comment_prefix_pattern = $csc_prefix_pattern;
    return;
} ## end sub make_closing_side_comment_prefix

##################################################
# CODE SECTION 4: receive lines from the tokenizer
##################################################

{    ## begin closure write_line

    my $nesting_depth;

    # Variables used by sub check_sequence_numbers:
    my $initial_seqno;
    my $last_seqno;
    my %saw_opening_seqno;
    my %saw_closing_seqno;

    # variables for the -qwaf option
    my $in_qw_seqno;
    my $in_qw_comma_count;
    my $last_new_seqno;
    my %new_seqno_from_old_seqno;
    my $last_ending_in_quote;
    my $added_seqno_count;

    sub initialize_write_line {

        $nesting_depth = undef;

        $initial_seqno     = undef;
        $last_seqno        = SEQ_ROOT;
        $last_new_seqno    = SEQ_ROOT;
        %saw_opening_seqno = ();
        %saw_closing_seqno = ();

        $in_qw_seqno              = 0;
        $in_qw_comma_count        = 0;    # b1491
        %new_seqno_from_old_seqno = ();
        $last_ending_in_quote     = 0;
        $added_seqno_count        = 0;

        return;
    } ## end sub initialize_write_line

    sub check_sequence_numbers {

        # Routine for checking sequence numbers.  This only needs to be
        # done occasionally in DEVEL_MODE to be sure everything is working
        # correctly.
        my ( $rtokens, $rtoken_type, $rtype_sequence, $input_line_no ) = @_;
        my $jmax = @{$rtokens} - 1;
        return if ( $jmax < 0 );
        foreach my $j ( 0 .. $jmax ) {
            my $seqno = $rtype_sequence->[$j];
            my $token = $rtokens->[$j];
            my $type  = $rtoken_type->[$j];
            $seqno = EMPTY_STRING unless ( defined($seqno) );
            my $err_msg =
"Error at j=$j, line number $input_line_no, seqno='$seqno', type='$type', tok='$token':\n";

            if ( !$seqno ) {

           # Sequence numbers are generated for opening tokens, so every opening
           # token should be sequenced.  Closing tokens will be unsequenced
           # if they do not have a matching opening token.
                if (   $is_opening_sequence_token{$token}
                    && $type ne 'q'
                    && $type ne 'Q' )
                {
                    Fault(
                        <<EOM
$err_msg Unexpected opening token without sequence number
EOM
                    );
                }
            }
            else {

                # Save starting seqno to identify sequence method:
                # New method starts with 2 and has continuous numbering
                # Old method (NOT USED) starts with >2 and may have gaps
                if ( !defined($initial_seqno) ) {
                    $initial_seqno = $seqno;

                    # Be sure that sequence numbers start with 2. If not,
                    # there is a programming error in the tokenizer.
                    if ( $initial_seqno != 2 ) {
                        Fault(<<EOM);
Expecting initial sequence number of 2 but got '$initial_seqno'
EOM
                    }

                    # Be sure the root sequence number is 1. This is set
                    # as a constant at the top of this module.
                    if ( SEQ_ROOT != 1 ) {
                        my $SEQ_ROOT = SEQ_ROOT;
                        Fault(<<EOM);
The constant SEQ_ROOT has been changed from 1 to '$SEQ_ROOT'.
EOM
                    }
                }

                if ( $is_opening_sequence_token{$token} ) {

                    # New method should have continuous numbering
                    if ( $initial_seqno == 2 && $seqno != $last_seqno + 1 ) {
                        Fault(
                            <<EOM
$err_msg Unexpected opening sequence number: previous seqno=$last_seqno, but seqno= $seqno
EOM
                        );
                    }
                    $last_seqno = $seqno;

                    # Numbers must be unique
                    if ( $saw_opening_seqno{$seqno} ) {
                        my $lno = $saw_opening_seqno{$seqno};
                        Fault(
                            <<EOM
$err_msg Already saw an opening tokens at line $lno with this sequence number
EOM
                        );
                    }
                    $saw_opening_seqno{$seqno} = $input_line_no;
                }

                # only one closing item per seqno
                elsif ( $is_closing_sequence_token{$token} ) {
                    if ( $saw_closing_seqno{$seqno} ) {
                        my $lno = $saw_closing_seqno{$seqno};
                        Fault(
                            <<EOM
$err_msg Already saw a closing token with this seqno  at line $lno
EOM
                        );
                    }
                    $saw_closing_seqno{$seqno} = $input_line_no;

                    # Every closing seqno must have an opening seqno
                    if ( !$saw_opening_seqno{$seqno} ) {
                        Fault(
                            <<EOM
$err_msg Saw a closing token but no opening token with this seqno
EOM
                        );
                    }
                }

                # Sequenced items must be opening or closing
                else {
                    Fault(
                        <<EOM
$err_msg Unexpected token type with a sequence number
EOM
                    );
                }
            }
        }
        return;
    } ## end sub check_sequence_numbers

    # hash keys which are common to old and new line_of_tokens
    my @common_keys;

    BEGIN {
        @common_keys = qw(
          _curly_brace_depth         _ending_in_quote
          _guessed_indentation_level _line_number
          _line_text                 _line_type
          _paren_depth               _square_bracket_depth
          _starting_in_quote
        );
    }

    sub write_line {

        my ( $self, $line_of_tokens_input ) = @_;

        # This routine receives lines one-by-one from the tokenizer and stores
        # them in a format suitable for further processing.  After the last
        # line has been sent, the tokenizer will call sub 'finish_formatting'
        # to do the actual formatting.

        # Given:
        #   $line_of_tokens_input = hash ref of one line from the tokenizer

        my $rLL            = $self->[_rLL_];
        my $line_of_tokens = {};

        # copy common hash key values
        @{$line_of_tokens}{@common_keys} =
          @{$line_of_tokens_input}{@common_keys};

        my $line_type = $line_of_tokens_input->{_line_type};
        my $tee_output;

        my $Klimit = $self->[_Klimit_];
        my ( $Kfirst, $Klast );

        # Handle line of non-code
        if ( $line_type ne 'CODE' ) {
            $tee_output ||= $rOpts_tee_pod
              && substr( $line_type, 0, 3 ) eq 'POD';

            $line_of_tokens->{_level_0}              = 0;
            $line_of_tokens->{_ci_level_0}           = 0;
            $line_of_tokens->{_nesting_blocks_0}     = EMPTY_STRING;
            $line_of_tokens->{_nesting_tokens_0}     = EMPTY_STRING;
            $line_of_tokens->{_ended_in_blank_token} = undef;
        }

        # Handle line of code
        else {

            my $rtokens = $line_of_tokens_input->{_rtokens};
            my $jmax    = @{$rtokens} - 1;

            if ( $jmax >= 0 ) {

                $Kfirst = defined($Klimit) ? $Klimit + 1 : 0;

                #----------------------------
                # get the tokens on this line
                #----------------------------
                $self->write_line_inner_loop( $line_of_tokens_input,
                    $line_of_tokens );

                # update Klimit for added tokens
                $Klimit = @{$rLL} - 1;
                $Klast  = $Klimit;

            } ## end if ( $jmax >= 0 )
            else {

                # blank line
                $line_of_tokens->{_level_0}              = 0;
                $line_of_tokens->{_ci_level_0}           = 0;
                $line_of_tokens->{_nesting_blocks_0}     = EMPTY_STRING;
                $line_of_tokens->{_nesting_tokens_0}     = EMPTY_STRING;
                $line_of_tokens->{_ended_in_blank_token} = undef;

            }

            $tee_output ||=
                 $rOpts_tee_block_comments
              && $jmax == 0
              && $rLL->[$Kfirst]->[_TYPE_] eq '#';

            $tee_output ||=
                 $rOpts_tee_side_comments
              && defined($Kfirst)
              && $Klimit > $Kfirst
              && $rLL->[$Klimit]->[_TYPE_] eq '#';

        } ## end if ( $line_type eq 'CODE')

        # Finish storing line variables
        $line_of_tokens->{_rK_range} = [ $Kfirst, $Klast ];
        $self->[_Klimit_] = $Klimit;
        my $rlines = $self->[_rlines_];
        push @{$rlines}, $line_of_tokens;

        if ($tee_output) {
            my $fh_tee    = $self->[_fh_tee_];
            my $line_text = $line_of_tokens_input->{_line_text};
            $fh_tee->print($line_text) if ($fh_tee);
        }

        # We must use the old line because the qw logic may change this flag
        $last_ending_in_quote = $line_of_tokens_input->{_ending_in_quote};

        return;
    } ## end sub write_line

    sub qw_to_function {
        my ( $self, $line_of_tokens, $is_ending_token ) = @_;

        # This sub implements the -qwaf option:
        # It is called for every type 'q' token which is part of a 'qw(' list.
        # Essentially all of the coding for the '-qwaf' option is in this sub.

        # Input parameters:
        #  $line_of_tokens = information hash for this line from the tokenizer,
        #  $is_ending_token = true if this qw does not extend to the next line

        # Method:
        # This qw token has already been pushed onto the output token stack, so
        # we will pop it off and push on a sequence of tokens created by
        # breaking it into an opening, a sequence of comma-separated quote
        # items, and a closing paren. For multi-line qw quotes, there will be
        # one call per input line until the end of the qw text is reached
        # and processed.

        # Note 1: A critical issue is to correctly generate and insert a new
        # sequence number for the new parens into the sequence number stream.
        # The new sequence number is the closure variable '$in_qw_seqno'.  It
        # is defined when the leading 'qw(' is seen, and is undefined when the
        # closing ')' is output.

        # Note 2: So far, no reason has been found to coordinate this logic
        # with the logic which adds and deletes commas. We are adding trailing
        # phantom commas here, except for a single list item, so no additional
        # trailing comma should be added. And if a phantom trailing comma gets
        # deleted, it should not matter because it does not get displayed.

        my $rLL                     = $self->[_rLL_];
        my $rSS                     = $self->[_rSS_];
        my $rdepth_of_opening_seqno = $self->[_rdepth_of_opening_seqno_];

        # Does this qw text spill over onto another line?
        my $is_continued =
          ( $is_ending_token && $line_of_tokens->{_ending_in_quote} );

        my $qw_text       = $rLL->[-1]->[_TOKEN_];
        my $qw_type       = $rLL->[-1]->[_TYPE_];
        my $qw_level      = $rLL->[-1]->[_LEVEL_];
        my $qw_text_start = $qw_text;
        my $opening       = EMPTY_STRING;
        my $closing       = EMPTY_STRING;
        my $has_opening_space;
        my $has_closing_space;

        # the new word tokens are 1 level deeper than the original 'q' token
        my $level_words = $qw_level + 1;

        if ( $qw_type ne 'q' ) {

            # This should never happen because the calling sub should have just
            # pushed a token of type 'q' onto the token list.
            my $lno = $line_of_tokens->{_line_number};
            Fault("$lno: expecting type 'q' but got $qw_type");
            return;
        }

        if ( !length($qw_text) ) {

            # This seems to be an empty type 'q' token. A blank line within a
            # qw quote is marked as a blank line rather than a blank 'q' token.
            # So this should never happen.
            my $lno = $line_of_tokens->{_line_number};
            DEVEL_MODE && Fault("$lno: received empty type 'q' text\n");
            return;
        }

        # remove leading 'qw(' if we are starting a new qw
        if ( !$in_qw_seqno ) {
            $opening = substr( $qw_text, 0, 3 );
            if ( $opening ne 'qw(' ) {

                # Caller should have checked this before calling
                my $lno = $line_of_tokens->{_line_number};
                DEVEL_MODE && Fault("$lno: unexpected qw opening: $opening\n");
                return;
            }
            $qw_text           = substr( $qw_text, 3 );
            $has_opening_space = $qw_text =~ s/^\s+//;

            # Do not use -qwaf under high stress (b1482,b1483,b1484,b1485,1486)
            # Note: so far all known cases of stress instability have had -naws
            # set, so this is included for now. It may eventually need to be
            # removed.
            # NOTE: The update for b1491 also fixes cases b1482-6 in a
            # more general way, so this test can be deactivated.
            if (   0
                && !$rOpts_add_whitespace
                && $level_words >= $high_stress_level )
            {
                return;
            }
        }

        # Look for and remove any closing ')'
        if ( !$is_continued ) {
            if ( length($qw_text) > 0 && substr( $qw_text, -1, 1 ) eq ')' ) {
                $closing = substr( $qw_text, -1,  1 );
                $qw_text = substr( $qw_text,  0, -1 );
                $qw_text =~ s/\s+$//;
                $has_closing_space = $qw_text =~ s/^\s+//;
            }
            else {

                # We are at the end of a 'qw(' quote according to the
                # tokenizer flag '_ending_in_quote', but there is no
                # ending ')'. The '$is_continued' flag seems to be wrong.
                my $lno = $line_of_tokens->{_line_number};
                Fault(<<EOM);
qwaf inconsistency at input line $lno:
closing token is '$closing'
is_continued = $is_continued
EOM
                return;
            }
        }

        # Get any quoted words
        my @words;
        if ( length($qw_text) ) {
            @words = split /\s+/, $qw_text;
        }

        # Be sure we have something left to output
        if ( !$opening && !$closing && !@words ) {
            my $lno = $line_of_tokens->{_line_number};
            DEVEL_MODE && Fault(<<EOM);
Error parsing the following qw string at line $lno:
$qw_text_start
EOM
            return;
        }

        # The combination -naws -lp can currently be unstable for multi-line qw
        # (b1487, b1488).
        # NOTE: this instability has been fixed by following the input
        # whitespace within parens, but keep this code for a while in case the
        # issue arises in the future (b1487).
        if (   0
            && !$rOpts_add_whitespace
            && $rOpts_line_up_parentheses
            && ( !$opening || !$closing ) )
        {
            return;
        }

        # c414 and c424: do not join a '\' and a closing ')' like here:
        #   my @clock_chars = qw( | / - \ | / - \ );
        if (
               @words
            && $closing
            && substr( $words[-1], -1, 1 ) eq BACKSLASH
            && (
                !$rOpts_add_whitespace
                || (   $tightness{')'} == 2
                    || $tightness{')'} == 1 && @words == 1 )
            )
          )
        {
            # fix by including a space after the \
            $words[-1] .= SPACE;

            # and for symmetry, before the first word if the '(' is on this line
            if ( $opening && $rOpts_add_whitespace ) {
                $words[0] = SPACE . $words[0];
            }
        }

        #---------------------------------------------------------------------
        # This is the point of no return if the transformation has not started
        #---------------------------------------------------------------------

        # pop old type q token
        my $rtoken_q = pop @{$rLL};

        # now push on the replacement tokens
        my $comma_count = 0;

        if ($opening) {

            # generate a new sequence number, one greater than the previous,
            # and update a count for synchronization with the calling sub.
            $in_qw_seqno = ++$last_new_seqno;
            $added_seqno_count++;
            my $seqno = $in_qw_seqno;

            # update relevant seqno hashes
            $self->[_K_opening_container_]->{$seqno} = @{$rLL};
            $rdepth_of_opening_seqno->[$seqno] = $nesting_depth;
            $nesting_depth++;
            $self->[_rI_opening_]->[$seqno] = @{$rSS};

            if ( $level_words > $self->[_maximum_level_] ) {
                my $input_line_no = $line_of_tokens->{_line_number};
                $self->[_maximum_level_]         = $level_words;
                $self->[_maximum_level_at_line_] = $input_line_no;
            }
            push @{$rSS}, $seqno;

            # make and push the 'qw' token
            my $rtoken_qw = copy_token_as_type( $rtoken_q, 'U', 'qw' );
            push @{$rLL}, $rtoken_qw;

            # make and push the '(' with the new sequence number
            my $rtoken_opening = copy_token_as_type( $rtoken_q, '{', '(' );
            $rtoken_opening->[_TYPE_SEQUENCE_] = $seqno;
            push @{$rLL}, $rtoken_opening;
        }

        # All words must be followed by a comma except for an intact
        # structure with a single word, like 'qw(hello)'
        my $commas_needed =
          !( ( $opening || !$in_qw_comma_count ) && $closing && @words == 1 );

        # Make and push each word as a type 'Q' quote followed by a phantom
        # comma. The phantom comma is type ',' and is processed
        # exactly like any other comma, but it has an empty string as the token
        # text, so the line will display as a regular qw quote.
        if (@words) {

            foreach my $word (@words) {

                # always space after a comma; follow input spacing after '('
                if ( $comma_count || $has_opening_space ) {
                    my $rtoken_space =
                      copy_token_as_type( $rtoken_q, 'b', SPACE );
                    $rtoken_space->[_LEVEL_] = $level_words;
                    push @{$rLL}, $rtoken_space;
                }

                # this quoted text
                my $rtoken_word = copy_token_as_type( $rtoken_q, 'Q', $word );
                $rtoken_word->[_LEVEL_] = $level_words;
                push @{$rLL}, $rtoken_word;

                # Add a comma if needed.  NOTE on trailing commas:
                # - For multiple words: Trailing commas must be added.
                #   Otherwise, -atc might put a comma in a qw list.
                # - For single words: Trailing commas are not required, and
                #   are best avoided. This is because:
                #   - atc will not add commas to a list which has no commas
                #   - This will make the single-item spacing rule work as
                #   expected.
                #   - This will reduce the chance of instability (b1491)
                if ($commas_needed) {
                    my $rtoken_comma =
                      copy_token_as_type( $rtoken_q, ',', EMPTY_STRING );
                    $rtoken_comma->[_LEVEL_] = $level_words;
                    push @{$rLL}, $rtoken_comma;
                    $comma_count++;
                }
            }
        }

        # make and push closing sequenced item ')'
        if ($closing) {

            # OPTIONAL: remove a previous comma if it is the only one. This can
            # happen if this closing paren starts a new line and there was just
            # one word in the qw list. The reason for doing this would be
            # to avoid possible instability, but none is currently known. b1491.
            # This has been tested but is currently inactive because it has not
            # been found to be necessary.
            if (   0
                && !@words
                && $in_qw_comma_count == 1
                && $rLL->[-1]->[_TYPE_] eq ',' )
            {

                # It is simpler to convert it to a blank; otherwise it would
                # be necessary to change the range [Kfirst,Klast] of the
                # previous line and the current line.
                $rLL->[-1]->[_TYPE_] = 'b';
            }

            # follow input spacing before ')'
            if ($has_closing_space) {
                my $rtoken_space = copy_token_as_type( $rtoken_q, 'b', SPACE );
                $rtoken_space->[_LEVEL_] = $level_words;
                push @{$rLL}, $rtoken_space;
            }

            my $seqno = $in_qw_seqno;
            $self->[_K_closing_container_]->{$seqno} = @{$rLL};
            $nesting_depth = $rdepth_of_opening_seqno->[$seqno];
            $self->[_rI_closing_]->[$seqno] = @{$rSS};
            push @{$rSS}, -1 * $seqno;

            # make the ')'
            my $rtoken_closing = copy_token_as_type( $rtoken_q, '}', ')' );
            $rtoken_closing->[_TYPE_SEQUENCE_] = $in_qw_seqno;
            push @{$rLL}, $rtoken_closing;

            # all done with this qw list
            $in_qw_seqno       = 0;
            $in_qw_comma_count = 0;
        }
        else {
            $in_qw_comma_count += $comma_count;
        }

        # The '_ending_in_quote' flag for this line is no longer needed
        if ($is_continued) { $line_of_tokens->{_ending_in_quote} = 0 }

        return;
    } ## end sub qw_to_function

    sub write_line_inner_loop {
        my ( $self, $line_of_tokens_old, $line_of_tokens ) = @_;

        # Copy the tokens on one line received from the tokenizer to their new
        # storage locations.

        # Input parameters:
        #  $line_of_tokens_old = line received from tokenizer
        #  $line_of_tokens     = line of tokens being formed for formatter

        my $rtokens = $line_of_tokens_old->{_rtokens};
        my $jmax    = @{$rtokens} - 1;
        if ( $jmax < 0 ) {

            # safety check; shouldn't happen
            my $lno = $line_of_tokens->{_line_number};
            DEVEL_MODE && Fault("$lno: unexpected jmax=$jmax\n");
            return;
        }

        my $line_index     = $line_of_tokens_old->{_line_number} - 1;
        my $rtoken_type    = $line_of_tokens_old->{_rtoken_type};
        my $rblock_type    = $line_of_tokens_old->{_rblock_type};
        my $rtype_sequence = $line_of_tokens_old->{_rtype_sequence};
        my $rlevels        = $line_of_tokens_old->{_rlevels};

        my $rLL                     = $self->[_rLL_];
        my $rSS                     = $self->[_rSS_];
        my $rdepth_of_opening_seqno = $self->[_rdepth_of_opening_seqno_];

        DEVEL_MODE
          && check_sequence_numbers( $rtokens, $rtoken_type,
            $rtype_sequence, $line_index + 1 );

        # Find the starting nesting depth ...
        # It must be the value of variable 'level' of the first token
        # because the nesting depth is used as a token tag in the
        # vertical aligner and is compared to actual levels.
        # So vertical alignment problems will occur with any other
        # starting value.
        if ( !defined($nesting_depth) ) {
            $nesting_depth                       = $rlevels->[0];
            $nesting_depth                       = 0 if ( $nesting_depth < 0 );
            $rdepth_of_opening_seqno->[SEQ_ROOT] = $nesting_depth - 1;
        }

        # error check for -qwaf:
        if ($in_qw_seqno) {
            if ( $rtoken_type->[0] ne 'q' ) {

                # -qwaf is expecting another 'q' token for multiline -qw
                # based on the {_ending_in_quote} flag from the tokenizer
                # of the previous line, but a 'q' didn't arrive.
                my $lno = $line_index + 1;
                Fault(
"$lno: -qwaf expecting qw continuation line but saw type '$rtoken_type->[0]'\n"
                );
            }
        }

        my $j = -1;

        # NOTE: coding efficiency is critical in this loop over all tokens
        foreach my $token ( @{$rtokens} ) {

            # NOTE: Do not clip the 'level' variable yet if it is negative. We
            # will do that later, in sub 'store_token_to_go'. The reason is
            # that in files with level errors, the logic in 'weld_cuddled_else'
            # uses a stack logic that will give bad welds if we clip levels
            # here. (A recent update will probably not even allow negative
            # levels to arrive here any longer).

            my @tokary;

            # Handle tokens with sequence numbers ...
            # note the ++ increment hidden here for efficiency
            if ( $rtype_sequence->[ ++$j ] ) {
                my $seqno_old = $rtype_sequence->[$j];
                my $seqno     = $seqno_old;

                my $sign = 1;
                if ( $is_opening_token{$token} ) {
                    if ($added_seqno_count) {
                        $seqno += $added_seqno_count;
                        $new_seqno_from_old_seqno{$seqno_old} = $seqno;
                    }
                    if ( DEVEL_MODE && $seqno != $last_new_seqno + 1 ) {
                        my $lno = $line_index + 1;
                        Fault("$lno: seqno=$seqno last=$last_new_seqno\n");
                    }
                    $last_new_seqno                          = $seqno;
                    $self->[_K_opening_container_]->{$seqno} = @{$rLL};
                    $rdepth_of_opening_seqno->[$seqno]       = $nesting_depth;
                    $nesting_depth++;

                    # Save a sequenced block type at its opening token.
                    # Note that unsequenced block types can occur in
                    # unbalanced code with errors but are ignored here.
                    if ( $rblock_type->[$j] ) {
                        my $block_type = $rblock_type->[$j];

                        # Store the block type with sequence number as hash key
                        $self->[_rblock_type_of_seqno_]->{$seqno} = $block_type;

                        # and save anynymous subs and named subs in separate
                        # hashes to avoid future pattern tests
                        if ( $matches_ASUB{$block_type} ) {
                            $self->[_ris_asub_block_]->{$seqno} = 1;
                        }

                        # The pre-check on space speeds up this test:
                        elsif ($block_type =~ /\s/
                            && $block_type =~ /$SUB_PATTERN/ )
                        {
                            $self->[_ris_sub_block_]->{$seqno} = 1;
                        }
                        else {
                            # not a sub type
                        }
                    }
                }
                elsif ( $is_closing_token{$token} ) {

                    if ($added_seqno_count) {
                        $seqno =
                          $new_seqno_from_old_seqno{$seqno_old} || $seqno_old;
                    }

                    # The opening depth should always be defined, and
                    # it should equal $nesting_depth-1.  To protect
                    # against unforeseen error conditions, however, we
                    # will check this and fix things if necessary.  For
                    # a test case see issue c055.
                    my $opening_depth = $rdepth_of_opening_seqno->[$seqno];
                    if ( !defined($opening_depth) ) {
                        $opening_depth = $nesting_depth - 1;
                        $opening_depth = 0 if ( $opening_depth < 0 );
                        $rdepth_of_opening_seqno->[$seqno] = $opening_depth;

                        # This is not fatal but should not happen.  The
                        # tokenizer generates sequence numbers
                        # incrementally upon encountering each new
                        # opening token, so every positive sequence
                        # number should correspond to an opening token.
                        my $lno = $line_index + 1;
                        DEVEL_MODE && Fault(<<EOM);
$lno: No opening token seen for closing token = '$token' at seq=$seqno at depth=$opening_depth
EOM
                    }
                    $self->[_K_closing_container_]->{$seqno} = @{$rLL};
                    $nesting_depth                           = $opening_depth;
                    $sign                                    = -1;
                }
                elsif ( $token eq '?' ) {
                    if ($added_seqno_count) {
                        $seqno += $added_seqno_count;
                        $new_seqno_from_old_seqno{$seqno_old} = $seqno;
                    }
                    if ( DEVEL_MODE && $seqno != $last_new_seqno + 1 ) {
                        my $lno = $line_index + 1;
                        Fault("$lno: seqno=$seqno last=$last_new_seqno\n");
                    }
                    $last_new_seqno = $seqno;
                    $self->[_K_opening_ternary_]->{$seqno} = @{$rLL};
                }
                elsif ( $token eq ':' ) {
                    if ($added_seqno_count) {
                        $seqno =
                          $new_seqno_from_old_seqno{$seqno_old} || $seqno_old;
                    }
                    $sign = -1;
                    $self->[_K_closing_ternary_]->{$seqno} = @{$rLL};
                }

                # The only sequenced types output by the tokenizer are
                # the opening & closing containers and the ternary
                # types. So we would only get here if the tokenizer has
                # been changed to mark some other tokens with sequence
                # numbers, or if an error has been introduced in a
                # hash such as %is_opening_container
                else {
                    my $lno = $line_index + 1;
                    DEVEL_MODE && Fault(<<EOM);
$lno: Unexpected sequenced token '$token' of type '$rtoken_type->[$j]', sequence=$seqno arrived from tokenizer.
Expecting only opening or closing container tokens or ternary tokens with sequence numbers.
EOM
                }

                if ( $sign > 0 ) {
                    $self->[_rI_opening_]->[$seqno] = @{$rSS};

                    # For efficiency, we find the maximum level of
                    # opening tokens of any type.  The actual maximum
                    # level will be that of their contents which is 1
                    # greater.  That will be fixed in sub
                    # 'finish_formatting'.
                    my $level = $rlevels->[$j];
                    if ( $level > $self->[_maximum_level_] ) {
                        $self->[_maximum_level_]         = $level;
                        $self->[_maximum_level_at_line_] = $line_index + 1;
                    }
                }
                else { $self->[_rI_closing_]->[$seqno] = @{$rSS} }
                push @{$rSS}, $sign * $seqno;
                $tokary[_TYPE_SEQUENCE_] = $seqno;
            }
            else {
                $tokary[_TYPE_SEQUENCE_] = EMPTY_STRING;
            }

            # Here we are storing the first five variables per token. The
            # remaining token variables will be added later as follows:
            #  _TOKEN_LENGTH_      is added by sub store_token
            #  _CUMULATIVE_LENGTH_ is added by sub store_token
            #  _CI_LEVEL_          is added by sub set_ci
            # So all token variables are available for use after sub set_ci.

            $tokary[_TOKEN_]      = $token;
            $tokary[_TYPE_]       = $rtoken_type->[$j];
            $tokary[_LEVEL_]      = $rlevels->[$j];
            $tokary[_LINE_INDEX_] = $line_index;

            push @{$rLL}, \@tokary;

            # handle -qwaf option for converting a qw quote (type = 'q') to
            # function call
            if (
                   $rOpts_qw_as_function
                && $rtoken_type->[$j] eq 'q'
                && (

                    # continuing in a qw?
                    $in_qw_seqno

                    # starting a new qw?
                    || ( ( $j > 0 || !$last_ending_in_quote )
                        && substr( $token, 0, 3 ) eq 'qw(' )
                )
              )
            {
                $self->qw_to_function( $line_of_tokens, $j == $jmax );
            }

        } ## end token loop

        # Need to remember if we can trim the input line
        $line_of_tokens->{_ended_in_blank_token} = $rtoken_type->[$jmax] eq 'b';

        # Values needed by Logger if a logfile is saved:
        if ( $self->[_save_logfile_] ) {
            $line_of_tokens->{_level_0}    = $rlevels->[0];
            $line_of_tokens->{_ci_level_0} = 0;               # fix later
            $line_of_tokens->{_nesting_blocks_0} =
              $line_of_tokens_old->{_nesting_blocks_0};
            $line_of_tokens->{_nesting_tokens_0} =
              $line_of_tokens_old->{_nesting_tokens_0};
        }

        return;

    } ## end sub write_line_inner_loop

} ## end closure write_line

#############################################
# CODE SECTION 5: Pre-process the entire file
#############################################

sub finish_formatting {

    my ( $self, $severe_error ) = @_;

    # The file has been tokenized and is ready to be formatted.
    # All of the relevant data is stored in $self, ready to go.

    # Given:
    #   $severe_error = true if a severe error was encountered

    # Returns:
    #   true if input file was copied verbatim due to errors
    #   false otherwise

    # Some of the code in sub break_lists is not robust enough to process code
    # with arbitrary brace errors. The simplest fix is to just return the file
    # verbatim if there are brace errors.  This fixes issue c160.
    $severe_error ||= get_saw_brace_error();

    # Check the maximum level. If it is extremely large we will give up and
    # output the file verbatim.  Note that the actual maximum level is 1
    # greater than the saved value, so we fix that here.
    $self->[_maximum_level_] += 1;
    my $maximum_level       = $self->[_maximum_level_];
    my $maximum_table_index = $#maximum_line_length_at_level;
    if ( !$severe_error && $maximum_level >= $maximum_table_index ) {
        $severe_error ||= 1;
        Warn(<<EOM);
The maximum indentation level, $maximum_level, exceeds the builtin limit of $maximum_table_index.
Something may be wrong; formatting will be skipped.
EOM
    }

    #----------------------------------------------------------------
    # Output file verbatim if severe error or no formatting requested
    #----------------------------------------------------------------
    if ( $severe_error || $rOpts->{notidy} ) {
        $self->dump_verbatim();
        $self->wrapup($severe_error);
        return 1;
    }

    {
        my $rix_side_comments = $self->set_CODE_type();

        $self->find_non_indenting_braces($rix_side_comments);

        # Handle any requested side comment deletions. It is easier to get
        # this done here rather than farther down the pipeline because IO
        # lines take a different route, and because lines with deleted HSC
        # become BL lines.  We have already handled any tee requests in sub
        # getline, so it is safe to delete side comments now.
        $self->delete_side_comments($rix_side_comments)
          if ( $rOpts_delete_side_comments
            || $rOpts_delete_closing_side_comments );
    }

    # Verify that the line hash does not have any unknown keys.
    $self->check_line_hashes() if (DEVEL_MODE);

    $self->interbracket_arrow_check();

    {
        # Make a pass through all tokens, adding or deleting any whitespace as
        # required.  Also make any other changes, such as adding semicolons.
        # All token changes must be made here so that the token data structure
        # remains fixed for the rest of this iteration.
        my ( $error, $rqw_lines ) = $self->respace_tokens();
        if ($error) {
            $self->dump_verbatim();
            $self->wrapup();
            return 1;
        }

        # sub 'set_ci' is called after sub respace to allow use of type counts
        # Token variable _CI_LEVEL_ is only defined after this call
        $self->set_ci();

        $self->find_multiline_qw($rqw_lines);
    }

    # Dump unique hash keys
    if ( $rOpts->{'dump-unique-keys'} ) {
        $self->dump_unique_keys();
        Exit(0);
    }

    # Dump any requested block summary data
    if ( $rOpts->{'dump-block-summary'} ) {
        $self->dump_block_summary();
        Exit(0);
    }

    # Dump variable usage info if requested
    if ( $rOpts->{'dump-unusual-variables'} ) {
        $self->dump_unusual_variables();
        Exit(0);
    }

    # Act on -warn-variable-types if requested and the logger is available
    # (the logger is deactivated during iterations)
    $self->warn_variable_types()
      if ( %{$rwarn_variable_types}
        && $self->[_logger_object_] );

    if (   $rOpts->{'warn-mismatched-args'}
        || $rOpts->{'warn-mismatched-returns'} )
    {
        $self->warn_mismatched()
          if ( $self->[_logger_object_] );
    }

    if ( $rOpts->{'dump-mismatched-args'} ) {
        $self->dump_mismatched_args();
        Exit(0);
    }

    if ( $rOpts->{'dump-mismatched-returns'} ) {
        $self->dump_mismatched_returns();
        Exit(0);
    }

    if ( $rOpts->{'dump-mixed-call-parens'} ) {
        $self->dump_mixed_call_parens();
        Exit(0);
    }

    # Act on -want-call-parens and --nowant-call-parens requested and the
    # logger is available (the logger is deactivated during iterations)
    $self->scan_call_parens()
      if ( %call_paren_style
        && $self->[_logger_object_] );

    $self->examine_vertical_tightness_flags();

    $self->set_excluded_lp_containers();

    $self->keep_old_line_breaks();

    # Implement any welding needed for the -wn or -cb options
    $self->weld_containers();

    # Collect info needed to implement the -xlp style
    $self->xlp_collapsed_lengths()
      if ( $rOpts_line_up_parentheses && $rOpts_extended_line_up_parentheses );

    # Locate small nested blocks which should not be broken
    $self->mark_short_nested_blocks();

    $self->special_indentation_adjustments();

    # Verify that the main token array looks OK.  If this ever causes a fault
    # then place similar checks before the sub calls above to localize the
    # problem.
    $self->check_rLL("Before 'process_all_lines'") if (DEVEL_MODE);

    # Finishes formatting and write the result to the line sink.
    # Eventually this call should just change the 'rlines' data according to the
    # new line breaks and then return so that we can do an internal iteration
    # before continuing with the next stages of formatting.
    $self->process_all_lines();

    # A final routine to tie up any loose ends
    $self->wrapup();
    return;
} ## end sub finish_formatting

my %is_loop_type;

BEGIN {
    my @q = qw( for foreach while do until );
    @is_loop_type{@q} = (1) x scalar(@q);
}

sub find_level_info {

    my ($self) = @_;

    # Find level ranges and total variations of all code blocks in this file.

    # Returns:
    #   ref to hash with block info, with seqno as key (see below)

    # The array _rSS_ has the complete container tree for this file.
    my $rSS = $self->[_rSS_];

    # We will be ignoring everything except code block containers
    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];

    my @stack;
    my %level_info;

    # TREE_LOOP:
    foreach my $sseq ( @{$rSS} ) {
        my $stack_depth = @stack;
        my $seq_next    = $sseq > 0 ? $sseq : -$sseq;

        next if ( !$rblock_type_of_seqno->{$seq_next} );
        if ( $sseq > 0 ) {

            # STACK_LOOP:
            my $item;
            foreach my $seq (@stack) {
                $item = $level_info{$seq};
                if ( $item->{maximum_depth} < $stack_depth ) {
                    $item->{maximum_depth} = $stack_depth;
                }
                $item->{block_count}++;
            } ## end STACK LOOP

            push @stack, $seq_next;
            my $block_type = $rblock_type_of_seqno->{$seq_next};

            # If this block is a loop nested within a loop, then we
            # will mark it as an 'inner_loop'. This is a useful
            # complexity measure.
            my $is_inner_loop = 0;
            if ( $is_loop_type{$block_type} && defined($item) ) {
                $is_inner_loop = $is_loop_type{ $item->{block_type} };
            }

            $level_info{$seq_next} = {
                starting_depth => $stack_depth,
                maximum_depth  => $stack_depth,
                block_count    => 1,
                block_type     => $block_type,
                is_inner_loop  => $is_inner_loop,
            };
        }
        else {
            my $seq_test = pop @stack;

            # error check
            if ( $seq_test != $seq_next ) {

                # Shouldn't happen - the $rSS array must have an error
                DEVEL_MODE && Fault("stack error finding total depths\n");

                %level_info = ();
                last;
            }
        }
    } ## end TREE_LOOP

    return \%level_info;
} ## end sub find_level_info

sub find_loop_label {

    my ( $self, $seqno ) = @_;

    # Given:
    #   $seqno = sequence number of a block of code for a loop
    # Return:
    #   $label = the loop label text, if any, or an empty string

    my $rLL                 = $self->[_rLL_];
    my $rlines              = $self->[_rlines_];
    my $K_opening_container = $self->[_K_opening_container_];

    my $label     = EMPTY_STRING;
    my $K_opening = $K_opening_container->{$seqno};

    # backup to the line with the opening paren, if any, in case the
    # keyword is on a different line
    my $Kp = $self->K_previous_code($K_opening);
    return $label unless ( defined($Kp) );
    if ( $rLL->[$Kp]->[_TOKEN_] eq ')' ) {
        $seqno     = $rLL->[$Kp]->[_TYPE_SEQUENCE_];
        $K_opening = $K_opening_container->{$seqno};
    }

    return $label unless ( defined($K_opening) );
    my $lx_open = $rLL->[$K_opening]->[_LINE_INDEX_];

    # look for a label within a few lines; allow a couple of blank lines
    foreach my $lx ( reverse( $lx_open - 3 .. $lx_open ) ) {
        last if ( $lx < 0 );
        my $line_of_tokens = $rlines->[$lx];
        my $line_type      = $line_of_tokens->{_line_type};

        # stop search on a non-code line
        last if ( $line_type ne 'CODE' );

        my $rK_range = $line_of_tokens->{_rK_range};
        my ( $Kfirst, $Klast_uu ) = @{$rK_range};

        # skip a blank line
        next if ( !defined($Kfirst) );

        # check for a label
        if ( $rLL->[$Kfirst]->[_TYPE_] eq 'J' ) {
            $label = $rLL->[$Kfirst]->[_TOKEN_];
            last;
        }

        # quit the search if we are above the starting line
        last if ( $lx < $lx_open );
    }

    return $label;
} ## end sub find_loop_label

{    ## closure find_mccabe_count
    my %is_mccabe_logic_keyword;
    my %is_mccabe_logic_operator;

    BEGIN {
        my @q = (qw( && || ||= &&= ? <<= >>= ));
        @is_mccabe_logic_operator{@q} = (1) x scalar(@q);

        @q = (qw( and or xor if else elsif unless until while for foreach ));
        @is_mccabe_logic_keyword{@q} = (1) x scalar(@q);
    } ## end BEGIN

    sub find_mccabe_count {
        my ($self) = @_;

        # Find the cumulative mccabe count to each token
        # Return '$rmccabe_count_sum' = ref to array with cumulative
        #   mccabe count to each token $K

        # NOTE: This sub currently follows the definitions in Perl::Critic

        my $rmccabe_count_sum;
        my $rLL    = $self->[_rLL_];
        my $count  = 0;
        my $Klimit = $self->[_Klimit_];
        foreach my $KK ( 0 .. $Klimit ) {
            $rmccabe_count_sum->{$KK} = $count;
            my $type = $rLL->[$KK]->[_TYPE_];
            if ( $type eq 'k' ) {
                my $token = $rLL->[$KK]->[_TOKEN_];
                if ( $is_mccabe_logic_keyword{$token} ) { $count++ }
            }
            else {
                if ( $is_mccabe_logic_operator{$type} ) {
                    $count++;
                }
            }
        }
        $rmccabe_count_sum->{ $Klimit + 1 } = $count;
        return $rmccabe_count_sum;
    } ## end sub find_mccabe_count
} ## end closure find_mccabe_count

sub find_code_line_count {
    my ($self) = @_;

    # Find the cumulative number of lines of code, excluding blanks,
    # comments and pod.
    # Return '$rcode_line_count' = ref to array with cumulative
    #   code line count for each input line number.

    my $rcode_line_count;
    my $rLL             = $self->[_rLL_];
    my $rlines          = $self->[_rlines_];
    my $ix_line         = -1;
    my $code_line_count = 0;

    # loop over all lines
    foreach my $line_of_tokens ( @{$rlines} ) {
        $ix_line++;

        # what type of line?
        my $line_type = $line_of_tokens->{_line_type};

        # if 'CODE' it must be non-blank and non-comment
        if ( $line_type eq 'CODE' ) {
            my $rK_range = $line_of_tokens->{_rK_range};
            my ( $Kfirst, $Klast ) = @{$rK_range};

            if ( defined($Kfirst) ) {

                # it is non-blank
                my $jmax = defined($Kfirst) ? $Klast - $Kfirst : -1;
                if ( $jmax > 0 || $rLL->[$Klast]->[_TYPE_] ne '#' ) {

                    # ok, it is a non-comment
                    $code_line_count++;
                }
            }
        }

        # Count all other special line types except pod;
        # For a list of line types see sub 'process_all_lines'
        else {
            if ( $line_type !~ /^POD/ ) { $code_line_count++ }
        }

        # Store the cumulative count using the input line index
        $rcode_line_count->[$ix_line] = $code_line_count;
    }
    return $rcode_line_count;
} ## end sub find_code_line_count

sub find_selected_packages {

    my ( $self, $rdump_block_types ) = @_;

    # Returns a list of all selected package statements in a file for use
    # in dumping block information.
    if (   !$rdump_block_types->{'*'}
        && !$rdump_block_types->{'package'}
        && !$rdump_block_types->{'class'} )
    {
        return [];
    }

    # Find all 'package' tokens in the file
    my $rLL = $self->[_rLL_];
    my @K_package_list;
    foreach my $KK ( 0 .. @{$rLL} - 1 ) {
        next if ( $rLL->[$KK]->[_TYPE_] ne 'P' );
        push @K_package_list, $KK;
    }

    # Get the information needed for the block dump
    my $rpackage_lists     = $self->package_info_maker( \@K_package_list );
    my $rpackage_info_list = $rpackage_lists->{'rpackage_info_list'};

    # Remove the first item in the info list, which is a dummy package main
    shift @{$rpackage_info_list};

    # Remove BLOCK format packages since they get reported as blocks separately
    my @filtered_list = grep { !$_->{is_block} } @{$rpackage_info_list};

    return \@filtered_list;
} ## end sub find_selected_packages

sub find_selected_blocks {

    my ( $self, $rdump_block_types, $rlevel_info ) = @_;

    # Find blocks needed for --dump-block-summary
    # Given:
    #   $rdump_block_types = hash of user selected block types
    #   $rlevel_info = info on max depth of blocks
    # Returns:
    #  $rslected_blocks = ref to a list of information on the selected blocks

    my $rLL                  = $self->[_rLL_];
    my $rlines               = $self->[_rlines_];
    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];
    my $K_opening_container  = $self->[_K_opening_container_];
    my $K_closing_container  = $self->[_K_closing_container_];
    my $ris_asub_block       = $self->[_ris_asub_block_];
    my $ris_sub_block        = $self->[_ris_sub_block_];

    my $dump_all_types = $rdump_block_types->{'*'};

    my @selected_blocks;

    #---------------------------------------------------
    # BEGIN loop over all blocks to find selected blocks
    #---------------------------------------------------
    foreach my $seqno ( keys %{$rblock_type_of_seqno} ) {

        my $type;
        my $name       = EMPTY_STRING;
        my $block_type = $rblock_type_of_seqno->{$seqno};
        my $K_opening  = $K_opening_container->{$seqno};
        my $K_closing  = $K_closing_container->{$seqno};
        my $level      = $rLL->[$K_opening]->[_LEVEL_];

        my $lx_open        = $rLL->[$K_opening]->[_LINE_INDEX_];
        my $line_of_tokens = $rlines->[$lx_open];
        my $rK_range       = $line_of_tokens->{_rK_range};
        my ( $Kfirst, $Klast ) = @{$rK_range};
        if ( !defined($Kfirst) || !defined($Klast) || $Kfirst > $K_opening ) {
            my $line_type = $line_of_tokens->{_line_type};

            # shouldn't happen
            my $CODE_type = $line_of_tokens->{_code_type};
            DEVEL_MODE && Fault(<<EOM);
unexpected line_type=$line_type at line $lx_open, code type=$CODE_type
EOM
            next;
        }

        my ( $max_change, $block_count, $inner_loop_plus ) =
          ( 0, 0, EMPTY_STRING );
        my $item = $rlevel_info->{$seqno};
        if ( defined($item) ) {
            my $starting_depth = $item->{starting_depth};
            my $maximum_depth  = $item->{maximum_depth};
            $block_count = $item->{block_count};
            $max_change  = $maximum_depth - $starting_depth + 1;

            # this is a '+' character if this block is an inner loops
            $inner_loop_plus = $item->{is_inner_loop} ? '+' : EMPTY_STRING;
        }

        # Skip closures unless type 'closure' is explicitly requested
        if ( ( $block_type eq '}' || $block_type eq ';' )
            && $rdump_block_types->{'closure'} )
        {
            $type = 'closure';
        }

        # Both 'sub' and 'asub' select an anonymous sub.
        # This allows anonymous subs to be explicitly selected
        elsif (
            $ris_asub_block->{$seqno}
            && (   $dump_all_types
                || $rdump_block_types->{'sub'}
                || $rdump_block_types->{'asub'} )
          )
        {
            $type = 'asub';

            # Look back to try to find some kind of name, such as
            #   my $var = sub {        - var is type 'i'
            #       var => sub {       - var is type 'w'
            #      -var => sub {       - var is type 'w'
            #     'var' => sub {       - var is type 'Q'
            my ( $saw_equals, $saw_fat_comma, $blank_count );
            foreach my $KK ( reverse( $Kfirst .. $K_opening - 1 ) ) {
                my $token_type = $rLL->[$KK]->[_TYPE_];
                if ( $token_type eq 'b' )  { $blank_count++;   next }
                if ( $token_type eq '=>' ) { $saw_fat_comma++; next }
                if ( $token_type eq '=' )  { $saw_equals++;    next }
                if ( $token_type eq 'i' && $saw_equals
                    || ( $token_type eq 'w' || $token_type eq 'Q' )
                    && $saw_fat_comma )
                {
                    $name = $rLL->[$KK]->[_TOKEN_];
                    last;
                }
            }
            my $rarg = { seqno => $seqno };
            $self->count_sub_input_args($rarg);
            my $count = $rarg->{shift_count_min};
            if ( !defined($count) ) { $count = '*' }

            $type .= '(' . $count . ')';
        }
        elsif ( $ris_sub_block->{$seqno}
            && ( $dump_all_types || $rdump_block_types->{'sub'} ) )
        {
            $type = 'sub';

            # what we want:
            #      $block_type               $name
            # 'sub setidentifier($)'    => 'setidentifier'
            # 'method setidentifier($)' => 'setidentifier'
            my @parts = split /\s+/, $block_type;
            $name = $parts[1];
            $name =~ s/\(.*$//;

            my $rarg = { seqno => $seqno };
            $self->count_sub_input_args($rarg);
            my $count = $rarg->{shift_count_min};
            if ( !defined($count) ) { $count = '*' }

            $type .= '(' . $count . ')';
        }
        elsif (
            $block_type =~ /^(package|class)\b/
            && (   $dump_all_types
                || $rdump_block_types->{'package'}
                || $rdump_block_types->{'class'} )
          )
        {
            $type = 'class';
            my @parts = split /\s+/, $block_type;
            $name = $parts[1];
            $name =~ s/\(.*$//;
        }
        elsif (
            $is_loop_type{$block_type}
            && (   $dump_all_types
                || $rdump_block_types->{$block_type}
                || $rdump_block_types->{ $block_type . $inner_loop_plus }
                || $rdump_block_types->{$inner_loop_plus} )
          )
        {
            $type = $block_type . $inner_loop_plus;
        }
        elsif ( $dump_all_types || $rdump_block_types->{$block_type} ) {
            if ( $is_loop_type{$block_type} ) {
                $name = $self->find_loop_label($seqno);
            }
            $type = $block_type;
        }
        else {
            next;
        }

        push @selected_blocks,
          {
            K_opening   => $K_opening,
            K_closing   => $K_closing,
            line_start  => $lx_open + 1,
            name        => $name,
            type        => $type,
            level       => $level,
            max_change  => $max_change,
            block_count => $block_count,
          };
    }    ## END loop to get info for selected blocks
    return \@selected_blocks;
} ## end sub find_selected_blocks

sub find_if_chains {

    my ( $self, $rdump_block_types, $rlevel_info ) = @_;

    # Find if-chains for --dump-block-summary

    # Given:
    #   $rdump_block_types = ref to hash with user block type selections
    #   $rlevel_info = info on max depth of blocks
    # Returns:
    #  $rslected_blocks = ref to a list of information on the selected blocks

    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];

    # For example, 'elsif4' means all if-chains with 4 or more 'elsif's
    my @selected_blocks;

    # See if user requested any if-chains
    # allow 'elsif3' or 'elsif+3'
    my @elsif_d = grep { /^elsif\+?\d+$/ } keys %{$rdump_block_types};
    if ( !@elsif_d ) { return \@selected_blocks }

    # In case of multiple selections, use the minimum
    my $elsif_count_min;
    foreach my $word (@elsif_d) {
        if ( $word =~ /(\d+)$/ ) {
            my $num = $1;
            if ( !defined($elsif_count_min) || $elsif_count_min > $num ) {
                $elsif_count_min = $num;
            }
        }
    }

    # Loop over blocks
    foreach my $seqno ( keys %{$rblock_type_of_seqno} ) {

        my $block_type = $rblock_type_of_seqno->{$seqno};

        # Must be 'if' or 'unless'
        next unless ( $block_type eq 'if' || $block_type eq 'unless' );

        # Collect info for this if-chain
        my $rif_chain =
          $self->follow_if_chain( $seqno, $rlevel_info, $elsif_count_min );
        next unless ($rif_chain);

        push @selected_blocks, $rif_chain;
    }
    return \@selected_blocks;
} ## end sub find_if_chains

sub follow_if_chain {
    my ( $self, $seqno_if, $rlevel_info, $elsif_count_min ) = @_;

    # Follow a chain of if-elsif-elsif-...-else blocks.

    # Given:
    #   $seqno_if = sequence number of an 'if' block
    #   $rlevel_info = hash of block level information
    #   $elsif_min_count = minimum number of 'elsif' blocks wanted
    # Return:
    #   nothing if number of 'elsif' blocks is less than $elsif_count_min
    #   ref to block info hash otherwise

    my $rLL                  = $self->[_rLL_];
    my $K_opening_container  = $self->[_K_opening_container_];
    my $K_closing_container  = $self->[_K_closing_container_];
    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];

    # Verify that seqno is an 'if' or 'unless'
    my $block_type = $rblock_type_of_seqno->{$seqno_if};
    if ( $block_type ne 'if' && $block_type ne 'unless' ) {
        Fault(
"Bad call: expecting block type 'if' or 'unless' but got '$block_type' for seqno=$seqno_if\n"
        );
        return;
    }

    # save sequence numbers in the chain for debugging
    my @seqno_list;

    # Loop to follow the chain
    my $max_change  = 0;
    my $block_count = 0;
    my $elsif_count = 0;

    # we are tracing the sequence numbers of consecutive if/elsif/else blocks
    my $seqno = $seqno_if;
    while ($seqno) {
        push @seqno_list, $seqno;

        # Update info for this block
        $block_type = $rblock_type_of_seqno->{$seqno};
        if ( $block_type eq 'elsif' ) { $elsif_count++ }
        my $item = $rlevel_info->{$seqno};
        if ( defined($item) ) {
            my $starting_depth = $item->{starting_depth};
            my $maximum_depth  = $item->{maximum_depth};
            $block_count += $item->{block_count};
            my $mxc = $maximum_depth - $starting_depth + 1;
            if ( $mxc > $max_change ) { $max_change = $mxc }
        }

        # Chain ends if this is an 'else' block
        last if ( $block_type eq 'else' );

        # Look at the token following the closing brace
        my $Kc  = $K_closing_container->{$seqno};
        my $K_k = $self->K_next_code($Kc);
        last unless defined($K_k);
        my $type_k  = $rLL->[$K_k]->[_TYPE_];
        my $token_k = $rLL->[$K_k]->[_TOKEN_];

        # Chain ends unless we arrive at keyword 'elsif' or 'else'
        last
          unless ( $type_k eq 'k'
            && ( $token_k eq 'elsif' || $token_k eq 'else' ) );

        # Handle keyword 'else' : next token be the opening block brace
        if ( $token_k eq 'else' ) {

            #     } else  {
            #     ^  ^    ^
            #     Kc |    |
            #        K_k Ko

            my $Ko = $self->K_next_code($K_k);
            last unless defined($Ko);
            $seqno = $rLL->[$Ko]->[_TYPE_SEQUENCE_];
            if ( $seqno && $rblock_type_of_seqno->{$seqno} eq 'else' ) {
                next;
            }

            # Shouldn't happen unless file has an error
            last;
        }

        # Handle keyword 'elsif':

        #     } elsif ( $something ) {
        #     ^  ^    ^            ^ ^
        #     Kc |    |            | |
        #        K_k  Kpo        Kpc Ko

        # hop over the elsif parens
        my $kpo = $self->K_next_code($K_k);
        last unless defined($kpo);
        my $seqno_p = $rLL->[$kpo]->[_TYPE_SEQUENCE_];
        last unless ( $seqno_p && $rLL->[$kpo]->[_TOKEN_] eq '(' );
        my $Kpc = $K_closing_container->{$seqno_p};
        last unless defined($Kpc);

        # should be at the opening elsif brace
        my $Ko = $self->K_next_code($Kpc);
        last unless defined($Ko);
        $seqno = $rLL->[$Ko]->[_TYPE_SEQUENCE_];
        if ( $seqno && $rblock_type_of_seqno->{$seqno} eq 'elsif' ) {
            next;
        }

        # Shouldn't happen unless file has an error
        last;
    } ## end while ($seqno)

    # check count
    return if ( $elsif_count < $elsif_count_min );

    # Store the chain
    my $K_opening = $K_opening_container->{$seqno_if};
    my $K_closing = $K_closing_container->{$seqno};
    my $lx_open   = $rLL->[$K_opening]->[_LINE_INDEX_];
    my $level     = $rLL->[$K_opening]->[_LEVEL_];

    my $rchain = {
        K_opening   => $K_opening,
        K_closing   => $K_closing,
        line_start  => $lx_open + 1,
        name        => "elsif+$elsif_count",
        type        => "if-chain",
        level       => $level,
        max_change  => $max_change,
        block_count => $block_count,
    };

    return $rchain;
} ## end sub follow_if_chain

sub dump_unique_keys {
    my ($self) = @_;

    # Implement --dump-unique-keys, -duk
    # Dump a list of hash keys used just one time

    my $rLL                 = $self->[_rLL_];
    my $Klimit              = $self->[_Klimit_];
    my $ris_list_by_seqno   = $self->[_ris_list_by_seqno_];
    my $K_opening_container = $self->[_K_opening_container_];
    my $K_closing_container = $self->[_K_closing_container_];

    # stack holds [$seqno, $KK, $KK_last_nb]
    my @stack;

    my $KK = -1;
    my $KK_last_nb;
    my $KK_this_nb = 0;

    my $K_end_skip = -1;

    #----------------------------------------------
    # Main loop to examine all hash keys and quotes
    #----------------------------------------------
    my @Q_list;
    my @K_start_qw_list;
    my $rwords = {};

    # Table of some known keys
    my %is_known_key = (
        ALRM     => { '$SIG' => 1 },
        TERM     => { '$SIG' => 1 },
        INT      => { '$SIG' => 1 },
        __DIE__  => { '$SIG' => 1 },
        __WARN__ => { '$SIG' => 1 },
        HOME     => { '$ENV' => 1 },
        USER     => { '$ENV' => 1 },
        LOGNAME  => { '$ENV' => 1 },
        PATH     => { '$ENV' => 1 },
        SHELL    => { '$ENV' => 1 },
        PERL5LIB => { '$ENV' => 1 },
        PERLLIB  => { '$ENV' => 1 },
    );

    my $add_known_keys = sub {
        my ( $rhash, $name ) = @_;
        foreach my $key ( keys %{$rhash} ) {
            if ( !defined( $is_known_key{$key} ) ) {
                $is_known_key{$key} = { $name => 1 };
            }
            else {
                $is_known_key{$key}->{$name} = 1;
            }
        }
    }; ## end $add_known_keys = sub

    # Add keys which may be unique to this environment.
    $add_known_keys->( \%SIG,   '$SIG' );
    $add_known_keys->( \%ENV,   '$ENV' );
    $add_known_keys->( \%ERRNO, '$!' );

    my $is_known_hash = sub {
        my ($key) = @_;

        # Given a hash key '$key',
        # Return:
        #   true if it is known and should be excluded
        #   false if it is not known

        my $rhash_names = $is_known_key{$key};
        return if ( !$rhash_names );

        # The key is known, now see if its hash name is known
        return if ( !@stack );
        my $Kbrace = $stack[-1]->[1];
        my $Khash  = $stack[-1]->[2];
        return if ( !defined($Kbrace) );
        return if ( !defined($Khash) );
        return if ( $rLL->[$Kbrace]->[_TYPE_] ne 'L' );
        my $hash_name = $rLL->[$Khash]->[_TOKEN_];
        return if ( !$rhash_names->{$hash_name} );
        return 1;
    }; ## end $is_known_hash = sub

    my $push_KK_last_nb = sub {

        # if the previous nonblank token was a hash key of type
        # 'Q' or 'w', then update its count

        # We are ignoring constant definitions
        if ( $KK < $K_end_skip ) { return }

        my $type_last  = $rLL->[$KK_last_nb]->[_TYPE_];
        my $token_last = $rLL->[$KK_last_nb]->[_TOKEN_];
        my $word;
        if ( $type_last eq 'w' ) {
            $word = $token_last;
        }
        elsif ( $type_last eq 'Q' ) {
            $word = substr( $token_last, 1, -1 );

            # Ignore text with interpolated values
            my $ch0 = substr( $token_last, 0, 1 );
            if ( $ch0 eq '"' ) {
                foreach my $sigil ( '$', '@' ) {
                    my $pos = index( $word, $sigil );
                    next   if ( $pos < 0 );
                    return if ( $pos == 0 );
                    my $ch_test = substr( $word, $pos - 1, 1 );
                    return if ( $ch_test ne '\\' );
                }
            }

            pop @Q_list;
        }
        else {
            # not a quote - possibly identifier
            return;
        }
        return unless ($word);

        # Bump count of known keys by 1 so that they will not appear as unique
        my $one = 1;
        if ( $is_known_key{$word} && $is_known_hash->($word) ) { $one++ }

        if ( !defined( $rwords->{$word} ) ) {
            $rwords->{$word} = [ $one, $KK_last_nb ];
        }
        else {
            $rwords->{$word}->[0]++;
        }
        return;
    }; ## end $push_KK_last_nb = sub

    #--------------------------
    # Main loop over all tokens
    #--------------------------
    while ( ++$KK <= $Klimit ) {

        my $type = $rLL->[$KK]->[_TYPE_];
        next if ( $type eq 'b' );
        next if ( $type eq '#' );
        $KK_last_nb = $KK_this_nb;
        $KK_this_nb = $KK;
        my $seqno = $rLL->[$KK]->[_TYPE_SEQUENCE_];
        if ($seqno) {
            if ( $is_opening_type{$type} ) {

                if ( $type eq 'L' ) {

                    # Skip past something like ${word}
                    if ( $KK_last_nb && $rLL->[$KK_last_nb]->[_TYPE_] eq 't' ) {
                        my $Kc = $K_closing_container->{$seqno};
                        my $Kn = $self->K_next_code($KK);
                        $Kn = $self->K_next_code($Kn);
                        if ( $Kn && $Kc && $Kn == $Kc && $Kc > $K_end_skip ) {
                            $K_end_skip = $Kc;
                        }
                    }
                }
                push @stack, [ $seqno, $KK, $KK_last_nb ];
            }
            elsif ( $is_closing_type{$type} ) {

                if ( $type eq 'R' ) {

                    # require a single item within the hash braces
                    my $Ko = $K_opening_container->{$seqno};
                    my $Kn = $self->K_next_code($Ko);
                    if ( defined($Kn) && $Kn == $KK_last_nb ) {
                        $push_KK_last_nb->();
                    }
                }

                my $item = pop @stack;
                if ( !$item || $item->[0] != $seqno ) {
                    if (DEVEL_MODE) {

                        # shouldn't happen for a balanced file
                        my $num = @stack;
                        my $got = $num ? $item->[0] : 'undef';
                        my $lno = $rLL->[$KK]->[_LINE_INDEX_];
                        Fault <<EOM;
stack error at seqno=$seqno type=$type num=$num got seqno=$got lno=$lno
EOM
                    }
                }
            }
            else {
                ## ternary
            }
        }
        else {
            if ( $type eq '=>' ) {
                my $parent_seqno = $self->parent_seqno_by_K($KK);
                if ( $parent_seqno && $ris_list_by_seqno->{$parent_seqno} ) {
                    $push_KK_last_nb->();
                }
            }
            elsif ( $type eq 'Q' ) {
                push @Q_list, $KK;
            }
            elsif ( $type eq 'q' ) {
                if ( !defined($KK_last_nb)
                    || $rLL->[$KK_last_nb]->[_TYPE_] ne 'q' )
                {
                    push @K_start_qw_list, $KK;
                }
            }
            elsif ( $type eq 'k' ) {

                # Look for 'use constant' and define its ending token
                if ( $rLL->[$KK]->[_TOKEN_] eq 'use' ) {
                    my $Kn = $self->K_next_code($KK);
                    next if ( !defined($Kn) );
                    next if ( $rLL->[$Kn]->[_TOKEN_] ne 'constant' );
                    $Kn = $self->K_next_code($Kn);
                    next if ( !defined($Kn) );
                    my $seqno_n = $rLL->[$Kn]->[_TYPE_SEQUENCE_];
                    if ($seqno_n) {

                        # skip a block of constant definitions
                        my $token_n = $rLL->[$Kn]->[_TOKEN_];
                        if ( $token_n eq '{' ) {
                            $K_end_skip = $K_closing_container->{$seqno_n};
                        }
                        else {
                            ## unexpected format, skip
                        }
                    }
                    else {

                        # skip a single constant definition
                        $K_end_skip = $Kn + 1;
                    }
                }
            }
            else {
                # continue search
            }
        }
    } ## end while ( ++$KK <= $Klimit )

    # find hash keys seen just one time
    my %unique_words;
    foreach my $key ( keys %{$rwords} ) {
        my ( $count, $K ) = @{ $rwords->{$key} };
        next if ( $count != 1 );
        $unique_words{$key} = $K;
    }

    return if ( !%unique_words );

    # check each unique word against the list of type Q tokens
    if (@Q_list) {
        my $imax = $#Q_list;
        foreach my $i ( 0 .. $imax ) {

            # Ignore multiline quotes
            my $K = $Q_list[$i];
            if (   ( $i == 0 || $Q_list[ $i - 1 ] + 1 != $K )
                && ( $i == $imax || $Q_list[ $i + 1 ] != $K + 1 ) )
            {

                # remove quotes
                my $word = substr( $rLL->[$K]->[_TOKEN_], 1, -1 );

                if ( $unique_words{$word} ) {
                    delete $unique_words{$word};
                }
            }
        }
    }

    return if ( !%unique_words );

    # Remove any keys which are also in a qw list
    foreach my $Kqw (@K_start_qw_list) {
        my ( $K_last_q_uu, $rlist ) = $self->get_qw_list($Kqw);
        foreach my $word ( @{$rlist} ) {
            if ( $unique_words{$word} ) {
                delete $unique_words{$word};
            }
        }
    }

    return if ( !%unique_words );

    # report unique words
    my $output_string = EMPTY_STRING;
    my @list;
    foreach my $word ( keys %unique_words ) {
        my $K   = $unique_words{$word};
        my $lno = $rLL->[$K]->[_LINE_INDEX_] + 1;
        push @list, [ $word, $lno ];
    }
    @list = sort { $a->[1] <=> $b->[1] || $a->[0] cmp $b->[0] } @list;
    foreach my $item (@list) {
        my ( $word, $lno ) = @{$item};
        $output_string .= "$word,$lno\n";
    }
    if ($output_string) {
        my $input_stream_name = get_input_stream_name();
        chomp $output_string;
        print {*STDOUT} <<EOM;
==> $input_stream_name <==
$output_string
EOM
    }

    return;

} ## end sub dump_unique_keys

sub dump_block_summary {
    my ($self) = @_;

    # Dump information about selected code blocks to STDOUT
    # This sub is called when
    #   --dump-block-summary (-dbs) is set.

    # The following controls are available:
    #  --dump-block-types=s (-dbt=s), where s is a list of block types
    #    (if else elsif for foreach while do ... sub) ; default is 'sub'
    #  --dump-block-minimum-lines=n (-dbml=n), where n is the minimum
    #    number of lines for a block to be included; default is 20.

    my $rOpts_dump_block_types = $rOpts->{'dump-block-types'};
    if ( !defined($rOpts_dump_block_types) ) { $rOpts_dump_block_types = 'sub' }
    $rOpts_dump_block_types =~ s/^\s+//;
    $rOpts_dump_block_types =~ s/\s+$//;
    my @list = split /\s+/, $rOpts_dump_block_types;
    my %dump_block_types;
    @dump_block_types{@list} = (1) x scalar(@list);

    # Get level variation info for code blocks
    my $rlevel_info = $self->find_level_info();

    # Get block info
    my $rselected_blocks =
      $self->find_selected_blocks( \%dump_block_types, $rlevel_info );

    # Get if-chains
    my $rselected_if_chains =
      $self->find_if_chains( \%dump_block_types, $rlevel_info );

    # Get package info
    my $rpackages = $self->find_selected_packages( \%dump_block_types );

    # merge
    my @all_blocks =
      ( @{$rselected_blocks}, @{$rselected_if_chains}, @{$rpackages} );

    return unless (@all_blocks);

    my $input_stream_name = get_input_stream_name();

    # Get code line count
    my $rcode_line_count = $self->find_code_line_count();

    # Get mccabe count
    my $rmccabe_count_sum = $self->find_mccabe_count();

    my $rOpts_dump_block_minimum_lines = $rOpts->{'dump-block-minimum-lines'};
    if ( !defined($rOpts_dump_block_minimum_lines) ) {
        $rOpts_dump_block_minimum_lines = 20;
    }

    my $rLL = $self->[_rLL_];

    # add various counts, filter and print to STDOUT
    my $routput_lines = [];
    foreach my $item (@all_blocks) {

        my $K_opening = $item->{K_opening};
        my $K_closing = $item->{K_closing};

        # define total number of lines
        my $lx_open    = $rLL->[$K_opening]->[_LINE_INDEX_];
        my $lx_close   = $rLL->[$K_closing]->[_LINE_INDEX_];
        my $line_count = $lx_close - $lx_open + 1;

        # define total number of lines of code excluding blanks, comments, pod
        my $code_lines_open  = $rcode_line_count->[$lx_open];
        my $code_lines_close = $rcode_line_count->[$lx_close];
        my $code_lines       = 0;
        if ( defined($code_lines_open) && defined($code_lines_close) ) {
            $code_lines = $code_lines_close - $code_lines_open + 1;
        }

        # filter out blocks below the selected code line limit
        if ( $code_lines < $rOpts_dump_block_minimum_lines ) {
            next;
        }

        # add mccabe_count for this block
        my $mccabe_closing = $rmccabe_count_sum->{ $K_closing + 1 };
        my $mccabe_opening = $rmccabe_count_sum->{$K_opening};
        my $mccabe_count   = 1;    # add 1 to match Perl::Critic
        if ( defined($mccabe_opening) && defined($mccabe_closing) ) {
            $mccabe_count += $mccabe_closing - $mccabe_opening;
        }

        # Store the final set of print variables
        # Note: K_opening is added for sorting but deleted before printing
        push @{$routput_lines}, [

            $input_stream_name,
            $item->{line_start},
            $line_count,
            $code_lines,
            $item->{type},
            $item->{name},
            $item->{level},
            $item->{max_change},
            $item->{block_count},
            $mccabe_count,
            $K_opening,

        ];
    }

    return unless @{$routput_lines};

    # Sort blocks and packages on starting line number
    my @sorted_lines = sort { $a->[-1] <=> $b->[-1] } @{$routput_lines};

    print {*STDOUT}
"file,line,line_count,code_lines,type,name,level,max_change,block_count,mccabe_count\n";

    foreach my $rline_vars (@sorted_lines) {

        # remove K_opening which was added for stable sorting
        pop @{$rline_vars};
        my $line = join( ",", @{$rline_vars} ) . "\n";
        print {*STDOUT} $line;
    }
    return;
} ## end sub dump_block_summary

sub set_ci {

    my ($self) = @_;

    # Set the basic continuation indentation (ci) for all tokens.
    # This is a replacement for the values previously computed in
    # sub Perl::Tidy::Tokenizer::tokenizer_wrapup. In most cases it
    # produces identical results, but in a few cases it is an improvement.

    use constant DEBUG_SET_CI => 0;

    # This turns on an optional piece of logic which makes the new and
    # old computations of ci agree.  It has almost no effect on actual
    # programs but is useful for testing.
    use constant SET_CI_OPTION_0 => 1;

    # This is slightly different from the hash in in break_lists
    # with a similar name (removed '?' and ':' to fix t007 and others)
    my %is_logical_container_for_ci;
    my @q = qw# if elsif unless while and or err not && | || ! #;
    @is_logical_container_for_ci{@q} = (1) x scalar(@q);

    # This is slightly different from a tokenizer hash with a similar name:
    my %is_container_label_type_for_ci;
    @q = qw# k && | || ? : ! #;
    @is_container_label_type_for_ci{@q} = (1) x scalar(@q);

    # Undo ci of closing list paren followed by these binary operators:
    # - initially defined for issue t027, then
    # - added '=' for t015
    # - added '=~' for 'locale.in'
    # - added '<=>' for 'corelist.in'
    # Note:
    #   See @value_requestor_type for more that might be included
    #   See also @is_binary_type
    my %bin_op_type;
    @q = qw# . ** -> + - / * = != ^ < > % >= <= =~ !~ <=> x #;
    @bin_op_type{@q} = (1) x scalar(@q);

    my %is_list_end_type;
    @q = qw( ; { } );
    push @q, ',';
    @is_list_end_type{@q} = (1) x scalar(@q);

    my $rLL    = $self->[_rLL_];
    my $Klimit = $self->[_Klimit_];
    return unless defined($Klimit);

    my $token        = ';';
    my $type         = ';';
    my $last_token   = $token;
    my $last_type    = $type;
    my $ci_last      = 0;
    my $ci_next      = 0;
    my $ci_next_next = 1;
    my $rstack       = [];

    my $seq_root = SEQ_ROOT;
    my $rparent  = {
        _seqno           => $seq_root,
        _ci_open         => 0,
        _ci_open_next    => 0,
        _ci_close        => 0,
        _ci_close_next   => 0,
        _container_type  => 'Block',
        _ci_next_next    => $ci_next_next,
        _comma_count     => 0,
        _semicolon_count => 0,
        _Kc              => undef,
    };

    # Debug stuff
    my @debug_lines;
    my %saw_ci_diff;

    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];
    my $ris_sub_block        = $self->[_ris_sub_block_];
    my $ris_asub_block       = $self->[_ris_asub_block_];
    my $K_opening_container  = $self->[_K_opening_container_];
    my $K_closing_container  = $self->[_K_closing_container_];
    my $K_closing_ternary    = $self->[_K_closing_ternary_];
    my $rlines               = $self->[_rlines_];
    my $rtype_count_by_seqno = $self->[_rtype_count_by_seqno_];

    my $want_break_before_comma = $want_break_before{','};

    my $map_block_follows = sub {

        # return true if a sort/map/etc block follows the closing brace
        # of container $seqno
        my ($seqno) = @_;
        my $Kc = $K_closing_container->{$seqno};
        return unless defined($Kc);

        # Skip past keyword
        my $Kcn = $self->K_next_code($Kc);
        return unless defined($Kcn);
        my $seqno_n = $rLL->[$Kcn]->[_TYPE_SEQUENCE_];
        return if ($seqno_n);

        # Look for opening block brace
        my $Knn = $self->K_next_code($Kcn);
        return unless defined($Knn);
        my $seqno_nn = $rLL->[$Knn]->[_TYPE_SEQUENCE_];
        return unless ($seqno_nn);
        my $K_nno = $K_opening_container->{$seqno_nn};
        return unless ( $K_nno && $K_nno == $Knn );
        my $block_type = $rblock_type_of_seqno->{$seqno_nn};

        if ($block_type) {
            return $is_block_with_ci{$block_type};
        }
        return;
    }; ## end $map_block_follows = sub

    my $redo_preceding_comment_ci = sub {

        # We need to reset the ci of the previous comment(s)
        my ( $K, $ci ) = @_;
        my $Km = $self->K_previous_code($K);
        return if ( !defined($Km) );
        foreach my $Kt ( $Km + 1 .. $K - 1 ) {
            if ( $rLL->[$Kt]->[_TYPE_] eq '#' ) {
                $rLL->[$Kt]->[_CI_LEVEL_] = $ci;
            }
        }
        return;
    }; ## end $redo_preceding_comment_ci = sub

    # Definitions of the sequence of ci_values being maintained:
    # $ci_last      = the ci value of the previous non-blank, non-comment token
    # $ci_this      = the ci value to be stored for this token at index $KK
    # $ci_next      = the normal ci for the next token, set by the previous tok
    # $ci_next_next = the normal next value of $ci_next in this container

    #--------------------------
    # Main loop over all tokens
    #--------------------------
    my $KK = -1;
    foreach my $rtoken_K ( @{$rLL} ) {

        $KK++;

        #------------------
        # Section 1. Blanks
        #------------------
        if ( ( $type = $rtoken_K->[_TYPE_] ) eq 'b' ) {

            $rtoken_K->[_CI_LEVEL_] = $ci_next;

            # 'next' to avoid saving last_ values for blanks and commas
            next;
        }

        #--------------------
        # Section 2. Comments
        #--------------------
        if ( $type eq '#' ) {

            my $ci_this = $ci_next;

            # If at '#' in ternary before a ? or :, use that level to make
            # the comment line up with the next ? or : line.  (see c202/t052)
            # i.e. if a nested ? follows, we increase the '#' level by 1, and
            # if a nested : follows, we decrease the '#' level by 1.
            # This is the only place where this sub changes a _LEVEL_ value.
            my $Kn;
            my $parent_container_type = $rparent->{_container_type};
            if ( $parent_container_type eq 'Ternary' ) {
                $Kn = $self->K_next_code($KK);
                if ($Kn) {
                    my $type_kn = $rLL->[$Kn]->[_TYPE_];
                    if ( $is_ternary{$type_kn} ) {
                        $rLL->[$KK]->[_LEVEL_] = $rLL->[$Kn]->[_LEVEL_];

                        # and use the ci of a terminating ':'
                        if ( $Kn == $rparent->{_Kc} ) {
                            $ci_this = $rparent->{_ci_close};
                        }
                    }
                }
            }

            # Undo ci for a block comment followed by a closing token or , or ;
            # provided that the parent container:
            # - ends without ci, or
            # - starts ci=0 and is a comma list or this follows a closing type
            # - has a level jump
            if (
                $ci_this
                && (
                    !$rparent->{_ci_close}
                    || (
                        !$rparent->{_ci_open_next}
                        && ( ( $rparent->{_comma_count} || $last_type eq ',' )
                            || $is_closing_type{$last_type} )
                    )
                )
              )
            {
                # Be sure this is a block comment
                my $lx       = $rtoken_K->[_LINE_INDEX_];
                my $rK_range = $rlines->[$lx]->{_rK_range};
                my $Kfirst;
                if ($rK_range) { $Kfirst = $rK_range->[0] }
                if ( defined($Kfirst) && $Kfirst == $KK ) {

                    # Look for trailing closing token
                    #    [ and possibly ',' or ';' ]
                    $Kn = $self->K_next_code($KK) if ( !$Kn );
                    my $Kc = $rparent->{_Kc};
                    if (
                           $Kn
                        && $Kc
                        && (
                            $Kn == $Kc

                            # only look for comma if -wbb=',' is set
                            # to minimize changes to existing formatting
                            || (   $rLL->[$Kn]->[_TYPE_] eq ','
                                && $want_break_before_comma
                                && $parent_container_type eq 'List' )

                            # do not look ahead for a bare ';' because
                            # it changes old formatting with little benefit.
##                          || (   $rLL->[$Kn]->[_TYPE_] eq ';'
##                                && $parent_container_type eq 'Block' )
                        )
                      )
                    {

                        # Be sure container has a level jump
                        my $level_KK = $rLL->[$KK]->[_LEVEL_];
                        my $level_Kc = $rLL->[$Kc]->[_LEVEL_];

                        # And be sure this is not a hanging side comment
                        my $CODE_type = $rlines->[$lx]->{_code_type};
                        my $is_HSC    = $CODE_type && $CODE_type eq 'HSC';

                        if ( $level_Kc < $level_KK && !$is_HSC ) {
                            $ci_this = 0;
                        }
                    }
                }
            }

            $ci_next = $ci_this;
            $rtoken_K->[_CI_LEVEL_] = $ci_this;

            # 'next' to avoid saving last_ values for blanks and commas
            next;
        }

        #------------------------------------------------------------
        # Section 3. Continuing with non-blank and non-comment tokens
        #------------------------------------------------------------

        $token = $rtoken_K->[_TOKEN_];

        # Set ci values appropriate for most tokens:
        my $ci_this = $ci_next;
        $ci_next = $ci_next_next;

        # Now change these ci values as necessary for special cases...

        #----------------------------
        # Section 4. Container tokens
        #----------------------------
        if ( $rtoken_K->[_TYPE_SEQUENCE_] ) {

            my $seqno = $rtoken_K->[_TYPE_SEQUENCE_];

            #-------------------------------------
            # Section 4.1 Opening container tokens
            #-------------------------------------
            if ( $is_opening_sequence_token{$token} ) {

                my $level = $rtoken_K->[_LEVEL_];

                # Default ci values for the closing token, to be modified
                # as necessary:
                my $ci_close      = $ci_next;
                my $ci_close_next = $ci_next_next;

                my $Kc =
                    $type eq '?'
                  ? $K_closing_ternary->{$seqno}
                  : $K_closing_container->{$seqno};

                #  $Kn  = $self->K_next_nonblank($KK);
                my $Kn;
                if ( $KK < $Klimit ) {
                    $Kn = $KK + 1;
                    if ( $rLL->[$Kn]->[_TYPE_] eq 'b' && $Kn < $Klimit ) {
                        $Kn += 1;
                    }
                }

                #  $Kcn = $self->K_next_code($Kc);
                my $Kcn;
                if ( $Kc && $Kc < $Klimit ) {
                    $Kcn = $Kc + 1;
                    if ( $rLL->[$Kcn]->[_TYPE_] eq 'b' && $Kcn < $Klimit ) {
                        $Kcn += 1;
                    }
                    if ( $rLL->[$Kcn]->[_TYPE_] eq '#' ) {
                        $Kcn = $self->K_next_code($Kcn);
                    }
                }

                my $opening_level_jump =
                  $Kn ? $rLL->[$Kn]->[_LEVEL_] - $level : 0;

                # initialize ci_next_next to its standard value
                $ci_next_next = 1;

                # Default: ci of first item of list with level jump is same as
                # ci of first item of container
                if ( $opening_level_jump > 0 ) {
                    $ci_next = $rparent->{_ci_open_next};
                }

                my ( $comma_count, $semicolon_count );
                my $rtype_count = $rtype_count_by_seqno->{$seqno};
                if ($rtype_count) {
                    $comma_count     = $rtype_count->{','};
                    $semicolon_count = $rtype_count->{';'};

                    # Do not include a terminal semicolon in the count (the
                    # comma_count has already been corrected by respace_tokens)
                    # We only need to know if there are semicolons or not, so
                    # for speed we can just do this test if the count is 1.
                    if ( $semicolon_count && $semicolon_count == 1 ) {
                        my $Kcm = $self->K_previous_code($Kc);
                        if ( $rLL->[$Kcm]->[_TYPE_] eq ';' ) {
                            $semicolon_count--;
                        }
                    }
                }

                my $container_type;

                #-------------------------
                # Section 4.1.1 Code Block
                #-------------------------
                my $block_type = $rblock_type_of_seqno->{$seqno};
                if ($block_type) {
                    $container_type = 'Block';

                    # set default depending on block type
                    $ci_close = 0;

                    my $no_semicolon =
                         $is_block_without_semicolon{$block_type}
                      || $ris_sub_block->{$seqno}
                      || $last_type eq 'J';

                    if ( !$no_semicolon ) {

                        # Optional fix for block types sort/map/etc which use
                        # zero ci at terminal brace if previous keyword had
                        # zero ci.  This will cause sort/map/grep filter blocks
                        # to line up. Note that sub 'undo_ci' will also try to
                        # do this, so this is not a critical operation.
                        if ( $is_block_with_ci{$block_type} ) {
                            my $parent_seqno = $rparent->{_seqno};
                            if (

                                # only do this within containers
                                $parent_seqno != SEQ_ROOT

                                # only in containers without ',' and ';'
                                && !$rparent->{_comma_count}
                                && !$rparent->{_semicolon_count}

                                && $map_block_follows->($seqno)
                              )
                            {
                                if ($ci_last) {
                                    $ci_close = $ci_this;
                                }
                            }
                            else {
                                $ci_close = $ci_this;
                            }
                        }

                        # keep ci if certain operators follow (fix c202/t024)
                        if ( !$ci_close && $Kcn ) {
                            my $type_kcn  = $rLL->[$Kcn]->[_TYPE_];
                            my $token_kcn = $rLL->[$Kcn]->[_TOKEN_];
                            if (   $type_kcn =~ /^(\.|\&\&|\|\|)$/
                                || $type_kcn eq 'k' && $is_and_or{$token_kcn} )
                            {
                                $ci_close = $ci_this;
                            }
                        }
                    }

                    if ( $rparent->{_container_type} ne 'Ternary' ) {
                        $ci_this = 0;
                    }
                    $ci_next       = 0;
                    $ci_close_next = $ci_close;
                }

                #----------------------
                # Section 4.1.2 Ternary
                #----------------------
                elsif ( $type eq '?' ) {
                    $container_type = 'Ternary';
                    if ( $rparent->{_container_type} eq 'List'
                        && !$rparent->{_ci_open_next} )
                    {
                        $ci_this  = 0;
                        $ci_close = 0;
                    }

                    # redo ci of any preceding comments if necessary
                    # at an outermost ? (which has no level jump)
                    if ( !$opening_level_jump ) {
                        $redo_preceding_comment_ci->( $KK, $ci_this );
                    }
                }

                #-------------------------------
                # Section 4.1.3 Logical or List?
                #-------------------------------
                else {
                    my $is_logical = $is_container_label_type_for_ci{$last_type}
                      && $is_logical_container_for_ci{$last_token}

                      # Part 1 of optional patch to get agreement with previous
                      # ci This makes almost no difference in a typical program
                      # because we will seldom break within an array index.
                      || $type eq '[' && SET_CI_OPTION_0;

                    if ( !$is_logical && $token eq '(' ) {

                        # 'foreach' and 'for' paren contents are treated as
                        # logical except for C-style 'for'
                        if ( $last_type eq 'k' ) {
                            $is_logical ||= $last_token eq 'foreach';

                            # C-style 'for' container will be type 'List'
                            if ( $last_token eq 'for' ) {
                                $is_logical =
                                  !( $rtype_count && $rtype_count->{'f'} );
                            }
                        }

                        # Check for 'for' and 'foreach' loops with iterators
                        elsif ( $last_type eq 'i' && defined($Kcn) ) {
                            my $seqno_kcn = $rLL->[$Kcn]->[_TYPE_SEQUENCE_];
                            my $type_kcn  = $rLL->[$Kcn]->[_TOKEN_];
                            if ( $seqno_kcn && $type_kcn eq '{' ) {
                                my $block_type_kcn =
                                  $rblock_type_of_seqno->{$seqno_kcn};
                                $is_logical ||= $block_type_kcn
                                  && ( $block_type_kcn eq 'for'
                                    || $block_type_kcn eq 'foreach' );
                            }

                            # Search backwards for 'for'/'foreach' with
                            # iterator in case user is running from an editor
                            # and did not include the block (fixes case
                            # 'xci.in').
                            my $Km = $self->K_previous_code($KK);
                            foreach ( 0 .. 2 ) {
                                $Km = $self->K_previous_code($Km);
                                last unless defined($Km);
                                last unless ( $rLL->[$Km]->[_TYPE_] eq 'k' );
                                my $tok = $rLL->[$Km]->[_TOKEN_];
                                next if ( $tok eq 'my' );
                                $is_logical ||=
                                  ( $tok eq 'for' || $tok eq 'foreach' );
                                last;
                            }
                        }
                        elsif ( $last_token eq '(' ) {
                            $is_logical ||=
                              $rparent->{_container_type} eq 'Logical';
                        }
                        else {
                            # does not look like a logical paren
                        }
                    }

                    #------------------------
                    # Section 4.1.3.1 Logical
                    #------------------------
                    if ($is_logical) {
                        $container_type = 'Logical';

                        # Pass ci though an '!'
                        if ( $last_type eq '!' ) { $ci_this = $ci_last }

                        $ci_next_next  = 0;
                        $ci_close_next = $ci_this;

                        # Part 2 of optional patch to get agreement with
                        # previous ci
                        if ( $type eq '[' && SET_CI_OPTION_0 ) {

                            $ci_next_next = $ci_this;

                            # Undo ci at a chain of indexes or hash keys
                            if ( $last_type eq '}' ) {
                                $ci_this = $ci_last;
                            }
                        }

                        if ($opening_level_jump) {
                            $ci_next = 0;
                        }
                    }

                    #---------------------
                    # Section 4.1.3.2 List
                    #---------------------
                    else {

                        # Here 'List' is a catchall for none of the above types
                        $container_type = 'List';

                        # lists in blocks ...
                        if ( $rparent->{_container_type} eq 'Block' ) {

                            # undo ci if another closing token follows
                            if ( defined($Kcn) ) {
                                my $closing_level_jump =
                                  $rLL->[$Kcn]->[_LEVEL_] - $level;
                                if ( $closing_level_jump < 0 ) {
                                    $ci_close = $ci_this;
                                }
                            }
                        }

                        # lists not in blocks ...
                        else {

                            if ( !$rparent->{_comma_count} ) {

                                $ci_close = $ci_this;

                                # undo ci at binary op after right paren if no
                                # commas in container; fixes t027, t028
                                if (   $ci_close_next != $ci_close
                                    && defined($Kcn)
                                    && $bin_op_type{ $rLL->[$Kcn]->[_TYPE_] } )
                                {
                                    $ci_close_next = $ci_close;
                                }
                            }

                            if ( $rparent->{_container_type} eq 'Ternary' ) {
                                $ci_next = 0;
                            }
                        }

                        # Undo ci at a chain of indexes or hash keys
                        if ( $token ne '(' && $last_type eq '}' ) {
                            $ci_this = $ci_close = $ci_last;
                        }
                    }
                }

                #---------------------------------------
                # Section 4.1.4 Store opening token info
                #---------------------------------------

                # Most closing tokens should align with their opening tokens.
                if (
                       $type eq '{'
                    && $token ne '('
                    && $is_list_end_type{$last_type}

                    # avoid asub blocks, which may have prototypes ending in '}'
                    && !$ris_asub_block->{$seqno}
                  )
                {
                    $ci_close = $ci_this;
                }

                # Closing ci must never be less than opening
                if ( $ci_close < $ci_this ) { $ci_close = $ci_this }

                push @{$rstack}, $rparent;
                $rparent = {
                    _seqno           => $seqno,
                    _container_type  => $container_type,
                    _ci_next_next    => $ci_next_next,
                    _ci_open         => $ci_this,
                    _ci_open_next    => $ci_next,
                    _ci_close        => $ci_close,
                    _ci_close_next   => $ci_close_next,
                    _comma_count     => $comma_count,
                    _semicolon_count => $semicolon_count,
                    _Kc              => $Kc,
                };
            }

            #-------------------------------------
            # Section 4.2 Closing container tokens
            #-------------------------------------
            else {

                my $seqno_test = $rparent->{_seqno};
                if ( $seqno_test ne $seqno ) {

                    # Shouldn't happen if we are processing balanced text.
                    # (Unbalanced text should go out verbatim)
                    DEVEL_MODE
                      && Fault("stack error: $seqno_test != $seqno\n");
                }

                # Use ci_this, ci_next values set by the matching opening token:
                $ci_this = $rparent->{_ci_close};
                $ci_next = $rparent->{_ci_close_next};
                my $ci_open_old = $rparent->{_ci_open};

                # Then pop the stack and use the parent ci_next_next value:
                if ( @{$rstack} ) {
                    $rparent      = pop @{$rstack};
                    $ci_next_next = $rparent->{_ci_next_next};
                }
                else {

                    # Shouldn't happen if we are processing balanced text.
                    DEVEL_MODE && Fault("empty stack - shouldn't happen\n");
                }

                # Fix: undo ci at a closing token followed by a closing token.
                # Goal is to keep formatting independent of the existence of a
                # trailing comma or semicolon.
                if ( $ci_this > 0 && !$ci_open_old && !$rparent->{_ci_close} ) {
                    my $Kc = $rparent->{_Kc};
                    my $Kn = $self->K_next_code($KK);
                    if ( $Kc && $Kn && $Kc == $Kn ) {
                        $ci_this = $ci_next = 0;
                    }
                }
            }
        }

        #---------------------------------
        # Section 5. Semicolons and Labels
        #---------------------------------
        # The next token after a ';' and label (type 'J') starts a new stmt
        # The ci after a C-style for ';' (type 'f') is handled similarly.
        elsif ( $type eq ';' || $type eq 'J' || $type eq 'f' ) {
            $ci_next = 0;
            if ( $is_closing_type{$last_type} ) { $ci_this = $ci_last }
        }

        #--------------------
        # Section 6. Keywords
        #--------------------
        # Undo ci after a format statement
        elsif ( $type eq 'k' ) {
            if ( substr( $token, 0, 6 ) eq 'format' ) {
                $ci_next = 0;
            }
        }

        #------------------
        # Section 7. Commas
        #------------------
        # A comma and the subsequent item normally have ci undone
        # unless ci has been set at a lower level
        elsif ( $type eq ',' ) {

            if ( $rparent->{_container_type} eq 'List' ) {
                $ci_this = $ci_next = $rparent->{_ci_open_next};
            }
        }

        else {
            # not a special ci type
        }

        # Save debug info if requested
        DEBUG_SET_CI && do {

            my $seqno = $rtoken_K->[_TYPE_SEQUENCE_];
            my $level = $rtoken_K->[_LEVEL_];
            my $ci    = $rtoken_K->[_CI_LEVEL_];
            if ( $ci > 1 ) { $ci = 1 }

            my $tok      = $token;
            my $last_tok = $last_token;
            $tok      =~ s/\t//g;
            $last_tok =~ s/\t//g;
            $tok = length($tok) > 3 ? substr( $tok, 0, 8 ) : $tok;
            $last_tok =
              length($last_tok) > 3 ? substr( $last_tok, 0, 8 ) : $last_tok;
            $tok      =~ s/["']//g;
            $last_tok =~ s/["']//g;
            my $block_type;
            $block_type = $rblock_type_of_seqno->{$seqno} if ($seqno);
            $block_type = EMPTY_STRING unless ($block_type);
            my $ptype = $rparent->{_container_type};
            my $pname = $ptype;

            my $error =
              $ci_this == $ci ? EMPTY_STRING : $type eq 'b' ? "error" : "ERROR";
            if ($error) { $saw_ci_diff{$KK} = 1 }

            my $lno = $rtoken_K->[_LINE_INDEX_] + 1;
            $debug_lines[$KK] = <<EOM;
$lno\t$ci\t$ci_this\t$ci_next\t$last_type\t$last_tok\t$type\t$tok\t$seqno\t$level\t$pname\t$block_type\t$error
EOM
        };

        #----------------------------------
        # Store the ci value for this token
        #----------------------------------
        $rtoken_K->[_CI_LEVEL_] = $ci_this;

        # Remember last nonblank, non-comment token info for the next pass
        $ci_last    = $ci_this;
        $last_token = $token;
        $last_type  = $type;

    }    ## End main loop over tokens

    #----------------------
    # Post-loop operations:
    #----------------------

    if (DEBUG_SET_CI) {
        my @output_lines;
        foreach my $Kd ( 0 .. $Klimit ) {
            my $line = $debug_lines[$Kd];
            if ($line) {
                my $Kp = $self->K_previous_code($Kd);
                my $Kn = $self->K_next_code($Kd);
                if (   DEBUG_SET_CI > 1
                    || $Kp && $saw_ci_diff{$Kp}
                    || $saw_ci_diff{$Kd}
                    || $Kn && $saw_ci_diff{$Kn} )
                {
                    push @output_lines, $line;
                }
            }
        }
        if (@output_lines) {
            unshift @output_lines, <<EOM;
lno\tci\tci_this\tci_next\tlast_type\tlast_tok\ttype\ttok\tseqno\tlevel\tpname\tblock_type\terror?
EOM
            foreach my $line (@output_lines) {
                chomp $line;
                print {*STDOUT} $line, "\n";
            }
        }
    }

    return;
} ## end sub set_ci

sub set_CODE_type {
    my ($self) = @_;

    # Examine each line of code and set a flag '$CODE_type' to describe it.
    # Also return a list of lines with side comments.

    my $rLL    = $self->[_rLL_];
    my $rlines = $self->[_rlines_];

    my $rOpts_format_skipping_begin = $rOpts->{'format-skipping-begin'};
    my $rOpts_format_skipping_end   = $rOpts->{'format-skipping-end'};
    my $rOpts_static_block_comment_prefix =
      $rOpts->{'static-block-comment-prefix'};

    # Remember indexes of lines with side comments
    my @ix_side_comments;

    my $In_format_skipping_section = 0;
    my $Saw_VERSION_in_this_file   = 0;
    my $has_side_comment           = 0;
    my $last_line_had_side_comment = 0;
    my ( $Kfirst, $Klast );
    my $CODE_type;

    # Loop to set CODE_type

    # Possible CODE_types
    # 'VB'  = Verbatim - line goes out verbatim (a quote)
    # 'FS'  = Format Skipping - line goes out verbatim
    # 'BL'  = Blank Line
    # 'HSC' = Hanging Side Comment - fix this hanging side comment
    # 'SBCX'= Static Block Comment Without Leading Space
    # 'SBC' = Static Block Comment
    # 'BC'  = Block Comment - an ordinary full line comment
    # 'IO'  = Indent Only - line goes out unchanged except for indentation
    # 'NIN' = No Internal Newlines - line does not get broken
    # 'VER' = VERSION statement
    # ''    = ordinary line of code with no restrictions

    #--------------------
    # Loop over all lines
    #--------------------
    my $ix_line = -1;
    foreach my $line_of_tokens ( @{$rlines} ) {
        $ix_line++;
        my $line_type = $line_of_tokens->{_line_type};

        my $last_CODE_type = $CODE_type;

        # Set default to be ordinary code
        $CODE_type = EMPTY_STRING;

        #-------------------------------------
        # This is only for lines marked 'CODE'
        #-------------------------------------
        if ( $line_type ne 'CODE' ) {
            next;
        }

        my $input_line = $line_of_tokens->{_line_text};

        my $Klast_prev = $Klast;
        ( $Kfirst, $Klast ) = @{ $line_of_tokens->{_rK_range} };
        my $jmax = defined($Kfirst) ? $Klast - $Kfirst : -1;

        my $is_block_comment;
        if ( $jmax >= 0 && $rLL->[$Klast]->[_TYPE_] eq '#' ) {
            if   ( $jmax == 0 ) { $is_block_comment = 1; }
            else                { $has_side_comment = 1 }
        }

        #-----------------------------------------------------------
        # Write line verbatim if we are in a formatting skip section
        #-----------------------------------------------------------
        if ($In_format_skipping_section) {

            # Note: extra space appended to comment simplifies pattern matching
            if (
                $is_block_comment

                # optional fast pre-check
                && ( substr( $rLL->[$Kfirst]->[_TOKEN_], 0, 4 ) eq '#>>>'
                    || $rOpts_format_skipping_end )

                && ( $rLL->[$Kfirst]->[_TOKEN_] . SPACE ) =~
                /$format_skipping_pattern_end/
              )
            {
                $In_format_skipping_section = 0;
                my $input_line_no = $line_of_tokens->{_line_number};
                write_logfile_entry(
                    "Line $input_line_no: Exiting format-skipping section\n");
            }
            elsif (
                $is_block_comment

                # optional fast pre-check
                && ( substr( $rLL->[$Kfirst]->[_TOKEN_], 0, 4 ) eq '#<<<'
                    || $rOpts_format_skipping_begin )

                && $rOpts_format_skipping
                && ( $rLL->[$Kfirst]->[_TOKEN_] . SPACE ) =~
                /$format_skipping_pattern_begin/
              )
            {
                # warn of duplicate starting comment lines, git #118
                my $input_line_no = $line_of_tokens->{_line_number};
                warning(
"Already in format-skipping section which started at line $In_format_skipping_section\n",
                    $input_line_no
                );
            }
            else {
                # not at a format skipping control line
            }
            $CODE_type = 'FS';
            next;
        }

        #----------------------------
        # Check for a continued quote
        #----------------------------
        if ( $line_of_tokens->{_starting_in_quote} ) {

            # A line which is entirely a quote or pattern must go out
            # verbatim.  Note: the \n is contained in $input_line.
            if ( $jmax <= 0 ) {
                if ( $self->[_save_logfile_] && $input_line =~ /\t/ ) {
                    my $input_line_number = $line_of_tokens->{_line_number};
                    $self->note_embedded_tab($input_line_number);
                }
                $CODE_type = 'VB';
                next;
            }
        }

        #-------------------------------------------------
        # See if we are entering a formatting skip section
        #-------------------------------------------------
        if (
            $is_block_comment

            # optional fast pre-check
            && ( substr( $rLL->[$Kfirst]->[_TOKEN_], 0, 4 ) eq '#<<<'
                || $rOpts_format_skipping_begin )

            && $rOpts_format_skipping
            && ( $rLL->[$Kfirst]->[_TOKEN_] . SPACE ) =~
            /$format_skipping_pattern_begin/
          )
        {
            my $input_line_no = $line_of_tokens->{_line_number};
            $In_format_skipping_section = $input_line_no;
            write_logfile_entry(
                "Line $input_line_no: Entering format-skipping section\n");
            $CODE_type = 'FS';
            next;
        }

        # ignore trailing blank tokens (they will get deleted later)
        if ( $jmax > 0 && $rLL->[$Klast]->[_TYPE_] eq 'b' ) {
            $jmax--;
        }

        #-----------
        # Blank line
        #-----------
        if ( $jmax < 0 ) {
            $CODE_type = 'BL';
            next;
        }

        #---------
        # Comments
        #---------
        if ($is_block_comment) {

            # see if this is a static block comment (starts with ## by default)
            my $is_static_block_comment = 0;
            my $no_leading_space        = substr( $input_line, 0, 1 ) eq '#';
            if (

                # optional fast pre-check
                (
                    substr( $rLL->[$Kfirst]->[_TOKEN_], 0, 2 ) eq '##'
                    || $rOpts_static_block_comment_prefix
                )

                && $rOpts_static_block_comments
                && $input_line =~ /$static_block_comment_pattern/
              )
            {
                $is_static_block_comment = 1;
            }

            # Check for comments which are line directives
            # Treat exactly as static block comments without leading space
            # reference: perlsyn, near end, section Plain Old Comments (Not!)
            # example: '# line 42 "new_filename.plx"'
            if (
                   $no_leading_space
                && $input_line =~ m{^\#   \s*
                           line \s+ (\d+)   \s*
                           (?:\s("?)([^"]+)\2)? \s*
                           $}x
              )
            {
                $is_static_block_comment = 1;
            }

            # look for hanging side comment ...
            if (
                $last_line_had_side_comment     # this follows as side comment
                && !$no_leading_space           # with some leading space, and
                && !$is_static_block_comment    # this is not a static comment
              )
            {

                #  continuing an existing HSC chain?
                if ( $last_CODE_type eq 'HSC' ) {
                    $has_side_comment = 1;
                    $CODE_type        = 'HSC';
                    next;
                }

                #  starting a new HSC chain?
                if (

                    $rOpts->{'hanging-side-comments'}    # user is allowing
                                                         # hanging side comments
                                                         # like this

                    && ( defined($Klast_prev) && $Klast_prev > 1 )

                    # and the previous side comment was not static (issue c070)
                    && !(
                           $rOpts->{'static-side-comments'}
                        && $rLL->[$Klast_prev]->[_TOKEN_] =~
                        /$static_side_comment_pattern/
                    )

                  )
                {

                    # and it is not a closing side comment (issue c070).
                    my $K_penult = $Klast_prev - 1;
                    $K_penult -= 1 if ( $rLL->[$K_penult]->[_TYPE_] eq 'b' );
                    my $follows_csc =
                      (      $rLL->[$K_penult]->[_TOKEN_] eq '}'
                          && $rLL->[$K_penult]->[_TYPE_] eq '}'
                          && $rLL->[$Klast_prev]->[_TOKEN_] =~
                          /$closing_side_comment_prefix_pattern/ );

                    if ( !$follows_csc ) {
                        $has_side_comment = 1;
                        $CODE_type        = 'HSC';
                        next;
                    }
                }
            }

            if ($is_static_block_comment) {
                $CODE_type = $no_leading_space ? 'SBCX' : 'SBC';
                next;
            }
            elsif ( $last_line_had_side_comment
                && !$rOpts_maximum_consecutive_blank_lines
                && $rLL->[$Kfirst]->[_LEVEL_] > 0 )
            {
                # Emergency fix to keep a block comment from becoming a hanging
                # side comment.  This fix is for the case that blank lines
                # cannot be inserted.  There is related code in sub
                # 'process_line_of_CODE'
                $CODE_type = 'SBCX';
                next;
            }
            else {
                $CODE_type = 'BC';
                next;
            }
        }

        #-------------------------
        # Other special code types
        #-------------------------
        if ($rOpts_indent_only) {
            $CODE_type = 'IO';
            next;
        }

        if ( !$rOpts_add_newlines ) {
            $CODE_type = 'NIN';
            next;
        }

        #   Patch needed for MakeMaker.  Do not break a statement
        #   in which $VERSION may be calculated.  See MakeMaker.pm;
        #   this is based on the coding in it.
        #   The first line of a file that matches this will be eval'd:
        #       /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/
        #   Examples:
        #     *VERSION = \'1.01';
        #     ( $VERSION ) = '$Revision: 1.74 $ ' =~ /\$Revision:\s+([^\s]+)/;
        #   We will pass such a line straight through without breaking
        #   it unless -npvl is used.

        #   Patch for problem reported in RT #81866, where files
        #   had been flattened into a single line and couldn't be
        #   tidied without -npvl.  There are two parts to this patch:
        #   First, it is not done for a really long line (80 tokens for now).
        #   Second, we will only allow up to one semicolon
        #   before the VERSION.  We need to allow at least one semicolon
        #   for statements like this:
        #      require Exporter;  our $VERSION = $Exporter::VERSION;
        #   where both statements must be on a single line for MakeMaker

        if (  !$Saw_VERSION_in_this_file
            && $jmax < 80
            && $input_line =~
            /^[^;]*;?[^;]*([\$*])(([\w\:\']*)\bVERSION)\b.*\=/ )
        {
            $Saw_VERSION_in_this_file = 1;
            write_logfile_entry("passing VERSION line; -npvl deactivates\n");

            # This code type has lower priority than others
            $CODE_type = 'VER';
            next;
        }
    }
    continue {
        $line_of_tokens->{_code_type} = $CODE_type;

        $last_line_had_side_comment = $has_side_comment;
        if ($has_side_comment) {
            push @ix_side_comments, $ix_line;
            $has_side_comment = 0;
        }
    }

    return \@ix_side_comments;
} ## end sub set_CODE_type

sub block_seqno_of_paren_keyword {

    my ( $self, $KK ) = @_;

    # Find brace at '){' after keyword such as for, foreach, ...
    # SEE ALSO: sub block_seqno_of_paren_seqno

    # Given:
    #   $KK = index of a keyword followed by parens and block '... ( ) {'
    #         such as 'for', 'foreach', 'while', 'if', 'elsif' ..
    # Return:
    #   $seqno of the opening block brace for this keyword, if any
    #   $K_end_iterator = index of the last token of an iterator, if any
    # or
    #   nothing if not found

    #         'for my $var (..) { ... }'
    #           ^               ^
    #           |               |
    #           --$KK           --$seqno of brace that we want

    my $rLL = $self->[_rLL_];

    # look ahead for an opening paren
    my $K_paren = $self->[_rK_next_seqno_by_K_]->[$KK];
    return unless defined($K_paren);
    my $token_paren = $rLL->[$K_paren]->[_TOKEN_];
    return unless ( $token_paren eq '(' );

    # found a paren, but does it belong to this keyword?
    my $seqno_paren = $rLL->[$K_paren]->[_TYPE_SEQUENCE_];

    # see if this opening paren immediately follows the keyword
    my $K_n = $self->K_next_code($KK);
    return unless $K_n;

    # is it the next token? this is the common case
    my $K_end_iterator;
    my $saw_my;
    my $token_KK = $rLL->[$KK]->[_TOKEN_];
    if ( $K_n != $K_paren ) {

        # look for 'for $var (', 'for my $var (', 'for my (', 'for $var ('
        if ( $is_for_foreach{$token_KK} ) {
            my $type_K_n  = $rLL->[$K_n]->[_TYPE_];
            my $token_K_n = $rLL->[$K_n]->[_TOKEN_];

            # skip past a 'my'
            if ( $type_K_n eq 'k' ) {
                if ( $is_my_state_our{$token_K_n} ) {
                    $K_n    = $self->K_next_code($K_n);
                    $saw_my = 1;
                }
                else { return }
            }

            # skip an identifier
            if ( $K_n && $K_n != $K_paren && $rLL->[$K_n]->[_TYPE_] eq 'i' ) {
                $K_n = $self->K_next_code($K_n);

                # force this iterator to be entered as new lexical
                $K_end_iterator = $K_paren;
            }
        }
    }

    # we must be at the paren
    return unless ( $K_n && $K_n == $K_paren );

    # now jump to the closing paren
    $K_paren = $self->[_K_closing_container_]->{$seqno_paren};

    # then look for the opening brace immediately after it
    my $K_brace = $self->K_next_code($K_paren);
    return unless ($K_brace);

    # check for experimental 'for list': for my ( $a, $b) (@list) {
    #                                              ^
    if (   $rLL->[$K_brace]->[_TOKEN_] eq '('
        && !$K_end_iterator
        && $is_for_foreach{$token_KK} )
    {
        if ( !$saw_my ) { $K_end_iterator = $K_brace }
        my $seqno_test = $rLL->[$K_brace]->[_TYPE_SEQUENCE_];
        my $K_test     = $self->[_K_closing_container_]->{$seqno_test};
        return unless $K_test;
        $K_brace = $self->K_next_code($K_test);
        return unless ($K_brace);
    }

    return unless ( $rLL->[$K_brace]->[_TOKEN_] eq '{' );
    my $seqno_brace = $rLL->[$K_brace]->[_TYPE_SEQUENCE_];
    return unless ($seqno_brace);
    my $block_type = $self->[_rblock_type_of_seqno_]->{$seqno_brace};

    # Verify that this is the correct brace
    if ( $block_type ne $token_KK ) {

        # If not, this is unexpected and should be investigated
        # (the block type may have been mis-marked)
        my $lno = $rLL->[$KK]->[_LINE_INDEX_] + 1;
        DEVEL_MODE && Fault(<<EOM);
at line $lno: found block type $block_type: expecting $token_KK - please check
EOM
        return;
    }

    return ( $seqno_brace, $K_end_iterator );
} ## end sub block_seqno_of_paren_keyword

sub has_complete_package {
    my ($self) = @_;

    # return true if this file appears to contain at least one complete package

    my $Klast = $self->K_last_code();
    return unless defined($Klast);

    my $rLL = $self->[_rLL_];

    my $rK_package_list = $self->[_rK_package_list_];
    return unless ( defined($rK_package_list) && @{$rK_package_list} );

    # look for a file like this:
    # package A::B
    # ...
    # 1;

    my $KK   = $rK_package_list->[0];
    my $item = $rLL->[$KK];
    my $type = $item->[_TYPE_];

    # Stored K values may be off by 1 due to an added blank
    if ( $type eq 'b' ) {
        $KK += 1;
        $item = $rLL->[$KK];
        $type = $item->[_TYPE_];
    }

    # safety check - shouldn't happen
    if ( $type ne 'P' ) {
        DEVEL_MODE && Fault("Expecting type 'P' but found '$type'");
        return;
    }
    my $level = $item->[_LEVEL_];
    return unless ( $level == 0 );

    # Look for '1;' at next package, if any, and at end of file
    my @K_semicolon_test = ($Klast);
    if ( @{$rK_package_list} > 1 ) {
        my $K_package = $rK_package_list->[1];
        my $Ktest     = $self->K_previous_code($K_package);
        push @K_semicolon_test, $Ktest;
    }

    foreach my $Ktest (@K_semicolon_test) {
        if ( $rLL->[$Ktest]->[_TYPE_] eq 'b' ) { $Ktest -= 1 }
        if ( $Ktest > $KK && $Ktest && $rLL->[$Ktest]->[_TYPE_] eq ';' ) {
            my $K1 = $self->K_previous_code($Ktest);
            if ( $K1 && $rLL->[$K1]->[_TOKEN_] eq '1' ) {
                return 1;
            }
        }
    }
    return;
} ## end sub has_complete_package

sub is_complete_script {
    my ( $self, $rline_type_count, $rkeyword_count ) = @_;

    # Guess if we are formatting a complete script
    # Given:
    #   $rline_type_count = hash ref of count of line types
    #   $rkeyword_count   = hash ref of count of keywords
    # Return: true or false

    # Goal: help decide if we should skip certain warning checks when
    # operating on just part of a script (such as from an editor).

    #----------------------------------------------------------------
    # TEST 1: Assume a file with known extension is a complete script
    #----------------------------------------------------------------
    my %is_standard_file_extension = (
        'pm'  => 1,
        'pl'  => 1,
        'plx' => 1,
        't'   => 1,
    );
    my $input_stream_name = get_input_stream_name();

    # look for a file extension
    my $pos_dot        = rindex( $input_stream_name, '.' );
    my $file_extension = EMPTY_STRING;
    if ( $pos_dot > 0 ) {
        $file_extension = substr( $input_stream_name, $pos_dot + 1 );

        # allow additional digits, like .pm.0, .pm.1 etc
        if (   defined($file_extension)
            && length($file_extension)
            && $file_extension =~ /^\d+$/ )
        {
            my $str = substr( $input_stream_name, 0, $pos_dot );
            $pos_dot = rindex( $str, '.' );
            if ( $pos_dot > 0 ) {
                $file_extension = substr( $str, $pos_dot + 1 );
            }
        }

        return 1 if $is_standard_file_extension{ lc($file_extension) };
    }

    #-------------------------------------------------------------
    # TEST 2: a positive starting level implies an incomplete script
    #-------------------------------------------------------------
    my $rLL = $self->[_rLL_];
    return unless ( @{$rLL} );
    my $sil = $rLL->[0]->[_LEVEL_];
    return if ($sil);

    #------------------------------------
    # TEST 3: look for a complete package
    #------------------------------------
    return 1 if $self->has_complete_package();

    #----------------------------
    # TEST 4: examine other clues
    #----------------------------
    my $rlines     = $self->[_rlines_];
    my $line_count = @{$rlines};
    return unless ($line_count);

    my $input_line    = $rlines->[0]->{_line_text};
    my $saw_hash_bang = substr( $input_line, 0, 2 ) eq '#!'
      && $input_line =~ /^\#\!.*perl\b/;

    my $rK_package_list = $self->[_rK_package_list_];
    my $saw_package     = defined($rK_package_list) && @{$rK_package_list};
    my $sub_count       = +keys %{ $self->[_ris_sub_block_] };
    my $use_count       = 0;
    $use_count += $rkeyword_count->{use}     if $rkeyword_count->{use};
    $use_count += $rkeyword_count->{require} if $rkeyword_count->{require};

    # Make a guess using the available clues. No single clue is conclusive.
    my $score = 0;

    # starting indicators
    $score += 50
      if ( $saw_hash_bang
        || $self->[_saw_use_strict_]
        || $saw_package );

    $score +=
        $use_count > 1 ? 50
      : $use_count > 0 ? 25
      :                  0;

    # interior indicators
    $score +=
        $line_count > 50 ? 50
      : $line_count > 25 ? 25
      :                    0;
    $score +=
        $sub_count > 1 ? 50
      : $sub_count > 0 ? 25
      :                  0;

    # common filter keywords
    foreach (qw( exit print printf open system exec die )) {
        if ( $rkeyword_count->{$_} ) { $score += 50; last; }
    }

    $score += 50 if $rline_type_count->{POD};

    # ending indicator
    $score += 50 if $self->[_saw_END_or_DATA_];

    if ( $score >= 100 ) { return 1 }
    return;
} ## end sub is_complete_script

use constant DEBUG_USE_CONSTANT => 0;

sub get_qw_list {
    my ( $self, $Kn ) = @_;

    # Given:
    #  $Kn = index of start of a qw quote
    # Return:
    #  ($K_last_q, \@list) to list of words, or
    #  nothing if error

    my $rLL = $self->[_rLL_];
    return unless defined($Kn);
    my $type_n = $rLL->[$Kn]->[_TYPE_];
    return unless ( $type_n eq 'q' );
    my $token_n  = $rLL->[$Kn]->[_TOKEN_];
    my $K_last_q = $Kn;

    # collect a multi-line qw
    my $string = $token_n;
    foreach my $Knn ( $Kn + 1 .. @{$rLL} - 1 ) {
        my $type_nn = $rLL->[$Knn]->[_TYPE_];
        next if ( $type_nn eq 'b' );
        last if ( $type_nn ne 'q' );
        $string .= SPACE . $rLL->[$Knn]->[_TOKEN_];
        $K_last_q = $Knn;
    }

    $string = substr( $string, 2 );        # remove qw
    $string =~ s/^\s*//;                   # trim left
    $string = substr( $string, 1 );        # remove opening mark char
    $string = substr( $string, 0, -1 );    # remove closing mark char
    $string =~ s/^\s*//;                   # trim left
    $string =~ s/\s*$//;                   # trim right

    my @list = split /\s+/, $string;
    return ( $K_last_q, \@list );
} ## end sub get_qw_list

sub expand_quoted_word_list {
    my ( $self, $Kbeg ) = @_;

    # Expand a list quoted words
    # Given:
    #   $Kbeg = index of the start of a list of quoted words
    # Returns:
    #   ref to list if found words
    #   undef if not successful, or non-constant list item encountered
    my $rLL = $self->[_rLL_];
    return unless defined($Kbeg);
    my $Klimit = @{$rLL} - 1;
    my @list;
    my $Kn = $Kbeg - 1;
    while ( ++$Kn <= $Klimit ) {

        my $type  = $rLL->[$Kn]->[_TYPE_];
        my $token = $rLL->[$Kn]->[_TOKEN_];

        next if ( $type eq 'b' );
        next if ( $type eq '#' );
        next if ( $token eq '(' );
        next if ( $token eq ')' );
        next if ( $token eq ',' );
        last if ( $type eq ';' );
        last if ( $token eq '}' );

        if ( $type eq 'q' ) {

            # qw list
            my ( $K_last_q, $rlist ) = $self->get_qw_list($Kn);
            return if ( !defined($K_last_q) );
            if ( $K_last_q > $Kn ) { $Kn = $K_last_q }
            push @list, @{$rlist};
        }
        elsif ( $type eq 'Q' ) {

            # single quoted word
            next if ( length($token) < 3 );
            my $name = substr( $token, 1, -1 );
            push @list, $name;
        }

        else {

            # Give up on anything else..
            # some examples where we have to quit:
            #  @EXPORT = Archive::Tar::Constant->_list_consts( __PACKAGE__ );
            #  @EXPORT = ( @CONSTANTS, qw( %ALL_CODESETS));
            #  @EXPORT = ( @{$EXPORT_TAGS{standard}}, ..
            return;
        }
    } ## end while ( ++$Kn <= $Klimit )
    return \@list;

} ## end sub expand_quoted_word_list

sub expand_EXPORT_list {
    my ( $self, $KK, $rhash ) = @_;

    # Given:
    #  $KK = index of variable @EXPORT or @EXPORT_OK
    #  $rhash = a hash to fill
    # Task:
    #  Update $rhash with any quoted words which follow any subsequent '='

    my $rLL = $self->[_rLL_];
    my $Kn  = $self->K_next_code($KK);

    # Require a following '='
    return unless ( $Kn && $rLL->[$Kn]->[_TYPE_] eq '=' );

    # Move to the next token
    $Kn = $self->K_next_code($Kn);
    return unless ($Kn);

    # Get any list
    my $rlist = $self->expand_quoted_word_list($Kn);
    return unless ($rlist);

    # Include the listed words in the hash
    foreach ( @{$rlist} ) { $rhash->{$_} = 1 }
    return;
} ## end sub expand_EXPORT_list

sub scan_variable_usage {

    my ( $self, ($roption) ) = @_;

    # Scan for unused and reused lexical variables in a single sweep.

    # Given:
    #   $roption = an optional set of types of checks,
    #              all checks are made if not given
    # Return:
    #   - nothing if no errors found
    #   - ref to a list of 'warnings', one per variable, in line order.
    #     Each list item is a hash of values describing the issue. These
    #     are stored in a list of hash refs, as follows:
    #        push @warnings,
    #          {
    #            name        => $name,        # name, such as '$var', '%data'
    #            line_number => $line_number, # line number where defined
    #            K           => $KK,          # index of token $name
    #            keyword     => $keyword,     # 'my', 'state', 'for', 'foreach'
    #            letter      => $letter,      # one of: r s p u
    #            note        => $note,        # additional text info
    #            see_line    => $see_line,    # line referenced in note
    #          };

    my $rLL                  = $self->[_rLL_];
    my $rlines               = $self->[_rlines_];
    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];
    my $ris_sub_block        = $self->[_ris_sub_block_];
    my $K_closing_container  = $self->[_K_closing_container_];

    # check for file without code (could be all pod or comments)
    return unless defined( $self->K_first_code() );

    # issues are indicated by these names:
    my %unusual_variable_issue_note = (
        c => "unused constant",
        p => "package crossing",
        r => "reused",
        s => "multi-sigil",
        u => "unused lexical",
    );

    # Default is to do all checks if no control hash received (dump mode)
    if ( !defined($roption) ) {
        foreach my $key ( keys %unusual_variable_issue_note ) {
            $roption->{$key} = 1;
        }
    }

    my $issue_type_string = "Issue types are";
    foreach my $letter ( reverse sort keys %unusual_variable_issue_note ) {
        next if ( !$roption->{$letter} );
        my $txt = $unusual_variable_issue_note{$letter};
        $issue_type_string .= " '$letter'=$txt";
    }

    # Unpack the control hash
    my $check_sigil         = $roption->{'s'};
    my $check_cross_package = $roption->{'p'};
    my $check_unused        = $roption->{'u'};
    my $check_reused        = $roption->{'r'};
    my $check_constant      = $roption->{'c'};

    my %is_valid_sigil = ( '$' => 1, '@' => 1, '%' => 1 );

    # Variables defining current state:
    my $current_package = 'main';

    # The basic idea of this routine is straightforward:
    # - We create a stack of block braces
    # - We walk through the tokens in the file
    # - At an opening block brace, we push a new stack entry
    # - At a closing block brace, we pop the stack,
    #     and check the count of any 'my' vars (issue 'u')
    # - At an identifier, like '$var':
    #   - if it follows a 'my' we enter it on the stack with starting count 0
    #     check conflicts with any other vars on the stack (issues 'r' and 's')
    #   - otherwise, we see if the variable is in the stack, and if so,
    #     update the count
    # - At a package, we see if it has access to existing 'my' vars (issue 'p')

    # There are lots of details, but that's the main idea. A difficulty is
    # when 'my' vars are created in the control section of blocks such as
    # for, foreach, if, unless, .. these follow special rules. The
    # way it is done here is to propagate such vars in a special control
    # layer stack entry which is pushed on just before these blocks.

    my $rblock_stack   = [];
    my $rconstant_hash = {};
    my $ruse_vars_hash = {};
    my $rEXPORT_hash   = {};

    #---------------------------------------
    # sub to push a block brace on the stack
    #---------------------------------------
    my $push_block_stack = sub {
        my ( $seqno, $rvars ) = @_;

        # push an entry for a new block onto the block stack:
        # Given:
        #  $seqno   = the sequence number of the code block
        #  $rvars   = hash of initial identifiers for the block, if given
        #             will be empty hash ref if not given
        if ( !defined($rvars) ) { $rvars = {} }

        push @{$rblock_stack},
          { seqno => $seqno, package => $current_package, rvars => $rvars };
        return;
    }; ## end $push_block_stack = sub

    $push_block_stack->(SEQ_ROOT);

    # $rhash holds all lexecal variables defined within a given block:
    #   $rhash->{
    #    $name => {
    #        count      => $count,
    #        line_index => $line_index,
    #        keyword    => $keyword,
    #        package    => $package,
    #        K          => $KK
    #    }
    #   };
    #   $name = the variable name, such as '$data', '@list', '%vars',
    #   $count =  number of uses
    #   $line_index = index of the line where it is defined
    #   $keyword = 'my' or 'state' or 'for' or 'foreach'
    #   $package = what package was in effect when it was defined
    #   $KK = token index (for sorting)

    # Variables for a batch of lexical vars being collected:
    my $my_keyword;                 # 'state' or 'my' keyword for this set
    my $K_end_my           = -1;    # max token index of this set
    my $in_signature_seqno = 0;     # true while scanning a signature
    my $my_starting_count  = 0;     # the initial token count for this set

    # Variables for warning messages:
    my @warnings;                   # array of warning messages
    my %package_warnings;           # warning messages for package cross-over
    my %sub_count_by_package;       # how many subs defined in a package

    # Variables for scanning interpolated quotes:
    my $ix_HERE_END = -1;         # the line index of the last here target read
    my $in_interpolated_quote;    # in multiline quote with interpolation?

    #-------------------------------------------------------
    # sub to check for overlapping usage, issues 'r' and 's'
    #-------------------------------------------------------
    my $check_for_overlapping_variables = sub {

        my ( $name, $KK ) = @_;

        # Given:
        #   $name = a variable with sigil, such as '$var', '%var', '@var';
        #   $KK   = index associated with this variable
        #   $line_index = index of line where this name first appears
        # Task:
        #   Create a warning if this overlaps a previously defined variable
        # Returns:
        #   true if error, variable is not of expected form with sigil
        #   false if no error

        my $sigil = EMPTY_STRING;
        my $word  = EMPTY_STRING;
        if ( $name =~ /^(\W+)(\w+)$/ ) {
            $sigil = $1;
            $word  = $2;
        }
        else {

            # give up, flag as error
            # could be something like '$' or '@' in a signature, or
            # for $Storable::downgrade_restricted (0, 1, ...
            return 1;
        }

        # Perform checks for reused names
        my @sigils_to_test;
        if ($check_sigil) {
            if ($check_reused) {
                @sigils_to_test = (qw( $ @ % ));
            }
            else {
                foreach my $sig (qw( $ @ % )) {
                    if ( $sig ne $sigil ) { push @sigils_to_test, $sig; }
                }
            }
        }
        elsif ($check_reused) {
            push @sigils_to_test, $sigil;
        }
        else {
            # neither
        }

        # See if this name has been seen, possibly with a different sigil
        if (@sigils_to_test) {

            # Look at stack and 'use vars' hash
            foreach
              my $item ( @{$rblock_stack}, $ruse_vars_hash->{$current_package} )
            {

                # distinguish between stack item and use vars item
                my $rhash = defined( $item->{seqno} ) ? $item->{rvars} : $item;

                foreach my $sig (@sigils_to_test) {
                    my $test_name = $sig . $word;

                    next unless ( $rhash->{$test_name} );
                    my $first_line = $rhash->{$test_name}->{line_index} + 1;
                    my $letter;
                    my $note;
                    my $see_line = 0;
                    if ( $sig eq $sigil ) {
                        my $as_iterator =
                          defined($my_keyword)
                          && ( $my_keyword eq 'for'
                            || $my_keyword eq 'foreach' )
                          ? ' as iterator'
                          : EMPTY_STRING;
                        $note   = "reused$as_iterator - see line $first_line";
                        $letter = 'r';
                    }
                    else {
                        $see_line = $first_line;
                        $note =
                          "overlaps $test_name in scope - see line $see_line";
                        $letter = 's';
                    }

                    my $line_index = $rLL->[$KK]->[_LINE_INDEX_];
                    push @warnings,
                      {
                        name        => $name,
                        keyword     => $my_keyword,
                        note        => $note,
                        see_line    => $see_line,
                        line_number => $line_index + 1,
                        letter      => $letter,
                        K           => $KK,
                      };
                    last;
                }
            }
        }
        return;
    }; ## end $check_for_overlapping_variables = sub

    #--------------------------------
    # sub to checkin a new identifier
    #--------------------------------
    my $checkin_new_lexical = sub {
        my ($KK) = @_;

        # Store the new identifier at index $KK

        my $name       = $rLL->[$KK]->[_TOKEN_];
        my $line_index = $rLL->[$KK]->[_LINE_INDEX_];

        # Special checks for signature variables
        if ($in_signature_seqno) {

            # must be in top signature layer
            my $parent = $self->parent_seqno_by_K($KK);
            return if ( $parent != $in_signature_seqno );

            # must be preceded by a comma or opening paren
            my $Kp = $self->K_previous_code($KK);
            return if ( !$Kp );
            my $token_p = $rLL->[$Kp]->[_TOKEN_];
            my $type_p  = $rLL->[$Kp]->[_TYPE_];
            return if ( $type_p ne ',' && $token_p ne '(' );
        }

        my $bad_name = $check_for_overlapping_variables->( $name, $KK );
        return if ($bad_name);

        # Store this lexical variable
        my $rhash = $rblock_stack->[-1]->{rvars};
        $rhash->{$name} = {
            count      => $my_starting_count,
            line_index => $line_index,
            keyword    => $my_keyword,
            package    => $current_package,
            K          => $KK,
        };
        return;
    }; ## end $checkin_new_lexical = sub

    #--------------------------------------------------
    # sub to update counts for a list of variable names
    #--------------------------------------------------
    my $update_use_count = sub {
        my ( $sigil_string, $word, $bracket ) = @_;

        # Given:
        #   $sigil_string = a string of leading sigils, like '$', '$$', '@$$'
        #   $word         = the following bareword
        #   $bracket      = a following array or hash bracket or brace, if any
        #                   (token types '[' and 'L')
        #   Note: any braces around the bareword must have been stripped
        #   by the caller
        # Task:
        #   Form the hash key ($word, @word, or %word) and update the count

        return unless ($check_unused);

        return unless ( defined($sigil_string) && defined($word) );

        my $sigil = substr( $sigil_string, -1, 1 );
        return unless ( $is_valid_sigil{$sigil} );

        # Examples:
        # input     => key
        # $var         $var
        # @var         @var
        # $var[        @var
        # $var{        %var
        # @$var        $var
        # ${var}       $var  (caller must remove the braces)
        # @$var[0..2]  $var
        # @var[0..2]   @var  array slice
        # @var{w1 w2}  %var  hash slice
        # %var{w1 w2}  %var  hash slice

        my $name;
        if ( $bracket && length($sigil_string) == 1 ) {
            if    ( $bracket eq '{' ) { $sigil = '%' }
            elsif ( $bracket eq '[' ) { $sigil = '@' }
            else                      { }
        }
        $name = $sigil . $word;

        foreach my $layer ( reverse( @{$rblock_stack} ) ) {
            my $rvars = $layer->{rvars};
            if ( $rvars->{$name} ) {
                $rvars->{$name}->{count}++;
                last;
            }
        }
        return;
    }; ## end $update_use_count = sub

    my $checkin_new_constant = sub {
        my ( $KK, $word ) = @_;
        my $line_index = $rLL->[$KK]->[_LINE_INDEX_];
        my $rvars      = {
            count      => 0,
            line_index => $line_index,
            package    => $current_package,
            K          => $KK,
        };
        $rconstant_hash->{$current_package}->{$word} = $rvars;
        return;
    }; ## end $checkin_new_constant = sub

    my $push_new_EXPORT = sub {
        my ( $KK, $package ) = @_;

        # Save index of any @EXPORT and @EXPORT_OK lists
        $package = $current_package unless ($package);
        push @{ $rEXPORT_hash->{$package} }, $KK;
        return;
    }; ## end $push_new_EXPORT = sub

    my $scan_use_vars = sub {
        my ($KK) = @_;
        my $Kn = $self->K_next_code($KK);
        return unless ($Kn);
        my $rlist = $self->expand_quoted_word_list($Kn);
        return unless ($rlist);
        my $line_index = $rLL->[$KK]->[_LINE_INDEX_];
        $my_keyword = 'use vars';
        foreach my $name ( @{$rlist} ) {
            my $bad_name = $check_for_overlapping_variables->( $name, $KK );
            next if ($bad_name);
            my $rvars = {
                line_index => $line_index,
                package    => $current_package,
                K          => $KK,
            };
            $ruse_vars_hash->{$current_package}->{$name} = $rvars;
        }
        return;
    }; ## end $scan_use_vars = sub

    my $scan_use_constant = sub {
        my ($KK) = @_;
        my $Kn = $self->K_next_code($KK);
        return unless ($Kn);
        my $type_n  = $rLL->[$Kn]->[_TYPE_];
        my $token_n = $rLL->[$Kn]->[_TOKEN_];

        # version?
        if ( $type_n eq 'n' || $type_n eq 'v' ) {
            $Kn      = $self->K_next_code($Kn);
            $type_n  = $rLL->[$Kn]->[_TYPE_];
            $token_n = $rLL->[$Kn]->[_TOKEN_];
        }

        if ( $token_n eq '(' ) {
            $Kn      = $self->K_next_code($Kn);
            $type_n  = $rLL->[$Kn]->[_TYPE_];
            $token_n = $rLL->[$Kn]->[_TOKEN_];
        }

        # use constant _meth1_=>1;
        if ( $type_n eq 'w' ) {
            $checkin_new_constant->( $Kn, $token_n );
        }

        # use constant '_meth1_',1;
        elsif ( $type_n eq 'Q' ) {

            # don't try to handle anything strange
            if ( length($token_n) < 3 ) { return }
            my $name = substr( $token_n, 1, -1 );
            $checkin_new_constant->( $Kn, $name );
        }

        # use constant qw(_meth2_ 2);
        elsif ( $type_n eq 'q' ) {
            my $name;
            if ( $token_n =~ /qw\s*.(\w+)/ ) {
                $name = $1;
                $checkin_new_constant->( $Kn, $name );
            }
        }

        # A hash ref with multiple definitions:
        # use constant { _meth3_=>3, _meth4_=>4};
        # use constant { '_meth3_',3, '_meth4_',4};
        elsif ( $type_n eq '{' && $token_n eq '{' ) {
            my $seqno_n = $rLL->[$Kn]->[_TYPE_SEQUENCE_];
            return unless $seqno_n;
            my $Kc = $self->[_K_closing_container_]->{$seqno_n};
            return unless $Kc;

            # loop to collect constants in hash ref
            my $Knn               = $self->K_next_code($Kn);
            my $total_comma_count = 0;
            my $last_type         = ',';
            my $level_start       = $rLL->[$Knn]->[_LEVEL_];

            foreach my $Kx ( $Knn .. $Kc - 1 ) {
                my $type  = $rLL->[$Kx]->[_TYPE_];
                my $token = $rLL->[$Kx]->[_TOKEN_];
                next if ( $type eq 'b' || $type eq '#' );
                my $level = $rLL->[$Kx]->[_LEVEL_];
                next if ( $level > $level_start );
                if ( $level < $level_start ) {
                    ## shouldn't happen
                    my $lno = $rLL->[$Kx]->[_LINE_INDEX_] + 1;
                    DEBUG_USE_CONSTANT
                      && Fault("$lno: level=$level > start=$level_start\n");
                    return;
                }
                if ( $last_type eq ',' && !( $total_comma_count % 2 ) ) {
                    if ( $type eq 'w' ) {
                        $checkin_new_constant->( $Kx, $token );
                    }
                    elsif ( $type eq 'Q' ) {
                        if ( length($token) < 3 ) { return }
                        my $name = substr( $token, 1, -1 );
                        $checkin_new_constant->( $Kx, $name );
                    }
                    else {
                        my $lno = $rLL->[$Kx]->[_LINE_INDEX_] + 1;
                        DEBUG_USE_CONSTANT
                          && Fault(
                            "$lno: unexpected type: type=$type token=$token\n");
                        return;
                    }
                }
                else {
                    if ( $type eq ',' || $type eq '=>' ) {
                        $total_comma_count++;
                    }
                }
                $last_type = $type;
            }
        }

        elsif ( $type_n eq ';' ) {

        }

        else {
            my $ln = $rLL->[$KK]->[_LINE_INDEX_] + 1;
            DEBUG_USE_CONSTANT && Fault("$ln: unknown use constant syntax\n");
        }
        return;
    }; ## end $scan_use_constant = sub

    my $update_constant_count = sub {
        my ( $KK, $word ) = @_;
        if ( !defined($word) ) { $word = $rLL->[$KK]->[_TOKEN_] }
        my $package = $current_package;
        my $pos     = rindex( $word, '::' );
        if ( $pos >= 0 ) {
            $package = $pos > 0 ? substr( $word, 0, $pos ) : 'main';
            $word    = substr( $word, $pos + 2 );
        }
        return if ( !defined( $rconstant_hash->{$package} ) );
        my $rvars = $rconstant_hash->{$package}->{$word};
        return if ( !defined($rvars) );
        return if ( $KK <= $rvars->{K} );
        $rvars->{count}++;
        return;
    }; ## end $update_constant_count = sub

    #-----------------------------------------------
    # sub to check for zero counts when stack closes
    #-----------------------------------------------
    my $check_for_unused_names = sub {
        my ($rhash) = @_;
        foreach my $name ( keys %{$rhash} ) {
            my $entry   = $rhash->{$name};
            my $count   = $entry->{count};
            my $keyword = $entry->{keyword};

            if ( !$count ) {

                # typically global vars are for external access so we
                # do not report them as type 'u' (unused)
                next if ( $keyword eq 'our' || $keyword eq 'use vars' );

                push @warnings,
                  {
                    name        => $name,
                    keyword     => $entry->{keyword},
                    note        => EMPTY_STRING,
                    see_line    => 0,
                    line_number => $entry->{line_index} + 1,
                    letter      => 'u',
                    K           => $entry->{K},
                  };
            }
        }
        return;
    }; ## end $check_for_unused_names = sub

    #---------------------------------------
    # sub to scan interpolated text for vars
    #---------------------------------------
    my $scan_quoted_text = sub {
        my ($text) = @_;
        return unless ($check_unused);

        # Looking for something like $word, @word, $word[, $$word, ${word}, ..
        while ( $text =~ / ([\$\@]  [\$]*) \{?(\w+)\}? ([\[\{]?) /gcx ) {
            ##              ------1------      -2-      ---3---
            my $sigil_string = $1;
            my $word         = $2;
            my $brace        = $3;
            $update_use_count->( $sigil_string, $word, $brace );
        } ## end while ( $text =~ ...)
        return;
    }; ## end $scan_quoted_text = sub

    #-------------------------------------------------------------
    # sub to find the next opening brace seqno of an if-elsif- chain
    #-------------------------------------------------------------
    my $push_next_if_chain = sub {
        my ( $KK, $rpopped_vars ) = @_;

        # Given:
        #   $KK = index of a closing block brace of if/unless/elsif chain
        #   $rpopped_vars = values just popped off the stack
        # Task:
        #   - do nothing if chain ends, or
        #   - push $rpopped_vars onto the next block in the chain

        #  $seqno_block = sequence number of next opening block in the chain,
        my $seqno_block;
        my $K_n = $self->K_next_code($KK);
        return unless ($K_n);
        return unless ( $rLL->[$K_n]->[_TYPE_] eq 'k' );

        # For an 'elsif' the brace will be after the closing paren
        #         'elsif (..) { ... }'
        #           ^         ^
        #           |         |
        #           --$KK     --$seqno of brace that we want
        #
        if ( $rLL->[$K_n]->[_TOKEN_] eq 'elsif' ) {
            ( $seqno_block, my $K_last_iterator_uu ) =
              $self->block_seqno_of_paren_keyword($K_n);
        }

        # For an 'else' the brace will be the next token
        #         'else   { ... }'
        #          ^      ^
        #          |      |
        #          --$KK  --$seqno of brace that we want
        #
        elsif ( $rLL->[$K_n]->[_TOKEN_] eq 'else' ) {
            my $K_nn = $self->K_next_code($K_n);
            if (   $K_nn
                && $is_opening_token{ $rLL->[$K_nn]->[_TOKEN_] } )
            {
                $seqno_block = $rLL->[$K_nn]->[_TYPE_SEQUENCE_];
            }
        }

        else {
            # chain ends if no elsif/else block
        }

        if (   $seqno_block
            && $rblock_type_of_seqno->{$seqno_block} )
        {
            $push_block_stack->( $seqno_block, $rpopped_vars );
        }
        return;
    }; ## end $push_next_if_chain = sub

    my $scan_braced_id = sub {
        my ($KK) = @_;

        # We are at an opening brace and looking for something like this:
        #   @{word}[@var]
        #   ${word}
        #    ^
        #    |
        #    -- $KK

        return unless ($check_unused);

        # Look back for the sigil
        my $Kp = $self->K_previous_code($KK);

        return unless ( defined($Kp) && $rLL->[$Kp]->[_TYPE_] eq 't' );
        my $sigil_string = $rLL->[$Kp]->[_TOKEN_];

        # Look forward for the bareword
        my $Kn = $self->K_next_code($KK);
        return unless ( defined($Kn) && $rLL->[$Kn]->[_TYPE_] eq 'w' );
        my $word = $rLL->[$Kn]->[_TOKEN_];

        # Look forward for the closing brace
        my $Knn = $self->K_next_code($Kn);
        return unless ( defined($Knn) && $rLL->[$Knn]->[_TYPE_] eq 'R' );

        # Look forward for a possible { or [
        my $bracket;
        my $Knnn = $self->K_next_code($Knn);
        if ( defined($Knnn) ) {
            my $next_type = $rLL->[$Knnn]->[_TYPE_];
            if ( $next_type eq 'L' || $next_type eq '[' ) {
                $bracket = $rLL->[$Knnn]->[_TOKEN_];
            }
        }
        $update_use_count->( $sigil_string, $word, $bracket );
        return;
    }; ## end $scan_braced_id = sub

    my $check_sub_signature = sub {
        my ($KK) = @_;

        # looking for a sub signature
        #    sub xxx (...) {
        #    -------
        #          | |   | |
        #        $KK $Kn | |
        #                  $K_opening_brace

        # Note: this version cannot handle signatures within signatures.
        # Inner signatures are currently ignored. For example, only the
        # outermost $a below will be checked in this line:

        #  sub xyz ($a = sub ($a) { $a."z" }) { $a->("a")."y" }

        # What happens is that variable $K_end_my is set by the first
        # signature, and the second signature is within it and so does
        # not get activated. A stack scheme would be necessary to handle
        # this, but does not seem necessary because this probably only
        # occurs in test code, and the only downside is that we limit
        # some checking.

        my $Kn = $self->K_next_code($KK);
        return unless ( $rLL->[$Kn]->[_TOKEN_] eq '(' );
        my $seqno_paren = $rLL->[$Kn]->[_TYPE_SEQUENCE_];
        return unless ($seqno_paren);
        my $K_closing_paren = $self->[_K_closing_container_]->{$seqno_paren};
        my $K_opening_brace = $self->K_next_code($K_closing_paren);
        return unless ($K_opening_brace);
        my $seqno_brace = $rLL->[$K_opening_brace]->[_TYPE_SEQUENCE_];
        my $token_brace = $rLL->[$K_opening_brace]->[_TOKEN_];
        return unless ( $seqno_brace && $token_brace eq '{' );

        # Treat signature variables like my variables
        # Create special block on the stack..see note above for
        # $is_if_unless
        if ( $K_opening_brace > $K_end_my ) {
            $K_end_my           = $K_opening_brace;
            $my_keyword         = 'sub signature';
            $in_signature_seqno = $seqno_paren;
            $push_block_stack->($seqno_brace);
        }
        return;
    }; ## end $check_sub_signature = sub

    my $rkeyword_count   = {};
    my $rline_type_count = {};

    #--------------------
    # Loop over all lines
    #--------------------
    my $ix_line = -1;
    foreach my $line_of_tokens ( @{$rlines} ) {
        $ix_line++;
        my $line_type = $line_of_tokens->{_line_type};
        if ( $line_type ne 'CODE' ) {
            $rline_type_count->{$line_type}++;
            next;
        }

        my ( $Kfirst, $Klast ) = @{ $line_of_tokens->{_rK_range} };
        next unless defined($Kfirst);

        #----------------------------------
        # Loop over all tokens on this line
        #----------------------------------
        foreach my $KK ( $Kfirst .. $Klast ) {
            my $type = $rLL->[$KK]->[_TYPE_];
            next if ( $type eq 'b' || $type eq '#' );
            my $token = $rLL->[$KK]->[_TOKEN_];
            my $seqno = $rLL->[$KK]->[_TYPE_SEQUENCE_];

            if ($seqno) {
                my $block_type;
                $block_type = $rblock_type_of_seqno->{$seqno} if ($seqno);

                my $is_on_stack = ( $seqno == $rblock_stack->[-1]->{seqno} );

                if ( $is_opening_token{$token} ) {

                    # always push a block
                    if ($block_type) {

                        # exit signature if we will push a duplicate block
                        if (   $in_signature_seqno
                            && @{$rblock_stack}
                            && $seqno == $rblock_stack->[-1]->{seqno} )
                        {
                            $in_signature_seqno = 0;
                        }

                        $push_block_stack->($seqno);

                        # update sub count for cross-package checks
                        if ( $ris_sub_block->{$seqno} ) {
                            $sub_count_by_package{$current_package}++;
                        }
                    }

                    # look for something like @{word} etc
                    if ( $type eq 'L' ) {
                        $scan_braced_id->($KK);
                    }
                }

                elsif ( $is_closing_token{$token} ) {

                    # always pop the stack if this token is on the stack
                    if ($is_on_stack) {
                        my $stack_item   = pop @{$rblock_stack};
                        my $rpopped_vars = $stack_item->{rvars};

                        # if we popped a block token
                        if ($block_type) {

                            # the current package gets updated at a block end
                            $current_package = $stack_item->{package};

                            # Check for unused vars if requested
                            if ( $check_unused && $rpopped_vars ) {
                                $check_for_unused_names->($rpopped_vars);
                            }

                            # Check for and propagate an if-chain control layer,
                            # which will have the same seqno.
                            if ( @{$rblock_stack}
                                && $seqno == $rblock_stack->[-1]->{seqno} )
                            {

                                # pop again
                                $stack_item   = pop @{$rblock_stack};
                                $rpopped_vars = $stack_item->{rvars};

                                # Check unused vars
                                # - except for vars in an if-chain control layer
                                #   because they are involved in logic
                                if (   $check_unused
                                    && $rpopped_vars
                                    && !$is_if_unless_elsif_else{$block_type} )
                                {
                                    $check_for_unused_names->($rpopped_vars);
                                }

                                # propagate control layer along if chain
                                if ( $is_if_unless_elsif{$block_type} ) {
                                    $push_next_if_chain->( $KK, $rpopped_vars );
                                }
                            }
                        }

                        # error if we just popped a non-block token:
                        else {
                            my $K_n     = $self->K_next_code($KK);
                            my $token_n = $rLL->[$K_n]->[_TOKEN_];
                            my $lno     = $ix_line + 1;
                            DEVEL_MODE && Fault(<<EOM);
Non-block closing token '$token' on stack followed by token $token_n at line $lno
Expecting to find an opening token here.
EOM
                        }
                    }

                    # if not on the stack: error if this is a block
                    elsif ($block_type) {
                        my $lno         = $ix_line + 1;
                        my $stack_seqno = $rblock_stack->[-1]->{seqno};
                        DEVEL_MODE
                          && Fault(
"stack error: seqno=$seqno ne $stack_seqno near line $lno\n"
                          );

                        # give up - file may be unbalanced
                        return;
                    }
                    else {
                        # not a block, not on stack: nothing to do
                    }
                }
                else {
                    # ternary
                }
            }

            #----------
            # a keyword
            #----------
            elsif ( $type eq 'k' ) {

                #----------------------------------------------
                # look for lexical keyword 'my', 'state', 'our'
                #----------------------------------------------
                if ( $is_my_state_our{$token} ) {
                    $my_keyword = $token;

                    # Set '$K_end_my' to be the last $K index of the variables
                    # controlled by this 'my' keyword
                    my $Kn = $self->K_next_code($KK);
                    $K_end_my = $Kn;
                    if ( $Kn && $rLL->[$Kn]->[_TOKEN_] eq '(' ) {
                        my $seqno_next = $rLL->[$Kn]->[_TYPE_SEQUENCE_];
                        $K_end_my = $K_closing_container->{$seqno_next};
                    }

                    # Get initial count
                    $my_starting_count = 0;
                    my $K_last_code = $self->K_previous_code($KK);
                    if ( defined($K_last_code) ) {
                        my $last_type = $rLL->[$K_last_code]->[_TYPE_];

                        # A preceding \ implies that this memory can be used
                        # even if the variable name does not appear again.
                        # For example: return \my $string_buf;
                        if ( $last_type eq '\\' ) { $my_starting_count = 1 }
                    }
                }

                #--------------------------------------------------
                # look for certain keywords which introduce blocks:
                # such as 'for my $var (..) { ... }'
                #--------------------------------------------------
                elsif ( $is_if_unless_while_until_for_foreach{$token} ) {
                    my ( $seqno_brace, $K_end_iterator ) =
                      $self->block_seqno_of_paren_keyword($KK);
                    if ($seqno_brace) {

                        # Found the brace. Mark an iterator as a new lexical
                        # variable in order to catch something like:
                        #    my $i;
                        #    foreach $i(...) { }
                        # where the iterator $i is not the same as the first
                        # $i, We should be beyond any existing $K_end_my, but
                        # check anyway:
                        if ( $K_end_iterator && $K_end_iterator > $K_end_my ) {
                            $K_end_my   = $K_end_iterator;
                            $my_keyword = $token;
                        }

                        # Variables created between these keywords and their
                        # opening brace have special scope rules. We will
                        # create a special 'control layer' stack entry for them
                        # here, with the same block sequence number.  When the
                        # closing block brace arrives, it will look for a
                        # duplicate stack entry and either close it or,
                        # for if-elsif-else chain, propagate it onward.
                        $push_block_stack->($seqno_brace);
                    }
                }
                elsif ( $token eq 'sub' ) {
                    $check_sub_signature->($KK);
                }
                else {
                    $rkeyword_count->{$token}++;
                }
            }

            #--------------
            # an identifier
            #--------------
            elsif ( $type eq 'i' || $type eq 'Z' ) {

                # Still collecting 'my' vars?
                if ( $KK <= $K_end_my ) {
                    $checkin_new_lexical->($KK);
                }

                # Not collecting 'my' vars - update counts
                elsif ( $check_unused || $check_constant ) {

                    my $sigil_string = EMPTY_STRING;
                    my $word         = EMPTY_STRING;

                    # The regex below will match numbers, like '$34x', but that
                    # should not be a problem because it will not match a hash
                    # key.
                    if ( $token =~ /^(\W+)?(\w.*)$/ ) {
                        $sigil_string = $1 if ($1);
                        $word         = $2;

                        if ( $check_constant && $word ) {

                            # look for constant invoked like '&ORD' or '->ORD'
                            if ( !$sigil_string || $sigil_string eq '&' ) {
                                $update_constant_count->( $KK, $word );
                            }
                            elsif ( $sigil_string eq '@'
                                && index( $word, 'EXPORT' ) >= 0 )
                            {
                                # Looking for stuff like:
                                #   @EXPORT_OK
                                #   @ALPHA::BETA::EXPORT
                                my $package = $current_package;
                                my $name    = $word;
                                my $pos     = rindex( $word, '::' );
                                if ( $pos >= 0 ) {
                                    $package = substr( $word, 0, $pos );
                                    $name    = substr( $word, $pos + 2 );
                                }
                                if ( $name eq 'EXPORT' || $name eq 'EXPORT_OK' )
                                {
                                    $push_new_EXPORT->( $KK, $package );
                                }
                            }
                            else { }
                        }

                        if ($sigil_string) {
                            my $sigil = substr( $sigil_string, -1, 1 );
                            if ( !$is_valid_sigil{$sigil} ) {
                                $sigil_string = EMPTY_STRING;
                                $word         = EMPTY_STRING;
                            }
                        }
                    }

                    if (   $check_unused
                        && $sigil_string
                        && $word
                        && $word =~ /\w+/ )
                    {

                        my $Kn = $self->K_next_code($KK);
                        my $bracket;
                        if ( defined($Kn) ) {
                            my $next_type = $rLL->[$Kn]->[_TYPE_];
                            if ( $next_type eq '[' || $next_type eq 'L' ) {
                                $bracket = $rLL->[$Kn]->[_TOKEN_];
                            }
                        }
                        $update_use_count->( $sigil_string, $word, $bracket );
                    }
                }
                else {
                    # ignore variable if not collecting 'my' or counts
                }
            }

            #----------------
            # a sub statement
            #----------------
            elsif ( $type eq 'S' ) {
                $check_sub_signature->($KK);
            }

            #--------------------
            # a package statement
            #--------------------
            elsif ( $type eq 'P' ) {
                my ( $keyword, $package ) = split /\s+/, $token, 2;

                # keyword 'package' may be on a previous line
                if ( !$package ) { $package = $keyword }

                if ( $package ne $current_package ) {
                    $current_package = $package;

                    # Look for lexical vars declared in other packages which
                    # will be accessible in this package. We will limit
                    # this check to new package statements at the top level
                    # in order to filter out some common cases.
                    if ( $check_cross_package && @{$rblock_stack} == 1 ) {
                        my $rpackage_warnings = $package_warnings{$package};
                        if ( !defined($rpackage_warnings) ) {
                            $rpackage_warnings = [];
                            $package_warnings{$package} = $rpackage_warnings;
                        }
                        foreach my $item ( @{$rblock_stack} ) {
                            my $rhash = $item->{rvars};
                            foreach my $name ( keys %{$rhash} ) {
                                my $entry = $rhash->{$name};
                                my $pkg   = $entry->{package};
                                if ( $pkg ne $package ) {
                                    my $lno      = $ix_line + 1;
                                    my $see_line = $lno;
                                    my $note =
"is accessible in later packages, see line $see_line";
                                    push @{$rpackage_warnings},
                                      {
                                        name        => $name,
                                        keyword     => $entry->{keyword},
                                        note        => $note,
                                        see_line    => $see_line,
                                        line_number => $entry->{line_index} + 1,
                                        letter      => 'p',
                                        K           => $entry->{K},
                                      };
                                }
                            }
                        }
                    }
                }
            }

            #-----------
            # a here doc
            #-----------
            elsif ( $type eq 'h' ) {

                # scan here-doc if it is interpolated
                if ( $check_unused && is_interpolated_here_doc($token) ) {
                    my $ix_HERE = max( $ix_HERE_END, $ix_line );

                    # collect the here doc text
                    ( $ix_HERE_END, my $here_text ) =
                      $self->get_here_text($ix_HERE);

                    # scan the here-doc text
                    $scan_quoted_text->($here_text);
                }
            }

            #---------------------
            # a quote of some type
            #---------------------
            elsif ( $type eq 'Q' ) {

                # is this an interpolated quote?
                my $interpolated;
                if ( $KK == $Kfirst && $line_of_tokens->{_starting_in_quote} ) {
                    $interpolated = $in_interpolated_quote;
                }
                else {

                    # is interpolated if it follow a match operator =~ or !~
                    my $K_last_code = $self->K_previous_code($KK);
                    if (   $K_last_code
                        && $is_re_match_op{ $rLL->[$K_last_code]->[_TYPE_] } )
                    {
                        $interpolated = 1;
                    }

                    # is not interpolated for leading operators: qw q tr y '
                    elsif ( $token =~ /^(qw | q[^qrx] | tr | [y\'] )/x ) {
                        $interpolated = 0;
                    }

                    # is interpolated for everything else
                    else {
                        $interpolated = 1;
                    }
                }

                if ($interpolated) {
                    $scan_quoted_text->($token);
                }

                if ( $KK == $Klast && $line_of_tokens->{_ending_in_quote} ) {
                    $in_interpolated_quote = $interpolated;
                }
                else {
                    $in_interpolated_quote = 0;
                }
            }
            elsif ( $type eq 'w' ) {
                if ( $token eq 'vars' ) {
                    my $Kp = $self->K_previous_code($KK);
                    if (   defined($Kp)
                        && $rLL->[$Kp]->[_TOKEN_] eq 'use'
                        && $rLL->[$Kp]->[_TYPE_] eq 'k' )
                    {
                        $scan_use_vars->($KK);
                    }
                }
                if ($check_constant) {
                    if ( $token eq 'constant' ) {
                        my $Kp = $self->K_previous_code($KK);
                        if (   defined($Kp)
                            && $rLL->[$Kp]->[_TOKEN_] eq 'use'
                            && $rLL->[$Kp]->[_TYPE_] eq 'k' )
                        {
                            $scan_use_constant->($KK);
                        }
                        else {
                            $update_constant_count->($KK);
                        }
                    }
                    else {
                        $update_constant_count->($KK);
                    }
                }
            }
            elsif ( $type eq 'C' ) {
                if ($check_constant) {
                    $update_constant_count->($KK);
                }
            }
            elsif ( $type eq 'U' ) {
                if ($check_constant) {
                    $update_constant_count->($KK);
                }
            }
            else {
                # skip all other token types
            }
        }
    }

    #----------
    # Finish up
    #----------

    # skip final 'c' and 'u' output if this appears to be a snippet
    my $is_possible_snippet = $roption->{is_possible_snippet};
    my $more_u_checks =
         $check_unused
      && @{$rblock_stack} == 1
      && keys %{ $rblock_stack->[0]->{rvars} };
    my $more_c_checks = $check_constant && keys %{$rconstant_hash};

    if ( $is_possible_snippet
        && ( $more_u_checks || $more_c_checks ) )
    {

        # the flag $is_possible_snippet = 0:No  1:Uncertain   2:Yes
        if (   $is_possible_snippet == 1
            && $self->is_complete_script( $rline_type_count, $rkeyword_count ) )
        {
            # not a snippet
        }

        # is possible snippet: deactivate 'c' and 'u
        else {
            $check_unused   = 0;
            $check_constant = 0;
        }
    }

    if ( @{$rblock_stack} != 1 ) {

        # shouldn't happen for a balanced input file
        DEVEL_MODE && Fault("stack error at end of scan\n");
    }
    else {
        if ($check_unused) {
            foreach my $item ( @{$rblock_stack} ) {
                my $rhash = $item->{rvars};
                $check_for_unused_names->($rhash);
            }
        }
    }

    if ($check_constant) {
        my @warnings_c;
        my %packages_with_warnings;
        foreach my $package ( keys %{$rconstant_hash} ) {
            my $rhash = $rconstant_hash->{$package};
            next if ( !defined($rhash) );
            foreach my $name ( keys %{$rhash} ) {
                my $entry = $rconstant_hash->{$package}->{$name};
                next if ( $entry->{count} );
                push @warnings_c,
                  {
                    name        => $name,
                    keyword     => 'use constant',
                    see_line    => EMPTY_STRING,
                    note        => "appears unused in package $package",
                    line_number => $entry->{line_index} + 1,
                    letter      => 'c',
                    package     => $package,
                    K           => $entry->{K},
                  };
                $packages_with_warnings{$package} = 1;
            }
        }

        # filter out constants found in @EXPORT and @EXPORT_OK
        if (@warnings_c) {

            # expand relevant EXPORT lists
            my $rEXPORT_words_by_package = {};
            foreach my $package ( keys %packages_with_warnings ) {
                my $rKlist = $rEXPORT_hash->{$package};
                next unless ($rKlist);
                $rEXPORT_words_by_package->{$package} = {};
                foreach my $KK ( @{$rKlist} ) {
                    $self->expand_EXPORT_list( $KK,
                        $rEXPORT_words_by_package->{$package} );
                }
            }

            # remove warnings in EXPORT lists
            foreach my $rwarning (@warnings_c) {
                my $package = $rwarning->{package};
                my $name    = $rwarning->{name};
                my $rhash   = $rEXPORT_words_by_package->{$package};
                next if ( $rhash && $rhash->{$name} );
                push @warnings, $rwarning;
            }
        }
    }

    # Merge package issues...
    # Only include cross-package warnings for packages which created subs.
    # This will limit this type of warning to significant package changes.
    my @p_warnings;
    foreach my $key ( keys %package_warnings ) {
        next if ( !$sub_count_by_package{$key} );
        push @p_warnings, @{ $package_warnings{$key} };
    }

    # Remove duplicate package warnings for the same initial line, which can
    # happen if there were multiple packages.
    if (@p_warnings) {
        my %seen;

        # sort on package warning line order
        @p_warnings = sort { $a->{see_line} <=> $b->{see_line} } @p_warnings;

        # use first package warning for a given variable
        foreach my $item (@p_warnings) {
            my $key = $item->{line_number} . ':' . $item->{name};
            next if ( $seen{$key}++ );
            push @warnings, $item;
        }
    }

    if (@warnings) {

        # filter out certain common 'our' variables from all warnings
        #  because they are common and difficult to fix, and
        # sort on token index and issue type

        my %is_exempted_global_name;
        my @q = qw( $VERSION @EXPORT @EXPORT_OK %EXPORT_TAGS @ISA $AUTOLOAD );
        @is_exempted_global_name{@q} = (1) x scalar(@q);

        @warnings =
          sort { $a->{K} <=> $b->{K} || $a->{letter} cmp $b->{letter} }

          # FIXME: this limitation may eventually just be for 'our' vars
          # after 'use vars' coding is finalized
          grep {
            ( $_->{keyword} ne 'our' && $_->{keyword} ne 'use vars' )
              || !$is_exempted_global_name{ $_->{name} }
          } @warnings;
    }

    return ( \@warnings, $issue_type_string );
} ## end sub scan_variable_usage

sub dump_unusual_variables {
    my ($self) = @_;

    # process a --dump-unusual-variables(-duv) command

    my ( $rlines, $issue_type_string ) = $self->scan_variable_usage();
    return unless ( $rlines && @{$rlines} );

    my $input_stream_name = get_input_stream_name();

    # output for multiple types
    my $output_string = <<EOM;
$input_stream_name: output for --dump-unusual-variables
$issue_type_string
Line:Issue: Var: note
EOM
    foreach my $item ( @{$rlines} ) {
        my $lno     = $item->{line_number};
        my $letter  = $item->{letter};
        my $keyword = $item->{keyword};
        my $name    = $item->{name};
        my $note    = $item->{note};
        if ($note) { $note = ": $note" }
        $output_string .= "$lno:$letter: $keyword $name$note\n";
    }
    print {*STDOUT} $output_string;

    return;
} ## end sub dump_unusual_variables

sub initialize_warn_hash {
    my ( $long_name, $default, $rall_opts ) = @_;

    # Given:
    #   $long_name   = full option name
    #   $default     = default value
    #   $rall_opts   = all possible options
    # Return the corresponding option hash

    # Example of all possible options for --warn-variable-types=s
    #  r - reused scope
    #  s - reused sigil
    #  p - package boundaries crossed by lexical variables
    #  u - unused lexical variable defined by my, state, our
    #  c - unused constant defined by use constant

    # Other warn options use different letters

    # Other controls:
    #  0 - none of the above
    #  1 - all of the above
    #  * - all of the above

    # Example:
    #  -wvt='s r'  : do check types 's' and 'r'

    my $rwarn_hash = {};

    if ( !$rall_opts || !@{$rall_opts} ) {
        Fault("all_options is empty for call with option $long_name\n");
        return $rwarn_hash;
    }

    my $user_option_string = $rOpts->{$long_name};
    if ( !defined($user_option_string) ) { $user_option_string = $default }
    return $rwarn_hash unless ($user_option_string);

    my %is_valid_option;
    @is_valid_option{ @{$rall_opts} } = (1) x scalar( @{$rall_opts} );

    # allow comma separators
    $user_option_string =~ s/,/ /g;

    my @opts = split_words($user_option_string);
    return $rwarn_hash unless (@opts);

    # check a single item
    if ( @opts == 1 ) {
        my $opt = $opts[0];

        # Split a single option of bundled letters like 'rsp' into 'r s p'
        # but give a warning because this may not be allowed in the future
        if ( length($opt) > 1 ) {
            @opts = split //, $opt;
            Warn("Please use space-separated letters in --$long_name\n");
        }
        elsif ( $opt eq '*' || $opt eq '1' ) {
            @opts = keys %is_valid_option;
        }
        elsif ( $opt eq '0' ) {
            return $rwarn_hash;
        }
        else {
            # should be one of the allowed letters - catch any error below
        }
    }

    my $msg = EMPTY_STRING;
    foreach my $opt (@opts) {
        if ( $is_valid_option{$opt} ) {
            $rwarn_hash->{$opt} = 1;
            next;
        }

        # invalid option..
        if ( $opt =~ /^[01\*]$/ ) {
            $msg .=
              "--$long_name cannot contain $opt mixed with other options\n";
        }
        else {
            $msg .= "--$long_name has unexpected symbol: '$opt'\n";
        }
    }
    if ($msg) { Die($msg) }
    return $rwarn_hash;
} ## end sub initialize_warn_hash

sub make_excluded_name_hash {
    my ($option_name) = @_;

    # Convert a list of words into a hash ref for an input option
    # Given:
    #   $option_name = the name of an input option
    #       example:   'warn-variable-exclusion-list'
    my $rexcluded_name_hash = {};
    my $excluded_names      = $rOpts->{$option_name};
    if ($excluded_names) {
        $excluded_names =~ s/,/ /g;
        my @xl      = split_words($excluded_names);
        my $err_msg = EMPTY_STRING;
        foreach my $name (@xl) {
            if ( $name =~ /^([\$\@\%\*])?(\w+)?(\*)?$/ ) {
                my $left_star  = $1;
                my $key        = $2;
                my $right_star = $3;
                if ( defined($left_star) ) {
                    if ( $left_star ne '*' ) {
                        if ( defined($key) ) {

                            # append sigil to the bareword
                            $key = $left_star . $key;
                        }
                        else {

                            # word not given: '$*' is ok but just '$' is not
                            if ($right_star) { $key = $left_star }
                        }
                        $left_star = EMPTY_STRING;
                    }
                }

                # Wildcard matching codes:
                # 1 = no stars
                # 2 = left star only
                # 3 = right star only
                # 4 = both left and right stars
                my $code = 1;
                $code += 1 if ($left_star);
                $code += 2 if ($right_star);
                if ( !defined($key) ) {
                    $err_msg .= "--$option_name has unexpected name: '$name'\n";
                }
                else {
                    $rexcluded_name_hash->{$key} = $code;
                }
            }
            else {
                $err_msg .= "--$option_name has unexpected name: '$name'\n";
            }
        }
        if ($err_msg) { Die($err_msg) }
    }
    return $rexcluded_name_hash;
} ## end sub make_excluded_name_hash

sub wildcard_match {

    my ( $name, $rwildcard_match_list ) = @_;

    # Given:
    #    $name = a string to test for a match
    #    $rwildcard_match_list = a list of [key,code] pairs:
    #        key  = a string to match
    #        code = 2, 3, or 4 is match type (see comments below)
    # Return:
    #    true for a match
    #    false for no match

    # For example, key='$pack' with code=3 is short for '$pack*'
    # which will match '$package', '$packer', etc

    # Loop over all possible matches
    foreach ( @{$rwildcard_match_list} ) {
        my ( $key, $code ) = @{$_};
        my $len_key  = length($key);
        my $len_name = length($name);
        next if ( $len_name < $len_key );

        # code 2 = left star only
        if ( $code == 2 ) {
            if ( substr( $name, -$len_key, $len_key ) eq $key ) { return 1 }
        }

        # code 3 = right star only
        elsif ( $code == 3 ) {
            if ( substr( $name, 0, $len_key ) eq $key ) { return 1 }
        }

        # code 4 = both left and right stars
        elsif ( $code == 4 ) {
            if ( index( $name, $key, 0 ) >= 0 ) { return 1 }
        }
        else {
            DEVEL_MODE && Fault("unexpected code '$code' for '$name'\n");
        }
    }
    return;
} ## end sub wildcard_match

sub initialize_warn_variable_types {

    my ( $wvt_in_args, $num_files, $line_range_clipped ) = @_;

    # Initialization for:
    #    --warn-variable-types=s and
    #    --warn-variable-exclusion-list=s
    # Given:
    #   $wvt_in_args = true if the -wvt parameter was on the command line
    #   $num_files = number of files on the command line
    #   $line_range_clipped = true if only part of a file is being formatted

    my @all_opts = qw( r s p u c );
    $rwarn_variable_types =
      initialize_warn_hash( 'warn-variable-types', 0, \@all_opts );

    # Check for issues 'u' or 'c' cannot be fully made if we are working
    # on a partial file (snippet), so we save info about that.
    if ( $rwarn_variable_types->{u} || $rwarn_variable_types->{c} ) {

        # Three value switch: 0=NO, 1=MAYBE 2=DEFINITELY
        my $is_possible_snippet = 1;

        # assume snippet if incomplete line range is being formatted
        if ($line_range_clipped) {
            $is_possible_snippet = 2;
        }

        # assume complete script if operating on multiple files or if
        # operating on one file and -wvt came in on the command line
        if ( $is_possible_snippet == 1 && $num_files ) {
            if ( $num_files > 1 || $wvt_in_args && $num_files ) {
                $is_possible_snippet = 0;
            }
        }

        $rwarn_variable_types->{is_possible_snippet} = $is_possible_snippet;
    }

    $ris_warn_variable_excluded_name =
      make_excluded_name_hash('warn-variable-exclusion-list');
    return;
} ## end sub initialize_warn_variable_types

sub filter_excluded_names {

    my ( $rwarnings, $rexcluded_name_hash ) = @_;

    # Remove warnings for variable names excluded by user request
    # for an operation like --warn-variable-types

    # Given:
    #   $rwarnigns = ref to list of warning info hashes
    #   $rexcluded_name_hash = ref to hash with excluded names
    # Return updated $rwarnings with excluded names removed
    if ( @{$rwarnings} && $rexcluded_name_hash ) {

        # Check for exact matches
        $rwarnings =
          [ grep { !$rexcluded_name_hash->{ $_->{name} } } @{$rwarnings} ];

        # See if there are any wildcard names
        my @excluded_wildcards;
        foreach my $key ( keys %{$rexcluded_name_hash} ) {
            my $code = $rexcluded_name_hash->{$key};
            if ( $code != 1 ) {
                push @excluded_wildcards, [ $key, $code ];
            }
        }

        if (@excluded_wildcards) {
            my @tmp;
            foreach my $item ( @{$rwarnings} ) {
                my $name = $item->{name};
                if ( wildcard_match( $name, \@excluded_wildcards ) ) {
                    next;
                }
                push @tmp, $item;
            }
            $rwarnings = \@tmp;
        }
    }
    return $rwarnings;
} ## end sub filter_excluded_names

sub warn_variable_types {
    my ($self) = @_;

    # process a --warn-variable-types command

    my $wv_key    = 'warn-variable-types';
    my $wv_option = $rOpts->{$wv_key};
    return unless ( %{$rwarn_variable_types} );

    my ( $rwarnings, $issue_type_string ) =
      $self->scan_variable_usage($rwarn_variable_types);
    return unless ( $rwarnings && @{$rwarnings} );

    $rwarnings =
      filter_excluded_names( $rwarnings, $ris_warn_variable_excluded_name );

    # loop to form error messages
    my $message_middle = EMPTY_STRING;
    foreach my $item ( @{$rwarnings} ) {
        my $name    = $item->{name};
        my $lno     = $item->{line_number};
        my $letter  = $item->{letter};
        my $keyword = $item->{keyword};
        my $note    = $item->{note};
        if ($note) { $note = ": $note" }
        $message_middle .= "$lno:$letter: $keyword $name$note\n";
    }

    if ($message_middle) {
        my $message = "Begin scan for --$wv_key=$wv_option\n";
        $message .= <<EOM;
$issue_type_string
Line:Issue: Var: note
EOM
        $message .= $message_middle;
        $message .= "End scan for --$wv_key=$wv_option:\n";
        warning($message);
    }
    return;
} ## end sub warn_variable_types

sub block_seqno_of_paren_seqno {

    my ( $self, $seqno_paren ) = @_;

    # Find brace at '){' after paren of keyword such as for, foreach, ...
    # SEE ALSO: sub block_seqno_of_paren_keyword

    # Given:
    #  $seqno_paren = sequence number of the paren following a keyword which
    #    may either introduce a block or be a trailing statement modifier,
    #    such as 'if',
    # Return:
    #    - the sequence number of the block, if any, or
    #    - nothing

    #  if (...) { ...
    #     ^   ^ ^
    #     |   | |
    #     |   | K_opening_brace => return sequno of this brace
    #     |   K_closing_paren
    #     $seqno_paren = seqno of this paren pair

    return unless $seqno_paren;
    my $K_closing_paren = $self->[_K_closing_container_]->{$seqno_paren};
    return unless ($K_closing_paren);
    my $K_opening_brace = $self->K_next_code($K_closing_paren);
    return unless ($K_opening_brace);
    my $rLL         = $self->[_rLL_];
    my $seqno_block = $rLL->[$K_opening_brace]->[_TYPE_SEQUENCE_];
    return
      unless ( $seqno_block
        && $rLL->[$K_opening_brace]->[_TOKEN_] eq '{'
        && $self->[_rblock_type_of_seqno_]->{$seqno_block} );
    return $seqno_block;
} ## end sub block_seqno_of_paren_seqno

sub dump_mixed_call_parens {
    my ($self) = @_;

    # Implent --dump-mixed-call-parens

    my $opt_name = 'dump-mixed-call-parens';
    return unless $rOpts->{$opt_name};

    my $rLL = $self->[_rLL_];

    my %skip_keywords;
    my @q = qw( my our local state
      and cmp continue do else elsif eq ge gt le lt ne not or xor );
    @skip_keywords{@q} = (1) x scalar(@q);

    my %call_counts;
    foreach my $KK ( 0 .. @{$rLL} - 1 ) {

        # Types which will be checked:
        # 'k'=builtin keyword, 'U'=user defined sub, 'w'=unknown bareword
        next unless ( $is_kwU{ $rLL->[$KK]->[_TYPE_] } );

        my $type  = $rLL->[$KK]->[_TYPE_];
        my $token = $rLL->[$KK]->[_TOKEN_];
        if ( $type eq 'k' && $skip_keywords{$token} ) { next }

        my $Kn = $self->K_next_code($KK);
        next unless defined($Kn);
        my $token_Kn = $rLL->[$Kn]->[_TOKEN_];
        my $have_paren;
        if    ( $token_Kn eq '=>' ) { next }
        elsif ( $token_Kn eq '->' ) { next }
        elsif ( $token_Kn eq '(' )  { $have_paren = 1 }
        else                        { $have_paren = 0 }

        # return if this is the block form of 'if', 'unless', ..
        if (   $have_paren
            && $is_if_unless_while_until_for_foreach{$token} )
        {
            my $seqno = $rLL->[$Kn]->[_TYPE_SEQUENCE_];
            next if ( $self->block_seqno_of_paren_seqno($seqno) );
        }

        if ( !defined( $call_counts{$token} ) ) {
            $call_counts{$token} = [ 0, 0, $type ];
        }
        $call_counts{$token}->[$have_paren]++;
    }
    my @mixed_counts;
    foreach my $key ( keys %call_counts ) {
        my ( $no_count, $yes_count, $type ) = @{ $call_counts{$key} };
        next unless ( $no_count && $yes_count );

        push @mixed_counts,
          {
            name      => $key,
            type      => $type,
            no_count  => $no_count,
            yes_count => $yes_count,
          };
    }
    return unless (@mixed_counts);

    # sort on lc of type so that user sub type 'U' will come after 'k'
    my @sorted =
      sort { lc $a->{type} cmp lc $b->{type} || $a->{name} cmp $b->{name} }
      @mixed_counts;

    my $input_stream_name = get_input_stream_name();
    my $output_string     = <<EOM;
$input_stream_name: output for --dump-mixed-call-parens
use -wcp=s and/or nwcp=s to find line numbers, where s is a string of words
types are 'k'=builtin keyword 'U'=user sub  'w'=other word
type:word:+count:-count
EOM
    foreach my $item (@sorted) {
        my $type      = $item->{type};
        my $name      = $item->{name};
        my $no_count  = $item->{no_count};
        my $yes_count = $item->{yes_count};
        $output_string .= "$type:$name:$yes_count:$no_count\n";
    }
    print {*STDOUT} $output_string;
    return;
} ## end sub dump_mixed_call_parens

sub initialize_call_paren_style {

    # parse --want-call-parens=s and --nowant-call-parens=s
    # and store results in this global hash:
    %call_paren_style = ();
    my $iter = -1;
    foreach my $opt_name ( 'nowant-call-parens', 'want-call-parens' ) {
        $iter++;
        my $opt = $rOpts->{$opt_name};
        next unless defined($opt);

        # allow comma separators
        $opt =~ s/,/ /g;
        if ( my @q = split_words($opt) ) {
            foreach my $word (@q) {

                # words must be simple identifiers, or '&'
                if ( $word !~ /^(?:\&|\w+)$/ || $word =~ /^\d/ ) {
                    Die("Unexpected word in --$opt_name: '$word'\n");
                }
                if ( $iter && defined( $call_paren_style{$word} ) ) {
                    Warn("'$word' occurs in both -nwcp and -wcp, using -wcp\n");
                }
            }
            @call_paren_style{@q} = ($iter) x scalar(@q);
        }
    }
    return;
} ## end sub initialize_call_paren_style

sub scan_call_parens {
    my ($self) = @_;

    # Perform a scan requested by --want-call-parens
    # We search for selected functions or keywords and for a following paren.
    # A warning is issued if the paren existence is not what is wanted
    # according to the setting --want-call-parens.

    # This routine does not attempt to add or remove parens, it merely
    # issues a warning so that the user can make a change if desired.
    # It is risky to add or delete parens automatically; see git #128.

    return unless (%call_paren_style);
    my $opt_name = 'want-call-parens';

    my $rwarnings = [];

    #---------------------
    # Loop over all tokens
    #---------------------
    my $rLL = $self->[_rLL_];
    foreach my $KK ( 0 .. @{$rLL} - 1 ) {

        # Types which will be checked:
        # 'k'=builtin keyword, 'U'=user defined sub, 'w'=unknown bareword
        next unless ( $is_kwU{ $rLL->[$KK]->[_TYPE_] } );

        # Are we looking for this word?
        my $type       = $rLL->[$KK]->[_TYPE_];
        my $token      = $rLL->[$KK]->[_TOKEN_];
        my $want_paren = $call_paren_style{$token};

        # Only user-defined subs (type 'U') have defaults.
        if ( !defined($want_paren) ) {
            $want_paren =
                $type eq 'k' ? undef
              : $type eq 'U' ? $call_paren_style{'&'}
              :                undef;
        }
        next unless defined($want_paren);

        # This is a selected word. Look for a '(' at the next token.
        my $Kn = $self->K_next_code($KK);
        next unless defined($Kn);

        my $token_Kn = $rLL->[$Kn]->[_TOKEN_];
        if    ( $token_Kn eq '=>' ) { next }
        elsif ( $token_Kn eq '->' ) { next }
        elsif ( $token_Kn eq '(' )  { next if ($want_paren) }
        else                        { next if ( !$want_paren ) }

        # return if this is the block form of 'if', 'unless', ..
        if (   $token_Kn eq '('
            && $is_if_unless_while_until_for_foreach{$token} )
        {
            my $seqno = $rLL->[$Kn]->[_TYPE_SEQUENCE_];
            next if ( $self->block_seqno_of_paren_seqno($seqno) );
        }

        # This disagrees with the wanted style; issue a warning.
        my $note     = $want_paren ? "no call parens" : "has call parens";
        my $rwarning = {
            token       => $token,
            token_next  => $token_Kn,
            want        => $want_paren,
            note        => $note,
            line_number => $rLL->[$KK]->[_LINE_INDEX_] + 1,
            KK          => $KK,
            Kn          => $Kn,
        };
        push @{$rwarnings}, $rwarning;
    }

    # Report any warnings
    if ( @{$rwarnings} ) {
        my $message = "Begin scan for --$opt_name\n";
        $message .= <<EOM;
Line:text:
EOM
        foreach my $item ( @{$rwarnings} ) {
            my $token      = $item->{token};
            my $token_next = $item->{token_next};
            my $note       = $item->{note};
            my $lno        = $item->{line_number};

            # trim long tokens for the output line
            if ( length($token_next) > 23 ) {
                $token_next = substr( $token_next, 0, 20 ) . '...';
            }

            # stop before a ':' to allow use of ':' as spreadsheet col separator
            my $ii = index( $token_next, ':' );
            if ( $ii >= 0 ) { $token_next = substr( $token_next, 0, $ii ) }

            $message .= "$lno:$token $token_next: $note\n";
        }
        $message .= "End scan for --$opt_name\n";

        # Note that this is sent in a single call to warning() in order
        # to avoid triggering a stop on large warning count
        warning($message);
    }
    return;
} ## end sub scan_call_parens

sub find_non_indenting_braces {

    my ( $self, $rix_side_comments ) = @_;

    # Find and mark all non-indenting braces in this file.

    # Given:
    #   $rix_side_comments = index of lines which have side comments
    # Find and save the line indexes of these special side comments in:
    #   $self->[_rseqno_non_indenting_brace_by_ix_];

    # Non-indenting braces are opening braces of the form
    #   { #<<< ...
    # which do not cause an increase in indentation level.
    # They are enabled with the --non-indenting-braces, or -nib, flag.

    return unless ( $rOpts->{'non-indenting-braces'} );
    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );
    my $rlines               = $self->[_rlines_];
    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];
    my $rseqno_non_indenting_brace_by_ix =
      $self->[_rseqno_non_indenting_brace_by_ix_];

    foreach my $ix ( @{$rix_side_comments} ) {
        my $line_of_tokens = $rlines->[$ix];
        my $line_type      = $line_of_tokens->{_line_type};
        if ( $line_type ne 'CODE' ) {

            # shouldn't happen
            DEVEL_MODE && Fault("unexpected line_type=$line_type\n");
            next;
        }
        my $rK_range = $line_of_tokens->{_rK_range};
        my ( $Kfirst, $Klast ) = @{$rK_range};
        if ( !defined($Kfirst) || $rLL->[$Klast]->[_TYPE_] ne '#' ) {

            # shouldn't happen
            DEVEL_MODE && Fault("did not get a comment\n");
            next;
        }
        next if ( $Klast <= $Kfirst );    # maybe HSC
        my $token_sc = $rLL->[$Klast]->[_TOKEN_];
        my $K_m      = $Klast - 1;
        my $type_m   = $rLL->[$K_m]->[_TYPE_];
        if ( $type_m eq 'b' && $K_m > $Kfirst ) {
            $K_m--;
            $type_m = $rLL->[$K_m]->[_TYPE_];
        }
        my $seqno_m = $rLL->[$K_m]->[_TYPE_SEQUENCE_];
        if ($seqno_m) {
            my $block_type_m = $rblock_type_of_seqno->{$seqno_m};

            # The pattern ends in \s but we have removed the newline, so
            # we added it back for the match. That way we require an exact
            # match to the special string and also allow additional text.
            $token_sc .= "\n";
            if (   $block_type_m
                && $is_opening_type{$type_m}
                && $token_sc =~ /$non_indenting_brace_pattern/ )
            {
                $rseqno_non_indenting_brace_by_ix->{$ix} = $seqno_m;
            }
        }
    }
    return;
} ## end sub find_non_indenting_braces

sub interbracket_arrow_check {

    my ($self) = @_;

    # Implement the options to add or delete optional arrows between brackets
    my $rOpts_add            = $rOpts->{'add-interbracket-arrows'};
    my $rOpts_del            = $rOpts->{'delete-interbracket-arrows'};
    my $rOpts_warn           = $rOpts->{'warn-interbracket-arrows'};
    my $rOpts_warn_and_style = $rOpts_warn && %interbracket_arrow_style;

    return
      unless ( $rOpts_add || $rOpts_del || $rOpts_warn_and_style );

    # Method:
    #  Loop over all opening brackets and look back for a possible arrow
    #  and closing bracket.  If the location between brackets allows an
    #  optional arrow, then see if one should be added or deleted.
    #  Set a flag for sub respace_tokens which will make the change.

    # Deleting examples:
    #  $variables->{'a'}->{'b'}     $variables->{'a'}{'b'}
    #  $variables{'a'}->{'b'}       $variables{'a'}->{'b'}
    #  $items[1]->[4]->{red}        $items[1][4]{red}
    #  $items{blue}->[4]->{red}     $items{blue}[4]{red}

    #  Adding examples:
    #  $variables->{'a'}{'b'}       $variables->{'a'}->{'b'}
    #  $variables{'a'}->{'b'}       $variables{'a'}->{'b'}
    #  $items[1][4]{red}            $items[1]->[4]->{red}
    #  $items{blue}[4]{red}         $items{blue}->[4]->{red}

    # bracket chain      ]   { }   [ ]  [
    #                      |     |    |
    # arrow ok?            ?     ?    ?

    # The following chain rule is used to locate optional arrow locations:
    # Scanning left to right:
    #  -arrows can begin once we see an opening token preceded by:
    #    - an ->, or
    #    - a simple scalar identifier like '$href{' or '$aryref['
    #  - Once arrows begin they may continue to the end of the bracket chain.

    #   To illustrate why we just can't add and remove arrows between
    #   ']' and '[', for example, consider
    #   my $v1 = [ 1, 2, [ 3, 4 ] ]->[2]->[0];    # ok
    #   my $v2 = [ 1, 2, [ 3, 4 ] ]->[2][0];      # ok, keep required arrow
    #   my $v3 = [ 1, 2, [ 3, 4 ] ][2][0];        # Error

    #   Note that an arrow does not get placed between '}' and '[' here:
    #     my $val = ${$x}[1];
    #   Perltidy marks the '$' as type 't', and since the logic below checks
    #   for identifiers of type 'i', it will work ok.

    # We will maintain the flag for this check in the following hash:
    my %trailing_arrow_ok_by_seqno;

    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );
    my $K_opening_container = $self->[_K_opening_container_];

    my @lno_del;
    my @lno_add;

    my $warn = sub {

        # write a warning on changes made or needed if -wia is set
        my ( $rlno_list, $first_word ) = @_;
        my $str;
        my $num_changes = @{$rlno_list};
        my @unique_lno  = do {
            my %seen;
            grep { !$seen{$_}++ } @{$rlno_list};
        };
        my $num_lno = @unique_lno;
        my $num_lim = 10;
        if ( $num_lno <= $num_lim ) {
            $str = join( SPACE, @unique_lno );
        }
        else {
            $str = join( SPACE, @unique_lno[ 0 .. $num_lim - 1 ] ) . " ...";
        }
        my $ess1 = $num_changes == 1 ? EMPTY_STRING : 's';
        my $ess2 = $num_lno == 1     ? EMPTY_STRING : 's';
        my $msg  = "$first_word $num_changes '->'$ess1 at line$ess2 $str\n";
        warning($msg);
        return;
    }; ## end $warn = sub

    # Complexity control flag:
    #  =0 left container must just contain a single token
    #  =1 left container must not contain other containers [DEFAULT]
    #  =2 no complexity constraints
    my $complexity = $rOpts->{'interbracket-arrow-complexity'};
    if ( !defined($complexity) ) { $complexity = 1 }

    #--------------------------------------------
    # Main loop over all opening container tokens
    #--------------------------------------------
    foreach my $seqno ( sort { $a <=> $b } keys %{$K_opening_container} ) {

        # We just want opening token types 'L" or '['
        # Note: the tokenizer marks hash braces '{' and '}' as 'L' and 'R'
        # but we have to be careful because small block braces can also
        # get marked 'L' and 'R' for formatting purposes.
        my $Ko   = $K_opening_container->{$seqno};
        my $type = $rLL->[$Ko]->[_TYPE_];
        next if ( $type ne 'L' && $type ne '[' );

        # Now find the previous nonblank token
        my $K_m = $Ko - 1;
        next if ( $K_m < 0 );
        my $type_m = $rLL->[$K_m]->[_TYPE_];
        if ( $type_m eq 'b' && $K_m > 0 ) {
            $K_m -= 1;
            $type_m = $rLL->[$K_m]->[_TYPE_];
        }

        # These vars will hold the previous closing bracket, if any;
        # initialized to this token but will be moved if it is an arrow
        my $K_mm    = $K_m;
        my $type_mm = $type_m;

        # Decide if an inter-bracket arrow could follow the closing token
        # of this container..

        # preceded by scalar identifier (such as '$array[' or '$hash{') ?
        if ( $type_m eq 'i' || $type_m eq 'Z' ) {

            my $token_m = $rLL->[$K_m]->[_TOKEN_];
            if ( substr( $token_m, 0, 1 ) eq '$' ) {

                # arrows can follow the CLOSING bracket of this container
                $trailing_arrow_ok_by_seqno{$seqno} = 1;
            }
        }

        # or a closing bracket or hash brace
        elsif ( $type_m eq ']' || $type_m eq 'R' ) {
            my $seqno_m = $rLL->[$K_m]->[_TYPE_SEQUENCE_];

            # propagate the arrow status flag
            $trailing_arrow_ok_by_seqno{$seqno} =
              $trailing_arrow_ok_by_seqno{$seqno_m};
        }

        # check a pointer and if found, back up one more token
        elsif ( $type_m eq '->' ) {

            # arrows can follow the CLOSING bracket of this container
            $trailing_arrow_ok_by_seqno{$seqno} = 1;

            # back up one token before the arrow
            $K_mm = $K_m - 1;
            next if ( $K_mm <= 0 );
            $type_mm = $rLL->[$K_mm]->[_TYPE_];
            if ( $type_mm eq 'b' && $K_mm > 0 ) {
                $K_mm -= 1;
                $type_mm = $rLL->[$K_mm]->[_TYPE_];
            }
        }
        else {
            # something else
        }

        # now check for a preceding closing bracket or hash brace
        next if ( $type_mm ne ']' && $type_mm ne 'R' );
        my $seqno_mm = $rLL->[$K_mm]->[_TYPE_SEQUENCE_];
        next if ( !$seqno_mm );

        $trailing_arrow_ok_by_seqno{$seqno} = 1;

        # We are between brackets with these two or three sequential tokens,
        # indexes _mm and _m are identical if there is no arrow.
        #   $type_mm   $type_m     $type
        #    R or ]      ->?       [  or L

        # Can an inter-bracket arrow be here?
        next unless ( $trailing_arrow_ok_by_seqno{$seqno_mm} );

        # If the user defined a style, only continue if this requires
        # adding or deleting an '->' to match the style
        if (%interbracket_arrow_style) {
            my $style = $interbracket_arrow_style{ $type_mm . $type };
            next if ( !$style );
            next
              if ( $style == -1 && $type_m ne '->'
                || $style == 1 && $type_m eq '->' );
        }

        next if ( $type_m eq '->' && !$rOpts_del && !$rOpts_warn );
        next if ( $type_m ne '->' && !$rOpts_add && !$rOpts_warn );

        # Do not continue if the left container is too complex..
        # complexity flag = 0: only one nonblank token in the brackets
        if ( !$complexity ) {
            my $count = 0;
            my $Ko_mm = $K_opening_container->{$seqno_mm};
            next unless defined($Ko_mm);
            foreach my $KK ( $Ko_mm + 1 .. $K_mm - 2 ) {
                next if ( $rLL->[$KK]->[_TYPE_] eq 'b' );
                $count++;
                last if ( $count > 1 );
            }
            next if ( $count > 1 );
        }

        # complexity flag = 1: no interior container tokens
        elsif ( $complexity == 1 ) {

            if ( $seqno_mm ne $seqno - 1 ) {
                next;
            }
        }
        else {
            # complexity flag >1 => no restriction
        }

        # set a flag telling sub respace_tokens to actually make the change
        my $lno = 1 + $rLL->[$Ko]->[_LINE_INDEX_];
        if ( $type_m eq '->' ) {
            if ($rOpts_del) {
                $self->[_rwant_arrow_before_seqno_]->{$seqno} = -1;
            }
            if ( $rOpts_del || $rOpts_warn_and_style ) { push @lno_del, $lno }
        }
        else {
            if ($rOpts_add) {
                $self->[_rwant_arrow_before_seqno_]->{$seqno} = 1;
            }
            if ( $rOpts_add || $rOpts_warn_and_style ) { push @lno_add, $lno }
        }
    }

    if ($rOpts_warn) {
        my $wia = '--warn-interbracket-arrows report:';
        $warn->( \@lno_add, $rOpts_add ? "$wia added" : "$wia: missing" )
          if (@lno_add);
        $warn->( \@lno_del, $rOpts_del ? "$wia deleted " : "$wia: unwanted " )
          if (@lno_del);
    }
    return;
} ## end sub interbracket_arrow_check

sub delete_side_comments {
    my ( $self, $rix_side_comments ) = @_;

    # Handle any requested side comment deletions.
    # Given:
    #   $rix_side_comments = ref to list of indexes of lines with side comments

    my $rLL                  = $self->[_rLL_];
    my $rlines               = $self->[_rlines_];
    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];
    my $rseqno_non_indenting_brace_by_ix =
      $self->[_rseqno_non_indenting_brace_by_ix_];

    foreach my $ix ( @{$rix_side_comments} ) {
        my $line_of_tokens = $rlines->[$ix];
        my $line_type      = $line_of_tokens->{_line_type};

        # This fault shouldn't happen because we only saved CODE lines with
        # side comments in the TASK 1 loop above.
        if ( $line_type ne 'CODE' ) {
            if (DEVEL_MODE) {
                my $lno = $ix + 1;
                Fault(<<EOM);
Hit unexpected line_type = '$line_type' near line $lno while deleting side comments, should be 'CODE'
EOM
            }
            next;
        }

        my $CODE_type = $line_of_tokens->{_code_type};
        my $rK_range  = $line_of_tokens->{_rK_range};
        my ( $Kfirst, $Klast ) = @{$rK_range};

        if ( !defined($Kfirst) || $rLL->[$Klast]->[_TYPE_] ne '#' ) {
            if (DEVEL_MODE) {
                my $lno = $ix + 1;
                Fault(<<EOM);
Did not find side comment near line $lno while deleting side comments
EOM
            }
            next;
        }

        my $delete_side_comment =
             $rOpts_delete_side_comments
          && ( $Klast > $Kfirst || $CODE_type eq 'HSC' )
          && (!$CODE_type
            || $CODE_type eq 'HSC'
            || $CODE_type eq 'IO'
            || $CODE_type eq 'NIN' );

        # Do not delete special control side comments
        if ( $rseqno_non_indenting_brace_by_ix->{$ix} ) {
            $delete_side_comment = 0;
        }

        if (
               $rOpts_delete_closing_side_comments
            && !$delete_side_comment
            && $Klast > $Kfirst
            && (  !$CODE_type
                || $CODE_type eq 'HSC'
                || $CODE_type eq 'IO'
                || $CODE_type eq 'NIN' )
          )
        {
            my $token  = $rLL->[$Klast]->[_TOKEN_];
            my $K_m    = $Klast - 1;
            my $type_m = $rLL->[$K_m]->[_TYPE_];
            if ( $type_m eq 'b' && $K_m > $Kfirst ) { $K_m-- }
            my $seqno_m = $rLL->[$K_m]->[_TYPE_SEQUENCE_];

            # patch to delete asub csc's (c380)
            if ( !$seqno_m && $K_m && $rLL->[$K_m]->[_TYPE_] eq ';' ) {
                $K_m    = $K_m - 1;
                $type_m = $rLL->[$K_m]->[_TYPE_];
                if ( $type_m eq 'b' && $K_m > $Kfirst ) { $K_m-- }
                if ( $K_m == $Kfirst ) {
                    $seqno_m = $rLL->[$K_m]->[_TYPE_SEQUENCE_];
                }
            }

            if ($seqno_m) {
                my $block_type_m = $rblock_type_of_seqno->{$seqno_m};
                if (   $block_type_m
                    && $token        =~ /$closing_side_comment_prefix_pattern/
                    && $block_type_m =~ /$closing_side_comment_list_pattern/
                    && $block_type_m !~
                    /$closing_side_comment_exclusion_pattern/ )
                {
                    $delete_side_comment = 1;
                }
            }
        } ## end if ( $rOpts_delete_closing_side_comments...)

        if ($delete_side_comment) {

            # We are actually just changing the side comment to a blank.
            # This may produce multiple blanks in a row, but sub respace_tokens
            # will check for this and fix it.
            $rLL->[$Klast]->[_TYPE_]  = 'b';
            $rLL->[$Klast]->[_TOKEN_] = SPACE;

            # The -io option outputs the line text, so we have to update
            # the line text so that the comment does not reappear.
            if ( $CODE_type eq 'IO' ) {
                my $line = EMPTY_STRING;
                foreach my $KK ( $Kfirst .. $Klast - 1 ) {
                    $line .= $rLL->[$KK]->[_TOKEN_];
                }
                $line =~ s/\s+$//;
                $line_of_tokens->{_line_text} = $line . "\n";
            }

            # If we delete a hanging side comment the line becomes blank.
            if ( $CODE_type eq 'HSC' ) { $line_of_tokens->{_code_type} = 'BL' }
        }
    }
    return;
} ## end sub delete_side_comments

my %wU;
my %wiq;
my %is_wit;
my %is_sigil;
my %is_nonlist_keyword;
my %is_nonlist_type;
my %is_s_y_m_slash;
my %is_unexpected_equals;
my %is_ascii_type;

BEGIN {

    # added 'U' to fix cases b1125 b1126 b1127
    my @q = qw( w U );
    @wU{@q} = (1) x scalar(@q);

    @q = qw( w i q Q G C Z );
    @wiq{@q} = (1) x scalar(@q);

    @q = qw( w i t );    # for c250: added new types 'P', 'S', formerly 'i'
    @is_wit{@q} = (1) x scalar(@q);

    @q = qw( $ & % * @ );
    @is_sigil{@q} = (1) x scalar(@q);

    # Parens following these keywords will not be marked as lists. Note that
    # 'for' is not included and is handled separately, by including 'f' in the
    # hash %is_counted_type, since it may or may not be a c-style for loop.
    @q = qw( if elsif unless and or );
    @is_nonlist_keyword{@q} = (1) x scalar(@q);

    # Parens following these types will not be marked as lists
    @q = qw( && || );
    @is_nonlist_type{@q} = (1) x scalar(@q);

    @q = qw( s y m / );
    @is_s_y_m_slash{@q} = (1) x scalar(@q);

    @q = qw( = == != );
    @is_unexpected_equals{@q} = (1) x scalar(@q);

    # We can always skip expensive length_function->() calls for these
    # ascii token types
    @q = qw#
      b k L R ; ( { [ ? : ] } ) f t n v F p m pp mm
      .. :: << >> ** && .. || // -> => += -= .= %= &= |= ^= *= <>
      ( ) <= >= == =~ !~ != ++ -- /= x=
      ... **= <<= >>= &&= ||= //= <=>
      + - / * | % ! x ~ = \ ? : . < > ^ &
      #;
    push @q, ',';
    @is_ascii_type{@q} = (1) x scalar(@q);

} ## end BEGIN

{ #<<< begin closure respace_tokens

my $rLL_new;    # This will be the new array of tokens

# These are variables in $self
my $rLL;
my $length_function;

my $K_closing_ternary;
my $K_opening_ternary;
my $rchildren_of_seqno;
my $rhas_broken_code_block;
my $rhas_broken_list;
my $rhas_broken_list_with_lec;
my $rhas_code_block;
my $rhas_list;
my $rhas_ternary;
my $ris_assigned_structure;
my $ris_broken_container;
my $ris_excluded_lp_container;
my $ris_list_by_seqno;
my $ris_permanently_broken;
my $rlec_count_by_seqno;
my $roverride_cab3;
my $rparent_of_seqno;
my $rtype_count_by_seqno;
my $rblock_type_of_seqno;
my $rwant_arrow_before_seqno;
my $ris_sub_block;
my $ris_asub_block;
my $rseqno_arrow_call_chain_start;
my $rarrow_call_chain;

my $K_opening_container;
my $K_closing_container;
my @K_sequenced_token_list;
my @seqno_paren_arrow;

my %K_first_here_doc_by_seqno;

my $last_nonblank_code_type;
my $last_nonblank_code_token;
my $last_nonblank_block_type;
my $last_last_nonblank_code_type;
my $last_last_nonblank_code_token;
my $K_last_S;
my $K_last_S_is_my;

my %seqno_stack;
my %K_old_opening_by_seqno;
my $depth_next;
my $depth_next_max;
my @sub_seqno_stack;
my $current_sub_seqno;

my $cumulative_length;

# Variables holding the current line info
my $Ktoken_vars;
my $Kfirst_old;
my $Klast_old;
my $Klast_old_code;
my $CODE_type;

my $rwhitespace_flags;

# new index K of package or class statements
my $rK_package_list;

# new index K of @_ tokens
my $rK_AT_underscore_by_sub_seqno;

# new index K of first $self tokens for each sub
my $rK_first_self_by_sub_seqno;

# new index K of first 'bless' for each sub
my $rK_bless_by_sub_seqno;

# new index K of 'return' for each sub
my $rK_return_by_sub_seqno;

# new index K of 'wantarray' for each sub
my $rK_wantarray_by_sub_seqno;

# info about list of sub call args
my $rsub_call_paren_info_by_seqno;
my $rDOLLAR_underscore_by_sub_seqno;

# index K of the preceding 'S' token for a sub
my $rK_sub_by_seqno;

# true for a 'my' sub
my $ris_my_sub_by_seqno;

sub initialize_respace_tokens_closure {

    my ($self) = @_;

    $rLL_new = [];    # This is the new array

    $rLL = $self->[_rLL_];

    $length_function           = $self->[_length_function_];
    $K_closing_ternary         = $self->[_K_closing_ternary_];
    $K_opening_ternary         = $self->[_K_opening_ternary_];
    $rchildren_of_seqno        = $self->[_rchildren_of_seqno_];
    $rhas_broken_code_block    = $self->[_rhas_broken_code_block_];
    $rhas_broken_list          = $self->[_rhas_broken_list_];
    $rhas_broken_list_with_lec = $self->[_rhas_broken_list_with_lec_];
    $rhas_code_block           = $self->[_rhas_code_block_];
    $rhas_list                 = $self->[_rhas_list_];
    $rhas_ternary              = $self->[_rhas_ternary_];
    $ris_assigned_structure    = $self->[_ris_assigned_structure_];
    $ris_broken_container      = $self->[_ris_broken_container_];
    $ris_excluded_lp_container = $self->[_ris_excluded_lp_container_];
    $ris_list_by_seqno         = $self->[_ris_list_by_seqno_];
    $ris_permanently_broken    = $self->[_ris_permanently_broken_];
    $rlec_count_by_seqno       = $self->[_rlec_count_by_seqno_];
    $roverride_cab3            = $self->[_roverride_cab3_];
    $rparent_of_seqno          = $self->[_rparent_of_seqno_];
    $rtype_count_by_seqno      = $self->[_rtype_count_by_seqno_];
    $rblock_type_of_seqno      = $self->[_rblock_type_of_seqno_];
    $rwant_arrow_before_seqno  = $self->[_rwant_arrow_before_seqno_];
    $ris_sub_block             = $self->[_ris_sub_block_];
    $ris_asub_block            = $self->[_ris_asub_block_];

    $rK_package_list               = $self->[_rK_package_list_];
    $rK_AT_underscore_by_sub_seqno = $self->[_rK_AT_underscore_by_sub_seqno_];
    $rK_first_self_by_sub_seqno    = $self->[_rK_first_self_by_sub_seqno_];
    $rK_bless_by_sub_seqno         = $self->[_rK_bless_by_sub_seqno_];
    $rK_return_by_sub_seqno        = $self->[_rK_return_by_sub_seqno_];
    $rK_wantarray_by_sub_seqno     = $self->[_rK_wantarray_by_sub_seqno_];
    $rsub_call_paren_info_by_seqno = $self->[_rsub_call_paren_info_by_seqno_];
    $rseqno_arrow_call_chain_start = $self->[_rseqno_arrow_call_chain_start_];
    $rarrow_call_chain             = $self->[_rarrow_call_chain_];
    $rDOLLAR_underscore_by_sub_seqno =
      $self->[_rDOLLAR_underscore_by_sub_seqno_];
    $rK_sub_by_seqno     = $self->[_rK_sub_by_seqno_];
    $ris_my_sub_by_seqno = $self->[_ris_my_sub_by_seqno_];

    %K_first_here_doc_by_seqno = ();

    $last_nonblank_code_type       = ';';
    $last_nonblank_code_token      = ';';
    $last_nonblank_block_type      = EMPTY_STRING;
    $last_last_nonblank_code_type  = ';';
    $last_last_nonblank_code_token = ';';
    $K_last_S                      = 1;
    $K_last_S_is_my                = undef;

    %seqno_stack            = ();
    %K_old_opening_by_seqno = ();    # Note: old K index
    $depth_next             = 0;
    $depth_next_max         = 0;

    @sub_seqno_stack   = ();
    $current_sub_seqno = 0;

    # we will be setting token lengths as we go
    $cumulative_length = 0;

    $Ktoken_vars    = undef;          # the old K value of $rtoken_vars
    $Kfirst_old     = undef;          # min K of old line
    $Klast_old      = undef;          # max K of old line
    $Klast_old_code = undef;          # K of last token if side comment
    $CODE_type      = EMPTY_STRING;

    # Set the whitespace flags, which indicate the token spacing preference.
    $rwhitespace_flags = $self->set_whitespace_flags();

    # Note that $K_opening_container and $K_closing_container have values
    # defined in sub get_line() for the previous K indexes.  They were needed
    # in case option 'indent-only' was set, and we didn't get here. We no
    # longer need those and will eliminate them now to avoid any possible
    # mixing of old and new values.  This must be done AFTER the call to
    # set_whitespace_flags, which needs these.
    $K_opening_container = $self->[_K_opening_container_] = {};
    $K_closing_container = $self->[_K_closing_container_] = {};

    @K_sequenced_token_list = ();

    # array for saving seqno's of ')->' for possible line breaks, git #171
    @seqno_paren_arrow = ();

    return;

} ## end sub initialize_respace_tokens_closure

sub respace_tokens {

    my $self = shift;

    # This routine is called once per file to do as much formatting as possible
    # before new line breaks are set.

    # Returns:
    #   $severe_error = true if processing must terminate immediately
    #   $rqw_lines    = ref to list of lines with qw quotes (for -qwaf)
    my ( $severe_error, $rqw_lines );

    # We do not change any spaces in --indent-only mode
    if ( $rOpts->{'indent-only'} ) {

        # We need to define lengths for -indent-only to avoid undefs, even
        # though these values are not actually needed for option --indent-only.

        $rLL               = $self->[_rLL_];
        $cumulative_length = 0;

        foreach my $item ( @{$rLL} ) {
            my $token = $item->[_TOKEN_];
            my $token_length =
              $length_function ? $length_function->($token) : length($token);
            $cumulative_length += $token_length;
            $item->[_TOKEN_LENGTH_]      = $token_length;
            $item->[_CUMULATIVE_LENGTH_] = $cumulative_length;
        }

        return ( $severe_error, $rqw_lines );
    }

    # This routine makes all necessary and possible changes to the tokenization
    # after the initial tokenization of the file. This is a tedious routine,
    # but basically it consists of inserting and deleting whitespace between
    # nonblank tokens according to the selected parameters. In a few cases
    # non-space characters are added, deleted or modified.

    # The goal of this routine is to create a new token array which only needs
    # the definition of new line breaks and padding to complete formatting.  In
    # a few cases we have to cheat a little to achieve this goal.  In
    # particular, we may not know if a semicolon will be needed, because it
    # depends on how the line breaks go.  To handle this, we include the
    # semicolon as a 'phantom' which can be displayed as normal or as an empty
    # string.

    # Method: The old tokens are copied one-by-one, with changes, from the old
    # linear storage array $rLL to a new array $rLL_new.

    # (re-)initialize closure variables for this problem
    $self->initialize_respace_tokens_closure();

    #--------------------------------
    # Main over all lines of the file
    #--------------------------------
    my $rlines    = $self->[_rlines_];
    my $line_type = EMPTY_STRING;
    my $last_K_out;

    foreach my $line_of_tokens ( @{$rlines} ) {

        my $input_line_number = $line_of_tokens->{_line_number};
        my $last_line_type    = $line_type;
        $line_type = $line_of_tokens->{_line_type};
        next unless ( $line_type eq 'CODE' );
        $CODE_type = $line_of_tokens->{_code_type};

        if ( $CODE_type eq 'BL' ) {
            my $seqno = $seqno_stack{ $depth_next - 1 };
            if ( defined($seqno) ) {
                $self->[_rblank_and_comment_count_]->{$seqno} += 1;
                if (  !$ris_permanently_broken->{$seqno}
                    && $rOpts_maximum_consecutive_blank_lines )
                {
                    $ris_permanently_broken->{$seqno} = 1;
                    $self->mark_parent_containers( $seqno,
                        $ris_permanently_broken );
                }
            }
        }

        my $rK_range = $line_of_tokens->{_rK_range};
        my ( $Kfirst, $Klast ) = @{$rK_range};
        next unless defined($Kfirst);
        ( $Kfirst_old, $Klast_old ) = ( $Kfirst, $Klast );
        $Klast_old_code = $Klast_old;

        # Be sure an old K value is defined for sub store_token
        $Ktoken_vars = $Kfirst;

        # Check for correct sequence of token indexes...
        # An error here means that sub write_line() did not correctly
        # package the tokenized lines as it received them.  If we
        # get a fault here it has not output a continuous sequence
        # of K values.  Or a line of CODE may have been mis-marked as
        # something else.  There is no good way to continue after such an
        # error.
        if ( defined($last_K_out) ) {
            if ( $Kfirst != $last_K_out + 1 ) {
                Fault_Warn(
                    "Program Bug: last K out was $last_K_out but Kfirst=$Kfirst"
                );
                $severe_error = 1;
                return ( $severe_error, $rqw_lines );
            }
        }
        else {

            # The first token should always have been given index 0 by sub
            # write_line()
            if ( $Kfirst != 0 ) {
                Fault("Program Bug: first K is $Kfirst but should be 0");
            }
        }
        $last_K_out = $Klast;

        # Handle special lines of code
        if ( $CODE_type && $CODE_type ne 'NIN' && $CODE_type ne 'VER' ) {

            # CODE_types are as follows.
            # 'BL' = Blank Line
            # 'VB' = Verbatim - line goes out verbatim
            # 'FS' = Format Skipping - line goes out verbatim, no blanks
            # 'IO' = Indent Only - only indentation may be changed
            # 'NIN' = No Internal Newlines - line does not get broken
            # 'HSC'=Hanging Side Comment - fix this hanging side comment
            # 'BC'=Block Comment - an ordinary full line comment
            # 'SBC'=Static Block Comment - a block comment which does not get
            #      indented
            # 'SBCX'=Static Block Comment Without Leading Space
            # 'VER'=VERSION statement
            # '' or (undefined) - no restrictions

            # Copy tokens unchanged
            foreach my $KK ( $Kfirst .. $Klast ) {
                $Ktoken_vars = $KK;
                $self->store_token( $rLL->[$KK] );
            }
            next;
        }

        # Handle normal line..

        # Define index of last token before any side comment for comma counts
        my $type_end = $rLL->[$Klast_old_code]->[_TYPE_];
        if ( ( $type_end eq '#' || $type_end eq 'b' )
            && $Klast_old_code > $Kfirst_old )
        {
            $Klast_old_code--;
            if (   $rLL->[$Klast_old_code]->[_TYPE_] eq 'b'
                && $Klast_old_code > $Kfirst_old )
            {
                $Klast_old_code--;
            }
        }

        # Insert any essential whitespace between lines
        # if last line was normal CODE.
        # Patch for rt #125012: use K_previous_code rather than '_nonblank'
        # because comments may disappear.
        # Note that we must do this even if --noadd-whitespace is set
        if ( $last_line_type eq 'CODE' ) {
            if (
                is_essential_whitespace(
                    $last_last_nonblank_code_token,
                    $last_last_nonblank_code_type,
                    $last_nonblank_code_token,
                    $last_nonblank_code_type,
                    $rLL->[$Kfirst]->[_TOKEN_],
                    $rLL->[$Kfirst]->[_TYPE_],
                )
              )
            {
                $self->store_token();
            }
        }

        #-----------------------------------------------
        # Inner loop to respace tokens on a line of code
        #-----------------------------------------------

        # The inner loop is in a separate sub for clarity
        $self->respace_tokens_inner_loop( $Kfirst, $Klast, $input_line_number );

        if ( $line_of_tokens->{_ending_in_quote} ) {
            my $seqno = $seqno_stack{ $depth_next - 1 };
            if ( defined($seqno) ) {
                $ris_permanently_broken->{$seqno} = 1;
                $self->mark_parent_containers( $seqno,
                    $ris_permanently_broken );
            }
        }
    }    # End line loop

    # finalize data structures
    $self->respace_post_loop_ops();

    # Reset memory to be the new array
    $self->[_rLL_] = $rLL_new;
    my $Klimit;
    if ( @{$rLL_new} ) { $Klimit = @{$rLL_new} - 1 }
    $self->[_Klimit_] = $Klimit;

    # During development, verify that the new array still looks okay.
    DEVEL_MODE && $self->check_token_array();

    # update the token limits of each line
    ( $severe_error, $rqw_lines ) = $self->resync_lines_and_tokens();

    return ( $severe_error, $rqw_lines );
} ## end sub respace_tokens

sub respace_tokens_inner_loop {

    my ( $self, $Kfirst, $Klast, $input_line_number ) = @_;

    # Loop to copy all tokens on one line, making any spacing changes,
    # while also collecting information needed by later subs.

    # Given:
    #   $Kfirst = index of first token on this line
    #   $Klast  = index of last token on this line
    #   $input_line_number  = number of this line in input stream

    my $type;
    foreach my $KK ( $Kfirst .. $Klast ) {

        # Update closure variable needed by sub store_token
        $Ktoken_vars = $KK;

        my $rtoken_vars = $rLL->[$KK];

        # Handle a blank space ...
        if ( ( $type = $rtoken_vars->[_TYPE_] ) eq 'b' ) {

            # Delete it if not wanted by whitespace rules
            # or we are deleting all whitespace
            # Note that whitespace flag is a flag indicating whether a
            # white space BEFORE the token is needed
            next if ( $KK >= $Klast );    # skip terminal blank
            my $Knext = $KK + 1;

            if ($rOpts_freeze_whitespace) {
                $self->store_token($rtoken_vars);
                next;
            }

            my $ws = $rwhitespace_flags->[$Knext];
            if (   $ws == WS_NO
                || $rOpts_delete_old_whitespace )
            {

                my $token_next = $rLL->[$Knext]->[_TOKEN_];
                my $type_next  = $rLL->[$Knext]->[_TYPE_];

                my $do_not_delete = is_essential_whitespace(
                    $last_last_nonblank_code_token,
                    $last_last_nonblank_code_type,
                    $last_nonblank_code_token,
                    $last_nonblank_code_type,
                    $token_next,
                    $type_next,
                );

                # Note that repeated blanks will get filtered out here
                next unless ($do_not_delete);
            }

            # make it just one character
            $rtoken_vars->[_TOKEN_] = SPACE;
            $self->store_token($rtoken_vars);
            next;
        }

        my $token = $rtoken_vars->[_TOKEN_];

        # Handle a sequenced token ... i.e. one of ( ) { } [ ] ? :
        if ( $rtoken_vars->[_TYPE_SEQUENCE_] ) {

            # One of ) ] } ...
            if ( $is_closing_token{$token} ) {

                my $type_sequence = $rtoken_vars->[_TYPE_SEQUENCE_];
                my $block_type    = $rblock_type_of_seqno->{$type_sequence};

                #---------------------------------------------
                # check for semicolon addition in a code block
                #---------------------------------------------
                if ($block_type) {

                    # if not preceded by a ';' ..
                    if ( $last_nonblank_code_type ne ';' ) {

                        # tentatively insert a semicolon if appropriate
                        $self->add_phantom_semicolon($KK)
                          if $rOpts->{'add-semicolons'};
                    }

                    if (   $ris_sub_block->{$type_sequence}
                        || $ris_asub_block->{$type_sequence} )
                    {
                        $current_sub_seqno = pop @sub_seqno_stack;
                    }
                }

                #----------------------------------------------------------
                # check for addition/deletion of a trailing comma in a list
                #----------------------------------------------------------
                else {

                    # if this looks like a list ..
                    my $rtype_count = $rtype_count_by_seqno->{$type_sequence};
                    if (   !$rtype_count
                        || !$rtype_count->{';'} && !$rtype_count->{'f'} )
                    {

                        # if NOT preceded by a comma..
                        if ( $last_nonblank_code_type ne ',' ) {

                            # insert a comma if requested
                            if (
                                   $rOpts_add_trailing_commas
                                && %trailing_comma_rules

                                # and...
                                && (

                                    # ... there is a comma or fat_comma
                                    $rtype_count
                                    && (   $rtype_count->{','}
                                        || $rtype_count->{'=>'} )

                                    # ... or exception for nested container
                                    || (
                                        $rOpts_add_lone_trailing_commas
                                        && $is_closing_type{
                                            $last_nonblank_code_type}
                                    )
                                )

                                # and not preceded by '=>'
                                # (unusual but can occur in test files)
                                && $last_nonblank_code_type ne '=>'
                              )
                            {
                                my $rule = $trailing_comma_rules{add};
                                if ( $rule && $rule->{$token} ) {
                                    $self->add_trailing_comma( $KK, $Kfirst,
                                        $rule->{$token} );
                                }
                            }
                        }

                        # if preceded by a comma ..
                        else {

                            # delete a trailing comma if requested
                            my $deleted;
                            if (
                                   $rOpts_delete_trailing_commas
                                && %trailing_comma_rules
                                && $rtype_count
                                && $rtype_count->{','}
                                && (   $rOpts_delete_lone_trailing_commas
                                    || $rtype_count->{','} > 1
                                    || $rtype_count->{'=>'} )

                                # ignore zero-size qw commas
                                && $last_nonblank_code_token
                              )
                            {
                                my $rule = $trailing_comma_rules{delete};
                                if ( $rule && $rule->{$token} ) {
                                    $deleted =
                                      $self->delete_trailing_comma( $KK,
                                        $Kfirst, $rule->{$token} );
                                }
                            }

                            # delete a weld-interfering comma if requested
                            if (  !$deleted
                                && $rOpts_delete_weld_interfering_commas
                                && $is_closing_type{
                                    $last_last_nonblank_code_type} )
                            {
                                $self->delete_weld_interfering_comma($KK);
                            }
                        }
                    }
                }
            }

            # Opening container
            else {
                my $type_sequence = $rtoken_vars->[_TYPE_SEQUENCE_];
                if ( $rwant_arrow_before_seqno->{$type_sequence} ) {

                    # +1 means add  -1 means delete previous arrow
                    if ( $rwant_arrow_before_seqno->{$type_sequence} > 0 ) {
                        $self->add_interbracket_arrow();
                    }
                    else {
                        $self->delete_interbracket_arrow();
                        $rwhitespace_flags->[$KK] = WS_NO;
                    }
                }

                # Save info for sub call arg count check
                if ( $token eq '(' ) {
                    if (

                        # function(
                        $last_nonblank_code_type eq 'U'
                        || $last_nonblank_code_type eq 'w'

                        # ->function(
                        || (   $last_nonblank_code_type eq 'i'
                            && $last_last_nonblank_code_type eq '->' )

                        # &function(
                        || ( $last_nonblank_code_type eq 'i'
                            && substr( $last_nonblank_code_token, 0, 1 ) eq
                            '&' )
                      )
                    {
                        $rsub_call_paren_info_by_seqno->{$type_sequence} = {
                            type_mm => $last_last_nonblank_code_type,
                            token_m => $last_nonblank_code_token,
                        };
                    }
                }

                # At a sub block, save info to cross check arg counts
                elsif ( $ris_sub_block->{$type_sequence} ) {
                    $rK_sub_by_seqno->{$type_sequence} = $K_last_S;
                    if ($K_last_S_is_my) {
                        $ris_my_sub_by_seqno->{$type_sequence} = 1;
                    }
                    push @sub_seqno_stack, $current_sub_seqno;
                    $current_sub_seqno = $type_sequence;
                }
                elsif ( $ris_asub_block->{$type_sequence} ) {
                    push @sub_seqno_stack, $current_sub_seqno;
                    $current_sub_seqno = $type_sequence;
                }

                # Look for '$_[' for mismatched arg checks
                elsif ($token eq '['
                    && $last_nonblank_code_token eq '$_'
                    && $current_sub_seqno )
                {
                    push
                      @{ $rDOLLAR_underscore_by_sub_seqno->{$current_sub_seqno}
                      },
                      $type_sequence;
                }
                else {
                    ## not a special opening token
                }
            }
        }

        # Modify certain tokens here for whitespace
        # The following is not yet done, but could be:
        #   sub (x x x)
        #     ( $type =~ /^[wit]$/ )
        elsif ( $is_wit{$type} ) {

            # index() is several times faster than a regex test with \s here
            ##   $token =~ /\s/
            if ( index( $token, SPACE ) > 0 || index( $token, "\t" ) > 0 ) {

                # change '$  var'  to '$var' etc
                # change '@    '   to '@'
                # Examples: <<snippets/space1.in>>
                my $ord = ord( substr( $token, 1, 1 ) );
                if (

                    # quick test for possible blank at second char
                    $ord > 0 && ( $ord < ORD_PRINTABLE_MIN
                        || $ord > ORD_PRINTABLE_MAX )
                  )
                {
                    my ( $sigil, $word ) = split /\s+/, $token, 2;

                    # $sigil =~ /^[\$\&\%\*\@]$/ )
                    if ( $is_sigil{$sigil} ) {
                        $token = $sigil;
                        $token .= $word if ( defined($word) );    # fix c104
                        $rtoken_vars->[_TOKEN_] = $token;
                    }
                }

                # trim identifiers of trailing blanks which can occur
                # under some unusual circumstances, such as if the
                # identifier 'witch' has trailing blanks on input here:
                #
                # sub
                # witch
                # ()   # prototype may be on new line ...
                # ...
                my $ord_ch = ord( substr( $token, -1, 1 ) );
                if (

                    # quick check for possible ending space
                    $ord_ch > 0 && ( $ord_ch < ORD_PRINTABLE_MIN
                        || $ord_ch > ORD_PRINTABLE_MAX )
                  )
                {
                    $token =~ s/\s+$//g;
                    $rtoken_vars->[_TOKEN_] = $token;
                }
            }
            if ( $type eq 'i' ) {
                if ( $token eq '@_' && $current_sub_seqno ) {

                    # remember the new K of this @_; this may be
                    # off by 1 if a blank gets inserted before it
                    push
                      @{ $rK_AT_underscore_by_sub_seqno->{$current_sub_seqno} },
                      scalar( @{$rLL_new} );
                }

                # Remember new K of the first '$self' in a sub for -dma option
                if ( $token eq '$self' && $current_sub_seqno ) {
                    $rK_first_self_by_sub_seqno->{$current_sub_seqno} ||=
                      scalar( @{$rLL_new} );
                }

                # Remember new K and name of blessed objects for -dma option
                if (
                    (
                           $last_nonblank_code_token eq 'bless'
                        && $last_nonblank_code_type eq 'k'
                    )
                    || (
                           $last_last_nonblank_code_token eq 'bless'
                        && $last_last_nonblank_code_type eq 'k'
                        && (

                            $last_nonblank_code_token eq 'my'
                            || $last_nonblank_code_token eq '('
                        )
                    )
                  )
                {
                    push @{ $rK_bless_by_sub_seqno->{$current_sub_seqno} },
                      [ scalar( @{$rLL_new} ), $token ];
                }
            }
            elsif ( $type eq 'w' ) {
                if (   $last_nonblank_code_token eq 'use'
                    && $last_nonblank_code_type eq 'k' )
                {
                    if ( $token eq 'strict' ) { $self->[_saw_use_strict_] = 1 }
                }
            }
            else {
                # Could be something like '* STDERR' or '$ debug'
            }
        }

        # handle keywords
        elsif ( $type eq 'k' ) {
            if ( $token eq 'return' ) {

                # remember the new K of this 'return; this may be
                # off by 1 if a blank gets inserted before it
                push
                  @{ $rK_return_by_sub_seqno->{$current_sub_seqno} },
                  scalar( @{$rLL_new} );
            }
            if ( $token eq 'wantarray' ) {
                push
                  @{ $rK_wantarray_by_sub_seqno->{$current_sub_seqno} },
                  scalar( @{$rLL_new} );
            }
        }

        # handle semicolons
        elsif ( $type eq ';' ) {

            # Remove unnecessary semicolons, but not after bare
            # blocks, where it could be unsafe if the brace is
            # mis-tokenized.
            if (
                $rOpts->{'delete-semicolons'}
                && (
                    (
                           $last_nonblank_block_type
                        && $last_nonblank_code_type eq '}'
                        && (
                            $is_block_without_semicolon{
                                $last_nonblank_block_type}
                            || $last_nonblank_block_type =~ /$SUB_PATTERN/
                            || $last_nonblank_block_type =~ /^\w+:$/
                        )
                    )
                    || $last_nonblank_code_type eq ';'
                )
              )
            {

                # This looks like a deletable semicolon, but even if a
                # semicolon can be deleted it is not necessarily best to do
                # so.  We apply these additional rules for deletion:
                # - Always ok to delete a ';' at the end of a line
                # - Never delete a ';' before a '#' because it would
                #   promote it to a block comment.
                # - If a semicolon is not at the end of line, then only
                #   delete if it is followed by another semicolon or closing
                #   token.  This includes the comment rule.  It may take
                #   two passes to get to a final state, but it is a little
                #   safer.  For example, keep the first semicolon here:
                #      eval { sub bubba { ok(0) }; ok(0) } || ok(1);
                #   It is not required but adds some clarity.
                my $ok_to_delete = 1;
                if ( $KK < $Klast ) {
                    my $Kn = $self->K_next_nonblank($KK);
                    if ( defined($Kn) && $Kn <= $Klast ) {
                        my $next_nonblank_token_type = $rLL->[$Kn]->[_TYPE_];
                        $ok_to_delete = $next_nonblank_token_type eq ';'
                          || $next_nonblank_token_type eq '}';
                    }
                }

                # do not delete only nonblank token in a file
                else {
                    my $Kp = $self->K_previous_code( undef, $rLL_new );
                    my $Kn = $self->K_next_nonblank($KK);
                    $ok_to_delete = defined($Kn) || defined($Kp);
                }

                if ($ok_to_delete) {
                    $self->note_deleted_semicolon($input_line_number);
                    next;
                }
                else {
                    write_logfile_entry("Extra ';'\n");
                }
            }
        }

        elsif ( $type eq '->' ) {
            if ( $last_nonblank_code_token eq ')' ) {

                # save seqno of closing paren with arrow, ')->', git #171
                # (the paren seqno is still on the stack)
                my $seqno_paren = $seqno_stack{$depth_next};
                if ($seqno_paren) { push @seqno_paren_arrow, $seqno_paren }
            }
        }

        # delete repeated commas if requested
        elsif ( $type eq ',' ) {
            if (   $last_nonblank_code_type eq ','
                && $rOpts->{'delete-repeated-commas'} )
            {

                # Do not delete the leading comma of a line with a side
                # comment. This could promote the side comment to a block
                # comment.  See test 'mangle4.in'
                my $lno = 1 + $rLL->[$KK]->[_LINE_INDEX_];
                if ( $KK eq $Kfirst && $rLL->[$Klast]->[_TYPE_] eq '#' ) {
                    complain(
                        "repeated comma before side comment, not deleted\n",
                        $lno );
                }
                else {
                    complain( "deleted repeated ','\n", $lno );
                    next;
                }
            }
            elsif ($last_nonblank_code_type eq '=>'
                && $rOpts->{'delete-repeated-commas'} )
            {
                my $lno = 1 + $rLL->[$KK]->[_LINE_INDEX_];
                complain( "found '=>,' ... error?\n", $lno );
            }
            else {
                # not a repeated comma type
            }

            # remember input line index of first comma if -wtc is used
            if (%trailing_comma_rules) {
                my $seqno = $seqno_stack{ $depth_next - 1 };
                if ( defined($seqno)
                    && !defined( $self->[_rfirst_comma_line_index_]->{$seqno} )
                  )
                {
                    $self->[_rfirst_comma_line_index_]->{$seqno} =
                      $rtoken_vars->[_LINE_INDEX_];
                }
            }
        }

        # check a quote for problems
        elsif ( $type eq 'Q' ) {
            $self->check_Q( $KK, $Kfirst, $input_line_number )
              if ( $self->[_save_logfile_] );
        }

        # Old patch to add space to something like "x10".
        # Note: This is now done in the Tokenizer, but this code remains
        # for reference.
        elsif ( $type eq 'n' ) {
            if ( substr( $token, 0, 1 ) eq 'x' && $token =~ /^x\d+/ ) {
                $token =~ s/x/x /;
                $rtoken_vars->[_TOKEN_] = $token;
                if (DEVEL_MODE) {
                    Fault(<<EOM);
Near line $input_line_number, Unexpected need to split a token '$token' - this should now be done by the Tokenizer
EOM
                }
            }
        }

        elsif ( $type eq '=>' ) {
            if (   $last_nonblank_code_type eq '=>'
                && $rOpts->{'delete-repeated-commas'} )
            {

                # Check for repeated '=>'s
                # Note that ',=>' is useful and called a winking fat comma

                # Do not delete the leading fat comma of a line with a side
                # comment. This could promote the side comment to a block
                # comment.  See test 'mangle4.in'
                my $lno = 1 + $rLL->[$KK]->[_LINE_INDEX_];
                if ( $KK eq $Kfirst && $rLL->[$Klast]->[_TYPE_] eq '#' ) {
                    complain(
                        "-repeated '=>' before side comment, not deleted\n",
                        $lno );
                }
                else {
                    complain( "deleted repeated '=>'\n", $lno );
                    next;
                }
            }

            # remember input line index of first '=>' if -wtc is used
            if (%trailing_comma_rules) {
                my $seqno = $seqno_stack{ $depth_next - 1 };
                if ( defined($seqno)
                    && !defined( $self->[_rfirst_comma_line_index_]->{$seqno} )
                  )
                {
                    $self->[_rfirst_comma_line_index_]->{$seqno} =
                      $rtoken_vars->[_LINE_INDEX_];
                }
            }
        }

        # check for a qw quote
        elsif ( $type eq 'q' ) {

            # Trim spaces from right of qw quotes.  Also trim from the left for
            # safety (the tokenizer should have done this).
            # To avoid trimming qw quotes use -ntqw; this causes the
            # tokenizer to set them as type 'Q' instead of 'q'.
            $token =~ s/^ \s+ | \s+ $//gx;
            $rtoken_vars->[_TOKEN_] = $token;
            if ( $self->[_save_logfile_] && $token =~ /\t/ ) {
                $self->note_embedded_tab($input_line_number);
            }
            if (   $rwhitespace_flags->[$KK] == WS_YES
                && @{$rLL_new}
                && $rLL_new->[-1]->[_TYPE_] ne 'b'
                && $rOpts_add_whitespace )
            {
                $self->store_token();
            }
            $self->store_token($rtoken_vars);
            next;
        }

        # Remove space after '<<'. Note that perl may use a space after
        # '<<' to guess tokenization for numeric targets. See git #174.
        elsif ( $type eq 'h' ) {
            if ( index( $token, SPACE ) > 0 || index( $token, "\t" ) > 0 ) {
                if ( $token =~ /^ (\<\<\~?) \s+ ([^\d].*) $/x ) {
                    $token = $1 . $2;
                    $rtoken_vars->[_TOKEN_] = $token;
                }
            }
        }
        elsif ( $type eq 'S' ) {

            # Trim spaces in sub definitions

            # save the NEW index of this token which will normally
            # be @{$rLL_new} plus 1 because a blank is usually inserted
            # ahead of it. The user routine will back up if necessary.
            # Note that an isolated prototype starting on new line will
            # be marked as 'S' but start with '(' and must be skipped.
            if ( substr( $token, 0, 1 ) ne '(' ) {

                $K_last_S = @{$rLL_new} + 1;

                # also, remember if this is a 'my' sub
                $K_last_S_is_my = $last_nonblank_code_type eq 'k'
                  && (
                    $last_nonblank_code_token eq 'my'
                    || (   $last_nonblank_code_token eq 'sub'
                        && $last_last_nonblank_code_type eq 'k'
                        && $last_last_nonblank_code_token eq 'my' )
                  );
            }

            # Note: an asub with prototype like this will come this way
            # and be partially treated as a named sub
            #     sub () {

            # -spp = 0 : no space before opening prototype paren
            # -spp = 1 : stable (follow input spacing)
            # -spp = 2 : always space before opening prototype paren
            if ( !defined($rOpts_space_prototype_paren)
                || $rOpts_space_prototype_paren == 1 )
            {
                ## default: stable
            }
            elsif ( $rOpts_space_prototype_paren == 0 ) {
                $token =~ s/\s+\(/\(/;
            }
            elsif ( $rOpts_space_prototype_paren == 2 ) {
                $token =~ s/\(/ (/;
            }
            else {
                ## should have been caught with the integer range check
                ## continue with the default
                DEVEL_MODE && Fault(<<EOM);
unexpected integer value space-prototype-paren=$rOpts_space_prototype_paren
EOM
            }

            # one space max, and no tabs
            $token =~ s/\s+/ /g;
            $rtoken_vars->[_TOKEN_] = $token;

            $self->[_ris_special_identifier_token_]->{$token} = 'sub';
        }

        # and trim spaces in package statements (added for c250)
        elsif ( $type eq 'P' ) {

            # clean up spaces in package identifiers, like
            #   "package        Bob::Dog;"
            if ( $token =~ s/\s+/ /g ) {
                $rtoken_vars->[_TOKEN_] = $token;
                $self->[_ris_special_identifier_token_]->{$token} = 'package';
            }

            # remember the new K of this package; this may be
            # off by 1 if a blank gets inserted before it
            push @{$rK_package_list}, scalar( @{$rLL_new} );
        }

        # change 'LABEL   :'   to 'LABEL:'
        elsif ( $type eq 'J' ) {
            $token =~ s/\s+//g;
            $rtoken_vars->[_TOKEN_] = $token;
        }

        else {
            # no special processing for this token type
        }

        # Store this token with possible previous blank
        if (   $rwhitespace_flags->[$KK] == WS_YES
            && @{$rLL_new}
            && $rLL_new->[-1]->[_TYPE_] ne 'b'
            && $rOpts_add_whitespace )
        {
            $self->store_token();
        }
        $self->store_token($rtoken_vars);

    }    # End token loop

    return;
} ## end sub respace_tokens_inner_loop

sub respace_post_loop_ops {

    my ($self) = @_;

    # We have just completed the 'respace' operation, in which we have made
    # a pass through all tokens and set the whitespace between tokens to be
    # according to user settings.  The new tokens have been placed in the new
    # token list '$rLL_new'. Now we have to go through this new list and
    # define some indexes which allow quick access into it.

    return unless ( @{$rLL_new} );

    # Setup array for finding the next sequence number after any token
    my @K_next_seqno_by_K;
    my $K_last = 0;
    foreach my $K (@K_sequenced_token_list) {
        push @K_next_seqno_by_K, ($K) x ( $K - $K_last );
        $K_last = $K;
    }

    # Note: here is the slow way to do the above loop (100 ms)
    ## foreach my $KK ( $K_last .. $K - 1 ) {
    ##     $K_next_seqno_by_K[$KK] = $K;
    ## }

    # This is faster (63 ms)
    ## my @q = ( $K_last .. $K - 1 );
    ## @K_next_seqno_by_K[@q] = ($K) x scalar(@q);

    # The push method above is fastest, at 37 ms in my benchmark.

    $self->[_rK_next_seqno_by_K_]      = \@K_next_seqno_by_K;
    $self->[_rK_sequenced_token_list_] = \@K_sequenced_token_list;

    # Verify that arrays @K_sequenced_token_list and @{$rSS} are parallel
    # arrays, meaning that they have a common array index 'I'. This index maybe
    # be found by seqno with rI_container and rI_closing.
    if (DEVEL_MODE) {
        my $num_rSS  = @{ $self->[_rSS_] };
        my $num_Kseq = @K_sequenced_token_list;

        # If this error occurs, we have gained or lost one or more of the
        # sequenced tokens received from the tokenizer. This should never
        # happen.
        if ( $num_rSS != $num_Kseq ) {
            Fault(<<EOM);
num_rSS= $num_rSS != num_Kseq=$num_Kseq
EOM
        }
    }

    # Find and remember lists by sequence number
    foreach my $seqno ( keys %{$K_opening_container} ) {
        my $K_opening = $K_opening_container->{$seqno};
        next unless defined($K_opening);

        # code errors may leave undefined closing tokens
        my $K_closing = $K_closing_container->{$seqno};
        next unless defined($K_closing);

        my $lx_open   = $rLL_new->[$K_opening]->[_LINE_INDEX_];
        my $lx_close  = $rLL_new->[$K_closing]->[_LINE_INDEX_];
        my $line_diff = $lx_close - $lx_open;
        $ris_broken_container->{$seqno} = $line_diff;

        # See if this is a list
        my $is_list;
        my $rtype_count = $rtype_count_by_seqno->{$seqno};
        if ($rtype_count) {
            my $comma_count     = $rtype_count->{','};
            my $fat_comma_count = $rtype_count->{'=>'};
            my $semicolon_count = $rtype_count->{';'};
            if ( $rtype_count->{'f'} ) {
                $semicolon_count += $rtype_count->{'f'};
            }

            # We will define a list to be a container with one or more commas
            # and no semicolons. Note that we have included the semicolons
            # in a 'for' container in the semicolon count to keep c-style for
            # statements from being formatted as lists.
            if ( ( $comma_count || $fat_comma_count ) && !$semicolon_count ) {
                $is_list = 1;

                # We need to do one more check for a parenthesized list:
                # At an opening paren following certain tokens, such as 'if',
                # we do not want to format the contents as a list.
                if ( $rLL_new->[$K_opening]->[_TOKEN_] eq '(' ) {
                    my $Kp = $self->K_previous_code( $K_opening, $rLL_new );
                    if ( defined($Kp) ) {
                        my $type_p  = $rLL_new->[$Kp]->[_TYPE_];
                        my $token_p = $rLL_new->[$Kp]->[_TOKEN_];
                        $is_list =
                          $type_p eq 'k'
                          ? !$is_nonlist_keyword{$token_p}
                          : !$is_nonlist_type{$type_p};
                    }
                }
            }
        }

        # Look for a block brace marked as uncertain.  If the tokenizer thinks
        # its guess is uncertain for the type of a brace following an unknown
        # bareword then it adds a trailing space as a signal.  We can fix the
        # type here now that we have had a better look at the contents of the
        # container. This fixes case b1085. To find the corresponding code in
        # Tokenizer.pm search for 'b1085' with an editor.
        my $block_type = $rblock_type_of_seqno->{$seqno};
        if ( $block_type && substr( $block_type, -1, 1 ) eq SPACE ) {

            # Always remove the trailing space
            $block_type =~ s/\s+$//;

            # Try to filter out parenless sub calls
            my $Knn1 = $self->K_next_nonblank( $K_opening, $rLL_new );
            my $Knn2;
            if ( defined($Knn1) ) {
                $Knn2 = $self->K_next_nonblank( $Knn1, $rLL_new );
            }
            my $type_nn1 = defined($Knn1) ? $rLL_new->[$Knn1]->[_TYPE_] : 'b';
            my $type_nn2 = defined($Knn2) ? $rLL_new->[$Knn2]->[_TYPE_] : 'b';

            #   if ( $type_nn1 =~ /^[wU]$/ && $type_nn2 =~ /^[wiqQGCZ]$/ ) {
            if ( $wU{$type_nn1} && $wiq{$type_nn2} ) {
                $is_list = 0;
            }

            # Convert to a hash brace if it looks like it holds a list
            if ($is_list) {
                $block_type = EMPTY_STRING;
            }

            $rblock_type_of_seqno->{$seqno} = $block_type;
        }

        # Handle a list container
        if ( $is_list && !$block_type ) {
            $ris_list_by_seqno->{$seqno} = $seqno;

            # Update parent container properties
            my $depth              = 0;
            my $rparent_seqno_list = $self->get_parent_containers($seqno);
            foreach my $seqno_parent ( @{$rparent_seqno_list} ) {
                $depth++;

                # for $rhas_list we need to save the minimum depth
                if (  !$rhas_list->{$seqno_parent}
                    || $rhas_list->{$seqno_parent} > $depth )
                {
                    $rhas_list->{$seqno_parent} = $depth;
                }

                if ($line_diff) {
                    $rhas_broken_list->{$seqno_parent} = 1;

                    # Patch1: We need to mark broken lists with non-terminal
                    # line-ending commas for the -bbx=2 parameter. This insures
                    # that the list will stay broken.  Otherwise the flag
                    # -bbx=2 can be unstable.  This fixes case b789 and b938.

                    # Patch2: Updated to also require either one fat comma or
                    # one more line-ending comma.  Fixes cases b1069 b1070
                    # b1072 b1076.
                    if (
                        $rlec_count_by_seqno->{$seqno}
                        && (   $rlec_count_by_seqno->{$seqno} > 1
                            || $rtype_count_by_seqno->{$seqno}->{'=>'} )
                      )
                    {
                        $rhas_broken_list_with_lec->{$seqno_parent} = 1;
                    }
                }
            }
        }

        # Handle code blocks ...
        # The -lp option needs to know if a container holds a code block
        elsif ( $block_type && $rOpts_line_up_parentheses ) {

            # Update parent container properties
            my $rparent_seqno_list = $self->get_parent_containers($seqno);
            foreach my $seqno_parent ( @{$rparent_seqno_list} ) {
                $rhas_code_block->{$seqno_parent}        = 1;
                $rhas_broken_code_block->{$seqno_parent} = $line_diff;
            }
        }
        else {
            # nothing special to do for this container token
        }
    }

    # Find containers with ternaries, needed for -lp formatting.
    foreach my $seqno ( keys %{$K_opening_ternary} ) {

        # Update parent container properties
        $self->mark_parent_containers( $seqno, $rhas_ternary );
    }

    # Turn off -lp for containers with here-docs with text within a container,
    # since they have their own fixed indentation.  Fixes case b1081.
    if ($rOpts_line_up_parentheses) {
        foreach my $seqno ( keys %K_first_here_doc_by_seqno ) {
            my $Kh      = $K_first_here_doc_by_seqno{$seqno};
            my $Kc      = $K_closing_container->{$seqno};
            my $line_Kh = $rLL_new->[$Kh]->[_LINE_INDEX_];
            my $line_Kc = $rLL_new->[$Kc]->[_LINE_INDEX_];
            next if ( $line_Kh == $line_Kc );
            $ris_excluded_lp_container->{$seqno} = 1;
        }
    }

    # Set a flag to turn off -cab=3 in complex structures.  Otherwise,
    # instability can occur.  When it is overridden the behavior of the closest
    # match, -cab=2, will be used instead.  This fixes cases b1096 b1113.
    if ( $rOpts_comma_arrow_breakpoints == 3 ) {
        foreach my $seqno ( keys %{$K_opening_container} ) {

            my $rtype_count = $rtype_count_by_seqno->{$seqno};
            next unless ( $rtype_count && $rtype_count->{'=>'} );

            # override -cab=3 if this contains a sub-list
            if ( !defined( $roverride_cab3->{$seqno} ) ) {
                if ( $rhas_list->{$seqno} ) {
                    $roverride_cab3->{$seqno} = 2;
                }

                # or if this is a sub-list of its parent container
                else {
                    my $seqno_parent = $rparent_of_seqno->{$seqno};
                    if ( defined($seqno_parent)
                        && $ris_list_by_seqno->{$seqno_parent} )
                    {
                        $roverride_cab3->{$seqno} = 2;
                    }
                }
            }
        }
    }

    # Search for chains of method calls of the form (git #171)
    #      )->xxx( )->xxx(  )->
    # We have previously saved the seqno of all ')->' combinations
    my $in_chain_seqno = 0;
    while ( my $seqno = shift @seqno_paren_arrow ) {

        #      ) -> func (
        #      ) -> func (
        # $Kc--^         ^--$K_test

        my $Kc      = $K_closing_container->{$seqno};
        my $K_arrow = $self->K_next_nonblank( $Kc,      $rLL_new );
        my $K_func  = $self->K_next_nonblank( $K_arrow, $rLL_new );
        my $K_test  = $self->K_next_nonblank( $K_func,  $rLL_new );

        last if ( !defined($K_test) );

        # ignore index operation like ')->{' or ')->[' and end any chain
        my $tok = $rLL_new->[$K_func]->[_TOKEN_];
        if ( $tok eq '[' || $tok eq '{' ) { $in_chain_seqno = 0; next }

        # mark seqno of parens which are part of a call chain
        my $seqno_start = $in_chain_seqno ? $in_chain_seqno : $seqno;
        $rseqno_arrow_call_chain_start->{$seqno} = $seqno_start;

        # save a list of the arrows, needed to set line breaks
        push @{ $rarrow_call_chain->{$seqno_start} }, $K_arrow;

        # See if this chain continues
        if (   @seqno_paren_arrow
            && defined($K_test)
            && $rLL_new->[$K_test]->[_TOKEN_] eq '('
            && $rLL_new->[$K_test]->[_TYPE_SEQUENCE_] eq $seqno_paren_arrow[0] )
        {
            $in_chain_seqno ||= $seqno;
        }
        else { $in_chain_seqno = 0 }
    } ## end while ( my $seqno = shift...)

    # For efficiency, remove chains with length < 2
    foreach my $seqno ( keys %{$rseqno_arrow_call_chain_start} ) {
        my $seqno_start = $rseqno_arrow_call_chain_start->{$seqno};
        if ( @{ $rarrow_call_chain->{$seqno_start} } < 2 ) {
            delete $rseqno_arrow_call_chain_start->{$seqno};
            delete $rarrow_call_chain->{$seqno_start};
        }
    }

    return;
} ## end sub respace_post_loop_ops

sub store_token {

    my ( $self, ($item) ) = @_;

    # Store one token during respace operations

    # Given:
    #  $item =
    #    if defined      => reference to a token to be stored
    #    if not defined  => make and store a blank space

    # NOTE: this sub is called once per token so coding efficiency is critical.

    # If no arg, then make and store a blank space
    if ( !$item ) {

        #  - Never start the array with a space, and
        #  - Never store two consecutive spaces
        if ( @{$rLL_new} && $rLL_new->[-1]->[_TYPE_] ne 'b' ) {

            # Note that the level and ci_level of newly created spaces should
            # be the same as the previous token.  Otherwise the coding for the
            # -lp option can create a blinking state in some rare cases.
            # (see b1109, b1110).
            $item                    = [];
            $item->[_TYPE_]          = 'b';
            $item->[_TOKEN_]         = SPACE;
            $item->[_TYPE_SEQUENCE_] = EMPTY_STRING;
            $item->[_LINE_INDEX_]    = $rLL_new->[-1]->[_LINE_INDEX_];
            $item->[_LEVEL_]         = $rLL_new->[-1]->[_LEVEL_];
        }
        else { return }
    }

    # The next multiple assignment statements are significantly faster than
    # doing them one-by-one.
    my (

        $type,
        $token,
        $type_sequence,

      ) = @{$item}[

      _TYPE_,
      _TOKEN_,
      _TYPE_SEQUENCE_,

      ];

    # Set the token length.  Later it may be adjusted again if phantom or
    # ignoring side comment lengths. It is always okay to calculate the length
    # with $length_function->() if it is defined, but it is extremely slow so
    # we avoid it and use the builtin length() for printable ascii tokens.
    # Note: non-printable ascii characters (like tab) may get different lengths
    # by the two methods, so we have to use $length_function for them.
    my $token_length =
      (      $length_function
          && !$is_ascii_type{$type}
          && $token =~ /[[:^ascii:][:^print:]]/ )
      ? $length_function->($token)
      : length($token);

    # handle blanks
    if ( $type eq 'b' ) {

        # Do not output consecutive blanks. This situation should have been
        # prevented earlier, but it is worth checking because later routines
        # make this assumption.
        if ( @{$rLL_new} && $rLL_new->[-1]->[_TYPE_] eq 'b' ) {
            return;
        }
    }

    # handle comments
    elsif ( $type eq '#' ) {

        # trim comments if necessary
        my $ord = ord( substr( $token, -1, 1 ) );
        if (
            $ord > 0
            && (   $ord < ORD_PRINTABLE_MIN
                || $ord > ORD_PRINTABLE_MAX )
            && $token =~ s/\s+$//
          )
        {
            $token_length =
              $length_function ? $length_function->($token) : length($token);
            $item->[_TOKEN_] = $token;
        }

        my $ignore_sc_length = $rOpts_ignore_side_comment_lengths;

        # Ignore length of '## no critic' comments even if -iscl is not set
        if (   !$ignore_sc_length
            && !$rOpts_ignore_perlcritic_comments
            && $token_length > 10
            && substr( $token, 1, 1 ) eq '#'
            && $token =~ /^##\s*no\s+critic\b/ )
        {

            # Is it a side comment or a block comment?
            if ( $Ktoken_vars > $Kfirst_old ) {

                # This is a side comment. If we do not ignore its length, and
                # -iscl has not been set, then the line could be broken and
                # perlcritic will complain. So this is essential:
                $ignore_sc_length ||= 1;

                # It would be a good idea to also make this behave like a
                # static side comment, but this is not essential and would
                # change existing formatting.  So we will leave it to the user
                # to set -ssc if desired.
            }
            else {

                # This is a full-line (block) comment.
                # It would be a good idea to make this behave like a static
                # block comment, but this is not essential and would change
                # existing formatting.  So we will leave it to the user to
                # set -sbc if desired
            }
        }

        # Set length of ignored side comments as just 1
        if ( $ignore_sc_length && ( !$CODE_type || $CODE_type eq 'HSC' ) ) {
            $token_length = 1;
        }

        my $seqno = $seqno_stack{ $depth_next - 1 };
        if ( defined($seqno) ) {
            $self->[_rblank_and_comment_count_]->{$seqno} += 1
              if ( $CODE_type eq 'BC' );
            if ( !$ris_permanently_broken->{$seqno} ) {
                $ris_permanently_broken->{$seqno} = 1;
                $self->mark_parent_containers( $seqno,
                    $ris_permanently_broken );
            }
        }
    }

    # handle non-blanks and non-comments
    else {

        my $block_type;

        # check for a sequenced item (i.e., container or ?/:)
        if ($type_sequence) {

            # This will be the index of this item in the new array
            my $KK_new = @{$rLL_new};

            # remember new K of sequence tokens
            push @K_sequenced_token_list, $KK_new;

            if ( $is_opening_token{$token} ) {

                $K_opening_container->{$type_sequence} = $KK_new;
                $block_type = $rblock_type_of_seqno->{$type_sequence};

                # Fix for case b1100: Count a line ending in ', [' as having
                # a line-ending comma.  Otherwise, these commas can be hidden
                # with something like --opening-square-bracket-right
                if (   $last_nonblank_code_type eq ','
                    && $Ktoken_vars == $Klast_old_code
                    && $Ktoken_vars > $Kfirst_old )
                {
                    $rlec_count_by_seqno->{$type_sequence}++;
                }

                if (   $last_nonblank_code_type eq '='
                    || $last_nonblank_code_type eq '=>' )
                {
                    $ris_assigned_structure->{$type_sequence} =
                      $last_nonblank_code_type;
                }

                my $seqno_parent = $seqno_stack{ $depth_next - 1 };
                $seqno_parent = SEQ_ROOT unless defined($seqno_parent);
                push @{ $rchildren_of_seqno->{$seqno_parent} }, $type_sequence;
                $rparent_of_seqno->{$type_sequence}     = $seqno_parent;
                $seqno_stack{$depth_next}               = $type_sequence;
                $K_old_opening_by_seqno{$type_sequence} = $Ktoken_vars;
                $depth_next++;

                if ( $depth_next > $depth_next_max ) {
                    $depth_next_max = $depth_next;
                }
            }
            elsif ( $is_closing_token{$token} ) {

                $K_closing_container->{$type_sequence} = $KK_new;
                $block_type = $rblock_type_of_seqno->{$type_sequence};

                # Do not include terminal commas in counts
                if (   $last_nonblank_code_type eq ','
                    || $last_nonblank_code_type eq '=>' )
                {
                    $rtype_count_by_seqno->{$type_sequence}
                      ->{$last_nonblank_code_type}--;

                    if (   $Ktoken_vars == $Kfirst_old
                        && $last_nonblank_code_type eq ','
                        && $rlec_count_by_seqno->{$type_sequence} )
                    {
                        $rlec_count_by_seqno->{$type_sequence}--;
                    }

                    # set flag to retain trailing comma breaks (b1493, c416)
                    # length check needed to ignore phantom commas (b1496)
                    if (   $last_nonblank_code_type eq ','
                        && $trailing_comma_break_rules{$token}
                        && length($last_nonblank_code_token) )
                    {

                        my $rule = $trailing_comma_break_rules{$token};
                        my ( $letter, $paren_flag ) = @{$rule};
                        my $match;
                        if ( $letter eq 'b' ) {
                            $match = $Ktoken_vars == $Kfirst_old;
                        }
                        elsif ( $letter eq 'm' ) {
                            $match = $K_old_opening_by_seqno{$type_sequence} <
                              $Kfirst_old;
                        }
                        elsif ( $letter eq '1' || $letter eq '*' ) {
                            $match = 1;
                        }
                        else {
                            ## shouldn't happen - treat as 'b' for now
                            DEVEL_MODE && Fault(<<EOM);
unexpected option '$letter' for --trailing-comma-break-flag at token '$token'
EOM
                            $match = $Ktoken_vars == $Kfirst_old;
                        }

                        if ( $match && $paren_flag && $token eq ')' ) {
                            $match &&=
                              $self->match_paren_control_flag( $type_sequence,
                                $paren_flag, $rLL_new );
                        }

                        if ($match) {
                            $self->[_rbreak_container_]->{$type_sequence} = 1;
                        }
                    }
                }

                # Update the stack...
                $depth_next--;
            }
            else {

                # For ternary, note parent but do not include as child
                my $seqno_parent = $seqno_stack{ $depth_next - 1 };
                $seqno_parent = SEQ_ROOT unless defined($seqno_parent);
                $rparent_of_seqno->{$type_sequence} = $seqno_parent;

                # These are not yet used but could be useful
                if ( $token eq '?' ) {
                    $K_opening_ternary->{$type_sequence} = $KK_new;
                }
                elsif ( $token eq ':' ) {
                    $K_closing_ternary->{$type_sequence} = $KK_new;
                }
                else {

                    # We really shouldn't arrive here, just being cautious:
                    # The only sequenced types output by the tokenizer are the
                    # opening & closing containers and the ternary types. Each
                    # of those was checked above. So we would only get here
                    # if the tokenizer has been changed to mark some other
                    # tokens with sequence numbers.
                    if (DEVEL_MODE) {
                        Fault(
"Unexpected token type with sequence number: type='$type', seqno='$type_sequence'"
                        );
                    }
                }
            }
        }

        # Remember the most recent two non-blank, non-comment tokens.
        # NOTE: the phantom semicolon code may change the output stack
        # without updating these values.  Phantom semicolons are considered
        # the same as blanks for now, but future needs might change that.
        # See the related note in sub 'add_phantom_semicolon'.
        $last_last_nonblank_code_type  = $last_nonblank_code_type;
        $last_last_nonblank_code_token = $last_nonblank_code_token;

        $last_nonblank_code_type  = $type;
        $last_nonblank_code_token = $token;
        $last_nonblank_block_type = $block_type;

        # count selected types
        if ( $is_counted_type{$type} ) {
            my $seqno = $seqno_stack{ $depth_next - 1 };
            if ( defined($seqno) ) {
                $rtype_count_by_seqno->{$seqno}->{$type}++;

                # Count line-ending commas for -bbx
                if ( $type eq ',' && $Ktoken_vars == $Klast_old_code ) {
                    $rlec_count_by_seqno->{$seqno}++;
                }

                # Remember index of first here doc target
                if ( $type eq 'h' && !$K_first_here_doc_by_seqno{$seqno} ) {
                    my $KK_new = @{$rLL_new};
                    $K_first_here_doc_by_seqno{$seqno} = $KK_new;

                    # the here doc which follows makes the container broken
                    if ( !$ris_permanently_broken->{$seqno} ) {
                        $ris_permanently_broken->{$seqno} = 1;
                        $self->mark_parent_containers( $seqno,
                            $ris_permanently_broken );
                    }
                }
            }
        }
    }

    # cumulative length is the length sum including this token
    $cumulative_length += $token_length;

    $item->[_CUMULATIVE_LENGTH_] = $cumulative_length;
    $item->[_TOKEN_LENGTH_]      = $token_length;

    # For reference, here is how to get the parent sequence number.
    # This is not used because it is slower than finding it on the fly
    # in sub parent_seqno_by_K:

    # my $seqno_parent =
    #     $type_sequence && $is_opening_token{$token}
    #   ? $seqno_stack{ $depth_next - 2 }
    #   : $seqno_stack{ $depth_next - 1 };
    # my $KK = @{$rLL_new};
    # $rseqno_of_parent_by_K->{$KK} = $seqno_parent;

    # and finally, add this item to the new array
    push @{$rLL_new}, $item;
    return;
} ## end sub store_token

sub add_phantom_semicolon {

    my ( $self, $KK ) = @_;

    # The token at old index $KK is a closing block brace, and not preceded
    # by a semicolon. Before we push it onto the new token list, we may
    # want to add a phantom semicolon which can be activated if the the
    # block is broken on output.

    # We are only adding semicolons for certain block types
    my $type_sequence = $rLL->[$KK]->[_TYPE_SEQUENCE_];
    return unless ($type_sequence);
    my $block_type = $rblock_type_of_seqno->{$type_sequence};
    return unless ($block_type);
    return
      unless ( $ok_to_add_semicolon_for_block_type{$block_type}
        || $block_type =~ /^(sub|package)/
        || $block_type =~ /^\w+\:$/ );

    # Find the most recent token in the new token list
    my $Kp = $self->K_previous_nonblank( undef, $rLL_new );
    return unless ( defined($Kp) );    # shouldn't happen except for bad input

    my $type_p          = $rLL_new->[$Kp]->[_TYPE_];
    my $token_p         = $rLL_new->[$Kp]->[_TOKEN_];
    my $type_sequence_p = $rLL_new->[$Kp]->[_TYPE_SEQUENCE_];

    # Do not add a semicolon if...
    return
      if (

        # it would follow a comment (and be isolated)
        $type_p eq '#'

        # it follows a code block ( because they are not always wanted
        # there and may add clutter)
        || $type_sequence_p && $rblock_type_of_seqno->{$type_sequence_p}

        # it would follow a label
        || $type_p eq 'J'

        # it would be inside a 'format' statement (and cause syntax error)
        || (   $type_p eq 'k'
            && $token_p =~ /format/ )

      );

    # Do not add a semicolon if it would impede a weld with an immediately
    # following closing token...like this
    #   { ( some code ) }
    #                  ^--No semicolon can go here

    # look at the previous token... note use of the _NEW rLL array here,
    # but sequence numbers are invariant.
    my $seqno_inner = $rLL_new->[$Kp]->[_TYPE_SEQUENCE_];

    # If it is also a CLOSING token we have to look closer...
    if (
           $seqno_inner
        && $is_closing_token{$token_p}

        # we only need to look if there is just one inner container..
        && defined( $rchildren_of_seqno->{$type_sequence} )
        && @{ $rchildren_of_seqno->{$type_sequence} } == 1
      )
    {

        # Go back and see if the corresponding two OPENING tokens are also
        # together.  Note that we are using the OLD K indexing here:
        my $K_outer_opening = $K_old_opening_by_seqno{$type_sequence};
        if ( defined($K_outer_opening) ) {
            my $K_nxt = $self->K_next_nonblank($K_outer_opening);
            if ( defined($K_nxt) ) {
                my $seqno_nxt = $rLL->[$K_nxt]->[_TYPE_SEQUENCE_];

                # Is the next token after the outer opening the same as
                # our inner closing (i.e. same sequence number)?
                # If so, do not insert a semicolon here.
                return if ( $seqno_nxt && $seqno_nxt == $seqno_inner );
            }
        }
    }

    # We will insert an empty semicolon here as a placeholder.  Later, if
    # it becomes the last token on a line, we will bring it to life.  The
    # advantage of doing this is that (1) we just have to check line
    # endings, and (2) the phantom semicolon has zero width and therefore
    # won't cause needless breaks of one-line blocks.
    my $Ktop = -1;
    if (   $rLL_new->[$Ktop]->[_TYPE_] eq 'b'
        && $want_left_space{';'} == WS_NO )
    {

        # convert the blank into a semicolon..
        # be careful: we are working on the new stack top
        # on a token which has been stored.
        my $rcopy = copy_token_as_type( $rLL_new->[$Ktop], 'b', SPACE );

        # Convert the existing blank to:
        #   a phantom semicolon for one_line_block option = 0 or 1
        #   a real semicolon    for one_line_block option = 2
        my $tok     = EMPTY_STRING;
        my $len_tok = 0;
        if ( $rOpts_one_line_block_semicolons == 2 ) {
            $tok     = ';';
            $len_tok = 1;
        }

        $rLL_new->[$Ktop]->[_TOKEN_]        = $tok;
        $rLL_new->[$Ktop]->[_TOKEN_LENGTH_] = $len_tok;
        $rLL_new->[$Ktop]->[_TYPE_]         = ';';

        $self->[_rtype_count_by_seqno_]->{$type_sequence}->{';'}++;

        # NOTE: we are changing the output stack without updating variables
        # $last_nonblank_code_type, etc. Future needs might require that
        # those variables be updated here.  For now, it seems ok to skip
        # this.

        # Then store a new blank
        $self->store_token($rcopy);
    }
    else {

        # Patch for issue c078: keep line indexes in order.  If the top
        # token is a space that we are keeping (due to '-wls=';') then
        # we have to check that old line indexes stay in order.
        # In very rare
        # instances in which side comments have been deleted and converted
        # into blanks, we may have filtered down multiple blanks into just
        # one. In that case the top blank may have a higher line number
        # than the previous nonblank token. Although the line indexes of
        # blanks are not really significant, we need to keep them in order
        # in order to pass error checks.
        if ( $rLL_new->[$Ktop]->[_TYPE_] eq 'b' ) {
            my $old_top_ix = $rLL_new->[$Ktop]->[_LINE_INDEX_];
            my $new_top_ix = $rLL_new->[$Kp]->[_LINE_INDEX_];
            if ( $new_top_ix < $old_top_ix ) {
                $rLL_new->[$Ktop]->[_LINE_INDEX_] = $new_top_ix;
            }
        }

        my $rcopy = copy_token_as_type( $rLL_new->[$Kp], ';', EMPTY_STRING );
        $self->store_token($rcopy);
    }
    return;
} ## end sub add_phantom_semicolon

sub delay_trailing_comma_op {

    my ( $self, $if_add, $stable_flag ) = @_;

    # Given:
    #  $if_add = true for add comma operation, false for delete
    #  $stable_flag = true if -btct setting makes this stable

    # Returns:
    #   true if a trailing comma operation should be skipped
    #   false otherwise

    # This can prevent unwanted path-dependent formatting when both
    # line breaks are changing and we are only adding or deleting
    # commas, but not both. See git #156

    # Get user setting, if any
    my $delay = $rOpts->{'delay-trailing-comma-operations'};

    # Set default if not defined:
    #  - if deleting: delay always ok
    #  - if adding:   delay ok unless breaks will be stabilized by -btct setting
    # Explanation:
    #  - deleting can be irreversible, so it is safest to delay
    #  - adding, along with -btct, can save original line breaks which would
    #    be lost otherwise, so it may be best not to delay.
    if ( !defined($delay) ) {
        $delay = $if_add ? !$stable_flag : 1;
    }

    return if ( !$delay );

    # We must be at the first of multiple iterations for a delay
    my $it             = Perl::Tidy::get_iteration_count();
    my $max_iterations = $rOpts->{'iterations'};
    if ( $it == 1 && $max_iterations > 1 ) {

        # if so, set flag to request another iteration
        $self->[_want_second_iteration_] = 1;
        return 1;
    }
    return;
} ## end sub delay_trailing_comma_op

my %is_b_i_h;

BEGIN {
    my @q = qw( b i h );
    @is_b_i_h{@q} = (1) x scalar(@q);
}

sub add_trailing_comma {

    # Implement the --add-trailing-commas flag to the line end before index $KK:

    my ( $self, $KK, $Kfirst, $trailing_comma_add_rule ) = @_;

    # Input parameter:
    #  $KK = index of closing token in old ($rLL) token list
    #        which starts a new line and is not preceded by a comma
    #  $Kfirst = index of first token on the current line of input tokens
    #  $trailing_comma_add_rule = user control flags for adding trailng commas

    # For example, we might want to add a comma here:

    #   bless {
    #           _name   => $name,
    #           _price  => $price,
    #           _rebate => $rebate  <------ location of possible bare comma
    #          }, $pkg;
    #          ^-------------------closing token at index $KK on new line

    # Do not add a comma if it would follow a comment
    my $Kp = $self->K_previous_nonblank( undef, $rLL_new );
    return unless ( defined($Kp) );
    my $type_p = $rLL_new->[$Kp]->[_TYPE_];
    return if ( $type_p eq '#' );

    return unless ($trailing_comma_add_rule);
    my ( $trailing_comma_style, $paren_flag, $stable_flag ) =
      @{$trailing_comma_add_rule};

    # see if the user wants a trailing comma here
    my $match =
      $self->match_trailing_comma_rule( $KK, $Kfirst, $Kp,
        $trailing_comma_style, $paren_flag, $stable_flag, 1 );

    # Do not add if this would cause excess line length and possible
    # instability.  This is b1458 fix method 1.  This is more general than fix
    # method 2, below, which also worked.  So this is not needed for b1458 but
    # re-activated and updated for b1495.
    if (   $match
        && $rOpts_delete_trailing_commas
        && $KK > 0 )
    {
        if ( !$stable_flag && $is_b_i_h{$trailing_comma_style} ) {
            my $line_index     = $rLL->[ $KK - 1 ]->[_LINE_INDEX_];
            my $rlines         = $self->[_rlines_];
            my $line_of_tokens = $rlines->[$line_index];
            my $input_line     = $line_of_tokens->{_line_text};
            my $len =
                $length_function
              ? $length_function->($input_line) - 1
              : length($input_line) - 1;
            my $new_len = $want_left_space{','} ? $len + 2 : $len + 1;
            my $level   = $rLL->[$Kfirst]->[_LEVEL_];
            my $max_len = $maximum_line_length_at_level[$level];

            if ( $new_len > $max_len ) {
                $match = 0;
            }
        }
    }

    # If so, and not delayed, add a comma
    if ( $match && !$self->delay_trailing_comma_op( 1, $stable_flag ) ) {

        # any blank after the comma will be added before the closing paren,
        # below
        $self->store_new_token( ',', ',', $Kp );
    }
    return;

} ## end sub add_trailing_comma

sub delete_trailing_comma {

    my ( $self, $KK, $Kfirst, $trailing_comma_delete_rule ) = @_;

    # Apply the --delete-trailing-commas flag to the comma before index $KK

    # Input parameter:
    #  $KK = index of a closing token in OLD ($rLL) token list
    #        which is preceded by a comma on the same line.
    #  $Kfirst = index of first token on the current line of input tokens
    #  $delete_option = user control flag

    # Returns true if the comma was deleted

    # For example, we might want to delete this comma:
    #    my @asset = ("FASMX", "FASGX", "FASIX",);
    #    |                                     |^--------token at index $KK
    #    |                                     ^------comma of interest
    #    ^-------------token at $Kfirst

    # Verify that the previous token is a comma.  Note that we are working in
    # the new token list $rLL_new.
    my $Kp = $self->K_previous_nonblank( undef, $rLL_new );
    return unless ( defined($Kp) );
    if ( $rLL_new->[$Kp]->[_TYPE_] ne ',' ) {

        # there must be a '#' between the ',' and closing token; give up.
        return;
    }

    # Do not delete commas when formatting under stress to avoid instability.
    # This fixes b1389, b1390, b1391, b1392.  The $high_stress_level has
    # been found to work well for trailing commas.
    if ( $rLL_new->[$Kp]->[_LEVEL_] >= $high_stress_level ) {
        return;
    }

    return unless ($trailing_comma_delete_rule);
    my ( $trailing_comma_style, $paren_flag, $stable_flag ) =
      @{$trailing_comma_delete_rule};

    # See if the user wants this trailing comma
    my $match =
      $self->match_trailing_comma_rule( $KK, $Kfirst, $Kp,
        $trailing_comma_style, $paren_flag, $stable_flag, 0 );

    # Patch: the --noadd-whitespace flag can cause instability in complex
    # structures. In this case do not delete the comma. Fixes b1409.
    if ( !$match && !$rOpts_add_whitespace ) {
        my $Kn = $self->K_next_nonblank($KK);
        if ( defined($Kn) ) {
            my $type_n = $rLL->[$Kn]->[_TYPE_];
            if ( $type_n ne ';' && $type_n ne '#' ) { return }
        }
    }

    # b1458 fix method 2: do not remove a comma after a leading brace type 'R'
    # since it is under stress and could become unstable. This is a more
    # specific fix but the logic is cleaner than method 1.
    if (  !$match
        && $rOpts_add_trailing_commas
        && $rLL->[$Kfirst]->[_TYPE_] eq 'R' )
    {

        # previous old token should be the comma..
        my $Kp_old = $self->K_previous_nonblank( $KK, $rLL );
        if (   defined($Kp_old)
            && $Kp_old > $Kfirst
            && $rLL->[$Kp_old]->[_TYPE_] eq ',' )
        {

            # if the comma follows the first token of the line ..
            my $Kpp_old = $self->K_previous_nonblank( $Kp_old, $rLL );
            if ( defined($Kpp_old) && $Kpp_old eq $Kfirst ) {

                # do not delete it
                $match = 1;
            }
        }
    }

    # If no match and not delayed
    if ( !$match && !$self->delay_trailing_comma_op( 0, $stable_flag ) ) {

        # delete it
        return $self->unstore_last_nonblank_token(',');
    }
    return;

} ## end sub delete_trailing_comma

sub delete_weld_interfering_comma {

    my ( $self, $KK ) = @_;

    # Apply the flag '--delete-weld-interfering-commas' to the comma
    # before index $KK

    # Input parameter:
    #  $KK = index of a closing token in OLD ($rLL) token list
    #        which is preceded by a comma on the same line.

    # Returns true if the comma was deleted

    # For example, we might want to delete this comma:

    # my $tmpl = { foo => {no_override => 1, default => 42}, };
    #                                                     || ^------$KK
    #                                                     |^---$Kp
    #                                              $Kpp---^
    #
    # Note that:
    #  index $KK is in the old $rLL array, but
    #  indexes $Kp and $Kpp are in the new $rLL_new array.

    my $type_sequence = $rLL->[$KK]->[_TYPE_SEQUENCE_];
    return unless ($type_sequence);

    # Find the previous token and verify that it is a comma.
    my $Kp = $self->K_previous_nonblank( undef, $rLL_new );
    return unless ( defined($Kp) );
    if ( $rLL_new->[$Kp]->[_TYPE_] ne ',' ) {

        # it is not a comma, so give up ( it is probably a '#' )
        return;
    }

    # This must be the only comma in this list
    my $rtype_count = $self->[_rtype_count_by_seqno_]->{$type_sequence};
    return
      unless ( defined($rtype_count)
        && $rtype_count->{','}
        && $rtype_count->{','} == 1 );

    # Back up to the previous closing token
    my $Kpp = $self->K_previous_nonblank( $Kp, $rLL_new );
    return unless ( defined($Kpp) );
    my $seqno_pp = $rLL_new->[$Kpp]->[_TYPE_SEQUENCE_];
    my $type_pp  = $rLL_new->[$Kpp]->[_TYPE_];

    # The containers must be nesting (i.e., sequence numbers must differ by 1 )
    if ( $seqno_pp && $is_closing_type{$type_pp} ) {
        if ( $seqno_pp == $type_sequence + 1 ) {

            # remove the ',' from the top of the new token list
            return $self->unstore_last_nonblank_token(',');
        }
    }
    return;

} ## end sub delete_weld_interfering_comma

sub add_interbracket_arrow {
    my ($self) = @_;

    # Add a new '->' after the last token on the stack
    my $Kp = $self->K_previous_nonblank( undef, $rLL_new );
    return unless ( defined($Kp) );

    # verify that we are adding after a } or ]
    my $type_p = $rLL_new->[$Kp]->[_TYPE_];
    if ( $type_p ne 'R' && $type_p ne ']' ) {
        DEVEL_MODE && Fault("trying to store new arrow after type $type_p");
        return;
    }

    $self->store_new_token( '->', '->', $Kp );
    if ( $want_right_space{'->'} == WS_YES ) { $self->store_token() }

    return;
} ## end sub add_interbracket_arrow

sub delete_interbracket_arrow {
    my ($self) = @_;

    # Delete the last nonblank token on the stack which is an '->'
    my $Kp = $self->K_previous_nonblank( undef, $rLL_new );
    return unless ( defined($Kp) );

    # verify that we are deleting an '->'
    my $type_p = $rLL_new->[$Kp]->[_TYPE_];
    if ( $type_p ne '->' ) {
        DEVEL_MODE && Fault("trying to delete arrow but type $type_p");
        return;
    }

    $self->unstore_last_nonblank_token( '->', -1 );

    return;
} ## end sub delete_interbracket_arrow

sub unstore_last_nonblank_token {

    my ( $self, $type, ($want_space) ) = @_;

    # remove the most recent nonblank token from the new token list
    # Input parameter:
    #   $type = type to be removed (for safety check)
    #   $want_space = telling if a space should remain
    #                 1 => always
    #                 0 or undef => only if there was one (used for ',')
    #                -1 => never (used for '->')

    # Returns true if success
    #         false if error

    # This was written and is used for removing commas, but might
    # be useful for other tokens. If it is ever used for other tokens
    # then the issue of what to do about the other variables, such
    # as token counts and the '$last...' vars needs to be considered.

    # Safety check, shouldn't happen
    if ( @{$rLL_new} < 3 ) {
        DEVEL_MODE && Fault("not enough tokens on stack to remove '$type'\n");
        return;
    }

    if ( !defined($want_space) ) { $want_space = 0 }

    my ( $rcomma, $rblank );

    # Note: originally just for ',' but now also for '->'

    # case 1: pop comma from top of stack
    if ( $rLL_new->[-1]->[_TYPE_] eq $type ) {
        $rcomma = pop @{$rLL_new};
    }

    # case 2: pop blank and then comma from top of stack
    elsif ($rLL_new->[-1]->[_TYPE_] eq 'b'
        && $rLL_new->[-2]->[_TYPE_] eq $type )
    {
        $rblank = pop @{$rLL_new};
        $rcomma = pop @{$rLL_new};
    }

    # case 3: error, shouldn't happen unless bad call
    else {
        DEVEL_MODE && Fault("Could not find token type '$type' to remove\n");
        return;
    }

    # A note on updating vars set by sub store_token for this comma: If we
    # reduce the comma count by 1 then we also have to change the variable
    # $last_nonblank_code_type to be $last_last_nonblank_code_type because
    # otherwise sub store_token is going to ALSO reduce the comma count.
    # Alternatively, we can leave the count alone and the
    # $last_nonblank_code_type alone. Then sub store_token will produce
    # the correct result. This is simpler and is done here.

    # remove a remaining blank if requested
    if ( $rLL_new->[-1]->[_TYPE_] eq 'b' ) {

        # current method for deleted '->'
        if ( $want_space == -1 ) {
            pop @{$rLL_new};
        }
    }

    # add a blank if requested
    else {
        if ( $want_space == 1 ) {
            $self->store_token();
        }
        elsif ( !$want_space ) {

            # add one if there was one (current method for commas)
            if ( defined($rblank) ) {
                my $len = length($type);
                $rblank->[_CUMULATIVE_LENGTH_] -= $len;  # fix for deleted comma
                push @{$rLL_new}, $rblank;
            }
        }
        else {
            # want_space=-1 so do not add a blank
        }
    }

    return 1;
} ## end sub unstore_last_nonblank_token

sub is_list_assignment {
    my ( $self, $K_opening ) = @_;

    # Given:
    #   $K_opening = index in $rLL_new of an opening paren
    # Return:
    #   true if this is a list assignment of the form '@xxx = ('
    #   false otherwise

    return unless defined($K_opening);
    my $Km = $self->K_previous_nonblank( $K_opening, $rLL_new );
    return unless defined($Km);
    my $type_m = $rLL_new->[$Km]->[_TYPE_];

    # Look for list assignment like '@list = (' or '@{$ref} = ('
    #   or '%hash = ('
    if ( $type_m eq '=' ) {
        my $token_m = $rLL_new->[$Km]->[_TOKEN_];
        $Km = $self->K_previous_nonblank( $Km, $rLL_new );
        return unless defined($Km);
        $type_m  = $rLL_new->[$Km]->[_TYPE_];
        $token_m = $rLL_new->[$Km]->[_TOKEN_];

        # backup past a braced item
        if ( $token_m eq '}' ) {
            my $seqno_m = $rLL_new->[$Km]->[_TYPE_SEQUENCE_];
            return unless ($seqno_m);
            my $K_opening_m = $self->[_K_opening_container_]->{$seqno_m};
            return unless defined($K_opening_m);
            $Km = $self->K_previous_nonblank( $K_opening_m, $rLL_new );
            return unless defined($Km);
            $type_m  = $rLL_new->[$Km]->[_TYPE_];
            $token_m = $rLL_new->[$Km]->[_TOKEN_];
        }

        if ( $type_m eq 'i' || $type_m eq 't' ) {
            my $sigil = substr( $token_m, 0, 1 );
            if ( $sigil eq '@' ) {
                return 1;
            }
        }
    }
    return;
} ## end sub is_list_assignment

my %is_not_list_paren;

BEGIN {
    ## trailing comma logic ignores opening parens preceded by these tokens
    my @q = qw# if elsif unless while and or err not && | || ? : ! . #;
    @is_not_list_paren{@q} = (1) x scalar(@q);
}

sub match_trailing_comma_rule {

    my ( $self, $KK, $Kfirst, $Kp, $trailing_comma_style, $paren_flag,
        $stable_flag, $if_add )
      = @_;

    # Decide if a trailing comma rule is matched.

    # Input parameter:
    #  $KK = index of closing token in old ($rLL) token list which follows
    #    the location of a possible trailing comma. See diagram below.
    #  $Kfirst = (old) index of first token on the current line of input tokens
    #  $Kp = index of previous nonblank token in new ($rLL_new) array
    #  $trailing_comma_rule = packed user control flags
    #  $if_add = true if adding comma, false if deleting comma

    # Returns:
    #   false    if no match
    #   true     if match
    #  !$if_add  to keep the current state unchanged

    # For example, we might be checking for addition of a comma here:

    #   bless {
    #           _name   => $name,
    #           _price  => $price,
    #           _rebate => $rebate  <------ location of possible trailing comma
    #          }, $pkg;
    #          ^-------------------closing token at index $KK

    # List of $trailing_comma_style values:
    #   undef  stable: do not change
    #   '1' or '*' : every list should have a trailing comma
    #   'm' a multi-line list should have a trailing commas
    #   'b' trailing commas should be 'bare' (comma followed by newline)
    #   'i' same as s=h but also include any list with no more than about one
    #       comma per line
    #   'h' lists of key=>value pairs with a bare trailing comma
    #   '0' : no list should have a trailing comma
    #   ' ' or -wtc not defined : leave trailing commas unchanged [DEFAULT].

    # Note the hierarchy:
    # '1' includes all 'm' includes all 'b' includes all 'i' includes all 'h'

    # Note: an interesting generalization would be to let an upper case
    # letter denote the negation of styles 'm', 'b', 'h', 'i'. This might
    # be useful for undoing operations. It would be implemented as a wrapper
    # around this routine.

    # Return !$if_add to keep the current state unchanged
    my $no_change = !$if_add;

    # If no style defined : do not add or delete
    if ( !defined($trailing_comma_style) ) { return $no_change }

    #----------------------------------------
    # Set some flags describing this location
    #----------------------------------------
    my $type_sequence = $rLL->[$KK]->[_TYPE_SEQUENCE_];
    return $no_change unless ($type_sequence);
    my $closing_token = $rLL->[$KK]->[_TOKEN_];

    # factors which force stability
    my $is_permanently_broken =
      $self->[_ris_permanently_broken_]->{$type_sequence};
    $is_permanently_broken ||= $rOpts_break_at_old_comma_breakpoints
      && !$rOpts_ignore_old_breakpoints;
    $is_permanently_broken ||= $stable_flag;

    my $K_opening = $self->[_K_opening_container_]->{$type_sequence};
    return $no_change if ( !defined($K_opening) );
    my $iline_first_comma =
      $self->[_rfirst_comma_line_index_]->{$type_sequence};
    my $iline_last_comma = $rLL_new->[$Kp]->[_LINE_INDEX_];
    my $rtype_count      = $self->[_rtype_count_by_seqno_]->{$type_sequence};
    my $comma_count      = 0;
    my $fat_comma_count  = 0;
    my $has_inner_multiline_structure;
    my $has_inner_multiline_commas;

    # if outer container is paren, return if this is not a possible list
    # For example, return for an if paren 'if ('
    my $token = $rLL_new->[$K_opening]->[_TOKEN_];
    my $is_arrow_call;
    my $is_hash_value;
    my $is_paren_list;
    if ( $token eq '(' ) {
        $is_paren_list = 1;
        my $Km = $self->K_previous_nonblank( $K_opening, $rLL_new );
        if ( defined($Km) ) {
            my $type_m  = $rLL_new->[$Km]->[_TYPE_];
            my $token_m = $rLL_new->[$Km]->[_TOKEN_];
            if ( $type_m eq 'k' ) {
                if ( $is_not_list_paren{$token_m} ) { return $no_change }
            }
            $is_arrow_call = $type_m eq '->';
            $is_hash_value = $type_m eq '=>';
        }
    }

    if ($rtype_count) {
        $comma_count     = $rtype_count->{','};
        $fat_comma_count = $rtype_count->{'=>'};
    }

    my $follows_isolated_closing_token;

    #----------------------------------------------------------------
    # If no existing commas, see if we have an inner nested container
    #----------------------------------------------------------------
    if (
          !$comma_count
        && $if_add    # for safety, should be true if no commas
        && $is_closing_type{$last_nonblank_code_type}
      )
    {

        # check for nesting closing containers
        my $Kpp = $self->K_previous_nonblank( undef, $rLL_new );
        return if ( !defined($Kpp) );
        my $seqno_pp = $rLL_new->[$Kpp]->[_TYPE_SEQUENCE_];
        my $type_pp  = $rLL_new->[$Kpp]->[_TYPE_];

        # nesting containers have sequence numbers which differ by 1
        my $is_nesting_right =
             $seqno_pp
          && $is_closing_type{$type_pp}
          && ( $seqno_pp == $type_sequence + 1 );

        # Do not add a comma which will be deleted by
        # --delete-weld-interfering commas (b1471)
        if (   $is_nesting_right
            && $rOpts_delete_weld_interfering_commas )
        {
            return;
        }

        # Does this trailing comma follow an isolated closing token?
        if ($is_nesting_right) {
            my $ix_pp = $rLL_new->[$Kpp]->[_LINE_INDEX_];
            my $Kpp_m = $self->K_previous_nonblank( $Kpp, $rLL_new );
            if ($Kpp_m) {
                my $ix_pp_m = $rLL_new->[$Kpp_m]->[_LINE_INDEX_];
                $follows_isolated_closing_token = $ix_pp > $ix_pp_m;
            }
        }

        #--------------------------------
        # If no comma and no fat comma...
        #--------------------------------
        if ( !$fat_comma_count ) {

            # containers must be nesting on the right
            return unless ($is_nesting_right);

            # give up if it is a code block
            if ( $self->[_rblock_type_of_seqno_]->{$seqno_pp} ) {
                return;
            }

            # if outer container is paren, must be sub call or list assignment
            # Note that _ris_function_call_paren_ does not currently include
            # calls of the form '->(', so that has to be checked separately.
            if (   $token eq '('
                && !$self->[_ris_function_call_paren_]->{$type_sequence}
                && !$is_arrow_call
                && !$is_hash_value
                && !$self->is_list_assignment($K_opening) )
            {
                return;
            }

            my $K_opening_pp = $self->[_K_opening_container_]->{$seqno_pp};
            return unless defined($K_opening_pp);
            my $iline_o = $rLL_new->[$K_opening_pp]->[_LINE_INDEX_];
            my $iline_c = $rLL_new->[$Kpp]->[_LINE_INDEX_];

            my $rtype_count_pp = $self->[_rtype_count_by_seqno_]->{$seqno_pp};
            return unless ($rtype_count_pp);

            $has_inner_multiline_structure =
                 $iline_c > $iline_o
              && ( $rtype_count_pp->{','} || $rtype_count_pp->{'=>'} )
              && !$rtype_count_pp->{';'};
            return unless ($has_inner_multiline_structure);

            # look for inner multiline commas
            $iline_first_comma =
              $self->[_rfirst_comma_line_index_]->{$seqno_pp};
            return if ( !defined($iline_first_comma) );
            my $iline_ppc = $rLL_new->[$Kpp]->[_LINE_INDEX_];
            return if ( $iline_ppc <= $iline_first_comma );
            $has_inner_multiline_commas = 1;

            # OK, we have an inner container with commas
        }
    }

    #--------------------------------
    # Characterize the trailing comma
    #--------------------------------
    if ( !defined($iline_first_comma) ) {

        # Shouldn't happen: if this sub was called without any commas in this
        # container, then either we should have found one in a nested container
        # or already returned.
        if (DEVEL_MODE) {
            my $type_kp = $rLL_new->[$Kp]->[_TYPE_];
            Fault(
"at line $iline_last_comma but line of first comma not defined, at Kp=$Kp, type=$type_kp\n"
            );
        }
        return;
    }

    # multiline commas: first and last commas on different lines
    # Note that _ris_broken_container_ also stores the line diff
    # but it is not available at this early stage.
    my $line_diff_commas = $iline_last_comma - $iline_first_comma;
    my $has_multiline_commas =
      $line_diff_commas > 0 || $has_inner_multiline_commas;

    # Multiline ('m'): the opening and closing tokens on different lines
    my $iline_o      = $rLL_new->[$K_opening]->[_LINE_INDEX_];
    my $iline_c      = $rLL->[$KK]->[_LINE_INDEX_];
    my $is_multiline = $iline_c > $iline_o;

    # Require additional stability factors when adding commas
    if ($if_add) {

        # basic stability rules
        my $is_stable = (

            # has commas not in parens, or multiple lines ending in commas
            $comma_count
              && ( !$is_paren_list || $has_multiline_commas )

              # or contains an inner multiline structure
              || $has_inner_multiline_structure

              # or has other stabilizing factors, like comments and blank lines
              || $is_permanently_broken
        );

        # special stability rules for fat-commas ...
        if ( !$is_stable && $fat_comma_count ) {

            # stable if not in paren list
            $is_stable ||= !$is_paren_list;

            # a paren container must span several lines (b1489, b1490)
            # and the trailing comma must follow an isolated closing token if
            # just 1 '=>' (b1492 b1493 b1494)
            $is_stable ||= ( $iline_c - $iline_o > 1 )
              && ( $follows_isolated_closing_token
                || $fat_comma_count > 1 );
        }

        $is_multiline &&= $is_stable;
    }

    # Bare 'b': a multiline where the closing container token starts a new line:
    my $is_bare_trailing_comma = $is_multiline && $KK == $Kfirst;

    #---------------------
    # Check for a match...
    #---------------------

    my $match;

    #----------------------------
    # 0 : does not match any list
    #----------------------------
    if ( $trailing_comma_style eq '0' ) {
        $match = 0;
    }

    #------------------------------
    # '*' or '1' : matches any list
    #------------------------------
    elsif ( $trailing_comma_style eq '*' || $trailing_comma_style eq '1' ) {
        $match = 1;
    }

    #-----------------------------
    # 'm' matches a Multiline list
    #-----------------------------
    elsif ( $trailing_comma_style eq 'm' ) {
        $match = $is_multiline;
    }

    #----------------------------------
    # 'b' matches a Bare trailing comma
    #----------------------------------
    elsif ( $trailing_comma_style eq 'b' ) {
        $match = $is_bare_trailing_comma;
    }

    #--------------------------------------------------------------------------
    # 'h' matches a bare hash list with about 1 comma and 1 fat comma per line.
    # 'i' matches a bare stable list with about 1 comma per line.
    #--------------------------------------------------------------------------
    elsif ( $trailing_comma_style eq 'h' || $trailing_comma_style eq 'i' ) {

        # We can treat these together because they are similar.
        # The set of 'i' matches includes the set of 'h' matches.

        # the trailing comma must be bare for both 'h' and 'i'
        return if ( !$is_bare_trailing_comma );

        # There must be no more than one comma per line for both 'h' and 'i'
        # The new_comma_count here will include the trailing comma.
        my $new_comma_count = $comma_count;
        $new_comma_count += 1 if ($if_add);
        my $excess_commas = $new_comma_count - $line_diff_commas - 1;
        if ( $excess_commas > 0 ) {

            # Exception for a special edge case for option 'i': if the trailing
            # comma is followed by a blank line or comment, then it cannot be
            # covered.  Then we can safely accept a small list to avoid
            # instability (issue b1443).
            if (   $trailing_comma_style eq 'i'
                && $iline_c - $rLL_new->[$Kp]->[_LINE_INDEX_] > 1
                && $new_comma_count <= 2 )
            {
                $match = 1;
            }

            # Patch for instability issue b1456: -boc can trick this test; so
            # skip it when deleting commas to avoid possible instability
            # with option 'h' in combination with -atc -dtc -boc;
            elsif (
                $trailing_comma_style eq 'h'

                # this is a deletion (due to -dtc)
                && !$if_add

                # -atc is also set
                && $rOpts_add_trailing_commas

                # -boc is set and active
                && $rOpts_break_at_old_comma_breakpoints
                && !$rOpts_ignore_old_breakpoints
              )
            {
                # ignore this test
            }
            else {
                return 0;
            }
        }

        # check fat commas
        if (
              !$match
            && $fat_comma_count
            && (

                # - a list of key=>value pairs with at least 2 fat commas is a
                # match for both 'h' and 'i'
                $fat_comma_count >= 2

                # - an isolated fat comma is a match for type 'h'
                #   and also 'i' (see note below)
                || (
                       $fat_comma_count == 1
                    && $new_comma_count == 1
                    ## && $if_add ## removed to fix b1476

                    ## removed so that 'i' and 'h' work the same here
                    ## && $trailing_comma_style eq 'h'
                )
            )
          )
        {

            # but comma count (including trailer) and fat comma count must
            # differ by by no more than 1. This allows for some small
            # variations.
            my $comma_diff = $new_comma_count - $fat_comma_count;
            $match = ( $comma_diff >= -1 && $comma_diff <= 1 );
        }

        # For 'i' only, a list that can be shown to be stable is a match
        if ( !$match && $trailing_comma_style eq 'i' ) {
            $match = (
                $is_permanently_broken
                  || ( $rOpts_break_at_old_comma_breakpoints
                    && !$rOpts_ignore_old_breakpoints )
            );
        }
    }

    #-------------------------------------------------------------------------
    # Unrecognized parameter. This should have been caught in the input check.
    #-------------------------------------------------------------------------
    else {

        DEVEL_MODE && Fault("Unrecognized parameter '$trailing_comma_style'\n");

        # do not add or delete
        return !$if_add;
    }

    # Now do any special paren check
    if (   $match
        && $paren_flag
        && $paren_flag ne '1'
        && $paren_flag ne '*'
        && $closing_token eq ')' )
    {
        $match &&=
          $self->match_paren_control_flag( $type_sequence, $paren_flag,
            $rLL_new );
    }

    # Fix for b1379, b1380, b1381, b1382, b1384 part 1. Mark trailing commas
    # for use by -vtc logic to avoid instability when -dtc and -atc are both
    # active.
    if ($match) {
        if ( $if_add && $rOpts_delete_trailing_commas
            || !$if_add && $rOpts_add_trailing_commas )
        {
            $self->[_ris_bare_trailing_comma_by_seqno_]->{$type_sequence} = 1;

            # The combination of -atc and -dtc and -cab=3 can be unstable
            # (b1394). So we deactivate -cab=3 in this case.
            # A value of '0' or '4' is required for stability of case b1451.
            if ( $rOpts_comma_arrow_breakpoints == 3 ) {
                $self->[_roverride_cab3_]->{$type_sequence} = 0;
            }
        }
    }
    return $match;
} ## end sub match_trailing_comma_rule

sub store_new_token {

    my ( $self, $type, $token, $Kp ) = @_;

    # Create and insert a completely new token into the output stream
    # Caller must add space after this token if necessary

    # Input parameters:
    #  $type  = the token type
    #  $token = the token text
    #  $Kp    = index of the previous token in the new list, $rLL_new

    # This operation is a little tricky because we are creating a new token and
    # we have to take care to follow the requested whitespace rules.

    my $Ktop         = @{$rLL_new} - 1;
    my $top_is_space = $Ktop >= 0 && $rLL_new->[$Ktop]->[_TYPE_] eq 'b';
    if ( $top_is_space && $want_left_space{$type} == WS_NO ) {

        #----------------------------------------------------
        # Method 1: Convert the top blank into the new token.
        #----------------------------------------------------

        # Be Careful: we are working on the top of the new stack, on a token
        # which has been stored.

        $rLL_new->[$Ktop]->[_TOKEN_]        = $token;
        $rLL_new->[$Ktop]->[_TOKEN_LENGTH_] = length($token);
        $rLL_new->[$Ktop]->[_TYPE_]         = $type;

        # NOTE: we are changing the output stack without updating variables
        # $last_nonblank_code_type, etc. Future needs might require that
        # those variables be updated here.  For now, we just update the
        # type counts as necessary.

        if ( $is_counted_type{$type} ) {
            my $seqno = $seqno_stack{ $depth_next - 1 };
            if ($seqno) {
                $self->[_rtype_count_by_seqno_]->{$seqno}->{$type}++;
            }
        }
    }
    else {

        #----------------------------------------
        # Method 2: Use the normal storage method
        #----------------------------------------

        # Patch for issue c078: keep line indexes in order.  If the top
        # token is a space that we are keeping (due to '-wls=...) then
        # we have to check that old line indexes stay in order.
        # In very rare
        # instances in which side comments have been deleted and converted
        # into blanks, we may have filtered down multiple blanks into just
        # one. In that case the top blank may have a higher line number
        # than the previous nonblank token. Although the line indexes of
        # blanks are not really significant, we need to keep them in order
        # in order to pass error checks.
        if ($top_is_space) {
            my $old_top_ix = $rLL_new->[$Ktop]->[_LINE_INDEX_];
            my $new_top_ix = $rLL_new->[$Kp]->[_LINE_INDEX_];
            if ( $new_top_ix < $old_top_ix ) {
                $rLL_new->[$Ktop]->[_LINE_INDEX_] = $new_top_ix;
            }
        }
        else {
            if ( $want_left_space{$type} == WS_YES ) {
                $self->store_token();
            }
        }

        my $rcopy = copy_token_as_type( $rLL_new->[$Kp], $type, $token );
        $self->store_token($rcopy);

    }

    $last_last_nonblank_code_type  = $last_nonblank_code_type;
    $last_last_nonblank_code_token = $last_nonblank_code_token;

    $last_nonblank_code_type  = $type;
    $last_nonblank_code_token = $token;

    # This sub is currently called to store non-block types ',' and '->', so:
    $last_nonblank_block_type = EMPTY_STRING;

    return;
} ## end sub store_new_token

sub check_Q {

    my ( $self, $KK, $Kfirst, $line_number ) = @_;

    # Check that a quote looks okay, and report possible problems
    # to the logfile.
    # Given:
    #   $KK = index of the quote token
    #   $Kfirst = index of first token on the line
    #   $line_number = number of the line in the input stream

    my $token = $rLL->[$KK]->[_TOKEN_];
    if ( $token =~ /\t/ ) {
        $self->note_embedded_tab($line_number);
    }

    # The remainder of this routine looks for something like
    #        '$var = s/xxx/yyy/;'
    # in case it should have been '$var =~ s/xxx/yyy/;'

    # Start by looking for a token beginning with one of: s y m / tr
    return
      unless ( $is_s_y_m_slash{ substr( $token, 0, 1 ) }
        || substr( $token, 0, 2 ) eq 'tr' );

    # ... and preceded by one of: = == !=
    my $Kp = $self->K_previous_nonblank( undef, $rLL_new );
    return unless ( defined($Kp) );
    my $previous_nonblank_type = $rLL_new->[$Kp]->[_TYPE_];
    return unless ( $is_unexpected_equals{$previous_nonblank_type} );
    my $previous_nonblank_token = $rLL_new->[$Kp]->[_TOKEN_];

    my $previous_nonblank_type_2  = 'b';
    my $previous_nonblank_token_2 = EMPTY_STRING;
    my $Kpp                       = $self->K_previous_nonblank( $Kp, $rLL_new );
    if ( defined($Kpp) ) {
        $previous_nonblank_type_2  = $rLL_new->[$Kpp]->[_TYPE_];
        $previous_nonblank_token_2 = $rLL_new->[$Kpp]->[_TOKEN_];
    }

    my $next_nonblank_token = EMPTY_STRING;
    my $Kn                  = $KK + 1;
    my $Kmax                = @{$rLL} - 1;
    if ( $Kn <= $Kmax && $rLL->[$Kn]->[_TYPE_] eq 'b' ) { $Kn += 1 }
    if ( $Kn <= $Kmax ) {
        $next_nonblank_token = $rLL->[$Kn]->[_TOKEN_];
    }

    my $token_0 = $rLL->[$Kfirst]->[_TOKEN_];
    my $type_0  = $rLL->[$Kfirst]->[_TYPE_];

    if (

        # preceded by simple scalar
        $previous_nonblank_type_2 eq 'i'
        && $previous_nonblank_token_2 =~ /^\$/

        # followed by some kind of termination
        # (but give complaint if we can not see far enough ahead)
        && $next_nonblank_token =~ /^[; \)\}]$/

        # scalar is not declared
        && !( $type_0 eq 'k' && $is_my_our_local{$token_0} )
      )
    {
        my $lno   = 1 + $rLL_new->[$Kp]->[_LINE_INDEX_];
        my $guess = substr( $previous_nonblank_token, 0, 1 ) . '~';
        complain(
"Line $lno: Note: be sure you want '$previous_nonblank_token' instead of '$guess' here\n"
        );
    }
    return;
} ## end sub check_Q

} ## end closure respace_tokens

sub resync_lines_and_tokens {

    my $self = shift;

    # Re-construct the arrays of tokens associated with the original input
    # lines since they have probably changed due to inserting and deleting
    # blanks and a few other tokens.

    # Return parameters:
    # set severe_error = true if processing needs to terminate
    my $severe_error;
    my $rqw_lines = [];

    my $rLL    = $self->[_rLL_];
    my $Klimit = $self->[_Klimit_];
    my $rlines = $self->[_rlines_];
    my @Krange_code_without_comments;
    my @Klast_valign_code;

    # This is the next token and its line index:
    my $Knext = 0;
    my $Kmax  = defined($Klimit) ? $Klimit : -1;

    # Verify that old line indexes are in still order.  If this error occurs,
    # check locations where sub 'respace_tokens' creates new tokens (like
    # blank spaces).  It must have set a bad old line index.
    if ( DEVEL_MODE && defined($Klimit) ) {
        my $iline = $rLL->[0]->[_LINE_INDEX_];
        foreach my $KK ( 1 .. $Klimit ) {
            my $iline_last = $iline;
            $iline = $rLL->[$KK]->[_LINE_INDEX_];
            if ( $iline < $iline_last ) {
                my $KK_m    = $KK - 1;
                my $token_m = $rLL->[$KK_m]->[_TOKEN_];
                my $token   = $rLL->[$KK]->[_TOKEN_];
                my $type_m  = $rLL->[$KK_m]->[_TYPE_];
                my $type    = $rLL->[$KK]->[_TYPE_];
                Fault(<<EOM);
Line indexes out of order at index K=$KK:
at KK-1 =$KK_m: old line=$iline_last, type='$type_m', token='$token_m'
at KK   =$KK: old line=$iline, type='$type', token='$token',
EOM
            }
        }
    }

    my $iline = -1;
    foreach my $line_of_tokens ( @{$rlines} ) {
        $iline++;
        next if ( $line_of_tokens->{_line_type} ne 'CODE' );

        # Get the old number of tokens on this line
        my $rK_range_old = $line_of_tokens->{_rK_range};
        my ( $Kfirst_old, $Klast_old ) = @{$rK_range_old};
        my $Kdiff_old = 0;
        if ( defined($Kfirst_old) ) {
            $Kdiff_old = $Klast_old - $Kfirst_old;
        }

        # Find the range of NEW K indexes for the line:
        # $Kfirst = index of first token on line
        # $Klast  = index of last token on line
        my ( $Kfirst, $Klast );

        my $Knext_beg = $Knext;    # this will be $Kfirst if we find tokens

        # Optimization: Although the actual K indexes may be completely
        # changed after respacing, the number of tokens on any given line
        # will often be nearly unchanged.  So we will see if we can start
        # our search by guessing that the new line has the same number
        # of tokens as the old line.
        my $Knext_guess = $Knext + $Kdiff_old;
        if (   $Knext_guess > $Knext
            && $Knext_guess < $Kmax
            && $rLL->[$Knext_guess]->[_LINE_INDEX_] <= $iline )
        {

            # the guess is good, so we can start our search here
            $Knext = $Knext_guess + 1;
        }

        # search for the change in input line number
        while ($Knext <= $Kmax
            && $rLL->[$Knext]->[_LINE_INDEX_] <= $iline )
        {
            $Knext++;
        }

        if ( $Knext > $Knext_beg ) {

            $Klast = $Knext - 1;

            # Delete any terminal blank token
            if ( $rLL->[$Klast]->[_TYPE_] eq 'b' ) { $Klast -= 1 }

            if ( $Klast < $Knext_beg ) {
                $Klast = undef;
            }
            else {

                $Kfirst = $Knext_beg;

                # Save ranges of non-comment code. This will be used by
                # sub keep_old_line_breaks.
                if ( $rLL->[$Kfirst]->[_TYPE_] ne '#' ) {
                    push @Krange_code_without_comments, [ $Kfirst, $Klast ];
                }

                # Only save ending K indexes of code types which are blank
                # or 'VER'.  These will be used for a convergence check.
                # See related code in sub 'convey_batch_to_vertical_aligner'
                my $CODE_type = $line_of_tokens->{_code_type};
                if (  !$CODE_type
                    || $CODE_type eq 'VER' )
                {
                    push @Klast_valign_code, $Klast;
                }
            }
        }

        # It is only safe to trim the actual line text if the input
        # line had a terminal blank token. Otherwise, we may be
        # in a quote.
        if ( $line_of_tokens->{_ended_in_blank_token} ) {
            $line_of_tokens->{_line_text} =~ s/\s+$//;
        }
        $line_of_tokens->{_rK_range} = [ $Kfirst, $Klast ];

        # Deleting semicolons can create new empty code lines
        # which should be marked as blank
        if ( !defined($Kfirst) ) {
            my $CODE_type = $line_of_tokens->{_code_type};
            if ( !$CODE_type ) {
                $line_of_tokens->{_code_type} = 'BL';
            }
        }
        else {

            #---------------------------------------------------
            # save indexes of all lines with a 'q' at either end
            # for later use by sub find_multiline_qw
            #---------------------------------------------------
            if (   $rLL->[$Kfirst]->[_TYPE_] eq 'q'
                || $rLL->[$Klast]->[_TYPE_] eq 'q' )
            {
                push @{$rqw_lines}, $iline;
            }
        }
    }

    # There shouldn't be any nodes beyond the last one.  This routine is
    # relinking lines and tokens after the tokens have been respaced.  A fault
    # here indicates some kind of bug has been introduced into the above loops.
    # There is not good way to keep going; we better stop here.
    if ( $Knext <= $Kmax ) {
        Fault_Warn(
            "unexpected tokens at end of file when reconstructing lines");
        $severe_error = 1;
        return ( $severe_error, $rqw_lines );
    }
    $self->[_rKrange_code_without_comments_] = \@Krange_code_without_comments;

    # Setup the convergence test in the FileWriter based on line-ending indexes
    my $file_writer_object = $self->[_file_writer_object_];
    $file_writer_object->setup_convergence_test( \@Klast_valign_code );

    return ( $severe_error, $rqw_lines );

} ## end sub resync_lines_and_tokens

sub package_info_maker {

    my ( $self, $rK_package_list ) = @_;

    # Create a hash of values which can be used to find the package of any
    # token.  This sub must be called after rLL has been updated because it
    # calls parent_seqno_by_K.

    # Given:
    #  @{$rK_package_list} = a simple list of token index K of each 'package'
    #  statement in the file.
    # Returns:
    #   {
    #    'rpackage_info_list'   => \@package_info_list,
    #    'rpackage_lookup_list' => \@package_lookup_list,
    #   }
    #  which are two lists with useful information on all packages

    my $rLL                 = $self->[_rLL_];
    my $K_closing_container = $self->[_K_closing_container_];
    my $Klimit              = @{$rLL} - 1;

    # RETURN LIST #1: package_info_list:
    # The package of a token at an arbitrary index K is the last entry
    # in the list for which K_opening < K < K_closing.
    # If no package is found, then the package is 'main'.
    # This list is in order of the index K of the package statements.
    # so the search can stop if we find K_opening > K.
    my @package_info_list;

    # Start with an entry for 'main'
    push @package_info_list,
      {
        type        => 'package',
        name        => 'main',
        level       => 0,
        line_start  => 0,
        K_opening   => 0,
        K_closing   => $Klimit,
        is_block    => 0,
        max_change  => 0,
        block_count => 0,
      };

    my @package_stack;
    push @package_stack, 0;

    # RETURN LIST #2: package_lookup_list:
    # A flat list of [$name, $Kbegin, $Kend], where package is name '$name'
    # from token index $Kbegin to the index $Kend.  This is easier to use than
    # LIST #1 since it eliminates the need for a stack.
    my @package_lookup_list;
    push @package_lookup_list, [ 'main', 0, 0 ];

    foreach my $KK ( @{$rK_package_list} ) {
        my $item = $rLL->[$KK];
        my $type = $item->[_TYPE_];

        # Stored K values may be off by 1 due to an added blank
        if ( $type eq 'b' ) {
            $KK += 1;
            $item = $rLL->[$KK];
            $type = $item->[_TYPE_];
        }

        # shouldn't happen:
        if ( $type ne 'P' ) {
            DEVEL_MODE && Fault("type '$type' expected to be 'P'\n");
            next;
        }

        my $token = $item->[_TOKEN_];
        my ( $keyword, $name ) = split /\s+/, $token, 2;

        my $K_opening = $KK;
        my $lx_start  = $item->[_LINE_INDEX_];

        # for non-BLOCK form:
        my $level        = $item->[_LEVEL_];
        my $parent_seqno = $self->parent_seqno_by_K($KK);
        my $is_block     = 0;

        # Check for BLOCK form:
        # package NAME VERSION BLOCK

        # Skip past VERSION
        my $Kn = $self->K_next_code($KK);
        if ( $Kn && $rLL->[$Kn]->[_TYPE_] eq 'n' ) {
            $Kn = $self->K_next_code($Kn);
        }

        # Look for BLOCK
        if ( $Kn && $rLL->[$Kn]->[_TOKEN_] eq '{' ) {
            my $seqno_n = $rLL->[$Kn]->[_TYPE_SEQUENCE_];
            $level += 1;
            $parent_seqno = $seqno_n;
            $is_block     = $seqno_n;
        }

        my $K_closing = $Klimit;
        if ( $parent_seqno != SEQ_ROOT ) {
            my $Kc = $K_closing_container->{$parent_seqno};
            if ( defined($Kc) ) {
                $K_closing = $Kc;
            }
        }

        # This is the index of this new package in the package_info_list
        my $ii_next = @package_info_list;

        while (@package_stack) {
            my $ii = $package_stack[-1];
            my $Kc = $package_info_list[$ii]->{K_closing};

            # pop an inactive stack item and keep going
            if ( $Kc < $K_opening ) {
                pop @package_stack;
                my $i_top    = $package_stack[-1];
                my $name_top = $package_info_list[$i_top]->{name};
                push @package_lookup_list, [ $name_top, $Kc + 1 ];
                next;
            }

            # end a stack item at this level
            else {
                my $level_i = $package_info_list[$ii]->{level};
                if ( $level_i == $level ) {
                    $package_info_list[$ii]->{K_closing} = $K_opening - 1;
                    pop @package_stack;
                }
            }
            last;
        } ## end while (@package_stack)

        push @package_lookup_list, [ $name, $K_opening ];
        push @package_stack,       $ii_next;

        # max_change and block_count are for possible future usage
        push @package_info_list,
          {
            type        => $keyword,
            name        => $name,
            level       => $level,
            line_start  => $lx_start + 1,
            K_opening   => $K_opening,
            K_closing   => $K_closing,
            is_block    => $is_block,
            max_change  => 0,
            block_count => 0,
          };
    }

    my $imax = @package_lookup_list - 1;
    my $Kend = $Klimit;
    foreach my $i ( reverse( 0 .. $imax ) ) {
        $package_lookup_list[$i]->[2] = $Kend;
        $Kend = $package_lookup_list[$i]->[1] - 1;
    }

    # Eliminate any needless starting package 'main'
    if ( @package_lookup_list > 1 && $package_lookup_list[0]->[2] < 0 ) {
        shift @package_lookup_list;
    }

    return {
        'rpackage_info_list'   => \@package_info_list,
        'rpackage_lookup_list' => \@package_lookup_list,
    };
} ## end sub package_info_maker

use constant DEBUG_COUNT => 0;

my %is_non_interfering_keyword;
my %is_keyword_returning_scalar;

BEGIN {

    # Builtin keywords which do not interfere with counting args.
    # They do not produce arrays and do not consume more than one arg, so
    # following parens are not required.
    my @q = qw(
      abs     and     chr     cmp    continue cos
      defined delete  do      else   elsif    eq
      exp     fc      ge      gt     hex      int
      lc      lcfirst le      length local    log
      lt      my      ne      not    oct      or
      ord     ord     our     pop    pos      rand
      ref     scalar  shift   sin    sqrt     srand
      state   uc      ucfirst undef  xor
    );
    @is_non_interfering_keyword{@q} = (1) x scalar(@q);

    # Builtin keywords possibly taking multiple parameters but returning a
    # scalar value. These can be handled if the args are in parens.
    @q = qw( substr join atan2 );
    @is_keyword_returning_scalar{@q} = (1) x scalar(@q);
}

sub count_list_elements {
    my ( $self, $rarg_list ) = @_;

    # Given call arg hash containing:
    #   $seqno_list   = sequence number of a paren of list to be counted, or
    #   $K_list_start = starting index of list (for 'return' lists)
    #   $shift_count_min  = starting min arg count items to include
    #   $shift_count_max  = starting max arg count items to include
    #   $is_signature = true if this is a sub signature list
    #   $self_name    = name of first arg found

    # Return:
    #   -shift_count_min  => starting min arg count items to include, or
    #      undef if a specific number was not determined
    #   -shift_count_max  => starting max arg count items to include
    #      undef if a specific number was not determined
    #   -self_name => possibly updated name of first arg
    #   -initialized => a hash entry maintained by this routine
    #     for keeping track of repeated calls for 'return' lists

    # Method:
    #   - The basic method is to count commas, but
    #   - if we encounter sigils @ or % or other problems which prevent a
    #     count, then we do a simple return; the count will then be indefinite.

    # Set the counts to undef in case we have to do a simple return upon
    # encountering an indeterminate list count
    my $shift_count_min_input = $rarg_list->{shift_count_min};
##  my $shift_count_max_input = $rarg_list->{shift_count_max};
    $rarg_list->{shift_count_min} = undef;
    $rarg_list->{shift_count_max} = undef;

    my $seqno_list   = $rarg_list->{seqno_list};
    my $K_list_start = $rarg_list->{K_list_start};
    my $is_signature = $rarg_list->{is_signature};
    my $self_name    = $is_signature ? EMPTY_STRING : $rarg_list->{self_name};

    my $rLL = $self->[_rLL_];
    my $K_list_end;

    # Input option 1: $seqno_list is a container
    my $is_return_list;
    if ( defined($seqno_list) ) {
        $K_list_start = $self->[_K_opening_container_]->{$seqno_list};
        $K_list_end   = $self->[_K_closing_container_]->{$seqno_list};
        return unless ( defined($K_list_end) );
    }

    # Input option 2: $K_list_start is the index of a token,
    # such as 'return', which has trailing args to count.
    elsif ( defined($K_list_start) ) {

        # Skip past a leading blank if necessary
        if ( $rLL->[$K_list_start]->[_TYPE_] eq 'b' ) { $K_list_start++ }

        $is_return_list = $rLL->[$K_list_start]->[_TYPE_] eq 'k'
          && $rLL->[$K_list_start]->[_TOKEN_] eq 'return';
        $K_list_end = @{$rLL} - 1;

        # Optimization for common case of simple return
        my $Kn = $self->K_next_code($K_list_start);
        return unless ($Kn);
        my $type_n = $rLL->[$Kn]->[_TYPE_];
        if (   $type_n eq ';'
            || $is_closing_type{$type_n}
            || ( $type_n eq 'k' && $is_if_unless{ $rLL->[$Kn]->[_TOKEN_] } ) )
        {
            $rarg_list->{shift_count_max} = 0;
            return;
        }

        # Check for 'return ()'
        if ( $rLL->[$Kn]->[_TOKEN_] eq '(' ) {
            my $Knn = $self->K_next_code($Kn);
            if ( $Knn && $rLL->[$Knn]->[_TOKEN_] eq ')' ) {
                $rarg_list->{shift_count_max} = 0;
                return;
            }
        }
    }

    else {
        DEVEL_MODE && Fault("Neither seqno_list nor K_list_start defined\n");
        return;
    }

    # Initialize the arg count for this call.  We start with any 'shift' counts
    # previously seen if this is not a signature or 'return' list
    my $arg_count = 0;
    if ( $seqno_list && $shift_count_min_input && !$is_signature ) {
        $arg_count = $shift_count_min_input;
    }

    # For signature lists we need to remember a minimum
    my $arg_count_min;

    my @seqno_stack;
    if ($seqno_list) { push @seqno_stack, $seqno_list }

    my $KK = $K_list_start;
    my $KK_last_last_nb;
    my $KK_last_nb;
    my $KK_this_nb = $K_list_start;

    my $backup_on_last = sub {

        # exclude the latest token upon encountering end of list
        # to avoid adding 1 extra comma at the end
        $KK_this_nb      = $KK_last_nb;
        $KK_last_nb      = $KK_last_last_nb;
        $KK_last_last_nb = undef;
        return;
    }; ## end $backup_on_last = sub

    #--------------------------------------------------------
    # Main loop to scan the container looking for list items.
    #--------------------------------------------------------
    while ( ++$KK < $K_list_end ) {

        # safety check - shouldn't happen
        if ( !$KK || $KK <= $KK_this_nb ) {
            if (DEVEL_MODE) {
                my $lno = $rLL->[$KK_this_nb]->[_LINE_INDEX_] + 1;
                Fault("near line $lno: index $KK decreased, was $KK_this_nb\n");
            }
            return;
        }

        my $type = $rLL->[$KK]->[_TYPE_];
        next   if ( $type eq 'b' );
        next   if ( $type eq '#' );
        last   if ( $type eq ';' );
        return if ( $type eq '..' );

        # i.e., ($str=~/(\d+)(\w+)/) may be a list of n items
        return if ( $type eq '=~' );

        $KK_last_last_nb = $KK_last_nb;
        $KK_last_nb      = $KK_this_nb;
        $KK_this_nb      = $KK;
        my $token = $rLL->[$KK]->[_TOKEN_];

        # Handle a sequenced item
        if ( my $seqno = $rLL->[$KK]->[_TYPE_SEQUENCE_] ) {

            if ( $is_opening_type{$type} ) {
                if ( $token eq '(' ) {

                    # Skip past args to args to subs not returning
                    # lists, like 'pop(' 'length('
                    if ($KK_last_nb) {
                        my $token_last = $rLL->[$KK_last_nb]->[_TOKEN_];
                        my $type_last  = $rLL->[$KK_last_nb]->[_TYPE_];
                        if (   $type_last eq 'k'
                            && $is_non_interfering_keyword{$token_last} )
                        {
                            $KK = $self->[_K_closing_container_]->{$seqno};
                            next;
                        }
                    }

                    # If not a list..
                    if ( !$self->is_list_by_seqno($seqno) ) {

                        # always enter a container following 'return', as in:
                        #   return (find_sub($subname) =~ /^(.*):(\d+)-(\d+)$/);
                        if ( $is_return_list && $KK_last_nb == $K_list_start ) {
                            push @seqno_stack, $seqno;
                            next;
                        }

                        my $Kc = $self->[_K_closing_container_]->{$seqno};
                        if ( !$Kc ) { $backup_on_last->(); last }

                        # Enter nested parens with inner list
                        #   ( ( $v1, $v2) )
                        #   | |         | |
                        # $KK $Kn   $Kc_p $Kc
                        if ( $self->[_rhas_list_]->{$seqno} ) {
                            my $Kc_p = $self->K_previous_code($Kc);
                            if ( $Kc_p && $rLL->[$Kc_p]->[_TOKEN_] eq ')' ) {
                                my $seqno_c_p =
                                  $rLL->[$Kc_p]->[_TYPE_SEQUENCE_];
                                if ( $seqno_c_p && $seqno_c_p == $seqno + 1 ) {
                                    my $Kn = $self->K_next_code($KK);
                                    if ( $Kn && $rLL->[$Kn]->[_TOKEN_] eq '(' )
                                    {
                                        push @seqno_stack, $seqno;
                                        next;
                                    }
                                }
                            }
                        }

                        # enter a list slice, such as '(caller)[1,2]'
                        my $Kn = $self->K_next_code($Kc);
                        if ( $Kn && $rLL->[$Kn]->[_TOKEN_] eq '[' ) {
                            my $seqno_next = $rLL->[$Kn]->[_TYPE_SEQUENCE_];
                            if (   $seqno_next
                                && $self->is_list_by_seqno($seqno_next) )
                            {
                                $KK = $Kn;
                                push @seqno_stack, $seqno_next;
                                next;
                            }
                        }

                        my $KK_n = $self->K_next_code($KK);
                        if ($KK_n) {

                            # look for something like return (@list), which
                            # will not be marked as a list due to lack of a
                            # comma
                            my $type_KK_n  = $rLL->[$KK_n]->[_TYPE_];
                            my $token_KK_n = $rLL->[$KK_n]->[_TOKEN_];
                            if ( $type_KK_n eq 't' || $type_KK_n eq 'i' ) {
                                my $sigil = substr( $token_KK_n, 0, 1 );
                                if ( $sigil eq '@' || $sigil eq '%' ) { return }
                            }
                            elsif ( $type_KK_n eq 'k' ) {

                                # look for something like
                                #     return (map { ...
                                if ( !$is_non_interfering_keyword{$token_KK_n} )
                                {
                                    return;
                                }
                            }
                            else { }
                        }
                    }

                    # a list..
                    else {

                        # Descend into a paren list in some special cases:
                        if ($KK_last_nb) {

                            my $token_last = $rLL->[$KK_last_nb]->[_TOKEN_];
                            my $type_last  = $rLL->[$KK_last_nb]->[_TYPE_];

                            # 'return (' or 'my ('
                            my $ok = $type_last eq 'k'
                              && ( $token_last eq 'return'
                                || $token_last eq 'my' );

                            # ',('
                            $ok ||= $type_last eq ',';

                            # '(('
                            $ok ||= $token_last eq '(';

                            # 'wantarray ? ('
                            $ok ||=
                                 $KK_last_last_nb
                              && $is_return_list
                              && $rLL->[$KK_last_nb]->[_TYPE_] eq '?'
                              && $rLL->[$KK_last_last_nb]->[_TOKEN_] eq
                              'wantarray';

                            if ($ok) {
                                push @seqno_stack, $seqno;
                                next;
                            }
                        }
                    }
                }

                # Otherwise skip past this container
                $KK = $self->[_K_closing_container_]->{$seqno};
                next;
            }
            elsif ( $is_closing_type{$type} ) {
                my $seqno_test = pop @seqno_stack;
                if ( $seqno_test && $seqno_test eq $seqno ) {

                    # hide all closing tokens to avoid adding an extra
                    # comma at the end at something like '$x,)'
                    $backup_on_last->();
                    next;
                }
                $backup_on_last->();
                last;
            }
            elsif ( $type eq '?' ) {

                # continue scanning ternary for 'return wantarray ?'
                if (   $rLL->[$KK_last_nb]->[_TOKEN_] eq 'wantarray'
                    && $rLL->[$KK_last_nb]->[_TYPE_] eq 'k'
                    && $KK_last_last_nb
                    && $rLL->[$KK_last_last_nb]->[_TOKEN_] eq 'return'
                    && $rLL->[$KK_last_last_nb]->[_TYPE_] eq 'k' )
                {
                    push @seqno_stack, $seqno;
                    next;
                }

                # give up in a return list
                if ($is_return_list) {
                    return;
                }

                # otherwise skip past this ternary
                $KK = $self->[_K_closing_ternary_]->{$seqno};
                next;
            }
            elsif ( $type eq ':' ) {
                my $seqno_test = pop @seqno_stack;
                if ( $seqno_test && $seqno_test eq $seqno ) {

                    # for wantarray ternary, assume one item after ':'
                    # TODO: if wantarray was preceded by '!' then we should
                    # swap the two counts here
                    $arg_count_min = 1;
                    $backup_on_last->();
                    last;
                }
                $backup_on_last->();
                last;
            }
            else {
                DEVEL_MODE
                  && Fault("unexpected seqno=$seqno for type='$type'\n");
            }
        }

        # handle identifiers
        elsif ( $type eq 'i' || $type eq 't' ) {
            my $sigil = substr( $token, 0, 1 );

            # give up if we find list sigils not preceded by 'scalar'
            if ( $sigil eq '%' || $sigil eq '@' ) {
                my $K_last = $self->K_previous_code($KK);
                if ( defined($K_last) ) {
                    my $type_last = $rLL->[$K_last]->[_TYPE_];
                    next if ( $type_last eq '+' || $type_last eq 'p' );
                    next if ( $type_last eq q{\\} );
                    next if ( $type_last eq '!' );
                    my $token_last = $rLL->[$K_last]->[_TOKEN_];
                    next if ( $type_last eq 'k' && $token_last eq 'scalar' );
                }
                return;
            }

            # remember the name of the first item, maybe something like '$self'
            elsif ( $sigil eq '$'
                && !$self_name
                && !$arg_count )
            {
                $self_name = $token;
                $rarg_list->{self_name} = $self_name;
            }
            else {
                # continue search
            }
        }

        # handle commas: count commas separating args in a list
        elsif ( $type eq ',' ) {
            $arg_count++;
        }

        # treat fat commas as commas
        elsif ( $type eq '=>' ) {
            $arg_count++;
        }

        # an '=' in a signature indicates an optional arg
        elsif ( $type eq '=' ) {
            if ( $is_signature && !defined($arg_count_min) ) {
                $arg_count_min = $arg_count;
            }
        }

        # check for a paren-less call
        elsif ( $is_kwU{$type} ) {

            # Something like 'length $str' is ok
            if ( $type eq 'k' ) {

                # Something like 'length $str' is ok
                next if ( $is_non_interfering_keyword{$token} );

                next if ( $token eq 'wantarray' );

                # hop over asubs
                next if ( $token eq 'sub' );

                # something like return 1 if ...
                if ( $is_if_unless{$token} ) {
                    $backup_on_last->();
                    last;
                }
            }

            # Certain subsequent tokens prevent problems
            my $Kn = $self->K_next_code($KK);
            next unless defined($Kn);
            my $token_Kn = $rLL->[$Kn]->[_TOKEN_];
            my $type_Kn  = $rLL->[$Kn]->[_TYPE_];
            next
              if ( $token_Kn eq ')'
                || $type_Kn eq '=>'
                || $type_Kn eq '->'
                || $type_Kn eq ',' );

            # Certain keywords returning scalars are okay if not made
            # as paren-less calls
            next
              if ( $type eq 'k'
                && $token_Kn eq '('
                && $is_keyword_returning_scalar{$token} );

            # Otherwise, the safe thing is to give up because a function call:
            # -might be paren-less with multiple args, or
            # -it might return a list (i.e. splice, split, localtime, ...)
            # which will interfere with counting args
            if (DEBUG_COUNT) {
                my $lno               = $rLL->[$KK]->[_LINE_INDEX_] + 1;
                my $input_stream_name = get_input_stream_name();
                print {*STDERR}
"DEBUG_COUNT: file $input_stream_name line=$lno type=$type tok=$token token_Kn=$token_Kn\n";
            }
            return;
        }

        else {
            # continue search
        }
    } ## end while ( ++$KK < $K_list_end)

    # Increase the count by 1 if the list does not have a trailing comma
    if (   defined($KK_this_nb)
        && $KK_this_nb > $K_list_start
        && $rLL->[$KK_this_nb]->[_TYPE_] ne ',' )
    {
        $arg_count++;
    }

    if ( !defined($arg_count_min) ) {
        $arg_count_min = $arg_count;
    }

    $rarg_list->{shift_count_min} = $arg_count_min;
    $rarg_list->{shift_count_max} = $arg_count;
    return;

} ## end sub count_list_elements

# A constant to limit backward searches
use constant MANY_TOKENS => 100;

my %is_shift_pop;
my %is_scalar_sigil;
my %is_array_sigil;

BEGIN {
    my @q = qw( shift pop );
    @is_shift_pop{@q}    = (1) x scalar(@q);
    @q                   = qw( $ * & );
    @is_scalar_sigil{@q} = (1) x scalar(@q);
    @q                   = qw( @ % );
    @is_array_sigil{@q}  = (1) x scalar(@q);
}

sub count_prototype_args {
    my ($string) = @_;

    # Given
    #  $string = a string with a prototype in parens, such as '($$;$)'
    # Returns ($count_min, $count_max)
    #  $count_min = min specific number of args expected, or
    #               undef if number of args can vary
    #  $count_max = max specific number of args expected, or
    #               undef if number of args can vary
    my @chars     = split //, $string;
    my $count_min = 0;
    my $count_max = 0;
    my $saw_semicolon;
    my $bump_count = sub {
        $count_max++;
        $count_min++ if ( !$saw_semicolon );
        return;
    };
    my $saw_array = sub {
        $count_max = undef;
        $count_min = undef if ( !$saw_semicolon );
        return;
    };
    while (@chars) {
        my $ch = shift @chars;
        if    ( !defined($ch) )                 { $saw_array->(); last }
        elsif ( $ch eq '(' )                    { last if ($count_min) }
        elsif ( $ch eq ')' )                    { last }
        elsif ( $ch eq ';' && !$saw_semicolon ) { $saw_semicolon = 1 }
        elsif ( $ch eq '_' && !$saw_semicolon ) {
            $saw_semicolon = 1;
            $bump_count->() if ( !$count_min );
        }
        elsif ( $is_array_sigil{$ch} )  { $saw_array->(); last }
        elsif ( $is_scalar_sigil{$ch} ) { $bump_count->(); }
        elsif ( $ch eq q{\\} ) {
            $ch = shift @chars;
            last unless defined($ch);
            $bump_count->();
        }
        else { next }
    } ## end while (@chars)
    return ( $count_min, $count_max );
} ## end sub count_prototype_args

sub find_sub_token {

    my ( $self, $seqno_block ) = @_;

    # Given:
    #   $seqno_block = sequence number of a sub block brace
    # Return:
    #   $Ksub = index of the actual 'sub' token for the sub
    #           this will include the name of a named sub, and any prototype
    #   undef   if cannot find it; this is not a critical sub, so no heroics
    #
    # Notation:
    #
    #    sub find_sub_token {
    #    |                  |
    #    $Ksub              --$K_opening_container for $seqno_block

    my $rLL = $self->[_rLL_];

    # See if sub respace_tokens saved the index of the previous type 'S'
    # for us. May need to back up 1 token if spaces were deleted.
    my $K_sub = $self->[_rK_sub_by_seqno_]->{$seqno_block};
    if ( defined($K_sub) ) {
        my $type = $rLL->[$K_sub]->[_TYPE_];
        if ( $type ne 'S' ) {
            $K_sub -= 1;
            $type = $rLL->[$K_sub]->[_TYPE_];
            if ( $type ne 'S' ) {
                if (DEVEL_MODE) {
                    my $token = $rLL->[$K_sub]->[_TOKEN_];
                    my $lno   = $rLL->[$K_sub]->[_LINE_INDEX_] + 1;
                    my $block_type =
                      $self->[_rblock_type_of_seqno_]->{$seqno_block};
                    Fault(<<EOM);
line $lno: Bad Ksub=$K_sub for block $seqno_block,
expecting type 'S' and token=$block_type
found type '$type' and token='$token'
EOM
                }

                # This shouldn't happen, but try to keep going
                # with the help of the search loop below.
                $K_sub = undef;
            }
        }
    }

    # Must search for it...
    # Scan backward from the opening brace to find the keyword 'sub'
    if ( !defined($K_sub) ) {

        # We normally only arrive here for anonymous subs. But also
        # if --indent-only is set because respace_tokens is skipped.
        my $K_opening_block = $self->[_K_opening_container_]->{$seqno_block};
        my $Kt_min          = $K_opening_block - MANY_TOKENS;
        if ( $Kt_min < 0 ) { $Kt_min = 0 }
        foreach my $Kt ( reverse( $Kt_min .. $K_opening_block ) ) {
            my $token = $rLL->[$Kt]->[_TOKEN_];
            my $type  = $rLL->[$Kt]->[_TYPE_];
            if ( $type eq 'S' ) {

                # type 'S' could be 'method xxx' or '$fn=sub () {' - see c372
                $K_sub = $Kt;
                last;
            }
            if ( ( $type eq 'k' || $type eq 'i' )
                && substr( $token, 0, 3 ) eq 'sub' )
            {

                # anonymous subs are type 'k'
                $K_sub = $Kt;
                last;
            }
        }
    }
    return $K_sub;
} ## end sub find_sub_token

sub count_default_sub_args {
    my ( $self, $item, $seqno ) = @_;

    # Given:
    #   $item = hash ref with sub arg info
    #   $seqno  => sequence number of a sub block of a paren
    #       containing possible default args
    # Task:
    #   count default args and update minimum arg count in $item

    my $rLL = $self->[_rLL_];
    return unless ($seqno);

    # The token before the opening must be a ',' or '('
    my $K_o    = $self->[_K_opening_container_]->{$seqno};
    my $K_test = $self->K_previous_code($K_o);
    return unless defined($K_test);
    my $token_test = $rLL->[$K_test]->[_TOKEN_];
    return if ( $token_test ne ',' && $token_test ne '(' );

    # Check that an opening token has the previous sequence number
    if ( $token_test eq '(' ) {
        my $seqno_o = $rLL->[$K_test]->[_TYPE_SEQUENCE_];
        if ( !$seqno_o || $seqno_o != $seqno - 1 ) {

            # shouldn't happen: may be bad call value since the token
            # with '$seqno' was just before a closing paren
            DEVEL_MODE && Fault("seqno_o=$seqno_o != $seqno-1\n");
            return;
        }
    }

    my $rtype_count = $self->[_rtype_count_by_seqno_]->{$seqno};
    my $default_arg_count;
    if ($rtype_count) {

        # One or more commas, like:  ( ... $v1, $v2, ($d1, $d2) )=@_
        # Note that the comma_count does not include any trailing comma
        # so we always add 1
        $default_arg_count = $rtype_count->{','} + 1;
    }

    if ( !defined($default_arg_count) ) {

        # Check for empty parens, like:  ( ... $v1, $v2, () )=@_
        my $K_n = $self->K_next_code($K_o);
        my $K_c = $self->[_K_closing_container_]->{$seqno};
        return if ( $K_n == $K_c );

        # No commas but not empty, so 1 arg in parens
        # Something like:  ( ... $v1, $v2, ($d1) )=@_
        $default_arg_count = 1;
    }
    return unless ($default_arg_count);

    # Update the minimum count to exclude the defaults
    if ( $item->{shift_count_min} >= $default_arg_count ) {
        $item->{shift_count_min} -= $default_arg_count;
    }
    else {
        DEVEL_MODE
          && Fault(
"default count is $default_arg_count but total is $item->{shift_count_min}"
          );
    }

    return;
} ## end sub count_default_sub_args

sub count_sub_input_args {
    my ( $self, $item ) = @_;

    # Given: $item = hash ref with
    #   seqno  => $seqno_block = sequence number of a sub block
    #   max_arg_count => optional optimization flag, see note below

    # Updates hash ref $item with values for keys:
    #   shift_count_min  => minimum absolute number of input args
    #   shift_count_max  => maximum absolute number of input args
    #   self_name    => name of first arg (if it can be determined)
    #   is_signature => true if args are in a signature
    #   .. plus several other quantities of interest to the caller
    # These keys are left undefined if they cannot be determined.
    # 'shift_count_min' and 'shift_count_max' are the same except for
    # a signature or prototype.

    my $seqno_block = $item->{seqno};
    return unless ($seqno_block);

    # Pull out optional optimization flag. If this is true then there
    # may be calls to this sub with args, so we should to do a full
    # search of the entire sub if this would cause a -wma warning.
    my $max_arg_count = $item->{max_arg_count};

    my $rLL                 = $self->[_rLL_];
    my $K_opening_container = $self->[_K_opening_container_];
    my $K_closing_container = $self->[_K_closing_container_];
    my $K_opening_block     = $self->[_K_opening_container_]->{$seqno_block};

    # Find index '$K' of the last '@_' in this sub, if any
    # Note on '$K_last_at_underscore': if we exit with only seeing shifts,
    # but a pre-scan saw @_ somewhere after the last K, then the count
    # is dubious and we do a simple return
    my $K_last_at_underscore = 0;
    my $rKlist = $self->[_rK_AT_underscore_by_sub_seqno_]->{$seqno_block};
    if ( defined($rKlist) ) {
        $K_last_at_underscore = $rKlist->[-1];
    }

    # Note on $_[n]: if there are any shifts of @_ or references to @_, we
    # cannot use these for a count. Otherwise, we can use the range of n in
    # $_[n] to get an expected arg count if all indexes n are simple integers.
    # So for example if we see anything like $_[2+$i] we have to give up.
    my $seqno_at_index_min;
    my $at_index_min;
    my $at_index_max;

    my $dollar_underscore_zero_name = sub {

        # Find the first arg name for a sub which references $_[0] and does
        # not do shifting. There are two possibilities:
        #   return '$word' in something like '$word = $_[0];'
        #   return nothing otherwise
        return unless ( $seqno_at_index_min && $at_index_min == 0 );
        my $Ko = $K_opening_container->{$seqno_at_index_min};
        my $Kc = $K_closing_container->{$seqno_at_index_min};
        return unless ( $Ko && $Kc );
        my $K_semicolon = $self->K_next_code($Kc);
        return unless ( $K_semicolon && $rLL->[$K_semicolon]->[_TYPE_] eq ';' );
        my $K_m = $self->K_previous_code($Ko);
        return unless ( $K_m && $rLL->[$K_m]->[_TOKEN_] eq '$_' );
        my $K_mm = $self->K_previous_code($K_m);
        return unless ( $K_mm && $rLL->[$K_mm]->[_TYPE_] eq '=' );
        my $K_mmm = $self->K_previous_code($K_mm);
        return unless ( $K_mmm && $rLL->[$K_mmm]->[_TYPE_] eq 'i' );
        my $name = $rLL->[$K_mmm]->[_TOKEN_];
        return unless ( $name =~ /^\$\w/ );
        return $name;
    }; ## end $dollar_underscore_zero_name = sub

    my $rseqno_DOLLAR_underscore =
      $self->[_rDOLLAR_underscore_by_sub_seqno_]->{$seqno_block};
    if ( !defined($rKlist) && $rseqno_DOLLAR_underscore ) {
        my $ok;
        foreach my $seqno_DOLLAR ( @{$rseqno_DOLLAR_underscore} ) {
            $ok = 0;
            my $Ko = $K_opening_container->{$seqno_DOLLAR};
            my $Kn = $self->K_next_code($Ko);
            last unless ($Kn);
            last unless ( $rLL->[$Kn]->[_TYPE_] eq 'n' );
            my $token = ( $rLL->[$Kn]->[_TOKEN_] );
            last unless ( $token =~ /^\d+$/ );
            my $Knn = $self->K_next_code($Kn);
            my $Kc  = $K_closing_container->{$seqno_DOLLAR};
            last unless ( $Knn && $Kc && $Knn == $Kc );

            if ( !defined($at_index_min) || $token < $at_index_min ) {
                $at_index_min = $token;
                if ( !defined($seqno_at_index_min) ) {
                    $seqno_at_index_min = $seqno_DOLLAR;
                }
            }
            if ( !defined($at_index_max) || $token > $at_index_max ) {
                $at_index_max = $token;
            }
            $ok = 1;
        }
        if ( !$ok ) {
            $at_index_min = undef;
            $at_index_max = undef;
        }
    }

    # flag indicating we saw a "pop @_" or just "pop;";
    my $saw_pop_at_underscore;

    my $ix_HERE_END = -1;

    my $K_sub = $self->find_sub_token($seqno_block);

    # shouldn't happen:
    if ( !defined($K_sub) || $K_sub >= $K_opening_block ) {
        if ( !defined($K_sub) ) { $K_sub = 'undef' }
        DEVEL_MODE && Fault("Bad K_sub=$K_sub, opening=$K_opening_block\n");
        return;
    }

    #----------------------------------
    # Check for and process a prototype
    #----------------------------------
    my $sub_token  = $rLL->[$K_sub]->[_TOKEN_];
    my $iproto_beg = index( $sub_token, '(' );
    if ( $iproto_beg > 0 ) {
        my $iproto_end = index( $sub_token, ')', $iproto_beg );
        if ( $iproto_end > $iproto_beg ) {
            my $prototype =
              substr( $sub_token, $iproto_beg, $iproto_end - $iproto_beg + 1 );
            my ( $prototype_count_min, $prototype_count_max ) =
              count_prototype_args($prototype);
            $item->{prototype}           = $prototype;
            $item->{prototype_count_min} = $prototype_count_min;
            $item->{prototype_count_max} = $prototype_count_max;

            # Since we don't yet know if we must add 1 for a method call, we
            # will just continue normally and let the caller figure it out.
        }
    }

    #---------------------------------------
    # Check for and process a signature list
    #---------------------------------------
    my $Ksub_p = $self->K_next_code($K_sub);
    if (   $rLL->[$Ksub_p]->[_TYPE_SEQUENCE_]
        && $rLL->[$Ksub_p]->[_TOKEN_] eq '(' )
    {
        # Switch to searching the signature container. We will get the
        # count when we arrive at the closing token.
        my $seqno_list = $rLL->[$Ksub_p]->[_TYPE_SEQUENCE_];
        $item->{seqno_list}   = $seqno_list;
        $item->{is_signature} = 1;
        $self->count_list_elements($item);

        # We are finished for a signature list
        return;
    }

    #-------------------------------------------------------------
    # Main loop: look for =shift; and =@_; within sub block braces
    #-------------------------------------------------------------
    my $seqno     = $seqno_block;
    my $K_opening = $self->[_K_opening_container_]->{$seqno};
    my $K_closing = $self->[_K_closing_container_]->{$seqno};
    return unless defined($K_closing);

    my $level_opening = $rLL->[$K_opening]->[_LEVEL_];

    # Count number of 'shift;' at the top level
    my $shift_count                      = 0;
    my $self_name                        = EMPTY_STRING;
    my $semicolon_count_after_last_shift = 0;
    my $in_interpolated_quote;

    my $KK         = $K_opening;
    my $KK_this_nb = $KK;
    while ( ++$KK < $K_closing ) {

        # safety check - shouldn't happen
        if ( !$KK || $KK <= $KK_this_nb ) {
            if (DEVEL_MODE) {
                my $lno = $rLL->[$KK_this_nb]->[_LINE_INDEX_] + 1;
                Fault("near line $lno: index $KK decreased, was $KK_this_nb\n");
            }
            return;
        }

        my $type = $rLL->[$KK]->[_TYPE_];
        next if ( $type eq 'b' );
        next if ( $type eq '#' );
        $KK_this_nb = $KK;

        my $token = $rLL->[$KK]->[_TOKEN_];

        # Note that '$_' here is marked as type 'Z': print $_[0];
        if ( $type eq 'i' || $type eq 'Z' ) {

            # look for '@_'
            if ( $token eq '@_' ) {

                # Found '@_': the search will end here
                my $level = $rLL->[$KK]->[_LEVEL_];

                # Give up upon finding @_ at a lower level
                return unless ( $level == $level_opening + 1 );

                # Look ahead for ';'
                my $K_p = $self->K_next_code($KK);
                return unless ($K_p);
                return unless ( $rLL->[$K_p]->[_TYPE_] eq ';' );

                # Look back for ' = @_'
                my $K_m = $self->K_previous_code($KK);
                return unless defined($K_m);
                my $type_m = $rLL->[$K_m]->[_TYPE_];
                return unless ( $type_m eq '=' );

                # Look back for ' ) = @_'
                my $K_mm = $self->K_previous_code($K_m);
                return unless defined($K_mm);
                my $token_mm = $rLL->[$K_mm]->[_TOKEN_];
                my $seqno_mm = $rLL->[$K_mm]->[_TYPE_SEQUENCE_];

                #  Count args in the list ( ... ) = @_;
                if ( $seqno_mm && $token_mm eq ')' ) {
                    $item->{seqno_list}      = $seqno_mm;
                    $item->{is_signature}    = 0;
                    $item->{shift_count_min} = $shift_count;
                    $item->{shift_count_max} = $shift_count;
                    $self->count_list_elements($item);

                    # Count default args placed in separate parens, such as:
                    #      .. $v1 ,($def1, $def2)) = @_
                    #      .. $v1 ,($def1, $def2),) = @_

                    # look at the token before the last ')'
                    my $K_mm_p = $self->K_previous_code($K_mm);
                    my $token_mm_p =
                      $K_mm_p ? $rLL->[$K_mm_p]->[_TOKEN_] : SPACE;

                    # skip past a trailing comma
                    if ( $token_mm_p eq ',' ) {
                        $K_mm_p = $self->K_previous_code($K_mm_p);
                        $token_mm_p =
                          $K_mm_p ? $rLL->[$K_mm_p]->[_TOKEN_] : SPACE;
                    }

                    # if we find a closing paren, count the items and
                    # update shift_count_min
                    if ( $token_mm_p eq ')' ) {
                        my $seqno_mm_p = $rLL->[$K_mm_p]->[_TYPE_SEQUENCE_];
                        $self->count_default_sub_args( $item, $seqno_mm_p );
                    }

                    # NOTE: this could disagree with $_[n] usage; we
                    # ignore this for now.
                    return;
                }

                # Give up if = @_ is not preceded by a simple list
                return;
            }

            # Give up if we find an indexed ref to $_[..]
            elsif ( $token eq '$_' ) {

                # Found $_: currently the search ends at '$_['
                my $Kn = $self->K_next_code($KK);
                if ( $Kn && $rLL->[$Kn]->[_TOKEN_] eq '[' ) {

                    # Give up unless we might be able to define a count
                    # when there are just references to $_[n] values
                    if ( !defined($at_index_max) || $shift_count ) {
                        return;
                    }
                }
            }

            # Give up at something like '&func;'
            elsif ( substr( $token, 0, 1 ) eq '&' ) {
                my $Kn = $self->K_next_code($KK);
                if ( $Kn && $rLL->[$Kn]->[_TOKEN_] ne '(' ) {
                    return;
                }
            }

            else {
                # continue search
            }
        }

        #------------------------------
        # look for '=shift;' or '=pop;'
        #------------------------------
        elsif ( $type eq 'k' ) {
            if ( $is_shift_pop{$token} ) {

                # look for 'shift;' and count as 1 arg
                my $Kp = $self->K_next_code($KK);
                return unless defined($Kp);
                my $type_p  = $rLL->[$Kp]->[_TYPE_];
                my $token_p = $rLL->[$Kp]->[_TOKEN_];

                # look for any of these with shift or pop:
                # shift;
                # shift @_;
                # shift();
                # shift(@_);

                # remove any opening paren
                my $in_parens;
                if ( $token_p eq '(' ) {
                    $in_parens = 1;
                    $Kp        = $self->K_next_code($Kp);
                    return unless defined($Kp);
                    $type_p  = $rLL->[$Kp]->[_TYPE_];
                    $token_p = $rLL->[$Kp]->[_TOKEN_];
                }

                # look for '@_'
                if ( $type_p eq 'i' || $type_p eq 't' ) {

                    # keep going if not @_
                    next if ( $token_p ne '@_' );

                    $Kp = $self->K_next_code($Kp);
                    return unless defined($Kp);
                    $type_p  = $rLL->[$Kp]->[_TYPE_];
                    $token_p = $rLL->[$Kp]->[_TOKEN_];
                }

                # remove any closing paren
                if ( $in_parens && $token_p eq ')' ) {
                    $Kp = $self->K_next_code($Kp);
                    return unless defined($Kp);
                    $type_p  = $rLL->[$Kp]->[_TYPE_];
                    $token_p = $rLL->[$Kp]->[_TOKEN_];
                }

                # Just give up if this shift is not followed by a semicolon or
                # closing brace or arrow. This is the safe thing to do to avoid
                # false errors. There are too many ways for problems to arise.
                # Especially if the next token is one of '||' '//' 'or'.
                return
                  if ( $type_p ne ';' && $type_p ne '->' && $Kp ne $K_closing );
                my $level = $rLL->[$KK]->[_LEVEL_];

                # Give up on lower level shifts
                return unless ( $level == $level_opening + 1 );

                # If we get to the end without finding '(..) = @_;' then
                # we will consider the count unreliable if we saw a 'pop'
                # or if a previous block contained other statements.
                $saw_pop_at_underscore ||= $token eq 'pop';

                $shift_count++;
                $semicolon_count_after_last_shift = 0;

                # Save self name:
                #    '$self = shift'
                #      |    |   |
                #  $K_mm  $K_m  $KK
                if ( $shift_count == 1 && !$self_name ) {
                    my $K_m = $self->K_previous_code($KK);
                    return unless ( defined($K_m) );
                    my $type_m = $rLL->[$K_m]->[_TYPE_];

                    # For something like: sub get_thing {shift->{thing}}
                    # use $_[0] as the name
                    if ( $type_p eq '->' ) {
                        if ( $type_m eq '{' || $type_m eq ';' ) {
                            $self_name = '$_[0]';
                            $item->{self_name} = $self_name;
                        }
                    }
                    else {
                        if ( $type_m eq '=' ) {

                            my $K_mm = $self->K_previous_code($K_m);
                            return unless defined($K_mm);

                            my $type_mm  = $rLL->[$K_mm]->[_TYPE_];
                            my $token_mm = $rLL->[$K_mm]->[_TOKEN_];
                            my $seqno_mm = $rLL->[$K_mm]->[_TYPE_SEQUENCE_];

                            # check for $self in parens, like ($self)=shift
                            if ( $seqno_mm && $token_mm eq ')' ) {
                                my $Ko = $K_opening_container->{$seqno_mm};
                                $K_mm = $self->K_next_code($Ko);
                                if ($K_mm) {
                                    $type_mm  = $rLL->[$K_mm]->[_TYPE_];
                                    $token_mm = $rLL->[$K_mm]->[_TOKEN_];
                                }
                            }

                            if ( $type_mm eq 'i' ) {
                                $self_name = $token_mm;

                                # we store self_name immediately because it will
                                # be needed even if we cannot get an arg count
                                $item->{self_name} = $self_name;
                            }
                        }
                    }
                }

                # Skip past any parens and @_; let the semicolon be seen next
                if ( $KK < $Kp - 1 ) { $KK = $Kp - 1 }

            }
            elsif ( $token eq 'bless' ) {

                # Could look for something like the following:
                #  my $self = bless {}, $class;
                #  my $self = bless {}, shift;

            }
            elsif ( $is_if_unless{$token} ) {

                #-------------------------------
                # RETURN: Optional early return.
                #-------------------------------
                # Give up and exit at 'if' or 'unless' if we have seen a few
                # semicolons following the last 'shift'. The number '2' here
                # has been found to work well.
                if ( $semicolon_count_after_last_shift > 2 ) {
                    if ( !defined($max_arg_count)
                        || $max_arg_count <= $shift_count )
                    {

                        if (  !$saw_pop_at_underscore
                            && $KK >= $K_last_at_underscore )
                        {
                            $item->{shift_count_min} = $shift_count;
                            $item->{shift_count_max} = $shift_count;
                        }
                        return;
                    }
                }
            }
            else {
            }
        }

        # Check for a container boundary
        elsif ( $rLL->[$KK]->[_TYPE_SEQUENCE_] ) {
            if ( $is_opening_type{$type} ) {

                my $seqno_test = $rLL->[$KK]->[_TYPE_SEQUENCE_];

                #---------------------------------------------
                # Skip past a sub declearation within this sub
                #---------------------------------------------
                if (   $self->[_ris_sub_block_]->{$seqno_test}
                    || $self->[_ris_asub_block_]->{$seqno_test} )
                {
                    my $Kc = $self->[_K_closing_container_]->{$seqno_test};
                    return if ( !$Kc );
                    return if ( $Kc <= $KK );
                    $KK = $Kc;
                }
            }
        }
        elsif ( $type eq ';' ) {
            $semicolon_count_after_last_shift++;
        }

        # scan a quote for @_ and $_[
        elsif ( $type eq 'Q' ) {

            my $K_last_code = $self->K_previous_code($KK);
            next unless defined($K_last_code);
            my $K_last_type = $rLL->[$K_last_code]->[_TYPE_];
            if ( $K_last_type eq 'Q' ) {

                # starting in quote : use old interpolation value
            }
            elsif ( $is_re_match_op{$K_last_type} ) {
                $in_interpolated_quote = 1;
            }

            # is not interpolated for leading operators: qw q tr y '
            elsif ( $token =~ /^(qw | q[^qrx] | tr | [y\'] )/x ) {
                $in_interpolated_quote = 0;
            }

            # is interpolated for everything else
            else {
                $in_interpolated_quote = 1;
            }

            # look for '@_' and '$_[' in an interpolated quote
            next unless ($in_interpolated_quote);
            my $pos;
            $pos = index( $token, '@_' );
            return
              if ( $pos == 0
                || $pos > 0 && substr( $token, $pos - 1, 1 ) ne BACKSLASH );

            $pos = index( $token, '$_[' );
            return
              if ( $pos == 0
                || $pos > 0 && substr( $token, $pos - 1, 1 ) ne BACKSLASH );
        }

        # scan here text for @_ and $_[
        elsif ( $type eq 'h' ) {
            next if ( !is_interpolated_here_doc($token) );
            my $ix_line = $rLL->[$KK]->[_LINE_INDEX_];
            my $ix_HERE = max( $ix_HERE_END, $ix_line );
            ( $ix_HERE_END, my $here_text ) = $self->get_here_text($ix_HERE);

            if ($here_text) {
                my $pos;
                $pos = index( $here_text, '@_' );
                return
                  if (
                    $pos == 0
                    || ( $pos > 0
                        && substr( $here_text, $pos - 1, 1 ) ne BACKSLASH )
                  );

                $pos = index( $here_text, '$_[' );
                return
                  if (
                    $pos == 0
                    || ( $pos > 0
                        && substr( $here_text, $pos - 1, 1 ) ne BACKSLASH )
                  );
            }
        }
        else {
            # continue search
        }
    } ## end while ( ++$KK < $K_closing)

    #--------------------------------
    # the whole file has been scanned
    #--------------------------------

    # if no shifts @_ and no references to @_, look for $[n]
    if ( defined($at_index_max) && !$shift_count ) {
        $shift_count = $at_index_max + 1;

        # Create a self name like '$_[0]' if we can't find user-defined name.
        # Then any sub calls with '$_[0]->' will be recognized as self
        # calls by sub cross_check_sub_calls.
        if ( !$self_name && $at_index_min == 0 ) {
            $self_name         = $dollar_underscore_zero_name->();
            $self_name         = '$_[0]' unless ($self_name);
            $item->{self_name} = $self_name;
        }
    }

    if ( !$saw_pop_at_underscore ) {
        $item->{shift_count_min} = $shift_count;
        $item->{shift_count_max} = $shift_count;
    }
    return;

} ## end sub count_sub_input_args

use constant DEBUG_RETURN_COUNT => 0;

sub count_sub_return_args {
    my ( $self, $item ) = @_;

    # Given: $item = hash ref with
    #   seqno  => sequence number of a sub block
    # Set values for these keys in '$item':
    #   return_count_min  => minimum number of output args
    #                        = undef if indeterminate, such as @list
    #   K_return_count_min => K value of the min
    #   return_count_max  => maximum number of output args
    #                        = undef if indeterminate, such as @list
    #   K_return_count_max => K value of the max
    my $seqno_sub = $item->{seqno};
    return unless ($seqno_sub);

    my $rKlist = $self->[_rK_return_by_sub_seqno_]->{$seqno_sub};
    return if ( !defined($rKlist) );

    # loop over all return statements in this sub
    my $rLL                  = $self->[_rLL_];
    my $rhash                = {};
    my $rK_return_count_hash = {};

    # retain old vars during transition phase
    my $return_count_min;
    my $return_count_max;

    foreach ( @{$rKlist} ) {
        my $K_return = $rLL->[$_]->[_TYPE_] eq 'b' ? $_ + 1 : $_;
##      my $type     = $rLL->[$K_return]->[_TYPE_];
        my $token = $rLL->[$K_return]->[_TOKEN_];
        if ( $token ne 'return' ) {
            DEVEL_MODE && Fault("expecting 'return' but got $token\n");
            last;
        }
        $rhash->{K_list_start} = $K_return;
        $self->count_list_elements($rhash);
        my $count = $rhash->{shift_count_max};
        if ( !defined($count) ) {
            $item->{return_count_indefinite} = $K_return;
            $item->{return_count_max}        = undef;
            last;
        }

        # new count?
        if ( !$rK_return_count_hash->{$count} ) {
            $rK_return_count_hash->{$count} = $K_return;
        }

        # retain old vars during transition phase
        # Note: using <= to match old results but could use <
        if ( !defined($return_count_min) || $count <= $return_count_min ) {
            $return_count_min           = $count;
            $item->{return_count_min}   = $count;
            $item->{K_return_count_min} = $K_return;
        }

        # Note: using >= to match old results but could use >
        if ( !defined($return_count_max) || $count >= $return_count_max ) {
            $return_count_max           = $count;
            $item->{return_count_max}   = $count;
            $item->{K_return_count_max} = $K_return;
        }
    }

    $item->{rK_return_count_hash} = $rK_return_count_hash;

    if ( DEBUG_RETURN_COUNT > 1 ) {
        my $min = $item->{return_count_min};
        my $max = $item->{return_count_max};
        $min = '*' unless defined($min);
        $max = '*' unless defined($max);
        print "DEBUG_RETURN: returning min=$min max=$max\n";
    }
    return;
} ## end sub count_sub_return_args

sub count_return_values_wanted {
    my ( $self, $item ) = @_;

    # Given: $item = a hash ref with
    #   seqno_list => sequence number the call arg list of a sub call
    # Set value for this key in '$item':
    #   return_count_wanted => number of return items wanted from the call
    #                        = undef if indeterminate, such as @list

    # get the sequence number of the call arg list for this call
    my $seqno_list = $item->{seqno_list};
    return unless ($seqno_list);

    # Give up if call is followed by a bound operator, for example
    #     my ( $fh, $tmpfile ) = $self->io()->tempfile( DIR => $dir );
    #                                      |
    #                                      ^--$Kc
    my $rLL  = $self->[_rLL_];
    my $Kc   = $self->[_K_closing_container_]->{$seqno_list};
    my $Kc_n = $self->K_next_code($Kc);
    if ($Kc_n) {
        my $type_n = $rLL->[$Kc_n]->[_TYPE_];
        my $ok     = $type_n eq ';' || $is_closing_type{$type_n};
        if ( !$ok && $type_n eq 'k' ) {
            my $token_n = $rLL->[$Kc_n]->[_TOKEN_];
            $ok ||= $is_if_unless{$token_n};
            $ok ||= $is_and_or{$token_n};
        }
        return unless $ok;
    }

    my $Ko   = $self->[_K_opening_container_]->{$seqno_list};
    my $K_m  = $self->K_previous_code($Ko);
    my $K_mm = $self->K_previous_code($K_m);
    return unless ( defined($K_mm) );
    my $type_m  = $rLL->[$K_m]->[_TYPE_];
    my $token_m = $rLL->[$K_m]->[_TOKEN_];
    my $type_mm = $rLL->[$K_mm]->[_TYPE_];

    # start of backwards search depends on the call type...
    # note: see var $rsub_call_paren_info_by_seqno in sub respace_tokens
    my $K_equals;

    # 'function('
    if ( $type_m eq 'U' || $type_m eq 'w' ) {
        $K_equals = $K_mm;
    }

    # '->function('
    elsif ( $type_m eq 'i' && $type_mm eq '->' ) {
        my $K_mmm = $self->K_previous_code($K_mm);
        my $K_mm4 = $self->K_previous_code($K_mmm);
        return unless defined($K_mm4);
        my $type_mmm = $rLL->[$K_mmm]->[_TYPE_];

        # something like '$self->function('
        if ( $type_mmm eq 'i' ) {
            $K_equals = $K_mm4;
        }

        # something complex like '$hash_of_objects{my_obj}->function('
        else {

            # TBD:
            return;
        }
    }

    # '&function('
    elsif ( $type_m eq 'i' && substr( $token_m, 0, 1 ) eq '&' ) {
        $K_equals = $K_mm;
    }

    # '$function->('  [ TODO: simple anonymous sub call, not used yet ]
    elsif ( $type_m eq '->' && $type_mm eq 'i' ) {
        my $K_mmm = $self->K_previous_code($K_mm);
        $K_equals = $K_mmm;
    }

    # error
    else {
        DEVEL_MODE
          && Fault(
"unexpected call with type_m=$type_m token_m=$token_m type_mm=$type_mm\n"
          );
        return;
    }

    # look for '='
    # Note that this ignores a return via a slice, like
    #          ($v1,$v2) =(f(x))[1,3]
    # because this is an array return, and we just want explicit lists
    if ( !$K_equals || $rLL->[$K_equals]->[_TYPE_] ne '=' ) {
        return;
    }

    my $K_c = $self->K_previous_code($K_equals);
    return unless ( defined($K_c) );
    my $type_c  = $rLL->[$K_c]->[_TYPE_];
    my $token_c = $rLL->[$K_c]->[_TOKEN_];
    if ( $token_c ne ')' ) {

        # Handle @array = f(x) or $scalar=f(x), and things like
        #   $rhash->{vv} = f();
        #   $hash{vv} = f();
        #   $array[$index] = f();
        if ( $is_closing_type{$type_c} ) {

            # backup from the closing brace to any identifier
            # Note: currently only going back one index, a sub could
            # be written to handle more complex things
            my $seqno_c = $rLL->[$K_c]->[_TYPE_SEQUENCE_];
            return if ( !$seqno_c );
            my $Ko_c = $self->[_K_opening_container_]->{$seqno_c};
            return unless defined($Ko_c);
            my $K_c_new = $self->K_previous_code($Ko_c);
            return unless defined($K_c_new);
            $type_c  = $rLL->[$K_c_new]->[_TYPE_];
            $token_c = $rLL->[$K_c_new]->[_TOKEN_];

            if ( $type_c eq '->' ) {
                $K_c_new = $self->K_previous_code($K_c_new);
                return unless defined($K_c_new);
                $type_c  = $rLL->[$K_c_new]->[_TYPE_];
                $token_c = $rLL->[$K_c_new]->[_TOKEN_];
            }
        }

        if ( $type_c eq 'i' || $type_c eq 't' ) {
            my $sigil = substr( $token_c, 0, 1 );
            if ( $sigil eq '$' ) {
                $item->{return_count_wanted} = 1;
                $item->{want_scalar}         = 1;
            }
        }
        return;
    }

    # Count elements in (list of values)=f(x)
    my $seqno_lhs = $rLL->[$K_c]->[_TYPE_SEQUENCE_];
    return unless ($seqno_lhs);
    my $rhash = {};
    $rhash->{seqno_list} = $seqno_lhs;
    $self->count_list_elements($rhash);
    my $return_count_wanted = $rhash->{shift_count_max};
    if ( DEBUG_RETURN_COUNT > 1 ) {
        print "DEBUG_RETURN_COUNT: want $return_count_wanted\n";
    }
    $item->{return_count_wanted} = $return_count_wanted;
    return;
} ## end sub count_return_values_wanted

sub sub_def_info_maker {

    my ( $self, $rpackage_lookup_list, $rprelim_call_info ) = @_;

    # Given:
    #   $rpackage_lookup_list = list with info for finding containing package
    #   $rprelim_call_info = hash ref with first try at call info

    # Returns two hash references:
    #    \%sub_info_by_seqno,
    #    \%sub_seqno_by_key,
    # where
    #     $sub_info_by_seqno{seqno} = {
    #      seqno        => $seqno,
    #      package      => $package,
    #      name         => $name,
    #      seqno_list   => $seqno of the paren list of args
    #      shift_count  => number of args
    #      is_signature => true if seqno_list is a sub signature
    #      self_name    => name of first arg
    #  }
    # and
    #    $sub_seqno_by_key{'package::name'} = seqno;
    # which gives the seqno for a sub name

    # TODO: possible future update:
    # package name for 'my' sub and anonymous sub will be parent sub seqno

    my $rLL                  = $self->[_rLL_];
    my $K_opening_container  = $self->[_K_opening_container_];
    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];
    my $ris_sub_block        = $self->[_ris_sub_block_];

    #----------------------------------
    # Main loop over subs to count args
    #----------------------------------
    my @package_stack = reverse( @{$rpackage_lookup_list} );
    my ( $current_package, $Kbegin, $Kend ) = @{ pop @package_stack };
    my %sub_info_by_seqno;
    my %sub_seqno_by_key;
    foreach my $seqno ( sort { $a <=> $b } keys %{$ris_sub_block} ) {

        # update the current package
        my $Ko = $K_opening_container->{$seqno};
        while ( $Ko > $Kend && @package_stack ) {
            ( $current_package, $Kbegin, $Kend ) = @{ pop @package_stack };
        }
        my $block_type = $rblock_type_of_seqno->{$seqno};

        #-----------------------------
        # Get the sub name and package
        #-----------------------------

        # Examples of what we want to extract from '$block_type':
        #   $block_type                   $name
        #   'sub setidentifier($)'    => 'setidentifier'
        #   'method setidentifier($)' => 'setidentifier'
        # Examples:
        # "sub hello", "sub hello($)", "sub hello     ($)"
        # There will be a single space after 'sub' but any number before
        # prototype
        my $name      = $block_type;
        my $pos_space = index( $block_type, SPACE );
        if ( $pos_space > 0 ) {
            $name = substr( $block_type, $pos_space + 1 );
        }
        my $pos_paren = index( $name, '(' );
        my $prototype;
        if ( $pos_paren > 0 ) {
            $prototype = substr( $name, $pos_paren );
            $name      = substr( $name, 0, $pos_paren );
            $name =~ s/\s+$//;
        }

        my $package = $current_package;
        if ( ( index( $name, ':' ) >= 0 || index( $name, "'" ) >= 0 )
            && $name =~ /^(.*\W)(\w+)$/ )
        {
            $package = $1;
            $name    = $2;
            $package =~ s/\'/::/g;
            $package =~ s/::$//;
        }
        $package = 'main' unless ($package);

        # Make a hash of info for this sub
        my $lno  = $rLL->[$Ko]->[_LINE_INDEX_] + 1;
        my $item = {
            seqno       => $seqno,
            package     => $package,
            name        => $name,
            line_number => $lno,
        };

        my $key = $package . '::' . $name;

        # Set flag indicating if args may be expected to allow optimization
        my $call_item = $rprelim_call_info->{$key};
        $item->{max_arg_count} = $call_item->{max_arg_count};

        # Add a count of the number of input args
        $self->count_sub_input_args($item);

        # Add a count of the number of return args
        $self->count_sub_return_args($item);

        # Store the sub info by sequence number
        $sub_info_by_seqno{$seqno} = $item;

        # and save the sub sequence number indexed by sub name
        $sub_seqno_by_key{$key} = $seqno;
    }
    return ( \%sub_info_by_seqno, \%sub_seqno_by_key );
} ## end sub sub_def_info_maker

sub update_sub_call_paren_info {

    my ( $self, $rpackage_lookup_list ) = @_;

    # Given:
    #   $rpackage_lookup_list = list with info for finding containing package

    # Update the hash of info about the call parameters with arg counts
    # and package. It contains the sequence number of each paren and
    # type of call, and we must add the arg count and package.

    my $rLL                  = $self->[_rLL_];
    my $K_opening_container  = $self->[_K_opening_container_];
    my $K_closing_container  = $self->[_K_closing_container_];
    my $rtype_count_by_seqno = $self->[_rtype_count_by_seqno_];
    my $rsub_call_paren_info_by_seqno =
      $self->[_rsub_call_paren_info_by_seqno_];

    my @package_stack = reverse( @{$rpackage_lookup_list} );
    my ( $current_package, $Kbegin, $Kend ) = @{ pop @package_stack };

    my $is_dollar_underscore_zero = sub {

        my ($K_closing_bracket) = @_;

        # Given:
        #   $K_closing_bracket - index of a ']'
        # Return:
        #   true of this is the end of '$_[0]'
        #   false otherwise
        #
        #  return $_[0]->PP_decode_json(...
        #             |
        #             ---$K_closing_bracket
        return unless ($K_closing_bracket);
        my $seqno = $rLL->[$K_closing_bracket]->[_TYPE_SEQUENCE_];
        return unless ($seqno);
        my $Ko = $K_opening_container->{$seqno};
        return unless defined($Ko);
        my $Knum = $self->K_next_code($Ko);
        return unless ( $Knum && $rLL->[$Knum]->[_TOKEN_] eq '0' );
        my $Kc = $self->K_next_code($Knum);
        return unless ( $Kc eq $K_closing_bracket );
        my $K_p = $self->K_previous_code($Ko);
        return unless ( $rLL->[$K_p]->[_TOKEN_] eq '$_' );
        return 1;
    }; ## end $is_dollar_underscore_zero = sub

    #----------------------------------------------
    # Loop over sequence numbers of all call parens
    #----------------------------------------------
    # parens are of the form f(  ->f(    &f(  where 'f' is a bareword
    #                         ^     ^      ^
    # Note that we do not handle anonymous subs because it is not possible to
    # connect them to the actual sub definition.
    foreach
      my $seqno ( sort { $a <=> $b } keys %{$rsub_call_paren_info_by_seqno} )
    {

        # update the current package
        my $Ko = $K_opening_container->{$seqno};
        while ( $Ko > $Kend && @package_stack ) {
            ( $current_package, $Kbegin, $Kend ) = @{ pop @package_stack };
        }

        # get the next call list
        my $item    = $rsub_call_paren_info_by_seqno->{$seqno};
        my $name    = $item->{token_m};
        my $type_mm = $item->{type_mm};

        # find function and package
        my $is_ampersand_call;

        # name will be like '&function' for an & call
        if ( substr( $name, 0, 1 ) eq '&' ) {
            $is_ampersand_call = 1;
            $name              = substr( $name, 1 );
        }

        my $call_type = $is_ampersand_call ? '&' : EMPTY_STRING;

        my $caller_name = EMPTY_STRING;
        my $class_name  = EMPTY_STRING;
        if ( $type_mm eq '->' ) {
            $call_type = '->';
            my $K_m   = $self->K_previous_code($Ko);
            my $K_mm  = $self->K_previous_code($K_m);
            my $K_mmm = $self->K_previous_code($K_mm);
            if ( defined($K_mmm) ) {
                my $type_mmm  = $rLL->[$K_mmm]->[_TYPE_];
                my $token_mmm = $rLL->[$K_mmm]->[_TOKEN_];
                if ( $type_mmm eq 'i' ) {
                    $caller_name = $token_mmm;
                }
                elsif ( $type_mmm eq 'w' ) {

                    ##  A::B->do_something( $var1, $var2 );
                    ##  wwww->iiiiiiiiiiii{ iiiii, iiiii };
                    if ( index( $token_mmm, '::' ) >= 0 ) {
                        $class_name = $token_mmm;
                        $class_name =~ s/::$//;
                    }
                }
                elsif ( $token_mmm eq ']' ) {
                    if ( $is_dollar_underscore_zero->($K_mmm) ) {
                        $caller_name = '$_[0]';
                    }
                }
                else { }
            }
        }

        # look for explicit package on name
        my $package = $current_package;
        if ( ( index( $name, ':' ) >= 0 || index( $name, "'" ) >= 0 )
            && $name =~ /^(.*\W)(\w+)$/ )
        {
            $package = $1;
            $name    = $2;
            $package =~ s/\'/::/g;
            $package =~ s/::$//;
        }
        else {
            if ($class_name) {
                $package = $class_name;
            }
        }
        if ( !$package ) { $package = 'main' }

        # count the args
        my $rtype_count = $rtype_count_by_seqno->{$seqno};
        my $arg_count   = 0;
        if ($rtype_count) {
            my $comma_count     = $rtype_count->{','};
            my $fat_comma_count = $rtype_count->{'=>'};
            if ($comma_count)     { $arg_count += $comma_count }
            if ($fat_comma_count) { $arg_count += $fat_comma_count }
        }

        # The comma count does not include any trailing comma, so add 1..
        if ( !$arg_count ) {

            # ..but not if parens are empty
            my $Kc = $K_closing_container->{$seqno};
            my $Kn = $Ko + 1;
            if ( $Kn < $Kc ) {
                my $type_n = $rLL->[$Kn]->[_TYPE_];
                if ( $type_n eq 'b' ) {
                    $Kn += 1;
                    $type_n = $rLL->[$Kn]->[_TYPE_];
                }
                if ( $type_n eq '#' ) {
                    $Kn = $self->K_next_code($Ko);
                }
                if ( $Kn != $Kc ) { $arg_count += 1 }
            }
        }
        else {
            $arg_count += 1;
        }

        # The arg count is undefined if there are non-scalars in the list
        $item->{seqno_list} = $seqno;
        if ($arg_count) {
            $item->{is_signature}    = 0;
            $item->{shift_count_min} = 0;
            $item->{self_name}       = EMPTY_STRING;
            $self->count_list_elements($item);
            $arg_count = $item->{shift_count_min};
        }

        # get the return count expected for this call by scanning to the left
        $self->count_return_values_wanted($item);

        # update the hash of info for this item
        my $line_number = $rLL->[$Ko]->[_LINE_INDEX_] + 1;
        $item->{arg_count}   = $arg_count;
        $item->{package}     = $package;
        $item->{name}        = $name;
        $item->{line_number} = $line_number;
        $item->{call_type}   = $call_type;
        $item->{caller_name} = $caller_name;
        $item->{class_name}  = $class_name;
    }
    return;
} ## end sub update_sub_call_paren_info

{
    #-----------------------------------------------------
    # Sub to look at first use of $self in a specified sub
    #-----------------------------------------------------
    my %self_call_cache;
    my %is_oo_call_cache;

    sub initialize_self_call_cache {
        my $self = shift;

        # must be called once per file before first call to sub self_call_check
        %self_call_cache  = ();
        %is_oo_call_cache = ();
        return;
    } ## end sub initialize_self_call_cache

    sub self_call_check {
        my ( $self, $seqno_sub ) = @_;

        # Try to decide if a sub call with '$self->' is a call to an
        # internal sub by looking at the first '$self' usage.

        # Given:
        #   $seqno_sub = sequence number of sub to be checked
        # Return:
        #   $is_self_call = true if this is an internal $self-> call
        #                   based on the first $self in the sub.
        #   $is_oo_call   = true if a call '$self->' appears to be
        #         within an OO framework which hides the $self arg.
        # This uses the variable _rK_first_self_by_sub_seqno_ which
        # is set by sub respace_tokens.

        my $is_self_call = $self_call_cache{$seqno_sub};
        my $is_oo_call   = $is_oo_call_cache{$seqno_sub};

        if ( !defined($is_self_call) ) {
            $is_self_call = 0;
            $is_oo_call   = 0;

            my $rLL = $self->[_rLL_];
            my $K_first_self =
              $self->[_rK_first_self_by_sub_seqno_]->{$seqno_sub};

            # an index K stored by respace_tokens may be 1 low
            $K_first_self++
              if ( $K_first_self
                && $rLL->[$K_first_self]->[_TYPE_] eq 'b' );

            my $Kn     = $self->K_next_code($K_first_self);
            my $type_n = $Kn ? $rLL->[$Kn]->[_TYPE_] : 'b';

            #-----------------------------------------
            # Try 3a. if "$self->" then assume OO call
            #-----------------------------------------
            if ( $type_n eq '->' ) {
                $is_self_call = 1;

                # Also set a flag to reduce the call arg count by 1
                # because it looks this is an OO system which
                # hides the $self call arg.
                # NOTE: to be sure, we could scan all sub args
                # in advance to check that all first sub args
                # are not named $self
                $is_oo_call = 1;
            }

            #--------------------------
            # Try 3b. "$self = bless"
            #--------------------------
            elsif ( $type_n eq '=' ) {
                my $Knn = $self->K_next_code($Kn);
                $is_self_call = $Knn && $rLL->[$Knn]->[_TOKEN_] eq 'bless';
            }

            # none of the above
            else { }

            $self_call_cache{$seqno_sub}  = $is_self_call;
            $is_oo_call_cache{$seqno_sub} = $is_oo_call;
        }
        return ( $is_self_call, $is_oo_call );
    } ## end sub self_call_check
}

use constant DEBUG_SELF => 0;

sub cross_check_sub_calls {

    my ($self) = @_;

    # This routine looks for issues for these parameters:
    #   --dump-mismatched-args
    #   --warn-mismatched-args
    #   --dump-mismatched-returns
    #   --warn-mismatched-returns

    # It returns a hash of values with any warnings found

    my $rLL = $self->[_rLL_];

    # The mismatched-args checks are indicated by these letters:
    # a = both method and non-method calls to a sub
    #     - even for two subs in a different package
    # o = overcount: call arg counts exceed number expected by a sub
    # u = undercount: call arg counts less than number expected by a sub
    #     - except if expecting N or less (N=4 by default)
    # i = indeterminate: expected number of args was not determined
    my %call_arg_issue_note = (
        a => "both method and non-method calls to a sub",
        o => "excess args passed",
        u => "fewer args than expected passed",
        i => "indeterminate sub arg count",
    );
    my %do_mismatched_call_type           = %call_arg_issue_note;
    my $mismatched_arg_undercount_cutoff  = 0;
    my $mismatched_arg_overcount_cutoff   = 0;
    my $ris_mismatched_call_excluded_name = {};

    # The mismatched-returns checks are indicated by these letters:
    my %return_issue_note = (
        x => "want array but no return seen",
        y => "want scalar but no return seen",
        o => "want array with excess count",
        u => "want array with count not matched by sub",
        s => "want scalar but sub only returns arrays with count >1",
    );
    my %do_mismatched_return_type           = %return_issue_note;
    my $ris_mismatched_return_excluded_name = {};

    # initialize a cache used for efficiency
    $self->initialize_self_call_cache();

    my $is_dump =
      $rOpts->{'dump-mismatched-args'} || $rOpts->{'dump-mismatched-returns'};

    # initialize if not in a dump mode
    if ( !$is_dump ) {

        %do_mismatched_call_type = %{$rwarn_mismatched_arg_types};
        $mismatched_arg_undercount_cutoff =
          $rOpts->{'warn-mismatched-arg-undercount-cutoff'};
        $mismatched_arg_overcount_cutoff =
          $rOpts->{'warn-mismatched-arg-overcount-cutoff'};
        $ris_mismatched_call_excluded_name =
          $ris_warn_mismatched_arg_excluded_name;

        %do_mismatched_return_type = %{$rwarn_mismatched_return_types};
        $ris_mismatched_return_excluded_name =
          $ris_warn_mismatched_return_excluded_name;
    }

    # hardwired name exclusions
    $ris_mismatched_call_excluded_name->{AUTOLOAD} = 1;
    $ris_mismatched_call_excluded_name->{DESTROY}  = 1;

    my $K_opening_container = $self->[_K_opening_container_];
    my $rK_package_list     = $self->[_rK_package_list_];
    my $ris_my_sub_by_seqno = $self->[_ris_my_sub_by_seqno_];
    my $rsub_call_paren_info_by_seqno =
      $self->[_rsub_call_paren_info_by_seqno_];
    my $rK_bless_by_sub_seqno = $self->[_rK_bless_by_sub_seqno_];

    #----------------------------
    # Make a package lookup table
    #----------------------------
    my $rpackage_lists       = $self->package_info_maker($rK_package_list);
    my $rpackage_lookup_list = $rpackage_lists->{'rpackage_lookup_list'};

    #-------------------------------------------
    # Update sub call paren info with arg counts
    #-------------------------------------------
    $self->update_sub_call_paren_info($rpackage_lookup_list);

    #----------------------------------
    # Preliminary min and max call args
    #----------------------------------
    # This is preliminary because some of the calls will eventually be
    # rejected if they appear to be to external objects. This info is
    # needed to optimize the sub arg search in the case of zero args.
    my %upper_bound_call_info;
    foreach my $seqno ( keys %{$rsub_call_paren_info_by_seqno} ) {
        my $rcall_item = $rsub_call_paren_info_by_seqno->{$seqno};

        my $call_type = $rcall_item->{call_type};
        my $package   = $rcall_item->{package};
        my $name      = $rcall_item->{name};
        my $arg_count = $rcall_item->{arg_count};
        my $key       = $package . '::' . $name;

        next unless defined($arg_count);
        if ( $call_type eq '->' ) {
            $arg_count += 1;
            $upper_bound_call_info{$key}->{method_call_count}++;
        }
        else {
            $upper_bound_call_info{$key}->{direct_call_count}++;
        }
        my $max = $upper_bound_call_info{$key}->{max_arg_count};
        my $min = $upper_bound_call_info{$key}->{min_arg_count};
        if ( !defined($max) || $arg_count > $max ) {
            $upper_bound_call_info{$key}->{max_arg_count} = $arg_count;
        }
        if ( !defined($min) || $arg_count < $min ) {
            $upper_bound_call_info{$key}->{min_arg_count} = $arg_count;
        }
    }

    #-----------------------------------
    # Get arg counts for sub definitions
    #-----------------------------------
    my ( $rsub_info_by_seqno, $rsub_seqno_by_key ) =
      $self->sub_def_info_maker( $rpackage_lookup_list,
        \%upper_bound_call_info );

    # Hash to hold combined info for subs and calls
    my %common_hash;

    #---------------------------------------------
    # First split the calls into direct and method
    #---------------------------------------------
    my @method_call_seqnos;
    foreach my $seqno ( keys %{$rsub_call_paren_info_by_seqno} ) {
        my $rcall_item = $rsub_call_paren_info_by_seqno->{$seqno};
        my $package    = $rcall_item->{package};
        my $name       = $rcall_item->{name};
        my $key        = $package . '::' . $name;
        if ( $rcall_item->{call_type} eq '->' ) {
            push @method_call_seqnos, $seqno;
        }
        else {
            push @{ $common_hash{$key}->{direct_calls} }, $rcall_item;
        }
    }

    #----------------------------------------------
    # Now split method calls into self and external
    #----------------------------------------------
    my @debug_warnings;
    foreach my $seqno (@method_call_seqnos) {
        my $rcall_item       = $rsub_call_paren_info_by_seqno->{$seqno};
        my $package          = $rcall_item->{package};
        my $name             = $rcall_item->{name};
        my $caller_name      = $rcall_item->{caller_name};
        my $class_name       = $rcall_item->{class_name};
        my $key_receiver_sub = $package . '::' . $name;
        my $is_self_call;

        # Find the sub which contains this call
        my $seqno_sub_parent = $self->parent_sub_seqno($seqno);
        if ($seqno_sub_parent) {
            my $item = $rsub_info_by_seqno->{$seqno_sub_parent};
            if ($item) {

                my $key_parent_sub   = $item->{package} . '::' . $item->{name};
                my $parent_self_name = $item->{self_name};
                my $caller_is_dollar_self = $caller_name eq '$self';

                # Decide if this method call is to an internal sub:
                #  Try 1 and Try 2 are general, for any object name
                #  Try 3 and Try 4 are guesses for common uses of '$self'

                #------------------------------------------------
                # Try 1: Parent sub self name matches caller name
                #------------------------------------------------
                if ($parent_self_name) {

                    # and the only calls to parent sub (if any) are arrow calls.
                    if (
                        $parent_self_name eq $caller_name
                        && (  !$common_hash{$key_parent_sub}->{direct_calls}
                            || $caller_is_dollar_self )
                      )
                    {
                        $is_self_call = 1;
                    }
                }

                #---------------------------------------------------------
                # Try 2. See if the name was blessed in the containing sub
                #---------------------------------------------------------
                if ( !$is_self_call ) {
                    my $item_self = $item->{self_name};
                    $item_self = 'undef' unless $item_self;
                    my $rK_bless_list =
                      $rK_bless_by_sub_seqno->{$seqno_sub_parent};
                    if ($rK_bless_list) {
                        my $Ko = $K_opening_container->{$seqno};
                        foreach my $blessing ( @{$rK_bless_list} ) {

                            # Index K and blessed name were stored with sub.
                            # $K_blessed may be 1 token before K of '$self'
                            my ( $K_blessed, $name_blessed ) = @{$blessing};

                            # name of blessed object must match
                            next if ( $name_blessed ne $caller_name );

                            # keyword 'bless' must be at top sub level. We have
                            # to back up 1 token in case $self is in parens.
                            my $Kp = $self->K_previous_code($K_blessed);
                            next if ( !$Kp );
                            my $parent_seqno = $self->parent_seqno_by_K($Kp);
                            next
                              if (!$parent_seqno
                                || $parent_seqno != $seqno_sub_parent );

                            # bless must be before the call
                            next if ( $K_blessed > $Ko );

                            $is_self_call = 1;
                            last;
                        }
                    }
                }

                #-------------------------------------------------------
                # Try 3. Caller is '$self'; look at first '$self' in sub
                #-------------------------------------------------------
                if ( !$is_self_call && $caller_is_dollar_self ) {
                    ( $is_self_call, $rcall_item->{is_oo_call} ) =
                      $self->self_call_check($seqno_sub_parent);
                }

                #-------------------------------------------------------------
                # Try 4. caller is '$self': receiver='$self', '$class', '$_[0]'
                #-------------------------------------------------------------
                if ( !$is_self_call && $caller_is_dollar_self ) {
                    my $seqno_sub_called =
                      $rsub_seqno_by_key->{$key_receiver_sub};
                    if ($seqno_sub_called) {
                        my $item_called =
                          $rsub_info_by_seqno->{$seqno_sub_called};
                        my $receiver = $item_called->{self_name};

                        #------------------------------------------------
                        # Try 4a: receiver has some recognized self names
                        #------------------------------------------------
                        if (
                            $receiver
                            && (   $receiver eq $caller_name
                                || $receiver eq '$class'
                                || $receiver eq '$_[0]' )
                          )
                        {
                            $is_self_call = 1;
                        }

                        #-----------------------------------
                        # Try 4b: check for a recursive call
                        #-----------------------------------
                        else {
                            $is_self_call =
                              $seqno_sub_called == $seqno_sub_parent;
                        }
                    }
                }

                if (   DEBUG_SELF
                    && !$is_self_call
                    && $caller_is_dollar_self
                    && $seqno_sub_parent )
                {
                    my $Ko_sub      = $K_opening_container->{$seqno_sub_parent};
                    my $ln_parent   = $rLL->[$Ko_sub]->[_LINE_INDEX_] + 1;
                    my $Ko          = $K_opening_container->{$seqno};
                    my $ln          = $rLL->[$Ko]->[_LINE_INDEX_] + 1;
                    my $parent_self = $item->{self_name};
                    my $receiver_self = 'missing';
                    my $ln_receiver   = 'undef';
                    my $seqno_sub_called =
                      $rsub_seqno_by_key->{$key_receiver_sub};

                    if ($seqno_sub_called) {
                        my $item_called =
                          $rsub_info_by_seqno->{$seqno_sub_called};
                        $receiver_self = $item_called->{self_name};
                        my $Ko_receiver =
                          $K_opening_container->{$seqno_sub_called};
                        $ln_receiver = $rLL->[$Ko_receiver]->[_LINE_INDEX_] + 1;
                    }

                    # use DEBUG_SELF=3 to see missing subs
                    else {
                        next if ( DEBUG_SELF < 3 );
                    }

                    # use DEBUG_SELF=2 to see undef-self-undef
                    next
                      if ( DEBUG_SELF < 2 && !$parent_self && !$receiver_self );
                    if ( !$parent_self )   { $parent_self   = 'undef' }
                    if ( !$receiver_self ) { $receiver_self = 'undef' }
                    push @debug_warnings,
                      {
                        Ko            => $Ko,
                        caller_name   => $caller_name,
                        parent_self   => $parent_self,
                        receiver_self => $receiver_self,
                        sub_called    => $name,
                        line_number   => $ln,
                        ln_parent     => $ln_parent,
                        ln_receiver   => $ln_receiver,
                      };
                }
            }
        }

        # Save this method call as either an internal (self) or external call
        if ($is_self_call) {
            push @{ $common_hash{$key_receiver_sub}->{self_calls} },
              $rcall_item;
        }
        else {

            # mark calls made by unknown (non-self) objects, we can't track
            # them, but we can track calls at the class level.
            if ( !$class_name ) {
                $rcall_item->{is_unknown_object_call} = 1;
            }
        }
    }

    if ( DEBUG_SELF && @debug_warnings ) {
        @debug_warnings = sort { $a->{Ko} <=> $b->{Ko} } @debug_warnings;
        my $output_string = EMPTY_STRING;
        foreach my $item (@debug_warnings) {
##          my $caller_name   = $item->{caller_name};
            my $parent_self   = $item->{parent_self};
            my $receiver_self = $item->{receiver_self};
            my $sub_called    = $item->{sub_called};
            my $line_number   = $item->{line_number};
            my $ln_parent     = $item->{ln_parent};
            my $ln_receiver   = $item->{ln_receiver};
            $output_string .=
"$line_number: \$self->$sub_called in parent line $ln_parent with self=$parent_self to receiver line $ln_receiver with self=$receiver_self\n";
        }
        warning($output_string);
    }

    #-------------------------------
    # Loop to merge prototype counts
    #-------------------------------
    foreach my $key ( keys %common_hash ) {
        my $seqno_sub = $rsub_seqno_by_key->{$key};
        next if ( !defined($seqno_sub) );
        my $rsub_item = $rsub_info_by_seqno->{$seqno_sub};
        next if ( !$rsub_item->{prototype} );
        my $item          = $common_hash{$key};
        my $rdirect_calls = $item->{direct_calls};
        my $rself_calls   = $item->{self_calls};
        my $num_direct    = defined($rdirect_calls) ? @{$rdirect_calls} : 0;
        my $num_self      = defined($rself_calls)   ? @{$rself_calls}   : 0;

        # Use prototype values if given and all calls are direct
        # Otherwise, ignore the prototype.
        next if ($num_self);
        next if ( !$num_direct );

        my $shift_count_min = $rsub_item->{prototype_count_min};
        my $shift_count_max = $rsub_item->{prototype_count_max};
        if ($num_self) {
            if ( defined($shift_count_min) ) { $shift_count_min++ }
            if ( defined($shift_count_max) ) { $shift_count_max++ }
        }

        # For calls with '&' to subs with prototypes, use the upper bound of
        # the prototype max and the max found by scanning the script.
        my $shift_count_max_amp = $shift_count_max;
        if ( defined($shift_count_max) ) {
            my $standard_max = $rsub_item->{shift_count_max};
            if ( !defined($standard_max) || $standard_max > $shift_count_max ) {
                $shift_count_max_amp = $standard_max;
            }
        }
        $rsub_item->{shift_count_max_amp} = $shift_count_max_amp;

        # overwrite values found by scanning the script with prototype values
        $rsub_item->{shift_count_min} = $shift_count_min;
        $rsub_item->{shift_count_max} = $shift_count_max;

    }

    #--------------------------------------------------------------
    # Loop over all sub calls to compare call and return arg counts
    #--------------------------------------------------------------
    foreach my $seqno ( keys %{$rsub_call_paren_info_by_seqno} ) {

        my $rcall_item = $rsub_call_paren_info_by_seqno->{$seqno};

        # Skip method calls by unknown objects
        next if ( $rcall_item->{is_unknown_object_call} );

        my $arg_count           = $rcall_item->{arg_count};
        my $return_count_wanted = $rcall_item->{return_count_wanted};
        my $want_scalar         = $rcall_item->{want_scalar};
        my $package             = $rcall_item->{package};
        my $name                = $rcall_item->{name};
        my $call_type           = $rcall_item->{call_type};
        my $key                 = $package . '::' . $name;

        my ( $shift_count_min,  $shift_count_max,  $self_name );
        my ( $return_count_min, $return_count_max, $return_count_indefinite );
        my ($rK_return_count_hash);

        # look for the sub ..
        my $seqno_sub = $rsub_seqno_by_key->{$key};
        my $rK_return_list;
        my $saw_wantarray;
        if ( defined($seqno_sub) ) {

            my $rsub_item = $rsub_info_by_seqno->{$seqno_sub};
            $saw_wantarray =
              defined( $self->[_rK_wantarray_by_sub_seqno_]->{$seqno_sub} );

            # skip 'my' subs for now, they need special treatment. If
            # anonymous subs are added, 'my' subs could also be added then.
            if ( !$ris_my_sub_by_seqno->{$seqno_sub} ) {
                $common_hash{$key}->{rsub_item} = $rsub_item;
                $shift_count_min                = $rsub_item->{shift_count_min};
                $shift_count_max                = $rsub_item->{shift_count_max};
                if ( $call_type eq '&' && $rsub_item->{prototype} ) {
                    $shift_count_max = $rsub_item->{shift_count_max_amp};
                }
                $self_name        = $rsub_item->{self_name};
                $return_count_min = $rsub_item->{return_count_min};
                $return_count_max = $rsub_item->{return_count_max};
                $return_count_indefinite =
                  $rsub_item->{return_count_indefinite};
                $rK_return_list =
                  $self->[_rK_return_by_sub_seqno_]->{$seqno_sub};
                $common_hash{$key}->{rK_return_list} = $rK_return_list;
                $rK_return_count_hash = $rsub_item->{rK_return_count_hash};
            }
        }

        #------------------------------------
        # compare caller/sub input arg counts
        #------------------------------------
        if ( defined($shift_count_min) && defined($arg_count) ) {
            if ( $call_type eq '->' && !$rcall_item->{is_oo_call} ) {
                $arg_count += 1;
            }
            my $excess = $arg_count - $shift_count_min;

            my $max = $common_hash{$key}->{max_arg_count};
            my $min = $common_hash{$key}->{min_arg_count};
            if ( !defined($max) || $arg_count > $max ) {
                $common_hash{$key}->{max_arg_count} = $arg_count;
            }
            if ( !defined($min) || $arg_count < $min ) {
                $common_hash{$key}->{min_arg_count} = $arg_count;
            }
            if ( $excess < 0 ) {
                push @{ $common_hash{$key}->{under_count} }, $rcall_item;
            }
            elsif ( $excess > 0 ) {
                if ( defined($shift_count_max) ) {
                    $excess = $arg_count - $shift_count_max;
                    if ( $excess > 0 ) {
                        push @{ $common_hash{$key}->{over_count} }, $rcall_item;
                    }
                }
            }
            else {
                ## $excess = 0
            }
        }

        #---------------------------------------------
        # compare caller/sub return counts if possible
        #---------------------------------------------

        # rhs check: only check subs returning finite lists (i.e. not '@list');
        next if ($return_count_indefinite);

        # lhs check: only check when a finite return list is wanted
        next if ( !$return_count_wanted );

        # ignore scalar if wantarray seen
        next if ( $want_scalar && $saw_wantarray );

        # update min-max want ranges for the output report
        my $max = $common_hash{$key}->{want_count_max};
        my $min = $common_hash{$key}->{want_count_min};
        if ( !defined($max) || $return_count_wanted > $max ) {
            $common_hash{$key}->{want_count_max} = $return_count_wanted;
        }
        if ( !defined($min) || $return_count_wanted < $min ) {
            $common_hash{$key}->{want_count_min} = $return_count_wanted;
        }

        # return issue 'x': want array but no return seen
        # return issue 'y': want scalar but no return seen
        if ( !defined($rK_return_list) ) {
            if ($want_scalar) {
                push @{ $common_hash{$key}->{return_issues}->{y} }, $rcall_item;
            }
            else {
                push @{ $common_hash{$key}->{return_issues}->{x} }, $rcall_item;
            }
        }

        # safety check
        elsif ( !defined($return_count_max) ) {

            # shouldn't happen-should be defined if $rK_return_list is defined
            DEVEL_MODE && Fault("return_count_max should be defined here\n");
        }

        # check for exact match
        elsif ( $return_count_wanted == $return_count_max ) {
            ## ok
        }

        # return issue 'o': overwant
        elsif ( $return_count_wanted > $return_count_max ) {

            # but no error for scalar request of 1 when max 0 returned
            if ( !$want_scalar ) {
                push @{ $common_hash{$key}->{return_issues}->{o} }, $rcall_item;
            }
        }

        # if want less than max...
        else {

            # issue 'u': want array for an unmatched count less than max
            # issue 's': want scalar but all return counts are >1
            if ( defined($rK_return_count_hash) ) {
                my $K_return = $rK_return_count_hash->{$return_count_wanted};
                if ( !defined($K_return) ) {
                    if ($want_scalar) {
                        push @{ $common_hash{$key}->{return_issues}->{s} },
                          $rcall_item;
                    }
                    else {
                        push @{ $common_hash{$key}->{return_issues}->{u} },
                          $rcall_item;
                    }
                }
            }
            else {
                ## safety check, shouldn't happen
                DEVEL_MODE && Fault("return count hash not defined\n");
            }
        }
    }

    #------------------------------------
    # Construct one-line warning messages
    #------------------------------------
    my @call_arg_warnings;
    my @return_warnings;
    my $max_shift_count_with_undercount = 0;
    my $number_of_undercount_warnings   = 0;

    # variables with information about a sub needed for warning output:
    my (

        $lno,              $name,
        $shift_count_min,  $shift_count_max,
        $min_arg_count,    $max_arg_count,
        $return_count_min, $return_count_max,
        $want_count_min,   $want_count_max,
    );

    my $push_call_arg_warning = sub {
        my ( $letter, $note ) = @_;
        my $shift_count = $shift_count_min;
        if ( $shift_count_min ne '*' && $shift_count_min ne $shift_count_max ) {
            $shift_count = "$shift_count_min-$shift_count_max";
        }
        my $output_line =
"$lno:$letter:$name:$shift_count:$min_arg_count:$max_arg_count: $note\n";
        push @call_arg_warnings,
          {
            line_number => $lno,
            letter      => $letter,
            name        => $name,
            output_line => $output_line,
          };
        return;
    }; ## end $push_call_arg_warning = sub

    my $push_return_warning = sub {
        my ( $letter, $note, $lno_return ) = @_;
        my $return_count = $return_count_min;
        if (   $return_count_min ne '*'
            && $return_count_min ne $return_count_max )
        {
            $return_count = "$return_count_min-$return_count_max";
        }
        my $output_line =
"$lno_return:$letter:$name:$return_count:$want_count_min:$want_count_max: $note\n";
        push @return_warnings,
          {
            line_number => $lno_return,
            letter      => $letter,
            name        => $name,
            output_line => $output_line,
          };
        return;
    }; ## end $push_return_warning = sub

    #-------------------
    # Loop over each sub
    #-------------------
    foreach my $key ( keys %common_hash ) {
        my $item = $common_hash{$key};

        # Check for mixed method/direct calls:
        my $rsub_item = $item->{rsub_item};
        next unless defined($rsub_item);

        $name = $rsub_item->{name};
        $lno  = $rsub_item->{line_number};
##      my $rK_return_list = $item->{rK_return_list};
        my $rself_calls   = $item->{self_calls};
        my $rdirect_calls = $item->{direct_calls};
        my $num_self      = defined($rself_calls)   ? @{$rself_calls}   : 0;
        my $num_direct    = defined($rdirect_calls) ? @{$rdirect_calls} : 0;

##      my $K_return_count_min = $rsub_item->{K_return_count_min};
        my $K_return_count_max = $rsub_item->{K_return_count_max};

        $shift_count_min  = $rsub_item->{shift_count_min};
        $shift_count_max  = $rsub_item->{shift_count_max};
        $return_count_min = $rsub_item->{return_count_min};
        $return_count_max = $rsub_item->{return_count_max};
        $min_arg_count    = $item->{min_arg_count};
        $max_arg_count    = $item->{max_arg_count};
        $want_count_min   = $item->{want_count_min};
        $want_count_max   = $item->{want_count_max};

        # change undefs to '*' for the output text
        foreach (

            $shift_count_min,  $shift_count_max,
            $return_count_min, $return_count_max,
            $min_arg_count,    $max_arg_count,
            $want_count_min,   $want_count_max,
          )
        {
            $_ = '*' unless defined($_);
        }

        #-----------------------------------------------------------------
        # Make a one-line message for each mismatch call issue of this sub
        #-----------------------------------------------------------------

        my $rover_count     = $item->{over_count};
        my $runder_count    = $item->{under_count};
        my $num_over_count  = defined($rover_count)  ? @{$rover_count}  : 0;
        my $num_under_count = defined($runder_count) ? @{$runder_count} : 0;

        #--------------------------------------------------
        # issue 'a': subs with both self-> and direct calls
        #--------------------------------------------------
        if ( $num_self && $num_direct && $do_mismatched_call_type{'a'} ) {

            my $letter             = 'a';
            my $lines_self_calls   = stringify_line_range($rself_calls);
            my $lines_direct_calls = stringify_line_range($rdirect_calls);
            my $self_name          = $rsub_item->{self_name};
            if ( !defined($self_name) ) { $self_name = EMPTY_STRING }
            my $ess1 = $num_self > 1   ? 's' : EMPTY_STRING;
            my $ess2 = $num_direct > 1 ? 's' : EMPTY_STRING;
            my $str  = $self_name . '->call' . $ess1;
            my $note =
"$num_self $str($lines_self_calls) and $num_direct call$ess2($lines_direct_calls)";
            $push_call_arg_warning->( $letter, $note );
        }

        #---------------------------------------------------------
        # Ignore calls to a sub which was not defined in this file
        #---------------------------------------------------------
        if ( !defined($rsub_item) ) {
            next;
        }

        #-------------------------------------------------------------------
        # issue 'i': indeterminate. Could not determine a specific arg count
        #-------------------------------------------------------------------
        if ( $shift_count_min eq '*' ) {
            my $letter = 'i';
            if ( $do_mismatched_call_type{$letter} ) {

                # skip *:*:* (no disagreement - call counts also indeterminate)
                next
                  if ( $shift_count_min eq $min_arg_count
                    && $shift_count_min eq $max_arg_count );

                my $note = $call_arg_issue_note{$letter};
                $push_call_arg_warning->( $letter, $note );
            }
        }

        # otherwise check call arg counts
        else {

            #---------------------
            # issue 'o': overcount
            #---------------------
            if (   $num_over_count
                && $do_mismatched_call_type{'o'}
                && $shift_count_max >= $mismatched_arg_overcount_cutoff )
            {
                my $letter     = 'o';
                my $line_range = stringify_line_range($rover_count);
                my $total      = $num_direct + $num_self;
                my $note       = $call_arg_issue_note{$letter};
                $note .=
                  $total > 1
                  ? " at $num_over_count of $total calls ($line_range)"
                  : " at $line_range";
                $push_call_arg_warning->( $letter, $note );
            }

            #----------------------
            # issue 'u': undercount
            #----------------------
            if ($num_under_count) {

                if ( $shift_count_min > $max_shift_count_with_undercount ) {
                    $max_shift_count_with_undercount = $shift_count_min;
                }

                # Skip the warning for small lists with undercount
                if (   $do_mismatched_call_type{'u'}
                    && $shift_count_min >= $mismatched_arg_undercount_cutoff )
                {
                    my $letter     = 'u';
                    my $line_range = stringify_line_range($runder_count);
                    my $total      = $num_direct + $num_self;

                    my $note = $call_arg_issue_note{$letter};
                    $note .=
                      $total > 1
                      ? " at $num_under_count of $total calls ($line_range)"
                      : " at $line_range";

                    $number_of_undercount_warnings++;
                    $push_call_arg_warning->( $letter, $note );
                }
            }
        }

        #-------------------------------------------------------------------
        # Make a one-line message for each mismatch return issue of this sub
        #-------------------------------------------------------------------
        my $return_issues = $item->{return_issues};
        if ($return_issues) {
            foreach my $letter ( keys %return_issue_note ) {
                next if ( !$do_mismatched_return_type{$letter} );
                my $rissues = $return_issues->{$letter};
                my $number  = defined($rissues) ? @{$rissues} : 0;
                next unless ($number);
                my $line_range = stringify_line_range($rissues);
                my $total      = $num_direct + $num_self;

                my $note = $return_issue_note{$letter};
                $note .=
                  $total > 1
                  ? " at $number of $total calls ($line_range)"
                  : " at $line_range";

                # The one-line message shows the line number of the return
                # with the maximum count if there are returns. If no returns
                # (types 'x' and 'y') it shows the first line of the sub ($lno).
                my $lno_return =
                  defined($K_return_count_max)
                  ? $rLL->[$K_return_count_max]->[_LINE_INDEX_] + 1
                  : $lno;

                $push_return_warning->( $letter, $note, $lno_return );
            } ## end loop to save one line for mismatched returns
        }
    }

    #-----------------------------------------------
    # Make the sorted/filtered call arg issue report
    #-----------------------------------------------
    my $rcall_arg_warnings = sort_warnings( \@call_arg_warnings );
    $rcall_arg_warnings = filter_excluded_names( $rcall_arg_warnings,
        $ris_mismatched_call_excluded_name );
    my $call_arg_warning_output = EMPTY_STRING;
    my $call_arg_hint           = EMPTY_STRING;
    if ( @{$rcall_arg_warnings} ) {
        my $header =
          "Issue types are 'a'=arrow mismatch 'u'=undercount 'o'=overcount";
        if ($is_dump) { $header .= " 'i'=indeterminate" }
        $call_arg_warning_output = <<EOM;
$header
Line:Issue:Sub:#args:Min:Max: note
EOM
        foreach ( @{$rcall_arg_warnings} ) {
            $call_arg_warning_output .= $_->{output_line};
        }
        if ( !$is_dump && $number_of_undercount_warnings ) {
            my $wmauc_min = $max_shift_count_with_undercount + 1;
            $call_arg_hint = <<EOM;
Note: use -wmauc=$wmauc_min or greater to prevent undercount warnings in this file
or put parentheses around default sub args and use -wmauc=0
EOM
            $call_arg_warning_output .= $call_arg_hint;
        }
    }

    #---------------------------------------------
    # Make the sorted/filtered return issue report
    #---------------------------------------------
    my $rreturn_warnings = sort_warnings( \@return_warnings );
    $rreturn_warnings = filter_excluded_names( $rreturn_warnings,
        $ris_mismatched_return_excluded_name );

    my $return_warning_output = EMPTY_STRING;
    if ( @{$rreturn_warnings} ) {
        $return_warning_output = <<EOM;
Issue types 'u'=under-want 'o'=over-want 'x','y'=no return 's'=scalar-array mix
Line:Issue:Sub:#Returned:Min_wanted:Max_wanted: note
EOM
        foreach ( @{$rreturn_warnings} ) {
            $return_warning_output .= $_->{output_line};
        }
    }

    return {
        call_arg_warning_output => $call_arg_warning_output,
        return_warning_output   => $return_warning_output,
    };
} ## end sub cross_check_sub_calls

sub sort_warnings {

    my ($rwarnings) = @_;

    # Given:
    #   $rwarnigns = ref to list of warning info hashes
    # Return updated $rwarnings
    #   - Sorted by line number
    if ( @{$rwarnings} ) {

        # sort by line number
        $rwarnings = [
            sort {
                     $a->{line_number} <=> $b->{line_number}
                  || $a->{letter} cmp $b->{letter}
            } @{$rwarnings}
        ];
    }
    return $rwarnings;
} ## end sub sort_warnings

sub stringify_line_range {
    my ($rcalls) = @_;

    # Given:
    #   $rcalls = ref to list of call info
    # Return:
    #   $string = single line of text with just the line range

    my $string = EMPTY_STRING;
    if ( $rcalls && @{$rcalls} ) {
        my @sorted =
          sort { $a->{line_number} <=> $b->{line_number} } @{$rcalls};
        my $num     = @sorted;
        my $lno_beg = $sorted[0]->{line_number};
        my $lno_end = $sorted[-1]->{line_number};
        if ( $num == 1 ) {
            $string = "line $lno_beg";
        }
        elsif ( $num == 2 ) {
            $string = "lines $lno_beg,$lno_end";
        }
        else {
            $string = "lines $lno_beg..$lno_end";
        }
    }
    return $string;
} ## end sub stringify_line_range

sub initialize_warn_mismatched {

    #  a - mismatched arrow operator calls
    #  o - overcount
    #  u - undercount
    $rwarn_mismatched_arg_types =
      initialize_warn_hash( 'warn-mismatched-arg-types', 1, [qw( a o u )] );
    $ris_warn_mismatched_arg_excluded_name =
      make_excluded_name_hash('warn-mismatched-arg-exclusion-list');

    #  x - want array but no return seen
    #  o - want array with excess count
    #  u - want array with unmatched count
    #  y - want scalar but no return seen
    #  s - want scalar but only arrays with count > 1 returned
    $rwarn_mismatched_return_types =
      initialize_warn_hash( 'warn-mismatched-return-types',
        1, [qw( x o u y s )] );
    $ris_warn_mismatched_return_excluded_name =
      make_excluded_name_hash('warn-mismatched-return-exclusion-list');
    return;
} ## end sub initialize_warn_mismatched

sub warn_mismatched {
    my ($self) = @_;

    # process both --warn-mismatched-args and --warn-mismatched-returns,
    my $rhash = $self->cross_check_sub_calls();

    my $wma_key = 'warn-mismatched-args';
    if ( $rOpts->{$wma_key} ) {
        my $output_lines = $rhash->{call_arg_warning_output};
        if ($output_lines) {
            chomp $output_lines;
            warning(<<EOM);
Begin scan for --$wma_key
$output_lines
End scan for --$wma_key
EOM
        }
    }

    my $wmr_key = 'warn-mismatched-returns';
    if ( $rOpts->{$wmr_key} ) {
        my $output_lines = $rhash->{return_warning_output};
        if ($output_lines) {
            chomp $output_lines;
            warning(<<EOM);
Begin scan for --$wmr_key
$output_lines
End scan for --$wmr_key
EOM
        }
    }
    return;
} ## end sub warn_mismatched

sub dump_mismatched_args {
    my ($self) = @_;

    # process a --dump-mismatched-args command
    my $rhash         = $self->cross_check_sub_calls();
    my $output_string = $rhash->{call_arg_warning_output};
    if ($output_string) {
        my $input_stream_name = get_input_stream_name();
        chomp $output_string;
        print {*STDOUT} <<EOM;
$input_stream_name: output for --dump-mismatched-args
$output_string
EOM
    }
    return;
} ## end sub dump_mismatched_args

sub dump_mismatched_returns {
    my ($self) = @_;

    # process a --dump-mismatched-returns command
    my $rhash         = $self->cross_check_sub_calls();
    my $output_string = $rhash->{return_warning_output};
    if ($output_string) {
        my $input_stream_name = get_input_stream_name();
        chomp $output_string;
        print {*STDOUT} <<EOM;
$input_stream_name: output for --dump-mismatched-returns
$output_string
EOM
    }
    return;
} ## end sub dump_mismatched_returns

sub check_for_old_break {
    my ( $self, $KK, $rkeep_break_hash, $rbreak_hash ) = @_;

    # This sub is called to help implement flags:
    # --keep-old-breakpoints-before and --keep-old-breakpoints-after
    # Given:
    #   $KK               = index of a token,
    #   $rkeep_break_hash = user control for --keep-old-...
    #   $rbreak_hash      = hash of tokens where breaks are requested
    # Set $rbreak_hash as follows if a user break is requested:
    #    = 1 make a hard break (flush the current batch)
    #        best for something like leading commas (-kbb=',')
    #    = 2 make a soft break (keep building current batch)
    #        best for something like leading ->

    my $rLL = $self->[_rLL_];

    my $seqno = $rLL->[$KK]->[_TYPE_SEQUENCE_];

    # non-container tokens use the type as the key
    if ( !$seqno ) {
        my $type = $rLL->[$KK]->[_TYPE_];
        if ( $rkeep_break_hash->{$type} ) {
            $rbreak_hash->{$KK} = $is_soft_keep_break_type{$type} ? 2 : 1;
        }
    }

    # container tokens use the token as the key
    else {
        my $token = $rLL->[$KK]->[_TOKEN_];
        my $flag  = $rkeep_break_hash->{$token};
        if ($flag) {

            my $match = $flag eq '1' || $flag eq '*';

            # check for special matching codes
            if ( !$match ) {
                if ( $token eq '(' || $token eq ')' ) {
                    $match = $self->match_paren_control_flag( $seqno, $flag );
                }
                elsif ( $token eq '{' || $token eq '}' ) {

                    # These tentative codes 'b' and 'B' for brace types are
                    # placeholders for possible future brace types. They
                    # are not documented and may be changed.
                    my $block_type = $self->[_rblock_type_of_seqno_]->{$seqno};
                    if    ( $flag eq 'b' ) { $match = $block_type }
                    elsif ( $flag eq 'B' ) { $match = !$block_type }
                    else {
                        ## unknown code - no match
                        DEVEL_MODE && Fault(<<EOM);
unexpected code '$flag' for --keep-old-breakpoints: expecting 'b' or 'B'
EOM
                    }
                }
                else {
                    # no match
                }
            }
            if ($match) {
                my $type = $rLL->[$KK]->[_TYPE_];
                $rbreak_hash->{$KK} = $is_soft_keep_break_type{$type} ? 2 : 1;
            }
        }
    }
    return;
} ## end sub check_for_old_break

sub keep_old_line_breaks {

    my ($self) = @_;

    # Called once per file to find and mark any old line breaks which
    # should be kept.  We will be translating the input hashes into
    # token indexes.

    # A flag is set as follows:
    # = 1 make a hard break (flush the current batch)
    #     best for something like leading commas (-kbb=',')
    # = 2 make a soft break (keep building current batch)
    #     best for something like leading ->

    my $rLL = $self->[_rLL_];
    my $rKrange_code_without_comments =
      $self->[_rKrange_code_without_comments_];
    my $rbreak_before_Kfirst = $self->[_rbreak_before_Kfirst_];
    my $rbreak_after_Klast   = $self->[_rbreak_after_Klast_];
    my $rbreak_container     = $self->[_rbreak_container_];

    #----------------------------------------
    # Apply --break-at-old-method-breakpoints
    #----------------------------------------

    # This code moved here from sub break_lists to fix b1120
    if ( $rOpts->{'break-at-old-method-breakpoints'} ) {
        foreach my $item ( @{$rKrange_code_without_comments} ) {
            my ( $Kfirst, $Klast ) = @{$item};
            my $type  = $rLL->[$Kfirst]->[_TYPE_];
            my $token = $rLL->[$Kfirst]->[_TOKEN_];

            # leading '->' use a value of 2 which causes a soft
            # break rather than a hard break
            if ( $type eq '->' ) {

                # ignore -bom after an opening token ( a syntax error, b1475 )
                my $Kp = $self->K_previous_nonblank($Kfirst);
                next if ( !defined($Kp) );
                next if ( $is_opening_type{ $rLL->[$Kp]->[_TYPE_] } );

                # ignore -bom if this does not look like a method call; c426
                my $Kn = $self->K_next_nonblank($Kfirst);
                next if ( !defined($Kn) );
                my $token_n = $rLL->[$Kn]->[_TYPE_];
                next if ( $token_n eq '{' || $token_n eq '[' );

                $rbreak_before_Kfirst->{$Kfirst} = 2;
            }

            # leading ')->' use a special flag to insure that both
            # opening and closing parens get opened
            # Fix for b1120: only for parens, not braces
            elsif ( $token eq ')' ) {
                my $Kn = $self->K_next_nonblank($Kfirst);
                next if ( !defined($Kn) );
                next if ( $Kn > $Klast );
                next if ( $rLL->[$Kn]->[_TYPE_] ne '->' );
                my $seqno = $rLL->[$Kfirst]->[_TYPE_SEQUENCE_];
                next if ( !$seqno );

                # Note: in previous versions there was a fix here to avoid
                # instability between conflicting -bom and -pvt or -pvtc flags.
                # The fix skipped -bom for a small line difference.  But this
                # was troublesome, and instead the fix has been moved to
                # sub set_vertical_tightness_flags where priority is given to
                # the -bom flag over -pvt and -pvtc flags.  Both opening and
                # closing paren flags are involved because even though -bom only
                # requests breaking before the closing paren, automated logic
                # opens the opening paren when the closing paren opens.
                # Relevant cases are b977, b1215, b1270, b1303

                # ignore -bom if this does not look like a method call; c426
                $Kn = $self->K_next_nonblank($Kn);
                next if ( !defined($Kn) );
                my $token_n = $rLL->[$Kn]->[_TYPE_];
                next if ( $token_n eq '{' || $token_n eq '[' );

                $rbreak_container->{$seqno} = 1;
            }
            else {
                # not a special case
            }
        }
    }

    #---------------------------------------------------------------------
    # Apply --keep-old-breakpoints-before and --keep-old-breakpoints-after
    #---------------------------------------------------------------------

    return unless ( %keep_break_before_type || %keep_break_after_type );

    foreach my $item ( @{$rKrange_code_without_comments} ) {
        my ( $Kfirst, $Klast ) = @{$item};
        $self->check_for_old_break( $Kfirst, \%keep_break_before_type,
            $rbreak_before_Kfirst );
        $self->check_for_old_break( $Klast, \%keep_break_after_type,
            $rbreak_after_Klast );
    }
    return;
} ## end sub keep_old_line_breaks

sub weld_containers {

    my ($self) = @_;

    # Called once per file to do any welding operations requested by --weld*
    # flags.

    # This count is used to eliminate needless calls for weld checks elsewhere
    $total_weld_count = 0;

    return if ( $rOpts->{'indent-only'} );
    return unless ($rOpts_add_newlines);

    # Important: sub 'weld_cuddled_blocks' must be called before
    # sub 'weld_nested_containers'. This is because the cuddled option needs to
    # use the original _LEVEL_ values of containers, but the weld nested
    # containers changes _LEVEL_ of welded containers.

    # Here is a good test case to be sure that both cuddling and welding
    # are working and not interfering with each other: <<snippets/ce_wn1.in>>

    #   perltidy -wn -ce

   # if ($BOLD_MATH) { (
   #     $labels, $comment,
   #     join( '', '<B>', &make_math( $mode, '', '', $_ ), '</B>' )
   # ) } else { (
   #     &process_math_in_latex( $mode, $math_style, $slevel, "\\mbox{$text}" ),
   #     $after
   # ) }

    $self->weld_cuddled_blocks() if ( %{$rcuddled_block_types} );

    if ( $rOpts->{'weld-nested-containers'} ) {

        $self->weld_nested_containers();

        $self->weld_nested_quotes();
    }

    #-------------------------------------------------------------
    # All welding is done. Finish setting up weld data structures.
    #-------------------------------------------------------------

    my $rLL                  = $self->[_rLL_];
    my $rK_weld_left         = $self->[_rK_weld_left_];
    my $rK_weld_right        = $self->[_rK_weld_right_];
    my $rweld_len_right_at_K = $self->[_rweld_len_right_at_K_];

    my @K_multi_weld;
    my @keys = keys %{$rK_weld_right};
    $total_weld_count = @keys;

    # First pass to process binary welds.
    # This loop is processed in unsorted order for efficiency.
    foreach my $Kstart (@keys) {
        my $Kend = $rK_weld_right->{$Kstart};

        # An error here would be due to an incorrect initialization introduced
        # in one of the above weld routines, like sub weld_nested.
        if ( $Kend <= $Kstart ) {
            Fault("Bad weld link: Kend=$Kend <= Kstart=$Kstart\n")
              if (DEVEL_MODE);
            next;
        }

        # Set weld values for all tokens this welded pair
        foreach ( $Kstart + 1 .. $Kend ) {
            $rK_weld_left->{$_} = $Kstart;
        }
        foreach my $Kx ( $Kstart .. $Kend - 1 ) {
            $rK_weld_right->{$Kx} = $Kend;
            $rweld_len_right_at_K->{$Kx} =
              $rLL->[$Kend]->[_CUMULATIVE_LENGTH_] -
              $rLL->[$Kx]->[_CUMULATIVE_LENGTH_];
        }

        # Remember the leftmost index of welds which continue to the right
        if ( defined( $rK_weld_right->{$Kend} )
            && !defined( $rK_weld_left->{$Kstart} ) )
        {
            push @K_multi_weld, $Kstart;
        }
    }

    # Second pass to process chains of welds (these are rare).
    # This has to be processed in sorted order.
    if (@K_multi_weld) {
        my $Kend = -1;
        foreach my $Kstart ( sort { $a <=> $b } @K_multi_weld ) {

            # Skip any interior K which was originally missing a left link
            next if ( $Kstart <= $Kend );

            # Find the end of this chain
            $Kend = $rK_weld_right->{$Kstart};
            my $Knext = $rK_weld_right->{$Kend};
            while ( defined($Knext) ) {
                if ( $Knext <= $Kend ) {
                    ## shouldn't happen: K should increase for right weld
                    DEVEL_MODE && Fault(<<EOM);
Error: Knext=$Knext = rK_weld_right->{$Kend} is not increasing
EOM
                    last;
                }
                $Kend  = $Knext;
                $Knext = $rK_weld_right->{$Kend};
            } ## end while ( defined($Knext) )

            # Set weld values this chain
            foreach ( $Kstart + 1 .. $Kend ) {
                $rK_weld_left->{$_} = $Kstart;
            }
            foreach my $Kx ( $Kstart .. $Kend - 1 ) {
                $rK_weld_right->{$Kx} = $Kend;
                $rweld_len_right_at_K->{$Kx} =
                  $rLL->[$Kend]->[_CUMULATIVE_LENGTH_] -
                  $rLL->[$Kx]->[_CUMULATIVE_LENGTH_];
            }
        }
    }

    return;
} ## end sub weld_containers

sub weld_cuddled_blocks {

    my ($self) = @_;

    # Called once per file to handle cuddled formatting

    my $rK_weld_left         = $self->[_rK_weld_left_];
    my $rK_weld_right        = $self->[_rK_weld_right_];
    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];

    # This routine implements the -cb flag by finding the appropriate
    # closing and opening block braces and welding them together.
    return unless ( %{$rcuddled_block_types} );

    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );

    my $rbreak_container          = $self->[_rbreak_container_];
    my $ris_broken_container      = $self->[_ris_broken_container_];
    my $ris_cuddled_closing_brace = $self->[_ris_cuddled_closing_brace_];
    my $K_closing_container       = $self->[_K_closing_container_];

    # A stack to remember open chains at all levels: This is a hash rather than
    # an array for safety because negative levels can occur in files with
    # errors.  This allows us to keep processing with negative levels.
    # $in_chain{$level} = [$chain_type, $type_sequence];
    my %in_chain;
    my $CBO = $rOpts->{'cuddled-break-option'};

    # loop over structure items to find cuddled pairs
    my $level = 0;
    foreach my $KK ( @{ $self->[_rK_sequenced_token_list_] } ) {
        my $rtoken_vars   = $rLL->[$KK];
        my $type_sequence = $rtoken_vars->[_TYPE_SEQUENCE_];
        if ( !$type_sequence ) {
            next if ( $KK == 0 );    # first token in file may not be container

            # A fault here implies that an error was made in the little loop at
            # the bottom of sub 'respace_tokens' which set the values of
            # _rK_sequenced_token_list_.  Or an error has been introduced in
            # the loop control lines above.
            Fault("sequence = $type_sequence not defined at K=$KK")
              if (DEVEL_MODE);
            next;
        }

        # NOTE: we must use the original levels here. They can get changed
        # by sub 'weld_nested_containers', so this routine must be called
        # before sub 'weld_nested_containers'.
        my $last_level = $level;
        $level = $rtoken_vars->[_LEVEL_];

        if    ( $level < $last_level ) { $in_chain{$last_level} = undef }
        elsif ( $level > $last_level ) { $in_chain{$level}      = undef }
        else {
            # level unchanged
        }

        # We are only looking at code blocks
        my $token = $rtoken_vars->[_TOKEN_];
        my $type  = $rtoken_vars->[_TYPE_];
        next unless ( $type eq $token );

        if ( $token eq '{' ) {

            my $block_type = $rblock_type_of_seqno->{$type_sequence};
            if ( !$block_type ) {

                # patch for unrecognized block types which may not be labeled
                my $Kp = $self->K_previous_code($KK);
                next unless $Kp;
                $block_type = $rLL->[$Kp]->[_TOKEN_];
            }
            if ( $in_chain{$level} ) {

                # we are in a chain and are at an opening block brace.
                # See if we are welding this opening brace with the previous
                # block brace.  Get their identification numbers:
                my $closing_seqno = $in_chain{$level}->[1];
                my $opening_seqno = $type_sequence;

                # The preceding block must be on multiple lines so that its
                # closing brace will start a new line.
                if (   !$ris_broken_container->{$closing_seqno}
                    && !$rbreak_container->{$closing_seqno} )
                {
                    next unless ( $CBO == 2 );
                    $rbreak_container->{$closing_seqno} = 1;
                }

                # We can weld the closing brace to its following word ..
                my $Ko = $K_closing_container->{$closing_seqno};
                my $Kon;
                if ( defined($Ko) ) {
                    $Kon = $self->K_next_nonblank($Ko);
                }

                # ..unless it is a comment
                if ( defined($Kon) && $rLL->[$Kon]->[_TYPE_] ne '#' ) {

                    # OK to weld these two tokens...
                    $rK_weld_right->{$Ko} = $Kon;
                    $rK_weld_left->{$Kon} = $Ko;

                    # Set flag that we want to break the next container
                    # so that the cuddled line is balanced.
                    $rbreak_container->{$opening_seqno} = 1
                      if ($CBO);

                    # Remember which braces are cuddled.
                    # The closing brace is used to set adjusted indentations.
                    # The opening brace is not yet used but might eventually
                    # be needed in setting adjusted indentation.
                    $ris_cuddled_closing_brace->{$closing_seqno} = 1;

                }

            }
            else {

                # We are not in a chain. Start a new chain if we see the
                # starting block type.
                if ( $rcuddled_block_types->{$block_type} ) {
                    $in_chain{$level} = [ $block_type, $type_sequence ];
                }
                else {
                    $block_type = '*';
                    $in_chain{$level} = [ $block_type, $type_sequence ];
                }
            }
        }
        elsif ( $token eq '}' ) {
            if ( $in_chain{$level} ) {

                # We are in a chain at a closing brace.  See if this chain
                # continues..
                my $Knn = $self->K_next_code($KK);
                next unless $Knn;

                my $chain_type          = $in_chain{$level}->[0];
                my $next_nonblank_token = $rLL->[$Knn]->[_TOKEN_];
                if (
                    $rcuddled_block_types->{$chain_type}->{$next_nonblank_token}
                  )
                {

                    # Note that we do not weld yet because we must wait until
                    # we we are sure that an opening brace for this follows.
                    $in_chain{$level}->[1] = $type_sequence;
                }
                else { $in_chain{$level} = undef }
            }
        }
        else {
            # not a curly brace
        }
    }
    return;
} ## end sub weld_cuddled_blocks

sub find_nested_pairs {

    my ($self) = @_;

    # This routine is called once per file to do preliminary work needed for
    # the --weld-nested option.  This information is also needed for adding
    # semicolons.

    # Returns:
    #   \@nested_pairs = ref to a list in which each item is a ref to
    #   to the sequence numbers of two nested containers:
    #        [ $seqno_inner, $seqno_outer ]

    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );
    my $Num = @{$rLL};

    my $K_opening_container  = $self->[_K_opening_container_];
    my $K_closing_container  = $self->[_K_closing_container_];
    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];
    my $rK_next_seqno_by_K   = $self->[_rK_next_seqno_by_K_];

    # We define an array of pairs of nested containers
    my @nested_pairs;

    # Names of calling routines can either be marked as 'i' or 'w',
    # and they may invoke a sub call with an '->'. We will consider
    # any consecutive string of such types as a single unit when making
    # weld decisions.  We also allow a leading !
    my $is_name_type = {
        'i'  => 1,
        'w'  => 1,
        'U'  => 1,
        '->' => 1,
        '!'  => 1,
    };

    # Loop over all closing container tokens
    foreach my $inner_seqno ( keys %{$K_closing_container} ) {
        my $K_inner_closing = $K_closing_container->{$inner_seqno};

        # See if it is immediately followed by another, outer closing token
        my $K_outer_closing = $K_inner_closing + 1;
        $K_outer_closing += 1
          if ( $K_outer_closing < $Num
            && $rLL->[$K_outer_closing]->[_TYPE_] eq 'b' );

        next if ( $K_outer_closing >= $Num );
        my $outer_seqno = $rLL->[$K_outer_closing]->[_TYPE_SEQUENCE_];
        next if ( !$outer_seqno );
        my $token_outer_closing = $rLL->[$K_outer_closing]->[_TOKEN_];
        next if ( !$is_closing_token{$token_outer_closing} );

        # Simple filter: No commas or semicolons in the outer container
        my $rtype_count = $self->[_rtype_count_by_seqno_]->{$outer_seqno};
        if ($rtype_count) {
            next if ( $rtype_count->{','} || $rtype_count->{';'} );
        }

        # Now we have to check the opening tokens.
        my $K_outer_opening = $K_opening_container->{$outer_seqno};
        my $K_inner_opening = $K_opening_container->{$inner_seqno};
        next if ( !defined($K_outer_opening) );
        next if ( !defined($K_inner_opening) );

        my $inner_blocktype = $rblock_type_of_seqno->{$inner_seqno};
        my $outer_blocktype = $rblock_type_of_seqno->{$outer_seqno};

        # Verify that the inner opening token is the next container after the
        # outer opening token.
        my $K_io_check = $rK_next_seqno_by_K->[$K_outer_opening];
        next unless defined($K_io_check);
        if ( $K_io_check != $K_inner_opening ) {

            # The inner opening container does not immediately follow the outer
            # opening container, but we may still allow a weld if they are
            # separated by a sub signature.  For example, we may have something
            # like this, where $K_io_check may be at the first 'x' instead of
            # 'io'.  So we need to hop over the signature and see if we arrive
            # at 'io'.

            #            oo               io
            #             |     x       x |
            #   $obj->then( sub ( $code ) {
            #       ...
            #       return $c->render(text => '', status => $code);
            #   } );
            #   | |
            #  ic oc

            next if ( !$inner_blocktype || $inner_blocktype ne 'sub' );
            next if $rLL->[$K_io_check]->[_TOKEN_] ne '(';
            my $seqno_signature = $rLL->[$K_io_check]->[_TYPE_SEQUENCE_];
            next unless defined($seqno_signature);
            my $K_signature_closing = $K_closing_container->{$seqno_signature};
            next unless defined($K_signature_closing);
            my $K_test = $rK_next_seqno_by_K->[$K_signature_closing];
            next
              unless ( defined($K_test) && $K_test == $K_inner_opening );

            # OK, we have arrived at 'io' in the above diagram.  We should put
            # a limit on the length or complexity of the signature here.  There
            # is no perfect way to do this, one way is to put a limit on token
            # count.  For consistency with older versions, we should allow a
            # signature with a single variable to weld, but not with
            # multiple variables.  A single variable as in 'sub ($code) {' can
            # have a $Kdiff of 2 to 4, depending on spacing.

            # But two variables like 'sub ($v1,$v2) {' can have a diff of 4 to
            # 7, depending on spacing. So to keep formatting consistent with
            # previous versions, we will also avoid welding if there is a comma
            # in the signature.

            my $Kdiff = $K_signature_closing - $K_io_check;
            next if ( $Kdiff > 4 );

            # backup comma count test; but we cannot get here with Kdiff<=4
            my $rtc = $self->[_rtype_count_by_seqno_]->{$seqno_signature};
            next if ( $rtc && $rtc->{','} );
        }

        # Yes .. this is a possible nesting pair.
        # They can be separated by a small amount.
        my $K_diff = $K_inner_opening - $K_outer_opening;

        # Count the number of nonblank characters separating them.
        # Note: the $nonblank_count includes the inner opening container
        # but not the outer opening container, so it will be >= 1.
        if ( $K_diff < 0 ) {

            # Shouldn't happen
            DEVEL_MODE
              && Fault(
"unexpected negative index diff=$K_diff = Kio-Koo =$K_inner_opening - $K_outer_opening"
              );
            next;
        }
        my $nonblank_count = 0;
        my $type;
        my $is_name;

        # Here is an example of a long identifier chain which counts as a
        # single nonblank here (this spans about 10 K indexes):
        #     if ( !Boucherot::SetOfConnections->new->handler->execute(
        #        ^--K_o_o                                             ^--K_i_o
        #       @array) )
        my $Kn_first = $K_outer_opening;
        my $Kn_last_nonblank;
        my $saw_comment;

        foreach my $Kn ( $K_outer_opening + 1 .. $K_inner_opening ) {
            next if ( $rLL->[$Kn]->[_TYPE_] eq 'b' );
            if ( !$nonblank_count )        { $Kn_first = $Kn }
            if ( $Kn eq $K_inner_opening ) { $nonblank_count++; last; }
            $Kn_last_nonblank = $Kn;

            # skip chain of identifier tokens
            my $last_type    = $type;
            my $last_is_name = $is_name;
            $type = $rLL->[$Kn]->[_TYPE_];
            if ( $type eq '#' ) { $saw_comment = 1; last }
            $is_name = $is_name_type->{$type};
            next if ( $is_name && $last_is_name );

            # do not count a possible leading - of bareword hash key
            next if ( $type eq 'm' && !$last_type );

            $nonblank_count++;
            last if ( $nonblank_count > 2 );
        }

        # Do not weld across a comment .. fix for c058.
        next if ($saw_comment);

        # Patch for b1104: do not weld to a paren preceded by sort/map/grep
        # because the special line break rules may cause a blinking state
        if (   defined($Kn_last_nonblank)
            && $rLL->[$K_inner_opening]->[_TOKEN_] eq '('
            && $rLL->[$Kn_last_nonblank]->[_TYPE_] eq 'k' )
        {
            my $token = $rLL->[$Kn_last_nonblank]->[_TOKEN_];

            # Turn off welding at sort/map/grep (
            if ( $is_sort_map_grep{$token} ) { $nonblank_count = 10 }
        }

        my $token_oo = $rLL->[$K_outer_opening]->[_TOKEN_];

        if (

            # 1: adjacent opening containers, like: do {{
            $nonblank_count == 1

            # 2. anonymous sub + prototype or sig:  )->then( sub ($code) {
            # ... but it seems best not to stack two structural blocks, like
            # this
            #    sub make_anon_with_my_sub { sub {
            # because it probably hides the structure a little too much.
            || (   $inner_blocktype
                && $inner_blocktype eq 'sub'
                && $rLL->[$Kn_first]->[_TOKEN_] eq 'sub'
                && !$outer_blocktype )

            # 3. short item following opening paren, like:  fun( yyy (
            || $nonblank_count == 2 && $token_oo eq '('

            # 4. weld around fat commas, if requested (git #108), such as
            #     elf->call_method( method_name_foo => {
            || (   $type eq '=>'
                && $nonblank_count <= 3
                && %weld_fat_comma_rules
                && $weld_fat_comma_rules{$token_oo} )
          )
        {
            push @nested_pairs,
              [ $inner_seqno, $outer_seqno, $K_inner_closing ];
        }
        next;
    }

    #------------------------------------
    # Make the final list of nested pairs
    #------------------------------------

    # The weld routine expects the pairs in order in the form
    #   [$seqno_inner, $seqno_outer]
    # And they must be in the same order as the inner closing tokens
    # (otherwise, welds of three or more adjacent tokens will not work).  The K
    # value of this inner closing token has temporarily been stored for
    # sorting.
    @nested_pairs =

      # Drop the K index after sorting (it would cause trouble downstream)
      map { [ $_->[0], $_->[1] ] }

      # Sort on the K values
      sort { $a->[2] <=> $b->[2] } @nested_pairs;

    return \@nested_pairs;
} ## end sub find_nested_pairs

sub match_paren_control_flag {

    my ( $self, $seqno, $flag, ($rLL) ) = @_;

    # Input parameters:
    #   $seqno = sequence number of the container (should be paren)
    #   $flag  = the flag which defines what matches
    #   $rLL   = an optional alternate token list needed for respace operations

    # Decide if this paren is excluded by user request:
    #   undef matches no parens
    #   '*' matches all parens
    #   'k' matches only if the previous nonblank token is a perl builtin
    #       keyword (such as 'if', 'while'),
    #   'K' matches if 'k' does not, meaning if the previous token is not a
    #       keyword.
    #   'f' matches if the previous token is a function other than a keyword.
    #   'F' matches if 'f' does not.
    #   'w' matches if either 'k' or 'f' match.
    #   'W' matches if 'w' does not.

    $rLL = $self->[_rLL_] unless ( defined($rLL) );

    return 0 unless ( defined($flag) );
    return 0 if $flag eq '0';
    return 1 if $flag eq '1';
    return 1 if $flag eq '*';
    return 0 unless ($seqno);
    my $K_opening = $self->[_K_opening_container_]->{$seqno};
    return unless ( defined($K_opening) );

    my ( $is_f, $is_k, $is_w );
    my $Kp = $self->K_previous_nonblank( $K_opening, $rLL );
    if ( defined($Kp) ) {
        my $type_p = $rLL->[$Kp]->[_TYPE_];

        # keyword?
        $is_k = $type_p eq 'k';

        # function call?
        $is_f = $self->[_ris_function_call_paren_]->{$seqno};

        # either keyword or function call?
        $is_w = $is_k || $is_f;
    }
    my $match;
    if    ( $flag eq 'k' ) { $match = $is_k }
    elsif ( $flag eq 'K' ) { $match = !$is_k }
    elsif ( $flag eq 'f' ) { $match = $is_f }
    elsif ( $flag eq 'F' ) { $match = !$is_f }
    elsif ( $flag eq 'w' ) { $match = $is_w }
    elsif ( $flag eq 'W' ) { $match = !$is_w }
    else {
        ## no match
        DEVEL_MODE && Fault(<<EOM);
unexpected code '$flag' in sub match_paren_control_flag: expecting one of kKfFwW
EOM
    }
    return $match;
} ## end sub match_paren_control_flag

sub is_excluded_weld {

    my ( $self, $KK, $is_leading ) = @_;

    # Decide if this weld is excluded by user request

    # Given:
    #   $KK = index of this weld token
    #   $is_leading = true if this will the outer token of a weld

    my $rLL         = $self->[_rLL_];
    my $rtoken_vars = $rLL->[$KK];
    my $token       = $rtoken_vars->[_TOKEN_];
    my $rflags      = $weld_nested_exclusion_rules{$token};
    return 0 unless ( defined($rflags) );
    my $flag = $is_leading ? $rflags->[0] : $rflags->[1];
    return 0 unless ( defined($flag) );
    return 1 if $flag eq '*';
    my $seqno = $rtoken_vars->[_TYPE_SEQUENCE_];
    return $self->match_paren_control_flag( $seqno, $flag );
} ## end sub is_excluded_weld

# hashes to simplify welding logic
my %type_ok_after_bareword;
my %has_tight_paren;

BEGIN {

    # types needed for welding RULE 6
    my @q = qw# => -> { ( [ #;
    @type_ok_after_bareword{@q} = (1) x scalar(@q);

    # these types do not 'like' to be separated from a following paren
    @q = qw( w i q Q G C Z U );
    @has_tight_paren{@q} = (1) x scalar(@q);
} ## end BEGIN

use constant DEBUG_WELD => 0;

sub setup_new_weld_measurements {

    my ( $self, $Kouter_opening, $Kinner_opening ) = @_;

    # Define quantities to check for excess line lengths when welded.
    # Called by sub 'weld_nested_containers' and sub 'weld_nested_quotes'

    # Given:
    #   ($Kouter_opening, $Kinner_opening) = indexes of outer and inner opening
    #     containers to be welded

    # Returns these variables:
    #   $new_weld_ok = true (new weld ok) or false (do not start new weld)
    #   $starting_indent = starting indentation
    #   $starting_lentot = starting cumulative length
    #   $msg = diagnostic message for debugging

    my $rLL                = $self->[_rLL_];
    my $rlines             = $self->[_rlines_];
    my $rK_next_seqno_by_K = $self->[_rK_next_seqno_by_K_];

    my $starting_level;
    my $starting_ci;
    my $starting_lentot;
    my $maximum_text_length;
    my $msg = EMPTY_STRING;

    my $iline_oo = $rLL->[$Kouter_opening]->[_LINE_INDEX_];
    my $rK_range = $rlines->[$iline_oo]->{_rK_range};
    my ( $Kfirst, $Klast_uu ) = @{$rK_range};

    #-------------------------------------------------------------------------
    # We now define a reference index, '$Kref', from which to start measuring
    # This choice turns out to be critical for keeping welds stable during
    # iterations, so we go through a number of STEPS...
    #-------------------------------------------------------------------------

    # STEP 1: Our starting guess is to use measure from the first token of the
    # current line.  This is usually a good guess.
    my $Kref = $Kfirst;

    # STEP 2: See if we should go back a little farther
    my $Kprev = $self->K_previous_nonblank($Kfirst);
    if ( defined($Kprev) ) {

        # Avoid measuring from between an opening paren and a previous token
        # which should stay close to it ... fixes b1185
        my $token_oo  = $rLL->[$Kouter_opening]->[_TOKEN_];
        my $type_prev = $rLL->[$Kprev]->[_TYPE_];
        if (   $Kouter_opening == $Kfirst
            && $token_oo eq '('
            && $has_tight_paren{$type_prev} )
        {
            $Kref = $Kprev;
        }

        # Back up and count length from a token like '=' or '=>' if -lp
        # is used (this fixes b520)
        # ...or if a break is wanted before there
        elsif ($rOpts_line_up_parentheses
            || $want_break_before{$type_prev} )
        {

            # If there are other sequence items between the start of this line
            # and the opening token in question, then do not include tokens on
            # the previous line in length calculations.  This check added to
            # fix case b1174 which had a '?' on the line
            my $no_previous_seq_item = $Kref == $Kouter_opening
              || $rK_next_seqno_by_K->[$Kref] == $Kouter_opening;
            if ( $no_previous_seq_item
                && substr( $type_prev, 0, 1 ) eq '=' )
            {
                $Kref = $Kprev;

                # Fix for b1144 and b1112: backup to the first nonblank
                # character before the =>, or to the start of its line.
                if ( $type_prev eq '=>' ) {
                    my $iline_prev    = $rLL->[$Kprev]->[_LINE_INDEX_];
                    my $rK_range_prev = $rlines->[$iline_prev]->{_rK_range};
                    my ( $Kfirst_prev, $Klast_prev_uu ) = @{$rK_range_prev};
                    my $nb_count = 0;
                    foreach my $KK ( reverse( $Kfirst_prev .. $Kref - 1 ) ) {
                        next if ( $rLL->[$KK]->[_TYPE_] eq 'b' );
                        $Kref = $KK;

                        # Continue at type 'w' to get previous dash.  Example:
                        #   -classification => [ qw(
                        # This fixes b1502.
                        last if ( $nb_count || $rLL->[$KK]->[_TYPE_] ne 'w' );
                        $nb_count++;
                    }
                }
            }
        }
        else {
            # do not need to backup
        }
    }

    # STEP 3: Now look ahead for a ternary and, if found, use it.
    # This fixes case b1182.
    # Also look for a ')' at the same level and, if found, use it.
    # This fixes case b1224.
    if ( $Kref < $Kouter_opening ) {
        my $Knext      = $rK_next_seqno_by_K->[$Kref];
        my $level_oo   = $rLL->[$Kouter_opening]->[_LEVEL_];
        my $Knext_last = $Knext;
        while ( $Knext && $Knext < $Kouter_opening ) {
            if ( $rLL->[$Knext]->[_LEVEL_] == $level_oo ) {
                if (   $is_ternary{ $rLL->[$Knext]->[_TYPE_] }
                    || $rLL->[$Knext]->[_TOKEN_] eq ')' )
                {
                    $Kref = $Knext;
                    last;
                }
            }
            $Knext = $rK_next_seqno_by_K->[$Knext];
            if ( $Knext <= $Knext_last ) {
                ## shouldn't happen: $rK_next_seqno_by_K is corrupted
                DEVEL_MODE && Fault(<<EOM);
Knext should not increase: Knext_last=$Knext_last >= Knext=$Knext
EOM
                last;
            }
            $Knext_last = $Knext;
        } ## end while ( $Knext && $Knext ...)
    }

    # fix c1468 - do not measure from a leading opening block brace -
    # which is not a one-line block
    if (   $Kref < $Kouter_opening
        && $Kref == $Kfirst
        && $rLL->[$Kref]->[_TOKEN_] eq '{' )
    {
        my $seqno_ref = $rLL->[$Kref]->[_TYPE_SEQUENCE_];
        if ($seqno_ref) {
            my $block_type = $self->[_rblock_type_of_seqno_]->{$seqno_ref};
            if ($block_type) {
                my $Kref_c   = $self->[_K_closing_container_]->{$seqno_ref};
                my $ln_ref_o = $rLL->[$Kref]->[_LINE_INDEX_];
                my $ln_ref_c = $rLL->[$Kref_c]->[_LINE_INDEX_];
                if ( $ln_ref_c > $ln_ref_o ) {
                    $Kref = $self->K_next_nonblank($Kref);
                }
            }
        }
    }

    # Define the starting measurements we will need
    $starting_lentot =
      $Kref <= 0 ? 0 : $rLL->[ $Kref - 1 ]->[_CUMULATIVE_LENGTH_];
    $starting_level = $rLL->[$Kref]->[_LEVEL_];
    $starting_ci    = $rLL->[$Kref]->[_CI_LEVEL_];

    $maximum_text_length = $maximum_text_length_at_level[$starting_level] -
      $starting_ci * $rOpts_continuation_indentation;

    # STEP 4: Switch to using the outer opening token as the reference
    # point if a line break before it would make a longer line.
    # Fixes case b1055 and is also an alternate fix for b1065.
    my $starting_level_oo = $rLL->[$Kouter_opening]->[_LEVEL_];
    if ( $Kref < $Kouter_opening ) {
        my $starting_ci_oo = $rLL->[$Kouter_opening]->[_CI_LEVEL_];
        my $lentot_oo = $rLL->[ $Kouter_opening - 1 ]->[_CUMULATIVE_LENGTH_];
        my $maximum_text_length_oo =
          $maximum_text_length_at_level[$starting_level_oo] -
          $starting_ci_oo * $rOpts_continuation_indentation;

        # The excess length to any cumulative length K = lenK is either
        #     $excess = $lenk - ($lentot    + $maximum_text_length),     or
        #     $excess = $lenk - ($lentot_oo + $maximum_text_length_oo),
        # so the worst case (maximum excess) corresponds to the configuration
        # with minimum value of the sum: $lentot + $maximum_text_length
        if ( $lentot_oo + $maximum_text_length_oo <
            $starting_lentot + $maximum_text_length )
        {
            $Kref                = $Kouter_opening;
            $starting_level      = $starting_level_oo;
            $starting_ci         = $starting_ci_oo;
            $starting_lentot     = $lentot_oo;
            $maximum_text_length = $maximum_text_length_oo;
        }
    }

    my $new_weld_ok = 1;

    # STEP 5, fix b1020: Avoid problem areas with the -wn -lp combination.  The
    # combination -wn -lp -dws -naws does not work well and can cause blinkers.
    # It will probably only occur in stress testing.  For this situation we
    # will only start a new weld if we start at a 'good' location.
    # - Added 'if' to fix case b1032.
    # - Require blank before certain previous characters to fix b1111.
    # - Add ';' to fix case b1139
    # - Convert from '$ok_to_weld' to '$new_weld_ok' to fix b1162.
    # - relaxed constraints for b1227
    # - added skip if type is 'q' for b1349 and b1350 b1351 b1352 b1353
    # - added skip if type is 'Q' for b1447
    if (   $starting_ci
        && $rOpts_line_up_parentheses
        && $rOpts_delete_old_whitespace
        && !$rOpts_add_whitespace
        && $rLL->[$Kinner_opening]->[_TYPE_] ne 'q'
        && $rLL->[$Kinner_opening]->[_TYPE_] ne 'Q'
        && defined($Kprev) )
    {
        my $type_first  = $rLL->[$Kfirst]->[_TYPE_];
        my $token_first = $rLL->[$Kfirst]->[_TOKEN_];
        my $type_prev   = $rLL->[$Kprev]->[_TYPE_];
        my $type_pp     = 'b';
        if ( $Kprev >= 0 ) { $type_pp = $rLL->[ $Kprev - 1 ]->[_TYPE_] }

        my $is_good_location =

          $type_prev =~ /^[\,\.\;]/
          || ( $type_prev =~ /^[=\{\[\(\L]/
            && ( $type_pp eq 'b' || $type_pp eq '}' || $type_first eq 'k' ) )
          || $type_first =~ /^[=\,\.\;\{\[\(\L]/
          || $type_first eq '||'
          || (
            $type_first eq 'k'
            && (   $token_first eq 'if'
                || $token_first eq 'or' )
          );

        if ( !$is_good_location ) {
            $msg =
"Skipping weld: poor break with -lp and ci at type_first='$type_first' type_prev='$type_prev' type_pp=$type_pp\n";
            $new_weld_ok = 0;
        }
    }
    return ( $new_weld_ok, $maximum_text_length, $starting_lentot, $msg );
} ## end sub setup_new_weld_measurements

sub excess_line_length_for_Krange {

    my ( $self, $Kfirst, $Klast ) = @_;

    # returns $excess_length =
    #   by how many characters a line composed of tokens $Kfirst .. $Klast will
    #   exceed the allowed line length

    my $rLL = $self->[_rLL_];
    my $length_before_Kfirst =
      $Kfirst <= 0
      ? 0
      : $rLL->[ $Kfirst - 1 ]->[_CUMULATIVE_LENGTH_];

    # backup before a side comment if necessary
    my $Kend = $Klast;
    if (   $rOpts_ignore_side_comment_lengths
        && $rLL->[$Klast]->[_TYPE_] eq '#' )
    {
        my $Kprev = $self->K_previous_nonblank($Klast);
        if ( defined($Kprev) && $Kprev >= $Kfirst ) { $Kend = $Kprev }
    }

    # get the length of the text
    my $length = $rLL->[$Kend]->[_CUMULATIVE_LENGTH_] - $length_before_Kfirst;

    # get the size of the text window
    my $level           = $rLL->[$Kfirst]->[_LEVEL_];
    my $ci_level        = $rLL->[$Kfirst]->[_CI_LEVEL_];
    my $max_text_length = $maximum_text_length_at_level[$level] -
      $ci_level * $rOpts_continuation_indentation;

    my $excess_length = $length - $max_text_length;

    DEBUG_WELD
      && print
"Kfirst=$Kfirst, Klast=$Klast, Kend=$Kend, level=$level, ci=$ci_level, max_text_length=$max_text_length, length=$length\n";
    return ($excess_length);
} ## end sub excess_line_length_for_Krange

sub weld_nested_containers {

    my ($self) = @_;

    # Called once per file for option '--weld-nested-containers'

    my $rK_weld_left  = $self->[_rK_weld_left_];
    my $rK_weld_right = $self->[_rK_weld_right_];

    # This routine implements the -wn flag by "welding together"
    # the nested closing and opening tokens which were previously
    # identified by sub 'find_nested_pairs'.  "welding" simply
    # involves setting certain hash values which will be checked
    # later during formatting.

    my $rLL                     = $self->[_rLL_];
    my $rlines                  = $self->[_rlines_];
    my $K_opening_container     = $self->[_K_opening_container_];
    my $K_closing_container     = $self->[_K_closing_container_];
    my $rK_next_seqno_by_K      = $self->[_rK_next_seqno_by_K_];
    my $rblock_type_of_seqno    = $self->[_rblock_type_of_seqno_];
    my $ris_asub_block          = $self->[_ris_asub_block_];
    my $rmax_vertical_tightness = $self->[_rmax_vertical_tightness_];

    my $rOpts_asbl = $rOpts->{'opening-anonymous-sub-brace-on-new-line'};

    # Find nested pairs of container tokens for any welding.
    my $rnested_pairs = $self->find_nested_pairs();

    # Return unless there are nested pairs to weld
    return unless ( defined($rnested_pairs) && @{$rnested_pairs} );

    # NOTE: It would be nice to apply RULE 5 right here by deleting unwanted
    # pairs.  But it isn't clear if this is possible because we don't know
    # which sequences might actually start a weld.

    my $rOpts_break_at_old_method_breakpoints =
      $rOpts->{'break-at-old-method-breakpoints'};

    # This array will hold the sequence numbers of the tokens to be welded.
    my @welds;

    # Variables needed for estimating line lengths
    my $maximum_text_length;    # maximum spaces available for text
    my $starting_lentot;        # cumulative text to start of current line

    my $iline_outer_opening   = -1;
    my $weld_count_this_start = 0;
    my $weld_starts_in_block  = 0;

    # OLD: $single_line_tol added to fix cases b1180 b1181
    #       = $rOpts_continuation_indentation > $rOpts_indent_columns ? 1 : 0;
    # NEW: $single_line_tol=0  fixes b1212; and b1180-1181 work ok now
    #                      =1  for -vmll and -lp; fixes b1452, b1453, b1454
    # NOTE: the combination -vmll and -lp can be unstable, especially when
    # also combined with -wn. It may eventually be necessary to turn off -vmll
    # if -lp is set. For now, this works. The value '1' is a minimum which
    # works but can be increased if necessary.
    my $single_line_tol =
      $rOpts_variable_maximum_line_length && $rOpts_line_up_parentheses
      ? 1
      : 0;

    my $multiline_tol = $single_line_tol + 1 +
      max( $rOpts_indent_columns, $rOpts_continuation_indentation );

    # Define a welding cutoff level: do not start a weld if the inside
    # container level equals or exceeds this level.

    # We use the minimum of two criteria, either of which may be more
    # restrictive.  The 'alpha' value is more restrictive in (b1206, b1252) and
    # the 'beta' value is more restrictive in other cases (b1243).
    # Reduced beta term from beta+3 to beta+2 to fix b1401. Previously:
    # my $weld_cutoff_level = min($stress_level_alpha, $stress_level_beta + 2);
    # This is now '$high_stress_level'.

    # The vertical tightness flags can throw off line length calculations.
    # This patch was added to fix instability issue b1284.
    # It works to always use a tol of 1 for 1 line block length tests, but
    # this restricted value keeps test case wn6.wn working as before.
    # It may be necessary to include '[' and '{' here in the future.
    my $one_line_tol = $opening_vertical_tightness{'('} ? 1 : 0;

    # Abbreviations:
    #  _oo=outer opening, i.e. first of  { {
    #  _io=inner opening, i.e. second of { {
    #  _oc=outer closing, i.e. second of } {
    #  _ic=inner closing, i.e. first of  } }

    my $previous_pair;

    # Main loop over nested pairs...
    # We are working from outermost to innermost pairs so that
    # level changes will be complete when we arrive at the inner pairs.
    while ( @{$rnested_pairs} ) {
        my $item = pop @{$rnested_pairs};
        my ( $inner_seqno, $outer_seqno ) = @{$item};

        my $Kouter_opening = $K_opening_container->{$outer_seqno};
        my $Kinner_opening = $K_opening_container->{$inner_seqno};
        my $Kouter_closing = $K_closing_container->{$outer_seqno};
        my $Kinner_closing = $K_closing_container->{$inner_seqno};

        # RULE: do not weld if inner container has <= 3 tokens unless the next
        # token is a heredoc (so we know there will be multiple lines)
        if ( $Kinner_closing - $Kinner_opening <= 4 ) {
            my $Knext_nonblank = $self->K_next_nonblank($Kinner_opening);
            next unless defined($Knext_nonblank);
            my $type = $rLL->[$Knext_nonblank]->[_TYPE_];
            next unless ( $type eq 'h' );
        }

        my $outer_opening = $rLL->[$Kouter_opening];
        my $inner_opening = $rLL->[$Kinner_opening];
        my $outer_closing = $rLL->[$Kouter_closing];
        my $inner_closing = $rLL->[$Kinner_closing];

        # RULE: do not weld to a hash brace.  The reason is that it has a very
        # strong bond strength to the next token, so a line break after it
        # may not work.  Previously we allowed welding to something like @{
        # but that caused blinking states (cases b751, b779).
        if ( $inner_opening->[_TYPE_] eq 'L' ) {
            next;
        }

        # RULE: do not weld to a square bracket which does not contain commas
        if ( $inner_opening->[_TYPE_] eq '[' ) {
            my $rtype_count = $self->[_rtype_count_by_seqno_]->{$inner_seqno};
            next unless ( $rtype_count && $rtype_count->{','} );

            # Do not weld if there is text before a '[' such as here:
            #      curr_opt ( @beg [2,5] )
            # It will not break into the desired sandwich structure.
            # This fixes case b109, 110.
            my $Kdiff = $Kinner_opening - $Kouter_opening;
            next if ( $Kdiff > 2 );
            next
              if ( $Kdiff == 2
                && $rLL->[ $Kouter_opening + 1 ]->[_TYPE_] ne 'b' );

        }

        # RULE: Avoid welding under stress.  The idea is that we need to have a
        # little space* within a welded container to avoid instability.  Note
        # that after each weld the level values are reduced, so long multiple
        # welds can still be made.  This rule will seldom be a limiting factor
        # in actual working code. Fixes b1206, b1243.
        my $inner_level = $inner_opening->[_LEVEL_];
        if ( $inner_level >= $high_stress_level ) { next }

        # extra tolerance added under high stress to fix b1481
        my $stress_tol = ( $high_stress_level - $inner_level <= 1 ) ? 1 : 0;

        # Set flag saying if this pair starts a new weld
        my $starting_new_weld = !( @welds && $outer_seqno == $welds[-1]->[0] );

        # Set flag saying if this pair is adjacent to the previous nesting pair
        # (even if previous pair was rejected as a weld)
        my $touch_previous_pair =
          defined($previous_pair) && $outer_seqno == $previous_pair->[0];
        $previous_pair = $item;

        my $do_not_weld_rule = 0;
        my $Msg              = EMPTY_STRING;
        my $is_one_line_weld;

        my $iline_oo = $outer_opening->[_LINE_INDEX_];
        my $iline_io = $inner_opening->[_LINE_INDEX_];
        my $iline_ic = $inner_closing->[_LINE_INDEX_];
        my $iline_oc = $outer_closing->[_LINE_INDEX_];
        my $token_oo = $outer_opening->[_TOKEN_];
        my $token_io = $inner_opening->[_TOKEN_];

        # DO-NOT-WELD RULE 7: Do not weld if this conflicts with -bom
        # Added for case b973. Moved here from below to fix b1423.
        if (  !$do_not_weld_rule
            && $rOpts_break_at_old_method_breakpoints
            && $iline_io > $iline_oo )
        {

            foreach my $iline ( $iline_oo + 1 .. $iline_io ) {
                my $rK_range = $rlines->[$iline]->{_rK_range};
                next unless defined($rK_range);
                my ( $Kfirst, $Klast_uu ) = @{$rK_range};
                next unless defined($Kfirst);
                if ( $rLL->[$Kfirst]->[_TYPE_] eq '->' ) {
                    $do_not_weld_rule = 7;
                    last;
                }
            }
        }
        next if ($do_not_weld_rule);

        # Turn off vertical tightness at possible one-line welds.  Fixes b1402,
        # b1419, b1421, b1424, b1425. This also fixes issues b1338, b1339,
        # b1340, b1341, b1342, b1343, which previously used a separate fix.
        # Issue c161 is the latest and simplest check, using
        # $iline_ic==$iline_io as the test.
        if (   %opening_vertical_tightness
            && $iline_ic == $iline_io
            && $opening_vertical_tightness{$token_oo} )
        {
            $rmax_vertical_tightness->{$outer_seqno} = 0;
        }

        my $is_multiline_weld =
             $iline_oo == $iline_io
          && $iline_ic == $iline_oc
          && $iline_io != $iline_ic;

        if (DEBUG_WELD) {
            my $len_oo = $rLL->[$Kouter_opening]->[_CUMULATIVE_LENGTH_];
            my $len_io = $rLL->[$Kinner_opening]->[_CUMULATIVE_LENGTH_];
            $Msg .= <<EOM;
Pair seqo=$outer_seqno seqi=$inner_seqno  lines: loo=$iline_oo lio=$iline_io lic=$iline_ic loc=$iline_oc
Koo=$Kouter_opening Kio=$Kinner_opening Kic=$Kinner_closing Koc=$Kouter_closing lenoo=$len_oo lenio=$len_io
tokens '$token_oo' .. '$token_io'
EOM
        }

        # DO-NOT-WELD RULE 0:
        # Avoid a new paren-paren weld if inner parens are 'sheared' (separated
        # by one line).  This can produce instabilities (fixes b1250 b1251
        # 1256).
        if (  !$is_multiline_weld
            && $iline_ic == $iline_io + 1
            && $token_oo eq '('
            && $token_io eq '(' )
        {
            if (DEBUG_WELD) {
                $Msg .= "RULE 0: Not welding due to sheared inner parens\n";
                print {*STDOUT} $Msg;
            }
            next;
        }

        # If this pair is not adjacent to the previous pair (skipped or not),
        # then measure lengths from the start of line of oo.
        if (
            !$touch_previous_pair

            # Also do this if restarting at a new line; fixes case b965, s001
            || ( !$weld_count_this_start && $iline_oo > $iline_outer_opening )
          )
        {

            # Remember the line we are using as a reference
            $iline_outer_opening   = $iline_oo;
            $weld_count_this_start = 0;
            $weld_starts_in_block  = 0;

            ( my $new_weld_ok, $maximum_text_length, $starting_lentot, my $msg )
              = $self->setup_new_weld_measurements( $Kouter_opening,
                $Kinner_opening );

            if (
                !$new_weld_ok
                && (   $iline_oo != $iline_io
                    || $iline_ic != $iline_oc )
              )
            {
                if (DEBUG_WELD) { print {*STDOUT} $msg }
                next;
            }

            my $rK_range = $rlines->[$iline_oo]->{_rK_range};
            my ( $Kfirst, $Klast ) = @{$rK_range};

            # An existing one-line weld is a line in which
            # (1) the containers are all on one line, and
            # (2) the line does not exceed the allowable length
            if ( $iline_oo == $iline_oc ) {

                # All the tokens are on one line, now check their length.
                # Start with the full line index range. We will reduce this
                # in the coding below in some cases.
                my $Kstart = $Kfirst;
                my $Kstop  = $Klast;

                # Note that the following minimal choice for measuring will
                # work and will not cause any instabilities because it is
                # invariant:

                ##  my $Kstart = $Kouter_opening;
                ##  my $Kstop  = $Kouter_closing;

                # But that can lead to some undesirable welds.  So a little
                # more complicated method has been developed.

                # We are trying to avoid creating bad two-line welds when we are
                # working on long, previously un-welded input text, such as

                # INPUT (example of a long input line weld candidate):
                ## $mutation->transpos( $self->RNA->position($mutation->label, $atg_label));

                #  GOOD two-line break: (not welded; result marked too long):
                ## $mutation->transpos(
                ##                 $self->RNA->position($mutation->label, $atg_label));

                #  BAD two-line break: (welded; result if we weld):
                ## $mutation->transpos($self->RNA->position(
                ##                                      $mutation->label, $atg_label));

                # We can only get an approximate estimate of the final length,
                # since the line breaks may change, and for -lp mode because
                # even the indentation is not yet known.

                my $level_first = $rLL->[$Kfirst]->[_LEVEL_];
                my $level_last  = $rLL->[$Klast]->[_LEVEL_];
                my $level_oo    = $rLL->[$Kouter_opening]->[_LEVEL_];
                my $level_oc    = $rLL->[$Kouter_closing]->[_LEVEL_];

                # - measure to the end of the original line if balanced
                # - measure to the closing container if unbalanced (fixes b1230)
                #if ( $level_first != $level_last ) { $Kstop = $Kouter_closing }
                if ( $level_oc > $level_last ) { $Kstop = $Kouter_closing }

                # - measure from the start of the original line if balanced
                # - measure from the most previous token with same level
                #   if unbalanced (b1232)
                if ( $Kouter_opening > $Kfirst && $level_oo > $level_first ) {
                    $Kstart = $Kouter_opening;

                    foreach
                      my $KK ( reverse( $Kfirst + 1 .. $Kouter_opening - 1 ) )
                    {
                        next if ( $rLL->[$KK]->[_TYPE_] eq 'b' );
                        last if ( $rLL->[$KK]->[_LEVEL_] < $level_oo );
                        $Kstart = $KK;
                    }
                }

                my $excess =
                  $self->excess_line_length_for_Krange( $Kstart, $Kstop );

                # Coding simplified here for case b1219.
                # Increased tol from 0 to 1 when pvt>0 to fix b1284.
                $is_one_line_weld = $excess <= $one_line_tol;
            }

            # DO-NOT-WELD RULE 1:
            # Do not weld something that looks like the start of a two-line
            # function call, like this: <<snippets/wn6.in>>
            #    $trans->add_transformation(
            #        PDL::Graphics::TriD::Scale->new( $sx, $sy, $sz ) );
            # We will look for a semicolon after the closing paren.

            # We want to weld something complex, like this though
            # my $compass = uc( opposite_direction( line_to_canvas_direction(
            #     @{ $coords[0] }, @{ $coords[1] } ) ) );
            # Otherwise we will get a 'blinker'. For example, the following
            # would become a blinker without this rule:
            #        $Self->_Add( $SortOrderDisplay{ $Field
            #              ->GenerateFieldForSelectSQL() } );
            # But it is okay to weld a two-line statement if it looks like
            # it was already welded, meaning that the two opening containers are
            # on a different line that the two closing containers.  This is
            # necessary to prevent blinking of something like this with
            # perltidy -wn -pbp (starting indentation two levels deep):

            # $top_label->set_text( gettext(
            #    "Unable to create personal directory - check permissions.") );
            if (   $iline_oc == $iline_oo + 1
                && $iline_io == $iline_ic
                && $token_oo eq '(' )
            {

                # Look for following semicolon...
                my $Knext_nonblank = $self->K_next_nonblank($Kouter_closing);
                my $next_nonblank_type =
                  defined($Knext_nonblank)
                  ? $rLL->[$Knext_nonblank]->[_TYPE_]
                  : 'b';
                if ( $next_nonblank_type eq ';' ) {

                    # Then do not weld if no other containers between inner
                    # opening and closing.
                    my $Knext_seq_item = $rK_next_seqno_by_K->[$Kinner_opening];
                    if ( $Knext_seq_item == $Kinner_closing ) {
                        $do_not_weld_rule = 1;
                    }
                }
            }
        } ## end starting new weld sequence

        else {

            # set the 1-line flag if continuing a weld sequence; fixes b1239
            $is_one_line_weld = ( $iline_oo == $iline_oc );
        }

        # DO-NOT-WELD RULE 2:
        # Do not weld an opening paren to an inner one line brace block
        # We will just use old line numbers for this test and require
        # iterations if necessary for convergence

        # For example, otherwise we could cause the opening paren
        # in the following example to separate from the caller name
        # as here:

        #    $_[0]->code_handler
        #      ( sub { $more .= $_[1] . ":" . $_[0] . "\n" } );

        # Here is another example where we do not want to weld:
        #  $wrapped->add_around_modifier(
        #    sub { push @tracelog => 'around 1'; $_[0]->(); } );

        # If the one line sub block gets broken due to length or by the
        # user, then we can weld.  The result will then be:
        # $wrapped->add_around_modifier( sub {
        #    push @tracelog => 'around 1';
        #    $_[0]->();
        # } );

        # Updated to fix cases b1082 b1102 b1106 b1115:
        # Also, do not weld to an intact inner block if the outer opening token
        # is on a different line. For example, this prevents oscillation
        # between these two states in case b1106:

        #    return map{
        #        ($_,[$self->$_(@_[1..$#_])])
        #    }@every;

        #    return map { (
        #        $_, [ $self->$_( @_[ 1 .. $#_ ] ) ]
        #    ) } @every;

        # The effect of this change on typical code is very minimal.  Sometimes
        # it may take a second iteration to converge, but this gives protection
        # against blinking.
        if (   !$do_not_weld_rule
            && !$is_one_line_weld
            && $iline_ic == $iline_io )
        {
            $do_not_weld_rule = 2
              if ( $token_oo eq '(' || $iline_oo != $iline_io );
        }

        # DO-NOT-WELD RULE 2A:
        # Do not weld an opening asub brace in -lp mode if -asbl is set. This
        # helps avoid instabilities in one-line block formation, and fixes
        # b1241.  Previously, the '$is_one_line_weld' flag was tested here
        # instead of -asbl, and this fixed most cases. But it turns out that
        # the real problem was the -asbl flag, and switching to this was
        # necessary to fixe b1268.  This also fixes b1269, b1277, b1278.
        if (  !$do_not_weld_rule
            && $rOpts_line_up_parentheses
            && $rOpts_asbl
            && $ris_asub_block->{$outer_seqno} )
        {
            $do_not_weld_rule = '2A';
        }

        # DO-NOT-WELD RULE 3:
        # Do not weld if this makes our line too long.
        # Use a tolerance which depends on if the old tokens were welded
        # (fixes cases b746 b748 b749 b750 b752 b753 b754 b755 b756 b758 b759)
        if ( !$do_not_weld_rule ) {

            # Measure to a little beyond the inner opening token if it is
            # followed by a bare word, which may have unusual line break rules.

            # NOTE: Originally this was OLD RULE 6: do not weld to a container
            # which is followed on the same line by an unknown bareword token.
            # This can cause blinkers (cases b626, b611).  But OK to weld one
            # line welds to fix cases b1057 b1064.  For generality, OLD RULE 6
            # has been merged into RULE 3 here to also fix cases b1078 b1091.

            my $K_for_length = $Kinner_opening;
            my $Knext_io     = $self->K_next_nonblank($Kinner_opening);
            next unless ( defined($Knext_io) );    # shouldn't happen
            my $type_io_next = $rLL->[$Knext_io]->[_TYPE_];

            # Note: may need to eventually also include other types here,
            # such as 'Z' and 'Y':   if ($type_io_next =~ /^[ZYw]$/) {
            if ( $type_io_next eq 'w' ) {
                my $Knext_io2 = $self->K_next_nonblank($Knext_io);
                next unless ( defined($Knext_io2) );
                my $type_io_next2 = $rLL->[$Knext_io2]->[_TYPE_];
                if ( !$type_ok_after_bareword{$type_io_next2} ) {
                    $K_for_length = $Knext_io2;
                }
            }

            # Use a tolerance for welds over multiple lines to avoid blinkers.
            # We can use zero tolerance if it looks like we are working on an
            # existing weld.
            my $tol =
                $is_one_line_weld || $is_multiline_weld
              ? $single_line_tol
              : $multiline_tol;
            $tol += $stress_tol;

            # By how many characters does this exceed the text window?
            my $excess =
              $self->cumulative_length_before_K($K_for_length) -
              $starting_lentot + 1 + $tol -
              $maximum_text_length;

            # Old patch: Use '>=0' instead of '> 0' here to fix cases b995 b998
            # b1000 b1001 b1007 b1008 b1009 b1010 b1011 b1012 b1016 b1017 b1018
            # Revised patch: New tolerance definition allows going back to '> 0'
            # here.  This fixes case b1124.  See also cases b1087 and b1087a.
            if ( $excess > 0 ) { $do_not_weld_rule = 3 }

            if (DEBUG_WELD) {
                $Msg .=
"RULE 3 test: excess length to K=$Kinner_opening is $excess > 0 with tol= $tol ?) \n";
            }
        }

        # DO-NOT-WELD RULE 4; implemented for git#10:
        # Do not weld an opening -ce brace if the next container is on a single
        # line, different from the opening brace. (This is very rare).  For
        # example, given the following with -ce, we will avoid joining the {
        # and [

        #  } else {
        #      [ $_, length($_) ]
        #  }

        # because this would produce a terminal one-line block:

        #  } else { [ $_, length($_) ]  }

        # which may not be what is desired. But given this input:

        #  } else { [ $_, length($_) ]  }

        # then we will do the weld and retain the one-line block
        if ( !$do_not_weld_rule && $rOpts->{'cuddled-else'} ) {
            my $block_type = $rblock_type_of_seqno->{$outer_seqno};
            if ( $block_type && $rcuddled_block_types->{'*'}->{$block_type} ) {
                my $io_line = $inner_opening->[_LINE_INDEX_];
                my $ic_line = $inner_closing->[_LINE_INDEX_];
                my $oo_line = $outer_opening->[_LINE_INDEX_];
                if ( $oo_line < $io_line && $ic_line == $io_line ) {
                    $do_not_weld_rule = 4;
                }
            }
        }

        # DO-NOT-WELD RULE 5: do not include welds excluded by user
        if (
              !$do_not_weld_rule
            && %weld_nested_exclusion_rules
            && ( $self->is_excluded_weld( $Kouter_opening, $starting_new_weld )
                || $self->is_excluded_weld( $Kinner_opening, 0 ) )
          )
        {
            $do_not_weld_rule = 5;
        }

        # DO-NOT-WELD RULE 6: This has been merged into RULE 3 above.

        if ($do_not_weld_rule) {

            # After neglecting a pair, we start measuring from start of point
            # io ... but not if previous type does not like to be separated
            # from its container (fixes case b1184)
            my $Kprev     = $self->K_previous_nonblank($Kinner_opening);
            my $type_prev = defined($Kprev) ? $rLL->[$Kprev]->[_TYPE_] : 'w';
            if ( !$has_tight_paren{$type_prev} ) {
                my $starting_level    = $inner_opening->[_LEVEL_];
                my $starting_ci_level = $inner_opening->[_CI_LEVEL_];
                $starting_lentot =
                  $self->cumulative_length_before_K($Kinner_opening);
                $maximum_text_length =
                  $maximum_text_length_at_level[$starting_level] -
                  $starting_ci_level * $rOpts_continuation_indentation;
            }

            if (DEBUG_WELD) {
                $Msg .= "Not welding due to RULE $do_not_weld_rule\n";
                print {*STDOUT} $Msg;
            }

            # Normally, a broken pair should not decrease indentation of
            # intermediate tokens:
            ##      if ( $last_pair_broken ) { next }
            # However, for long strings of welded tokens, such as '{{{{{{...'
            # we will allow broken pairs to also remove indentation.
            # This will keep very long strings of opening and closing
            # braces from marching off to the right.  We will do this if the
            # number of tokens in a weld before the broken weld is 4 or more.
            # This rule will mainly be needed for test scripts, since typical
            # welds have fewer than about 4 welded tokens.
            if ( !@welds || @{ $welds[-1] } < 4 ) { next }
        }

        # otherwise start new weld ...
        elsif ($starting_new_weld) {
            $weld_count_this_start++;
            if (DEBUG_WELD) {
                $Msg .= "Starting new weld\n";
                print {*STDOUT} $Msg;
            }
            push @welds, $item;

            my $parent_seqno = $self->parent_seqno_by_K($Kouter_closing);
            $weld_starts_in_block = $parent_seqno == SEQ_ROOT
              || $rblock_type_of_seqno->{$parent_seqno};

            $rK_weld_right->{$Kouter_opening} = $Kinner_opening;
            $rK_weld_left->{$Kinner_opening}  = $Kouter_opening;

            $rK_weld_right->{$Kinner_closing} = $Kouter_closing;
            $rK_weld_left->{$Kouter_closing}  = $Kinner_closing;
        }

        # ... or extend current weld
        else {
            $weld_count_this_start++;
            if (DEBUG_WELD) {
                $Msg .= "Extending current weld\n";
                print {*STDOUT} $Msg;
            }
            unshift @{ $welds[-1] }, $inner_seqno;
            $rK_weld_right->{$Kouter_opening} = $Kinner_opening;
            $rK_weld_left->{$Kinner_opening}  = $Kouter_opening;

            $rK_weld_right->{$Kinner_closing} = $Kouter_closing;
            $rK_weld_left->{$Kouter_closing}  = $Kinner_closing;

            # Keep a broken container broken at multiple welds.  This might
            # also be useful for simple welds, but for now it is restricted
            # to multiple welds to minimize changes to existing coding.  This
            # fixes b1429, b1430.  Updated for issue c198: but allow a
            # line differences of 1 (simple shear) so that a simple shear
            # can remain or become a single line.
            if ( $iline_ic - $iline_io > 1 ) {

                # Only set this break if it is the last possible weld in this
                # chain.  This will keep some extreme test cases unchanged.
                my $is_chain_end = !@{$rnested_pairs}
                  || $rnested_pairs->[-1]->[1] != $inner_seqno;
                if ($is_chain_end) {
                    $self->[_rbreak_container_]->{$inner_seqno} = 1;
                }
            }
        }

        # After welding, reduce the indentation level if all intermediate tokens
        my $dlevel = $outer_opening->[_LEVEL_] - $inner_opening->[_LEVEL_];
        if ( $dlevel != 0 ) {
            my $Kstart = $Kinner_opening;
            my $Kstop  = $Kinner_closing;
            foreach my $KK ( $Kstart .. $Kstop ) {
                $rLL->[$KK]->[_LEVEL_] += $dlevel;
            }

            # Copy opening ci level to help break at = for -lp mode (case b1124)
            $rLL->[$Kinner_opening]->[_CI_LEVEL_] =
              $rLL->[$Kouter_opening]->[_CI_LEVEL_];

            # But only copy the closing ci level if the outer container is
            # in a block; otherwise poor results can be produced.
            if ($weld_starts_in_block) {
                $rLL->[$Kinner_closing]->[_CI_LEVEL_] =
                  $rLL->[$Kouter_closing]->[_CI_LEVEL_];
            }
        }
    } ## end while ( @{$rnested_pairs})

    return;
} ## end sub weld_nested_containers

sub weld_nested_quotes {

    my $self = shift;

    # Called once per file for option '--weld-nested-containers'. This
    # does welding on qw quotes.

    # See if quotes are excluded from welding
    my $rflags = $weld_nested_exclusion_rules{'q'};
    return if ( defined($rflags) && defined( $rflags->[1] ) );

    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );
    my $Num = @{$rLL};

    my $rK_weld_left        = $self->[_rK_weld_left_];
    my $rK_weld_right       = $self->[_rK_weld_right_];
    my $K_opening_container = $self->[_K_opening_container_];
    my $K_closing_container = $self->[_K_closing_container_];
    my $rlines              = $self->[_rlines_];

    my $starting_lentot;
    my $maximum_text_length;

    my $is_single_quote = sub {
        my ( $Kbeg, $Kend, $quote_type ) = @_;
        foreach my $K ( $Kbeg .. $Kend ) {
            my $test_type = $rLL->[$K]->[_TYPE_];
            next   if ( $test_type eq 'b' );
            return if ( $test_type ne $quote_type );
        }
        return 1;
    }; ## end $is_single_quote = sub

    # Length tolerance - same as previously used for sub weld_nested
    my $multiline_tol =
      1 + max( $rOpts_indent_columns, $rOpts_continuation_indentation );

    # look for single qw quotes nested in containers
    foreach my $outer_seqno ( keys %{$K_opening_container} ) {
        my $Kouter_opening = $K_opening_container->{$outer_seqno};

        # see if the next token is a quote of some type
        my $Kn = $Kouter_opening + 1;
        next if ( $Kn >= $Num - 1 );
        my $next_type = $rLL->[$Kn]->[_TYPE_];
        if ( $next_type eq 'b' ) {
            $next_type = $rLL->[ ++$Kn ]->[_TYPE_];
        }

        next if ( $next_type ne 'q' && $next_type ne 'Q' );
        my $next_token = $rLL->[$Kn]->[_TOKEN_];
        next if ( substr( $next_token, 0, 1 ) ne 'q' );

        # The token before the closing container must also be a quote
        my $Kouter_closing = $K_closing_container->{$outer_seqno};
        my $Kinner_closing = $self->K_previous_nonblank($Kouter_closing);
        next unless ( $rLL->[$Kinner_closing]->[_TYPE_] eq $next_type );

        # This is an inner opening container
        my $Kinner_opening = $Kn;

        # Do not weld to single-line quotes. Nothing is gained, and it may
        # look bad.
        next if ( $Kinner_closing == $Kinner_opening );

        # RULE: Avoid welding under stress. This is an alternate b1502 fix.
        my $inner_level = $rLL->[$Kinner_opening]->[_LEVEL_];
        if ( $inner_level >= $high_stress_level ) { next }

        # Only weld to quotes delimited with container tokens. This is
        # because welding to arbitrary quote delimiters can produce code
        # which is less readable than without welding.
        my $closing_delimiter =
          substr( $rLL->[$Kinner_closing]->[_TOKEN_], -1, 1 );
        next
          unless ( $is_closing_token{$closing_delimiter}
            || $closing_delimiter eq '>' );

        # Now make sure that there is just a single quote in the container
        next
          unless (
            $is_single_quote->(
                $Kinner_opening + 1,
                $Kinner_closing - 1,
                $next_type
            )
          );

        # OK: This is a candidate for welding
        my $Msg = EMPTY_STRING;
        my $do_not_weld;

        my $iline_oo    = $rLL->[$Kouter_opening]->[_LINE_INDEX_];
        my $iline_io    = $rLL->[$Kinner_opening]->[_LINE_INDEX_];
        my $iline_oc    = $rLL->[$Kouter_closing]->[_LINE_INDEX_];
        my $iline_ic    = $rLL->[$Kinner_closing]->[_LINE_INDEX_];
        my $is_old_weld = ( $iline_oo == $iline_io && $iline_ic == $iline_oc );

        # Fix for case b1189. If quote is marked as type 'Q' then only weld
        # if the two closing tokens are on the same input line.  Otherwise,
        # the closing line will be output earlier in the pipeline than
        # other CODE lines and welding will not actually occur. This will
        # leave a half-welded structure with potential formatting
        # instability.  This might be fixed by adding a check for a weld on
        # a closing Q token and sending it down the normal channel, but it
        # would complicate the code and is potentially risky.
        next
          if (!$is_old_weld
            && $next_type eq 'Q'
            && $iline_ic != $iline_oc );

        # If welded, the line must not exceed allowed line length
        ( my $ok_to_weld, $maximum_text_length, $starting_lentot, my $msg ) =
          $self->setup_new_weld_measurements( $Kouter_opening,
            $Kinner_opening );
        if ( !$ok_to_weld ) {
            if (DEBUG_WELD) { print {*STDOUT} $msg }
            next;
        }

        my $length =
          $rLL->[$Kinner_opening]->[_CUMULATIVE_LENGTH_] - $starting_lentot;
        my $excess = $length + $multiline_tol - $maximum_text_length;

        my $excess_max = ( $is_old_weld ? $multiline_tol : 0 );
        if ( $excess >= $excess_max ) {
            $do_not_weld = 1;
        }

        if (DEBUG_WELD) {
            if ( !$is_old_weld ) { $is_old_weld = EMPTY_STRING }
            $Msg .=
"excess=$excess>=$excess_max, multiline_tol=$multiline_tol, is_old_weld='$is_old_weld'\n";
        }

        # Check weld exclusion rules for outer container
        if ( !$do_not_weld ) {
            my $is_leading = !defined( $rK_weld_left->{$Kouter_opening} );
            if ( $self->is_excluded_weld( $Kouter_opening, $is_leading ) ) {
                if (DEBUG_WELD) {
                    $Msg .=
"No qw weld due to weld exclusion rules for outer container\n";
                }
                $do_not_weld = 1;
            }
        }

        # Check the length of the last line (fixes case b1039)
        if ( !$do_not_weld ) {
            my $rK_range_ic = $rlines->[$iline_ic]->{_rK_range};
            my ( $Kfirst_ic, $Klast_ic_uu ) = @{$rK_range_ic};
            my $excess_ic =
              $self->excess_line_length_for_Krange( $Kfirst_ic,
                $Kouter_closing );

            # Allow extra space for additional welded closing container(s)
            # and a space and comma or semicolon.
            # NOTE: weld len has not been computed yet. Use 2 spaces
            # for now, correct for a single weld. This estimate could
            # be made more accurate if necessary.
            my $weld_len = defined( $rK_weld_right->{$Kouter_closing} ) ? 2 : 0;
            if ( $excess_ic + $weld_len + 2 > 0 ) {
                if (DEBUG_WELD) {
                    $Msg .=
"No qw weld due to excess ending line length=$excess_ic + $weld_len + 2 > 0\n";
                }
                $do_not_weld = 1;
            }
        }

        if ($do_not_weld) {
            if (DEBUG_WELD) {
                $Msg .= "Not Welding QW\n";
                print {*STDOUT} $Msg;
            }
            next;
        }

        # OK to weld
        if (DEBUG_WELD) {
            $Msg .= "Welding QW\n";
            print {*STDOUT} $Msg;
        }

        $rK_weld_right->{$Kouter_opening} = $Kinner_opening;
        $rK_weld_left->{$Kinner_opening}  = $Kouter_opening;

        $rK_weld_right->{$Kinner_closing} = $Kouter_closing;
        $rK_weld_left->{$Kouter_closing}  = $Kinner_closing;

        # Undo one indentation level if an extra level was added to this
        # multiline quote
        my $qw_seqno =
          $self->[_rstarting_multiline_qw_seqno_by_K_]->{$Kinner_opening};
        if (   $qw_seqno
            && $self->[_rmultiline_qw_has_extra_level_]->{$qw_seqno} )
        {
            foreach my $K ( $Kinner_opening + 1 .. $Kinner_closing - 1 ) {
                $rLL->[$K]->[_LEVEL_] -= 1;
            }
            $rLL->[$Kinner_opening]->[_CI_LEVEL_] = 0;
            $rLL->[$Kinner_closing]->[_CI_LEVEL_] = 0;
        }

        # undo CI for other welded quotes
        else {

            foreach my $K ( $Kinner_opening .. $Kinner_closing ) {
                $rLL->[$K]->[_CI_LEVEL_] = 0;
            }
        }

        # Change the level of a closing qw token to be that of the outer
        # containing token. This will allow -lp indentation to function
        # correctly in the vertical aligner.
        # Patch to fix c002: but not if it contains text
        if ( length( $rLL->[$Kinner_closing]->[_TOKEN_] ) == 1 ) {
            $rLL->[$Kinner_closing]->[_LEVEL_] =
              $rLL->[$Kouter_closing]->[_LEVEL_];
        }
    }
    return;
} ## end sub weld_nested_quotes

sub is_welded_at_seqno {

    my ( $self, $seqno ) = @_;

    # Given:
    #   $seqno = a sequence number:
    # Return:
    #   true if it is welded either left or right
    #   false otherwise
    return unless ( $total_weld_count && defined($seqno) );
    my $KK_o = $self->[_K_opening_container_]->{$seqno};
    return unless defined($KK_o);
    return defined( $self->[_rK_weld_left_]->{$KK_o} )
      || defined( $self->[_rK_weld_right_]->{$KK_o} );
} ## end sub is_welded_at_seqno

sub mark_short_nested_blocks {

    my $self = shift;

    # This routine looks at the entire file and marks any short nested blocks
    # which should not be broken.  The results are stored in the hash
    #     $rshort_nested->{$type_sequence}
    # which will be true if the container should remain intact.
    #
    # For example, consider the following line:

    #   sub cxt_two { sort { $a <=> $b } test_if_list() }

    # The 'sort' block is short and nested within an outer sub block.
    # Normally, the existence of the 'sort' block will force the sub block to
    # break open, but this is not always desirable. Here we will set a flag for
    # the sort block to prevent this.  To give the user control, we will
    # follow the input file formatting.  If either of the blocks is broken in
    # the input file then we will allow it to remain broken. Otherwise we will
    # set a flag to keep it together in later formatting steps.

    # The flag which is set here will be checked in two places:
    # 'sub process_line_of_CODE' and 'sub starting_one_line_block'

    return if $rOpts->{'indent-only'};

    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );

    return unless ( $rOpts->{'one-line-block-nesting'} );

    my $K_opening_container     = $self->[_K_opening_container_];
    my $K_closing_container     = $self->[_K_closing_container_];
    my $rbreak_container        = $self->[_rbreak_container_];
    my $ris_broken_container    = $self->[_ris_broken_container_];
    my $rshort_nested           = $self->[_rshort_nested_];
    my $rblock_type_of_seqno    = $self->[_rblock_type_of_seqno_];
    my $rK_sequenced_token_list = $self->[_rK_sequenced_token_list_];

    # Variables needed for estimating line lengths
    my $maximum_text_length;
    my $starting_lentot;
    my $length_tol = 1;

    my $excess_length_to_K = sub {
        my ($K) = @_;

        # Estimate the length from the line start to a given token
        my $length = $self->cumulative_length_before_K($K) - $starting_lentot;
        my $excess_length = $length + $length_tol - $maximum_text_length;
        return ($excess_length);
    }; ## end $excess_length_to_K = sub

    # loop over all containers
    my @open_block_stack;
    my $iline = -1;
    foreach my $KK ( @{$rK_sequenced_token_list} ) {
        my $rtoken_vars   = $rLL->[$KK];
        my $type_sequence = $rtoken_vars->[_TYPE_SEQUENCE_];
        if ( !$type_sequence ) {
            next if ( $KK == 0 );    # first token in file may not be container

            # A fault here implies that an error was made in the little loop at
            # the bottom of sub 'respace_tokens' which set the values of
            # $rK_sequenced_token_list.  Or an error has been introduced in the
            # loop control lines above.
            Fault("sequence = $type_sequence not defined at K=$KK")
              if (DEVEL_MODE);
            next;
        }

        # Patch: do not mark short blocks with welds.
        # In some cases blinkers can form (case b690).
        if ( $total_weld_count && $self->is_welded_at_seqno($type_sequence) ) {
            next;
        }

        # We are just looking at code blocks
        my $token = $rtoken_vars->[_TOKEN_];
        my $type  = $rtoken_vars->[_TYPE_];
        next unless ( $type eq $token );
        next unless ( $rblock_type_of_seqno->{$type_sequence} );

        # Keep a stack of all acceptable block braces seen.
        # Only consider blocks entirely on one line so dump the stack when line
        # changes.
        my $iline_last = $iline;
        $iline = $rLL->[$KK]->[_LINE_INDEX_];
        if ( $iline != $iline_last ) { @open_block_stack = () }

        if ( $token eq '}' ) {
            if (@open_block_stack) { pop @open_block_stack }
        }
        next unless ( $token eq '{' );

        # block must be balanced (bad scripts may be unbalanced)
        my $K_opening = $K_opening_container->{$type_sequence};
        my $K_closing = $K_closing_container->{$type_sequence};
        next unless ( defined($K_opening) && defined($K_closing) );

        # require that this block be entirely on one line
        next
          if ( $ris_broken_container->{$type_sequence}
            || $rbreak_container->{$type_sequence} );

        # See if this block fits on one line of allowed length (which may
        # be different from the input script)
        $starting_lentot =
          $KK <= 0 ? 0 : $rLL->[ $KK - 1 ]->[_CUMULATIVE_LENGTH_];
        my $level    = $rLL->[$KK]->[_LEVEL_];
        my $ci_level = $rLL->[$KK]->[_CI_LEVEL_];
        $maximum_text_length =
          $maximum_text_length_at_level[$level] -
          $ci_level * $rOpts_continuation_indentation;

        # Dump the stack if block is too long and skip this block
        if ( $excess_length_to_K->($K_closing) > 0 ) {
            @open_block_stack = ();
            next;
        }

        # OK, Block passes tests, remember it
        push @open_block_stack, $type_sequence;

        # We are only marking nested code blocks,
        # so check for a previous block on the stack
        next if ( @open_block_stack <= 1 );

        # Looks OK, mark this as a short nested block
        $rshort_nested->{$type_sequence} = 1;

    }
    return;
} ## end sub mark_short_nested_blocks

sub special_indentation_adjustments {

    my ($self) = @_;

    # Called once per file to define the levels to be used for computing
    # actual indentation. These levels are initialized to be the structural
    # levels and then are adjusted if necessary for special purposes.
    # The adjustments are made either by changing _CI_LEVEL_ directly or
    # by setting modified levels in the array $self->[_radjusted_levels_].

    # NOTE: This routine is called after the weld routines, which may have
    # already adjusted the initial values of _LEVEL_, so we are making
    # adjustments on top of those levels.  It would be nicer to have the
    # weld routines also use this adjustment, but that gets complicated
    # when we combine -gnu -wn and also have some welded quotes.
    my $rLL = $self->[_rLL_];
    return unless ( @{$rLL} );

    # Initialize the adjusted levels to be the structural levels
    my @adjusted_levels = map { $_->[_LEVEL_] } @{$rLL};
    $self->[_radjusted_levels_] = \@adjusted_levels;

    my $min_starting_level = min(@adjusted_levels);

    # First set adjusted levels for any non-indenting braces.
    $self->do_non_indenting_braces();

    # Adjust breaks and indentation list containers
    $self->break_before_list_opening_containers();

    # Set adjusted levels for the whitespace cycle option.
    $self->whitespace_cycle_adjustment();

    $self->braces_left_setup();

    # Adjust continuation indentation if -bli is set
    $self->bli_adjustment();

    $self->extended_ci()
      if ($rOpts_extended_continuation_indentation);

    # Now clip any starting or adjusted levels to be non-negative
    $self->clip_adjusted_levels($min_starting_level);

    return;
} ## end sub special_indentation_adjustments

sub clip_adjusted_levels {

    my ( $self, $min_starting_level ) = @_;

    # Replace any negative adjusted levels with zero.
    # Negative levels can only occur in files with brace errors.
    # Given:
    #   $min_starting_level = minimum (adjusted) level of the input stream

    # Clip the original _LEVEL_ values to zero if necessary
    my $rLL = $self->[_rLL_];
    if ( $min_starting_level < 0 ) {
        foreach my $item ( @{$rLL} ) {
            if ( $item->[_LEVEL_] < 0 ) { $item->[_LEVEL_] = 0 }
        }
    }

    # Clip the adjusted levels to zero if necessary
    my $radjusted_levels = $self->[_radjusted_levels_];
    return unless ( defined($radjusted_levels) && @{$radjusted_levels} );
    my $min = min( @{$radjusted_levels} );    # fast check for min
    if ( $min < 0 ) {

        # slow loop, but rarely needed
        foreach ( @{$radjusted_levels} ) { $_ = 0 if ( $_ < 0 ) }
    }

    return;
} ## end sub clip_adjusted_levels

sub do_non_indenting_braces {

    my ($self) = @_;

    # Called once per file to handle the --non-indenting-braces parameter.
    # Remove indentation within marked braces if requested

    # Any non-indenting braces have been found by sub find_non_indenting_braces
    # and are defined by the following hash:
    my $rseqno_non_indenting_brace_by_ix =
      $self->[_rseqno_non_indenting_brace_by_ix_];
    return unless ( %{$rseqno_non_indenting_brace_by_ix} );

    my $rlines                     = $self->[_rlines_];
    my $K_opening_container        = $self->[_K_opening_container_];
    my $K_closing_container        = $self->[_K_closing_container_];
    my $rspecial_side_comment_type = $self->[_rspecial_side_comment_type_];
    my $radjusted_levels           = $self->[_radjusted_levels_];

    # First locate all of the marked blocks
    my @K_stack;
    foreach my $ix ( keys %{$rseqno_non_indenting_brace_by_ix} ) {
        my $seqno          = $rseqno_non_indenting_brace_by_ix->{$ix};
        my $KK             = $K_opening_container->{$seqno};
        my $line_of_tokens = $rlines->[$ix];
        my $rK_range       = $line_of_tokens->{_rK_range};
        my ( $Kfirst_uu, $Klast ) = @{$rK_range};
        $rspecial_side_comment_type->{$Klast} = 'NIB';
        push @K_stack, [ $KK, 1 ];
        my $Kc = $K_closing_container->{$seqno};
        push @K_stack, [ $Kc, -1 ] if ( defined($Kc) );
    }
    return unless (@K_stack);
    @K_stack = sort { $a->[0] <=> $b->[0] } @K_stack;

    # Then loop to remove indentation within marked blocks
    my $KK_last = 0;
    my $ndeep   = 0;
    foreach my $item (@K_stack) {
        my ( $KK, $inc ) = @{$item};
        if ( $ndeep > 0 ) {

            foreach ( $KK_last + 1 .. $KK ) {
                $radjusted_levels->[$_] -= $ndeep;
            }

            # We just subtracted the old $ndeep value, which only applies to a
            # '{'.  The new $ndeep applies to a '}', so we undo the error.
            if ( $inc < 0 ) { $radjusted_levels->[$KK] += 1 }
        }

        $ndeep += $inc;
        $KK_last = $KK;
    }
    return;
} ## end sub do_non_indenting_braces

sub whitespace_cycle_adjustment {

    my $self = shift;

    # Called once per file to implement the --whitespace-cycle option
    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );
    my $radjusted_levels = $self->[_radjusted_levels_];
    my $maximum_level    = $self->[_maximum_level_];

    if (   $rOpts_whitespace_cycle
        && $rOpts_whitespace_cycle > 0
        && $rOpts_whitespace_cycle < $maximum_level )
    {

        my $Kmax = @{$rLL} - 1;

        my $whitespace_last_level  = -1;
        my @whitespace_level_stack = ();
        my $last_nonblank_type     = 'b';
        my $last_nonblank_token    = EMPTY_STRING;
        foreach my $KK ( 0 .. $Kmax ) {
            my $level_abs = $radjusted_levels->[$KK];
            my $level     = $level_abs;
            if ( $level_abs < $whitespace_last_level ) {
                pop(@whitespace_level_stack);
            }
            if ( !@whitespace_level_stack ) {
                push @whitespace_level_stack, $level_abs;
            }
            else {
                if ( $level_abs > $whitespace_last_level ) {
                    $level = $whitespace_level_stack[-1] +
                      ( $level_abs - $whitespace_last_level );

                    if (
                        # 1 Try to break at a block brace
                        (
                               $level > $rOpts_whitespace_cycle
                            && $last_nonblank_type eq '{'
                            && $last_nonblank_token eq '{'
                        )

                        # 2 Then either a brace or bracket
                        || (   $level > $rOpts_whitespace_cycle + 1
                            && $last_nonblank_token =~ /^[\{\[]$/ )

                        # 3 Then a paren too
                        || $level > $rOpts_whitespace_cycle + 2
                      )
                    {
                        $level = 1;
                    }
                    push @whitespace_level_stack, $level;
                }
            }
            $level = $whitespace_level_stack[-1];
            $radjusted_levels->[$KK] = $level;

            $whitespace_last_level = $level_abs;
            my $type  = $rLL->[$KK]->[_TYPE_];
            my $token = $rLL->[$KK]->[_TOKEN_];
            if ( $type ne 'b' ) {
                $last_nonblank_type  = $type;
                $last_nonblank_token = $token;
            }
        }
    }
    return;
} ## end sub whitespace_cycle_adjustment

use constant DEBUG_BBX => 0;

sub break_before_list_opening_containers {

    my ($self) = @_;

    # This routine is called once per batch to implement parameters:
    # --break-before-hash-brace=n and similar -bbx=n flags
    #    and their associated indentation flags:
    # --break-before-hash-brace-and-indent and similar -bbxi=n

    # Nothing to do if none of the -bbx=n parameters has been set
    return unless %break_before_container_types;

    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );

    # Loop over all opening container tokens
    my $K_opening_container       = $self->[_K_opening_container_];
    my $K_closing_container       = $self->[_K_closing_container_];
    my $ris_broken_container      = $self->[_ris_broken_container_];
    my $ris_permanently_broken    = $self->[_ris_permanently_broken_];
    my $rhas_list                 = $self->[_rhas_list_];
    my $rhas_broken_list_with_lec = $self->[_rhas_broken_list_with_lec_];
    my $radjusted_levels          = $self->[_radjusted_levels_];
    my $rparent_of_seqno          = $self->[_rparent_of_seqno_];
    my $rlines                    = $self->[_rlines_];
    my $rtype_count_by_seqno      = $self->[_rtype_count_by_seqno_];
    my $rlec_count_by_seqno       = $self->[_rlec_count_by_seqno_];
    my $rno_xci_by_seqno          = $self->[_rno_xci_by_seqno_];
    my $rK_weld_right             = $self->[_rK_weld_right_];
    my $rblock_type_of_seqno      = $self->[_rblock_type_of_seqno_];

    my $length_tol =
      max( 1, $rOpts_continuation_indentation, $rOpts_indent_columns );
    if ($rOpts_ignore_old_breakpoints) {

        # Patch suggested by b1231; the old tol was excessive.
        ## $length_tol += $rOpts_maximum_line_length;
        $length_tol *= 2;
    }

    #-------------------------------------------------------
    # These arrays are used to mark the affected containers:
    #-------------------------------------------------------
    my $rbreak_before_container_by_seqno = {};
    my $rwant_reduced_ci                 = {};

    #------------------------------
    # Main loop over all containers
    #------------------------------
    foreach my $seqno ( keys %{$K_opening_container} ) {

        #----------------------------------------------------------------
        # Part 1: Examine any -bbx=n flags
        #----------------------------------------------------------------

        next if ( $rblock_type_of_seqno->{$seqno} );
        my $KK = $K_opening_container->{$seqno};

        # This must be a list or contain a list.
        # Note1: switched from 'has_broken_list' to 'has_list' to fix b1024.
        # Note2: 'has_list' holds the depth to the sub-list.  We will require
        #  a depth of just 1
        my $is_list  = $self->is_list_by_seqno($seqno);
        my $has_list = $rhas_list->{$seqno};

        # Fix for b1173: if welded opening container, use flag of innermost
        # seqno.  Otherwise, the restriction $has_list==1 prevents triple and
        # higher welds from following the -BBX parameters.
        if ($total_weld_count) {
            my $KK_test = $rK_weld_right->{$KK};
            if ( defined($KK_test) ) {
                my $seqno_inner = $rLL->[$KK_test]->[_TYPE_SEQUENCE_];
                $is_list ||= $self->is_list_by_seqno($seqno_inner);
                $has_list = $rhas_list->{$seqno_inner};
            }
        }

        next unless ( $is_list || $has_list && $has_list == 1 );

        my $has_list_with_lec = $rhas_broken_list_with_lec->{$seqno};

        # Only for types of container tokens with a non-default break option
        my $token        = $rLL->[$KK]->[_TOKEN_];
        my $break_option = $break_before_container_types{$token};
        next unless ($break_option);

        # Do not use -bbx under stress for stability ... fixes b1300
        # TODO: review this; do we also need to look at stress_level_lalpha?
        my $level = $rLL->[$KK]->[_LEVEL_];
        if ( $level >= $stress_level_beta ) {
            DEBUG_BBX
              && print
"BBX: Switching off at $seqno: level=$level exceeds beta stress level=$stress_level_beta\n";
            next;
        }

        # Require previous nonblank to be '=' or '=>'
        my $Kprev = $KK - 1;
        next if ( $Kprev < 0 );
        my $prev_type = $rLL->[$Kprev]->[_TYPE_];
        if ( $prev_type eq 'b' ) {
            $Kprev--;
            next if ( $Kprev < 0 );
            $prev_type = $rLL->[$Kprev]->[_TYPE_];
        }
        next unless ( $is_equal_or_fat_comma{$prev_type} );

        my $ci = $rLL->[$KK]->[_CI_LEVEL_];

        #--------------------------------------------
        # New coding for option 2 (break if complex).
        #--------------------------------------------
        # This new coding uses clues which are invariant under formatting to
        # decide if a list is complex.  For now it is only applied when -lp
        # and -vmll are used, but eventually it may become the standard method.
        # Fixes b1274, b1275, and others, including b1099.
        # Update: case b1469 also had this type of problem; it had the
        # combination ci>i and used -xci. This is just a band-aid; eventually
        # it might be best if all cases use this logic, but that would change
        # existing formatting.
        if ( $break_option == 2 ) {

            my $b1469 = $rOpts_continuation_indentation > $rOpts_indent_columns
              && $rOpts_extended_continuation_indentation;

            if (   $rOpts_line_up_parentheses
                || $rOpts_variable_maximum_line_length
                || $b1469 )
            {

                # Start with the basic definition of a complex list...
                my $is_complex = $is_list && $has_list;

                # and it is also complex if the parent is a list
                if ( !$is_complex ) {
                    my $parent = $rparent_of_seqno->{$seqno};
                    if ( $self->is_list_by_seqno($parent) ) {
                        $is_complex = 1;
                    }
                }

                # finally, we will call it complex if there are inner opening
                # and closing container tokens, not parens, within the outer
                # container tokens.
                if ( !$is_complex ) {
                    my $Kp      = $self->K_next_nonblank($KK);
                    my $token_p = defined($Kp) ? $rLL->[$Kp]->[_TOKEN_] : 'b';
                    if ( $is_opening_token{$token_p} && $token_p ne '(' ) {

                        my $Kc      = $K_closing_container->{$seqno};
                        my $Km      = $self->K_previous_nonblank($Kc);
                        my $token_m = 'b';
                        my $type_m  = SPACE;
                        if ( defined($Km) ) {
                            $token_m = $rLL->[$Km]->[_TOKEN_];
                            $type_m  = $rLL->[$Km]->[_TYPE_];
                        }

                        # ignore any optional ending comma
                        if ( $type_m eq ',' ) {
                            $Km = $self->K_previous_nonblank($Km);
                            $token_m =
                              defined($Km) ? $rLL->[$Km]->[_TOKEN_] : 'b';
                        }

                        $is_complex ||=
                          $is_closing_token{$token_m} && $token_m ne ')';
                    }
                }

                # Convert to option 3 (always break) if complex
                next unless ($is_complex);
                $break_option = 3;
            }
        }

        # Fix for b1231: the has_list_with_lec does not cover all cases.
        # A broken container containing a list and with line-ending commas
        # will stay broken, so can be treated as if it had a list with lec.
        $has_list_with_lec ||=
             $has_list
          && $ris_broken_container->{$seqno}
          && $rlec_count_by_seqno->{$seqno};

        DEBUG_BBX
          && print {*STDOUT}
"BBX: Looking at seqno=$seqno, token = $token with option=$break_option\n";

        # -bbx=1 = stable, try to follow input
        if ( $break_option == 1 ) {

            my $iline    = $rLL->[$KK]->[_LINE_INDEX_];
            my $rK_range = $rlines->[$iline]->{_rK_range};
            my ( $Kfirst, $Klast_uu ) = @{$rK_range};
            next unless ( $KK == $Kfirst );
        }

        # -bbx=2 => apply this style only for a 'complex' list
        elsif ( $break_option == 2 ) {

            #  break if this list contains a broken list with line-ending comma
            my $ok_to_break;
            my $Msg = EMPTY_STRING;
            if ($has_list_with_lec) {
                $ok_to_break = 1;
                DEBUG_BBX && do { $Msg = "has list with lec;" };
            }

            if ( !$ok_to_break ) {

                # Turn off -xci if -bbx=2 and this container has a sublist but
                # not a broken sublist. This avoids creating blinkers.  The
                # problem is that -xci can cause one-line lists to break open,
                # and thereby creating formatting instability.
                # This fixes cases b1033 b1036 b1037 b1038 b1042 b1043 b1044
                # b1045 b1046 b1047 b1051 b1052 b1061.
                if ($has_list) { $rno_xci_by_seqno->{$seqno} = 1 }

                my $parent = $rparent_of_seqno->{$seqno};
                if ( $self->is_list_by_seqno($parent) ) {
                    DEBUG_BBX && do { $Msg = "parent is list" };
                    $ok_to_break = 1;
                }
            }

            if ( !$ok_to_break ) {
                DEBUG_BBX
                  && print {*STDOUT} "Not breaking at seqno=$seqno: $Msg\n";
                next;
            }

            DEBUG_BBX
              && print {*STDOUT} "OK to break at seqno=$seqno: $Msg\n";

            # Patch: turn off -xci if -bbx=2 and -lp
            # This fixes cases b1090 b1095 b1101 b1116 b1118 b1121 b1122
            $rno_xci_by_seqno->{$seqno} = 1 if ($rOpts_line_up_parentheses);
        }

        # -bbx=3 = always break
        elsif ( $break_option == 3 ) {

            # ok to break
        }

        # Bad flag, this shouldn't happen because of the integer range checks.
        # Continue using behavior same as option 3 if not in DEVEL_MODE
        else {
            DEVEL_MODE && Fault(<<EOM);
Bad -bbx break option=$break_option for '$token': fix integer range checks.
EOM
        }

        # Set a flag for actual implementation later in
        # sub insert_breaks_before_list_opening_containers
        $rbreak_before_container_by_seqno->{$seqno} = 1;
        DEBUG_BBX
          && print {*STDOUT} "BBX: ok to break at seqno=$seqno\n";

        # -bbxi=0: Nothing more to do if the ci value remains unchanged
        my $ci_flag = $container_indentation_options{$token};
        next unless ($ci_flag);

        # -bbxi=1: This option removes ci and is handled in
        # later sub get_final_indentation
        if ( $ci_flag == 1 ) {
            $rwant_reduced_ci->{$seqno} = 1;
            next;
        }

        # -bbxi=2: This option changes the level ...
        # This option can conflict with -xci in some cases.  We can turn off
        # -xci for this container to avoid blinking.  For now, only do this if
        # -vmll is set.  ( fixes b1335, b1336 )
        if ($rOpts_variable_maximum_line_length) {
            $rno_xci_by_seqno->{$seqno} = 1;
        }

        #----------------------------------------------------------------
        # Part 2: Perform tests before committing to changing ci and level
        #----------------------------------------------------------------

        # Before changing the ci level of the opening container, we need
        # to be sure that the container will be broken in the later stages of
        # formatting.  We have to do this because we are working early in the
        # formatting pipeline.  A problem can occur if we change the ci or
        # level of the opening token but do not actually break the container
        # open as expected.  In most cases it wouldn't make any difference if
        # we changed ci or not, but there are some edge cases where this
        # can cause blinking states, so we need to try to only change ci if
        # the container will really be broken.

        # Only consider containers already broken
        next if ( !$ris_broken_container->{$seqno} );

        # Patch to fix issue b1305: the combination of -naws and ci>i appears
        # to cause an instability.  It should almost never occur in practice.
        next
          if (!$rOpts_add_whitespace
            && $rOpts_continuation_indentation > $rOpts_indent_columns );

        # Always ok to change ci for permanently broken containers
        if ( $ris_permanently_broken->{$seqno} ) { }

        # Always OK if this list contains a broken sub-container with
        # a non-terminal line-ending comma
        elsif ($has_list_with_lec) { }

        # Otherwise, we are considering a single container...
        else {

            # A single container must have at least 1 line-ending comma:
            next unless ( $rlec_count_by_seqno->{$seqno} );

            my $OK;

            # Since it has a line-ending comma, it will stay broken if the
            # -boc flag is set
            if ($rOpts_break_at_old_comma_breakpoints) { $OK = 1 }

            # OK if the container contains multiple fat commas
            # Better: multiple lines with fat commas
            if ( !$OK && !$rOpts_ignore_old_breakpoints ) {
                my $rtype_count = $rtype_count_by_seqno->{$seqno};
                next unless ($rtype_count);
                my $fat_comma_count = $rtype_count->{'=>'};
                DEBUG_BBX
                  && print {*STDOUT} "BBX: fat comma count=$fat_comma_count\n";
                if ( $fat_comma_count && $fat_comma_count >= 2 ) { $OK = 1 }
            }

            # The last check we can make is to see if this container could
            # fit on a single line.  Use the least possible indentation
            # estimate, ci=0, so we are not subtracting $ci *
            # $rOpts_continuation_indentation from tabulated
            # $maximum_text_length  value.
            if ( !$OK ) {
                my $maximum_text_length = $maximum_text_length_at_level[$level];
                my $K_closing           = $K_closing_container->{$seqno};
                my $length = $self->cumulative_length_before_K($K_closing) -
                  $self->cumulative_length_before_K($KK);
                my $excess_length = $length - $maximum_text_length;
                DEBUG_BBX
                  && print {*STDOUT}
"BBX: excess=$excess_length: maximum_text_length=$maximum_text_length, length=$length, ci=$ci\n";

                # OK if the net container definitely breaks on length
                if ( $excess_length > $length_tol ) {
                    $OK = 1;
                    DEBUG_BBX
                      && print {*STDOUT} "BBX: excess_length=$excess_length\n";
                }

                # Otherwise skip it
                else { next }
            }
        }

        #------------------------------------------------------------
        # Part 3: Looks OK: apply -bbx=n and any related -bbxi=n flag
        #------------------------------------------------------------

        DEBUG_BBX && print {*STDOUT} "BBX: OK to break\n";

        # -bbhbi=n
        # -bbsbi=n
        # -bbpi=n

        # where:

        # n=0  default indentation (usually one ci)
        # n=1  outdent one ci
        # n=2  indent one level (minus one ci)

        # NOTE: We are adjusting indentation of the opening container. The
        # closing container will normally follow the indentation of the opening
        # container automatically, so this is not currently done.
        next unless ($ci);

        # option 1: outdent
        if ( $ci_flag == 1 ) {
            $ci -= 1;
        }

        # option 2: indent one level
        elsif ( $ci_flag == 2 ) {
            $ci -= 1;
            $radjusted_levels->[$KK] += 1;
        }

        # unknown option
        else {
            # Shouldn't happen - leave ci unchanged
            DEVEL_MODE && Fault(<<EOM);
unexpected ci flag '$ci_flag' for -bbpi -bbsbi -bbhbi: expecting one of 0 1 2
EOM
        }

        $rLL->[$KK]->[_CI_LEVEL_] = $ci if ( $ci >= 0 );
    }

    #------------------
    # Store the results
    #------------------
    $self->[_rbreak_before_container_by_seqno_] =
      $rbreak_before_container_by_seqno;
    $self->[_rwant_reduced_ci_] = $rwant_reduced_ci;

    return;
} ## end sub break_before_list_opening_containers

use constant DEBUG_XCI => 0;

sub extended_ci {

    my ($self) = @_;

    # This routine implements the -xci (--extended-continuation-indentation)
    # flag.  We add CI to interior tokens of a container which itself has CI but
    # only if a token does not already have CI.

    # To do this, we will locate opening tokens which themselves have
    # continuation indentation (CI).  We track them with their sequence
    # numbers.  These sequence numbers are called 'controlling sequence
    # numbers'.  They apply continuation indentation to the tokens that they
    # contain.  These inner tokens remember their controlling sequence numbers.
    # Later, when these inner tokens are output, they have to see if the output
    # lines with their controlling tokens were output with CI or not.  If not,
    # then they must remove their CI too.

    # The controlling CI concept works hierarchically.  But CI itself is not
    # hierarchical; it is either on or off. There are some rare instances where
    # it would be best to have hierarchical CI too, but not enough to be worth
    # the programming effort.

    # The operations to remove unwanted CI are done in sub 'undo_ci'.

    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );

    my $ris_list_by_seqno        = $self->[_ris_list_by_seqno_];
    my $ris_seqno_controlling_ci = $self->[_ris_seqno_controlling_ci_];
    my $rseqno_controlling_my_ci = $self->[_rseqno_controlling_my_ci_];
    my $rno_xci_by_seqno         = $self->[_rno_xci_by_seqno_];
    my $ris_bli_container        = $self->[_ris_bli_container_];
    my $rblock_type_of_seqno     = $self->[_rblock_type_of_seqno_];

    my %available_space;

    # Loop over all opening container tokens
    my $K_opening_container     = $self->[_K_opening_container_];
    my $K_closing_container     = $self->[_K_closing_container_];
    my $rK_sequenced_token_list = $self->[_rK_sequenced_token_list_];
    my @seqno_stack;
    my $seqno_top;
    my $K_last;

    # The following variable can be used to allow a little extra space to
    # avoid blinkers.  A value $len_tol = 20 fixed the following
    # fixes cases: b1025 b1026 b1027 b1028 b1029 b1030 but NOT b1031.
    # It turned out that the real problem was mis-parsing a list brace as
    # a code block in a 'use' statement when the line length was extremely
    # small.  A value of 0 works now, but a slightly larger value can
    # be used to minimize the chance of a blinker.
    my $len_tol = 0;

    foreach my $KK ( @{$rK_sequenced_token_list} ) {

        # Fix all tokens up to the next sequence item if we are changing CI
        if ($seqno_top) {

            my $is_list = $ris_list_by_seqno->{$seqno_top};
            my $space   = $available_space{$seqno_top};
            my $count   = 0;
            foreach my $Kt ( $K_last + 1 .. $KK - 1 ) {

                next if ( $rLL->[$Kt]->[_CI_LEVEL_] );

                # But do not include tokens which might exceed the line length
                # and are not in a list.
                # ... This fixes case b1031
                if (   $is_list
                    || $rLL->[$Kt]->[_TOKEN_LENGTH_] < $space
                    || $rLL->[$Kt]->[_TYPE_] eq '#' )
                {
                    $rLL->[$Kt]->[_CI_LEVEL_] = 1;
                    $rseqno_controlling_my_ci->{$Kt} = $seqno_top;
                    $count++;
                }
            }
            $ris_seqno_controlling_ci->{$seqno_top} += $count;
        }

        $K_last = $KK;

        my $seqno = $rLL->[$KK]->[_TYPE_SEQUENCE_];

        # see if we have reached the end of the current controlling container
        if ( $seqno_top && $seqno == $seqno_top ) {
            $seqno_top = pop @seqno_stack;
        }

        # Patch to fix some block types...
        # Certain block types arrive from the tokenizer without CI but should
        # have it for this option.  These include anonymous subs and
        #     do sort map grep eval
        my $block_type = $rblock_type_of_seqno->{$seqno};
        if ( $block_type && $is_block_with_ci{$block_type} ) {
            $rLL->[$KK]->[_CI_LEVEL_] = 1;
            if ($seqno_top) {
                $rseqno_controlling_my_ci->{$KK} = $seqno_top;
                $ris_seqno_controlling_ci->{$seqno_top}++;
            }
        }

        # If this does not have ci, update ci if necessary and continue looking
        else {
            if ( !$rLL->[$KK]->[_CI_LEVEL_] ) {
                if ($seqno_top) {
                    $rLL->[$KK]->[_CI_LEVEL_] = 1;
                    $rseqno_controlling_my_ci->{$KK} = $seqno_top;
                    $ris_seqno_controlling_ci->{$seqno_top}++;
                }
                next;
            }
        }

        # We are looking for opening container tokens with ci
        my $K_opening = $K_opening_container->{$seqno};
        next unless ( defined($K_opening) && $KK == $K_opening );

        # Make sure there is a corresponding closing container
        # (could be missing if the script has a brace error)
        my $K_closing = $K_closing_container->{$seqno};
        next unless defined($K_closing);

        # Skip if requested by -bbx to avoid blinkers
        next if ( $rno_xci_by_seqno->{$seqno} );

        # Skip if this is a -bli container (this fixes case b1065) Note: case
        # b1065 is also fixed by the update for b1055, so this update is not
        # essential now.  But there does not seem to be a good reason to add
        # xci and bli together, so the update is retained.
        next if ( $ris_bli_container->{$seqno} );

        # Require different input lines. This will filter out a large number
        # of small hash braces and array brackets.  If we accidentally filter
        # out an important container, it will get fixed on the next pass.
        if (
            $rLL->[$K_opening]->[_LINE_INDEX_] ==
            $rLL->[$K_closing]->[_LINE_INDEX_]
            && ( $rLL->[$K_closing]->[_CUMULATIVE_LENGTH_] -
                $rLL->[$K_opening]->[_CUMULATIVE_LENGTH_] >
                $rOpts_maximum_line_length )
          )
        {
            DEBUG_XCI
              && print "XCI: Skipping seqno=$seqno, require different lines\n";
            next;
        }

        # Do not apply -xci if adding extra ci will put the container contents
        # beyond the line length limit (fixes cases b899 b935)
        my $level    = $rLL->[$K_opening]->[_LEVEL_];
        my $ci_level = $rLL->[$K_opening]->[_CI_LEVEL_];
        my $maximum_text_length =
          $maximum_text_length_at_level[$level] -
          $ci_level * $rOpts_continuation_indentation;

        # Fix for b1197 b1198 b1199 b1200 b1201 b1202
        # Do not apply -xci if we are running out of space
        # TODO: review this; do we also need to look at stress_level_alpha?
        if ( $level >= $stress_level_beta ) {
            DEBUG_XCI
              && print
"XCI: Skipping seqno=$seqno, level=$level exceeds stress level=$stress_level_beta\n";
            next;
        }

        # remember how much space is available for patch b1031 above
        my $space =
          $maximum_text_length - $len_tol - $rOpts_continuation_indentation;

        if ( $space < 0 ) {
            DEBUG_XCI && print "XCI: Skipping seqno=$seqno, space=$space\n";
            next;
        }
        DEBUG_XCI && print "XCI: OK seqno=$seqno, space=$space\n";

        $available_space{$seqno} = $space;

        # This becomes the next controlling container
        push @seqno_stack, $seqno_top if ($seqno_top);
        $seqno_top = $seqno;
    }
    return;
} ## end sub extended_ci

sub braces_left_setup {

    # Called once per file to mark all -bl, -sbl, and -asbl containers
    my $self = shift;

    my $rOpts_bl   = $rOpts->{'opening-brace-on-new-line'};
    my $rOpts_sbl  = $rOpts->{'opening-sub-brace-on-new-line'};
    my $rOpts_asbl = $rOpts->{'opening-anonymous-sub-brace-on-new-line'};
    return unless ( $rOpts_bl || $rOpts_sbl || $rOpts_asbl );

    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );

    # We will turn on this hash for braces controlled by these flags:
    my $rbrace_left = $self->[_rbrace_left_];

    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];
    my $ris_asub_block       = $self->[_ris_asub_block_];
    my $ris_sub_block        = $self->[_ris_sub_block_];
    foreach my $seqno ( keys %{$rblock_type_of_seqno} ) {

        my $block_type = $rblock_type_of_seqno->{$seqno};

        # use -asbl flag for an anonymous sub block
        if ( $ris_asub_block->{$seqno} ) {
            if ($rOpts_asbl) {
                $rbrace_left->{$seqno} = 1;
            }
        }

        # use -sbl flag for a named sub
        elsif ( $ris_sub_block->{$seqno} ) {
            if ($rOpts_sbl) {
                $rbrace_left->{$seqno} = 1;
            }
        }

        # use -bl flag if not a sub block of any type
        else {
            if (   $rOpts_bl
                && $block_type =~ /$bl_pattern/
                && $block_type !~ /$bl_exclusion_pattern/ )
            {
                $rbrace_left->{$seqno} = 1;
            }
        }
    }
    return;
} ## end sub braces_left_setup

sub bli_adjustment {

    # Called once per file to implement the --brace-left-and-indent option.
    # If -bli is set, adds one continuation indentation for certain braces
    my $self = shift;
    return unless ( $rOpts->{'brace-left-and-indent'} );
    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );

    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];
    my $ris_bli_container    = $self->[_ris_bli_container_];
    my $rbrace_left          = $self->[_rbrace_left_];
    my $K_opening_container  = $self->[_K_opening_container_];
    my $K_closing_container  = $self->[_K_closing_container_];

    foreach my $seqno ( keys %{$rblock_type_of_seqno} ) {
        my $block_type = $rblock_type_of_seqno->{$seqno};
        if (   $block_type
            && $block_type =~ /$bli_pattern/
            && $block_type !~ /$bli_exclusion_pattern/ )
        {
            $ris_bli_container->{$seqno} = 1;
            $rbrace_left->{$seqno}       = 1;
            my $Ko = $K_opening_container->{$seqno};
            my $Kc = $K_closing_container->{$seqno};
            if ( defined($Ko) && defined($Kc) ) {
                $rLL->[$Kc]->[_CI_LEVEL_] = ++$rLL->[$Ko]->[_CI_LEVEL_];
            }
        }
    }
    return;
} ## end sub bli_adjustment

sub find_multiline_qw {

    my ( $self, $rqw_lines ) = @_;

    # Multiline qw quotes are not sequenced items like containers { [ (
    # but behave in some respects in a similar way. So this routine finds them
    # and creates a separate sequence number system for later use.

    # This is straightforward because they always begin at the end of one line
    # and end at the beginning of a later line. This is true no matter how we
    # finally make our line breaks, so we can find them before deciding on new
    # line breaks.

    # Input parameter:
    #   if $rqw_lines is defined it is a ref to array of all line index numbers
    #   for which there is a type 'q' qw quote at either end of the line. This
    #   was defined by sub resync_lines_and_tokens for efficiency.
    #

    my $rlines = $self->[_rlines_];

    # if $rqw_lines is not defined (this will occur with -io option) then we
    # will have to scan all lines.
    if ( !defined($rqw_lines) ) {
        $rqw_lines = [ 0 .. @{$rlines} - 1 ];
    }

    # if $rqw_lines is defined but empty, just return because there are no
    # multiline qw's
    else {
        if ( !@{$rqw_lines} ) { return }
    }

    my $rstarting_multiline_qw_seqno_by_K = {};
    my $rending_multiline_qw_seqno_by_K   = {};
    my $rKrange_multiline_qw_by_seqno     = {};
    my $rmultiline_qw_has_extra_level     = {};

    my $ris_excluded_lp_container = $self->[_ris_excluded_lp_container_];

    my $rLL = $self->[_rLL_];
    my $qw_seqno;
    my $num_qw_seqno = 0;
    my $K_start_multiline_qw;

    # For reference, here is the old loop, before $rqw_lines became available:
    ##  foreach my $line_of_tokens ( @{$rlines} ) {
    foreach my $iline ( @{$rqw_lines} ) {
        my $line_of_tokens = $rlines->[$iline];

        # Note that these first checks are required in case we have to scan
        # all lines, not just lines with type 'q' at the ends.
        my $line_type = $line_of_tokens->{_line_type};
        next unless ( $line_type eq 'CODE' );
        my $rK_range = $line_of_tokens->{_rK_range};
        my ( $Kfirst, $Klast ) = @{$rK_range};
        next unless ( defined($Kfirst) && defined($Klast) );   # skip blank line

        # Continuing a sequence of qw lines ...
        if ( defined($K_start_multiline_qw) ) {
            my $type = $rLL->[$Kfirst]->[_TYPE_];

            # shouldn't happen
            if ( $type ne 'q' ) {
                DEVEL_MODE && print {*STDERR} <<EOM;
STRANGE: started multiline qw at K=$K_start_multiline_qw but didn't see q qw at K=$Kfirst\n";
EOM
                $K_start_multiline_qw = undef;
                next;
            }
            my $Kprev  = $self->K_previous_nonblank($Kfirst);
            my $Knext  = $self->K_next_nonblank($Kfirst);
            my $type_m = defined($Kprev) ? $rLL->[$Kprev]->[_TYPE_] : 'b';
            my $type_p = defined($Knext) ? $rLL->[$Knext]->[_TYPE_] : 'b';
            if ( $type_m eq 'q' && $type_p ne 'q' ) {
                $rending_multiline_qw_seqno_by_K->{$Kfirst} = $qw_seqno;
                $rKrange_multiline_qw_by_seqno->{$qw_seqno} =
                  [ $K_start_multiline_qw, $Kfirst ];
                $K_start_multiline_qw = undef;
                $qw_seqno             = undef;
            }
        }

        # Starting a new a sequence of qw lines ?
        if ( !defined($K_start_multiline_qw)
            && $rLL->[$Klast]->[_TYPE_] eq 'q' )
        {
            my $Kprev  = $self->K_previous_nonblank($Klast);
            my $Knext  = $self->K_next_nonblank($Klast);
            my $type_m = defined($Kprev) ? $rLL->[$Kprev]->[_TYPE_] : 'b';
            my $type_p = defined($Knext) ? $rLL->[$Knext]->[_TYPE_] : 'b';
            if ( $type_m ne 'q' && $type_p eq 'q' ) {
                $num_qw_seqno++;
                $qw_seqno             = 'q' . $num_qw_seqno;
                $K_start_multiline_qw = $Klast;
                $rstarting_multiline_qw_seqno_by_K->{$Klast} = $qw_seqno;
            }
        }
    }

    # Give multiline qw lists extra indentation instead of CI.  This option
    # works well but is currently only activated when the -xci flag is set.
    # The reason is to avoid unexpected changes in formatting.
    if ($rOpts_extended_continuation_indentation) {
        foreach my $qw_seqno_x ( keys %{$rKrange_multiline_qw_by_seqno} ) {
            my $rKrange = $rKrange_multiline_qw_by_seqno->{$qw_seqno_x};
            my ( $Kbeg, $Kend ) = @{$rKrange};

            # require isolated closing token
            my $token_end           = $rLL->[$Kend]->[_TOKEN_];
            my $is_isolated_closing = length($token_end) == 1
              && ( $is_closing_token{$token_end} || $token_end eq '>' );
            next unless ($is_isolated_closing);

            # require isolated opening token
            my $token_beg = $rLL->[$Kbeg]->[_TOKEN_];

            # allow space(s) after the qw
            if ( length($token_beg) > 3 && substr( $token_beg, 2, 1 ) =~ m/\s/ )
            {
                $token_beg =~ s/\s+//;
            }

            next unless ( length($token_beg) == 3 );

            foreach my $KK ( $Kbeg + 1 .. $Kend - 1 ) {
                $rLL->[$KK]->[_LEVEL_]++;
                $rLL->[$KK]->[_CI_LEVEL_] = 0;
            }

            # set flag for -wn option, which will remove the level
            $rmultiline_qw_has_extra_level->{$qw_seqno_x} = 1;
        }
    }

    # For the -lp option we need to mark all parent containers of
    # multiline quotes
    if ( $rOpts_line_up_parentheses && !$rOpts_extended_line_up_parentheses ) {

        foreach my $qw_seqno_x ( keys %{$rKrange_multiline_qw_by_seqno} ) {
            my $rKrange = $rKrange_multiline_qw_by_seqno->{$qw_seqno_x};
            my ( $Kbeg, $Kend ) = @{$rKrange};
            my $parent_seqno = $self->parent_seqno_by_K($Kend);
            next unless ($parent_seqno);

            # If the parent container exactly surrounds this qw, then -lp
            # formatting seems to work so we will not mark it.
            my $is_tightly_contained;
            my $Kn      = $self->K_next_nonblank($Kend);
            my $seqno_n = defined($Kn) ? $rLL->[$Kn]->[_TYPE_SEQUENCE_] : undef;
            if ( defined($seqno_n) && $seqno_n eq $parent_seqno ) {

                my $Kp = $self->K_previous_nonblank($Kbeg);
                my $seqno_p =
                  defined($Kp) ? $rLL->[$Kp]->[_TYPE_SEQUENCE_] : undef;
                if ( defined($seqno_p) && $seqno_p eq $parent_seqno ) {
                    $is_tightly_contained = 1;
                }
            }

            $ris_excluded_lp_container->{$parent_seqno} = 1
              unless ($is_tightly_contained);

            # continue up the tree marking parent containers
            $self->mark_parent_containers( $parent_seqno,
                $ris_excluded_lp_container );
        }
    }

    $self->[_rstarting_multiline_qw_seqno_by_K_] =
      $rstarting_multiline_qw_seqno_by_K;
    $self->[_rending_multiline_qw_seqno_by_K_] =
      $rending_multiline_qw_seqno_by_K;
    $self->[_rKrange_multiline_qw_by_seqno_] = $rKrange_multiline_qw_by_seqno;
    $self->[_rmultiline_qw_has_extra_level_] = $rmultiline_qw_has_extra_level;

    return;
} ## end sub find_multiline_qw

use constant DEBUG_COLLAPSED_LENGTHS => 0;

# Minimum space reserved for contents of a code block.  A value of 40 has given
# reasonable results.  With a large line length, say -l=120, this will not
# normally be noticeable but it will prevent making a mess in some edge cases.
use constant MIN_BLOCK_LEN => 40;

my %is_handle_type;

BEGIN {
    my @q = qw( w C U G i k => );
    @is_handle_type{@q} = (1) x scalar(@q);

    my $i = 0;
    use constant {
        _max_prong_len_         => $i++,
        _handle_len_            => $i++,
        _seqno_o_               => $i++,
        _iline_o_               => $i++,
        _K_o_                   => $i++,
        _K_c_                   => $i++,
        _interrupted_list_rule_ => $i++,
    };
} ## end BEGIN

sub is_fragile_block_type {

    my ( $self, $block_type, $seqno ) = @_;

    # Given:
    #  $block_type = the block type of a token, and
    #  $seqno      = its sequence number

    # Return:
    #  true if this block type stays broken after being broken,
    #  false otherwise

    # This sub has been added to isolate a tricky decision needed
    # to fix issue b1428.

    # The coding here needs to agree with:
    # - sub process_line where variable '$rbrace_follower' is set
    # - sub process_line_inner_loop where variable '$is_opening_BLOCK' is set,

    if (   $is_sort_map_grep_eval{$block_type}
        || $block_type eq 't'
        || $self->[_rshort_nested_]->{$seqno} )
    {
        return 0;
    }

    return 1;

} ## end sub is_fragile_block_type

{    ## closure xlp_collapsed_lengths

    my $max_prong_len;
    my $len;
    my $last_nonblank_type;
    my @stack;

    sub xlp_collapsed_lengths_initialize {

        $max_prong_len      = 0;
        $len                = 0;
        $last_nonblank_type = 'b';
        @stack              = ();

        push @stack, [
            0,           # $max_prong_len,
            0,           # $handle_len,
            SEQ_ROOT,    # $seqno,
            undef,       # $iline,
            undef,       # $KK,
            undef,       # $K_c,
            undef,       # $interrupted_list_rule
        ];

        return;
    } ## end sub xlp_collapsed_lengths_initialize

    sub cumulative_length_to_comma {

        my ( $self, $KK, $K_comma, $K_closing ) = @_;

        # Given:
        #  $KK        = index of starting token, or blank before start
        #  $K_comma   = index of line-ending comma
        #  $K_closing = index of the container closing token

        # Return:
        #  $length = cumulative length of the term

        my $rLL = $self->[_rLL_];
        if ( $rLL->[$KK]->[_TYPE_] eq 'b' ) { $KK++ }
        my $length = 0;
        if (
               $KK < $K_comma
            && $rLL->[$K_comma]->[_TYPE_] eq ','    # should be true

            # Ignore if terminal comma, causes instability (b1297,
            # b1330)
            && (
                $K_closing - $K_comma > 2
                || (   $K_closing - $K_comma == 2
                    && $rLL->[ $K_comma + 1 ]->[_TYPE_] ne 'b' )
            )

            # The comma should be in this container
            && ( $rLL->[$K_comma]->[_LEVEL_] - 1 ==
                $rLL->[$K_closing]->[_LEVEL_] )
          )
        {

            # An additional check: if line ends in ), and the ) has vtc then
            # skip this estimate. Otherwise, vtc can give oscillating results.
            # Fixes b1448. For example, this could be unstable:

            #  ( $os ne 'win' ? ( -selectcolor => "red" ) : () ),
            #  |                                               |^--K_comma
            #  |                                               ^-- K_prev
            #  ^--- KK

            # An alternative, possibly better strategy would be to try to turn
            # off -vtc locally, but it turns out to be difficult to locate the
            # appropriate closing token when it is not on the same line as its
            # opening token.

            my $K_prev = $self->K_previous_nonblank($K_comma);
            if (   defined($K_prev)
                && $K_prev >= $KK
                && $rLL->[$K_prev]->[_TYPE_SEQUENCE_] )
            {
                my $token = $rLL->[$K_prev]->[_TOKEN_];
                my $type  = $rLL->[$K_prev]->[_TYPE_];
                if ( $closing_vertical_tightness{$token} && $type ne 'R' ) {
                    ## type 'R' does not normally get broken, so ignore
                    ## skip length calculation
                    return 0;
                }
            }
            my $starting_len =
              $KK >= 0 ? $rLL->[ $KK - 1 ]->[_CUMULATIVE_LENGTH_] : 0;
            $length = $rLL->[$K_comma]->[_CUMULATIVE_LENGTH_] - $starting_len;
        }
        return $length;
    } ## end sub cumulative_length_to_comma

    sub xlp_collapsed_lengths {

        my $self = shift;

        #----------------------------------------------------------------
        # Define the collapsed lengths of containers for -xlp indentation
        #----------------------------------------------------------------

        # We need an estimate of the minimum required line length starting at
        # any opening container for the -xlp style. This is needed to avoid
        # using too much indentation space for lower level containers and
        # thereby running out of space for outer container tokens due to the
        # maximum line length limit.

        # The basic idea is that at each node in the tree we imagine that we
        # have a fork with a handle and collapsible prongs:
        #
        #                            |------------
        #                            |--------
        #                ------------|-------
        #                 handle     |------------
        #                            |--------
        #                              prongs
        #
        # Each prong has a minimum collapsed length. The collapsed length at a
        # node is the maximum of these minimum lengths, plus the handle length.
        # Each of the prongs may itself be a tree node.

        # This is just a rough calculation to get an approximate starting point
        # for indentation.  Later routines will be more precise.  It is
        # important that these estimates be independent of the line breaks of
        # the input stream in order to avoid instabilities.

        my $rLL                        = $self->[_rLL_];
        my $rlines                     = $self->[_rlines_];
        my $rcollapsed_length_by_seqno = $self->[_rcollapsed_length_by_seqno_];
        my $rtype_count_by_seqno       = $self->[_rtype_count_by_seqno_];
        my $rK_next_seqno_by_K         = $self->[_rK_next_seqno_by_K_];

        my $K_start_multiline_qw;
        my $level_start_multiline_qw = 0;

        xlp_collapsed_lengths_initialize();

        #--------------------------------
        # Loop over all lines in the file
        #--------------------------------
        my $iline = -1;
        my $skip_next_line;
        foreach my $line_of_tokens ( @{$rlines} ) {
            $iline++;
            if ($skip_next_line) {
                $skip_next_line = 0;
                next;
            }
            my $line_type = $line_of_tokens->{_line_type};
            next if ( $line_type ne 'CODE' );
            my $CODE_type = $line_of_tokens->{_code_type};

            # Always skip blank lines
            next if ( $CODE_type eq 'BL' );

            # Note on other line types:
            # 'FS' (Format Skipping) lines may contain opening/closing tokens so
            #      we have to process them to keep the stack correctly sequenced
            # 'VB' (Verbatim) lines could be skipped, but testing shows that
            #      results look better if we include their lengths.

            # Also note that we could exclude -xlp formatting of containers with
            # 'FS' and 'VB' lines, but in testing that was not really beneficial

            # So we process tokens in 'FS' and 'VB' lines like all the rest...

            my $rK_range = $line_of_tokens->{_rK_range};
            my ( $K_first, $K_last ) = @{$rK_range};
            next unless ( defined($K_first) && defined($K_last) );

            my $has_comment = $rLL->[$K_last]->[_TYPE_] eq '#';

            # Always ignore block comments
            next if ( $has_comment && $K_first == $K_last );

            # Handle an intermediate line of a multiline qw quote. These may
            # require including some -ci or -i spaces.  See cases c098/x063.
            # Updated to check all lines (not just $K_first==$K_last) to fix
            # b1316
            my $K_begin_loop = $K_first;
            if ( $rLL->[$K_first]->[_TYPE_] eq 'q' ) {

                my $KK       = $K_first;
                my $level    = $rLL->[$KK]->[_LEVEL_];
                my $ci_level = $rLL->[$KK]->[_CI_LEVEL_];

                # remember the level of the start
                if ( !defined($K_start_multiline_qw) ) {
                    $K_start_multiline_qw     = $K_first;
                    $level_start_multiline_qw = $level;
                    my $seqno_qw =
                      $self->[_rstarting_multiline_qw_seqno_by_K_]
                      ->{$K_start_multiline_qw};
                    if ( !$seqno_qw ) {
                        my $Kp = $self->K_previous_nonblank($K_first);
                        if ( defined($Kp) && $rLL->[$Kp]->[_TYPE_] eq 'q' ) {

                            $K_start_multiline_qw = $Kp;
                            $level_start_multiline_qw =
                              $rLL->[$K_start_multiline_qw]->[_LEVEL_];
                        }
                        else {

                            # Fix for b1319, b1320
                            $K_start_multiline_qw = undef;
                        }
                    }
                }

                if ( defined($K_start_multiline_qw) ) {
                    $len = $rLL->[$KK]->[_CUMULATIVE_LENGTH_] -
                      $rLL->[ $KK - 1 ]->[_CUMULATIVE_LENGTH_];

                    # We may have to add the spaces of one level or ci level
                    # ...  it depends depends on the -xci flag, the -wn flag,
                    # and if the qw uses a container token as the quote
                    # delimiter.

                    # First rule: add ci if there is a $ci_level
                    if ($ci_level) {
                        $len += $rOpts_continuation_indentation;
                    }

                    # Second rule: otherwise, look for an extra indentation
                    # level from the start and add one indentation level if
                    # found.
                    else {
                        if ( $level > $level_start_multiline_qw ) {
                            $len += $rOpts_indent_columns;
                        }
                    }

                    if ( $len > $max_prong_len ) { $max_prong_len = $len }

                    $last_nonblank_type = 'q';

                    $K_begin_loop = $K_first + 1;

                    # We can skip to the next line if more tokens
                    next if ( $K_begin_loop > $K_last );
                }
            }

            # If starting in quote type Q we have no control over indentation
            # so just ignore the length of this token (see git #138)
            elsif ( $rLL->[$K_first]->[_TYPE_] eq 'Q' ) {
                if ( $line_of_tokens->{_starting_in_quote} ) {
                    $K_begin_loop = $K_first + 1;
                    next if ( $K_begin_loop > $K_last );
                }
            }
            else {
            }

            $K_start_multiline_qw = undef;

            # Find the terminal token, before any side comment
            my $K_terminal = $K_last;
            if ($has_comment) {
                $K_terminal -= 1;
                $K_terminal -= 1
                  if ( $rLL->[$K_terminal]->[_TYPE_] eq 'b'
                    && $K_terminal > $K_first );
            }

            # Use length to terminal comma if interrupted list rule applies
            if ( @stack && $stack[-1]->[_interrupted_list_rule_] ) {
                my $K_c = $stack[-1]->[_K_c_];
                if ( defined($K_c) ) {

                    #----------------------------------------------------------
                    # BEGIN patch for issue b1408: If this line ends in an
                    # opening token, look for the closing token and comma at
                    # the end of the next line. If so, combine the two lines to
                    # get the correct sums.  This problem seems to require -xlp
                    # -vtc=2 and blank lines to occur. Use %is_opening_type to
                    # fix b1431.
                    #----------------------------------------------------------
                    if ( $is_opening_type{ $rLL->[$K_terminal]->[_TYPE_] }
                        && !$has_comment )
                    {
                        my $seqno_end = $rLL->[$K_terminal]->[_TYPE_SEQUENCE_];
                        my $Kc_test   = $rK_next_seqno_by_K->[$K_terminal];

                        # We are looking for a short broken remnant on the next
                        # line; something like the third line here (b1408):

                    #     parent =>
                    #       Moose::Util::TypeConstraints::find_type_constraint(
                    #               'RefXX' ),
                    # or this
                    #
                    #  Help::WorkSubmitter->_filter_chores_and_maybe_warn_user(
                    #                                    $story_set_all_chores),
                    # or this (b1431):
                    #        $issue->{
                    #           'borrowernumber'},  # borrowernumber
                        if (   defined($Kc_test)
                            && $seqno_end == $rLL->[$Kc_test]->[_TYPE_SEQUENCE_]
                            && $rLL->[$Kc_test]->[_LINE_INDEX_] == $iline + 1 )
                        {
                            my $line_of_tokens_next = $rlines->[ $iline + 1 ];
                            my $rtype_count =
                              $rtype_count_by_seqno->{$seqno_end};
                            my ( $K_first_next, $K_terminal_next ) =
                              @{ $line_of_tokens_next->{_rK_range} };

                            # backup at a side comment
                            if ( defined($K_terminal_next)
                                && $rLL->[$K_terminal_next]->[_TYPE_] eq '#' )
                            {
                                my $Kprev =
                                  $self->K_previous_nonblank($K_terminal_next);
                                if ( defined($Kprev)
                                    && $Kprev >= $K_first_next )
                                {
                                    $K_terminal_next = $Kprev;
                                }
                            }

                            if (
                                defined($K_terminal_next)

                                # next line ends with a comma
                                && $rLL->[$K_terminal_next]->[_TYPE_] eq ','

                                # which follows the closing container token
                                && (
                                    $K_terminal_next - $Kc_test == 1
                                    || (   $K_terminal_next - $Kc_test == 2
                                        && $rLL->[ $K_terminal_next - 1 ]
                                        ->[_TYPE_] eq 'b' )
                                )

                                # no commas in the container
                                && (   !defined($rtype_count)
                                    || !$rtype_count->{','} )

                                # for now, restrict this to a container with
                                # just 1 or two tokens
                                && $K_terminal_next - $K_terminal <= 5

                              )
                            {

                                # combine the next line with the current line
                                $K_terminal     = $K_terminal_next;
                                $skip_next_line = 1;
                                if (DEBUG_COLLAPSED_LENGTHS) {
                                    print "Combining lines at line $iline\n";
                                }
                            }
                        }
                    }

                    #--------------------------
                    # END patch for issue b1408
                    #--------------------------
                    if ( $rLL->[$K_terminal]->[_TYPE_] eq ',' ) {

                        my $length =
                          $self->cumulative_length_to_comma( $K_first,
                            $K_terminal, $K_c );

                        # Fix for b1331: at a broken => item, include the
                        # length of the previous half of the item plus one for
                        # the missing space
                        if ( $last_nonblank_type eq '=>' ) {
                            $length += $len + 1;
                        }
                        if ( $length > $max_prong_len ) {
                            $max_prong_len = $length;
                        }
                    }
                }
            }

            #----------------------------------
            # Loop over all tokens on this line
            #----------------------------------
            $self->xlp_collapse_lengths_inner_loop( $iline, $K_begin_loop,
                $K_terminal, $K_last );

            # Now take care of any side comment;
            if ($has_comment) {
                if ($rOpts_ignore_side_comment_lengths) {
                    $len = 0;
                }
                else {

                 # For a side comment when -iscl is not set, measure length from
                 # the start of the previous nonblank token
                    my $len0 =
                        $K_terminal > 0
                      ? $rLL->[ $K_terminal - 1 ]->[_CUMULATIVE_LENGTH_]
                      : 0;
                    $len = $rLL->[$K_last]->[_CUMULATIVE_LENGTH_] - $len0;
                    if ( $len > $max_prong_len ) { $max_prong_len = $len }
                }
            }

        } ## end loop over lines

        if (DEBUG_COLLAPSED_LENGTHS) {
            print "\nCollapsed lengths--\n";
            foreach
              my $key ( sort { $a <=> $b } keys %{$rcollapsed_length_by_seqno} )
            {
                my $clen = $rcollapsed_length_by_seqno->{$key};
                print "$key -> $clen\n";
            }
        }

        return;
    } ## end sub xlp_collapsed_lengths

    sub xlp_collapse_lengths_inner_loop {

        my ( $self, $iline, $K_begin_loop, $K_terminal, $K_last ) = @_;

        # Loop over tokens on a line for sub xlp_collapse_lengths

        # Given:
        #   $iline = line number in input stream
        #   ($K_begin_loop, $K_terminal) = token index range to scan
        #   $K_last = last token index on this line

        my $rLL                 = $self->[_rLL_];
        my $K_closing_container = $self->[_K_closing_container_];

        my $rblock_type_of_seqno       = $self->[_rblock_type_of_seqno_];
        my $rcollapsed_length_by_seqno = $self->[_rcollapsed_length_by_seqno_];
        my $ris_permanently_broken     = $self->[_ris_permanently_broken_];
        my $ris_list_by_seqno          = $self->[_ris_list_by_seqno_];
        my $rhas_broken_list           = $self->[_rhas_broken_list_];
        my $rtype_count_by_seqno       = $self->[_rtype_count_by_seqno_];

        #----------------------------------
        # Loop over tokens on this line ...
        #----------------------------------
        my $type;
        foreach my $KK ( $K_begin_loop .. $K_terminal ) {

            next if ( ( $type = $rLL->[$KK]->[_TYPE_] ) eq 'b' );

            #------------------------
            # Handle sequenced tokens
            #------------------------
            my $seqno = $rLL->[$KK]->[_TYPE_SEQUENCE_];
            if ($seqno) {

                my $token = $rLL->[$KK]->[_TOKEN_];

                #----------------------------
                # Entering a new container...
                #----------------------------
                if ( $is_opening_token{$token}
                    && defined( $K_closing_container->{$seqno} ) )
                {

                    # save current prong length
                    $stack[-1]->[_max_prong_len_] = $max_prong_len;
                    $max_prong_len = 0;

                    # Start new prong one level deeper
                    my $handle_len = 0;
                    if ( $rblock_type_of_seqno->{$seqno} ) {

                        # code blocks do not use -lp indentation, but behave as
                        # if they had a handle of one indentation length
                        $handle_len = $rOpts_indent_columns;

                    }
                    else {
                        if ( $is_handle_type{$last_nonblank_type} ) {
                            $handle_len = $len;
                            $handle_len += 1
                              if ( $KK > 0
                                && $rLL->[ $KK - 1 ]->[_TYPE_] eq 'b' );
                        }
                    }

                    # Set a flag if the 'Interrupted List Rule' will be applied
                    # (see sub copy_old_breakpoints).
                    # - Added check on has_broken_list to fix issue b1298

                    my $interrupted_list_rule =
                         $ris_permanently_broken->{$seqno}
                      && $ris_list_by_seqno->{$seqno}
                      && !$rhas_broken_list->{$seqno}
                      && !$rOpts_ignore_old_breakpoints;

                    # NOTES: Since we are looking at old line numbers we have
                    # to be very careful not to introduce an instability.

                    # This following causes instability (b1288-b1296):
                    #   $interrupted_list_rule ||=
                    #     $rOpts_break_at_old_comma_breakpoints;

                    #  - We could turn off the interrupted list rule if there is
                    #    a broken sublist, to follow 'Compound List Rule 1'.
                    #  - We could use the _rhas_broken_list_ flag for this.
                    #  - But it seems safer not to do this, to avoid
                    #    instability, since the broken sublist could be
                    #    temporary.  It seems better to let the formatting
                    #    stabilize by itself after one or two iterations.
                    #  - So, not doing this for now

                    # Turn off the interrupted list rule if -vmll is set and a
                    # list has '=>' characters.  This avoids instabilities due
                    # to dependence on old line breaks; issue b1325.
                    if (   $interrupted_list_rule
                        && $rOpts_variable_maximum_line_length )
                    {
                        my $rtype_count = $rtype_count_by_seqno->{$seqno};
                        if ( $rtype_count && $rtype_count->{'=>'} ) {
                            $interrupted_list_rule = 0;
                        }
                    }

                    my $K_c = $K_closing_container->{$seqno};

                    # Add length of any terminal list item if interrupted
                    # so that the result is the same as if the term is
                    # in the next line (b1446).

                    if (
                           $interrupted_list_rule
                        && $KK < $K_terminal

                        # The line should end in a comma
                        # NOTE: this currently assumes break after comma.
                        # As long as the other call to cumulative_length..
                        # makes the same assumption we should remain stable.
                        && $rLL->[$K_terminal]->[_TYPE_] eq ','

                      )
                    {
                        $max_prong_len =
                          $self->cumulative_length_to_comma( $KK + 1,
                            $K_terminal, $K_c );
                    }

                    push @stack, [

                        $max_prong_len,
                        $handle_len,
                        $seqno,
                        $iline,
                        $KK,
                        $K_c,
                        $interrupted_list_rule
                    ];

                }

                #--------------------
                # Exiting a container
                #--------------------
                elsif ( $is_closing_token{$token} && @stack ) {

                    # The current prong ends - get its handle
                    my $item          = pop @stack;
                    my $handle_len    = $item->[_handle_len_];
                    my $seqno_o       = $item->[_seqno_o_];
                    my $iline_o       = $item->[_iline_o_];
                    my $K_o           = $item->[_K_o_];
                    my $K_c_expect    = $item->[_K_c_];
                    my $collapsed_len = $max_prong_len;

                    if ( $seqno_o ne $seqno ) {

                        # This can happen if input file has brace errors.
                        # Otherwise it shouldn't happen.  Not fatal but -lp
                        # formatting could get messed up.
                        if ( DEVEL_MODE && !get_saw_brace_error() ) {
                            Fault(<<EOM);
sequence numbers differ; at CLOSING line $iline, seq=$seqno, Kc=$KK .. at OPENING line $iline_o, seq=$seqno_o, Ko=$K_o, expecting Kc=$K_c_expect
EOM
                        }
                    }

                    #------------------------------------------
                    # Rules to avoid scrunching code blocks ...
                    #------------------------------------------
                    # Some test cases:
                    # c098/x107 x108 x110 x112 x114 x115 x117 x118 x119
                    my $block_type = $rblock_type_of_seqno->{$seqno};
                    if ($block_type) {

                        my $K_c          = $KK;
                        my $block_length = MIN_BLOCK_LEN;
                        my $is_one_line_block;
                        my $level = $rLL->[$K_o]->[_LEVEL_];
                        if ( defined($K_o) && defined($K_c) ) {

                            # note: fixed 3 May 2022 (removed 'my')
                            $block_length =
                              $rLL->[ $K_c - 1 ]->[_CUMULATIVE_LENGTH_] -
                              $rLL->[$K_o]->[_CUMULATIVE_LENGTH_];
                            $is_one_line_block = $iline == $iline_o;
                        }

                        # Code block rule 1: Use the total block length if
                        # it is less than the minimum.
                        if ( $block_length < MIN_BLOCK_LEN ) {
                            $collapsed_len = $block_length;
                        }

                        # Code block rule 2: Use the full length of a
                        # one-line block to avoid breaking it, unless
                        # extremely long.  We do not need to do a precise
                        # check here, because if it breaks then it will
                        # stay broken on later iterations.
                        elsif (
                               $is_one_line_block
                            && $block_length <
                            $maximum_line_length_at_level[$level]

                            # But skip this for blocks types which can reform,
                            # like sort/map/grep/eval blocks, to avoid
                            # instability (b1345, b1428)
                            && $self->is_fragile_block_type( $block_type,
                                $seqno )
                          )
                        {
                            $collapsed_len = $block_length;
                        }

                        # Code block rule 3: Otherwise the length should be
                        # at least MIN_BLOCK_LEN to avoid scrunching code
                        # blocks.
                        elsif ( $collapsed_len < MIN_BLOCK_LEN ) {
                            $collapsed_len = MIN_BLOCK_LEN;
                        }
                        else {
                            # none of these rules applies
                        }
                    }

                    # Store the result.  Some extra space, '2', allows for
                    # length of an opening token, inside space, comma, ...
                    # This constant has been tuned to give good overall
                    # results.
                    $collapsed_len += 2;
                    $rcollapsed_length_by_seqno->{$seqno} = $collapsed_len;

                    # Restart scanning the lower level prong
                    if (@stack) {
                        $max_prong_len = $stack[-1]->[_max_prong_len_];
                        $collapsed_len += $handle_len;
                        if ( $collapsed_len > $max_prong_len ) {
                            $max_prong_len = $collapsed_len;
                        }
                    }
                }

                # it is a ternary or input file is unbalanced
                else {

                }

                $len                = 0;
                $last_nonblank_type = $type;
                next;
            }

            #----------------------------
            # Handle non-container tokens
            #----------------------------
            my $token_length = $rLL->[$KK]->[_TOKEN_LENGTH_];

            # Count lengths of things like 'xx => yy' as a single item
            if ( $type eq '=>' ) {
                $len += $token_length + 1;

                # fix $len for -naws, issue b1457
                if ( !$rOpts_add_whitespace ) {
                    if ( defined( $rLL->[ $KK + 1 ] )
                        && $rLL->[ $KK + 1 ]->[_TYPE_] ne 'b' )
                    {
                        $len -= 1;
                    }
                }

                if ( $len > $max_prong_len ) { $max_prong_len = $len }
            }
            elsif ( $last_nonblank_type eq '=>' ) {
                $len += $token_length;
                if ( $len > $max_prong_len ) { $max_prong_len = $len }

                # but only include one => per item
                $len = $token_length;
            }

            # include everything to end of line after a here target
            elsif ( $type eq 'h' ) {
                $len = $rLL->[$K_last]->[_CUMULATIVE_LENGTH_] -
                  $rLL->[ $KK - 1 ]->[_CUMULATIVE_LENGTH_];
                if ( $len > $max_prong_len ) { $max_prong_len = $len }
            }

            # for everything else just use the token length
            else {
                $len = $token_length;
                if ( $len > $max_prong_len ) { $max_prong_len = $len }
            }
            $last_nonblank_type = $type;

        } ## end loop over tokens on this line

        return;

    } ## end sub xlp_collapse_lengths_inner_loop

} ## end closure xlp_collapsed_lengths

sub is_excluded_lp {

    my ( $self, $KK ) = @_;

    # Decide if this container is excluded by user request

    # Given:
    #   $KK = index of the container opening token
    # Return:
    #   true if this token is excluded (i.e., may not use -lp)
    #   false otherwise

    # The control hash can either describe:
    #   what to exclude:  $line_up_parentheses_control_is_lpxl = 1, or
    #   what to include:  $line_up_parentheses_control_is_lpxl = 0

    my $rLL         = $self->[_rLL_];
    my $rtoken_vars = $rLL->[$KK];
    my $token       = $rtoken_vars->[_TOKEN_];
    my $rflags      = $line_up_parentheses_control_hash{$token};

    #-----------------------------------------------
    # TEST #1: check match to listed container types
    #-----------------------------------------------
    if ( !defined($rflags) ) {

        # There is no entry for this container, so we are done
        return !$line_up_parentheses_control_is_lpxl;
    }

    my ( $flag1, $flag2 ) = @{$rflags};

    #-----------------------------------------------------------
    # TEST #2: check match to flag1, the preceding nonblank word
    #-----------------------------------------------------------
    my $match_flag1 = !defined($flag1) || $flag1 eq '*';
    if ( !$match_flag1 ) {

        # Find the previous token
        my ( $is_f, $is_k, $is_w );
        my $Kp = $self->K_previous_nonblank($KK);
        if ( defined($Kp) ) {
            my $type_p = $rLL->[$Kp]->[_TYPE_];
            my $seqno  = $rtoken_vars->[_TYPE_SEQUENCE_];

            # keyword?
            $is_k = $type_p eq 'k';

            # function call?
            $is_f = $self->[_ris_function_call_paren_]->{$seqno};

            # either keyword or function call?
            $is_w = $is_k || $is_f;
        }

        # Check for match based on flag1 and the previous token:
        if    ( $flag1 eq 'k' ) { $match_flag1 = $is_k }
        elsif ( $flag1 eq 'K' ) { $match_flag1 = !$is_k }
        elsif ( $flag1 eq 'f' ) { $match_flag1 = $is_f }
        elsif ( $flag1 eq 'F' ) { $match_flag1 = !$is_f }
        elsif ( $flag1 eq 'w' ) { $match_flag1 = $is_w }
        elsif ( $flag1 eq 'W' ) { $match_flag1 = !$is_w }
        else {
            ## no match
            DEVEL_MODE && Fault(<<EOM);
unexpected --lp-exclusion code '$flag1': expecting one of kKfFwW
EOM
        }
    }

    # See if we can exclude this based on the flag1 test...
    if ($line_up_parentheses_control_is_lpxl) {
        return 1 if ($match_flag1);
    }
    else {
        return 1 if ( !$match_flag1 );
    }

    #-------------------------------------------------------------
    # TEST #3: exclusion based on flag2 and the container contents
    #-------------------------------------------------------------

    # Note that this is an exclusion test for both -lpxl or -lpil input methods
    # The options are:
    #  0 or blank: ignore container contents
    #  1 exclude non-lists or lists with sublists
    #  2 same as 1 but also exclude lists with code blocks

    my $match_flag2;
    if ($flag2) {

        my $seqno = $rtoken_vars->[_TYPE_SEQUENCE_];

        my $is_list        = $self->[_ris_list_by_seqno_]->{$seqno};
        my $has_list       = $self->[_rhas_list_]->{$seqno};
        my $has_code_block = $self->[_rhas_code_block_]->{$seqno};
        my $has_ternary    = $self->[_rhas_ternary_]->{$seqno};

        if (  !$is_list
            || $has_list
            || $flag2 eq '2' && ( $has_code_block || $has_ternary ) )
        {
            $match_flag2 = 1;
        }
    }
    return $match_flag2;
} ## end sub is_excluded_lp

sub set_excluded_lp_containers {

    my ($self) = @_;
    return unless ($rOpts_line_up_parentheses);
    my $rLL = $self->[_rLL_];
    return unless ( defined($rLL) && @{$rLL} );

    my $K_opening_container       = $self->[_K_opening_container_];
    my $ris_excluded_lp_container = $self->[_ris_excluded_lp_container_];
    my $rblock_type_of_seqno      = $self->[_rblock_type_of_seqno_];

    foreach my $seqno ( keys %{$K_opening_container} ) {

        # code blocks are always excluded by the -lp coding so we can skip them
        next if ( $rblock_type_of_seqno->{$seqno} );

        my $KK = $K_opening_container->{$seqno};
        next unless defined($KK);

        # see if a user exclusion rule turns off -lp for this container
        if ( $self->is_excluded_lp($KK) ) {
            $ris_excluded_lp_container->{$seqno} = 1;
        }
    }
    return;
} ## end sub set_excluded_lp_containers

######################################
# CODE SECTION 6: Process line-by-line
######################################

sub process_all_lines {

    my $self = shift;

    #----------------------------------------------------------
    # Main loop to format all lines of a file according to type
    #----------------------------------------------------------

    my $rlines                     = $self->[_rlines_];
    my $rOpts_keep_old_blank_lines = $rOpts->{'keep-old-blank-lines'};
    my $file_writer_object         = $self->[_file_writer_object_];
    my $logger_object              = $self->[_logger_object_];
    my $vertical_aligner_object    = $self->[_vertical_aligner_object_];
    my $save_logfile               = $self->[_save_logfile_];

    # Flag to prevent blank lines when POD occurs in a format skipping sect.
    my $in_format_skipping_section;

    # set locations for blanks around long runs of keywords
    my $rwant_blank_line_after = $self->keyword_group_scan();

    my $line_type      = EMPTY_STRING;
    my $i_last_POD_END = -10;
    my $i              = -1;
    foreach my $line_of_tokens ( @{$rlines} ) {

        # insert blank lines requested for keyword sequences
        if ( defined( $rwant_blank_line_after->{$i} )
            && $rwant_blank_line_after->{$i} == 1 )
        {
            $self->want_blank_line();
        }

        $i++;

        my $last_line_type = $line_type;
        $line_type = $line_of_tokens->{_line_type};
        my $input_line = $line_of_tokens->{_line_text};

        # _line_type codes are:
        #   SYSTEM         - system-specific code before hash-bang line
        #   CODE           - line of perl code (including comments)
        #   POD_START      - line starting pod, such as '=head'
        #   POD            - pod documentation text
        #   POD_END        - last line of pod section, '=cut'
        #   HERE           - text of here-document
        #   HERE_END       - last line of here-doc (target word)
        #   FORMAT         - format section
        #   FORMAT_END     - last line of format section, '.'
        #   SKIP           - code skipping section
        #   SKIP_END       - last line of code skipping section, '#>>V'
        #   DATA_START     - __DATA__ line
        #   DATA           - unidentified text following __DATA__
        #   END_START      - __END__ line
        #   END            - unidentified text following __END__
        #   ERROR          - we are in big trouble, probably not a perl script

        # put a blank line after an =cut which comes before __END__ and __DATA__
        # (required by podchecker)
        if ( $last_line_type eq 'POD_END' && !$self->[_saw_END_or_DATA_] ) {
            $i_last_POD_END = $i;
            $file_writer_object->reset_consecutive_blank_lines();
            if ( !$in_format_skipping_section && $input_line !~ /^\s*$/ ) {
                $self->want_blank_line();
            }
        }

        # handle line of code..
        if ( $line_type eq 'CODE' ) {

            my $CODE_type = $line_of_tokens->{_code_type};
            $in_format_skipping_section = $CODE_type eq 'FS';

            # Handle blank lines
            if ( $CODE_type eq 'BL' ) {

                # Keep this blank? Start with the flag -kbl=n, where
                #   n=0 ignore all old blank lines
                #   n=1 stable: keep old blanks, but limited by -mbl=n
                #   n=2 keep all old blank lines, regardless of -mbl=n
                # If n=0 we delete all old blank lines and let blank line
                # rules generate any needed blank lines.
                my $kgb_keep = $rOpts_keep_old_blank_lines;

                # Then delete lines requested by the keyword-group logic if
                # allowed
                if (   $kgb_keep == 1
                    && defined( $rwant_blank_line_after->{$i} )
                    && $rwant_blank_line_after->{$i} == 2 )
                {
                    $kgb_keep = 0;
                }

                # But always keep a blank line following an =cut
                if ( $i - $i_last_POD_END < 3 && !$kgb_keep ) {
                    $kgb_keep = 1;
                }

                if ($kgb_keep) {
                    $self->flush($CODE_type);
                    $file_writer_object->write_blank_code_line(
                        $rOpts_keep_old_blank_lines == 2 );
                    $self->[_last_line_leading_type_] = 'b';
                }
                next;
            }
            else {

                # Let logger see all non-blank lines of code. This is a slow
                # operation so we avoid it if it is not going to be saved.
                if ( $save_logfile && $logger_object ) {

                    # get updated indentation levels
                    my $rK_range = $line_of_tokens->{_rK_range};
                    my ( $Kfirst, $Klast_uu ) = @{$rK_range};
                    if ( defined($Kfirst) ) {
                        my $level_0 = $self->[_radjusted_levels_]->[$Kfirst];
                        my $ci_level_0 =
                          $self->[_rLL_]->[$Kfirst]->[_CI_LEVEL_];
                        $line_of_tokens->{_level_0}    = $level_0;
                        $line_of_tokens->{_ci_level_0} = $ci_level_0;
                    }

                    $logger_object->black_box( $line_of_tokens,
                        $vertical_aligner_object->get_output_line_number() );
                }
            }

            # Handle Format Skipping (FS) and Verbatim (VB) Lines
            if ( $CODE_type eq 'VB' || $CODE_type eq 'FS' ) {
                $self->write_unindented_line($input_line);
                $file_writer_object->reset_consecutive_blank_lines();
                next;
            }

            # Handle all other lines of code
            $self->process_line_of_CODE($line_of_tokens);
        }

        # handle line of non-code..
        else {

            # set special flags
            my $skip_line = 0;
            if ( substr( $line_type, 0, 3 ) eq 'POD' ) {

                # Pod docs should have a preceding blank line.  But stay
                # out of __END__ and __DATA__ sections, because
                # the user may be using this section for any purpose whatsoever
                if ( $rOpts->{'delete-pod'} ) { $skip_line = 1; }
                if ( $rOpts->{'trim-pod'} ) {
                    chomp $input_line;
                    $input_line =~ s/\s+$//;
                    $input_line .= "\n";
                }
                if (   !$skip_line
                    && !$in_format_skipping_section
                    && $line_type eq 'POD_START'
                    && !$self->[_saw_END_or_DATA_] )
                {
                    $self->want_blank_line();
                }
            }

            # leave the blank counters in a predictable state
            # after __END__ or __DATA__
            elsif ( $line_type eq 'END_START' || $line_type eq 'DATA_START' ) {
                $file_writer_object->reset_consecutive_blank_lines();
                $self->[_saw_END_or_DATA_] = 1;
            }

            # Patch to avoid losing blank lines after a code-skipping block;
            # fixes case c047.
            elsif ( $line_type eq 'SKIP_END' ) {
                $file_writer_object->reset_consecutive_blank_lines();
            }
            else {
                ## some other line type
            }

            # write unindented non-code line
            if ( !$skip_line ) {
                $self->write_unindented_line($input_line);
            }
        }
    }
    return;

} ## end sub process_all_lines

{    ## closure keyword_group_scan

    # this is the return var
    my $rhash_of_desires;

    # user option variables for -kgb
    my (

        $rOpts_kgb_after,
        $rOpts_kgb_before,
        $rOpts_kgb_delete,
        $rOpts_kgb_inside,
        $rOpts_kgb_size_max,
        $rOpts_kgb_size_min,

    );

    # group variables, initialized by kgb_initialize_group_vars
    my ( $ibeg, $iend, $count, $level_beg, $K_closing );
    my ( @iblanks, @group, @subgroup );

    # line variables, updated by sub keyword_group_scan
    my ( $line_type, $CODE_type, $K_first, $K_last );
    my $number_of_groups_seen;

    #------------------------
    # -kgb helper subroutines
    #------------------------

    sub kgb_initialize_options {

        # check and initialize user options for -kgb
        # return error flag:
        #  true for some input error, do not continue
        #  false if ok

        # Local copies of the various control parameters
        $rOpts_kgb_after  = $rOpts->{'keyword-group-blanks-after'};    # '-kgba'
        $rOpts_kgb_before = $rOpts->{'keyword-group-blanks-before'};   # '-kgbb'
        $rOpts_kgb_delete = $rOpts->{'keyword-group-blanks-delete'};   # '-kgbd'
        $rOpts_kgb_inside = $rOpts->{'keyword-group-blanks-inside'};   # '-kgbi'

        # A range of sizes can be input with decimal notation like 'min.max'
        # with any number of dots between the two numbers. Examples:
        #    string    =>    min    max  matches
        #    1.1             1      1    exactly 1
        #    1.3             1      3    1,2, or 3
        #    1..3            1      3    1,2, or 3
        #    5               5      -    5 or more
        #    6.              6      -    6 or more
        #    .2              -      2    up to 2
        #    1.0             1      0    nothing
        my $rOpts_kgb_size = $rOpts->{'keyword-group-blanks-size'};    # '-kgbs'
        ( $rOpts_kgb_size_min, $rOpts_kgb_size_max ) = split /\.+/,
          $rOpts_kgb_size;
        if (   $rOpts_kgb_size_min && $rOpts_kgb_size_min !~ /^\d+$/
            || $rOpts_kgb_size_max && $rOpts_kgb_size_max !~ /^\d+$/ )
        {
            Warn(<<EOM);
Unexpected value for -kgbs: '$rOpts_kgb_size'; expecting 'min' or 'min.max';
ignoring all -kgb flags
EOM

            # Turn this option off so that this message does not keep repeating
            # during iterations and other files.
            $rOpts->{'keyword-group-blanks-size'} = EMPTY_STRING;
            return $rhash_of_desires;
        }
        $rOpts_kgb_size_min = 1 unless ($rOpts_kgb_size_min);

        if ( $rOpts_kgb_size_max && $rOpts_kgb_size_max < $rOpts_kgb_size_min )
        {
            return $rhash_of_desires;
        }

        # check codes for $rOpts_kgb_before and
        # $rOpts_kgb_after:
        #   0 = never (delete if exist)
        #   1 = stable (keep unchanged)
        #   2 = always (insert if missing)
        my $ok = $rOpts_kgb_size_min > 0
          && ( $rOpts_kgb_before != 1
            || $rOpts_kgb_after != 1
            || $rOpts_kgb_inside
            || $rOpts_kgb_delete );

        return $rhash_of_desires if ( !$ok );

        # The following parameter combination can be unstable (c302):
        if (   $rOpts_kgb_size_max
            && $rOpts_kgb_after == INSERT
            && $rOpts_kgb_before == DELETE )
        {
            # We reset kgb_before=STABLE to fix and continue
            $rOpts_kgb_before = STABLE;
        }

        return;
    } ## end sub kgb_initialize_options

    sub kgb_initialize_group_vars {

        # Definitions:
        #      $ibeg = first line index of this entire group
        #      $iend =  last line index of this entire group
        #     $count = total number of keywords seen in this entire group
        # $level_beg = indentation level of this group
        #     @group = [ $i, $token, $count ] =list of all keywords & blanks
        #  @subgroup =  $j, index of group where token changes
        #   @iblanks = line indexes of blank lines in input stream in this group
        #  where i=starting line index
        #        token (the keyword)
        #        count = number of this token in this subgroup
        #            j = index in group where token changes
        $ibeg      = -1;
        $iend      = undef;
        $level_beg = -1;
        $K_closing = undef;
        $count     = 0;
        @group     = ();
        @subgroup  = ();
        @iblanks   = ();
        return;
    } ## end sub kgb_initialize_group_vars

    sub kgb_initialize_line_vars {
        $CODE_type = EMPTY_STRING;
        $K_first   = undef;
        $K_last    = undef;
        $line_type = EMPTY_STRING;
        return;
    } ## end sub kgb_initialize_line_vars

    sub kgb_initialize {

        # initialize all closure variables for -kgb
        # return:
        #   true to cause immediate exit (something is wrong)
        #   false to continue ... all is okay

        # This is the return variable:
        $rhash_of_desires = {};

        # initialize and check user options;
        my $quit = kgb_initialize_options();
        if ($quit) { return $quit }

        # initialize variables for the current group and subgroups:
        kgb_initialize_group_vars();

        # initialize variables for the most recently seen line:
        kgb_initialize_line_vars();

        $number_of_groups_seen = 0;

        # all okay
        return;
    } ## end sub kgb_initialize

    sub kgb_insert_blank_after {

        my ($i) = @_;

        # Given:
        #   $i = line number after which blank is requested

        $rhash_of_desires->{$i} = 1;
        my $ip = $i + 1;
        if ( defined( $rhash_of_desires->{$ip} )
            && $rhash_of_desires->{$ip} == 2 )
        {
            $rhash_of_desires->{$ip} = 0;
        }
        return;
    } ## end sub kgb_insert_blank_after

    sub kgb_split_into_sub_groups {

        # place blanks around long sub-groups of keywords
        # ...if requested
        return unless ($rOpts_kgb_inside);

        # loop over sub-groups, index k
        push @subgroup, scalar(@group);
        my $kbeg = 1;
        my $kend = @subgroup - 1;
        foreach my $k ( $kbeg .. $kend ) {

            # index j runs through all keywords found
            my $j_b = $subgroup[ $k - 1 ];
            my $j_e = $subgroup[$k] - 1;

            # index i is the actual line number of a keyword
            my ( $i_b,    $tok_b_uu, $count_b ) = @{ $group[$j_b] };
            my ( $i_e_uu, $tok_e_uu, $count_e ) = @{ $group[$j_e] };
            my $num = $count_e - $count_b + 1;

            # This subgroup runs from line $ib to line $ie-1, but may contain
            # blank lines
            if ( $num >= $rOpts_kgb_size_min ) {

                # if there are blank lines, we require that at least $num lines
                # be non-blank up to the boundary with the next subgroup.
                my $nog_b = my $nog_e = 1;
                if ( @iblanks && !$rOpts_kgb_delete ) {
                    my $j_bb = $j_b + $num - 1;
                    my ( $i_bb_uu, $tok_bb_uu, $count_bb ) = @{ $group[$j_bb] };
                    $nog_b = $count_bb - $count_b + 1 == $num;

                    my $j_ee = $j_e - ( $num - 1 );
                    my ( $i_ee_uu, $tok_ee_uu, $count_ee ) = @{ $group[$j_ee] };
                    $nog_e = $count_e - $count_ee + 1 == $num;
                }
                if ( $nog_b && $k > $kbeg ) {
                    kgb_insert_blank_after( $i_b - 1 );
                }
                if ( $nog_e && $k < $kend ) {
                    my ( $i_ep, $tok_ep_uu, $count_ep_uu ) =
                      @{ $group[ $j_e + 1 ] };
                    kgb_insert_blank_after( $i_ep - 1 );
                }
            }
        }
        return;
    } ## end sub kgb_split_into_sub_groups

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

        # delete line $i if it is blank
        my $rlines = $self->[_rlines_];
        return if ( $i < 0 || $i >= @{$rlines} );
        return if ( $rlines->[$i]->{_line_type} ne 'CODE' );
        my $code_type = $rlines->[$i]->{_code_type};
        if ( $code_type eq 'BL' ) { $rhash_of_desires->{$i} = 2; }
        return;
    } ## end sub kgb_delete_if_blank

    sub kgb_delete_inner_blank_lines {

        # always remove unwanted trailing blank lines from our list
        return unless (@iblanks);
        while (@iblanks) {
            my $ibl = pop @iblanks;
            if ( $ibl < $iend ) { push @iblanks, $ibl; last }
            $iend = $ibl;
        }

        # now mark mark interior blank lines for deletion if requested
        return unless ($rOpts_kgb_delete);

        while (@iblanks) {
            my $ibl = pop @iblanks;
            $rhash_of_desires->{$ibl} = 2;
        }

        return;
    } ## end sub kgb_delete_inner_blank_lines

    sub kgb_end_group {

        my ( $self, ($bad_ending) ) = @_;

        # End a group of keywords

        # Given:
        #   $bad_ending = false if group ends ok
        #                 true  if group ends badly (strange pattern)

        if ( defined($ibeg) && $ibeg >= 0 ) {

            # then handle sufficiently large groups
            if ( $count >= $rOpts_kgb_size_min ) {

                $number_of_groups_seen++;

                # do any blank deletions regardless of the count
                kgb_delete_inner_blank_lines();

                my $rlines = $self->[_rlines_];
                if ( $ibeg > 0 ) {
                    my $code_type = $rlines->[ $ibeg - 1 ]->{_code_type};

                    # patch for hash bang line which is not currently marked as
                    # a comment; mark it as a comment
                    if ( $ibeg == 1 && !$code_type ) {
                        my $line_text = $rlines->[ $ibeg - 1 ]->{_line_text};
                        $code_type = 'BC'
                          if ( $line_text && $line_text =~ /^#/ );
                    }

                    # Do not insert a blank after a comment
                    # (this could be subject to a flag in the future)
                    if ( $code_type !~ /(?:BC|SBC|SBCX)/ ) {
                        if ( $rOpts_kgb_before == INSERT ) {
                            kgb_insert_blank_after( $ibeg - 1 );

                        }
                        elsif ( $rOpts_kgb_before == DELETE ) {
                            $self->kgb_delete_if_blank( $ibeg - 1 );
                        }
                        else {
                            ## == STABLE
                        }
                    }
                }

                # We will only put blanks before code lines. We could loosen
                # this rule a little, but we have to be very careful because
                # for example we certainly don't want to drop a blank line
                # after a line like this:
                #   my $var = <<EOM;
                if ( $line_type eq 'CODE' && defined($K_first) ) {

                    # - Do not put a blank before a line of different level
                    # - Do not put a blank line if we ended the search badly
                    # - Do not put a blank at the end of the file
                    # - Do not put a blank line before a hanging side comment
                    my $rLL      = $self->[_rLL_];
                    my $level    = $rLL->[$K_first]->[_LEVEL_];
                    my $ci_level = $rLL->[$K_first]->[_CI_LEVEL_];

                    if (   $level == $level_beg
                        && $ci_level == 0
                        && !$bad_ending
                        && $iend < @{$rlines}
                        && $CODE_type ne 'HSC' )
                    {
                        if ( $rOpts_kgb_after == INSERT ) {
                            kgb_insert_blank_after($iend);
                        }
                        elsif ( $rOpts_kgb_after == DELETE ) {
                            $self->kgb_delete_if_blank( $iend + 1 );
                        }
                        else {
                            ## == STABLE
                        }
                    }
                }
            }
            kgb_split_into_sub_groups();
        }

        # reset for another group
        kgb_initialize_group_vars();

        return;
    } ## end sub kgb_end_group

    sub kgb_find_container_end {

        my ($self) = @_;

        # If the keyword line is continued onto subsequent lines, find the
        # closing token '$K_closing' so that we can easily skip past the
        # contents of the container.

        # We only set this value if we find a simple list, meaning
        # -contents only one level deep
        # -not welded

        # First check: skip if next line is not one deeper
        my $Knext_nonblank = $self->K_next_nonblank($K_last);
        return if ( !defined($Knext_nonblank) );
        my $rLL        = $self->[_rLL_];
        my $level_next = $rLL->[$Knext_nonblank]->[_LEVEL_];
        return if ( $level_next != $level_beg + 1 );

        # Find the parent container of the first token on the next line
        my $parent_seqno = $self->parent_seqno_by_K($Knext_nonblank);
        return unless ( defined($parent_seqno) );

        # Must not be a weld (can be unstable)
        return
          if ( $total_weld_count
            && $self->is_welded_at_seqno($parent_seqno) );

        # Opening container must exist and be on this line
        my $Ko = $self->[_K_opening_container_]->{$parent_seqno};
        return if ( !defined($Ko) || $Ko <= $K_first || $Ko > $K_last );

        # Verify that the closing container exists and is on a later line
        my $Kc = $self->[_K_closing_container_]->{$parent_seqno};
        return if ( !defined($Kc) || $Kc <= $K_last );

        # That's it
        $K_closing = $Kc;

        return;
    } ## end sub kgb_find_container_end

    sub kgb_add_to_group {

        my ( $self, $i, $token, $level ) = @_;

        # End the previous group if we have reached the maximum
        # group size
        if ( $rOpts_kgb_size_max && @group >= $rOpts_kgb_size_max ) {
            $self->kgb_end_group();
        }

        if ( @group == 0 ) {
            $ibeg      = $i;
            $level_beg = $level;
            $count     = 0;
        }

        $count++;
        $iend = $i;

        # New sub-group?
        if ( !@group || $token ne $group[-1]->[1] ) {
            push @subgroup, scalar(@group);
        }
        push @group, [ $i, $token, $count ];

        # remember if this line ends in an open container
        $self->kgb_find_container_end();

        return;
    } ## end sub kgb_add_to_group

    sub keyword_group_scan {

        my $self = shift;

        # Called once per file to process --keyword-group-blanks-* parameters.
        # This is the main subroutine for the -kgb option

        # Task:
        # Manipulate blank lines around keyword groups (kgb* flags)
        # Scan all lines looking for runs of consecutive lines beginning with
        # selected keywords.  Example keywords are 'my', 'our', 'local', ... but
        # they may be anything.  We will set flags requesting that blanks be
        # inserted around and within them according to input parameters.  Note
        # that we are scanning the lines as they came in in the input stream, so
        # they are not necessarily well formatted.

        # Returns:
        # The output of this sub is a return hash ref whose keys are the indexes
        # of lines after which we desire a blank line.  For line index $i:
        #  $rhash_of_desires->{$i} = 1 means we want a blank line AFTER line $i
        #  $rhash_of_desires->{$i} = 2 means we want blank line $i removed

        # Nothing to do if no blanks can be output. This test added to fix
        # case b760.
        if ( !$rOpts_maximum_consecutive_blank_lines ) {
            return $rhash_of_desires;
        }

        #---------------
        # initialization
        #---------------
        my $quit = kgb_initialize();
        if ($quit) { return $rhash_of_desires }

        my $rLL    = $self->[_rLL_];
        my $rlines = $self->[_rlines_];

        $self->kgb_end_group();
        my $i = -1;
        my $Opt_repeat_count =
          $rOpts->{'keyword-group-blanks-repeat-count'};    # '-kgbr'

        #----------------------------------
        # loop over all lines of the source
        #----------------------------------
        foreach my $line_of_tokens ( @{$rlines} ) {

            $i++;
            last
              if ( $Opt_repeat_count > 0
                && $number_of_groups_seen >= $Opt_repeat_count );

            kgb_initialize_line_vars();

            $line_type = $line_of_tokens->{_line_type};

            # always end a group at non-CODE
            if ( $line_type ne 'CODE' ) { $self->kgb_end_group(); next }

            $CODE_type = $line_of_tokens->{_code_type};

            # end any group at a format skipping line
            if ( $CODE_type && $CODE_type eq 'FS' ) {
                $self->kgb_end_group();
                next;
            }

            # continue in a verbatim (VB) type; it may be quoted text
            if ( $CODE_type eq 'VB' ) {
                if ( $ibeg >= 0 ) { $iend = $i; }
                next;
            }

            # and continue in blank (BL) types
            if ( $CODE_type eq 'BL' ) {
                if ( $ibeg >= 0 ) {
                    $iend = $i;
                    push @iblanks, $i;

                    # propagate current subgroup token
                    my $tok = $group[-1]->[1];
                    push @group, [ $i, $tok, $count ];
                }
                next;
            }

            # examine the first token of this line
            my $rK_range = $line_of_tokens->{_rK_range};
            ( $K_first, $K_last ) = @{$rK_range};
            if ( !defined($K_first) ) {

                # Somewhat unexpected blank line..
                # $rK_range is normally defined for line type CODE, but this can
                # happen for example if the input line was a single semicolon
                # which is being deleted.  In that case there was code in the
                # input file but it is not being retained. So we can silently
                # return.
                return $rhash_of_desires;
            }

            my $level    = $rLL->[$K_first]->[_LEVEL_];
            my $type     = $rLL->[$K_first]->[_TYPE_];
            my $token    = $rLL->[$K_first]->[_TOKEN_];
            my $ci_level = $rLL->[$K_first]->[_CI_LEVEL_];

            # End a group 'badly' at an unexpected level.  This will prevent
            # blank lines being incorrectly placed after the end of the group.
            # We are looking for any deviation from two acceptable patterns:
            #   PATTERN 1: a simple list; secondary lines are at level+1
            #   PATTERN 2: a long statement; all secondary lines same level
            # This was added as a fix for case b1177, in which a complex
            # structure got incorrectly inserted blank lines.
            if ( $ibeg >= 0 ) {

                # Check for deviation from PATTERN 1, simple list:
                if ( defined($K_closing) && $K_first < $K_closing ) {
                    $self->kgb_end_group(1) if ( $level != $level_beg + 1 );
                }

                # Check for deviation from PATTERN 2, single statement:
                elsif ( $level != $level_beg ) { $self->kgb_end_group(1) }
                else {
                    ## no deviation
                }
            }

            # Do not look for keywords in lists ( keyword 'my' can occur in
            # lists, see case b760); fixed for c048.
            # Switch from ->is_list_by_K to !->is_in_block_by_K to fix b1464
            if ( !$self->is_in_block_by_K($K_first) ) {
                if ( $ibeg >= 0 ) { $iend = $i }
                next;
            }

            # see if this is a code type we seek (i.e. comment)
            if (   $CODE_type
                && $keyword_group_list_comment_pattern
                && $CODE_type =~ /$keyword_group_list_comment_pattern/ )
            {

                my $tok = $CODE_type;

                # Continuing a group
                if ( $ibeg >= 0 && $level == $level_beg ) {
                    $self->kgb_add_to_group( $i, $tok, $level );
                }

                # Start new group
                else {

                    # first end old group if any; we might be starting new
                    # keywords at different level
                    if ( $ibeg >= 0 ) { $self->kgb_end_group(); }
                    $self->kgb_add_to_group( $i, $tok, $level );
                }
                next;
            }

            # See if it is a keyword we seek, but never start a group in a
            # continuation line; the code may be badly formatted.
            if (   $ci_level == 0
                && $type eq 'k'
                && $token =~ /$keyword_group_list_pattern/ )
            {

                # Continuing a keyword group
                if ( $ibeg >= 0 && $level == $level_beg ) {
                    $self->kgb_add_to_group( $i, $token, $level );
                }

                # Start new keyword group
                else {

                    # first end old group if any; we might be starting new
                    # keywords at different level
                    if ( $ibeg >= 0 ) { $self->kgb_end_group(); }
                    $self->kgb_add_to_group( $i, $token, $level );
                }
                next;
            }

            # This is not one of our keywords, but we are in a keyword group
            # so see if we should continue or quit
            elsif ( $ibeg >= 0 ) {

                # - bail out on a large level change; we may have walked into a
                #   data structure or anonymous sub code.
                if ( $level > $level_beg + 1 || $level < $level_beg ) {
                    $self->kgb_end_group(1);
                    next;
                }

                # - keep going on a continuation line of the same level, since
                #   it is probably a continuation of our previous keyword,
                # - and keep going past hanging side comments because we never
                #   want to interrupt them.
                if ( ( ( $level == $level_beg ) && $ci_level > 0 )
                    || $CODE_type eq 'HSC' )
                {
                    $iend = $i;
                    next;
                }

                # - continue if if we are within in a container which started
                # with the line of the previous keyword.
                if ( defined($K_closing) && $K_first <= $K_closing ) {

                    # continue if entire line is within container
                    if ( $K_last <= $K_closing ) { $iend = $i; next }

                    # continue at ); or }; or ];
                    my $KK = $K_closing + 1;
                    if ( $rLL->[$KK]->[_TYPE_] eq ';' ) {
                        if ( $KK < $K_last ) {
                            if ( $rLL->[ ++$KK ]->[_TYPE_] eq 'b' ) { ++$KK }
                            if ( $KK > $K_last || $rLL->[$KK]->[_TYPE_] ne '#' )
                            {
                                $self->kgb_end_group(1);
                                next;
                            }
                        }
                        $iend = $i;
                        next;
                    }

                    $self->kgb_end_group(1);
                    next;
                }

                # - end the group if none of the above
                $self->kgb_end_group();
                next;
            }

            # not in a keyword group; continue
            else { next }
        } ## end of loop over all lines

        $self->kgb_end_group();
        return $rhash_of_desires;

    } ## end sub keyword_group_scan
} ## end closure keyword_group_scan

#######################################
# CODE SECTION 7: Process lines of code
#######################################

{    ## begin closure process_line_of_CODE

    # The routines in this closure receive lines of code and combine them into
    # 'batches' and send them along. A 'batch' is the unit of code which can be
    # processed further as a unit. It has the property that it is the largest
    # amount of code into which which perltidy is free to place one or more
    # line breaks within it without violating any constraints.

    # When a new batch is formed it is sent to sub 'grind_batch_of_code'.

    # flags needed by the store routine
    my $line_of_tokens;
    my $no_internal_newlines;
    my $CODE_type;
    my $current_line_starts_in_quote;

    # range of K of tokens for the current line
    my ( $K_first, $K_last );

    my ( $rLL, $radjusted_levels, $rparent_of_seqno, $rdepth_of_opening_seqno,
        $rblock_type_of_seqno, $ri_starting_one_line_block );

    # past stored nonblank tokens and flags
    my (
        $K_last_nonblank_code,       $K_dangling_elsif,
        $is_static_block_comment,    $last_CODE_type,
        $last_line_had_side_comment, $next_parent_seqno,
        $next_slevel,
    );

    # Called once at the start of a new file
    sub initialize_process_line_of_CODE {
        $K_last_nonblank_code       = undef;
        $K_dangling_elsif           = 0;
        $is_static_block_comment    = 0;
        $last_line_had_side_comment = 0;
        $next_parent_seqno          = SEQ_ROOT;
        $next_slevel                = undef;
        return;
    } ## end sub initialize_process_line_of_CODE

    # Batch variables: these describe the current batch of code being formed
    # and sent down the pipeline.  They are initialized in the next
    # sub.
    my (
        $rbrace_follower,   $index_start_one_line_block,
        $starting_in_quote, $ending_in_quote,
    );

    # Called before the start of each new batch
    sub initialize_batch_variables {

        # Initialize array values for a new batch.  Any changes here must be
        # carefully coordinated with sub store_token_to_go.

        $max_index_to_go            = UNDEFINED_INDEX;
        $summed_lengths_to_go[0]    = 0;
        $nesting_depth_to_go[0]     = 0;
        $ri_starting_one_line_block = [];

        # Redefine some sparse arrays.
        # It is more efficient to redefine these sparse arrays and rely on
        # undef's instead of initializing to 0's.  Testing showed that using
        # @array=() is more efficient than $#array=-1

        @old_breakpoint_to_go    = ();
        @forced_breakpoint_to_go = ();
        @block_type_to_go        = ();
        @mate_index_to_go        = ();
        @type_sequence_to_go     = ();

        # NOTE: @nobreak_to_go is sparse and could be treated this way, but
        # testing showed that there would be very little efficiency gain
        # because an 'if' test must be added in store_token_to_go.

        # The initialization code for the remaining batch arrays is as follows
        # and can be activated for testing.  But profiling shows that it is
        # time-consuming to re-initialize the batch arrays and is not necessary
        # because the maximum valid token, $max_index_to_go, is carefully
        # controlled.  This means however that it is not possible to do any
        # type of filter or map operation directly on these arrays.  And it is
        # not possible to use negative indexes. As a precaution against program
        # changes which might do this, sub pad_array_to_go adds some undefs at
        # the end of the current batch of data.

        ## 0 && do { #<<<
        ## @nobreak_to_go           = ();
        ## @token_lengths_to_go     = ();
        ## @levels_to_go            = ();
        ## @ci_levels_to_go         = ();
        ## @tokens_to_go            = ();
        ## @K_to_go                 = ();
        ## @types_to_go             = ();
        ## @leading_spaces_to_go    = ();
        ## @reduced_spaces_to_go    = ();
        ## @inext_to_go             = ();
        ## @parent_seqno_to_go      = ();
        ## };

        $rbrace_follower = undef;
        $ending_in_quote = 0;

        $index_start_one_line_block = undef;

        # initialize forced breakpoint vars associated with each output batch
        $forced_breakpoint_count      = 0;
        $index_max_forced_break       = UNDEFINED_INDEX;
        $forced_breakpoint_undo_count = 0;

        return;
    } ## end sub initialize_batch_variables

    sub leading_spaces_to_go {

        my ($ii) = @_;

        # Return the number of indentation spaces for token at index $ii
        # in the output stream

        return 0 if ( $ii < 0 );
        my $indentation = $leading_spaces_to_go[$ii];
        return ref($indentation) ? $indentation->get_spaces() : $indentation;
    } ## end sub leading_spaces_to_go

    sub create_one_line_block {

        # note that this updates a closure variable
        $index_start_one_line_block = shift;

        # Set index starting next one-line block
        # Given:
        #   $index_start_one_line_block = starting index in _to_go array
        #   undef => end current one-line block
        #
        # call with no args to delete the current one-line block
        return;
    } ## end sub create_one_line_block

    # Routine to place the current token into the output stream.
    # Called once per output token.

    use constant DEBUG_STORE => 0;

    sub store_token_to_go {

        my ( $self, $Ktoken_vars, $rtoken_vars ) = @_;

        #-------------------------------------------------------
        # Token storage utility for sub process_line_of_CODE.
        # Add one token to the next batch of '_to_go' variables.
        #-------------------------------------------------------

        # Input parameters:
        #   $Ktoken_vars = the index K in the global token array
        #   $rtoken_vars = $rLL->[$Ktoken_vars] = the corresponding token values
        #                  unless they are temporarily being overridden

        #------------------------------------------------------------------
        # NOTE: called once per token so coding efficiency is critical here.
        # All changes need to be benchmarked with Devel::NYTProf.
        #------------------------------------------------------------------

        my (

            $type,
            $token,
            $ci_level,
            $level,
            $seqno,
            $length,

          ) = @{$rtoken_vars}[

          _TYPE_,
          _TOKEN_,
          _CI_LEVEL_,
          _LEVEL_,
          _TYPE_SEQUENCE_,
          _TOKEN_LENGTH_,

          ];

        # Check for emergency flush...
        # The K indexes in the batch must always be a continuous sequence of
        # the global token array.  The batch process programming assumes this.
        # If storing this token would cause this relation to fail we must dump
        # the current batch before storing the new token.  It is extremely rare
        # for this to happen. One known example is the following two-line
        # snippet when run with parameters
        # --noadd-newlines  --space-terminal-semicolon:
        #    if ( $_ =~ /PENCIL/ ) { $pencil_flag= 1 } ; ;
        #    $yy=1;
        if ( $max_index_to_go >= 0 ) {
            if ( $Ktoken_vars != $K_to_go[$max_index_to_go] + 1 ) {
                $self->flush_batch_of_CODE();
            }

            # Do not output consecutive blank tokens ... this should not
            # happen, but it is worth checking.  Later code can then make the
            # simplifying assumption that blank tokens are not consecutive.
            elsif ( $type eq 'b' && $types_to_go[$max_index_to_go] eq 'b' ) {

                if (DEVEL_MODE) {

                    # if this happens, it is may be that consecutive blanks
                    # were inserted into the token stream in 'respace_tokens'
                    my $lno = $rLL->[$Ktoken_vars]->[_LINE_INDEX_] + 1;
                    Fault("consecutive blanks near line $lno; please fix");
                }
                return;
            }
            else {
                ## all ok
            }
        }

        # Do not start a batch with a blank token.
        # Fixes cases b149 b888 b984 b985 b986 b987
        else {
            if ( $type eq 'b' ) { return }
        }

        # Update counter and do initializations if first token of new batch
        if ( !++$max_index_to_go ) {

            # Reset flag '$starting_in_quote' for a new batch.  It must be set
            # to the value of '$in_continued_quote', but here for efficiency we
            # set it to zero, which is its normal value. Then in coding below
            # we will change it if we find we are actually in a continued quote.
            $starting_in_quote = 0;

            # Update the next parent sequence number for each new batch.

            #----------------------------------------
            # Begin coding from sub parent_seqno_by_K
            #----------------------------------------

            # The following is equivalent to this call but much faster:
            #    $next_parent_seqno = $self->parent_seqno_by_K($Ktoken_vars);

            $next_parent_seqno = SEQ_ROOT;
            if ($seqno) {
                $next_parent_seqno = $rparent_of_seqno->{$seqno};
            }
            else {
                my $Kt = $self->[_rK_next_seqno_by_K_]->[$Ktoken_vars];
                if ( defined($Kt) ) {

                    # if next container token is closing, it is the parent seqno
                    if ( $is_closing_type{ $rLL->[$Kt]->[_TYPE_] } ) {
                        $next_parent_seqno = $rLL->[$Kt]->[_TYPE_SEQUENCE_];
                    }

                    # otherwise we want its parent container
                    else {
                        $next_parent_seqno =
                          $rparent_of_seqno->{ $rLL->[$Kt]->[_TYPE_SEQUENCE_] };
                    }
                }
            }
            $next_parent_seqno = SEQ_ROOT
              if ( !defined($next_parent_seqno) );

            #--------------------------------------
            # End coding from sub parent_seqno_by_K
            #--------------------------------------

            $next_slevel = $rdepth_of_opening_seqno->[$next_parent_seqno] + 1;
        }

        # Safety check that length is defined. This is slow and should not be
        # needed now, so just do it in DEVEL_MODE to check programming changes.
        # Formerly needed for --indent-only, in which the entire set of tokens
        # is normally turned into type 'q'. Lengths are now defined in sub
        # 'respace_tokens' so this check is no longer needed.
        if ( DEVEL_MODE && !defined($length) ) {
            my $lno = $rLL->[$Ktoken_vars]->[_LINE_INDEX_] + 1;
            $length = length($token);
            Fault(<<EOM);
undefined length near line $lno; num chars=$length, token='$token'
EOM
        }

        #----------------------------
        # add this token to the batch
        #----------------------------
        $K_to_go[$max_index_to_go]             = $Ktoken_vars;
        $types_to_go[$max_index_to_go]         = $type;
        $tokens_to_go[$max_index_to_go]        = $token;
        $ci_levels_to_go[$max_index_to_go]     = $ci_level;
        $levels_to_go[$max_index_to_go]        = $level;
        $nobreak_to_go[$max_index_to_go]       = $no_internal_newlines;
        $token_lengths_to_go[$max_index_to_go] = $length;

        # Skip point initialization for these sparse arrays - undef's okay;
        # See also related code in sub initialize_batch_variables.
        ## $old_breakpoint_to_go[$max_index_to_go]    = 0;
        ## $forced_breakpoint_to_go[$max_index_to_go] = 0;
        ## $block_type_to_go[$max_index_to_go]        = EMPTY_STRING;
        ## $type_sequence_to_go[$max_index_to_go]     = $seqno;

        # NOTE:  nobreak_to_go can be treated as a sparse array, but testing
        # showed that there is almost no efficiency gain because an if test
        # would need to be added.

        # We keep a running sum of token lengths from the start of this batch:
        #   summed_lengths_to_go[$i]   = total length to just before token $i
        #   summed_lengths_to_go[$i+1] = total length to just after token $i
        $summed_lengths_to_go[ $max_index_to_go + 1 ] =
          $summed_lengths_to_go[$max_index_to_go] + $length;

        # Initialize some sequence-dependent variables to their normal values
        $parent_seqno_to_go[$max_index_to_go]  = $next_parent_seqno;
        $nesting_depth_to_go[$max_index_to_go] = $next_slevel;

        # Then fix them at container tokens:
        if ($seqno) {

            $type_sequence_to_go[$max_index_to_go] = $seqno;

            $block_type_to_go[$max_index_to_go] =
              $rblock_type_of_seqno->{$seqno};

            if ( $is_opening_token{$token} ) {

                my $slevel = $rdepth_of_opening_seqno->[$seqno];
                $nesting_depth_to_go[$max_index_to_go] = $slevel;
                $next_slevel = $slevel + 1;

                $next_parent_seqno = $seqno;

            }
            elsif ( $is_closing_token{$token} ) {

                $next_slevel = $rdepth_of_opening_seqno->[$seqno];
                my $slevel = $next_slevel + 1;
                $nesting_depth_to_go[$max_index_to_go] = $slevel;

                my $parent_seqno = $rparent_of_seqno->{$seqno};
                $parent_seqno = SEQ_ROOT unless defined($parent_seqno);
                $parent_seqno_to_go[$max_index_to_go] = $parent_seqno;
                $next_parent_seqno                    = $parent_seqno;

            }
            else {
                # ternary token: nothing to do
            }
        }

        # Define the indentation that this token will have in two cases:
        # Without CI = reduced_spaces_to_go
        # With CI    = leading_spaces_to_go
        $leading_spaces_to_go[$max_index_to_go] =
          $reduced_spaces_to_go[$max_index_to_go] =
          $rOpts_indent_columns * $radjusted_levels->[$Ktoken_vars];
        if ($ci_level) {
            $leading_spaces_to_go[$max_index_to_go] +=
              $rOpts_continuation_indentation;
        }

        # Correct these values if we are starting in a continued quote
        if (   $current_line_starts_in_quote
            && $Ktoken_vars == $K_first )
        {
            # in a continued quote - correct value set above if first token
            if ( $max_index_to_go == 0 ) { $starting_in_quote = 1 }

            $leading_spaces_to_go[$max_index_to_go] = 0;
            $reduced_spaces_to_go[$max_index_to_go] = 0;
        }

        DEBUG_STORE && do {
            my ( $pkg, $file_uu, $lno ) = caller();
            print {*STDOUT}
"STORE: from $pkg $lno: storing token $token type $type lev=$level at $max_index_to_go\n";
        };
        return;
    } ## end sub store_token_to_go

    sub flush_batch_of_CODE {

        my ($self) = @_;

        # Finish and process the current batch.
        # This must be the only call to grind_batch_of_CODE()

        return if ( $max_index_to_go < 0 );

        # Create an array to hold variables for this batch
        my $this_batch = $self->[_this_batch_] = [];

        $this_batch->[_starting_in_quote_] = 1 if ($starting_in_quote);
        $this_batch->[_ending_in_quote_]   = 1 if ($ending_in_quote);

        if ( $CODE_type || $last_CODE_type ) {
            $this_batch->[_batch_CODE_type_] =
                $K_to_go[$max_index_to_go] >= $K_first
              ? $CODE_type
              : $last_CODE_type;
        }

        $last_line_had_side_comment =
          ( $max_index_to_go > 0 && $types_to_go[$max_index_to_go] eq '#' );

        # The flag $is_static_block_comment applies to the line which just
        # arrived. So it only applies if we are outputting that line.
        if ( $is_static_block_comment && !$last_line_had_side_comment ) {
            $this_batch->[_is_static_block_comment_] = $K_to_go[0] == $K_first;
        }

        $this_batch->[_ri_starting_one_line_block_] =
          $ri_starting_one_line_block;

        #-------------------
        # process this batch
        #-------------------
        $self->grind_batch_of_CODE();

        # Done .. this batch is history
        initialize_batch_variables();

        return;
    } ## end sub flush_batch_of_CODE

    sub end_batch {

        # End the current batch, EXCEPT for a few special cases
        my ($self) = @_;

        if ( $max_index_to_go < 0 ) {

            # nothing to do .. this is harmless but wastes time.
            if (DEVEL_MODE) {
                Fault("sub end_batch called with nothing to do; please fix\n");
            }
            return;
        }

        # Exceptions when a line does not end with a comment... (fixes c058)
        if ( $types_to_go[$max_index_to_go] ne '#' ) {

            # Exception 1: Do not end line in a weld
            return
              if ( $total_weld_count
                && $self->[_rK_weld_right_]->{ $K_to_go[$max_index_to_go] } );

            # Exception 2: just set a tentative breakpoint if we might be in a
            # one-line block
            if ( defined($index_start_one_line_block) ) {
                $self->set_forced_breakpoint($max_index_to_go);
                return;
            }
        }

        $self->flush_batch_of_CODE();
        return;
    } ## end sub end_batch

    sub flush_vertical_aligner {
        my ($self) = @_;
        my $vao = $self->[_vertical_aligner_object_];
        $vao->flush();
        return;
    } ## end sub flush_vertical_aligner

    sub flush {
        my ( $self, ($CODE_type_flush) ) = @_;

        # Sub flush is called to output any tokens in the pipeline, so that
        # an alternate source of lines can be written in the correct order
        # Optional parameter:
        #   $CODE_type_flush = 'BL' for flushing to insert a blank line

        $index_start_one_line_block = undef;

        # End the current batch, if it holds any tokens, with 1 exception
        if ( $max_index_to_go >= 0 ) {

            # Exception: if we are flushing within the code stream only to
            # insert blank line(s), then we can keep the batch intact at a
            # weld. This improves formatting of -ce.  See test 'ce1.ce'
            if ( $CODE_type_flush && $CODE_type_flush eq 'BL' ) {
                $self->end_batch();
            }

            # otherwise, we have to shut things down completely.
            else { $self->flush_batch_of_CODE() }
        }

        $self->flush_vertical_aligner();
        return;
    } ## end sub flush

    my %is_assignment_or_fat_comma;

    BEGIN {
        %is_assignment_or_fat_comma = %is_assignment;
        $is_assignment_or_fat_comma{'=>'} = 1;
    }

    sub add_missing_else {

        my ($self) = @_;

        # Add a missing 'else' block.
        # $K_dangling_elsif = index of closing elsif brace not followed by else

        # Make sure everything looks okay
        if (  !$K_dangling_elsif
            || $K_dangling_elsif < $K_first
            || $rLL->[$K_dangling_elsif]->[_TYPE_] ne '}' )
        {
            DEVEL_MODE && Fault("could not find closing elsif brace\n");
        }

        my $comment = $rOpts->{'add-missing-else-comment'};

        # Safety check
        if ( substr( $comment, 0, 1 ) ne '#' ) { $comment = '#' . $comment }

        # Calculate indentation
        my $level  = $radjusted_levels->[$K_dangling_elsif];
        my $spaces = SPACE x ( $level * $rOpts_indent_columns );
        my $line1  = $spaces . "else {\n";
        my $line3  = $spaces . "}\n";
        $spaces .= SPACE x $rOpts_indent_columns;
        my $line2 = $spaces . $comment . "\n";

        # clear the output pipeline
        $self->flush();

        my $file_writer_object = $self->[_file_writer_object_];

        $file_writer_object->write_code_line($line1);
        $file_writer_object->write_code_line($line2);
        $file_writer_object->write_code_line($line3);
        return;
    } ## end sub add_missing_else

    sub process_line_of_CODE {

        my ( $self, $my_line_of_tokens ) = @_;

        #----------------------------------------------------------------
        # This routine is called once per INPUT line to format all of the
        # tokens on that line.
        #----------------------------------------------------------------

        # It outputs full-line comments and blank lines immediately.

        # For lines of code:
        # - Tokens are copied one-by-one from the global token
        #   array $rLL to a set of '_to_go' arrays which collect batches of
        #   tokens. This is done with calls to 'store_token_to_go'.
        # - A batch is closed and processed upon reaching a well defined
        #   structural break point (i.e. code block boundary) or forced
        #   breakpoint (i.e. side comment or special user controls).
        # - Subsequent stages of formatting make additional line breaks
        #   appropriate for lists and logical structures, and as necessary to
        #   keep line lengths below the requested maximum line length.

        #-----------------------------------
        # begin initialize closure variables
        #-----------------------------------
        $line_of_tokens = $my_line_of_tokens;
        my $rK_range = $line_of_tokens->{_rK_range};
        if ( !defined( $rK_range->[0] ) ) {

            # Empty line: This can happen if tokens are deleted, for example
            # with the -mangle parameter
            return;
        }

        ( $K_first, $K_last ) = @{$rK_range};
        $last_CODE_type               = $CODE_type;
        $CODE_type                    = $line_of_tokens->{_code_type};
        $current_line_starts_in_quote = $line_of_tokens->{_starting_in_quote};

        $rLL                     = $self->[_rLL_];
        $radjusted_levels        = $self->[_radjusted_levels_];
        $rparent_of_seqno        = $self->[_rparent_of_seqno_];
        $rdepth_of_opening_seqno = $self->[_rdepth_of_opening_seqno_];
        $rblock_type_of_seqno    = $self->[_rblock_type_of_seqno_];

        #---------------------------------
        # end initialize closure variables
        #---------------------------------

        # This flag will become nobreak_to_go and should be set to 2 to prevent
        # a line break AFTER the current token.
        $no_internal_newlines = 0;
        if ( !$rOpts_add_newlines || $CODE_type eq 'NIN' ) {
            $no_internal_newlines = 2;
        }

        my $input_line = $line_of_tokens->{_line_text};

        my ( $is_block_comment, $has_side_comment );
        if ( $rLL->[$K_last]->[_TYPE_] eq '#' ) {
            if ( $K_last == $K_first && $CODE_type ne 'HSC' ) {
                $is_block_comment = 1;
            }
            else { $has_side_comment = 1 }
        }

        my $is_static_block_comment_without_leading_space =
          $CODE_type eq 'SBCX';
        $is_static_block_comment =
          $CODE_type eq 'SBC' || $is_static_block_comment_without_leading_space;

        # check for a $VERSION statement
        if ( $CODE_type eq 'VER' ) {
            $self->[_saw_VERSION_in_this_file_] = 1;
            $no_internal_newlines = 2;
        }

        # Add interline blank if any
        my $last_old_nonblank_type   = "b";
        my $first_new_nonblank_token = EMPTY_STRING;
        my $K_first_true             = $K_first;
        if ( $max_index_to_go >= 0 ) {
            $last_old_nonblank_type   = $types_to_go[$max_index_to_go];
            $first_new_nonblank_token = $rLL->[$K_first]->[_TOKEN_];
            if (  !$is_block_comment
                && $types_to_go[$max_index_to_go] ne 'b'
                && $K_first > 0
                && $rLL->[ $K_first - 1 ]->[_TYPE_] eq 'b' )
            {
                $K_first -= 1;
            }
        }

        my $rtok_first = $rLL->[$K_first];

        my $in_quote = $line_of_tokens->{_ending_in_quote};
        $ending_in_quote = $in_quote;

        #------------------------------------
        # Handle a block (full-line) comment.
        #------------------------------------
        if ($is_block_comment) {

            if ( $rOpts->{'delete-block-comments'} ) {
                $self->flush();
                return;
            }

            $index_start_one_line_block = undef;
            $self->end_batch() if ( $max_index_to_go >= 0 );

            # output a blank line before block comments
            if (
                # unless we follow a blank or comment line
                $self->[_last_line_leading_type_] ne '#'
                && $self->[_last_line_leading_type_] ne 'b'

                # only if allowed
                && $rOpts->{'blanks-before-comments'}

                # if this is NOT an empty comment, unless it follows a side
                # comment and could become a hanging side comment.
                && (
                    $rtok_first->[_TOKEN_] ne '#'
                    || (   $last_line_had_side_comment
                        && $rLL->[$K_first]->[_LEVEL_] > 0 )
                )

                # not after a short line ending in an opening token
                # because we already have space above this comment.
                # Note that the first comment in this if block, after
                # the 'if (', does not get a blank line because of this.
                && !$self->[_last_output_short_opening_token_]

                # never before static block comments
                && !$is_static_block_comment
              )
            {
                $self->flush();    # switching to new output stream
                my $file_writer_object = $self->[_file_writer_object_];
                $file_writer_object->write_blank_code_line();
                $self->[_last_line_leading_type_] = 'b';
            }

            if (
                $rOpts->{'indent-block-comments'}
                && (  !$rOpts->{'indent-spaced-block-comments'}
                    || $input_line =~ /^\s+/ )
                && !$is_static_block_comment_without_leading_space
              )
            {
                my $Ktoken_vars = $K_first;
                my $rtoken_vars = $rLL->[$Ktoken_vars];
                $self->store_token_to_go( $Ktoken_vars, $rtoken_vars );
                $self->end_batch();
            }
            else {

                # switching to new output stream
                $self->flush();

                # Note that last arg in call here is 'undef' for comments
                my $file_writer_object = $self->[_file_writer_object_];
                $file_writer_object->write_code_line(
                    $rtok_first->[_TOKEN_] . "\n", undef );
                $self->[_last_line_leading_type_] = '#';
            }
            return;
        }

        #--------------------------------------------
        # Compare input/output indentation in logfile
        #--------------------------------------------
        if ( $self->[_save_logfile_] ) {

            my $guessed_indentation_level =
              $line_of_tokens->{_guessed_indentation_level};

            # Compare input/output indentation except for:
            #  - hanging side comments
            #  - continuation lines (have unknown leading blank space)
            #  - and lines which are quotes (they may have been outdented)
            my $exception =
                 $CODE_type eq 'HSC'
              || $rtok_first->[_CI_LEVEL_] > 0
              || $guessed_indentation_level == 0
              && $rtok_first->[_TYPE_] eq 'Q';

            if ( !$exception ) {
                my $input_line_number = $line_of_tokens->{_line_number};
                $self->compare_indentation_levels( $K_first,
                    $guessed_indentation_level, $input_line_number );
            }
        }

        #-----------------------------------------
        # Handle a line marked as indentation-only
        #-----------------------------------------

        if ( $CODE_type eq 'IO' ) {
            $self->flush();
            my $line = $input_line;

            # Fix for rt #125506 Unexpected string formatting
            # in which leading space of a terminal quote was removed
            $line =~ s/\s+$//;
            $line =~ s/^\s+// unless ( $line_of_tokens->{_starting_in_quote} );

            my $Ktoken_vars = $K_first;

            # We work with a copy of the token variables and change the
            # first token to be the entire line as a quote variable
            my $rtoken_vars = $rLL->[$Ktoken_vars];
            $rtoken_vars = copy_token_as_type( $rtoken_vars, 'q', $line );

            # Patch: length is not really important here but must be defined
            $rtoken_vars->[_TOKEN_LENGTH_] = length($line);

            $self->store_token_to_go( $Ktoken_vars, $rtoken_vars );
            $self->end_batch();
            return;
        }

        #---------------------------
        # Handle all other lines ...
        #---------------------------

        $K_dangling_elsif = 0;

        # This is a good place to kill incomplete one-line blocks
        if ( $max_index_to_go >= 0 ) {

            # For -iob and -lp, mark essential old breakpoints.
            # Fixes b1021 b1023 b1034 b1048 b1049 b1050 b1056 b1058
            # See related code below.
            if ( $rOpts_ignore_old_breakpoints && $rOpts_line_up_parentheses ) {
                my $type_first = $rLL->[$K_first_true]->[_TYPE_];
                if ( $is_assignment_or_fat_comma{$type_first} ) {
                    $old_breakpoint_to_go[$max_index_to_go] = 1;
                }
            }

            if (

                # this check needed -mangle (for example rt125012)
                (
                       ( !$index_start_one_line_block )
                    && ( $last_old_nonblank_type eq ';' )
                    && ( $first_new_nonblank_token ne '}' )
                )

                # Patch for RT #98902. Honor request to break at old commas.
                || (   $rOpts_break_at_old_comma_breakpoints
                    && $last_old_nonblank_type eq ',' )
              )
            {
                $forced_breakpoint_to_go[$max_index_to_go] = 1
                  if ($rOpts_break_at_old_comma_breakpoints);
                $index_start_one_line_block = undef;
                $self->end_batch();
            }

            # Keep any requested breaks before this line.  Note that we have to
            # use the original K_first because it may have been reduced above
            # to add a blank.  The value of the flag is as follows:
            #   1 => hard break, flush the batch
            #   2 => soft break, set breakpoint and continue building the batch
            # added check on max_index_to_go for c177
            if (   $max_index_to_go >= 0
                && $self->[_rbreak_before_Kfirst_]->{$K_first_true} )
            {
                $index_start_one_line_block = undef;
                if ( $self->[_rbreak_before_Kfirst_]->{$K_first_true} == 2 ) {
                    $self->set_forced_breakpoint($max_index_to_go);
                }
                else {
                    $self->end_batch();
                }
            }
        }

        #--------------------------------------
        # loop to process the tokens one-by-one
        #--------------------------------------
        $self->process_line_inner_loop($has_side_comment);

        # if there is anything left in the output buffer ...
        if ( $max_index_to_go >= 0 ) {

            my $type       = $rLL->[$K_last]->[_TYPE_];
            my $break_flag = $self->[_rbreak_after_Klast_]->{$K_last};

            # we have to flush ..
            if (

                # if there is a side comment...
                $type eq '#'

                # if this line ends in a quote
                # NOTE: This is critically important for insuring that quoted
                # lines do not get processed by things like -sot and -sct
                || $in_quote

                # if this is a VERSION statement
                || $CODE_type eq 'VER'

                # to keep a label at the end of a line
                || ( $type eq 'J' && $rOpts_break_after_labels != 2 )

                # if we have a hard break request
                || $break_flag && $break_flag != 2

                # if we are instructed to keep all old line breaks
                || !$rOpts->{'delete-old-newlines'}

                # if this is a line of the form 'use overload'. A break here in
                # the input file is a good break because it will allow the
                # operators which follow to be formatted well. Without this
                # break the formatting with -ci=4 -xci is poor, for example.

                #   use overload
                #     '+' => sub {
                #       print length $_[2], "\n";
                #       my ( $x, $y ) = _order(@_);
                #       Number::Roman->new( int $x + $y );
                #     },
                #     '-' => sub {
                #       my ( $x, $y ) = _order(@_);
                #       Number::Roman->new( int $x - $y );
                #     };
                || (   $max_index_to_go == 2
                    && $types_to_go[0] eq 'k'
                    && $tokens_to_go[0] eq 'use'
                    && $tokens_to_go[$max_index_to_go] eq 'overload' )
              )
            {
                $index_start_one_line_block = undef;
                $self->end_batch();
            }

            else {

                # Check for a soft break request
                if ( $break_flag && $break_flag == 2 ) {
                    $self->set_forced_breakpoint($max_index_to_go);
                }

                # mark old line breakpoints in current output stream
                if (
                    !$rOpts_ignore_old_breakpoints

                    # Mark essential old breakpoints if combination -iob -lp is
                    # used.  These two options do not work well together, but
                    # we can avoid turning -iob off by ignoring -iob at certain
                    # essential line breaks.  See also related code above.
                    # Fixes b1021 b1023 b1034 b1048 b1049 b1050 b1056 b1058
                    || (   $rOpts_line_up_parentheses
                        && $is_assignment_or_fat_comma{$type} )
                  )
                {
                    $old_breakpoint_to_go[$max_index_to_go] = 1;
                }
            }
        }

        if ( $K_dangling_elsif && $rOpts_add_missing_else ) {
            $self->add_missing_else();
        }

        return;
    } ## end sub process_line_of_CODE

    sub process_line_inner_loop {

        my ( $self, $has_side_comment ) = @_;

        #--------------------------------------------------------------------
        # Loop to move all tokens from one input line to a newly forming batch
        #--------------------------------------------------------------------

        # Do not start a new batch with a blank space
        if ( $max_index_to_go < 0 && $rLL->[$K_first]->[_TYPE_] eq 'b' ) {
            $K_first++;
        }

        foreach my $Ktoken_vars ( $K_first .. $K_last ) {

            my $rtoken_vars = $rLL->[$Ktoken_vars];

            #--------------
            # handle blanks
            #--------------
            if ( $rtoken_vars->[_TYPE_] eq 'b' ) {
                $self->store_token_to_go( $Ktoken_vars, $rtoken_vars );
                next;
            }

            #------------------
            # handle non-blanks
            #------------------
            my $type = $rtoken_vars->[_TYPE_];

            # If we are continuing after seeing a right curly brace, flush
            # buffer unless we see what we are looking for, as in
            #   } else ...
            if ($rbrace_follower) {
                my $token = $rtoken_vars->[_TOKEN_];
                if ( !$rbrace_follower->{$token} ) {
                    $self->end_batch() if ( $max_index_to_go >= 0 );
                }
                $rbrace_follower = undef;
            }

            my (
                $block_type,       $type_sequence,
                $is_opening_BLOCK, $is_closing_BLOCK,
                $nobreak_BEFORE_BLOCK
            );

            if ( $rtoken_vars->[_TYPE_SEQUENCE_] ) {

                my $token = $rtoken_vars->[_TOKEN_];
                $type_sequence = $rtoken_vars->[_TYPE_SEQUENCE_];
                $block_type    = $rblock_type_of_seqno->{$type_sequence};

                if (   $block_type
                    && $token eq $type
                    && $block_type ne 't'
                    && !$self->[_rshort_nested_]->{$type_sequence} )
                {

                    if ( $type eq '{' ) {
                        $is_opening_BLOCK     = 1;
                        $nobreak_BEFORE_BLOCK = $no_internal_newlines;
                    }
                    elsif ( $type eq '}' ) {
                        $is_closing_BLOCK     = 1;
                        $nobreak_BEFORE_BLOCK = $no_internal_newlines;
                    }
                    else {
                        ## error - block should be enclosed by curly brace
                        DEVEL_MODE && Fault(<<EOM);
block type '$block_type' has unexpected container type '$type'
EOM
                    }
                }
            }

            #---------------------
            # handle side comments
            #---------------------
            if ($has_side_comment) {

                # if at last token ...
                if ( $Ktoken_vars == $K_last ) {
                    $self->store_token_to_go( $Ktoken_vars, $rtoken_vars );
                    next;
                }

                # if before last token ... do not allow breaks which would
                # promote a side comment to a block comment
                if (   $Ktoken_vars == $K_last - 1
                    || $Ktoken_vars == $K_last - 2
                    && $rLL->[ $K_last - 1 ]->[_TYPE_] eq 'b' )
                {
                    $no_internal_newlines = 2;
                }
            }

            # Process non-blank and non-comment tokens ...

            #-----------------
            # handle semicolon
            #-----------------
            if ( $type eq ';' ) {

                my $next_nonblank_token_type = 'b';
                my $next_nonblank_token      = EMPTY_STRING;
                if ( $Ktoken_vars < $K_last ) {
                    my $Knnb = $Ktoken_vars + 1;
                    $Knnb++ if ( $rLL->[$Knnb]->[_TYPE_] eq 'b' );
                    $next_nonblank_token      = $rLL->[$Knnb]->[_TOKEN_];
                    $next_nonblank_token_type = $rLL->[$Knnb]->[_TYPE_];
                }

                if (   $rOpts_break_at_old_semicolon_breakpoints
                    && ( $Ktoken_vars == $K_first )
                    && $max_index_to_go >= 0
                    && !defined($index_start_one_line_block) )
                {
                    $self->end_batch();
                }

                $self->store_token_to_go( $Ktoken_vars, $rtoken_vars );

                $self->end_batch()
                  if (
                    !$no_internal_newlines
                    && (  !$rOpts_keep_interior_semicolons
                        || $Ktoken_vars >= $K_last )
                    && ( $next_nonblank_token ne '}' )
                  );
            }

            #-----------
            # handle '{'
            #-----------
            elsif ($is_opening_BLOCK) {

                # Tentatively output this token.  This is required before
                # calling starting_one_line_block.  We may have to unstore
                # it, though, if we have to break before it.
                $self->store_token_to_go( $Ktoken_vars, $rtoken_vars );

                # Look ahead to see if we might form a one-line block..
                my $too_long =
                  $self->starting_one_line_block( $Ktoken_vars,
                    $K_last_nonblank_code, $K_last );
                $self->clear_breakpoint_undo_stack();

                # to simplify the logic below, set a flag to indicate if
                # this opening brace is far from the keyword which introduces it
                my $keyword_on_same_line = 1;
                if (
                       $max_index_to_go >= 0
                    && defined($K_last_nonblank_code)
                    && $rLL->[$K_last_nonblank_code]->[_TYPE_] eq ')'
                    && ( ( $rtoken_vars->[_LEVEL_] < $levels_to_go[0] )
                        || $too_long )
                  )
                {
                    $keyword_on_same_line = 0;
                }

                # Break before '{' if requested with -bl or -bli flag
                my $want_break = $self->[_rbrace_left_]->{$type_sequence};

                # But do not break if this token is welded to the left
                if ( $total_weld_count
                    && defined( $self->[_rK_weld_left_]->{$Ktoken_vars} ) )
                {
                    $want_break = 0;
                }

                # Break BEFORE an opening '{' ...
                if (

                    # if requested
                    $want_break

                    # and we were unable to start looking for a block,
                    && !defined($index_start_one_line_block)

                    # or if it will not be on same line as its keyword, so that
                    # it will be outdented (eval.t, overload.t), and the user
                    # has not insisted on keeping it on the right
                    || (   !$keyword_on_same_line
                        && !$rOpts_opening_brace_always_on_right )
                  )
                {

                    # but only if allowed
                    if ( !$nobreak_BEFORE_BLOCK ) {

                        # since we already stored this token, we must unstore it
                        $self->unstore_token_to_go();

                        # then output the line
                        $self->end_batch() if ( $max_index_to_go >= 0 );

                        # and now store this token at the start of a new line
                        $self->store_token_to_go( $Ktoken_vars, $rtoken_vars );
                    }
                }

                # now output this line
                $self->end_batch()
                  if ( $max_index_to_go >= 0 && !$no_internal_newlines );
            }

            #-----------
            # handle '}'
            #-----------
            elsif ($is_closing_BLOCK) {

                my $next_nonblank_token_type = 'b';
                my $next_nonblank_token      = EMPTY_STRING;
                my $Knnb;
                if ( $Ktoken_vars < $K_last ) {
                    $Knnb = $Ktoken_vars + 1;
                    $Knnb++ if ( $rLL->[$Knnb]->[_TYPE_] eq 'b' );
                    $next_nonblank_token      = $rLL->[$Knnb]->[_TOKEN_];
                    $next_nonblank_token_type = $rLL->[$Knnb]->[_TYPE_];
                }

                # If there is a pending one-line block ..
                if ( defined($index_start_one_line_block) ) {

                    # Fix for b1208: if a side comment follows this closing
                    # brace then we must include its length in the length test
                    # ... unless the -issl flag is set (fixes b1307-1309).
                    # Assume a minimum of 1 blank space to the comment.
                    my $added_length = 0;
                    if (   $has_side_comment
                        && !$rOpts_ignore_side_comment_lengths
                        && $next_nonblank_token_type eq '#' )
                    {
                        $added_length = 1 + $rLL->[$K_last]->[_TOKEN_LENGTH_];
                    }

                    # we have to terminate it if..
                    if (

                        # it is too long (final length may be different from
                        # initial estimate). note: must allow 1 space for this
                        # token
                        $self->excess_line_length( $index_start_one_line_block,
                            $max_index_to_go ) + $added_length >= 0
                      )
                    {
                        $index_start_one_line_block = undef;
                    }
                }

                # put a break before this closing curly brace if appropriate
                $self->end_batch()
                  if ( $max_index_to_go >= 0
                    && !$nobreak_BEFORE_BLOCK
                    && !defined($index_start_one_line_block) );

                # store the closing curly brace
                $self->store_token_to_go( $Ktoken_vars, $rtoken_vars );

                # ok, we just stored a closing curly brace.  Often, but
                # not always, we want to end the line immediately.
                # So now we have to check for special cases.

                # if this '}' successfully ends a one-line block..
                my $one_line_block_type = EMPTY_STRING;
                my $keep_going;
                if ( defined($index_start_one_line_block) ) {

                    # Remember the type of token just before the
                    # opening brace.  It would be more general to use
                    # a stack, but this will work for one-line blocks.
                    # c1461 fix
                    my $Ko  = $self->[_K_opening_container_]->{$type_sequence};
                    my $Kom = $self->K_previous_nonblank($Ko);
                    if ( defined($Kom) ) {
                        $one_line_block_type = $rLL->[$Kom]->[_TYPE_];
                    }

                    # we have to actually make it by removing tentative
                    # breaks that were set within it
                    $self->undo_forced_breakpoint_stack(0);

                    # For -lp, extend the nobreak to include a trailing
                    # terminal ','.  This is because the -lp indentation was
                    # not known when making one-line blocks, so we may be able
                    # to move the line back to fit.  Otherwise we may create a
                    # needlessly stranded comma on the next line.
                    my $iend_nobreak = $max_index_to_go - 1;
                    if (   $rOpts_line_up_parentheses
                        && $next_nonblank_token_type eq ','
                        && $Knnb eq $K_last )
                    {
                        my $p_seqno = $parent_seqno_to_go[$max_index_to_go];
                        my $is_excluded =
                          $self->[_ris_excluded_lp_container_]->{$p_seqno};
                        $iend_nobreak = $max_index_to_go if ( !$is_excluded );
                    }

                    $self->set_nobreaks( $index_start_one_line_block,
                        $iend_nobreak );

                    # save starting block indexes so that sub correct_lp can
                    # check and adjust -lp indentation (c098)
                    push @{$ri_starting_one_line_block},
                      $index_start_one_line_block;

                    # then re-initialize for the next one-line block
                    $index_start_one_line_block = undef;

                    # then decide if we want to break after the '}' ..
                    # We will keep going to allow certain brace followers as in:
                    #   do { $ifclosed = 1; last } unless $losing;
                    #
                    # But make a line break if the curly ends a
                    # significant block:
                    if (
                        (
                            $is_block_without_semicolon{$block_type}

                            # Follow users break point for
                            # one line block types U & G, such as a 'try' block
                            || $one_line_block_type =~ /^[UG]$/
                            && $Ktoken_vars == $K_last
                        )

                        # if needless semicolon follows we handle it later
                        && $next_nonblank_token ne ';'
                      )
                    {
                        $self->end_batch()
                          unless ($no_internal_newlines);
                    }
                }

                # set string indicating what we need to look for brace follower
                # tokens
                if ( $is_if_unless_elsif_else{$block_type} ) {
                    $rbrace_follower = undef;
                }
                elsif ( $block_type eq 'do' ) {
                    $rbrace_follower = \%is_do_follower;
                    if (
                        $self->tight_paren_follows( $K_to_go[0], $Ktoken_vars )
                      )
                    {
                        $rbrace_follower = { ')' => 1 };
                    }
                }

                # added eval for borris.t
                elsif ($is_sort_map_grep_eval{$block_type}
                    || $one_line_block_type eq 'G' )
                {
                    $rbrace_follower = undef;
                    $keep_going      = 1;
                }

                # anonymous sub
                elsif ( $self->[_ris_asub_block_]->{$type_sequence} ) {
                    if ($one_line_block_type) {

                        $rbrace_follower = \%is_anon_sub_1_brace_follower;

                        # Exceptions to help keep -lp intact, see git #74 ...
                        # Exception 1: followed by '}' on this line
                        if (   $Ktoken_vars < $K_last
                            && $next_nonblank_token eq '}' )
                        {
                            $rbrace_follower = undef;
                            $keep_going      = 1;
                        }

                        # Exception 2: followed by '}' on next line if -lp set.
                        # The -lp requirement allows the formatting to follow
                        # old breaks when -lp is not used, minimizing changes.
                        # Fixes issue c087.
                        elsif ($Ktoken_vars == $K_last
                            && $rOpts_line_up_parentheses )
                        {
                            my $K_closing_container =
                              $self->[_K_closing_container_];
                            my $p_seqno = $parent_seqno_to_go[$max_index_to_go];
                            my $Kc      = $K_closing_container->{$p_seqno};
                            my $is_excluded =
                              $self->[_ris_excluded_lp_container_]->{$p_seqno};
                            $keep_going =
                              (      defined($Kc)
                                  && $rLL->[$Kc]->[_TOKEN_] eq '}'
                                  && !$is_excluded
                                  && $Kc - $Ktoken_vars <= 2 );
                            $rbrace_follower = undef if ($keep_going);
                        }
                        else {
                            ## not an exception
                        }
                    }
                    else {
                        $rbrace_follower = \%is_anon_sub_brace_follower;
                    }
                }

                # None of the above: specify what can follow a closing
                # brace of a block which is not an
                # if/elsif/else/do/sort/map/grep/eval
                # Testfiles:
                # 'Toolbar.pm', 'Menubar.pm', bless.t, '3rules.pl', 'break1.t
                else {
                    $rbrace_follower = \%is_other_brace_follower;
                }

                # See if an elsif block is followed by another elsif or else;
                # complain if not.
                if ( $block_type eq 'elsif' ) {

                    # more code on this line ? ( this is unusual )
                    if (   $next_nonblank_token_type ne 'b'
                        && $next_nonblank_token_type ne '#' )
                    {
                        # check for 'elsif' or 'else'
                        if ( !$is_elsif_else{$next_nonblank_token} ) {
                            write_logfile_entry("(No else block)\n");

                            # Note that we cannot add a missing else block
                            # in this case because more code follows the
                            # closing elsif brace on the same line.
                            if ( $rOpts_warn_missing_else && !DEVEL_MODE ) {
                                my $lno =
                                  $rLL->[$Ktoken_vars]->[_LINE_INDEX_] + 1;
                                warning("$lno: No else block\n");
                            }
                        }
                    }

                    # no more code on this line, so check on next line
                    else {
                        my $K_next = $self->K_next_code($K_last);
                        if (   !defined($K_next)
                            || $rLL->[$K_next]->[_TYPE_] ne 'k'
                            || !$is_elsif_else{ $rLL->[$K_next]->[_TOKEN_] } )
                        {
                            $K_dangling_elsif = $Ktoken_vars;
                            write_logfile_entry("(No else block)\n");
                            if ( $rOpts_warn_missing_else && !DEVEL_MODE ) {
                                my $lno =
                                  $rLL->[$Ktoken_vars]->[_LINE_INDEX_] + 1;
                                if ($rOpts_add_missing_else) {
                                    warning(
                                        "$lno: Adding missing else block\n");
                                }
                                else {
                                    warning(
"$lno: No else block (use -ame to add one)\n"
                                    );
                                }
                            }
                        }
                    }
                }

                # keep going after certain block types (map,sort,grep,eval)
                # added eval for borris.t
                if ($keep_going) {

                    # keep going
                    $rbrace_follower = undef;

                }

                # if no more tokens, postpone decision until re-entering
                elsif ( ( $next_nonblank_token_type eq 'b' )
                    && $rOpts_add_newlines )
                {
                    if ( !$rbrace_follower ) {
                        $self->end_batch()
                          if (!$no_internal_newlines
                            && $max_index_to_go >= 0 );
                    }
                }
                elsif ($rbrace_follower) {

                    if ( $rbrace_follower->{$next_nonblank_token} ) {

                        # Fix for b1385: keep break after a comma following a
                        # 'do' block. This could also be used for other block
                        # types, but that would cause a significant change in
                        # existing formatting without much benefit.
                        if (   $next_nonblank_token_type eq ','
                            && $Knnb eq $K_last
                            && $block_type eq 'do'
                            && $rOpts_add_newlines
                            && $self->is_trailing_comma($Knnb) )
                        {
                            $self->[_rbreak_after_Klast_]->{$K_last} = 1;
                        }
                    }
                    else {
                        $self->end_batch()
                          if (!$no_internal_newlines
                            && $max_index_to_go >= 0 );
                    }

                    $rbrace_follower = undef;
                }

                else {
                    $self->end_batch()
                      if ( !$no_internal_newlines && $max_index_to_go >= 0 );
                }

            } ## end treatment of closing block token

            #------------------------------
            # handle here_doc target string
            #------------------------------
            elsif ( $type eq 'h' ) {

                # no newlines after seeing here-target
                $no_internal_newlines = 2;
                $self->store_token_to_go( $Ktoken_vars, $rtoken_vars );
            }

            #-----------------------------
            # handle all other token types
            #-----------------------------
            else {

                $self->store_token_to_go( $Ktoken_vars, $rtoken_vars );

                # break after a label if requested
                if (   $rOpts_break_after_labels
                    && $type eq 'J'
                    && $rOpts_break_after_labels == 1 )
                {
                    $self->end_batch()
                      unless ($no_internal_newlines);
                }
            }

            # remember previous nonblank, non-comment OUTPUT token
            $K_last_nonblank_code = $Ktoken_vars;

        } ## end of loop over all tokens in this line
        return;
    } ## end sub process_line_inner_loop

} ## end closure process_line_of_CODE

sub tight_paren_follows {

    my ( $self, $K_to_go_0, $K_ic ) = @_;

    # Given:
    #   $K_to_go_0 = first token index K of this output batch (=K_to_go[0])
    #   $K_ic = index of the closing do brace (=K_to_go[$max_index_to_go])
    # Return:
    #   false if we want a break after the closing do brace
    #   true if we do not want a break after the closing do brace

    # We are at the closing brace of a 'do' block.  See if this brace is
    # followed by a closing paren, and if so, set a flag which indicates
    # that we do not want a line break between the '}' and ')'.

    # xxxxx ( ...... do {  ... } ) {
    #                          ^-------looking at this brace, K_ic

    # Subscript notation:
    # _i = inner container (braces in this case)
    # _o = outer container (parens in this case)
    # _io = inner opening = '{'
    # _ic = inner closing = '}'
    # _oo = outer opening = '('
    # _oc = outer closing = ')'

    #       |--K_oo                 |--K_oc  = outer container
    # xxxxx ( ...... do {  ...... } ) {
    #                   |--K_io   |--K_ic    = inner container

    # In general, the safe thing to do is return a 'false' value
    # if the statement appears to be complex.  This will have
    # the downstream side-effect of opening up outer containers
    # to help make complex code readable.  But for simpler
    # do blocks it can be preferable to keep the code compact
    # by returning a 'true' value.

    return unless defined($K_ic);
    my $rLL = $self->[_rLL_];

    # we should only be called at a closing block
    my $seqno_i = $rLL->[$K_ic]->[_TYPE_SEQUENCE_];
    return unless ($seqno_i);    # shouldn't happen;

    # This only applies if the next nonblank is a ')'
    my $K_oc = $self->K_next_nonblank($K_ic);
    return unless defined($K_oc);
    my $token_next = $rLL->[$K_oc]->[_TOKEN_];
    return unless ( $token_next eq ')' );

    my $seqno_o = $rLL->[$K_oc]->[_TYPE_SEQUENCE_];
    my $K_io    = $self->[_K_opening_container_]->{$seqno_i};
    my $K_oo    = $self->[_K_opening_container_]->{$seqno_o};
    return unless ( defined($K_io) && defined($K_oo) );

    # RULE 1: Do not break before a closing signature paren
    # (regardless of complexity).  This is a fix for issue git#22.
    # Looking for something like:
    #   sub xxx ( ... do {  ... } ) {
    #                               ^----- next block_type
    my $K_test = $self->K_next_nonblank($K_oc);
    if ( defined($K_test) && $rLL->[$K_test]->[_TYPE_] eq '{' ) {
        my $seqno_test = $rLL->[$K_test]->[_TYPE_SEQUENCE_];
        if ($seqno_test) {
            if (   $self->[_ris_asub_block_]->{$seqno_test}
                || $self->[_ris_sub_block_]->{$seqno_test} )
            {
                return 1;
            }
        }
    }

    # RULE 2: Break if the contents within braces appears to be 'complex'.  We
    # base this decision on the number of tokens between braces.

    # xxxxx ( ... do {  ... } ) {
    #                 ^^^^^^

    # Although very simple, it has the advantages of (1) being insensitive to
    # changes in lengths of identifier names, (2) easy to understand, implement
    # and test.  A test case for this is 't/snippets/long_line.in'.

    # Example: $K_ic - $K_oo = 9       [Pass Rule 2]
    # if ( do { $2 !~ /&/ } ) { ... }

    # Example: $K_ic - $K_oo = 10      [Pass Rule 2]
    # for ( split /\s*={70,}\s*/, do { local $/; <DATA> }) { ... }

    # Example: $K_ic - $K_oo = 20      [Fail Rule 2]
    # test_zero_args( "do-returned list slice", do { ( 10, 11 )[ 2, 3 ]; });

    return if ( $K_ic - $K_io > 16 );

    # RULE 3: break if the code between the opening '(' and the '{' is 'complex'
    # As with the previous rule, we decide based on the token count

    # xxxxx ( ... do {  ... } ) {
    #        ^^^^^^^^

    # Example: $K_ic - $K_oo = 9       [Pass Rule 2]
    #          $K_io - $K_oo = 4       [Pass Rule 3]
    # if ( do { $2 !~ /&/ } ) { ... }

    # Example: $K_ic - $K_oo = 10    [Pass rule 2]
    #          $K_io - $K_oo = 9     [Pass rule 3]
    # for ( split /\s*={70,}\s*/, do { local $/; <DATA> }) { ... }

    return if ( $K_io - $K_oo > 9 );

    # RULE 4: Break if we have already broken this batch of output tokens
    return if ( $K_oo < $K_to_go_0 );

    # RULE 5: Break if input is not on one line
    # For example, we will set the flag for the following expression
    # written in one line:

    # This has: $K_ic - $K_oo = 10    [Pass rule 2]
    #           $K_io - $K_oo = 8     [Pass rule 3]
    #   $self->debug( 'Error: ' . do { local $/; <$err> } );

    # but we break after the brace if it is on multiple lines on input, since
    # the user may prefer it on multiple lines:

    # [Fail rule 5]
    #   $self->debug(
    #       'Error: ' . do { local $/; <$err> }
    #   );

    if ( !$rOpts_ignore_old_breakpoints ) {
        my $iline_oo = $rLL->[$K_oo]->[_LINE_INDEX_];
        my $iline_oc = $rLL->[$K_oc]->[_LINE_INDEX_];
        return if ( $iline_oo != $iline_oc );
    }

    # OK to keep the paren tight
    return 1;
} ## end sub tight_paren_follows

my %is_brace_semicolon_colon;

BEGIN {
    my @q = qw( { } ; : );
    @is_brace_semicolon_colon{@q} = (1) x scalar(@q);
}

sub starting_one_line_block {

    my ( $self, $Kj, $K_last_nonblank, $K_last ) = @_;

    # After seeing an opening curly brace, look for the closing brace and see
    # if the entire block will fit on a line.  This routine is not always right
    # so a check is made later (at the closing brace) to make sure we really
    # have a one-line block.  We have to do this preliminary check, though,
    # because otherwise we would always break at a semicolon within a one-line
    # block if the block contains multiple statements.

    # Given:
    #  $Kj              = index of opening brace
    #  $K_last_nonblank = index of previous nonblank code token
    #  $K_last          = index of last token of input line

    # Calls 'create_one_line_block' if one-line block might be formed.

    # Returns:
    #  $too_long:
    #   true  = distance from opening keyword to OPENING brace exceeds
    #          the maximum line length.
    #   false otherwise
    # Note that this flag is for distance from the statement start to the
    # OPENING brace, not the closing brace.

    my $rbreak_container     = $self->[_rbreak_container_];
    my $rshort_nested        = $self->[_rshort_nested_];
    my $rLL                  = $self->[_rLL_];
    my $K_opening_container  = $self->[_K_opening_container_];
    my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];

    # kill any current block - we can only go 1 deep
    create_one_line_block(undef);

    my $i_start = 0;

    # This routine should not have been called if there are no tokens in the
    # 'to_go' arrays of previously stored tokens.  A previous call to
    # 'store_token_to_go' should have stored an opening brace. An error here
    # indicates that a programming change may have caused a flush operation to
    # clean out the previously stored tokens.
    if ( !defined($max_index_to_go) || $max_index_to_go < 0 ) {
        Fault("program bug: store_token_to_go called incorrectly\n")
          if (DEVEL_MODE);
        return;
    }

    # Return if block should be broken
    my $type_sequence_j = $rLL->[$Kj]->[_TYPE_SEQUENCE_];
    if ( $rbreak_container->{$type_sequence_j} ) {
        return;
    }

    my $ris_bli_container = $self->[_ris_bli_container_];
    my $is_bli            = $ris_bli_container->{$type_sequence_j};

    my $block_type = $rblock_type_of_seqno->{$type_sequence_j};
    $block_type = EMPTY_STRING unless ( defined($block_type) );

    my $previous_nonblank_token = EMPTY_STRING;
    my $i_last_nonblank         = -1;
    if ( defined($K_last_nonblank) ) {
        $i_last_nonblank = $K_last_nonblank - $K_to_go[0];
        if ( $i_last_nonblank >= 0 ) {
            $previous_nonblank_token = $rLL->[$K_last_nonblank]->[_TOKEN_];
        }
    }

    #---------------------------------------------------------------------
    # find the starting keyword for this block (such as 'if', 'else', ...)
    #---------------------------------------------------------------------
    if (
        $max_index_to_go == 0
        ##|| $block_type =~ /^[\{\}\;\:]$/
        || $is_brace_semicolon_colon{$block_type}
        || substr( $block_type, 0, 7 ) eq 'package'
      )
    {
        $i_start = $max_index_to_go;
    }

    # the previous nonblank token should start these block types
    elsif (
        $i_last_nonblank >= 0
        && (   $previous_nonblank_token eq $block_type
            || $self->[_ris_asub_block_]->{$type_sequence_j}
            || $self->[_ris_sub_block_]->{$type_sequence_j}
            || substr( $block_type, -2, 2 ) eq '()' )
      )
    {
        $i_start = $i_last_nonblank;

        # For signatures and extended syntax ...
        # If this brace follows a parenthesized list, we should look back to
        # find the keyword before the opening paren because otherwise we might
        # form a one line block which stays intact, and cause the parenthesized
        # expression to break open. That looks bad.
        if ( $tokens_to_go[$i_start] eq ')' ) {

            # Find the opening paren
            my $K_start = $K_to_go[$i_start];
            return unless defined($K_start);
            my $seqno = $type_sequence_to_go[$i_start];
            return unless ($seqno);
            my $K_opening = $K_opening_container->{$seqno};
            return if ( !defined($K_opening) );
            my $i_opening = $i_start + ( $K_opening - $K_start );

            # give up if not on this line
            return if ( $i_opening < 0 );
            $i_start = $i_opening;

            # go back one token before the opening paren
            if ( $i_start > 0 )                                  { $i_start-- }
            if ( $types_to_go[$i_start] eq 'b' && $i_start > 0 ) { $i_start--; }
            my $lev = $levels_to_go[$i_start];
            if ( $lev > $rLL->[$Kj]->[_LEVEL_] ) { return }
        }

        # include a length of any preceding assignment token if we break before
        # it (b1461)
        elsif ( $i_start > 0 ) {
            my $i_eq = $i_start - 1;
            if ( $types_to_go[$i_eq] eq 'b' && $i_eq > 0 ) { $i_eq--; }
            my $type_eq = $types_to_go[$i_eq];
            if ( $is_assignment{$type_eq} && $want_break_before{$type_eq} ) {
                $i_start = $i_eq;
            }
        }
        else {
            # $i_start is 0 - cannot back up
        }
    }
    elsif ( $previous_nonblank_token eq ')' ) {

        # For something like "if (xxx) {", the keyword "if" will be
        # just after the most recent break. This will be 0 unless
        # we have just killed a one-line block and are starting another.
        # (doif.t)
        # Note: cannot use inext_index_to_go[] here because that array
        # is still being constructed.
        $i_start = $index_max_forced_break + 1;
        if ( $types_to_go[$i_start] eq 'b' ) {
            $i_start++;
        }

        # Patch to avoid breaking short blocks defined with extended_syntax:
        # Strip off any trailing () which was added in the parser to mark
        # the opening keyword.  For example, in the following
        #    create( TypeFoo $e) {$bubba}
        # the blocktype would be marked as create()
        my $stripped_block_type = $block_type;
        if ( substr( $block_type, -2, 2 ) eq '()' ) {
            $stripped_block_type = substr( $block_type, 0, -2 );
        }
        if ( $tokens_to_go[$i_start] ne $stripped_block_type ) {
            return;
        }
    }

    # patch for SWITCH/CASE to retain one-line case/when blocks
    elsif ( $block_type eq 'case' || $block_type eq 'when' ) {

        # Note: cannot use inext_index_to_go[] here because that array
        # is still being constructed.
        $i_start = $index_max_forced_break + 1;
        if ( $types_to_go[$i_start] eq 'b' ) {
            $i_start++;
        }
        if ( $tokens_to_go[$i_start] ne $block_type ) {
            return;
        }
    }
    else {

        #-------------------------------------------
        # Couldn't find start - return too_long flag
        #-------------------------------------------
        return 1;
    }

    my $pos = total_line_length( $i_start, $max_index_to_go ) - 1;

    my $maximum_line_length =
      $maximum_line_length_at_level[ $levels_to_go[$i_start] ];

    # see if distance to the opening container is too great to even start
    if ( $pos > $maximum_line_length ) {

        #------------------------------
        # too long to the opening token
        #------------------------------
        return 1;
    }

    #-----------------------------------------------------------------------
    # OK so far: the statement is not to long just to the OPENING token. Now
    # see if everything to the closing token will fit on one line
    #-----------------------------------------------------------------------

    # This is part of an update to fix cases b562 .. b983
    my $K_closing = $self->[_K_closing_container_]->{$type_sequence_j};
    return unless ( defined($K_closing) );
    my $container_length = $rLL->[$K_closing]->[_CUMULATIVE_LENGTH_] -
      $rLL->[$Kj]->[_CUMULATIVE_LENGTH_];

    my $excess = $pos + 1 + $container_length - $maximum_line_length;

    # Add a small tolerance for welded tokens (case b901)
    if ( $total_weld_count && $self->is_welded_at_seqno($type_sequence_j) ) {
        $excess += 2;
    }

    if ( $excess > 0 ) {

        # line is too long...  there is no chance of forming a one line block
        # if the excess is more than 1 char
        return if ( $excess > 1 );

        # ... and give up if it is not a one-line block on input.
        # note: for a one-line block on input, it may be possible to keep
        # it as a one-line block (by removing a needless semicolon ).
        my $K_start = $K_to_go[$i_start];
        my $ldiff =
          $rLL->[$K_closing]->[_LINE_INDEX_] - $rLL->[$K_start]->[_LINE_INDEX_];
        return if ($ldiff);
    }

    #------------------------------------------------------------------
    # Loop to check contents and length of the potential one-line block
    #------------------------------------------------------------------
    foreach my $Ki ( $Kj + 1 .. $K_last ) {

        # old whitespace could be arbitrarily large, so don't use it
        if ( $rLL->[$Ki]->[_TYPE_] eq 'b' ) { $pos += 1 }
        else { $pos += $rLL->[$Ki]->[_TOKEN_LENGTH_] }

        # ignore some small blocks
        my $type_sequence_i = $rLL->[$Ki]->[_TYPE_SEQUENCE_];
        my $nobreak         = $rshort_nested->{$type_sequence_i};

        # Return false result if we exceed the maximum line length,
        if ( $pos > $maximum_line_length ) {
            return;
        }

        # keep going for non-containers
        elsif ( !$type_sequence_i ) {

        }

        # return if we encounter another opening brace before finding the
        # closing brace.
        elsif ($rLL->[$Ki]->[_TOKEN_] eq '{'
            && $rLL->[$Ki]->[_TYPE_] eq '{'
            && $rblock_type_of_seqno->{$type_sequence_i}
            && !$nobreak )
        {
            return;
        }

        # if we find our closing brace..
        elsif ($rLL->[$Ki]->[_TOKEN_] eq '}'
            && $rLL->[$Ki]->[_TYPE_] eq '}'
            && $rblock_type_of_seqno->{$type_sequence_i}
            && !$nobreak )
        {

            # be sure any trailing comment also fits on the line
            my $Ki_nonblank = $Ki;
            if ( $Ki_nonblank < $K_last ) {
                $Ki_nonblank++;
                if (   $rLL->[$Ki_nonblank]->[_TYPE_] eq 'b'
                    && $Ki_nonblank < $K_last )
                {
                    $Ki_nonblank++;
                }
            }

            # Patch for one-line sort/map/grep/eval blocks with side comments:
            # We will ignore the side comment length for sort/map/grep/eval
            # because this can lead to statements which change every time
            # perltidy is run.  Here is an example from Denis Moskowitz which
            # oscillates between these two states without this patch:

## --------
## grep { $_->foo ne 'bar' } # asdfa asdf asdf asdf asdf asdf asdf asdf asdf asdf asdf
##  @baz;
##
## grep {
##     $_->foo ne 'bar'
##   }    # asdfa asdf asdf asdf asdf asdf asdf asdf asdf asdf asdf
##   @baz;
## --------

            # When the first line is input it gets broken apart by the main
            # line break logic in sub process_line_of_CODE.
            # When the second line is input it gets recombined by
            # process_line_of_CODE and passed to the output routines.  The
            # output routines (break_long_lines) do not break it apart
            # because the bond strengths are set to the highest possible value
            # for grep/map/eval/sort blocks, so the first version gets output.
            # It would be possible to fix this by changing bond strengths,
            # but they are high to prevent errors in older versions of perl.
            # See c100 for eval test.
            if (   $Ki < $K_last
                && $rLL->[$K_last]->[_TYPE_] eq '#'
                && $rLL->[$K_last]->[_LEVEL_] == $rLL->[$Ki]->[_LEVEL_]
                && !$rOpts_ignore_side_comment_lengths
                && !$is_sort_map_grep_eval{$block_type}
                && $K_last - $Ki_nonblank <= 2 )
            {
                # Only include the side comment for if/else/elsif/unless if it
                # immediately follows (because the current '$rbrace_follower'
                # logic for these will give an immediate brake after these
                # closing braces).  So for example a line like this
                #     if (...) { ... } ; # very long comment......
                # will already break like this:
                #     if (...) { ... }
                #     ; # very long comment......
                # so we do not need to include the length of the comment, which
                # would break the block. Project 'bioperl' has coding like this.
                if (  !$is_if_unless_elsif_else{$block_type}
                    || $K_last == $Ki_nonblank )
                {
                    $Ki_nonblank = $K_last;
                    $pos += $rLL->[$Ki_nonblank]->[_TOKEN_LENGTH_];

                    if ( $Ki_nonblank > $Ki + 1 ) {

                        # source whitespace could be anything, assume
                        # at least one space before the hash on output
                        if ( $rLL->[ $Ki + 1 ]->[_TYPE_] eq 'b' ) {
                            $pos += 1;
                        }
                        else { $pos += $rLL->[ $Ki + 1 ]->[_TOKEN_LENGTH_] }
                    }

                    if ( $pos >= $maximum_line_length ) {
                        return;
                    }
                }
            }

            #--------------------------
            # ok, it's a one-line block
            #--------------------------
            create_one_line_block($i_start);
            return;
        }

        # just keep going for other characters
        else {
        }
    }

    #--------------------------------------------------
    # End Loop to examine tokens in potential one-block
    #--------------------------------------------------

    # We haven't hit the closing brace, but there is still space. So the
    # question here is, should we keep going to look at more lines in hopes of
    # forming a new one-line block, or should we stop right now. The problem
    # with continuing is that we will not be able to honor breaks before the
    # opening brace if we continue.

    # Typically we will want to keep trying to make one-line blocks for things
    # like sort/map/grep/eval.  But it is not always a good idea to make as
    # many one-line blocks as possible, so other types are not done.  The user
    # can always use -mangle.

    # If we want to keep going, we will create a new one-line block.
    # The blocks which we can keep going are in a hash, but we never want
    # to continue if we are at a '-bli' block.
    if ( $want_one_line_block{$block_type} && !$is_bli ) {
        my $rtype_count = $self->[_rtype_count_by_seqno_]->{$type_sequence_j};
        my $semicolon_count = $rtype_count
          && $rtype_count->{';'} ? $rtype_count->{';'} : 0;

        # Ignore a terminal semicolon in the count
        if ( $semicolon_count <= 2 ) {
            my $K_closing_container = $self->[_K_closing_container_];
            my $K_closing_j         = $K_closing_container->{$type_sequence_j};
            my $Kp                  = $self->K_previous_nonblank($K_closing_j);
            if ( defined($Kp)
                && $rLL->[$Kp]->[_TYPE_] eq ';' )
            {
                $semicolon_count -= 1;
            }
        }
        if ( $semicolon_count <= 0 ) {
            create_one_line_block($i_start);
        }
        elsif ( $semicolon_count == 1 && $block_type eq 'eval' ) {

            # Mark short broken eval blocks for possible later use in
            # avoiding adding spaces before a 'package' line. This is not
            # essential but helps keep newer and older formatting the same.
            $self->[_ris_short_broken_eval_block_]->{$type_sequence_j} = 1;
        }
        else {
            # do not continue the search
        }
    }
    return;
} ## end sub starting_one_line_block

sub unstore_token_to_go {

    # remove most recent token from output stream
    my $self = shift;
    if ( $max_index_to_go > 0 ) {
        $max_index_to_go--;
    }
    else {
        $max_index_to_go = UNDEFINED_INDEX;
    }
    return;
} ## end sub unstore_token_to_go

sub compare_indentation_levels {

    my ( $self, $K_first, $guessed_indentation_level, $line_number ) = @_;

    # Check to see if output line leading space agrees with input line.
    # This can be very useful for debugging a script which has an extra
    # or missing brace.
    # Given:
    #   $K_first = index of first token on the line
    #   $guessed_indentation_level = guess based on leading spaces in input
    #   $line_number = line number in input stream

    return unless ( defined($K_first) );

    my $rLL = $self->[_rLL_];

    # ignore a line with a leading blank token - issue c195
    my $type = $rLL->[$K_first]->[_TYPE_];
    return if ( $type eq 'b' );

    my $structural_indentation_level = $self->[_radjusted_levels_]->[$K_first];

    # record max structural depth for log file
    if ( $structural_indentation_level > $self->[_maximum_BLOCK_level_] ) {
        $self->[_maximum_BLOCK_level_]         = $structural_indentation_level;
        $self->[_maximum_BLOCK_level_at_line_] = $line_number;
    }

    my $type_sequence = $rLL->[$K_first]->[_TYPE_SEQUENCE_];
    my $is_closing_block =
         $type_sequence
      && $self->[_rblock_type_of_seqno_]->{$type_sequence}
      && $type eq '}';

    if ( $guessed_indentation_level ne $structural_indentation_level ) {
        $self->[_last_tabbing_disagreement_] = $line_number;

        if ($is_closing_block) {

            if ( !$self->[_in_brace_tabbing_disagreement_] ) {
                $self->[_in_brace_tabbing_disagreement_] = $line_number;
            }
            if ( !$self->[_first_brace_tabbing_disagreement_] ) {
                $self->[_first_brace_tabbing_disagreement_] = $line_number;
            }
        }

        if ( !$self->[_in_tabbing_disagreement_] ) {
            $self->[_tabbing_disagreement_count_]++;

            if ( $self->[_tabbing_disagreement_count_] <= MAX_NAG_MESSAGES ) {
                write_logfile_entry(
"Start indentation disagreement: input=$guessed_indentation_level; output=$structural_indentation_level\n"
                );
            }
            $self->[_in_tabbing_disagreement_]    = $line_number;
            $self->[_first_tabbing_disagreement_] = $line_number
              unless ( $self->[_first_tabbing_disagreement_] );
        }
    }
    else {

        $self->[_in_brace_tabbing_disagreement_] = 0 if ($is_closing_block);

        my $in_tabbing_disagreement = $self->[_in_tabbing_disagreement_];
        if ($in_tabbing_disagreement) {

            if ( $self->[_tabbing_disagreement_count_] <= MAX_NAG_MESSAGES ) {
                write_logfile_entry(
"End indentation disagreement from input line $in_tabbing_disagreement\n"
                );

                if ( $self->[_tabbing_disagreement_count_] == MAX_NAG_MESSAGES )
                {
                    write_logfile_entry(
                        "No further tabbing disagreements will be noted\n");
                }
            }
            $self->[_in_tabbing_disagreement_] = 0;

        }
    }
    return;
} ## end sub compare_indentation_levels

###################################################
# CODE SECTION 8: Utilities for setting breakpoints
###################################################

{    ## begin closure set_forced_breakpoint

    my @forced_breakpoint_undo_stack;

    # These are global vars for efficiency:
    # my $forced_breakpoint_count;
    # my $forced_breakpoint_undo_count;
    # my $index_max_forced_break;

    # Break before or after certain tokens based on user settings
    my %break_before_or_after_token;

    BEGIN {

        # Updated to use all operators. This fixes case b1054
        # Here is the previous simplified version:
        ## my @q = qw( . : ? and or xor && || );
        my @q = @all_operators;

        push @q, ',';
        @break_before_or_after_token{@q} = (1) x scalar(@q);
    } ## end BEGIN

    sub set_fake_breakpoint {

        # Just bump up the breakpoint count as a signal that there are breaks.
        # This is useful if we have breaks but may want to postpone deciding
        # where to make them.
        $forced_breakpoint_count++;
        return;
    } ## end sub set_fake_breakpoint

    use constant DEBUG_FORCE => 0;

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

        # Set a breakpoint AFTER the token at index $i in the _to_go arrays.

        # Exceptions:
        # - If the token at index $i is a blank, backup to $i-1 to
        #   get to the previous nonblank token.
        # - For certain tokens, the break may be placed BEFORE the token
        #   at index $i, depending on user break preference settings.
        # - If a break is made after an opening token, then a break will
        #   also be made before the corresponding closing token.

        # Returns: $i_nonblank
        #   = index of the token after which the breakpoint was actually placed
        #   = undef if breakpoint was not set.
        my $i_nonblank;

        if ( !defined($i) || $i < 0 ) {

            # Calls with bad index $i are harmless but waste time and should
            # be caught and eliminated during code development.
            if (DEVEL_MODE) {
                my ( $a, $b, $c ) = caller();
                Fault(
"Bad call to forced breakpoint from $a $b $c ; called with i=$i; please fix\n"
                );
            }
            return;
        }

        # Break after token $i
        $i_nonblank = $self->set_forced_breakpoint_AFTER($i);

        # If we break at an opening container..break at the closing
        my $set_closing;
        if ( defined($i_nonblank)
            && $is_opening_sequence_token{ $tokens_to_go[$i_nonblank] } )
        {
            $set_closing = 1;
            $self->set_closing_breakpoint($i_nonblank);
        }

        DEBUG_FORCE && do {
            my ( $pkg, $file_uu, $lno ) = caller();
            my $msg =
"FORCE $forced_breakpoint_count after call from $pkg $lno with i=$i max=$max_index_to_go";
            if ( !defined($i_nonblank) ) {
                $i = EMPTY_STRING unless defined($i);
                $msg .= " but could not set break after i='$i'\n";
            }
            else {
                my $nobr = $nobreak_to_go[$i_nonblank];
                $nobr = 0 if ( !defined($nobr) );
                $msg .= <<EOM;
set break after $i_nonblank: tok=$tokens_to_go[$i_nonblank] type=$types_to_go[$i_nonblank] nobr=$nobr
EOM
                if ( defined($set_closing) ) {
                    $msg .=
" Also set closing breakpoint corresponding to this token\n";
                }
            }
            print {*STDOUT} $msg;
        };

        return $i_nonblank;
    } ## end sub set_forced_breakpoint

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

        # Set a breakpoint AFTER the token at index $i in the _to_go arrays.

        # Exceptions:
        # - If the token at index $i is a blank, backup to $i-1 to
        #   get to the previous nonblank token.
        # - For certain tokens, the break may be placed BEFORE the token
        #   at index $i, depending on user break preference settings.

        # Returns:
        #   - the index of the token after which the break was set, or
        #   - undef if no break was set

        # This routine is only called by sub set_forced_breakpoint and
        # sub set_closing_breakpoint.

        return if ( !defined($i) );
        return if ( $i < 0 );

        # Back up at a blank so we have a token to examine.
        # This was added to fix for cases like b932 involving an '=' break.
        if ( $i > 0 && $types_to_go[$i] eq 'b' ) { $i-- }

        # Never break between welded tokens
        return
          if ( $total_weld_count
            && $self->[_rK_weld_right_]->{ $K_to_go[$i] } );

        my $token = $tokens_to_go[$i];
        my $type  = $types_to_go[$i];

        # patch for phantom commas, used for -qwaf
        if ( !$token && $type eq ',' ) { $token = ',' }

        # For certain tokens, use user settings to decide if we break before or
        # after it
        if ( $break_before_or_after_token{$token}
            && ( $type eq $token || $type eq 'k' ) )
        {
            if ( $want_break_before{$token} && $i >= 0 ) { $i-- }
        }

        # breaks are forced before 'if' and 'unless'
        elsif ( $is_if_unless{$token} && $type eq 'k' ) { $i-- }
        else {
            # do not break before
        }

        if ( $i >= 0 && $i <= $max_index_to_go ) {
            my $i_nonblank = ( $types_to_go[$i] ne 'b' ) ? $i : $i - 1;

            if (   $i_nonblank >= 0
                && !$nobreak_to_go[$i_nonblank]
                && !$forced_breakpoint_to_go[$i_nonblank] )
            {
                $forced_breakpoint_to_go[$i_nonblank] = 1;

                if ( $i_nonblank > $index_max_forced_break ) {
                    $index_max_forced_break = $i_nonblank;
                }
                $forced_breakpoint_count++;
                $forced_breakpoint_undo_stack[ $forced_breakpoint_undo_count++ ]
                  = $i_nonblank;

                # success
                return $i_nonblank;
            }
        }
        return;
    } ## end sub set_forced_breakpoint_AFTER

    sub clear_breakpoint_undo_stack {
        my ($self) = @_;
        $forced_breakpoint_undo_count = 0;
        return;
    }

    use constant DEBUG_UNDOBP => 0;

    sub undo_forced_breakpoint_stack {

        my ( $self, $i_start ) = @_;

        # Given $i_start, a non-negative index the 'undo stack' of breakpoints,
        # remove all breakpoints from the top of the 'undo stack' down to and
        # including index $i_start.

        # The 'undo stack' is a stack of all breakpoints made for a batch of
        # code.

        if ( $i_start < 0 ) {
            $i_start = 0;
            my ( $pkg, $file_uu, $lno ) = caller();

            # Bad call, can only be due to a recent programming change.
            Fault(
"Program Bug: undo_forced_breakpoint_stack from $pkg $lno has bad i=$i_start "
            ) if (DEVEL_MODE);
            return;
        }

        while ( $forced_breakpoint_undo_count > $i_start ) {
            $forced_breakpoint_undo_count--;
            my $i =
              $forced_breakpoint_undo_stack[$forced_breakpoint_undo_count];
            if ( $i >= 0 && $i <= $max_index_to_go ) {
                $forced_breakpoint_to_go[$i] = 0;
                $forced_breakpoint_count--;

                DEBUG_UNDOBP && do {
                    my ( $pkg, $file_uu, $lno ) = caller();
                    print {*STDOUT}
"UNDOBP: undo forced_breakpoint i=$i $forced_breakpoint_undo_count from $pkg $lno max=$max_index_to_go\n";
                };
            }

            # shouldn't happen, but not a critical error
            else {
                if (DEVEL_MODE) {
                    my ( $pkg, $file_uu, $lno ) = caller();
                    Fault(<<EOM);
Program Bug: undo_forced_breakpoint from $pkg $lno has i=$i but max=$max_index_to_go
EOM
                }
            }
        } ## end while ( $forced_breakpoint_undo_count...)
        return;
    } ## end sub undo_forced_breakpoint_stack
} ## end closure set_forced_breakpoint

{    ## begin closure set_closing_breakpoint

    my %postponed_breakpoint;

    sub initialize_postponed_breakpoint {
        %postponed_breakpoint = ();
        return;
    }

    sub has_postponed_breakpoint {
        my ($seqno) = @_;
        return $postponed_breakpoint{$seqno};
    }

    sub set_closing_breakpoint {

        my ( $self, $i_break ) = @_;

        # Set a breakpoint at a matching closing token
        # Given:
        #   $i_break = index of the opening token

        if ( defined( $mate_index_to_go[$i_break] ) ) {

            # Don't reduce the '2' in the statement below.
            # Test files: attrib.t, BasicLyx.pm.html
            if ( $mate_index_to_go[$i_break] > $i_break + 2 ) {

             # break before } ] and ), but sub set_forced_breakpoint will decide
             # to break before or after a ? and :
                my $inc = ( $tokens_to_go[$i_break] eq '?' ) ? 0 : 1;
                $self->set_forced_breakpoint_AFTER(
                    $mate_index_to_go[$i_break] - $inc );
            }
        }
        else {
            my $type_sequence = $type_sequence_to_go[$i_break];
            if ($type_sequence) {
                $postponed_breakpoint{$type_sequence} = 1;
            }
        }
        return;
    } ## end sub set_closing_breakpoint
} ## end closure set_closing_breakpoint

#########################################
# CODE SECTION 9: Process batches of code
#########################################

{    ## begin closure grind_batch_of_CODE

    # The routines in this closure begin the processing of a 'batch' of code.

    # A variable to keep track of consecutive nonblank lines so that we can
    # insert occasional blanks
    my @nonblank_lines_at_depth;

    # A variable to remember maximum size of previous batches; this is needed
    # by the logical padding routine
    my $peak_batch_size;
    my $batch_count;

    # variables to keep track of indentation of unmatched containers.
    my %saved_opening_indentation;

    sub initialize_grind_batch_of_CODE {
        @nonblank_lines_at_depth   = ();
        $peak_batch_size           = 0;
        $batch_count               = 0;
        %saved_opening_indentation = ();
        return;
    } ## end sub initialize_grind_batch_of_CODE

    # sub grind_batch_of_CODE receives sections of code which are the longest
    # possible lines without a break.  In other words, it receives what is left
    # after applying all breaks forced by blank lines, block comments, side
    # comments, pod text, and structural braces.  Its job is to break this code
    # down into smaller pieces, if necessary, which fit within the maximum
    # allowed line length.  Then it sends the resulting lines of code on down
    # the pipeline to the VerticalAligner package, breaking the code into
    # continuation lines as necessary.  The batch of tokens are in the "to_go"
    # arrays.  The name 'grind' is slightly suggestive of a machine continually
    # breaking down long lines of code, but mainly it is unique and easy to
    # remember and find with an editor search.

    # The two routines 'process_line_of_CODE' and 'grind_batch_of_CODE' work
    # together in the following way:

    # - 'process_line_of_CODE' receives the original INPUT lines one-by-one and
    # combines them into the largest sequences of tokens which might form a new
    # line.
    # - 'grind_batch_of_CODE' determines which tokens will form the OUTPUT
    # lines.

    # So sub 'process_line_of_CODE' builds up the longest possible continuous
    # sequences of tokens, regardless of line length, and then
    # grind_batch_of_CODE breaks these sequences back down into the new output
    # lines.

    # Sub 'grind_batch_of_CODE' ships its output lines to the vertical aligner.

    use constant DEBUG_GRIND => 0;

    sub check_grind_input {

        my ($self) = @_;

        # Check for valid input to sub grind_batch_of_CODE.  An error here
        # would most likely be due to an error in 'sub store_token_to_go'.
        # NOTE: This is only called when DEVEL_MODE is set.

        # Be sure there are tokens in the batch
        if ( $max_index_to_go < 0 ) {
            Fault(<<EOM);
sub grind incorrectly called with max_index_to_go=$max_index_to_go
EOM
        }
        my $Klimit = $self->[_Klimit_];

        # The local batch tokens must be a continuous part of the global token
        # array.
        my $KK;
        foreach my $ii ( 0 .. $max_index_to_go ) {

            my $Km = $KK;

            $KK = $K_to_go[$ii];
            if ( !defined($KK) || $KK < 0 || $KK > $Klimit ) {
                $KK = '(undef)' unless defined($KK);
                Fault(<<EOM);
at batch index at i=$ii, the value of K_to_go[$ii] = '$KK' is out of the valid range (0 - $Klimit)
EOM
            }

            if ( $ii > 0 && $KK != $Km + 1 ) {
                my $im = $ii - 1;
                Fault(<<EOM);
Non-sequential K indexes: i=$im has Km=$Km; but i=$ii has K=$KK;  expecting K = Km+1
EOM
            }
        }
        return;
    } ## end sub check_grind_input

    # This filter speeds up a critical if-test
    my %quick_filter;

    BEGIN {
        my @q = qw# L { ( [ R ] ) } ? : f => #;
        push @q, ',';
        @quick_filter{@q} = (1) x scalar(@q);
    }

    sub grind_batch_of_CODE {

        my ($self) = @_;

        #-----------------------------------------------------------------
        # This sub directs the formatting of one complete batch of tokens.
        # The tokens of the batch are in the '_to_go' arrays.
        #-----------------------------------------------------------------

        # $this_batch = ref to array of vars for this output batch
        my $this_batch = $self->[_this_batch_];

        $this_batch->[_peak_batch_size_] = $peak_batch_size;
        $this_batch->[_batch_count_]     = ++$batch_count;

        $self->check_grind_input() if (DEVEL_MODE);

        # This routine is only called from sub flush_batch_of_code, so that
        # routine is a better spot for debugging.
        DEBUG_GRIND && do {
            my $token = my $type = EMPTY_STRING;
            if ( $max_index_to_go >= 0 ) {
                $token = $tokens_to_go[$max_index_to_go];
                $type  = $types_to_go[$max_index_to_go];
            }
            my $output_str = EMPTY_STRING;
            if ( $max_index_to_go > 20 ) {
                my $mm = $max_index_to_go - 10;
                $output_str =
                  join( EMPTY_STRING, @tokens_to_go[ 0 .. 10 ] ) . " ... "
                  . join( EMPTY_STRING,
                    @tokens_to_go[ $mm .. $max_index_to_go ] );
            }
            else {
                $output_str = join EMPTY_STRING,
                  @tokens_to_go[ 0 .. $max_index_to_go ];
            }
            print {*STDOUT} <<EOM;
grind got batch number $batch_count with $max_index_to_go tokens, last type '$type' tok='$token', text:
$output_str
EOM
        };

        # Remove any trailing blank, which is possible (c192 has example)
        if ( $max_index_to_go >= 0 && $types_to_go[$max_index_to_go] eq 'b' ) {
            $max_index_to_go -= 1;
        }

        return if ( $max_index_to_go < 0 );

        my $lp_object_count_this_batch;
        if ($rOpts_line_up_parentheses) {
            $lp_object_count_this_batch = $self->set_lp_indentation();
        }

        #-----------------------------
        # Shortcut for block comments.
        #-----------------------------

        my $is_HSC;

        if (  !$max_index_to_go
            && $types_to_go[0] eq '#' )
        {

            # But not for block comments with lp because they must use the lp
            # corrector step below.
            # And not for hanging side comments.

            my $batch_CODE_type = $this_batch->[_batch_CODE_type_];
            $is_HSC = $batch_CODE_type && $batch_CODE_type eq 'HSC';

            if (   !$is_HSC
                && !$lp_object_count_this_batch )
            {
                my $ibeg = 0;
                $this_batch->[_ri_first_] = [$ibeg];
                $this_batch->[_ri_last_]  = [$ibeg];

                $self->convey_batch_to_vertical_aligner();

                my $level = $levels_to_go[$ibeg];
                $self->[_last_line_leading_type_]  = $types_to_go[$ibeg];
                $self->[_last_line_leading_level_] = $level;
                $nonblank_lines_at_depth[$level]   = 1;
                return;
            }
        }

        #-------------
        # Normal route
        #-------------

        my $rLL = $self->[_rLL_];

        #-------------------------------------------------------
        # Loop over the batch to initialize some batch variables
        #-------------------------------------------------------
        my $comma_count_in_batch = 0;
        my @colon_list;
        my @ix_seqno_controlling_ci;
        my %comma_arrow_count;
        my $comma_arrow_count_contained = 0;
        my @unmatched_closing_indexes_in_this_batch;
        my @unmatched_opening_indexes_in_this_batch;

        my @i_for_semicolon;
        foreach my $i ( 0 .. $max_index_to_go ) {

            if ( $types_to_go[$i] eq 'b' ) {
                $inext_to_go[$i] = $inext_to_go[ $i - 1 ] = $i + 1;
                next;
            }

            $inext_to_go[$i] = $i + 1;

            # This is an optional shortcut to save a bit of time by skipping
            # most tokens.  Note: the filter may need to be updated if the
            # next 'if' tests are ever changed to include more token types.
            next if ( !$quick_filter{ $types_to_go[$i] } );

            my $type = $types_to_go[$i];

            # gather info needed by sub break_long_lines
            if ( $type_sequence_to_go[$i] ) {

                # remember indexes of any tokens controlling xci
                # in this batch. This list is needed by sub undo_ci.
                my $seqno = $type_sequence_to_go[$i];
                if ( $self->[_ris_seqno_controlling_ci_]->{$seqno} ) {
                    push @ix_seqno_controlling_ci, $i;
                }

                if ( $is_opening_sequence_token{ $tokens_to_go[$i] } ) {
                    if ( $self->[_rbreak_container_]->{$seqno} ) {
                        $self->set_forced_breakpoint($i);
                    }
                    push @unmatched_opening_indexes_in_this_batch, $i;
                    if ( $type eq '?' ) {
                        push @colon_list, $type;
                    }
                }
                else {    ##  $is_closing_sequence_token{$token}

                    if ( $i > 0 && $self->[_rbreak_container_]->{$seqno} ) {
                        $self->set_forced_breakpoint( $i - 1 );
                    }

                    my $i_mate = pop @unmatched_opening_indexes_in_this_batch;
                    if ( defined($i_mate) && $i_mate >= 0 ) {
                        if ( $type_sequence_to_go[$i_mate] ==
                            $type_sequence_to_go[$i] )
                        {
                            $mate_index_to_go[$i]      = $i_mate;
                            $mate_index_to_go[$i_mate] = $i;
                            my $cac = $comma_arrow_count{$seqno};
                            $comma_arrow_count_contained += $cac if ($cac);
                        }
                        else {
                            push @unmatched_opening_indexes_in_this_batch,
                              $i_mate;
                            push @unmatched_closing_indexes_in_this_batch, $i;
                        }
                    }
                    else {
                        push @unmatched_closing_indexes_in_this_batch, $i;
                    }
                    if ( $type eq ':' ) {
                        push @colon_list, $type;
                    }
                }

            } ## end if ($seqno)

            elsif ( $type eq ',' ) { $comma_count_in_batch++; }
            elsif ( $type eq '=>' ) {
                if (@unmatched_opening_indexes_in_this_batch) {
                    my $j     = $unmatched_opening_indexes_in_this_batch[-1];
                    my $seqno = $type_sequence_to_go[$j];
                    $comma_arrow_count{$seqno}++;
                }
            }
            elsif ( $type eq 'f' ) {
                push @i_for_semicolon, $i;
            }
            else {
                ## not a special type
            }

        } ## end for ( my $i = 0 ; $i <=...)

        # Break at a single interior C-style for semicolon in this batch (c154)
        if ( @i_for_semicolon && @i_for_semicolon == 1 ) {
            my $i     = $i_for_semicolon[0];
            my $inext = $inext_to_go[$i];
            if ( $inext <= $max_index_to_go && $types_to_go[$inext] ne '#' ) {
                $self->set_forced_breakpoint($i);
            }
        }

        my $is_unbalanced_batch = @unmatched_opening_indexes_in_this_batch +
          @unmatched_closing_indexes_in_this_batch;

        if (@unmatched_opening_indexes_in_this_batch) {
            $this_batch->[_runmatched_opening_indexes_] =
              \@unmatched_opening_indexes_in_this_batch;
        }

        if (@ix_seqno_controlling_ci) {
            $this_batch->[_rix_seqno_controlling_ci_] =
              \@ix_seqno_controlling_ci;
        }

        #------------------------
        # Set special breakpoints
        #------------------------
        # If this line ends in a code block brace, set breaks at any
        # previous closing code block braces to breakup a chain of code
        # blocks on one line.  This is very rare but can happen for
        # user-defined subs.  For example we might be looking at this:
        #  BOOL { $server_data{uptime} > 0; } NUM { $server_data{load}; } STR {
        my $saw_good_break;    # flag to force breaks even if short line
        if (

            # looking for opening or closing block brace
            $block_type_to_go[$max_index_to_go]

            # never any good breaks if just one token
            && $max_index_to_go > 0

            # but not one of these which are never duplicated on a line:
            # until|while|for|if|elsif|else
            && !$is_block_without_semicolon{ $block_type_to_go[$max_index_to_go]
            }
          )
        {
            my $lev = $nesting_depth_to_go[$max_index_to_go];

            # Walk backwards from the end and
            # set break at any closing block braces at the same level.
            # But quit if we are not in a chain of blocks.
            foreach my $i ( reverse( 0 .. $max_index_to_go - 1 ) ) {
                last if ( $levels_to_go[$i] < $lev );   # stop at a lower level
                next if ( $levels_to_go[$i] > $lev );   # skip past higher level

                if ( $block_type_to_go[$i] ) {
                    if ( $tokens_to_go[$i] eq '}' ) {
                        $self->set_forced_breakpoint($i);
                        $saw_good_break = 1;
                    }
                }

                # quit if we see anything besides words, function, blanks
                # at this level
                elsif ( $types_to_go[$i] !~ /^[\(\)Gwib]$/ ) { last }
                else {
                    ## keep going
                }
            }
        }

        #-----------------------------------------------
        # insertion of any blank lines before this batch
        #-----------------------------------------------

        my $imin = 0;
        my $imax = $max_index_to_go;

        # trim any blank tokens - for safety, but should not be necessary
        if ( $types_to_go[$imin] eq 'b' ) { $imin++ }
        if ( $types_to_go[$imax] eq 'b' ) { $imax-- }

        if ( $imin > $imax ) {
            if (DEVEL_MODE) {
                my $K0  = $K_to_go[0];
                my $lno = EMPTY_STRING;
                if ( defined($K0) ) { $lno = $rLL->[$K0]->[_LINE_INDEX_] + 1 }
                Fault(<<EOM);
Strange: received batch containing only blanks near input line $lno: after trimming imin=$imin, imax=$imax
EOM
            }
            return;
        }

        my $last_line_leading_type  = $self->[_last_line_leading_type_];
        my $last_line_leading_level = $self->[_last_line_leading_level_];

        my $leading_type  = $types_to_go[0];
        my $leading_level = $levels_to_go[0];

        # add blank line(s) before certain key types but not after a comment
        if ( $last_line_leading_type ne '#' ) {
            my $blank_count   = 0;
            my $leading_token = $tokens_to_go[0];

            # break before certain key blocks except one-liners
            if ( $leading_type eq 'k' ) {
                if ( $leading_token eq 'BEGIN' || $leading_token eq 'END' ) {
                    $blank_count = $rOpts->{'blank-lines-before-subs'}
                      if ( terminal_type_i( 0, $max_index_to_go ) ne '}' );
                }

                # Break before certain block types if we haven't had a
                # break at this level for a while.  This is the
                # difficult decision..
                elsif ($last_line_leading_type ne 'b'
                    && $is_if_unless_while_until_for_foreach{$leading_token} )
                {
                    my $lc = $nonblank_lines_at_depth[$last_line_leading_level];
                    if ( !defined($lc) ) { $lc = 0 }

                    # patch for RT #128216: no blank line inserted at a level
                    # change
                    if ( $levels_to_go[0] != $last_line_leading_level ) {
                        $lc = 0;
                    }

                    if (   $rOpts->{'blanks-before-blocks'}
                        && $lc >= $rOpts->{'long-block-line-count'}
                        && $self->consecutive_nonblank_lines() >=
                        $rOpts->{'long-block-line-count'}
                        && terminal_type_i( 0, $max_index_to_go ) ne '}' )
                    {
                        $blank_count = 1;
                    }
                }
                else {
                    # no blank line needed
                }
            }

            # blank lines before subs except declarations and one-liners
            # Fix for c250: added new type 'P', changed 'i' to 'S'
            elsif ( $leading_type eq 'S' || $leading_type eq 'P' ) {
                my $special_identifier =
                  $self->[_ris_special_identifier_token_]->{$leading_token};
                if ($special_identifier) {
                    ##   $leading_token =~ /$SUB_PATTERN/
                    if ( $special_identifier eq 'sub' ) {

                        $blank_count = $rOpts->{'blank-lines-before-subs'}
                          if ( terminal_type_i( 0, $max_index_to_go ) !~
                            /^[\;\}\,]$/ );
                    }

                    # break before all package declarations
                    ##      substr( $leading_token, 0, 8 ) eq 'package '
                    elsif ( $special_identifier eq 'package' ) {

                        # ... except in a very short eval block
                        my $pseqno = $parent_seqno_to_go[0];
                        $blank_count = $rOpts->{'blank-lines-before-packages'}
                          if (
                            !$self->[_ris_short_broken_eval_block_]->{$pseqno}
                          );
                    }
                    else {
                        DEVEL_MODE && Fault(<<EOM);
Found special identifier '$special_identifier', but expecting 'sub' or 'package'
EOM
                    }
                }
            }

            # Check for blank lines wanted before a closing brace
            elsif ( $leading_token eq '}' ) {
                if (   $rOpts->{'blank-lines-before-closing-block'}
                    && $block_type_to_go[0]
                    && $block_type_to_go[0] =~
                    /$blank_lines_before_closing_block_pattern/ )
                {
                    my $nblanks = $rOpts->{'blank-lines-before-closing-block'};
                    if ( $nblanks > $blank_count ) {
                        $blank_count = $nblanks;
                    }
                }
            }
            else {
                # no blank line needed
            }

            if ($blank_count) {

                # future: send blank line down normal path to VerticalAligner?
                $self->flush_vertical_aligner();
                my $file_writer_object = $self->[_file_writer_object_];
                $file_writer_object->require_blank_code_lines($blank_count);
            }
        }

        # update blank line variables and count number of consecutive
        # non-blank, non-comment lines at this level
        if (   $leading_level == $last_line_leading_level
            && ( $leading_type ne '#' || $is_HSC )
            && defined( $nonblank_lines_at_depth[$leading_level] ) )
        {
            $nonblank_lines_at_depth[$leading_level]++;
        }
        else {
            $nonblank_lines_at_depth[$leading_level] = 1;
        }

        $self->[_last_line_leading_type_]  = $is_HSC ? 'q' : $leading_type;
        $self->[_last_line_leading_level_] = $leading_level;

        #--------------------------
        # scan lists and long lines
        #--------------------------

        # Flag to remember if we called sub 'pad_array_to_go'.
        # Some routines (break_lists(), break_long_lines() ) need some
        # extra tokens added at the end of the batch.  Most batches do not
        # use these routines, so we will avoid calling 'pad_array_to_go'
        # unless it is needed.
        my $called_pad_array_to_go;

        # set all forced breakpoints for good list formatting
        my $is_long_line;
        my $multiple_old_lines_in_batch;
        if ( $max_index_to_go > 0 ) {
            $is_long_line =
              $self->excess_line_length( $imin, $max_index_to_go ) > 0;

            my $Kbeg = $K_to_go[0];
            my $Kend = $K_to_go[$max_index_to_go];
            $multiple_old_lines_in_batch =
              $rLL->[$Kend]->[_LINE_INDEX_] - $rLL->[$Kbeg]->[_LINE_INDEX_];
        }

        # Optional optimization: avoid calling break_lists for a single block
        # brace.  This is done by turning off the flag $is_unbalanced_batch.
        elsif ($is_unbalanced_batch) {
            my $block_type = $block_type_to_go[0];
            if (   $block_type
                && !$lp_object_count_this_batch
                && $is_block_without_semicolon{$block_type} )
            {
                # opening blocks can skip break_lists call if no commas in
                # container.
                if ( $leading_type eq '{' ) {
                    my $seqno       = $type_sequence_to_go[0];
                    my $rtype_count = $self->[_rtype_count_by_seqno_]->{$seqno};
                    if ($rtype_count) {
                        my $comma_count = $rtype_count->{','};
                        if ( !$comma_count ) {
                            $is_unbalanced_batch = 0;
                        }
                    }
                }

                # closing block braces can be skipped
                else {
                    $is_unbalanced_batch = 0;
                }

            }
        }
        else {
            # single balanced token
        }

        my $rbond_strength_bias = [];
        if (
               $is_long_line
            || $multiple_old_lines_in_batch

            # must always call break_lists() with unbalanced batches because
            # it is maintaining some stacks
            || $is_unbalanced_batch

            # call break_lists if we might want to break at commas
            || (
                $comma_count_in_batch
                && (   $rOpts_maximum_fields_per_table > 0
                    && $rOpts_maximum_fields_per_table <= $comma_count_in_batch
                    || $rOpts_comma_arrow_breakpoints == 0 )
            )

            # call break_lists if user may want to break open some one-line
            # hash references
            || (   $comma_arrow_count_contained
                && $rOpts_comma_arrow_breakpoints != 3 )
          )
        {
            # add a couple of extra terminal blank tokens
            $self->pad_array_to_go();
            $called_pad_array_to_go = 1;

            my $sgb = $self->break_lists( $is_long_line, $rbond_strength_bias );
            $saw_good_break ||= $sgb;
        }

        # let $ri_first and $ri_last be references to lists of
        # first and last tokens of line fragments to output..
        my ( $ri_first, $ri_last );

        #-----------------------------
        # a single token uses one line
        #-----------------------------
        if ( !$max_index_to_go ) {
            $ri_first = [$imin];
            $ri_last  = [$imax];
        }

        # for multiple tokens
        else {

            #-------------------------
            # write a single line if..
            #-------------------------
            if (
                (

                    # this line is 'short'
                    !$is_long_line

                    # and we didn't see a good breakpoint
                    && !$saw_good_break

                    # and we don't already have an interior breakpoint
                    && !$forced_breakpoint_count
                )

                # or, we aren't allowed to add any newlines
                || !$rOpts_add_newlines

              )
            {
                $ri_first = [$imin];
                $ri_last  = [$imax];
            }

            #-----------------------------
            # otherwise use multiple lines
            #-----------------------------
            else {

                # add a couple of extra terminal blank tokens if we haven't
                # already done so
                $self->pad_array_to_go() unless ($called_pad_array_to_go);

                ( $ri_first, $ri_last, my $rbond_strength_to_go ) =
                  $self->break_long_lines( $saw_good_break, \@colon_list,
                    $rbond_strength_bias );

                $self->break_all_chain_tokens( $ri_first, $ri_last );

                $self->break_method_call_chains( $ri_first, $ri_last )
                  if ( %{ $self->[_rseqno_arrow_call_chain_start_] } );

                $self->break_equals( $ri_first, $ri_last )
                  if @{$ri_first} >= 3;

                # now we do a correction step to clean this up a bit
                # (The only time we would not do this is for debugging)
                $self->recombine_breakpoints( $ri_first, $ri_last,
                    $rbond_strength_to_go )
                  if ( $rOpts_recombine && @{$ri_first} > 1 );

                $self->insert_final_ternary_breaks( $ri_first, $ri_last )
                  if (@colon_list);
            }

            $self->insert_breaks_before_list_opening_containers( $ri_first,
                $ri_last )
              if ( %break_before_container_types && $max_index_to_go > 0 );

            # Check for a phantom semicolon at the end of the batch
            if ( !$token_lengths_to_go[$imax] && $types_to_go[$imax] eq ';' ) {
                $self->unmask_phantom_token($imax);
            }

            if ( $rOpts_one_line_block_semicolons == 0 ) {
                $self->delete_one_line_semicolons( $ri_first, $ri_last );
            }

            # Remember the largest batch size processed. This is needed by the
            # logical padding routine to avoid padding the first nonblank token
            if ( $max_index_to_go > $peak_batch_size ) {
                $peak_batch_size = $max_index_to_go;
            }
        }

        # The batch has now been divided into lines
        $this_batch->[_ri_first_] = $ri_first;
        $this_batch->[_ri_last_]  = $ri_last;

        #-------------------
        # -lp corrector step
        #-------------------
        if ($lp_object_count_this_batch) {
            $self->correct_lp_indentation();
        }

        #--------------------
        # ship this batch out
        #--------------------
        $self->convey_batch_to_vertical_aligner();

        #-------------------------------------------------------------------
        # Write requested number of blank lines after an opening block brace
        #-------------------------------------------------------------------
        if ($rOpts_blank_lines_after_opening_block) {
            my $iterm = $imax;
            if ( $types_to_go[$iterm] eq '#' && $iterm > $imin ) {
                $iterm -= 1;
                if ( $types_to_go[$iterm] eq 'b' && $iterm > $imin ) {
                    $iterm -= 1;
                }
            }

            if (   $types_to_go[$iterm] eq '{'
                && $block_type_to_go[$iterm]
                && $block_type_to_go[$iterm] =~
                /$blank_lines_after_opening_block_pattern/ )
            {
                my $nblanks = $rOpts_blank_lines_after_opening_block;
                $self->flush_vertical_aligner();
                my $file_writer_object = $self->[_file_writer_object_];
                $file_writer_object->require_blank_code_lines($nblanks);
            }
        }

        return;
    } ## end sub grind_batch_of_CODE

    sub iprev_to_go {
        my ($i) = @_;

        # Given index $i of a token in the '_to_go' arrays, return
        # the index of the previous nonblank token.
        return $i - 1 > 0
          && $types_to_go[ $i - 1 ] eq 'b' ? $i - 2 : $i - 1;
    } ## end sub iprev_to_go

    sub unmask_phantom_token {
        my ( $self, $iend ) = @_;

        # Turn a phantom token into a real token.

        # Input parameter:
        #   $iend = the index in the output batch array of this token.

        # Phantom tokens are specially marked token types (such as ';')  with
        # no token text which only become real tokens if they occur at the end
        # of an output line.  At one time phantom ',' tokens were handled
        # here, but now they are processed elsewhere.

        my $rLL         = $self->[_rLL_];
        my $KK          = $K_to_go[$iend];
        my $line_number = 1 + $rLL->[$KK]->[_LINE_INDEX_];

        my $type = $types_to_go[$iend];
        return unless ( $type eq ';' );
        my $tok     = $type;
        my $tok_len = length($tok);
        if ( $want_left_space{$type} != WS_NO ) {
            $tok = SPACE . $tok;
            $tok_len += 1;
        }

        $tokens_to_go[$iend]        = $tok;
        $token_lengths_to_go[$iend] = $tok_len;

        $rLL->[$KK]->[_TOKEN_]        = $tok;
        $rLL->[$KK]->[_TOKEN_LENGTH_] = $tok_len;

        $self->note_added_semicolon($line_number);

        # This changes the summed lengths of the rest of this batch
        foreach ( $iend .. $max_index_to_go ) {
            $summed_lengths_to_go[ $_ + 1 ] += $tok_len;
        }
        return;
    } ## end sub unmask_phantom_token

    sub save_opening_indentation {

        my ( $self, $rindentation_list ) = @_;

        # Save indentations of lines of all unmatched opening tokens.
        # These will be used by sub get_opening_indentation.
        # This should be called after each batch of tokens is output.

        # Given:
        #   $rindentation_list = ref to indentations for each line

        # $runmatched_opening_indexes = list of indexes of unmatched tokens
        my $this_batch = $self->[_this_batch_];
        my $runmatched_opening_indexes =
          $this_batch->[_runmatched_opening_indexes_];

        $runmatched_opening_indexes = []
          if ( !defined($runmatched_opening_indexes) );

        # QW INDENTATION PATCH 1:
        # Also save indentation for multiline qw quotes
        my @i_qw;
        my $seqno_qw_opening;
        if ( $types_to_go[$max_index_to_go] eq 'q' ) {
            my $KK = $K_to_go[$max_index_to_go];
            $seqno_qw_opening =
              $self->[_rstarting_multiline_qw_seqno_by_K_]->{$KK};
            if ($seqno_qw_opening) {
                push @i_qw, $max_index_to_go;
            }
        }

        # we need to save indentations of any unmatched opening tokens
        # in this batch because we may need them in a subsequent batch.
        foreach my $i_opening ( @{$runmatched_opening_indexes}, @i_qw ) {

            my $seqno = $type_sequence_to_go[$i_opening];

            if ( !$seqno ) {
                if ( $seqno_qw_opening && $i_opening == $max_index_to_go ) {
                    $seqno = $seqno_qw_opening;
                }
                else {

                    # shouldn't happen
                    $seqno = 'UNKNOWN';
                    DEVEL_MODE && Fault("unable to find sequence number\n");
                }
            }

            $saved_opening_indentation{$seqno} = [
                $self->lookup_opening_indentation(
                    $i_opening, $rindentation_list
                )
            ];
        }
        return;
    } ## end sub save_opening_indentation

    sub get_saved_opening_indentation {

        my ($seqno) = @_;

        # Lookup indentation of an output line with a given container token

        # Given:
        #   $seqno = sequence number of a container token

        my ( $indent, $offset, $is_leading, $exists ) = ( 0, 0, 0, 0 );

        if ($seqno) {
            if ( $saved_opening_indentation{$seqno} ) {
                ( $indent, $offset, $is_leading ) =
                  @{ $saved_opening_indentation{$seqno} };
                $exists = 1;
            }
        }

        # some kind of serious error it doesn't exist
        # (example is badfile.t)

        return ( $indent, $offset, $is_leading, $exists );
    } ## end sub get_saved_opening_indentation
} ## end closure grind_batch_of_CODE

sub lookup_opening_indentation {

    my ( $self, $i_opening, $rindentation_list ) = @_;

    # Get the indentation of the line in the current output batch
    # which output a selected opening token
    #
    # Given:
    #   $i_opening - index of an opening token in the current output batch
    #                whose line indentation we need
    #   $rindentation_list - reference to a list containing the indentation
    #            used for each line.  (NOTE: the first slot in
    #            this list is the last returned line number, and this is
    #            followed by the list of indentations).
    #
    # Return
    #   -the indentation of the line which contained token $i_opening
    #   -and its offset (number of columns) from the start of the line

    # $ri_first - reference to list of the first index $i for each output
    #  line in this batch
    # $ri_last - reference to list of the last index $i for each output
    #  line in this batch
    my $this_batch = $self->[_this_batch_];
    my $ri_first   = $this_batch->[_ri_first_];
    my $ri_last    = $this_batch->[_ri_last_];

    if ( !@{$ri_last} ) {

        # An error here implies a bug introduced by a recent program change.
        # Every batch of code has lines, so this should never happen.
        if (DEVEL_MODE) {
            Fault("Error in opening_indentation: no lines");
        }
        return ( 0, 0, 0 );
    }

    my $nline = $rindentation_list->[0];    # line number of previous lookup

    # reset line location if necessary
    $nline = 0 if ( $i_opening < $ri_first->[$nline] );

    # find the correct line
    if ( $i_opening <= $ri_last->[-1] ) {
        while ( $i_opening > $ri_last->[$nline] ) { $nline++; }
    }

    # Error - token index is out of bounds - shouldn't happen
    # A program bug has been introduced in one of the calling routines.
    # We better stop here.
    else {
        my $i_last_line = $ri_last->[-1];
        if (DEVEL_MODE) {
            Fault(<<EOM);
Program bug in call to lookup_opening_indentation - index out of range
 called with index i_opening=$i_opening  > $i_last_line = max index of last line
This batch has max index = $max_index_to_go,
EOM
        }
        $nline = $#{$ri_last};
    }

    $rindentation_list->[0] =
      $nline;    # save line number to start looking next call
    my $ibeg       = $ri_first->[$nline];
    my $offset     = token_sequence_length( $ibeg, $i_opening ) - 1;
    my $is_leading = ( $ibeg == $i_opening );
    return ( $rindentation_list->[ $nline + 1 ], $offset, $is_leading );
} ## end sub lookup_opening_indentation

sub terminal_type_i {

    my ( $ibeg, $iend ) = @_;

    # Given:
    #  ($ibeg, $iend) = index range of the current output buffer line
    # Returns type of last token on this line (terminal token), as follows:
    #   # for a full-line comment
    #   ' ' for a blank line
    #   otherwise returns final token type

    # Start at the end and work backwards
    my $i      = $iend;
    my $type_i = $types_to_go[$i];

    # Check for side comment
    if ( $type_i eq '#' ) {
        $i--;
        if ( $i < $ibeg ) {
            return $type_i;
        }
        $type_i = $types_to_go[$i];
    }

    # Skip past a blank
    if ( $type_i eq 'b' ) {
        $i--;
        if ( $i < $ibeg ) {
            return $type_i;
        }
        $type_i = $types_to_go[$i];
    }

    # Found it..make sure it is a BLOCK termination,
    # but hide a terminal } after sort/map/grep/eval/do because it is not
    # necessarily the end of the line.  (terminal.t)
    my $block_type = $block_type_to_go[$i];
    if (
        $type_i eq '}'
        && (  !$block_type
            || $is_sort_map_grep_eval_do{$block_type} )
      )
    {
        $type_i = 'b';
    }
    return $type_i;
} ## end sub terminal_type_i

sub pad_array_to_go {

    my ($self) = @_;

    # To simplify coding in break_lists and set_bond_strengths, it helps to
    # create some extra blank tokens at the end of the arrays.  We also add
    # some undef's to help guard against using invalid data.
    $K_to_go[ $max_index_to_go + 1 ]             = undef;
    $tokens_to_go[ $max_index_to_go + 1 ]        = EMPTY_STRING;
    $tokens_to_go[ $max_index_to_go + 2 ]        = EMPTY_STRING;
    $tokens_to_go[ $max_index_to_go + 3 ]        = undef;
    $types_to_go[ $max_index_to_go + 1 ]         = 'b';
    $types_to_go[ $max_index_to_go + 2 ]         = 'b';
    $types_to_go[ $max_index_to_go + 3 ]         = undef;
    $nesting_depth_to_go[ $max_index_to_go + 2 ] = undef;
    $nesting_depth_to_go[ $max_index_to_go + 1 ] =
      $nesting_depth_to_go[$max_index_to_go];

    #    /^[R\}\)\]]$/
    if ( $is_closing_type{ $types_to_go[$max_index_to_go] } ) {
        if ( $nesting_depth_to_go[$max_index_to_go] <= 0 ) {

            # Nesting depths are set to be >=0 in sub write_line, so it should
            # not be possible to get here unless the code has a bracing error
            # which leaves a closing brace with zero nesting depth.
            if ( !get_saw_brace_error() ) {
                if (DEVEL_MODE) {
                    Fault(<<EOM);
Program bug in pad_array_to_go: hit nesting error which should have been caught
EOM
                }
            }
        }
        else {
            $nesting_depth_to_go[ $max_index_to_go + 1 ] -= 1;
        }
    }

    #       /^[L\{\(\[]$/
    elsif ( $is_opening_type{ $types_to_go[$max_index_to_go] } ) {
        $nesting_depth_to_go[ $max_index_to_go + 1 ] += 1;
    }
    else {
        ## must be ? or :
    }
    return;
} ## end sub pad_array_to_go

sub break_method_call_chains {

    my ( $self, $ri_left, $ri_right ) = @_;

    # If there is a break at any member of a method call chain, break
    # at each method call in the chain (all or none logic). git #171.

    # Given:
    #   $ri_first - reference to list of the first index $i for each output
    #               line in this batch
    #   $ri_last - reference to list of the last index $i for each output line
    #              in this batch

    return unless ( %{ $self->[_rseqno_arrow_call_chain_start_] } );

    # Look for '->' breakpoints
    my @i_arrow_breaks;
    my $rlist = !$want_break_before{'->'} ? $ri_right : $ri_left;
    foreach my $ii ( @{$rlist} ) {
        if ( $types_to_go[$ii] eq '->' ) { push @i_arrow_breaks, $ii }
    }
    return unless (@i_arrow_breaks);

    # See if these are part of a call chain
    my @insert_list;
    my %is_end_i;
    @is_end_i{ @{$ri_left} }  = (1) x scalar( @{$ri_left} );
    @is_end_i{ @{$ri_right} } = (1) x scalar( @{$ri_right} );
    my $one = !$want_break_before{'->'} ? 0 : 1;
    foreach my $ii (@i_arrow_breaks) {

        my $ip = iprev_to_go($ii);
        next if ( $ip < 0 || $tokens_to_go[$ip] ne ')' );
        my $seqno       = $type_sequence_to_go[$ip];
        my $seqno_start = $self->[_rseqno_arrow_call_chain_start_]->{$seqno};
        next unless ($seqno_start);

        # Found a call chain...
        my @Klist = @{ $self->[_rarrow_call_chain_]->{$seqno_start} };
        my $Kref  = $K_to_go[0];
        foreach my $KK (@Klist) {

            # Add missing breaks
            my $i_K = $KK - $Kref;
            next if ( $i_K <= 0 || $i_K >= $max_index_to_go );
            next if ( $is_end_i{$i_K} );
            if ( $K_to_go[$i_K] != $KK ) {
                ## shouldn't happen due to previous checks on i vs K
                DEVEL_MODE && Fault(<<EOM);
                        unexpected array offset error i=$i_K K=$KK Kref= $Kref
EOM
                next;
            }
            push @insert_list, $i_K - $one;
        }
    }

    # Insert any new break points
    if (@insert_list) {
        $self->insert_additional_breaks( \@insert_list, $ri_left, $ri_right );
    }
    return;
} ## end sub break_method_call_chains

sub break_all_chain_tokens {

    my ( $self, $ri_left, $ri_right ) = @_;

    # Scan the current breakpoints looking for breaks at certain "chain
    # operators" (. : && || + etc) which often occur repeatedly in a long
    # statement.  If we see a break at any one, break at all similar tokens
    # within the same container.

    # Given:
    #   $ri_first - reference to list of the first index $i for each output
    #               line in this batch
    #   $ri_last - reference to list of the last index $i for each output line
    #              in this batch

    my %saw_chain_type;
    my %left_chain_type;
    my %right_chain_type;
    my %interior_chain_type;
    my @insert_list;
    my $nmax = @{$ri_right} - 1;

    # scan the left and right end tokens of all lines
    my $end_count = 0;
    for my $n ( 0 .. $nmax ) {
        my $il    = $ri_left->[$n];
        my $ir    = $ri_right->[$n];
        my $typel = $types_to_go[$il];
        my $typer = $types_to_go[$ir];
        $typel = '+' if ( $typel eq '-' );    # treat + and - the same
        $typer = '+' if ( $typer eq '-' );
        $typel = '*' if ( $typel eq '/' );    # treat * and / the same
        $typer = '*' if ( $typer eq '/' );

        my $keyl = $typel eq 'k' ? $tokens_to_go[$il] : $typel;
        my $keyr = $typer eq 'k' ? $tokens_to_go[$ir] : $typer;
        if ( $is_chain_operator{$keyl} && $want_break_before{$typel} ) {
            next if ( $typel eq '?' );
            push @{ $left_chain_type{$keyl} }, $il;
            $saw_chain_type{$keyl} = 1;
            $end_count++;
        }
        if ( $is_chain_operator{$keyr} && !$want_break_before{$typer} ) {
            next if ( $typer eq '?' );
            push @{ $right_chain_type{$keyr} }, $ir;
            $saw_chain_type{$keyr} = 1;
            $end_count++;
        }
    }

    return unless $end_count;

    # now look for any interior tokens of the same types
    my $interior_count = 0;
    my $has_interior_dot_or_plus;
    for my $n ( 0 .. $nmax ) {
        my $il = $ri_left->[$n];
        my $ir = $ri_right->[$n];
        foreach my $i ( $il + 1 .. $ir - 1 ) {
            my $type = $types_to_go[$i];
            my $key  = $type eq 'k' ? $tokens_to_go[$i] : $type;
            $key = '+' if ( $key eq '-' );
            $key = '*' if ( $key eq '/' );
            if ( $saw_chain_type{$key} ) {
                push @{ $interior_chain_type{$key} }, $i;
                $interior_count++;
                $has_interior_dot_or_plus ||= ( $key eq '.' || $key eq '+' );
            }
        }
    }
    return unless $interior_count;

    my @keys = keys %saw_chain_type;

    # quit if just ONE continuation line with leading .  For example--
    # print LATEXFILE '\framebox{\parbox[c][' . $h . '][t]{' . $w . '}{'
    #  . $contents;
    # Fixed for b1399.
    if ( $has_interior_dot_or_plus && $nmax == 1 && @keys == 1 ) {
        return;
    }

    # now make a list of all new break points

    # loop over all chain types
    foreach my $key (@keys) {

        # loop over all interior chain tokens
        foreach my $itest ( @{ $interior_chain_type{$key} } ) {

            # loop over all left end tokens of same type
            if ( $left_chain_type{$key} ) {
                next if $nobreak_to_go[ $itest - 1 ];
                foreach my $i ( @{ $left_chain_type{$key} } ) {
                    next unless $self->in_same_container_i( $i, $itest );
                    push @insert_list, $itest - 1;

                    # Break at matching ? if this : is at a different level.
                    # For example, the ? before $THRf_DEAD in the following
                    # should get a break if its : gets a break.
                    #
                    # my $flags =
                    #     ( $_ & 1 ) ? ( $_ & 4 ) ? $THRf_DEAD : $THRf_ZOMBIE
                    #   : ( $_ & 4 ) ? $THRf_R_DETACHED
                    #   :              $THRf_R_JOINABLE;
                    if (   $key eq ':'
                        && $levels_to_go[$i] != $levels_to_go[$itest] )
                    {
                        my $i_question = $mate_index_to_go[$itest];
                        if ( defined($i_question) && $i_question > 0 ) {
                            push @insert_list, $i_question - 1;
                        }
                    }
                    last;
                }
            }

            # loop over all right end tokens of same type
            if ( $right_chain_type{$key} ) {
                next if $nobreak_to_go[$itest];
                foreach my $i ( @{ $right_chain_type{$key} } ) {
                    next unless $self->in_same_container_i( $i, $itest );
                    push @insert_list, $itest;

                    # break at matching ? if this : is at a different level
                    if (   $key eq ':'
                        && $levels_to_go[$i] != $levels_to_go[$itest] )
                    {
                        my $i_question = $mate_index_to_go[$itest];
                        if ( defined($i_question) ) {
                            push @insert_list, $i_question;
                        }
                    }
                    last;
                }
            }
        }
    }

    # insert any new break points
    if (@insert_list) {
        $self->insert_additional_breaks( \@insert_list, $ri_left, $ri_right );
    }
    return;
} ## end sub break_all_chain_tokens

sub insert_additional_breaks {

    my ( $self, $ri_break_list, $ri_first, $ri_last ) = @_;

    # This routine will add line breaks at requested locations after
    # sub break_long_lines has made preliminary breaks.

    # Given:
    #   $ri_break_list = list of index locations for additional breaks
    #   $ri_first - reference to current list of the first index $i for each
    #               output line in this batch
    #   $ri_last - reference to current list of the last index $i for each
    #               output line in this batch

    my $i_f;
    my $i_l;
    my $line_number = 0;
    foreach my $i_break_left ( sort { $a <=> $b } @{$ri_break_list} ) {

        next if ( $nobreak_to_go[$i_break_left] );

        $i_f = $ri_first->[$line_number];
        $i_l = $ri_last->[$line_number];
        while ( $i_l <= $i_break_left ) {
            $line_number++;

            # shouldn't happen unless caller passes bad indexes
            if ( $line_number >= @{$ri_last} ) {
                if (DEVEL_MODE) {
                    Fault(<<EOM);
Non-fatal program bug: couldn't set break at $i_break_left
EOM
                }
                return;
            }
            $i_f = $ri_first->[$line_number];
            $i_l = $ri_last->[$line_number];
        } ## end while ( $i_l <= $i_break_left)

        # Do not leave a blank at the end of a line; back up if necessary
        if ( $types_to_go[$i_break_left] eq 'b' ) { $i_break_left-- }

        my $i_break_right = $inext_to_go[$i_break_left];
        if (   $i_break_left >= $i_f
            && $i_break_left < $i_l
            && $i_break_right > $i_f
            && $i_break_right <= $i_l )
        {
            splice( @{$ri_first}, $line_number, 1, ( $i_f, $i_break_right ) );
            splice( @{$ri_last},  $line_number, 1, ( $i_break_left, $i_l ) );
        }
    }
    return;
} ## end sub insert_additional_breaks

{    ## begin closure in_same_container_i
    my $ris_break_token;
    my $ris_comma_token;

    BEGIN {

        # all cases break on seeing commas at same level
        my @q = qw( => );
        push @q, ',';
        @{$ris_comma_token}{@q} = (1) x scalar(@q);

        # Non-ternary text also breaks on seeing any of qw(? : || or )
        # Example: we would not want to break at any of these .'s
        #  : "<A HREF=\"#item_" . htmlify( 0, $s2 ) . "\">$str</A>"
        push @q, qw( or || ? : );
        @{$ris_break_token}{@q} = (1) x scalar(@q);
    } ## end BEGIN

    sub in_same_container_i {

        my ( $self, $i1, $i2 ) = @_;

        # Check to see if tokens at $i1 and $i2 are in the same container, and
        # not separated by certain characters: => , ? : || or
        # This is an interface between the _to_go arrays to the rLL array

        # quick check
        my $parent_seqno_1 = $parent_seqno_to_go[$i1];
        return if ( $parent_seqno_to_go[$i2] ne $parent_seqno_1 );

        if ( $i2 < $i1 ) { ( $i1, $i2 ) = ( $i2, $i1 ) }
        my $K1 = $K_to_go[$i1];
        my $K2 = $K_to_go[$i2];

        my $depth_1 = $nesting_depth_to_go[$i1];
        return if ( $depth_1 < 0 );

        # Shouldn't happen since i1 and i2 have same parent:
        return unless ( $nesting_depth_to_go[$i2] == $depth_1 );

        # Select character set to scan for
        my $type_1 = $types_to_go[$i1];
        my $rbreak = ( $type_1 ne ':' ) ? $ris_break_token : $ris_comma_token;

        my $rK_next_seqno_by_K = $self->[_rK_next_seqno_by_K_];

        # Fast preliminary loop to verify that tokens are in the same container
        my $KK         = $K1;
        my $Knext_last = $KK;
        while ( defined( $KK = $rK_next_seqno_by_K->[$KK] ) ) {

            if ( $KK <= $Knext_last ) {
                ## shouldn't happen: $rK_next_seqno_by_K is corrupted
                DEVEL_MODE && Fault(<<EOM);
Knext should not increase: Knext_last=$Knext_last >= Knext=$KK
EOM
                last;
            }
            $Knext_last = $KK;

            last if ( $KK >= $K2 );
            my $ii      = $i1 + $KK - $K1;
            my $depth_i = $nesting_depth_to_go[$ii];
            return if ( $depth_i < $depth_1 );
            next   if ( $depth_i > $depth_1 );
            if ( $type_1 ne ':' ) {
                my $tok_i = $tokens_to_go[$ii];
                return if ( $tok_i eq '?' || $tok_i eq ':' );
            }
        } ## end while ( defined( $KK = $rK_next_seqno_by_K...))

        # Slow loop checking for certain characters

        #-----------------------------------------------------
        # This is potentially a slow routine and not critical.
        # For safety just give up for large differences.
        # See test file 'infinite_loop.txt'
        #-----------------------------------------------------
        return if ( $i2 - $i1 > 200 );

        foreach my $ii ( $i1 + 1 .. $i2 - 1 ) {

            my $depth_i = $nesting_depth_to_go[$ii];
            next   if ( $depth_i > $depth_1 );
            return if ( $depth_i < $depth_1 );
            my $typ_i = $types_to_go[$ii];
            if ( $typ_i eq 'k' ) { $typ_i = $tokens_to_go[$ii] }
            return if ( $rbreak->{$typ_i} );
        }
        return 1;
    } ## end sub in_same_container_i
} ## end closure in_same_container_i

sub break_equals {

    my ( $self, $ri_left, $ri_right ) = @_;

    # Look for assignment operators that could use a breakpoint.

    # Given:
    #   $ri_first - reference to current list of the first index $i for each
    #               output line in this batch
    #   $ri_last - reference to current list of the last index $i for each
    #               output line in this batch

    # For example, in the following snippet
    #
    #    $HOME = $ENV{HOME}
    #      || $ENV{LOGDIR}
    #      || $pw[7]
    #      || die "no home directory for user $<";
    #
    # we could break at the = to get this, which is a little nicer:
    #    $HOME =
    #         $ENV{HOME}
    #      || $ENV{LOGDIR}
    #      || $pw[7]
    #      || die "no home directory for user $<";
    #
    # The logic here follows the logic in set_logical_padding, which
    # will add the padding in the second line to improve alignment.
    #
    my $nmax = @{$ri_right} - 1;
    return if ( $nmax < 2 );

    # scan the left ends of first two lines
    my $tokbeg = EMPTY_STRING;
    my $depth_beg;
    for my $n ( 1 .. 2 ) {
        my $il     = $ri_left->[$n];
        my $typel  = $types_to_go[$il];
        my $tokenl = $tokens_to_go[$il];
        my $keyl   = $typel eq 'k' ? $tokenl : $typel;

        my $has_leading_op = $is_chain_operator{$keyl};
        return unless ($has_leading_op);
        if ( $n > 1 ) {
            return
              unless ( $tokenl eq $tokbeg
                && $nesting_depth_to_go[$il] eq $depth_beg );
        }
        $tokbeg    = $tokenl;
        $depth_beg = $nesting_depth_to_go[$il];
    }

    # now look for any interior tokens of the same types
    my $il = $ri_left->[0];
    my $ir = $ri_right->[0];

    # now make a list of all new break points
    my @insert_list;
    foreach my $i ( reverse( $il + 1 .. $ir - 1 ) ) {
        my $type = $types_to_go[$i];
        if (   $is_assignment{$type}
            && $nesting_depth_to_go[$i] eq $depth_beg )
        {
            if ( $want_break_before{$type} ) {
                push @insert_list, $i - 1;
            }
            else {
                push @insert_list, $i;
            }
        }
    }

    # Break after a 'return' followed by a chain of operators
    #  return ( $^O !~ /win32|dos/i )
    #    && ( $^O ne 'VMS' )
    #    && ( $^O ne 'OS2' )
    #    && ( $^O ne 'MacOS' );
    # To give:
    #  return
    #       ( $^O !~ /win32|dos/i )
    #    && ( $^O ne 'VMS' )
    #    && ( $^O ne 'OS2' )
    #    && ( $^O ne 'MacOS' );
    my $i = 0;
    if (   $types_to_go[$i] eq 'k'
        && $tokens_to_go[$i] eq 'return'
        && $ir > $il
        && $nesting_depth_to_go[$i] eq $depth_beg )
    {
        push @insert_list, $i;
    }

    return unless (@insert_list);

    # One final check...
    # scan second and third lines and be sure there are no assignments
    # we want to avoid breaking at an = to make something like this:
    #    unless ( $icon =
    #           $html_icons{"$type-$state"}
    #        or $icon = $html_icons{$type}
    #        or $icon = $html_icons{$state} )
    for my $n ( 1 .. 2 ) {
        my $il_n = $ri_left->[$n];
        my $ir_n = $ri_right->[$n];
        foreach my $ii ( $il_n + 1 .. $ir_n ) {
            my $type = $types_to_go[$ii];
            return
              if ( $is_assignment{$type}
                && $nesting_depth_to_go[$ii] eq $depth_beg );
        }
    }

    # ok, insert any new break point
    if (@insert_list) {
        $self->insert_additional_breaks( \@insert_list, $ri_left, $ri_right );
    }
    return;
} ## end sub break_equals

{    ## begin closure recombine_breakpoints

    # This routine is called once per batch to see if it would be better
    # to combine some of the lines into which the batch has been broken.

    my %is_amp_amp;
    my %is_math_op;
    my %is_plus_minus;
    my %is_mult_div;

    BEGIN {

        my @q;
        @q = qw( && || );
        @is_amp_amp{@q} = (1) x scalar(@q);

        @q = qw( + - * / );
        @is_math_op{@q} = (1) x scalar(@q);

        @q = qw( + - );
        @is_plus_minus{@q} = (1) x scalar(@q);

        @q = qw( * / );
        @is_mult_div{@q} = (1) x scalar(@q);
    } ## end BEGIN

    sub Debug_dump_breakpoints {

        my ( $self, $ri_beg, $ri_end, $msg ) = @_;

        # Debug routine to dump current breakpoints...not normally called
        # Given: indexes to the current lines:
        #   $ri_beg = ref to array of BEGinning indexes of each line
        #   $ri_end = ref to array of ENDing indexes of each line
        print {*STDOUT} "----Dumping breakpoints from: $msg----\n";
        for my $n ( 0 .. @{$ri_end} - 1 ) {
            my $ibeg = $ri_beg->[$n];
            my $iend = $ri_end->[$n];
            my $text = EMPTY_STRING;
            foreach my $i ( $ibeg .. $iend ) {
                $text .= $tokens_to_go[$i];
            }
            print {*STDOUT} "$n ($ibeg:$iend) $text\n";
        }
        print {*STDOUT} "----\n";
        return;
    } ## end sub Debug_dump_breakpoints

    sub delete_one_line_semicolons {

        my ( $self, $ri_beg, $ri_end ) = @_;

        # Given: indexes to the current lines:
        #   $ri_beg = ref to array of beginning indexes of each line
        #   $ri_end = ref to array of ending indexes of each line

        my $rLL                 = $self->[_rLL_];
        my $K_opening_container = $self->[_K_opening_container_];

        # Walk down the lines of this batch and delete any semicolons
        # terminating one-line blocks;
        my $nmax = @{$ri_end} - 1;

        foreach my $n ( 0 .. $nmax ) {
            my $i_beg    = $ri_beg->[$n];
            my $i_e      = $ri_end->[$n];
            my $K_beg    = $K_to_go[$i_beg];
            my $K_e      = $K_to_go[$i_e];
            my $K_end    = $K_e;
            my $type_end = $rLL->[$K_end]->[_TYPE_];
            if ( $type_end eq '#' ) {
                $K_end = $self->K_previous_nonblank($K_end);
                if ( defined($K_end) ) { $type_end = $rLL->[$K_end]->[_TYPE_]; }
            }

            # we are looking for a line ending in closing brace
            next
              unless ( $type_end eq '}' && $rLL->[$K_end]->[_TOKEN_] eq '}' );

            # ...and preceded by a semicolon on the same line
            my $K_semicolon = $self->K_previous_nonblank($K_end);
            next unless defined($K_semicolon);
            my $i_semicolon = $i_beg + ( $K_semicolon - $K_beg );
            next if ( $i_semicolon <= $i_beg );
            next unless ( $rLL->[$K_semicolon]->[_TYPE_] eq ';' );

            # Safety check - shouldn't happen - not critical
            # This is not worth throwing a Fault, except in DEVEL_MODE
            if ( $types_to_go[$i_semicolon] ne ';' ) {
                DEVEL_MODE
                  && Fault("unexpected type looking for semicolon");
                next;
            }

            # ... with the corresponding opening brace on the same line
            my $type_sequence = $rLL->[$K_end]->[_TYPE_SEQUENCE_];
            my $K_opening     = $K_opening_container->{$type_sequence};
            next unless ( defined($K_opening) );
            my $i_opening = $i_beg + ( $K_opening - $K_beg );
            next if ( $i_opening < $i_beg );

            # ... and only one semicolon between these braces
            my $semicolon_count = 0;
            foreach my $K ( $K_opening + 1 .. $K_semicolon - 1 ) {
                if ( $rLL->[$K]->[_TYPE_] eq ';' ) {
                    $semicolon_count++;
                    last;
                }
            }
            next if ($semicolon_count);

            # ...ok, then make the semicolon invisible
            my $len = $token_lengths_to_go[$i_semicolon];
            $tokens_to_go[$i_semicolon]            = EMPTY_STRING;
            $token_lengths_to_go[$i_semicolon]     = 0;
            $rLL->[$K_semicolon]->[_TOKEN_]        = EMPTY_STRING;
            $rLL->[$K_semicolon]->[_TOKEN_LENGTH_] = 0;
            foreach ( $i_semicolon .. $max_index_to_go ) {
                $summed_lengths_to_go[ $_ + 1 ] -= $len;
            }
        }
        return;
    } ## end sub delete_one_line_semicolons

    use constant DEBUG_RECOMBINE => 0;

    sub recombine_breakpoints {

        my ( $self, $ri_beg, $ri_end, $rbond_strength_to_go ) = @_;

        # This sub implements the 'recombine' operation on a batch.
        # Its task is to combine some of these lines back together to
        # improve formatting.  The need for this arises because
        # sub 'break_long_lines' is very liberal in setting line breaks
        # for long lines, always setting breaks at good breakpoints, even
        # when that creates small lines.  Sometimes small line fragments
        # are produced which would look better if they were combined.

        # Input parameters:
        #  $ri_beg = ref to array of BEGinning indexes of each line
        #  $ri_end = ref to array of ENDing indexes of each line
        #  $rbond_strength_to_go = array of bond strengths pulling
        #    tokens together, used to decide where best to recombine lines.

        #-------------------------------------------------------------------
        # Do nothing under extreme stress; use <= 2 for c171.
        # (NOTE: New optimizations make this unnecessary.  But removing this
        # check is not really useful because this condition only occurs in
        # test runs, and another formatting pass will fix things anyway.)
        # This routine has a long history of improvements. Some past
        # relevant issues are : c118, c167, c171, c186, c187, c193, c200.
        #-------------------------------------------------------------------
        return if ( $high_stress_level <= 2 );

        my $nmax_start = @{$ri_end} - 1;
        return if ( $nmax_start <= 0 );

        my $iend_max = $ri_end->[$nmax_start];
        if ( $types_to_go[$iend_max] eq '#' ) {
            $iend_max = iprev_to_go($iend_max);
        }
        my $has_terminal_semicolon =
          $iend_max >= 0 && $types_to_go[$iend_max] eq ';';

        #--------------------------------------------------------------------
        # Break into the smallest possible sub-sections to improve efficiency
        #--------------------------------------------------------------------

        # Also make a list of all good joining tokens between the lines
        # n-1 and n.
        my @joint;

        my $rsections = [];
        my $nbeg_sec  = 0;
        my $nend_sec;
        my $nmax_section = 0;
        foreach my $nn ( 1 .. $nmax_start ) {
            my $ibeg_1 = $ri_beg->[ $nn - 1 ];
            my $iend_1 = $ri_end->[ $nn - 1 ];
            my $iend_2 = $ri_end->[$nn];
            my $ibeg_2 = $ri_beg->[$nn];

            # Define certain good joint tokens
            my $itok;
            foreach my $itest ( $iend_1, $ibeg_2 ) {
                my $type = $types_to_go[$itest];
                if (   $is_math_op{$type}
                    || $is_amp_amp{$type}
                    || $is_assignment{$type}
                    || $type eq ':' )
                {
                    $itok = $itest;
                }
            }

            # joint[$nn] = index of joint character
            $joint[$nn] = $itok;

            # Update the section list
            my $excess = $self->excess_line_length( $ibeg_1, $iend_2, 1 );
            if (
                $excess <= 1

                # The number 5 here is an arbitrary small number intended
                # to keep most small matches in one sub-section.
                || ( defined($nend_sec)
                    && ( $nn < 5 || $nmax_start - $nn < 5 ) )
              )
            {
                $nend_sec = $nn;
            }
            else {
                if ( defined($nend_sec) ) {
                    push @{$rsections}, [ $nbeg_sec, $nend_sec ];
                    my $num = $nend_sec - $nbeg_sec;
                    if ( $num > $nmax_section ) { $nmax_section = $num }
                    $nbeg_sec = $nn;
                    $nend_sec = undef;
                }
                $nbeg_sec = $nn;
            }
        }

        if ( defined($nend_sec) ) {
            push @{$rsections}, [ $nbeg_sec, $nend_sec ];
            my $num = $nend_sec - $nbeg_sec;
            if ( $num > $nmax_section ) { $nmax_section = $num }
        }

        my $num_sections = @{$rsections};

        if ( DEBUG_RECOMBINE > 1 ) {
            print {*STDOUT} <<EOM;
sections=$num_sections; nmax_sec=$nmax_section
EOM
        }

        if ( DEBUG_RECOMBINE > 0 ) {
            my $max = 0;
            print {*STDOUT}
              "-----\n$num_sections sections found for nmax=$nmax_start\n";
            foreach my $sect ( @{$rsections} ) {
                my ( $nbeg, $nend ) = @{$sect};
                my $num = $nend - $nbeg;
                if ( $num > $max ) { $max = $num }
                print {*STDOUT} "$nbeg $nend\n";
            }
            print {*STDOUT} "max size=$max of $nmax_start lines\n";
        }

        # Loop over all sub-sections.  Note that we have to work backwards
        # from the end of the batch since the sections use original line
        # numbers, and the line numbers change as we go.
        foreach my $section ( reverse @{$rsections} ) {
            my ( $nbeg, $nend ) = @{$section};
            $self->recombine_section_loop(
                {
                    _ri_beg                 => $ri_beg,
                    _ri_end                 => $ri_end,
                    _nbeg                   => $nbeg,
                    _nend                   => $nend,
                    _rjoint                 => \@joint,
                    _rbond_strength_to_go   => $rbond_strength_to_go,
                    _has_terminal_semicolon => $has_terminal_semicolon,
                }
            );
        } ## end while ( my $section = pop...)

        return;
    } ## end sub recombine_breakpoints

    sub recombine_section_loop {
        my ( $self, $rhash ) = @_;

        # Recombine breakpoints for one section of lines in the current batch

        # Given:
        #   $ri_beg, $ri_end = ref to arrays with token indexes of the first
        #     and last line
        #   $nbeg, $nend  = line numbers bounding this section
        #   $rjoint       = ref to array of good joining tokens per line

        # Update: $ri_beg, $ri_end, $rjoint if lines are joined

        # Returns:
        #   nothing

        #-------------
        # Definitions:
        #-------------
        # $rhash = {

        #   _ri_beg  = ref to array with starting token index by line
        #   _ri_end  = ref to array with ending token index by line
        #   _nbeg    = first line number of this section
        #   _nend    = last line number of this section
        #   _rjoint  = ref to array of good joining tokens for each line
        #   _rbond_strength_to_go   = array of bond strengths
        #   _has_terminal_semicolon = true if last line of batch has ';'

        #   _num_freeze      = fixed number of lines at end of this batch
        #   _optimization_on = true during final optimization loop
        #   _num_compares    = total number of line compares made so far
        #   _pair_list       = list of line pairs in optimal search order

        # };

        #-------------
        # How it works
        #-------------

        # We are working with a sequence of output lines and looking at
        # each pair. We must decide if it is better to join each of
        # these line pairs.

        # The brute force method is to loop through all line pairs and
        # join the best possible pair, as determined by either some
        # logical criterion or by the maximum 'bond strength' assigned
        # to the joining token.  Then keep doing this until there are
        # no remaining line pairs to join.

        # This works, but a problem is that it can theoretically take
        # on the order of N^2 comparisons in some pathological cases.
        # This can require an excessive amount of run time.

        # We can avoid excessive run time by conceptually dividing the
        # work into two phases. In the first phase we make any joints
        # required by user settings or logic other than the strength of
        # joints.  In the second phase we make any remaining joints
        # based on strengths.  To do this optimally, we do a preliminary
        # sort on joint strengths and always loop in that order.  That
        # way, we can stop a search on the first joint strength because
        # it will be the maximum.

        # This method is very fast, requiring no more than 3*N line
        # comparisons, where N is the number of lines (see below).

        my $ri_beg = $rhash->{_ri_beg};
        my $ri_end = $rhash->{_ri_end};

        # Line index range of this section:
        my $nbeg = $rhash->{_nbeg};    # stays constant
        my $nend = $rhash->{_nend};    # will decrease

        # $nmax_batch = starting number of lines in the full batch
        # $num_freeze = number of lines following this section to leave alone
        my $nmax_batch = @{$ri_end} - 1;
        $rhash->{_num_freeze} = $nmax_batch - $nend;

        # Setup the list of line pairs to test.  This stores the following
        # values for each line pair:
        #   [ $n=index of the second line of the pair, $bs=bond strength]
        my @pair_list;
        my $rbond_strength_to_go = $rhash->{_rbond_strength_to_go};
        foreach my $n ( $nbeg + 1 .. $nend ) {
            my $iend_1   = $ri_end->[ $n - 1 ];
            my $ibeg_2   = $ri_beg->[$n];
            my $bs_tweak = 0;
            if ( $is_amp_amp{ $types_to_go[$ibeg_2] } ) { $bs_tweak = 0.25 }
            my $bs = $rbond_strength_to_go->[$iend_1] + $bs_tweak;
            push @pair_list, [ $n, $bs ];
        }

        # Any order for testing is possible, but optimization is only possible
        # if we sort the line pairs on decreasing joint strength.
        @pair_list =
          sort { $b->[1] <=> $a->[1] || $a->[0] <=> $b->[0] } @pair_list;
        $rhash->{_rpair_list} = \@pair_list;

        #----------------
        # Iteration limit
        #----------------

        # This is now a very fast loop which runs in O(n) time, but a
        # check on total number of iterations is retained to guard
        # against future programming errors.

        # Most cases require roughly 1 comparison per line pair (1 full pass).
        # The upper bound is estimated to be about 3 comparisons per line pair
        # unless optimization is deactivated.  The approximate breakdown is:
        #   1 pass with 1 compare per joint to do any special cases, plus
        #   1 pass with up to 2 compares per joint in optimization mode
        # The most extreme cases in my collection are:
        #    camel1.t  - needs 2.7 compares per line (12 without optimization)
        #    ternary.t - needs 2.8 compares per line (12 without optimization)
        #    c206      - needs 3.3 compares per line, found with random testing
        # So a value of MAX_COMPARE_RATIO = 4 looks like an upper bound as
        # long as optimization is used.  A value of 20 should allow all code to
        # pass even if optimization is turned off for testing.
        use constant MAX_COMPARE_RATIO => DEVEL_MODE ? 4 : 20;

        my $num_pairs    = $nend - $nbeg + 1;
        my $max_compares = MAX_COMPARE_RATIO * $num_pairs;

        # Always start with optimization off
        $rhash->{_num_compares}    = 0;
        $rhash->{_optimization_on} = 0;
        $rhash->{_ix_best_last}    = 0;

        #--------------------------------------------
        # loop until there are no more recombinations
        #--------------------------------------------
        my $nmax_last = $nmax_batch + 1;
        while (1) {

            # Stop when the number of lines in the batch does not decrease
            $nmax_batch = @{$ri_end} - 1;
            if ( $nmax_batch >= $nmax_last ) {
                last;
            }
            $nmax_last = $nmax_batch;

            #-----------------------------------------
            # inner loop to find next best combination
            #-----------------------------------------
            $self->recombine_inner_loop($rhash);

            # Iteration limit check:
            if ( $rhash->{_num_compares} > $max_compares ) {

                # See note above; should only get here on a programming error
                if (DEVEL_MODE) {
                    my $ibeg = $ri_beg->[$nbeg];
                    my $Kbeg = $K_to_go[$ibeg];
                    my $lno  = $self->[_rLL_]->[$Kbeg]->[_LINE_INDEX_];
                    Fault(<<EOM);
inner loop passes =$rhash->{_num_compares} exceeds max=$max_compares, near line $lno
EOM
                }
                last;
            }

        } ## end while (1)

        if (DEBUG_RECOMBINE) {
            my $ratio = sprintf "%0.3f", $rhash->{_num_compares} / $num_pairs;
            print {*STDOUT}
"exiting recombine_inner_loop with $nmax_last lines, opt=$rhash->{_optimization_on}, starting pairs=$num_pairs, num_compares=$rhash->{_num_compares}, ratio=$ratio\n";
        }

        return;
    } ## end sub recombine_section_loop

    sub recombine_inner_loop {
        my ( $self, $rhash ) = @_;

        # This is the inner loop of the recombine operation. We are working on
        # a sequence of multiple lines. We look at each pair of lines and
        # decide if formatting would be improved if the pair were joined
        # into a single line. If there are multiple of such possible
        # recombinations, we select the best.  If a recombination is made,
        # the number of lines in this group of lines will be reduced by one.
        # See comments in the calling routine for further explanation.

        # Input:
        #    $rhash has parameters controlling this recombine operation
        # Returns: nothing

        my $rK_weld_right = $self->[_rK_weld_right_];
        my $rK_weld_left  = $self->[_rK_weld_left_];

        my $ri_beg               = $rhash->{_ri_beg};
        my $ri_end               = $rhash->{_ri_end};
        my $nbeg                 = $rhash->{_nbeg};
        my $rjoint               = $rhash->{_rjoint};
        my $rbond_strength_to_go = $rhash->{_rbond_strength_to_go};
        my $rpair_list           = $rhash->{_rpair_list};

        # This will remember the best joint:
        my $n_best  = 0;
        my $bs_best = 0.;
        my $ix_best = 0;
        my $num_bs  = 0;

        # The index range of lines in this group is $nbeg to $nstop
        my $nmax       = @{$ri_end} - 1;
        my $nstop      = $nmax - $rhash->{_num_freeze};
        my $num_joints = $nstop - $nbeg;

        # Turn off optimization if just two joints remain to allow
        # special two-line logic to be checked (c193)
        if ( $rhash->{_optimization_on} && $num_joints <= 2 ) {
            $rhash->{_optimization_on} = 0;
        }

        # Start where we ended the last search
        my $ix_start = $rhash->{_ix_best_last};

        # Keep the starting index in bounds
        $ix_start = max( 0, $ix_start );

        # Make a search order list which cycles around to visit
        # all line pairs.
        my $ix_max  = @{$rpair_list} - 1;
        my @ix_list = ( $ix_start .. $ix_max, 0 .. $ix_start - 1 );
        my $ix_last = $ix_list[-1];

        #-------------------------
        # loop over all line pairs
        #-------------------------
        my $incomplete_loop;
        foreach my $ix (@ix_list) {
            my $item = $rpair_list->[$ix];
            my ( $n, $bs ) = @{$item};

            # This flag will be true if we 'last' out of this loop early.
            # We cannot turn on optimization if this is true.
            $incomplete_loop = $ix != $ix_last;

            # Update the count of the number of times through this inner loop
            $rhash->{_num_compares}++;

            #----------------------------------------------------------
            # If we join the current pair of lines,
            # line $n-1 will become the left part of the joined line
            # line $n will become the right part of the joined line
            #
            # Here are Indexes of the endpoint tokens of the two lines:
            #
            #  -----line $n-1--- | -----line $n-----
            #  $ibeg_1   $iend_1 | $ibeg_2   $iend_2
            #                    ^
            #                    |
            # We want to decide if we should remove the line break
            # between the tokens at $iend_1 and $ibeg_2
            #
            # We will apply a number of ad-hoc tests to see if joining
            # here will look ok.  The code will just move to the next
            # pair if the join doesn't look good.  If we get through
            # the gauntlet of tests, the lines will be recombined.
            #----------------------------------------------------------
            #
            # beginning and ending tokens of the lines we are working on
            my $ibeg_1 = $ri_beg->[ $n - 1 ];
            my $iend_1 = $ri_end->[ $n - 1 ];
            my $iend_2 = $ri_end->[$n];
            my $ibeg_2 = $ri_beg->[$n];

            # The combined line cannot be too long
            my $excess = $self->excess_line_length( $ibeg_1, $iend_2, 1 );
            next if ( $excess > 0 );

            my $type_iend_1 = $types_to_go[$iend_1];
            my $type_iend_2 = $types_to_go[$iend_2];
            my $type_ibeg_1 = $types_to_go[$ibeg_1];
            my $type_ibeg_2 = $types_to_go[$ibeg_2];

            DEBUG_RECOMBINE > 1 && do {
                print {*STDOUT}
"RECOMBINE: ix=$ix iend1=$iend_1 iend2=$iend_2 n=$n nmax=$nmax if=$ibeg_1 type=$type_ibeg_1 =$tokens_to_go[$ibeg_1] next_type=$type_ibeg_2 next_tok=$tokens_to_go[$ibeg_2]\n";
            };

            # If line $n is the last line, we set some flags and
            # do any special checks for it
            my $this_line_is_semicolon_terminated;
            if ( $n == $nmax ) {

                if ( $type_ibeg_2 eq '{' ) {

                    # join isolated ')' and '{' if requested (git #110)
                    if (   $rOpts_cuddled_paren_brace
                        && $type_iend_1 eq '}'
                        && $iend_1 == $ibeg_1
                        && $ibeg_2 == $iend_2 )
                    {
                        if (   $tokens_to_go[$iend_1] eq ')'
                            && $tokens_to_go[$ibeg_2] eq '{' )
                        {
                            $n_best  = $n;
                            $ix_best = $ix;
                            last;
                        }
                    }

                    # otherwise, a terminal '{' should stay where it is
                    # unless preceded by a fat comma
                    next if ( $type_iend_1 ne '=>' );
                }

                $this_line_is_semicolon_terminated =
                  $rhash->{_has_terminal_semicolon};

            }

            #----------------------------------------------------------
            # Recombine Section 0:
            # Examine the special token joining this line pair, if any.
            # Put as many tests in this section to avoid duplicate code
            # and to make formatting independent of whether breaks are
            # to the left or right of an operator.
            #----------------------------------------------------------

            my $itok = $rjoint->[$n];
            if ($itok) {
                my $ok_0 = recombine_section_0( $itok, $ri_beg, $ri_end, $n );
                next if ( !$ok_0 );
            }

            #----------------------------------------------------------
            # Recombine Section 1:
            # Join welded nested containers immediately
            #----------------------------------------------------------

            if (
                $total_weld_count
                && ( $type_sequence_to_go[$iend_1]
                    && defined( $rK_weld_right->{ $K_to_go[$iend_1] } )
                    || $type_sequence_to_go[$ibeg_2]
                    && defined( $rK_weld_left->{ $K_to_go[$ibeg_2] } ) )
              )
            {
                $n_best  = $n;
                $ix_best = $ix;
                last;
            }

            #----------------------------------------------------------
            # Recombine Section 2:
            # Examine token at $iend_1 (right end of first line of pair)
            #----------------------------------------------------------

            my ( $ok_2, $skip_Section_3 ) =
              recombine_section_2( $ri_beg, $ri_end, $n,
                $this_line_is_semicolon_terminated );
            next if ( !$ok_2 );

            #----------------------------------------------------------
            # Recombine Section 3:
            # Examine token at $ibeg_2 (left end of second line of pair)
            #----------------------------------------------------------

            # Join lines identified above as capable of
            # causing an outdented line with leading closing paren.
            # Note that we are skipping the rest of this section
            # and the rest of the loop to do the join.
            if ($skip_Section_3) {
                $forced_breakpoint_to_go[$iend_1] = 0;
                $n_best                           = $n;
                $ix_best                          = $ix;
                $incomplete_loop                  = 1;
                last;
            }

            my ( $ok_3, $bs_tweak ) =
              recombine_section_3( $ri_beg, $ri_end, $n,
                $this_line_is_semicolon_terminated );
            next if ( !$ok_3 );

            #----------------------------------------------------------
            # Recombine Section 4:
            # Combine the lines if we arrive here and it is possible
            #----------------------------------------------------------

            # honor hard breakpoints
            next if ( $forced_breakpoint_to_go[$iend_1] );

            if (DEVEL_MODE) {

                # This fault can only occur if an array index error has been
                # introduced by a recent programming change.
                my $bs_check = $rbond_strength_to_go->[$iend_1] + $bs_tweak;
                if ( $bs_check != $bs ) {
                    Fault(<<EOM);
bs=$bs != $bs_check for break after type $type_iend_1 ix=$ix n=$n
EOM
                }
            }

            # Require a few extra spaces before recombining lines if we
            # are at an old breakpoint unless this is a simple list or
            # terminal line.  The goal is to avoid oscillating between
            # two quasi-stable end states.  For example this snippet
            # caused problems:

##    my $this =
##    bless {
##        TText => "[" . ( join ',', map { "\"$_\"" } split "\n", $_ ) . "]"
##      },
##      $type;
            next
              if ( $old_breakpoint_to_go[$iend_1]
                && !$this_line_is_semicolon_terminated
                && $n < $nmax
                && $excess + 4 > 0
                && $type_iend_2 ne ',' );

            # do not recombine if we would skip in indentation levels
            if ( $n < $nmax ) {

                my $if_next       = $ri_beg->[ $n + 1 ];
                my $level_1       = $levels_to_go[$ibeg_1];
                my $level_2       = $levels_to_go[$ibeg_2];
                my $level_if_next = $levels_to_go[$if_next];

                next
                  if (
                       $level_1 < $level_2
                    && $level_2 < $level_if_next

                    # but an isolated 'if (' is undesirable
                    && !(
                           $n == 1
                        && $iend_1 - $ibeg_1 <= 2
                        && $type_ibeg_1 eq 'k'
                        && $tokens_to_go[$ibeg_1] eq 'if'
                        && $tokens_to_go[$iend_1] ne '('
                    )
                  );
            }

            ## OLD: honor no-break's
            ## next if ( $bs >= NO_BREAK - 1 );  # removed for b1257

            # remember the pair with the greatest bond strength
            if ( !$n_best ) {

                # First good joint ...
                $n_best  = $n;
                $ix_best = $ix;
                $bs_best = $bs;
                $num_bs  = 1;

                # In optimization mode: stop on the first acceptable joint
                # because we already know it has the highest strength
                if ( $rhash->{_optimization_on} == 1 ) {
                    last;
                }
            }
            else {

                # Second and later joints ..
                $num_bs++;

                # save maximum strength; in case of a tie select min $n
                if ( $bs > $bs_best || $bs == $bs_best && $n < $n_best ) {
                    $n_best  = $n;
                    $ix_best = $ix;
                    $bs_best = $bs;
                }
            }

        } ## end loop over all line pairs

        #---------------------------------------------------
        # recombine the pair with the greatest bond strength
        #---------------------------------------------------
        if ($n_best) {
            DEBUG_RECOMBINE > 1
              && print "BEST: nb=$n_best nbeg=$nbeg stop=$nstop bs=$bs_best\n";
            splice @{$ri_beg}, $n_best,     1;
            splice @{$ri_end}, $n_best - 1, 1;
            splice @{$rjoint}, $n_best,     1;

            splice @{$rpair_list}, $ix_best, 1;

            # Update the line indexes in the pair list:
            # Old $n values greater than the best $n decrease by 1
            # because of the splice we just did.
            foreach my $item ( @{$rpair_list} ) {
                my $n_old = $item->[0];
                if ( $n_old > $n_best ) { $item->[0] -= 1 }
            }

            # Store the index of this location for starting the next search.
            # We must subtract 1 to get an updated index because the splice
            # above just removed the best pair.
            # BUT CAUTION: if this is the first pair in the pair list, then
            # this produces an invalid index. So this index must be tested
            # before use in the next pass through the outer loop.
            $rhash->{_ix_best_last} = $ix_best - 1;

            # Turn on optimization if ...
            if (

                # it is not already on, and
                !$rhash->{_optimization_on}

                # we have not taken a shortcut to get here, and
                && !$incomplete_loop

                # we have seen a good break on strength, and
                && $num_bs

              )
            {

                # To deactivate optimization for testing purposes, the next
                # line can be commented out. This will increase run time.
                $rhash->{_optimization_on} = 1;
                if (DEBUG_RECOMBINE) {
                    my $num_compares = $rhash->{_num_compares};
                    my $pair_count   = @ix_list;
                    print {*STDOUT}
"Entering optimization phase at $num_compares compares, pair count = $pair_count\n";
                }
            }
        }
        return;
    } ## end sub recombine_inner_loop

    sub recombine_section_0 {
        my ( $itok, $ri_beg, $ri_end, $n ) = @_;

        # Recombine Section 0:
        # Examine special candidate joining token $itok

        # Given:
        #  $itok = index of token at a possible join of lines $n-1 and $n

        # Return:
        #  true  => ok to combine
        #  false => do not combine lines

        # Here are Indexes of the endpoint tokens of the two lines:
        #
        #  -----line $n-1--- | -----line $n-----
        #  $ibeg_1   $iend_1 | $ibeg_2   $iend_2
        #              ^         ^
        #              |         |
        #              ------------$itok is one of these tokens

        # Put as many tests in this section to avoid duplicate code
        # and to make formatting independent of whether breaks are
        # to the left or right of an operator.

        my $nmax   = @{$ri_end} - 1;
        my $ibeg_1 = $ri_beg->[ $n - 1 ];
        my $iend_1 = $ri_end->[ $n - 1 ];
##      my $ibeg_2 = $ri_beg->[$n];
        my $iend_2 = $ri_end->[$n];

        if ($itok) {

            my $type = $types_to_go[$itok];

            if ( $type eq ':' ) {

                # do not join at a colon unless it disobeys the
                # break request
                if ( $itok eq $iend_1 ) {
                    return unless $want_break_before{$type};
                }
                else {
                    return if $want_break_before{$type};
                }
            } ## end if ':'

            # handle math operators + - * /
            elsif ( $is_math_op{$type} ) {

                # Combine these lines if this line is a single
                # number, or if it is a short term with same
                # operator as the previous line.  For example, in
                # the following code we will combine all of the
                # short terms $A, $B, $C, $D, $E, $F, together
                # instead of leaving them one per line:
                #  my $time =
                #    $A * $B * $C * $D * $E * $F *
                #    ( 2. * $eps * $sigma * $area ) *
                #    ( 1. / $tcold**3 - 1. / $thot**3 );

                # This can be important in math-intensive code.

                my $good_combo;

                my $itokp  = min( $inext_to_go[$itok],  $iend_2 );
                my $itokpp = min( $inext_to_go[$itokp], $iend_2 );
                my $itokm  = max( iprev_to_go($itok),  $ibeg_1 );
                my $itokmm = max( iprev_to_go($itokm), $ibeg_1 );

                # check for a number on the right
                if ( $types_to_go[$itokp] eq 'n' ) {

                    # ok if nothing else on right
                    if ( $itokp == $iend_2 ) {
                        $good_combo = 1;
                    }
                    else {

                        # look one more token to right..
                        # okay if math operator or some termination
                        $good_combo =
                          ( ( $itokpp == $iend_2 )
                              && $is_math_op{ $types_to_go[$itokpp] } )
                          || $types_to_go[$itokpp] =~ /^[#,;]$/;
                    }
                }

                # check for a number on the left
                if ( !$good_combo && $types_to_go[$itokm] eq 'n' ) {

                    # okay if nothing else to left
                    if ( $itokm == $ibeg_1 ) {
                        $good_combo = 1;
                    }

                    # otherwise look one more token to left
                    else {

                        # okay if math operator, comma, or assignment
                        $good_combo = ( $itokmm == $ibeg_1 )
                          && ( $is_math_op{ $types_to_go[$itokmm] }
                            || $types_to_go[$itokmm] =~ /^[,]$/
                            || $is_assignment{ $types_to_go[$itokmm] } );
                    }
                }

                # look for a single short token either side of the
                # operator
                if ( !$good_combo ) {

                    # Slight adjustment factor to make results
                    # independent of break before or after operator
                    # in long summed lists.  (An operator and a
                    # space make two spaces).
                    my $two = ( $itok eq $iend_1 ) ? 2 : 0;

                    $good_combo =

                      # numbers or id's on both sides of this joint
                      $types_to_go[$itokp] =~ /^[in]$/
                      && $types_to_go[$itokm] =~ /^[in]$/

                      # one of the two lines must be short:
                      && (
                        (
                            # no more than 2 nonblank tokens right
                            # of joint
                            $itokpp == $iend_2

                            # short
                            && token_sequence_length( $itokp, $iend_2 ) <
                            $two + $rOpts_short_concatenation_item_length
                        )
                        || (
                            # no more than 2 nonblank tokens left of
                            # joint
                            $itokmm == $ibeg_1

                            # short
                            && token_sequence_length( $ibeg_1, $itokm ) <
                            2 - $two + $rOpts_short_concatenation_item_length
                        )

                      )

                      # keep pure terms; don't mix +- with */
                      && !(
                        $is_plus_minus{$type}
                        && (   $is_mult_div{ $types_to_go[$itokmm] }
                            || $is_mult_div{ $types_to_go[$itokpp] } )
                      )
                      && !(
                        $is_mult_div{$type}
                        && (   $is_plus_minus{ $types_to_go[$itokmm] }
                            || $is_plus_minus{ $types_to_go[$itokpp] } )
                      )

                      ;
                }

                # it is also good to combine if we can reduce to 2
                # lines
                if ( !$good_combo ) {

                    # index on other line where same token would be
                    # in a long chain.
                    my $iother = ( $itok == $iend_1 ) ? $iend_2 : $ibeg_1;

                    $good_combo =
                         $n == 2
                      && $n == $nmax
                      && $types_to_go[$iother] ne $type;
                }

                return unless ($good_combo);

            } ## end math

            elsif ( $is_amp_amp{$type} ) {
                ##TBD
            } ## end &&, ||

            elsif ( $is_assignment{$type} ) {
                ##TBD
            }
            else {
                # not a special type
            }
            ## end assignment
        }

        # ok to combine lines
        return 1;
    } ## end sub recombine_section_0

    sub recombine_section_2 {

        my ( $ri_beg, $ri_end, $n, $this_line_is_semicolon_terminated ) = @_;

        # Recombine Section 2:
        # We are comparing two lines to see if they should be combined
        # into a single line. This sub examines the token '$iend_1' in
        # the following diagram (right end of first line of pair):

        # Here are Indexes of the endpoint tokens of the two lines:
        #
        #  -----line $n-1--- | -----line $n-----
        #  $ibeg_1   $iend_1 | $ibeg_2   $iend_2
        #              ^
        #              |
        #              -----Section 2 looks at this token

        # Returns:
        #   (nothing)         => do not join lines
        #   1, skip_Section_3 => ok to join lines

        # $skip_Section_3 is a flag for skipping the next section
        my $skip_Section_3 = 0;

        my $nmax      = @{$ri_end} - 1;
        my $ibeg_1    = $ri_beg->[ $n - 1 ];
        my $iend_1    = $ri_end->[ $n - 1 ];
        my $iend_2    = $ri_end->[$n];
        my $ibeg_2    = $ri_beg->[$n];
        my $ibeg_3    = $n < $nmax ? $ri_beg->[ $n + 1 ] : -1;
        my $ibeg_nmax = $ri_beg->[$nmax];

        my $type_iend_1 = $types_to_go[$iend_1];
        my $type_iend_2 = $types_to_go[$iend_2];
        my $type_ibeg_1 = $types_to_go[$ibeg_1];
        my $type_ibeg_2 = $types_to_go[$ibeg_2];

        # an isolated '}' may join with a ';' terminated segment
        if ( $type_iend_1 eq '}' ) {

            # Check for cases where combining a semicolon terminated
            # statement with a previous isolated closing paren will
            # allow the combined line to be outdented.  This is
            # generally a good move.  For example, we can join up
            # the last two lines here:
            #  (
            #      $dev,  $ino,   $mode,  $nlink, $uid,     $gid, $rdev,
            #      $size, $atime, $mtime, $ctime, $blksize, $blocks
            #    )
            #    = stat($file);
            #
            # to get:
            #  (
            #      $dev,  $ino,   $mode,  $nlink, $uid,     $gid, $rdev,
            #      $size, $atime, $mtime, $ctime, $blksize, $blocks
            #  ) = stat($file);
            #
            # which makes the parens line up.
            #
            # Another example, from Joe Matarazzo, probably looks best
            # with the 'or' clause appended to the trailing paren:
            #  $self->some_method(
            #      PARAM1 => 'foo',
            #      PARAM2 => 'bar'
            #  ) or die "Some_method didn't work";
            #
            # But we do not want to do this for something like the -lp
            # option where the paren is not outdentable because the
            # trailing clause will be far to the right.
            #
            # The logic here is synchronized with the logic in sub
            # sub get_final_indentation, which actually does
            # the outdenting.
            #
            my $combine_ok = $this_line_is_semicolon_terminated

              # only one token on last line
              && $ibeg_1 == $iend_1

              # must be structural paren
              && $tokens_to_go[$iend_1] eq ')'

              # style must allow outdenting,
              && !$closing_token_indentation{')'}

              # but leading colons probably line up with a
              # previous colon or question (count could be wrong).
              && $type_ibeg_2 ne ':'

              # only one step in depth allowed.  this line must not
              # begin with a ')' itself.
              && ( $nesting_depth_to_go[$iend_1] ==
                $nesting_depth_to_go[$iend_2] + 1 );

            # But only combine leading '&&', '||', if no previous && || :
            # seen. This count includes these tokens at all levels.  The
            # idea is that seeing these at any level can make it hard to read
            # formatting if we recombine.
            if ( $is_amp_amp{$type_ibeg_2} ) {
                foreach my $n_t ( reverse( 0 .. $n - 2 ) ) {
                    my $ibeg_t = $ri_beg->[$n_t];
                    my $type_t = $types_to_go[$ibeg_t];
                    if ( $is_amp_amp{$type_t} || $type_t eq ':' ) {
                        $combine_ok = 0;
                        last;
                    }
                }
            }

            $skip_Section_3 ||= $combine_ok;

            # YVES patch 2 of 2:
            # Allow cuddled eval chains, like this:
            #   eval {
            #       #STUFF;
            #       1; # return true
            #   } or do {
            #       #handle error
            #   };
            # This patch works together with a patch in
            # setting adjusted indentation (where the closing eval
            # brace is outdented if possible).
            # The problem is that an 'eval' block has continuation
            # indentation and it looks better to undo it in some
            # cases.  If we do not use this patch we would get:
            #   eval {
            #       #STUFF;
            #       1; # return true
            #       }
            #       or do {
            #       #handle error
            #     };
            # The alternative, for uncuddled style, is to create
            # a patch in get_final_indentation which undoes
            # the indentation of a leading line like 'or do {'.
            # This doesn't work well with -icb through
            if (
                   $block_type_to_go[$iend_1]
                && $rOpts_brace_follower_vertical_tightness > 0
                && (

                    # -bfvt=1, allow cuddled eval chains [default]
                    (
                           $tokens_to_go[$iend_2] eq '{'
                        && $block_type_to_go[$iend_1] eq 'eval'
                        && !ref( $leading_spaces_to_go[$iend_1] )
                        && !$rOpts_indent_closing_brace
                    )

                    # -bfvt=2, allow most brace followers [part of git #110]
                    || (   $rOpts_brace_follower_vertical_tightness > 1
                        && $ibeg_1 == $iend_1 )

                )

                && (
                    ( $type_ibeg_2 =~ /^(\&\&|\|\|)$/ )
                    || (   $type_ibeg_2 eq 'k'
                        && $is_and_or{ $tokens_to_go[$ibeg_2] } )
                    || $is_if_unless{ $tokens_to_go[$ibeg_2] }
                )
              )
            {
                $skip_Section_3 ||= 1;
            }

            my $keep_going = (
                $skip_Section_3

                  # handle '.' and '?' specially below
                  || ( $type_ibeg_2 =~ /^[\.\?]$/ )

                  # fix for c054 (unusual -pbp case)
                  || $type_ibeg_2 eq '=='
            );

            return unless ($keep_going);
        }

        elsif ( $type_iend_1 eq '{' ) {

            # YVES
            # honor breaks at opening brace
            # Added to prevent recombining something like this:
            #  } || eval { package main;
            return if ( $forced_breakpoint_to_go[$iend_1] );
        }

        # do not recombine lines with ending &&, ||,
        elsif ( $is_amp_amp{$type_iend_1} ) {
            return unless ( $want_break_before{$type_iend_1} );
        }

        # Identify and recombine a broken ?/: chain
        elsif ( $type_iend_1 eq '?' ) {

            # Do not recombine different levels
            return
              if ( $levels_to_go[$ibeg_1] ne $levels_to_go[$ibeg_2] );

            # do not recombine unless next line ends in :
            return unless ( $type_iend_2 eq ':' );
        }

        # for lines ending in a comma...
        elsif ( $type_iend_1 eq ',' ) {

            # Do not recombine at comma which is following the
            # input bias.
            # NOTE: this could be controlled by a special flag,
            # but it seems to work okay.
            return if ( $old_breakpoint_to_go[$iend_1] );

            # An isolated '},' may join with an identifier + ';'
            # This is useful for the class of a 'bless' statement
            # (bless.t)
            if (   $type_ibeg_1 eq '}'
                && $type_ibeg_2 eq 'i' )
            {
                my $combine_ok =
                  (      ( $ibeg_1 == ( $iend_1 - 1 ) )
                      && ( $iend_2 == ( $ibeg_2 + 1 ) )
                      && $this_line_is_semicolon_terminated );

                return if ( !$combine_ok );

                # override breakpoint
                $forced_breakpoint_to_go[$iend_1] = 0;
            }

            # but otherwise ..
            else {

                # do not recombine after a comma unless this will
                # leave just 1 more line
                return if ( $n + 1 < $nmax );

                # do not recombine if there is a change in
                # indentation depth
                return
                  if ( $levels_to_go[$iend_1] != $levels_to_go[$iend_2] );

                # do not recombine a "complex expression" after a
                # comma.  "complex" means no parens.
                my $saw_paren;
                foreach my $ii ( $ibeg_2 .. $iend_2 ) {
                    if ( $tokens_to_go[$ii] eq '(' ) {
                        $saw_paren = 1;
                        last;
                    }
                }
                return if $saw_paren;
            }
        }

        # opening paren..
        elsif ( $type_iend_1 eq '(' ) {

            # No longer doing this
        }

        elsif ( $type_iend_1 eq ')' ) {

            # No longer doing this
        }

        # keep a terminal for-semicolon
        elsif ( $type_iend_1 eq 'f' ) {
            return;
        }

        # if '=' at end of line ...
        elsif ( $is_assignment{$type_iend_1} ) {

            # keep break after = if it was in input stream
            # this helps prevent 'blinkers'
            return
              if (
                $old_breakpoint_to_go[$iend_1]

                # don't strand an isolated '='
                && $iend_1 != $ibeg_1
              );

            my $is_short_quote =
              (      $type_ibeg_2 eq 'Q'
                  && $ibeg_2 == $iend_2
                  && token_sequence_length( $ibeg_2, $ibeg_2 ) <
                  $rOpts_short_concatenation_item_length );
            my $is_ternary_joint = (
                $type_ibeg_1 eq '?' && ( $ibeg_3 >= 0
                    && $types_to_go[$ibeg_3] eq ':' )
            );

            # always join an isolated '=', a short quote, or if this
            # will put ?/: at start of adjacent lines
            if (   $ibeg_1 != $iend_1
                && !$is_short_quote
                && !$is_ternary_joint )
            {
                my $combine_ok = (
                    (

                        # unless we can reduce this to two lines
                        $nmax < $n + 2

                          # or three lines, the last with a leading
                          # semicolon
                          || ( $nmax == $n + 2
                            && $types_to_go[$ibeg_nmax] eq ';' )

                          # or the next line ends with a here doc
                          || $type_iend_2 eq 'h'

                          # or the next line ends in an open paren or
                          # brace and the break hasn't been forced
                          # [dima.t]
                          || (!$forced_breakpoint_to_go[$iend_1]
                            && $type_iend_2 eq '{' )
                    )

                      # do not recombine if the two lines might align
                      # well this is a very approximate test for this
                      && (

                        # RT#127633 - the leading tokens are not
                        # operators
                        ( $type_ibeg_2 ne $tokens_to_go[$ibeg_2] )

                        # or they are different
                        || (   $ibeg_3 >= 0
                            && $type_ibeg_2 ne $types_to_go[$ibeg_3] )
                      )
                );

                return if ( !$combine_ok );

                if (

                    # Recombine if we can make two lines
                    $nmax >= $n + 2

                    # -lp users often prefer this:
                    #  my $title = function($env, $env, $sysarea,
                    #                       "bubba Borrower Entry");
                    #  so we will recombine if -lp is used we have
                    #  ending comma
                    && !(
                           $ibeg_3 > 0
                        && ref( $leading_spaces_to_go[$ibeg_3] )
                        && $type_iend_2 eq ','
                    )
                  )
                {

                    # otherwise, scan the rhs line up to last token for
                    # complexity.  Note that we are not counting the last token
                    # in case it is an opening paren.
                    my $ok = simple_rhs( $ri_end, $n, $nmax, $ibeg_2, $iend_2 );
                    return if ( !$ok );

                }
            }

            if ( $tokens_to_go[$ibeg_2] !~ /^[\{\(\[]$/ ) {
                $forced_breakpoint_to_go[$iend_1] = 0;
            }
        }

        # for keywords..
        elsif ( $type_iend_1 eq 'k' ) {

            # make major control keywords stand out
            # (recombine.t)
            return
              if (

                #/^(last|next|redo|return)$/
                $is_last_next_redo_return{ $tokens_to_go[$iend_1] }

                # but only if followed by multiple lines
                && $n < $nmax
              );

            if ( $is_and_or{ $tokens_to_go[$iend_1] } ) {
                return
                  unless $want_break_before{ $tokens_to_go[$iend_1] };
            }
        }
        elsif ( $type_iend_1 eq '.' ) {

            # NOTE: the logic here should match that of section 3 so that
            # line breaks are independent of choice of break before or after.
            # It would be nice to combine them in section 0, but the
            # special junction case ') .' makes that difficult.
            # This section added to fix issues c172, c174.
            my $i_next_nonblank = $ibeg_2;
            my $summed_len_1    = $summed_lengths_to_go[ $iend_1 + 1 ] -
              $summed_lengths_to_go[$ibeg_1];
            my $summed_len_2 = $summed_lengths_to_go[ $iend_2 + 1 ] -
              $summed_lengths_to_go[$ibeg_2];
            my $iend_1_minus = max( $ibeg_1, iprev_to_go($iend_1) );

            my $combine_ok = (

                # ... unless there is just one and we can reduce
                # this to two lines if we do.  For example, this
                #
                #
                #  $bodyA .=
                #    '($dummy, $pat) = &get_next_tex_cmd;' . '$args .= $pat;'
                #
                #  looks better than this:
                #  $bodyA .= '($dummy, $pat) = &get_next_tex_cmd;' .
                #    '$args .= $pat;'

                # check for 2 lines, not in a long broken '.' chain
                ( $n == 2 && $n == $nmax && $type_iend_1 ne $type_iend_2 )

                  # ... or this would strand a short quote , like this
                  #                "some long quote" .
                  #                "\n";
                  || (
                       $types_to_go[$i_next_nonblank] eq 'Q'
                    && $i_next_nonblank >= $iend_2 - 2
                    && $token_lengths_to_go[$i_next_nonblank] <
                    $rOpts_short_concatenation_item_length

                    #  additional constraints to fix c167
                    && (   $types_to_go[$iend_1_minus] ne 'Q'
                        || $summed_len_2 < $summed_len_1 )
                  )
            );
            return if ( !$combine_ok );

            # added for issue c352
            if ($this_line_is_semicolon_terminated) {
                $forced_breakpoint_to_go[$iend_1] = 0;
            }
        }
        else {
            # not a special type
        }
        return ( 1, $skip_Section_3 );
    } ## end sub recombine_section_2

    sub simple_rhs {

        my ( $ri_end, $n, $nmax, $ibeg_2, $iend_2 ) = @_;

        # Scan line ibeg_2 to $iend_2 up to last token for complexity.
        # We are not counting the last token in case it is an opening paren.

        # Given:
        #   $ri_end - ref to list of indexes of line-ending tokens
        #   $n = current line index
        #   $nmax = maximum line index
        #   ($ibeg_2, $iend_2) = index range of line to scan

        # Return:
        #   true  if rhs is simple, ok to recombine
        #   false otherwise

        my $tv    = 0;
        my $depth = $nesting_depth_to_go[$ibeg_2];
        foreach my $i ( $ibeg_2 + 1 .. $iend_2 - 1 ) {
            if ( $nesting_depth_to_go[$i] != $depth ) {
                $tv++;
                last if ( $tv > 1 );
            }
            $depth = $nesting_depth_to_go[$i];
        }

        # ok to recombine if no level changes before
        # last token
        if ( $tv > 0 ) {

            # otherwise, do not recombine if more than
            # two level changes.
            return if ( $tv > 1 );

            # check total complexity of the two
            # adjacent lines that will occur if we do
            # this join
            my $istop =
              ( $n < $nmax )
              ? $ri_end->[ $n + 1 ]
              : $iend_2;
            foreach my $i ( $iend_2 .. $istop ) {
                if ( $nesting_depth_to_go[$i] != $depth ) {
                    $tv++;
                    last if ( $tv > 2 );
                }
                $depth = $nesting_depth_to_go[$i];
            }

            # do not recombine if total is more than 2
            # level changes
            return if ( $tv > 2 );
        }
        return 1;
    } ## end sub simple_rhs

    sub recombine_section_3 {

        my ( $ri_beg, $ri_end, $n, $this_line_is_semicolon_terminated ) = @_;

        # Recombine Section 3:
        # We are comparing two lines to see if they should be combined
        # into a single line. This sub examines the token '$ibeg_2' in
        # the following diagram (left end of second line of pair):

        # Here are Indexes of the endpoint tokens of the two lines:
        #
        #  -----line $n-1--- | -----line $n-----
        #  $ibeg_1   $iend_1 | $ibeg_2   $iend_2
        #                        ^
        #                        |
        #                        -----Section 3 looks at this token

        # Returns:
        #   (nothing)         => do not join lines
        #   1, bs_tweak => ok to join lines

        # $bstweak is a small tolerance to add to bond strengths
        my $bs_tweak = 0;

        my $nmax   = @{$ri_end} - 1;
        my $ibeg_1 = $ri_beg->[ $n - 1 ];
        my $iend_1 = $ri_end->[ $n - 1 ];
        my $iend_2 = $ri_end->[$n];
        my $ibeg_2 = $ri_beg->[$n];

        my $ibeg_0    = $n > 1          ? $ri_beg->[ $n - 2 ] : -1;
        my $ibeg_3    = $n < $nmax      ? $ri_beg->[ $n + 1 ] : -1;
        my $ibeg_4    = $n + 2 <= $nmax ? $ri_beg->[ $n + 2 ] : -1;
        my $ibeg_nmax = $ri_beg->[$nmax];

        my $type_iend_1 = $types_to_go[$iend_1];
        my $type_iend_2 = $types_to_go[$iend_2];
        my $type_ibeg_1 = $types_to_go[$ibeg_1];
        my $type_ibeg_2 = $types_to_go[$ibeg_2];

        # handle lines with leading &&, ||
        if ( $is_amp_amp{$type_ibeg_2} ) {

            # ok to recombine if it follows a ? or :
            # and is followed by an open paren..
            my $ok =
              ( $is_ternary{$type_ibeg_1} && $tokens_to_go[$iend_2] eq '(' )

              # or is followed by a ? or : at same depth
              #
              # We are looking for something like this. We can
              # recombine the && line with the line above to make the
              # structure more clear:
              #  return
              #    exists $G->{Attr}->{V}
              #    && exists $G->{Attr}->{V}->{$u}
              #    ? %{ $G->{Attr}->{V}->{$u} }
              #    : ();
              #
              # We should probably leave something like this alone:
              #  return
              #       exists $G->{Attr}->{E}
              #    && exists $G->{Attr}->{E}->{$u}
              #    && exists $G->{Attr}->{E}->{$u}->{$v}
              #    ? %{ $G->{Attr}->{E}->{$u}->{$v} }
              #    : ();
              # so that we either have all of the &&'s (or ||'s)
              # on one line, as in the first example, or break at
              # each one as in the second example.  However, it
              # sometimes makes things worse to check for this because
              # it prevents multiple recombinations.  So this is not done.
              || ( $ibeg_3 >= 0
                && $is_ternary{ $types_to_go[$ibeg_3] }
                && $nesting_depth_to_go[$ibeg_3] ==
                $nesting_depth_to_go[$ibeg_2] );

            # Combine a trailing && term with an || term: fix for
            # c060 This is rare but can happen.
            $ok ||= 1
              if ( $ibeg_3 < 0
                && $type_ibeg_2 eq '&&'
                && $type_ibeg_1 eq '||'
                && $nesting_depth_to_go[$ibeg_2] ==
                $nesting_depth_to_go[$ibeg_1] );

            return if !$ok && $want_break_before{$type_ibeg_2};
            $forced_breakpoint_to_go[$iend_1] = 0;

            # tweak the bond strength to give this joint priority
            # over ? and :
            $bs_tweak = 0.25;
        }

        # Identify and recombine a broken ?/: chain
        elsif ( $type_ibeg_2 eq '?' ) {

            # Do not recombine different levels
            my $lev = $levels_to_go[$ibeg_2];
            return if ( $lev ne $levels_to_go[$ibeg_1] );

            # Do not recombine a '?' if either next line or
            # previous line does not start with a ':'.  The reasons
            # are that (1) no alignment of the ? will be possible
            # and (2) the expression is somewhat complex, so the
            # '?' is harder to see in the interior of the line.
            my $follows_colon  = $ibeg_1 >= 0 && $type_ibeg_1 eq ':';
            my $precedes_colon = $ibeg_3 >= 0 && $types_to_go[$ibeg_3] eq ':';
            return unless ( $follows_colon || $precedes_colon );

            # we will always combining a ? line following a : line
            if ( !$follows_colon ) {

                # ...otherwise recombine only if it looks like a
                # chain.  we will just look at a few nearby lines
                # to see if this looks like a chain.
                my $local_count = 0;
                foreach my $ii ( $ibeg_0, $ibeg_1, $ibeg_3, $ibeg_4 ) {
                    $local_count++
                      if $ii >= 0
                      && $types_to_go[$ii] eq ':'
                      && $levels_to_go[$ii] == $lev;
                }
                return if ( $local_count <= 1 );
            }
            $forced_breakpoint_to_go[$iend_1] = 0;
        }

        # do not recombine lines with leading '.'
        elsif ( $type_ibeg_2 eq '.' ) {
            my $i_next_nonblank = min( $inext_to_go[$ibeg_2], $iend_2 );
            my $summed_len_1    = $summed_lengths_to_go[ $iend_1 + 1 ] -
              $summed_lengths_to_go[$ibeg_1];
            my $summed_len_2 = $summed_lengths_to_go[ $iend_2 + 1 ] -
              $summed_lengths_to_go[$ibeg_2];

            my $combine_ok = (

                # ... unless there is just one and we can reduce
                # this to two lines if we do.  For example, this
                #
                #
                #  $bodyA .=
                #    '($dummy, $pat) = &get_next_tex_cmd;' . '$args .= $pat;'
                #
                #  looks better than this:
                #  $bodyA .= '($dummy, $pat) = &get_next_tex_cmd;'
                #    . '$args .= $pat;'

                ( $n == 2 && $n == $nmax && $type_ibeg_1 ne $type_ibeg_2 )

                  # ... or this would strand a short quote , like this
                  #                . "some long quote"
                  #                . "\n";
                  || (
                       $types_to_go[$i_next_nonblank] eq 'Q'
                    && $i_next_nonblank >= $iend_2 - 1
                    && $token_lengths_to_go[$i_next_nonblank] <
                    $rOpts_short_concatenation_item_length

                    #  additional constraints to fix c167
                    && (
                        $types_to_go[$iend_1] ne 'Q'

                        # allow a term shorter than the previous term
                        || $summed_len_2 < $summed_len_1

                        # or allow a short semicolon-terminated term if this
                        # makes two lines (see c169)
                        || (   $n == 2
                            && $n == $nmax
                            && $this_line_is_semicolon_terminated )
                    )
                  )
            );

            return if ( !$combine_ok );

            # added for issue c352
            if ($this_line_is_semicolon_terminated) {
                $forced_breakpoint_to_go[$iend_1] = 0;
            }
        }

        # handle leading keyword..
        elsif ( $type_ibeg_2 eq 'k' ) {

            # handle leading "or"
            if ( $tokens_to_go[$ibeg_2] eq 'or' ) {

                my $combine_ok = (
                    $this_line_is_semicolon_terminated
                      && (
                        $type_ibeg_1 eq '}'
                        || (

                            # following 'if' or 'unless' or 'or'
                            $type_ibeg_1 eq 'k'
                            && $is_if_unless{ $tokens_to_go[$ibeg_1] }

                            # important: only combine a very simple
                            # or statement because the step below
                            # may have combined a trailing 'and'
                            # with this or, and we do not want to
                            # then combine everything together
                            && ( $iend_2 - $ibeg_2 <= 7 )
                        )
                      )
                );

                return if ( !$combine_ok );

                #X: RT #81854
                $forced_breakpoint_to_go[$iend_1] = 0
                  if ( !$old_breakpoint_to_go[$iend_1] );
            }

            # handle leading 'and' and 'xor'
            elsif ($tokens_to_go[$ibeg_2] eq 'and'
                || $tokens_to_go[$ibeg_2] eq 'xor' )
            {

                # Decide if we will combine a single terminal 'and'
                # after an 'if' or 'unless'.

                #     This looks best with the 'and' on the same
                #     line as the 'if':
                #
                #         $a = 1
                #           if $seconds and $nu < 2;
                #
                #     But this looks better as shown:
                #
                #         $a = 1
                #           if !$this->{Parents}{$_}
                #           or $this->{Parents}{$_} eq $_;
                #
                my $combine_ok = $this_line_is_semicolon_terminated
                  && (

                    # following 'if' or 'unless' or 'or'
                    $type_ibeg_1 eq 'k'
                    && (   $is_if_unless{ $tokens_to_go[$ibeg_1] }
                        || $tokens_to_go[$ibeg_1] eq 'or' )
                  );
                return if ( !$combine_ok );
            }

            # handle leading "if" and "unless"
            elsif ( $is_if_unless{ $tokens_to_go[$ibeg_2] } ) {

                # Combine something like:
                #    next
                #      if ( $lang !~ /${l}$/i );
                # into:
                #    next if ( $lang !~ /${l}$/i );
                my $combine_ok = $this_line_is_semicolon_terminated

                  #  previous line begins with 'and' or 'or'
                  && $type_ibeg_1 eq 'k'
                  && $is_and_or{ $tokens_to_go[$ibeg_1] };
                return if ( !$combine_ok );
            }

            # handle all other leading keywords
            else {

                # keywords look best at start of lines,
                # but combine things like "1 while"
                if ( !$is_assignment{$type_iend_1} ) {
                    return
                      if ( ( $type_iend_1 ne 'k' )
                        && ( $tokens_to_go[$ibeg_2] ne 'while' ) );
                }
            }
        }

        # similar treatment of && and || as above for 'and' and
        # 'or': NOTE: This block of code is currently bypassed
        # because of a previous block but is retained for possible
        # future use.
        elsif ( $is_amp_amp{$type_ibeg_2} ) {

            # maybe looking at something like:
            # unless $TEXTONLY || $item =~ m%</?(hr>|p>|a|img)%i;
            my $combine_ok = $this_line_is_semicolon_terminated

              # previous line begins with an 'if' or 'unless'
              # keyword
              && $type_ibeg_1 eq 'k'
              && $is_if_unless{ $tokens_to_go[$ibeg_1] };

            return if ( !$combine_ok );
        }

        # handle line with leading = or similar
        elsif ( $is_assignment{$type_ibeg_2} ) {
            return unless ( $n == 1 || $n == $nmax );
            return if ( $old_breakpoint_to_go[$iend_1] );
            my $combine_ok = (

                # if we can reduce this to two lines
                $nmax == 2

                  # or three lines, the last with a leading semicolon
                  || ( $nmax == 3 && $types_to_go[$ibeg_nmax] eq ';' )

                  # or the next line ends with a here doc
                  || $type_iend_2 eq 'h'

                  # or this is a short line ending in ;
                  || ( $n == $nmax
                    && $this_line_is_semicolon_terminated )
            );
            return if ( !$combine_ok );
            $forced_breakpoint_to_go[$iend_1] = 0;
        }
        else {

        }
        return ( 1, $bs_tweak );
    } ## end sub recombine_section_3

} ## end closure recombine_breakpoints

sub insert_final_ternary_breaks {

    my ( $self, $ri_left, $ri_right ) = @_;

    # Called once per batch to look for and do any final line breaks for
    # long ternary chains
    # Given:
    #   $ri_left = ref to array with token indexes of the left line ends
    #   $ri_right = ref to array with token indexes of the right line ends

    my $nmax = @{$ri_right} - 1;

    # scan the left and right end tokens of all lines
    my $i_first_colon = -1;
    for my $n ( 0 .. $nmax ) {
        my $il    = $ri_left->[$n];
        my $ir    = $ri_right->[$n];
        my $typel = $types_to_go[$il];
        my $typer = $types_to_go[$ir];
        return if ( $typel eq '?' );
        return if ( $typer eq '?' );
        if ( $typel eq ':' ) { $i_first_colon = $il; last; }
        if ( $typer eq ':' ) { $i_first_colon = $ir; last; }
    }

    # For long ternary chains,
    # if the first : we see has its ? is in the interior
    # of a preceding line, then see if there are any good
    # breakpoints before the ?.
    if ( $i_first_colon > 0 ) {
        my $i_question = $mate_index_to_go[$i_first_colon];
        if ( defined($i_question) && $i_question > 0 ) {
            my @insert_list;
            foreach my $ii ( reverse( 0 .. $i_question - 1 ) ) {
                my $token = $tokens_to_go[$ii];
                my $type  = $types_to_go[$ii];

                # For now, a good break is either a comma or,
                # in a long chain, a 'return'.
                # Patch for RT #126633: added the $nmax>1 check to avoid
                # breaking after a return for a simple ternary.  For longer
                # chains the break after return allows vertical alignment, so
                # it is still done.  So perltidy -wba='?' will not break
                # immediately after the return in the following statement:
                # sub x {
                #    return 0 ? 'aaaaaaaaaaaaaaaaaaaaa' :
                #      'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
                # }
                if (
                    (
                           $type eq ','
                        || $type eq 'k' && ( $nmax > 1 && $token eq 'return' )
                    )
                    && $self->in_same_container_i( $ii, $i_question )
                  )
                {
                    push @insert_list, $ii;
                    last;
                }
            }

            # insert any new break points
            if (@insert_list) {
                $self->insert_additional_breaks( \@insert_list, $ri_left,
                    $ri_right );
            }
        }
    }
    return;
} ## end sub insert_final_ternary_breaks

sub insert_breaks_before_list_opening_containers {

    my ( $self, $ri_left, $ri_right ) = @_;

    # This routine is called once per batch to implement the parameters
    # --break-before-hash-brace, etc.

    # Given:
    #   $ri_left = ref to array with token indexes of the left line ends
    #   $ri_right = ref to array with token indexes of the right line ends

    # Nothing to do if none of these parameters has been set
    return unless %break_before_container_types;

    my $nmax = @{$ri_right} - 1;
    return if ( $nmax < 0 );

    my $rLL = $self->[_rLL_];

    my $rbreak_before_container_by_seqno =
      $self->[_rbreak_before_container_by_seqno_];
    my $rK_weld_left = $self->[_rK_weld_left_];

    # scan the ends of all lines
    my @insert_list;
    for my $n ( 0 .. $nmax ) {
        my $il = $ri_left->[$n];
        my $ir = $ri_right->[$n];
        next if ( $ir <= $il );
        my $Kl       = $K_to_go[$il];
        my $Kr       = $K_to_go[$ir];
        my $Kend     = $Kr;
        my $type_end = $rLL->[$Kr]->[_TYPE_];

        # Backup before any side comment
        if ( $type_end eq '#' ) {
            $Kend = $self->K_previous_nonblank($Kr);
            next unless defined($Kend);
            $type_end = $rLL->[$Kend]->[_TYPE_];
        }

        # Backup to the start of any weld; fix for b1173.
        if ($total_weld_count) {
            my $Kend_test = $rK_weld_left->{$Kend};
            if ( defined($Kend_test) && $Kend_test > $Kl ) {
                $Kend      = $Kend_test;
                $Kend_test = $rK_weld_left->{$Kend};
            }

            # Do not break if we did not back up to the start of a weld
            # (shouldn't happen)
            next if ( defined($Kend_test) );
        }

        my $token = $rLL->[$Kend]->[_TOKEN_];
        next if ( !$is_opening_token{$token} );
        next if ( $Kl >= $Kend - 1 );

        my $seqno = $rLL->[$Kend]->[_TYPE_SEQUENCE_];
        next if ( !defined($seqno) );

        # Use the flag which was previously set
        next unless ( $rbreak_before_container_by_seqno->{$seqno} );

        # Install a break before this opening token.
        my $Kbreak = $self->K_previous_nonblank($Kend);
        my $ibreak = $Kbreak - $Kl + $il;
        next if ( $ibreak < $il );
        next if ( $nobreak_to_go[$ibreak] );
        push @insert_list, $ibreak;
    }

    # insert any new break points
    if (@insert_list) {
        $self->insert_additional_breaks( \@insert_list, $ri_left, $ri_right );
    }
    return;
} ## end sub insert_breaks_before_list_opening_containers

sub note_added_semicolon {
    my ( $self, $line_number ) = @_;
    $self->[_last_added_semicolon_at_] = $line_number;
    if ( $self->[_added_semicolon_count_] == 0 ) {
        $self->[_first_added_semicolon_at_] = $line_number;
    }
    $self->[_added_semicolon_count_]++;
    write_logfile_entry("Added ';' here\n");
    return;
} ## end sub note_added_semicolon

sub note_deleted_semicolon {
    my ( $self, $line_number ) = @_;
    $self->[_last_deleted_semicolon_at_] = $line_number;
    if ( $self->[_deleted_semicolon_count_] == 0 ) {
        $self->[_first_deleted_semicolon_at_] = $line_number;
    }
    $self->[_deleted_semicolon_count_]++;
    write_logfile_entry("Deleted unnecessary ';' at line $line_number\n");
    return;
} ## end sub note_deleted_semicolon

sub note_embedded_tab {
    my ( $self, $line_number ) = @_;
    $self->[_embedded_tab_count_]++;
    $self->[_last_embedded_tab_at_] = $line_number;
    if ( !$self->[_first_embedded_tab_at_] ) {
        $self->[_first_embedded_tab_at_] = $line_number;
    }

    if ( $self->[_embedded_tab_count_] <= MAX_NAG_MESSAGES ) {
        write_logfile_entry("Embedded tabs in quote or pattern\n");
    }
    return;
} ## end sub note_embedded_tab

use constant DEBUG_CORRECT_LP => 0;

sub correct_lp_indentation {

    my ($self) = @_;

    # When the -lp option is used, we need to make a last pass through
    # each line to correct the indentation positions in case they differ
    # from the predictions.  This is necessary because perltidy uses a
    # predictor/corrector method for aligning with opening parens.  The
    # predictor is usually good, but sometimes stumbles.  The corrector
    # tries to patch things up once the actual opening paren locations
    # are known.

    my $this_batch = $self->[_this_batch_];

    my $ri_first = $this_batch->[_ri_first_];
    my $ri_last  = $this_batch->[_ri_last_];

    # first remove continuation indentation if appropriate
    my $max_line = @{$ri_first} - 1;

    #---------------------------------------------------------------------------
    # PASS 1: reduce indentation if necessary at any long one-line blocks (c098)
    #---------------------------------------------------------------------------

    # The point is that sub 'starting_one_line_block' made one-line blocks based
    # on default indentation, not -lp indentation. So some of the one-line
    # blocks may be too long when given -lp indentation.  We will fix that now
    # if possible, using the list of these closing block indexes.
    my $ri_starting_one_line_block =
      $this_batch->[_ri_starting_one_line_block_];
    if ( @{$ri_starting_one_line_block} ) {
        $self->correct_lp_indentation_pass_1( $ri_first, $ri_last,
            $ri_starting_one_line_block );
    }

    #-------------------------------------------------------------------
    # PASS 2: look for and fix other problems in each line of this batch
    #-------------------------------------------------------------------

    # look at each output line ...
    foreach my $line ( 0 .. $max_line ) {
        my $ibeg = $ri_first->[$line];
        my $iend = $ri_last->[$line];

        # looking at each token in this output line ...
        foreach my $i ( $ibeg .. $iend ) {

            # How many space characters to place before this token
            # for special alignment.  Actual padding is done in the
            # continue block.

            # looking for next unvisited indentation item ...
            my $indentation = $leading_spaces_to_go[$i];

            # This is just for indentation objects (c098)
            next unless ( ref($indentation) );

            # Visit each indentation object just once
            next if ( $indentation->get_marked() );

            # Mark first visit
            $indentation->set_marked(1);

            # Skip indentation objects which do not align with container tokens
            my $align_seqno = $indentation->get_align_seqno();
            next unless ($align_seqno);

            # Skip a container which is entirely on this line
            my $Ko = $self->[_K_opening_container_]->{$align_seqno};
            my $Kc = $self->[_K_closing_container_]->{$align_seqno};
            if ( defined($Ko) && defined($Kc) ) {
                next if ( $Ko >= $K_to_go[$ibeg] && $Kc <= $K_to_go[$iend] );
            }

            #  Note on flag '$do_not_pad':
            #  We want to avoid a situation like this, where the aligner
            #  inserts whitespace before the '=' to align it with a previous
            #  '=', because otherwise the parens might become mis-aligned in a
            #  situation like this, where the '=' has become aligned with the
            #  previous line, pushing the opening '(' forward beyond where we
            #  want it.
            #
            #  $mkFloor::currentRoom = '';
            #  $mkFloor::c_entry     = $c->Entry(
            #                                 -width        => '10',
            #                                 -relief       => 'sunken',
            #                                 ...
            #                                 );
            #
            #  We leave it to the aligner to decide how to do this.
            if ( $line == 1 && $i == $ibeg ) {
                $this_batch->[_do_not_pad_] = 1;
            }

            #--------------------------------------------
            # Now see what the error is and try to fix it
            #--------------------------------------------
            my $closing_index = $indentation->get_closed();
            my $predicted_pos = $indentation->get_spaces();

            # Find actual position:
            my $actual_pos;

            if ( $i == $ibeg ) {

                # Case 1: token is first character of of batch - table lookup
                if ( $line == 0 ) {

                    $actual_pos = $predicted_pos;

                    my ( $indent, $offset, $is_leading_uu, $exists_uu ) =
                      get_saved_opening_indentation($align_seqno);
                    if ( defined($indent) ) {

                        # NOTE: we could use '1' here if no space after
                        # opening and '2' if want space; it is hardwired at 1
                        # like -gnu-style. But it is probably best to leave
                        # this alone because changing it would change
                        # formatting of much existing code without any
                        # significant benefit.
                        $actual_pos = get_spaces($indent) + $offset + 1;
                    }
                }

                # Case 2: token starts a new line - use length of previous line
                else {

                    my $ibegm = $ri_first->[ $line - 1 ];
                    my $iendm = $ri_last->[ $line - 1 ];
                    $actual_pos = total_line_length( $ibegm, $iendm );

                    # follow -pt style
                    ++$actual_pos
                      if ( $types_to_go[ $iendm + 1 ] eq 'b' );

                }
            }

            # Case 3: $i>$ibeg: token is mid-line - use length to previous token
            else {

                $actual_pos = total_line_length( $ibeg, $i - 1 );

                # for mid-line token, we must check to see if all
                # additional lines have continuation indentation,
                # and remove it if so.  Otherwise, we do not get
                # good alignment.
                if ( $closing_index > $iend ) {
                    my $ibeg_next = $ri_first->[ $line + 1 ];
                    if ( $ci_levels_to_go[$ibeg_next] > 0 ) {
                        $self->undo_lp_ci( $line, $i, $closing_index,
                            $ri_first, $ri_last );
                    }
                }
            }

            # By how many spaces (plus or minus) would we need to increase the
            # indentation to get alignment with the opening token?
            my $move_right = $actual_pos - $predicted_pos;

            if (DEBUG_CORRECT_LP) {
                my $tok   = substr( $tokens_to_go[$i], 0, 8 );
                my $avail = $self->get_available_spaces_to_go($ibeg);
                print
"CORRECT_LP for seq=$align_seqno, predicted pos=$predicted_pos actual=$actual_pos => move right=$move_right available=$avail i=$i max=$max_index_to_go tok=$tok\n";
            }

            # nothing more to do if no error to correct (gnu2.t)
            if ( $move_right == 0 ) {
                $indentation->set_recoverable_spaces($move_right);
                next;
            }

            # Get any collapsed length defined for -xlp
            my $collapsed_length =
              $self->[_rcollapsed_length_by_seqno_]->{$align_seqno};
            $collapsed_length = 0 unless ( defined($collapsed_length) );

            if (DEBUG_CORRECT_LP) {
                print
"CORRECT_LP for seq=$align_seqno, collapsed length is $collapsed_length\n";
            }

            # if we have not seen closure for this indentation in this batch,
            # and do not have a collapsed length estimate, we can only pass on
            # a request to the vertical aligner
            if ( $closing_index < 0 && !$collapsed_length ) {
                $indentation->set_recoverable_spaces($move_right);
                next;
            }

            # If necessary, look ahead to see if there is really any leading
            # whitespace dependent on this whitespace, and also find the
            # longest line using this whitespace.  Since it is always safe to
            # move left if there are no dependents, we only need to do this if
            # we may have dependent nodes or need to move right.

            my $have_child = $indentation->get_have_child();
            my %saw_indentation;
            my $line_count = 1;
            $saw_indentation{$indentation} = $indentation;

            # How far can we move right before we hit the limit?
            # let $right_margen = the number of spaces that we can increase
            # the current indentation before hitting the maximum line length.
            my $right_margin = 0;

            if ( $have_child || $move_right > 0 ) {
                $have_child = 0;

                # include estimated collapsed length for incomplete containers
                my $max_length = 0;
                if ( $Kc > $K_to_go[$max_index_to_go] ) {
                    $max_length = $collapsed_length + $predicted_pos;
                }

                if ( $i == $ibeg ) {
                    my $length = total_line_length( $ibeg, $iend );
                    if ( $length > $max_length ) { $max_length = $length }
                }

                # look ahead at the rest of the lines of this batch..
                foreach my $line_t ( $line + 1 .. $max_line ) {
                    my $ibeg_t = $ri_first->[$line_t];
                    my $iend_t = $ri_last->[$line_t];
                    last if ( $closing_index <= $ibeg_t );

                    # remember all different indentation objects
                    my $indentation_t = $leading_spaces_to_go[$ibeg_t];
                    $saw_indentation{$indentation_t} = $indentation_t;
                    $line_count++;

                    # remember longest line in the group
                    my $length_t = total_line_length( $ibeg_t, $iend_t );
                    if ( $length_t > $max_length ) {
                        $max_length = $length_t;
                    }
                }

                $right_margin =
                  $maximum_line_length_at_level[ $levels_to_go[$ibeg] ] -
                  $max_length;
                if ( $right_margin < 0 ) { $right_margin = 0 }
            }

            my $first_line_comma_count =
              grep { $_ eq ',' } @types_to_go[ $ibeg .. $iend ];
            my $comma_count = $indentation->get_comma_count();
            my $arrow_count = $indentation->get_arrow_count();

            # This is a simple approximate test for vertical alignment:
            # if we broke just after an opening paren, brace, bracket,
            # and there are 2 or more commas in the first line,
            # and there are no '=>'s,
            # then we are probably vertically aligned.  We could set
            # an exact flag in sub break_lists, but this is good
            # enough.
            my $indentation_count = keys %saw_indentation;
            my $is_vertically_aligned =
              (      $i == $ibeg
                  && $first_line_comma_count > 1
                  && $indentation_count == 1
                  && ( $arrow_count == 0 || $arrow_count == $line_count ) );

            # Make the move if possible ..
            if (

                # we can always move left
                $move_right < 0

                # -xlp

                # incomplete container
                || (   $rOpts_extended_line_up_parentheses
                    && $Kc > $K_to_go[$max_index_to_go] )
                || $closing_index < 0

                # but we should only move right if we are sure it will
                # not spoil vertical alignment
                || ( $comma_count == 0 )
                || ( $comma_count > 0 && !$is_vertically_aligned )
              )
            {
                my $move =
                  ( $move_right <= $right_margin )
                  ? $move_right
                  : $right_margin;

                if (DEBUG_CORRECT_LP) {
                    print
                      "CORRECT_LP for seq=$align_seqno, moving $move spaces\n";
                }

                foreach ( keys %saw_indentation ) {
                    $saw_indentation{$_}
                      ->permanently_decrease_available_spaces( -$move );
                }
            }

            # Otherwise, record what we want and the vertical aligner
            # will try to recover it.
            else {
                $indentation->set_recoverable_spaces($move_right);
            }
        } ## end loop over tokens in a line
    } ## end loop over lines
    return;
} ## end sub correct_lp_indentation

sub correct_lp_indentation_pass_1 {
    my ( $self, $ri_first, $ri_last, $ri_starting_one_line_block ) = @_;

    # So some of the one-line blocks may be too long when given -lp
    # indentation.  We will fix that now if possible, using the list of these
    # closing block indexes.
    # Given:
    #   $ri_first - reference to current list of the first index $i for each
    #               output line in this batch
    #   $ri_last - reference to current list of the last index $i for each
    #               output line in this batch
    #   $ri_starting_one_line_block = list of indexes starting 1-line blocks

    my @ilist = @{$ri_starting_one_line_block};
    return unless (@ilist);

    my $max_line = @{$ri_first} - 1;
    my $inext    = shift @ilist;

    # loop over lines, checking length of each with a one-line block
    my ( $ibeg, $iend );
    foreach my $line ( 0 .. $max_line ) {
        $iend = $ri_last->[$line];
        next if ( $inext > $iend );
        $ibeg = $ri_first->[$line];

        # This is just for lines with indentation objects (c098)
        my $excess =
          ref( $leading_spaces_to_go[$ibeg] )
          ? $self->excess_line_length( $ibeg, $iend )
          : 0;

        if ( $excess > 0 ) {
            my $available_spaces = $self->get_available_spaces_to_go($ibeg);

            if ( $available_spaces > 0 ) {
                my $delete_want = min( $available_spaces, $excess );
                my $deleted_spaces_uu =
                  $self->reduce_lp_indentation( $ibeg, $delete_want );
                $available_spaces = $self->get_available_spaces_to_go($ibeg);
            }
        }

        # skip forward to next one-line block to check
        while (@ilist) {
            $inext = shift @ilist;
            next if ( $inext <= $iend );
            last if ( $inext > $iend );
        }
        last if ( $inext <= $iend );
    }
    return;
} ## end sub correct_lp_indentation_pass_1

sub undo_lp_ci {

    my ( $self, $line_open, $i_start, $closing_index, $ri_first, $ri_last ) =
      @_;

    # If there is a single, long parameter within parens, like this:
    #
    #  $self->command( "/msg "
    #        . $infoline->chan
    #        . " You said $1, but did you know that it's square was "
    #        . $1 * $1 . " ?" );
    #
    # we can remove the continuation indentation of the 2nd and higher lines
    # to achieve this effect, which is more pleasing:
    #
    #  $self->command("/msg "
    #                 . $infoline->chan
    #                 . " You said $1, but did you know that it's square was "
    #                 . $1 * $1 . " ?");
    # Given:
    #   $line_open = index of line with opening paren
    #   $i_start = index of token at end of starting line ["/msg" above]
    #   $closing_index = index of the closing token
    #   $ri_first - reference to current list of the first index $i for each
    #               output line in this batch
    #   $ri_last - reference to current list of the last index $i for each
    #               output line in this batch

    my $max_line = @{$ri_first} - 1;

    # must be multiple lines
    return if ( $max_line <= $line_open );

    my $lev_start     = $levels_to_go[$i_start];
    my $ci_start_plus = 1 + $ci_levels_to_go[$i_start];

    # see if all additional lines in this container have continuation
    # indentation
    my $line_1 = 1 + $line_open;
    my $n      = $line_open;

    while ( ++$n <= $max_line ) {
        my $ibeg = $ri_first->[$n];
        my $iend = $ri_last->[$n];
        if ( $ibeg eq $closing_index ) { $n--; last }
        return if ( $lev_start != $levels_to_go[$ibeg] );
        return if ( $ci_start_plus != $ci_levels_to_go[$ibeg] );
        last   if ( $closing_index <= $iend );
    } ## end while ( ++$n <= $max_line)

    # we can reduce the indentation of all continuation lines
    my $continuation_line_count = $n - $line_open;
    @ci_levels_to_go[ @{$ri_first}[ $line_1 .. $n ] ] =
      (0) x ($continuation_line_count);
    @leading_spaces_to_go[ @{$ri_first}[ $line_1 .. $n ] ] =
      @reduced_spaces_to_go[ @{$ri_first}[ $line_1 .. $n ] ];
    return;
} ## end sub undo_lp_ci

################################################
# CODE SECTION 10: Code to break long statements
################################################

use constant DEBUG_BREAK_LINES => 0;

sub break_long_lines {

    my ( $self, $saw_good_break, $rcolon_list, $rbond_strength_bias ) = @_;

    #-----------------------------------------------------------
    # Break a batch of tokens into lines which do not exceed the
    # maximum line length.
    #-----------------------------------------------------------

    # Input parameters:
    #  $saw_good_break - a flag set by break_lists
    #  $rcolon_list    - ref to a list of all the ? and : tokens in the batch,
    #    in order.
    #  $rbond_strength_bias - small bond strength bias values set by break_lists

    # Output: returns references to the arrays:
    #  @i_first
    #  @i_last
    # which contain the indexes $i of the first and last tokens on each
    # line.

    # In addition, the array:
    #   $forced_breakpoint_to_go[$i]
    # may be updated to be =1 for any index $i after which there must be
    # a break.  This signals later routines not to undo the breakpoint.

    # Method:
    # This routine is called if a statement is longer than the maximum line
    # length, or if a preliminary scanning located desirable break points.
    # Sub break_lists has already looked at these tokens and set breakpoints
    # (in array $forced_breakpoint_to_go[$i]) where it wants breaks (for
    # example after commas, after opening parens, and before closing parens).
    # This routine will honor these breakpoints and also add additional
    # breakpoints as necessary to keep the line length below the maximum
    # requested.  It bases its decision on where the 'bond strength' is
    # lowest.

    my @i_first        = ();    # the first index to output
    my @i_last         = ();    # the last index to output
    my @i_colon_breaks = ();    # needed to decide if we have to break at ?'s
    if ( $types_to_go[0] eq ':' ) { push @i_colon_breaks, 0 }

    # Get the 'bond strengths' between tokens
    my $rbond_strength_to_go = $self->set_bond_strengths();

    # Add any comma bias set by break_lists
    if ( @{$rbond_strength_bias} ) {
        foreach my $item ( @{$rbond_strength_bias} ) {
            my ( $ii, $bias ) = @{$item};
            if ( $ii >= 0 && $ii <= $max_index_to_go ) {
                $rbond_strength_to_go->[$ii] += $bias;
            }
            else {
                if (DEVEL_MODE) {
                    my $KK  = $K_to_go[0];
                    my $lno = $self->[_rLL_]->[$KK]->[_LINE_INDEX_];
                    Fault(
"Bad bond strength bias near line $lno: i=$ii must be between 0 and $max_index_to_go\n"
                    );
                }
            }
        }
    }

    my $imin = 0;
    my $imax = $max_index_to_go;
    if ( $types_to_go[$imin] eq 'b' ) { $imin++ }
    if ( $types_to_go[$imax] eq 'b' ) { $imax-- }

    my $i_begin             = $imin;
    my $last_break_strength = NO_BREAK;
    my $i_last_break        = -1;
    my $line_count          = 0;

    # see if any ?/:'s are in order
    my $colons_in_order = 1;
    my $last_tok        = EMPTY_STRING;
    foreach ( @{$rcolon_list} ) {
        if ( $_ eq $last_tok ) { $colons_in_order = 0; last }
        $last_tok = $_;
    }

    # This is a sufficient but not necessary condition for colon chain
    my $is_colon_chain = ( $colons_in_order && @{$rcolon_list} > 2 );

    #------------------------------------------
    # BEGINNING of main loop to set breakpoints
    # Keep iterating until we reach the end
    #------------------------------------------
    while ( $i_begin <= $imax ) {

        #------------------------------------------------------------------
        # Find the best next breakpoint based on token-token bond strengths
        #------------------------------------------------------------------
        my ( $i_lowest, $lowest_strength, $Msg ) =
          $self->break_lines_inner_loop(

            $i_begin,
            $i_last_break,
            $imax,
            $last_break_strength,
            $line_count,
            $rbond_strength_to_go,
            $saw_good_break,

          );

        # Now make any adjustments required by ternary breakpoint rules
        if ( @{$rcolon_list} ) {

            my $i_next_nonblank = $inext_to_go[$i_lowest];

            #-------------------------------------------------------
            # ?/: rule 1 : if a break here will separate a '?' on this
            # line from its closing ':', then break at the '?' instead.
            # But do not break a sequential chain of ?/: statements
            #-------------------------------------------------------
            if ( !$is_colon_chain ) {
                foreach my $i ( $i_begin + 1 .. $i_lowest - 1 ) {
                    next unless ( $tokens_to_go[$i] eq '?' );

                    # do not break if statement is broken by side comment
                    next
                      if ( $tokens_to_go[$max_index_to_go] eq '#'
                        && terminal_type_i( 0, $max_index_to_go ) !~
                        /^[\;\}]$/ );

                    # no break needed if matching : is also on the line
                    next
                      if ( defined( $mate_index_to_go[$i] )
                        && $mate_index_to_go[$i] <= $i_next_nonblank );

                    $i_lowest = $i;
                    if ( $want_break_before{'?'} ) { $i_lowest-- }
                    $i_next_nonblank = $inext_to_go[$i_lowest];
                    last;
                }
            }

            my $next_nonblank_type = $types_to_go[$i_next_nonblank];

            #-------------------------------------------------------------
            # ?/: rule 2 : if we break at a '?', then break at its ':'
            #
            # Note: this rule is also in sub break_lists to handle a break
            # at the start and end of a line (in case breaks are dictated
            # by side comments).
            #-------------------------------------------------------------
            if ( $next_nonblank_type eq '?' ) {
                $self->set_closing_breakpoint($i_next_nonblank);
            }
            elsif ( $types_to_go[$i_lowest] eq '?' ) {
                $self->set_closing_breakpoint($i_lowest);
            }
            else {
                # not at a '?'
            }

            #--------------------------------------------------------
            # ?/: rule 3 : if we break at a ':' then we save
            # its location for further work below.  We may need to go
            # back and break at its '?'.
            #--------------------------------------------------------
            if ( $next_nonblank_type eq ':' ) {
                push @i_colon_breaks, $i_next_nonblank;
            }
            elsif ( $types_to_go[$i_lowest] eq ':' ) {
                push @i_colon_breaks, $i_lowest;
            }
            else {
                # not at a ':'
            }

            # here we should set breaks for all '?'/':' pairs which are
            # separated by this line
        }

        # Fix two-line shear (c406)
        my $i_next_nonblank = $inext_to_go[$i_lowest];
        if ( $tokens_to_go[$i_next_nonblank] eq ')' ) {

            # Example of a '2 line shear':

            #   $wrapped->add_around_modifier(
            #       sub { push @tracelog => 'around 1'; $_[0]->(); } );

            # If we try formatting this with increasing line lengths, the
            # break based on bond strengths is after the '(' until the closing
            # paren is just beyond the line length limit. In that case, it can
            # switch to being just before the ')'.  This is rare, and may be
            # undesirable because it can cause unexpected formatting
            # variations between similar code, and worse, instability with
            # trailing commas.  So we check for that here and put the break
            # back after the opening '(' if the ')' is not preceded by a ','.
            # Issue c406.
            my $i_prev    = iprev_to_go($i_next_nonblank);
            my $i_opening = $mate_index_to_go[$i_next_nonblank];
            if (   $types_to_go[$i_prev] ne ','
                && defined($i_opening)
                && $i_opening > $i_last_break )
            {
                # set a forced breakpoint to block recombination
                $i_lowest = $i_opening;
                $forced_breakpoint_to_go[$i_lowest] = 1;
            }
        }

        #--------------------------------------------------
        # guard against infinite loop (should never happen)
        #--------------------------------------------------
        if ( $i_lowest <= $i_last_break ) {
            DEVEL_MODE
              && Fault("i_lowest=$i_lowest <= i_last_break=$i_last_break\n");
            $i_lowest = $imax;
        }

        DEBUG_BREAK_LINES
          && print {*STDOUT}
"BREAK: best is i = $i_lowest strength = $lowest_strength;\nReason>> $Msg\n";

        $line_count++;

        # save this line segment, after trimming blanks at the ends
        push( @i_first,
            ( $types_to_go[$i_begin] eq 'b' ) ? $i_begin + 1 : $i_begin );
        push( @i_last,
            ( $types_to_go[$i_lowest] eq 'b' ) ? $i_lowest - 1 : $i_lowest );

        # set a forced breakpoint at a container opening, if necessary, to
        # signal a break at a closing container.  Excepting '(' for now.
        if (
            (
                   $tokens_to_go[$i_lowest] eq '{'
                || $tokens_to_go[$i_lowest] eq '['
            )
            && !$forced_breakpoint_to_go[$i_lowest]
          )
        {
            $self->set_closing_breakpoint($i_lowest);
        }

        # get ready to find the next breakpoint
        $last_break_strength = $lowest_strength;
        $i_last_break        = $i_lowest;
        $i_begin             = $i_lowest + 1;

        # skip past a blank
        if ( ( $i_begin <= $imax ) && ( $types_to_go[$i_begin] eq 'b' ) ) {
            $i_begin++;
        }
    } ## end while ( $i_begin <= $imax)

    #-------------------------------------------------
    # END of main loop to set continuation breakpoints
    #-------------------------------------------------

    #-----------------------------------------------------------
    # ?/: rule 4 -- if we broke at a ':', then break at
    # corresponding '?' unless this is a chain of ?: expressions
    #-----------------------------------------------------------
    if (@i_colon_breaks) {
        my $is_chain = ( $colons_in_order && @i_colon_breaks > 1 );
        if ( !$is_chain ) {
            $self->do_colon_breaks( \@i_colon_breaks, \@i_first, \@i_last );
        }
    }

    return ( \@i_first, \@i_last, $rbond_strength_to_go );
} ## end sub break_long_lines

# small bond strength numbers to help break ties
use constant TINY_BIAS => 0.0001;
use constant MAX_BIAS  => 0.001;

my %is_dot_and_or;

BEGIN {
    my @q = qw( . && || );
    @is_dot_and_or{@q} = (1) x scalar(@q);
}

sub break_lines_inner_loop {

    # Find the best next breakpoint in index range ($i_begin .. $imax)
    # which, if possible, does not exceed the maximum line length.

    my (
        $self,

        $i_begin,
        $i_last_break,
        $imax,
        $last_break_strength,
        $line_count,
        $rbond_strength_to_go,
        $saw_good_break,

    ) = @_;

    # Given:
    #   $i_begin               = first index of range
    #   $i_last_break          = index of previous break
    #   $imax                  = last index of range
    #   $last_break_strength   = bond strength of last break
    #   $line_count            = number of output lines so far
    #   $rbond_strength_to_go  = ref to array of bond strengths
    #   $saw_good_break        = true if old line had a good breakpoint

    # Returns:
    #   $i_lowest               = index of best breakpoint
    #   $lowest_strength        = 'bond strength' at best breakpoint
    #   $Msg                    = string of debug info

    my $Msg                    = EMPTY_STRING;
    my $strength               = NO_BREAK;
    my $i_test                 = $i_begin - 1;
    my $i_lowest               = -1;
    my $starting_sum           = $summed_lengths_to_go[$i_begin];
    my $lowest_strength        = NO_BREAK;
    my $leading_alignment_type = EMPTY_STRING;
    my $leading_spaces         = leading_spaces_to_go($i_begin);
    my $maximum_line_length =
      $maximum_line_length_at_level[ $levels_to_go[$i_begin] ];
    DEBUG_BREAK_LINES
      && do {
        $Msg .= "updating leading spaces to be $leading_spaces at i=$i_begin\n";
      };

    # Do not separate an isolated bare word from an opening paren.
    # Alternate Fix #2 for issue b1299.  This waits as long as possible
    # to make the decision.
    # Note for fix #c250: to keep line breaks unchanged under -extrude when
    # switching from 'i' to 'S' for subs, we would have to also check 'S', i.e.
    # =~/^[Si]$/.  But this was never necessary at a sub signature, so we leave
    # it alone and allow the new version to be different for --extrude. For a
    # test file run perl527/signatures.t with --extrude.
    if ( $types_to_go[$i_begin] eq 'i'
        && substr( $tokens_to_go[$i_begin], 0, 1 ) =~ /\w/ )
    {
        my $i_next_nonblank = $inext_to_go[$i_begin];
        if ( $tokens_to_go[$i_next_nonblank] eq '(' ) {
            $rbond_strength_to_go->[$i_begin] = NO_BREAK;
        }
    }

    # Avoid a break which would strand a single punctuation
    # token.  For example, we do not want to strand a leading
    # '.' which is followed by a long quoted string.
    # But note that we do want to do this with -extrude (l=1)
    # so please test any changes to this code on -extrude.
    if (
           ( $i_begin < $imax )
        && ( $tokens_to_go[$i_begin] eq $types_to_go[$i_begin] )
        && !$forced_breakpoint_to_go[$i_begin]
        && !(

            # Allow break after a closing eval brace. This is an
            # approximate way to simulate a forced breakpoint made in
            # Section B below.  No differences have been found, but if
            # necessary the full logic of Section B could be used here
            # (see c165).
            $tokens_to_go[$i_begin] eq '}'
            && $block_type_to_go[$i_begin]
            && $block_type_to_go[$i_begin] eq 'eval'
        )
        && (
            (
                $leading_spaces +
                $summed_lengths_to_go[ $i_begin + 1 ] -
                $starting_sum
            ) < $maximum_line_length
        )
      )
    {
        $i_test = min( $imax, $inext_to_go[$i_begin] ) - 1;
        DEBUG_BREAK_LINES && do {
            $Msg .= " :skip ahead at i=$i_test";
        };
    }

    #-------------------------------------------------------
    # Begin INNER_LOOP over the indexes in the _to_go arrays
    #-------------------------------------------------------
    while ( ++$i_test <= $imax ) {
        my $type                     = $types_to_go[$i_test];
        my $token                    = $tokens_to_go[$i_test];
        my $i_next_nonblank          = $inext_to_go[$i_test];
        my $next_nonblank_type       = $types_to_go[$i_next_nonblank];
        my $next_nonblank_token      = $tokens_to_go[$i_next_nonblank];
        my $next_nonblank_block_type = $block_type_to_go[$i_next_nonblank];

        #---------------------------------------------------------------
        # Section A: Get token-token strength and handle any adjustments
        #---------------------------------------------------------------

        # adjustments to the previous bond strength may have been made, and
        # we must keep the bond strength of a token and its following blank
        # the same;
        my $last_strength = $strength;
        $strength = $rbond_strength_to_go->[$i_test];
        if ( $type eq 'b' ) { $strength = $last_strength }

        # reduce strength a bit to break ties at an old comma breakpoint ...
        if (

            $old_breakpoint_to_go[$i_test]

            # Patch: limited to just commas to avoid blinking states
            && $type eq ','

            # which is a 'good' breakpoint, meaning ...
            # we don't want to break before it
            && !$want_break_before{$type}

            # and either we want to break before the next token
            # or the next token is not short (i.e. not a '*', '/' etc.)
            && $i_next_nonblank <= $imax
            && (   $want_break_before{$next_nonblank_type}
                || $token_lengths_to_go[$i_next_nonblank] > 2
                || $next_nonblank_type eq ','
                || $is_opening_type{$next_nonblank_type} )
          )
        {
            $strength -= TINY_BIAS;
            DEBUG_BREAK_LINES && do { $Msg .= " :-bias at i=$i_test" };
        }

        # otherwise increase strength a bit if this token would be at the
        # maximum line length.  This is necessary to avoid blinking
        # in the above example when the -iob flag is added.
        else {
            my $len =
              $leading_spaces +
              $summed_lengths_to_go[ $i_test + 1 ] -
              $starting_sum;
            if ( $len >= $maximum_line_length ) {
                $strength += TINY_BIAS;
                DEBUG_BREAK_LINES && do { $Msg .= " :+bias at i=$i_test" };
            }
        }

        #-------------------------------------
        # Section B: Handle forced breakpoints
        #-------------------------------------
        my $must_break;

        # Force an immediate break at certain operators
        # with lower level than the start of the line,
        # unless we've already seen a better break.
        #
        # Note on an issue with a preceding '?' :

        # There may be a break at a previous ? if the line is long.  Because
        # of this we do not want to force a break if there is a previous ? on
        # this line.  For now the best way to do this is to not break if we
        # have seen a lower strength point, which is probably a ?.
        #
        # Example of unwanted breaks we are avoiding at a '.' following a ?
        # from pod2html using perltidy -gnu:
        # )
        # ? "\n&lt;A NAME=\""
        # . $value
        # . "\"&gt;\n$text&lt;/A&gt;\n"
        # : "\n$type$pod2.html\#" . $value . "\"&gt;$text&lt;\/A&gt;\n";
        if (
            ( $strength <= $lowest_strength )
            && ( $nesting_depth_to_go[$i_begin] >
                $nesting_depth_to_go[$i_next_nonblank] )
            && (
                ## /^(\.|\&\&|\|\|)$/
                $is_dot_and_or{$next_nonblank_type}
                || (
                    $next_nonblank_type eq 'k'

                    ##  /^(and|or)$/  # note: includes 'xor' now
                    && $is_and_or{$next_nonblank_token}
                )
            )
          )
        {
            $self->set_forced_breakpoint($i_next_nonblank);
            DEBUG_BREAK_LINES
              && do { $Msg .= " :Forced break at i=$i_next_nonblank" };
        }

        if (

            # Try to put a break where requested by break_lists
            $forced_breakpoint_to_go[$i_test]

            # break between ) { in a continued line so that the '{' can
            # be outdented
            # See similar logic in break_lists which catches instances
            # where a line is just something like ') {'.  We have to
            # be careful because the corresponding block keyword might
            # not be on the first line, such as 'for' here:
            #
            # eval {
            #     for ("a") {
            #         for $x ( 1, 2 ) { local $_ = "b"; s/(.*)/+$1/ }
            #     }
            # };
            #
            || (
                   $line_count
                && ( $token eq ')' )
                && ( $next_nonblank_type eq '{' )
                && ($next_nonblank_block_type)
                && ( $next_nonblank_block_type ne $tokens_to_go[$i_begin] )

                # RT #104427: Dont break before opening sub brace because
                # sub block breaks handled at higher level, unless
                # it looks like the preceding list is long and broken
                && !(

                    (
                           $next_nonblank_block_type =~ /$SUB_PATTERN/
                        || $matches_ASUB{$next_nonblank_block_type}
                    )
                    && ( $nesting_depth_to_go[$i_begin] ==
                        $nesting_depth_to_go[$i_next_nonblank] )
                )

                && !$rOpts_opening_brace_always_on_right
            )

            # There is an implied forced break at a terminal opening brace
            || ( ( $type eq '{' ) && ( $i_test == $imax ) )
          )
        {

            # Forced breakpoints must sometimes be overridden, for example
            # because of a side comment causing a NO_BREAK.  It is easier
            # to catch this here than when they are set.
            if ( $strength < NO_BREAK - 1 ) {
                $strength   = $lowest_strength - TINY_BIAS;
                $must_break = 1;
                DEBUG_BREAK_LINES
                  && do { $Msg .= " :set must_break at i=$i_next_nonblank" };
            }
        }

        # quit if a break here would put a good terminal token on
        # the next line and we already have a possible break
        if (
               ( $next_nonblank_type eq ';' || $next_nonblank_type eq ',' )
            && !$must_break
            && (
                (
                    $leading_spaces +
                    $summed_lengths_to_go[ $i_next_nonblank + 1 ] -
                    $starting_sum
                ) > $maximum_line_length
            )
          )
        {
            if ( $i_lowest >= 0 ) {
                DEBUG_BREAK_LINES && do {
                    $Msg .= " :quit at good terminal='$next_nonblank_type'";
                };
                last;
            }
        }

        #------------------------------------------------------------
        # Section C: Look for the lowest bond strength between tokens
        #------------------------------------------------------------
        if ( ( $strength <= $lowest_strength ) && ( $strength < NO_BREAK ) ) {

            # break at previous best break if it would have produced
            # a leading alignment of certain common tokens, and it
            # is different from the latest candidate break
            if ($leading_alignment_type) {
                DEBUG_BREAK_LINES && do {
                    $Msg .=
                      " :last at leading_alignment='$leading_alignment_type'";
                };
                last;
            }

            # Force at least one breakpoint if old code had good
            # break It is only called if a breakpoint is required or
            # desired.  This will probably need some adjustments
            # over time.  A goal is to try to be sure that, if a new
            # side comment is introduced into formatted text, then
            # the same breakpoints will occur.  scbreak.t
            if (
                $i_test == $imax            # we are at the end
                && !$forced_breakpoint_count
                && $saw_good_break          # old line had good break
                && $type =~ /^[#;\{]$/      # and this line ends in
                                            # ';' or side comment
                && $i_last_break < 0        # and we haven't made a break
                && $i_lowest >= 0           # and we saw a possible break
                && $i_lowest < $imax - 1    # (but not just before this ;)
                && $strength - $lowest_strength < 0.5 * WEAK    # and it's good
              )
            {

                DEBUG_BREAK_LINES && do {
                    $Msg .= " :last at good old break\n";
                };
                last;
            }

            # Do not skip past an important break point in a short final
            # segment.  For example, without this check we would miss the
            # break at the final / in the following code:
            #
            #  $depth_stop =
            #    ( $tau * $mass_pellet * $q_0 *
            #        ( 1. - exp( -$t_stop / $tau ) ) -
            #        4. * $pi * $factor * $k_ice *
            #        ( $t_melt - $t_ice ) *
            #        $r_pellet *
            #        $t_stop ) /
            #    ( $rho_ice * $Qs * $pi * $r_pellet**2 );
            #
            if (
                   $line_count > 2
                && $i_lowest >= 0    # and we saw a possible break
                && $i_lowest < $i_test
                && $i_test > $imax - 2
                && $nesting_depth_to_go[$i_begin] >
                $nesting_depth_to_go[$i_lowest]
                && $lowest_strength < $last_break_strength - .5 * WEAK
              )
            {
                # Make this break for math operators for now
                my $ir = $inext_to_go[$i_lowest];
                my $il = iprev_to_go($ir);
                if (   $types_to_go[$il] =~ /^[\/\*\+\-\%]$/
                    || $types_to_go[$ir] =~ /^[\/\*\+\-\%]$/ )
                {
                    DEBUG_BREAK_LINES && do {
                        $Msg .= " :last-noskip_short";
                    };
                    last;
                }
            }

            # Update the minimum bond strength location
            $lowest_strength = $strength;
            $i_lowest        = $i_test;
            if ($must_break) {
                DEBUG_BREAK_LINES && do {
                    $Msg .= " :last-must_break";
                };
                last;
            }

            # set flags to remember if a break here will produce a
            # leading alignment of certain common tokens
            if (   $line_count > 0
                && $i_test < $imax
                && ( $lowest_strength - $last_break_strength <= MAX_BIAS ) )
            {
                my $i_last_end = iprev_to_go($i_begin);
                my $tok_beg    = $tokens_to_go[$i_begin];
                my $type_beg   = $types_to_go[$i_begin];
                if (

                    # check for leading alignment of certain tokens
                    (
                           $tok_beg eq $next_nonblank_token
                        && $is_chain_operator{$tok_beg}
                        && (   $type_beg eq 'k'
                            || $type_beg eq $tok_beg )
                        && $nesting_depth_to_go[$i_begin] >=
                        $nesting_depth_to_go[$i_next_nonblank]
                    )

                    || (   $tokens_to_go[$i_last_end] eq $token
                        && $is_chain_operator{$token}
                        && ( $type eq 'k' || $type eq $token )
                        && $nesting_depth_to_go[$i_last_end] >=
                        $nesting_depth_to_go[$i_test] )
                  )
                {
                    $leading_alignment_type = $next_nonblank_type;
                }
            }
        }

        #-----------------------------------------------------------
        # Section D: See if the maximum line length will be exceeded
        #-----------------------------------------------------------

        # Quit if there are no more tokens to test
        last if ( $i_test >= $imax );

        # Keep going if we have not reached the limit
        my $excess =
          $leading_spaces +
          $summed_lengths_to_go[ $i_test + 2 ] -
          $starting_sum -
          $maximum_line_length;

        if ( $excess < 0 ) {
            next;
        }
        elsif ( $excess == 0 ) {

            # To prevent blinkers we will avoid leaving a token exactly at
            # the line length limit unless it is the last token or one of
            # several "good" types.
            #
            # The following code was a blinker with -pbp before this
            # modification:
            #     $last_nonblank_token eq '('
            #         && $is_indirect_object_taker{ $paren_type
            #             [$paren_depth] }
            # The issue causing the problem is that if the
            # term [$paren_depth] gets broken across a line then
            # the whitespace routine doesn't see both opening and closing
            # brackets and will format like '[ $paren_depth ]'.  This
            # leads to an oscillation in length depending if we break
            # before the closing bracket or not.
            if (   $i_test + 1 < $imax
                && $next_nonblank_type ne ','
                && !$is_closing_type{$next_nonblank_type} )
            {
                # too long
                DEBUG_BREAK_LINES && do {
                    $Msg .= " :too_long";
                }
            }
            else {
                next;
            }
        }
        else {
            # too long
        }

        # a break here makes the line too long ...

        DEBUG_BREAK_LINES && do {
            my $ltok = $token;
            my $rtok =
              $next_nonblank_token ? $next_nonblank_token : EMPTY_STRING;
            my $i_testp2 = $i_test + 2;
            if ( $i_testp2 > $max_index_to_go + 1 ) {
                $i_testp2 = $max_index_to_go + 1;
            }
            if ( length($ltok) > 6 ) { $ltok = substr( $ltok, 0, 8 ) }
            if ( length($rtok) > 6 ) { $rtok = substr( $rtok, 0, 8 ) }
            print {*STDOUT}
"BREAK: i=$i_test imax=$imax $types_to_go[$i_test] $next_nonblank_type sp=($leading_spaces) lnext= $summed_lengths_to_go[$i_testp2] str=$strength    $ltok $rtok\n";
        };

        # Exception: allow one extra terminal token after exceeding line length
        # if it would strand this token.
        if (   $i_lowest == $i_test
            && $token_lengths_to_go[$i_test] > 1
            && ( $next_nonblank_type eq ';' || $next_nonblank_type eq ',' )
            && $rOpts_fuzzy_line_length )
        {
            DEBUG_BREAK_LINES && do {
                $Msg .= " :do_not_strand next='$next_nonblank_type'";
            };
            next;
        }

        # Stop if here if we have a solution and the line will be too long
        if ( $i_lowest >= 0 ) {
            DEBUG_BREAK_LINES && do {
                $Msg .=
" :Done-too_long && i_lowest=$i_lowest at itest=$i_test, imax=$imax";
            };
            last;
        }
    } ## end while ( ++$i_test <= $imax)

    #-----------------------------------------------------
    # End INNER_LOOP over the indexes in the _to_go arrays
    #-----------------------------------------------------

    # Be sure we return an index in the range ($ibegin .. $imax).
    # We will break at imax if no other break was found.
    if ( $i_lowest < 0 ) { $i_lowest = $imax }

    return ( $i_lowest, $lowest_strength, $Msg );
} ## end sub break_lines_inner_loop

sub do_colon_breaks {

    my ( $self, $ri_colon_breaks, $ri_first, $ri_last ) = @_;

    # Given:
    #   $ri_colon_breaks = ref to list of indexes breaks at ':' tokens
    #   $ri_first - reference to current list of the first index $i for each
    #               output line in this batch
    #   $ri_last - reference to current list of the last index $i for each
    #               output line in this batch

    # Add additional breaks if we are in a ?/: chain.
    # Simplified method used here: This is a ?/: chain if it has
    # multiple ?/: pairs all in order; otherwise not.

    my @insert_list = ();
    foreach ( @{$ri_colon_breaks} ) {
        my $i_question = $mate_index_to_go[$_];
        if ( defined($i_question) ) {
            if ( $want_break_before{'?'} ) {
                $i_question = iprev_to_go($i_question);
            }

            if ( $i_question >= 0 ) {
                push @insert_list, $i_question;
            }
        }
        $self->insert_additional_breaks( \@insert_list, $ri_first, $ri_last );
    }
    return;
} ## end sub do_colon_breaks

###########################################
# CODE SECTION 11: Code to break long lists
###########################################

{    ## begin closure break_lists

    # These routines and variables are involved in finding good
    # places to break long lists.

    my (

        $block_type,
        $current_depth,
        $depth,
        $i_last_colon,
        $i_line_end,
        $i_line_start,
        $i_last_nonblank_token,
        $last_nonblank_block_type,
        $last_nonblank_token,
        $last_nonblank_type,
        $last_old_breakpoint_count,
        $minimum_depth,
        $next_nonblank_block_type,
        $next_nonblank_token,
        $next_nonblank_type,
        $old_breakpoint_count,
        $starting_breakpoint_count,
        $starting_depth,
        $token,
        $type,
        $type_sequence,

    );

    my (

        @breakpoint_stack,
        @breakpoint_undo_stack,
        @comma_index,
        @container_type,
        @identifier_count_stack,
        @index_before_arrow,
        @interrupted_list,
        @item_count_stack,
        @last_comma_index,
        @last_dot_index,
        @last_nonblank_type_stack,
        @old_breakpoint_count_stack,
        @opening_structure_index_stack,
        @rfor_semicolon_list,
        @has_old_logical_breakpoints,
        @rand_or_list,
        @i_equals,
        @override_cab3,
        @type_sequence_stack,

    );

    # these arrays must retain values between calls
    my ( @has_broken_sublist, @dont_align, @want_comma_break );

    my $length_tol;
    my $lp_tol_boost;

    sub initialize_break_lists {
        @dont_align         = ();
        @has_broken_sublist = ();
        @want_comma_break   = ();

        #---------------------------------------------------
        # Set tolerances to prevent formatting instabilities
        #---------------------------------------------------

        # Define tolerances to use when checking if closed
        # containers will fit on one line.  This is necessary to avoid
        # formatting instability. The basic tolerance is based on the
        # following:

        # - Always allow for at least one extra space after a closing token so
        # that we do not strand a comma or semicolon. (oneline.t).

        # - Use an increased line length tolerance when -ci > -i to avoid
        # blinking states (case b923 and others).
        $length_tol =
          1 + max( 0, $rOpts_continuation_indentation - $rOpts_indent_columns );

        # In addition, it may be necessary to use a few extra tolerance spaces
        # when -lp is used and/or when -xci is used.  The history of this
        # so far is as follows:

        # FIX1: At least 3 characters were been found to be required for -lp
        # to fixes cases b1059 b1063 b1117.

        # FIX2: Further testing showed that we need a total of 3 extra spaces
        # when -lp is set for non-lists, and at least 2 spaces when -lp and
        # -xci are set.
        # Fixes cases b1063 b1103 b1134 b1135 b1136 b1138 b1140 b1143 b1144
        # b1145 b1146 b1147 b1148 b1151 b1152 b1153 b1154 b1156 b1157 b1164
        # b1165

        # FIX3: To fix cases b1169 b1170 b1171, an update was made in sub
        # 'find_token_starting_list' to go back before an initial blank space.
        # This fixed these three cases, and allowed the tolerances to be
        # reduced to continue to fix all other known cases of instability.
        # This gives the current tolerance formulation.

        $lp_tol_boost = 0;

        if ($rOpts_line_up_parentheses) {

            # boost tol for combination -lp -xci
            if ($rOpts_extended_continuation_indentation) {
                $lp_tol_boost = 2;

                # and one more for -lp -xci -vmll (b1470, b1474, b1266)
                if ($rOpts_variable_maximum_line_length) {
                    $lp_tol_boost = max( 2, $rOpts_indent_columns );
                }
            }

            # boost tol for combination -lp and any -vtc > 0, but only for
            # non-list containers
            else {
                foreach ( keys %closing_vertical_tightness ) {
                    next
                      unless ( $closing_vertical_tightness{$_} );
                    $lp_tol_boost = 1;    # Fixes B1193;
                    last;
                }
            }
        }

        # Define a level where list formatting becomes highly stressed and
        # needs to be simplified. Introduced for case b1262.
        # $list_stress_level = min($stress_level_alpha, $stress_level_beta + 2);
        # This is now '$high_stress_level'.

        return;
    } ## end sub initialize_break_lists

    # routine to define essential variables when we go 'up' to
    # a new depth
    sub check_for_new_minimum_depth {
        my ( $self, $depth_t, $seqno ) = @_;

        # Initialize for a new minimum depth

        # Given:
        #   $depth_t = new depth
        #   $seqno = sequence number of the parent container
        if ( $depth_t < $minimum_depth ) {

            $minimum_depth = $depth_t;

            # these arrays need not retain values between calls
            my $old_seqno     = $type_sequence_stack[$depth_t];
            my $changed_seqno = !defined($old_seqno) || $old_seqno != $seqno;
            $type_sequence_stack[$depth_t] = $seqno;
            $override_cab3[$depth_t]       = undef;
            if ( $rOpts_comma_arrow_breakpoints == 3 && $seqno ) {
                $override_cab3[$depth_t] = $self->[_roverride_cab3_]->{$seqno};
            }
            $breakpoint_stack[$depth_t]         = $starting_breakpoint_count;
            $container_type[$depth_t]           = EMPTY_STRING;
            $identifier_count_stack[$depth_t]   = 0;
            $index_before_arrow[$depth_t]       = -1;
            $interrupted_list[$depth_t]         = 1;
            $item_count_stack[$depth_t]         = 0;
            $last_nonblank_type_stack[$depth_t] = EMPTY_STRING;
            $opening_structure_index_stack[$depth_t] = -1;

            $breakpoint_undo_stack[$depth_t]       = undef;
            $comma_index[$depth_t]                 = undef;
            $last_comma_index[$depth_t]            = undef;
            $last_dot_index[$depth_t]              = undef;
            $old_breakpoint_count_stack[$depth_t]  = undef;
            $has_old_logical_breakpoints[$depth_t] = 0;
            $rand_or_list[$depth_t]                = [];
            $rfor_semicolon_list[$depth_t]         = [];
            $i_equals[$depth_t]                    = -1;

            # these arrays must retain values between calls
            if ( $changed_seqno || !defined( $has_broken_sublist[$depth_t] ) ) {
                $dont_align[$depth_t]         = 0;
                $has_broken_sublist[$depth_t] = 0;
                $want_comma_break[$depth_t]   = 0;
            }
        }
        return;
    } ## end sub check_for_new_minimum_depth

    sub set_comma_breakpoints {

        my ( $self, $i, $dd, $rbond_strength_bias ) = @_;

        # Decide which commas to break at within a container
        # Given:
        #   $i  = index of current token in main loop over tokens, or
        #       = $max_index_to_go + 1 for post-loop operations (c410)
        #   $dd = stack depth
        #   $rbond-strength_bias = ref to array of bond strength biases which
        #            may be updated for commas not in lists
        # Return:
        #   $bp_count = number of comma breakpoints set
        #   $do_not_break_apart = a flag indicating if container need not
        #     be broken open
        my $bp_count           = 0;
        my $do_not_break_apart = 0;

        # anything to do?
        if ( $item_count_stack[$dd] ) {

            # Do not break a list unless there are some non-line-ending commas.
            # This avoids getting different results with only non-essential
            # commas, and fixes b1192.
            my $seqno = $type_sequence_stack[$dd];

            my $real_comma_count =
              $seqno ? $self->[_rtype_count_by_seqno_]->{$seqno}->{','} : 1;

            # handle commas not in containers...
            if ( $dont_align[$dd] ) {
                $self->do_uncontained_comma_breaks( $dd, $rbond_strength_bias );
            }

            # handle commas within containers...
            elsif ($real_comma_count) {
                my $fbc = $forced_breakpoint_count;

                # always open comma lists not preceded by keywords,
                # barewords, identifiers (that is, anything that doesn't
                # look like a function call)
                # c250: added new sub identifier type 'S'
                my $must_break_open =
                  $last_nonblank_type_stack[$dd] !~ /^[kwiUS]$/;

                $self->table_maker(
                    {
                        depth            => $dd,
                        i_opening_paren  => $opening_structure_index_stack[$dd],
                        i_closing_paren  => $i,
                        item_count       => $item_count_stack[$dd],
                        identifier_count => $identifier_count_stack[$dd],
                        rcomma_index     => $comma_index[$dd],
                        next_nonblank_type  => $next_nonblank_type,
                        list_type           => $container_type[$dd],
                        interrupted         => $interrupted_list[$dd],
                        rdo_not_break_apart => \$do_not_break_apart,
                        must_break_open     => $must_break_open,
                        has_broken_sublist  => $has_broken_sublist[$dd],
                    }
                );
                $bp_count           = $forced_breakpoint_count - $fbc;
                $do_not_break_apart = 0 if $must_break_open;
            }
            else {
                ## no real commas, nothing to do
            }
        }
        return ( $bp_count, $do_not_break_apart );
    } ## end sub set_comma_breakpoints

    # These types are excluded at breakpoints to prevent blinking
    # Switched from excluded to included as part of fix for b1214
    my %is_uncontained_comma_break_included_type;

    BEGIN {

        my @q = qw# k R } ) ] Y Z U w i q Q .
          = **= += *= &= <<= &&= -= /= |= >>= ||= //= .= %= ^= x= #;
        @is_uncontained_comma_break_included_type{@q} = (1) x scalar(@q);
    } ## end BEGIN

    sub do_uncontained_comma_breaks {

        my ( $self, $dd, $rbond_strength_bias ) = @_;

        # Handle commas not in containers

        # Given:
        #   $dd = depth of this layer of commas
        #   $rbond_strength_bias = array of bond strengths to be updated

        # This is a catch-all routine for commas that we
        # don't know what to do with because the don't fall
        # within containers.  We will bias the bond strength
        # to break at commas which ended lines in the input
        # file.  This usually works better than just trying
        # to put as many items on a line as possible.  A
        # downside is that if the input file is garbage it
        # won't work very well. However, the user can always
        # prevent following the old breakpoints with the
        # -iob flag.

        # Check added for issue c131; an error here would be due to an
        # error initializing @comma_index when entering depth $dd.
        if (DEVEL_MODE) {
            foreach my $ii ( @{ $comma_index[$dd] } ) {
                if ( $ii < 0 || $ii > $max_index_to_go ) {
                    my $KK  = $K_to_go[0];
                    my $lno = $self->[_rLL_]->[$KK]->[_LINE_INDEX_];
                    Fault(<<EOM);
Bad comma index near line $lno: i=$ii must be between 0 and $max_index_to_go
EOM
                }
            }
        }

        my $bias                  = -.01;
        my $old_comma_break_count = 0;
        foreach my $ii ( @{ $comma_index[$dd] } ) {

            if ( $old_breakpoint_to_go[$ii] ) {
                $old_comma_break_count++;

                # Store the bias info for use by sub set_bond_strength
                push @{$rbond_strength_bias}, [ $ii, $bias ];

                # reduce bias magnitude to force breaks in order
                $bias *= 0.99;
            }
        }

        # Also put a break before the first comma if
        # (1) there was a break there in the input, and
        # (2) there was exactly one old break before the first comma break
        # (3) OLD: there are multiple old comma breaks
        # (3) NEW: there are one or more old comma breaks (see return example)
        # (4) the first comma is at the starting level ...
        #     ... fixes cases b064 b065 b068 b210 b747
        # (5) the batch does not start with a ci>0 [ignore a ci change by -xci]
        #     ... fixes b1220.  If ci>0 we are in the middle of a snippet,
        #     maybe because -boc has been forcing out previous lines.

        # For example, we will follow the user and break after
        # 'print' in this snippet:
        #    print
        #      "conformability (Not the same dimension)\n",
        #      "\t", $have, " is ", text_unit($hu), "\n",
        #      "\t", $want, " is ", text_unit($wu), "\n",
        #      ;
        #
        # Another example, just one comma, where we will break after
        # the return:
        #  return
        #    $x * cos($a) - $y * sin($a),
        #    $x * sin($a) + $y * cos($a);

        # Breaking a print statement:
        # print SAVEOUT
        #   ( $? & 127 ) ? " (SIG#" . ( $? & 127 ) . ")" : "",
        #   ( $? & 128 ) ? " -- core dumped" : "", "\n";
        #
        #  But we will not force a break after the opening paren here
        #  (causes a blinker):
        #        $heap->{stream}->set_output_filter(
        #            poe::filter::reference->new('myotherfreezer') ),
        #          ;
        #
        my $i_first_comma = $comma_index[$dd]->[0];
        my $level_comma   = $levels_to_go[$i_first_comma];
        my $ci_start      = $ci_levels_to_go[0];

        # Here we want to use the value of ci before any -xci adjustment
        if ( $ci_start && $rOpts_extended_continuation_indentation ) {
            my $K0 = $K_to_go[0];
            if ( $self->[_rseqno_controlling_my_ci_]->{$K0} ) { $ci_start = 0 }
        }
        if (  !$ci_start
            && $old_breakpoint_to_go[$i_first_comma]
            && $level_comma == $levels_to_go[0] )
        {
            my $ibreak    = -1;
            my $obp_count = 0;
            foreach my $ii ( reverse( 0 .. $i_first_comma - 1 ) ) {
                if ( $old_breakpoint_to_go[$ii] ) {
                    $obp_count++;
                    last if ( $obp_count > 1 );
                    $ibreak = $ii
                      if ( $levels_to_go[$ii] == $level_comma );
                }
            }

            # Changed rule from multiple old commas to just one here:
            if ( $ibreak >= 0 && $obp_count == 1 && $old_comma_break_count > 0 )
            {
                my $ibreak_m = $ibreak;
                $ibreak_m-- if ( $types_to_go[$ibreak_m] eq 'b' );
                if ( $ibreak_m >= 0 ) {

                    # In order to avoid blinkers we have to be fairly
                    # restrictive:

                    # OLD Rules:
                    #  Rule 1: Do not to break before an opening token
                    #  Rule 2: avoid breaking at ternary operators
                    #  (see b931, which is similar to the above print example)
                    #  Rule 3: Do not break at chain operators to fix case b1119
                    #   - The previous test was '$typem !~ /^[\(\{\[L\?\:]$/'

                    # NEW Rule, replaced above rules after case b1214:
                    #  only break at one of the included types

                    # Be sure to test any changes to these rules against runs
                    # with -l=0 such as the 'bbvt' test (perltidyrc_colin)
                    # series.
                    my $type_m = $types_to_go[$ibreak_m];

                    # Switched from excluded to included for b1214. If necessary
                    # the token could also be checked if type_m eq 'k'
                    if ( $is_uncontained_comma_break_included_type{$type_m} ) {

                        # Rule added to fix b1449:
                        # Do not break before a '?' if -nbot is set
                        # Otherwise, we may alternately arrive here and
                        # set the break, or not, depending on the input.
                        my $no_break;
                        my $ibreak_p = $inext_to_go[$ibreak_m];
                        if (  !$rOpts_break_at_old_ternary_breakpoints
                            && $ibreak_p <= $max_index_to_go )
                        {
                            my $type_p = $types_to_go[$ibreak_p];
                            $no_break = $type_p eq '?';
                        }

                        $self->set_forced_breakpoint($ibreak)
                          if ( !$no_break );
                    }
                }
            }
        }
        return;
    } ## end sub do_uncontained_comma_breaks

    my %is_logical_container;
    my %quick_filter_A;
    my %quick_filter_B;

    BEGIN {
        my @q = qw# if elsif unless while and or err not && | || ? : ! #;
        @is_logical_container{@q} = (1) x scalar(@q);

        # Filters to allow most tokens to skip past tedious if-elsif blocks
        %quick_filter_A     = %is_assignment;
        @q                  = qw( || && f k );
        @quick_filter_A{@q} = (1) x scalar(@q);

        %quick_filter_B = %is_assignment;
        @q              = qw# => . ; < > ~ #;
        push @q, ',';
        push @q, 'f';    # added for ';' for issue c154
        @quick_filter_B{@q} = (1) x scalar(@q);

    } ## end BEGIN

    sub set_for_semicolon_breakpoints {
        my ( $self, $dd ) = @_;

        # Given:
        #   $dd = depth of this layer

        # Set breakpoints for semicolons in C-style 'for' containers
        foreach ( @{ $rfor_semicolon_list[$dd] } ) {
            $self->set_forced_breakpoint($_);
        }
        return;
    } ## end sub set_for_semicolon_breakpoints

    sub set_logical_breakpoints {
        my ( $self, $dd ) = @_;

        # Given:
        #   $dd = depth of this layer

        # Set breakpoints at logical operators
        if (
               $item_count_stack[$dd] == 0
            && $is_logical_container{ $container_type[$dd] }

            || $has_old_logical_breakpoints[$dd]
          )
        {

            # Look for breaks in this order:
            # 0   1    2   3
            # or  and  ||  &&
            foreach my $ii ( 0 .. 3 ) {
                if ( $rand_or_list[$dd][$ii] ) {
                    foreach ( @{ $rand_or_list[$dd][$ii] } ) {
                        $self->set_forced_breakpoint($_);
                    }

                    # break at any 'if' and 'unless' too
                    foreach ( @{ $rand_or_list[$dd][4] } ) {
                        $self->set_forced_breakpoint($_);
                    }
                    $rand_or_list[$dd] = [];
                    last;
                }
            }
        }
        return;
    } ## end sub set_logical_breakpoints

    sub is_unbreakable_container {

        my $dd = shift;

        # Given:
        #   $dd = depth of this layer
        # Return:
        #   true if the container should not be broken
        #   false otherwise

        # never break a container of one of these types
        # because bad things can happen (map1.t):
        return $is_sort_map_grep{ $container_type[$dd] };
    } ## end sub is_unbreakable_container

    sub break_lists {

        my ( $self, $is_long_line, $rbond_strength_bias ) = @_;

        # This routine is called once per batch, if the batch is a list, to
        # set line breaks so that hierarchical structure can be displayed and
        # so that list items can be vertically aligned.

        # Given:
        #   $is_long_line = true if this batch requires multiple output lines
        #   $rbond_strength_bias = array of bond strengths to be updated
        # Task:
        #   Update the array @forced_breakpoint_to_go with breakpoints.
        #   This array is used by sub 'break_long_lines' to set final
        #   breakpoints.

        # This is probably the most complex routine in perltidy,
        # so I have broken it into pieces and over-commented it.

        $starting_depth = $nesting_depth_to_go[0];

        $block_type                = SPACE;
        $current_depth             = $starting_depth;
        $i_last_colon              = -1;
        $i_line_end                = -1;
        $i_line_start              = -1;
        $last_nonblank_token       = ';';
        $last_nonblank_type        = ';';
        $last_nonblank_block_type  = SPACE;
        $last_old_breakpoint_count = 0;
        $minimum_depth = $current_depth + 1;    # forces update in check below
        $old_breakpoint_count      = 0;
        $starting_breakpoint_count = $forced_breakpoint_count;
        $token                     = ';';
        $type                      = ';';
        $type_sequence             = EMPTY_STRING;

        my $total_depth_variation = 0;
        my $i_old_assignment_break;
        my $depth_last = $starting_depth;
        my $comma_follows_last_closing_token;

        $self->check_for_new_minimum_depth( $current_depth,
            $parent_seqno_to_go[0] )
          if ( $current_depth < $minimum_depth );

        my $i_want_previous_break = -1;

        my $saw_good_breakpoint;

        #----------------------------------------
        # Main loop over all tokens in this batch
        #----------------------------------------
        foreach my $i ( 0 .. $max_index_to_go ) {
            if ( $type ne 'b' ) {
                $i_last_nonblank_token    = $i - 1;
                $last_nonblank_type       = $type;
                $last_nonblank_token      = $token;
                $last_nonblank_block_type = $block_type;
            }

            # set break if flag was set
            if ( $i_want_previous_break >= 0 ) {
                $self->set_forced_breakpoint($i_want_previous_break);
                $i_want_previous_break = -1;
            }

            $type = $types_to_go[$i];
            next if ( $type eq 'b' );

            $last_old_breakpoint_count = $old_breakpoint_count;

            $block_type    = $block_type_to_go[$i];
            $token         = $tokens_to_go[$i];
            $type_sequence = $type_sequence_to_go[$i];

            my $i_next_nonblank = $inext_to_go[$i];
            $next_nonblank_type       = $types_to_go[$i_next_nonblank];
            $next_nonblank_token      = $tokens_to_go[$i_next_nonblank];
            $next_nonblank_block_type = $block_type_to_go[$i_next_nonblank];

            #-------------------------------------------
            # Loop Section A: Look for special breakpoints...
            #-------------------------------------------

            # Check for a good old breakpoint ..
            if ( $old_breakpoint_to_go[$i] ) {
                ( $i_want_previous_break, $i_old_assignment_break ) =
                  $self->examine_old_breakpoint( $i, $i_next_nonblank,
                    $i_want_previous_break, $i_old_assignment_break );
            }

            $depth = $nesting_depth_to_go[ $i + 1 ];

            $total_depth_variation += abs( $depth - $depth_last );
            $depth_last = $depth;

            # safety check - be sure we always break after a comment
            # Shouldn't happen .. an error here probably means that the
            # nobreak flag did not get turned off correctly during
            # formatting.
            if ( $type eq '#' ) {
                if ( $i != $max_index_to_go ) {
                    if (DEVEL_MODE) {
                        Fault(<<EOM);
Non-fatal program bug: backup logic required to break after a comment
EOM
                    }
                    $nobreak_to_go[$i] = 0;
                    $self->set_forced_breakpoint($i);
                } ## end if ( $i != $max_index_to_go)
            } ## end if ( $type eq '#' )

            # Force breakpoints at certain tokens in long lines.
            # Note that such breakpoints will be undone later if these tokens
            # are fully contained within parens on a line.
            if (

                # break before a keyword within a line
                $type eq 'k'
                && $i > 0

                # if one of these keywords:
                && $is_if_unless_while_until_for_foreach{$token}

                # but do not break at something like '1 while'
                && ( $last_nonblank_type ne 'n' || $i > 2 )

                # and let keywords follow a closing 'do' brace
                && (  !$last_nonblank_block_type
                    || $last_nonblank_block_type ne 'do' )

                && (
                    $is_long_line

                    # or container is broken (by side-comment, etc)
                    || (
                        $next_nonblank_token eq '('
                        && ( !defined( $mate_index_to_go[$i_next_nonblank] )
                            || $mate_index_to_go[$i_next_nonblank] < $i )
                    )
                )
              )
            {
                $self->set_forced_breakpoint( $i - 1 );
            }

            # remember locations of '||'  and '&&' for possible breaks if we
            # decide this is a long logical expression.
            if ( $quick_filter_A{$type} ) {
                if ( $type eq '||' ) {
                    push @{ $rand_or_list[$depth][2] }, $i;
                    ++$has_old_logical_breakpoints[$depth]
                      if ( ( $i == $i_line_start || $i == $i_line_end )
                        && $rOpts_break_at_old_logical_breakpoints );
                }
                elsif ( $type eq '&&' ) {
                    push @{ $rand_or_list[$depth][3] }, $i;
                    ++$has_old_logical_breakpoints[$depth]
                      if ( ( $i == $i_line_start || $i == $i_line_end )
                        && $rOpts_break_at_old_logical_breakpoints );
                }
                elsif ( $type eq 'f' ) {
                    push @{ $rfor_semicolon_list[$depth] }, $i;
                }
                elsif ( $type eq 'k' ) {
                    if ( $token eq 'and' ) {
                        push @{ $rand_or_list[$depth][1] }, $i;
                        ++$has_old_logical_breakpoints[$depth]
                          if ( ( $i == $i_line_start || $i == $i_line_end )
                            && $rOpts_break_at_old_logical_breakpoints );
                    }

                    # break immediately at 'or's which are probably not in a
                    # logical block -- but we will break in logical breaks
                    # below so that they do not add to the
                    # forced_breakpoint_count
                    elsif ( $token eq 'or' ) {
                        push @{ $rand_or_list[$depth][0] }, $i;
                        ++$has_old_logical_breakpoints[$depth]
                          if ( ( $i == $i_line_start || $i == $i_line_end )
                            && $rOpts_break_at_old_logical_breakpoints );
                        if ( $is_logical_container{ $container_type[$depth] } )
                        {
                        }
                        else {
                            if ($is_long_line) {
                                $self->set_forced_breakpoint($i);
                            }
                            elsif ( ( $i == $i_line_start || $i == $i_line_end )
                                && $rOpts_break_at_old_logical_breakpoints )
                            {
                                $saw_good_breakpoint = 1;
                            }
                            else {
                                ## not a good break
                            }
                        }
                    }
                    elsif ( $token eq 'if' || $token eq 'unless' ) {
                        push @{ $rand_or_list[$depth][4] }, $i;
                        if ( ( $i == $i_line_start || $i == $i_line_end )
                            && $rOpts_break_at_old_logical_breakpoints )
                        {
                            $self->set_forced_breakpoint($i);
                        }
                    }
                    else {
                        ## not one of: 'and' 'or' 'if' 'unless'
                    }
                }
                elsif ( $is_assignment{$type} ) {
                    $i_equals[$depth] = $i;
                }
                else {
                    # error : no code to handle a type in %quick_filter_A
                    DEVEL_MODE && Fault(<<EOM);
Missing code to handle token type '$type' which is in the quick_filter_A
EOM
                }
            }

            if ($type_sequence) {

                #-----------------------------------------
                # Loop Section B: Handle a sequenced token
                #-----------------------------------------
                $self->break_lists_type_sequence($i);

                #------------------------------------------
                # Loop Section C: Handle Increasing Depth..
                #------------------------------------------

                # hardened against bad input syntax: depth jump must be 1 and
                # type must be opening..fixes c102
                if ( $depth == $current_depth + 1 && $is_opening_type{$type} ) {
                    $self->break_lists_increasing_depth($i);
                }

                #------------------------------------------
                # Loop Section D: Handle Decreasing Depth..
                #------------------------------------------

                # hardened against bad input syntax: depth jump must be 1 and
                # type must be closing .. fixes c102
                elsif ($depth == $current_depth - 1
                    && $is_closing_type{$type} )
                {

                    # Note that $rbond_strength_bias will not get changed by
                    # this call. It gets changed in the call to
                    # set_comma_breakpoints at the end of this routine for
                    # commas not in lists.
                    $self->break_lists_decreasing_depth( $i,
                        $rbond_strength_bias );

                    $comma_follows_last_closing_token =
                      $next_nonblank_type eq ',' || $next_nonblank_type eq '=>';

                }
                else {
                    ## not a depth change
                }
            }

            #----------------------------------
            # Loop Section E: Handle this token
            #----------------------------------

            $current_depth = $depth;

            # most token types can skip the rest of this loop
            next if ( !$quick_filter_B{$type} );

            # Turn off comma alignment if we are sure that this is not a list
            # environment.  To be safe, we will do this if we see certain
            # non-list tokens, such as ';', '=', and also the environment is
            # not a list.
            ##      $type =~ /^[\;\<\>\~f]$/ || $is_assignment{$type}
            if ( $is_non_list_type{$type} ) {
                if ( !$self->is_in_list_by_i($i) ) {
                    $dont_align[$depth]         = 1;
                    $want_comma_break[$depth]   = 0;
                    $index_before_arrow[$depth] = -1;

                    # no special comma breaks in C-style 'for' terms (c154)
                    if ( $type eq 'f' ) { $last_comma_index[$depth] = undef }
                }
            }

            # handle any commas
            elsif ( $type eq ',' ) {
                $self->study_comma( $i, $comma_follows_last_closing_token );
            }

            # handle comma-arrow
            elsif ( $type eq '=>' ) {
                next if ( $last_nonblank_type eq '=>' );
                next if $rOpts_break_at_old_comma_breakpoints;
                next
                  if ( $rOpts_comma_arrow_breakpoints == 3
                    && !defined( $override_cab3[$depth] ) );
                $want_comma_break[$depth]   = 1;
                $index_before_arrow[$depth] = $i_last_nonblank_token;
                next;

            }
            elsif ( $type eq '.' ) {
                $last_dot_index[$depth] = $i;

            }
            else {

                # error : no code to handle a type in %quick_filter_B
                DEVEL_MODE && Fault(<<EOM);
Missing code to handle token type '$type' which is in the quick_filter_B
EOM
            }

        } ## end main loop over tokens

        #----------------------------------------
        # Now set breaks for any unfinished lists
        #----------------------------------------
        foreach my $dd ( reverse( $minimum_depth .. $current_depth ) ) {

            $interrupted_list[$dd]   = 1;
            $has_broken_sublist[$dd] = 1 if ( $dd < $current_depth );
            if ( $item_count_stack[$dd] ) {
                $self->set_comma_breakpoints( $max_index_to_go + 1,
                    $dd, $rbond_strength_bias );

            }
            $self->set_logical_breakpoints($dd)
              if ( $has_old_logical_breakpoints[$dd] );
            $self->set_for_semicolon_breakpoints($dd)
              if ( @{ $rfor_semicolon_list[$dd] } );

            # break open container...
            my $i_opening = $opening_structure_index_stack[$dd];
            if (
                   defined($i_opening)
                && $i_opening >= 0
                && !is_unbreakable_container($dd)

                # Avoid a break which would place an isolated ' or "
                # on a line
                && !(
                       $type eq 'Q'
                    && $i_opening >= $max_index_to_go - 2
                    && ( $token eq "'" || $token eq '"' )
                )
              )
            {
                $self->set_forced_breakpoint($i_opening);
            }
        } ## end for ( my $dd = $current_depth...)

        #------------------------------------------------
        # Set the return the flag '$saw_good_breakpoint'.
        #------------------------------------------------
        # This flag indicates if the input file had some good breakpoints.
        # It will be used to force a break in a line shorter than the
        # allowed line length.
        if ( $has_old_logical_breakpoints[$current_depth] ) {
            $saw_good_breakpoint = 1;
        }

        # A complex line with one break at an = has a good breakpoint.
        # This is not complex ($total_depth_variation=0):
        # $res1
        #   = 10;
        #
        # This is complex ($total_depth_variation=6):
        # $res2 =
        #  (is_boundp("a", 'self-insert') && is_boundp("b", 'self-insert'));

        # The check ($i_old_.. < $max_index_to_go) was added to fix b1333
        elsif ($i_old_assignment_break
            && $total_depth_variation > 4
            && $old_breakpoint_count == 1
            && $i_old_assignment_break < $max_index_to_go )
        {
            $saw_good_breakpoint = 1;
        }
        else {
            ## not a good breakpoint
        }

        return $saw_good_breakpoint;
    } ## end sub break_lists

    sub study_comma {

        my ( $self, $i, $comma_follows_last_closing_token ) = @_;

        # Study and store info for a list comma
        # Given:
        #  $i = index of this comma in the _to_go output batch array
        #  $comma_follows_last_closing_token = true if it follows ')' '}' or ']'

        $last_dot_index[$depth]   = undef;
        $last_comma_index[$depth] = $i;

        # break here if this comma follows a '=>'
        # but not if there is a side comment after the comma
        if ( $want_comma_break[$depth] ) {

            if ( $is_closing_type{$next_nonblank_type} ) {
                if ($rOpts_comma_arrow_breakpoints) {
                    $want_comma_break[$depth] = 0;
                    return;
                }
            }

            $self->set_forced_breakpoint($i)
              unless ( $next_nonblank_type eq '#' );

            # break before the previous token if it looks safe
            # Example of something that we will not try to break before:
            #   DBI::SQL_SMALLINT() => $ado_consts->{adSmallInt},
            # Also we don't want to break at a binary operator (like +):
            # $c->createOval(
            #    $x + $R, $y +
            #    $R => $x - $R,
            #    $y - $R, -fill   => 'black',
            # );
            my $ibreak = $index_before_arrow[$depth] - 1;
            if ( $ibreak > 0
                && !$is_closing_token{ $tokens_to_go[ $ibreak + 1 ] } )
            {
                if ( $tokens_to_go[$ibreak] eq '-' ) { $ibreak-- }
                if ( $types_to_go[$ibreak] eq 'b' )  { $ibreak-- }
                if ( $types_to_go[$ibreak] =~ /^[,wiZCUG\(\{\[]$/ ) {

                    # don't break before a comma, as in the following:
                    # ( LONGER_THAN,=> 1,
                    #    EIGHTY_CHARACTERS,=> 2,
                    #    CAUSES_FORMATTING,=> 3,
                    #    LIKE_THIS,=> 4,
                    # );
                    # This example is for -tso but should be general rule
                    if (   $types_to_go[ $ibreak + 1 ] ne '->'
                        && $types_to_go[ $ibreak + 1 ] ne ',' )
                    {
                        $self->set_forced_breakpoint($ibreak);
                    }
                }
            }

            $want_comma_break[$depth]   = 0;
            $index_before_arrow[$depth] = -1;

            # handle list which mixes '=>'s and ','s:
            # treat any list items so far as an interrupted list
            $interrupted_list[$depth] = 1;
            return;
        }

        # Break after all commas above starting depth...
        # But only if the last closing token was followed by a comma,
        #   to avoid breaking a list operator (issue c119)
        if (   $depth < $starting_depth
            && $comma_follows_last_closing_token
            && !$dont_align[$depth] )
        {
            $self->set_forced_breakpoint($i)
              unless ( $next_nonblank_type eq '#' );
            return;
        }

        # add this comma to the list..
        my $item_count = $item_count_stack[$depth];
        if ( $item_count == 0 ) {

            # but do not form a list with no opening structure
            # for example:

            #            open INFILE_COPY, ">$input_file_copy"
            #              or die ("very long message");
            if ( ( $opening_structure_index_stack[$depth] < 0 )
                && $self->is_in_block_by_i($i) )
            {
                $dont_align[$depth] = 1;
            }
        }

        $comma_index[$depth][$item_count] = $i;
        ++$item_count_stack[$depth];
        if ( $last_nonblank_type =~ /^[iR\]]$/ ) {
            $identifier_count_stack[$depth]++;
        }
        return;
    } ## end sub study_comma

    my %poor_types;
    my %poor_keywords;
    my %poor_next_types;
    my %poor_next_keywords;

    BEGIN {

        # Setup filters for detecting very poor breaks to ignore.
        # b1097: old breaks after type 'L' and before 'R' are poor
        # b1450: old breaks at 'eq' and related operators are poor
        my @q = qw( == <= >= != );

        @poor_types{@q}       = (1) x scalar(@q);
        @poor_next_types{@q}  = (1) x scalar(@q);
        $poor_types{'L'}      = 1;
        $poor_next_types{'R'} = 1;

        @q                      = qw( eq ne le ge lt gt );
        @poor_keywords{@q}      = (1) x scalar(@q);
        @poor_next_keywords{@q} = (1) x scalar(@q);
    } ## end BEGIN

    sub examine_old_breakpoint {

        my ( $self, $i, $i_next_nonblank, $i_want_previous_break,
            $i_old_assignment_break )
          = @_;

        # Look at an old breakpoint and set/update certain flags:

        # Given indexes of three tokens in this batch:
        #   $i_next_nonblank        - index of the next nonblank token
        #   $i_want_previous_break  - we want a break before this index
        #   $i_old_assignment_break - the index of an '=' or equivalent
        # Update:
        #   $old_breakpoint_count   - a counter to increment unless poor break
        # Update and return:
        #   $i_want_previous_break
        #   $i_old_assignment_break

        #-----------------------
        # Filter out poor breaks
        #-----------------------
        # Just return if this is a poor break and pretend it does not exist.
        # Otherwise, poor breaks made under stress can cause instability.
        my $poor_break;
        if   ( $type eq 'k' ) { $poor_break ||= $poor_keywords{$token} }
        else                  { $poor_break ||= $poor_types{$type} }

        if ( $next_nonblank_type eq 'k' ) {
            $poor_break ||= $poor_next_keywords{$next_nonblank_token};
        }
        else {
            $poor_break ||= $poor_next_types{$next_nonblank_type};
        }

        # Also ignore any high stress level breaks; fixes b1395
        $poor_break ||= $levels_to_go[$i] >= $high_stress_level;
        if ($poor_break) { goto RETURN }

        #--------------------------------------------
        # Not a poor break, so continue to examine it
        #--------------------------------------------
        $old_breakpoint_count++;
        $i_line_end   = $i;
        $i_line_start = $i_next_nonblank;

        #---------------------------------------
        # Do we want to break before this token?
        #---------------------------------------

        # Break before certain keywords if user broke there and
        # this is a 'safe' break point. The idea is to retain
        # any preferred breaks for sequential list operations,
        # like a schwartzian transform.
        if ($rOpts_break_at_old_keyword_breakpoints) {
            if (
                   $next_nonblank_type eq 'k'
                && $is_keyword_returning_list{$next_nonblank_token}
                && (   $type =~ /^[=\)\]\}Riw]$/
                    || $type eq 'k' && $is_keyword_returning_list{$token} )
              )
            {

                # we actually have to set this break next time through
                # the loop because if we are at a closing token (such
                # as '}') which forms a one-line block, this break might
                # get undone.

                # But do not do this at an '=' if:
                # - the user wants breaks before an equals (b434 b903)
                # - or -naws is set (can be unstable, see b1354)
                my $skip = $type eq '='
                  && ( $want_break_before{$type}
                    || !$rOpts_add_whitespace );

                $i_want_previous_break = $i
                  unless ($skip);

            }
        }

        # Break before attributes if user broke there
        if ($rOpts_break_at_old_attribute_breakpoints) {
            if ( $next_nonblank_type eq 'A' ) {
                $i_want_previous_break = $i;
            }
        }

        #---------------------------------
        # Is this an old assignment break?
        #---------------------------------
        if ( $is_assignment{$type} ) {
            $i_old_assignment_break = $i;
        }
        elsif ( $is_assignment{$next_nonblank_type} ) {
            $i_old_assignment_break = $i_next_nonblank;
        }
        else {
            ## not old assignment break
        }

      RETURN:
        return ( $i_want_previous_break, $i_old_assignment_break );
    } ## end sub examine_old_breakpoint

    sub break_lists_type_sequence {

        my ( $self, $i ) = @_;

        # We have encountered a sequenced token while setting list breakpoints

        # Given:
        #  $i = index of this token in the _to_go output batch array

        # if closing type, one of } ) ] :
        if ( $is_closing_sequence_token{$token} ) {

            if ( $type eq ':' ) {
                $i_last_colon = $i;

                # retain break at a ':' line break
                if (   ( $i == $i_line_start || $i == $i_line_end )
                    && $rOpts_break_at_old_ternary_breakpoints
                    && $levels_to_go[$i] < $high_stress_level )
                {

                    $self->set_forced_breakpoint($i);

                    # Break at a previous '=', but only if it is before
                    # the mating '?'. Mate_index test fixes b1287.
                    my $ieq = $i_equals[$depth];
                    my $mix = $mate_index_to_go[$i];
                    if ( !defined($mix) ) { $mix = -1 }
                    if ( $ieq > 0 && $ieq < $mix ) {
                        $self->set_forced_breakpoint( $i_equals[$depth] );
                        $i_equals[$depth] = -1;
                    }
                }
            }

            # handle any postponed closing breakpoints
            if ( has_postponed_breakpoint($type_sequence) ) {
                my $inc = ( $type eq ':' ) ? 0 : 1;
                if ( $i >= $inc ) {
                    $self->set_forced_breakpoint( $i - $inc );
                }
            }
        }

        # must be opening token, one of { ( [ ?
        else {

            # set breaks at ?/: if they will get separated (and are
            # not a ?/: chain), or if the '?' is at the end of the
            # line
            if ( $token eq '?' ) {
                my $i_colon = $mate_index_to_go[$i];
                if (
                    !defined($i_colon) # the ':' is not in this batch
                    || $i == 0         # this '?' is the first token of the line
                    || $i == $max_index_to_go    # or this '?' is the last token
                  )
                {

                    # don't break if # this has a side comment, and
                    # don't break at a '?' if preceded by ':' on
                    # this line of previous ?/: pair on this line.
                    # This is an attempt to preserve a chain of ?/:
                    # expressions (elsif2.t).
                    if (
                        (
                               $i_last_colon < 0
                            || $parent_seqno_to_go[$i_last_colon] !=
                            $parent_seqno_to_go[$i]
                        )
                        && $tokens_to_go[$max_index_to_go] ne '#'
                      )
                    {
                        $self->set_forced_breakpoint($i);
                    }
                    $self->set_closing_breakpoint($i);
                }
            }

            # must be one of { ( [
            else {

                # do requested -lp breaks at the OPENING token for BROKEN
                # blocks.  NOTE: this can be done for both -lp and -xlp,
                # but only -xlp can really take advantage of this.  So this
                # is currently restricted to -xlp to avoid excess changes to
                # existing -lp formatting.
                if ( $rOpts_extended_line_up_parentheses
                    && !defined( $mate_index_to_go[$i] ) )
                {
                    my $lp_object =
                      $self->[_rlp_object_by_seqno_]->{$type_sequence};
                    if ($lp_object) {
                        my $K_begin_line = $lp_object->get_K_begin_line();
                        my $i_begin_line = $K_begin_line - $K_to_go[0];
                        $self->set_forced_lp_break( $i_begin_line, $i );
                    }
                }
            }
        }
        return;
    } ## end sub break_lists_type_sequence

    sub break_lists_increasing_depth {

        my ( $self, $i ) = @_;

        # Given:
        #  $i = index of this token in the _to_go output batch array

        #--------------------------------------------
        # prepare for a new list when depth increases
        # token $i is a '(','{', or '['
        #--------------------------------------------

        #----------------------------------------------------------
        # BEGIN initialize depth arrays
        # ... use the same order as sub check_for_new_minimum_depth
        #----------------------------------------------------------
        $type_sequence_stack[$depth] = $type_sequence;

        $override_cab3[$depth] = undef;
        if ( $rOpts_comma_arrow_breakpoints == 3 && $type_sequence ) {
            $override_cab3[$depth] =
              $self->[_roverride_cab3_]->{$type_sequence};
        }

        $breakpoint_stack[$depth] = $forced_breakpoint_count;
        $container_type[$depth] =

          #      k => && || ? : .
          $is_container_label_type{$last_nonblank_type}
          ? $last_nonblank_token
          : EMPTY_STRING;
        $identifier_count_stack[$depth]        = 0;
        $index_before_arrow[$depth]            = -1;
        $interrupted_list[$depth]              = 0;
        $item_count_stack[$depth]              = 0;
        $last_nonblank_type_stack[$depth]      = $last_nonblank_type;
        $opening_structure_index_stack[$depth] = $i;

        $breakpoint_undo_stack[$depth]       = $forced_breakpoint_undo_count;
        $comma_index[$depth]                 = undef;
        $last_comma_index[$depth]            = undef;
        $last_dot_index[$depth]              = undef;
        $old_breakpoint_count_stack[$depth]  = $old_breakpoint_count;
        $has_old_logical_breakpoints[$depth] = 0;
        $rand_or_list[$depth]                = [];
        $rfor_semicolon_list[$depth]         = [];
        $i_equals[$depth]                    = -1;

        # if line ends here then signal closing token to break
        if ( $next_nonblank_type eq 'b' || $next_nonblank_type eq '#' ) {
            $self->set_closing_breakpoint($i);
        }

        # Not all lists of values should be vertically aligned..
        $dont_align[$depth] =

          # code BLOCKS are handled at a higher level
          $block_type

          # certain paren lists
          || ( $type eq '(' ) && (

            # it does not usually look good to align a list of
            # identifiers in a parameter list, as in:
            #    my($var1, $var2, ...)
            # (This test should probably be refined, for now I'm just
            # testing for any keyword)
            ( $last_nonblank_type eq 'k' )

            # a trailing '(' usually indicates a non-list
            || ( $next_nonblank_type eq '(' )
          );
        $has_broken_sublist[$depth] = 0;
        $want_comma_break[$depth]   = 0;

        #----------------------------
        # END initialize depth arrays
        #----------------------------

        # patch to outdent opening brace of long if/for/..
        # statements (like this one).  See similar coding in
        # set_continuation breaks.  We have also catch it here for
        # short line fragments which otherwise will not go through
        # break_long_lines.
        if (
            $block_type

            # if we have the ')' but not its '(' in this batch..
            && ( $last_nonblank_token eq ')' )
            && !defined( $mate_index_to_go[$i_last_nonblank_token] )

            # and user wants brace to left
            && !$rOpts_opening_brace_always_on_right

            && ( $type eq '{' )     # should be true
            && ( $token eq '{' )    # should be true
          )
        {
            $self->set_forced_breakpoint( $i - 1 );
        }

        return;
    } ## end sub break_lists_increasing_depth

    sub break_lists_decreasing_depth {

        my ( $self, $i, $rbond_strength_bias ) = @_;

        # Given:
        #  $i = index of this token in the _to_go output batch array
        #  $rbond_strength_bias = list of bond strengths to be updated

        # We have arrived at a closing container token in sub break_lists:
        # the token at index $i is one of these: ')','}', ']'
        # A number of important breakpoints for this container can now be set
        # based on the information that we have collected. This includes:
        # - breaks at commas to format tables
        # - breaks at certain logical operators and other good breakpoints
        # - breaks at opening and closing containers if needed by selected
        #   formatting styles
        # These breaks are made by calling sub 'set_forced_breakpoint'

        # Note that $rbond_strength_bias is passed to sub
        # set_comma_breakpoints, but it will not be changed.  It only gets
        # changed by later calls for incomplete lists.

        $self->check_for_new_minimum_depth( $depth, $parent_seqno_to_go[$i] )
          if ( $depth < $minimum_depth );

        # force all outer logical containers to break after we see on
        # old breakpoint
        $has_old_logical_breakpoints[$depth] ||=
          $has_old_logical_breakpoints[$current_depth];

        # Patch to break between ') {' if the paren list is broken.
        # There is similar logic in break_long_lines for
        # non-broken lists.
        if (   $token eq ')'
            && $next_nonblank_block_type
            && $interrupted_list[$current_depth]
            && $next_nonblank_type eq '{'
            && !$rOpts_opening_brace_always_on_right )
        {
            $self->set_forced_breakpoint($i);
        }

#print "LISTY sees: i=$i type=$type  tok=$token  block=$block_type depth=$depth next=$next_nonblank_type next_block=$next_nonblank_block_type inter=$interrupted_list[$current_depth]\n";

        #-----------------------------------------------------------------
        # Set breaks at commas to display a table of values if appropriate
        #-----------------------------------------------------------------
        my ( $bp_count, $do_not_break_apart ) = ( 0, 0 );
        if ( $item_count_stack[$current_depth] ) {
            ( $bp_count, $do_not_break_apart ) =
              $self->set_comma_breakpoints( $i, $current_depth,
                $rbond_strength_bias );
        }

        #-----------------------------------------------------------
        # Now set flags needed to decide if we should break open the
        # container ... This is a long rambling section which has
        # grown over time to handle all situations.
        #-----------------------------------------------------------
        my $i_opening = $opening_structure_index_stack[$current_depth];
        my $saw_opening_structure = ( $i_opening >= 0 );
        my $lp_object;
        if ( $rOpts_line_up_parentheses && $saw_opening_structure ) {
            $lp_object = $self->[_rlp_object_by_seqno_]
              ->{ $type_sequence_to_go[$i_opening] };
        }

        # this term is long if we had to break at interior commas..
        my $is_long_term = $bp_count > 0;

        # If this is a short container with one or more comma arrows,
        # then we will mark it as a long term to open it if requested.
        # $rOpts_comma_arrow_breakpoints =
        #    0 - open only if comma precedes closing brace
        #    1 - stable: except for one line blocks
        #    2 - try to form 1 line blocks
        #    3 - ignore =>
        #    4 - always open up if vt=0
        #    5 - stable: even for one line blocks if vt=0

        my $cab_flag = $rOpts_comma_arrow_breakpoints;

        # replace -cab=3 if overriden
        if ( $cab_flag == 3 && $type_sequence ) {
            my $test_cab = $self->[_roverride_cab3_]->{$type_sequence};
            if ( defined($test_cab) ) { $cab_flag = $test_cab }
        }

        # PATCH: Modify the -cab flag if we are not processing a list:
        # We only want the -cab flag to apply to list containers, so
        # for non-lists we use the default and stable -cab=5 value.
        # Fixes case b939a.
        if ( $type_sequence && !$self->[_ris_list_by_seqno_]->{$type_sequence} )
        {
            $cab_flag = 5;
        }

        # Ignore old breakpoints when under stress.
        # Fixes b1203 b1204 as well as b1197-b1200.
        # But not if -lp: fixes b1264, b1265.  NOTE: rechecked with
        # b1264 to see if this check is still required at all, and
        # these still require a check, but at higher level beta+3
        # instead of beta:  b1193 b780
        if (   $saw_opening_structure
            && !$lp_object
            && $levels_to_go[$i_opening] >= $high_stress_level )
        {
            $cab_flag = 2;

            # Do not break hash braces under stress (fixes b1238)
            $do_not_break_apart ||= $types_to_go[$i_opening] eq 'L';

            # This option fixes b1235, b1237, b1240 with old and new
            # -lp, but formatting is nicer with next option.
            ## $is_long_term ||=
            ##  $levels_to_go[$i_opening] > $stress_level_beta + 1;

            # This option fixes b1240 but not b1235, b1237 with new -lp,
            # but this gives better formatting than the previous option.
            # TODO: see if stress_level_alpha should also be considered
            $do_not_break_apart ||=
              $levels_to_go[$i_opening] > $stress_level_beta;
        }

        if (  !$is_long_term
            && $saw_opening_structure
            && $is_opening_token{ $tokens_to_go[$i_opening] }
            && $index_before_arrow[ $depth + 1 ] > 0
            && !$opening_vertical_tightness{ $tokens_to_go[$i_opening] } )
        {
            $is_long_term =
                 $cab_flag == 4
              || $cab_flag == 0 && $last_nonblank_type eq ','
              || $cab_flag == 5 && $old_breakpoint_to_go[$i_opening];
        }

        # mark term as long if the length between opening and closing
        # parens exceeds allowed line length
        if ( !$is_long_term && $saw_opening_structure ) {

            my $i_opening_minus = $self->find_token_starting_list($i_opening);

            my $excess = $self->excess_line_length( $i_opening_minus, $i );

            # Use standard spaces for indentation of lists in -lp mode
            # if it gives a longer line length. This helps to avoid an
            # instability due to forming and breaking one-line blocks.
            # This fixes case b1314.
            my $indentation = $leading_spaces_to_go[$i_opening_minus];
            if ( ref($indentation)
                && $self->[_ris_broken_container_]->{$type_sequence} )
            {
                my $lp_spaces  = $indentation->get_spaces();
                my $std_spaces = $indentation->get_standard_spaces();
                my $diff       = $std_spaces - $lp_spaces;
                if ( $diff > 0 ) { $excess += $diff }
            }

            my $tol = $length_tol;

            # boost tol for an -lp container
            if (
                   $lp_tol_boost
                && $lp_object
                && ( $rOpts_extended_continuation_indentation
                    || !$self->[_ris_list_by_seqno_]->{$type_sequence} )
              )
            {
                $tol += $lp_tol_boost;
            }

            # Patch to avoid blinking with -bbxi=2 and -cab=2
            # in which variations in -ci cause unstable formatting
            # in edge cases. We just always add one ci level so that
            # the formatting is independent of the -BBX results.
            # Fixes cases b1137 b1149 b1150 b1155 b1158 b1159 b1160
            # b1161 b1166 b1167 b1168
            if (  !$ci_levels_to_go[$i_opening]
                && $self->[_rbreak_before_container_by_seqno_]->{$type_sequence}
              )
            {
                $tol += $rOpts_continuation_indentation;
            }

            $is_long_term = $excess + $tol > 0;

        }

        # We've set breaks after all comma-arrows.  Now we have to
        # undo them if this can be a one-line block
        # (the only breakpoints set will be due to comma-arrows)

        if (

            # user doesn't require breaking after all comma-arrows
            ( $cab_flag != 0 ) && ( $cab_flag != 4 )

            # and if the opening structure is in this batch
            && $saw_opening_structure

            # and either on the same old line
            && (
                $old_breakpoint_count_stack[$current_depth] ==
                $last_old_breakpoint_count

                # or user wants to form long blocks with arrows
                # check on _rbreak_container_ added for b1500
                || ( $cab_flag == 2
                    && !$self->[_rbreak_container_]->{$type_sequence} )
            )

            # and we made breakpoints between the opening and closing
            && ( $breakpoint_undo_stack[$current_depth] <
                $forced_breakpoint_undo_count )

            # and this block is short enough to fit on one line
            # Note: use < because need 1 more space for possible comma
            && !$is_long_term

          )
        {
            $self->undo_forced_breakpoint_stack(
                $breakpoint_undo_stack[$current_depth] );
        }

        # now see if we have any comma breakpoints left
        my $has_comma_breakpoints =
          ( $breakpoint_stack[$current_depth] != $forced_breakpoint_count );

        # update broken-sublist flag of the outer container
        $has_broken_sublist[$depth] =
             $has_broken_sublist[$depth]
          || $has_broken_sublist[$current_depth]
          || $is_long_term
          || $has_comma_breakpoints;

        # Having come to the closing ')', '}', or ']', now we have to decide
        # if we should 'open up' the structure by placing breaks at the
        # opening and closing containers.  This is a tricky decision.  Here
        # are some of the basic considerations:
        #
        # -If this is a BLOCK container, then any breakpoints will have
        # already been set (and according to user preferences), so we need do
        # nothing here.
        #
        # -If we have a comma-separated list for which we can align the list
        # items, then we need to do so because otherwise the vertical aligner
        # cannot currently do the alignment.
        #
        # -If this container does itself contain a container which has been
        # broken open, then it should be broken open to properly show the
        # structure.
        #
        # -If there is nothing to align, and no other reason to break apart,
        # then do not do it.
        #
        # We will not break open the parens of a long but 'simple' logical
        # expression.  For example:
        #
        # This is an example of a simple logical expression and its formatting:
        #
        #     if ( $bigwasteofspace1 && $bigwasteofspace2
        #         || $bigwasteofspace3 && $bigwasteofspace4 )
        #
        # Most people would prefer this than the 'spacey' version:
        #
        #     if (
        #         $bigwasteofspace1 && $bigwasteofspace2
        #         || $bigwasteofspace3 && $bigwasteofspace4
        #     )
        #
        # To illustrate the rules for breaking logical expressions, consider:
        #
        #             FULLY DENSE:
        #             if ( $opt_excl
        #                 and ( exists $ids_excl_uc{$id_uc}
        #                     or grep $id_uc =~ /$_/, @ids_excl_uc ))
        #
        # This is on the verge of being difficult to read.  The current
        # default is to open it up like this:
        #
        #             DEFAULT:
        #             if (
        #                 $opt_excl
        #                 and ( exists $ids_excl_uc{$id_uc}
        #                     or grep $id_uc =~ /$_/, @ids_excl_uc )
        #               )
        #
        # This is a compromise which tries to avoid being too dense and to
        # spacey.  A more spaced version would be:
        #
        #             SPACEY:
        #             if (
        #                 $opt_excl
        #                 and (
        #                     exists $ids_excl_uc{$id_uc}
        #                     or grep $id_uc =~ /$_/, @ids_excl_uc
        #                 )
        #               )
        #
        # Some people might prefer the spacey version -- an option could be
        # added.  The innermost expression contains a long block '( exists
        # $ids_...  ')'.
        #
        # Here is how the logic goes: We will force a break at the 'or' that
        # the innermost expression contains, but we will not break apart its
        # opening and closing containers because (1) it contains no
        # multi-line sub-containers itself, and (2) there is no alignment to
        # be gained by breaking it open like this
        #
        #             and (
        #                 exists $ids_excl_uc{$id_uc}
        #                 or grep $id_uc =~ /$_/, @ids_excl_uc
        #             )
        #
        # (although this looks perfectly ok and might be good for long
        # expressions).  The outer 'if' container, though, contains a broken
        # sub-container, so it will be broken open to avoid too much density.
        # Also, since it contains no 'or's, there will be a forced break at
        # its 'and'.

        # Handle the experimental flag --break-open-compact-parens
        # NOTE: This flag is not currently used and may eventually be removed.
        # If this flag is set, we will implement it by
        # pretending we did not see the opening structure, since in that case
        # parens always get opened up.
        if (   $saw_opening_structure
            && $rOpts_break_open_compact_parens )
        {

            # This parameter is a one-character flag, as follows:
            #  '0' matches no parens  -> break open NOT OK
            #  '1' matches all parens -> break open OK
            #  Other values are same as used by the weld-exclusion-list
            my $flag = $rOpts_break_open_compact_parens;
            if (   $flag eq '*'
                || $flag eq '1' )
            {
                $saw_opening_structure = 0;
            }
            else {

                # NOTE: $seqno will be equal to closure var $type_sequence here
                my $seqno = $type_sequence_to_go[$i_opening];
                $saw_opening_structure =
                  !$self->match_paren_control_flag( $seqno, $flag );
            }
        }

        # Set some more flags telling something about this container..
        my $is_simple_logical_expression;
        if (   $item_count_stack[$current_depth] == 0
            && $saw_opening_structure
            && $tokens_to_go[$i_opening] eq '('
            && $is_logical_container{ $container_type[$current_depth] } )
        {

            # This seems to be a simple logical expression with
            # no existing breakpoints.  Set a flag to prevent
            # opening it up.
            if ( !$has_comma_breakpoints ) {
                $is_simple_logical_expression = 1;
            }

            #---------------------------------------------------
            # This seems to be a simple logical expression with
            # breakpoints (broken sublists, for example).  Break
            # at all 'or's and '||'s.
            #---------------------------------------------------
            else {
                $self->set_logical_breakpoints($current_depth);
            }
        }

        # break long terms at any C-style for semicolons (c154)
        if ( $is_long_term
            && @{ $rfor_semicolon_list[$current_depth] } )
        {
            $self->set_for_semicolon_breakpoints($current_depth);

            # and open up a long 'for' or 'foreach' container to allow
            # leading term alignment unless -lp is used.
            $has_comma_breakpoints = 1 unless ($lp_object);
        }

        #----------------------------------------------------------------
        # FINALLY: Break open container according to the flags which have
        # been set.
        #----------------------------------------------------------------
        if (

            # breaks for code BLOCKS are handled at a higher level
            !$block_type

            # we do not need to break at the top level of an 'if'
            # type expression
            && !$is_simple_logical_expression

            ## modification to keep ': (' containers vertically tight;
            ## but probably better to let user set -vt=1 to avoid
            ## inconsistency with other paren types
            ## && ($container_type[$current_depth] ne ':')

            # otherwise, we require one of these reasons for breaking:
            && (

                # - this term has forced line breaks
                $has_comma_breakpoints

                # - the opening container is separated from this batch
                #   for some reason (comment, blank line, code block)
                # - this is a non-paren container spanning multiple lines
                || !$saw_opening_structure

                # - this is a long block contained in another breakable
                #   container
                || $is_long_term && !$self->is_in_block_by_i($i_opening)
            )
          )
        {

            # do special -lp breaks at the CLOSING token for INTACT
            # blocks (because we might not do them if the block does
            # not break open)
            if ($lp_object) {
                my $K_begin_line = $lp_object->get_K_begin_line();
                my $i_begin_line = $K_begin_line - $K_to_go[0];
                $self->set_forced_lp_break( $i_begin_line, $i_opening );
            }

            # break after opening structure.
            # note: break before closing structure will be automatic
            if ( $minimum_depth <= $current_depth ) {

                if ( $i_opening >= 0 ) {
                    if (   !$do_not_break_apart
                        && !is_unbreakable_container($current_depth) )
                    {
                        $self->set_forced_breakpoint($i_opening);

                        # Do not let brace types L/R use vertical tightness
                        # flags to recombine if we have to break on length
                        # because instability is possible if both vt and vtc
                        # flags are set ... see issue b1444.
                        if (   $is_long_term
                            && $types_to_go[$i_opening] eq 'L'
                            && $opening_vertical_tightness{'{'}
                            && $closing_vertical_tightness{'}'} )
                        {
                            my $seqno = $type_sequence_to_go[$i_opening];
                            if ($seqno) {
                                $self->[_rbreak_container_]->{$seqno} = 1;
                            }
                        }
                    }
                }

                # break at ',' of lower depth level before opening token
                if ( $last_comma_index[$depth] ) {
                    $self->set_forced_breakpoint( $last_comma_index[$depth] );
                }

                # break at '.' of lower depth level before opening token
                if ( $last_dot_index[$depth] ) {
                    $self->set_forced_breakpoint( $last_dot_index[$depth] );
                }

                # break before opening structure if preceded by another
                # closing structure and a comma.  This is normally
                # done by the previous closing brace, but not
                # if it was a one-line block.
                if ( $i_opening > 2 ) {
                    my $i_prev =
                      ( $types_to_go[ $i_opening - 1 ] eq 'b' )
                      ? $i_opening - 2
                      : $i_opening - 1;

                    my $type_prev  = $types_to_go[$i_prev];
                    my $token_prev = $tokens_to_go[$i_prev];
                    if (
                        $type_prev eq ','
                        && (   $types_to_go[ $i_prev - 1 ] eq ')'
                            || $types_to_go[ $i_prev - 1 ] eq '}' )
                      )
                    {
                        $self->set_forced_breakpoint($i_prev);
                    }

                    # also break before something like ':('  or '?('
                    # if appropriate.
                    elsif ($type_prev =~ /^([k\:\?]|&&|\|\|)$/
                        && $want_break_before{$token_prev} )
                    {
                        $self->set_forced_breakpoint($i_prev);
                    }
                    else {
                        ## not a breakpoint
                    }
                }
            }

            # break after comma following closing structure
            if ( $types_to_go[ $i + 1 ] eq ',' ) {
                $self->set_forced_breakpoint( $i + 1 );
            }

            # break before an '=' following closing structure
            if (
                $is_assignment{$next_nonblank_type}
                && ( $breakpoint_stack[$current_depth] !=
                    $forced_breakpoint_count )
              )
            {
                $self->set_forced_breakpoint($i);
            }

            # break at any comma before the opening structure Added
            # for -lp, but seems to be good in general.  It isn't
            # obvious how far back to look; the '5' below seems to
            # work well and will catch the comma in something like
            #  push @list, myfunc( $param, $param, ..

            my $icomma = $last_comma_index[$depth];
            if ( defined($icomma) && ( $i_opening - $icomma ) < 5 ) {
                if ( !$forced_breakpoint_to_go[$icomma] ) {
                    $self->set_forced_breakpoint($icomma);
                }
            }
        }

        #-----------------------------------------------------------
        # Break open a logical container open if it was already open
        #-----------------------------------------------------------
        elsif ($is_simple_logical_expression
            && $has_old_logical_breakpoints[$current_depth] )
        {
            $self->set_logical_breakpoints($current_depth);
        }

        # Handle long container which does not get opened up
        elsif ($is_long_term) {

            # must set fake breakpoint to alert outer containers that
            # they are complex
            set_fake_breakpoint();
        }
        else {
            ## do not break open
        }

        return;
    } ## end sub break_lists_decreasing_depth
} ## end closure break_lists

my %is_kwiZ;
my %is_key_type;

BEGIN {

    # Added 'w' to fix b1172
    my @q = qw( k w i Z -> );
    @is_kwiZ{@q} = (1) x scalar(@q);

    # added = for b1211
    @q = qw< ( [ { L R } ] ) = b >;
    push @q, ',';
    @is_key_type{@q} = (1) x scalar(@q);
} ## end BEGIN

use constant DEBUG_FIND_START => 0;

sub find_token_starting_list {

    # When testing to see if a block will fit on one line, some
    # previous token(s) may also need to be on the line; particularly
    # if this is a sub call.  So we will look back at least one
    # token.
    my ( $self, $i_opening_paren ) = @_;

    # Given:
    #   $i_opening_paren = index of the opening token in the _to_go arrays
    #                      note: it could be any of { [ (

    # This will be the return index
    my $i_opening_minus = $i_opening_paren;

    if ( $i_opening_minus <= 0 ) {
        return $i_opening_minus;
    }

    my $im1 = $i_opening_paren - 1;
    my ( $iprev_nb, $type_prev_nb ) = ( $im1, $types_to_go[$im1] );
    if ( $type_prev_nb eq 'b' && $iprev_nb > 0 ) {
        $iprev_nb -= 1;
        $type_prev_nb = $types_to_go[$iprev_nb];
    }

    if ( $type_prev_nb eq ',' ) {

        # a previous comma is a good break point
        # $i_opening_minus = $i_opening_paren;
    }

    elsif (
        $tokens_to_go[$i_opening_paren] eq '('

        # non-parens added here to fix case b1186
        || $is_kwiZ{$type_prev_nb}
      )
    {
        $i_opening_minus = $im1;

        # Walk back to improve length estimate...
        # FIX for cases b1169 b1170 b1171: start walking back
        # at the previous nonblank. This makes the result insensitive
        # to the flag --space-function-paren, and similar.
        # previous loop: for ( my $j = $im1 ; $j >= 0 ; $j-- ) {
        foreach my $j ( reverse( 0 .. $iprev_nb ) ) {
            if ( $is_key_type{ $types_to_go[$j] } ) {

                # fix for b1211
                if ( $types_to_go[$j] eq '=' ) { $i_opening_minus = $j }
                last;
            }
            $i_opening_minus = $j;
        }
        if ( $types_to_go[$i_opening_minus] eq 'b' ) { $i_opening_minus++ }
    }

    # fix for b1467
    elsif ( $type_prev_nb eq '=' ) {
        if ( $want_break_before{$type_prev_nb} ) {
            $i_opening_minus = $iprev_nb;
        }
    }

    else {
        ## previous token not special
    }

    DEBUG_FIND_START && print <<EOM;
FIND_START: i=$i_opening_paren tok=$tokens_to_go[$i_opening_paren] => im=$i_opening_minus tok=$tokens_to_go[$i_opening_minus]
EOM

    return $i_opening_minus;
} ## end sub find_token_starting_list

{    ## begin closure table_maker

    use constant DEBUG_SPARSE => 0;

    sub table_maker {

        my ( $self, $rhash_IN ) = @_;

        # Given a list of comma-separated items, set breakpoints at some of
        # the commas, if necessary, to make it easy to read.
        # This is done by making calls to 'set_forced_breakpoint'.
        # This is a complex routine because there are many special cases.

        # Returns: nothing

        # The numerous variables involved are contained three hashes:
        # $rhash_IN : For contents see the calling routine
        # $rhash_A: For contents see return from sub 'table_layout_A'
        # $rhash_B: For contents see return from sub 'table_layout_B'

        # Find lengths of all list items needed for calculating page layout
        my $rhash_A = table_layout_A($rhash_IN);
        return if ( !defined($rhash_A) );

        # Some variables received from caller...
        my $i_closing_paren    = $rhash_IN->{i_closing_paren};
        my $i_opening_paren    = $rhash_IN->{i_opening_paren};
        my $has_broken_sublist = $rhash_IN->{has_broken_sublist};
        my $interrupted        = $rhash_IN->{interrupted};

        #-----------------------------------------
        # Section A: Handle some special cases ...
        #-----------------------------------------

        #-------------------------------------------------------------
        # Special Case A1: Compound List Rule 1:
        # Break at (almost) every comma for a list containing a broken
        # sublist.  This has higher priority than the Interrupted List
        # Rule.
        #-------------------------------------------------------------
        if ($has_broken_sublist) {
            $self->apply_broken_sublist_rule( $rhash_A, $interrupted );
            return;
        }

        #--------------------------------------------------------------
        # Special Case A2: Interrupted List Rule:
        # A list is forced to use old breakpoints if it was interrupted
        # by side comments or blank lines, or requested by user.
        #--------------------------------------------------------------
        if (   $rOpts_break_at_old_comma_breakpoints
            || $interrupted
            || $i_opening_paren < 0 )
        {
            my $i_first_comma     = $rhash_A->{_i_first_comma};
            my $i_true_last_comma = $rhash_A->{_i_true_last_comma};
            $self->copy_old_breakpoints( $i_first_comma, $i_true_last_comma );
            return;
        }

        #-----------------------------------------------------------------
        # Special Case A3: If it fits on one line, return and let the line
        # break logic decide if and where to break.
        #-----------------------------------------------------------------

        # The -bbxi=2 parameters can add an extra hidden level of indentation
        # so they need a tolerance to avoid instability.  Fixes b1259, 1260.
        my $opening_token = $tokens_to_go[$i_opening_paren];
        my $tol           = 0;
        if (   $break_before_container_types{$opening_token}
            && $container_indentation_options{$opening_token}
            && $container_indentation_options{$opening_token} == 2 )
        {
            $tol = $rOpts_indent_columns;

            # use greater of -ci and -i (fix for case b1334)
            if ( $tol < $rOpts_continuation_indentation ) {
                $tol = $rOpts_continuation_indentation;
            }
        }

        # Increase tol when -atc and -dtc are both used to allow for
        # possible loss in length on next pass due to a comma. Fixes b1455.
        if (
               $rOpts_delete_trailing_commas
            && $rOpts_add_trailing_commas

            # optional additional restriction which works for b1455:
            && $rOpts_extended_continuation_indentation
            && $rOpts_continuation_indentation > $rOpts_indent_columns
          )
        {
            $tol += 1;
        }

        # c410: check for $i_closing_paren > $max_index_to_go
        my $i_opening_minus = $self->find_token_starting_list($i_opening_paren);
        my $iend            = min( $i_closing_paren, $max_index_to_go );
        my $excess = $self->excess_line_length( $i_opening_minus, $iend );
        return if ( $excess + $tol <= 0 );

        #---------------------------------------
        # Section B: Handle a multiline list ...
        #---------------------------------------

        $self->break_multiline_list( $rhash_IN, $rhash_A, $i_opening_minus );
        return;

    } ## end sub table_maker

    sub apply_broken_sublist_rule {

        my ( $self, $rhash_A, $interrupted ) = @_;

        # Break at (almost) every comma for a list containing a broken
        # sublist.

        my $ritem_lengths     = $rhash_A->{_ritem_lengths};
        my $ri_term_begin     = $rhash_A->{_ri_term_begin};
        my $ri_term_end       = $rhash_A->{_ri_term_end};
        my $ri_term_comma     = $rhash_A->{_ri_term_comma};
        my $item_count        = $rhash_A->{_item_count_A};
        my $i_first_comma     = $rhash_A->{_i_first_comma};
        my $i_true_last_comma = $rhash_A->{_i_true_last_comma};

        # Break at every comma except for a comma between two
        # simple, small terms.  This prevents long vertical
        # columns of, say, just 0's.
        my $small_length = 10;    # 2 + actual maximum length wanted

        # We'll insert a break in long runs of small terms to
        # allow alignment in uniform tables.
        my $skipped_count = 0;
        my $columns       = table_columns_available($i_first_comma);
        my $fields        = int( $columns / $small_length );
        if (   $rOpts_maximum_fields_per_table
            && $fields > $rOpts_maximum_fields_per_table )
        {
            $fields = $rOpts_maximum_fields_per_table;
        }
        my $max_skipped_count = $fields - 1;

        my $is_simple_last_term = 0;
        my $is_simple_next_term = 0;
        foreach my $j ( 0 .. $item_count ) {
            $is_simple_last_term = $is_simple_next_term;
            $is_simple_next_term = 0;
            if (   $j < $item_count
                && $ri_term_end->[$j] == $ri_term_begin->[$j]
                && $ritem_lengths->[$j] <= $small_length )
            {
                $is_simple_next_term = 1;
            }
            next if $j == 0;
            if (   $is_simple_last_term
                && $is_simple_next_term
                && $skipped_count < $max_skipped_count )
            {
                $skipped_count++;
            }
            else {
                $skipped_count = 0;
                my $i_tc = $ri_term_comma->[ $j - 1 ];
                last unless defined($i_tc);
                $self->set_forced_breakpoint($i_tc);
            }
        }

        # always break at the last comma if this list is
        # interrupted; we wouldn't want to leave a terminal '{', for
        # example.
        if ($interrupted) {
            $self->set_forced_breakpoint($i_true_last_comma);
        }
        return;
    } ## end sub apply_broken_sublist_rule

    sub set_emergency_comma_breakpoints {

        my (

            $self,    #

            $number_of_fields_best,
            $rhash_IN,
            $comma_count,
            $i_first_comma,

        ) = @_;

        # The computed number of table fields is negative, so we have to make
        # an emergency fix.

        my $rcomma_index        = $rhash_IN->{rcomma_index};
        my $next_nonblank_type  = $rhash_IN->{next_nonblank_type};
        my $rdo_not_break_apart = $rhash_IN->{rdo_not_break_apart};
        my $must_break_open     = $rhash_IN->{must_break_open};

        # are we an item contained in an outer list?
        my $in_hierarchical_list = $next_nonblank_type =~ /^[\}\,]$/;

        # In many cases, it may be best to not force a break if there is just
        # one comma, because the standard continuation break logic will do a
        # better job without it.

        # In the common case that all but one of the terms can fit
        # on a single line, it may look better not to break open the
        # containing parens.  Consider, for example

        #     $color =
        #       join ( '/',
        #         sort { $color_value{$::a} <=> $color_value{$::b}; }
        #         keys %colors );

        # which will look like this with the container broken:

        #   $color = join (
        #       '/',
        #       sort { $color_value{$::a} <=> $color_value{$::b}; } keys %colors
        #   );

        # Here is an example of this rule for a long last term:

        #   log_message( 0, 256, 128,
        #       "Number of routes in adj-RIB-in to be considered: $peercount" );

        # And here is an example with a long first term:

        # $s = sprintf(
        # "%2d wallclock secs (%$f usr %$f sys + %$f cusr %$f csys = %$f CPU)",
        #     $r, $pu, $ps, $cu, $cs, $tt
        #   )
        #   if $style eq 'all';

        my $i_last_comma = $rcomma_index->[ $comma_count - 1 ];

        my $long_last_term = $self->excess_line_length( 0, $i_last_comma ) <= 0;
        my $long_first_term =
          $self->excess_line_length( $i_first_comma + 1, $max_index_to_go ) <=
          0;

        # break at every comma ...
        if (

            # if requested by user or is best looking
            $number_of_fields_best == 1

            # or if this is a sublist of a larger list
            || $in_hierarchical_list

            # or if multiple commas and we don't have a long first or last
            # term
            || ( $comma_count > 1
                && !( $long_last_term || $long_first_term ) )
          )
        {
            foreach ( 0 .. $comma_count - 1 ) {
                $self->set_forced_breakpoint( $rcomma_index->[$_] );
            }
        }
        elsif ($long_last_term) {

            $self->set_forced_breakpoint($i_last_comma);
            ${$rdo_not_break_apart} = 1 unless $must_break_open;
        }
        elsif ($long_first_term) {

            $self->set_forced_breakpoint($i_first_comma);
        }
        else {

            # let breaks be defined by default bond strength logic
        }
        return;
    } ## end sub set_emergency_comma_breakpoints

    sub break_multiline_list {
        my ( $self, $rhash_IN, $rhash_A, $i_opening_minus ) = @_;

        # We have a list spanning multiple lines and are trying
        # to decide the best way to set comma breakpoints.

        # Overridden variables
        my $item_count       = $rhash_A->{_item_count_A};
        my $identifier_count = $rhash_A->{_identifier_count_A};

        # Derived variables:
##      my $ritem_lengths          = $rhash_A->{_ritem_lengths};
##      my $ri_term_begin          = $rhash_A->{_ri_term_begin};
##      my $ri_term_end            = $rhash_A->{_ri_term_end};
        my $ri_term_comma          = $rhash_A->{_ri_term_comma};
        my $rmax_length            = $rhash_A->{_rmax_length};
        my $comma_count            = $rhash_A->{_comma_count};
        my $i_effective_last_comma = $rhash_A->{_i_effective_last_comma};
        my $first_term_length      = $rhash_A->{_first_term_length};
        my $i_first_comma          = $rhash_A->{_i_first_comma};
        my $i_last_comma           = $rhash_A->{_i_last_comma};
##      my $i_true_last_comma      = $rhash_A->{_i_true_last_comma};

        # Variables received from caller
        my $i_opening_paren = $rhash_IN->{i_opening_paren};
##      my $i_closing_paren     = $rhash_IN->{i_closing_paren};
        my $rcomma_index       = $rhash_IN->{rcomma_index};
        my $next_nonblank_type = $rhash_IN->{next_nonblank_type};
        my $list_type          = $rhash_IN->{list_type};
##      my $interrupted         = $rhash_IN->{interrupted};
        my $rdo_not_break_apart = $rhash_IN->{rdo_not_break_apart};
        my $must_break_open     = $rhash_IN->{must_break_open};

## NOTE: these input vars from caller use the values from rhash_A (see above):
##      my $item_count          = $rhash_IN->{item_count};
##      my $identifier_count    = $rhash_IN->{identifier_count};

        # NOTE: i_opening_paren changes value below so we need to get these here
        my $opening_is_in_block = $self->is_in_block_by_i($i_opening_paren);
        my $opening_token       = $tokens_to_go[$i_opening_paren];

        #---------------------------------------------------------------
        # Section B1: Determine '$number_of_fields' = the best number of
        # fields to use if this is to be formatted as a table.
        #---------------------------------------------------------------

        # Now we know that this block spans multiple lines; we have to set
        # at least one breakpoint -- real or fake -- as a signal to break
        # open any outer containers.
        set_fake_breakpoint();

        # Set a flag indicating if we need to break open to keep -lp
        # items aligned.  This is necessary if any of the list terms
        # exceeds the available space after the '('.
        my $need_lp_break_open = $must_break_open;
        my $is_lp_formatting   = ref( $leading_spaces_to_go[$i_first_comma] );
        if ( $is_lp_formatting && !$must_break_open ) {
            my $columns_if_unbroken =
              $maximum_line_length_at_level[ $levels_to_go[$i_opening_minus] ]
              - total_line_length( $i_opening_minus, $i_opening_paren );
            $need_lp_break_open =
                 ( $rmax_length->[0] > $columns_if_unbroken )
              || ( $rmax_length->[1] > $columns_if_unbroken )
              || ( $first_term_length > $columns_if_unbroken );
        }

        my $hash_B =
          $self->table_layout_B( $rhash_IN, $rhash_A, $is_lp_formatting );
        return if ( !defined($hash_B) );

        # Updated variables
        $i_first_comma   = $hash_B->{_i_first_comma_B};
        $i_opening_paren = $hash_B->{_i_opening_paren_B};
        $item_count      = $hash_B->{_item_count_B};

        # New variables
        my $columns              = $hash_B->{_columns};
        my $formatted_columns    = $hash_B->{_formatted_columns};
        my $formatted_lines      = $hash_B->{_formatted_lines};
        my $max_width            = $hash_B->{_max_width};
        my $new_identifier_count = $hash_B->{_new_identifier_count};
        my $number_of_fields     = $hash_B->{_number_of_fields};
##      my $odd_or_even             = $hash_B->{_odd_or_even};
        my $packed_columns          = $hash_B->{_packed_columns};
        my $packed_lines            = $hash_B->{_packed_lines};
        my $pair_width              = $hash_B->{_pair_width};
        my $ri_ragged_break_list    = $hash_B->{_ri_ragged_break_list};
        my $use_separate_first_term = $hash_B->{_use_separate_first_term};

        # are we an item contained in an outer list?
        my $in_hierarchical_list = $next_nonblank_type =~ /^[\}\,]$/;

        my $unused_columns = $formatted_columns - $packed_columns;

        # set some empirical parameters to help decide if we should try to
        # align; high sparsity does not look good, especially with few lines
        my $sparsity = ($unused_columns) / ($formatted_columns);
        my $max_allowed_sparsity =
            ( $item_count < 3 )    ? 0.1
          : ( $packed_lines == 1 ) ? 0.15
          : ( $packed_lines == 2 ) ? 0.4
          :                          0.7;

        my $two_line_word_wrap_ok;
        if ( $opening_token eq '(' ) {

            # default is to allow wrapping of short paren lists
            $two_line_word_wrap_ok = 1;

            # but turn off word wrap where requested
            if ($rOpts_break_open_compact_parens) {

                # This parameter is a one-character flag, as follows:
                #  '0' matches no parens  -> break open NOT OK -> word wrap OK
                #  '1' matches all parens -> break open OK -> word wrap NOT OK
                #  Other values are the same as used by the weld-exclusion-list
                my $flag = $rOpts_break_open_compact_parens;
                if (   $flag eq '*'
                    || $flag eq '1' )
                {
                    $two_line_word_wrap_ok = 0;
                }
                elsif ( $flag eq '0' ) {
                    $two_line_word_wrap_ok = 1;
                }
                else {
                    my $seqno = $type_sequence_to_go[$i_opening_paren];
                    $two_line_word_wrap_ok =
                      !$self->match_paren_control_flag( $seqno, $flag );
                }
            }
        }

        #-------------------------------------------------------------------
        # Section B2: Check for shortcut methods, which avoid treating
        # a list as a table for relatively small parenthesized lists.  These
        # are usually easier to read if not formatted as tables.
        #-------------------------------------------------------------------
        if (
            $packed_lines <= 2           # probably can fit in 2 lines
            && $item_count < 9           # doesn't have too many items
            && $opening_is_in_block      # not a sub-container
            && $two_line_word_wrap_ok    # ok to wrap this paren list
          )
        {

            # Section B2A: Shortcut method 1: for -lp and just one comma:
            # This is a no-brainer, just break at the comma.
            if (
                $is_lp_formatting      # -lp
                && $item_count == 2    # two items, one comma
                && !$must_break_open
              )
            {
                my $i_break = $rcomma_index->[0];
                $self->set_forced_breakpoint($i_break);
                ${$rdo_not_break_apart} = 1;
                return;

            }

            # Section B2B: Shortcut method 2 is for most small ragged lists
            # which might look best if not displayed as a table.
            if (
                ( $number_of_fields == 2 && $item_count == 3 )
                || (
                    $new_identifier_count > 0    # isn't all quotes
                    && $sparsity > 0.15
                )    # would be fairly spaced gaps if aligned
              )
            {

                my $break_count = $self->set_ragged_breakpoints( $ri_term_comma,
                    $ri_ragged_break_list );
                ++$break_count if ($use_separate_first_term);

                # NOTE: we should really use the true break count here,
                # which can be greater if there are large terms and
                # little space, but usually this will work well enough.
                if ( !$must_break_open ) {
                    if ( $break_count <= 1
                        || ( $is_lp_formatting && !$need_lp_break_open ) )
                    {
                        ${$rdo_not_break_apart} = 1;
                    }
                }
                return;
            }

        } ## end shortcut methods

        # debug stuff
        DEBUG_SPARSE && do {

            # How many spaces across the page will we fill?
            my $columns_per_line =
              int( $number_of_fields / 2 ) * $pair_width +
              ( $number_of_fields % 2 ) * $max_width;

            print {*STDOUT}
"SPARSE:cols=$columns commas=$comma_count items:$item_count ids=$identifier_count pairwidth=$pair_width fields=$number_of_fields lines packed: $packed_lines packed_cols=$packed_columns fmtd:$formatted_lines cols /line:$columns_per_line  unused:$unused_columns fmtd:$formatted_columns sparsity=$sparsity allow=$max_allowed_sparsity\n";

        };

        #------------------------------------------------------------------
        # Section B3: Compound List Rule 2:
        # If this list is too long for one line, and it is an item of a
        # larger list, then we must format it, regardless of sparsity
        # (ian.t).  One reason that we have to do this is to trigger
        # Compound List Rule 1, above, which causes breaks at all commas of
        # all outer lists.  In this way, the structure will be properly
        # displayed.
        #------------------------------------------------------------------

        # Decide if this list is too long for one line unless broken
        my $total_columns = table_columns_available($i_opening_paren);
        my $too_long      = $packed_columns > $total_columns;

        # For a paren list, include the length of the token just before the
        # '(' because this is likely a sub call, and we would have to
        # include the sub name on the same line as the list.  This is still
        # imprecise, but not too bad.  (steve.t)
        if ( !$too_long && $i_opening_paren > 0 && $opening_token eq '(' ) {

            $too_long = $self->excess_line_length( $i_opening_minus,
                $i_effective_last_comma + 1 ) > 0;
        }

        # TODO: For an item after a '=>', try to include the length of the
        # thing before the '=>'.  This is crude and should be improved by
        # actually looking back token by token.
        if ( !$too_long && $i_opening_paren > 0 && $list_type eq '=>' ) {
            my $i_opening_minus_test = $i_opening_paren - 4;
            if ( $i_opening_minus_test >= 0 ) {
                $too_long = $self->excess_line_length( $i_opening_minus_test,
                    $i_effective_last_comma + 1 ) > 0;
            }
        }

        # Always break lists contained in '[' and '{' if too long for 1 line,
        # and always break lists which are too long and part of a more complex
        # structure.
        my $must_break_open_container = $must_break_open
          || ( $too_long
            && ( $in_hierarchical_list || !$two_line_word_wrap_ok ) );

        #--------------------------------------------------------------------
        # Section B4: A table will work here. But do not attempt to align
        # columns if this is a tiny table or it would be too spaced.  It
        # seems that the more packed lines we have, the sparser the list that
        # can be allowed and still look ok.
        #--------------------------------------------------------------------

        if (   ( $formatted_lines < 3 && $packed_lines < $formatted_lines )
            || ( $formatted_lines < 2 )
            || ( $unused_columns > $max_allowed_sparsity * $formatted_columns )
          )
        {
            #----------------------------------------------------------------
            # Section B4A: too sparse: would not look good aligned in a table
            #----------------------------------------------------------------

            # use old breakpoints if this is a 'big' list
            if ( $packed_lines > 2 && $item_count > 10 ) {
                write_logfile_entry("List sparse: using old breakpoints\n");
                $self->copy_old_breakpoints( $i_first_comma, $i_last_comma );
            }

            # let the continuation logic handle it if 2 lines
            else {

                my $break_count = $self->set_ragged_breakpoints( $ri_term_comma,
                    $ri_ragged_break_list );
                ++$break_count if ($use_separate_first_term);

                if ( !$must_break_open_container ) {
                    if ( $break_count <= 1
                        || ( $is_lp_formatting && !$need_lp_break_open ) )
                    {
                        ${$rdo_not_break_apart} = 1;
                    }
                }
            }
            return;
        }

        #--------------------------------------------
        # Section B4B: Go ahead and format as a table
        #--------------------------------------------
        $self->write_formatted_table( $number_of_fields, $comma_count,
            $rcomma_index, $use_separate_first_term );

        return;
    } ## end sub break_multiline_list

    sub table_layout_A {

        my ($rhash_IN) = @_;

        # Find lengths of all list items needed to calculate page layout

        # Returns:
        #    - nothing if this list is empty, or
        #    - a ref to a hash containing some derived parameters

        my $i_opening_paren  = $rhash_IN->{i_opening_paren};
        my $i_closing_paren  = $rhash_IN->{i_closing_paren};
        my $identifier_count = $rhash_IN->{identifier_count};
        my $rcomma_index     = $rhash_IN->{rcomma_index};
        my $item_count       = $rhash_IN->{item_count};

        # nothing to do if no commas seen
        return if ( $item_count < 1 );

        my $i_first_comma     = $rcomma_index->[0];
        my $i_true_last_comma = $rcomma_index->[ $item_count - 1 ];
        my $i_last_comma      = $i_true_last_comma;
        if ( $i_last_comma >= $max_index_to_go ) {
            $item_count -= 1;
            return if ( $item_count < 1 );
            $i_last_comma = $rcomma_index->[ $item_count - 1 ];
        }

        my $comma_count = $item_count;

        my $ritem_lengths = [];
        my $ri_term_begin = [];
        my $ri_term_end   = [];
        my $ri_term_comma = [];

        my $rmax_length = [ 0, 0 ];

        my $i_prev_plus;
        my $first_term_length;
        my $i      = $i_opening_paren;
        my $is_odd = 1;

        foreach my $j ( 0 .. $comma_count - 1 ) {
            $is_odd      = 1 - $is_odd;
            $i_prev_plus = $i + 1;
            $i           = $rcomma_index->[$j];

            my $i_term_end =
              ( $i == 0 || $types_to_go[ $i - 1 ] eq 'b' )
              ? $i - 2
              : $i - 1;
            my $i_term_begin =
              ( $types_to_go[$i_prev_plus] eq 'b' )
              ? $i_prev_plus + 1
              : $i_prev_plus;
            push @{$ri_term_begin}, $i_term_begin;
            push @{$ri_term_end},   $i_term_end;
            push @{$ri_term_comma}, $i;

            # note: currently adding 2 to all lengths (for comma and space)
            my $length =
              2 + token_sequence_length( $i_term_begin, $i_term_end );
            push @{$ritem_lengths}, $length;

            if ( $j == 0 ) {
                $first_term_length = $length;
            }
            else {

                if ( $length > $rmax_length->[$is_odd] ) {
                    $rmax_length->[$is_odd] = $length;
                }
            }
        }

        # now we have to make a distinction between the comma count and item
        # count, because the item count will be one greater than the comma
        # count if the last item is not terminated with a comma
        my $i_b =
          ( $types_to_go[ $i_last_comma + 1 ] eq 'b' )
          ? $i_last_comma + 1
          : $i_last_comma;

        # NOTE: $i_closing_paren = $max_index_to_go+1 for a list which does
        # not end in a closing paren. So the following test works (c410)
        my $i_e =
          ( $types_to_go[ $i_closing_paren - 1 ] eq 'b' )
          ? $i_closing_paren - 2
          : $i_closing_paren - 1;
        my $i_effective_last_comma = $i_last_comma;

        my $last_item_length = token_sequence_length( $i_b + 1, $i_e );

        if ( $last_item_length > 0 ) {

            # add 2 to length because other lengths include a comma and a blank
            $last_item_length += 2;
            push @{$ritem_lengths}, $last_item_length;
            push @{$ri_term_begin}, $i_b + 1;
            push @{$ri_term_end},   $i_e;
            push @{$ri_term_comma}, undef;

            my $i_odd = $item_count % 2;

            if ( $last_item_length > $rmax_length->[$i_odd] ) {
                $rmax_length->[$i_odd] = $last_item_length;
            }

            $item_count++;
            $i_effective_last_comma = $i_e + 1;

            if ( $types_to_go[ $i_b + 1 ] =~ /^[iR\]]$/ ) {
                $identifier_count++;
            }
        }

        # be sure we do not extend beyond the current list length
        if ( $i_effective_last_comma >= $max_index_to_go ) {
            $i_effective_last_comma = $max_index_to_go - 1;
        }

        # Return the hash of derived variables.
        return {

            # Updated variables
            _item_count_A       => $item_count,
            _identifier_count_A => $identifier_count,

            # New variables
            _ritem_lengths          => $ritem_lengths,
            _ri_term_begin          => $ri_term_begin,
            _ri_term_end            => $ri_term_end,
            _ri_term_comma          => $ri_term_comma,
            _rmax_length            => $rmax_length,
            _comma_count            => $comma_count,
            _i_effective_last_comma => $i_effective_last_comma,
            _first_term_length      => $first_term_length,
            _i_first_comma          => $i_first_comma,
            _i_last_comma           => $i_last_comma,
            _i_true_last_comma      => $i_true_last_comma,
        };

    } ## end sub table_layout_A

    sub table_layout_B {

        my ( $self, $rhash_IN, $rhash_A, $is_lp_formatting ) = @_;

        # Determine variables for the best table layout, including
        # the best number of fields.

        # Returns:
        #    - nothing if nothing more to do
        #    - a ref to a hash containing some derived parameters

        # Variables from caller
        my $i_opening_paren     = $rhash_IN->{i_opening_paren};
        my $list_type           = $rhash_IN->{list_type};
        my $next_nonblank_type  = $rhash_IN->{next_nonblank_type};
        my $rcomma_index        = $rhash_IN->{rcomma_index};
        my $rdo_not_break_apart = $rhash_IN->{rdo_not_break_apart};

        # Table size variables
        my $comma_count            = $rhash_A->{_comma_count};
        my $first_term_length      = $rhash_A->{_first_term_length};
        my $i_effective_last_comma = $rhash_A->{_i_effective_last_comma};
        my $i_first_comma          = $rhash_A->{_i_first_comma};
        my $identifier_count       = $rhash_A->{_identifier_count_A};
        my $item_count             = $rhash_A->{_item_count_A};
        my $ri_term_begin          = $rhash_A->{_ri_term_begin};
        my $ri_term_comma          = $rhash_A->{_ri_term_comma};
        my $ri_term_end            = $rhash_A->{_ri_term_end};
        my $ritem_lengths          = $rhash_A->{_ritem_lengths};
        my $rmax_length            = $rhash_A->{_rmax_length};

        # Specify if the list must have an even number of fields or not.
        # It is generally safest to assume an even number, because the
        # list items might be a hash list.  But if we can be sure that
        # it is not a hash, then we can allow an odd number for more
        # flexibility.
        # 1 = odd field count ok, 2 = want even count
        my $odd_or_even = 2;
        if (
               $identifier_count >= $item_count - 1
            || $is_assignment{$next_nonblank_type}
            || (   $list_type
                && $list_type ne '=>'
                && $list_type !~ /^[\:\?]$/ )
          )
        {
            $odd_or_even = 1;
        }

        # do we have a long first term which should be
        # left on a line by itself?
        my $use_separate_first_term = (
            $odd_or_even == 1              # only if we can use 1 field/line
              && $item_count > 3           # need several items
              && $first_term_length >
              2 * $rmax_length->[0] - 2    # need long first term
              && $first_term_length >
              2 * $rmax_length->[1] - 2    # need long first term
        );

        # or do we know from the type of list that the first term should
        # be placed alone?
        if ( !$use_separate_first_term ) {
            if ( $is_keyword_with_special_leading_term{$list_type} ) {
                $use_separate_first_term = 1;

                # should the container be broken open?
                if ( $item_count < 3 ) {
                    if ( $i_first_comma - $i_opening_paren < 4 ) {
                        ${$rdo_not_break_apart} = 1;
                    }
                }
                elsif ($first_term_length < 20
                    && $i_first_comma - $i_opening_paren < 4 )
                {
                    my $columns = table_columns_available($i_first_comma);
                    if ( $first_term_length < $columns ) {
                        ${$rdo_not_break_apart} = 1;
                    }
                }
                else {
                    # break
                }
            }
        }

        # if so,
        if ($use_separate_first_term) {

            # ..set a break and update starting values
            $self->set_forced_breakpoint($i_first_comma);
            $item_count--;

            #---------------------------------------------------------------
            # Section B1A: Stop if one item remains ($i_first_comma = undef)
            #---------------------------------------------------------------
            # Fix for b1442: use '$item_count' here instead of '$comma_count'
            # to make the result independent of any trailing comma.
            return if ( $item_count <= 1 );

            $i_opening_paren = $i_first_comma;
            $i_first_comma   = $rcomma_index->[1];
            shift @{$ritem_lengths};
            shift @{$ri_term_begin};
            shift @{$ri_term_end};
            shift @{$ri_term_comma};
        }

        # if not, update the metrics to include the first term
        else {
            if ( $first_term_length > $rmax_length->[0] ) {
                $rmax_length->[0] = $first_term_length;
            }
        }

        # Field width parameters
        my $pair_width = ( $rmax_length->[0] + $rmax_length->[1] );
        my $max_width =
          ( $rmax_length->[0] > $rmax_length->[1] )
          ? $rmax_length->[0]
          : $rmax_length->[1];

        # Number of free columns across the page width for laying out tables
        my $columns = table_columns_available($i_first_comma);

        # Patch for b1210 and b1216-b1218 when -vmll is set.  If we are unable
        # to break after an opening paren, then the maximum line length for the
        # first line could be less than the later lines.  So we need to reduce
        # the line length.  Normally, we will get a break after an opening
        # paren, but in some cases we might not.
        if (   $rOpts_variable_maximum_line_length
            && $tokens_to_go[$i_opening_paren] eq '('
            && @{$ri_term_begin} )
        {
            my $ib   = $ri_term_begin->[0];
            my $type = $types_to_go[$ib];

            # So far, the only known instance of this problem is when
            # a bareword follows an opening paren with -vmll
            if ( $type eq 'w' ) {

                # If a line starts with paren+space+terms, then its max length
                # could be up to ci+2-i spaces less than if the term went out
                # on a line after the paren.  So..
                my $tol_w = max( 0,
                    2 + $rOpts_continuation_indentation -
                      $rOpts_indent_columns );
                $columns = max( 0, $columns - $tol_w );

                ## Here is the original b1210 fix, but it failed on b1216-b1218
                ##my $columns2 = table_columns_available($i_opening_paren);
                ##$columns = min( $columns, $columns2 );
            }
        }

        # Estimated maximum number of fields which fit this space.
        # This will be our first guess:
        my $number_of_fields_max =
          maximum_number_of_fields( $columns, $odd_or_even, $max_width,
            $pair_width );
        my $number_of_fields = $number_of_fields_max;

        # Find the best-looking number of fields.
        # This will be our second guess, if possible.
        my ( $number_of_fields_best, $ri_ragged_break_list,
            $new_identifier_count )
          = $self->study_list_complexity( $ri_term_begin, $ri_term_end,
            $ritem_lengths, $max_width );

        if (   $number_of_fields_best != 0
            && $number_of_fields_best < $number_of_fields_max )
        {
            $number_of_fields = $number_of_fields_best;
        }

        # fix b1427
        elsif ($number_of_fields_best > 1
            && $number_of_fields_best > $number_of_fields_max )
        {
            $number_of_fields_best = $number_of_fields_max;
        }
        else {
            # no change
        }

        # If we are crowded and the -lp option is being used, try
        # to undo some indentation
        if (
            $is_lp_formatting
            && (
                $number_of_fields == 0
                || (   $number_of_fields == 1
                    && $number_of_fields != $number_of_fields_best )
            )
          )
        {
            ( $number_of_fields, $number_of_fields_best, $columns ) =
              $self->lp_table_fix(
                {
                    columns               => $columns,
                    i_first_comma         => $i_first_comma,
                    max_width             => $max_width,
                    number_of_fields      => $number_of_fields,
                    number_of_fields_best => $number_of_fields_best,
                    odd_or_even           => $odd_or_even,
                    pair_width            => $pair_width,
                    ritem_lengths         => $ritem_lengths,
                }
              );
        }

        # try for one column if two won't work
        if ( $number_of_fields <= 0 ) {
            $number_of_fields = int( $columns / $max_width );
        }

        # The user can place an upper bound on the number of fields,
        # which can be useful for doing maintenance on tables
        if (   $rOpts_maximum_fields_per_table
            && $number_of_fields > $rOpts_maximum_fields_per_table )
        {
            $number_of_fields = $rOpts_maximum_fields_per_table;
        }

        # How many columns (characters) and lines would this container take
        # if no additional whitespace were added?
        my $packed_columns = token_sequence_length( $i_opening_paren + 1,
            $i_effective_last_comma + 1 );
        if ( $columns <= 0 ) { $columns = 1 }    # avoid divide by zero
        my $packed_lines = 1 + int( $packed_columns / $columns );

        #-----------------------------------------------------------------
        # Section B1B: Stop here if we did not compute a positive number of
        # fields. In this case we just have to bail out.
        #-----------------------------------------------------------------
        if ( $number_of_fields <= 0 ) {

            $self->set_emergency_comma_breakpoints(

                $number_of_fields_best,
                $rhash_IN,
                $comma_count,
                $i_first_comma,

            );
            return;
        }

        #------------------------------------------------------------------
        # Section B1B: We have a tentative field count that seems to work.
        # Now we must look more closely to determine if a table layout will
        # actually look okay.
        #------------------------------------------------------------------

        # How many lines will this require?
        my $formatted_lines = $item_count / $number_of_fields;
        if ( $formatted_lines != int($formatted_lines) ) {
            $formatted_lines = 1 + int($formatted_lines);
        }

        # So far we've been trying to fill out to the right margin.  But
        # compact tables are easier to read, so let's see if we can use fewer
        # fields without increasing the number of lines.
        $number_of_fields = compactify_table( $item_count, $number_of_fields,
            $formatted_lines, $odd_or_even );

        my $formatted_columns;

        if ( $number_of_fields > 1 ) {
            $formatted_columns =
              ( $pair_width * ( int( $item_count / 2 ) ) +
                  ( $item_count % 2 ) * $max_width );
        }
        else {
            $formatted_columns = $max_width * $item_count;
        }
        if ( $formatted_columns < $packed_columns ) {
            $formatted_columns = $packed_columns;
        }

        # Construce hash_B:
        return {

            # Updated variables
            _i_first_comma_B   => $i_first_comma,
            _i_opening_paren_B => $i_opening_paren,
            _item_count_B      => $item_count,

            # New variables
            _columns                 => $columns,
            _formatted_columns       => $formatted_columns,
            _formatted_lines         => $formatted_lines,
            _max_width               => $max_width,
            _new_identifier_count    => $new_identifier_count,
            _number_of_fields        => $number_of_fields,
            _odd_or_even             => $odd_or_even,
            _packed_columns          => $packed_columns,
            _packed_lines            => $packed_lines,
            _pair_width              => $pair_width,
            _ri_ragged_break_list    => $ri_ragged_break_list,
            _use_separate_first_term => $use_separate_first_term,
        };
    } ## end sub table_layout_B

    sub lp_table_fix {

        # try to undo some -lp indentation to improve table formatting

        my ( $self, $rcall_hash ) = @_;

        my $columns               = $rcall_hash->{columns};
        my $i_first_comma         = $rcall_hash->{i_first_comma};
        my $max_width             = $rcall_hash->{max_width};
        my $number_of_fields      = $rcall_hash->{number_of_fields};
        my $number_of_fields_best = $rcall_hash->{number_of_fields_best};
        my $odd_or_even           = $rcall_hash->{odd_or_even};
        my $pair_width            = $rcall_hash->{pair_width};
        my $ritem_lengths         = $rcall_hash->{ritem_lengths};

        my $available_spaces =
          $self->get_available_spaces_to_go($i_first_comma);
        if ( $available_spaces > 0 ) {

            my $spaces_wanted = $max_width - $columns;    # for 1 field

            if ( $number_of_fields_best == 0 ) {
                $number_of_fields_best =
                  get_maximum_fields_wanted($ritem_lengths);
            }

            if ( $number_of_fields_best != 1 ) {
                my $spaces_wanted_2 = 1 + $pair_width - $columns; # for 2 fields
                if ( $available_spaces > $spaces_wanted_2 ) {
                    $spaces_wanted = $spaces_wanted_2;
                }
            }

            if ( $spaces_wanted > 0 ) {
                my $deleted_spaces =
                  $self->reduce_lp_indentation( $i_first_comma,
                    $spaces_wanted );

                # redo the math
                if ( $deleted_spaces > 0 ) {
                    $columns = table_columns_available($i_first_comma);
                    $number_of_fields =
                      maximum_number_of_fields( $columns, $odd_or_even,
                        $max_width, $pair_width );

                    if (   $number_of_fields_best == 1
                        && $number_of_fields >= 1 )
                    {
                        $number_of_fields = $number_of_fields_best;
                    }
                }
            }
        }
        return ( $number_of_fields, $number_of_fields_best, $columns );
    } ## end sub lp_table_fix

    sub write_formatted_table {

        # Write a table of comma separated items with fixed number of fields
        my ( $self, $number_of_fields, $comma_count, $rcomma_index,
            $use_separate_first_term )
          = @_;

        write_logfile_entry(
            "List: auto formatting with $number_of_fields fields/row\n");

        if ( $number_of_fields < 1 ) {
            ## shouldn't happen - caller passed bad parameter
            DEVEL_MODE && Fault("bad number of fields=$number_of_fields\n");
            return;
        }

        my $j_first_break =
            $use_separate_first_term
          ? $number_of_fields
          : $number_of_fields - 1;

        my $j = $j_first_break;
        while ( $j < $comma_count ) {
            my $i_comma = $rcomma_index->[$j];
            $self->set_forced_breakpoint($i_comma);
            $j += $number_of_fields;
        }
        return;
    } ## end sub write_formatted_table

} ## end closure set_comma_breakpoint_final

sub study_list_complexity {

    my ( $self, $ri_term_begin, $ri_term_end, $ritem_lengths, $max_width ) = @_;

    # Look for complex tables which should be formatted with one term per line.
    # Returns the following:
    #
    #  \@i_ragged_break_list = list of good breakpoints to avoid lines
    #    which are hard to read
    #  $number_of_fields_best = suggested number of fields based on
    #    complexity; = 0 if any number may be used.
    #
    my $item_count            = @{$ri_term_begin};
    my $complex_item_count    = 0;
    my $number_of_fields_best = $rOpts_maximum_fields_per_table;
    my $i_max                 = @{$ritem_lengths} - 1;

    my $i_last_last_break = -3;
    my $i_last_break      = -2;
    my @i_ragged_break_list;

    my $definitely_complex = 30;
    my $definitely_simple  = 12;
    my $quote_count        = 0;

    for my $i ( 0 .. $i_max ) {
        my $ib = $ri_term_begin->[$i];
        my $ie = $ri_term_end->[$i];

        # define complexity: start with the actual term length
        my $weighted_length = ( $ritem_lengths->[$i] - 2 );

        ##TBD: join types here and check for variations
        ##my $str=join "", @tokens_to_go[$ib..$ie];

        my $is_quote = 0;
        if ( $types_to_go[$ib] =~ /^[qQ]$/ ) {
            $is_quote = 1;
            $quote_count++;
        }
        elsif ( $types_to_go[$ib] =~ /^[w\-]$/ ) {
            $quote_count++;
        }
        else {
            # not a quote
        }

        if ( $ib eq $ie ) {
            if ( $is_quote && $tokens_to_go[$ib] =~ /\s/ ) {
                $complex_item_count++;
                $weighted_length *= 2;
            }
            else {
            }
        }
        else {
            if ( first { $_ eq 'b' } @types_to_go[ $ib .. $ie ] ) {
                $complex_item_count++;
                $weighted_length *= 2;
            }
            if ( first { $_ eq '..' } @types_to_go[ $ib .. $ie ] ) {
                $weighted_length += 4;
            }
        }

        # add weight for extra tokens.
        $weighted_length += 2 * ( $ie - $ib );

        # mark a ragged break after this item it if it is 'long and complex':
        if ( $weighted_length >= $definitely_complex ) {

            # if we broke after the previous term
            # then break before it too
            if (   $i_last_break == $i - 1
                && $i > 1
                && $i_last_last_break != $i - 2 )
            {

                ## TODO: don't strand a small term
                pop @i_ragged_break_list;
                push @i_ragged_break_list, $i - 2;
                push @i_ragged_break_list, $i - 1;
            }

            push @i_ragged_break_list, $i;
            $i_last_last_break = $i_last_break;
            $i_last_break      = $i;
        }

        # don't break before a small last term -- it will
        # not look good on a line by itself.
        elsif ($i == $i_max
            && $i_last_break == $i - 1
            && $weighted_length <= $definitely_simple )
        {
            pop @i_ragged_break_list;
        }
        else {
            # ok as is
        }
    }

    my $identifier_count = $i_max + 1 - $quote_count;

    # Need more tuning here..
    if (   $max_width > 12
        && $complex_item_count > $item_count / 2
        && $number_of_fields_best != 2 )
    {
        $number_of_fields_best = 1;
    }

    return ( $number_of_fields_best, \@i_ragged_break_list, $identifier_count );
} ## end sub study_list_complexity

sub get_maximum_fields_wanted {

    my ($ritem_lengths) = @_;

    # Not all tables look good with more than one field of items.
    # This routine looks at a table and decides if it should be
    # formatted with just one field or not.
    # This coding is still under development.
    my $number_of_fields_best = 0;

    # For just a few items, we tentatively assume just 1 field.
    my $item_count = @{$ritem_lengths};
    if ( $item_count <= 5 ) {
        $number_of_fields_best = 1;
    }

    # For larger tables, look at it both ways and see what looks best
    else {

        my $is_odd            = 1;
        my @max_length        = ( 0,     0 );
        my @last_length_2     = ( undef, undef );
        my @first_length_2    = ( undef, undef );
        my $last_length       = undef;
        my $total_variation_1 = 0;
        my $total_variation_2 = 0;

        my @total_variation_2_sums = ( 0, 0 );

        foreach my $j ( 0 .. $item_count - 1 ) {

            $is_odd = 1 - $is_odd;
            my $length = $ritem_lengths->[$j];
            if ( $length > $max_length[$is_odd] ) {
                $max_length[$is_odd] = $length;
            }

            if ( defined($last_length) ) {
                my $dl = abs( $length - $last_length );
                $total_variation_1 += $dl;
            }
            $last_length = $length;

            my $ll = $last_length_2[$is_odd];
            if ( defined($ll) ) {
                my $dl = abs( $length - $ll );
                $total_variation_2_sums[$is_odd] += $dl;
            }
            else {
                $first_length_2[$is_odd] = $length;
            }
            $last_length_2[$is_odd] = $length;
        }
        $total_variation_2 =
          $total_variation_2_sums[0] + $total_variation_2_sums[1];

        my $factor = ( $item_count > 10 ) ? 1 : ( $item_count > 5 ) ? 0.75 : 0;
        if ( $total_variation_2 >= $factor * $total_variation_1 ) {
            $number_of_fields_best = 1;
        }
    }
    return ($number_of_fields_best);
} ## end sub get_maximum_fields_wanted

sub table_columns_available {
    my $i_first_comma = shift;
    my $columns =
      $maximum_line_length_at_level[ $levels_to_go[$i_first_comma] ] -
      leading_spaces_to_go($i_first_comma);

    # Patch: the vertical formatter does not line up lines whose lengths
    # exactly equal the available line length because of allowances
    # that must be made for side comments.  Therefore, the number of
    # available columns is reduced by 1 character.
    $columns -= 1;
    return $columns;
} ## end sub table_columns_available

sub maximum_number_of_fields {

    # how many fields will fit in the available space?
    my ( $columns, $odd_or_even, $max_width, $pair_width ) = @_;
    my $max_pairs        = int( $columns / $pair_width );
    my $number_of_fields = $max_pairs * 2;
    if (   $odd_or_even == 1
        && $max_pairs * $pair_width + $max_width <= $columns )
    {
        $number_of_fields++;
    }
    return $number_of_fields;
} ## end sub maximum_number_of_fields

sub compactify_table {

    my ( $item_count, $number_of_fields, $formatted_lines, $odd_or_even ) = @_;

    # For a table with a certain number of fields and a certain number
    # of lines, see if reducing the number of fields will make it look
    # better.

    # Given:
    #  $item_count = count of list items
    #  $number_of_fields = current number of items per line
    #  $formatted_lines = number of lines this will require
    #  $odd_or_even =  1=>odd field count is ok, 2=>want even count

    # Return:
    #  $number_of_fields = updated number of items per line

    if ( $number_of_fields >= $odd_or_even * 2 && $formatted_lines > 0 ) {

        my $min_fields = $number_of_fields;

        if ( $odd_or_even < 1 ) {
            ## shouldn't happen - caller passed bad parameter
            DEVEL_MODE && Fault("bad value for odd_or_even=$odd_or_even\n");
            return $number_of_fields;
        }

        while ($min_fields >= $odd_or_even
            && $min_fields * $formatted_lines >= $item_count )
        {
            $number_of_fields = $min_fields;
            $min_fields -= $odd_or_even;
        } ## end while ( $min_fields >= $odd_or_even...)
    }
    return $number_of_fields;
} ## end sub compactify_table

sub set_ragged_breakpoints {

    my ( $self, $ri_term_comma, $ri_ragged_break_list ) = @_;

    # Set breakpoints in a list that cannot be formatted nicely as a table.

    my $break_count = 0;
    foreach ( @{$ri_ragged_break_list} ) {
        my $j = $ri_term_comma->[$_];
        if ($j) {
            $self->set_forced_breakpoint($j);
            $break_count++;
        }
    }
    return $break_count;
} ## end sub set_ragged_breakpoints

sub copy_old_breakpoints {
    my ( $self, $i_first_comma, $i_last_comma ) = @_;

    # We are formatting a list and have decided to make comma breaks
    # the same as in the input file.

    # If the comma style is under certain controls, and if this is a
    # comma breakpoint with the comma at the beginning of the next
    # line, then we must pass that index instead. This will allow sub
    # set_forced_breakpoints to check and follow the user settings. This
    # produces a uniform style and can prevent instability (b1422).
    #
    # The flag '$controlled_comma_style' will be set if the user
    # entered any of -wbb=',' -wba=',' -kbb=',' -kba=','.  It is not
    # set for the -boc flag, but we will need to treat -boc in the
    # same way for lists with breaks both before and after commas to
    # avoid excess iterations.

    my @i_old_breaks;
    for my $i ( $i_first_comma .. $i_last_comma ) {
        if ( $old_breakpoint_to_go[$i] ) {
            push @i_old_breaks, $i;
        }
    }

    # just copy old breakpoints unless $controlled_comma_style or -boc
    if (   !$controlled_comma_style
        && !$rOpts_break_at_old_comma_breakpoints )
    {
        foreach my $ii (@i_old_breaks) {
            $self->set_forced_breakpoint($ii);
        }
        return;
    }

    # Scan for commas before and after the old breakpoints...
    my @i_breaks;
    my $num_after;
    my $num_before;
    foreach my $i (@i_old_breaks) {
        my $i_break = $i;
        if ( $types_to_go[$i_break] ne ',' ) {
            my $index = $inext_to_go[$i_break];
            if ( $index > $i_break && $types_to_go[$index] eq ',' ) {
                $i_break = $index;
                $num_before++;
            }
        }
        else { $num_after++; }
        push @i_breaks, $i_break;
    }

    # -boc by itself can use old breaks except when there are mixed
    # leading and trailing commas. In that case excess iterations
    # can occur (see b878)
    if (  !$controlled_comma_style
        && $rOpts_break_at_old_comma_breakpoints )
    {

        my $mixed = $num_before && $num_after;
        if ( !$mixed ) {
            @i_breaks = @i_old_breaks;
        }
    }

    foreach my $ii (@i_breaks) {
        $self->set_forced_breakpoint($ii);
    }

    return;
} ## end sub copy_old_breakpoints

sub set_nobreaks {
    my ( $self, $i, $j ) = @_;

    # Given:
    #   $i = starting index in _to_go arrays
    #   $j = ending index in _to_go arrays
    # Task:
    #   set nobreak_to_go for index range $i .. $j
    if ( $i >= 0 && $i <= $j && $j <= $max_index_to_go ) {

        0 && do {
            my ( $pkg, $file_uu, $lno ) = caller();
            print {*STDOUT}
"NOBREAK: forced_breakpoint $forced_breakpoint_count from $pkg $lno with i=$i max=$max_index_to_go type=$types_to_go[$i]\n";
        };

        @nobreak_to_go[ $i .. $j ] = (1) x ( $j - $i + 1 );
    }

    # shouldn't happen; non-critical error
    else {
        if (DEVEL_MODE) {
            my ( $pkg, $file_uu, $lno ) = caller();
            Fault(<<EOM);
NOBREAK ERROR: from $pkg $lno with i=$i j=$j max=$max_index_to_go
EOM
        }
    }
    return;
} ## end sub set_nobreaks

###############################################
# CODE SECTION 12: Code for setting indentation
###############################################

sub token_sequence_length {

    # return length of tokens ($ibeg .. $iend) including $ibeg & $iend
    my ( $ibeg, $iend ) = @_;

    # fix possible negative starting index
    if ( $ibeg < 0 ) { $ibeg = 0 }

    # returns 0 if index range is empty (some subs assume this)
    if ( $ibeg > $iend ) {
        return 0;
    }

    return $summed_lengths_to_go[ $iend + 1 ] - $summed_lengths_to_go[$ibeg];
} ## end sub token_sequence_length

sub total_line_length {

    # return length of a line of tokens ($ibeg .. $iend)
    my ( $ibeg, $iend ) = @_;

    # get the leading spaces on this line ...
    my $spaces = $leading_spaces_to_go[$ibeg];
    if ( ref($spaces) ) { $spaces = $spaces->get_spaces() }

    # ... then add the net token length
    return $spaces + $summed_lengths_to_go[ $iend + 1 ] -
      $summed_lengths_to_go[$ibeg];

} ## end sub total_line_length

sub excess_line_length {

    my ( $self, $ibeg, $iend, ($ignore_right_weld) ) = @_;

    # Return number of characters by which a line of tokens ($ibeg..$iend)
    # exceeds the allowable line length.
    # Given:
    #   $ibeg, $iend = range of indexes of this line in the _to_go arrays
    #   $ignore_right_weld = optional flag = true to exclude any right weld
    # NOTE: profiling shows that efficiency of this routine is essential.

    # Start with the leading spaces on this line ...
    my $excess = $leading_spaces_to_go[$ibeg];
    if ( ref($excess) ) { $excess = $excess->get_spaces() }

    # ... and include right weld lengths unless requested not to
    if (   $total_weld_count
        && $type_sequence_to_go[$iend]
        && !$ignore_right_weld )
    {
        my $wr = $self->[_rweld_len_right_at_K_]->{ $K_to_go[$iend] };
        $excess += $wr if defined($wr);
    }

    # ... then add the net token length, minus the maximum length
    return $excess +
      $summed_lengths_to_go[ $iend + 1 ] -
      $summed_lengths_to_go[$ibeg] -
      $maximum_line_length_at_level[ $levels_to_go[$ibeg] ];

} ## end sub excess_line_length

sub get_spaces {

    # return the number of leading spaces associated with an indentation
    # variable $indentation is either a constant number of spaces or an object
    # with a get_spaces method.
    my $indentation = shift;
    return ref($indentation) ? $indentation->get_spaces() : $indentation;
} ## end sub get_spaces

sub get_recoverable_spaces {

    # return the number of spaces (+ means shift right, - means shift left)
    # that we would like to shift a group of lines with the same indentation
    # to get them to line up with their opening parens
    my $indentation = shift;
    return ref($indentation) ? $indentation->get_recoverable_spaces() : 0;
} ## end sub get_recoverable_spaces

sub get_available_spaces_to_go {

    my ( $self, $ii ) = @_;
    my $item = $leading_spaces_to_go[$ii];

    # return the number of available leading spaces associated with an
    # indentation variable.  $indentation is either a constant number of
    # spaces or an object with a get_available_spaces method.
    return ref($item) ? $item->get_available_spaces() : 0;
} ## end sub get_available_spaces_to_go

{    ## begin closure set_lp_indentation

    use constant DEBUG_LP => 0;

    # Stack of -lp index objects which survives between batches.
    my $rLP;
    my $max_lp_stack;

    # The predicted position of the next opening container which may start
    # an -lp indentation level.  This survives between batches.
    my $lp_position_predictor;

    BEGIN {

        # Index names for the -lp stack variables.
        # Do not combine with other BEGIN blocks (c101).

        my $i = 0;
        use constant {
            _lp_ci_level_        => $i++,
            _lp_level_           => $i++,
            _lp_object_          => $i++,
            _lp_container_seqno_ => $i++,
            _lp_space_count_     => $i++,
        };
    } ## end BEGIN

    sub initialize_lp_vars {

        # initialize gnu variables for a new file;
        # must be called once at the start of a new file.

        $lp_position_predictor = 0;
        $max_lp_stack          = 0;

        # we can turn off -lp if all levels will be at or above the cutoff
        if ( $high_stress_level <= 1 ) {
            $rOpts_line_up_parentheses          = 0;
            $rOpts_extended_line_up_parentheses = 0;
        }

        # fix for b1459: -naws adds stress for -xlp
        if ( $high_stress_level <= 2 && !$rOpts_add_whitespace ) {
            $rOpts_extended_line_up_parentheses = 0;
        }

        # fix for b1465: -vmll adds stress for -xlp
        if ( $high_stress_level <= 2 && $rOpts_variable_maximum_line_length ) {
            $rOpts_extended_line_up_parentheses = 0;
        }

        $rLP = [];

        # initialize the leading whitespace stack to negative levels
        # so that we can never run off the end of the stack
        $rLP->[$max_lp_stack]->[_lp_ci_level_]        = -1;
        $rLP->[$max_lp_stack]->[_lp_level_]           = -1;
        $rLP->[$max_lp_stack]->[_lp_object_]          = undef;
        $rLP->[$max_lp_stack]->[_lp_container_seqno_] = SEQ_ROOT;
        $rLP->[$max_lp_stack]->[_lp_space_count_]     = 0;

        return;
    } ## end sub initialize_lp_vars

    # hashes for efficient testing
    my %hash_test1;
    my %hash_test2;
    my %hash_test3;

    BEGIN {
        my @q = qw< } ) ] >;
        @hash_test1{@q} = (1) x scalar(@q);
        @q = qw( : ? f );
        push @q, ',';
        @hash_test2{@q} = (1) x scalar(@q);
        @q              = qw( . || && );
        @hash_test3{@q} = (1) x scalar(@q);
    } ## end BEGIN

    # shared variables, re-initialized for each batch
    my $rlp_object_list;
    my $max_lp_object_list;
    my %lp_comma_count;
    my %lp_arrow_count;
    my $space_count;
    my $current_level;
    my $current_ci_level;
    my $ii_begin_line;
    my $in_lp_mode;
    my $stack_changed;
    my $K_last_nonblank;
    my $last_nonblank_token;
    my $last_nonblank_type;
    my $last_last_nonblank_type;

    sub set_lp_indentation {

        my ($self) = @_;

        # Define the leading whitespace for all tokens in the current batch
        # when the -lp formatting is selected.

        # Returns number of tokens in this batch which have leading spaces
        # defined by an lp object:
        my $lp_object_count_this_batch = 0;

        # Safety check: this should not be called when there is nothing to do
        if (   !$rOpts_line_up_parentheses
            || !defined($max_index_to_go)
            || $max_index_to_go < 0 )
        {
            my $lp_str =
              defined($rOpts_line_up_parentheses)
              ? $rOpts_line_up_parentheses
              : 'undef';
            my $max_str =
              defined($max_index_to_go) ? $max_index_to_go : 'undef';
            DEVEL_MODE
              && Fault(
"should not be here with -lp=$lp_str -max_index_to_go=$max_str\n"
              );
            return $lp_object_count_this_batch;
        }

        # List of -lp indentation objects created in this batch
        $rlp_object_list    = [];
        $max_lp_object_list = -1;

        %lp_comma_count          = ();
        %lp_arrow_count          = ();
        $space_count             = undef;
        $current_level           = undef;
        $current_ci_level        = undef;
        $ii_begin_line           = 0;
        $in_lp_mode              = 0;
        $stack_changed           = 1;
        $K_last_nonblank         = undef;
        $last_nonblank_token     = EMPTY_STRING;
        $last_nonblank_type      = EMPTY_STRING;
        $last_last_nonblank_type = EMPTY_STRING;

        my %last_lp_equals = ();

        my $rLL        = $self->[_rLL_];
        my $this_batch = $self->[_this_batch_];

        my $starting_in_quote = $this_batch->[_starting_in_quote_];

        my $imin = 0;

        # The 'starting_in_quote' flag means that the first token is the first
        # token of a line and it is also the continuation of some kind of
        # multi-line quote or pattern.  It must have no added leading
        # whitespace, so we can skip it.
        if ($starting_in_quote) {
            $imin += 1;
        }

        my $Kpnb = $K_to_go[0] - 1;
        if ( $Kpnb > 0 && $rLL->[$Kpnb]->[_TYPE_] eq 'b' ) {
            $Kpnb -= 1;
        }
        if ( $Kpnb >= 0 && $rLL->[$Kpnb]->[_TYPE_] ne 'b' ) {
            $K_last_nonblank = $Kpnb;
        }

        if ( defined($K_last_nonblank) ) {
            $last_nonblank_token = $rLL->[$K_last_nonblank]->[_TOKEN_];
            $last_nonblank_type  = $rLL->[$K_last_nonblank]->[_TYPE_];
        }

        #-----------------------------------
        # Loop over all tokens in this batch
        #-----------------------------------
        foreach my $ii ( $imin .. $max_index_to_go ) {

            my $type        = $types_to_go[$ii];
            my $token       = $tokens_to_go[$ii];
            my $level       = $levels_to_go[$ii];
            my $ci_level    = $ci_levels_to_go[$ii];
            my $total_depth = $nesting_depth_to_go[$ii];

            # get the top state from the stack if it has changed
            if ($stack_changed) {
                my $rLP_top   = $rLP->[$max_lp_stack];
                my $lp_object = $rLP_top->[_lp_object_];
                if ($lp_object) {
                    ( $space_count, $current_level, $current_ci_level ) =
                      @{ $lp_object->get_spaces_level_ci() };
                }
                else {
                    $current_ci_level = $rLP_top->[_lp_ci_level_];
                    $current_level    = $rLP_top->[_lp_level_];
                    $space_count      = $rLP_top->[_lp_space_count_];
                }
                $stack_changed = 0;
            }

            #------------------------------------------------------------
            # Break at a previous '=' if necessary to control line length
            #------------------------------------------------------------
            if ( $type eq '{' || $type eq '(' ) {
                $lp_comma_count{ $total_depth + 1 } = 0;
                $lp_arrow_count{ $total_depth + 1 } = 0;

                # If we come to an opening token after an '=' token of some
                # type, see if it would be helpful to 'break' after the '=' to
                # save space
                my $ii_last_equals = $last_lp_equals{$total_depth};
                if ($ii_last_equals) {
                    $self->lp_equals_break_check( $ii, $ii_last_equals );
                }
            }

            #------------------------
            # Handle decreasing depth
            #------------------------
            # Note that one token may have both decreasing and then increasing
            # depth. For example, (level, ci) can go from (1,1) to (2,0).  So,
            # in this example we would first go back to (1,0) then up to (2,0)
            # in a single call.
            if ( $level < $current_level || $ci_level < $current_ci_level ) {
                $self->lp_decreasing_depth($ii);
            }

            #------------------------
            # handle increasing depth
            #------------------------
            if ( $level > $current_level || $ci_level > $current_ci_level ) {
                $self->lp_increasing_depth($ii);
            }

            #------------------
            # Handle all tokens
            #------------------
            if ( $type ne 'b' ) {

                # Count commas and look for non-list characters.  Once we see a
                # non-list character, we give up and don't look for any more
                # commas.
                if ( $type eq '=>' ) {
                    $lp_arrow_count{$total_depth}++;

                    # remember '=>' like '=' for estimating breaks (but see
                    # above note for b1035)
                    $last_lp_equals{$total_depth} = $ii;
                }

                elsif ( $type eq ',' ) {
                    $lp_comma_count{$total_depth}++;
                }

                elsif ( $is_assignment{$type} ) {
                    $last_lp_equals{$total_depth} = $ii;
                }
                else {
                    ## not a special type
                }

                # this token might start a new line if ..
                if (
                    $ii > $ii_begin_line

                    && (

                        # this is the first nonblank token of the line
                        $ii == 1 && $types_to_go[0] eq 'b'

                        # or previous character was one of these:
                        #  /^([\:\?\,f])$/
                        || $hash_test2{$last_nonblank_type}

                        # or previous character was opening and this is not
                        # closing
                        || ( $last_nonblank_type eq '{' && $type ne '}' )
                        || ( $last_nonblank_type eq '(' and $type ne ')' )

                        # or this token is one of these:
                        #  /^([\.]|\|\||\&\&)$/
                        || $hash_test3{$type}

                        # or this is a closing structure
                        || (   $last_nonblank_type eq '}'
                            && $last_nonblank_token eq $last_nonblank_type )

                        # or previous token was keyword 'return'
                        || (
                            $last_nonblank_type eq 'k'
                            && (   $last_nonblank_token eq 'return'
                                && $type ne '{' )
                        )

                        # or starting a new line at certain keywords is fine
                        || ( $type eq 'k'
                            && $is_if_unless_and_or_last_next_redo_return{
                                $token} )

                        # or this is after an assignment after a closing
                        # structure
                        || (
                            $is_assignment{$last_nonblank_type}
                            && (
                                # /^[\}\)\]]$/
                                $hash_test1{$last_last_nonblank_type}

                                # and it is significantly to the right
                                || $lp_position_predictor > (
                                    $maximum_line_length_at_level[$level] -
                                      $rOpts_maximum_line_length / 2
                                )
                            )
                        )
                    )
                  )
                {
                    check_for_long_gnu_style_lines($ii);
                    $ii_begin_line = $ii;

                    # back up 1 token if we want to break before that type
                    # otherwise, we may strand tokens like '?' or ':' on a line
                    if ( $ii_begin_line > 0 ) {
                        my $wbb =
                            $last_nonblank_type eq 'k'
                          ? $want_break_before{$last_nonblank_token}
                          : $want_break_before{$last_nonblank_type};
                        $ii_begin_line-- if ($wbb);
                    }
                }

                $K_last_nonblank         = $K_to_go[$ii];
                $last_last_nonblank_type = $last_nonblank_type;
                $last_nonblank_type      = $type;
                $last_nonblank_token     = $token;

            } ## end if ( $type ne 'b' )

            # remember the predicted position of this token on the output line
            if ( $ii > $ii_begin_line ) {

                ## NOTE: this is a critical loop - the following call has been
                ## expanded for about 2x speedup:
                ## $lp_position_predictor =
                ##    total_line_length( $ii_begin_line, $ii );

                my $indentation = $leading_spaces_to_go[$ii_begin_line];
                if ( ref($indentation) ) {
                    $indentation = $indentation->get_spaces();
                }
                $lp_position_predictor =
                  $indentation +
                  $summed_lengths_to_go[ $ii + 1 ] -
                  $summed_lengths_to_go[$ii_begin_line];
            }
            else {
                $lp_position_predictor =
                  $space_count + $token_lengths_to_go[$ii];
            }

            # Store the indentation object for this token.
            # This allows us to manipulate the leading whitespace
            # (in case we have to reduce indentation to fit a line) without
            # having to change any token values.

            #---------------------------------------------------------------
            # replace leading whitespace with indentation objects where used
            #---------------------------------------------------------------
            if ( $rLP->[$max_lp_stack]->[_lp_object_] ) {
                $lp_object_count_this_batch++;
                my $lp_object = $rLP->[$max_lp_stack]->[_lp_object_];
                $leading_spaces_to_go[$ii] = $lp_object;
                if (   $max_lp_stack > 0
                    && $ci_level
                    && $rLP->[ $max_lp_stack - 1 ]->[_lp_object_] )
                {
                    $reduced_spaces_to_go[$ii] =
                      $rLP->[ $max_lp_stack - 1 ]->[_lp_object_];
                }
                else {
                    $reduced_spaces_to_go[$ii] = $lp_object;
                }
            }
        } ## end loop over all tokens in this batch

        undo_incomplete_lp_indentation()
          if ( !$rOpts_extended_line_up_parentheses );

        return $lp_object_count_this_batch;
    } ## end sub set_lp_indentation

    sub lp_equals_break_check {

        my ( $self, $ii, $ii_last_equals ) = @_;

        # If we come to an opening token after an '=' token of some
        # type, see if it would be helpful to 'break' after the '=' to
        # save space.

        # Given:
        #   $ii = index of an opening token in the output batch
        #   $ii_begin_line = index of token starting next output line
        # Update:
        #   $lp_position_predictor - updated position predictor
        #   $ii_begin_line = updated starting token index

        # Skip an empty set of parens, such as after channel():
        #   my $exchange = $self->_channel()->exchange(
        # This fixes issues b1318 b1322 b1323 b1328
        my $is_empty_container;
        if ( $ii_last_equals && $ii < $max_index_to_go ) {
            my $seqno    = $type_sequence_to_go[$ii];
            my $inext_nb = $ii + 1;
            $inext_nb++
              if ( $types_to_go[$inext_nb] eq 'b' );
            my $seqno_nb = $type_sequence_to_go[$inext_nb];
            $is_empty_container = $seqno && $seqno_nb && $seqno_nb == $seqno;
        }

        if (   $ii_last_equals
            && $ii_last_equals > $ii_begin_line
            && !$is_empty_container )
        {

            my $seqno = $type_sequence_to_go[$ii];

            # find the position if we break at the '='
            my $i_test = $ii_last_equals;

            # Fix for issue b1229, check if want break before this token
            # Fix for issue b1356, if i_test is a blank, the leading spaces may
            #   be incorrect (if it was an interline blank).
            # Fix for issue b1357 .. b1370, i_test must be prev nonblank
            #   ( the ci value for blanks can vary )
            # See also case b223
            # Fix for issue b1371-b1374 : all of these and the above are fixed
            # by simply backing up one index and setting the leading spaces of
            # a blank equal to that of the equals.
            if ( $want_break_before{ $types_to_go[$i_test] } ) {
                $i_test -= 1;
                $leading_spaces_to_go[$i_test] =
                  $leading_spaces_to_go[$ii_last_equals]
                  if ( $types_to_go[$i_test] eq 'b' );
            }
            elsif ( $types_to_go[ $i_test + 1 ] eq 'b' ) { $i_test++ }
            else {
                # no change needed
            }

            my $test_position = total_line_length( $i_test, $ii );
            my $mll = $maximum_line_length_at_level[ $levels_to_go[$i_test] ];

            #------------------------------------------------------
            # Break if structure will reach the maximum line length
            #------------------------------------------------------

            # Historically, -lp just used one-half line length here
            my $len_increase = $rOpts_maximum_line_length / 2;

            # For -xlp, we can also use the pre-computed lengths
            my $min_len = $self->[_rcollapsed_length_by_seqno_]->{$seqno};
            if ( $min_len && $min_len > $len_increase ) {
                $len_increase = $min_len;
            }

            if (

                # if we might exceed the maximum line length
                $lp_position_predictor + $len_increase > $mll

                # if a -bbx flag WANTS a break before this opening token
                || (   $seqno
                    && $self->[_rbreak_before_container_by_seqno_]->{$seqno} )

                # or we are beyond the 1/4 point and there was an old
                # break at an assignment (not '=>') [fix for b1035]
                || (
                    $lp_position_predictor >
                    $mll - $rOpts_maximum_line_length * 3 / 4
                    && $types_to_go[$ii_last_equals] ne '=>'
                    && (
                        $old_breakpoint_to_go[$ii_last_equals]
                        || (   $ii_last_equals > 0
                            && $old_breakpoint_to_go[ $ii_last_equals - 1 ] )
                        || (   $ii_last_equals > 1
                            && $types_to_go[ $ii_last_equals - 1 ] eq 'b'
                            && $old_breakpoint_to_go[ $ii_last_equals - 2 ] )
                    )
                )
              )
            {

                # then make the switch -- note that we do not set a
                # real breakpoint here because we may not really need
                # one; sub break_lists will do that if necessary.

                my $Kc = $self->[_K_closing_container_]->{$seqno};
                if (

                    # For -lp, only if the closing token is in this
                    # batch (c117).  Otherwise it cannot be done by sub
                    # break_lists.
                    defined($Kc) && $Kc <= $K_to_go[$max_index_to_go]

                    # For -xlp, we only need one nonblank token after
                    # the opening token.
                    || $rOpts_extended_line_up_parentheses
                  )
                {
                    $ii_begin_line         = $i_test + 1;
                    $lp_position_predictor = $test_position;

                    #--------------------------------------------------
                    # Fix for an opening container terminating a batch:
                    #--------------------------------------------------
                    # To get alignment of a -lp container with its
                    # contents, we have to put a break after $i_test.
                    # For $ii<$max_index_to_go, this will be done by
                    # sub break_lists based on the indentation object.
                    # But for $ii=$max_index_to_go, the indentation
                    # object for this seqno will not be created until
                    # the next batch, so we have to set a break at
                    # $i_test right now in order to get one.
                    if (   $ii == $max_index_to_go
                        && !$block_type_to_go[$ii]
                        && $types_to_go[$ii] eq '{'
                        && $seqno
                        && !$self->[_ris_excluded_lp_container_]->{$seqno} )
                    {
                        $self->set_forced_lp_break( $ii_begin_line, $ii );
                    }
                }
            }
        }
        return;
    } ## end sub lp_equals_break_check

    sub lp_decreasing_depth {
        my ( $self, $ii ) = @_;

        # This is called by sub set_lp_indentation for a token at index $ii
        # which has a lower nesting depth compared to the previous token.
        # We have to update the stack variables for the new indentation.

        my $rLL = $self->[_rLL_];

        my $level    = $levels_to_go[$ii];
        my $ci_level = $ci_levels_to_go[$ii];

        # loop to decrease $max_lp_stack until we find the first entry at or
        # completely below this level
        while (1) {

            # Be sure we have not hit the stack bottom - should never
            # happen because only negative levels can get here, and
            # $level was forced to be positive above.
            if ( $max_lp_stack <= 0 ) {

                # non-fatal, just keep going except in DEVEL_MODE
                if (DEVEL_MODE) {
                    Fault(<<EOM);
program bug with -lp: stack_error. level=$level; ci_level=$ci_level; rerun with -nlp
EOM
                }
                last;
            }

            # save index of token which closes this level
            if ( $rLP->[$max_lp_stack]->[_lp_object_] ) {
                my $lp_object = $rLP->[$max_lp_stack]->[_lp_object_];

                $lp_object->set_closed($ii);

                my $comma_count = 0;
                my $arrow_count = 0;
                my $type        = $types_to_go[$ii];
                if ( $type eq '}' || $type eq ')' ) {
                    my $total_depth = $nesting_depth_to_go[$ii];
                    $comma_count = $lp_comma_count{$total_depth};
                    $arrow_count = $lp_arrow_count{$total_depth};
                    $comma_count = 0 if ( !defined($comma_count) );
                    $arrow_count = 0 if ( !defined($arrow_count) );
                }

                $lp_object->set_comma_count($comma_count);
                $lp_object->set_arrow_count($arrow_count);

                # Undo any extra indentation if we saw no commas
                my $available_spaces = $lp_object->get_available_spaces();
                my $K_start          = $lp_object->get_K_begin_line();

                if (   $available_spaces > 0
                    && $K_start >= $K_to_go[0]
                    && ( $comma_count <= 0 || $arrow_count > 0 ) )
                {

                    my $i = $lp_object->get_lp_item_index();

                    # Safety check for a valid stack index. It
                    # should be ok because we just checked that the
                    # index K of the token associated with this
                    # indentation is in this batch.
                    if ( $i < 0 || $i > $max_lp_object_list ) {
                        my $KK  = $K_to_go[$ii];
                        my $lno = $rLL->[$KK]->[_LINE_INDEX_];
                        DEVEL_MODE && Fault(<<EOM);
Program bug with -lp near line $lno.  Stack index i=$i should be >=0 and <= max=$max_lp_object_list
EOM
                        last;
                    }

                    if ( $arrow_count == 0 ) {
                        $rlp_object_list->[$i]
                          ->permanently_decrease_available_spaces(
                            $available_spaces);
                    }
                    else {
                        $rlp_object_list->[$i]
                          ->tentatively_decrease_available_spaces(
                            $available_spaces);
                    }
                    foreach my $j ( $i + 1 .. $max_lp_object_list ) {
                        $rlp_object_list->[$j]
                          ->decrease_SPACES($available_spaces);
                    }
                }
            }

            #------------------
            # go down one level
            #------------------
            --$max_lp_stack;

            my $rLP_top = $rLP->[$max_lp_stack];
            my $ci_lev  = $rLP_top->[_lp_ci_level_];
            my $lev     = $rLP_top->[_lp_level_];
            my $spaces  = $rLP_top->[_lp_space_count_];
            if ( $rLP_top->[_lp_object_] ) {
                my $lp_obj = $rLP_top->[_lp_object_];
                ( $spaces, $lev, $ci_lev ) =
                  @{ $lp_obj->get_spaces_level_ci() };
            }

            # stop when we reach a level at or below the current
            # level
            if ( $lev <= $level && $ci_lev <= $ci_level ) {
                $space_count      = $spaces;
                $current_level    = $lev;
                $current_ci_level = $ci_lev;
                last;
            }
        } ## end while (1)
        return;
    } ## end sub lp_decreasing_depth

    sub lp_increasing_depth {
        my ( $self, $ii ) = @_;

        # This is called by sub set_lp_indentation for a token at index $ii
        # which has an increasing nesting depth compared to the previous token.
        # We have to update the stack variables for the new indentation.

        my $rLL = $self->[_rLL_];

        my $type     = $types_to_go[$ii];
        my $level    = $levels_to_go[$ii];
        my $ci_level = $ci_levels_to_go[$ii];

        $stack_changed = 1;

        # Compute the standard incremental whitespace.  This will be
        # the minimum incremental whitespace that will be used.  This
        # choice results in a smooth transition between the gnu-style
        # and the standard style.
        my $standard_increment =
          ( $level - $current_level ) * $rOpts_indent_columns +
          ( $ci_level - $current_ci_level ) * $rOpts_continuation_indentation;

        # Now we have to define how much extra incremental space
        # ("$available_space") we want.  This extra space will be
        # reduced as necessary when long lines are encountered or when
        # it becomes clear that we do not have a good list.
        my $available_spaces = 0;
        my $align_seqno      = 0;
        my $K_extra_space;

        my $last_nonblank_seqno;
        my $last_nonblank_block_type;
        if ( defined($K_last_nonblank) ) {
            $last_nonblank_seqno = $rLL->[$K_last_nonblank]->[_TYPE_SEQUENCE_];
            $last_nonblank_block_type =
                $last_nonblank_seqno
              ? $self->[_rblock_type_of_seqno_]->{$last_nonblank_seqno}
              : undef;
        }

        $in_lp_mode = $rLP->[$max_lp_stack]->[_lp_object_];

        #-----------------------------------------------
        # Initialize indentation spaces on empty stack..
        #-----------------------------------------------
        if ( $max_lp_stack == 0 ) {
            $space_count = $level * $rOpts_indent_columns;
        }

        #----------------------------------------
        # Add the standard space increment if ...
        #----------------------------------------
        elsif (

            # if this is a BLOCK, add the standard increment
            $last_nonblank_block_type

            # or if this is not a sequenced item
            || !$last_nonblank_seqno

            # or this container is excluded by user rules
            # or contains here-docs or multiline qw text
            || defined($last_nonblank_seqno)
            && $self->[_ris_excluded_lp_container_]->{$last_nonblank_seqno}

            # or if last nonblank token was not structural indentation
            || $last_nonblank_type ne '{'

            # and do not start -lp under stress .. fixes b1244, b1255
            || !$in_lp_mode && $level >= $high_stress_level

          )
        {

            # If we have entered lp mode, use the top lp object to get
            # the current indentation spaces because it may have
            # changed.  Fixes b1285, b1286.
            if ($in_lp_mode) {
                $space_count = $in_lp_mode->get_spaces();
            }
            $space_count += $standard_increment;
        }

        #---------------------------------------------------------------
        # -lp mode: try to use space to the first non-blank level change
        #---------------------------------------------------------------
        else {

            # see how much space we have available
            my $test_space_count = $lp_position_predictor;
            my $excess           = 0;
            my $min_len =
              $self->[_rcollapsed_length_by_seqno_]->{$last_nonblank_seqno};
            my $next_opening_too_far;

            if ( defined($min_len) ) {
                $excess =
                  $test_space_count +
                  $min_len -
                  $maximum_line_length_at_level[$level];
                if ( $excess > 0 ) {
                    $test_space_count -= $excess;

                    # will the next opening token be a long way out?
                    $next_opening_too_far =
                      $lp_position_predictor + $excess >
                      $maximum_line_length_at_level[$level];
                }
            }

            my $rLP_top             = $rLP->[$max_lp_stack];
            my $min_gnu_indentation = $rLP_top->[_lp_space_count_];
            if ( $rLP_top->[_lp_object_] ) {
                $min_gnu_indentation = $rLP_top->[_lp_object_]->get_spaces();
            }
            $available_spaces = $test_space_count - $min_gnu_indentation;

            # Fix for combo -naws and -xlp (b1501; also b1466)
            my $tol = !$rOpts_add_whitespace
              && $rOpts_extended_line_up_parentheses ? 1 : 0;

            # Do not startup -lp indentation mode if no space ...
            # ... or if it puts the opening far to the right
            if ( !$in_lp_mode
                && ( $available_spaces <= $tol || $next_opening_too_far ) )
            {
                $space_count += $standard_increment;
                $available_spaces = 0;
            }

            # Use -lp mode
            else {
                $space_count = $test_space_count;

                $in_lp_mode = 1;
                if ( $available_spaces >= $standard_increment ) {
                    $min_gnu_indentation += $standard_increment;
                }
                elsif ( $available_spaces > 1 ) {
                    $min_gnu_indentation += $available_spaces + 1;

                    # The "+1" space can cause mis-alignment if there is no
                    # blank space between the opening paren and the next
                    # nonblank token (i.e., -pt=2) and the container does not
                    # get broken open.  So we will mark this token for later
                    # space removal by sub 'xlp_tweak' if this container
                    # remains intact (issue git #106).
                    if (
                        $type ne 'b'

                        # Skip if the maximum line length is exceeded here
                        && $excess <= 0

                        # This is only for level changes, not ci level changes.
                        # But note: this test is here out of caution but I have
                        # not found a case where it is actually necessary.
                        && $is_opening_token{$last_nonblank_token}

                        # Be sure we are at consecutive nonblanks.  This test
                        # should be true, but it guards against future coding
                        # changes to level values assigned to blank spaces.
                        && $ii > 0
                        && $types_to_go[ $ii - 1 ] ne 'b'

                      )
                    {
                        $K_extra_space = $K_to_go[$ii];
                    }
                }
                elsif ( $is_opening_token{$last_nonblank_token} ) {
                    if ( ( $tightness{$last_nonblank_token} < 2 ) ) {
                        $min_gnu_indentation += 2;
                    }
                    else {
                        $min_gnu_indentation += 1;
                    }
                }
                else {
                    $min_gnu_indentation += $standard_increment;
                }
                $available_spaces = $space_count - $min_gnu_indentation;

                if ( $available_spaces < 0 ) {
                    $space_count      = $min_gnu_indentation;
                    $available_spaces = 0;
                }
                $align_seqno = $last_nonblank_seqno;
            }
        }

        #-------------------------------------------
        # update the state, but not on a blank token
        #-------------------------------------------
        if ( $type ne 'b' ) {

            if ( $rLP->[$max_lp_stack]->[_lp_object_] ) {
                $rLP->[$max_lp_stack]->[_lp_object_]->set_have_child(1);
                $in_lp_mode = 1;
            }

            #----------------------------------------
            # Create indentation object if in lp-mode
            #----------------------------------------
            ++$max_lp_stack;
            my $lp_object;
            if ($in_lp_mode) {

                # A negative level implies not to store the item in the
                # item_list
                my $lp_item_index = 0;
                if ( $level >= 0 ) {
                    $lp_item_index = ++$max_lp_object_list;
                }

                my $K_begin_line = 0;
                if (   $ii_begin_line >= 0
                    && $ii_begin_line <= $max_index_to_go )
                {
                    $K_begin_line = $K_to_go[$ii_begin_line];
                }

                # Minor Fix: when creating indentation at a side
                # comment we don't know what the space to the actual
                # next code token will be.  We will allow a space for
                # sub correct_lp to move it in if necessary.
                # NOTE for c314, c400: this fix is not really necessary,
                # and it caused a DEVEL_MODE fault when -i=0.
                # It could be completely removed, but this would change
                # existing formatting in a few cases. So for now, the fix
                # is to only skip this if -i=0.
                if (
                       $type eq '#'
                    && $max_index_to_go > 0
                    && $align_seqno

                    # fix for c314, c400 (see above note)
                    && $rOpts_indent_columns > 0
                  )
                {
                    $available_spaces += 1;
                }

                my $standard_spaces = $leading_spaces_to_go[$ii];
                $lp_object = Perl::Tidy::IndentationItem->new(
                    spaces           => $space_count,
                    level            => $level,
                    ci_level         => $ci_level,
                    available_spaces => $available_spaces,
                    lp_item_index    => $lp_item_index,
                    align_seqno      => $align_seqno,
                    K_begin_line     => $K_begin_line,
                    standard_spaces  => $standard_spaces,
                    K_extra_space    => $K_extra_space,
                );

                DEBUG_LP && do {
                    my $tok_beg = $rLL->[$K_begin_line]->[_TOKEN_];
                    my $token   = $tokens_to_go[$ii];
                    print {*STDOUT} <<EOM;
DEBUG_LP: Created object at tok=$token type=$type for seqno $align_seqno level=$level ci=$ci_level spaces=$space_count avail=$available_spaces kbeg=$K_begin_line tokbeg=$tok_beg lp=$lp_position_predictor
EOM
                };

                if ( $level >= 0 ) {
                    $rlp_object_list->[$max_lp_object_list] = $lp_object;
                }

                if (   $is_opening_token{$last_nonblank_token}
                    && $last_nonblank_seqno )
                {
                    $self->[_rlp_object_by_seqno_]->{$last_nonblank_seqno} =
                      $lp_object;
                }
            }

            #------------------------------------
            # Store this indentation on the stack
            #------------------------------------
            $rLP->[$max_lp_stack]->[_lp_ci_level_] = $ci_level;
            $rLP->[$max_lp_stack]->[_lp_level_]    = $level;
            $rLP->[$max_lp_stack]->[_lp_object_]   = $lp_object;
            $rLP->[$max_lp_stack]->[_lp_container_seqno_] =
              $last_nonblank_seqno;
            $rLP->[$max_lp_stack]->[_lp_space_count_] = $space_count;

            # If the opening paren is beyond the half-line length, then
            # we will use the minimum (standard) indentation.  This will
            # help avoid problems associated with running out of space
            # near the end of a line.  As a result, in deeply nested
            # lists, there will be some indentations which are limited
            # to this minimum standard indentation. But the most deeply
            # nested container will still probably be able to shift its
            # parameters to the right for proper alignment, so in most
            # cases this will not be noticeable.
            if ( $available_spaces > 0 && $lp_object ) {
                my $halfway =
                  $maximum_line_length_at_level[$level] -
                  $rOpts_maximum_line_length / 2;
                $lp_object->tentatively_decrease_available_spaces(
                    $available_spaces)
                  if ( $space_count > $halfway );
            }
        }
        return;
    } ## end sub lp_increasing_depth

    sub check_for_long_gnu_style_lines {

        # Look at the current estimated maximum line length, and
        # remove some whitespace if it exceeds the desired maximum
        my ($ii_to_go) = @_;

        # Given:
        #   $ii_to_go = index of current token under consideration

        # nothing can be done if no stack items defined for this line
        return if ( $max_lp_object_list < 0 );

        # See if we have exceeded the maximum desired line length ..
        # keep 2 extra free because they are needed in some cases
        # (result of trial-and-error testing)
        my $tol = 2;

        # But reduce tol to 0 at a terminal comma; fixes b1432
        if (   $types_to_go[$ii_to_go] eq ','
            && $ii_to_go < $max_index_to_go )
        {
            my $in = $ii_to_go + 1;
            if ( $types_to_go[$in] eq 'b' && $in < $max_index_to_go ) { $in++ }
            if ( $is_closing_token{ $tokens_to_go[$in] } ) {
                $tol = 0;
            }
        }

        my $spaces_needed =
          $lp_position_predictor -
          $maximum_line_length_at_level[ $levels_to_go[$ii_to_go] ] +
          $tol;

        return if ( $spaces_needed <= 0 );

        # We are over the limit, so try to remove a requested number of
        # spaces from leading whitespace.  We are only allowed to remove
        # from whitespace items created on this batch, since others have
        # already been used and cannot be undone.
        my @candidates = ();

        # loop over all whitespace items created for the current batch
        foreach my $i ( 0 .. $max_lp_object_list ) {
            my $item = $rlp_object_list->[$i];

            # item must still be open to be a candidate (otherwise it
            # cannot influence the current token)
            next if ( $item->get_closed() >= 0 );

            my $available_spaces = $item->get_available_spaces();

            if ( $available_spaces > 0 ) {
                push( @candidates, [ $i, $available_spaces ] );
            }
        }

        return unless (@candidates);

        # sort by available whitespace so that we can remove whitespace
        # from the maximum available first.
        @candidates =
          sort { $b->[1] <=> $a->[1] || $a->[0] <=> $b->[0] } @candidates;

        # keep removing whitespace until we are done or have no more
        foreach my $candidate (@candidates) {
            my ( $i, $available_spaces ) = @{$candidate};
            my $deleted_spaces =
              ( $available_spaces > $spaces_needed )
              ? $spaces_needed
              : $available_spaces;

            # remove the incremental space from this item
            $rlp_object_list->[$i]->decrease_available_spaces($deleted_spaces);

            my $i_debug = $i;

            # update the leading whitespace of this item and all items
            # that came after it
            $i -= 1;
            while ( ++$i <= $max_lp_object_list ) {

                my $old_spaces = $rlp_object_list->[$i]->get_spaces();
                if ( $old_spaces >= $deleted_spaces ) {
                    $rlp_object_list->[$i]->decrease_SPACES($deleted_spaces);
                }

                # shouldn't happen except for code bug:
                else {
                    # non-fatal, keep going except in DEVEL_MODE
                    if (DEVEL_MODE) {
                        my $level = $rlp_object_list->[$i_debug]->get_level();
                        my $ci_level =
                          $rlp_object_list->[$i_debug]->get_ci_level();
                        my $old_level = $rlp_object_list->[$i]->get_level();
                        my $old_ci_level_uu =
                          $rlp_object_list->[$i]->get_ci_level();
                        Fault(<<EOM);
program bug with -lp: want to delete $deleted_spaces from item $i, but old=$old_spaces deleted: lev=$level ci=$ci_level  deleted: level=$old_level ci=$ci_level
EOM
                    }
                }
            } ## end while ( ++$i <= $max_lp_object_list)
            $lp_position_predictor -= $deleted_spaces;
            $spaces_needed         -= $deleted_spaces;
            last if ( $spaces_needed <= 0 );
        }
        return;
    } ## end sub check_for_long_gnu_style_lines

    sub undo_incomplete_lp_indentation {

        #------------------------------------------------------------------
        # Undo indentation for all incomplete -lp indentation levels of the
        # current batch unless -xlp is set.
        #------------------------------------------------------------------

        # This routine is called once after each output stream batch is
        # finished to undo indentation for all incomplete -lp indentation
        # levels.  If this routine is called then comments and blank lines will
        # disrupt this indentation style.  In older versions of perltidy this
        # was always done because it could cause problems otherwise, but recent
        # improvements allow fairly good results to be obtained by skipping
        # this step with the -xlp flag.

        # nothing to do if no stack items defined for this line
        return if ( $max_lp_object_list < 0 );

        # loop over all whitespace items created for the current batch
        foreach my $i ( 0 .. $max_lp_object_list ) {
            my $item = $rlp_object_list->[$i];

            # only look for open items
            next if ( $item->get_closed() >= 0 );

            # Tentatively remove all of the available space
            # (The vertical aligner will try to get it back later)
            my $available_spaces = $item->get_available_spaces();
            if ( $available_spaces > 0 ) {

                # delete incremental space for this item
                $rlp_object_list->[$i]
                  ->tentatively_decrease_available_spaces($available_spaces);

                # Reduce the total indentation space of any nodes that follow
                # Note that any such nodes must necessarily be dependents
                # of this node.
                foreach ( $i + 1 .. $max_lp_object_list ) {
                    $rlp_object_list->[$_]->decrease_SPACES($available_spaces);
                }
            }
        }
        return;
    } ## end sub undo_incomplete_lp_indentation
} ## end closure set_lp_indentation

#----------------------------------------------------------------------
# sub to set a requested break before an opening container in -lp mode.
#----------------------------------------------------------------------
sub set_forced_lp_break {

    my ( $self, $i_begin_line, $i_opening ) = @_;

    # Given:
    #   $i_begin_line = index of break in the _to_go arrays
    #   $i_opening = index of the opening container

    # Set any requested break at a token before this opening container
    # token. This is often an '=' or '=>' but can also be things like
    # '.', ',', 'return'.  It was defined by sub set_lp_indentation.

    # Important:
    #   For intact containers, call this at the closing token.
    #   For broken containers, call this at the opening token.
    # This will avoid needless breaks when it turns out that the
    # container does not actually get broken.  This isn't known until
    # the closing container for intact blocks.

    return
      if ( $i_begin_line < 0
        || $i_begin_line > $max_index_to_go );

    # Handle request to put a break break immediately before this token.
    # We may not want to do that since we are also breaking after it.
    if ( $i_begin_line == $i_opening ) {

        # The following rules should be reviewed.  We may want to always
        # allow the break.  If we do not do the break, the indentation
        # may be off.

        # RULE: don't break before it unless it is welded to a qw.
        # This works well, but we may want to relax this to allow
        # breaks in additional cases.
        return
          if ( !$self->[_rK_weld_right_]->{ $K_to_go[$i_opening] } );
        return unless ( $types_to_go[$max_index_to_go] eq 'q' );
    }

    # Only break for breakpoints at the same
    # indentation level as the opening paren
    my $test1 = $nesting_depth_to_go[$i_opening];
    my $test2 = $nesting_depth_to_go[$i_begin_line];
    return if ( $test2 != $test1 );

    # Back up at a blank (fixes case b932)
    my $ibr = $i_begin_line - 1;
    if (   $ibr > 0
        && $types_to_go[$ibr] eq 'b' )
    {
        $ibr--;
    }
    if ( $ibr >= 0 ) {
        my $i_nonblank = $self->set_forced_breakpoint($ibr);

        # Crude patch to prevent sub recombine_breakpoints from undoing
        # this break, especially after an '='.  It will leave old
        # breakpoints alone. See c098/x045 for some examples.
        if ( defined($i_nonblank) ) {
            $old_breakpoint_to_go[$i_nonblank] = 1;
        }
    }
    return;
} ## end sub set_forced_lp_break

sub reduce_lp_indentation {

    my ( $self, $i, $spaces_wanted ) = @_;

    # Reduce the leading whitespace at token $i if possible by $spaces_wanted
    # (a large value of $spaces_wanted will remove all excess space)
    # NOTE: to be called from break_lists only for a sequence of tokens
    # contained between opening and closing parens/braces/brackets

    my $deleted_spaces = 0;

    my $item             = $leading_spaces_to_go[$i];
    my $available_spaces = $item->get_available_spaces();

    if (
        $available_spaces > 0
        && ( ( $spaces_wanted <= $available_spaces )
            || !$item->get_have_child() )
      )
    {

        # we'll remove these spaces, but mark them as recoverable
        $deleted_spaces =
          $item->tentatively_decrease_available_spaces($spaces_wanted);
    }

    return $deleted_spaces;
} ## end sub reduce_lp_indentation

###########################################################
# CODE SECTION 13: Preparing batches for vertical alignment
###########################################################

sub check_convey_batch_input {

    my ($self) = @_;

    # Check for valid input to sub convey_batch_to_vertical_aligner.  An
    # error here would most likely be due to an error in the calling
    # routine 'sub grind_batch_of_CODE'.

    my $this_batch = $self->[_this_batch_];
    my $ri_first   = $this_batch->[_ri_first_];
    my $ri_last    = $this_batch->[_ri_last_];

    # $ri_first = ref to list of starting line indexes in _to_go arrays
    # $ri_last  = ref to list of ending line indexes in _to_go arrays
    if ( !defined($ri_first) || !defined($ri_last) ) {
        Fault(<<EOM);
Undefined line ranges ri_first and/r ri_last
EOM
    }

    my $nmax       = @{$ri_first} - 1;
    my $nmax_check = @{$ri_last} - 1;
    if ( $nmax < 0 || $nmax_check < 0 || $nmax != $nmax_check ) {
        Fault(<<EOM);
Line range index error: nmax=$nmax but nmax_check=$nmax_check
These should be equal and >=0
EOM
    }
    my ( $ibeg, $iend );
    foreach my $n ( 0 .. $nmax ) {
        my $iend_m = $iend;
        $ibeg = $ri_first->[$n];
        $iend = $ri_last->[$n];
        if ( $ibeg < 0 || $iend < $ibeg || $iend > $max_index_to_go ) {
            Fault(<<EOM);
Bad line range at line index $n of $nmax: ibeg=$ibeg, iend=$iend
These should have iend >= ibeg and be in the range (0..$max_index_to_go)
EOM
        }
        next if ( $n == 0 );
        if ( $ibeg <= $iend_m ) {
            Fault(<<EOM);
Line ranges overlap: iend=$iend_m at line $n-1 but ibeg=$ibeg for line $n
EOM
        }
    }
    return;
} ## end sub check_convey_batch_input

sub convey_batch_to_vertical_aligner {

    my ($self) = @_;

    # This routine receives a batch of code for which the final line breaks
    # have been defined. Here we prepare the lines for passing to the vertical
    # aligner.  We do the following tasks:
    # - mark certain vertical alignment tokens, such as '=', in each line
    # - make final indentation adjustments
    # - do logical padding: insert extra blank spaces to help display certain
    #   logical constructions
    # - send the line to the vertical aligner

    my $rLL               = $self->[_rLL_];
    my $Klimit            = $self->[_Klimit_];
    my $ris_list_by_seqno = $self->[_ris_list_by_seqno_];
    my $this_batch        = $self->[_this_batch_];

    my $do_not_pad      = $this_batch->[_do_not_pad_];
    my $batch_CODE_type = $this_batch->[_batch_CODE_type_];
    my $ri_first        = $this_batch->[_ri_first_];
    my $ri_last         = $this_batch->[_ri_last_];

    $self->check_convey_batch_input() if (DEVEL_MODE);

    my $n_last_line = @{$ri_first} - 1;

    my $ibeg = $ri_first->[0];
    my $iend = $ri_last->[0];

    my $type_beg  = $types_to_go[$ibeg];
    my $type_end  = $types_to_go[$iend];
    my $token_beg = $tokens_to_go[$ibeg];

    my $rindentation_list = [0];    # ref to indentations for each line
    my ( $cscw_block_comment, $closing_side_comment, $is_block_comment,
        $is_HSC );

    if (  !$max_index_to_go
        && $type_beg eq '#' )
    {
        if ( $batch_CODE_type && $batch_CODE_type eq 'HSC' ) { $is_HSC = 1 }
        else { $is_block_comment = 1 }
    }

    if ($rOpts_closing_side_comments) {
        ( $closing_side_comment, $cscw_block_comment ) =
          $self->add_closing_side_comment();
    }

    # for multi-line batches ...
    if ( $n_last_line > 0 ) {

        # undo continuation indentation
        $self->undo_ci();

        # flush before a long if statement to avoid unwanted alignment
        $self->flush_vertical_aligner()
          if ( $type_beg eq 'k'
            && $is_if_unless{$token_beg} );

        $self->set_logical_padding()
          if ($rOpts_logical_padding);

        $self->xlp_tweak()
          if ($rOpts_extended_line_up_parentheses);
    }

    # -xci must undo continuation indentation even for single lines
    elsif ($rOpts_extended_continuation_indentation) {
        $self->undo_ci();
    }
    else {
        # ok: single line, no -xci
    }

    if (DEVEL_MODE) { $self->check_batch_summed_lengths() }

    # ----------------------------------------------------------
    # define the vertical alignments for all lines of this batch
    # ----------------------------------------------------------
    my $rline_alignments;

    # Quick handling of lines with a single tokens
    if ( !$max_index_to_go ) {

        # Hanging side comment
        if ($is_HSC) {
            $rline_alignments = make_HSC_vertical_alignments();
        }

        # All Other single tokens
        # = [ [ $rtokens, $rfields, $rpatterns, $rfield_lengths ] ];
        else {

            $rline_alignments = [
                [
                    [],
                    [ $tokens_to_go[0] ],
                    [ $types_to_go[0] ],
                    [ $summed_lengths_to_go[1] - $summed_lengths_to_go[0] ],
                ]
            ];
        }
    }

    # Multiple tokens
    else {
        $rline_alignments = $self->make_vertical_alignments();
    }

    # ----------------------------------------------
    # loop to send each line to the vertical aligner
    # ----------------------------------------------
    my ( $type_beg_last, $type_end_last, $ibeg_next, $iend_next, $ljump );

    foreach my $nline ( 0 .. $n_last_line ) {

        # ----------------------------------------------------------------
        # This hash will hold the args for vertical alignment of this line
        # We will populate it as we go.
        # ----------------------------------------------------------------
        my $rvao_args = {};

        if ( $nline > 0 ) {
            $type_beg_last = $type_beg;
            $type_end_last = $type_end;

            $ibeg = $ibeg_next;
            $iend = $iend_next;

            $type_beg  = $types_to_go[$ibeg];
            $type_end  = $types_to_go[$iend];
            $token_beg = $tokens_to_go[$ibeg];
        }

        my $Kbeg = $K_to_go[$ibeg];
        my $Kend = $K_to_go[$iend];

        if ( $nline < $n_last_line ) {
            $ibeg_next = $ri_first->[ $nline + 1 ];
            $iend_next = $ri_last->[ $nline + 1 ];

            my $Kbeg_next = $K_to_go[$ibeg_next];
            $ljump =
              $rLL->[$Kbeg_next]->[_LEVEL_] - $rLL->[$Kend]->[_LEVEL_];
        }
        elsif ( !$is_block_comment && $Kend < $Klimit ) {

            # Patch for git #51, a bare closing qw paren was not outdented
            # if the flag '-nodelete-old-newlines is set
            # Note that we are just looking ahead for the next nonblank
            # character. We could scan past an arbitrary number of block
            # comments or hanging side comments by calling K_next_code, but it
            # could add significant run time with very little to be gained.
            my $Kbeg_next = $Kend + 1;
            if (   $Kbeg_next < $Klimit
                && $rLL->[$Kbeg_next]->[_TYPE_] eq 'b' )
            {
                $Kbeg_next += 1;
            }
            $ljump =
              $rLL->[$Kbeg_next]->[_LEVEL_] - $rLL->[$Kend]->[_LEVEL_];
        }
        else {
            $ljump = 0;
        }

        # ---------------------------------------------------
        # Define the check value 'Kend' to send for this line
        # ---------------------------------------------------
        # The 'Kend' value is an integer for checking that lines come out of
        # the far end of the pipeline in the right order.  It increases
        # linearly along the token stream.  But we only send ending K values of
        # non-comments down the pipeline.  This is equivalent to checking that
        # the last CODE_type is blank or equal to 'VER'. See also sub
        # resync_lines_and_tokens for related coding.  Note that
        # '$batch_CODE_type' is the code type of the line to which the ending
        # token belongs.
        if ( !$batch_CODE_type || $batch_CODE_type eq 'VER' ) {
            $rvao_args->{Kend} = $Kend;
        }

        # ---------------------------------------------
        # get the vertical alignment info for this line
        # ---------------------------------------------

        # The lines are broken into fields which can be spaced by the vertical
        # to achieve vertical alignment.  These fields are the actual text
        # which will be output, so from here on no more changes can be made to
        # the text.
        my $rline_alignment = $rline_alignments->[$nline];

        # Programming check: (shouldn't happen)
        # The number of tokens which separate the fields must always be
        # one less than the number of fields. If this is not true then
        # an error has been introduced in sub make_alignment_patterns.
        if (DEVEL_MODE) {
            my ( $rtokens, $rfields, $rpatterns_uu, $rfield_lengths_uu ) =
              @{$rline_alignment};
            if ( @{$rfields} && ( @{$rtokens} != ( @{$rfields} - 1 ) ) ) {
                my $nt  = @{$rtokens};
                my $nf  = @{$rfields};
                my $msg = <<EOM;
Program bug in Perl::Tidy::Formatter, probably in sub 'make_alignment_patterns':
The number of tokens = $nt should be one less than number of fields: $nf
EOM
                Fault($msg);
            }
        }

        # --------------------------------------
        # get the final indentation of this line
        # --------------------------------------
        my (

            $indentation,
            $lev,
            $level_end,
            $i_terminal,
            $is_outdented_line,

        ) = $self->get_final_indentation(

            $ibeg,
            $iend,
            $rindentation_list,
            $ljump,

        );

        # --------------------------------
        # define flag 'outdent_long_lines'
        # --------------------------------
        if (
            # we will allow outdenting of long lines..
            # which are long quotes, if allowed
            ( $type_beg eq 'Q' && $rOpts_outdent_long_quotes )

            # which are long block comments, if allowed
            || (
                   $type_beg eq '#'
                && $rOpts_outdent_long_comments

                # but not if this is a static block comment
                && !$this_batch->[_is_static_block_comment_]
            )
          )
        {
            $rvao_args->{outdent_long_lines} = 1;

            # convert -lp indentation objects to spaces to allow outdenting
            if ( ref($indentation) ) {
                $indentation = $indentation->get_spaces();
            }
        }

        # --------------------------------------------------
        # define flags 'break_alignment_before' and '_after'
        # --------------------------------------------------

        # These flags tell the vertical aligner to stop alignment before or
        # after this line.
        if ($is_outdented_line) {
            $rvao_args->{break_alignment_before} = 1;
            $rvao_args->{break_alignment_after}  = 1;
        }
        elsif ($do_not_pad) {
            $rvao_args->{break_alignment_before} = 1;
        }

        # flush at an 'if' which follows a line with (1) terminal semicolon
        # or (2) terminal block_type which is not an 'if'.  This prevents
        # unwanted alignment between the lines.
        elsif ( $token_beg eq 'if' && $type_beg eq 'k' ) {
            my $type_m = 'b';
            my $block_type_m;

            if ( $Kbeg > 0 ) {
                my $Km = $Kbeg - 1;
                $type_m = $rLL->[$Km]->[_TYPE_];
                if ( $type_m eq 'b' && $Km > 0 ) {
                    $Km -= 1;
                    $type_m = $rLL->[$Km]->[_TYPE_];
                }
                if ( $type_m eq '#' && $Km > 0 ) {
                    $Km -= 1;
                    $type_m = $rLL->[$Km]->[_TYPE_];
                    if ( $type_m eq 'b' && $Km > 0 ) {
                        $Km -= 1;
                        $type_m = $rLL->[$Km]->[_TYPE_];
                    }
                }

                my $seqno_m = $rLL->[$Km]->[_TYPE_SEQUENCE_];
                if ($seqno_m) {
                    $block_type_m = $self->[_rblock_type_of_seqno_]->{$seqno_m};
                }
            }

            # break after anything that is not if-like
            if (
                $type_m eq ';'
                || (   $type_m eq '}'
                    && $block_type_m
                    && $block_type_m ne 'if'
                    && $block_type_m ne 'unless'
                    && $block_type_m ne 'elsif'
                    && $block_type_m ne 'else' )
              )
            {
                $rvao_args->{break_alignment_before} = 1;
            }
        }
        else {
            # do not need to break vertical alignment here
        }

        # ----------------------------------
        # define 'rvertical_tightness_flags'
        # ----------------------------------
        # These flags tell the vertical aligner if/when to combine consecutive
        # lines, based on the user input parameters.
        if (   !$is_block_comment
            && !$self->[_no_vertical_tightness_flags_] )
        {
            $rvao_args->{rvertical_tightness_flags} =
              $self->set_vertical_tightness_flags( $nline,
                $closing_side_comment );
        }

        # ----------------------------------
        # define 'is_terminal_ternary'  flag
        # ----------------------------------

        # This flag is set at the final ':' of a ternary chain to request
        # vertical alignment of the final term.  Here is a slightly complex
        # example:
        #
        # $self->{_text} = (
        #    !$section        ? ''
        #   : $type eq 'item' ? "the $section entry"
        #   :                   "the section on $section"
        # )
        # . (
        #   $page
        #   ? ( $section ? ' in ' : '' ) . "the $page$page_ext manpage"
        #   : ' elsewhere in this document'
        # );
        #
        if ( $type_beg eq ':' || $nline > 0 && $type_end_last eq ':' ) {

            my $is_terminal_ternary = 0;
            my $last_leading_type   = $nline > 0 ? $type_beg_last : ':';
            my $terminal_type       = $types_to_go[$i_terminal];
            if (   $terminal_type ne ';'
                && $n_last_line > $nline
                && $level_end == $lev )
            {
                my $Kbeg_next = $K_to_go[$ibeg_next];
                $level_end     = $rLL->[$Kbeg_next]->[_LEVEL_];
                $terminal_type = $rLL->[$Kbeg_next]->[_TYPE_];
            }
            if (
                $last_leading_type eq ':'
                && (   ( $terminal_type eq ';' && $level_end <= $lev )
                    || ( $terminal_type ne ':' && $level_end < $lev ) )
              )
            {

                # the terminal term must not contain any ternary terms, as in
                # my $ECHO = (
                #       $Is_MSWin32 ? ".\\echo$$"
                #     : $Is_MacOS   ? ":echo$$"
                #     : ( $Is_NetWare ? "echo$$" : "./echo$$" )
                # );
                $is_terminal_ternary = 1;

                my $rK_next_seqno_by_K = $self->[_rK_next_seqno_by_K_];
                my $KP                 = $Kbeg;
                my $Knext_last         = $KP;
                while ( defined( $KP = $rK_next_seqno_by_K->[$KP] ) ) {

                    if ( $KP <= $Knext_last ) {
                        ## shouldn't happen: $rK_next_seqno_by_K is corrupted
                        DEVEL_MODE && Fault(<<EOM);
Knext should not increase: Knext_last=$Knext_last >= Knext=$KP
EOM
                        last;
                    }
                    $Knext_last = $KP;

                    last if ( $KP > $Kend );
                    my $type_KP = $rLL->[$KP]->[_TYPE_];
                    if ( $type_KP eq '?' || $type_KP eq ':' ) {
                        $is_terminal_ternary = 0;
                        last;
                    }
                } ## end while ( defined( $KP = $rK_next_seqno_by_K...))
            }
            $rvao_args->{is_terminal_ternary} = $is_terminal_ternary;
        }

        # -------------------------------------------------
        # add any new closing side comment to the last line
        # -------------------------------------------------
        if ( $closing_side_comment && $nline == $n_last_line ) {
            my ( $rtokens, $rfields, $rpatterns, $rfield_lengths ) =
              @{$rline_alignment};

            if ( @{$rfields} ) {
                $rfields->[-1] .= " $closing_side_comment";

              # NOTE: Patch for csc. We can just use 1 for the length of the csc
              # because its length should not be a limiting factor from here on.
                $rfield_lengths->[-1] += 2;

                # repack
                $rline_alignment =
                  [ $rtokens, $rfields, $rpatterns, $rfield_lengths ];
            }
        }

        # ------------------------
        # define flag 'list_seqno'
        # ------------------------

        # This flag indicates if this line is contained in a multi-line list
        if ( !$is_block_comment ) {
            my $parent_seqno = $parent_seqno_to_go[$ibeg];
            $rvao_args->{list_seqno} = $ris_list_by_seqno->{$parent_seqno};
        }

        # The alignment tokens have been marked with nesting_depths, so we need
        # to pass nesting depths to the vertical aligner. They remain invariant
        # under all formatting operations.  Previously, level values were sent
        # to the aligner.  But they can be altered in welding and other
        # operations, and this can lead to alignment errors.
        my $nesting_depth_beg = $nesting_depth_to_go[$ibeg];
        my $nesting_depth_end = $nesting_depth_to_go[$iend];

        # A quirk in the definition of nesting depths is that the closing token
        # has the same depth as internal tokens.  The vertical aligner is
        # programmed to expect them to have the lower depth, so we fix this.
        if ( $is_closing_type{ $types_to_go[$ibeg] } ) { $nesting_depth_beg-- }
        if ( $is_closing_type{ $types_to_go[$iend] } ) { $nesting_depth_end-- }

        # Adjust nesting depths to keep -lp indentation for qw lists.  This is
        # required because qw lists contained in brackets do not get nesting
        # depths, but the vertical aligner is watching nesting depth changes to
        # decide if a -lp block is intact.  Without this patch, qw lists
        # enclosed in angle brackets will not get the correct -lp indentation.

        # Looking for line with isolated qw ...
        if (   $rOpts_line_up_parentheses
            && $type_beg eq 'q'
            && $ibeg == $iend )
        {

            # ... which is part of a multiline qw
            my $Km = $self->K_previous_nonblank($Kbeg);
            my $Kp = $self->K_next_nonblank($Kbeg);
            if (   defined($Km) && $rLL->[$Km]->[_TYPE_] eq 'q'
                || defined($Kp) && $rLL->[$Kp]->[_TYPE_] eq 'q' )
            {
                $nesting_depth_beg++;
                $nesting_depth_end++;
            }
        }

        # ---------------------------------
        # define flag 'forget_side_comment'
        # ---------------------------------

        # This flag tells the vertical aligner to reset the side comment
        # location if we are entering a new block from level 0.  This is
        # intended to keep side comments from drifting too far to the right.
        if (   $block_type_to_go[$i_terminal]
            && $nesting_depth_end > $nesting_depth_beg )
        {
            $rvao_args->{forget_side_comment} =
              !$self->[_radjusted_levels_]->[$Kbeg];
        }

        # -----------------------------------
        # Store the remaining non-flag values
        # -----------------------------------
        $rvao_args->{ci_level}        = $ci_levels_to_go[$ibeg];
        $rvao_args->{indentation}     = $indentation;
        $rvao_args->{level_end}       = $nesting_depth_end;
        $rvao_args->{level}           = $nesting_depth_beg;
        $rvao_args->{rline_alignment} = $rline_alignment;
        $rvao_args->{maximum_line_length} =
          $maximum_line_length_at_level[ $levels_to_go[$ibeg] ];

        # --------------------------------------
        # send this line to the vertical aligner
        # --------------------------------------
        my $vao = $self->[_vertical_aligner_object_];
        $vao->valign_input($rvao_args);

        $do_not_pad = 0;

    } ## end of loop to output each line

    # Set flag indicating if the last line ends in an opening
    # token and is very short, so that a blank line is not
    # needed if the subsequent line is a comment.
    # Examples of what we are looking for:
    #   {
    #   && (
    #   BEGIN {
    #   default {
    #   sub {
    $self->[_last_output_short_opening_token_]

      # line ends in opening token
      #              /^[\{\(\[L]$/
      = $is_opening_type{$type_end}

      # and either
      && (
        # line has either single opening token
        $iend == $ibeg

        # or is a single token followed by opening token.
        # Note that sub identifiers have blanks like 'sub doit'
        #                                 $token_beg !~ /\s+/
        || ( $iend - $ibeg <= 2 && index( $token_beg, SPACE ) < 0 )
      )

      # and limit total to 10 character widths
      && token_sequence_length( $ibeg, $iend ) <= 10;

    # Remember indentation of lines containing opening containers for
    # later use by sub get_final_indentation
    $self->save_opening_indentation($rindentation_list)
      if ( $this_batch->[_runmatched_opening_indexes_]
        || $types_to_go[$max_index_to_go] eq 'q' );

    # Output any new -cscw block comment
    if ($cscw_block_comment) {
        $self->flush_vertical_aligner();
        my $file_writer_object = $self->[_file_writer_object_];
        $file_writer_object->write_code_line( $cscw_block_comment . "\n" );
    }
    return;
} ## end sub convey_batch_to_vertical_aligner

sub check_batch_summed_lengths {

    my ( $self, ($msg) ) = @_;

    # Debug routine for summed lengths
    #   $msg = optional debug message

    $msg = EMPTY_STRING unless defined($msg);
    my $rLL = $self->[_rLL_];

    # Verify that the summed lengths are correct. We want to be sure that
    # errors have not been introduced by programming changes.  Summed lengths
    # are defined in sub store_token.  Operations like padding and unmasking
    # semicolons can change token lengths, but those operations are expected to
    # update the summed lengths when they make changes.  So the summed lengths
    # should always be correct.
    foreach my $i ( 0 .. $max_index_to_go ) {
        my $len_by_sum =
          $summed_lengths_to_go[ $i + 1 ] - $summed_lengths_to_go[$i];
        my $len_tok_i = $token_lengths_to_go[$i];
        my $KK        = $K_to_go[$i];
        my $len_tok_K;

        # For --indent-only, there is not always agreement between
        # token lengths in _rLL_ and token_lengths_to_go, so skip that check.
        if ( defined($KK) && !$rOpts_indent_only ) {
            $len_tok_K = $rLL->[$KK]->[_TOKEN_LENGTH_];
        }
        if ( $len_by_sum != $len_tok_i
            || defined($len_tok_K) && $len_by_sum != $len_tok_K )
        {
            my $lno = defined($KK) ? $rLL->[$KK]->[_LINE_INDEX_] + 1 : "undef";
            $KK = 'undef' unless defined($KK);
            my $tok  = $tokens_to_go[$i];
            my $type = $types_to_go[$i];
            Fault(<<EOM);
Summed lengths are appear to be incorrect.  $msg
lengths disagree: token length by sum=$len_by_sum but token_length_to_go[$i] = $len_tok_i and rLL->[$KK]->[_TOKEN_LENGTH_]=$len_tok_K
near line $lno starting with '$tokens_to_go[0]..' at token i=$i K=$KK token_type='$type' token='$tok'
EOM
        }
    }
    return;
} ## end sub check_batch_summed_lengths

{    ## begin closure set_vertical_alignment_markers
    my %is_vertical_alignment_type;
    my %is_not_vertical_alignment_token;
    my %is_vertical_alignment_keyword;
    my %is_terminal_alignment_type;
    my %is_low_level_alignment_token;

    BEGIN {

        my @q;

        # Replaced =~ and // in the list.  // had been removed in RT 119588
        @q = qw#
          = **= += *= &= <<= &&= -= /= |= >>= ||= //= .= %= ^= x=
          { ? : => && || ~~ !~~ =~ !~ // <=> ->
          #;
        @is_vertical_alignment_type{@q} = (1) x scalar(@q);

        # These 'tokens' are not aligned. We need this to remove [
        # from the above list because it has type ='{'
        @q = qw( [ );
        @is_not_vertical_alignment_token{@q} = (1) x scalar(@q);

        # these are the only types aligned at a line end
        @q = qw( && || => );
        @is_terminal_alignment_type{@q} = (1) x scalar(@q);

        # these tokens only align at line level
        @q = ( '{', '(' );
        @is_low_level_alignment_token{@q} = (1) x scalar(@q);

        # eq and ne were removed from this list to improve alignment chances
        @q = qw( if unless and or err for foreach while until );
        @is_vertical_alignment_keyword{@q} = (1) x scalar(@q);
    } ## end BEGIN

    # These are the main return variables. They are closure variables
    # for efficient access by sub .._token_loop needs.
    my $ralignment_type_to_go;
    my $ralignment_counts;

    sub set_vertical_alignment_markers {

        my ($self) = @_;

        # This routine looks at all output lines of a batch for certain tokens
        # which can serve as vertical alignment markers (such as an '=').

        # $ri_first = ref to list of starting line indexes in _to_go arrays
        # $ri_last  = ref to list of ending line indexes in _to_go arrays
        my $this_batch = $self->[_this_batch_];
        my $ri_first   = $this_batch->[_ri_first_];
        my $ri_last    = $this_batch->[_ri_last_];

        # Method: We look at each token $i in this output batch and set
        # $ralignment_type_to_go->[$i] equal to those tokens at which we would
        # accept vertical alignment.

        #----------------------------
        # Initialize return variables
        #----------------------------
        $ralignment_type_to_go = [];
        $ralignment_counts     = [];

        # NOTE: closing side comments can insert up to 2 additional tokens
        # beyond the original $max_index_to_go, so we need to check ri_last for
        # the last index.
        my $max_line = @{$ri_first} - 1;
        my $max_i    = $ri_last->[$max_line];
        if ( $max_i < $max_index_to_go ) { $max_i = $max_index_to_go }

        # -----------------------------------------------------------------
        # Shortcut:
        #    - no alignments if there is only 1 token.
        #    - and nothing to do if we aren't allowed to change whitespace.
        # -----------------------------------------------------------------
        if ( $max_i <= 0 || !$rOpts_add_whitespace ) {
            goto RETURN;
        }

        # -------------------------------
        # First handle any side comment.
        # -------------------------------
        my $i_terminal = $max_i;
        if ( $types_to_go[$max_i] eq '#' ) {

            # We know $max_i > 0 if we get here.
            $i_terminal -= 1;
            if ( $i_terminal > 0 && $types_to_go[$i_terminal] eq 'b' ) {
                $i_terminal -= 1;
            }

            my $token = $tokens_to_go[$max_i];
            my $KK    = $K_to_go[$max_i];

            my $is_closing_block = $types_to_go[$i_terminal] eq '}'
              && $tokens_to_go[$i_terminal] eq '}';

            # Patch to check for asub closing side comments (c380)
            # These follow '};' rather than bare '}'
            $is_closing_block ||=
                 $types_to_go[$i_terminal] eq ';'
              && $i_terminal == $inext_to_go[0]
              && $types_to_go[0] eq '}'
              && $tokens_to_go[0] eq '}';

            # Do not align various special side comments
            my $do_not_align = (

                # it is any specially marked side comment
                ( defined($KK) && $self->[_rspecial_side_comment_type_]->{$KK} )

                  # or it is a static side comment
                  || ( $rOpts->{'static-side-comments'}
                    && $token =~ /$static_side_comment_pattern/ )

                  # or a closing side comment
                  || ( $is_closing_block
                    && $token =~ /$closing_side_comment_prefix_pattern/ )
            );

            # - For the specific combination -vc -nvsc, we put all side comments
            #   at fixed locations. Note that we will lose hanging side comment
            #   alignments. Otherwise, hsc's can move to strange locations.
            # - For -nvc -nvsc we make all side comments vertical alignments
            #   because the vertical aligner will check for -nvsc and be able
            #   to reduce the final padding to the side comments for long lines.
            #   and keep hanging side comments aligned.
            if (   !$do_not_align
                && !$rOpts_valign_side_comments
                && $rOpts_valign_code )
            {

                $do_not_align = 1;
                my $ipad = $max_i - 1;
                if ( $types_to_go[$ipad] eq 'b' ) {
                    my $pad_spaces =
                      $rOpts->{'minimum-space-to-comment'} -
                      $token_lengths_to_go[$ipad];
                    $self->pad_token( $ipad, $pad_spaces );
                }
            }

            if ( !$do_not_align ) {
                $ralignment_type_to_go->[$max_i] = '#';
                $ralignment_counts->[$max_line]++;
            }
        }

        # ----------------------------------------------
        # Nothing more to do on this line if -nvc is set
        # ----------------------------------------------
        if ( !$rOpts_valign_code ) {
            goto RETURN;
        }

        # -------------------------------------
        # Loop over each line of this batch ...
        # -------------------------------------

        foreach my $nline ( 0 .. $max_line ) {

            my $ibeg = $ri_first->[$nline];
            my $iend = $ri_last->[$nline];

            next if ( $iend <= $ibeg );

            # back up before any side comment
            if ( $iend > $i_terminal ) { $iend = $i_terminal }

            #----------------------------------
            # Loop over all tokens on this line
            #----------------------------------
            $self->set_vertical_alignment_markers_token_loop( $nline, $ibeg,
                $iend );
        }

      RETURN:
        return ( $ralignment_type_to_go, $ralignment_counts );
    } ## end sub set_vertical_alignment_markers

    my %is_dot_question_colon;

    BEGIN {
        my @q = qw( . ? : );
        @is_dot_question_colon{@q} = (1) x scalar(@q);
    }

    sub set_vertical_alignment_markers_token_loop {
        my ( $self, $nline, $ibeg, $iend ) = @_;

        # Input parameters:
        #   $nline = index of this line in the current batch
        #   $ibeg, $iend = index range of tokens to check in the _to_go arrays

        # Task:
        # Set vertical alignment markers for the tokens on one line
        # of the current output batch. This is done by updating the
        # three closure variables needed by sub 'make_alignment_patterns':
        #  $ralignment_type_to_go - alignment type of tokens, like '=', if any
        #  $ralignment_counts - number of alignment tokens in the line

        my $level_beg = $levels_to_go[$ibeg];
        my $token_beg = $tokens_to_go[$ibeg];
        my $type_beg  = $types_to_go[$ibeg];

        my $last_vertical_alignment_BEFORE_index = -1;
        my $vert_last_nonblank_type              = $type_beg;

        # ----------------------------------------------------------------
        # Initialization code merged from 'sub delete_needless_alignments'
        # ----------------------------------------------------------------
        my $i_good_paren  = -1;
        my $i_elsif_close = $ibeg - 1;
        my $i_elsif_open  = $iend + 1;
        my @imatch_list;
        if ( $type_beg eq 'k' ) {

            # Initialization for paren patch: mark a location of a paren we
            # should keep, such as one following something like a leading
            # 'if', 'elsif',
            $i_good_paren = $ibeg + 1;
            if ( $types_to_go[$i_good_paren] eq 'b' ) {
                $i_good_paren++;
            }

            # Initialization for 'elsif' patch: remember the paren range of
            # an elsif, and do not make alignments within them because this
            # can cause loss of padding and overall brace alignment in the
            # vertical aligner.
            if (   $token_beg eq 'elsif'
                && $i_good_paren < $iend
                && $tokens_to_go[$i_good_paren] eq '(' )
            {
                $i_elsif_open  = $i_good_paren;
                $i_elsif_close = $mate_index_to_go[$i_good_paren];
                if ( !defined($i_elsif_close) ) { $i_elsif_close = -1 }
            }
        }

        # --------------------------------------------
        # Loop over each token in this output line ...
        # --------------------------------------------
        my $type;
        foreach my $i ( $ibeg + 1 .. $iend ) {

            next if ( ( $type = $types_to_go[$i] ) eq 'b' );

            my $token = $tokens_to_go[$i];
            my $alignment_type;

            # ----------------------------------------------
            # Check for 'paren patch' : Remove excess parens
            # ----------------------------------------------

            # Excess alignment of parens can prevent other good alignments.
            # For example, note the parens in the first two rows of the
            # following snippet.  They would normally get marked for
            # alignment and aligned as follows:

            #    my $w = $columns * $cell_w + ( $columns + 1 ) * $border;
            #    my $h = $rows * $cell_h +    ( $rows + 1 ) * $border;
            #    my $img = new Gimp::Image( $w, $h, RGB );

            # This causes unnecessary paren alignment and prevents the
            # third equals from aligning. If we remove the unwanted
            # alignments we get:

            #    my $w   = $columns * $cell_w + ( $columns + 1 ) * $border;
            #    my $h   = $rows * $cell_h + ( $rows + 1 ) * $border;
            #    my $img = new Gimp::Image( $w, $h, RGB );

            # A rule for doing this which works well is to remove alignment
            # of parens whose containers do not contain other aligning
            # tokens, with the exception that we always keep alignment of
            # the first opening paren on a line (for things like 'if' and
            # 'elsif' statements).
            if ( $token eq ')' && @imatch_list ) {

                # undo the corresponding opening paren if:
                # - it is at the top of the stack
                # - and not the first overall opening paren
                # - does not follow a leading keyword on this line
                my $imate = $mate_index_to_go[$i];
                if ( !defined($imate) ) { $imate = -1 }
                if (   $imatch_list[-1] eq $imate
                    && ( $ibeg > 1 || @imatch_list > 1 )
                    && $imate > $i_good_paren )
                {
                    if ( $ralignment_type_to_go->[$imate] ) {
                        $ralignment_type_to_go->[$imate] = EMPTY_STRING;
                        $ralignment_counts->[$nline]--;
                    }
                    pop @imatch_list;
                }
            }

            # do not align tokens at lower level than start of line
            # except for side comments
            if ( $levels_to_go[$i] < $level_beg ) {
                next;
            }

            #--------------------------------------------------------
            # First see if we want to align BEFORE this token
            #--------------------------------------------------------

            # The first possible token that we can align before
            # is index 2 because: 1) it doesn't normally make sense to
            # align before the first token and 2) the second
            # token must be a blank if we are to align before
            # the third
            if ( $i < $ibeg + 2 ) { }

            # must follow a blank token
            elsif ( $types_to_go[ $i - 1 ] ne 'b' ) { }

            # otherwise, do not align two in a row to create a
            # blank field
            elsif ( $last_vertical_alignment_BEFORE_index == $i - 2 ) { }

            # align before one of these keywords
            # (within a line, since $i>1)
            elsif ( $type eq 'k' ) {

                #  /^(if|unless|and|or|eq|ne)$/
                if ( $is_vertical_alignment_keyword{$token} ) {
                    $alignment_type = $token;

                    # Align postfix 'unless' and 'if' if requested (git #116)
                    # These are the only equivalent keywords. For equivalent
                    # token types see '%operator_map'.
                    if ( $token eq 'unless' && $rOpts_valign_if_unless ) {
                        $alignment_type = 'if';
                    }
                }
            }

            # align qw in a 'use' statement (issue git #93)
            elsif ( $type eq 'q' ) {
                if ( $types_to_go[0] eq 'k' && $tokens_to_go[0] eq 'use' ) {
                    $alignment_type = $type;
                }
            }

            # align before one of these types..
            elsif ( $is_vertical_alignment_type{$type}
                && !$is_not_vertical_alignment_token{$token} )
            {
                $alignment_type = $token;

                if ( $rOpts_valign_wide_equals && $is_assignment{$type} ) {
                    $alignment_type = '=';
                }

                # Do not align a terminal token.  Although it might
                # occasionally look ok to do this, this has been found to be
                # a good general rule.  The main problems are:
                # (1) that the terminal token (such as an = or :) might get
                # moved far to the right where it is hard to see because
                # nothing follows it, and
                # (2) doing so may prevent other good alignments.
                # Current exceptions are && and || and =>
                if ( $i == $iend ) {
                    $alignment_type = EMPTY_STRING
                      unless ( $is_terminal_alignment_type{$type} );
                }

                # Do not align leading ': (' or '. ('.  This would prevent
                # alignment in something like the following:
                #   $extra_space .=
                #       ( $input_line_number < 10 )  ? "  "
                #     : ( $input_line_number < 100 ) ? " "
                #     :                                "";
                # or
                #  $code =
                #      ( $case_matters ? $accessor : " lc($accessor) " )
                #    . ( $yesno        ? " eq "       : " ne " )

                # Also, do not align a ( following a leading ? so we can
                # align something like this:
                #   $converter{$_}->{ushortok} =
                #     $PDL::IO::Pic::biggrays
                #     ? ( m/GIF/          ? 0 : 1 )
                #     : ( m/GIF|RAST|IFF/ ? 0 : 1 );
                if (   $i == $ibeg + 2
                    && $is_dot_question_colon{$type_beg}
                    && $types_to_go[ $i - 1 ] eq 'b' )
                {
                    $alignment_type = EMPTY_STRING;
                }

                # Certain tokens only align at the same level as the
                # initial line level
                if (   $is_low_level_alignment_token{$token}
                    && $levels_to_go[$i] != $level_beg )
                {
                    $alignment_type = EMPTY_STRING;
                }

                if ( $token eq '(' ) {

                    # For a paren after keyword, only align if-like parens,
                    # such as:
                    #    if    ( $a ) { &a }
                    #    elsif ( $b ) { &b }
                    #          ^-------------------aligned parens
                    if ( $vert_last_nonblank_type eq 'k'
                        && !$is_if_unless_elsif{ $tokens_to_go[ $i - 2 ] } )
                    {
                        $alignment_type = EMPTY_STRING;
                    }

                    # Do not align a spaced-function-paren if requested.
                    # Issue git #53, #73.
                    if ( !$rOpts_function_paren_vertical_alignment ) {
                        my $seqno = $type_sequence_to_go[$i];
                        $alignment_type = EMPTY_STRING
                          if ( $self->[_ris_function_call_paren_]->{$seqno} );
                    }

                    # make () align with qw in a 'use' statement (git #93)
                    if (   $tokens_to_go[0] eq 'use'
                        && $types_to_go[0] eq 'k'
                        && defined( $mate_index_to_go[$i] )
                        && $mate_index_to_go[$i] == $i + 1 )
                    {
                        $alignment_type = 'q';

                        ## Note on discussion git #101. We could make this
                        ## a separate type '()' to separate it from qw's:
                        ## $alignment_type =
                        ##  $rOpts_valign_empty_parens_with_qw ? 'q' : '()';
                    }
                }

                # be sure the alignment tokens are unique
                # This experiment didn't work well: reason not determined
                # if ($token ne $type) {$alignment_type .= $type}
            }

            # make qw() functions using -qwaf align 'use' statement
            elsif ( $type eq 'U' ) {
                if (   $types_to_go[0] eq 'k'
                    && $tokens_to_go[0] eq 'use'
                    && substr( $token, 0, 2 ) eq 'qw' )
                {
                    $alignment_type = 'q';
                }
            }
            else {
                ## not a special type
            }

            # NOTE: This is deactivated because it causes the previous
            # if/elsif alignment to fail
            #elsif ( $type eq '}' && $token eq '}' && $block_type_to_go[$i])
            #{ $alignment_type = $type; }

            if ($alignment_type) {
                $last_vertical_alignment_BEFORE_index = $i;
            }

            #--------------------------------------------------------
            # Next see if we want to align AFTER the previous nonblank
            #--------------------------------------------------------

            # We want to line up ',' and interior ';' tokens, with the added
            # space AFTER these tokens.  (Note: interior ';' is included
            # because it may occur in short blocks).
            else {
                if (

                    # previous token IS one of these:
                    (
                           $vert_last_nonblank_type eq ','
                        || $vert_last_nonblank_type eq ';'
                    )

                    # and it follows a blank
                    && $types_to_go[ $i - 1 ] eq 'b'

                    # and it's NOT one of these
                    && !$is_closing_token{$type}

                    # then go ahead and align
                  )

                {
                    $alignment_type = $vert_last_nonblank_type;
                }
            }

            #-----------------------
            # Set the alignment type
            #-----------------------
            if ($alignment_type) {

                # but do not align the opening brace of an anonymous sub
                if (   $token eq '{'
                    && $block_type_to_go[$i]
                    && $matches_ASUB{ $block_type_to_go[$i] } )
                {

                }

                # and do not make alignments within 'elsif' parens
                elsif ( $i > $i_elsif_open && $i < $i_elsif_close ) {

                }

                # and ignore any tokens which have leading padded spaces
                # example: perl527/lop.t
                elsif ( substr( $alignment_type, 0, 1 ) eq SPACE ) {

                }

                else {
                    $ralignment_type_to_go->[$i] = $alignment_type;
                    $ralignment_counts->[$nline]++;
                    push @imatch_list, $i;
                }
            }

            $vert_last_nonblank_type = $type;
        }
        return;
    } ## end sub set_vertical_alignment_markers_token_loop

} ## end closure set_vertical_alignment_markers

sub make_HSC_vertical_alignments {

    # This is the alignment for a hanging side comment
    my $rline_alignments;

    #--------------------------------------
    # Case 1: no alignments if -naws is set
    #--------------------------------------
    if ( !$rOpts_add_whitespace ) {

        # Nothing to do if we are not allowed to add whitespace
        $rline_alignments = [
            [
                [], [ SPACE . $tokens_to_go[0] ],
                ['#'],
                [ 1 + $summed_lengths_to_go[1] - $summed_lengths_to_go[0] ],
            ]
        ];
    }

    #-----------------------
    # Case 2: -nvsc flag set
    #-----------------------
    # - For the specific combination -vc -nvsc, we put all side comments
    #   at fixed locations. Note that we will lose hanging side comment
    #   alignments. Otherwise, hsc's can move to strange locations.
    # - For -nvc -nvsc we make all side comments vertical alignments
    #   because the vertical aligner will check for -nvsc and be able
    #   to reduce the final padding to the side comments for long lines.
    #   and keep hanging side comments aligned.
    elsif ( !$rOpts_valign_side_comments && $rOpts_valign_code ) {
        my $pad_spaces = $rOpts->{'minimum-space-to-comment'};
        $rline_alignments = [
            [

                [],
                [ SPACE x $pad_spaces . $tokens_to_go[0] ],
                ['q'],
                [
                    $pad_spaces +
                      $summed_lengths_to_go[1] -
                      $summed_lengths_to_go[0]
                ],
            ]
        ];
    }

    #--------------------------------------
    # Case 3: Normal case of no constraints
    #--------------------------------------
    # Originally, a hanging side comment line was constructed as three tokens:
    #    type 'q' with zero length,
    #    type 'b' with length 1
    #    type '#' with the text of the comment
    # In this way, the comment became a true side comment through all of the
    # tokenization operations. However, this caused a problem (c269) with subs
    # K_next_* and K_previous_*, which would stop at the 'q' token.  Rather
    # than change those to skip an empty 'q', the hanging side comment was
    # left as a block comment but the line was marked as 'HSC'. Only when
    # we make the vertical alignments, right here, do we need to construct
    # the artificial 'q', 'b', '#' sequence for the vertical aligner.
    else {
        $rline_alignments = [
            [
                ['#'],
                [ SPACE, $tokens_to_go[0] ],
                [ 'qb',  '#' ],
                [ 1,     $summed_lengths_to_go[1] - $summed_lengths_to_go[0] ],
            ]
        ];
    }

    return $rline_alignments;
} ## end sub make_HSC_vertical_alignments

sub make_vertical_alignments {
    my ($self) = @_;

    my $this_batch = $self->[_this_batch_];
    my $ri_first   = $this_batch->[_ri_first_];
    my $ri_last    = $this_batch->[_ri_last_];

    # Given:
    #   $ri_first = ref to list of starting line indexes in _to_go arrays
    #   $ri_last  = ref to list of ending line indexes in _to_go arrays

    #----------------------------
    # Shortcut for a single token
    #----------------------------
    if ( $max_index_to_go == 0 ) {
        if ( @{$ri_first} == 1 && $ri_last->[0] == 0 ) {
            my $rtokens   = [];
            my $rfields   = [ $tokens_to_go[0] ];
            my $rpatterns = [ $types_to_go[0] ];
            my $rfield_lengths =
              [ $summed_lengths_to_go[1] - $summed_lengths_to_go[0] ];
            return [ [ $rtokens, $rfields, $rpatterns, $rfield_lengths ] ];
        }

        # Strange line packing, not fatal but should not happen
        else {

            if (DEVEL_MODE) {
                my $max_line = @{$ri_first} - 1;
                my $ibeg     = $ri_first->[0];
                my $iend     = $ri_last->[0];
                my $tok_b    = $tokens_to_go[$ibeg];
                my $tok_e    = $tokens_to_go[$iend];
                my $type_b   = $types_to_go[$ibeg];
                my $type_e   = $types_to_go[$iend];
                Fault(
"Strange..max_index=0 but nlines=$max_line ibeg=$ibeg tok=$tok_b type=$type_b iend=$iend tok=$tok_e type=$type_e; please check\n"
                );
            }
        }
    }

    #---------------------------------------------------------
    # Step 1: Define the alignment tokens for the entire batch
    #---------------------------------------------------------
    my ( $ralignment_type_to_go, $ralignment_counts );

    # We only need to make this call if vertical alignment of code is
    # requested or if a line might have a side comment.
    if (   $rOpts_valign_code
        || $types_to_go[$max_index_to_go] eq '#' )
    {
        ( $ralignment_type_to_go, $ralignment_counts ) =
          $self->set_vertical_alignment_markers();
    }

    #----------------------------------------------
    # Step 2: Break each line into alignment fields
    #----------------------------------------------
    my $rline_alignments = [];
    my $max_line         = @{$ri_first} - 1;
    foreach my $line ( 0 .. $max_line ) {

        my $ibeg = $ri_first->[$line];
        my $iend = $ri_last->[$line];

        my $rtok_fld_pat_len = $self->make_alignment_patterns(

            $ibeg,
            $iend,
            $ralignment_type_to_go,
            $ralignment_counts->[$line],

        );
        push @{$rline_alignments}, $rtok_fld_pat_len;
    }
    return $rline_alignments;
} ## end sub make_vertical_alignments

sub get_seqno {

    my ( $self, $ii ) = @_;

    # Get opening and closing sequence numbers of a token for the vertical
    # aligner.  Assign qw quotes a value to allow qw opening and closing tokens
    # to be treated somewhat like opening and closing tokens for stacking
    # tokens by the vertical aligner.

    # Given:
    #   $ii = index of token in the output batch

    my $rLL = $self->[_rLL_];

    my $KK    = $K_to_go[$ii];
    my $seqno = $rLL->[$KK]->[_TYPE_SEQUENCE_];

    if ( $rLL->[$KK]->[_TYPE_] eq 'q' ) {
        my $SEQ_QW = -1;
        my $token  = $rLL->[$KK]->[_TOKEN_];
        if ( $ii > 0 ) {
            $seqno = $SEQ_QW if ( $token =~ /^qw\s*[\(\{\[]/ );
        }
        else {
            # _ending_in_quote_ = true if line ends in quote
            if ( !$self->[_this_batch_]->[_ending_in_quote_] ) {
                $seqno = $SEQ_QW if ( $token =~ /[\)\}\]]$/ );
            }
        }
    }
    return ($seqno);
} ## end sub get_seqno

sub undo_contained_ci {

    my ( $self, $ri_first, $ri_last ) = @_;

    # Given:
    #   $ri_first = ref to list of starting line indexes in _to_go arrays
    #   $ri_last  = ref to list of ending line indexes in _to_go arrays

    # Undo ci for a sequence of lines in a container which all have both ci
    # and a jump in level. Written for issue git #137. This mainly occurs
    # in code with very long quotes when -nolq is set.  Examples:

    #    diag( 'Test run performed at: '
    #            . DateTime->now
    #            . ' with Moose '
    #            . ( Moose->VERSION || 'git repo' ) );
    #    $d = sqrt( ( $x->[$x_l] - $x->[$x_r] )**2 +
    #            ( $y->[$x_l] - $y->[$x_r] )**2 );

    # These all involve lines with ci within a complete container, where the
    # batch ends in ');' or '];' or '};' with possible side comment.  The
    # opening container token does not end a line, and this causes the double
    # jump.

    my $max_line = @{$ri_first} - 1;
    return if ( $max_line < 1 );

    my $ibeg_max = $ri_first->[$max_line];
    my $iend_max = $ri_last->[$max_line];
    my $i_opening;
    my $line_last;

    # Look for Case 1: last line begins with ');'
    if ( $is_closing_token{ $tokens_to_go[$ibeg_max] } ) {
        my $i_n = $inext_to_go[$ibeg_max];
        return if ( $i_n < $ibeg_max || $i_n > $iend_max );
        return if ( $types_to_go[$i_n] ne ';' );
        $i_opening = $mate_index_to_go[$ibeg_max];
        return if ( !defined($i_opening) || $i_opening <= 0 );
        $line_last = $max_line - 1;
    }

    # Look for Case 2: last line has some text which ends with ');'
    else {
        my $i_t = $iend_max;
        if ( $types_to_go[$i_t] eq '#' ) {
            $i_t = iprev_to_go($i_t);
        }
        return if ( $i_t <= $ibeg_max );
        return if ( $types_to_go[$i_t] ne ';' );
        $i_t = iprev_to_go($i_t);
        return if ( $i_t <= $ibeg_max );
        return if ( !$is_closing_token{ $tokens_to_go[$i_t] } );
        $i_opening = $mate_index_to_go[$i_t];
        return if ( !defined($i_opening) || $i_opening < 0 );
        $line_last = $max_line;
    }

    # Scan backwards to the line with the opening container,
    # looking for a set of lines with ci to remove which have
    # the same level and ci as the final line of the group
    my $ibeg_last  = $ri_first->[$line_last];
    my $level_last = $levels_to_go[$ibeg_last];
    return unless ( $ci_levels_to_go[$ibeg_last] );

    # do not change ci under -lp control
    return if ( ref( $reduced_spaces_to_go[$ibeg_last] ) );

    my $line_start = $line_last;
    foreach my $line ( reverse( 0 .. $line_last ) ) {
        my $ibeg = $ri_first->[$line];
        return if ( ref( $reduced_spaces_to_go[$ibeg] ) );
        last   if ( !$ci_levels_to_go[$ibeg] );
        last   if ( $levels_to_go[$ibeg] != $level_last );
        $line_start = $line;
    }

    # There must be a jump in level and ci from the line before the start,
    # and it must contain the opening container token.
    my $line_o = $line_start - 1;
    return if ( $line_o < 0 );
    my $ibeg_o = $ri_first->[$line_o];
    my $iend_o = $ri_last->[$line_o];
    return if ( $ci_levels_to_go[$ibeg_o] );
    return if ( $levels_to_go[$ibeg_o] >= $level_last );
    return if ( $i_opening < $ibeg_o || $i_opening > $iend_o );

    # ok to undo the ci of this group
    foreach my $line_t ( $line_start .. $line_last ) {
        my $ibeg_t = $ri_first->[$line_t];
        $ci_levels_to_go[$ibeg_t]      = 0;
        $leading_spaces_to_go[$ibeg_t] = $reduced_spaces_to_go[$ibeg_t];
    }
    return;
} ## end sub undo_contained_ci

{
    my %undo_extended_ci;

    sub initialize_undo_ci {
        %undo_extended_ci = ();
        return;
    }

    sub undo_ci {

        # Undo continuation indentation in certain sequences
        my ($self) = @_;

        my $this_batch = $self->[_this_batch_];
        my $ri_first   = $this_batch->[_ri_first_];
        my $ri_last    = $this_batch->[_ri_last_];
        my $rix_seqno_controlling_ci =
          $this_batch->[_rix_seqno_controlling_ci_];

        # Given:
        #   $ri_first = ref to list of starting line indexes in _to_go arrays
        #   $ri_last  = ref to list of ending line indexes in _to_go arrays
        #   $rix_seqno_controlling_ci = a control array

        my ( $line_1, $line_2 );
        my $max_line = @{$ri_first} - 1;

        my $rseqno_controlling_my_ci = $self->[_rseqno_controlling_my_ci_];

        # Prepare a list of controlling indexes for each line if required.
        # This is used for efficient processing below.  Note: this is
        # critical for speed. In the initial implementation I just looped
        # through the @$rix_seqno_controlling_ci list below. Using NYT_prof, I
        # found that this routine was causing a huge run time in large lists.
        # On a very large list test case, this new coding dropped the run time
        # of this routine from 30 seconds to 169 milliseconds.
        my @i_controlling_ci;
        if ( $rix_seqno_controlling_ci && @{$rix_seqno_controlling_ci} ) {
            my @tmp     = reverse @{$rix_seqno_controlling_ci};
            my $ix_next = pop @tmp;
            foreach my $line ( 0 .. $max_line ) {
                my $iend = $ri_last->[$line];
                while ( defined($ix_next) && $ix_next <= $iend ) {
                    push @{ $i_controlling_ci[$line] }, $ix_next;
                    $ix_next = pop @tmp;
                }
            }
        }

        # Loop over all lines of the batch ...

        # Workaround originally created for problem c007, in which the
        # combination -lp -xci could produce a "Program bug" message in unusual
        # circumstances.
        my $skip_SECTION_1;
        if (   $rOpts_line_up_parentheses
            && $rOpts_extended_continuation_indentation )
        {

            # Only set this flag if -lp is actually used here
            foreach my $line ( 0 .. $max_line ) {
                my $ibeg = $ri_first->[$line];
                if ( ref( $leading_spaces_to_go[$ibeg] ) ) {
                    $skip_SECTION_1 = 1;
                    last;
                }
            }
        }

        my $line_double_jump;
        foreach my $line ( 0 .. $max_line ) {

            my $ibeg = $ri_first->[$line];
            my $iend = $ri_last->[$line];

            #-----------------------------------
            # SECTION 1: Undo needless common CI
            #-----------------------------------

            # We are looking at leading tokens and looking for a sequence all
            # at the same level and all at a higher level than enclosing lines.

            # For example, we can undo continuation indentation in sort/map/grep
            # chains

            #    my $dat1 = pack( "n*",
            #        map { $_, $lookup->{$_} }
            #          sort { $a <=> $b }
            #          grep { $lookup->{$_} ne $default } keys %$lookup );

            # to become

            #    my $dat1 = pack( "n*",
            #        map { $_, $lookup->{$_} }
            #        sort { $a <=> $b }
            #        grep { $lookup->{$_} ne $default } keys %$lookup );

            if ( $line && !$skip_SECTION_1 ) {

                my $ibeg_last = $ri_first->[ $line - 1 ];
                my $lev       = $levels_to_go[$ibeg];
                my $lev_last  = $levels_to_go[$ibeg_last];

                # set flag for calling undo_contained_ci
                if (   $lev == $lev_last + 1
                    && $ci_levels_to_go[$ibeg]
                    && !$ci_levels_to_go[$ibeg_last] )
                {
                    $line_double_jump = $line;
                }

                # if we have started a chain..
                if ($line_1) {

                    # see if it continues..
                    if ( $lev == $lev_last ) {
                        if (   $types_to_go[$ibeg] eq 'k'
                            && $is_sort_map_grep{ $tokens_to_go[$ibeg] } )
                        {

                            # chain continues...
                            # check for chain ending at end of a statement
                            my $is_semicolon_terminated = (
                                $line == $max_line
                                  && (
                                    $types_to_go[$iend] eq ';'

                                    # with possible side comment
                                    || (   $types_to_go[$iend] eq '#'
                                        && $iend - $ibeg >= 2
                                        && $types_to_go[ $iend - 2 ] eq ';'
                                        && $types_to_go[ $iend - 1 ] eq 'b' )
                                  )
                            );

                            $line_2 = $line
                              if ($is_semicolon_terminated);
                        }
                        else {

                            # kill chain
                            $line_1 = undef;
                        }
                    }
                    elsif ( $lev < $lev_last ) {

                        # chain ends with previous line
                        $line_2 = $line - 1;
                    }
                    else {

                        # ( $lev > $lev_last )
                        # kill chain
                        $line_1 = undef;
                    }

                    # undo the continuation indentation if a chain ends
                    if ( defined($line_2) && defined($line_1) ) {
                        my $continuation_line_count = $line_2 - $line_1 + 1;
                        @ci_levels_to_go[ @{$ri_first}[ $line_1 .. $line_2 ] ]
                          = (0) x ($continuation_line_count)
                          if ( $continuation_line_count >= 0 );
                        @leading_spaces_to_go[ @{$ri_first}
                          [ $line_1 .. $line_2 ] ] =
                          @reduced_spaces_to_go[ @{$ri_first}
                          [ $line_1 .. $line_2 ] ];
                        $line_1 = undef;
                    }
                }

                # not in a chain yet..
                else {

                    # look for start of a new sort/map/grep chain
                    if ( $lev > $lev_last ) {
                        if (   $types_to_go[$ibeg] eq 'k'
                            && $is_sort_map_grep{ $tokens_to_go[$ibeg] } )
                        {
                            $line_1 = $line;
                        }
                    }
                }

            }

            #-------------------------------------
            # SECTION 2: Undo ci at cuddled blocks
            #-------------------------------------

            # Note that sub get_final_indentation will be called later to
            # actually do this, but for now we will tentatively mark cuddled
            # lines with ci=0 so that the the -xci loop which follows will be
            # correct at cuddles.
            if (
                $types_to_go[$ibeg] eq '}'
                && ( $nesting_depth_to_go[$iend] + 1 ==
                    $nesting_depth_to_go[$ibeg] )
              )
            {
                my $terminal_type = $types_to_go[$iend];
                if ( $terminal_type eq '#' && $iend > $ibeg ) {
                    $terminal_type = $types_to_go[ $iend - 1 ];
                    if ( $terminal_type eq '#' && $iend - 1 > $ibeg ) {
                        $terminal_type = $types_to_go[ $iend - 2 ];
                    }
                }

                # Patch for rt144979, part 2. Coordinated with part 1.
                # Skip cuddled braces.
                my $seqno_beg                = $type_sequence_to_go[$ibeg];
                my $is_cuddled_closing_brace = $seqno_beg
                  && $self->[_ris_cuddled_closing_brace_]->{$seqno_beg};

                if ( $terminal_type eq '{' && !$is_cuddled_closing_brace ) {
                    $ci_levels_to_go[$ibeg] = 0;
                }
            }

            #--------------------------------------------------------
            # SECTION 3: Undo ci set by sub extended_ci if not needed
            #--------------------------------------------------------

            # Undo the ci of the leading token if its controlling token
            # went out on a previous line without ci
            if ( $ci_levels_to_go[$ibeg] ) {
                my $Kbeg  = $K_to_go[$ibeg];
                my $seqno = $rseqno_controlling_my_ci->{$Kbeg};
                if ( $seqno && $undo_extended_ci{$seqno} ) {

                    # but do not undo ci set by the -lp flag
                    if ( !ref( $reduced_spaces_to_go[$ibeg] ) ) {
                        $ci_levels_to_go[$ibeg] = 0;
                        $leading_spaces_to_go[$ibeg] =
                          $reduced_spaces_to_go[$ibeg];
                    }
                }
            }

            # Flag any controlling opening tokens in lines without ci.  This
            # will be used later in the above if statement to undo the ci which
            # they added.  The array i_controlling_ci[$line] was prepared at
            # the top of this routine.
            if ( !$ci_levels_to_go[$ibeg]
                && defined( $i_controlling_ci[$line] ) )
            {
                foreach my $i ( @{ $i_controlling_ci[$line] } ) {
                    my $seqno = $type_sequence_to_go[$i];
                    $undo_extended_ci{$seqno} = 1;
                }
            }
        }

        #-------------------------------------
        # Undo ci in containers if -mci is set
        #-------------------------------------
        if ( $line_double_jump && $rOpts_minimize_continuation_indentation ) {
            $self->undo_contained_ci( $ri_first, $ri_last );
        }

        return;
    } ## end sub undo_ci
}

{    ## begin closure set_logical_padding
    my %is_math_op;

    BEGIN {

        my @q = qw( + - * / );
        @is_math_op{@q} = (1) x scalar(@q);
    }

    sub set_logical_padding {

        my ($self) = @_;

        # Look at a batch of lines and see if extra padding can improve the
        # alignment when there are certain leading operators. Here is an
        # example, in which some extra space is introduced before
        # '( $year' to make it line up with the subsequent lines:
        #
        #       if (   ( $Year < 1601 )
        #           || ( $Year > 2899 )
        #           || ( $EndYear < 1601 )
        #           || ( $EndYear > 2899 ) )
        #       {
        #           &Error_OutOfRange;
        #       }

        my $this_batch = $self->[_this_batch_];

        my $ri_first          = $this_batch->[_ri_first_];
        my $ri_last           = $this_batch->[_ri_last_];
        my $starting_in_quote = $this_batch->[_starting_in_quote_];

        my $max_line = @{$ri_first} - 1;

        my ( $ibeg, $ibeg_next, $ibegm, $iend, $iendm, $ipad, $pad_spaces,
            $tok_next, $type_next, $has_leading_op_next, $has_leading_op );

        # Patch to produce padding in the first line of short code blocks.
        # This is part of an update to fix cases b562 .. b983.
        # This is needed to compensate for a change which was made in 'sub
        # starting_one_line_block' to prevent blinkers.  Previously, that sub
        # would not look at the total block size and rely on sub
        # break_long_lines to break up long blocks. Consequently, the
        # first line of those batches would end in the opening block brace of a
        # sort/map/grep/eval block.  When this was changed to immediately check
        # for blocks which were too long, the opening block brace would go out
        # in a single batch, and the block contents would go out as the next
        # batch.  This caused the logic in this routine which decides if the
        # first line should be padded to be incorrect.  To fix this, we set a
        # flag if the previous batch ended in an opening sort/map/grep/eval
        # block brace, and use it to adjust the logic to compensate.

        # For example, the following would have previously been a single batch
        # but now is two batches.  We want to pad the line starting in '$dir':
        #    my (@indices) =                      # batch n-1  (prev batch n)
        #      sort {                             # batch n-1  (prev batch n)
        #            $dir eq 'left'               # batch n
        #          ? $cells[$a] <=> $cells[$b]    # batch n
        #          : $cells[$b] <=> $cells[$a];   # batch n
        #      } ( 0 .. $#cells );                # batch n

        my $rLL                  = $self->[_rLL_];
        my $rblock_type_of_seqno = $self->[_rblock_type_of_seqno_];

        my $is_short_block;
        if ( $K_to_go[0] > 0 ) {
            my $Kp = $K_to_go[0] - 1;
            if ( $Kp > 0 && $rLL->[$Kp]->[_TYPE_] eq 'b' ) {
                $Kp -= 1;
            }
            if ( $Kp > 0 && $rLL->[$Kp]->[_TYPE_] eq '#' ) {
                $Kp -= 1;
                if ( $Kp > 0 && $rLL->[$Kp]->[_TYPE_] eq 'b' ) {
                    $Kp -= 1;
                }
            }
            my $seqno = $rLL->[$Kp]->[_TYPE_SEQUENCE_];
            if ($seqno) {
                my $block_type = $rblock_type_of_seqno->{$seqno};
                if ($block_type) {
                    $is_short_block = $is_sort_map_grep_eval{$block_type};
                    $is_short_block ||= $want_one_line_block{$block_type};
                }
            }
        }

        # looking at each line of this batch..
        foreach my $line ( 0 .. $max_line - 1 ) {

            # see if the next line begins with a logical operator
            $ibeg      = $ri_first->[$line];
            $iend      = $ri_last->[$line];
            $ibeg_next = $ri_first->[ $line + 1 ];
            $tok_next  = $tokens_to_go[$ibeg_next];
            $type_next = $types_to_go[$ibeg_next];

            $has_leading_op_next = ( $type_next eq 'k' )
              ? $is_chain_operator{$tok_next}      # and, or
              : $is_chain_operator{$type_next};    # + - * / : ? && ||

            # Fix for git134
            if (  !$has_leading_op_next
                && $iend > $ibeg + 2
                && $types_to_go[ $ibeg + 1 ] eq 'b'
                && $is_opening_type{ $types_to_go[$ibeg] }
                && $nesting_depth_to_go[$iend] > $nesting_depth_to_go[$ibeg] )
            {
                my $iend_next = $ri_last->[ $line + 1 ];
                $self->pad_broken_list( $ibeg, $iend, $ibeg_next, $iend_next );
            }

            next unless ($has_leading_op_next);

            # next line must not be at lesser depth
            next
              if ( $nesting_depth_to_go[$ibeg] >
                $nesting_depth_to_go[$ibeg_next] );

            # identify the token in this line to be padded on the left
            $ipad = undef;

            # handle lines at same depth...
            if ( $nesting_depth_to_go[$ibeg] ==
                $nesting_depth_to_go[$ibeg_next] )
            {

                # if this is not first line of the batch ...
                if ( $line > 0 ) {

                    # and we have leading operator..
                    next if $has_leading_op;

                    # Introduce padding if..
                    # 1. the previous line is at lesser depth, or
                    # 2. the previous line ends in an assignment
                    # 3. the previous line ends in a 'return'
                    # 4. the previous line ends in a comma
                    # Example 1: previous line at lesser depth
                    #       if (   ( $Year < 1601 )      # <- we are here but
                    #           || ( $Year > 2899 )      #  list has not yet
                    #           || ( $EndYear < 1601 )   # collapsed vertically
                    #           || ( $EndYear > 2899 ) )
                    #       {
                    #
                    # Example 2: previous line ending in assignment:
                    #    $leapyear =
                    #        $year % 4   ? 0     # <- We are here
                    #      : $year % 100 ? 1
                    #      : $year % 400 ? 0
                    #      : 1;
                    #
                    # Example 3: previous line ending in comma:
                    #    push @expr,
                    #        /test/   ? undef
                    #      : eval($_) ? 1
                    #      : eval($_) ? 1
                    #      :            0;

                    # be sure levels agree (never indent after an indented 'if')
                    next
                      if ( $levels_to_go[$ibeg] ne $levels_to_go[$ibeg_next] );

                    # allow padding on first line after a comma but only if:
                    # (1) this is line 2 and
                    # (2) there are at more than three lines and
                    # (3) lines 3 and 4 have the same leading operator
                    # These rules try to prevent padding within a long
                    # comma-separated list.
                    my $ok_comma;
                    if (   $types_to_go[$iendm] eq ','
                        && $line == 1
                        && $max_line > 2 )
                    {
                        my $ibeg_next_next = $ri_first->[ $line + 2 ];
                        my $tok_next_next  = $tokens_to_go[$ibeg_next_next];
                        $ok_comma = $tok_next_next eq $tok_next;
                    }

                    my $ok_pad = (
                             $is_assignment{ $types_to_go[$iendm] }
                          || $ok_comma
                          || ( $nesting_depth_to_go[$ibegm] <
                            $nesting_depth_to_go[$ibeg] )
                          || ( $types_to_go[$iendm] eq 'k'
                            && $tokens_to_go[$iendm] eq 'return' )
                    );
                    next if ( !$ok_pad );

                    # we will add padding before the first token
                    $ipad = $ibeg;
                }

                # for first line of the batch..
                else {

                    # WARNING: Never indent if first line is starting in a
                    # continued quote, which would change the quote.
                    next if $starting_in_quote;

                    # if this is text after closing '}'
                    # then look for an interior token to pad
                    if ( $types_to_go[$ibeg] eq '}' ) {

                    }

                    # otherwise, we might pad if it looks really good
                    elsif ($is_short_block) {
                        $ipad = $ibeg;
                    }
                    else {

                        # we might pad token $ibeg, so be sure that it
                        # is at the same depth as the next line.
                        next
                          if ( $nesting_depth_to_go[$ibeg] !=
                            $nesting_depth_to_go[$ibeg_next] );

                        # We can pad on line 1 of a statement if at least 3
                        # lines will be aligned. Otherwise, it
                        # can look very confusing.

                 # We have to be careful not to pad if there are too few
                 # lines.  The current rule is:
                 # (1) in general we require at least 3 consecutive lines
                 # with the same leading chain operator token,
                 # (2) but an exception is that we only require two lines
                 # with leading colons if there are no more lines.  For example,
                 # the first $i in the following snippet would get padding
                 # by the second rule:
                 #
                 #   $i == 1 ? ( "First", "Color" )
                 # : $i == 2 ? ( "Then",  "Rarity" )
                 # :           ( "Then",  "Name" );

                        next if ( $max_line <= 1 );

                        my $leading_token = $tokens_to_go[$ibeg_next];
                        my $tokens_differ;

                        # never indent line 1 of a '.' series because
                        # previous line is most likely at same level.
                        # TODO: we should also look at the leading_spaces
                        # of the last output line and skip if it is same
                        # as this line.
                        next if ( $leading_token eq '.' );

                        my $count = 1;
                        foreach my $l ( 2 .. 3 ) {
                            last if ( $line + $l > $max_line );
                            $count++;
                            my $ibeg_next_next = $ri_first->[ $line + $l ];
                            next
                              if ( $tokens_to_go[$ibeg_next_next] eq
                                $leading_token );
                            $tokens_differ = 1;
                            last;
                        }
                        next if ($tokens_differ);
                        next if ( $count < 3 && $leading_token ne ':' );
                        $ipad = $ibeg;
                    }
                }
            }

            # find interior token to pad if necessary
            if ( !defined($ipad) ) {

                foreach my $i ( $ibeg .. $iend - 1 ) {

                    # find any unclosed container
                    next
                      if ( !$type_sequence_to_go[$i]
                        || !defined( $mate_index_to_go[$i] )
                        || $mate_index_to_go[$i] <= $iend );

                    # find next nonblank token to pad
                    $ipad = $inext_to_go[$i];
                    last if $ipad;
                }
                last if ( !$ipad || $ipad > $iend );
            }

            # We cannot pad the first leading token of a file because
            # it could cause a bug in which the starting indentation
            # level is guessed incorrectly each time the code is run
            # though perltidy, thus causing the code to march off to
            # the right.  For example, the following snippet would have
            # this problem:

##     ov_method mycan( $package, '(""' ),       $package
##  or ov_method mycan( $package, '(0+' ),       $package
##  or ov_method mycan( $package, '(bool' ),     $package
##  or ov_method mycan( $package, '(nomethod' ), $package;

            # If this snippet is within a block this won't happen
            # unless the user just processes the snippet alone within
            # an editor.  In that case either the user will see and
            # fix the problem or it will be corrected next time the
            # entire file is processed with perltidy.
            my $peak_batch_size = $this_batch->[_peak_batch_size_];
            next if ( $ipad == 0 && $peak_batch_size <= 1 );

            # next line must not be at greater depth
            my $iend_next = $ri_last->[ $line + 1 ];
            next
              if ( $nesting_depth_to_go[ $iend_next + 1 ] >
                $nesting_depth_to_go[$ipad] );

            # lines must be somewhat similar to be padded..
            my $inext_next = $inext_to_go[$ibeg_next];
            my $type       = $types_to_go[$ipad];

            # see if there are multiple continuation lines
            my $logical_continuation_lines = 1;
            if ( $line + 2 <= $max_line ) {
                my $leading_token  = $tokens_to_go[$ibeg_next];
                my $ibeg_next_next = $ri_first->[ $line + 2 ];
                if (   $tokens_to_go[$ibeg_next_next] eq $leading_token
                    && $nesting_depth_to_go[$ibeg_next] eq
                    $nesting_depth_to_go[$ibeg_next_next] )
                {
                    $logical_continuation_lines++;
                }
            }

            # see if leading types match
            my $types_match = $types_to_go[$inext_next] eq $type;
            my $matches_without_bang;

            # if first line has leading ! then compare the following token
            if ( !$types_match && $type eq '!' ) {
                $types_match = $matches_without_bang =
                  $types_to_go[$inext_next] eq $types_to_go[ $ipad + 1 ];
            }
            if (

                # either we have multiple continuation lines to follow
                # and we are not padding the first token
                (
                    $logical_continuation_lines > 1
                    && ( $ipad > 0 || $is_short_block )
                )

                # or..
                || (

                    # types must match
                    $types_match

                    # and keywords must match if keyword
                    && !(
                           $type eq 'k'
                        && $tokens_to_go[$ipad] ne $tokens_to_go[$inext_next]
                    )
                )
              )
            {

                #----------------------begin special checks--------------
                #
                # SPECIAL CHECK 1:
                # A check is needed before we can make the pad.
                # If we are in a list with some long items, we want each
                # item to stand out.  So in the following example, the
                # first line beginning with '$casefold->' would look good
                # padded to align with the next line, but then it
                # would be indented more than the last line, so we
                # won't do it.
                #
                #  ok(
                #      $casefold->{code}         eq '0041'
                #        && $casefold->{status}  eq 'C'
                #        && $casefold->{mapping} eq '0061',
                #      'casefold 0x41'
                #  );
                #
                # Note:
                # It would be faster, and almost as good, to use a comma
                # count, and not pad if comma_count > 1 and the previous
                # line did not end with a comma.
                #
                my $ok_to_pad = 1;

                my $ibg   = $ri_first->[ $line + 1 ];
                my $depth = $nesting_depth_to_go[ $ibg + 1 ];

                # just use simplified formula for leading spaces to avoid
                # needless sub calls
                my $lsp = $levels_to_go[$ibg] + $ci_levels_to_go[$ibg];

                # look at each line beyond the next ..
                my $l = $line + 1;
                foreach my $ltest ( $line + 2 .. $max_line ) {
                    $l = $ltest;
                    my $ibeg_t = $ri_first->[$l];

                    # quit looking at the end of this container
                    last
                      if ( $nesting_depth_to_go[ $ibeg_t + 1 ] < $depth )
                      || ( $nesting_depth_to_go[$ibeg_t] < $depth );

                    # cannot do the pad if a later line would be
                    # outdented more
                    if ( $levels_to_go[$ibeg_t] + $ci_levels_to_go[$ibeg_t] <
                        $lsp )
                    {
                        $ok_to_pad = 0;
                        last;
                    }
                }

                # don't pad if we end in a broken list
                if ( $l == $max_line ) {
                    my $i2 = $ri_last->[$l];
                    if ( $types_to_go[$i2] eq '#' ) {
                        my $i1 = $ri_first->[$l];
                        next if terminal_type_i( $i1, $i2 ) eq ',';
                    }
                }

                # SPECIAL CHECK 2:
                # a minus may introduce a quoted variable, and we will
                # add the pad only if this line begins with a bare word,
                # such as for the word 'Button' here:
                #    [
                #         Button      => "Print letter \"~$_\"",
                #        -command     => [ sub { print "$_[0]\n" }, $_ ],
                #        -accelerator => "Meta+$_"
                #    ];
                #
                #  On the other hand, if 'Button' is quoted, it looks best
                #  not to pad:
                #    [
                #        'Button'     => "Print letter \"~$_\"",
                #        -command     => [ sub { print "$_[0]\n" }, $_ ],
                #        -accelerator => "Meta+$_"
                #    ];
                if ( $types_to_go[$ibeg_next] eq 'm' ) {
                    $ok_to_pad = 0 if $types_to_go[$ibeg] eq 'Q';
                }

                next unless $ok_to_pad;

                #----------------------end special check---------------

                my $length_1 = total_line_length( $ibeg,      $ipad - 1 );
                my $length_2 = total_line_length( $ibeg_next, $inext_next - 1 );
                $pad_spaces = $length_2 - $length_1;

                # If the first line has a leading ! and the second does
                # not, then remove one space to try to align the next
                # leading characters, which are often the same.  For example:
                #  if (  !$ts
                #      || $ts == $self->Holder
                #      || $self->Holder->Type eq "Arena" )
                #
                # This usually helps readability, but if there are subsequent
                # ! operators things will still get messed up.  For example:
                #
                #  if (  !exists $Net::DNS::typesbyname{$qtype}
                #      && exists $Net::DNS::classesbyname{$qtype}
                #      && !exists $Net::DNS::classesbyname{$qclass}
                #      && exists $Net::DNS::typesbyname{$qclass} )
                # We can't fix that.
                if ($matches_without_bang) { $pad_spaces-- }

                # make sure this won't change if -lp is used
                my $indentation_1 = $leading_spaces_to_go[$ibeg];
                if ( ref($indentation_1)
                    && $indentation_1->get_recoverable_spaces() == 0 )
                {
                    my $indentation_2 = $leading_spaces_to_go[$ibeg_next];
                    if ( ref($indentation_2)
                        && $indentation_2->get_recoverable_spaces() != 0 )
                    {
                        $pad_spaces = 0;
                    }
                }

                # we might be able to handle a pad of -1 by removing a blank
                # token.
                if ( $pad_spaces < 0 ) {

                    # Deactivated for -kpit due to conflict. This block deletes
                    # a space in an attempt to improve alignment in some cases,
                    # but it may conflict with user spacing requests.  For now
                    # it is just deactivated if the -kpit option is used.
                    if ( $pad_spaces == -1 ) {
                        if (
                               $ipad > $ibeg
                            && $types_to_go[ $ipad - 1 ] eq 'b'
                            && !%keyword_paren_inner_tightness

                            # additional tests added for c385:
                            && (
                                $types_to_go[$inext_next] eq $types_to_go[$ipad]
                                || (
                                    $types_to_go[$ipad] eq '!'
                                    && ( $types_to_go[ $ipad + 1 ] eq
                                        $types_to_go[$inext_next] )
                                )
                            )
                          )
                        {
                            $self->pad_token( $ipad - 1, $pad_spaces );
                        }
                    }
                    $pad_spaces = 0;
                }

                # now apply any padding for alignment
                if ( $ipad >= 0 && $pad_spaces ) {

                    my $length_t = total_line_length( $ibeg, $iend );
                    if ( $pad_spaces + $length_t <=
                        $maximum_line_length_at_level[ $levels_to_go[$ibeg] ] )
                    {
                        $self->pad_token( $ipad, $pad_spaces );
                    }
                }
            }
        }
        continue {
            $iendm          = $iend;
            $ibegm          = $ibeg;
            $has_leading_op = $has_leading_op_next;
        } ## end of loop over lines
        return;
    } ## end sub set_logical_padding
} ## end closure set_logical_padding

sub pad_broken_list {
    my ( $self, $ibeg, $iend, $ibeg_next, $iend_next ) = @_;

    # Given:
    #   $ibeg, $iend           = index range of line to get padding
    #   $ibeg_next, $iend_next = index range of next line

    # This fixes a minor issue discussed in git134. In the example shown
    # below, the is a broken list because of the q term, so line breaks
    # are copied from the input. We want to insert padding at
    # '[ $clientKey,' to align with the next line.

    #    $q->do(
    #        q{
    #          Something
    #        },
    #        [ $clientKey,        ## <-- pad spaces needed here
    #            $systemKey,
    #        ],
    #    );

    # Notation for the line being padded:
    #
    #    [ $clientKey,
    #    | |         |
    #    | |         ------- $iend
    #    | ------ $ibeg+2
    #    ---- $ibeg

    # NOTES:
    # - This particular list is broken because of the 'q' term in the list
    # - It is extremely rare for this routine to be called for typical code
    #   (I found just two examples in my large collection of test scripts)
    # - This routine is not called for the last line of a batch. This
    #   is not necessary because perltidy will generally put a break
    #   after the opening token in that case.

    # The basic logic is to pad the first blank space $ibeg+1 using the
    # leading spaces that would have been given to token at $ibeg+2 if:
    # - this line begins with an opening token which is
    # - followed by additional tokens on the same line,
    # - and is a list container, and
    # - the line terminates in a comma whose parent is this container,
    # - then pad using the indentation of the second token

    # So in other words, we are simulating doing a line break after the
    # first token and then recombining with a -vt operation. That cannot
    # actually happen for a broken list.

    # Next token must be blank for padding, and must be followed
    # by at least one token and comma
    return if ( $iend < $ibeg + 3 || $types_to_go[ $ibeg + 1 ] ne 'b' );

    # This is only for lists
    my $seqno = $type_sequence_to_go[$ibeg];
    return if ( !$seqno );
    my $is_list = $self->[_ris_list_by_seqno_]->{$seqno};
    return if ( !$is_list );

    # First token on next line must be in same container
    my $seqno_beg_next = $parent_seqno_to_go[$ibeg_next];
    return if ( !$seqno_beg_next || $seqno_beg_next != $seqno );

    # This does not work well if the closing token is on the next line
    return
      if ( !defined( $mate_index_to_go[$ibeg] )
        || $mate_index_to_go[$ibeg] <= $iend_next );

    # Line must end in a comma, with possible side comment
    my $i_terminal = $iend;
    if ( $types_to_go[$i_terminal] eq '#' ) {
        $i_terminal -= 1;
        if ( $types_to_go[$i_terminal] eq 'b' ) {
            $i_terminal -= 1;
        }
    }
    return if ( $i_terminal < $ibeg + 2 );
    return if ( $types_to_go[$i_terminal] ne ',' );

    # add padding to make the second token have the same location
    # as if it had been output separately and later joined with -vt
    my $lsp      = $leading_spaces_to_go[$ibeg];
    my $lsp_next = $leading_spaces_to_go[$ibeg_next];

    # this is not for -lp style
    return if ( ref($lsp) || ref($lsp_next) );

    my $pad_spaces =
      $lsp_next -
      ( $lsp + $token_lengths_to_go[$ibeg] +
          $token_lengths_to_go[ $ibeg + 1 ] );

    return if ( $pad_spaces <= 0 );

    # Do not pad if it will cause excess line length
    my $excess = $self->excess_line_length( $ibeg, $iend );
    return if ( $excess + $pad_spaces > 0 );

    $self->pad_token( $ibeg + 1, $pad_spaces );
    return;
} ## end sub pad_broken_list

sub pad_token {

    # insert $pad_spaces before token number $ipad
    my ( $self, $ipad, $pad_spaces ) = @_;
    my $rLL     = $self->[_rLL_];
    my $KK      = $K_to_go[$ipad];
    my $tok     = $rLL->[$KK]->[_TOKEN_];
    my $tok_len = $rLL->[$KK]->[_TOKEN_LENGTH_];

    if ( $pad_spaces > 0 ) {
        $tok = SPACE x $pad_spaces . $tok;
        $tok_len += $pad_spaces;
    }
    elsif ( $pad_spaces == 0 ) {
        return;
    }
    elsif ( $pad_spaces == -1 && $tokens_to_go[$ipad] eq SPACE ) {
        $tok     = EMPTY_STRING;
        $tok_len = 0;
    }
    else {

        # shouldn't happen
        DEVEL_MODE
          && Fault("unexpected request for pad spaces = $pad_spaces\n");
        return;
    }

    $tok     = $rLL->[$KK]->[_TOKEN_]        = $tok;
    $tok_len = $rLL->[$KK]->[_TOKEN_LENGTH_] = $tok_len;

    $token_lengths_to_go[$ipad] += $pad_spaces;
    $tokens_to_go[$ipad] = $tok;

    foreach my $i ( $ipad .. $max_index_to_go ) {
        $summed_lengths_to_go[ $i + 1 ] += $pad_spaces;
    }
    return;
} ## end sub pad_token

sub xlp_tweak {

    my ($self) = @_;

    # Remove one indentation space from unbroken containers marked with
    # 'K_extra_space'.  These are mostly two-line lists with short names
    # formatted with -xlp -pt=2.
    #
    # Before this fix (extra space in line 2):
    #    is($module->VERSION, $expected,
    #        "$main_module->VERSION matches $module->VERSION ($expected)");
    #
    # After this fix:
    #    is($module->VERSION, $expected,
    #       "$main_module->VERSION matches $module->VERSION ($expected)");
    #
    # Notes:
    #  - This fixes issue git #106
    #  - This must be called after 'set_logical_padding'.
    #  - This is currently only applied to -xlp. It would also work for -lp
    #    but that style is essentially frozen.

    my $this_batch = $self->[_this_batch_];
    my $ri_first   = $this_batch->[_ri_first_];
    my $ri_last    = $this_batch->[_ri_last_];

    # Must be 2 or more lines
    return if ( @{$ri_first} <= 1 );

    # Pull indentation object from start of second line
    my $ibeg_1    = $ri_first->[1];
    my $lp_object = $leading_spaces_to_go[$ibeg_1];
    return if ( !ref($lp_object) );

    # This only applies to an indentation object with a marked token
    my $K_extra_space = $lp_object->get_K_extra_space();
    return unless ($K_extra_space);

    # Look for the marked token within the first line of this batch
    my $ibeg_0 = $ri_first->[0];
    my $iend_0 = $ri_last->[0];
    my $ii     = $ibeg_0 + $K_extra_space - $K_to_go[$ibeg_0];
    return if ( $ii <= $ibeg_0 || $ii > $iend_0 );

    # Skip padded tokens, they have already been aligned
    my $tok = $tokens_to_go[$ii];
    return if ( substr( $tok, 0, 1 ) eq SPACE );

    # Skip 'if'-like statements, this does not improve them
    return
      if ( $types_to_go[$ibeg_0] eq 'k'
        && $is_if_unless_elsif{ $tokens_to_go[$ibeg_0] } );

    # Looks okay, reduce indentation by 1 space if possible
    my $spaces = $lp_object->get_spaces();
    if ( $spaces > 0 ) {
        $lp_object->decrease_SPACES(1);
    }

    return;
} ## end sub xlp_tweak

{    ## begin closure make_alignment_patterns

    my %keyword_map;
    my %operator_map;
    my %is_k_w_n_C_bang;
    my %is_my_local_our;
    my %is_use_like;
    my %is_binary_type;
    my %is_binary_keyword;
    my %name_map;

    BEGIN {

        # Note: %block_type_map is now global to enable the -gal=s option

        # Map certain keywords to the same 'if' class to align
        # long if/elsif sequences. [elsif.pl]. But note that this is
        # only for purposes of making the patterns, not alignment tokens.
        # The only possible equivalent alignment tokens are 'if' and 'unless',
        # and this is handled earlier under control of $rOpts_valign_if_unless
        # to avoid making this a global hash.
        %keyword_map = (
            'unless'  => 'if',
            'else'    => 'if',
            'elsif'   => 'if',
            'when'    => 'given',
            'default' => 'given',
            'case'    => 'switch',

            # treat an 'undef' similar to numbers and quotes
            'undef' => 'Q',
        );

        # Map certain operators to the same class for alignment.
        # Note that this map is for the alignment tokens, not the patterns.
        # We could have placed 'unless' => 'if' here, but since that is
        # under control of $rOpts_valign_if_unless, it is handled elsewhere.
        %operator_map = (
            '!~' => '=~',
            '+=' => '+=',
            '-=' => '+=',
            '*=' => '+=',
            '/=' => '+=',
        );

        %is_k_w_n_C_bang = (
            'k' => 1,
            'w' => 1,
            'n' => 1,
            'C' => 1,
            '!' => 1,
        );

        # leading keywords which to skip for efficiency when making parenless
        # container names
        my @q = qw( my local our return );
        @is_my_local_our{@q} = (1) x scalar(@q);

        # leading keywords where we should just join one token to form
        # parenless name
        @q = qw( use );
        @is_use_like{@q} = (1) x scalar(@q);

        # token types which prevent using leading word as a container name
        @q = qw{
          x / : % . | ^ < = > || >= != *= => !~ == && |= .= -= =~ += <=
          %= ^= x= ~~ ** << /= &= // >> ~. &. |. ^.
          **= <<= >>= &&= ||= //= <=> !~~ &.= |.= ^.= <<~
        };
        push @q, ',';
        @is_binary_type{@q} = (1) x scalar(@q);

        # token keywords which prevent using leading word as a container name
        @q = qw( and or err eq ne cmp );
        @is_binary_keyword{@q} = (1) x scalar(@q);

        # Some common function calls whose args can be aligned.  These do not
        # give good alignments if the lengths differ significantly.
        %name_map = (
            'unlike' => 'like',
            'isnt'   => 'is',
            ##'is_deeply' => 'is',   # poor; names lengths too different
        );

    } ## end BEGIN

    sub make_alignment_patterns {

        my (
            $self,

            $ibeg,
            $iend,
            $ralignment_type_to_go,
            $alignment_count,

        ) = @_;

        #------------------------------------------------------------------
        # This sub creates arrays of vertical alignment info for one output
        # line.
        #------------------------------------------------------------------

        # Input parameters:
        #  $ibeg, $iend - index range of this line in the _to_go arrays
        #  $ralignment_type_to_go - alignment type of tokens, like '=', if any
        #  $alignment_count - number of alignment tokens in the line

        # The arrays which are created contain strings that can be tested by
        # the vertical aligner to see if consecutive lines can be aligned
        # vertically.
        #
        # The four arrays are indexed on the vertical
        # alignment fields and are:
        # @tokens - a list of any vertical alignment tokens for this line.
        #   These are tokens, such as '=' '&&' '#' etc which
        #   we want to might align vertically.  These are
        #   decorated with various information such as
        #   nesting depth to prevent unwanted vertical
        #   alignment matches.
        # @fields - the actual text of the line between the vertical alignment
        #   tokens.
        # @patterns - a modified list of token types, one for each alignment
        #   field.  These should normally each match before alignment is
        #   allowed, even when the alignment tokens match.
        # @field_lengths - the display width of each field

        # -------------------------------------
        # Shortcut for lines without alignments
        # -------------------------------------
        if ( !$alignment_count ) {
            my $rtokens = [];
            my $rfield_lengths =
              [ $summed_lengths_to_go[ $iend + 1 ] -
                  $summed_lengths_to_go[$ibeg] ];
            my $rpatterns;
            my $rfields;
            if ( $ibeg == $iend ) {
                $rfields   = [ $tokens_to_go[$ibeg] ];
                $rpatterns = [ $types_to_go[$ibeg] ];
            }
            else {
                $rfields =
                  [ join( EMPTY_STRING, @tokens_to_go[ $ibeg .. $iend ] ) ];
                $rpatterns =
                  [ join( EMPTY_STRING, @types_to_go[ $ibeg .. $iend ] ) ];
            }
            return [ $rtokens, $rfields, $rpatterns, $rfield_lengths ];
        }

        my $i_start              = $ibeg;
        my $depth                = 0;
        my $i_depth_prev         = $i_start;
        my $depth_prev           = $depth;
        my %container_name       = ( 0 => EMPTY_STRING );
        my $saw_exclamation_mark = 0;

        my @tokens        = ();
        my @fields        = ();
        my @patterns      = ();
        my @field_lengths = ();

        #-------------------------------------------------------------
        # Make a container name for any uncontained commas, issue c089
        #-------------------------------------------------------------
        # This is a generalization of the fix for rt136416 which was a
        # specialized patch just for 'use Module' statements.
        # We restrict this to semicolon-terminated statements; that way
        # we know that the top level commas are not in a list container.
        if ( $ibeg == 0 && $iend == $max_index_to_go ) {
            my $iterm = $max_index_to_go;
            if ( $types_to_go[$iterm] eq '#' ) {
                $iterm = iprev_to_go($iterm);
            }

            # Alignment lines ending like '=> sub {';  fixes issue c093
            my $term_type_ok = $types_to_go[$iterm] eq ';';
            $term_type_ok ||=
              $tokens_to_go[$iterm] eq '{' && $block_type_to_go[$iterm];

            if (   $iterm > $ibeg
                && $term_type_ok
                && !$is_my_local_our{ $tokens_to_go[$ibeg] }
                && $levels_to_go[$ibeg] eq $levels_to_go[$iterm] )
            {
                $container_name{'0'} =
                  make_uncontained_comma_name( $ibeg, $iterm );
            }
        }

        #--------------------------------
        # Begin main loop over all tokens
        #--------------------------------
        my $j = 0;    # field index

        $patterns[0] = EMPTY_STRING;
        my %token_count;
        my $type;
        for my $i ( $ibeg .. $iend ) {

            # handle a blank space
            if ( ( $type = $types_to_go[$i] ) eq 'b' ) {
                $patterns[$j] .= $type;
                next;
            }

            #-------------------------------------------------------------
            # Part 1: keep track of containers balanced on this line only.
            #-------------------------------------------------------------
            # These are used below to prevent unwanted cross-line alignments.
            # Unbalanced containers already avoid aligning across
            # container boundaries.
            if ( $type_sequence_to_go[$i] ) {
                my $token = $tokens_to_go[$i];
                if ( $is_opening_token{$token} ) {

                    # if container is balanced on this line...
                    my $i_mate = $mate_index_to_go[$i];
                    if ( !defined($i_mate) ) { $i_mate = -1 }
                    if ( $i_mate > $i && $i_mate <= $iend ) {
                        $i_depth_prev = $i;
                        $depth_prev   = $depth;
                        $depth++;

                     # Append the previous token name to make the container name
                     # more unique.  This name will also be given to any commas
                     # within this container, and it helps avoid undesirable
                     # alignments of different types of containers.

                     # Containers beginning with { and [ are given those names
                     # for uniqueness. That way commas in different containers
                     # will not match. Here is an example of what this prevents:
                     #   a => [ 1,       2, 3 ],
                     #   b => { b1 => 4, b2 => 5 },
                     # Here is another example of what we avoid by labeling the
                     # commas properly:

                   # is_d( [ $a,        $a ], [ $b,               $c ] );
                   # is_d( { foo => $a, bar => $a }, { foo => $b, bar => $c } );
                   # is_d( [ \$a,       \$a ], [ \$b,             \$c ] );

                        my $name =
                          $token eq '(' ? $self->make_paren_name($i) : $token;

                        # name cannot be '.', so change to something else if so
                        if ( $name eq '.' ) { $name = 'dot' }

                        $container_name{$depth} = "+" . $name;

                        # Make the container name even more unique if necessary.
                        # If we are not vertically aligning this opening paren,
                        # append a character count to avoid bad alignment since
                        # it usually looks bad to align commas within containers
                        # for which the opening parens do not align.  Here
                        # is an example very BAD alignment of commas (because
                        # the atan2 functions are not all aligned):
                        #    $XY =
                        #      $X * $RTYSQP1 * atan2( $X, $RTYSQP1 ) +
                        #      $Y * $RTXSQP1 * atan2( $Y, $RTXSQP1 ) -
                        #      $X * atan2( $X,            1 ) -
                        #      $Y * atan2( $Y,            1 );
                        #
                        # On the other hand, it is usually okay to align commas
                        # if opening parens align, such as:
                        #    glVertex3d( $cx + $s * $xs, $cy,            $z );
                        #    glVertex3d( $cx,            $cy + $s * $ys, $z );
                        #    glVertex3d( $cx - $s * $xs, $cy,            $z );
                        #    glVertex3d( $cx,            $cy - $s * $ys, $z );
                        #
                        # To distinguish between these situations, we append
                        # the length of the line from the previous matching
                        # token, or beginning of line, to the function name.
                        # This will allow the vertical aligner to reject
                        # undesirable matches.

                        # if we are not aligning on this paren...
                        if ( !$ralignment_type_to_go->[$i] ) {

                            # Add the length to the name ...
                            my $len = $summed_lengths_to_go[$i] -
                              $summed_lengths_to_go[$i_start];

                            # Do not include the length of any '!'. Otherwise,
                            # commas in the following line will not match:
                            #  ok( 20, tapprox( ( pdl 2,  3 ), ( pdl 2, 3 ) ) );
                            #  ok( 21, !tapprox( ( pdl 2, 3 ), ( pdl 2, 4 ) ) );
                            if ($saw_exclamation_mark) { $len -= 1 }

                            # For first token, use distance from start of line
                            # but subtract off the indentation due to level.
                            # Otherwise, results could vary with indentation.
                            if ( $i_start == $ibeg ) {
                                $len +=
                                  leading_spaces_to_go($ibeg) -
                                  $levels_to_go[$i_start] *
                                  $rOpts_indent_columns;
                            }
                            if ( $len < 0 ) { $len = 0 }

                            # tack this length onto the container name to try
                            # to make a unique token name
                            $container_name{$depth} .= "-" . $len;
                        } ## end if ( !$ralignment_type_to_go...)
                    } ## end if ( $i_mate > $i && $i_mate...)
                } ## end if ( $is_opening_token...)

                elsif ( $is_closing_token{$token} ) {
                    $i_depth_prev = $i;
                    $depth_prev   = $depth;
                    $depth-- if $depth > 0;
                }
                else {
                    ## must be ternary
                }
            } ## end if ( $type_sequence_to_go...)

            #------------------------------------------------------------
            # Part 2: if we find a new synchronization token, we are done
            # with a field
            #------------------------------------------------------------
            if ( $i > $i_start && $ralignment_type_to_go->[$i] ) {

                my $tok = my $raw_tok = $ralignment_type_to_go->[$i];

                # map similar items
                my $tok_map = $operator_map{$tok};
                $tok = $tok_map if ($tok_map);

                # make separators in different nesting depths unique
                # by appending the nesting depth digit.
                if ( $raw_tok ne '#' ) {
                    $tok .= "$nesting_depth_to_go[$i]";
                }

                # also decorate commas with any container name to avoid
                # unwanted cross-line alignments.
                if ( $raw_tok eq ',' || $raw_tok eq '=>' ) {

                  # If we are at an opening token which increased depth, we have
                  # to use the name from the previous depth.
                    my $depth_last = $i == $i_depth_prev ? $depth_prev : $depth;
                    my $depth_p =
                      ( $depth_last < $depth ? $depth_last : $depth );
                    if ( $container_name{$depth_p} ) {
                        $tok .= $container_name{$depth_p};
                    }
                }

                # Patch to avoid aligning leading and trailing if, unless.
                # Mark trailing if, unless statements with container names.
                # This makes them different from leading if, unless which
                # are not so marked at present.  If we ever need to name
                # them too, we could use ci to distinguish them.
                # Example problem to avoid:
                #    return ( 2, "DBERROR" )
                #      if ( $retval == 2 );
                #    if   ( scalar @_ ) {
                #        my ( $a, $b, $c, $d, $e, $f ) = @_;
                #    }
                if ( $raw_tok eq '(' ) {
                    if (   $ci_levels_to_go[$ibeg]
                        && $container_name{$depth} =~ /^\+(if|unless)/ )
                    {
                        $tok .= $container_name{$depth};
                    }
                }

                # Decorate block braces with block types to avoid
                # unwanted alignments such as the following:
                # foreach ( @{$routput_array} ) { $fh->print($_) }
                # eval                          { $fh->close() };
                if ( $raw_tok eq '{' && $block_type_to_go[$i] ) {
                    my $block_type = $block_type_to_go[$i];

                    # map certain related block types to allow
                    # else blocks to align
                    $block_type = $block_type_map{$block_type}
                      if ( defined( $block_type_map{$block_type} ) );

                    # remove sub names to allow one-line sub braces to align
                    # regardless of name
                    if ( $block_type =~ /$SUB_PATTERN/ ) { $block_type = 'sub' }

                    # allow all control-type blocks to align
                    if ( $block_type =~ /^[A-Z]+$/ ) { $block_type = 'BEGIN' }

                    $tok .= $block_type;

                    # Avoid aligning opening braces across leading ci level
                    # changes by marking block type with _ci (issue c224)
                    if ( $ci_levels_to_go[$ibeg] ) { $tok .= '_1' }
                }

                # Mark multiple copies of certain tokens with a copy number.
                # This will allow the aligner to decide if they are matched.
                # For example, the two equals in the example below will be
                # labeled '=0' and '=0.2'.  Later, the '=0.2' will be ignored
                # in alignment because it has no match.
                #    $|          = $debug = 1 if $opt_d;
                #    $full_index = 1          if $opt_i;

                if ( $raw_tok eq '=' || $raw_tok eq '=>' ) {
                    $token_count{$tok}++;
                    if ( $token_count{$tok} > 1 ) {
                        $tok .= '.' . $token_count{$tok};
                    }
                }

                # concatenate the text of the consecutive tokens to form
                # the field
                push( @fields,
                    join( EMPTY_STRING, @tokens_to_go[ $i_start .. $i - 1 ] ) );

                push @field_lengths,
                  $summed_lengths_to_go[$i] - $summed_lengths_to_go[$i_start];

                # store the alignment token for this field
                push( @tokens, $tok );

                # get ready for the next batch
                $i_start              = $i;
                $saw_exclamation_mark = 0;
                $j++;
                $patterns[$j] = EMPTY_STRING;
            } ## end if ( new synchronization token

            #-----------------------------------------------
            # Part 3: continue accumulating the next pattern
            #-----------------------------------------------

            if ( $is_k_w_n_C_bang{$type} ) {

                # for keywords we have to use the actual text
                if ( $type eq 'k' ) {

                    my $tok_fix = $tokens_to_go[$i];

                    # but map certain keywords to a common string to allow
                    # alignment.
                    $tok_fix = $keyword_map{$tok_fix}
                      if ( defined( $keyword_map{$tok_fix} ) );

                    # VSN PATCH: all 'n' chars in a pattern must be for token
                    # type 'n' (number). i.e. convert 'print' to 'priNt'
                    $tok_fix =~ tr/n/N/;

                    $patterns[$j] .= $tok_fix;
                }

                # ignore any ! in patterns
                elsif ( $type eq '!' ) {
                    $saw_exclamation_mark = 1;
                }

                # Handle $type =~ /^[wnC]$/...
                # Mark most things before arrows as a quote to
                # get them to line up. Testfile: mixed.pl.
                else {

                    my $type_fix = $type;

                    if ( $i < $iend - 1 ) {
                        my $next_type = $types_to_go[ $i + 1 ];
                        my $i_next_nonblank =
                          ( ( $next_type eq 'b' ) ? $i + 2 : $i + 1 );

                        if ( $types_to_go[$i_next_nonblank] eq '=>' ) {
                            $type_fix = 'Q';

                            # Patch to ignore leading minus before words,
                            # by changing pattern 'mQ' into just 'Q',
                            # so that we can align things like this:
                            #  Button   => "Print letter \"~$_\"",
                            #  -command => [ sub { print "$_[0]\n" }, $_ ],
                            if ( $patterns[$j] eq 'm' ) {
                                $patterns[$j] = EMPTY_STRING;
                            }
                        }
                    }

                    # Convert a bareword within braces into a quote for
                    # matching.  This will allow alignment of expressions like
                    # this:
                    #    local ( $SIG{'INT'} ) = IGNORE;
                    #    local ( $SIG{ALRM} )  = 'POSTMAN';
                    if (   $type eq 'w'
                        && $i > $ibeg
                        && $i < $iend
                        && $types_to_go[ $i - 1 ] eq 'L'
                        && $types_to_go[ $i + 1 ] eq 'R' )
                    {
                        $type_fix = 'Q';
                    }

                    # VSN PATCH: no longer changing 'n' to 'Q' here; this
                    # will be handled in the vertical aligner and allow
                    # the aligner to find numbers more efficiently.
                    ##: if ( $type eq 'n' ) { $type_fix = 'Q' }

                    $patterns[$j] .= $type_fix;
                }
            } ## end elsif ( $is_k_w_n_C{$type} )

            # everything else
            else {
                $patterns[$j] .= $type;

                # remove any zero-level name at first fat comma
                if ( $depth == 0 && $type eq '=>' ) {
                    $container_name{$depth} = EMPTY_STRING;
                }
            }

        } ## end for my $i ( $ibeg .. $iend)

        #---------------------------------------------------------------
        # End of main loop .. join text of tokens to make the last field
        #---------------------------------------------------------------
        push( @fields,
            join( EMPTY_STRING, @tokens_to_go[ $i_start .. $iend ] ) );
        push @field_lengths,
          $summed_lengths_to_go[ $iend + 1 ] - $summed_lengths_to_go[$i_start];

        return [ \@tokens, \@fields, \@patterns, \@field_lengths ];
    } ## end sub make_alignment_patterns

    sub make_uncontained_comma_name {
        my ( $ibeg, $iterm ) = @_;

        # Given:
        #   $ibeg = first index
        #   $iterm = last index

        # Make a container name by combining all leading barewords,
        # keywords and functions.
        my $name  = EMPTY_STRING;
        my $count = 0;
        my $count_max;
        my $iname_end;
        my $ilast_blank;
        for my $ii ( $ibeg .. $iterm ) {
            my $type = $types_to_go[$ii];
            if ( $type eq 'b' ) {
                $ilast_blank = $ii;
                next;
            }

            my $token = $tokens_to_go[$ii];

            # Give up if we find an opening paren, binary operator or
            # comma within or after the proposed container name.
            if (   $token eq '('
                || $is_binary_type{$type}
                || $type eq 'k' && $is_binary_keyword{$token} )
            {
                $name = EMPTY_STRING;
                last;
            }

            # The container name is only built of certain types:
            # 'k'=builtin keyword, 'U'=user defined sub, 'w'=unknown bareword
            last if ( !$is_kwU{$type} );

            # Normally it is made of one word, but two words for 'use'
            if ( $count == 0 ) {
                if (   $type eq 'k'
                    && $is_use_like{ $tokens_to_go[$ii] } )
                {
                    $count_max = 2;
                }
                else {
                    $count_max = 1;
                }
            }
            elsif ( defined($count_max) && $count >= $count_max ) {
                last;
            }
            else {
                ## continue
            }

            if ( defined( $name_map{$token} ) ) {
                $token = $name_map{$token};
            }

            $name .= SPACE . $token;
            $iname_end = $ii;
            $count++;
        }

        # Require a space after the container name token(s)
        if (   $name
            && defined($ilast_blank)
            && $ilast_blank > $iname_end )
        {
            $name = substr( $name, 1 );
        }
        return $name;
    } ## end sub make_uncontained_comma_name

} ## end closure make_alignment_patterns

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

    # The token at index $i is a '('.
    # Create an alignment name for it to avoid incorrect alignments.

    # Start with the name of the previous nonblank token...
    my $name = EMPTY_STRING;
    my $im   = $i - 1;
    return EMPTY_STRING if ( $im < 0 );
    if ( $types_to_go[$im] eq 'b' ) { $im--; }
    return EMPTY_STRING if ( $im < 0 );
    $name = $tokens_to_go[$im];

    # Prepend any sub name to an isolated -> to avoid unwanted alignments
    # [test case is test8/penco.pl]
    if ( $name eq '->' ) {
        $im--;
        if ( $im >= 0 && $types_to_go[$im] ne 'b' ) {
            $name = $tokens_to_go[$im] . $name;
        }
    }

    # Finally, remove any leading arrows
    if ( substr( $name, 0, 2 ) eq '->' ) {
        $name = substr( $name, 2 );
    }
    return $name;
} ## end sub make_paren_name

{    ## begin closure get_final_indentation

    my ( $last_indentation_written, $last_unadjusted_indentation,
        $last_leading_token );

    sub initialize_get_final_indentation {
        $last_indentation_written    = 0;
        $last_unadjusted_indentation = 0;
        $last_leading_token          = EMPTY_STRING;
        return;
    } ## end sub initialize_get_final_indentation

    sub get_final_indentation {

        my (
            $self,

            $ibeg,
            $iend,
            $rindentation_list,
            $level_jump,

        ) = @_;

        #--------------------------------------------------------------
        # This routine makes any necessary adjustments to get the final
        # indentation of a line in the Formatter.
        #--------------------------------------------------------------

        # Given:
        #   ($ibeg, $iend) = index range of tokens on this line
        #   $rindentation_list = ref to indentation of each line in this batch,
        #                        to be updated by this sub
        #   $level_jump = level change to $token $ibeg from previous token

        # It starts with the basic indentation which has been defined for the
        # leading token, and then takes into account any options that the user
        # has set regarding special indenting and outdenting.

        # This routine has to resolve a number of complex interacting issues,
        # including:
        # 1. The various -cti=n type flags, which contain the desired change in
        #    indentation for lines ending in commas and semicolons, should be
        #    followed,
        # 2. qw quotes require special processing and do not fit perfectly
        #    with normal containers,
        # 3. formatting with -wn can complicate things, especially with qw
        #    quotes,
        # 4. formatting with the -lp option is complicated, and does not
        #    work well with qw quotes and with -wn formatting.
        # 5. a number of special situations, such as 'cuddled' formatting.
        # 6. This routine is mainly concerned with outdenting closing tokens
        #    but note that there is some overlap with the functions of sub
        #    undo_ci, which was processed earlier, so care has to be taken to
        #    keep them coordinated.

        my $this_batch = $self->[_this_batch_];

        # Find the last code token of this line
        my $i_terminal    = $iend;
        my $terminal_type = $types_to_go[$iend];
        if ( $terminal_type eq '#' && $i_terminal > $ibeg ) {
            $i_terminal -= 1;
            $terminal_type = $types_to_go[$i_terminal];
            if ( $terminal_type eq 'b' && $i_terminal > $ibeg ) {
                $i_terminal -= 1;
                $terminal_type = $types_to_go[$i_terminal];
            }
        }

        my $is_outdented_line;

        my $type_beg            = $types_to_go[$ibeg];
        my $token_beg           = $tokens_to_go[$ibeg];
        my $level_beg           = $levels_to_go[$ibeg];
        my $block_type_beg      = $block_type_to_go[$ibeg];
        my $leading_spaces_beg  = $leading_spaces_to_go[$ibeg];
        my $seqno_beg           = $type_sequence_to_go[$ibeg];
        my $is_closing_type_beg = $is_closing_type{$type_beg};

        # QW INDENTATION PATCH 3:
        my $seqno_qw_closing;
        if ( $type_beg eq 'q' && $ibeg == 0 ) {
            my $KK = $K_to_go[$ibeg];
            $seqno_qw_closing =
              $self->[_rending_multiline_qw_seqno_by_K_]->{$KK};
        }

        my $is_semicolon_terminated = $terminal_type eq ';'
          && ( $nesting_depth_to_go[$iend] < $nesting_depth_to_go[$ibeg]
            || $seqno_qw_closing );

        # NOTE: A future improvement would be to make it semicolon terminated
        # even if it does not have a semicolon but is followed by a closing
        # block brace. This would undo ci even for something like the
        # following, in which the final paren does not have a semicolon because
        # it is a possible weld location:

        # if ($BOLD_MATH) {
        #     (
        #         $labels, $comment,
        #         join( '', '<B>', &make_math( $mode, '', '', $_ ), '</B>' )
        #     )
        # }
        #

        #---------------------------------------------------------
        # Section 1: set a flag and a default indentation
        #
        # Most lines are indented according to the initial token.
        # But it is common to outdent to the level just after the
        # terminal token in certain cases...
        # adjust_indentation flag:
        #       0 - do not adjust
        #       1 - outdent
        #       2 - vertically align with opening token
        #       3 - indent
        #---------------------------------------------------------

        my $adjust_indentation         = 0;
        my $default_adjust_indentation = 0;

        # Parameters needed for option 2, aligning with opening token:
        my (
            $opening_indentation, $opening_offset,
            $is_leading,          $opening_exists
        );

        #-------------------------------------
        # Section 1A:
        # if line starts with a sequenced item
        #-------------------------------------
        if ( $seqno_beg || $seqno_qw_closing ) {

            # This can be tedious so we let a sub do it
            (
                $adjust_indentation,
                $default_adjust_indentation,
                $opening_indentation,
                $opening_offset,
                $is_leading,
                $opening_exists,

            ) = $self->get_closing_token_indentation(

                $ibeg,
                $iend,
                $rindentation_list,
                $level_jump,
                $i_terminal,
                $is_semicolon_terminated,
                $seqno_qw_closing,

            );
        }

        #-----------------------------------------
        # Section 1B:
        # if line starts with a non-sequenced item
        #-----------------------------------------
        else {
            if ( $type_beg eq ';' && !$rOpts_indent_leading_semicolon ) {
                $adjust_indentation = 1;
            }
        }

        #---------------------------------------------------------
        # Section 2: set indentation according to flag set above
        #
        # Select the indentation object to define leading
        # whitespace.  If we are outdenting something like '} } );'
        # then we want to use one level below the last token
        # ($i_terminal) in order to get it to fully outdent through
        # all levels.
        #---------------------------------------------------------
        my $indentation;
        my $lev;
        my $level_end = $levels_to_go[$iend];

        #------------------------------------
        # Section 2A: adjust_indentation == 0
        # No change in indentation
        #------------------------------------
        if ( $adjust_indentation == 0 ) {
            $indentation = $leading_spaces_beg;
            $lev         = $level_beg;
        }

        #-------------------------------------------------------------------
        # Section 2B: adjust_indentation == 1
        # Change the indentation to be that of a different token on the line
        #-------------------------------------------------------------------
        elsif ( $adjust_indentation == 1 ) {

            # Previously, the indentation of the terminal token was used:
            # OLD CODING:
            # $indentation = $reduced_spaces_to_go[$i_terminal];
            # $lev         = $levels_to_go[$i_terminal];

            # Generalization for MOJO patch:
            # Use the lowest level indentation of the tokens on the line.
            # For example, here we can use the indentation of the ending ';':
            #    } until ($selection > 0 and $selection < 10);   # ok to use ';'
            # But this will not outdent if we use the terminal indentation:
            #    )->then( sub {      # use indentation of the ->, not the {
            # Warning: reduced_spaces_to_go[] may be a reference, do not
            # do numerical checks with it

            my $i_ind = $ibeg;
            $indentation = $reduced_spaces_to_go[$i_ind];
            $lev         = $levels_to_go[$i_ind];
            while ( ++$i_ind <= $i_terminal ) {
                if ( $levels_to_go[$i_ind] < $lev ) {
                    $indentation = $reduced_spaces_to_go[$i_ind];
                    $lev         = $levels_to_go[$i_ind];
                }
            } ## end while ( ++$i_ind <= $i_terminal)
        }

        #--------------------------------------------------------------
        # Section 2C: adjust_indentation == 2
        # Handle indented closing token which aligns with opening token
        #--------------------------------------------------------------
        elsif ( $adjust_indentation == 2 ) {

            # handle option to align closing token with opening token
            $lev = $level_beg;

            # calculate spaces needed to align with opening token
            my $space_count =
              get_spaces($opening_indentation) + $opening_offset;

            # Indent less than the previous line.
            #
            # Problem: For -lp we don't exactly know what it was if there
            # were recoverable spaces sent to the aligner.  A good solution
            # would be to force a flush of the vertical alignment buffer, so
            # that we would know.  For now, this rule is used for -lp:
            #
            # When the last line did not start with a closing token we will
            # be optimistic that the aligner will recover everything wanted.
            #
            # This rule will prevent us from breaking a hierarchy of closing
            # tokens, and in a worst case will leave a closing paren too far
            # indented, but this is better than frequently leaving it not
            # indented enough.
            my $last_spaces = get_spaces($last_indentation_written);

            if ( ref($last_indentation_written)
                && !$is_closing_token{$last_leading_token} )
            {
                $last_spaces +=
                  get_recoverable_spaces($last_indentation_written);
            }

            # reset the indentation to the new space count if it works
            # only options are all or none: nothing in-between looks good
            $lev = $level_beg;

            my $diff = $last_spaces - $space_count;
            if ( $diff > 0 ) {
                $indentation = $space_count;
            }
            else {

                # We need to fix things ... but there is no good way to do it.
                # The best solution is for the user to use a longer maximum
                # line length.  We could get a smooth variation if we just move
                # the paren in using
                #    $space_count -= ( 1 - $diff );
                # But unfortunately this can give a rather unbalanced look.

                # For -xlp we currently allow a tolerance of one indentation
                # level and then revert to a simpler default.  This will jump
                # suddenly but keeps a balanced look.
                if (   $rOpts_extended_line_up_parentheses
                    && $diff >= -$rOpts_indent_columns
                    && $space_count > $leading_spaces_beg )
                {
                    $indentation = $space_count;
                }

                # Otherwise revert to defaults
                elsif ( $default_adjust_indentation == 0 ) {
                    $indentation = $leading_spaces_beg;
                }
                elsif ( $default_adjust_indentation == 1 ) {
                    $indentation = $reduced_spaces_to_go[$i_terminal];
                    $lev         = $levels_to_go[$i_terminal];
                }
                else {
                    # shouldn't happen - default_adjust_indentation is 0 or 1
                    DEVEL_MODE
                      && Fault(
"default_indentation=$default_adjust_indentation expected to be 0 or 1\n"
                      );

                    # continue with 0 if not in DEVEL_MODE
                    $indentation = $leading_spaces_beg;
                }
            }
        }

        #-------------------------------------------------------------
        # Section 2D: adjust_indentation == 3
        # Full indentation of closing tokens (-icb and -icp or -cti=2)
        #-------------------------------------------------------------
        else {

            # handle -icb (indented closing code block braces)
            # Updated method for indented block braces: indent one full level if
            # there is no continuation indentation.  This will occur for major
            # structures such as sub, if, else, but not for things like map
            # blocks.
            #
            # Note: only code blocks without continuation indentation are
            # handled here (if, else, unless, ..). In the following snippet,
            # the terminal brace of the sort block will have continuation
            # indentation as shown so it will not be handled by the coding
            # here.  We would have to undo the continuation indentation to do
            # this, but it probably looks ok as is.  This is a possible future
            # update for semicolon terminated lines.
            #
            #     if ($sortby eq 'date' or $sortby eq 'size') {
            #         @files = sort {
            #             $file_data{$a}{$sortby} <=> $file_data{$b}{$sortby}
            #                 or $a cmp $b
            #                 } @files;
            #         }
            #
            if (   $block_type_beg
                && $ci_levels_to_go[$i_terminal] == 0 )
            {
                my $spaces = get_spaces( $leading_spaces_to_go[$i_terminal] );
                $indentation = $spaces + $rOpts_indent_columns;

                # NOTE: for -lp we could create a new indentation object, but
                # there is probably no need to do it
            }

            # handle -icp and any -icb block braces which fall through above
            # test such as the 'sort' block mentioned above.
            else {

                # There are currently two ways to handle -icp...
                # One way is to use the indentation of the previous line:
                # $indentation = $last_indentation_written;

                # The other way is to use the indentation that the previous line
                # would have had if it hadn't been adjusted:
                $indentation = $last_unadjusted_indentation;

                # Current method: use the minimum of the two. This avoids
                # inconsistent indentation.
                if ( get_spaces($last_indentation_written) <
                    get_spaces($indentation) )
                {
                    $indentation = $last_indentation_written;
                }
            }

            # use previous indentation but use own level
            # to cause list to be flushed properly
            $lev = $level_beg;
        }

        #-------------------------------------------------------------
        # Remember indentation except for multi-line quotes, which get
        # no indentation
        #-------------------------------------------------------------
        if ( !( $ibeg == 0 && $this_batch->[_starting_in_quote_] ) ) {
            $last_indentation_written    = $indentation;
            $last_unadjusted_indentation = $leading_spaces_beg;
            $last_leading_token          = $token_beg;

            # Patch to make a line which is the end of a qw quote work with the
            # -lp option.  Make $token_beg look like a closing token as some
            # type even if it is not.  This variable will become
            # $last_leading_token at the end of this loop.  Then, if the -lp
            # style is selected, and the next line is also a
            # closing token, it will not get more indentation than this line.
            # We need to do this because qw quotes (at present) only get
            # continuation indentation, not one level of indentation, so we
            # need to turn off the -lp indentation.

            # ... a picture is worth a thousand words:

            # perltidy -wn -gnu (Without this patch):
            #   ok(defined(
            #       $seqio = $gb->get_Stream_by_batch([qw(J00522 AF303112
            #       2981014)])
            #             ));

            # perltidy -wn -gnu (With this patch):
            #  ok(defined(
            #      $seqio = $gb->get_Stream_by_batch([qw(J00522 AF303112
            #      2981014)])
            #  ));
            if ( $seqno_qw_closing
                && ( length($token_beg) > 1 || $token_beg eq '>' ) )
            {
                $last_leading_token = ')';
            }
        }

        #---------------------------------------------------------------------
        # Rule: lines with leading closing tokens should not be outdented more
        # than the line which contained the corresponding opening token.
        #---------------------------------------------------------------------

        if ( defined($opening_indentation) ) {

            # MOJO patch: Set a flag if this lines begins with ')->'
            my $leading_paren_arrow = (
                     $is_closing_type_beg
                  && $token_beg eq ')'
                  && (
                    (
                           $ibeg < $i_terminal
                        && $types_to_go[ $ibeg + 1 ] eq '->'
                    )
                    || (   $ibeg < $i_terminal - 1
                        && $types_to_go[ $ibeg + 1 ] eq 'b'
                        && $types_to_go[ $ibeg + 2 ] eq '->' )
                  )
            );

            # Updated per bug report in alex_bug.pl: we must not
            # mess with the indentation of closing logical braces, so
            # we must treat something like '} else {' as if it were
            # an isolated brace
            my $is_isolated_block_brace = $block_type_beg
              && (
                $i_terminal == $ibeg
                || $is_if_elsif_else_unless_while_until_for_foreach{
                    $block_type_beg}
              );

            # only do this for a ':; which is aligned with its leading '?'
            my $is_unaligned_colon = $type_beg eq ':' && !$is_leading;

            if (
                   !$leading_paren_arrow
                && !$is_isolated_block_brace
                && !$is_unaligned_colon
                && ( get_spaces($opening_indentation) >
                    get_spaces($indentation) )
              )
            {
                $indentation = $opening_indentation;
            }
        }

        #----------------------------------------------------
        # remember the indentation of each line of this batch
        #----------------------------------------------------
        push @{$rindentation_list}, $indentation;

        #---------------------------------------------
        # outdent lines with certain leading tokens...
        #---------------------------------------------
        if (

            # must be first word of this batch
            $ibeg == 0

            # and ...
            && (

                # certain leading keywords if requested
                $rOpts_outdent_keywords
                && $type_beg eq 'k'
                && $outdent_keyword{$token_beg}

                # or labels if requested
                || $rOpts_outdent_labels && $type_beg eq 'J'

                # or static block comments if requested
                || $this_batch->[_is_static_block_comment_]
                && $rOpts_outdent_static_block_comments
            )
          )
        {
            my $space_count = leading_spaces_to_go($ibeg);
            if ( $space_count > 0 ) {
                $space_count -= $rOpts_continuation_indentation;
                $is_outdented_line = 1;
                if ( $space_count < 0 ) { $space_count = 0 }

                # do not promote a spaced static block comment to non-spaced;
                # this is not normally necessary but could be for some
                # unusual user inputs (such as -ci = -i)
                if ( $type_beg eq '#' && $space_count == 0 ) {
                    $space_count = 1;
                }

                $indentation = $space_count;
            }
        }

        return (

            $indentation,
            $lev,
            $level_end,
            $i_terminal,
            $is_outdented_line,

        );
    } ## end sub get_final_indentation

    sub get_closing_token_indentation {

        # Determine indentation adjustment for a line with a leading closing
        # token - i.e. one of these:     ) ] } :

        # The indentation adjustment is found by checking all user controls,
        # which are sometimes in conflict.  So the logic is rather complex.

        # Returns:
        #  Flags giving the indentation to use for this line:

        #   $adjust_indentation,
        #       0 - do not adjust
        #       1 - outdent
        #       2 - vertically align with opening token
        #       3 - indent
        #   $default_adjust_indentation
        #       a default in case $adjust_indentation cannot be used
        #
        # Also returns info about the indentation of the opening token,
        # obtained from sub 'get_opening_indentation':

        #   $opening_indentation,
        #   $opening_offset,
        #   $is_leading,
        #   $opening_exists,

        my (
            $self,

            $ibeg,
            $iend,
            $rindentation_list,
            $level_jump,
            $i_terminal,
            $is_semicolon_terminated,
            $seqno_qw_closing,

        ) = @_;

        my $adjust_indentation         = 0;
        my $default_adjust_indentation = $adjust_indentation;
        my $terminal_type              = $types_to_go[$i_terminal];

        my $type_beg            = $types_to_go[$ibeg];
        my $token_beg           = $tokens_to_go[$ibeg];
        my $level_beg           = $levels_to_go[$ibeg];
        my $block_type_beg      = $block_type_to_go[$ibeg];
        my $leading_spaces_beg  = $leading_spaces_to_go[$ibeg];
        my $seqno_beg           = $type_sequence_to_go[$ibeg];
        my $is_closing_type_beg = $is_closing_type{$type_beg};

        # Return variables:
        my (
            $opening_indentation, $opening_offset,
            $is_leading,          $opening_exists
        );

        # Honor any flag to reduce -ci set by the -bbxi=n option
        if ( $seqno_beg && $self->[_rwant_reduced_ci_]->{$seqno_beg} ) {

            # if this is an opening, it must be alone on the line ...
            if ( $is_closing_type{$type_beg} || $ibeg == $i_terminal ) {
                $adjust_indentation = 1;
            }

            # ... or a single welded unit (fix for b1173)
            elsif ($total_weld_count) {
                my $K_beg      = $K_to_go[$ibeg];
                my $Kterm      = $K_to_go[$i_terminal];
                my $Kterm_test = $self->[_rK_weld_left_]->{$Kterm};
                if ( defined($Kterm_test) && $Kterm_test >= $K_beg ) {
                    $Kterm = $Kterm_test;
                }
                if ( $Kterm == $K_beg ) { $adjust_indentation = 1 }
            }
            else {
                # no change in ci needed
            }
        }

        my $ris_bli_container = $self->[_ris_bli_container_];
        my $is_bli_beg = $seqno_beg ? $ris_bli_container->{$seqno_beg} : 0;

        # Update the $is_bli flag as we go. It is initially 1.
        # We note seeing a leading opening brace by setting it to 2.
        # If we get to the closing brace without seeing the opening then we
        # turn it off.  This occurs if the opening brace did not get output
        # at the start of a line, so we will then indent the closing brace
        # in the default way.
        if ( $is_bli_beg && $is_bli_beg == 1 ) {
            my $K_opening_container = $self->[_K_opening_container_];
            my $K_opening           = $K_opening_container->{$seqno_beg};
            my $K_beg               = $K_to_go[$ibeg];
            if ( $K_beg eq $K_opening ) {
                $ris_bli_container->{$seqno_beg} = $is_bli_beg = 2;
            }
            else { $is_bli_beg = 0 }
        }

        # QW PATCH for the combination -lp -wn
        # For -lp formatting use $ibeg_weld_fix to get around the problem
        # that with -lp type formatting the opening and closing tokens to not
        # have sequence numbers.
        my $ibeg_weld_fix = $ibeg;
        if ( $seqno_qw_closing && $total_weld_count ) {
            my $i_plus = $inext_to_go[$ibeg];
            if ( $i_plus <= $max_index_to_go ) {
                my $K_plus = $K_to_go[$i_plus];
                if ( defined( $self->[_rK_weld_left_]->{$K_plus} ) ) {
                    $ibeg_weld_fix = $i_plus;
                }
            }
        }

        # if we are at a closing token of some type..
        if ( $is_closing_type_beg || $seqno_qw_closing ) {

            my $K_beg = $K_to_go[$ibeg];

            # get the indentation of the line containing the corresponding
            # opening token
            (
                $opening_indentation, $opening_offset,
                $is_leading,          $opening_exists
              )
              = $self->get_opening_indentation(

                $ibeg_weld_fix,
                $rindentation_list,
                $seqno_qw_closing

              );

            # Patch for rt144979, part 1. Coordinated with part 2.
            # Do not undo ci for a cuddled closing brace control; it
            # needs to be treated exactly the same ci as an isolated
            # closing brace.
            my $is_cuddled_closing_brace = $seqno_beg
              && $self->[_ris_cuddled_closing_brace_]->{$seqno_beg};

            # First set the default behavior:
            if (

                # default behavior is to outdent closing lines
                # of the form:   ");  };  ];  )->xxx;"
                $is_semicolon_terminated

                # and 'cuddled parens' of the form:   ")->pack(". Bug fix for RT
                # #123749]: the TYPES here were incorrectly ')' and '('.  The
                # corrected TYPES are '}' and '{'. But skip a cuddled block.
                || (
                       $terminal_type eq '{'
                    && $type_beg eq '}'
                    && ( $nesting_depth_to_go[$iend] + 1 ==
                        $nesting_depth_to_go[$ibeg] )
                    && !$is_cuddled_closing_brace
                )

                # remove continuation indentation for any line like
                #       } ... {
                # or without ending '{' and unbalanced, such as
                #       such as '}->{$operator}'
                || (
                    $type_beg eq '}'

                    && (   $types_to_go[$iend] eq '{'
                        || $levels_to_go[$iend] < $level_beg )

                    # but not if a cuddled block
                    && !$is_cuddled_closing_brace
                )

                # and when the next line is at a lower indentation level...

                # PATCH #1: and only if the style allows undoing continuation
                # for all closing token types. We should really wait until
                # the indentation of the next line is known and then make
                # a decision, but that would require another pass.

                # PATCH #2: and not if this token is under -xci control
                || (   $level_jump < 0
                    && !$some_closing_token_indentation
                    && !$self->[_rseqno_controlling_my_ci_]->{$K_beg} )

                # Patch for -wn=2, multiple welded closing tokens
                || (   $i_terminal > $ibeg
                    && $is_closing_type{ $types_to_go[$iend] } )

                # Alternate Patch for git #51, isolated closing qw token not
                # outdented if no-delete-old-newlines is set. This works, but
                # a more general patch elsewhere fixes the real problem: ljump.
                # || ( $seqno_qw_closing && $ibeg == $i_terminal )

              )
            {
                $adjust_indentation = 1;
            }

            # outdent something like '),'
            if (
                $terminal_type eq ','

                # Removed this constraint for -wn
                # OLD: allow just one character before the comma
                # && $i_terminal == $ibeg + 1

                # require LIST environment; otherwise, we may outdent too much -
                # this can happen in calls without parentheses (overload.t);
                && $self->is_in_list_by_i($i_terminal)
              )
            {
                $adjust_indentation = 1;
            }

            # undo continuation indentation of a terminal closing token if
            # it is the last token before a level decrease.  This will allow
            # a closing token to line up with its opening counterpart, and
            # avoids an indentation jump larger than 1 level.
            my $rLL    = $self->[_rLL_];
            my $Klimit = $self->[_Klimit_];
            if (   $i_terminal == $ibeg
                && $is_closing_type_beg
                && defined($K_beg)
                && $K_beg < $Klimit )
            {
                my $K_plus    = $K_beg + 1;
                my $type_plus = $rLL->[$K_plus]->[_TYPE_];

                if ( $type_plus eq 'b' && $K_plus < $Klimit ) {
                    $type_plus = $rLL->[ ++$K_plus ]->[_TYPE_];
                }

                if ( $type_plus eq '#' && $K_plus < $Klimit ) {
                    $type_plus = $rLL->[ ++$K_plus ]->[_TYPE_];
                    if ( $type_plus eq 'b' && $K_plus < $Klimit ) {
                        $type_plus = $rLL->[ ++$K_plus ]->[_TYPE_];
                    }

                    # Note: we have skipped past just one comment (perhaps a
                    # side comment).  There could be more, and we could easily
                    # skip past all the rest with the following code, or with a
                    # while loop.  It would be rare to have to do this, and
                    # those block comments would still be indented, so it would
                    # to leave them indented.  So it seems best to just stop at
                    # a maximum of one comment.
                    ##if ($type_plus eq '#') {
                    ##   $K_plus = $self->K_next_code($K_plus);
                    ##}
                }

                if ( !$is_bli_beg && defined($K_plus) ) {
                    my $lev        = $level_beg;
                    my $level_next = $rLL->[$K_plus]->[_LEVEL_];

                    # and do not undo ci if it was set by the -xci option
                    $adjust_indentation = 1
                      if ( $level_next < $lev
                        && !$self->[_rseqno_controlling_my_ci_]->{$K_beg} );
                }

                # Patch for RT #96101, in which closing brace of anonymous subs
                # was not outdented.  We should look ahead and see if there is
                # a level decrease at the next token (i.e., a closing token),
                # but right now we do not have that information.  For now
                # we see if we are in a list, and this works well.
                # See test files 'sub*.t' for good test cases.
                if (  !$rOpts_indent_closing_brace
                    && $block_type_beg
                    && $self->[_ris_asub_block_]->{$seqno_beg}
                    && $self->is_in_list_by_i($i_terminal) )
                {
                    (
                        $opening_indentation, $opening_offset,
                        $is_leading,          $opening_exists
                      )
                      = $self->get_opening_indentation( $ibeg,
                        $rindentation_list, undef );
                    my $indentation = $leading_spaces_beg;
                    if ( defined($opening_indentation)
                        && get_spaces($indentation) >
                        get_spaces($opening_indentation) )
                    {
                        $adjust_indentation = 1;
                    }
                }
            }

            # YVES patch 1 of 2:
            # Undo ci of line with leading closing eval brace,
            # but not beyond the indentation of the line with
            # the opening brace.
            if (   $block_type_beg
                && $block_type_beg eq 'eval'
                && !ref($leading_spaces_beg)
                && !$rOpts_indent_closing_brace )
            {
                (
                    $opening_indentation, $opening_offset,
                    $is_leading,          $opening_exists
                  )
                  = $self->get_opening_indentation( $ibeg, $rindentation_list,
                    undef );
                my $indentation = $leading_spaces_beg;
                if ( defined($opening_indentation)
                    && get_spaces($indentation) >
                    get_spaces($opening_indentation) )
                {
                    $adjust_indentation = 1;
                }
            }

            # patch for issue git #40: -bli setting has priority
            $adjust_indentation = 0 if ($is_bli_beg);

            $default_adjust_indentation = $adjust_indentation;

            # Now modify default behavior according to user request:
            # handle option to indent non-blocks of the form );  };  ];
            # But don't do special indentation to something like ')->pack('
            if ( !$block_type_beg ) {

                # Note that logical padding has already been applied, so we may
                # need to remove some spaces to get a valid hash key.
                my $tok = $token_beg;
                my $cti = $closing_token_indentation{$tok};

                # Fix the value of 'cti' for an isolated non-welded closing qw
                # delimiter.
                if ( $seqno_qw_closing && $ibeg_weld_fix == $ibeg ) {

                    # A quote delimiter which is not a container will not have
                    # a cti value defined.  In this case use the style of a
                    # paren. For example
                    #   my @fars = (
                    #      qw<
                    #        far
                    #        farfar
                    #        farfars-far
                    #      >,
                    #   );
                    if ( !defined($cti) && length($tok) == 1 ) {

                        # something other than ')', '}', ']' ; use flag for ')'
                        $cti = $closing_token_indentation{')'};

                        # But for now, do not outdent non-container qw
                        # delimiters because it would would change existing
                        # formatting.
                        if ( $tok ne '>' ) { $cti = 3 }
                    }

                    # A non-welded closing qw cannot currently use -cti=1
                    # because that option requires a sequence number to find
                    # the opening indentation, and qw quote delimiters are not
                    # sequenced items.
                    if ( defined($cti) && $cti == 1 ) { $cti = 0 }
                }

                if ( !defined($cti) ) {

                    # $cti may not be defined for several reasons.
                    # -padding may have been applied so the character
                    #  has a length > 1
                    # - we may have welded to a closing quote token.
                    #   Here is an example (perltidy -wn):
                    #       __PACKAGE__->load_components( qw(
                    #  >         Core
                    #  >
                    #  >     ) );
                    $adjust_indentation = 0;

                }
                elsif ( $cti == 1 ) {
                    if (   $i_terminal <= $ibeg + 1
                        || $is_semicolon_terminated )
                    {
                        $adjust_indentation = 2;
                    }
                    else {
                        $adjust_indentation = 0;
                    }
                }
                elsif ( $cti == 2 ) {
                    if ($is_semicolon_terminated) {
                        $adjust_indentation = 3;
                    }
                    else {
                        $adjust_indentation = 0;
                    }
                }
                elsif ( $cti == 3 ) {
                    $adjust_indentation = 3;
                }
                else {
                    ## cti == 0
                }
            }

            # handle option to indent blocks
            else {
                if (
                    $rOpts_indent_closing_brace
                    && (
                        $i_terminal == $ibeg    #  isolated terminal '}'
                        || $is_semicolon_terminated
                    )
                  )                             #  } xxxx ;
                {
                    $adjust_indentation = 3;
                }
            }
        } ## end if ( $is_closing_type_beg || $seqno_qw_closing )

        # if line begins with a ':', align it with any
        # previous line leading with corresponding ?
        elsif ( $type_beg eq ':' ) {
            (
                $opening_indentation, $opening_offset,
                $is_leading,          $opening_exists
              )
              = $self->get_opening_indentation( $ibeg,
                $rindentation_list, undef );
            if ($is_leading) { $adjust_indentation = 2; }
        }
        else {
            # not a closing type
        }

        # A final check: reset the flag value from 1 to 0 if moving left would
        # give this closing token less indentation than the line with its
        # opening token. We could do this check at the top for more efficiency
        # except for -lp.  For -lp, if the $adjust_indentation flag flips from
        # 1 to 2, then the -lp logic can do a better recovery if it knows that
        # the $default_adjust_indentation=1 instead of 0 (c435)
        if ( $adjust_indentation == 1 ) {
            my $no_left_adjustment_space = defined($opening_indentation)
              && get_spaces($leading_spaces_beg) <=
              get_spaces($opening_indentation);
            if ($no_left_adjustment_space) {
                $adjust_indentation = 0;
            }
        }

        return (

            $adjust_indentation,
            $default_adjust_indentation,
            $opening_indentation,
            $opening_offset,
            $is_leading,
            $opening_exists,

        );
    } ## end sub get_closing_token_indentation
} ## end closure get_final_indentation

sub get_opening_indentation {

    # get the indentation of the line which output the opening token
    # corresponding to a given closing token in the current output batch.
    #
    # given:
    # $i_closing - index in this line of a closing token ')' '}' or ']'
    #
    # $ri_first - reference to list of the first index $i for each output
    #               line in this batch
    # $ri_last - reference to list of the last index $i for each output line
    #              in this batch
    # $rindentation_list - reference to a list containing the indentation
    #            used for each line.
    # $qw_seqno - optional sequence number to use if normal seqno not defined
    #           (NOTE: would be more general to just look this up from index i)
    #
    # return:
    #   -the indentation of the line which contained the opening token
    #    which matches the token at index $i_opening
    #   -and its offset (number of columns) from the start of the line
    #
    my (
        $self,

        $i_closing,
        $rindentation_list,
        $qw_seqno

    ) = @_;

    # first, see if the opening token is in the current batch
    my $i_opening = $mate_index_to_go[$i_closing];
    my ( $indent, $offset, $is_leading, $exists );
    $exists = 1;
    if ( defined($i_opening) && $i_opening >= 0 ) {

        # it is..look up the indentation
        ( $indent, $offset, $is_leading ) =
          $self->lookup_opening_indentation( $i_opening, $rindentation_list );
    }

    # if not, it should have been stored in the hash by a previous batch
    else {
        my $seqno = $type_sequence_to_go[$i_closing];
        $seqno = $qw_seqno unless ($seqno);
        ( $indent, $offset, $is_leading, $exists ) =
          get_saved_opening_indentation($seqno);
    }
    return ( $indent, $offset, $is_leading, $exists );
} ## end sub get_opening_indentation

sub examine_vertical_tightness_flags {
    my ($self) = @_;

    # For efficiency, we will set a flag to skip all calls to sub
    # 'set_vertical_tightness_flags' if vertical tightness is not possible with
    # the user input parameters.  If vertical tightness is possible, we will
    # simply leave the flag undefined and return.

    # Vertical tightness is never possible with --freeze-whitespace
    if ($rOpts_freeze_whitespace) {
        $self->[_no_vertical_tightness_flags_] = 1;
        return;
    }

    # This sub is coordinated with sub set_vertical_tightness_flags.
    # The Section numbers in the following comments are the sections
    # in sub set_vertical_tightness_flags:

    # Examine controls for Section 1a:
    return if ($rOpts_line_up_parentheses);

    foreach my $key ( keys %opening_vertical_tightness ) {
        return if ( $opening_vertical_tightness{$key} );
    }

    # Examine controls for Section 1b:
    foreach my $key ( keys %closing_vertical_tightness ) {
        return if ( $closing_vertical_tightness{$key} );
    }

    # Examine controls for Section 1c:
    foreach my $key ( keys %opening_token_right ) {
        return if ( $opening_token_right{$key} );
    }

    # Examine controls for Section 1d:
    foreach my $key ( keys %stack_opening_token ) {
        return if ( $stack_opening_token{$key} );
    }
    foreach my $key ( keys %stack_closing_token ) {
        return if ( $stack_closing_token{$key} );
    }

    # Examine controls for Section 2:
    return if ($rOpts_block_brace_vertical_tightness);

    # Examine controls for Section 3:
    return if ($rOpts_stack_closing_block_brace);

    # None of the controls used for vertical tightness are set, so
    # we can skip all calls to sub set_vertical_tightness_flags
    $self->[_no_vertical_tightness_flags_] = 1;
    return;
} ## end sub examine_vertical_tightness_flags

my %is_uncovered_operator;

# b1060, b1499
BEGIN {
    my @q = qw( ? : && || );
    @is_uncovered_operator{@q} = (1) x scalar(@q);
}

sub set_vertical_tightness_flags {

    my ( $self, $nline, $closing_side_comment ) = @_;

    # Given:
    #   $nline = index of this line in the current output batch
    #   $closing_side_comment = true if line has side comment

    # Define vertical tightness controls for the nth line of a batch.
    # Note: do not call this sub for a block comment or if
    # $rOpts_freeze_whitespace is set.

    # These parameters are passed to the vertical aligner to indicated
    # if we should combine this line with the next line to achieve the
    # desired vertical tightness.  This was previously an array but
    # has been converted to a hash:

    # old   hash              Meaning
    # index key
    #
    # 0   _vt_type:           1=opening non-block    2=closing non-block
    #                         3=opening block brace  4=closing block brace
    #
    # 1a  _vt_opening_flag:   1=no multiple steps, 2=multiple steps ok
    # 1b  _vt_closing_flag:   spaces of padding to use if closing
    # 2   _vt_seqno:          sequence number of container
    # 3   _vt_valid flag:     do not append if this flag is false. Will be
    #           true if appropriate -vt flag is set.  Otherwise, Will be
    #           made true only for 2 line container in parens with -lp
    # 4   _vt_seqno_beg:      sequence number of first token of line
    # 5   _vt_seqno_end:      sequence number of last token of line
    # 6   _vt_min_lines:      min number of lines for joining opening cache,
    #                           0=no constraint
    # 7   _vt_max_lines:      max number of lines for joining opening cache,
    #                           0=no constraint

    # The vertical tightness mechanism can add whitespace, so whitespace can
    # continually increase if we allowed it when the -fws flag is set.
    # See case b499 for an example.

    # Uses these global parameters:
    #   $rOpts_block_brace_tightness
    #   $rOpts_block_brace_vertical_tightness
    #   $rOpts_stack_closing_block_brace
    #   $rOpts_line_up_parentheses
    #   %opening_vertical_tightness
    #   %closing_vertical_tightness
    #   %opening_token_right
    #   %stack_closing_token
    #   %stack_opening_token

    # Pull out needed batch variables
    my $this_batch = $self->[_this_batch_];
    my $ri_first   = $this_batch->[_ri_first_];
    my $ri_last    = $this_batch->[_ri_last_];

    my $n_last_line = @{$ri_first} - 1;
    if ( $nline < 0 || $nline > $n_last_line ) {
        DEVEL_MODE && Fault("bad line index '$nline' ; max is $n_last_line\n");
        return;
    }
    my $ibeg = $ri_first->[$nline];
    my $iend = $ri_last->[$nline];

    # Define these values for each vertical tightness type:
    my (

        $vt_type,
        $vt_opening_flag,
        $vt_closing_flag,
        $vt_seqno,
        $vt_valid_flag,
        $vt_min_lines,
        $vt_max_lines
    );

    # get the sequence numbers of the ends of this line
    my $vt_seqno_beg =
        $type_sequence_to_go[$ibeg] ? $type_sequence_to_go[$ibeg]
      : $types_to_go[$ibeg] eq 'q'  ? $self->get_seqno($ibeg)
      :                               EMPTY_STRING;
    my $vt_seqno_end =
        $type_sequence_to_go[$iend] ? $type_sequence_to_go[$iend]
      : $types_to_go[$iend] eq 'q'  ? $self->get_seqno($iend)
      :                               EMPTY_STRING;

    #--------------------------------------------------------------
    # Vertical Tightness Flags Section 1:
    # Handle Lines 1 .. n-1 but not the last line
    # For non-BLOCK tokens, we will need to examine the next line
    # too, so we won't consider the last line.
    #--------------------------------------------------------------
    if ( $nline < $n_last_line ) {

        # NOTE: Section 1 has 4 sub-sections: 1a, 1b, 1c, and 1d.  The logic to
        # reach any of these end states is complex, and it is possible but very
        # unlikely that more than one of these end states could be reached.
        # The current logic is to keep going and use the last such state.
        # There are currently no known instances where multiple end states can
        # be reached, but it is something to be aware of when making changes.

        #--------------------------------------------------------------
        # Vertical Tightness Flags Section 1a:
        # Look for Type 1, last token of this line is a non-block opening token
        #--------------------------------------------------------------
        my $ibeg_next = $ri_first->[ $nline + 1 ];
        my $token_end = $tokens_to_go[$iend];
        my $iend_next = $ri_last->[ $nline + 1 ];

        if (
               $type_sequence_to_go[$iend]
            && !$block_type_to_go[$iend]
            && $is_opening_token{$token_end}
            && (
                $opening_vertical_tightness{$token_end} > 0

                # allow 2-line method call to be closed up
                || (   $rOpts_line_up_parentheses
                    && $token_end eq '('
                    && $self->[_rlp_object_by_seqno_]
                    ->{ $type_sequence_to_go[$iend] }
                    && $iend > $ibeg
                    && $types_to_go[ $iend - 1 ] ne 'b' )
            )
          )
        {
            # avoid multiple jumps in nesting depth in one line if
            # requested
            my $ovt = $opening_vertical_tightness{$token_end};

            # if we are in -lp and the next line ends in a weld..
            if (   $rOpts_line_up_parentheses
                && $self->[_rK_weld_left_]->{ $K_to_go[$iend_next] } )
            {
                my $type_end_next = $types_to_go[$iend_next];

                # Turn off -vt if the next line ends in a closing token. This
                # avoids an instability with one-line welds (b1183).
                if ( $is_closing_type{$type_end_next} ) {
                    $ovt = 0;
                }

                # Turn off -vt if the next line ends in an opening token. This
                # avoids an instability (b1460).
                elsif ( $is_opening_type{$type_end_next} ) {
                    $ovt = 0;
                }

                # neither opening nor closing
                else {
                }
            }

            # The flag '_rbreak_container_' avoids conflict of -bom and -pt=1
            # or -pt=2; fixes b1270. See similar patch above for $cvt.
            my $seqno = $type_sequence_to_go[$iend];
            if (   $ovt
                && $seqno
                && $self->[_rbreak_container_]->{$seqno} )
            {
                $ovt = 0;
            }

            # The flag '_rmax_vertical_tightness_' avoids welding conflicts.
            if ( defined( $self->[_rmax_vertical_tightness_]->{$seqno} ) ) {
                $ovt =
                  min( $ovt, $self->[_rmax_vertical_tightness_]->{$seqno} );
            }

            if (
                $ovt >= 2
                || ( $nesting_depth_to_go[ $iend_next + 1 ] ==
                    $nesting_depth_to_go[$ibeg_next] )
              )
            {

                # If -vt flag has not been set, mark this as invalid
                # and aligner will validate it if it sees the closing paren
                # within 2 lines.
                my $valid_flag = $ovt;

                $vt_type         = 1;
                $vt_opening_flag = $ovt;
                $vt_closing_flag = 0;
                $vt_seqno        = $type_sequence_to_go[$iend];
                $vt_valid_flag   = $valid_flag;
                $vt_min_lines    = 0;
                $vt_max_lines    = 0;

            }
        }

        #--------------------------------------------------------------
        # Vertical Tightness Flags Section 1b:
        # Look for Type 2, first token of next line is a non-block closing
        # token .. and be sure this line does not have a side comment
        #--------------------------------------------------------------
        my $token_next = $tokens_to_go[$ibeg_next];
        if (
               $type_sequence_to_go[$ibeg_next]
            && !$block_type_to_go[$ibeg_next]
            && $is_closing_token{$token_next}
            && !$self->[_rbreak_container_]
            ->{ $type_sequence_to_go[$ibeg_next] }    # b1498
            && $types_to_go[$iend] ne '#'
          )    # for safety, shouldn't happen!
        {
            my $cvt   = $closing_vertical_tightness{$token_next};
            my $seqno = $type_sequence_to_go[$ibeg_next];

            # Avoid conflict of -bom and -pvt=1 or -pvt=2, fixes b977, b1303
            # See similar patch above for $ovt.
            # NOTE: this is overriden by fix for b1498 above and can
            # eventually be removed.
            if ( 0 && $cvt && $self->[_rbreak_container_]->{$seqno} ) {
                $cvt = 0;
            }

            # Implement cvt=3: like cvt=0 for assigned structures, like cvt=1
            # otherwise.  Added for rt136417.
            if ( $cvt == 3 ) {
                $cvt = $self->[_ris_assigned_structure_]->{$seqno} ? 0 : 1;
            }

            # The unusual combination -pvtc=2 -dws -naws can be unstable.
            # This fixes b1282, b1283.  This can be moved to set_options.
            if (   $cvt == 2
                && $rOpts_delete_old_whitespace
                && !$rOpts_add_whitespace )
            {
                $cvt = 1;
            }

            # Fix for b1379, b1380, b1381, b1382, b1384 part 2,
            # instability with adding and deleting trailing commas:
            # Reducing -cvt=2 to =1 fixes stability for -wtc=b in b1379,1380.
            # Reducing -cvt>0 to =0 fixes stability for -wtc=b in b1381,1382.
            # Reducing -cvt>0 to =0 fixes stability for -wtc=m in b1384
            if (   $cvt
                && $self->[_ris_bare_trailing_comma_by_seqno_]->{$seqno} )
            {
                $cvt = 0;
            }

            if (

                # Never append a trailing line like   ')->pack(' because it
                # will throw off later alignment.  So this line must start at a
                # deeper level than the next line (fix1 for welding, git #45).
                (
                    $nesting_depth_to_go[$ibeg_next] >=
                    $nesting_depth_to_go[ $iend_next + 1 ] + 1
                )
                && (
                    $cvt == 2
                    || (
                        !$self->is_in_list_by_i($ibeg_next)
                        && (
                            $cvt == 1

                            # allow closing up 2-line method calls
                            || (   $rOpts_line_up_parentheses
                                && $token_next eq ')'
                                && $type_sequence_to_go[$ibeg_next]
                                && $self->[_rlp_object_by_seqno_]
                                ->{ $type_sequence_to_go[$ibeg_next] } )
                        )
                    )
                )
              )
            {

                # decide which trailing closing tokens to append..
                my $ok = 0;
                if ( $cvt == 2 || $iend_next == $ibeg_next ) { $ok = 1 }
                else {
                    my $str = join( EMPTY_STRING,
                        @types_to_go[ $ibeg_next + 1 .. $ibeg_next + 2 ] );

                    # append closing token if followed by comment or ';'
                    # or another closing token (fix2 for welding, git #45)
                    if ( $str =~ /^b?[\)\]\}R#;]/ ) { $ok = 1 }
                }

                if ($ok) {
                    my $valid_flag = $cvt;
                    my $min_lines  = 0;
                    my $max_lines  = 0;

                    # Fix for b1187 and b1188: Blinking can occur if we allow
                    # welded tokens to re-form into one-line blocks during
                    # vertical alignment when -lp used.  So for this case we
                    # set the minimum number of lines to be 1 instead of 0.
                    # The maximum should be 1 if -vtc is not used.  If -vtc is
                    # used, we turn the valid
                    # flag off and set the maximum to 0. This is equivalent to
                    # using a large number.
                    my $seqno_ibeg_next = $type_sequence_to_go[$ibeg_next];
                    if (   $rOpts_line_up_parentheses
                        && $total_weld_count
                        && $seqno_ibeg_next
                        && $self->[_rlp_object_by_seqno_]->{$seqno_ibeg_next}
                        && $self->is_welded_at_seqno($seqno_ibeg_next) )
                    {
                        $min_lines  = 1;
                        $max_lines  = $cvt ? 0 : 1;
                        $valid_flag = 0;
                    }

                    $vt_type         = 2;
                    $vt_opening_flag = 0;
                    $vt_closing_flag = $tightness{$token_next} == 2 ? 0 : 1;
                    $vt_seqno        = $type_sequence_to_go[$ibeg_next];
                    $vt_valid_flag   = $valid_flag;
                    $vt_min_lines    = $min_lines;
                    $vt_max_lines    = $max_lines;
                }
            }
        }

        #--------------------------------------------------------------
        # Vertical Tightness Flags Section 1c:
        # Implement the Opening Token Right flag (Type 2)..
        # If requested, move an isolated trailing opening token to the end of
        # the previous line which ended in a comma.  We could do this
        # in sub recombine_breakpoints but that would cause problems
        # with -lp formatting.  The problem is that indentation will
        # quickly move far to the right in nested expressions.  By
        # doing it after indentation has been set, we avoid changes
        # to the indentation.  Actual movement of the token takes place
        # in sub valign_output_step_B.

        # Note added 4 May 2021: the man page suggests that the -otr flags
        # are mainly for opening tokens following commas.  But this seems
        # to have been generalized long ago to include other situations.
        # I checked the coding back to 2012 and it is essentially the same
        # as here, so it is best to leave this unchanged for now.
        #--------------------------------------------------------------
        if (
            $opening_token_right{ $tokens_to_go[$ibeg_next] }

            # previous line is not opening
            # (use -sot to combine with it)
            && !$is_opening_token{$token_end}

            # previous line ended in one of these
            # (add other cases if necessary; '=>' and '.' are not necessary
            && !$block_type_to_go[$ibeg_next]

            # this is a line with just an opening token
            && (   $iend_next == $ibeg_next
                || $iend_next == $ibeg_next + 2
                && $types_to_go[$iend_next] eq '#' )

            # Fix for case b1060 when both -baoo and -otr are set:
            # to avoid blinking, honor the -baoo flag over the -otr flag.
            # b1499 added ? and : for same reason
            ##&& $token_end ne '||' && $token_end ne '&&'
            && !$is_uncovered_operator{$token_end}

            # Keep break after '=' if -lp. Fixes b964 b1040 b1062 b1083 b1089.
            # Generalized from '=' to $is_assignment to fix b1375.
            && !(
                   $is_assignment{ $types_to_go[$iend] }
                && $rOpts_line_up_parentheses
                && $type_sequence_to_go[$ibeg_next]
                && $self->[_rlp_object_by_seqno_]
                ->{ $type_sequence_to_go[$ibeg_next] }
            )

            # looks bad if we align vertically with the wrong container
            && $tokens_to_go[$ibeg] ne $tokens_to_go[$ibeg_next]

            # give -kba priority over -otr (b1445)
            && !$self->[_rbreak_after_Klast_]->{ $K_to_go[$iend] }

            # Fix b1462, b1463: avoid possible edge instability with
            # the combination -xlp and -dws
            && !(
                   $rOpts_extended_line_up_parentheses
                && $rOpts_delete_old_whitespace
            )
          )
        {
            my $spaces = ( $types_to_go[ $ibeg_next - 1 ] eq 'b' ) ? 1 : 0;

            $vt_type         = 2;
            $vt_opening_flag = 0;
            $vt_closing_flag = $spaces;
            $vt_seqno        = $type_sequence_to_go[$ibeg_next];
            $vt_valid_flag   = 1;
            $vt_min_lines    = 0;
            $vt_max_lines    = 0;
        }

        #--------------------------------------------------------------
        # Vertical Tightness Flags Section 1d:
        # Stacking of opening and closing tokens (Type 2)
        #--------------------------------------------------------------
        my $stackable;
        my $token_beg_next = $tokens_to_go[$ibeg_next];

        # patch to make something like 'qw(' behave like an opening paren
        # (aran.t)
        if ( $types_to_go[$ibeg_next] eq 'q' ) {
            if ( $token_beg_next =~ /^qw\s*([\[\(\{])$/ ) {
                $token_beg_next = $1;
            }
        }

        if (   $is_closing_token{$token_end}
            && $is_closing_token{$token_beg_next} )
        {

            # avoid instability of combo -bom and -sct; b1179
            my $seq_next = $type_sequence_to_go[$ibeg_next];
            my $bom = $seq_next && $self->[_rbreak_container_]->{$seq_next};
            $stackable = $stack_closing_token{$token_beg_next}
              unless ( $block_type_to_go[$ibeg_next] || $bom );
        }
        elsif ($is_opening_token{$token_end}
            && $is_opening_token{$token_beg_next} )
        {
            $stackable = $stack_opening_token{$token_beg_next}
              unless ( $block_type_to_go[$ibeg_next] );    # shouldn't happen
        }
        else {
            ## not stackable
        }

        if ($stackable) {

            my $is_semicolon_terminated;
            if ( $nline + 1 == $n_last_line ) {
                my $terminal_type = terminal_type_i( $ibeg_next, $iend_next );
                $is_semicolon_terminated = $terminal_type eq ';'
                  && $nesting_depth_to_go[$iend_next] <
                  $nesting_depth_to_go[$ibeg_next];
            }

            # this must be a line with just an opening token
            # or end in a semicolon
            if (
                $is_semicolon_terminated
                || (   $iend_next == $ibeg_next
                    || $iend_next == $ibeg_next + 2
                    && $types_to_go[$iend_next] eq '#' )
              )
            {
                my $spaces = ( $types_to_go[ $ibeg_next - 1 ] eq 'b' ) ? 1 : 0;

                $vt_type         = 2;
                $vt_opening_flag = 0;
                $vt_closing_flag = $spaces;
                $vt_seqno        = $type_sequence_to_go[$ibeg_next];
                $vt_valid_flag   = 1;
                $vt_min_lines    = 0;
                $vt_max_lines    = 0;
            }
        }
    }

    #--------------------------------------------------------------
    # Vertical Tightness Flags Section 2:
    # Handle type 3, opening block braces on last line of the batch
    # Check for a last line with isolated opening BLOCK curly
    #--------------------------------------------------------------
    elsif ($rOpts_block_brace_vertical_tightness
        && $ibeg eq $iend
        && $types_to_go[$iend] eq '{'
        && $block_type_to_go[$iend]
        && $block_type_to_go[$iend] =~
        /$block_brace_vertical_tightness_pattern/ )
    {
        $vt_type         = 3;
        $vt_opening_flag = $rOpts_block_brace_vertical_tightness;
        $vt_closing_flag = 0;
        $vt_seqno        = 0;
        $vt_valid_flag   = 1;
        $vt_min_lines    = 0;
        $vt_max_lines    = 0;
    }

    #--------------------------------------------------------------
    # Vertical Tightness Flags Section 3:
    # Handle type 4, a closing block brace on the last line of the batch Check
    # for a last line with isolated closing BLOCK curly
    # Patch: added a check for any new closing side comment which the
    # -csc option may generate. If it exists, there will be a side comment
    # so we cannot combine with a brace on the next line.  This issue
    # occurs for the combination -scbb and -csc is used.
    #--------------------------------------------------------------
    elsif ($rOpts_stack_closing_block_brace
        && $ibeg eq $iend
        && $block_type_to_go[$iend]
        && $types_to_go[$iend] eq '}'
        && ( !$closing_side_comment || $nline < $n_last_line ) )
    {
        my $spaces = $rOpts_block_brace_tightness == 2 ? 0 : 1;

        $vt_type         = 4;
        $vt_opening_flag = 0;
        $vt_closing_flag = $spaces;
        $vt_seqno        = $type_sequence_to_go[$iend];
        $vt_valid_flag   = 1;
        $vt_min_lines    = 0;
        $vt_max_lines    = 0;
    }
    else {
        # no -vt flags apply
    }

    my $last_vt_type = $self->[_last_vt_type_];
    $self->[_last_vt_type_] = $vt_type;

    if ( !$vt_type ) {

        # Make a simple return if this line is not involved in vertical
        # tightness at all.
        if (   !$vt_seqno_beg
            && !$vt_seqno_end
            && !$last_vt_type )
        {
            return;
        }

        $vt_type         = 0;
        $vt_opening_flag = 0;
        $vt_closing_flag = 0;
        $vt_seqno        = 0;
        $vt_valid_flag   = 0;
        $vt_min_lines    = 0;
        $vt_max_lines    = 0;
    }
    else {

        # guard against undefined sequence numbers pulled from _to_go
        if ( !defined($vt_seqno) ) { $vt_seqno = 0 }
    }

    # return the full data structure
    return {
        _vt_type         => $vt_type,
        _vt_opening_flag => $vt_opening_flag,
        _vt_closing_flag => $vt_closing_flag,
        _vt_seqno        => $vt_seqno,
        _vt_valid_flag   => $vt_valid_flag,
        _vt_min_lines    => $vt_min_lines,
        _vt_max_lines    => $vt_max_lines,
        _vt_seqno_beg    => $vt_seqno_beg,
        _vt_seqno_end    => $vt_seqno_end,
    };

} ## end sub set_vertical_tightness_flags

##########################################################
# CODE SECTION 14: Code for creating closing side comments
##########################################################

{    ## begin closure accumulate_csc_text

# These routines are called once per batch when the --closing-side-comments flag
# has been set.

    my $rblock_leading_text;
    my %block_opening_line_number;
    my $csc_new_statement_ok;
    my $csc_last_label;
    my %csc_block_label;
    my $accumulating_text_for_block;
    my $leading_block_text;
    my $rleading_block_if_elsif_text;
    my $leading_block_text_level;
    my $leading_block_text_length_exceeded;
    my $leading_block_text_line_length;
    my $leading_block_text_line_number;

    sub initialize_csc_vars {
        $rblock_leading_text          = {};
        %block_opening_line_number    = ();
        $csc_new_statement_ok         = 1;
        $csc_last_label               = EMPTY_STRING;
        %csc_block_label              = ();
        $rleading_block_if_elsif_text = [];
        $accumulating_text_for_block  = EMPTY_STRING;
        reset_block_text_accumulator();
        return;
    } ## end sub initialize_csc_vars

    sub reset_block_text_accumulator {

        # save text after 'if' and 'elsif' to append after 'else'
        if ($accumulating_text_for_block) {

            ## ( $accumulating_text_for_block =~ /^(if|elsif)$/ ) {
            if ( $is_if_elsif{$accumulating_text_for_block} ) {
                push @{$rleading_block_if_elsif_text}, $leading_block_text;
            }
        }
        $accumulating_text_for_block        = EMPTY_STRING;
        $leading_block_text                 = EMPTY_STRING;
        $leading_block_text_level           = 0;
        $leading_block_text_length_exceeded = 0;
        $leading_block_text_line_number     = 0;
        $leading_block_text_line_length     = 0;
        return;
    } ## end sub reset_block_text_accumulator

    sub set_block_text_accumulator {
        my ( $self, $i ) = @_;
        $accumulating_text_for_block = $tokens_to_go[$i];
        if ( $accumulating_text_for_block !~ /^els/ ) {
            $rleading_block_if_elsif_text = [];
        }
        $leading_block_text                 = EMPTY_STRING;
        $leading_block_text_level           = $levels_to_go[$i];
        $leading_block_text_line_number     = $self->get_output_line_number();
        $leading_block_text_length_exceeded = 0;

        # this will contain the column number of the last character
        # of the closing side comment
        $leading_block_text_line_length =
          length($csc_last_label) +
          length($accumulating_text_for_block) +
          length( $rOpts->{'closing-side-comment-prefix'} ) +
          $leading_block_text_level * $rOpts_indent_columns + 3;
        return;
    } ## end sub set_block_text_accumulator

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

        # accumulate leading text for -csc, ignoring any side comments
        if (   $accumulating_text_for_block
            && !$leading_block_text_length_exceeded
            && $types_to_go[$i] ne '#' )
        {

            my $added_length = $token_lengths_to_go[$i];
            $added_length += 1 if $i == 0;
            my $new_line_length =
              $leading_block_text_line_length + $added_length;

            # we can add this text if we don't exceed some limits..
            if (

                # we must not have already exceeded the text length limit
                length($leading_block_text) <
                $rOpts_closing_side_comment_maximum_text

                # and either:
                # the new total line length must be below the line length limit
                # or the new length must be below the text length limit
                # (ie, we may allow one token to exceed the text length limit)
                && (
                    $new_line_length <
                    $maximum_line_length_at_level[$leading_block_text_level]

                    || length($leading_block_text) + $added_length <
                    $rOpts_closing_side_comment_maximum_text
                )

                # UNLESS: we are adding a closing paren before the brace we
                # seek.  This is an attempt to avoid situations where the ...
                # to be added are longer than the omitted right paren, as in:

                #foreach my $item (@a_rather_long_variable_name_here) {
                #   &whatever;
                #} ## end foreach my $item (@a_rather_long_variable_name_here...

                || (
                    $tokens_to_go[$i] eq ')'
                    && (
                        (
                               $i + 1 <= $max_index_to_go
                            && $block_type_to_go[ $i + 1 ]
                            && $block_type_to_go[ $i + 1 ] eq
                            $accumulating_text_for_block
                        )
                        || (   $i + 2 <= $max_index_to_go
                            && $block_type_to_go[ $i + 2 ]
                            && $block_type_to_go[ $i + 2 ] eq
                            $accumulating_text_for_block )
                    )
                )
              )
            {

                # add an extra space at each newline
                if ( $i == 0 && $types_to_go[$i] ne 'b' ) {
                    $leading_block_text .= SPACE;
                }

                # add the token text
                $leading_block_text .= $tokens_to_go[$i];
                $leading_block_text_line_length = $new_line_length;
            }

            # show that text was truncated if necessary
            elsif ( $types_to_go[$i] ne 'b' ) {
                $leading_block_text_length_exceeded = 1;
                $leading_block_text .= '...';
            }
            else {
                # not enough space to add text
            }
        }
        return;
    } ## end sub accumulate_block_text

    sub accumulate_csc_text {

        my ($self) = @_;

        # called once per output buffer when -csc is used. Accumulates
        # the text placed after certain closing block braces.
        # Defines and returns the following for this buffer:

        my $block_leading_text =
          EMPTY_STRING;    # the leading text of the last '}'
        my $rblock_leading_if_elsif_text;
        my $i_block_leading_text =
          -1;              # index of token owning block_leading_text
        my $block_line_count    = 100;          # how many lines the block spans
        my $terminal_type       = 'b';          # type of last nonblank token
        my $i_terminal          = 0;            # index of last nonblank token
        my $terminal_block_type = EMPTY_STRING;

        # update most recent statement label
        $csc_last_label = EMPTY_STRING unless ($csc_last_label);
        if ( $types_to_go[0] eq 'J' ) { $csc_last_label = $tokens_to_go[0] }
        my $block_label = $csc_last_label;

        # Loop over all tokens of this batch
        for my $i ( 0 .. $max_index_to_go ) {
            my $type       = $types_to_go[$i];
            my $block_type = $block_type_to_go[$i];
            my $token      = $tokens_to_go[$i];
            $block_type = EMPTY_STRING unless ($block_type);

            # remember last nonblank token type
            if ( $type ne '#' && $type ne 'b' ) {
                $terminal_type       = $type;
                $terminal_block_type = $block_type;
                $i_terminal          = $i;
            }

            my $type_sequence = $type_sequence_to_go[$i];
            if ( $block_type && $type_sequence ) {

                if ( $token eq '}' ) {

                    # restore any leading text saved when we entered this block
                    if ( defined( $rblock_leading_text->{$type_sequence} ) ) {
                        ( $block_leading_text, $rblock_leading_if_elsif_text )
                          = @{ $rblock_leading_text->{$type_sequence} };
                        $i_block_leading_text = $i;
                        delete $rblock_leading_text->{$type_sequence};
                        $rleading_block_if_elsif_text =
                          $rblock_leading_if_elsif_text;
                    }

                    if ( defined( $csc_block_label{$type_sequence} ) ) {
                        $block_label = $csc_block_label{$type_sequence};
                        delete $csc_block_label{$type_sequence};
                    }

                    # if we run into a '}' then we probably started accumulating
                    # at something like a trailing 'if' clause..no harm done.
                    if (   $accumulating_text_for_block
                        && $levels_to_go[$i] <= $leading_block_text_level )
                    {
                        reset_block_text_accumulator();
                    }

                    if ( defined( $block_opening_line_number{$type_sequence} ) )
                    {
                        my $output_line_number =
                          $self->get_output_line_number();
                        $block_line_count =
                          $output_line_number -
                          $block_opening_line_number{$type_sequence} + 1;
                        delete $block_opening_line_number{$type_sequence};
                    }
                    else {

                        # Error: block opening line undefined for this line..
                        # This shouldn't be possible, but it is not a
                        # significant problem.
                    }
                }

                elsif ( $token eq '{' ) {

                    my $line_number = $self->get_output_line_number();
                    $block_opening_line_number{$type_sequence} = $line_number;

                    # set a label for this block, except for
                    # a bare block which already has the label
                    # A label can only be used on the next {
                    if ( $block_type =~ /:$/ ) {
                        $csc_last_label = EMPTY_STRING;
                    }
                    $csc_block_label{$type_sequence} = $csc_last_label;
                    $csc_last_label = EMPTY_STRING;

                    if (   $accumulating_text_for_block
                        && $levels_to_go[$i] == $leading_block_text_level )
                    {

                        if ( $accumulating_text_for_block eq $block_type ) {

                            # save any leading text before we enter this block
                            $rblock_leading_text->{$type_sequence} = [
                                $leading_block_text,
                                $rleading_block_if_elsif_text
                            ];
                            $block_opening_line_number{$type_sequence} =
                              $leading_block_text_line_number;
                            reset_block_text_accumulator();
                        }
                        else {

                            # shouldn't happen, but not a serious error.
                            # We were accumulating -csc text for block type
                            # $accumulating_text_for_block and unexpectedly
                            # encountered a '{' for block type $block_type.
                        }
                    }
                }
                else {
                    ## should not get here
                    DEVEL_MODE
                      && Fault("token=$token should be '{' or '}' for block\n");
                }
            }

            if (   $type eq 'k'
                && $csc_new_statement_ok
                && $is_if_elsif_else_unless_while_until_for_foreach{$token}
                && $token =~ /$closing_side_comment_list_pattern/
                && $token !~ /$closing_side_comment_exclusion_pattern/ )
            {
                $self->set_block_text_accumulator($i);
            }
            else {

                # note: ignoring type 'q' because of tricks being played
                # with 'q' for hanging side comments
                if ( $type ne 'b' && $type ne '#' && $type ne 'q' ) {
                    $csc_new_statement_ok =
                      ( $block_type || $type eq 'J' || $type eq ';' );
                }
                if (   $type eq ';'
                    && $accumulating_text_for_block
                    && $levels_to_go[$i] == $leading_block_text_level )
                {
                    reset_block_text_accumulator();
                }
                else {
                    $self->accumulate_block_text($i);
                }
            }
        }

        # Treat an 'else' block specially by adding preceding 'if' and
        # 'elsif' text.  Otherwise, the 'end else' is not helpful,
        # especially for cuddled-else formatting.
        if ( $terminal_block_type =~ /^els/ && $rblock_leading_if_elsif_text ) {
            $block_leading_text =
              $self->make_else_csc_text( $i_terminal, $terminal_block_type,
                $block_leading_text, $rblock_leading_if_elsif_text );
        }

        # if this line ends in a label then remember it for the next pass
        $csc_last_label = EMPTY_STRING;
        if ( $terminal_type eq 'J' ) {
            $csc_last_label = $tokens_to_go[$i_terminal];
        }

        return ( $terminal_type, $i_terminal, $i_block_leading_text,
            $block_leading_text, $block_line_count, $block_label );
    } ## end sub accumulate_csc_text

    sub make_else_csc_text {

        # create additional -csc text for an 'else' and optionally 'elsif',
        # depending on the value of switch
        #
        #  = 0 add 'if' text to trailing else
        #  = 1 same as 0 plus:
        #      add 'if' to 'elsif's if can fit in line length
        #      add last 'elsif' to trailing else if can fit in one line
        #  = 2 same as 1 but do not check if exceed line length
        #
        # $rif_elsif_text = a reference to a list of all previous closing
        # side comments created for this if block
        #
        my ( $self, $i_terminal, $block_type, $block_leading_text,
            $rif_elsif_text )
          = @_;
        my $csc_text = $block_leading_text;

        if (   $block_type eq 'elsif'
            && $rOpts_closing_side_comment_else_flag == 0 )
        {
            return $csc_text;
        }

        my $count = @{$rif_elsif_text};
        return $csc_text unless ($count);

        my $if_text = '[ if' . $rif_elsif_text->[0];

        # always show the leading 'if' text on 'else'
        if ( $block_type eq 'else' ) {
            $csc_text .= $if_text;
        }

        # see if that's all
        if ( $rOpts_closing_side_comment_else_flag == 0 ) {
            return $csc_text;
        }

        my $last_elsif_text = EMPTY_STRING;
        if ( $count > 1 ) {
            $last_elsif_text = ' [elsif' . $rif_elsif_text->[ $count - 1 ];
            if ( $count > 2 ) { $last_elsif_text = ' [...' . $last_elsif_text; }
        }

        # tentatively append one more item
        my $saved_text = $csc_text;
        if ( $block_type eq 'else' ) {
            $csc_text .= $last_elsif_text;
        }
        else {
            $csc_text .= SPACE . $if_text;
        }

        # all done if no length checks requested
        if ( $rOpts_closing_side_comment_else_flag == 2 ) {
            return $csc_text;
        }

        # undo it if line length exceeded
        my $length =
          length($csc_text) +
          length($block_type) +
          length( $rOpts->{'closing-side-comment-prefix'} ) +
          $levels_to_go[$i_terminal] * $rOpts_indent_columns + 3;
        if (
            $length > $maximum_line_length_at_level[$leading_block_text_level] )
        {
            $csc_text = $saved_text;
        }
        return $csc_text;
    } ## end sub make_else_csc_text
} ## end closure accumulate_csc_text

{    ## begin closure balance_csc_text

    # Some additional routines for handling the --closing-side-comments option

    my %matching_char;

    BEGIN {
        %matching_char = (
            '{' => '}',
            '(' => ')',
            '[' => ']',
            '}' => '{',
            ')' => '(',
            ']' => '[',
        );
    } ## end BEGIN

    sub balance_csc_text {

        # Append characters to balance a closing side comment so that editors
        # such as vim can correctly jump through code.
        # Simple Example:
        #  input  = ## end foreach my $foo ( sort { $b  ...
        #  output = ## end foreach my $foo ( sort { $b  ...})

        # NOTE: This routine does not currently filter out structures within
        # quoted text because the bounce algorithms in text editors do not
        # necessarily do this either (a version of vim was checked and
        # did not do this).

        # Some complex examples which will cause trouble for some editors:
        #  while ( $mask_string =~ /\{[^{]*?\}/g ) {
        #  if ( $mask_str =~ /\}\s*els[^\{\}]+\{$/ ) {
        #  if ( $1 eq '{' ) {
        # test file test1/braces.pl has many such examples.

        my ($csc) = @_;

        # loop to examine characters one-by-one, RIGHT to LEFT and
        # build a balancing ending, LEFT to RIGHT.
        foreach my $pos ( reverse( 0 .. length($csc) - 1 ) ) {

            my $char = substr( $csc, $pos, 1 );

            # ignore everything except structural characters
            next unless ( $matching_char{$char} );

            # pop most recently appended character
            my $top = chop $csc;

            # push it back plus the mate to the newest character
            # unless they balance each other.
            $csc = $csc . $top . $matching_char{$char} unless ( $top eq $char );
        }

        # return the balanced string
        return $csc;
    } ## end sub balance_csc_text
} ## end closure balance_csc_text

sub get_asub_block_label {
    my ( $self, $seqno ) = @_;

    # Given:
    #   $seqno = the sequence number of an asub block
    # Return:
    #   $block_label = the text # that will be displayed before 'sub' in its
    #   closing side comment.
    # Note: see similar inline code in sub find_selected_blocks

    # Example:
    #     my $doit = sub { ...
    #                    |
    #                    ^----------walk back from here to get
    # $block_label = '$doit ='

    my $block_label = EMPTY_STRING;
    return $block_label unless ($seqno);
    my $K_opening = $self->[_K_opening_container_]->{$seqno};
    my $rLL       = $self->[_rLL_];
    return $block_label unless ($K_opening);
    my $K_search_min = max( 0, $K_opening - 6 );
    my ( $saw_equals, $saw_fat_comma, $blank_count, $nonblank_count );
    my $text = EMPTY_STRING;

    foreach my $KK ( reverse( $K_search_min .. $K_opening - 1 ) ) {
        my $token_type = $rLL->[$KK]->[_TYPE_];
        my $token      = $rLL->[$KK]->[_TOKEN_];

        # first nonblank, keyword 'sub', is not part of the label
        if ($nonblank_count) { $text = $token . $text }

        if ( $token_type eq 'b' ) { $blank_count++; next }
        else                      { $nonblank_count++ }
        if ( $token_type eq '=>' ) { $saw_fat_comma++; next }
        if ( $token_type eq '=' )  { $saw_equals++;    next }
        if ( $token_type eq 'i' && $saw_equals
            || ( $token_type eq 'w' || $token_type eq 'Q' ) && $saw_fat_comma )
        {
            $block_label = $text;
            $block_label =~ s/\s*$//;
            last;
        }
    }
    return $block_label;
} ## end sub get_asub_block_label

sub add_closing_side_comment {

    my ($self) = @_;

    my $rLL        = $self->[_rLL_];
    my $this_batch = $self->[_this_batch_];

    my $ri_first = $this_batch->[_ri_first_];
    my $ri_last  = $this_batch->[_ri_last_];

    # add closing side comments after closing block braces if -csc used
    my ( $closing_side_comment, $cscw_block_comment );

    #---------------------------------------------------------------
    # Step 1: loop through all tokens of this line to accumulate
    # the text needed to create the closing side comments. Also see
    # how the line ends.
    #---------------------------------------------------------------

    my ( $terminal_type, $i_terminal, $i_block_leading_text,
        $block_leading_text, $block_line_count, $block_label )
      = $self->accumulate_csc_text();

    #---------------------------------------------------------------
    # Step 2: make the closing side comment if this ends a block
    #---------------------------------------------------------------
    my $have_side_comment = $types_to_go[$max_index_to_go] eq '#';

    # Special check for asub closing side comments (c380)
    # These are the only types which follow '};' instead of a bare '}'
    if ( $terminal_type eq ';' && $closing_side_comment_want_asub ) {
        if (   $types_to_go[0] eq '}'
            && $tokens_to_go[0] eq '}'
            && $i_terminal == $inext_to_go[0] )
        {
            my $seqno = $type_sequence_to_go[0];
            if ( $self->[_ris_asub_block_]->{$seqno} ) {

                # reset the terminal token to be the closing brace so
                # that the code below ignores the trailing semicolon
                $terminal_type = '}';
                $i_terminal    = 0;

                # create a name for this asub block
                $block_label = $self->get_asub_block_label($seqno);
            }
        }
    }

    # if this line might end in a block closure..
    if (
        $terminal_type eq '}'

        # Fix 1 for c091, this is only for blocks
        && $block_type_to_go[$i_terminal]

        # ..and either
        && (

            # the block is long enough
            ( $block_line_count >= $rOpts->{'closing-side-comment-interval'} )

            # or there is an existing comment to check
            || (   $have_side_comment
                && $rOpts->{'closing-side-comment-warnings'} )
        )

        # .. and if this is one of the types of interest
        && $block_type_to_go[$i_terminal] =~
        /$closing_side_comment_list_pattern/
        && $block_type_to_go[$i_terminal] !~
        /$closing_side_comment_exclusion_pattern/

        # ..and the corresponding opening brace must is not in this batch
        # (because we do not need to tag one-line blocks, although this
        # should also be caught with a positive -csci value)
        && !defined( $mate_index_to_go[$i_terminal] )

        # ..and either
        && (

            # this is the last token (line doesn't have a side comment)
            !$have_side_comment

            # or the old side comment is a closing side comment
            || $tokens_to_go[$max_index_to_go] =~
            /$closing_side_comment_prefix_pattern/
        )
      )
    {

        # then make the closing side comment text
        if ($block_label) { $block_label .= SPACE }
        my $token =
"$rOpts->{'closing-side-comment-prefix'} $block_label$block_type_to_go[$i_terminal]";

        # append any extra descriptive text collected above
        if ( $i_block_leading_text == $i_terminal ) {
            $token .= $block_leading_text;
        }

        $token = balance_csc_text($token)
          if $rOpts->{'closing-side-comments-balanced'};

        $token =~ s/\s+$//;    # trim any trailing whitespace

        # handle case of existing closing side comment
        if ($have_side_comment) {

            # warn if requested and tokens differ significantly
            if ( $rOpts->{'closing-side-comment-warnings'} ) {
                my $old_csc = $tokens_to_go[$max_index_to_go];
                my $new_csc = $token;
                $new_csc =~ s/\s+//g;            # trim all whitespace
                $old_csc =~ s/\s+//g;            # trim all whitespace
                $new_csc =~ s/[\]\)\}\s]*$//;    # trim trailing structures
                $old_csc =~ s/[\]\)\}\s]*$//;    # trim trailing structures

                # trim trailing '...'
                my $new_trailing_dots = $new_csc =~ s/\.\.\.$//;
                $old_csc =~ s/\.\.\.\s*$//;

                # Patch to handle multiple closing side comments at
                # else and elsif's.  These have become too complicated
                # to check, so if we see an indication of
                # '[ if' or '[ # elsif', then assume they were made
                # by perltidy.
                if ( $block_type_to_go[$i_terminal] eq 'else' ) {
                    if ( $old_csc =~ /\[\s*elsif/ ) { $old_csc = $new_csc }
                }
                elsif ( $block_type_to_go[$i_terminal] eq 'elsif' ) {
                    if ( $old_csc =~ /\[\s*if/ ) { $old_csc = $new_csc }
                }
                else {
                    # neither else or elsif
                }

                # if old comment is contained in new comment,
                # only compare the common part.
                if ( length($new_csc) > length($old_csc) ) {
                    $new_csc = substr( $new_csc, 0, length($old_csc) );
                }

                # if the new comment is shorter and has been limited,
                # only compare the common part.
                if ( length($new_csc) < length($old_csc)
                    && $new_trailing_dots )
                {
                    $old_csc = substr( $old_csc, 0, length($new_csc) );
                }

                # any remaining difference?
                if ( $new_csc ne $old_csc ) {

                    # just leave the old comment if we are below the threshold
                    # for creating side comments
                    if ( $block_line_count <
                        $rOpts->{'closing-side-comment-interval'} )
                    {
                        $token = undef;
                    }

                    # otherwise we'll make a note of it
                    else {

                        my $msg_line_number;
                        my $K = $K_to_go[$i_terminal];
                        if ( defined($K) ) {
                            $msg_line_number = $rLL->[$K]->[_LINE_INDEX_] + 1;
                        }
                        warning(
"perltidy -cscw replaced: $tokens_to_go[$max_index_to_go]\n",
                            $msg_line_number
                        );

                        # save the old side comment in a new trailing block
                        # comment
                        my $timestamp = EMPTY_STRING;
                        if ( $rOpts->{'timestamp'} ) {
                            my ( $day, $month, $year ) = (localtime)[ 3, 4, 5 ];
                            $year  += 1900;
                            $month += 1;
                            $timestamp = "$year-$month-$day";
                        }
                        $cscw_block_comment =
"## perltidy -cscw $timestamp: $tokens_to_go[$max_index_to_go]";
                    }
                }

                # No differences.. we can safely delete old comment if we
                # are below the threshold
                elsif ( $block_line_count <
                    $rOpts->{'closing-side-comment-interval'} )
                {
                    # Since the line breaks have already been set, we have
                    # to remove the token from the _to_go array and also
                    # from the line range (this fixes issue c081).
                    # Note that we can only get here if -cscw has been set
                    # because otherwise the old comment is already deleted.
                    $token = undef;
                    my $ibeg = $ri_first->[-1];
                    my $iend = $ri_last->[-1];
                    if (   $iend > $ibeg
                        && $iend == $max_index_to_go
                        && $types_to_go[$max_index_to_go] eq '#' )
                    {
                        $iend--;
                        $max_index_to_go--;
                        if (   $iend > $ibeg
                            && $types_to_go[$max_index_to_go] eq 'b' )
                        {
                            $iend--;
                            $max_index_to_go--;
                        }
                        $ri_last->[-1] = $iend;
                    }
                }
                else {
                    ## above threshold, cannot delete
                }
            }

            # switch to the new csc (unless we deleted it!)
            if ($token) {

                my $len_tok = length($token); # NOTE: length no longer important
                my $added_len =
                  $len_tok - $token_lengths_to_go[$max_index_to_go];

                $tokens_to_go[$max_index_to_go]        = $token;
                $token_lengths_to_go[$max_index_to_go] = $len_tok;
                my $K = $K_to_go[$max_index_to_go];
                $rLL->[$K]->[_TOKEN_]        = $token;
                $rLL->[$K]->[_TOKEN_LENGTH_] = $len_tok;
                $summed_lengths_to_go[ $max_index_to_go + 1 ] += $added_len;
            }
        }

        # handle case of NO existing closing side comment
        else {

            # To avoid inserting a new token in the token arrays, we
            # will just return the new side comment so that it can be
            # inserted just before it is needed in the call to the
            # vertical aligner.
            $closing_side_comment = $token;
        }
    }
    return ( $closing_side_comment, $cscw_block_comment );
} ## end sub add_closing_side_comment

############################
# CODE SECTION 15: Summarize
############################

sub wrapup {

    # This is the last routine called when a file is formatted.
    # Flush buffer and write any informative messages
    my ( $self, ($severe_error) ) = @_;

    # Optional parameter:
    #   $severe_error = true if program is ending on an error
    #                   false for normal end

    $self->flush();
    my $file_writer_object = $self->[_file_writer_object_];
    $file_writer_object->decrement_output_line_number()
      ;    # fix up line number since it was incremented
    we_are_at_the_last_line();

    my $max_depth = $self->[_maximum_BLOCK_level_];
    my $at_line   = $self->[_maximum_BLOCK_level_at_line_];
    write_logfile_entry(
"Maximum leading structural depth is $max_depth in input at line $at_line\n"
    );

    my $added_semicolon_count    = $self->[_added_semicolon_count_];
    my $first_added_semicolon_at = $self->[_first_added_semicolon_at_];
    my $last_added_semicolon_at  = $self->[_last_added_semicolon_at_];

    if ( $added_semicolon_count > 0 ) {
        my $first = ( $added_semicolon_count > 1 ) ? "First" : EMPTY_STRING;
        my $what =
          ( $added_semicolon_count > 1 ) ? "semicolons were" : "semicolon was";
        write_logfile_entry("$added_semicolon_count $what added:\n");
        write_logfile_entry(
            "  $first at input line $first_added_semicolon_at\n");

        if ( $added_semicolon_count > 1 ) {
            write_logfile_entry(
                "   Last at input line $last_added_semicolon_at\n");
        }
        write_logfile_entry("  (Use -nasc to prevent semicolon addition)\n");
        write_logfile_entry("\n");
    }

    my $deleted_semicolon_count    = $self->[_deleted_semicolon_count_];
    my $first_deleted_semicolon_at = $self->[_first_deleted_semicolon_at_];
    my $last_deleted_semicolon_at  = $self->[_last_deleted_semicolon_at_];
    if ( $deleted_semicolon_count > 0 ) {
        my $first = ( $deleted_semicolon_count > 1 ) ? "First" : EMPTY_STRING;
        my $what =
          ( $deleted_semicolon_count > 1 )
          ? "semicolons were"
          : "semicolon was";
        write_logfile_entry(
            "$deleted_semicolon_count unnecessary $what deleted:\n");
        write_logfile_entry(
            "  $first at input line $first_deleted_semicolon_at\n");

        if ( $deleted_semicolon_count > 1 ) {
            write_logfile_entry(
                "   Last at input line $last_deleted_semicolon_at\n");
        }
        write_logfile_entry("  (Use -ndsm to prevent semicolon deletion)\n");
        write_logfile_entry("\n");
    }

    my $embedded_tab_count    = $self->[_embedded_tab_count_];
    my $first_embedded_tab_at = $self->[_first_embedded_tab_at_];
    my $last_embedded_tab_at  = $self->[_last_embedded_tab_at_];
    if ( $embedded_tab_count > 0 ) {
        my $first = ( $embedded_tab_count > 1 ) ? "First" : EMPTY_STRING;
        my $what =
          ( $embedded_tab_count > 1 )
          ? "quotes or patterns"
          : "quote or pattern";
        write_logfile_entry("$embedded_tab_count $what had embedded tabs:\n");
        write_logfile_entry(
"This means the display of this script could vary with device or software\n"
        );
        write_logfile_entry("  $first at input line $first_embedded_tab_at\n");

        if ( $embedded_tab_count > 1 ) {
            write_logfile_entry(
                "   Last at input line $last_embedded_tab_at\n");
        }
        write_logfile_entry("\n");
    }

    my $first_tabbing_disagreement = $self->[_first_tabbing_disagreement_];
    my $last_tabbing_disagreement  = $self->[_last_tabbing_disagreement_];
    my $in_tabbing_disagreement    = $self->[_in_tabbing_disagreement_];

    if ($first_tabbing_disagreement) {
        write_logfile_entry(
"First indentation disagreement seen at input line $first_tabbing_disagreement\n"
        );
    }

    my $first_btd = $self->[_first_brace_tabbing_disagreement_];
    if ($first_btd) {
        my $msg =
"First closing brace indentation disagreement started at input line $first_btd\n";
        write_logfile_entry($msg);

        # leave a hint in the .ERR file if there was a brace error
        if ( get_saw_brace_error() ) { warning("NOTE: $msg") }
    }

    my $in_btd = $self->[_in_brace_tabbing_disagreement_];
    if ($in_btd) {
        my $msg =
"Ending with brace indentation disagreement which started at input line $in_btd\n";
        write_logfile_entry($msg);

        # leave a hint in the .ERR file if there was a brace error
        if ( get_saw_brace_error() ) { warning("NOTE: $msg") }
    }

    if ($in_tabbing_disagreement) {
        my $msg =
"Ending with indentation disagreement which started at input line $in_tabbing_disagreement\n";
        write_logfile_entry($msg);
    }
    else {

        if ($last_tabbing_disagreement) {

            write_logfile_entry(
"Last indentation disagreement seen at input line $last_tabbing_disagreement\n"
            );
        }
        else {
            write_logfile_entry("No indentation disagreement seen\n");
        }
    }

    if ($first_tabbing_disagreement) {
        write_logfile_entry(
"Note: Indentation disagreement detection is not accurate for outdenting and -lp.\n"
        );
    }
    write_logfile_entry("\n");

    my $vao = $self->[_vertical_aligner_object_];
    $vao->report_anything_unusual();

    $file_writer_object->report_line_length_errors();

    # Define the formatter self-check for convergence.
    $self->[_converged_] = $severe_error
      || (!$self->[_want_second_iteration_]
        && $file_writer_object->get_convergence_check() )
      || $rOpts->{'indent-only'};

    return;
} ## end sub wrapup

} ## end package Perl::Tidy::Formatter
1;
 #####################################################################
#
# The Perl::Tidy::IndentationItem class supplies items which contain
# how much whitespace should be used at the start of a line
#
#####################################################################

package Perl::Tidy::IndentationItem;
use strict;
use warnings;

our $VERSION = '20250105';

BEGIN {

    # Array index names
    # Do not combine with other BEGIN blocks (c101).
    my $i = 0;
    use constant {
        _spaces_             => $i++,
        _level_              => $i++,
        _ci_level_           => $i++,
        _available_spaces_   => $i++,
        _closed_             => $i++,
        _comma_count_        => $i++,
        _lp_item_index_      => $i++,
        _have_child_         => $i++,
        _recoverable_spaces_ => $i++,
        _align_seqno_        => $i++,
        _marked_             => $i++,
        _K_begin_line_       => $i++,
        _arrow_count_        => $i++,
        _standard_spaces_    => $i++,
        _K_extra_space_      => $i++,
    };
} ## end BEGIN

sub AUTOLOAD {

    # Catch any undefined sub calls so that we are sure to get
    # some diagnostic information.  This sub should never be called
    # except for a programming error.
    our $AUTOLOAD;
    return if ( $AUTOLOAD =~ /\bDESTROY$/ );
    my ( $pkg, $fname, $lno ) = caller();
    my $my_package = __PACKAGE__;
    print {*STDERR} <<EOM;
======================================================================
Error detected in package '$my_package', version $VERSION
Received unexpected AUTOLOAD call for sub '$AUTOLOAD'
Called from package: '$pkg'
Called from File '$fname'  at line '$lno'
This error is probably due to a recent programming change
======================================================================
EOM
    exit 1;
} ## end sub AUTOLOAD

sub DESTROY {

    # required to avoid call to AUTOLOAD in some versions of perl
}

sub new {

    # Create an 'indentation_item' which describes one level of leading
    # whitespace when the '-lp' indentation is used.
    my ( $class, %input_hash ) = @_;

    # DEFINITIONS:
    # spaces             =>  # total leading white spaces
    # level              =>  # the indentation 'level'
    # ci_level           =>  # the 'continuation level'
    # available_spaces   =>  # how many left spaces available
    #                        # for this level
    # closed             =>  # index where we saw closing '}'
    # comma_count        =>  # how many commas at this level?
    # lp_item_index     =>  # index in output batch list
    # have_child         =>  # any dependents?
    # recoverable_spaces =>  # how many spaces to the right
    #                        # we would like to move to get
    #                        # alignment (negative if left)
    # align_seqno        =>  # if we are aligning with an opening structure,
    #                        # this is its seqno
    # marked             =>  # if visited by corrector logic
    # K_begin_line   =>  # first token index K of this level
    # arrow_count        =>  # how many =>'s

    my $self = [];
    bless $self, $class;

    $self->[_spaces_]             = $input_hash{spaces};
    $self->[_level_]              = $input_hash{level};
    $self->[_ci_level_]           = $input_hash{ci_level};
    $self->[_available_spaces_]   = $input_hash{available_spaces};
    $self->[_closed_]             = -1;
    $self->[_comma_count_]        = 0;
    $self->[_lp_item_index_]      = $input_hash{lp_item_index};
    $self->[_have_child_]         = 0;
    $self->[_recoverable_spaces_] = 0;
    $self->[_align_seqno_]        = $input_hash{align_seqno};
    $self->[_marked_]             = 0;
    $self->[_K_begin_line_]       = $input_hash{K_begin_line};
    $self->[_arrow_count_]        = 0;
    $self->[_standard_spaces_]    = $input_hash{standard_spaces};
    $self->[_K_extra_space_]      = $input_hash{K_extra_space};

    return $self;
} ## end sub new

sub permanently_decrease_available_spaces {

    # make a permanent reduction in the available indentation spaces
    # at one indentation item.  NOTE: if there are child nodes, their
    # total SPACES must be reduced by the caller.

    my ( $self, $spaces_needed ) = @_;
    my $available_spaces = $self->get_available_spaces();
    my $deleted_spaces =
      ( $available_spaces > $spaces_needed )
      ? $spaces_needed
      : $available_spaces;

    # Fixed for c085; a zero value must remain unchanged unless the closed
    # flag has been set.
    my $closed = $self->get_closed();
    $self->decrease_available_spaces($deleted_spaces)
      if ( $available_spaces != 0 || $closed >= 0 );
    $self->decrease_SPACES($deleted_spaces);
    $self->set_recoverable_spaces(0);

    return $deleted_spaces;
} ## end sub permanently_decrease_available_spaces

sub tentatively_decrease_available_spaces {

    # We are asked to tentatively delete $spaces_needed of indentation
    # for an indentation item.  We may want to undo this later.  NOTE: if
    # there are child nodes, their total SPACES must be reduced by the
    # caller.
    my ( $self, $spaces_needed ) = @_;
    my $available_spaces = $self->get_available_spaces();
    my $deleted_spaces =
      ( $available_spaces > $spaces_needed )
      ? $spaces_needed
      : $available_spaces;
    $self->decrease_available_spaces($deleted_spaces);
    $self->decrease_SPACES($deleted_spaces);
    $self->increase_recoverable_spaces($deleted_spaces);
    return $deleted_spaces;
} ## end sub tentatively_decrease_available_spaces

# time-critical sub
sub get_spaces {
    return $_[0]->[_spaces_];
}

sub get_standard_spaces {
    my $self = shift;
    return $self->[_standard_spaces_];
}

# time-critical sub
sub get_marked {
    return $_[0]->[_marked_];
}

sub set_marked {
    my ( $self, $value ) = @_;
    if ( defined($value) ) {
        $self->[_marked_] = $value;
    }
    return $self->[_marked_];
} ## end sub set_marked

sub get_available_spaces {
    my $self = shift;
    return $self->[_available_spaces_];
}

sub decrease_SPACES {
    my ( $self, $value ) = @_;
    if ( defined($value) ) {
        $self->[_spaces_] -= $value;
    }
    return $self->[_spaces_];
} ## end sub decrease_SPACES

sub decrease_available_spaces {
    my ( $self, $value ) = @_;

    if ( defined($value) ) {
        $self->[_available_spaces_] -= $value;
    }
    return $self->[_available_spaces_];
} ## end sub decrease_available_spaces

sub get_align_seqno {
    my $self = shift;
    return $self->[_align_seqno_];
}

sub get_recoverable_spaces {
    my $self = shift;
    return $self->[_recoverable_spaces_];
}

sub set_recoverable_spaces {
    my ( $self, $value ) = @_;
    if ( defined($value) ) {
        $self->[_recoverable_spaces_] = $value;
    }
    return $self->[_recoverable_spaces_];
} ## end sub set_recoverable_spaces

sub increase_recoverable_spaces {
    my ( $self, $value ) = @_;
    if ( defined($value) ) {
        $self->[_recoverable_spaces_] += $value;
    }
    return $self->[_recoverable_spaces_];
} ## end sub increase_recoverable_spaces

sub get_ci_level {
    my $self = shift;
    return $self->[_ci_level_];
}

sub get_level {
    my $self = shift;
    return $self->[_level_];
}

sub get_spaces_level_ci {
    my $self = shift;
    return [ $self->[_spaces_], $self->[_level_], $self->[_ci_level_] ];
}

sub get_lp_item_index {
    my $self = shift;
    return $self->[_lp_item_index_];
}

sub get_K_begin_line {
    my $self = shift;
    return $self->[_K_begin_line_];
}

sub get_K_extra_space {
    my $self = shift;
    return $self->[_K_extra_space_];
}

sub set_have_child {
    my ( $self, $value ) = @_;
    if ( defined($value) ) {
        $self->[_have_child_] = $value;
    }
    return $self->[_have_child_];
} ## end sub set_have_child

sub get_have_child {
    my $self = shift;
    return $self->[_have_child_];
}

sub set_arrow_count {
    my ( $self, $value ) = @_;
    if ( defined($value) ) {
        $self->[_arrow_count_] = $value;
    }
    return $self->[_arrow_count_];
} ## end sub set_arrow_count

sub get_arrow_count {
    my $self = shift;
    return $self->[_arrow_count_];
}

sub set_comma_count {
    my ( $self, $value ) = @_;
    if ( defined($value) ) {
        $self->[_comma_count_] = $value;
    }
    return $self->[_comma_count_];
} ## end sub set_comma_count

sub get_comma_count {
    my $self = shift;
    return $self->[_comma_count_];
}

sub set_closed {
    my ( $self, $value ) = @_;
    if ( defined($value) ) {
        $self->[_closed_] = $value;
    }
    return $self->[_closed_];
} ## end sub set_closed

sub get_closed {
    my $self = shift;
    return $self->[_closed_];
}
1;
 IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiMKIyBUaGlzIGlzIGEgc3RyaXBwZWQgZG93biB2ZXJzaW9uIG9mIElPOjpTY2FsYXIKIyBHaXZlbiBhIHJlZmVyZW5jZSB0byBhIHNjYWxhciwgaXQgc3VwcGxpZXMgZWl0aGVyOgojIGEgZ2V0bGluZSBtZXRob2Qgd2hpY2ggcmVhZHMgbGluZXMgKG1vZGU9J3InKSwgb3IKIyBhIHByaW50IG1ldGhvZCB3aGljaCByZWFkcyBsaW5lcyAobW9kZT0ndycpCiMKIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCnBhY2thZ2UgUGVybDo6VGlkeTo6SU9TY2FsYXI7CnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKdXNlIENhcnA7Cm91ciAkVkVSU0lPTiA9ICcyMDI1MDEwNSc7Cgp1c2UgY29uc3RhbnQgREVWRUxfTU9ERSAgID0+IDA7CnVzZSBjb25zdGFudCBFTVBUWV9TVFJJTkcgPT4gcXt9OwoKc3ViIEFVVE9MT0FEIHsKCiAgICAjIENhdGNoIGFueSB1bmRlZmluZWQgc3ViIGNhbGxzIHNvIHRoYXQgd2UgYXJlIHN1cmUgdG8gZ2V0CiAgICAjIHNvbWUgZGlhZ25vc3RpYyBpbmZvcm1hdGlvbi4gIFRoaXMgc3ViIHNob3VsZCBuZXZlciBiZSBjYWxsZWQKICAgICMgZXhjZXB0IGZvciBhIHByb2dyYW1taW5nIGVycm9yLgogICAgb3VyICRBVVRPTE9BRDsKICAgIHJldHVybiBpZiAoICRBVVRPTE9BRCA9fiAvXGJERVNUUk9ZJC8gKTsKCiAgICAjIE9yaWdpbmFsbHkgdGhlcmUgd2FzIGEgZHVtbXkgc3ViIGNsb3NlLiBBbGwgY2FsbHMgdG8gaXQgc2hvdWxkIGhhdmUgYmVlbgogICAgIyBlbGltaW5hdGVkLCBidXQgZm9yIHNhZmV0eSB3ZSB3aWxsIGNoZWNrIGZvciB0aGVtIGhlcmUuCiAgICByZXR1cm4gMSBpZiAoICRBVVRPTE9BRCA9fiAvXGJjbG9zZSQvICYmICFERVZFTF9NT0RFICk7CiAgICBteSAoICRwa2csICRmbmFtZSwgJGxubyApID0gY2FsbGVyKCk7CiAgICBteSAkbXlfcGFja2FnZSA9IF9fUEFDS0FHRV9fOwogICAgcHJpbnQgeypTVERFUlJ9IDw8RU9NOwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CkVycm9yIGRldGVjdGVkIGluIHBhY2thZ2UgJyRteV9wYWNrYWdlJywgdmVyc2lvbiAkVkVSU0lPTgpSZWNlaXZlZCB1bmV4cGVjdGVkIEFVVE9MT0FEIGNhbGwgZm9yIHN1YiAnJEFVVE9MT0FEJwpDYWxsZWQgZnJvbSBwYWNrYWdlOiAnJHBrZycKQ2FsbGVkIGZyb20gRmlsZSAnJGZuYW1lJyAgYXQgbGluZSAnJGxubycKVGhpcyBlcnJvciBpcyBwcm9iYWJseSBkdWUgdG8gYSByZWNlbnQgcHJvZ3JhbW1pbmcgY2hhbmdlCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KRU9NCiAgICBleGl0IDE7Cn0gIyMgZW5kIHN1YiBBVVRPTE9BRAoKc3ViIERFU1RST1kgewoKICAgICMgcmVxdWlyZWQgdG8gYXZvaWQgY2FsbCB0byBBVVRPTE9BRCBpbiBzb21lIHZlcnNpb25zIG9mIHBlcmwKfQoKc3ViIG5ldyB7CiAgICBteSAoICRwYWNrYWdlLCAkcnNjYWxhciwgJG1vZGUgKSA9IEBfOwogICAgbXkgJHJlZiA9IHJlZigkcnNjYWxhcik7CiAgICBpZiAoICRyZWYgbmUgJ1NDQUxBUicgKSB7CiAgICAgICAgY29uZmVzcyA8PEVPTTsKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCmV4cGVjdGluZyByZWYgdG8gU0NBTEFSIGJ1dCBnb3QgcmVmIHRvICgkcmVmKTsgdHJhY2UgZm9sbG93czoKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCkVPTQoKICAgIH0KICAgIGlmICggJG1vZGUgZXEgJ3cnICkgewogICAgICAgICR7JHJzY2FsYXJ9ID0gRU1QVFlfU1RSSU5HOwogICAgICAgIHJldHVybiBibGVzcyBbICRyc2NhbGFyLCAkbW9kZSBdLCAkcGFja2FnZTsKICAgIH0KICAgIGVsc2lmICggJG1vZGUgZXEgJ3InICkgewoKICAgICAgICAjIENvbnZlcnQgYSBzY2FsYXIgdG8gYW4gYXJyYXkuCiAgICAgICAgIyBUaGlzIGF2b2lkcyBsb29raW5nIGZvciAiXG4iIG9uIGVhY2ggY2FsbCB0byBnZXRsaW5lCiAgICAgICAgbXkgQGFycmF5OwogICAgICAgIGlmICggJHJzY2FsYXIgJiYgJHskcnNjYWxhcn0gKSB7CiAgICAgICAgICAgIEBhcnJheSA9IHNwbGl0IC9eLywgJHskcnNjYWxhcn07CiAgICAgICAgfQogICAgICAgIG15ICRpX25leHQgPSAwOwogICAgICAgIHJldHVybiBibGVzcyBbIFxAYXJyYXksICRtb2RlLCAkaV9uZXh0IF0sICRwYWNrYWdlOwogICAgfQogICAgZWxzZSB7CiAgICAgICAgY29uZmVzcyA8PEVPTTsKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCmV4cGVjdGluZyBtb2RlID0gJ3InIG9yICd3JyBidXQgZ290IG1vZGUgKCRtb2RlKTsgdHJhY2UgZm9sbG93czoKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCkVPTQogICAgfQp9ICMjIGVuZCBzdWIgbmV3CgpzdWIgZ2V0bGluZSB7CiAgICBteSAkc2VsZiA9IHNoaWZ0OwogICAgbXkgJG1vZGUgPSAkc2VsZi0+WzFdOwogICAgaWYgKCAkbW9kZSBuZSAncicgKSB7CiAgICAgICAgY29uZmVzcyA8PEVPTTsKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCmdldGxpbmUgY2FsbCByZXF1aXJlcyBtb2RlID0gJ3InIGJ1dCBtb2RlID0gKCRtb2RlKTsgdHJhY2UgZm9sbG93czoKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCkVPTQogICAgfQogICAgbXkgJGkgPSAkc2VsZi0+WzJdKys7CiAgICByZXR1cm4gJHNlbGYtPlswXS0+WyRpXTsKfSAjIyBlbmQgc3ViIGdldGxpbmUKCnN1YiBwcmludCB7CiAgICBteSAoICRzZWxmLCAkbXNnICkgPSBAXzsKICAgIG15ICRtb2RlID0gJHNlbGYtPlsxXTsKICAgIGlmICggJG1vZGUgbmUgJ3cnICkgewogICAgICAgIGNvbmZlc3MgPDxFT007Ci0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpwcmludCBjYWxsIHJlcXVpcmVzIG1vZGUgPSAndycgYnV0IG1vZGUgPSAoJG1vZGUpOyB0cmFjZSBmb2xsb3dzOgotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KRU9NCiAgICB9CiAgICAkeyAkc2VsZi0+WzBdIH0gLj0gJG1zZzsKICAgIHJldHVybjsKfSAjIyBlbmQgc3ViIHByaW50CjE7Cg== #####################################################################
#
# The Perl::Tidy::HtmlWriter class writes a copy of the input stream in html
#
#####################################################################

package Perl::Tidy::HtmlWriter;
use strict;
use warnings;
our $VERSION = '20250105';

use Carp;
use English qw( -no_match_vars );
use File::Basename;
use File::Temp qw();

use constant EMPTY_STRING => q{};
use constant SPACE        => q{ };

{ #<<< A non-indenting brace to contain all lexical variables

# class variables
my (

    # INITIALIZER: BEGIN block
    $missing_html_entities,
    $missing_pod_html,

    # INITIALIZER: BEGIN block
    %short_to_long_names,
    %token_short_names,

    # INITIALIZER: sub check_options
    $rOpts,
    $rOpts_html_entities,
    $css_linkname,
    %html_bold,
    %html_color,
    %html_italic,

);

# replace unsafe characters with HTML entity representation if HTML::Entities
# is available
#{ eval "use HTML::Entities"; $missing_html_entities = $@; }

BEGIN {

    $missing_html_entities = EMPTY_STRING;
    if ( !eval { require HTML::Entities; 1 } ) {
        $missing_html_entities = $EVAL_ERROR ? $EVAL_ERROR : 1;
    }

    $missing_pod_html = EMPTY_STRING;
    if ( !eval { require Pod::Html; 1 } ) {
        $missing_pod_html = $EVAL_ERROR ? $EVAL_ERROR : 1;
    }
} ## end BEGIN

sub AUTOLOAD {

    # Catch any undefined sub calls so that we are sure to get
    # some diagnostic information.  This sub should never be called
    # except for a programming error.
    our $AUTOLOAD;
    return if ( $AUTOLOAD =~ /\bDESTROY$/ );
    my ( $pkg, $fname, $lno ) = caller();
    my $my_package = __PACKAGE__;
    print {*STDERR} <<EOM;
======================================================================
Error detected in package '$my_package', version $VERSION
Received unexpected AUTOLOAD call for sub '$AUTOLOAD'
Called from package: '$pkg'
Called from File '$fname'  at line '$lno'
This error is probably due to a recent programming change
======================================================================
EOM
    exit 1;
} ## end sub AUTOLOAD

sub DESTROY {

    # required to avoid call to AUTOLOAD in some versions of perl
}

sub new {

    my ( $class, @arglist ) = @_;
    if ( @arglist % 2 ) { croak "Odd number of items in arg hash list\n" }

    my %defaults = (
        input_file         => undef,
        html_file          => undef,
        extension          => undef,
        html_toc_extension => undef,
        html_src_extension => undef,
    );
    my %args = ( %defaults, @arglist );

    my $input_file         = $args{input_file};
    my $html_file          = $args{html_file};
    my $extension          = $args{extension};
    my $html_toc_extension = $args{html_toc_extension};
    my $html_src_extension = $args{html_src_extension};

    my $html_fh = Perl::Tidy::streamhandle( $html_file, 'w' );
    if ( !$html_fh ) {
        Perl::Tidy::Warn("can't open html file '$html_file'\n");
        return;
    }
    my $html_file_opened = 1;

    if ( !$input_file || $input_file eq '-' || ref($input_file) ) {
        $input_file = "NONAME";
    }

    # write the table of contents to a string
    my $toc_string;
    my $html_toc_fh = Perl::Tidy::IOScalar->new( \$toc_string, 'w' );

    my $html_pre_fh;
    my @pre_string_stack;
    if ( $rOpts->{'html-pre-only'} ) {

        # pre section goes directly to the output stream
        $html_pre_fh = $html_fh;
        $html_pre_fh->print(<<"PRE_END");
<pre>
PRE_END
    }
    else {

        # pre section go out to a temporary string
        my $pre_string;
        $html_pre_fh = Perl::Tidy::IOScalar->new( \$pre_string, 'w' );
        push @pre_string_stack, \$pre_string;
    }

    # pod text gets diverted if the 'pod2html' is used
    my $html_pod_fh;
    my $pod_string;
    if ( $rOpts->{'pod2html'} ) {
        if ( $rOpts->{'html-pre-only'} ) {
            undef $rOpts->{'pod2html'};
        }
        else {
            if ($missing_pod_html) {
                Perl::Tidy::Warn(
"unable to find Pod::Html; cannot use pod2html\n-npod disables this message\n"
                );
                undef $rOpts->{'pod2html'};
            }
            else {
                $html_pod_fh = Perl::Tidy::IOScalar->new( \$pod_string, 'w' );
            }
        }
    }

    my $toc_filename;
    my $src_filename;
    if ( $rOpts->{'frames'} ) {
        if ( !$extension ) {
            Perl::Tidy::Warn(
"cannot use frames without a specified output extension; ignoring -frm\n"
            );
            undef $rOpts->{'frames'};
        }
        else {
            $toc_filename = $input_file . $html_toc_extension . $extension;
            $src_filename = $input_file . $html_src_extension . $extension;
        }
    }

    # ----------------------------------------------------------
    # Output is now directed as follows:
    # html_toc_fh <-- table of contents items
    # html_pre_fh <-- the <pre> section of formatted code, except:
    # html_pod_fh <-- pod goes here with the pod2html option
    # ----------------------------------------------------------

    my $title = $rOpts->{'title'};
    if ( !$title ) {
        ( $title, my $path_uu ) = fileparse($input_file);
    }
    my $toc_item_count = 0;
    my $in_toc_package = EMPTY_STRING;
    my $last_level     = 0;
    return bless {
        _input_file        => $input_file,          # name of input file
        _title             => $title,               # title, unescaped
        _html_file         => $html_file,           # name of .html output file
        _toc_filename      => $toc_filename,        # for frames option
        _src_filename      => $src_filename,        # for frames option
        _html_file_opened  => $html_file_opened,    # a flag
        _html_fh           => $html_fh,             # the output stream
        _html_pre_fh       => $html_pre_fh,         # pre section goes here
        _rpre_string_stack => \@pre_string_stack,   # stack of pre sections
        _html_pod_fh       => $html_pod_fh,         # pod goes here if pod2html
        _rpod_string       => \$pod_string,         # string holding pod
        _pod_cut_count     => 0,                    # how many =cut's?
        _html_toc_fh       => $html_toc_fh,         # fh for table of contents
        _rtoc_string       => \$toc_string,         # string holding toc
        _rtoc_item_count   => \$toc_item_count,     # how many toc items
        _rin_toc_package   => \$in_toc_package,     # package name
        _rtoc_name_count   => {},                   # hash to track unique names
        _rpackage_stack    => [],                   # stack to check for package
                                                    # name changes
        _rlast_level       => \$last_level,         # brace indentation level
    }, $class;
} ## end sub new

sub add_toc_item {

    # Add an item to the html table of contents.
    # This is called even if no table of contents is written,
    # because we still want to put the anchors in the <pre> text.
    # We are given an anchor name and its type; types are:
    #      'package', 'sub', '__END__', '__DATA__', 'EOF'
    # There must be an 'EOF' call at the end to wrap things up.
    my ( $self, $name, $type ) = @_;
    my $html_toc_fh     = $self->{_html_toc_fh};
    my $html_pre_fh     = $self->{_html_pre_fh};
    my $rtoc_name_count = $self->{_rtoc_name_count};
    my $rtoc_item_count = $self->{_rtoc_item_count};
    my $rlast_level     = $self->{_rlast_level};
    my $rin_toc_package = $self->{_rin_toc_package};
    my $rpackage_stack  = $self->{_rpackage_stack};

    # packages contain sublists of subs, so to avoid errors all package
    # items are written and finished with the following routines
    my $end_package_list = sub {
        if ( ${$rin_toc_package} ) {
            $html_toc_fh->print("</ul>\n</li>\n");
            ${$rin_toc_package} = EMPTY_STRING;
        }
        return;
    }; ## end $end_package_list = sub

    my $start_package_list = sub {
        my ( $unique_name, $package ) = @_;
        if ( ${$rin_toc_package} ) { $end_package_list->() }
        $html_toc_fh->print(<<EOM);
<li><a href=\"#$unique_name\">package $package</a>
<ul>
EOM
        ${$rin_toc_package} = $package;
        return;
    }; ## end $start_package_list = sub

    # start the table of contents on the first item
    if ( !${$rtoc_item_count} ) {

        # but just quit if we hit EOF without any other entries
        # in this case, there will be no toc
        return if ( $type eq 'EOF' );
        $html_toc_fh->print(<<"TOC_END");
<!-- BEGIN CODE INDEX --><a name="code-index"></a>
<ul>
TOC_END
    }
    ${$rtoc_item_count}++;

    # make a unique anchor name for this location:
    #   - packages get a 'package-' prefix
    #   - subs use their names
    my $unique_name = $name;
    if ( $type eq 'package' ) { $unique_name = "package-$name" }

    # append '-1', '-2', etc if necessary to make unique; this will
    # be unique because subs and packages cannot have a '-'
    if ( my $count = $rtoc_name_count->{ lc $unique_name }++ ) {
        $unique_name .= "-$count";
    }

    #   - all names get terminal '-' if pod2html is used, to avoid
    #     conflicts with anchor names created by pod2html
    if ( $rOpts->{'pod2html'} ) { $unique_name .= '-' }

    # start/stop lists of subs
    if ( $type eq 'sub' ) {
        my $package = $rpackage_stack->[ ${$rlast_level} ];
        if ( !$package ) { $package = 'main' }

        # if we're already in a package/sub list, be sure its the right
        # package or else close it
        if ( ${$rin_toc_package} && ${$rin_toc_package} ne $package ) {
            $end_package_list->();
        }

        # start a package/sub list if necessary
        if ( !${$rin_toc_package} ) {
            $start_package_list->( $unique_name, $package );
        }
    }

    # now write an entry in the toc for this item
    if ( $type eq 'package' ) {
        $start_package_list->( $unique_name, $name );
    }
    elsif ( $type eq 'sub' ) {
        $html_toc_fh->print("<li><a href=\"#$unique_name\">$name</a></li>\n");
    }
    else {
        $end_package_list->();
        $html_toc_fh->print("<li><a href=\"#$unique_name\">$name</a></li>\n");
    }

    # write the anchor in the <pre> section
    $html_pre_fh->print("<a name=\"$unique_name\"></a>");

    # end the table of contents, if any, on the end of file
    if ( $type eq 'EOF' ) {
        $html_toc_fh->print(<<"TOC_END");
</ul>
<!-- END CODE INDEX -->
TOC_END
    }
    return;
} ## end sub add_toc_item

BEGIN {

    # This is the official list of tokens which may be identified by the
    # user.  Long names are used as getopt keys.  Short names are
    # convenient short abbreviations for specifying input.  Short names
    # somewhat resemble token type characters, but are often different
    # because they may only be alphanumeric, to allow command line
    # input.  Also, note that because of case insensitivity of html,
    # this table must be in a single case only (I've chosen to use all
    # lower case).
    # When adding NEW_TOKENS: update this hash table
    # short names => long names
    %short_to_long_names = (
        'n'  => 'numeric',
        'p'  => 'paren',
        'q'  => 'quote',
        's'  => 'structure',
        'c'  => 'comment',
        'v'  => 'v-string',
        'cm' => 'comma',
        'w'  => 'bareword',
        'co' => 'colon',
        'pu' => 'punctuation',
        'i'  => 'identifier',
        'j'  => 'label',
        'h'  => 'here-doc-target',
        'hh' => 'here-doc-text',
        'k'  => 'keyword',
        'sc' => 'semicolon',
        'm'  => 'subroutine',
        'pd' => 'pod-text',
    );

    # Now we have to map actual token types into one of the above short
    # names; any token types not mapped will get 'punctuation'
    # properties.

    # The values of this hash table correspond to the keys of the
    # previous hash table.
    # The keys of this hash table are token types and can be seen
    # by running with --dump-token-types (-dtt).

    # When adding NEW_TOKENS: update this hash table
    # $type => $short_name
    # c250: changed 'M' to 'S'
    %token_short_names = (
        '#'  => 'c',
        'n'  => 'n',
        'v'  => 'v',
        'k'  => 'k',
        'F'  => 'k',
        'Q'  => 'q',
        'q'  => 'q',
        'J'  => 'j',
        'j'  => 'j',
        'h'  => 'h',
        'H'  => 'hh',
        'w'  => 'w',
        ','  => 'cm',
        '=>' => 'cm',
        ';'  => 'sc',
        ':'  => 'co',
        'f'  => 'sc',
        '('  => 'p',
        ')'  => 'p',
        'S'  => 'm',
        'pd' => 'pd',
        'A'  => 'co',
    );

    # These token types will all be called identifiers for now
    # Fix for c250: added new type 'P', formerly 'i'
    # ( but package statements will eventually be split into 'k' and 'i')
    my @identifier = qw< i t U C Y Z G P :: CORE::>;
    @token_short_names{@identifier} = ('i') x scalar(@identifier);

    # These token types will be called 'structure'
    my @structure = qw< { } >;
    @token_short_names{@structure} = ('s') x scalar(@structure);

    # OLD NOTES: save for reference
    # Any of these could be added later if it would be useful.
    # For now, they will by default become punctuation
    #    my @list = qw< L R [ ] >;
    #    @token_long_names{@list} = ('non-structure') x scalar(@list);
    #
    #    my @list = qw"
    #      / /= * *= ** **= + += - -= % %= = ++ -- << <<= >> >>= pp p m mm
    #      ";
    #    @token_long_names{@list} = ('math') x scalar(@list);
    #
    #    my @list = qw" & &= ~ ~= ^ ^= | |= ";
    #    @token_long_names{@list} = ('bit') x scalar(@list);
    #
    #    my @list = qw" == != < > <= <=> ";
    #    @token_long_names{@list} = ('numerical-comparison') x scalar(@list);
    #
    #    my @list = qw" && || ! &&= ||= //= ";
    #    @token_long_names{@list} = ('logical') x scalar(@list);
    #
    #    my @list = qw" . .= =~ !~ x x= ";
    #    @token_long_names{@list} = ('string-operators') x scalar(@list);
    #
    #    # Incomplete..
    #    my @list = qw" .. -> <> ... \ ? ";
    #    @token_long_names{@list} = ('misc-operators') x scalar(@list);

} ## end BEGIN

sub make_getopt_long_names {
    my ( $class, $rgetopt_names ) = @_;
    foreach my $short_name ( keys %short_to_long_names ) {
        my $long_name = $short_to_long_names{$short_name};
        push @{$rgetopt_names}, "html-color-$long_name=s";
        push @{$rgetopt_names}, "html-italic-$long_name!";
        push @{$rgetopt_names}, "html-bold-$long_name!";
    }
    push @{$rgetopt_names}, "html-color-background=s";
    push @{$rgetopt_names}, "html-linked-style-sheet=s";
    push @{$rgetopt_names}, "nohtml-style-sheets";
    push @{$rgetopt_names}, "html-pre-only";
    push @{$rgetopt_names}, "html-line-numbers";
    push @{$rgetopt_names}, "html-entities!";
    push @{$rgetopt_names}, "stylesheet";
    push @{$rgetopt_names}, "html-table-of-contents!";
    push @{$rgetopt_names}, "pod2html!";
    push @{$rgetopt_names}, "frames!";
    push @{$rgetopt_names}, "html-toc-extension=s";
    push @{$rgetopt_names}, "html-src-extension=s";

    # Pod::Html parameters:
    push @{$rgetopt_names}, "backlink=s";
    push @{$rgetopt_names}, "cachedir=s";
    push @{$rgetopt_names}, "htmlroot=s";
    push @{$rgetopt_names}, "libpods=s";
    push @{$rgetopt_names}, "podpath=s";
    push @{$rgetopt_names}, "podroot=s";
    push @{$rgetopt_names}, "title=s";

    # Pod::Html parameters with leading 'pod' which will be removed
    # before the call to Pod::Html
    push @{$rgetopt_names}, "podquiet!";
    push @{$rgetopt_names}, "podverbose!";
    push @{$rgetopt_names}, "podrecurse!";
    push @{$rgetopt_names}, "podflush";
    push @{$rgetopt_names}, "podheader!";
    push @{$rgetopt_names}, "podindex!";
    return;
} ## end sub make_getopt_long_names

sub make_abbreviated_names {

    # We're appending things like this to the expansion list:
    #      'hcc'    => [qw(html-color-comment)],
    #      'hck'    => [qw(html-color-keyword)],
    #  etc
    my ( $class, $rexpansion ) = @_;

    # abbreviations for color/bold/italic properties
    foreach my $short_name ( keys %short_to_long_names ) {
        my $long_name = $short_to_long_names{$short_name};
        ${$rexpansion}{"hc$short_name"}  = ["html-color-$long_name"];
        ${$rexpansion}{"hb$short_name"}  = ["html-bold-$long_name"];
        ${$rexpansion}{"hi$short_name"}  = ["html-italic-$long_name"];
        ${$rexpansion}{"nhb$short_name"} = ["nohtml-bold-$long_name"];
        ${$rexpansion}{"nhi$short_name"} = ["nohtml-italic-$long_name"];
    }

    # abbreviations for all other html options
    ${$rexpansion}{"hcbg"}  = ["html-color-background"];
    ${$rexpansion}{"pre"}   = ["html-pre-only"];
    ${$rexpansion}{"toc"}   = ["html-table-of-contents"];
    ${$rexpansion}{"ntoc"}  = ["nohtml-table-of-contents"];
    ${$rexpansion}{"nnn"}   = ["html-line-numbers"];
    ${$rexpansion}{"hent"}  = ["html-entities"];
    ${$rexpansion}{"nhent"} = ["nohtml-entities"];
    ${$rexpansion}{"css"}   = ["html-linked-style-sheet"];
    ${$rexpansion}{"nss"}   = ["nohtml-style-sheets"];
    ${$rexpansion}{"ss"}    = ["stylesheet"];
    ${$rexpansion}{"pod"}   = ["pod2html"];
    ${$rexpansion}{"npod"}  = ["nopod2html"];
    ${$rexpansion}{"frm"}   = ["frames"];
    ${$rexpansion}{"nfrm"}  = ["noframes"];
    ${$rexpansion}{"text"}  = ["html-toc-extension"];
    ${$rexpansion}{"sext"}  = ["html-src-extension"];
    return;
} ## end sub make_abbreviated_names

sub check_options {

    # This will be called once after options have been parsed
    # Note that we are defining the package variable $rOpts here:
    ( my $class, $rOpts ) = @_;

    # X11 color names for default settings that seemed to look ok
    # (these color names are only used for programming clarity; the hex
    # numbers are actually written)
##  use constant SaddleBrown   => "#8B4513";
    use constant ForestGreen   => "#228B22";
    use constant magenta4      => "#8B008B";
    use constant IndianRed3    => "#CD5555";
    use constant DeepSkyBlue4  => "#00688B";
    use constant MediumOrchid3 => "#B452CD";
    use constant black         => "#000000";
    use constant white         => "#FFFFFF";
    use constant red           => "#FF0000";

    # set default color, bold, italic properties
    # anything not listed here will be given the default (punctuation) color --
    # these types currently not listed and get default: ws pu s sc cm co p
    # When adding NEW_TOKENS: add an entry here if you don't want defaults

    # set_default_properties( $short_name, default_color, bold?, italic? );
    set_default_properties( 'c',  ForestGreen,   0, 0 );
    set_default_properties( 'pd', ForestGreen,   0, 1 );
    set_default_properties( 'k',  magenta4,      1, 0 );    # was SaddleBrown
    set_default_properties( 'q',  IndianRed3,    0, 0 );
    set_default_properties( 'hh', IndianRed3,    0, 1 );
    set_default_properties( 'h',  IndianRed3,    1, 0 );
    set_default_properties( 'i',  DeepSkyBlue4,  0, 0 );
    set_default_properties( 'w',  black,         0, 0 );
    set_default_properties( 'n',  MediumOrchid3, 0, 0 );
    set_default_properties( 'v',  MediumOrchid3, 0, 0 );
    set_default_properties( 'j',  IndianRed3,    1, 0 );
    set_default_properties( 'm',  red,           1, 0 );

    set_default_color( 'html-color-background',  white );
    set_default_color( 'html-color-punctuation', black );

    # setup property lookup tables for tokens based on their short names
    # every token type has a short name, and will use these tables
    # to do the html markup
    foreach my $short_name ( keys %short_to_long_names ) {
        my $long_name = $short_to_long_names{$short_name};
        $html_color{$short_name}  = $rOpts->{"html-color-$long_name"};
        $html_bold{$short_name}   = $rOpts->{"html-bold-$long_name"};
        $html_italic{$short_name} = $rOpts->{"html-italic-$long_name"};
    }

    # write style sheet to STDOUT and die if requested
    if ( defined( $rOpts->{'stylesheet'} ) ) {
        write_style_sheet_file('-');
        Perl::Tidy::Exit(0);
    }

    # make sure user gives a file name after -css
    $css_linkname = EMPTY_STRING;
    if ( defined( $rOpts->{'html-linked-style-sheet'} ) ) {
        $css_linkname = $rOpts->{'html-linked-style-sheet'};
        if ( $css_linkname =~ /^-/ ) {
            Perl::Tidy::Die("You must specify a valid filename after -css\n");
        }
    }

    # check for conflict
    if ( $css_linkname && $rOpts->{'nohtml-style-sheets'} ) {
        $rOpts->{'nohtml-style-sheets'} = 0;
        Perl::Tidy::Warn(
            "You can't specify both -css and -nss; -nss ignored\n");
    }

    # write a style sheet file if necessary
    if ($css_linkname) {

        # if the selected filename exists, don't write, because user may
        # have done some work by hand to create it; use backup name instead
        # Also, this will avoid a potential disaster in which the user
        # forgets to specify the style sheet, like this:
        #    perltidy -html -css myfile1.pl myfile2.pl
        # This would cause myfile1.pl to parsed as the style sheet by GetOpts
        if ( !-e $css_linkname ) {
            write_style_sheet_file($css_linkname);
        }
    }
    $rOpts_html_entities = $rOpts->{'html-entities'};
    return;
} ## end sub check_options

sub write_style_sheet_file {

    my $filename = shift;
    my $fh       = IO::File->new("> $filename");
    if ( !$fh ) {
        Perl::Tidy::Die("can't open $filename: $OS_ERROR\n");
    }
    write_style_sheet_data($fh);
    if ( $fh->can('close') && $filename ne '-' && !ref($filename) ) {
        $fh->close()
          or
          Perl::Tidy::Warn("can't close style sheet '$filename' : $OS_ERROR\n");
    }
    return;
} ## end sub write_style_sheet_file

sub write_style_sheet_data {

    # write the style sheet data to an open file handle
    my $fh = shift;

    my $bg_color   = $rOpts->{'html-color-background'};
    my $text_color = $rOpts->{'html-color-punctuation'};

    # pre-bgcolor is new, and may not be defined
    my $pre_bg_color = $rOpts->{'html-pre-color-background'};
    $pre_bg_color = $bg_color unless $pre_bg_color;

    $fh->print(<<"EOM");
/* default style sheet generated by perltidy */
body {background: $bg_color; color: $text_color}
pre { color: $text_color;
      background: $pre_bg_color;
      font-family: courier;
    }

EOM

    foreach my $short_name ( sort keys %short_to_long_names ) {
        my $long_name = $short_to_long_names{$short_name};

        my $abbrev = '.' . $short_name;
        if ( length($short_name) == 1 ) { $abbrev .= SPACE }    # for alignment
        my $color = $html_color{$short_name};
        if ( !defined($color) ) { $color = $text_color }
        $fh->print("$abbrev \{ color: $color;");

        if ( $html_bold{$short_name} ) {
            $fh->print(" font-weight:bold;");
        }

        if ( $html_italic{$short_name} ) {
            $fh->print(" font-style:italic;");
        }
        $fh->print("} /* $long_name */\n");
    }
    return;
} ## end sub write_style_sheet_data

sub set_default_color {

    # make sure that options hash $rOpts->{$key} contains a valid color
    my ( $key, $color ) = @_;
    if ( $rOpts->{$key} ) { $color = $rOpts->{$key} }
    $rOpts->{$key} = check_RGB($color);
    return;
} ## end sub set_default_color

sub check_RGB {

    # if color is a 6 digit hex RGB value, prepend a #, otherwise
    # assume that it is a valid ascii color name
    my ($color) = @_;
    if ( $color =~ /^[0-9a-fA-F]{6,6}$/ ) { $color = "#$color" }
    return $color;
} ## end sub check_RGB

sub set_default_properties {
    my ( $short_name, $color, $bold, $italic ) = @_;

    set_default_color( "html-color-$short_to_long_names{$short_name}", $color );
    my $key;
    $key           = "html-bold-$short_to_long_names{$short_name}";
    $rOpts->{$key} = defined( $rOpts->{$key} ) ? $rOpts->{$key} : $bold;
    $key           = "html-italic-$short_to_long_names{$short_name}";
    $rOpts->{$key} = defined( $rOpts->{$key} ) ? $rOpts->{$key} : $italic;
    return;
} ## end sub set_default_properties

sub pod_to_html {

    # Use Pod::Html to process the pod and make the page
    # then merge the perltidy code sections into it.
    # return 1 if success, 0 otherwise
    my ( $self, $pod_string, $css_string, $toc_string, $rpre_string_stack ) =
      @_;
    my $title        = $self->{_title};
    my $success_flag = 0;

    # don't try to use pod2html if no pod
    if ( !$pod_string ) {
        return $success_flag;
    }

    # Pod::Html requires a real temporary filename
    my ( $fh_tmp, $tmpfile ) = File::Temp::tempfile();
    if ( !$fh_tmp ) {
        Perl::Tidy::Warn(
            "unable to open temporary file $tmpfile; cannot use pod2html\n");
        return $success_flag;
    }

    #------------------------------------------------------------------
    # Warning: a temporary file is open; we have to clean up if
    # things go bad.  From here on all returns should be by going to
    # RETURN so that the temporary file gets unlinked.
    #------------------------------------------------------------------

    # write the pod text to the temporary file
    $fh_tmp->print($pod_string);

    if ( !$fh_tmp->close() ) {
        Perl::Tidy::Warn(
            "unable to close temporary file $tmpfile; cannot use pod2html\n");
        return $success_flag;
    }

    # Hand off the pod to pod2html.
    # Note that we can use the same temporary filename for input and output
    # because of the way pod2html works.
    {

        my @args;
        push @args, "--infile=$tmpfile", "--outfile=$tmpfile", "--title=$title";

        # Flags with string args:
        # "backlink=s", "cachedir=s", "htmlroot=s", "libpods=s",
        # "podpath=s", "podroot=s"
        # Note: -css=s is handled by perltidy itself
        foreach
          my $kw (qw( backlink cachedir htmlroot libpods podpath podroot ))
        {
            if ( $rOpts->{$kw} ) { push @args, "--$kw=$rOpts->{$kw}" }
        }

        # Toggle switches; these have extra leading 'pod'
        # "header!", "index!", "recurse!", "quiet!", "verbose!"
        foreach
          my $kw (qw( podheader podindex podrecurse podquiet podverbose ))
        {
            my $kwd = $kw;    # allows us to strip 'pod'
            if    ( $rOpts->{$kw} ) { $kwd =~ s/^pod//; push @args, "--$kwd" }
            elsif ( defined( $rOpts->{$kw} ) ) {
                $kwd =~ s/^pod//;
                push @args, "--no$kwd";
            }
            else {
                # user did not set this keyword
            }
        }

        # "flush",
        my $kw = 'podflush';
        if ( $rOpts->{$kw} ) { $kw =~ s/^pod//; push @args, "--$kw" }

        # Must clean up if pod2html dies (it can);
        # Be careful not to overwrite callers __DIE__ routine
        local $SIG{__DIE__} = sub {
            unlink($tmpfile) if -e $tmpfile;
            Perl::Tidy::Die( $_[0] );
        };

        Pod::Html::pod2html(@args);
    }
    $fh_tmp = IO::File->new( $tmpfile, 'r' );
    if ( !$fh_tmp ) {

        # this error shouldn't happen ... we just used this filename
        Perl::Tidy::Warn(
            "unable to open temporary file $tmpfile; cannot use pod2html\n");
        return $success_flag;
    }

    my $html_fh = $self->{_html_fh};
    my @toc;
    my $in_toc;
    my $ul_level = 0;
    my $no_print;

    # This routine will write the html selectively and store the toc
    my $html_print = sub {
        foreach my $line (@_) {
            $html_fh->print($line) unless ($no_print);
            if ($in_toc) { push @toc, $line }
        }
        return;
    }; ## end $html_print = sub

    # loop over lines of html output from pod2html and merge in
    # the necessary perltidy html sections
    my ( $saw_body, $saw_index, $saw_body_end );

    my $timestamp = EMPTY_STRING;
    if ( $rOpts->{'timestamp'} ) {
        my $date = localtime;
        $timestamp = "on $date";
    }
    while ( defined( my $line = $fh_tmp->getline() ) ) {

        if ( $line =~ /^\s*<html>\s*$/i ) {
            $html_print->("<!-- Generated by perltidy $timestamp -->\n");
            $html_print->($line);
        }

        # Copy the perltidy css, if any, after <body> tag
        elsif ( $line =~ /^\s*<body.*>\s*$/i ) {
            $saw_body = 1;
            $html_print->($css_string) if $css_string;
            $html_print->($line);

            # add a top anchor and heading
            $html_print->("<a name=\"-top-\"></a>\n");
            $title = escape_html($title);
            $html_print->("<h1>$title</h1>\n");
        }

        # check for start of index, old pod2html
        # before Pod::Html VERSION 1.15_02 it is delimited by comments as:
        #    <!-- INDEX BEGIN -->
        #    <ul>
        #     ...
        #    </ul>
        #    <!-- INDEX END -->
        #
        elsif ( $line =~ /^\s*<!-- INDEX BEGIN -->\s*$/i ) {
            $in_toc = 'INDEX';

            # when frames are used, an extra table of contents in the
            # contents panel is confusing, so don't print it
            $no_print = $rOpts->{'frames'}
              || !$rOpts->{'html-table-of-contents'};
            $html_print->("<h2>Doc Index:</h2>\n") if $rOpts->{'frames'};
            $html_print->($line);
        }

        # check for start of index, new pod2html
        # After Pod::Html VERSION 1.15_02 it is delimited as:
        # <ul id="index">
        # ...
        # </ul>
        elsif ( $line =~ /^\s*<ul\s+id="index">/i ) {
            $in_toc   = 'UL';
            $ul_level = 1;

            # when frames are used, an extra table of contents in the
            # contents panel is confusing, so don't print it
            $no_print = $rOpts->{'frames'}
              || !$rOpts->{'html-table-of-contents'};
            $html_print->("<h2>Doc Index:</h2>\n") if $rOpts->{'frames'};
            $html_print->($line);
        }

        # Check for end of index, old pod2html
        elsif ( $line =~ /^\s*<!-- INDEX END -->\s*$/i ) {
            $saw_index = 1;
            $html_print->($line);

            # Copy the perltidy toc, if any, after the Pod::Html toc
            if ($toc_string) {
                $html_print->("<hr />\n") if $rOpts->{'frames'};
                $html_print->("<h2>Code Index:</h2>\n");
                my @toc_st = split /^/, $toc_string;
                $html_print->(@toc_st);
            }
            $in_toc   = EMPTY_STRING;
            $no_print = 0;
        }

        # must track <ul> depth level for new pod2html
        elsif ( $line =~ /\s*<ul>\s*$/i && $in_toc eq 'UL' ) {
            $ul_level++;
            $html_print->($line);
        }

        # Check for end of index, for new pod2html
        elsif ( $line =~ /\s*<\/ul>/i && $in_toc eq 'UL' ) {
            $ul_level--;
            $html_print->($line);

            # Copy the perltidy toc, if any, after the Pod::Html toc
            if ( $ul_level <= 0 ) {
                $saw_index = 1;
                if ($toc_string) {
                    $html_print->("<hr />\n") if $rOpts->{'frames'};
                    $html_print->("<h2>Code Index:</h2>\n");
                    my @toc_st = split /^/, $toc_string;
                    $html_print->(@toc_st);
                }
                $in_toc   = EMPTY_STRING;
                $ul_level = 0;
                $no_print = 0;
            }
        }

        # Copy one perltidy section after each marker
        elsif ( $line =~ /^(.*)<!-- pERLTIDY sECTION -->(.*)$/ ) {
            $line = $2;
            $html_print->($1) if $1;

            # Intermingle code and pod sections if we saw multiple =cut's.
            if ( $self->{_pod_cut_count} > 1 ) {
                my $rpre_string = shift @{$rpre_string_stack};
                if ( ${$rpre_string} ) {
                    $html_print->('<pre>');
                    $html_print->( ${$rpre_string} );
                    $html_print->('</pre>');
                }
                else {

                    # shouldn't happen: we stored a string before writing
                    # each marker.
                    Perl::Tidy::Warn(
"Problem merging html stream with pod2html; order may be wrong\n"
                    );
                }
                $html_print->($line);
            }

            # If didn't see multiple =cut lines, we'll put the pod out first
            # and then the code, because it's less confusing.
            else {

                # since we are not intermixing code and pod, we don't need
                # or want any <hr> lines which separated pod and code
                $html_print->($line) unless ( $line =~ /^\s*<hr>\s*$/i );
            }
        }

        # Copy any remaining code section before the </body> tag
        elsif ( $line =~ /^\s*<\/body>\s*$/i ) {
            $saw_body_end = 1;
            if ( @{$rpre_string_stack} ) {
                if ( $self->{_pod_cut_count} <= 1 ) {
                    $html_print->('<hr />');
                }
                while ( @{$rpre_string_stack} ) {
                    my $rpre_string = shift @{$rpre_string_stack};
                    $html_print->('<pre>');
                    $html_print->( ${$rpre_string} );
                    $html_print->('</pre>');
                } ## end while ( @{$rpre_string_stack...})
            }
            $html_print->($line);
        }
        else {
            $html_print->($line);
        }
    } ## end while ( defined( my $line...))

    $success_flag = 1;
    if ( !$saw_body ) {
        Perl::Tidy::Warn("Did not see <body> in pod2html output\n");
        $success_flag = 0;
    }
    if ( !$saw_body_end ) {
        Perl::Tidy::Warn("Did not see </body> in pod2html output\n");
        $success_flag = 0;
    }
    if ( !$saw_index ) {
        Perl::Tidy::Warn("Did not find INDEX END in pod2html output\n");
        $success_flag = 0;
    }

    if ( $html_fh->can('close') ) {
        $html_fh->close();
    }

    # note that we have to unlink tmpfile before making frames
    # because the tmpfile may be one of the names used for frames
    if ( -e $tmpfile ) {
        if ( !unlink($tmpfile) ) {
            Perl::Tidy::Warn(
                "couldn't unlink temporary file $tmpfile: $OS_ERROR\n");
            $success_flag = 0;
        }
    }

    if ( $success_flag && $rOpts->{'frames'} ) {
        $self->make_frame( \@toc );
    }
    return $success_flag;
} ## end sub pod_to_html

sub make_frame {

    # Make a frame with table of contents in the left panel
    # and the text in the right panel.
    # On entry:
    #  $html_filename contains the no-frames html output
    #  $rtoc is a reference to an array with the table of contents
    my ( $self, $rtoc ) = @_;
    my $html_filename = $self->{_html_file};
    my $toc_filename  = $self->{_toc_filename};
    my $src_filename  = $self->{_src_filename};
    my $title         = $self->{_title};
    $title = escape_html($title);

    # FUTURE input parameter:
    my $top_basename = EMPTY_STRING;

    # We need to produce 3 html files:
    # 1. - the table of contents
    # 2. - the contents (source code) itself
    # 3. - the frame which contains them

    # get basenames for relative links
    my ( $toc_basename, $toc_path_uu ) = fileparse($toc_filename);
    my ( $src_basename, $src_path_uu ) = fileparse($src_filename);

    # 1. Make the table of contents panel, with appropriate changes
    # to the anchor names
    my $src_frame_name  = 'SRC';
    my $first_anchor_uu = write_toc_html(
        {
            title          => $title,
            toc_filename   => $toc_filename,
            src_basename   => $src_basename,
            rtoc           => $rtoc,
            src_frame_name => $src_frame_name,
        }
    );

    # 2. The current .html filename is renamed to be the contents panel
    rename( $html_filename, $src_filename )
      or Perl::Tidy::Die(
        "Cannot rename $html_filename to $src_filename: $OS_ERROR\n");

    # 3. Then use the original html filename for the frame
    write_frame_html(
        {
            title          => $title,
            frame_filename => $html_filename,
            top_basename   => $top_basename,
            toc_basename   => $toc_basename,
            src_basename   => $src_basename,
            src_frame_name => $src_frame_name,
        }
    );
    return;
} ## end sub make_frame

sub write_toc_html {

    # write a separate html table of contents file for frames
    my ($rarg_hash) = @_;

    my $title          = $rarg_hash->{title};
    my $toc_filename   = $rarg_hash->{toc_filename};
    my $src_basename   = $rarg_hash->{src_basename};
    my $rtoc           = $rarg_hash->{rtoc};
    my $src_frame_name = $rarg_hash->{src_frame_name};

    my $fh = IO::File->new( $toc_filename, 'w' )
      or Perl::Tidy::Die("Cannot open $toc_filename: $OS_ERROR\n");
    $fh->print(<<EOM);
<html>
<head>
<title>$title</title>
</head>
<body>
<h1><a href=\"$src_basename#-top-" target="$src_frame_name">$title</a></h1>
EOM

    my $first_anchor_uu =
      change_anchor_names( $rtoc, $src_basename, "$src_frame_name" );
    $fh->print( join EMPTY_STRING, @{$rtoc} );

    $fh->print(<<EOM);
</body>
</html>
EOM

    return;
} ## end sub write_toc_html

sub write_frame_html {

    # write an html file to be the table of contents frame

    my ($rarg_hash) = @_;

    my $title          = $rarg_hash->{title};
    my $frame_filename = $rarg_hash->{frame_filename};
    my $top_basename   = $rarg_hash->{top_basename};
    my $toc_basename   = $rarg_hash->{toc_basename};
    my $src_basename   = $rarg_hash->{src_basename};
    my $src_frame_name = $rarg_hash->{src_frame_name};

    my $fh = IO::File->new( $frame_filename, 'w' )
      or Perl::Tidy::Die("Cannot open $toc_basename: $OS_ERROR\n");

    $fh->print(<<EOM);
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
<?xml version="1.0" encoding="iso-8859-1" ?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>$title</title>
</head>
EOM

    # two left panels, one right, if master index file
    if ($top_basename) {
        $fh->print(<<EOM);
<frameset cols="20%,80%">
<frameset rows="30%,70%">
<frame src = "$top_basename" />
<frame src = "$toc_basename" />
</frameset>
EOM
    }

    # one left panels, one right, if no master index file
    else {
        $fh->print(<<EOM);
<frameset cols="20%,*">
<frame src = "$toc_basename" />
EOM
    }
    $fh->print(<<EOM);
<frame src = "$src_basename" name = "$src_frame_name" />
<noframes>
<body>
<p>If you see this message, you are using a non-frame-capable web client.</p>
<p>This document contains:</p>
<ul>
<li><a href="$toc_basename">A table of contents</a></li>
<li><a href="$src_basename">The source code</a></li>
</ul>
</body>
</noframes>
</frameset>
</html>
EOM
    return;
} ## end sub write_frame_html

sub change_anchor_names {

    # add a filename and target to anchors
    # also return the first anchor
    my ( $rlines, $filename, $target ) = @_;
    my $first_anchor;
    foreach my $line ( @{$rlines} ) {

        #  We're looking for lines like this:
        #  <LI><A HREF="#synopsis">SYNOPSIS</A></LI>
        #  ----  -       --------  -----------------
        #  $1              $4            $5
        if ( $line =~ /^(.*)<a(.*)href\s*=\s*"([^#]*)#([^"]+)"[^>]*>(.*)$/i ) {
            my $pre  = $1;
            my $name = $4;
            my $post = $5;
            my $href = "$filename#$name";
            $line = "$pre<a href=\"$href\" target=\"$target\">$post\n";
            if ( !$first_anchor ) { $first_anchor = $href }
        }
    }
    return $first_anchor;
} ## end sub change_anchor_names

sub close_html_file {
    my $self = shift;
    return unless $self->{_html_file_opened};

    my $html_fh     = $self->{_html_fh};
    my $rtoc_string = $self->{_rtoc_string};

    # There are 3 basic paths to html output...

    # ---------------------------------
    # Path 1: finish up if in -pre mode
    # ---------------------------------
    if ( $rOpts->{'html-pre-only'} ) {
        $html_fh->print(<<"PRE_END");
</pre>
PRE_END
        $html_fh->close()
          if ( $html_fh->can('close') );
        return;
    }

    # Finish the index
    $self->add_toc_item( 'EOF', 'EOF' );

    my $rpre_string_stack = $self->{_rpre_string_stack};

    # Patch to darken the <pre> background color in case of pod2html and
    # interleaved code/documentation.  Otherwise, the distinction
    # between code and documentation is blurred.
    if (   $rOpts->{pod2html}
        && $self->{_pod_cut_count} >= 1
        && $rOpts->{'html-color-background'} eq '#FFFFFF' )
    {
        $rOpts->{'html-pre-color-background'} = '#F0F0F0';
    }

    # put the css or its link into a string, if used
    my $css_string;
    my $fh_css = Perl::Tidy::IOScalar->new( \$css_string, 'w' );

    # use css linked to another file,
    if ( $rOpts->{'html-linked-style-sheet'} ) {
        $fh_css->print(
            qq(<link rel="stylesheet" href="$css_linkname" type="text/css" />));
    }

    # or no css,
    elsif ( $rOpts->{'nohtml-style-sheets'} ) {

    }

    # or use css embedded in this file
    else {
        $fh_css->print(<<'ENDCSS');
<style type="text/css">
<!--
ENDCSS
        write_style_sheet_data($fh_css);
        $fh_css->print(<<"ENDCSS");
-->
</style>
ENDCSS
    }

    # -----------------------------------------------------------
    # path 2: use pod2html if requested
    #         If we fail for some reason, continue on to path 3
    # -----------------------------------------------------------
    if ( $rOpts->{'pod2html'} ) {
        my $rpod_string = $self->{_rpod_string};
        $self->pod_to_html(
            ${$rpod_string}, $css_string,
            ${$rtoc_string}, $rpre_string_stack
        ) && return;
    }

    # --------------------------------------------------
    # path 3: write code in html, with pod only in italics
    # --------------------------------------------------
    my $input_file = $self->{_input_file};
    my $title      = escape_html($input_file);
    my $timestamp  = EMPTY_STRING;
    if ( $rOpts->{'timestamp'} ) {
        my $date = localtime;
        $timestamp = "on $date";
    }
    $html_fh->print(<<"HTML_START");
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!-- Generated by perltidy $timestamp -->
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>$title</title>
HTML_START

    # output the css, if used
    if ($css_string) {
        $html_fh->print($css_string);
        $html_fh->print(<<"ENDCSS");
</head>
<body>
ENDCSS
    }
    else {

        $html_fh->print(<<"HTML_START");
</head>
<body bgcolor=\"$rOpts->{'html-color-background'}\" text=\"$rOpts->{'html-color-punctuation'}\">
HTML_START
    }

    $html_fh->print("<a name=\"-top-\"></a>\n");
    $html_fh->print(<<"EOM");
<h1>$title</h1>
EOM

    # copy the table of contents
    if (   ${$rtoc_string}
        && !$rOpts->{'frames'}
        && $rOpts->{'html-table-of-contents'} )
    {
        $html_fh->print( ${$rtoc_string} );
    }

    # copy the pre section(s)
    my $fname_comment = $input_file;
    $fname_comment =~ s/--+/-/g;    # protect HTML comment tags
    $html_fh->print(<<"END_PRE");
<hr />
<!-- contents of filename: $fname_comment -->
<pre>
END_PRE

    foreach my $rpre_string ( @{$rpre_string_stack} ) {
        $html_fh->print( ${$rpre_string} );
    }

    # and finish the html page
    $html_fh->print(<<"HTML_END");
</pre>
</body>
</html>
HTML_END
    $html_fh->close()
      if ( $html_fh->can('close') );

    if ( $rOpts->{'frames'} ) {
        my @toc = split /^/, ${$rtoc_string};
        $self->make_frame( \@toc );
    }
    return;
} ## end sub close_html_file

sub markup_tokens {
    my ( $self, $rtokens, $rtoken_type, $rlevels ) = @_;
    my ( @colored_tokens, $type, $token, $level );
    my $rlast_level    = $self->{_rlast_level};
    my $rpackage_stack = $self->{_rpackage_stack};

    foreach my $j ( 0 .. @{$rtoken_type} - 1 ) {
        $type  = $rtoken_type->[$j];
        $token = $rtokens->[$j];
        $level = $rlevels->[$j];
        $level = 0 if ( $level < 0 );

        #-------------------------------------------------------
        # Update the package stack.  The package stack is needed to keep
        # the toc correct because some packages may be declared within
        # blocks and go out of scope when we leave the block.
        #-------------------------------------------------------
        if ( $level > ${$rlast_level} ) {
            if ( !$rpackage_stack->[ $level - 1 ] ) {
                $rpackage_stack->[ $level - 1 ] = 'main';
            }
            $rpackage_stack->[$level] = $rpackage_stack->[ $level - 1 ];
        }
        elsif ( $level < ${$rlast_level} ) {
            my $package = $rpackage_stack->[$level];
            if ( !$package ) { $package = 'main' }

            # if we change packages due to a nesting change, we
            # have to make an entry in the toc
            if ( $package ne $rpackage_stack->[ $level + 1 ] ) {
                $self->add_toc_item( $package, 'package' );
            }
        }
        else {
            ## level unchanged
        }
        ${$rlast_level} = $level;

        #-------------------------------------------------------
        # Intercept a sub name here; split it
        # into keyword 'sub' and sub name; and add an
        # entry in the toc
        # Fix for c250: switch from 'i' to 'S'
        #-------------------------------------------------------
        if ( $type eq 'S' && $token =~ /^(\w+\s+)(\w.*)$/ ) {
            $token = $self->markup_html_element( $1, 'k' );
            push @colored_tokens, $token;
            $token = $2;
            $type  = 'S';

            # but don't include sub declarations in the toc;
            # these will have leading token types 'i;'
            my $signature = join EMPTY_STRING, @{$rtoken_type};
            if ( $signature !~ /^i;/ ) {
                my $subname = $token;
                $subname =~ s/[\s\(].*$//; # remove any attributes and prototype
                $self->add_toc_item( $subname, 'sub' );
            }
        }

        #-------------------------------------------------------
        # Intercept a package name here; split it
        # into keyword 'package' and name; add to the toc,
        # and update the package stack
        #-------------------------------------------------------
        # Fix for c250: switch from 'i' to 'P' and allow 'class' or 'package'
        if ( $type eq 'P' && $token =~ /^(\w+\s+)(\w.*)$/ ) {
            $token = $self->markup_html_element( $1, 'k' );
            push @colored_tokens, $token;
            $token = $2;
            $type  = 'i';
            $self->add_toc_item( "$token", 'package' );
            $rpackage_stack->[$level] = $token;
        }

        $token = $self->markup_html_element( $token, $type );
        push @colored_tokens, $token;
    }
    return ( \@colored_tokens );
} ## end sub markup_tokens

sub markup_html_element {
    my ( $self, $token, $type ) = @_;

    return $token if ( $type eq 'b' );         # skip a blank token
    return $token if ( $token =~ /^\s*$/ );    # skip a blank line
    $token = escape_html($token);

    # get the short abbreviation for this token type
    my $short_name = $token_short_names{$type};
    if ( !defined($short_name) ) {
        $short_name = "pu";                    # punctuation is default
    }

    # handle style sheets..
    if ( !$rOpts->{'nohtml-style-sheets'} ) {
        if ( $short_name ne 'pu' ) {
            $token = qq(<span class="$short_name">) . $token . "</span>";
        }
    }

    # handle no style sheets..
    else {
        my $color = $html_color{$short_name};

        if ( $color && ( $color ne $rOpts->{'html-color-punctuation'} ) ) {
            $token = qq(<font color="$color">) . $token . "</font>";
        }
        if ( $html_italic{$short_name} ) { $token = "<i>$token</i>" }
        if ( $html_bold{$short_name} )   { $token = "<b>$token</b>" }
    }
    return $token;
} ## end sub markup_html_element

sub escape_html {

    my $token = shift;
    if ( $missing_html_entities || !$rOpts_html_entities ) {
        $token =~ s/\&/&amp;/g;
        $token =~ s/\</&lt;/g;
        $token =~ s/\>/&gt;/g;
        $token =~ s/\"/&quot;/g;
    }
    else {
        HTML::Entities::encode_entities($token);
    }
    return $token;
} ## end sub escape_html

sub finish_formatting {

    # called after last line
    my $self = shift;
    $self->close_html_file();
    return;
} ## end sub finish_formatting

sub write_line {

    my ( $self, $line_of_tokens ) = @_;
    return unless $self->{_html_file_opened};
    my $html_pre_fh = $self->{_html_pre_fh};
    my $line_type   = $line_of_tokens->{_line_type};
    my $input_line  = $line_of_tokens->{_line_text};
    my $line_number = $line_of_tokens->{_line_number};
    chomp $input_line;

    # markup line of code..
    my $html_line;
    if ( $line_type eq 'CODE' ) {
        my $rtoken_type = $line_of_tokens->{_rtoken_type};
        my $rtokens     = $line_of_tokens->{_rtokens};
        my $rlevels     = $line_of_tokens->{_rlevels};

        if ( $input_line =~ /(^\s*)/ ) {
            $html_line = $1;
        }
        else {
            $html_line = EMPTY_STRING;
        }
        my ($rcolored_tokens) =
          $self->markup_tokens( $rtokens, $rtoken_type, $rlevels );
        $html_line .= join EMPTY_STRING, @{$rcolored_tokens};
    }

    # markup line of non-code..
    else {
        my $line_character;
        if    ( $line_type eq 'HERE' )       { $line_character = 'H' }
        elsif ( $line_type eq 'HERE_END' )   { $line_character = 'h' }
        elsif ( $line_type eq 'FORMAT' )     { $line_character = 'H' }
        elsif ( $line_type eq 'FORMAT_END' ) { $line_character = 'h' }
        elsif ( $line_type eq 'SKIP' )       { $line_character = 'H' }
        elsif ( $line_type eq 'SKIP_END' )   { $line_character = 'h' }
        elsif ( $line_type eq 'SYSTEM' )     { $line_character = 'c' }
        elsif ( $line_type eq 'END_START' ) {
            $line_character = 'k';
            $self->add_toc_item( '__END__', '__END__' );
        }
        elsif ( $line_type eq 'DATA_START' ) {
            $line_character = 'k';
            $self->add_toc_item( '__DATA__', '__DATA__' );
        }
        elsif ( $line_type =~ /^POD/ ) {

            # fix for c250: changed 'P' to 'pd' here and in %token_short_names
            # to allow use of 'P' as new package token type
            $line_character = 'pd';
            if ( $rOpts->{'pod2html'} ) {
                my $html_pod_fh = $self->{_html_pod_fh};
                if ( $line_type eq 'POD_START' ) {

                    my $rpre_string_stack = $self->{_rpre_string_stack};
                    my $rpre_string       = $rpre_string_stack->[-1];

                    # if we have written any non-blank lines to the
                    # current pre section, start writing to a new output
                    # string
                    if ( ${$rpre_string} =~ /\S/ ) {
                        my $pre_string;
                        $html_pre_fh =
                          Perl::Tidy::IOScalar->new( \$pre_string, 'w' );
                        $self->{_html_pre_fh} = $html_pre_fh;
                        push @{$rpre_string_stack}, \$pre_string;

                        # leave a marker in the pod stream so we know
                        # where to put the pre section we just
                        # finished.
                        my $for_html = '=for html';    # don't confuse pod utils
                        $html_pod_fh->print(<<EOM);

$for_html
<!-- pERLTIDY sECTION -->

EOM
                    }

                    # otherwise, just clear the current string and start
                    # over
                    else {
                        ${$rpre_string} = EMPTY_STRING;
                        $html_pod_fh->print("\n");
                    }
                }
                $html_pod_fh->print( $input_line . "\n" );
                if ( $line_type eq 'POD_END' ) {
                    $self->{_pod_cut_count}++;
                    $html_pod_fh->print("\n");
                }
                return;
            }
        }
        else { $line_character = 'Q' }
        $html_line = $self->markup_html_element( $input_line, $line_character );
    }

    # add the line number if requested
    if ( $rOpts->{'html-line-numbers'} ) {
        my $extra_space =
            ( $line_number < 10 )   ? SPACE x 3
          : ( $line_number < 100 )  ? SPACE x 2
          : ( $line_number < 1000 ) ? SPACE
          :                           EMPTY_STRING;
        $html_line = $extra_space . $line_number . SPACE . $html_line;
    }

    # write the line
    $html_pre_fh->print("$html_line\n");
    return;
} ## end sub write_line

} ## end package Perl::Tidy::HtmlWriter
1;
 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 #####################################################################
#
# The Perl::Tidy::Logger class writes any .LOG and .ERR files
# and supplies some basic run information for error handling.
#
#####################################################################

package Perl::Tidy::Logger;
use strict;
use warnings;
our $VERSION = '20250105';
use Carp;
use English qw( -no_match_vars );

use constant EMPTY_STRING => q{};
use constant SPACE        => q{ };

sub AUTOLOAD {

    # Catch any undefined sub calls so that we are sure to get
    # some diagnostic information.  This sub should never be called
    # except for a programming error.
    our $AUTOLOAD;
    return if ( $AUTOLOAD =~ /\bDESTROY$/ );
    my ( $pkg, $fname, $lno ) = caller();
    my $my_package = __PACKAGE__;
    print {*STDERR} <<EOM;
======================================================================
Error detected in package '$my_package', version $VERSION
Received unexpected AUTOLOAD call for sub '$AUTOLOAD'
Called from package: '$pkg'
Called from File '$fname'  at line '$lno'
This error is probably due to a recent programming change
======================================================================
EOM
    exit 1;
} ## end sub AUTOLOAD

sub DESTROY {

    # required to avoid call to AUTOLOAD in some versions of perl
}

use constant DEFAULT_LOGFILE_GAP => 50;

sub new {

    my ( $class, @arglist ) = @_;
    if ( @arglist % 2 ) { croak "Odd number of items in arg hash list\n" }

    my %defaults = (
        rOpts           => undef,
        log_file        => undef,
        warning_file    => undef,
        fh_stderr       => undef,
        display_name    => undef,
        is_encoded_data => undef,
    );

    my %args = ( %defaults, @arglist );

    my $rOpts           = $args{rOpts};
    my $log_file        = $args{log_file};
    my $warning_file    = $args{warning_file};
    my $fh_stderr       = $args{fh_stderr};
    my $display_name    = $args{display_name};
    my $is_encoded_data = $args{is_encoded_data};

    my $fh_warnings = $rOpts->{'standard-error-output'} ? $fh_stderr : undef;

    # remove any old error output file if we might write a new one
    if ( !$fh_warnings && !ref($warning_file) ) {
        if ( -e $warning_file ) {
            unlink($warning_file)
              or Perl::Tidy::Die(
                "couldn't unlink warning file $warning_file: $OS_ERROR\n");
        }
    }

    my $logfile_gap =
      defined( $rOpts->{'logfile-gap'} )
      ? $rOpts->{'logfile-gap'}
      : DEFAULT_LOGFILE_GAP;
    if ( $logfile_gap == 0 ) { $logfile_gap = 1 }

    my $filename_stamp    = $display_name ? $display_name . ':' : "??";
    my $input_stream_name = $display_name ? $display_name       : "??";
    return bless {
        _log_file                      => $log_file,
        _logfile_gap                   => $logfile_gap,
        _rOpts                         => $rOpts,
        _fh_warnings                   => $fh_warnings,
        _last_input_line_written       => 0,
        _last_input_line_number        => undef,
        _at_end_of_file                => 0,
        _use_prefix                    => 1,
        _block_log_output              => 0,
        _line_of_tokens                => undef,
        _output_line_number            => undef,
        _wrote_line_information_string => 0,
        _wrote_column_headings         => 0,
        _warning_file                  => $warning_file,
        _warning_count                 => 0,
        _complaint_count               => 0,
        _is_encoded_data               => $is_encoded_data,
        _saw_code_bug      => -1,                    # -1=no 0=maybe 1=for sure
        _saw_brace_error   =>  0,
        _output_array      => [],
        _input_stream_name => $input_stream_name,
        _filename_stamp    => $filename_stamp,
        _save_logfile      => $rOpts->{'logfile'},
    }, $class;
} ## end sub new

sub get_input_stream_name {
    my $self = shift;
    return $self->{_input_stream_name};
}

sub set_last_input_line_number {
    my ( $self, $lno ) = @_;
    $self->{_last_input_line_number} = $lno;
    return;
}

sub get_warning_count {
    my $self = shift;
    return $self->{_warning_count};
}

sub get_use_prefix {
    my $self = shift;
    return $self->{_use_prefix};
}

sub block_log_output {
    my $self = shift;
    $self->{_block_log_output} = 1;
    return;
}

sub unblock_log_output {
    my $self = shift;
    $self->{_block_log_output} = 0;
    return;
}

sub interrupt_logfile {
    my $self = shift;
    $self->{_use_prefix} = 0;
    $self->warning("\n");
    $self->write_logfile_entry( '#' x 24 . "  WARNING  " . '#' x 25 . "\n" );
    return;
} ## end sub interrupt_logfile

sub resume_logfile {
    my $self = shift;
    $self->write_logfile_entry( '#' x 60 . "\n" );
    $self->{_use_prefix} = 1;
    return;
} ## end sub resume_logfile

sub we_are_at_the_last_line {
    my $self = shift;
    if ( !$self->{_wrote_line_information_string} ) {
        $self->write_logfile_entry("Last line\n\n");
    }
    $self->{_at_end_of_file} = 1;
    return;
} ## end sub we_are_at_the_last_line

# record some stuff in case we go down in flames
use constant MAX_PRINTED_CHARS => 35;

sub black_box {
    my ( $self, $line_of_tokens, $output_line_number ) = @_;

    # This routine saves information comparing the indentation of input
    # and output lines when a detailed logfile is requested.
    # This was very useful during the initial development of perltidy.

    my $input_line        = $line_of_tokens->{_line_text};
    my $input_line_number = $line_of_tokens->{_line_number};

    $self->{_line_of_tokens}                = $line_of_tokens;
    $self->{_output_line_number}            = $output_line_number;
    $self->{_wrote_line_information_string} = 0;

    my $last_input_line_written = $self->{_last_input_line_written};
    if (
        (
            ( $input_line_number - $last_input_line_written ) >=
            $self->{_logfile_gap}
        )
        || ( $input_line =~ /^\s*(sub|package)\s+(\w+)/ )
      )
    {
        my $structural_indentation_level = $line_of_tokens->{_level_0};
        $structural_indentation_level = 0
          if ( $structural_indentation_level < 0 );
        $self->{_last_input_line_written} = $input_line_number;
        ( my $out_str = $input_line ) =~ s/^\s+//;
        chomp $out_str;

        $out_str = ( '.' x $structural_indentation_level ) . $out_str;

        if ( length($out_str) > MAX_PRINTED_CHARS ) {
            $out_str = substr( $out_str, 0, MAX_PRINTED_CHARS ) . " ....";
        }
        $self->logfile_output( EMPTY_STRING, "$out_str\n" );
    }
    return;
} ## end sub black_box

sub write_logfile_entry {

    my ( $self, @msg ) = @_;

    # add leading >>> to avoid confusing error messages and code
    $self->logfile_output( ">>>", "@msg" );
    return;
} ## end sub write_logfile_entry

sub write_column_headings {
    my $self = shift;

    $self->{_wrote_column_headings} = 1;
    my $routput_array = $self->{_output_array};
    push @{$routput_array}, <<EOM;

Starting formatting pass...
The nesting depths in the table below are at the start of the lines.
The indicated output line numbers are not always exact.
ci = levels of continuation indentation; bk = 1 if in BLOCK, 0 if not.

in:out indent c b  nesting   code + messages; (messages begin with >>>)
lines  levels i k            (code begins with one '.' per indent level)
------  ----- - - --------   -------------------------------------------
EOM
    return;
} ## end sub write_column_headings

sub make_line_information_string {

    # make columns of information when a logfile message needs to go out
    my $self                    = shift;
    my $line_of_tokens          = $self->{_line_of_tokens};
    my $input_line_number       = $line_of_tokens->{_line_number};
    my $line_information_string = EMPTY_STRING;
    if ($input_line_number) {

        my $output_line_number   = $self->{_output_line_number};
        my $brace_depth          = $line_of_tokens->{_curly_brace_depth};
        my $paren_depth          = $line_of_tokens->{_paren_depth};
        my $square_bracket_depth = $line_of_tokens->{_square_bracket_depth};
        my $guessed_indentation_level =
          $line_of_tokens->{_guessed_indentation_level};

        my $structural_indentation_level = $line_of_tokens->{_level_0};

        $self->write_column_headings() unless $self->{_wrote_column_headings};

        # keep logfile columns aligned for scripts up to 999 lines;
        # for longer scripts it doesn't really matter
        my $extra_space = EMPTY_STRING;
        $extra_space .=
            ( $input_line_number < 10 )  ? SPACE x 2
          : ( $input_line_number < 100 ) ? SPACE
          :                                EMPTY_STRING;
        $extra_space .=
            ( $output_line_number < 10 )  ? SPACE x 2
          : ( $output_line_number < 100 ) ? SPACE
          :                                 EMPTY_STRING;

        # there are 2 possible nesting strings:
        # the original which looks like this:  (0 [1 {2
        # the new one, which looks like this:  {{[
        # the new one is easier to read, and shows the order, but
        # could be arbitrarily long, so we use it unless it is too long
        my $nesting_string =
          "($paren_depth [$square_bracket_depth {$brace_depth";
        my $nesting_string_new = $line_of_tokens->{_nesting_tokens_0};
        my $ci_level           = $line_of_tokens->{_ci_level_0};
        if ( $ci_level > 9 ) { $ci_level = '*' }
        my $bk = ( $line_of_tokens->{_nesting_blocks_0} =~ /1$/ ) ? '1' : '0';

        if ( length($nesting_string_new) <= 8 ) {
            $nesting_string =
              $nesting_string_new . SPACE x ( 8 - length($nesting_string_new) );
        }
        $line_information_string =
"L$input_line_number:$output_line_number$extra_space i$guessed_indentation_level:$structural_indentation_level $ci_level $bk $nesting_string";
    }
    return $line_information_string;
} ## end sub make_line_information_string

sub logfile_output {
    my ( $self, $prompt, $msg ) = @_;
    return if ( $self->{_block_log_output} );

    my $routput_array = $self->{_output_array};
    if ( $self->{_at_end_of_file} || !$self->{_use_prefix} ) {
        push @{$routput_array}, "$msg";
    }
    else {
        my $line_information_string = $self->make_line_information_string();
        $self->{_wrote_line_information_string} = 1;

        if ($line_information_string) {
            push @{$routput_array}, "$line_information_string   $prompt$msg";
        }
        else {
            push @{$routput_array}, "$msg";
        }
    }
    return;
} ## end sub logfile_output

sub get_saw_brace_error {
    my $self = shift;
    return $self->{_saw_brace_error};
}

sub increment_brace_error {
    my $self = shift;
    $self->{_saw_brace_error}++;
    return;
}

sub brace_warning {
    my ( $self, $msg, $msg_line_number ) = @_;

    use constant BRACE_WARNING_LIMIT => 10;
    my $saw_brace_error = $self->{_saw_brace_error};

    if ( $saw_brace_error < BRACE_WARNING_LIMIT ) {
        $self->warning( $msg, $msg_line_number );
    }
    $saw_brace_error++;
    $self->{_saw_brace_error} = $saw_brace_error;

    if ( $saw_brace_error == BRACE_WARNING_LIMIT ) {
        $self->warning("No further warnings of this type will be given\n");
    }
    return;
} ## end sub brace_warning

sub complain {

    # handle non-critical warning messages based on input flag
    my ( $self, $msg, $msg_line_number ) = @_;
    my $rOpts = $self->{_rOpts};

    # these appear in .ERR output only if -w flag is used
    if ( $rOpts->{'warning-output'} ) {
        $self->warning( $msg, $msg_line_number );
    }

    # otherwise, they go to the .LOG file
    else {
        $self->{_complaint_count}++;
        if ($msg_line_number) {

            # TODO: consider using same prefix as warning()
            $msg = $msg_line_number . ':' . $msg;
        }
        $self->write_logfile_entry($msg);
    }
    return;
} ## end sub complain

sub warning {

    my ( $self, $msg, ($msg_line_number) ) = @_;

    # Report errors to .ERR file (or stdout)
    # Given:
    #    $msg             = a string with the warning message
    #    $msg_line_number = optional line number prefix

    use constant WARNING_LIMIT => 50;

    # Always bump the warn count, even if no message goes out
    Perl::Tidy::Warn_count_bump();

    my $rOpts = $self->{_rOpts};
    if ( !$rOpts->{'quiet'} ) {

        my $warning_count   = $self->{_warning_count};
        my $fh_warnings     = $self->{_fh_warnings};
        my $is_encoded_data = $self->{_is_encoded_data};
        if ( !$fh_warnings ) {
            my $warning_file = $self->{_warning_file};
            $fh_warnings =
              Perl::Tidy::streamhandle( $warning_file, 'w', $is_encoded_data );
            if ( !$fh_warnings ) {
                Perl::Tidy::Die("couldn't open warning file '$warning_file'\n");
            }
            Perl::Tidy::Warn_msg("## Please see file $warning_file\n")
              unless ref($warning_file);
            $self->{_fh_warnings} = $fh_warnings;
            $fh_warnings->print("Perltidy version is $Perl::Tidy::VERSION\n");
        }

        my $filename_stamp = $self->{_filename_stamp};

        if ( $warning_count < WARNING_LIMIT ) {

            if ( !$warning_count ) {

                # On first error always write a line with the filename.  Note
                # that the filename will be 'perltidy' if input is from stdin
                # or from a data structure.
                if ($filename_stamp) {
                    $fh_warnings->print(
                        "\n$filename_stamp Begin Error Output Stream\n");
                }

                # Turn off filename stamping unless error output is directed
                # to the standard error output (with -se flag)
                if ( !$rOpts->{'standard-error-output'} ) {
                    $filename_stamp = EMPTY_STRING;
                    $self->{_filename_stamp} = $filename_stamp;
                }
            }

            if ( $self->get_use_prefix() > 0 && defined($msg_line_number) ) {
                $self->write_logfile_entry("WARNING: $msg");

                # add prefix 'filename:line_no: ' to message lines
                my $pre_string = $filename_stamp . $msg_line_number . ': ';
                chomp $msg;
                $msg =~ s/\n/\n$pre_string/g;
                $msg = $pre_string . $msg . "\n";

                $fh_warnings->print($msg);

            }
            else {
                $self->write_logfile_entry($msg);

                # add prefix 'filename: ' to message lines
                if ($filename_stamp) {
                    my $pre_string = $filename_stamp . SPACE;
                    chomp $msg;
                    $msg =~ s/\n/\n$pre_string/g;
                    $msg = $pre_string . $msg . "\n";
                }

                $fh_warnings->print($msg);
            }
        }
        $warning_count++;
        $self->{_warning_count} = $warning_count;

        if ( $warning_count == WARNING_LIMIT ) {
            $fh_warnings->print(
                $filename_stamp . "No further warnings will be given\n" );
        }
    }
    return;
} ## end sub warning

sub report_definite_bug {
    my $self = shift;
    $self->{_saw_code_bug} = 1;
    return;
}

sub get_save_logfile {
    my $self = shift;
    return $self->{_save_logfile};
}

sub finish {

    # called after all formatting to summarize errors
    my ($self) = @_;

    my $warning_count   = $self->{_warning_count};
    my $save_logfile    = $self->{_save_logfile};
    my $log_file        = $self->{_log_file};
    my $msg_line_number = $self->{_last_input_line_number};

    if ($warning_count) {
        if ($save_logfile) {
            $self->block_log_output();    # avoid echoing this to the logfile
            $self->warning(
                "The logfile $log_file may contain useful information\n",
                $msg_line_number );
            $self->unblock_log_output();
        }

        if ( $self->{_complaint_count} > 0 ) {
            $self->warning(
"To see $self->{_complaint_count} non-critical warnings rerun with -w\n",
                $msg_line_number
            );
        }

        if ( $self->{_saw_brace_error}
            && ( $self->{_logfile_gap} > 1 || !$save_logfile ) )
        {
            $self->warning( "To save a full .LOG file rerun with -g\n",
                $msg_line_number );
        }
    }

    if ($save_logfile) {
        my $is_encoded_data = $self->{_is_encoded_data};
        my $fh = Perl::Tidy::streamhandle( $log_file, 'w', $is_encoded_data );
        if ( !$fh ) {
            Perl::Tidy::Warn("unable to open log file '$log_file'\n");
        }
        else {
            my $routput_array = $self->{_output_array};
            foreach my $line ( @{$routput_array} ) { $fh->print($line) }
            if (   $fh->can('close')
                && !ref($log_file)
                && $log_file ne '-' )
            {
                $fh->close()
                  or Perl::Tidy::Warn(
                    "Error closing LOG file '$log_file': $OS_ERROR\n");
            }
        }
    }
    return;
} ## end sub finish
1;
 package Perl::Tidy::VerticalAligner;
use strict;
use warnings;
use Carp;

{ #<<< A non-indenting brace to contain all lexical variables

our $VERSION = '20250105';
use English qw( -no_match_vars );
use Scalar::Util 'refaddr';    # perl 5.8.1 and later
use Perl::Tidy::VerticalAligner::Alignment;
use Perl::Tidy::VerticalAligner::Line;

use constant DEVEL_MODE   => 0;
use constant EMPTY_STRING => q{};
use constant SPACE        => q{ };

# The Perl::Tidy::VerticalAligner package collects output lines and
# attempts to line up certain common tokens, such as => and #, which are
# identified by the calling routine.
#
# Usage:
#   - Initiate an object with a call to new().
#   - Write lines one-by-one with calls to valign_input().
#   - Make a final call to flush() to empty the pipeline.
#
# The sub valign_input collects lines into groups.  When a group reaches
# the maximum possible size it is processed for alignment and output.
# The maximum group size is reached whenever there is a change in indentation
# level, a blank line, a block comment, or an external flush call.  The calling
# routine may also force a break in alignment at any time.
#
# If the calling routine needs to interrupt the output and send other text to
# the output, it must first call flush() to empty the output pipeline.  This
# might occur for example if a block of pod text needs to be sent to the output
# between blocks of code.

# It is essential that a final call to flush() be made. Otherwise some
# final lines of text will be lost.

# Index...
# CODE SECTION 1: Preliminary code, global definitions and sub new
#                 sub new
# CODE SECTION 2: Some Basic Utilities
# CODE SECTION 3: Code to accept input and form groups
#                 sub valign_input
# CODE SECTION 4: Code to process comment lines
#                 sub _flush_comment_lines
# CODE SECTION 5: Code to process groups of code lines
#                 sub _flush_group_lines
# CODE SECTION 6: Pad Signed Number Columns
#                 sub pad_signed_number_columns
# CODE SECTION 7: Pad Wide Equals Columns
#                 sub pad_wide_equals_columns
# CODE SECTION 8: Output Step A
#                 sub valign_output_step_A
# CODE SECTION 9: Output Step B
#                 sub valign_output_step_B
# CODE SECTION 10: Output Step C
#                 sub valign_output_step_C
# CODE SECTION 11: Output Step D
#                 sub valign_output_step_D
# CODE SECTION 12: Summary
#                 sub report_anything_unusual

##################################################################
# CODE SECTION 1: Preliminary code, global definitions and sub new
##################################################################

sub AUTOLOAD {

    # Catch any undefined sub calls so that we are sure to get
    # some diagnostic information.  This sub should never be called
    # except for a programming error.
    our $AUTOLOAD;
    return if ( $AUTOLOAD =~ /\bDESTROY$/ );
    my ( $pkg, $fname, $lno ) = caller();
    my $my_package = __PACKAGE__;
    print {*STDERR} <<EOM;
======================================================================
Error detected in package '$my_package', version $VERSION
Received unexpected AUTOLOAD call for sub '$AUTOLOAD'
Called from package: '$pkg'
Called from File '$fname'  at line '$lno'
This error is probably due to a recent programming change
======================================================================
EOM
    exit 1;
} ## end sub AUTOLOAD

sub DESTROY {

    # required to avoid call to AUTOLOAD in some versions of perl
}

sub Die {
    my ($msg) = @_;
    Perl::Tidy::Die($msg);
    croak "unexpected return from Perl::Tidy::Die";
}

sub Fault {
    my ($msg) = @_;

    # This routine is called for errors that really should not occur
    # except if there has been a bug introduced by a recent program change.
    # Please add comments at calls to Fault to explain why the call
    # should not occur, and where to look to fix it.
    my ( $package0_uu, $filename0_uu, $line0,    $subroutine0_uu ) = caller(0);
    my ( $package1_uu, $filename1,    $line1,    $subroutine1 )    = caller(1);
    my ( $package2_uu, $filename2_uu, $line2_uu, $subroutine2 )    = caller(2);
    my $pkg = __PACKAGE__;

    my $input_stream_name = get_input_stream_name();

    Die(<<EOM);
==============================================================================
While operating on input stream with name: '$input_stream_name'
A fault was detected at line $line0 of sub '$subroutine1'
in file '$filename1'
which was called from line $line1 of sub '$subroutine2'
Message: '$msg'
This is probably an error introduced by a recent programming change.
$pkg reports VERSION='$VERSION'.
==============================================================================
EOM
    croak "unexpected return from sub Die";
} ## end sub Fault

my %valid_LINE_keys;

BEGIN {

    # define valid keys in a line object
    my @q = qw(
      jmax
      rtokens
      rfields
      rfield_lengths
      rpatterns
      indentation
      leading_space_count
      outdent_long_lines
      list_type
      list_seqno
      is_hanging_side_comment
      maximum_line_length
      rvertical_tightness_flags
      is_terminal_ternary
      j_terminal_match
      end_group
      Kend
      ci_level
      level
      level_end
      imax_pair

      ralignments
    );

    @valid_LINE_keys{@q} = (1) x scalar(@q);
} ## end BEGIN

BEGIN {

    # Define the fixed indexes for variables in $self, which is an array
    # reference.  Note the convention of leading and trailing underscores to
    # keep them unique.
    # Do not combine with other BEGIN blocks (c101).
    my $i = 0;
    use constant {
        _file_writer_object_ => $i++,
        _logger_object_      => $i++,
        _diagnostics_object_ => $i++,

        _rOpts_ => $i++,

        _last_level_written_            => $i++,
        _last_side_comment_column_      => $i++,
        _last_side_comment_line_number_ => $i++,
        _last_side_comment_length_      => $i++,
        _last_side_comment_level_       => $i++,
        _outdented_line_count_          => $i++,
        _first_outdented_line_at_       => $i++,
        _last_outdented_line_at_        => $i++,
        _consecutive_block_comments_    => $i++,

        _rgroup_lines_                => $i++,
        _group_level_                 => $i++,
        _group_type_                  => $i++,
        _group_maximum_line_length_   => $i++,
        _zero_count_                  => $i++,
        _last_leading_space_count_    => $i++,
        _comment_leading_space_count_ => $i++,
    };

    # Debug flag. This is a relic from the original program development
    # looking for problems with tab characters.  Caution: this debug flag can
    # produce a lot of output It should be 0 except when debugging small
    # scripts.

    use constant DEBUG_TABS => 0;

    my $debug_warning = sub {
        my $msg = shift;
        print {*STDOUT} "VALIGN_DEBUGGING with key $msg\n";
        return;
    };

    DEBUG_TABS && $debug_warning->('TABS');
} ## end BEGIN

# GLOBAL variables
my (

    %valign_control_hash,
    $valign_control_default,

    $rOpts_indent_columns,
    $rOpts_tabs,
    $rOpts_entab_leading_whitespace,
    $rOpts_fixed_position_side_comment,
    $rOpts_maximum_line_length,
    $rOpts_minimum_space_to_comment,
    $rOpts_valign_code,
    $rOpts_valign_block_comments,
    $rOpts_valign_side_comments,
    $rOpts_valign_signed_numbers,
    $rOpts_valign_signed_numbers_limit,
    $rOpts_valign_wide_equals,

    $require_tabs,

);

sub check_options {

    # This routine is called to check the user-supplied run parameters
    # and to configure the control hashes to them.
    my ($rOpts) = @_;

    # All alignments are done by default
    %valign_control_hash    = ();
    $valign_control_default = 1;

    # If -vil=s is entered without -vxl, assume -vxl='*'
    if (  !$rOpts->{'valign-exclusion-list'}
        && $rOpts->{'valign-inclusion-list'} )
    {
        $rOpts->{'valign-exclusion-list'} = '*';
    }

    # See if the user wants to exclude any alignment types ...
    if ( $rOpts->{'valign-exclusion-list'} ) {

        # The inclusion list is only relevant if there is an exclusion list
        if ( $rOpts->{'valign-inclusion-list'} ) {
            my @vil = split /\s+/, $rOpts->{'valign-inclusion-list'};
            @valign_control_hash{@vil} = (1) x scalar(@vil);
        }

        # Note that the -vxl list is done after -vil, so -vxl has priority
        # in the event of duplicate entries.
        my @vxl = split /\s+/, $rOpts->{'valign-exclusion-list'};
        @valign_control_hash{@vxl} = (0) x scalar(@vxl);

        # Optimization: revert to defaults if no exclusions.
        # This could happen with -vxl='  ' and any -vil list
        if ( !@vxl ) {
            %valign_control_hash = ();
        }

        # '$valign_control_default' applies to types not in the hash:
        # - If a '*' was entered then set it to be that default type
        # - Otherwise, leave it set it to 1
        if ( defined( $valign_control_hash{'*'} ) ) {
            $valign_control_default = $valign_control_hash{'*'};
        }

        # Side comments are controlled separately and must be removed
        # if given in a list.
        if (%valign_control_hash) {
            $valign_control_hash{'#'} = 1;
        }
    }

    # Initialize some global options
    $rOpts_indent_columns           = $rOpts->{'indent-columns'};
    $rOpts_tabs                     = $rOpts->{'tabs'};
    $rOpts_entab_leading_whitespace = $rOpts->{'entab-leading-whitespace'};
    $require_tabs = ( $rOpts_tabs || $rOpts_entab_leading_whitespace )
      && $rOpts_indent_columns > 0;

    $rOpts_fixed_position_side_comment =
      $rOpts->{'fixed-position-side-comment'};

    $rOpts_maximum_line_length      = $rOpts->{'maximum-line-length'};
    $rOpts_minimum_space_to_comment = $rOpts->{'minimum-space-to-comment'};
    $rOpts_valign_code              = $rOpts->{'valign-code'};
    $rOpts_valign_block_comments    = $rOpts->{'valign-block-comments'};
    $rOpts_valign_side_comments     = $rOpts->{'valign-side-comments'};
    $rOpts_valign_signed_numbers    = $rOpts->{'valign-signed-numbers'};
    $rOpts_valign_signed_numbers_limit =
      $rOpts->{'valign-signed-numbers-limit'};
    $rOpts_valign_wide_equals = $rOpts->{'valign-wide-equals'};

    return;
} ## end sub check_options

sub check_keys {
    my ( $rtest, $rvalid, $msg, $exact_match ) = @_;

    # Check the keys of a hash:
    # $rtest   = ref to hash to test
    # $rvalid  = ref to hash with valid keys

    # $msg = a message to write in case of error
    # $exact_match defines the type of check:
    #     = false: test hash must not have unknown key
    #     = true:  test hash must have exactly same keys as known hash
    my @unknown_keys =
      grep { !exists $rvalid->{$_} } keys %{$rtest};
    my @missing_keys =
      grep { !exists $rtest->{$_} } keys %{$rvalid};
    my $error = @unknown_keys;
    if ($exact_match) { $error ||= @missing_keys }
    if ($error) {
        local $LIST_SEPARATOR = ')(';
        my @expected_keys = sort keys %{$rvalid};
        @unknown_keys = sort @unknown_keys;
        Fault(<<EOM);
------------------------------------------------------------------------
Program error detected checking hash keys
Message is: '$msg'
Expected keys: (@expected_keys)
Unknown key(s): (@unknown_keys)
Missing key(s): (@missing_keys)
------------------------------------------------------------------------
EOM
    }
    return;
} ## end sub check_keys

sub new {

    my ( $class, @arglist ) = @_;
    if ( @arglist % 2 ) { croak "Odd number of items in arg hash list\n" }

    my %defaults = (
        rOpts              => undef,
        file_writer_object => undef,
        logger_object      => undef,
        diagnostics_object => undef,
    );
    my %args = ( %defaults, @arglist );

    # Initialize other caches and buffers
    initialize_step_B_cache();
    initialize_valign_buffer();
    initialize_decode();
    set_logger_object( $args{logger_object} );

    # Initialize all variables in $self.
    # To add an item to $self, first define a new constant index in the BEGIN
    # section.
    my $self = [];

    # objects
    $self->[_file_writer_object_] = $args{file_writer_object};
    $self->[_logger_object_]      = $args{logger_object};
    $self->[_diagnostics_object_] = $args{diagnostics_object};

    # shortcut to user options
    my $rOpts = $args{rOpts};
    $self->[_rOpts_] = $rOpts;

    # Batch of lines being collected
    $self->[_rgroup_lines_]                = [];
    $self->[_group_level_]                 = 0;
    $self->[_group_type_]                  = EMPTY_STRING;
    $self->[_group_maximum_line_length_]   = undef;
    $self->[_zero_count_]                  = 0;
    $self->[_comment_leading_space_count_] = 0;
    $self->[_last_leading_space_count_]    = 0;

    # Memory of what has been processed
    $self->[_last_level_written_]            = -1;
    $self->[_last_side_comment_column_]      = 0;
    $self->[_last_side_comment_line_number_] = 0;
    $self->[_last_side_comment_length_]      = 0;
    $self->[_last_side_comment_level_]       = -1;
    $self->[_outdented_line_count_]          = 0;
    $self->[_first_outdented_line_at_]       = 0;
    $self->[_last_outdented_line_at_]        = 0;
    $self->[_consecutive_block_comments_]    = 0;

    bless $self, $class;
    return $self;
} ## end sub new

#################################
# CODE SECTION 2: Basic Utilities
#################################

sub flush {

    # flush() is the external call to completely empty the pipeline.
    my ($self) = @_;

    # push things out the pipeline...

    # push out any current group lines
    $self->_flush_group_lines()
      if ( @{ $self->[_rgroup_lines_] } );

    # then anything left in the cache of step_B
    $self->_flush_step_B_cache();

    # then anything left in the buffer of step_C
    $self->dump_valign_buffer();

    return;
} ## end sub flush

sub initialize_for_new_group {
    my ($self) = @_;

    # initialize for a new group of lines to be aligned vertically

    $self->[_rgroup_lines_]                = [];
    $self->[_group_type_]                  = EMPTY_STRING;
    $self->[_zero_count_]                  = 0;
    $self->[_comment_leading_space_count_] = 0;
    $self->[_last_leading_space_count_]    = 0;
    $self->[_group_maximum_line_length_]   = undef;

    # Note that the value for _group_level_ is
    # handled separately in sub valign_input
    return;
} ## end sub initialize_for_new_group

sub group_line_count {
    my $self = shift;
    return +@{ $self->[_rgroup_lines_] };
}

# interface to Perl::Tidy::Diagnostics routines
# For debugging; not currently used
sub write_diagnostics {
    my ( $self, $msg ) = @_;
    my $diagnostics_object = $self->[_diagnostics_object_];
    if ($diagnostics_object) {
        $diagnostics_object->write_diagnostics($msg);
    }
    return;
} ## end sub write_diagnostics

{    ## begin closure for logger routines
    my $logger_object;

    # Called once per file to initialize the logger object
    sub set_logger_object {
        $logger_object = shift;
        return;
    }

    sub get_input_stream_name {
        my $input_stream_name = EMPTY_STRING;
        if ($logger_object) {
            $input_stream_name = $logger_object->get_input_stream_name();
        }
        return $input_stream_name;
    } ## end sub get_input_stream_name

    sub warning {
        my ($msg) = @_;
        if ($logger_object) {
            $logger_object->warning($msg);
        }
        return;
    } ## end sub warning

    sub write_logfile_entry {
        my ($msg) = @_;
        if ($logger_object) {
            $logger_object->write_logfile_entry($msg);
        }
        return;
    } ## end sub write_logfile_entry
}

sub get_cached_line_count {
    my $self = shift;
    return $self->group_line_count() + ( get_cached_line_type() ? 1 : 0 );
}

sub get_recoverable_spaces {

    # return the number of spaces (+ means shift right, - means shift left)
    # that we would like to shift a group of lines with the same indentation
    # to get them to line up with their opening parens
    my $indentation = shift;
    return ref($indentation) ? $indentation->get_recoverable_spaces() : 0;
} ## end sub get_recoverable_spaces

######################################################
# CODE SECTION 3: Code to accept input and form groups
######################################################

use constant DEBUG_VALIGN      => 0;
use constant SC_LONG_LINE_DIFF => 12;

my %is_opening_token;
my %is_closing_token;
my %is_digit_char;
my %is_plus_or_minus;
my %is_if_or;
my %is_assignment;
my %is_comma_token;
my %is_good_marginal_alignment;

BEGIN {

    my @q = qw< { ( [ >;
    @is_opening_token{@q} = (1) x scalar(@q);

    @q = qw< } ) ] >;
    @is_closing_token{@q} = (1) x scalar(@q);

    @q = qw( 0 1 2 3 4 5 6 7 8 9 );
    @is_digit_char{@q} = (1) x scalar(@q);

    @q = qw( + - );
    @is_plus_or_minus{@q} = (1) x scalar(@q);

    @q = qw( if unless or || );
    @is_if_or{@q} = (1) x scalar(@q);

    @q = qw( = **= += *= &= <<= &&= -= /= |= >>= ||= //= .= %= ^= x= );
    @is_assignment{@q} = (1) x scalar(@q);

    @q = qw( => );
    push @q, ',';
    @is_comma_token{@q} = (1) x scalar(@q);

    # We can be less restrictive in marginal cases at certain "good" alignments
    @q = qw( { ? => = );
    push @q, (',');
    @is_good_marginal_alignment{@q} = (1) x scalar(@q);

}

#--------------------------------------------
# VTFLAGS: Vertical tightness types and flags
#--------------------------------------------
# Vertical tightness is controlled by a 'type' and associated 'flags' for each
# line.  These values are set by sub Formatter::set_vertical_tightness_flags.
# These are defined as follows:

# Vertical Tightness Line Type Codes:
# Type 0, no vertical tightness condition
# Type 1, last token of this line is a non-block opening token
# Type 2, first token of next line is a non-block closing
# Type 3, isolated opening block brace
# type 4, isolated closing block brace

# Opening token flag values are the vertical tightness flags
# 0 do not join with next line
# 1 just one join per line
# 2 any number of joins

# Closing token flag values indicate spacing:
# 0 = no space added before closing token
# 1 = single space added before closing token

sub valign_input {

    #---------------------------------------------------------------------
    # This is the front door of the vertical aligner.  On each call
    # we receive one line of specially marked text for vertical alignment.
    # We compare the line with the current group, and either:
    # - the line joins the current group if alignments match, or
    # - the current group is flushed and a new group is started
    #---------------------------------------------------------------------
    #
    # The key input parameters describing each line are:
    #     $level          = indentation level of this line
    #     $rfields        = ref to array of fields
    #     $rpatterns      = ref to array of patterns, one per field
    #     $rtokens        = ref to array of tokens starting fields 1,2,..
    #     $rfield_lengths = ref to array of field display widths
    #
    # Here is an example of what this package does.  In this example,
    # we are trying to line up both the '=>' and the '#'.
    #
    #         '18' => 'grave',    #   \`
    #         '19' => 'acute',    #   `'
    #         '20' => 'caron',    #   \v
    # <-tabs-><f1-><--field 2 ---><-f3->
    # |            |              |    |
    # |            |              |    |
    # col1        col2         col3 col4
    #
    # The calling routine has already broken the entire line into 3 fields as
    # indicated.  (So the work of identifying promising common tokens has
    # already been done).
    #
    # In this example, there will be 2 tokens being matched: '=>' and '#'.
    # They are the leading parts of fields 2 and 3, but we do need to know
    # what they are so that we can dump a group of lines when these tokens
    # change.
    #
    # The fields contain the actual characters of each field.  The patterns
    # are like the fields, but they contain mainly token types instead
    # of tokens, so they have fewer characters.  They are used to be
    # sure we are matching fields of similar type.
    #
    # In this example, there will be 4 column indexes being adjusted.  The
    # first one is always at zero.  The interior columns are at the start of
    # the matching tokens, and the last one tracks the maximum line length.
    #
    # Each time a new line comes in, it joins the current vertical
    # group if possible.  Otherwise it causes the current group to be flushed
    # and a new group is started.
    #
    # For each new group member, the column locations are increased, as
    # necessary, to make room for the new fields.  When the group is finally
    # output, these column numbers are used to compute the amount of spaces of
    # padding needed for each field.
    #
    # Programming note: the fields are assumed not to have any tab characters.
    # Tabs have been previously removed except for tabs in quoted strings and
    # side comments.  Tabs in these fields can mess up the column counting.
    # The log file warns the user if there are any such tabs.

    my ( $self, $rcall_hash ) = @_;

    # Unpack the call args. This form is significantly faster than getting them
    # one-by-one.
    my (

        $Kend,
        $break_alignment_after,
        $break_alignment_before,
        $ci_level,
        $forget_side_comment,
        $indentation,
        $is_terminal_ternary,
        $level,
        $level_end,
        $list_seqno,
        $maximum_line_length,
        $outdent_long_lines,
        $rline_alignment,
        $rvertical_tightness_flags,

      ) =

      @{$rcall_hash}{
        qw(
          Kend
          break_alignment_after
          break_alignment_before
          ci_level
          forget_side_comment
          indentation
          is_terminal_ternary
          level
          level_end
          list_seqno
          maximum_line_length
          outdent_long_lines
          rline_alignment
          rvertical_tightness_flags
        )
      };

    my ( $rtokens, $rfields, $rpatterns, $rfield_lengths ) =
      @{$rline_alignment};

    # The index '$Kend' is a value which passed along with the line text to sub
    # 'write_code_line' for a convergence check.

    # number of fields is $jmax
    # number of tokens between fields is $jmax-1
    my $jmax = @{$rfields} - 1;

    my $leading_space_count =
      ref($indentation) ? $indentation->get_spaces() : $indentation;

    # set outdented flag to be sure we either align within statements or
    # across statement boundaries, but not both.
    my $is_outdented =
      $self->[_last_leading_space_count_] > $leading_space_count;
    $self->[_last_leading_space_count_] = $leading_space_count;

    # Identify a hanging side comment.  Hanging side comments have an empty
    # initial field.
    my $is_hanging_side_comment =
      ( $jmax == 1 && $rtokens->[0] eq '#' && $rfields->[0] =~ /^\s*$/ );

    # Undo outdented flag for a hanging side comment
    $is_outdented = 0 if $is_hanging_side_comment;

    # Identify a block comment.
    my $is_block_comment = $jmax == 0 && substr( $rfields->[0], 0, 1 ) eq '#';

    # Block comment .. update count
    if ($is_block_comment) {
        $self->[_consecutive_block_comments_]++;
    }

    # Not a block comment ..
    # Forget side comment column if we saw 2 or more block comments,
    # and reset the count
    else {

        if ( $self->[_consecutive_block_comments_] > 1 ) {
            $self->forget_side_comment();
        }
        $self->[_consecutive_block_comments_] = 0;
    }

    # Reset side comment location if we are entering a new block from level 0.
    # This is intended to keep them from drifting too far to the right.
    if ($forget_side_comment) {
        $self->forget_side_comment();
    }

    my $is_balanced_line = $level_end == $level;

    my $group_level               = $self->[_group_level_];
    my $group_maximum_line_length = $self->[_group_maximum_line_length_];

    DEBUG_VALIGN && do {
        my $nlines = $self->group_line_count();
        print {*STDOUT}
"Entering valign_input: lines=$nlines new #fields= $jmax, leading_count=$leading_space_count, level=$level, group_level=$group_level, level_end=$level_end\n";
    };

    # Validate cached line if necessary: If we can produce a container
    # with just 2 lines total by combining an existing cached opening
    # token with the closing token to follow, then we will mark both
    # cached flags as valid.
    my $cached_line_type = get_cached_line_type();
    if ($cached_line_type) {
        my $cached_line_opening_flag = get_cached_line_opening_flag();
        if ($rvertical_tightness_flags) {
            my $cached_seqno = get_cached_seqno();
            if (   $cached_seqno
                && $rvertical_tightness_flags->{_vt_seqno}
                && $rvertical_tightness_flags->{_vt_seqno} == $cached_seqno )
            {

                # Fix for b1187 and b1188: Normally this step is only done
                # if the number of existing lines is 0 or 1.  But to prevent
                # blinking, this range can be controlled by the caller.
                # If zero values are given we fall back on the range 0 to 1.
                my $line_count = $self->group_line_count();
                my $min_lines  = $rvertical_tightness_flags->{_vt_min_lines};
                my $max_lines  = $rvertical_tightness_flags->{_vt_max_lines};
                $min_lines = 0 if ( !$min_lines );
                $max_lines = 1 if ( !$max_lines );
                if (   ( $line_count >= $min_lines )
                    && ( $line_count <= $max_lines ) )
                {
                    $rvertical_tightness_flags->{_vt_valid_flag} ||= 1;
                    set_cached_line_valid(1);
                }
            }
        }

        # do not join an opening block brace (type 3, see VTFLAGS)
        # with an unbalanced line unless requested with a flag value of 2
        if (   $cached_line_type == 3
            && !$self->group_line_count()
            && $cached_line_opening_flag < 2
            && !$is_balanced_line )
        {
            set_cached_line_valid(0);
        }
    }

    # shouldn't happen:
    if ( $level < 0 ) { $level = 0 }

    # do not align code across indentation level changes
    # or changes in the maximum line length
    # or if vertical alignment is turned off
    if (
        $level != $group_level
        || (   $group_maximum_line_length
            && $maximum_line_length != $group_maximum_line_length )
        || $is_outdented
        || ( $is_block_comment && !$rOpts_valign_block_comments )
        || (   !$is_block_comment
            && !$rOpts_valign_side_comments
            && !$rOpts_valign_code )
      )
    {

        $self->_flush_group_lines( $level - $group_level )
          if ( @{ $self->[_rgroup_lines_] } );

        $group_level                         = $level;
        $self->[_group_level_]               = $group_level;
        $self->[_group_maximum_line_length_] = $maximum_line_length;

        # Update leading spaces after the above flush because the leading space
        # count may have been changed if the -icp flag is in effect
        $leading_space_count =
          ref($indentation) ? $indentation->get_spaces() : $indentation;
    }

    # --------------------------------------------------------------------
    # Collect outdentable block COMMENTS
    # --------------------------------------------------------------------
    if ( $self->[_group_type_] eq 'COMMENT' ) {
        if (   $is_block_comment
            && $outdent_long_lines
            && $leading_space_count == $self->[_comment_leading_space_count_] )
        {

            # Note that for a comment group we are not storing a line
            # but rather just the text and its length.
            push @{ $self->[_rgroup_lines_] },
              [ $rfields->[0], $rfield_lengths->[0], $Kend ];
            return;
        }
        else {
            $self->_flush_group_lines()
              if ( @{ $self->[_rgroup_lines_] } );
        }
    }

    my $rgroup_lines = $self->[_rgroup_lines_];
    if ( $break_alignment_before && @{$rgroup_lines} ) {
        $rgroup_lines->[-1]->{'end_group'} = 1;
    }

    # --------------------------------------------------------------------
    # add dummy fields for terminal ternary
    # --------------------------------------------------------------------
    my $j_terminal_match;

    if ( $is_terminal_ternary && @{$rgroup_lines} ) {
        $j_terminal_match = fix_terminal_ternary(
            {
                old_line       => $rgroup_lines->[-1],
                rfields        => $rfields,
                rtokens        => $rtokens,
                rpatterns      => $rpatterns,
                rfield_lengths => $rfield_lengths,
                group_level    => $group_level,
            }
        );
        $jmax = @{$rfields} - 1;
    }

    # --------------------------------------------------------------------
    # add dummy fields for else statement
    # --------------------------------------------------------------------

    # Note the trailing space after 'else' here. If there were no space between
    # the else and the next '{' then we would not be able to do vertical
    # alignment of the '{'.
    if (   $rfields->[0] eq 'else '
        && @{$rgroup_lines}
        && $is_balanced_line )
    {
        $j_terminal_match = fix_terminal_else(
            {
                old_line       => $rgroup_lines->[-1],
                rfields        => $rfields,
                rtokens        => $rtokens,
                rpatterns      => $rpatterns,
                rfield_lengths => $rfield_lengths,
            }
        );
        $jmax = @{$rfields} - 1;
    }

    # --------------------------------------------------------------------
    # Handle simple line of code with no fields to match.
    # --------------------------------------------------------------------
    if ( $jmax <= 0 ) {
        $self->[_zero_count_]++;

        # VSN PATCH for a single number, part 1.
        my $is_numeric =
          $rOpts_valign_signed_numbers && $rpatterns->[0] eq 'n,';

        if (   !$is_numeric
            && @{$rgroup_lines}
            && !get_recoverable_spaces( $rgroup_lines->[0]->{'indentation'} ) )
        {

            # flush the current group if it has some aligned columns..
            # or we haven't seen a comment lately
            if (   $rgroup_lines->[0]->{'jmax'} > 1
                || $self->[_zero_count_] > 3 )
            {
                $self->_flush_group_lines()
                  if ( @{ $self->[_rgroup_lines_] } );

                # Update '$rgroup_lines' - it will become a ref to empty array.
                # This allows avoiding a call to get_group_line_count below.
                $rgroup_lines = $self->[_rgroup_lines_];
            }
        }

        # start new COMMENT group if this comment may be outdented
        if (   $is_block_comment
            && $outdent_long_lines
            && !@{$rgroup_lines} )
        {
            $self->[_group_type_]                  = 'COMMENT';
            $self->[_comment_leading_space_count_] = $leading_space_count;
            $self->[_group_maximum_line_length_]   = $maximum_line_length;
            push @{$rgroup_lines},
              [ $rfields->[0], $rfield_lengths->[0], $Kend ];
            return;
        }

        # just write this line directly if no current group, no side comment,
        # and no space recovery is needed,
        # and not numeric - VSN PATCH for a single number, part 4.
        if (   !@{$rgroup_lines}
            && !$is_numeric
            && !get_recoverable_spaces($indentation) )
        {

            $self->valign_output_step_B(
                {
                    leading_space_count       => $leading_space_count,
                    line                      => $rfields->[0],
                    line_length               => $rfield_lengths->[0],
                    side_comment_length       => 0,
                    outdent_long_lines        => $outdent_long_lines,
                    rvertical_tightness_flags => $rvertical_tightness_flags,
                    level                     => $level,
                    level_end                 => $level_end,
                    Kend                      => $Kend,
                    maximum_line_length       => $maximum_line_length,
                }
            );
            return;
        }
    }
    else {
        $self->[_zero_count_] = 0;
    }

    # --------------------------------------------------------------------
    # It simplifies things to create a zero length side comment
    # if none exists.
    # --------------------------------------------------------------------
    if ( ( $jmax == 0 ) || ( $rtokens->[ $jmax - 1 ] ne '#' ) ) {
        $jmax += 1;
        $rtokens->[ $jmax - 1 ]  = '#';
        $rfields->[$jmax]        = EMPTY_STRING;
        $rfield_lengths->[$jmax] = 0;
        $rpatterns->[$jmax]      = '#';
    }

    # --------------------------------------------------------------------
    # create an object to hold this line
    # --------------------------------------------------------------------

    # The hash keys below must match the list of keys in %valid_LINE_keys.
    # Values in this hash are accessed directly, except for 'ralignments',
    # rather than with get/set calls for efficiency.
    my $new_line = Perl::Tidy::VerticalAligner::Line->new(
        {
            jmax                      => $jmax,
            rtokens                   => $rtokens,
            rfields                   => $rfields,
            rpatterns                 => $rpatterns,
            rfield_lengths            => $rfield_lengths,
            indentation               => $indentation,
            leading_space_count       => $leading_space_count,
            outdent_long_lines        => $outdent_long_lines,
            list_seqno                => $list_seqno,
            list_type                 => EMPTY_STRING,
            is_hanging_side_comment   => $is_hanging_side_comment,
            rvertical_tightness_flags => $rvertical_tightness_flags,
            is_terminal_ternary       => $is_terminal_ternary,
            j_terminal_match          => $j_terminal_match,
            end_group                 => $break_alignment_after,
            Kend                      => $Kend,
            ci_level                  => $ci_level,
            level                     => $level,
            level_end                 => $level_end,
            imax_pair                 => -1,
            maximum_line_length       => $maximum_line_length,

            ralignments => [],
        }
    );

    DEVEL_MODE
      && check_keys( $new_line, \%valid_LINE_keys,
        "Checking line keys at line definition", 1 );

    # --------------------------------------------------------------------
    # Decide if this is a simple list of items.
    # We use this to be less restrictive in deciding what to align.
    # --------------------------------------------------------------------
    decide_if_list($new_line) if ($list_seqno);

    # --------------------------------------------------------------------
    # Append this line to the current group (or start new group)
    # --------------------------------------------------------------------

    push @{ $self->[_rgroup_lines_] }, $new_line;
    $self->[_group_maximum_line_length_] = $maximum_line_length;

    # output this group if it ends in a terminal else or ternary line
    if ( defined($j_terminal_match) ) {
        $self->_flush_group_lines()
          if ( @{ $self->[_rgroup_lines_] } );
    }

    # Force break after jump to lower level
    elsif ($level_end < $level
        || $is_closing_token{ substr( $rfields->[0], 0, 1 ) } )
    {
        $self->_flush_group_lines(-1)
          if ( @{ $self->[_rgroup_lines_] } );
    }

    else {
        ##ok: no output needed
    }

    # --------------------------------------------------------------------
    # Some old debugging stuff
    # --------------------------------------------------------------------
    DEBUG_VALIGN && do {
        print {*STDOUT} "exiting valign_input fields:";
        dump_array( @{$rfields} );
        print {*STDOUT} "exiting valign_input tokens:";
        dump_array( @{$rtokens} );
        print {*STDOUT} "exiting valign_input patterns:";
        dump_array( @{$rpatterns} );
    };

    return;
} ## end sub valign_input

sub join_hanging_comment {

    my ( $new_line, $old_line ) = @_;

    # Add dummy fields to a hanging side comment to make it look
    # like the first line in its potential group.  This simplifies
    # the coding.

    # Given:
    #   $new_line = ref to hash of the line to be possibly changed
    #   $old_line = ref to hash of the previous reference line
    # Return:
    #   true if new line modified
    #   false otherwise

    my $jmax = $new_line->{'jmax'};

    # must be 2 fields
    return 0 unless ( $jmax == 1 );
    my $rtokens = $new_line->{'rtokens'};

    # the second field must be a comment
    return 0 unless ( $rtokens->[0] eq '#' );
    my $rfields = $new_line->{'rfields'};

    # the first field must be empty
    return 0 if ( $rfields->[0] !~ /^\s*$/ );

    # the current line must have fewer fields
    my $maximum_field_index = $old_line->{'jmax'};
    return 0
      if ( $maximum_field_index <= $jmax );

    # looks ok..
    my $rpatterns      = $new_line->{'rpatterns'};
    my $rfield_lengths = $new_line->{'rfield_lengths'};

    $new_line->{'is_hanging_side_comment'} = 1;

    $jmax                     = $maximum_field_index;
    $new_line->{'jmax'}       = $jmax;
    $rfields->[$jmax]         = $rfields->[1];
    $rfield_lengths->[$jmax]  = $rfield_lengths->[1];
    $rtokens->[ $jmax - 1 ]   = $rtokens->[0];
    $rpatterns->[ $jmax - 1 ] = $rpatterns->[0];

    foreach my $j ( 1 .. $jmax - 1 ) {
        $rfields->[$j]         = EMPTY_STRING;
        $rfield_lengths->[$j]  = 0;
        $rtokens->[ $j - 1 ]   = EMPTY_STRING;
        $rpatterns->[ $j - 1 ] = EMPTY_STRING;
    }
    return 1;
} ## end sub join_hanging_comment

sub decide_if_list {

    my $line = shift;

    # Given:
    #   $line = ref to hash of values for a line
    # Task:
    #   Set 'list_type' property

    # A list will be taken to be a line with a forced break in which all
    # of the field separators are commas or comma-arrows (except for the
    # trailing #)

    my $rtokens    = $line->{'rtokens'};
    my $test_token = $rtokens->[0];
    my ( $raw_tok, $lev, $tag, $tok_count ) =
      decode_alignment_token($test_token);
    if ( $is_comma_token{$raw_tok} ) {
        my $list_type = $test_token;
        my $jmax      = $line->{'jmax'};

        foreach ( 1 .. $jmax - 2 ) {
            ( $raw_tok, $lev, $tag, $tok_count ) =
              decode_alignment_token( $rtokens->[$_] );
            if ( !$is_comma_token{$raw_tok} ) {
                $list_type = EMPTY_STRING;
                last;
            }
        }
        $line->{'list_type'} = $list_type;
    }
    return;
} ## end sub decide_if_list

sub fix_terminal_ternary {

    # Add empty fields as necessary to align a ternary term
    # like this:
    #
    #  my $leapyear =
    #      $year % 4   ? 0
    #    : $year % 100 ? 1
    #    : $year % 400 ? 0
    #    :               1;
    #
    # returns the index of the terminal question token, if any

    my ($rcall_hash) = @_;

    my $old_line       = $rcall_hash->{old_line};
    my $rfields        = $rcall_hash->{rfields};
    my $rtokens        = $rcall_hash->{rtokens};
    my $rpatterns      = $rcall_hash->{rpatterns};
    my $rfield_lengths = $rcall_hash->{rfield_lengths};
    my $group_level    = $rcall_hash->{group_level};

    return if ( !$old_line );
    use constant EXPLAIN_TERNARY => 0;

    if (%valign_control_hash) {
        my $align_ok = $valign_control_hash{'?'};
        $align_ok = $valign_control_default unless defined($align_ok);
        return if ( !$align_ok );
    }

    my $jmax        = @{$rfields} - 1;
    my $rfields_old = $old_line->{'rfields'};

    my $rpatterns_old       = $old_line->{'rpatterns'};
    my $rtokens_old         = $old_line->{'rtokens'};
    my $maximum_field_index = $old_line->{'jmax'};

    # look for the question mark after the :
    my ($jquestion);
    my $depth_question;
    my $pad        = EMPTY_STRING;
    my $pad_length = 0;
    foreach my $j ( 0 .. $maximum_field_index - 1 ) {
        my $tok = $rtokens_old->[$j];
        my ( $raw_tok, $lev, $tag_uu, $tok_count_uu ) =
          decode_alignment_token($tok);
        if ( $raw_tok eq '?' ) {
            $depth_question = $lev;

            # depth must be correct
            next if ( $depth_question ne $group_level );

            $jquestion = $j;
            if ( $rfields_old->[ $j + 1 ] =~ /^(\?\s*)/ ) {
                $pad_length = length($1);
                $pad        = SPACE x $pad_length;
            }
            else {
                return;    # shouldn't happen
            }
            last;
        }
    }
    return if ( !defined($jquestion) );    # shouldn't happen

    # Now splice the tokens and patterns of the previous line
    # into the else line to insure a match.  Add empty fields
    # as necessary.
    my $jadd = $jquestion;

    # Work on copies of the actual arrays in case we have
    # to return due to an error
    my @fields        = @{$rfields};
    my @patterns      = @{$rpatterns};
    my @tokens        = @{$rtokens};
    my @field_lengths = @{$rfield_lengths};

    EXPLAIN_TERNARY && do {
        local $LIST_SEPARATOR = '><';
        print {*STDOUT} "CURRENT FIELDS=<@{$rfields_old}>\n";
        print {*STDOUT} "CURRENT TOKENS=<@{$rtokens_old}>\n";
        print {*STDOUT} "CURRENT PATTERNS=<@{$rpatterns_old}>\n";
        print {*STDOUT} "UNMODIFIED FIELDS=<@{$rfields}>\n";
        print {*STDOUT} "UNMODIFIED TOKENS=<@{$rtokens}>\n";
        print {*STDOUT} "UNMODIFIED PATTERNS=<@{$rpatterns}>\n";
    };

    # handle cases of leading colon on this line
    if ( $fields[0] =~ /^(:\s*)(.*)$/ ) {

        my ( $colon, $therest ) = ( $1, $2 );

        # Handle sub-case of first field with leading colon plus additional code
        # This is the usual situation as at the '1' below:
        #  ...
        #  : $year % 400 ? 0
        #  :               1;
        if ($therest) {

            # Split the first field after the leading colon and insert padding.
            # Note that this padding will remain even if the terminal value goes
            # out on a separate line.  This does not seem to look to bad, so no
            # mechanism has been included to undo it.
            my $field1_uu     = shift @fields;
            my $field_length1 = shift @field_lengths;
            my $len_colon     = length($colon);
            unshift @fields, ( $colon, $pad . $therest );
            unshift @field_lengths,
              ( $len_colon, $pad_length + $field_length1 - $len_colon );

            # change the leading pattern from : to ?
            return if ( $patterns[0] !~ s/^\:/?/ );

            # install leading tokens and patterns of existing line
            unshift( @tokens,   @{$rtokens_old}[ 0 .. $jquestion ] );
            unshift( @patterns, @{$rpatterns_old}[ 0 .. $jquestion ] );

            # insert appropriate number of empty fields
            splice( @fields,        1, 0, (EMPTY_STRING) x $jadd ) if $jadd;
            splice( @field_lengths, 1, 0, (0) x $jadd )            if $jadd;
        }

        # handle sub-case of first field just equal to leading colon.
        # This can happen for example in the example below where
        # the leading '(' would create a new alignment token
        # : ( $name =~ /[]}]$/ ) ? ( $mname = $name )
        # :                        ( $mname = $name . '->' );
        else {

            return if ( $jmax <= 0 || $tokens[0] eq '#' );    # shouldn't happen

            # prepend a leading ? onto the second pattern
            $patterns[1] = "?b" . $patterns[1];

            # pad the second field
            $fields[1]        = $pad . $fields[1];
            $field_lengths[1] = $pad_length + $field_lengths[1];

            # install leading tokens and patterns of existing line, replacing
            # leading token and inserting appropriate number of empty fields
            splice( @tokens,   0, 1, @{$rtokens_old}[ 0 .. $jquestion ] );
            splice( @patterns, 1, 0, @{$rpatterns_old}[ 1 .. $jquestion ] );
            splice( @fields,        1, 0, (EMPTY_STRING) x $jadd ) if $jadd;
            splice( @field_lengths, 1, 0, (0) x $jadd )            if $jadd;
        }
    }

    # Handle case of no leading colon on this line.  This will
    # be the case when -wba=':' is used.  For example,
    #  $year % 400 ? 0 :
    #                1;
    else {

        # install leading tokens and patterns of existing line
        $patterns[0] = '?' . 'b' . $patterns[0];
        unshift( @tokens,   @{$rtokens_old}[ 0 .. $jquestion ] );
        unshift( @patterns, @{$rpatterns_old}[ 0 .. $jquestion ] );

        # insert appropriate number of empty fields
        $jadd             = $jquestion + 1;
        $fields[0]        = $pad . $fields[0];
        $field_lengths[0] = $pad_length + $field_lengths[0];
        splice( @fields,        0, 0, (EMPTY_STRING) x $jadd ) if $jadd;
        splice( @field_lengths, 0, 0, (0) x $jadd )            if $jadd;
    }

    EXPLAIN_TERNARY && do {
        local $LIST_SEPARATOR = '><';
        print {*STDOUT} "MODIFIED TOKENS=<@tokens>\n";
        print {*STDOUT} "MODIFIED PATTERNS=<@patterns>\n";
        print {*STDOUT} "MODIFIED FIELDS=<@fields>\n";
    };

    # all ok .. update the arrays
    @{$rfields}        = @fields;
    @{$rtokens}        = @tokens;
    @{$rpatterns}      = @patterns;
    @{$rfield_lengths} = @field_lengths;

    # force a flush after this line
    return $jquestion;
} ## end sub fix_terminal_ternary

sub fix_terminal_else {

    # Add empty fields as necessary to align a balanced terminal
    # else block to a previous if/elsif/unless block,
    # like this:
    #
    #  if   ( 1 || $x ) { print "ok 13\n"; }
    #  else             { print "not ok 13\n"; }
    #
    # returns a positive value if the else block should be indented
    #
    my ($rcall_hash) = @_;

    my $old_line       = $rcall_hash->{old_line};
    my $rfields        = $rcall_hash->{rfields};
    my $rtokens        = $rcall_hash->{rtokens};
    my $rpatterns      = $rcall_hash->{rpatterns};
    my $rfield_lengths = $rcall_hash->{rfield_lengths};

    return if ( !$old_line );
    my $jmax = @{$rfields} - 1;
    return if ( $jmax <= 0 );

    if (%valign_control_hash) {
        my $align_ok = $valign_control_hash{'{'};
        $align_ok = $valign_control_default unless defined($align_ok);
        return if ( !$align_ok );
    }

    # check for balanced else block following if/elsif/unless
    my $rfields_old = $old_line->{'rfields'};

    # TBD: add handling for 'case'
    return if ( $rfields_old->[0] !~ /^(?:if|elsif|unless)\s*$/ );

    # look for the opening brace after the else, and extract the depth
    my $tok_brace = $rtokens->[0];
    my $depth_brace;
    if ( $tok_brace =~ /^\{(\d+)/ ) { $depth_brace = $1; }

    # probably:  "else # side_comment"
    else { return }

    my $rpatterns_old       = $old_line->{'rpatterns'};
    my $rtokens_old         = $old_line->{'rtokens'};
    my $maximum_field_index = $old_line->{'jmax'};

    # be sure the previous if/elsif is followed by an opening paren
    my $jparen    = 0;
    my $tok_paren = '(' . $depth_brace;
    my $tok_test  = $rtokens_old->[$jparen];
    return if ( $tok_test ne $tok_paren );    # shouldn't happen

    # Now find the opening block brace
    my ($jbrace);
    foreach my $j ( 1 .. $maximum_field_index - 1 ) {
        my $tok = $rtokens_old->[$j];
        if ( $tok eq $tok_brace ) {
            $jbrace = $j;
            last;
        }
    }
    return if ( !defined($jbrace) );          # shouldn't happen

    # Now splice the tokens and patterns of the previous line
    # into the else line to insure a match.  Add empty fields
    # as necessary.
    my $jadd = $jbrace - $jparen;
    splice( @{$rtokens},   0, 0, @{$rtokens_old}[ $jparen .. $jbrace - 1 ] );
    splice( @{$rpatterns}, 1, 0, @{$rpatterns_old}[ $jparen + 1 .. $jbrace ] );
    splice( @{$rfields},        1, 0, (EMPTY_STRING) x $jadd );
    splice( @{$rfield_lengths}, 1, 0, (0) x $jadd );

    # force a flush after this line if it does not follow a case
    if   ( $rfields_old->[0] =~ /^case\s*$/ ) { return }
    else                                      { return $jbrace }
} ## end sub fix_terminal_else

my %is_closing_block_type;

BEGIN {
    my @q = qw< } ] >;
    @is_closing_block_type{@q} = (1) x scalar(@q);
}

# This is a flag for testing alignment by sub sweep_left_to_right only.
# This test can help find problems with the alignment logic.
# This flag should normally be zero.
use constant TEST_SWEEP_ONLY => 0;

use constant EXPLAIN_CHECK_MATCH => 0;

sub check_match {

    # See if the current line matches the current vertical alignment group.

    my ( $self, $new_line, $base_line, $prev_line, $group_line_count ) = @_;

    # Given:
    #  $new_line  = the line being considered for group inclusion
    #  $base_line = the first line of the current group
    #  $prev_line = the line just before $new_line
    #  $group_line_count = number of lines in the current group

    # Returns: a flag and a value as follows:
    #    return (0, $imax_align)   if the line does not match
    #    return (1, $imax_align)   if the line matches but does not fit
    #    return (2, $imax_align)   if the line matches and fits

    use constant NO_MATCH      => 0;
    use constant MATCH_NO_FIT  => 1;
    use constant MATCH_AND_FIT => 2;

    # Return value '$return_value' describes the match with 3 possible values
    my $return_value;

    # Return value '$imax_align' is the index of the maximum matching token.
    # It will be used in the subsequent left-to-right sweep to align as many
    # tokens as possible for lines which partially match.
    my $imax_align = -1;

    # variable $GoToMsg explains reason for no match, for debugging
    my $GoToMsg = EMPTY_STRING;

    my $jmax                = $new_line->{'jmax'};
    my $maximum_field_index = $base_line->{'jmax'};

    my $jlimit = $jmax - 2;
    if ( $jmax > $maximum_field_index ) {
        $jlimit = $maximum_field_index - 2;
    }

    if ( $new_line->{'is_hanging_side_comment'} ) {

        # HSC's can join the group if they fit
    }

    # Everything else
    else {

        # A group with hanging side comments ends with the first non hanging
        # side comment.
        if ( $base_line->{'is_hanging_side_comment'} ) {
            $GoToMsg      = "end of hanging side comments";
            $return_value = NO_MATCH;
        }
        else {

            # The number of tokens that this line shares with the previous
            # line has been stored with the previous line.  This value was
            # calculated and stored by sub 'match_line_pair'.
            $imax_align = $prev_line->{'imax_pair'};

            # Only the following ci sequences are accepted (issue c225):
            #   0 0 0 ...  OK
            #   0 1 1 ...  OK but marginal*
            #   1 1 1 ...  OK
            # This check is rarely activated, but for example we want
            # to avoid something like this 'tail wag dog' situation:
            #  $tag        =~ s/\b([a-z]+)/\L\u$1/gio;
            #  $tag        =~ s/\b([b-df-hj-np-tv-z]+)\b/\U$1/gio
            #      if $tag =~ /-/;
            # *Note: we could set a flag for the 0 1 marginal case and
            # use it to prevent alignment of selected token types.
            my $ci_prev = $prev_line->{'ci_level'};
            my $ci_new  = $new_line->{'ci_level'};
            if (   $ci_prev != $ci_new
                && $imax_align >= 0
                && ( $ci_new == 0 || $group_line_count > 1 ) )
            {
                $imax_align = -1;
                $GoToMsg =
"Rejected ci: ci_prev=$ci_prev ci_new=$ci_new num=$group_line_count\n";
                $return_value = NO_MATCH;
            }
            elsif ( $imax_align != $jlimit ) {
                $GoToMsg = "Not all tokens match: $imax_align != $jlimit\n";
                $return_value = NO_MATCH;
            }
            else {
                ##ok: continue
            }
        }
    }

    if ( !defined($return_value) ) {

        # The tokens match, but the lines must have identical number of
        # tokens to join the group.
        if ( $maximum_field_index != $jmax ) {
            $GoToMsg      = "token count differs";
            $return_value = NO_MATCH;
        }

        # The tokens match. Now See if there is space for this line in the
        # current group.
        elsif ( $self->check_fit( $new_line, $base_line ) && !TEST_SWEEP_ONLY )
        {

            $GoToMsg = "match and fit, imax_align=$imax_align, jmax=$jmax\n";
            $return_value = MATCH_AND_FIT;
            $imax_align   = $jlimit;
        }
        else {
            $GoToMsg = "match but no fit, imax_align=$imax_align, jmax=$jmax\n";
            $return_value = MATCH_NO_FIT;
            $imax_align   = $jlimit;
        }
    }

    EXPLAIN_CHECK_MATCH
      && print
"returning $return_value because $GoToMsg, max match index =i $imax_align, jmax=$jmax\n";

    return ( $return_value, $imax_align );
} ## end sub check_match

sub check_fit {

    my ( $self, $new_line, $old_line ) = @_;

    # The new line has alignments identical to the current group. Now we have
    # to fit the new line into the group without causing a field to exceed the
    # line length limit.

    # Given:
    #   $new_line = ref to hash of the new line values
    #   $old_line = ref to hash of the previous line values
    # Returns:
    #   true if the new line alignments fit the old line
    #   false otherwise

    my $jmax                = $new_line->{'jmax'};
    my $leading_space_count = $new_line->{'leading_space_count'};
    my $rfield_lengths      = $new_line->{'rfield_lengths'};
    my $padding_available   = $old_line->get_available_space_on_right();
    my $jmax_old            = $old_line->{'jmax'};

    # Safety check ... only lines with equal array sizes should arrive here
    # from sub check_match.  So if this error occurs, look at recent changes in
    # sub check_match.  It is only supposed to check the fit of lines with
    # identical numbers of alignment tokens.
    if ( $jmax_old ne $jmax ) {

        warning(<<EOM);
Program bug detected in Perl::Tidy::VerticalAligner sub check_fit
unexpected difference in array lengths: $jmax != $jmax_old
EOM
        return;
    }

    # Save current columns in case this line does not fit.
    my @alignments = @{ $old_line->{'ralignments'} };
    foreach my $alignment (@alignments) {
        $alignment->save_column();
    }

    # Loop over all alignments ...
    for my $j ( 0 .. $jmax ) {

        my $pad = $rfield_lengths->[$j] - $old_line->current_field_width($j);

        if ( $j == 0 ) {
            $pad += $leading_space_count;
        }

        # Keep going if this field does not need any space.
        next if ( $pad < 0 );

        # Revert to the starting state if does not fit
        if ( $pad > $padding_available ) {

            #----------------------------------------------
            # Line does not fit -- revert to starting state
            #----------------------------------------------
            foreach my $alignment (@alignments) {
                $alignment->restore_column();
            }
            return;
        }

        # make room for this field
        $old_line->increase_field_width( $j, $pad );
        $padding_available -= $pad;
    }

    #-------------------------------------
    # The line fits, the match is accepted
    #-------------------------------------
    return 1;

} ## end sub check_fit

sub install_new_alignments {

    my ($new_line) = @_;

    # Given:
    #   $new_line = ref to hash of a line starting a new group
    # Task:
    #   setup alignment fields for this line

    my $jmax           = $new_line->{'jmax'};
    my $rfield_lengths = $new_line->{'rfield_lengths'};
    my $col            = $new_line->{'leading_space_count'};

    my @alignments;
    for my $j ( 0 .. $jmax ) {
        $col += $rfield_lengths->[$j];

        # create initial alignments for the new group
        my $alignment =
          Perl::Tidy::VerticalAligner::Alignment->new( { column => $col } );
        push @alignments, $alignment;
    }
    $new_line->{'ralignments'} = \@alignments;
    return;
} ## end sub install_new_alignments

sub copy_old_alignments {
    my ( $new_line, $old_line ) = @_;
    my @new_alignments = @{ $old_line->{'ralignments'} };
    $new_line->{'ralignments'} = \@new_alignments;
    return;
} ## end sub copy_old_alignments

sub dump_array {

    # debug routine to dump array contents
    local $LIST_SEPARATOR = ')(';
    print {*STDOUT} "(@_)\n";
    return;
} ## end sub dump_array

sub level_change {

    my ( $self, $leading_space_count, $diff, $level ) = @_;

    # compute decrease in level when we remove $diff spaces from the
    # leading spaces

    # Given:
    #   $leading_space_count = current leading line spaces
    #   $diff = number of spaces to remove
    #   $level = current indentation level
    # Return:
    #   $level = updated level accounting for the loss of spaces

    if ($rOpts_indent_columns) {
        my $olev =
          int( ( $leading_space_count + $diff ) / $rOpts_indent_columns );
        my $nlev = int( $leading_space_count / $rOpts_indent_columns );
        $level -= ( $olev - $nlev );
        if ( $level < 0 ) { $level = 0 }
    }
    return $level;
} ## end sub level_change

###############################################
# CODE SECTION 4: Code to process comment lines
###############################################

sub _flush_comment_lines {

    # Output a group consisting of COMMENT lines

    my ($self) = @_;
    my $rgroup_lines = $self->[_rgroup_lines_];
    return if ( !@{$rgroup_lines} );
    my $group_level               = $self->[_group_level_];
    my $group_maximum_line_length = $self->[_group_maximum_line_length_];
    my $leading_space_count       = $self->[_comment_leading_space_count_];

    # look for excessively long lines
    my $max_excess = 0;
    foreach my $item ( @{$rgroup_lines} ) {
        my ( $str_uu, $str_len ) = @{$item};
        my $excess =
          $str_len + $leading_space_count - $group_maximum_line_length;
        if ( $excess > $max_excess ) {
            $max_excess = $excess;
        }
    }

    # zero leading space count if any lines are too long
    if ( $max_excess > 0 ) {
        $leading_space_count -= $max_excess;
        if ( $leading_space_count < 0 ) { $leading_space_count = 0 }
        my $file_writer_object = $self->[_file_writer_object_];
        my $last_outdented_line_at =
          $file_writer_object->get_output_line_number();
        my $nlines = @{$rgroup_lines};
        $self->[_last_outdented_line_at_] =
          $last_outdented_line_at + $nlines - 1;
        my $outdented_line_count = $self->[_outdented_line_count_];
        if ( !$outdented_line_count ) {
            $self->[_first_outdented_line_at_] = $last_outdented_line_at;
        }
        $outdented_line_count += $nlines;
        $self->[_outdented_line_count_] = $outdented_line_count;
    }

    # write the lines
    my $outdent_long_lines = 0;

    foreach my $item ( @{$rgroup_lines} ) {
        my ( $str, $str_len, $Kend ) = @{$item};
        $self->valign_output_step_B(
            {
                leading_space_count       => $leading_space_count,
                line                      => $str,
                line_length               => $str_len,
                side_comment_length       => 0,
                outdent_long_lines        => $outdent_long_lines,
                rvertical_tightness_flags => undef,
                level                     => $group_level,
                level_end                 => $group_level,
                Kend                      => $Kend,
                maximum_line_length       => $group_maximum_line_length,
            }
        );
    }

    $self->initialize_for_new_group();
    return;
} ## end sub _flush_comment_lines

######################################################
# CODE SECTION 5: Code to process groups of code lines
######################################################

sub _flush_group_lines {

    # This is the vertical aligner internal flush, which leaves the cache
    # intact
    my ( $self, ($level_jump) ) = @_;

    # $level_jump = $next_level-$group_level, if known
    #             = undef if not known
    # Note: only the sign of the jump is needed

    my $rgroup_lines = $self->[_rgroup_lines_];
    return if ( !@{$rgroup_lines} );
    my $group_type  = $self->[_group_type_];
    my $group_level = $self->[_group_level_];

    # Debug
    0 && do {
        my ( $a, $b, $c ) = caller();
        my $nlines = @{$rgroup_lines};
        print {*STDOUT}
"APPEND0: _flush_group_lines called from $a $b $c lines=$nlines, type=$group_type \n";
    };

    #-------------------------------------------
    # Section 1: Handle a group of COMMENT lines
    #-------------------------------------------
    if ( $group_type eq 'COMMENT' ) {
        $self->_flush_comment_lines();
        return;
    }

    #------------------------------------------------------------------------
    # Section 2: Handle line(s) of CODE.  Most of the actual work of vertical
    # aligning happens here in the following steps:
    #------------------------------------------------------------------------

    # STEP 1: Remove most unmatched tokens. They block good alignments.
    my ( $max_lev_diff_uu, $saw_side_comment, $saw_signed_number ) =
      delete_unmatched_tokens( $rgroup_lines, $group_level );

    # STEP 2: Sweep top to bottom, forming subgroups of lines with exactly
    # matching common alignments.  The indexes of these subgroups are in the
    # return variable.
    my $rgroups = $self->sweep_top_down( $rgroup_lines, $group_level );

    # STEP 3: Sweep left to right through the lines, looking for leading
    # alignment tokens shared by groups.
    sweep_left_to_right( $rgroup_lines, $rgroups, $group_level )
      if ( @{$rgroups} > 1 );

    # STEP 4: Move side comments to a common column if possible.
    if ($saw_side_comment) {
        $self->align_side_comments( $rgroup_lines, $rgroups );
    }

    # STEP 5: For the -lp option, increase the indentation of lists
    # to the desired amount, but do not exceed the line length limit.

    # We are allowed to shift a group of lines to the right if:
    #  (1) its level is greater than the level of the previous group, and
    #  (2) its level is greater than the level of the next line to be written.

    my $extra_indent_ok;
    if ( $group_level > $self->[_last_level_written_] ) {

        # Use the level jump to next line to come, if given
        if ( defined($level_jump) ) {
            $extra_indent_ok = $level_jump < 0;
        }

        # Otherwise, assume the next line has the level of the end of last line.
        # This fixes case c008.
        else {
            my $level_end = $rgroup_lines->[-1]->{'level_end'};
            $extra_indent_ok = $group_level > $level_end;
        }
    }

    my $extra_leading_spaces =
      $extra_indent_ok
      ? get_extra_leading_spaces( $rgroup_lines, $rgroups )
      : 0;

    # STEP 6: add sign padding to columns numbers if needed
    pad_signed_number_columns($rgroup_lines)
      if ( $saw_signed_number && $rOpts_valign_signed_numbers );

    # STEP 7: pad wide equals
    pad_wide_equals_columns($rgroup_lines)
      if ($rOpts_valign_wide_equals);

    # STEP 8: Output the lines.
    # All lines in this group have the same leading spacing and maximum line
    # length
    my $group_leader_length       = $rgroup_lines->[0]->{'leading_space_count'};
    my $group_maximum_line_length = $rgroup_lines->[0]->{'maximum_line_length'};

    foreach my $line ( @{$rgroup_lines} ) {
        $self->valign_output_step_A(
            {
                line                 => $line,
                min_ci_gap           => 0,
                do_not_align         => 0,
                group_leader_length  => $group_leader_length,
                extra_leading_spaces => $extra_leading_spaces,
                level                => $group_level,
                maximum_line_length  => $group_maximum_line_length,
            }
        );
    }

    # Let the formatter know that this object has been processed and any
    # recoverable spaces have been handled.  This is needed for setting the
    # closing paren location in -lp mode.
    my $object = $rgroup_lines->[0]->{'indentation'};
    if ( ref($object) ) { $object->set_recoverable_spaces(0) }

    $self->initialize_for_new_group();
    return;
} ## end sub _flush_group_lines

{    ## closure for sub sweep_top_down

    my $rall_lines;         # all of the lines
    my $grp_level;          # level of all lines
    my $rgroups;            # describes the partition of lines we will make here
    my $group_line_count;   # number of lines in current partition

    BEGIN { $rgroups = [] }

    sub initialize_for_new_rgroup {
        $group_line_count = 0;
        return;
    }

    sub add_to_rgroup {

        my ($jend) = @_;
        my $rline = $rall_lines->[$jend];

        my $jbeg = $jend;
        if ( $group_line_count == 0 ) {
            install_new_alignments($rline);
        }
        else {
            my $rvals = pop @{$rgroups};
            $jbeg = $rvals->[0];
            copy_old_alignments( $rline, $rall_lines->[$jbeg] );
        }
        push @{$rgroups}, [ $jbeg, $jend, undef ];
        $group_line_count++;
        return;
    } ## end sub add_to_rgroup

    sub get_rgroup_jrange {

        return if ( !@{$rgroups} );
        return if ( $group_line_count <= 0 );
        my ( $jbeg, $jend ) = @{ $rgroups->[-1] };
        return ( $jbeg, $jend );
    } ## end sub get_rgroup_jrange

    sub end_rgroup {

        my ($imax_align) = @_;
        return if ( !@{$rgroups} );
        return if ( $group_line_count <= 0 );

        my ( $jbeg, $jend ) = @{ pop @{$rgroups} };
        push @{$rgroups}, [ $jbeg, $jend, $imax_align ];

        # Undo some alignments of poor two-line combinations.
        # We had to wait until now to know the line count.
        if ( $jend - $jbeg == 1 ) {
            my $line_0 = $rall_lines->[$jbeg];
            my $line_1 = $rall_lines->[$jend];

            my $imax_pair = $line_1->{'imax_pair'};
            if ( $imax_pair > $imax_align ) { $imax_align = $imax_pair }

            ## flag for possible future use:
            ## my $is_isolated_pair = $imax_pair < 0
            ##  && ( $jbeg == 0
            ##    || $rall_lines->[ $jbeg - 1 ]->{'imax_pair'} < 0 );

            my $imax_prev =
              $jbeg > 0 ? $rall_lines->[ $jbeg - 1 ]->{'imax_pair'} : -1;

            my ( $is_marginal, $imax_align_fix ) =
              is_marginal_match( $line_0, $line_1, $grp_level, $imax_align,
                $imax_prev );
            if ($is_marginal) {
                combine_fields( $line_0, $line_1, $imax_align_fix );
            }
        }

        initialize_for_new_rgroup();
        return;
    } ## end sub end_rgroup

    sub block_penultimate_match {

        # emergency reset to prevent sweep_left_to_right from trying to match a
        # failed terminal else match
        return if ( @{$rgroups} <= 1 );
        $rgroups->[-2]->[2] = -1;
        return;
    } ## end sub block_penultimate_match

    sub sweep_top_down {
        my ( $self, $rlines, $group_level ) = @_;

        # This is the first of two major sweeps to find alignments.
        # The other is sweep_left_to_right.

        # Given:
        #   $rlines = ref to hash of lines in this main alignment group
        #   $group_level = common indentation level of these lines
        # Return:
        #   $rgroups = ref to hash of subgroups created

        # Partition the set of lines into final alignment subgroups
        # and store the alignments with the lines.

        # The alignment subgroups we are making here are groups of consecutive
        # lines which have (1) identical alignment tokens and (2) do not
        # exceed the allowable maximum line length.  A later sweep from
        # left-to-right ('sweep_lr') will handle additional alignments.

        # transfer args to closure variables
        $rall_lines = $rlines;
        $grp_level  = $group_level;
        $rgroups    = [];
        initialize_for_new_rgroup();
        return unless @{$rlines};    # shouldn't happen

        # Unset the _end_group flag for the last line if it it set because it
        # is not needed and can causes problems for -lp formatting
        $rall_lines->[-1]->{'end_group'} = 0;

        # Loop over all lines ...
        my $jline = -1;
        foreach my $new_line ( @{$rall_lines} ) {
            $jline++;

            # Start a new subgroup if necessary
            if ( !$group_line_count ) {
                add_to_rgroup($jline);
                if ( $new_line->{'end_group'} ) {
                    end_rgroup(-1);
                }
                next;
            }

            my $j_terminal_match = $new_line->{'j_terminal_match'};
            my ( $jbeg, $jend_uu ) = get_rgroup_jrange();
            if ( !defined($jbeg) ) {

                # safety check, shouldn't happen
                warning(<<EOM);
Program bug detected in Perl::Tidy::VerticalAligner sub sweep_top_down
undefined index for group line count $group_line_count
EOM
                $jbeg = $jline;
            }
            my $base_line = $rall_lines->[$jbeg];

            # Initialize a global flag saying if the last line of the group
            # should match end of group and also terminate the group.  There
            # should be no returns between here and where the flag is handled
            # at the bottom.
            my $col_matching_terminal = 0;
            if ( defined($j_terminal_match) ) {

                # remember the column of the terminal ? or { to match with
                $col_matching_terminal =
                  $base_line->get_column($j_terminal_match);

                # Ignore an undefined value as a defensive step; shouldn't
                # normally happen.
                $col_matching_terminal = 0
                  unless defined($col_matching_terminal);
            }

            # -------------------------------------------------------------
            # Allow hanging side comment to join current group, if any.  The
            # only advantage is to keep the other tokens in the same group. For
            # example, this would make the '=' align here:
            #  $ax         = 1;           # side comment
            #                             # hanging side comment
            #  $boondoggle = 5;           # side comment
            #  $beetle     = 5;           # side comment

            # here is another example..

            #  _rtoc_name_count   => {},                   # hash to track ..
            #  _rpackage_stack    => [],                   # stack to check ..
            #                                              # name changes
            #  _rlast_level       => \$last_level,         # brace indentation
            #
            #
            # If this were not desired, the next step could be skipped.
            # -------------------------------------------------------------
            if ( $new_line->{'is_hanging_side_comment'} ) {
                join_hanging_comment( $new_line, $base_line );
            }

            # If this line has no matching tokens, then flush out the lines
            # BEFORE this line unless both it and the previous line have side
            # comments.  This prevents this line from pushing side comments out
            # to the right.
            elsif ( $new_line->{'jmax'} == 1 ) {

                # There are no matching tokens, so now check side comments.
                # Programming note: accessing arrays with index -1 is
                # risky in Perl, but we have verified there is at least one
                # line in the group and that there is at least one field,
                my $prev_comment =
                  $rall_lines->[ $jline - 1 ]->{'rfields'}->[-1];
                my $side_comment = $new_line->{'rfields'}->[-1];

                # do not end group if both lines have side comments
                if ( !$side_comment || !$prev_comment ) {

                    # Otherwise - VSN PATCH for a single number:
                    # - do not end group if numeric and no side comment, or
                    # - end if !numeric or side comment
                    my $pat        = $new_line->{'rpatterns'}->[0];
                    my $is_numeric = $rOpts_valign_signed_numbers
                      && ( $pat eq 'n,'
                        || $pat eq 'n,b' );
                    end_rgroup(-1) if ( !$is_numeric || $side_comment );
                }
            }
            else {
                ##ok: continue
            }

            # See if the new line matches and fits the current group,
            # if it still exists. Flush the current group if not.
            my $match_code;
            if ($group_line_count) {
                ( $match_code, my $imax_align ) =
                  $self->check_match( $new_line, $base_line,
                    $rall_lines->[ $jline - 1 ],
                    $group_line_count );
                if ( $match_code != 2 ) { end_rgroup($imax_align) }
            }

            # Store the new line
            add_to_rgroup($jline);

            if ( defined($j_terminal_match) ) {

                # Decide if we should fix a terminal match. We can either:
                # 1. fix it and prevent the sweep_lr from changing it, or
                # 2. leave it alone and let sweep_lr try to fix it.

                # The current logic is to fix it if:
                # -it has not joined to previous lines,
                # -and either the previous subgroup has just 1 line, or
                # -this line matched but did not fit (so sweep won't work)
                my $fixit;
                if ( $group_line_count == 1 ) {
                    $fixit ||= $match_code;
                    if ( !$fixit ) {
                        if ( @{$rgroups} > 1 ) {
                            my ( $jbegx, $jendx ) = @{ $rgroups->[-2] };
                            my $nlines = $jendx - $jbegx + 1;
                            $fixit ||= $nlines <= 1;
                        }
                    }
                }

                if ($fixit) {
                    $base_line = $new_line;
                    my $col_now = $base_line->get_column($j_terminal_match);

                    # Ignore an undefined value as a defensive step; shouldn't
                    # normally happen.
                    $col_now = 0 unless defined($col_now);

                    my $pad = $col_matching_terminal - $col_now;
                    my $padding_available =
                      $base_line->get_available_space_on_right();
                    if ( $col_now && $pad > 0 && $pad <= $padding_available ) {
                        $base_line->increase_field_width( $j_terminal_match,
                            $pad );
                    }

                    # do not let sweep_left_to_right change an isolated 'else'
                    if ( !$new_line->{'is_terminal_ternary'} ) {
                        block_penultimate_match();
                    }
                }
                end_rgroup(-1);
            }

            # end the group if we know we cannot match next line.
            elsif ( $new_line->{'end_group'} ) {
                end_rgroup(-1);
            }

            else {
                ##ok: continue
            }
        } ## end loop over lines

        end_rgroup(-1);
        return ($rgroups);
    } ## end sub sweep_top_down
}

sub two_line_pad {

    my ( $line_m, $line, $imax_min ) = @_;

    # Decide if two adjacent, isolated lines should be aligned

    # Given:
    #  $line_m, $line = two isolated (list) lines
    #  imax_min = number of common alignment tokens
    # Return:
    #  $pad_max = maximum suggested pad distance
    #           = 0 if alignment not recommended

    # Allow alignment if the difference in the two unpadded line lengths
    # is not more than either line length.  The idea is to avoid
    # aligning lines with very different field lengths, like these two:

    #   [
    #       'VARCHAR', DBI::SQL_VARCHAR, undef, "'", "'", undef, 0, 1,
    #       1, 0, 0, 0, undef, 0, 0
    #   ];

    # Note that this is only for two lines which do not have alignment tokens
    # in common with any other lines.  It is intended for lists, but it might
    # also be used for two non-list lines with a common leading '='.

    my $rfield_lengths   = $line->{'rfield_lengths'};
    my $rfield_lengths_m = $line_m->{'rfield_lengths'};

    # Safety check - shouldn't happen
    return 0
      if ( $imax_min >= @{$rfield_lengths}
        || $imax_min >= @{$rfield_lengths_m} );

    my $lensum_m = 0;
    my $lensum   = 0;
    foreach my $i ( 0 .. $imax_min ) {
        $lensum_m += $rfield_lengths_m->[$i];
        $lensum   += $rfield_lengths->[$i];
    }

    my ( $lenmin, $lenmax ) =
      $lensum >= $lensum_m ? ( $lensum_m, $lensum ) : ( $lensum, $lensum_m );

    my $patterns_match;
    if ( $line_m->{'list_type'} && $line->{'list_type'} ) {
        $patterns_match = 1;
        my $rpatterns_m = $line_m->{'rpatterns'};
        my $rpatterns   = $line->{'rpatterns'};
        foreach my $i ( 0 .. $imax_min ) {
            my $pat   = $rpatterns->[$i];
            my $pat_m = $rpatterns_m->[$i];

            # VSN PATCH: allow numbers to match quotes
            if ( $pat_m ne $pat && length($pat_m) eq length($pat) ) {
                $pat   =~ tr/n/Q/;
                $pat_m =~ tr/n/Q/;
            }

            if ( $pat ne $pat_m ) { $patterns_match = 0; last; }
        }
    }

    my $pad_max = $lenmax;
    if ( !$patterns_match && $lenmax > 2 * $lenmin ) { $pad_max = 0 }

    return $pad_max;
} ## end sub two_line_pad

sub sweep_left_to_right {

    my ( $rlines, $rgroups, $group_level ) = @_;

    # This is the second of two major sweeps to find alignments.
    # The other is sweep_top_down.

    # Given:
    #   $rlines = ref to hash of lines in this main alignment group
    #   $rgroups = ref to hash of subgroups
    #   $group_level = common indentation level of these lines
    # Task:
    #   add leading alignments where possible

    # So far we have divided the lines into groups having an equal number of
    # identical alignments.  Here we are going to look for common leading
    # alignments between the different groups and align them when possible.
    # For example, the three lines below are in three groups because each line
    # has a different number of commas.  In this routine we will sweep from
    # left to right, aligning the leading commas as we go, but stopping if we
    # hit the line length limit.

    #  my ( $num, $numi, $numj,  $xyza, $ka,   $xyzb, $kb, $aff, $error );
    #  my ( $i,   $j,    $error, $aff,  $asum, $avec );
    #  my ( $km,  $area, $varea );

    # nothing to do if just one group
    my $ng_max = @{$rgroups} - 1;
    return if ( $ng_max <= 0 );

    #---------------------------------------------------------------------
    # Step 1: Loop over groups to find all common leading alignment tokens
    #---------------------------------------------------------------------

    my $line;
    my $rtokens;
    my $imax;     # index of maximum non-side-comment alignment token
    my $istop;    # an optional stopping index
    my $jbeg;     # starting line index
    my $jend;     # ending line index

    my $line_m;
    my $rtokens_m;
    my $imax_m;
    my $istop_m;
    my $jbeg_m;
    my $jend_m;

    my $istop_mm;

    # Look at neighboring pairs of groups and form a simple list
    # of all common leading alignment tokens. Foreach such match we
    # store [$i, $ng], where
    #  $i = index of the token in the line (0,1,...)
    #  $ng is the second of the two groups with this common token
    my @icommon;

    # Hash to hold the maximum alignment change for any group
    my %max_move;

    # a small number of columns
    my $short_pad = 4;

    my $ng = -1;
    foreach my $item ( @{$rgroups} ) {
        $ng++;

        $istop_mm = $istop_m;

        # save _m values of previous group
        $line_m    = $line;
        $rtokens_m = $rtokens;
        $imax_m    = $imax;
        $istop_m   = $istop;
        $jbeg_m    = $jbeg;
        $jend_m    = $jend;

        # Get values for this group. Note that we just have to use values for
        # one of the lines of the group since all members have the same
        # alignments.
        ( $jbeg, $jend, $istop ) = @{$item};

        $line    = $rlines->[$jbeg];
        $rtokens = $line->{'rtokens'};
        $imax    = $line->{'jmax'} - 2;
        $istop   = -1    if ( !defined($istop) );
        $istop   = $imax if ( $istop > $imax );

        # Initialize on first group
        next if ( $ng == 0 );

        # Use the minimum index limit of the two groups
        my $imax_min = $imax > $imax_m ? $imax_m : $imax;

        # Also impose a limit if given.
        if ( $istop_m < $imax_min ) {
            $imax_min = $istop_m;
        }

        # Special treatment of two one-line groups isolated from other lines,
        # unless they form a simple list or a terminal match.  Otherwise the
        # alignment can look strange in some cases.
        my $list_type = $rlines->[$jbeg]->{'list_type'};
        if (
               $jend == $jbeg
            && $jend_m == $jbeg_m
            && ( $ng == 1 || $istop_mm < 0 )
            && ( $ng == $ng_max || $istop < 0 )
            && !$line->{'j_terminal_match'}

            # Only do this for imperfect matches. This is normally true except
            # when two perfect matches cannot form a group because the line
            # length limit would be exceeded. In that case we can still try
            # to match as many alignments as possible.
            && ( $imax != $imax_m || $istop_m != $imax_m )
          )
        {

            # We will just align assignments and simple lists
            next if ( $imax_min < 0 );
            next
              if ( $rtokens->[0] !~ /^=\d/
                && !$list_type );

            # In this case we will limit padding to a short distance.  This
            # is a compromise to keep some vertical alignment but prevent large
            # gaps, which do not look good for just two lines.
            my $pad_max =
              two_line_pad( $rlines->[$jbeg], $rlines->[$jbeg_m], $imax_min );
            next if ( !$pad_max );
            my $ng_m = $ng - 1;
            $max_move{"$ng_m"} = $pad_max;
            $max_move{"$ng"}   = $pad_max;
        }

        # Loop to find all common leading tokens.
        if ( $imax_min >= 0 ) {
            foreach my $i ( 0 .. $imax_min ) {
                my $tok   = $rtokens->[$i];
                my $tok_m = $rtokens_m->[$i];
                last if ( $tok ne $tok_m );
                push @icommon, [ $i, $ng, $tok ];
            }
        }
    }
    return unless @icommon;

    #----------------------------------------------------------
    # Step 2: Reorder and consolidate the list into a task list
    #----------------------------------------------------------

    # We have to work first from lowest token index to highest, then by group,
    # sort our list first on token index then group number
    @icommon = sort { $a->[0] <=> $b->[0] || $a->[1] <=> $b->[1] } @icommon;

    # Make a task list of the form
    #   [$i, ng_beg, $ng_end, $tok], ..
    # where
    #   $i is the index of the token to be aligned
    #   $ng_beg..$ng_end is the group range for this action
    my @todo;
    my ( $i, $ng_end, $tok );
    foreach my $item (@icommon) {
        my $ng_last = $ng_end;
        my $i_last  = $i;
        ( $i, $ng_end, $tok ) = @{$item};
        my $ng_beg = $ng_end - 1;
        if ( defined($ng_last) && $ng_beg == $ng_last && $i == $i_last ) {
            my $var = pop(@todo);
            $ng_beg = $var->[1];
        }
        my ( $raw_tok, $lev, $tag_uu, $tok_count_uu ) =
          decode_alignment_token($tok);
        push @todo, [ $i, $ng_beg, $ng_end, $raw_tok, $lev ];
    }

    #------------------------------
    # Step 3: Execute the task list
    #------------------------------
    do_left_to_right_sweep(
        {
            rlines      => $rlines,
            rgroups     => $rgroups,
            rtodo       => \@todo,
            rmax_move   => \%max_move,
            short_pad   => $short_pad,
            group_level => $group_level,
        }
    );
    return;
} ## end sub sweep_left_to_right

{    ## closure for sub do_left_to_right_sweep

    my %is_good_alignment_token;

    BEGIN {

        # One of the most difficult aspects of vertical alignment is knowing
        # when not to align.  Alignment can go from looking very nice to very
        # bad when overdone.  In the sweep algorithm there are two special
        # cases where we may need to limit padding to a '$short_pad' distance
        # to avoid some very ugly formatting:

        # 1. Two isolated lines with partial alignment
        # 2. A 'tail-wag-dog' situation, in which a single terminal
        #    line with partial alignment could cause a significant pad
        #    increase in many previous lines if allowed to join the alignment.

        # For most alignment tokens, we will allow only a small pad to be
        # introduced (the hardwired $short_pad variable) . But for some 'good'
        # alignments we can be less restrictive.

        # These are 'good' alignments, which are allowed more padding:
        my @q = qw( => = ? if unless or || { );
        push @q, ',';
        @is_good_alignment_token{@q} = (0) x scalar(@q);

        # Promote a few of these to 'best', with essentially no pad limit:
        $is_good_alignment_token{'='}      = 1;
        $is_good_alignment_token{'if'}     = 1;
        $is_good_alignment_token{'unless'} = 1;
        $is_good_alignment_token{'=>'}     = 1;

        # Note the hash values are set so that:
        #         if ($is_good_alignment_token{$raw_tok}) => best
        # if defined ($is_good_alignment_token{$raw_tok}) => good or best

    } ## end BEGIN

    sub move_to_common_column {

        # This is a sub called by sub do_left_to_right_sweep to
        # move the alignment column of token $itok to $col_want for a
        # sequence of groups.
        my ($rcall_hash) = @_;

        my $rlines    = $rcall_hash->{rlines};
        my $rgroups   = $rcall_hash->{rgroups};
        my $rmax_move = $rcall_hash->{rmax_move};
        my $ngb       = $rcall_hash->{ngb};
        my $nge       = $rcall_hash->{nge};
        my $itok      = $rcall_hash->{itok};
        my $col_want  = $rcall_hash->{col_want};
        my $raw_tok   = $rcall_hash->{raw_tok};

        return if ( !defined($ngb) || $nge <= $ngb );
        foreach my $ng ( $ngb .. $nge ) {

            my ( $jbeg, $jend_uu ) = @{ $rgroups->[$ng] };
            my $line = $rlines->[$jbeg];
            my $col  = $line->get_column($itok);
            my $move = $col_want - $col;
            if ( $move > 0 ) {

                # limit padding increase in isolated two lines
                next
                  if ( defined( $rmax_move->{$ng} )
                    && $move > $rmax_move->{$ng}
                    && !$is_good_alignment_token{$raw_tok} );

                $line->increase_field_width( $itok, $move );
            }
            elsif ( $move < 0 ) {

                # spot to take special action on failure to move
            }
            else {
                ##ok: (move==0)
            }
        }
        return;
    } ## end sub move_to_common_column

    sub do_left_to_right_sweep {

        my ($rcall_hash) = @_;

        # This is the worker routine for sub 'sweep_left_to_right'. Make
        # vertical alignments by sweeping from left to right over groups
        # of lines which have been located and prepared by the caller.

        my $rlines      = $rcall_hash->{rlines};
        my $rgroups     = $rcall_hash->{rgroups};
        my $rtodo       = $rcall_hash->{rtodo};
        my $rmax_move   = $rcall_hash->{rmax_move};
        my $short_pad   = $rcall_hash->{short_pad};
        my $group_level = $rcall_hash->{group_level};

        # $blocking_level[$nj is the level at a match failure between groups
        # $ng-1 and $ng
        my @blocking_level;
        my $group_list_type = $rlines->[0]->{'list_type'};

        foreach my $task ( @{$rtodo} ) {
            my ( $itok, $ng_beg, $ng_end, $raw_tok, $lev ) = @{$task};

            # Nothing to do for a single group
            next if ( $ng_end <= $ng_beg );

            my $ng_first;  # index of the first group of a continuous sequence
            my $col_want;  # the common alignment column of a sequence of groups
            my $col_limit; # maximum column before bumping into max line length
            my $line_count_ng_m = 0;
            my $jmax_m;
            my $it_stop_m;

            # Loop over the groups
            # 'ix_' = index in the array of lines
            # 'ng_' = index in the array of groups
            # 'it_' = index in the array of tokens
            my $ix_min      = $rgroups->[$ng_beg]->[0];
            my $ix_max      = $rgroups->[$ng_end]->[1];
            my $lines_total = $ix_max - $ix_min + 1;
            foreach my $ng ( $ng_beg .. $ng_end ) {
                my ( $ix_beg, $ix_end, $it_stop ) = @{ $rgroups->[$ng] };
                my $line_count_ng = $ix_end - $ix_beg + 1;

                # Important: note that since all lines in a group have a common
                # alignments object, we just have to work on one of the lines
                # (the first line).  All of the rest will be changed
                # automatically.
                my $line = $rlines->[$ix_beg];
                my $jmax = $line->{'jmax'};

                # the maximum space without exceeding the line length:
                my $avail   = $line->get_available_space_on_right();
                my $col     = $line->get_column($itok);
                my $col_max = $col + $avail;

                # Initialize on first group
                if ( !defined($col_want) ) {
                    $ng_first        = $ng;
                    $col_want        = $col;
                    $col_limit       = $col_max;
                    $line_count_ng_m = $line_count_ng;
                    $jmax_m          = $jmax;
                    $it_stop_m       = $it_stop;
                    next;
                }

                # RULE: Throw a blocking flag upon encountering a token level
                # different from the level of the first blocking token.  For
                # example, in the following example, if the = matches get
                # blocked between two groups as shown, then we want to start
                # blocking matches at the commas, which are at deeper level, so
                # that we do not get the big gaps shown here:

                #  my $unknown3 = pack( "v",          -2 );
                #  my $unknown4 = pack( "v",          0x09 );
                #  my $unknown5 = pack( "VVV",        0x06, 0x00, 0x00 );
                #  my $num_bbd_blocks  = pack( "V",   $num_lists );
                #  my $root_startblock = pack( "V",   $root_start );
                #  my $unknown6        = pack( "VV",  0x00, 0x1000 );

                # On the other hand, it is okay to keep matching at the same
                # level such as in a simple list of commas and/or fat commas.

                my $is_blocked = defined( $blocking_level[$ng] )
                  && $lev > $blocking_level[$ng];

                # TAIL-WAG-DOG RULE: prevent a 'tail-wag-dog' syndrome, meaning:
                # Do not let one or two lines with a **different number of
                # alignments** open up a big gap in a large block.  For
                # example, we will prevent something like this, where the first
                # line pries open the rest:

            #  $worksheet->write( "B7", "http://www.perl.com", undef, $format );
            #  $worksheet->write( "C7", "",                    $format );
            #  $worksheet->write( "D7", "",                    $format );
            #  $worksheet->write( "D8", "",                    $format );
            #  $worksheet->write( "D8", "",                    $format );

                # We should exclude from consideration two groups which are
                # effectively the same but separated because one does not
                # fit in the maximum allowed line length.
                my $is_same_group =
                  $jmax == $jmax_m && $it_stop_m == $jmax_m - 2;

                my $lines_above = $ix_beg - $ix_min;
                my $lines_below = $lines_total - $lines_above;

                # Increase the tolerable gap for certain favorable factors
                my $factor    = 1;
                my $top_level = $lev == $group_level;

                # Align best top level alignment tokens like '=', 'if', ...
                # A factor of 10 allows a gap of up to 40 spaces
                if ( $top_level && $is_good_alignment_token{$raw_tok} ) {
                    $factor = 10;
                }

                # Otherwise allow some minimal padding of good alignments
                else {

                    if (

                        defined( $is_good_alignment_token{$raw_tok} )

                        # We have to be careful if there are just 2 lines.
                        # This two-line factor allows large gaps only for 2
                        # lines which are simple lists with fewer items on the
                        # second line. It gives results similar to previous
                        # versions of perltidy.
                        && (
                            $lines_total > 2
                            || (   $group_list_type
                                && $jmax < $jmax_m
                                && $top_level )
                        )
                      )
                    {
                        $factor += 1;
                        if ($top_level) {
                            $factor += 1;
                        }
                    }
                }

                my $is_big_gap;
                if ( !$is_same_group ) {
                    $is_big_gap ||=
                      (      $lines_above == 1
                          || $lines_above == 2 && $lines_below >= 4 )
                      && $col_want > $col + $short_pad * $factor;
                    $is_big_gap ||=
                      (      $lines_below == 1
                          || $lines_below == 2 && $lines_above >= 4 )
                      && $col > $col_want + $short_pad * $factor;
                }

                # if match is limited by gap size, stop aligning at this level
                if ($is_big_gap) {
                    $blocking_level[$ng] = $lev - 1;
                }

                # quit and restart if it cannot join this batch
                if (   $col_want > $col_max
                    || $col > $col_limit
                    || $is_big_gap
                    || $is_blocked )
                {

                    # remember the level of the first blocking token
                    if ( !defined( $blocking_level[$ng] ) ) {
                        $blocking_level[$ng] = $lev;
                    }

                    move_to_common_column(
                        {
                            rlines    => $rlines,
                            rgroups   => $rgroups,
                            rmax_move => $rmax_move,
                            ngb       => $ng_first,
                            nge       => $ng - 1,
                            itok      => $itok,
                            col_want  => $col_want,
                            raw_tok   => $raw_tok,
                        }
                    );
                    $ng_first        = $ng;
                    $col_want        = $col;
                    $col_limit       = $col_max;
                    $line_count_ng_m = $line_count_ng;
                    $jmax_m          = $jmax;
                    $it_stop_m       = $it_stop;
                    next;
                }

                $line_count_ng_m += $line_count_ng;

                # update the common column and limit
                if ( $col > $col_want )      { $col_want  = $col }
                if ( $col_max < $col_limit ) { $col_limit = $col_max }

            } ## end loop over groups

            if ( $ng_end > $ng_first ) {
                move_to_common_column(
                    {
                        rlines    => $rlines,
                        rgroups   => $rgroups,
                        rmax_move => $rmax_move,
                        ngb       => $ng_first,
                        nge       => $ng_end,
                        itok      => $itok,
                        col_want  => $col_want,
                        raw_tok   => $raw_tok,
                    }
                );
            }
        } ## end loop over tasks

        return;
    } ## end sub do_left_to_right_sweep
}

sub delete_selected_tokens {

    my ( $line_obj, $ridel ) = @_;

    # Given:
    #   $line_obj = the line to be modified
    #   $ridel    = a ref to list of indexes to be deleted

    # remove unused alignment token(s) to improve alignment chances

    return if ( !defined($line_obj) || !defined($ridel) || !@{$ridel} );

    my $jmax_old           = $line_obj->{'jmax'};
    my $rfields_old        = $line_obj->{'rfields'};
    my $rfield_lengths_old = $line_obj->{'rfield_lengths'};
    my $rpatterns_old      = $line_obj->{'rpatterns'};
    my $rtokens_old        = $line_obj->{'rtokens'};
    my $j_terminal_match   = $line_obj->{'j_terminal_match'};

    use constant EXPLAIN_DELETE_SELECTED => 0;

    local $LIST_SEPARATOR = '> <';
    EXPLAIN_DELETE_SELECTED && print <<EOM;
delete indexes: <@{$ridel}>
old jmax: $jmax_old
old tokens: <@{$rtokens_old}>
old patterns: <@{$rpatterns_old}>
old fields: <@{$rfields_old}>
old field_lengths: <@{$rfield_lengths_old}>
EOM

    my $rfields_new        = [];
    my $rpatterns_new      = [];
    my $rtokens_new        = [];
    my $rfield_lengths_new = [];

    # Convert deletion list to a hash to allow any order, multiple entries,
    # and avoid problems with index values out of range
    my %delete_me;
    @delete_me{ @{$ridel} } = (1) x scalar( @{$ridel} );

    my $pattern_0      = $rpatterns_old->[0];
    my $field_0        = $rfields_old->[0];
    my $field_length_0 = $rfield_lengths_old->[0];
    push @{$rfields_new},        $field_0;
    push @{$rfield_lengths_new}, $field_length_0;
    push @{$rpatterns_new},      $pattern_0;

    # Loop to either copy items or concatenate fields and patterns
    my $jmin_del;
    foreach my $j ( 0 .. $jmax_old - 1 ) {
        my $token        = $rtokens_old->[$j];
        my $field        = $rfields_old->[ $j + 1 ];
        my $field_length = $rfield_lengths_old->[ $j + 1 ];
        my $pattern      = $rpatterns_old->[ $j + 1 ];
        if ( !$delete_me{$j} ) {
            push @{$rtokens_new},        $token;
            push @{$rfields_new},        $field;
            push @{$rpatterns_new},      $pattern;
            push @{$rfield_lengths_new}, $field_length;
        }
        else {
            if ( !defined($jmin_del) ) { $jmin_del = $j }
            $rfields_new->[-1] .= $field;
            $rfield_lengths_new->[-1] += $field_length;
            $rpatterns_new->[-1] .= $pattern;
        }
    }

    # ----- x ------ x ------ x ------
    #t      0        1        2        <- token indexing
    #f   0      1        2        3    <- field and pattern

    my $jmax_new = @{$rfields_new} - 1;
    $line_obj->{'rtokens'}        = $rtokens_new;
    $line_obj->{'rpatterns'}      = $rpatterns_new;
    $line_obj->{'rfields'}        = $rfields_new;
    $line_obj->{'rfield_lengths'} = $rfield_lengths_new;
    $line_obj->{'jmax'}           = $jmax_new;

    # The value of j_terminal_match will be incorrect if we delete tokens prior
    # to it. We will have to give up on aligning the terminal tokens if this
    # happens.
    if ( defined($j_terminal_match) && $jmin_del <= $j_terminal_match ) {
        $line_obj->{'j_terminal_match'} = undef;
    }

    # update list type -
    if ( $line_obj->{'list_seqno'} ) {

        ## This works, but for efficiency see if we need to make a change:
        ## decide_if_list($line_obj);

        # An existing list will still be a list but with possibly different
        # leading token
        my $old_list_type = $line_obj->{'list_type'};
        my $new_list_type = EMPTY_STRING;
        if ( $rtokens_new->[0] =~ /^(=>|,)/ ) {
            $new_list_type = $rtokens_new->[0];
        }
        if ( !$old_list_type || $old_list_type ne $new_list_type ) {
            decide_if_list($line_obj);
        }
    }

    EXPLAIN_DELETE_SELECTED && print <<EOM;

new jmax: $jmax_new
new tokens: <@{$rtokens_new}>
new patterns: <@{$rpatterns_new}>
new fields: <@{$rfields_new}>
EOM
    return;
} ## end sub delete_selected_tokens

{    ## closure for sub decode_alignment_token

    # This routine is called repeatedly for each token, so it needs to be
    # efficient.  We can speed things up by remembering the inputs and outputs
    # in a hash.
    my %decoded_token;

    sub initialize_decode {

        # We will re-initialize the hash for each file. Otherwise, there is
        # a danger that the hash can become arbitrarily large if a very large
        # number of files is processed at once.
        %decoded_token = ();
        return;
    } ## end sub initialize_decode

    sub decode_alignment_token {

        my ($tok) = @_;

        # Unpack the values packed in an alignment token

        # Given:
        #   $tok = an alignment token
        # Returns:
        #   ( $raw_tok, $lev, $tag, $tok_count )
        #
        # Usage:
        #        my ( $raw_tok, $lev, $tag, $tok_count ) =
        #          decode_alignment_token($token);

        # Alignment tokens have a trailing decimal level and optional tag (for
        # commas):
        # For example, the first comma in the following line
        #     sub banner  { crlf; report( shift, '/', shift ); crlf }
        # is decorated as follows:
        #    ,2+report-6  => (tok,lev,tag) =qw( ,   2   +report-6)

        # An optional token count may be appended with a leading dot.
        # Currently this is only done for '=' tokens but this could change.
        # For example, consider the following line:
        #   $nport   = $port = shift || $name;
        # The first '=' may either be '=0' or '=0.1' [level 0, first equals]
        # The second '=' will be '=0.2' [level 0, second equals]

        if ( defined( $decoded_token{$tok} ) ) {
            return @{ $decoded_token{$tok} };
        }

        my ( $raw_tok, $lev, $tag, $tok_count ) = ( $tok, 0, EMPTY_STRING, 1 );
        if ( $tok =~ /^(\D+)(\d+)([^\.]*)(\.(\d+))?$/ ) {
            $raw_tok   = $1;
            $lev       = $2;
            $tag       = $3 if ($3);
            $tok_count = $5 if ($5);
        }
        my @vals = ( $raw_tok, $lev, $tag, $tok_count );
        $decoded_token{$tok} = \@vals;
        return @vals;
    } ## end sub decode_alignment_token
}

sub delete_unmatched_tokens {
    my ( $rlines, $group_level ) = @_;

    # Remove as many obviously un-needed alignment tokens as possible.
    # This will prevent them from interfering with the final alignment.

    # Given:
    #   $rlines = ref to hash of all lines in this alignment group
    #   $group_level = their comment indentation level

    # Return:
    my $max_lev_diff      = 0;    # used to avoid a call to prune_tree
    my $saw_side_comment  = 0;    # used to avoid a call for side comments
    my $saw_signed_number = 0;    # used to avoid a call for -vsn

    # Handle no lines -- shouldn't happen
    return unless @{$rlines};

    # Handle a single line
    if ( @{$rlines} == 1 ) {
        my $line   = $rlines->[0];
        my $jmax   = $line->{'jmax'};
        my $length = $line->{'rfield_lengths'}->[$jmax];
        $saw_side_comment = $length > 0;
        return ( $max_lev_diff, $saw_side_comment, $saw_signed_number );
    }

    # ignore hanging side comments in these operations
    my @filtered   = grep { !$_->{'is_hanging_side_comment'} } @{$rlines};
    my $rnew_lines = \@filtered;

    $saw_side_comment = @filtered != @{$rlines};
    $max_lev_diff     = 0;

    # nothing to do if all lines were hanging side comments
    my $jmax = @{$rnew_lines} - 1;
    return ( $max_lev_diff, $saw_side_comment, $saw_signed_number )
      if ( $jmax < 0 );

    #----------------------------------------------------
    # Create a hash of alignment token info for each line
    #----------------------------------------------------
    ( my $rline_hashes, my $requals_info, $saw_side_comment, $max_lev_diff ) =
      make_alignment_info( $group_level, $rnew_lines, $saw_side_comment );

    #------------------------------------------------------------
    # Find independent subgroups of lines.  Neighboring subgroups
    # do not have a common alignment token.
    #------------------------------------------------------------
    my @subgroups;
    push @subgroups, [ 0, $jmax ];
    foreach my $jl ( 0 .. $jmax - 1 ) {
        if ( $rnew_lines->[$jl]->{'end_group'} ) {
            $subgroups[-1]->[1] = $jl;
            push @subgroups, [ $jl + 1, $jmax ];
        }
    }

    #-----------------------------------------------------------
    # PASS 1 over subgroups to remove unmatched alignment tokens
    #-----------------------------------------------------------
    delete_unmatched_tokens_main_loop(
        $group_level,  $rnew_lines, \@subgroups,
        $rline_hashes, $requals_info
    );

    #----------------------------------------------------------------
    # PASS 2: Construct a tree of matched lines and delete some small
    # deeper levels of tokens.  They also block good alignments.
    #----------------------------------------------------------------
    prune_alignment_tree($rnew_lines) if ($max_lev_diff);

    #--------------------------------------------
    # PASS 3: compare all lines for common tokens
    #--------------------------------------------
    $saw_signed_number =
      match_line_pairs( $rlines, $rnew_lines, \@subgroups, $group_level );

    return ( $max_lev_diff, $saw_side_comment, $saw_signed_number );
} ## end sub delete_unmatched_tokens

sub make_alignment_info {

    my ( $group_level, $rnew_lines, $saw_side_comment ) = @_;

    # Create a hash of alignment token info for each line
    # This info will be used to find common alignments

    # Given:
    #   $group_level = common indentation level
    #   $rnew_lines = ref to hash of line info
    #   $saw_side_comment = true if there is a side comment
    # Return:
    #   $rline_hashes = ref to hash with new line vars
    #  \@equals_info  = ref to array with info on any '=' tokens
    #   $saw_side_comment = updated side comment flag
    #   $max_lev_diff = maximum level change seen

    #----------------
    # Loop over lines
    #----------------
    my $rline_hashes = [];
    my @equals_info;
    my @line_info;    # no longer used
    my $jmax         = @{$rnew_lines} - 1;
    my $max_lev_diff = 0;
    foreach my $line ( @{$rnew_lines} ) {
        my $rhash     = {};
        my $rtokens   = $line->{'rtokens'};
        my $rpatterns = $line->{'rpatterns'};
        my $i         = 0;
        my ( $i_eq, $tok_eq, $pat_eq );
        my ( $lev_min, $lev_max );
        foreach my $tok ( @{$rtokens} ) {
            my ( $raw_tok, $lev, $tag, $tok_count ) =
              decode_alignment_token($tok);

            if ( $tok ne '#' ) {
                if ( !defined($lev_min) ) {
                    $lev_min = $lev;
                    $lev_max = $lev;
                }
                else {
                    if ( $lev < $lev_min ) { $lev_min = $lev }
                    if ( $lev > $lev_max ) { $lev_max = $lev }
                }
            }
            else {
                if ( !$saw_side_comment ) {
                    my $length = $line->{'rfield_lengths'}->[ $i + 1 ];
                    $saw_side_comment ||= $length;
                }
            }

            # Possible future upgrade: for multiple matches,
            # record [$i1, $i2, ..] instead of $i
            $rhash->{$tok} =
              [ $i, undef, undef, $raw_tok, $lev, $tag, $tok_count ];

            # remember the first equals at line level
            if ( !defined($i_eq) && $raw_tok eq '=' ) {

                if ( $lev eq $group_level ) {
                    $i_eq   = $i;
                    $tok_eq = $tok;
                    $pat_eq = $rpatterns->[$i];
                }
            }
            $i++;
        }
        push @{$rline_hashes}, $rhash;
        push @equals_info,     [ $i_eq,    $tok_eq, $pat_eq ];
        push @line_info,       [ $lev_min, $lev_max ];
        if ( defined($lev_min) ) {
            my $lev_diff = $lev_max - $lev_min;
            if ( $lev_diff > $max_lev_diff ) { $max_lev_diff = $lev_diff }
        }
    }

    #----------------------------------------------------
    # Loop to compare each line pair and remember matches
    #----------------------------------------------------
    my $rtok_hash = {};
    my $nr        = 0;
    foreach my $jl ( 0 .. $jmax - 1 ) {
        my $nl = $nr;
        $nr = 0;
        my $jr      = $jl + 1;
        my $rhash_l = $rline_hashes->[$jl];
        my $rhash_r = $rline_hashes->[$jr];
        foreach my $tok ( keys %{$rhash_l} ) {
            if ( defined( $rhash_r->{$tok} ) ) {
                my $il = $rhash_l->{$tok}->[0];
                my $ir = $rhash_r->{$tok}->[0];
                $rhash_l->{$tok}->[2] = $ir;
                $rhash_r->{$tok}->[1] = $il;
                if ( $tok ne '#' ) {
                    push @{ $rtok_hash->{$tok} }, ( $jl, $jr );
                    $nr++;
                }
            }
        }

        # Set a line break if no matching tokens between these lines
        # (this is not strictly necessary now but does not hurt)
        if ( $nr == 0 && $nl > 0 ) {
            $rnew_lines->[$jl]->{'end_group'} = 1;
        }

        # Also set a line break if both lines have simple equals but with
        # different leading characters in patterns.  This check is similar
        # to one in sub check_match, and will prevent sub
        # prune_alignment_tree from removing alignments which otherwise
        # should be kept. This fix is rarely needed, but it can
        # occasionally improve formatting.
        # For example:
        #     my $name = $this->{Name};
        #     $type = $this->ctype($genlooptype) if defined $genlooptype;
        #     my $declini = ( $asgnonly ? ""          : "\t$type *" );
        #     my $cast    = ( $type     ? "($type *)" : "" );
        # The last two lines start with 'my' and will not match the
        # previous line starting with $type, so we do not want
        # prune_alignment tree to delete their ? : alignments at a deeper
        # level.
        my ( $i_eq_l, $tok_eq_l, $pat_eq_l ) = @{ $equals_info[$jl] };
        my ( $i_eq_r, $tok_eq_r, $pat_eq_r ) = @{ $equals_info[$jr] };
        if ( defined($i_eq_l) && defined($i_eq_r) ) {

            # Also, do not align equals across a change in ci level
            my $ci_jump = $rnew_lines->[$jl]->{'ci_level'} !=
              $rnew_lines->[$jr]->{'ci_level'};

            if (
                   $tok_eq_l eq $tok_eq_r
                && $i_eq_l == 0
                && $i_eq_r == 0
                && ( substr( $pat_eq_l, 0, 1 ) ne substr( $pat_eq_r, 0, 1 )
                    || $ci_jump )
              )
            {
                $rnew_lines->[$jl]->{'end_group'} = 1;
            }
        }
    }
    return ( $rline_hashes, \@equals_info, $saw_side_comment, $max_lev_diff );
} ## end sub make_alignment_info

sub delete_unmatched_tokens_main_loop {

    my ( $group_level, $rnew_lines, $rsubgroups, $rline_hashes, $requals_info )
      = @_;

    #--------------------------------------------------------------
    # Main loop over subgroups to remove unmatched alignment tokens
    #--------------------------------------------------------------

    # flag to allow skipping pass 2 - not currently used
    my $saw_large_group;

    my $has_terminal_match = $rnew_lines->[-1]->{'j_terminal_match'};

    foreach my $item ( @{$rsubgroups} ) {
        my ( $jbeg, $jend ) = @{$item};

        my $nlines = $jend - $jbeg + 1;

        #---------------------------------------------------
        # Look for complete if/elsif/else and ternary blocks
        #---------------------------------------------------

        # We are looking for a common '$dividing_token' like these:

        #    if    ( $b and $s ) { $p->{'type'} = 'a'; }
        #    elsif ($b)          { $p->{'type'} = 'b'; }
        #    elsif ($s)          { $p->{'type'} = 's'; }
        #    else                { $p->{'type'} = ''; }
        #                        ^----------- dividing_token

        #   my $severity =
        #      !$routine                     ? '[PFX]'
        #     : $routine =~ /warn.*_d\z/     ? '[DS]'
        #     : $routine =~ /ck_warn/        ? 'W'
        #     : $routine =~ /ckWARN\d*reg_d/ ? 'S'
        #     : $routine =~ /ckWARN\d*reg/   ? 'W'
        #     : $routine =~ /vWARN\d/        ? '[WDS]'
        #     :                                '[PFX]';
        #                                    ^----------- dividing_token

        # Only look for groups which are more than 2 lines long.  Two lines
        # can get messed up doing this, probably due to the various
        # two-line rules.

        my $dividing_token;
        my %token_line_count;
        if ( $nlines > 2 ) {

            foreach my $jj ( $jbeg .. $jend ) {
                my %seen;
                my $line    = $rnew_lines->[$jj];
                my $rtokens = $line->{'rtokens'};
                foreach my $tok ( @{$rtokens} ) {
                    if ( !$seen{$tok} ) {
                        $seen{$tok}++;
                        $token_line_count{$tok}++;
                    }
                }
            }

            foreach my $tok ( keys %token_line_count ) {
                if ( $token_line_count{$tok} == $nlines ) {
                    if (   substr( $tok, 0, 1 ) eq '?'
                        || substr( $tok, 0, 1 ) eq '{' && $tok =~ /^\{\d+if/ )
                    {
                        $dividing_token = $tok;
                        last;
                    }
                }
            }
        }

        #-------------------------------------------------------------
        # Loop over subgroup lines to remove unwanted alignment tokens
        #-------------------------------------------------------------
        foreach my $jj ( $jbeg .. $jend ) {
            my $line    = $rnew_lines->[$jj];
            my $rtokens = $line->{'rtokens'};
            my $rhash   = $rline_hashes->[$jj];
            my $i_eq    = $requals_info->[$jj]->[0];
            my @idel;
            my $imax = @{$rtokens} - 2;
            my $delete_above_level;
            my $deleted_assignment_token;

            my $saw_dividing_token = EMPTY_STRING;
            $saw_large_group ||= $nlines > 2 && $imax > 1;

            # Loop over all alignment tokens
            foreach my $i ( 0 .. $imax ) {
                my $tok = $rtokens->[$i];
                next if ( $tok eq '#' );    # shouldn't happen
                my ( $iii_uu, $il, $ir, $raw_tok, $lev, $tag_uu, $tok_count ) =
                  @{ $rhash->{$tok} };

                #------------------------------------------------------
                # Here is the basic RULE: remove an unmatched alignment
                # which does not occur in the surrounding lines.
                #------------------------------------------------------
                my $delete_me = !defined($il) && !defined($ir);

                # Apply any user controls. Note that not all lines pass
                # this way so they have to be applied elsewhere too.
                my $align_ok = 1;
                if (%valign_control_hash) {
                    $align_ok = $valign_control_hash{$raw_tok};
                    $align_ok = $valign_control_default
                      unless defined($align_ok);
                    $delete_me ||= !$align_ok;
                }

                # But now we modify this with exceptions...

                # EXCEPTION 1: If we are in a complete ternary or
                # if/elsif/else group, and this token is not on every line
                # of the group, should we delete it to preserve overall
                # alignment?
                if ($dividing_token) {
                    if ( $token_line_count{$tok} >= $nlines ) {
                        $saw_dividing_token ||= $tok eq $dividing_token;
                    }
                    else {

                        # For shorter runs, delete toks to save alignment.
                        # For longer runs, keep toks after the '{' or '?'
                        # to allow sub-alignments within braces.  The
                        # number 5 lines is arbitrary but seems to work ok.
                        $delete_me ||= ( $nlines < 5 || !$saw_dividing_token );
                    }
                }

                # EXCEPTION 2: Remove all tokens above a certain level
                # following a previous deletion.  For example, we have to
                # remove tagged higher level alignment tokens following a
                # '=>' deletion because the tags of higher level tokens
                # will now be incorrect. For example, this will prevent
                # aligning commas as follows after deleting the second '=>'
                #    $w->insert(
                #         ListBox => origin => [ 270, 160 ],
                #         size    => [ 200,           55 ],
                #    );
                if ( defined($delete_above_level) ) {
                    if ( $lev > $delete_above_level ) {
                        $delete_me ||= 1;
                    }
                    else { $delete_above_level = undef }
                }

                # EXCEPTION 3: Remove all but certain tokens after an
                # assignment deletion.
                if (
                    $deleted_assignment_token
                    && ( $lev > $group_level
                        || !$is_if_or{$raw_tok} )
                  )
                {
                    $delete_me ||= 1;
                }

                # EXCEPTION 4: Do not touch the first line of a 2 line
                # terminal match, such as below, because j_terminal has
                # already been set.
                #    if ($tag) { $tago = "<$tag>"; $tagc = "</$tag>"; }
                #    else      { $tago = $tagc = ''; }
                # But see snippets 'else1.t' and 'else2.t'
                $delete_me = 0
                  if ( $jj == $jbeg
                    && $has_terminal_match
                    && $nlines == 2 );

                # EXCEPTION 5: misc additional rules for commas and equals
                if ( $delete_me && $tok_count == 1 ) {

                    # okay to delete second and higher copies of a token

                    # for a comma...
                    if ( $raw_tok eq ',' ) {

                        # Do not delete commas before an equals
                        $delete_me = 0
                          if ( defined($i_eq) && $i < $i_eq );

                        # Do not delete line-level commas
                        $delete_me = 0 if ( $lev <= $group_level );
                    }

                    # For an assignment at group level..
                    if (   $is_assignment{$raw_tok}
                        && $lev == $group_level )
                    {

                        # Do not delete if it is the last alignment of
                        # multiple tokens; this will prevent some
                        # undesirable alignments
                        if ( $imax > 0 && $i == $imax ) {
                            $delete_me = 0;
                        }

                        # Otherwise, set a flag to delete most
                        # remaining tokens
                        else { $deleted_assignment_token = $raw_tok }
                    }
                }

                # Do not let a user exclusion be reactivated by above rules
                $delete_me ||= !$align_ok;

                #------------------------------------
                # Add this token to the deletion list
                #------------------------------------
                if ($delete_me) {
                    push @idel, $i;

                    # update deletion propagation flags
                    if ( !defined($delete_above_level)
                        || $lev < $delete_above_level )
                    {

                        # delete all following higher level alignments
                        $delete_above_level = $lev;

                        # but keep deleting after => to next lower level
                        # to avoid some bizarre alignments
                        if ( $raw_tok eq '=>' ) {
                            $delete_above_level = $lev - 1;
                        }
                    }
                }
            }    # End loop over alignment tokens

            # Process all deletion requests for this line
            if (@idel) {
                delete_selected_tokens( $line, \@idel );
            }
        }    # End loop over lines
    } ## end main loop over subgroups

    return;
} ## end sub delete_unmatched_tokens_main_loop

sub match_line_pairs {
    my ( $rlines, $rnew_lines, $rsubgroups, $group_level ) = @_;

    # Compare each pair of lines and save information about common matches

    # Given:
    #   $rlines     = list of lines including hanging side comments
    #   $rnew_lines = list of lines without any hanging side comments
    #   $rsubgroups = list of subgroups of the new lines
    # Return:
    #   $saw_signed_number = true if a field has a signed number
    #                        (needed for --valign-signed-numbers)

    # TODO:
    # Maybe change: imax_pair => pair_match_info = ref to array
    #  = [$imax_align, $rMsg, ... ]
    #  This may eventually have multi-level match info

    # Previous line vars
    my ( $line_m, $rtokens_m, $rpatterns_m, $rfield_lengths_m, $imax_m,
        $list_type_m, $ci_level_m );

    # Current line vars
    my ( $line, $rtokens, $rpatterns, $rfield_lengths, $imax, $list_type,
        $ci_level );

    # Return parameter to avoid calls to sub pad_signed_number_columns
    my $saw_signed_number;

    # loop over subgroups
    foreach my $item ( @{$rsubgroups} ) {
        my ( $jbeg, $jend ) = @{$item};
        my $nlines = $jend - $jbeg + 1;
        next if ( $nlines <= 1 );

        # loop over lines in a subgroup
        foreach my $jj ( $jbeg .. $jend ) {

            $line_m           = $line;
            $rtokens_m        = $rtokens;
            $rpatterns_m      = $rpatterns;
            $rfield_lengths_m = $rfield_lengths;
            $imax_m           = $imax;
            $list_type_m      = $list_type;
            $ci_level_m       = $ci_level;

            $line           = $rnew_lines->[$jj];
            $rtokens        = $line->{'rtokens'};
            $rpatterns      = $line->{'rpatterns'};
            $rfield_lengths = $line->{'rfield_lengths'};
            $imax           = @{$rtokens} - 2;
            $list_type      = $line->{'list_type'};
            $ci_level       = $line->{'ci_level'};

            # Quick approximate check for signed numbers in this line.
            # This speeds up large runs by about 0.5%
            if ( !$saw_signed_number ) {

                my $rfields = $line->{'rfields'};
                foreach my $i ( 0 .. $imax + 1 ) {
                    next if ( index( $rpatterns->[$i], 'n' ) < 0 );
                    my $field = $rfields->[$i];
                    if (   index( $field, '-' ) >= 0
                        || index( $field, '+' ) >= 0 )
                    {
                        $saw_signed_number = 1;
                        last;
                    }
                }
            }

            # nothing to do for first line
            next if ( $jj == $jbeg );

            my $ci_jump = $ci_level - $ci_level_m;

            my $imax_min = $imax_m < $imax ? $imax_m : $imax;

            my $imax_align = -1;

            # find number of leading common tokens

            #---------------------------------
            # No match to hanging side comment
            #---------------------------------
            if ( $line->{'is_hanging_side_comment'} ) {

                # Should not get here; HSC's have been filtered out
                $imax_align = -1;
            }

            #-----------------------------
            # Handle comma-separated lists
            #-----------------------------
            elsif ( $list_type && $list_type eq $list_type_m ) {

                # do not align lists across a ci jump with new list method
                if ($ci_jump) { $imax_min = -1 }

                my $i_nomatch = $imax_min + 1;
                foreach my $i ( 0 .. $imax_min ) {
                    my $tok   = $rtokens->[$i];
                    my $tok_m = $rtokens_m->[$i];
                    if ( $tok ne $tok_m ) {
                        $i_nomatch = $i;
                        last;
                    }
                }

                $imax_align = $i_nomatch - 1;
            }

            #-----------------
            # Handle non-lists
            #-----------------
            else {
                my $i_nomatch = $imax_min + 1;
                foreach my $i ( 0 .. $imax_min ) {
                    my $tok   = $rtokens->[$i];
                    my $tok_m = $rtokens_m->[$i];
                    if ( $tok ne $tok_m ) {
                        $i_nomatch = $i;
                        last;
                    }

                    my $pat   = $rpatterns->[$i];
                    my $pat_m = $rpatterns_m->[$i];

                    # VSN PATCH: allow numbers to match quotes
                    if ( $pat_m ne $pat ) {
                        $pat   =~ tr/n/Q/;
                        $pat_m =~ tr/n/Q/;
                    }

                    # If patterns don't match, we have to be careful...
                    if ( $pat_m ne $pat ) {
                        my $pad =
                          $rfield_lengths->[$i] - $rfield_lengths_m->[$i];
                        my $match_code = compare_patterns(
                            {
                                group_level => $group_level,
                                tok         => $tok,
                                tok_m       => $tok_m,
                                pat         => $pat,
                                pat_m       => $pat_m,
                                pad         => $pad,
                            }
                        );
                        if ($match_code) {
                            if    ( $match_code == 1 ) { $i_nomatch = $i }
                            elsif ( $match_code == 2 ) { $i_nomatch = 0 }
                            else                       { }                  ##ok
                            last;
                        }
                    }
                }
                $imax_align = $i_nomatch - 1;
            }

            $line_m->{'imax_pair'} = $imax_align;

        } ## end loop over lines

        # Put fence at end of subgroup
        $line->{'imax_pair'} = -1;

    } ## end loop over subgroups

    # if there are hanging side comments, propagate the pair info down to them
    # so that lines can just look back one line for their pair info.
    if ( @{$rlines} > @{$rnew_lines} ) {
        my $last_pair_info = -1;
        foreach my $line_t ( @{$rlines} ) {
            if ( $line_t->{'is_hanging_side_comment'} ) {
                $line_t->{'imax_pair'} = $last_pair_info;
            }
            else {
                $last_pair_info = $line_t->{'imax_pair'};
            }
        }
    }
    return $saw_signed_number;
} ## end sub match_line_pairs

sub compare_patterns {

    my ($rcall_hash) = @_;

    my $group_level = $rcall_hash->{group_level};
    my $tok         = $rcall_hash->{tok};
##  my $tok_m       = $rcall_hash->{tok_m};
    my $pat   = $rcall_hash->{pat};
    my $pat_m = $rcall_hash->{pat_m};
    my $pad   = $rcall_hash->{pad};

    # This is a helper routine for sub match_line_pairs to decide if patterns
    # in two lines match well enough
    # Given:
    #   $tok_m, $pat_m = token and pattern of first line
    #   $tok, $pat     = token and pattern of second line
    #   $pad           = 0 if no padding is needed, !=0 otherwise
    # Return code:
    #   0 = patterns match, continue
    #   1 = no match
    #   2 = no match, and lines do not match at all

    my $GoToMsg     = EMPTY_STRING;
    my $return_code = 0;

    use constant EXPLAIN_COMPARE_PATTERNS => 0;

    my ( $alignment_token, $lev, $tag_uu, $tok_count_uu ) =
      decode_alignment_token($tok);

    # We have to be very careful about aligning commas
    # when the pattern's don't match, because it can be
    # worse to create an alignment where none is needed
    # than to omit one.  Here's an example where the ','s
    # are not in named containers.  The first line below
    # should not match the next two:
    #   ( $a, $b ) = ( $b, $r );
    #   ( $x1, $x2 ) = ( $x2 - $q * $x1, $x1 );
    #   ( $y1, $y2 ) = ( $y2 - $q * $y1, $y1 );
    if ( $alignment_token eq ',' ) {

        # do not align commas unless they are in named
        # containers
        if ( $tok !~ /[A-Za-z]/ ) {
            $return_code = 1;
            $GoToMsg     = "do not align commas in unnamed containers";
        }
        else {
            $return_code = 0;
        }
    }

    # do not align parens unless patterns match;
    # large ugly spaces can occur in math expressions.
    elsif ( $alignment_token eq '(' ) {

        # But we can allow a match if the parens don't
        # require any padding.
        if ( $pad != 0 ) {
            $return_code = 1;
            $GoToMsg     = "do not align '(' unless patterns match or pad=0";
        }
        else {
            $return_code = 0;
        }
    }

    # Handle an '=' alignment with different patterns to
    # the left.
    elsif ( $alignment_token eq '=' ) {

        # It is best to be a little restrictive when
        # aligning '=' tokens.  Here is an example of
        # two lines that we will not align:
        #       my $variable=6;
        #       $bb=4;
        # The problem is that one is a 'my' declaration,
        # and the other isn't, so they're not very similar.
        # We will filter these out by comparing the first
        # letter of the pattern.  This is crude, but works
        # well enough.
        if ( substr( $pat_m, 0, 1 ) ne substr( $pat, 0, 1 ) ) {
            $GoToMsg     = "first character before equals differ";
            $return_code = 1;
        }

        # The introduction of sub 'prune_alignment_tree'
        # enabled alignment of lists left of the equals with
        # other scalar variables. For example:
        # my ( $D, $s, $e ) = @_;
        # my $d             = length $D;
        # my $c             = $e - $s - $d;

        # But this would change formatting of a lot of scripts,
        # so for now we prevent alignment of comma lists on the
        # left with scalars on the left.  We will also prevent
        # any partial alignments.

        # set return code 2 if the = is at line level, but
        # set return code 1 if the = is below line level, i.e.
        #  sub new { my ( $p, $v ) = @_; bless \$v, $p }
        #  sub iter { my ($x) = @_; return undef if $$x < 0; return $$x--; }

        elsif ( ( index( $pat_m, ',' ) >= 0 ) ne ( index( $pat, ',' ) >= 0 ) ) {
            $GoToMsg     = "mixed commas/no-commas before equals";
            $return_code = 1;
            if ( $lev eq $group_level ) {
                $return_code = 2;
            }
        }
        else {
            $return_code = 0;
        }
    }
    else {
        $return_code = 0;
    }

    EXPLAIN_COMPARE_PATTERNS
      && $return_code
      && print {*STDOUT} "no match because $GoToMsg\n";

    return $return_code;

} ## end sub compare_patterns

sub fat_comma_to_comma {
    my ($str) = @_;

    # Given:
    #  $str = a decorated fat comma alignment token

    # Change '=>' to ','
    # and remove any trailing decimal count because currently fat commas have a
    # count and commas do not.

    # For example, change '=>2+{-3.2' into ',2+{-3'
    if ( $str =~ /^=>([^\.]*)/ ) { $str = ',' . $1 }
    return $str;
} ## end sub fat_comma_to_comma

sub get_line_token_info {

    my ($rlines) = @_;

    # Given:
    #   $rlines = ref to array of lines in this group

    # Scan lines of tokens and return summary information about the range of
    # levels and patterns.

    # First scan to check monotonicity. Here is an example of several
    # lines which are monotonic. The = is the lowest level, and
    # the commas are all one level deeper. So this is not nonmonotonic.
    #  $$d{"weeks"}   = [ "w",  "wk",  "wks", "week", "weeks" ];
    #  $$d{"days"}    = [ "d",  "day", "days" ];
    #  $$d{"hours"}   = [ "h",  "hr",  "hrs", "hour", "hours" ];
    my @all_token_info;
    my $all_monotonic = 1;
    foreach my $jj ( 0 .. @{$rlines} - 1 ) {
        my ($line) = $rlines->[$jj];
        my $rtokens = $line->{'rtokens'};
        my $last_lev;
        my $is_monotonic = 1;
        my $i            = -1;
        foreach my $tok ( @{$rtokens} ) {
            $i++;
            my ( $raw_tok, $lev, $tag, $tok_count ) =
              decode_alignment_token($tok);
            push @{ $all_token_info[$jj] },
              [ $raw_tok, $lev, $tag, $tok_count ];
            last if ( $tok eq '#' );
            if ( $i > 0 && $lev < $last_lev ) { $is_monotonic = 0 }
            $last_lev = $lev;
        }
        if ( !$is_monotonic ) { $all_monotonic = 0 }
    }

    my $rline_values = [];
    foreach my $jj ( 0 .. @{$rlines} - 1 ) {
        my ($line) = $rlines->[$jj];

        my $rtokens = $line->{'rtokens'};
        my $i       = -1;
        my ( $lev_min, $lev_max );
        my $token_pattern_max = EMPTY_STRING;
        my %saw_level;
        my $is_monotonic = 1;

        # find the index of the last token before the side comment
        my $imax      = @{$rtokens} - 2;
        my $imax_true = $imax;

        # If the entire group is monotonic, and the line ends in a comma list,
        # walk it back to the first such comma. this will have the effect of
        # making all trailing ragged comma lists match in the prune tree
        # routine.  these trailing comma lists can better be handled by later
        # alignment rules.

        # Treat fat commas the same as commas here by converting them to
        # commas.  This will improve the chance of aligning the leading parts
        # of ragged lists.

        my $tok_end = fat_comma_to_comma( $rtokens->[$imax] );
        if ( $all_monotonic && $tok_end =~ /^,/ ) {
            my $ii = $imax - 1;
            while ( $ii >= 0
                && fat_comma_to_comma( $rtokens->[$ii] ) eq $tok_end )
            {
                $imax = $ii;
                $ii--;
            } ## end while ( $ii >= 0 && fat_comma_to_comma...)
        }

        # make a first pass to find level range
        my $last_lev;
        foreach my $tok ( @{$rtokens} ) {
            $i++;
            last if ( $i > $imax );
            last if ( $tok eq '#' );
            my ( $raw_tok_uu, $lev, $tag_uu, $tok_count_uu ) =
              @{ $all_token_info[$jj]->[$i] };

            last if ( $tok eq '#' );
            $token_pattern_max .= $tok;
            $saw_level{$lev}++;
            if ( !defined($lev_min) ) {
                $lev_min = $lev;
                $lev_max = $lev;
            }
            else {
                if ( $lev < $lev_min )  { $lev_min      = $lev; }
                if ( $lev > $lev_max )  { $lev_max      = $lev; }
                if ( $lev < $last_lev ) { $is_monotonic = 0 }
            }
            $last_lev = $lev;
        }

        # handle no levels
        my $rtoken_patterns = {};
        my $rtoken_indexes  = {};
        my @levs            = sort { $a <=> $b } keys %saw_level;
        if ( !defined($lev_min) ) {
            $lev_min                     = -1;
            $lev_max                     = -1;
            $levs[0]                     = -1;
            $rtoken_patterns->{$lev_min} = EMPTY_STRING;
            $rtoken_indexes->{$lev_min}  = [];
        }

        # handle one level
        elsif ( $lev_max == $lev_min ) {
            $rtoken_patterns->{$lev_max} = $token_pattern_max;
            $rtoken_indexes->{$lev_max}  = [ ( 0 .. $imax ) ];
        }

        # handle multiple levels
        else {
            $rtoken_patterns->{$lev_max} = $token_pattern_max;
            $rtoken_indexes->{$lev_max}  = [ ( 0 .. $imax ) ];

            my $lev_top = pop @levs;    # already did max level
            my $itok    = -1;
            foreach my $tok ( @{$rtokens} ) {
                $itok++;
                last if ( $itok > $imax );
                my ( $raw_tok, $lev, $tag_uu, $tok_count_uu ) =
                  @{ $all_token_info[$jj]->[$itok] };
                last if ( $raw_tok eq '#' );
                foreach my $lev_test (@levs) {
                    next if ( $lev > $lev_test );
                    $rtoken_patterns->{$lev_test} .= $tok;
                    push @{ $rtoken_indexes->{$lev_test} }, $itok;
                }
            }
            push @levs, $lev_top;
        }

        push @{$rline_values},
          [
            $lev_min,        $lev_max,      $rtoken_patterns, \@levs,
            $rtoken_indexes, $is_monotonic, $imax_true,       $imax,
          ];

        # debug
        0 && do {
            local $LIST_SEPARATOR = ')(';
            print "lev_min=$lev_min, lev_max=$lev_max, levels=(@levs)\n";
            foreach my $key ( sort keys %{$rtoken_patterns} ) {
                print "$key => $rtoken_patterns->{$key}\n";
                print "$key => @{$rtoken_indexes->{$key}}\n";
            }
        };
    } ## end loop over lines
    return ( $rline_values, $all_monotonic );
} ## end sub get_line_token_info

sub prune_alignment_tree {
    my ($rlines) = @_;

    # Given:
    #   $rlines = ref to array of lines in this group

    # Prune the tree of alignments to limit depth of alignments

    my $jmax = @{$rlines} - 1;
    return if ( $jmax <= 0 );

    # Vertical alignment in perltidy is done as an iterative process.  The
    # starting point is to mark all possible alignment tokens ('=', ',', '=>',
    # etc) for vertical alignment.  Then we have to delete all alignments
    # which, if actually made, would detract from overall alignment.  This
    # is done in several phases of which this is one.

    # In this routine we look at the alignments of a group of lines as a
    # hierarchical tree.  We will 'prune' the tree to limited depths if that
    # will improve overall alignment at the lower depths.
    # For each line we will be looking at its alignment patterns down to
    # different fixed depths. For each depth, we include all lower depths and
    # ignore all higher depths.  We want to see if we can get alignment of a
    # larger group of lines if we ignore alignments at some lower depth.
    # Here is an # example:

    # for (
    #     [ '$var',     sub { join $_, "bar" },            0, "bar" ],
    #     [ 'CONSTANT', sub { join "foo", "bar" },         0, "bar" ],
    #     [ 'CONSTANT', sub { join "foo", "bar", 3 },      1, "barfoo3" ],
    #     [ '$myvar',   sub { my $var; join $var, "bar" }, 0, "bar" ],
    # );

    # In the above example, all lines have three commas at the lowest depth
    # (zero), so if there were no other alignments, these lines would all
    # align considering only the zero depth alignment token.  But some lines
    # have additional comma alignments at the next depth, so we need to decide
    # if we should drop those to keep the top level alignments, or keep those
    # for some additional low level alignments at the expense losing some top
    # level alignments.  In this case we will drop the deeper level commas to
    # keep the entire collection aligned.  But in some cases the decision could
    # go the other way.

    # The tree for this example at the zero depth has one node containing
    # all four lines, since they are identical at zero level (three commas).
    # At depth one, there are three 'children' nodes, namely:
    # - lines 1 and 2, which have a single comma in the 'sub' at depth 1
    # - line 3, which has 2 commas at depth 1
    # - line4, which has a ';' and a ',' at depth 1
    # There are no deeper alignments in this example.
    # so the tree structure for this example is:
    #
    #    depth 0         depth 1      depth 2
    #    [lines 1-4] --  [line 1-2] -  (empty)
    #                 |  [line 3]   -  (empty)
    #                 |  [line 4]   -  (empty)

    # We can carry this to any depth, but it is not really useful to go below
    # depth 2. To cleanly stop there, we will consider depth 2 to contain all
    # alignments at depth >=2.

    use constant EXPLAIN_PRUNE => 0;

    #-------------------------------------------------------------------
    # Prune Tree Step 1. Start by scanning the lines and collecting info
    #-------------------------------------------------------------------

    # Note that the caller had this info but we have to redo this now because
    # alignment tokens may have been deleted.
    my ( $rline_values, $all_monotonic ) = get_line_token_info($rlines);

    # If all the lines have levels which increase monotonically from left to
    # right, then the sweep-left-to-right pass can do a better job of alignment
    # than pruning, and without deleting alignments.
    return if ($all_monotonic);

    # Contents of $rline_values
    #   [
    #     $lev_min,        $lev_max,      $rtoken_patterns, \@levs,
    #     $rtoken_indexes, $is_monotonic, $imax_true,       $imax,
    #   ];

    # We can work to any depth, but there is little advantage to working
    # to a a depth greater than 2
    my $MAX_DEPTH = 2;

    # This arrays will hold the tree of alignment tokens at different depths
    # for these lines.
    my @match_tree;

    # Tree nodes contain these values:
    # $match_tree[$depth] = [$jbeg, $jend, $n_parent, $level, $pattern,
    #                        $nc_beg_p, $nc_end_p, $rindexes];
    # where
    #      $depth = 0,1,2 = index of depth of the match

    #  $jbeg beginning index j of the range of lines in this match
    #  $jend ending index j of the range of lines in this match
    #  $n_parent = index of the containing group at $depth-1, if it exists
    #  $level = actual level of code being matched in this group
    #  $pattern = alignment pattern being matched
    #  $nc_beg_p = first child
    #  $nc_end_p = last child
    #  $rindexes = ref to token indexes

    # the patterns and levels of the current group being formed at each depth
    my ( @token_patterns_current, @levels_current, @token_indexes_current );

    # the patterns and levels of the next line being tested at each depth
    my ( @token_patterns_next, @levels_next, @token_indexes_next );

    #-----------------------------------------------------------
    # define a recursive worker subroutine for tree construction
    #-----------------------------------------------------------

    # This is a recursive routine which is called if a match condition changes
    # at any depth when a new line is encountered.  It ends the match node
    # which changed plus all deeper nodes attached to it.
    my $end_node;
    $end_node = sub {
        my ( $depth, $jl, $n_parent ) = @_;

        # $depth is the tree depth
        # $jl is the  index of the line
        # $n_parent is index of the parent node of this node

        return if ( $depth > $MAX_DEPTH );

        # end any current group at this depth
        if (   $jl >= 0
            && defined( $match_tree[$depth] )
            && @{ $match_tree[$depth] }
            && defined( $levels_current[$depth] ) )
        {
            $match_tree[$depth]->[-1]->[1] = $jl;
        }

        # Define the index of the node we will create below
        my $ng_self = 0;
        if ( defined( $match_tree[$depth] ) ) {
            $ng_self = @{ $match_tree[$depth] };
        }

        # end any next deeper child node(s)
        $end_node->( $depth + 1, $jl, $ng_self );

        # update the levels being matched
        $token_patterns_current[$depth] = $token_patterns_next[$depth];
        $token_indexes_current[$depth]  = $token_indexes_next[$depth];
        $levels_current[$depth]         = $levels_next[$depth];

        # Do not start a new group at this level if it is not being used
        if ( !defined( $levels_next[$depth] )
            || $depth > 0
            && $levels_next[$depth] <= $levels_next[ $depth - 1 ] )
        {
            return;
        }

        # Create a node for the next group at this depth. We initially assume
        # that it will continue to $jmax, and correct that later if the node
        # ends earlier.
        push @{ $match_tree[$depth] },
          [
            $jl + 1, $jmax, $n_parent, $levels_current[$depth],
            $token_patterns_current[$depth],
            undef, undef, $token_indexes_current[$depth],
          ];

        return;
    }; ## end $end_node = sub

    #-----------------------------------------------------
    # Prune Tree Step 2. Loop to form the tree of matches.
    #-----------------------------------------------------
    foreach my $jp ( 0 .. $jmax ) {

        # working with two adjacent line indexes, 'm'=minus, 'p'=plus
        my $jm = $jp - 1;

        # Pull out needed values for the next line
        my ( $lev_min_uu, $lev_max_uu, $rtoken_patterns, $rlevs,
            $rtoken_indexes, $is_monotonic_uu, $imax_true_uu, $imax_uu )
          = @{ $rline_values->[$jp] };

        # Transfer levels and patterns for this line to the working arrays.
        # If the number of levels differs from our chosen MAX_DEPTH ...
        # if fewer than MAX_DEPTH: leave levels at missing depths undefined
        # if more than MAX_DEPTH: set the MAX_DEPTH level to be the maximum
        @levels_next = @{$rlevs}[ 0 .. $MAX_DEPTH ];
        if ( @{$rlevs} > $MAX_DEPTH ) {
            $levels_next[$MAX_DEPTH] = $rlevs->[-1];
        }
        my $depth = 0;
        foreach my $item (@levels_next) {
            $token_patterns_next[$depth] =
              defined($item) ? $rtoken_patterns->{$item} : undef;
            $token_indexes_next[$depth] =
              defined($item) ? $rtoken_indexes->{$item} : undef;
            $depth++;
        }

        # Look for a change in match groups...

        # Initialize on the first line
        if ( $jp == 0 ) {
            my $n_parent;
            $end_node->( 0, $jm, $n_parent );
        }

        # End groups if a hard flag has been set
        elsif ( $rlines->[$jm]->{'end_group'} ) {
            my $n_parent;
            $end_node->( 0, $jm, $n_parent );
        }

        # Continue at hanging side comment
        elsif ( $rlines->[$jp]->{'is_hanging_side_comment'} ) {
            next;
        }

        # Otherwise see if anything changed and update the tree if so
        else {
            foreach my $dep ( 0 .. $MAX_DEPTH ) {

                my $def_current = defined( $token_patterns_current[$dep] );
                my $def_next    = defined( $token_patterns_next[$dep] );
                last if ( !$def_current && !$def_next );
                if (   !$def_current
                    || !$def_next
                    || $token_patterns_current[$dep] ne
                    $token_patterns_next[$dep] )
                {
                    my $n_parent;
                    if ( $dep > 0 && defined( $match_tree[ $dep - 1 ] ) ) {
                        $n_parent = @{ $match_tree[ $dep - 1 ] } - 1;
                    }
                    $end_node->( $dep, $jm, $n_parent );
                    last;
                }
            }
        }
    } ## end loop to form tree of matches

    #---------------------------------------------------------
    # Prune Tree Step 3. Make links from parent to child nodes
    #---------------------------------------------------------

    # It seemed cleaner to do this as a separate step rather than during tree
    # construction.  The children nodes have links up to the parent node which
    # created them.  Now make links in the opposite direction, so the parents
    # can find the children.  We store the range of children nodes ($nc_beg,
    # $nc_end) of each parent with two additional indexes in the original array.
    # These will be undef if no children.
    foreach my $depth ( reverse( 1 .. $MAX_DEPTH ) ) {
        next unless defined( $match_tree[$depth] );
        my $nc_max = @{ $match_tree[$depth] } - 1;
        my $np_now;
        foreach my $nc ( 0 .. $nc_max ) {
            my $np = $match_tree[$depth]->[$nc]->[2];
            if ( !defined($np) ) {

                # shouldn't happen
                #print STDERR "lost child $np at depth $depth\n";
                next;
            }
            if ( !defined($np_now) || $np != $np_now ) {
                $np_now = $np;
                $match_tree[ $depth - 1 ]->[$np]->[5] = $nc;
            }
            $match_tree[ $depth - 1 ]->[$np]->[6] = $nc;
        }
    } ## end loop to make links down to the child nodes

    EXPLAIN_PRUNE > 0 && do {
        print "Tree complete. Found these groups:\n";
        foreach my $depth ( 0 .. $MAX_DEPTH ) {
            Dump_tree_groups( \@{ $match_tree[$depth] }, "depth=$depth" );
        }
    };

    #------------------------------------------------------
    # Prune Tree Step 4. Make a list of nodes to be deleted
    #------------------------------------------------------

    #  list of lines with tokens to be deleted:
    #  [$jbeg, $jend, $level_keep]
    #  $jbeg..$jend is the range of line indexes,
    #  $level_keep is the minimum level to keep
    my @delete_list;

    # We work with a list of nodes to visit at the next deeper depth.
    my @todo_list;
    if ( defined( $match_tree[0] ) ) {
        @todo_list = ( 0 .. @{ $match_tree[0] } - 1 );
    }

    foreach my $depth ( 0 .. $MAX_DEPTH ) {
        last if ( !@todo_list );
        my @todo_next;
        foreach my $np (@todo_list) {
            my ( $jbeg_p, $jend_p, $np_p_uu, $lev_p, $pat_p_uu, $nc_beg_p,
                $nc_end_p, $rindexes_p_uu )
              = @{ $match_tree[$depth]->[$np] };
            my $nlines_p = $jend_p - $jbeg_p + 1;

            # nothing to do if no children
            next unless defined($nc_beg_p);

            # Define the number of lines to either keep or delete a child node.
            # This is the key decision we have to make.  We want to delete
            # short runs of matched lines, and keep long runs.  It seems easier
            # for the eye to follow breaks in monotonic level changes than
            # non-monotonic level changes.  For example, the following looks
            # best if we delete the lower level alignments:

            #  [1]                  ~~ [];
            #  [ ["foo"], ["bar"] ] ~~ [ qr/o/, qr/a/ ];
            #  [ qr/o/, qr/a/ ]     ~~ [ ["foo"], ["bar"] ];
            #  [ "foo", "bar" ]     ~~ [ qr/o/, qr/a/ ];
            #  [ qr/o/, qr/a/ ]     ~~ [ "foo", "bar" ];
            #  $deep1               ~~ $deep1;

            # So we will use two thresholds.
            my $nmin_mono     = $depth + 2;
            my $nmin_non_mono = $depth + 6;
            if ( $nmin_mono > $nlines_p - 1 ) {
                $nmin_mono = $nlines_p - 1;
            }
            if ( $nmin_non_mono > $nlines_p - 1 ) {
                $nmin_non_mono = $nlines_p - 1;
            }

            # loop to keep or delete each child node
            foreach my $nc ( $nc_beg_p .. $nc_end_p ) {
                my ( $jbeg_c, $jend_c, $np_c_uu, $lev_c_uu, $pat_c_uu,
                    $nc_beg_c_uu, $nc_end_c_uu )
                  = @{ $match_tree[ $depth + 1 ]->[$nc] };
                my $nlines_c     = $jend_c - $jbeg_c + 1;
                my $is_monotonic = $rline_values->[$jbeg_c]->[5];
                my $nmin         = $is_monotonic ? $nmin_mono : $nmin_non_mono;
                if ( $nlines_c < $nmin ) {
##print "deleting child, nlines=$nlines_c, nmin=$nmin\n";
                    push @delete_list, [ $jbeg_c, $jend_c, $lev_p ];
                }
                else {
##print "keeping child, nlines=$nlines_c, nmin=$nmin\n";
                    push @todo_next, $nc;
                }
            }
        }
        @todo_list = @todo_next;
    } ## end loop to mark nodes to delete

    #------------------------------------------------------------
    # Prune Tree Step 5. Loop to delete selected alignment tokens
    #------------------------------------------------------------
    foreach my $item (@delete_list) {
        my ( $jbeg, $jend, $level_keep ) = @{$item};
        foreach my $jj ( $jbeg .. $jend ) {
            my $line = $rlines->[$jj];
            my @idel;
            my $rtokens = $line->{'rtokens'};
            my $imax    = @{$rtokens} - 2;
            foreach my $i ( 0 .. $imax ) {
                my $tok = $rtokens->[$i];
                my ( $raw_tok_uu, $lev, $tag_uu, $tok_count_uu ) =
                  decode_alignment_token($tok);
                if ( $lev > $level_keep ) {
                    push @idel, $i;
                }
            }
            if (@idel) {
                delete_selected_tokens( $line, \@idel );
            }
        }
    } ## end loop to delete selected alignment tokens

    return;
} ## end sub prune_alignment_tree

sub Dump_tree_groups {
    my ( $rgroup, $msg ) = @_;

    # Debug routine
    print "$msg\n";
    local $LIST_SEPARATOR = ')(';
    foreach my $item ( @{$rgroup} ) {
        my @fix = @{$item};
        foreach my $val (@fix) { $val = "undef" unless defined($val); }
        $fix[4] = "...";
        print "(@fix)\n";
    }
    return;
} ## end sub Dump_tree_groups

# This test did not give sufficiently better results to use as an update,
# but the flag is kept as a starting point for future testing.
use constant TEST_MARGINAL_EQ_ALIGNMENT => 0;

sub is_marginal_match {

    my ( $line_0, $line_1, $group_level, $imax_align, $imax_prev ) = @_;

    # Decide if we should undo some or all of the common alignments of a
    # group of just two lines.

    # Given:
    #   $line_0 and $line_1 - the two lines
    #   $group_level = the indentation level of the group being processed
    #   $imax_align = the maximum index of the common alignment tokens
    #                 of the two lines
    #   $imax_prev  = the maximum index of the common alignment tokens
    #                 with the line before $line_0 (=-1 of does not exist)

    # Return:
    #   $is_marginal = true if the two lines should NOT be fully aligned
    #                = false if the two lines can remain fully aligned
    #   $imax_align  = the index of the highest alignment token shared by
    #                  these two lines to keep if the match is marginal.

    # When we have an alignment group of just two lines like this, we are
    # working in the twilight zone of what looks good and what looks bad.
    # This routine is a collection of rules which work have been found to
    # work fairly well, but it will need to be updated from time to time.

    my $is_marginal = 0;

    #---------------------------------------
    # Always align certain special cases ...
    #---------------------------------------
    if (

        # always keep alignments of a terminal else or ternary
        defined( $line_1->{'j_terminal_match'} )

        # always align lists
        || $line_0->{'list_type'}

        # always align hanging side comments
        || $line_1->{'is_hanging_side_comment'}

      )
    {
        return ( $is_marginal, $imax_align );
    }

    my $jmax_0    = $line_0->{'jmax'};
    my $jmax_1    = $line_1->{'jmax'};
    my $rtokens_1 = $line_1->{'rtokens'};
##  my $rtokens_0        = $line_0->{'rtokens'};
    my $rfield_lengths_0 = $line_0->{'rfield_lengths'};
    my $rfield_lengths_1 = $line_1->{'rfield_lengths'};
    my $rpatterns_0      = $line_0->{'rpatterns'};
    my $rpatterns_1      = $line_1->{'rpatterns'};
    my $imax_next        = $line_1->{'imax_pair'};

    # We will scan the alignment tokens and set a flag '$is_marginal' if
    # it seems that the an alignment would look bad.
    my $max_pad            = 0;
    my $saw_good_alignment = 0;
    my $saw_if_or;                  # if we saw an 'if' or 'or' at group level
    my $raw_tokb = EMPTY_STRING;    # first token seen at group level
    my $jfirst_bad;
    my $line_ending_fat_comma;      # is last token just a '=>' ?
    my $j0_eq_pad;
    my $j0_max_pad = 0;

    foreach my $j ( 0 .. $jmax_1 - 2 ) {
        my ( $raw_tok, $lev, $tag_uu, $tok_count_uu ) =
          decode_alignment_token( $rtokens_1->[$j] );
        if ( $raw_tok && $lev == $group_level ) {
            if ( !$raw_tokb ) { $raw_tokb = $raw_tok }
            $saw_if_or ||= $is_if_or{$raw_tok};
        }

        # When the first of the two lines ends in a bare '=>' this will
        # probably be marginal match.  (For a bare =>, the next field length
        # will be 2 or 3, depending on side comment)
        $line_ending_fat_comma =
             $j == $jmax_1 - 2
          && $raw_tok eq '=>'
          && $rfield_lengths_0->[ $j + 1 ] <= 3;

        my $pad = $rfield_lengths_1->[$j] - $rfield_lengths_0->[$j];
        if ( $j == 0 ) {
            $pad += $line_1->{'leading_space_count'} -
              $line_0->{'leading_space_count'};

            # Remember the pad at a leading equals
            if ( $raw_tok eq '=' && $lev == $group_level ) {
                $j0_eq_pad = $pad;
                $j0_max_pad =
                  0.5 * ( $rfield_lengths_1->[0] + $rfield_lengths_0->[0] );
                $j0_max_pad = 4 if ( $j0_max_pad < 4 );
            }
        }

        if ( $pad < 0 )        { $pad     = -$pad }
        if ( $pad > $max_pad ) { $max_pad = $pad }
        if ( $is_good_marginal_alignment{$raw_tok}
            && !$line_ending_fat_comma )
        {
            $saw_good_alignment = 1;
        }
        else {
            $jfirst_bad = $j unless defined($jfirst_bad);
        }
        my $pat_0 = $rpatterns_0->[$j];
        my $pat_1 = $rpatterns_1->[$j];
        if ( $pat_0 ne $pat_1 && length($pat_0) eq length($pat_1) ) {
            $pat_0 =~ tr/n/Q/;
            $pat_1 =~ tr/n/Q/;
        }
        if ( $pat_0 ne $pat_1 ) {

            # Flag this as a marginal match since patterns differ.
            # Normally, we will not allow just two lines to match if
            # marginal. But we can allow matching in some specific cases.

            $jfirst_bad  = $j if ( !defined($jfirst_bad) );
            $is_marginal = 1  if ( $is_marginal == 0 );
            if ( $raw_tok eq '=' ) {

                # Here is an example of a marginal match:
                #       $done{$$op} = 1;
                #       $op         = compile_bblock($op);
                # The left tokens are both identifiers, but
                # one accesses a hash and the other doesn't.
                # We'll let this be a tentative match and undo
                # it later if we don't find more than 2 lines
                # in the group.
                $is_marginal = 2;
            }
        }
    }

    $is_marginal = 1 if ( $is_marginal == 0 && $line_ending_fat_comma );

    # Turn off the "marginal match" flag in some cases...
    # A "marginal match" occurs when the alignment tokens agree
    # but there are differences in the other tokens (patterns).
    # If we leave the marginal match flag set, then the rule is that we
    # will align only if there are more than two lines in the group.
    # We will turn of the flag if we almost have a match
    # and either we have seen a good alignment token or we
    # just need a small pad (2 spaces) to fit.  These rules are
    # the result of experimentation.  Tokens which misaligned by just
    # one or two characters are annoying.  On the other hand,
    # large gaps to less important alignment tokens are also annoying.
    if ( $is_marginal == 1
        && ( $saw_good_alignment || $max_pad < 3 ) )
    {
        $is_marginal = 0;
    }

    # We will use the line endings to help decide on alignments...
    # See if the lines end with semicolons...
    my $sc_term0;
    my $sc_term1;
    if ( $jmax_0 < 1 || $jmax_1 < 1 ) {

        # shouldn't happen
    }
    else {
        my $pat0 = $rpatterns_0->[ $jmax_0 - 1 ];
        my $pat1 = $rpatterns_1->[ $jmax_1 - 1 ];
        $sc_term0 = $pat0 =~ /;b?$/;
        $sc_term1 = $pat1 =~ /;b?$/;
    }

    if ( !$is_marginal && !$sc_term0 ) {

        # First line of assignment should be semicolon terminated.
        # For example, do not align here:
        #  $$href{-NUM_TEXT_FILES} = $$href{-NUM_BINARY_FILES} =
        #    $$href{-NUM_DIRS} = 0;
        if ( $is_assignment{$raw_tokb} ) {
            $is_marginal = 1;
        }
    }

    # Try to avoid some undesirable alignments of opening tokens
    # for example, the space between grep and { here:
    #  return map { ( $_ => $_ ) }
    #    grep     { /$handles/ } $self->_get_delegate_method_list;
    $is_marginal ||=
         ( $raw_tokb eq '(' || $raw_tokb eq '{' )
      && $jmax_1 == 2
      && $sc_term0 ne $sc_term1;

    #---------------------------------------
    # return if this is not a marginal match
    #---------------------------------------
    if ( !$is_marginal ) {
        return ( $is_marginal, $imax_align );
    }

    # Undo the marginal match flag in certain cases,

    # Two lines with a leading equals-like operator are allowed to
    # align if the patterns to the left of the equals are the same.
    # For example the following two lines are a marginal match but have
    # the same left side patterns, so we will align the equals.
    #     my $orig = my $format = "^<<<<< ~~\n";
    #     my $abc  = "abc";
    # But these have a different left pattern so they will not be
    # aligned
    #     $xmldoc .= $`;
    #     $self->{'leftovers'} .= "<bx-seq:seq" . $';

    # First line semicolon terminated but second not, usually ok:
    #               my $want = "'ab', 'a', 'b'";
    #               my $got  = join( ", ",
    #                    map { defined($_) ? "'$_'" : "undef" }
    #                          @got );
    #  First line not semicolon terminated, Not OK to match:
    #   $$href{-NUM_TEXT_FILES} = $$href{-NUM_BINARY_FILES} =
    #      $$href{-NUM_DIRS} = 0;
    my $pat0 = $rpatterns_0->[0];
    my $pat1 = $rpatterns_1->[0];

    #---------------------------------------------------------
    # Turn off the marginal flag for some types of assignments
    #---------------------------------------------------------
    if ( $is_assignment{$raw_tokb} ) {

        # undo marginal flag if first line is semicolon terminated
        # and leading patters match
        if ($sc_term0) {    # && $sc_term1) {
            $is_marginal = $pat0 ne $pat1;
        }
    }
    elsif ( $raw_tokb eq '=>' ) {

        # undo marginal flag if patterns match
        $is_marginal = $pat0 ne $pat1 || $line_ending_fat_comma;
    }
    elsif ( $raw_tokb eq '=~' ) {

        # undo marginal flag if both lines are semicolon terminated
        # and leading patters match
        if ( $sc_term1 && $sc_term0 ) {
            $is_marginal = $pat0 ne $pat1;
        }
    }
    else {
        ##ok: (none of the above)
    }

    #-----------------------------------------------------
    # Turn off the marginal flag if we saw an 'if' or 'or'
    #-----------------------------------------------------

    # A trailing 'if' and 'or' often gives a good alignment
    # For example, we can align these:
    #  return -1     if $_[0] =~ m/^CHAPT|APPENDIX/;
    #  return $1 + 0 if $_[0] =~ m/^SECT(\d*)$/;

    # or
    #  $d_in_m[2] = 29          if ( &Date_LeapYear($y) );
    #  $d         = $d_in_m[$m] if ( $d > $d_in_m[$m] );

    if ($saw_if_or) {

        # undo marginal flag if both lines are semicolon terminated
        if ( $sc_term0 && $sc_term1 ) {
            $is_marginal = 0;
        }
    }

    # For a marginal match, only keep matches before the first 'bad' match
    if (   $is_marginal
        && defined($jfirst_bad)
        && $imax_align > $jfirst_bad - 1 )
    {
        $imax_align = $jfirst_bad - 1;
    }

    #----------------------------------------------------------
    # Allow sweep to match lines with leading '=' in some cases
    #----------------------------------------------------------
    if ( $imax_align < 0 && defined($j0_eq_pad) ) {

        if (

            # If there is a following line with leading equals, or
            # preceding line with leading equals, then let the sweep align
            # them without restriction.  For example, the first two lines
            # here are a marginal match, but they are followed by a line
            # with leading equals, so the sweep-lr logic can align all of
            # the lines:

            #  $date[1] = $month_to_num{ $date[1] };            # <--line_0
            #  @xdate   = split( /[:\/\s]/, $log->field('t') ); # <--line_1
            #  $day     = sprintf( "%04d/%02d/%02d", @date[ 2, 1, 0 ] );
            #  $time    = sprintf( "%02d:%02d:%02d", @date[ 3 .. 5 ] );

            # Likewise, if we reverse the two pairs we want the same result

            #  $day     = sprintf( "%04d/%02d/%02d", @date[ 2, 1, 0 ] );
            #  $time    = sprintf( "%02d:%02d:%02d", @date[ 3 .. 5 ] );
            #  $date[1] = $month_to_num{ $date[1] };            # <--line_0
            #  @xdate   = split( /[:\/\s]/, $log->field('t') ); # <--line_1

            (
                   $imax_next >= 0
                || $imax_prev >= 0
                || TEST_MARGINAL_EQ_ALIGNMENT
            )
            && $j0_eq_pad >= -$j0_max_pad
            && $j0_eq_pad <= $j0_max_pad
          )
        {

            # But do not do this if there is a comma before the '='.
            # For example, the first two lines below have commas and
            # therefore are not allowed to align with lines 3 & 4:

            # my ( $x, $y ) = $self->Size();                      #<--line_0
            # my ( $left, $top, $right, $bottom ) = $self->Window(); #<--l_1
            # my $vx = $right - $left;
            # my $vy = $bottom - $top;

            if ( $rpatterns_0->[0] !~ /,/ && $rpatterns_1->[0] !~ /,/ ) {
                $imax_align = 0;
            }
        }
    }

    return ( $is_marginal, $imax_align );
} ## end sub is_marginal_match

sub get_extra_leading_spaces {

    my ( $rlines, $rgroups ) = @_;

    #----------------------------------------------------------
    # Define any extra indentation space (for the -lp option).
    # Here is why:
    # If a list has side comments, sub scan_list must dump the
    # list before it sees everything.  When this happens, it sets
    # the indentation to the standard scheme, but notes how
    # many spaces it would have liked to use.  We may be able
    # to recover that space here in the event that all of the
    # lines of a list are back together again.
    #----------------------------------------------------------

    return 0 if ( !@{$rlines} || !@{$rgroups} );

    my $object = $rlines->[0]->{'indentation'};
    return 0 if ( !ref($object) );
    my $extra_leading_spaces            = 0;
    my $extra_indentation_spaces_wanted = get_recoverable_spaces($object);
    return ($extra_leading_spaces) if ( !$extra_indentation_spaces_wanted );

    my $min_spaces = $extra_indentation_spaces_wanted;
    if ( $min_spaces > 0 ) { $min_spaces = 0 }

    # loop over all groups
    my $ng      = -1;
    my $ngroups = @{$rgroups};
    foreach my $item ( @{$rgroups} ) {
        $ng++;
        my ( $jbeg, $jend ) = @{$item};
        foreach my $j ( $jbeg .. $jend ) {
            next if ( $j == 0 );

            # all indentation objects must be the same
            if ( $object != $rlines->[$j]->{'indentation'} ) {
                return 0;
            }
        }

       # find the maximum space without exceeding the line length for this group
        my $avail = $rlines->[$jbeg]->get_available_space_on_right();
        my $spaces =
          ( $avail > $extra_indentation_spaces_wanted )
          ? $extra_indentation_spaces_wanted
          : $avail;

        #--------------------------------------------------------
        # Note: min spaces can be negative; for example with -gnu
        # f(
        #   do { 1; !!(my $x = bless []); }
        #  );
        #--------------------------------------------------------
        # The following rule is needed to match older formatting:
        # For multiple groups, we will keep spaces non-negative.
        # For a single group, we will allow a negative space.
        if ( $ngroups > 1 && $spaces < 0 ) { $spaces = 0 }

        # update the minimum spacing
        if ( $ng == 0 || $spaces < $extra_leading_spaces ) {
            $extra_leading_spaces = $spaces;
        }
    }

    # update the indentation object because with -icp the terminal
    # ');' will use the same adjustment.
    $object->permanently_decrease_available_spaces( -$extra_leading_spaces );
    return $extra_leading_spaces;
} ## end sub get_extra_leading_spaces

sub forget_side_comment {
    my ($self) = @_;
    $self->[_last_side_comment_column_] = 0;
    return;
}

sub is_good_side_comment_column {
    my ( $self, $line, $line_number, $level, $num5 ) = @_;

    # Upon encountering the first side comment of a group, decide if
    # a previous side comment should be forgotten.  This involves
    # checking several rules.

    # Given:
    #   $line = ref to info hash for the line of interest
    #   $line_number = number of this line in the output stream
    #   $level = indentation level of this line
    #   $num5 = ..see comments below

    # Return:
    #   true to KEEP old comment location
    #   false to FORGET old comment location
    my $KEEP   = 1;
    my $FORGET = 0;

    my $rfields                 = $line->{'rfields'};
    my $is_hanging_side_comment = $line->{'is_hanging_side_comment'};

    # RULE1: Never forget comment before a hanging side comment
    return $KEEP if ($is_hanging_side_comment);

    # RULE2: Forget a side comment after a short line difference,
    # where 'short line difference' is computed from a formula.
    # Using a smooth formula helps minimize sudden large changes.
    my $line_diff = $line_number - $self->[_last_side_comment_line_number_];
    my $alev_diff = abs( $level - $self->[_last_side_comment_level_] );

    # '$num5' is the number of comments in the first 5 lines after the first
    # comment.  It is needed to keep a compact group of side comments from
    # being influenced by a more distant side comment.
    $num5 = 1 if ( !$num5 );

    # Some values:

    #        $adiff  $num5   $short_diff
    #        0       *       12
    #        1       1       6
    #        1       2       4
    #        1       3       3
    #        1       4       2
    #        2       1       4
    #        2       2       2
    #        2       3       1
    #        3       1       3
    #        3       2       1

    my $short_diff = SC_LONG_LINE_DIFF / ( 1 + $alev_diff * $num5 );

    return $FORGET
      if ( $line_diff > $short_diff
        || !$rOpts_valign_side_comments );

    # RULE3: Forget a side comment if this line is at lower level and
    # ends a block
    my $last_sc_level = $self->[_last_side_comment_level_];
    return $FORGET
      if ( $level < $last_sc_level
        && $is_closing_block_type{ substr( $rfields->[0], 0, 1 ) } );

    # RULE 4: Forget the last side comment if this comment might join a cached
    # line ...
    if ( my $cached_line_type = get_cached_line_type() ) {

        # ... otherwise side comment alignment will get messed up.
        # For example, in the following test script
        # with using 'perltidy -sct -act=2', the last comment would try to
        # align with the previous and then be in the wrong column when
        # the lines are combined:

        # foreach $line (
        #    [0, 1, 2], [3, 4, 5], [6, 7, 8],    # rows
        #    [0, 3, 6], [1, 4, 7], [2, 5, 8],    # columns
        #    [0, 4, 8], [2, 4, 6]
        #  )                                     # diagonals
        return $FORGET
          if ( $cached_line_type == 2 || $cached_line_type == 4 );
    }

    # Otherwise, keep it alive
    return $KEEP;
} ## end sub is_good_side_comment_column

sub align_side_comments {

    my ( $self, $rlines, $rgroups ) = @_;

    # Align any side comments in this batch of lines

    # Given:
    #  $rlines  - the lines
    #  $rgroups - the partition of the lines into groups
    #
    # We will be working group-by-group because all side comments
    # (real or fake) in each group are already aligned. So we just have
    # to make alignments between groups wherever possible.

    # An unusual aspect is that within each group we have aligned both real
    # and fake side comments.  This has the consequence that the lengths of
    # long lines without real side comments can cause 'push' all side comments
    # to the right.  This seems unusual, but testing with and without this
    # feature shows that it is usually better this way.  Otherwise, side
    # comments can be hidden between long lines without side comments and
    # thus be harder to read.

    my $group_level        = $self->[_group_level_];
    my $continuing_sc_flow = $self->[_last_side_comment_length_] > 0
      && $group_level == $self->[_last_level_written_];

    # Find groups with side comments, and remember the first nonblank comment
    my $j_sc_beg;
    my @todo;
    my $ng = -1;
    foreach my $item ( @{$rgroups} ) {
        $ng++;
        my ( $jbeg, $jend ) = @{$item};
        foreach my $j ( $jbeg .. $jend ) {
            my $line = $rlines->[$j];
            my $jmax = $line->{'jmax'};
            if ( $line->{'rfield_lengths'}->[$jmax] ) {

                # this group has a line with a side comment
                push @todo, $ng;
                if ( !defined($j_sc_beg) ) {
                    $j_sc_beg = $j;
                }
                last;
            }
        }
    }

    # done if no groups with side comments
    return unless @todo;

    # Count $num5 = number of comments in the 5 lines after the first comment
    # This is an important factor in a decision formula
    my $num5 = 1;
    foreach my $jj ( $j_sc_beg + 1 .. @{$rlines} - 1 ) {
        my $ldiff = $jj - $j_sc_beg;
        last if ( $ldiff > 5 );
        my $line   = $rlines->[$jj];
        my $jmax   = $line->{'jmax'};
        my $sc_len = $line->{'rfield_lengths'}->[$jmax];
        next if ( !$sc_len );
        $num5++;
    }

    # Forget the old side comment location if necessary
    my $line_0 = $rlines->[$j_sc_beg];
    my $lnum =
      $j_sc_beg + $self->[_file_writer_object_]->get_output_line_number();
    my $keep_it =
      $self->is_good_side_comment_column( $line_0, $lnum, $group_level, $num5 );
    my $last_side_comment_column =
      $keep_it ? $self->[_last_side_comment_column_] : 0;

    # If there are multiple groups we will do two passes
    # so that we can find a common alignment for all groups.
    my $MAX_PASS = @todo > 1 ? 2 : 1;

    # Loop over passes
    my $max_comment_column = $last_side_comment_column;
    foreach my $PASS ( 1 .. $MAX_PASS ) {

        # If there are two passes, then on the last pass make the old column
        # equal to the largest of the group.  This will result in the comments
        # being aligned if possible.
        if ( $PASS == $MAX_PASS ) {
            $last_side_comment_column = $max_comment_column;
        }

        # Loop over the groups with side comments
        my $column_limit;
        foreach my $ngr (@todo) {
            my ( $jbeg, $jend_uu ) = @{ $rgroups->[$ngr] };

            # Note that since all lines in a group have common alignments, we
            # just have to work on one of the lines (the first line).
            my $line                    = $rlines->[$jbeg];
            my $jmax                    = $line->{'jmax'};
            my $is_hanging_side_comment = $line->{'is_hanging_side_comment'};
            last
              if ( $PASS < $MAX_PASS && $is_hanging_side_comment );

            # the maximum space without exceeding the line length:
            my $avail = $line->get_available_space_on_right();

            # try to use the previous comment column
            my $side_comment_column = $line->get_column( $jmax - 1 );
            my $move = $last_side_comment_column - $side_comment_column;

            # Remember the maximum possible column of the first line with
            # side comment
            if ( !defined($column_limit) ) {
                $column_limit = $side_comment_column + $avail;
            }

            next if ( $jmax <= 0 );

            # but if this doesn't work, give up and use the minimum space
            my $min_move = $rOpts_minimum_space_to_comment - 1;
            if ( $move > $avail ) {
                $move = $min_move;
            }

            # but we want some minimum space to the comment
            if (   $move >= 0
                && $j_sc_beg == 0
                && $continuing_sc_flow )
            {
                $min_move = 0;
            }

            # remove constraints on hanging side comments
            if ($is_hanging_side_comment) { $min_move = 0 }

            if ( $move < $min_move ) {
                $move = $min_move;
            }

            # don't exceed the available space
            if ( $move > $avail ) { $move = $avail }

            # We can only increase space, never decrease.
            if ( $move < 0 ) { $move = 0 }

            # Discover the largest column on the preliminary  pass
            if ( $PASS < $MAX_PASS ) {
                my $col = $line->get_column( $jmax - 1 ) + $move;

                # but ignore columns too large for the starting line
                if ( $col > $max_comment_column && $col < $column_limit ) {
                    $max_comment_column = $col;
                }
            }

            # Make the changes on the final pass
            else {
                $line->increase_field_width( $jmax - 1, $move );

                # remember this column for the next group
                $last_side_comment_column = $line->get_column( $jmax - 1 );
            }
        } ## end loop over groups
    } ## end loop over passes

    # Find the last side comment
    my $j_sc_last;
    my $ng_last = $todo[-1];
    my ( $jbeg, $jend ) = @{ $rgroups->[$ng_last] };
    foreach my $jj ( reverse( $jbeg .. $jend ) ) {
        my $line = $rlines->[$jj];
        my $jmax = $line->{'jmax'};
        if ( $line->{'rfield_lengths'}->[$jmax] ) {
            $j_sc_last = $jj;
            last;
        }
    }

    # Save final side comment info for possible use by the next batch
    if ( defined($j_sc_last) ) {
        my $line_number =
          $self->[_file_writer_object_]->get_output_line_number() + $j_sc_last;
        $self->[_last_side_comment_column_]      = $last_side_comment_column;
        $self->[_last_side_comment_line_number_] = $line_number;
        $self->[_last_side_comment_level_]       = $group_level;
    }
    return;
} ## end sub align_side_comments

###########################################
# CODE SECTION 6: Pad Signed Number Columns
###########################################

use constant DEBUG_VSN => 0;

my %is_leading_sign_pattern;

BEGIN {

    # PATTERNS: A pattern is basically the concatenation of all token types in
    # the field, with keywords converted to their actual text.  The formatter
    # has changed things like 'print' to 'priNt' so that all 'n's are numbers.
    # The following patterns 'n' can match a signed number of interest.
    # Thus 'n'=a signed or unsigned number, 'b'=a space, '}'=one of ) ] }
    my @q = ( 'n,', 'n,b', 'nb', 'nb}', 'nb},', 'n},', 'n};' );

    @is_leading_sign_pattern{@q} = (1) x scalar(@q);

}

sub min_max_median {
    my ($rvalues) = @_;

    # Given:  $rvalues = ref to an array of numbers
    # Return: the min, max, and median
    my $num = @{$rvalues};
    return unless ($num);

    my @sorted = sort { $a <=> $b } @{$rvalues};

    my $min  = $sorted[0];
    my $max  = $sorted[-1];
    my $imid = int( $num / 2 );
    my $median =
        @sorted % 2
      ? $sorted[$imid]
      : ( $sorted[ $imid - 1 ] + $sorted[$imid] ) / 2;

    return ( $min, $max, $median );
} ## end sub min_max_median

sub end_signed_number_column {
    my ( $rgroup_lines, $rcol_hash, $ix_last ) = @_;

    # Finish formatting a column of unsigned numbers
    # Given:
    #   $rgroup_lines - the current vertical alignment group of lines
    #   $rcol_hash    - a hash of information about this vertical column
    #   $ix_last      - index of the last line of this vertical column
    # Task:
    #   If this is a mixture of signed and unsigned numbers, then add a
    #   single space before the unsigned numbers to improve appearance.
    return unless ($rcol_hash);
    my $jcol          = $rcol_hash->{jcol};
    my $unsigned      = $rcol_hash->{unsigned_count};
    my $signed        = $rcol_hash->{signed_count};
    my $rsigned_lines = $rcol_hash->{rsigned_lines};

    if ( !$signed && $unsigned ) {
        DEVEL_MODE
          && Fault("avoid calling without mixed signed and unsigned\n");
        return;
    }

    my $pos_start_number = $rcol_hash->{pos_start_number};
    my $char_end_part1   = $rcol_hash->{char_end_part1};
    my $ix_first         = $rcol_hash->{ix_first};
    my $nlines           = $ix_last - $ix_first + 1;

    # check for skipped lines, shouldn't happen
    if ( $signed + $unsigned != $nlines ) {
        my $line    = $rgroup_lines->[$ix_last];
        my $rfields = $line->{'rfields'};
        my $text    = join EMPTY_STRING, @{$rfields};
        DEVEL_MODE && Fault(<<EOM);
We seem to have miscounted lines, please check:
signed=$signed
j=$jcol
unsigned=$unsigned
ix_first=$ix_first
ix_last=$ix_last
nlines=$nlines
text=$text
EOM
        return;
    }

    #-----------------------------------------------------------------
    # Form groups of unsigned numbers from the list of signed numbers.
    #-----------------------------------------------------------------
    my @unsigned_subgroups;
    my $ix_last_negative = $ix_first - 1;
    my %is_signed;
    foreach my $ix ( @{$rsigned_lines} ) {
        $is_signed{$ix} = 1;
        my $Nu = $ix - $ix_last_negative - 1;
        if ( $Nu > 0 && $Nu <= $rOpts_valign_signed_numbers_limit ) {
            push @unsigned_subgroups, [ $ix_last_negative + 1, $ix - 1 ];
        }
        $ix_last_negative = $ix;
    }

    # Exclude groups with more than about 20 consecutive numbers.  Little
    # visual improvement is gained by padding more than this, and this avoids
    # large numbers of differences in a file when a single line is changed.
    my $Nu = $ix_last - $ix_last_negative;
    if ( $Nu > 0 && $Nu <= $rOpts_valign_signed_numbers_limit ) {
        push @unsigned_subgroups, [ $ix_last_negative + 1, $ix_last ];
    }

    if ( !@unsigned_subgroups ) { return }    # shouldn't happen

    #--------------------------------------------
    # Find number lengths for irregularity checks
    #--------------------------------------------
    # Padding signed numbers looks best when the numbers, excluding signs,
    # all have about the same length. When the lengths are irregular, with
    # mostly longer unsigned numbers, it doesn't look good to do this. So
    # we need to filter out these bad-looking cases.

    # The 'field_lengths' are unreliable because they may include some
    # arbitrary trailing text; see 'substr.t' So we must look for the end of
    # the number at a space, comma, or closing container token. Note that these
    # lengths include the length of any signs.
    my @len_unsigned;
    my @len_signed;
    my @lengths;
    foreach my $ix ( $ix_first .. $ix_last ) {
        my $line   = $rgroup_lines->[$ix];
        my $rfield = $line->{'rfields'};
        my $str    = substr( $rfield->[$jcol], $pos_start_number );
        if ( $str =~ /^([^\s\,\)\]\}]*)/ ) { $str = $1 }
        my $len = length($str);
        if   ( $is_signed{$ix} ) { push @len_signed,   $len }
        else                     { push @len_unsigned, $len }
        push @lengths, [ $len, $ix ];
    }

    my ( $min_unsigned_length, $max_unsigned_length, $median_unsigned_length )
      = min_max_median( \@len_unsigned );
    my ( $min_signed_length_uu, $max_signed_length, $median_signed_length ) =
      min_max_median( \@len_signed );

    # Skip padding if no signed numbers exceed unsigned numbers in length
    if ( $max_signed_length <= $min_unsigned_length ) {
        return;
    }

    # If max signed length is greatest - all unsigned values can be padded
    elsif ( $max_signed_length > $max_unsigned_length ) {

        # Example:
        #    %wind_dir = (
        #        'n'  => [  1,  0 ],
        #        'ne' => [  1,  1 ],
        #        'e'  => [  0,  1 ],
        #        'se' => [ -1,  1 ],
        #        's'  => [ -1,  0 ],
        #        'sw' => [ -1, -1 ],
        #        'w'  => [  0, -1 ],
        #        'nw' => [  1, -1 ],
        #        ''   => [  0,  0 ],
        #    );

        # This is the ideal case - ok to continue and pad
    }

    # intermediate case: some signed numbers cannot be padded ...
    else {

        # We have to take a closer look.
        # Here is an example which looks bad if we do padding like this:
        #    my %hash = (
        #        X0 => -12867.098241163,
        #        X1 =>  2.31694338671684,       # unsigned w/   excess>0
        #        X2 => 0.0597726714860419,      # max length => excess=0
        #        Y0 =>  30043.1335503155,       # unsigned w/   excess>0
        #        Y1 => 0.0525784981597044,      # max length => excess=0
        #        Y2 => -2.32447131600783,
        #    );

        # To decide what looks okay, we count 'good' and 'bad' line interfaces:
        #    X0 - X1 = good (X0 is signed and X1 can move)
        #    X1 - X2 = bad  (x1 can move but x2 cannot)
        #    X2 - Y0 = bad  (x2 cannot move but Y0 can move)
        #    Y0 - Y1 = bad  (Y0 can move but Y1 cannot move)
        #    Y1 - Y2 = bad  (Y1 cannot move and Y2 is signed)
        # Result: 4 bad interfaces and 1 good => so we will skip this
        my $good_count = 0;
        my $bad_count  = 0;
        foreach my $item (@lengths) {
            $item->[0] = $max_unsigned_length - $item->[0];
        }
        my $item0 = shift @lengths;
        my ( $excess, $ix ) = @{$item0};
        my $immobile_count = $excess ? 0 : 1;
        foreach my $item (@lengths) {
            my $excess_m = $excess;
            my $ix_m     = $ix;
            ( $excess, $ix ) = @{$item};
            if ( !$excess ) { $immobile_count++ }

            if ( $is_signed{$ix_m} ) {

                # signed-unsigned interface
                if ( !$is_signed{$ix} ) {
                    if   ($excess) { $good_count++ }
                    else           { $bad_count++ }
                }

                # signed-signed: ok, not good or bad
            }
            else {

                # unsigned-signed interface
                if ( $is_signed{$ix} ) {
                    if   ($excess_m) { $good_count++ }
                    else             { $bad_count++ }
                }

                # unsigned-unsigned: bad if different
                else {
                    if ( $excess_m xor $excess ) {
                        $bad_count++;
                    }
                }
            }
        }

        # Filter 1: skip if more interfaces are 'bad' than 'good'
        if ( $bad_count > $good_count ) {
            return;
        }

        # Filter 2: skip in a table with multiple 'bad' interfaces and where
        # 'most' of the unsigned lengths are shorter than the signed lengths.
        # Using the median value makes this insensitive to small changes.
        if (   $median_unsigned_length >= $median_signed_length
            && $bad_count > 1
            && $immobile_count > 1 )
        {
            return;
        }

        # Anything that gets past these filters should look ok if padded
    }

    #---------------------------------------------
    # Compute actual available space for each line
    #---------------------------------------------
    my %excess_space;
    my $movable_count = 0;
    foreach my $item (@unsigned_subgroups) {
        my ( $ix_min, $ix_max ) = @{$item};
        foreach my $ix ( $ix_min .. $ix_max ) {
            my $line                = $rgroup_lines->[$ix];
            my $leading_space_count = $line->{'leading_space_count'};
            my $jmax                = $line->{'jmax'};
            my $rfield_lengths      = $line->{'rfield_lengths'};
            if ( $jcol >= $jmax ) {

                # shouldn't happen
                DEVEL_MODE && Fault("jcol=$jcol >= jmax=$jmax\n");
                return;
            }
            my @alignments = @{ $line->{'ralignments'} };
            my $col        = $alignments[$jcol]->{'column'};
            my $col_start =
                $jcol == 0
              ? $leading_space_count
              : $alignments[ $jcol - 1 ]->{'column'};
            my $avail        = $col - $col_start;
            my $field_length = $rfield_lengths->[$jcol];
            my $excess       = $avail - $field_length;
            $excess_space{$ix} = $excess;
            if ( $excess > 0 ) { $movable_count++ }
        }
    }

    return unless ($movable_count);

    # Count the number of signed-unsigned interfaces that would change
    # if we do the padding
    my $Nc = 0;
    foreach my $item (@unsigned_subgroups) {
        my ( $ix_min, $ix_max ) = @{$item};
        $Nc++ if ( $excess_space{$ix_min} > 0 && $ix_min != $ix_first );
        $Nc++ if ( $excess_space{$ix_max} > 0 && $ix_max != $ix_last );
    }

    #--------------------------------------------------------------------
    # Sparsity check:
    # Give up if the number of interface changes will be below the cutoff
    #--------------------------------------------------------------------
    if ( $unsigned > $Nc * $rOpts_valign_signed_numbers_limit ) {
        return;
    }

    #------------------------------------------------------------------------
    # Insert an extra space before the unsigned numbers if space is available
    #------------------------------------------------------------------------
    foreach my $item (@unsigned_subgroups) {
        my ( $ix_min, $ix_max ) = @{$item};

        foreach my $ix ( $ix_min .. $ix_max ) {
            next if ( $excess_space{$ix} <= 0 );
            my $line           = $rgroup_lines->[$ix];
            my $rfields        = $line->{'rfields'};
            my $rfield_lengths = $line->{'rfield_lengths'};
            pad_signed_field(
                \$rfields->[$jcol], \$rfield_lengths->[$jcol],
                $pos_start_number,  $char_end_part1
            );
        }
    }
    return;
} ## end sub end_signed_number_column

sub pad_signed_field {
    my ( $rstr, $rstr_len, $pos_start_number, $char_end_part1 ) = @_;

    # Insert an extra space before a number to highlight algebraic signs
    # in a column of numbers.
    # Given:
    #  $rstr     = ref to string
    #  $rstr_len = ref to display width of string (could include wide chars)
    #  $pos_start_number = string position of the leading digit
    #  $char_end_part1 = character at $pos_start_number - 1
    # Task: update $rstr and $rstr_len with a single space

    # First partition the string into $part1 and $part2, so that the
    # number starts at the beginning of part2.
    my $part1 = EMPTY_STRING;
    my $part2 = ${$rstr};
    my $str   = ${$rstr};
    if ( $pos_start_number > 0 ) {
        my $len = length($str);
        if ( $pos_start_number >= $len ) {
            DEVEL_MODE && Fault(<<EOM);
Expection position '$pos_start_number' < length $len of string '$str'
EOM
            return;
        }
        $part1 = substr( $str, 0, $pos_start_number );
        $part2 = substr( $str, $pos_start_number );

        # VERIFY that we are inserting a new space after either
        #   (1) an existing space or
        #   (2) an opening token.
        # Otherwise disaster can occur. An error here implies a programming
        # error in defining '$pos_start_number'.

        my $test_char1 = substr( $part1, -1, 1 );
        if ( $test_char1 ne $char_end_part1 ) {
            DEVEL_MODE && Fault(<<EOM);
Expecting '$char_end_part1' but saw '$test_char1' in string '$str'
Probably bad position '$pos_start_number'
EOM
            return;
        }
    }

    # VERIFY we are inserting a space before a digit character
    my $test_char2 = substr( $part2, 0, 1 );
    if ( $is_digit_char{$test_char2} ) {
        ${$rstr} = $part1 . SPACE . $part2;
        ${$rstr_len} += 1;
    }
    else {
        DEVEL_MODE && Fault(<<EOM);
Expecting test char2 as leading digit but saw '$test_char2' in string '$str'
May be bad position '$pos_start_number'
EOM
    }
    return;
} ## end sub pad_signed_field

sub split_field {
    my ( $pat1, $field, $pattern ) = @_;

    # Given;
    #   $pat1    = first part of a pattern before a numeric type 'n'
    #   $field   = corresponding text field
    #   $pattern = full pattern
    # Return:
    #   $pos_start_number = positiion in $field where the number should start
    #                     = 0 if cannot find
    #   $char_end_part1 = the character preceding $pos_start_number
    #   $ch_opening     = the preceding opening container character, if any

    # We have to find where the possible number starts in this field.
    # The safe thing to do is return @fail if anything does not look right.

    my $pos_start_number = 0;
    my $char_end_part1   = EMPTY_STRING;
    my $ch_opening       = EMPTY_STRING;
    my @fail             = ( $pos_start_number, $char_end_part1, $ch_opening );

    # Be sure there is just 'n' in the pattern. Multiple terms can occur
    # when fields are joined, but since we are jumping into the middle
    # of a field it is safest not to try to handle them.
    my $n_count = ( $pattern =~ tr/n/n/ );
    if ( $n_count && $n_count > 1 ) {
        return @fail;
    }

    # Same thing for commas
    my $comma_count = ( $pattern =~ tr/,/,/ );
    if ( $comma_count && $comma_count > 1 ) {
        return @fail;
    }

    # Require 0 or 1 braces
    my $len_field = length($field);
    my $len_pat1  = length($pat1);
    return @fail unless ( $len_pat1 && $len_field );

    # Look at the pattern ending
    my $ending_b = 0;
    my $ch       = substr( $pat1, -1, 1 );
    if ( $ch eq 'b' ) {
        $ending_b       = 1;
        $ch             = substr( $pat1, -2, 1 );
        $char_end_part1 = SPACE;
    }

    # handle either '{b' or '{'
    if ( $ch eq '{' ) {

        # Only one brace
        my $brace_count = ( $pat1 =~ tr/\{/\{/ );
        return @fail if ( $brace_count != 1 );

        my $i_paren   = index( $field, '(' );
        my $i_bracket = index( $field, '[' );
        my $i_brace   = index( $field, '{' );
        my $i_opening = length($field);
        if ( $i_paren >= 0 ) {
            $i_opening  = $i_paren;
            $ch_opening = '(';
        }
        if (   $i_bracket >= 0
            && $i_bracket < $i_opening )
        {
            $i_opening  = $i_bracket;
            $ch_opening = '[';
        }
        if ( $i_brace >= 0 && $i_brace < $i_opening ) {
            $i_opening  = $i_brace;
            $ch_opening = '{';
        }
        if (   $i_opening >= 0
            && $i_opening < length($field) - 1 )
        {
            $pos_start_number = $i_opening + 1 + $ending_b;
            $char_end_part1   = $ch_opening
              if ( !$ending_b );
        }
        else {
            # strange - could not find the opening token
        }
    }

    # no braces: maybe '=>b'
    else {

        # looking for patterns ending in '=b' or '=>b'
        if ( !$ending_b ) { return @fail }

        # find the = in the text
        my $pos_equals = index( $field, '=' );
        return @fail if ( $pos_equals < 0 );

        # be sure there are no other '=' in the pattern
        my $equals_count = ( $pat1 =~ tr/=/=/ );
        return @fail if ( $equals_count != 1 );

        if ( $len_pat1 >= 2 && substr( $pat1, -2, 2 ) eq '=b' ) {
            $pos_start_number = $pos_equals + 2;
        }
        elsif ( $len_pat1 >= 3 && substr( $pat1, -3, 3 ) eq '=>b' ) {
            $pos_start_number = $pos_equals + 3;
        }
        else {

            # cannot handle this pattern
            return @fail;
        }
    }

    if ( $pos_start_number <= 0 || $pos_start_number >= $len_field ) {
        return @fail;
    }

    return ( $pos_start_number, $char_end_part1, $ch_opening );
} ## end sub split_field

sub field_matches_end_pattern {
    my ( $field2, $pat2 ) = @_;

    # Check that a possible numeric field matches the ending pattern

    # Given:
    #  $field2 = the rest of the field after removing any sign
    #  $pat2   = the end pattern of this field
    # Return:
    #  false if field is definitely non-numeric
    #  true otherwise

    my $next_char   = substr( $pat2, 1, 1 );
    my $field2_trim = EMPTY_STRING;

    # if pattern is one of: 'n,', 'n,b'
    if ( $next_char eq ',' ) {
        my $icomma = index( $field2, ',' );
        if ( $icomma >= 0 ) {
            $field2_trim = substr( $field2, 0, $icomma );
        }
    }

    # if pattern is one of: 'nb', 'nb}', 'nb},'
    elsif ( $next_char eq 'b' ) {
        my $ispace = index( $field2, SPACE );
        if ( $ispace >= 0 ) {
            $field2_trim = substr( $field2, 0, $ispace );
        }
    }

    # if pattern is one of 'n},', 'n};'
    elsif ( $next_char eq '}' ) {
        if ( $field2 =~ /^([^\)\}\]]+)/ ) {
            $field2_trim = $1;
        }
    }

    # unrecognized pattern
    else {
        DEVEL_MODE && Fault(<<EOM);
Unexpected ending pattern '$pat2' next='$next_char' field2='$field2'
The hash 'is_leading_sign_pattern' seems to have changed but the code
has not been updated to handle it. Please fix.
EOM
        return;
    }

    if ( !length($field2_trim) ) {
        DEVEL_MODE
          && Fault(
            "STRANGE: cannot find end of field=$field2 for pat=$pat2 \n");
        return;
    }

    # Reject obviously non-numeric fields just to be sure we did not
    # jump into a quote of some kind
    if ( $field2_trim !~ /^[\d\.\+\-abcdefpx_]+$/i ) {
        DEBUG_VSN
          && print {*STDERR}
"Rejecting match to pat2='$pat2' with next=$next_char field2=$field2 trimmed='$field2_trim'\n";
        return;
    }
    return 1;
} ## end sub field_matches_end_pattern

sub pad_signed_number_columns {
    my ($rgroup_lines) = @_;

    # Given:
    #   $rgroup_lines = the current vertical alignment group of lines
    # Task:
    #   Look for columns of aligned numeric values, some of whose numbers
    #   have algebraic signs. Add a leading space to the unsigned
    #   numbers, if possible, so that the just the signs appear as the first
    #   character. Example of what we want to do:

    #    my @correct = (
    #        [  123456.79,   86753090000.868,  11 ],
    #        [ -123456.79,  -86753090000.868, -11 ],
    #        [  123456.001,  80.080,           10 ],
    #        [ -123456.001, -80.080,           0 ],
    #        [  10.9,        10.9,             11 ],
    #    );

    # The logic here is complex because we are working with bits of text
    # which have been broken into patterns which are convenient for the
    # vertical aligner, but we no longer have the original tokenization
    # which would have indicated the precise bounds of numbers.  So we
    # have to procede very carefully with lots of checks. There are
    # more checks than really necessary now because originally numbers
    # and quotes were both indicated with pattern 'Q'. But now numbers are
    # uniquely marked as pattern 'n', so there is less risk of an error.
    # The extra checks take very little time so they are retained.

    return unless ($rOpts_valign_signed_numbers);

    my %column_info;
    my @columns;

    #----------------
    # loop over lines
    #----------------
    my $ix_line = -1;
    my $jmax    = -1;
    foreach my $line ( @{$rgroup_lines} ) {
        $ix_line++;
        my $jmax_last = $jmax;
        $jmax = $line->{'jmax'};
        my $jmax_change = $jmax ne $jmax_last;

        my @alignments = @{ $line->{'ralignments'} };
        my $rfields    = $line->{'rfields'};
        my $rpatterns  = $line->{'rpatterns'};
        my $rtokens    = $line->{'rtokens'};

        #-----------------------------------------------
        # Check for a reduction in the number of columns
        #-----------------------------------------------
        if ( $jmax < $jmax_last ) {

            foreach my $jcol ( keys %column_info ) {

                # end any stranded columns on the right
                next if ( $jcol < $jmax );
                my $rcol_hash = $column_info{$jcol};
                next unless ($rcol_hash);
                if (   $rcol_hash->{signed_count}
                    && $rcol_hash->{unsigned_count} )
                {
                    end_signed_number_column( $rgroup_lines, $rcol_hash,
                        $ix_line - 1 );
                }
                delete $column_info{$jcol};
            }

            # Try to keep the end data column running; test case 'rfc.in'
            # The last item in a list will still need a trailing comma.
            my $jcol = $jmax - 1;
            if ( $jcol >= 0 && $column_info{$jcol} ) {
                my $alignment = $alignments[$jcol];
                my $old_col   = $columns[$jcol];
                my $col       = $alignment->{column};

                if (
                    $col < $old_col

                    # only do this if the text has a leading digit
                    && $rfields->[$jcol] =~ /^([+-]?)\d/

                    # and a signed number has been seen - issue c375
                    && ( $1 || $column_info{$jcol}->{signed_count} )
                  )
                {
                    my $spaces_needed = $old_col - $col;
                    my $spaces_available =
                      $line->get_available_space_on_right();
                    if ( $spaces_available >= $spaces_needed ) {
                        $line->increase_field_width( $jcol, $spaces_needed );
                    }
                }
            }
        }

        #--------------------------------------------
        # Loop over fields except last (side comment)
        #--------------------------------------------
        for my $jcol ( 0 .. $jmax - 1 ) {

            #-----------------------------------------
            # Decide if this is a new alignment column
            #-----------------------------------------
            my $alignment = $alignments[$jcol];
            my $old_col   = $columns[$jcol];
            my $col       = $alignment->{column};
            $columns[$jcol] = $col;
            if ( defined($old_col) && $old_col != $col ) {
                foreach my $jcol_old ( keys %column_info ) {
                    next if ( $jcol_old < $jcol );
                    my $rcol_hash = $column_info{$jcol_old};
                    if (   $rcol_hash->{signed_count}
                        && $rcol_hash->{unsigned_count} )
                    {
                        end_signed_number_column( $rgroup_lines, $rcol_hash,
                            $ix_line - 1 );
                    }
                    delete $column_info{$jcol_old};
                }
            }

            # A new padded sign column can only start at an alignment change
            my $rcol_hash = $column_info{$jcol};

            #------------------------------------------------------------
            # Examine this field, looking for signed and unsigned numbers
            #------------------------------------------------------------
            my $field   = $rfields->[$jcol];
            my $pattern = $rpatterns->[$jcol];

            my $is_signed_number   = 0;
            my $is_unsigned_number = 0;

            #--------------------------------------------------------
            # set $pos_start_number = index in field of digit or sign
            #--------------------------------------------------------
            my $pos_start_number = 0;
            my $char_end_part1   = EMPTY_STRING;
            my $ch_opening       = EMPTY_STRING;

            # Set $field_ok to false on encountering any problem
            # Do not pad signed and unsigned hash keys
            my $field_ok = length($field) > 0
              && substr( $rtokens->[$jcol], 0, 2 ) ne '=>';

            if ( $field_ok && $pattern ) {

                # Split the pattern at the first 'n'
                # $pat1 = pattern before the 'n' (if any)
                # $pat2 = pattern starting at the 'n'
                my ( $pat1, $pat2 );
                my $posq = index( $pattern, 'n' );
                if ( $posq < 0 ) {
                    $field_ok = 0;
                }
                else {
                    # Just look at up to 3 of the pattern characters
                    # We require $pat2 to have one of the known patterns
                    $pat1     = substr( $pattern, 0,     $posq );
                    $pat2     = substr( $pattern, $posq, 3 );
                    $field_ok = $is_leading_sign_pattern{$pat2};
                }

                if ($field_ok) {

                    # If the number starts within the field then we must
                    # find its offset position.
                    if ($pat1) {

                        # Note: an optimization would be to remember previous
                        # calls for each column and use them if possible, but
                        # benchmarking shows that this is not necessary.
                        # See .ba54 for example coding.
                        ( $pos_start_number, $char_end_part1, $ch_opening ) =
                          split_field( $pat1, $field, $pattern );

                        $field_ok ||= $pos_start_number;
                    }

                    if ($field_ok) {

                        # look for an optional + or - sign
                        my $test_char = substr( $field, $pos_start_number, 1 );
                        my $sign;
                        if ( $is_plus_or_minus{$test_char} ) {
                            $sign = $test_char;
                            $test_char =
                              substr( $field, $pos_start_number + 1, 1 );
                        }

                        # and a digit
                        if ( $is_digit_char{$test_char} ) {
                            my $field2;
                            if ($sign) {
                                $is_signed_number = 1;
                                $field2 =
                                  substr( $field, $pos_start_number + 1 );
                            }
                            else {
                                $is_unsigned_number = 1;
                                $field2 =
                                  $pos_start_number
                                  ? substr( $field, $pos_start_number )
                                  : $field;
                            }

                            # Check for match to ending pattern
                            $field_ok =
                              field_matches_end_pattern( $field2, $pat2 );
                        }
                        else {
                            $field_ok = 0;
                        }
                    }
                }
            }

            #----------------------
            # Figure out what to do
            #----------------------

            # we require a signed or unsigned number field
            # which is not a hash key
            $field_ok &&= ( $is_signed_number || $is_unsigned_number );

            # if a column has not started..
            if ( !$rcol_hash ) {

                # give up if this is cannot start a new column
                next if ( !$field_ok );

                # otherwise continue on to start a new column

            }

            # if a column has been started...
            else {

                # and this cannot be added to it
                if (  !$field_ok
                    || $rcol_hash->{pos_start_number} ne $pos_start_number
                    || $rcol_hash->{char_end_part1} ne $char_end_part1
                    || $rcol_hash->{col} ne $col )
                {

                    # then end the current column and start over
                    if (   $rcol_hash->{signed_count}
                        && $rcol_hash->{unsigned_count} )
                    {
                        end_signed_number_column( $rgroup_lines, $rcol_hash,
                            $ix_line - 1 );
                    }
                    delete $column_info{$jcol};
                    $rcol_hash = undef;
                }
            }

            if (DEBUG_VSN) {
                my $exists = defined($rcol_hash);
                print
"VSN: line=$ix_line change=$jmax_change jcol=$jcol field=$field exists?=$exists unsigned?=$is_unsigned_number signed?=$is_signed_number\n";
            }

            #---------------------------------------
            # Either start a new column, if possible
            #---------------------------------------
            if ( !defined($rcol_hash) ) {

                next if ( !$field_ok );

                my $rsigned_lines = $is_signed_number ? [$ix_line] : [];
                $column_info{$jcol} = {
                    unsigned_count   => $is_unsigned_number,
                    signed_count     => $is_signed_number,
                    pos_start_number => $pos_start_number,
                    char_end_part1   => $char_end_part1,
                    ix_first         => $ix_line,
                    col              => $col,
                    jcol             => $jcol,
                    rsigned_lines    => $rsigned_lines,
                };
            }

            #------------------------------
            # or extend the existing column
            #------------------------------
            else {
                $rcol_hash->{unsigned_count} += $is_unsigned_number;
                $rcol_hash->{signed_count}   += $is_signed_number;
                if ($is_signed_number) {
                    push @{ $rcol_hash->{rsigned_lines} }, $ix_line;
                }
            }
        }
    }

    #-------------------------------------
    # Loop to finish any remaining columns
    #-------------------------------------
    foreach my $jcol ( keys %column_info ) {
        my $rcol_hash = $column_info{$jcol};
        if ( $rcol_hash->{signed_count} && $rcol_hash->{unsigned_count} ) {
            end_signed_number_column( $rgroup_lines, $rcol_hash, $ix_line );
        }
    }
    return;
} ## end sub pad_signed_number_columns

#########################################
# CODE SECTION 7: Pad Wide Equals Columns
#########################################

use constant DEBUG_WEC => 0;

sub end_wide_equals_column {
    my ( $rgroup_lines, $rcol_hash, $ix_last ) = @_;

    # Finish formatting a column of wide equals
    # Given:
    #   $rgroup_lines - the current vertical alignment group of lines
    #   $rcol_hash    - a hash of information about this vertical column
    #   $ix_last      - index of the last line of this vertical column

    return unless ($rcol_hash);
    my $jcol      = $rcol_hash->{jcol};
    my $col       = $rcol_hash->{col};
    my $min_width = $rcol_hash->{min_width};
    my $max_width = $rcol_hash->{max_width};
    my $rwidths   = $rcol_hash->{rwidths};
    my $ix_first  = $rcol_hash->{ix_first};

    # check for skipped lines, shouldn't happen
    my $nlines = $ix_last - $ix_first + 1;
    my $num    = @{$rwidths};
    if ( $num != $nlines ) {
        my $line    = $rgroup_lines->[$ix_last];
        my $rfields = $line->{'rfields'};
        my $text    = join EMPTY_STRING, @{$rfields};
        DEVEL_MODE && Fault(<<EOM);
We seem to have miscounted lines, please check:
nlines=$nlines
num saved=$num
min width=$min_width
max width=$max_width
j=$jcol
ix_first=$ix_first
ix_last=$ix_last
text=$text
EOM
        return;
    }

    #------------------------------------------------------
    # loop over all lines of this vertical alignment column
    #------------------------------------------------------

    my (
        $current_alignment, $starting_colp,
        $current_line,      @previous_linked_lines
    );
    foreach my $item ( @{$rwidths} ) {
        my ( $ix, $width ) = @{$item};
        my $line = $rgroup_lines->[$ix];

        # add leading spaces to the shorter equality tokens to get
        # vertical alignment of the '=' signs
        my $jmax  = $line->{'jmax'};
        my $jcolp = $jcol + 1;

        my @alignments = @{ $line->{'ralignments'} };
        my $alignment  = $alignments[$jcolp];
        my $colp       = $alignment->{column};

        #------------------------------------------------------------
        # Transfer column width changes between equivalent alignments
        #------------------------------------------------------------

        # This step keeps alignments to the right correct in case the
        # alignment object changes but the actual alignment col does not.
        # It is extremely rare for this to occur. Issue c353.

        # nothing to do if no more real alignments on right
        if ( $jcolp >= $jmax - 1 ) {
            $current_alignment     = undef;
            $current_line          = undef;
            @previous_linked_lines = ();
        }

        # handle new rhs alignment
        elsif ( !$current_alignment ) {
            $current_alignment     = $alignment;
            $current_line          = $line;
            $starting_colp         = $colp;
            @previous_linked_lines = ();
        }

        # handle change in existing alignment
        elsif ( refaddr($alignment) != refaddr($current_alignment) ) {

            # change rhs alignment column - new vertical group on right
            if ( $starting_colp != $colp ) {
                $starting_colp         = $colp;
                @previous_linked_lines = ();
            }
            else {

                # Same starting alignment col on right, but different alignment
                # object. See if we must increase width of this new alignment
                # object.
                my $current_colp = $current_alignment->{column};
                if ( $current_colp > $colp ) {
                    my $excess = $current_colp - $colp;
                    my $padding_available =
                      $line->get_available_space_on_right();
                    if ( $excess <= $padding_available ) {
                        $line->increase_field_width( $jcolp, $excess );
                        $colp = $alignment->{column};
                    }
                }

                # remember the previous line in case we have to go back and
                # increasse its width
                push @previous_linked_lines, $current_line;
            }
            $current_alignment = $alignment;
            $current_line      = $line;
        }
        else {
            # continuing with same alignment
        }

        #-----------------------
        # add any needed padding
        #-----------------------
        my $pad = $max_width - $width;
        if ( $pad > 0 ) {

            my $rfields        = $line->{'rfields'};
            my $rfield_lengths = $line->{'rfield_lengths'};

            my $lenp   = $rfield_lengths->[$jcolp];
            my $avail  = $colp - $col;
            my $excess = $lenp + $pad - $avail;

            if ( $excess > 0 ) {

                my $padding_available = $line->get_available_space_on_right();
                if ( $excess <= $padding_available ) {
                    $line->increase_field_width( $jcolp, $excess );

                    # Increase space of any previous linked lines
                    foreach my $line_prev (@previous_linked_lines) {
                        $padding_available =
                          $line_prev->get_available_space_on_right();
                        if ( $excess <= $padding_available ) {
                            $line_prev->increase_field_width( $jcolp, $excess );
                        }
                        else {
                            last;
                        }
                    }
                }
                else {
                    $pad = 0;
                }

            }

            # Add spaces
            $rfields->[$jcolp] = ( SPACE x $pad ) . $rfields->[$jcolp];
            $rfield_lengths->[$jcolp] += $pad;
        }
    }
    return;
} ## end sub end_wide_equals_column

sub pad_wide_equals_columns {
    my ($rgroup_lines) = @_;

    # Given:
    #   $rgroup_lines = the current vertical alignment group of lines
    # Task:
    #   Look for columns of aligned equals tokens, some of which may be
    #   things like '-=', '&&=', etc.  Increase the field length of the
    #   previous field by 1 or 2 spaces where necessary and possible so
    #   that alignment of all '=' occurs.  For example, given

    #       $j    /= 2;
    #       $pow2 = $pow2 * $pow2;

    # In this case we want to add a leading space '=' term to get
    #       $j    /= 2;
    #       $pow2  = $pow2 * $pow2;

    # The logic here is somewhat similar to sub pad_signed_number_columns

    return unless ($rOpts_valign_wide_equals);

    my %column_info;
    my @columns;

    #----------------
    # loop over lines
    #----------------
    my $ix_line = -1;
    my $jmax    = -1;
    foreach my $line ( @{$rgroup_lines} ) {
        $ix_line++;
        my $jmax_last = $jmax;
        $jmax = $line->{'jmax'};
        my $jmax_change = $jmax ne $jmax_last;

        my @alignments = @{ $line->{'ralignments'} };
        my $rfields    = $line->{'rfields'};
        my $rtokens    = $line->{'rtokens'};

        #-----------------------------------------------
        # Check for a reduction in the number of columns
        #-----------------------------------------------
        if ( $jmax < $jmax_last ) {

            foreach my $jcol ( keys %column_info ) {

                # end any stranded columns on the right
                next if ( $jcol < $jmax );
                my $rcol_hash = $column_info{$jcol};
                next unless ($rcol_hash);
                if ( $rcol_hash->{max_width} > $rcol_hash->{min_width} ) {
                    end_wide_equals_column( $rgroup_lines, $rcol_hash,
                        $ix_line - 1 );
                }
                delete $column_info{$jcol};
            }
        }

        #--------------------------------------------------
        # Loop over fields except last field (side comment)
        #--------------------------------------------------
        for my $jcol ( 0 .. $jmax - 1 ) {

            #-----------------------------------------
            # Decide if this is a new alignment column
            #-----------------------------------------
            my $alignment = $alignments[$jcol];
            my $old_col   = $columns[$jcol];
            my $col       = $alignment->{column};
            $columns[$jcol] = $col;
            if ( defined($old_col) && $old_col != $col ) {
                foreach my $jcol_old ( keys %column_info ) {
                    next if ( $jcol_old < $jcol );
                    my $rcol_hash = $column_info{$jcol_old};
                    if ( $rcol_hash->{max_width} > $rcol_hash->{min_width} ) {
                        end_wide_equals_column( $rgroup_lines, $rcol_hash,
                            $ix_line - 1 );
                    }
                    delete $column_info{$jcol_old};
                }
            }

            # A new wide equals column can only start at an alignment change
            my $rcol_hash = $column_info{$jcol};

            #------------------------------------------------------
            # Examine this field, looking for equals or wide equals
            #------------------------------------------------------
            my $field_next = $rfields->[ $jcol + 1 ];
            my $token      = $rtokens->[$jcol];

            # See if this is an equals alignment group;
            # indicated by alignment token of '=' followed by a digit
            my $len_equals_symbol = 0;
            if (   length($token) > 1
                && substr( $token, 0, 1 ) eq '='
                && $is_digit_char{ substr( $token, 1, 1 ) } )
            {

                # find the actual equality symbol which starts the next field
                # i.e. '=' or '**=' or '-=' etc. We just need its length.
                my $pos = index( $field_next, '=' );
                if ( $pos >= 0 && $pos <= 2 ) {
                    $len_equals_symbol = $pos + 1;
                }
            }

            # if a column has not started..
            if ( !$rcol_hash ) {

                # give up if this is cannot start a new column
                next if ( !$len_equals_symbol );

                # otherwise continue on to start a new column

            }

            # if a column has been started...
            else {

                # and this cannot be added to it
                if ( !$len_equals_symbol || $rcol_hash->{col} ne $col ) {

                    # then end the current column and start over
                    if ( $rcol_hash->{max_width} > $rcol_hash->{min_width} ) {
                        end_wide_equals_column( $rgroup_lines, $rcol_hash,
                            $ix_line - 1 );
                    }
                    delete $column_info{$jcol};
                    $rcol_hash = undef;
                }
            }

            if (DEBUG_WEC) {
                my $exists = defined($rcol_hash);
                print
"WEA: line=$ix_line change=$jmax_change jcol=$jcol field=$field_next exists?=$exists equals?=$len_equals_symbol\n";
            }

            #---------------------------------------
            # Either start a new column, if possible
            #---------------------------------------
            if ( !defined($rcol_hash) ) {

                next if ( !$len_equals_symbol );

                $column_info{$jcol} = {
                    ix_first  => $ix_line,
                    col       => $col,
                    jcol      => $jcol,
                    min_width => $len_equals_symbol,
                    max_width => $len_equals_symbol,
                    rwidths   => [ [ $ix_line, $len_equals_symbol ] ],
                };
            }

            #------------------------------
            # or extend the existing column
            #------------------------------
            else {
                if ( $len_equals_symbol > $rcol_hash->{max_width} ) {
                    $rcol_hash->{max_width} = $len_equals_symbol;
                }
                if ( $len_equals_symbol < $rcol_hash->{min_width} ) {
                    $rcol_hash->{min_width} = $len_equals_symbol;
                }
                push @{ $rcol_hash->{rwidths} },
                  [ $ix_line, $len_equals_symbol ];
            }
        }
    }

    #-------------------------------------
    # Loop to finish any remaining columns
    #-------------------------------------
    foreach my $jcol ( keys %column_info ) {
        my $rcol_hash = $column_info{$jcol};
        if ( $rcol_hash->{max_width} > $rcol_hash->{min_width} ) {
            end_wide_equals_column( $rgroup_lines, $rcol_hash, $ix_line );
        }
    }
    return;
} ## end sub pad_wide_equals_columns

###############################
# CODE SECTION 8: Output Step A
###############################

sub valign_output_step_A {

    #------------------------------------------------------------
    # This is Step A in writing vertically aligned lines.
    # The line is prepared according to the alignments which have
    # been found. Then it is shipped to the next step.
    #------------------------------------------------------------

    my ( $self, $rinput_hash ) = @_;

    my $line                 = $rinput_hash->{line};
    my $min_ci_gap           = $rinput_hash->{min_ci_gap};
    my $do_not_align         = $rinput_hash->{do_not_align};
    my $group_leader_length  = $rinput_hash->{group_leader_length};
    my $extra_leading_spaces = $rinput_hash->{extra_leading_spaces};
    my $level                = $rinput_hash->{level};
    my $maximum_line_length  = $rinput_hash->{maximum_line_length};

    my $rfields                   = $line->{'rfields'};
    my $rfield_lengths            = $line->{'rfield_lengths'};
    my $leading_space_count       = $line->{'leading_space_count'};
    my $outdent_long_lines        = $line->{'outdent_long_lines'};
    my $maximum_field_index       = $line->{'jmax'};
    my $rvertical_tightness_flags = $line->{'rvertical_tightness_flags'};
    my $Kend                      = $line->{'Kend'};
    my $level_end                 = $line->{'level_end'};

    # Check for valid hash keys at end of lifetime of $line during development
    DEVEL_MODE
      && check_keys( $line, \%valid_LINE_keys,
        "Checking line keys at valign_output_step_A", 1 );

    # add any extra spaces
    if ( $leading_space_count > $group_leader_length ) {
        $leading_space_count += $min_ci_gap;
    }

    my $str     = $rfields->[0];
    my $str_len = $rfield_lengths->[0];

    my @alignments = @{ $line->{'ralignments'} };
    if ( @alignments != $maximum_field_index + 1 ) {

        # Shouldn't happen: sub install_new_alignments makes jmax alignments
        my $jmax_alignments = @alignments - 1;
        if (DEVEL_MODE) {
            Fault(
"alignment jmax=$jmax_alignments should equal $maximum_field_index\n"
            );
        }
        $do_not_align = 1;
    }

    # loop to concatenate all fields of this line and needed padding
    my $total_pad_count = 0;
    for my $j ( 1 .. $maximum_field_index ) {

        # skip zero-length side comments
        last
          if (
            ( $j == $maximum_field_index )
            && ( !defined( $rfields->[$j] )
                || ( $rfield_lengths->[$j] == 0 ) )
          );

        # compute spaces of padding before this field
        my $col = $alignments[ $j - 1 ]->{'column'};
        my $pad = $col - ( $str_len + $leading_space_count );

        if ($do_not_align) {
            $pad =
              ( $j < $maximum_field_index )
              ? 0
              : $rOpts_minimum_space_to_comment - 1;
        }

        # if the -fpsc flag is set, move the side comment to the selected
        # column if and only if it is possible, ignoring constraints on
        # line length and minimum space to comment
        if (   $rOpts_fixed_position_side_comment
            && $j == $maximum_field_index )
        {
            my $newpad = $pad + $rOpts_fixed_position_side_comment - $col - 1;
            if ( $newpad >= 0 ) { $pad = $newpad; }
        }

        # accumulate the padding
        if ( $pad > 0 ) { $total_pad_count += $pad; }

        # only add padding when we have a finite field;
        # this avoids extra terminal spaces if we have empty fields
        if ( $rfield_lengths->[$j] > 0 ) {
            $str .= SPACE x $total_pad_count;
            $str_len += $total_pad_count;
            $total_pad_count = 0;
            $str .= $rfields->[$j];
            $str_len += $rfield_lengths->[$j];
        }
        else {
            $total_pad_count = 0;
        }
    }

    my $side_comment_length = $rfield_lengths->[$maximum_field_index];

    # ship this line off
    $self->valign_output_step_B(
        {
            leading_space_count => $leading_space_count + $extra_leading_spaces,
            line                => $str,
            line_length         => $str_len,
            side_comment_length => $side_comment_length,
            outdent_long_lines  => $outdent_long_lines,
            rvertical_tightness_flags => $rvertical_tightness_flags,
            level                     => $level,
            level_end                 => $level_end,
            Kend                      => $Kend,
            maximum_line_length       => $maximum_line_length,
        }
    );
    return;
} ## end sub valign_output_step_A

sub combine_fields {

    my ( $line_0, $line_1, $imax_align ) = @_;

    # Given:
    #   $line_0, $line_1 = two adjacent lines
    #   $imax_align = index of last alignment wanted

    # Task:
    # We have a group of two lines for which we do not want to align tokens
    # between index $imax_align and the side comment.  So we will delete fields
    # between $imax_align and the side comment.  Alignments have already
    # been set so we have to adjust them.

    if ( !defined($imax_align) ) { $imax_align = -1 }

    # First delete the unwanted tokens
    my $jmax_old = $line_0->{'jmax'};
    my @idel     = ( $imax_align + 1 .. $jmax_old - 2 );
    return if ( !@idel );

    # Get old alignments before any changes are made
    my @old_alignments = @{ $line_0->{'ralignments'} };

    foreach my $line ( $line_0, $line_1 ) {
        delete_selected_tokens( $line, \@idel );
    }

    # Now adjust the alignments.  Note that the side comment alignment
    # is always at jmax-1, and there is an ending alignment at jmax.
    my @new_alignments;
    if ( $imax_align >= 0 ) {
        @new_alignments[ 0 .. $imax_align ] =
          @old_alignments[ 0 .. $imax_align ];
    }

    my $jmax_new = $line_0->{'jmax'};

    $new_alignments[ $jmax_new - 1 ] = $old_alignments[ $jmax_old - 1 ];
    $new_alignments[$jmax_new]       = $old_alignments[$jmax_old];
    $line_0->{'ralignments'}         = \@new_alignments;
    $line_1->{'ralignments'}         = \@new_alignments;
    return;
} ## end sub combine_fields

sub get_output_line_number {

    # Return the output line number to external modules.
    # The output line number reported to a caller =
    # the number of items still in the buffer +
    # the number of items written.
    my $self = shift;
    return $self->group_line_count() +
      $self->[_file_writer_object_]->get_output_line_number();
} ## end sub get_output_line_number

###############################
# CODE SECTION 9: Output Step B
###############################

{    ## closure for sub valign_output_step_B

    # These are values for a cache used by valign_output_step_B.
    my $cached_line_text;
    my $cached_line_text_length;
    my $cached_line_type;
    my $cached_line_opening_flag;
    my $cached_line_closing_flag;
    my $cached_seqno;
    my $cached_line_valid;
    my $cached_line_leading_space_count;
    my $cached_seqno_string;
    my $cached_line_Kend;
    my $cached_line_maximum_length;

    # These are passed to step_C:
    my $seqno_string;
    my $last_nonblank_seqno_string;

    sub set_last_nonblank_seqno_string {
        my ($val) = @_;
        $last_nonblank_seqno_string = $val;
        return;
    }

    sub get_cached_line_opening_flag {
        return $cached_line_opening_flag;
    }

    sub get_cached_line_type {
        return $cached_line_type;
    }

    sub set_cached_line_valid {
        my ($val) = @_;
        $cached_line_valid = $val;
        return;
    }

    sub get_cached_seqno {
        return $cached_seqno;
    }

    sub initialize_step_B_cache {

        # valign_output_step_B cache:
        $cached_line_text                = EMPTY_STRING;
        $cached_line_text_length         = 0;
        $cached_line_type                = 0;
        $cached_line_opening_flag        = 0;
        $cached_line_closing_flag        = 0;
        $cached_seqno                    = 0;
        $cached_line_valid               = 0;
        $cached_line_leading_space_count = 0;
        $cached_seqno_string             = EMPTY_STRING;
        $cached_line_Kend                = undef;
        $cached_line_maximum_length      = undef;

        # These vars hold a string of sequence numbers joined together used by
        # the cache
        $seqno_string               = EMPTY_STRING;
        $last_nonblank_seqno_string = EMPTY_STRING;
        return;
    } ## end sub initialize_step_B_cache

    sub _flush_step_B_cache {
        my ($self) = @_;

        # Send any text in the step_B cache on to step_C
        if ($cached_line_type) {
            $seqno_string = $cached_seqno_string;
            $self->valign_output_step_C(
                $seqno_string,
                $last_nonblank_seqno_string,

                $cached_line_text,
                $cached_line_leading_space_count,
                $self->[_last_level_written_],
                $cached_line_Kend,
            );
            $cached_line_type           = 0;
            $cached_line_text           = EMPTY_STRING;
            $cached_line_text_length    = 0;
            $cached_seqno_string        = EMPTY_STRING;
            $cached_line_Kend           = undef;
            $cached_line_maximum_length = undef;
        }
        return;
    } ## end sub _flush_step_B_cache

    sub handle_cached_line {

        my ( $self, $rinput, $leading_string, $leading_string_length ) = @_;

        # handle a cached line ..
        # either append the current line to it or write it out

        # The cached line will either be:
        # - passed along to step_C, or
        # - or combined with the current line

        my $last_level_written = $self->[_last_level_written_];

        my $leading_space_count       = $rinput->{leading_space_count};
        my $str                       = $rinput->{line};
        my $str_length                = $rinput->{line_length};
        my $rvertical_tightness_flags = $rinput->{rvertical_tightness_flags};
        my $level                     = $rinput->{level};
        my $level_end                 = $rinput->{level_end};
        my $maximum_line_length       = $rinput->{maximum_line_length};

        my ( $open_or_close, $seqno_beg );
        if ($rvertical_tightness_flags) {

            $open_or_close = $rvertical_tightness_flags->{_vt_type};
            $seqno_beg     = $rvertical_tightness_flags->{_vt_seqno_beg};
        }

        # Dump an invalid cached line
        if ( !$cached_line_valid ) {
            $self->valign_output_step_C(
                $seqno_string,
                $last_nonblank_seqno_string,

                $cached_line_text,
                $cached_line_leading_space_count,
                $last_level_written,
                $cached_line_Kend,
            );
        }

        # Handle cached line ending in OPENING tokens
        elsif ( $cached_line_type == 1 || $cached_line_type == 3 ) {

            my $gap = $leading_space_count - $cached_line_text_length;

            # handle option of just one tight opening per line:
            if ( $cached_line_opening_flag == 1 ) {
                if ( defined($open_or_close) && $open_or_close == 1 ) {
                    $gap = -1;
                }
            }

            # Do not join the lines if this might produce a one-line
            # container which exceeds the maximum line length.  This is
            # necessary prevent blinking, particularly with the combination
            # -xci -pvt=2.  In that case a one-line block alternately forms
            # and breaks, causing -xci to alternately turn on and off (case
            # b765).
            # Patched to fix cases b656 b862 b971 b972: always do the check
            # if the maximum line length changes (due to -vmll).
            if (
                $gap >= 0
                && ( $maximum_line_length != $cached_line_maximum_length
                    || ( defined($level_end) && $level > $level_end ) )
              )
            {
                my $test_line_length =
                  $cached_line_text_length + $gap + $str_length;

                # Add a small tolerance in the length test (fixes case b862)
                if ( $test_line_length > $cached_line_maximum_length - 2 ) {
                    $gap = -1;
                }
            }

            if ( $gap >= 0 && defined($seqno_beg) ) {
                $maximum_line_length   = $cached_line_maximum_length;
                $leading_string        = $cached_line_text . SPACE x $gap;
                $leading_string_length = $cached_line_text_length + $gap;
                $leading_space_count   = $cached_line_leading_space_count;
                $seqno_string = $cached_seqno_string . ':' . $seqno_beg;
                $level        = $last_level_written;
            }
            else {
                $self->valign_output_step_C(
                    $seqno_string,
                    $last_nonblank_seqno_string,

                    $cached_line_text,
                    $cached_line_leading_space_count,
                    $last_level_written,
                    $cached_line_Kend,
                );
            }
        }

        # Handle cached line ending in CLOSING tokens
        else {
            my $test_line =
              $cached_line_text . SPACE x $cached_line_closing_flag . $str;
            my $test_line_length =
              $cached_line_text_length +
              $cached_line_closing_flag +
              $str_length;
            if (

                # The new line must start with container
                $seqno_beg

                # The container combination must be okay..
                && (

                    # okay to combine like types
                    ( $open_or_close == $cached_line_type )

                    # closing block brace may append to non-block
                    || ( $cached_line_type == 2 && $open_or_close == 4 )

                    # something like ');'
                    || ( !$open_or_close && $cached_line_type == 2 )

                )

                # The combined line must fit
                && ( $test_line_length <= $cached_line_maximum_length )
              )
            {

                $seqno_string = $cached_seqno_string . ':' . $seqno_beg;

                # Patch to outdent closing tokens ending # in ');' If we
                # are joining a line like ');' to a previous stacked set of
                # closing tokens, then decide if we may outdent the
                # combined stack to the indentation of the ');'.  Since we
                # should not normally outdent any of the other tokens more
                # than the indentation of the lines that contained them, we
                # will only do this if all of the corresponding opening
                # tokens were on the same line.  This can happen with -sot
                # and -sct.

                # For example, it is ok here:
                #   __PACKAGE__->load_components( qw(
                #         PK::Auto
                #         Core
                #   ));
                #
                # But, for example, we do not outdent in this example
                # because that would put the closing sub brace out farther
                # than the opening sub brace:
                #
                #   perltidy -sot -sct
                #   $c->Tk::bind(
                #       '<Control-f>' => sub {
                #           my ($c) = @_;
                #           my $e = $c->XEvent;
                #           itemsUnderArea $c;
                #       } );
                #
                if (   $str =~ /^\);/
                    && $cached_line_text =~ /^[\)\}\]\s]*$/ )
                {

                    # The way to tell this is if the stacked sequence
                    # numbers of this output line are the reverse of the
                    # stacked sequence numbers of the previous non-blank
                    # line of sequence numbers.  So we can join if the
                    # previous nonblank string of tokens is the mirror
                    # image.  For example if stack )}] is 13:8:6 then we
                    # are looking for a leading stack like [{( which
                    # is 6:8:13. We only need to check the two ends,
                    # because the intermediate tokens must fall in order.
                    # Note on speed: having to split on colons and
                    # eliminate multiple colons might appear to be slow,
                    # but it's not an issue because we almost never come
                    # through here.  In a typical file we don't.

                    $seqno_string               =~ s/^:+//;
                    $last_nonblank_seqno_string =~ s/^:+//;
                    $seqno_string               =~ s/:+/:/g;
                    $last_nonblank_seqno_string =~ s/:+/:/g;

                    # how many spaces can we outdent?
                    my $diff =
                      $cached_line_leading_space_count - $leading_space_count;
                    if (   $diff > 0
                        && length($seqno_string)
                        && length($last_nonblank_seqno_string) ==
                        length($seqno_string) )
                    {
                        my @seqno_last =
                          ( split /:/, $last_nonblank_seqno_string );
                        my @seqno_now = ( split /:/, $seqno_string );
                        if (   @seqno_now
                            && @seqno_last
                            && $seqno_now[-1] == $seqno_last[0]
                            && $seqno_now[0] == $seqno_last[-1] )
                        {

                            # OK to outdent ..
                            # for absolute safety, be sure we only remove
                            # whitespace
                            my $ws = substr( $test_line, 0, $diff );
                            if ( ( length($ws) == $diff )
                                && $ws =~ /^\s+$/ )
                            {

                                $test_line = substr( $test_line, $diff );
                                $cached_line_leading_space_count -= $diff;
                                $last_level_written =
                                  $self->level_change(
                                    $cached_line_leading_space_count,
                                    $diff, $last_level_written );
                                $self->reduce_valign_buffer_indentation($diff);
                            }

                            # shouldn't happen, but not critical:
                            ##else {
                            ## ERROR transferring indentation here
                            ##}
                        }
                    }
                }

                # Change the args to look like we received the combined line
                $str                   = $test_line;
                $str_length            = $test_line_length;
                $leading_string        = EMPTY_STRING;
                $leading_string_length = 0;
                $leading_space_count   = $cached_line_leading_space_count;
                $level                 = $last_level_written;
                $maximum_line_length   = $cached_line_maximum_length;
            }
            else {
                $self->valign_output_step_C(
                    $seqno_string,
                    $last_nonblank_seqno_string,

                    $cached_line_text,
                    $cached_line_leading_space_count,
                    $last_level_written,
                    $cached_line_Kend,
                );
            }
        }
        return ( $str, $str_length, $leading_string, $leading_string_length,
            $leading_space_count, $level, $maximum_line_length );

    } ## end sub handle_cached_line

    sub valign_output_step_B {

        #---------------------------------------------------------
        # This is Step B in writing vertically aligned lines.
        # Vertical tightness is applied according to preset flags.
        # In particular this routine handles stacking of opening
        # and closing tokens.
        #---------------------------------------------------------

        my ( $self, $rinput ) = @_;

        my $leading_space_count       = $rinput->{leading_space_count};
        my $str                       = $rinput->{line};
        my $str_length                = $rinput->{line_length};
        my $side_comment_length       = $rinput->{side_comment_length};
        my $outdent_long_lines        = $rinput->{outdent_long_lines};
        my $rvertical_tightness_flags = $rinput->{rvertical_tightness_flags};
        my $level                     = $rinput->{level};
##      my $level_end                 = $rinput->{level_end};
        my $Kend                = $rinput->{Kend};
        my $maximum_line_length = $rinput->{maximum_line_length};

        # Useful -gcs test cases for wide characters are
        # perl527/(method.t.2, reg_mesg.t, mime-header.t)

        # handle outdenting of long lines:
        my $is_outdented_line;
        if ($outdent_long_lines) {
            my $excess =
              $str_length -
              $side_comment_length +
              $leading_space_count -
              $maximum_line_length;
            if ( $excess > 0 ) {
                $leading_space_count = 0;
                my $file_writer_object = $self->[_file_writer_object_];
                my $last_outdented_line_at =
                  $file_writer_object->get_output_line_number();
                $self->[_last_outdented_line_at_] = $last_outdented_line_at;

                my $outdented_line_count = $self->[_outdented_line_count_];
                if ( !$outdented_line_count ) {
                    $self->[_first_outdented_line_at_] =
                      $last_outdented_line_at;
                }
                $outdented_line_count++;
                $self->[_outdented_line_count_] = $outdented_line_count;
                $is_outdented_line = 1;
            }
        }

        # Make preliminary leading whitespace.  It could get changed
        # later by entabbing, so we have to keep track of any changes
        # to the leading_space_count from here on.
        my $leading_string =
          $leading_space_count > 0
          ? ( SPACE x $leading_space_count )
          : EMPTY_STRING;
        my $leading_string_length = length($leading_string);

        # Unpack any recombination data; it was packed by
        # sub 'Formatter::set_vertical_tightness_flags'

        # old   hash              Meaning
        # index key
        #
        # 0   _vt_type:           1=opening non-block    2=closing non-block
        #                         3=opening block brace  4=closing block brace
        #
        # 1a  _vt_opening_flag:  1=no multiple steps, 2=multiple steps ok
        # 1b  _vt_closing_flag:    spaces of padding to use if closing
        # 2   _vt_seqno:          sequence number of container
        # 3   _vt_valid flag:     do not append if this flag is false. Will be
        #           true if appropriate -vt flag is set.  Otherwise, Will be
        #           made true only for 2 line container in parens with -lp
        # 4   _vt_seqno_beg:      sequence number of first token of line
        # 5   _vt_seqno_end:      sequence number of last token of line
        # 6   _vt_min_lines:      min number of lines for joining opening cache,
        #                           0=no constraint
        # 7   _vt_max_lines:      max number of lines for joining opening cache,
        #                           0=no constraint

        my ( $open_or_close, $opening_flag, $closing_flag, $seqno, $valid,
            $seqno_beg, $seqno_end );
        if ($rvertical_tightness_flags) {

            $open_or_close = $rvertical_tightness_flags->{_vt_type};
            $opening_flag  = $rvertical_tightness_flags->{_vt_opening_flag};
            $closing_flag  = $rvertical_tightness_flags->{_vt_closing_flag};
            $seqno         = $rvertical_tightness_flags->{_vt_seqno};
            $valid         = $rvertical_tightness_flags->{_vt_valid_flag};
            $seqno_beg     = $rvertical_tightness_flags->{_vt_seqno_beg};
            $seqno_end     = $rvertical_tightness_flags->{_vt_seqno_end};
        }

        $seqno_string = $seqno_end;

        # handle any cached line ..
        # either append this line to it or write it out
        # Note: the function length() is used in this next test out of caution.
        # All testing has shown that the variable $cached_line_text_length is
        # correct, but its calculation is complex and a loss of cached text
        # would be a disaster.
        if ( length($cached_line_text) ) {

            (
                $str,
                $str_length,
                $leading_string,
                $leading_string_length,
                $leading_space_count,
                $level,
                $maximum_line_length

            ) = $self->handle_cached_line( $rinput, $leading_string,
                $leading_string_length );

            $cached_line_type           = 0;
            $cached_line_text           = EMPTY_STRING;
            $cached_line_text_length    = 0;
            $cached_line_Kend           = undef;
            $cached_line_maximum_length = undef;

        }

        # make the line to be written
        my $line        = $leading_string . $str;
        my $line_length = $leading_string_length + $str_length;

        # Safety check: be sure that a line to be cached as a stacked block
        # brace line ends in the appropriate opening or closing block brace.
        # This should always be the case if the caller set flags correctly.
        # Code '3' is for -sobb, code '4' is for -scbb.
        if ($open_or_close) {
            if (   $open_or_close == 3 && $line !~ /\{\s*$/
                || $open_or_close == 4 && $line !~ /\}\s*$/ )
            {
                $open_or_close = 0;
            }
        }

        # write or cache this line ...
        # fix for case b999: do not cache an outdented line
        # fix for b1378: do not cache an empty line
        if (  !$open_or_close
            || $side_comment_length > 0
            || $is_outdented_line
            || !$line_length )
        {
            $self->valign_output_step_C(
                $seqno_string,
                $last_nonblank_seqno_string,

                $line,
                $leading_space_count,
                $level,
                $Kend,
            );
        }
        else {
            $cached_line_text                = $line;
            $cached_line_text_length         = $line_length;
            $cached_line_type                = $open_or_close;
            $cached_line_opening_flag        = $opening_flag;
            $cached_line_closing_flag        = $closing_flag;
            $cached_seqno                    = $seqno;
            $cached_line_valid               = $valid;
            $cached_line_leading_space_count = $leading_space_count;
            $cached_seqno_string             = $seqno_string;
            $cached_line_Kend                = $Kend;
            $cached_line_maximum_length      = $maximum_line_length;
        }

        $self->[_last_level_written_]       = $level;
        $self->[_last_side_comment_length_] = $side_comment_length;
        return;
    } ## end sub valign_output_step_B
}

################################
# CODE SECTION 10: Output Step C
################################

{    ## closure for sub valign_output_step_C

    # Vertical alignment buffer used by valign_output_step_C
    my $valign_buffer_filling;
    my @valign_buffer;

    sub initialize_valign_buffer {
        @valign_buffer         = ();
        $valign_buffer_filling = EMPTY_STRING;
        return;
    }

    sub dump_valign_buffer {
        my ($self) = @_;

        # Send all lines in the current buffer on to step_D
        if (@valign_buffer) {
            foreach (@valign_buffer) {
                $self->valign_output_step_D( @{$_} );
            }
            @valign_buffer = ();
        }
        $valign_buffer_filling = EMPTY_STRING;
        return;
    } ## end sub dump_valign_buffer

    sub reduce_valign_buffer_indentation {

        my ( $self, $diff ) = @_;

        # Reduce the leading indentation of lines in the current
        # buffer by $diff spaces
        if ( $valign_buffer_filling && $diff ) {
            my $max_valign_buffer = @valign_buffer;
            foreach my $i ( 0 .. $max_valign_buffer - 1 ) {
                my ( $line, $leading_space_count, $level, $Kend ) =
                  @{ $valign_buffer[$i] };
                my $ws = substr( $line, 0, $diff );
                if ( ( length($ws) == $diff ) && $ws =~ /^\s+$/ ) {
                    $line = substr( $line, $diff );
                }
                if ( $leading_space_count >= $diff ) {
                    $leading_space_count -= $diff;
                    $level =
                      $self->level_change( $leading_space_count, $diff,
                        $level );
                }
                $valign_buffer[$i] =
                  [ $line, $leading_space_count, $level, $Kend ];
            }
        }
        return;
    } ## end sub reduce_valign_buffer_indentation

    sub valign_output_step_C {

        #-----------------------------------------------------------------------
        # This is Step C in writing vertically aligned lines.
        # Lines are either stored in a buffer or passed along to the next step.
        # The reason for storing lines is that we may later want to reduce their
        # indentation when -sot and -sct are both used.
        #-----------------------------------------------------------------------
        my (
            $self,
            $seqno_string,
            $last_nonblank_seqno_string,

            @args_to_D,
        ) = @_;

        # Dump any saved lines if we see a line with an unbalanced opening or
        # closing token.
        $self->dump_valign_buffer()
          if ( $seqno_string && $valign_buffer_filling );

        # Either store or write this line
        if ($valign_buffer_filling) {
            push @valign_buffer, [@args_to_D];
        }
        else {
            $self->valign_output_step_D(@args_to_D);
        }

        # For lines starting or ending with opening or closing tokens..
        if ($seqno_string) {
            $last_nonblank_seqno_string = $seqno_string;
            set_last_nonblank_seqno_string($seqno_string);

            # Start storing lines when we see a line with multiple stacked
            # opening tokens.
            # patch for RT #94354, requested by Colin Williams
            if (   index( $seqno_string, ':' ) >= 0
                && $seqno_string =~ /^\d+(\:+\d+)+$/
                && $args_to_D[0] !~ /^[\}\)\]\:\?]/ )
            {

                # This test is efficient but a little subtle: The first test
                # says that we have multiple sequence numbers and hence
                # multiple opening or closing tokens in this line.  The second
                # part of the test rejects stacked closing and ternary tokens.
                # So if we get here then we should have stacked unbalanced
                # opening tokens.

                # Here is a complex example:

                # Foo($Bar[0], {  # (side comment)
                #     baz => 1,
                # });

                # The first line has sequence 6::4.  It does not begin with
                # a closing token or ternary, so it passes the test and must be
                # stacked opening tokens.

                # The last line has sequence 4:6 but is a stack of closing
                # tokens, so it gets rejected.

                # Note that the sequence number of an opening token for a qw
                # quote is a negative number and will be rejected.  For
                # example, for the following line: skip_symbols([qw(
                # $seqno_string='10:5:-1'.  It would be okay to accept it but I
                # decided not to do this after testing.

                $valign_buffer_filling = $seqno_string;

            }
        }
        return;
    } ## end sub valign_output_step_C
}

###############################
# CODE SECTION 11: Output Step D
###############################

sub add_leading_tabs {

    my ( $line, $leading_space_count, $level ) = @_;

    # Convert leading whitespace to use tabs if -et or -t are set

    # Given:
    #   $line = the line of text to be written, without any tabs
    #   $leading_whitespace = expected number of leading blank spaces
    #   $level = indentation level (needed for -t)

    # Return:
    #   $line = the line with possible leading tabs

    my $trimmed_line = $line;
    $trimmed_line =~ s/^ [^\S\n]+ //gxm;

    # Check for discrepancy in actual leading white spaces with estimate
    if ( length($line) != length($trimmed_line) + $leading_space_count ) {

        # If $leading_space_count is zero, then this routine must not
        # be called because we might be in a quote of some kind
        if ( $leading_space_count <= 0 ) {
            DEVEL_MODE && Fault(<<EOM);
should not be here with leading space count = $leading_space_count
EOM
            return $line;
        }

        my $leading_space_count_test = length($line) - length($trimmed_line);

        # Skip tabbing if actual whitespace is less than expected
        if ( $leading_space_count_test < $leading_space_count ) {
            DEBUG_TABS
              && warning(<<EOM);
Error entabbing: expected count=$leading_space_count but only found $leading_space_count_test for line:
'$line'
EOM
            return $line;
        }

        # Use actual whitespace if it exceeds prediction. This mainly
        # occurs at hanging side comments.
        $leading_space_count = $leading_space_count_test;
    }

    #----------------------------------
    # Handle --entab-leading-whitespace
    #----------------------------------
    if ($rOpts_entab_leading_whitespace) {

        my $space_count =
          $leading_space_count % $rOpts_entab_leading_whitespace;
        my $tab_count =
          int( $leading_space_count / $rOpts_entab_leading_whitespace );
        my $leading_string = "\t" x $tab_count . SPACE x $space_count;
        $line = $leading_string . $trimmed_line;
    }

    #-----------------------------------------------
    # Handle -t (one tab per level; not recommended)
    #-----------------------------------------------
    elsif ( $rOpts_tabs && $level ) {

        my $leading_string = ( "\t" x $level );
        my $space_count = $leading_space_count - $level * $rOpts_indent_columns;

        # shouldn't happen:
        if ( $space_count < 0 ) {

            # But it could be an outdented comment
            if ( $line !~ /^\s*#/ ) {
                DEBUG_TABS
                  && warning(
"Error entabbing in valign_output_step_D: for level=$level count=$leading_space_count\n"
                  );
            }
            $leading_string = ( SPACE x $leading_space_count );
        }
        else {
            $leading_string .= ( SPACE x $space_count );
        }
        $line = $leading_string . $trimmed_line;
    }

    # nothing to do; we should have skipped a call to this sub
    else {
        if (DEVEL_MODE) {
            Fault(
"in tab sub but neither -t nor -et set: check flag 'require_tabs'\n"
            );
        }
    }
    return $line;
} ## end sub add_leading_tabs

sub valign_output_step_D {

    #----------------------------------------------------------------
    # This is Step D in writing vertically aligned lines.
    # It is the end of the vertical alignment pipeline.
    # Write one vertically aligned line of code to the output object.
    #----------------------------------------------------------------

    my ( $self, $line, $leading_space_count, $level, $Kend ) = @_;

    # Convert leading whitespace to use tabs if requested.
    if ( $require_tabs && $leading_space_count > 0 ) {
        $line = add_leading_tabs( $line, $leading_space_count, $level );
    }

    my $file_writer_object = $self->[_file_writer_object_];
    $file_writer_object->write_code_line( $line . "\n", $Kend );

    return;
} ## end sub valign_output_step_D

##########################
# CODE SECTION 12: Summary
##########################

sub report_anything_unusual {
    my $self = shift;

    my $outdented_line_count = $self->[_outdented_line_count_];
    if ( $outdented_line_count > 0 ) {
        write_logfile_entry(
            "$outdented_line_count long lines were outdented:\n");
        my $first_outdented_line_at = $self->[_first_outdented_line_at_];
        write_logfile_entry(
            "  First at output line $first_outdented_line_at\n");

        if ( $outdented_line_count > 1 ) {
            my $last_outdented_line_at = $self->[_last_outdented_line_at_];
            write_logfile_entry(
                "   Last at output line $last_outdented_line_at\n");
        }
        write_logfile_entry(
            "  use -noll to prevent outdenting, -l=n to increase line length\n"
        );
        write_logfile_entry("\n");
    }
    return;
} ## end sub report_anything_unusual

} ## end package Perl::Tidy::VerticalAligner
1;
 #####################################################################
#
# Perl::Tidy::Tokenizer reads a source and breaks it into a stream of tokens
#
# Usage Outline:
#
#   STEP 1: initialize or re-initialize Tokenizer with user options
#     Perl::Tidy::Tokenizer::check_options($rOpts);
#
#   STEP 2: create a tokenizer for a specific input source object
#     my $tokenizer = Perl::Tidy::Tokenizer->new(
#         source_object      => $source,
#         ...
#     );
#
#   STEP 3: get and process each tokenized 'line' (a hash ref of token info)
#    while ( my $line = $tokenizer->get_line() ) {
#        $formatter->write_line($line);
#    }
#
#   STEP 4: report errors
#    my $severe_error = $tokenizer->report_tokenization_errors();
#
# The source object can be a STRING ref, an ARRAY ref, or an object with a
# get_line() method which supplies one line (a character string) perl call.
#
# NOTE: This is not a real class.  Only one tokenizer my be used.
#
########################################################################

package Perl::Tidy::Tokenizer;
use strict;
use warnings;
use English qw( -no_match_vars );

our $VERSION = '20250105';

use Carp;

use constant DEVEL_MODE   => 0;
use constant EMPTY_STRING => q{};
use constant SPACE        => q{ };
use constant BACKSLASH    => q{\\};

{ #<<< A non-indenting brace to contain all lexical variables

# Parent sequence number of tree of containers; must be 1
use constant SEQ_ROOT => 1;

# Defaults for guessing old indentation
use constant INDENT_COLUMNS_DEFAULT => 4;
use constant TAB_SIZE_DEFAULT       => 8;

# Decimal values of some ascii characters for quick checks
use constant ORD_TAB           => 9;
use constant ORD_SPACE         => 32;
use constant ORD_PRINTABLE_MIN => 33;
use constant ORD_PRINTABLE_MAX => 126;

# A limit on message length when problems are detected
use constant LONG_MESSAGE => 256;

# GLOBAL VARIABLES which change during tokenization:
# These could also be stored in $self but it is more convenient and
# efficient to make them global lexical variables.
# INITIALIZER: sub prepare_for_a_new_file
my (

    $brace_depth,
    $context,
    $current_package,
    $last_nonblank_block_type,
    $last_nonblank_token,
    $last_nonblank_type,
    $next_sequence_number,
    $paren_depth,
    $rbrace_context,
    $rbrace_package,
    $rbrace_structural_type,
    $rbrace_type,
    $rcurrent_depth,
    $rcurrent_sequence_number,
    $rdepth_array,
    $ris_block_function,
    $ris_block_list_function,
    $ris_constant,
    $ris_user_function,
    $rnested_statement_type,
    $rnested_ternary_flag,
    $rparen_semicolon_count,
    $rparen_vars,
    $rparen_type,
    $rsaw_function_definition,
    $rsaw_use_module,
    $rsquare_bracket_structural_type,
    $rsquare_bracket_type,
    $rstarting_line_of_current_depth,
    $rtotal_depth,
    $ruser_function_prototype,
    $square_bracket_depth,
    $statement_type,
    $total_depth,
);

my (

    # GLOBAL CONSTANTS for routines in this package,
    # INITIALIZER: BEGIN block.
    %can_start_digraph,
    %expecting_operator_token,
    %expecting_operator_types,
    %expecting_term_token,
    %expecting_term_types,
    %is_block_operator,
    %is_digraph,
    %is_file_test_operator,
    %is_if_elsif_unless,
    %is_if_elsif_unless_case_when,
    %is_indirect_object_taker,
    %is_keyword_rejecting_question_as_pattern_delimiter,
    %is_keyword_rejecting_slash_as_pattern_delimiter,
    %is_keyword_taking_list,
    %is_keyword_taking_optional_arg,
    %is_q_qq_qw_qx_qr_s_y_tr_m,
    %is_q_qq_qx_qr_s_y_tr_m,
    %quote_modifiers,
    %is_semicolon_or_t,
    %is_sort_map_grep,
    %is_sort_map_grep_eval_do,
    %is_tetragraph,
    %is_trigraph,
    %is_valid_token_type,
    %other_line_endings,
    %really_want_term,
    @closing_brace_names,
    @opening_brace_names,

    # GLOBAL CONSTANT hash lookup table of operator expected values
    # INITIALIZER: BEGIN block
    %op_expected_table,

    # GLOBAL VARIABLES which are constant after being configured.
    # INITIALIZER: BEGIN block and modified by sub check_options
    %is_code_block_token,
    %is_keyword,
    %is_my_our_state,
    %is_package,
    %matching_end_token,

    # INITIALIZER: sub check_options
    $code_skipping_pattern_begin,
    $code_skipping_pattern_end,
    $format_skipping_pattern_begin,
    $format_skipping_pattern_end,

    $rOpts_code_skipping,
    $rOpts_code_skipping_begin,
    $rOpts_format_skipping,
    $rOpts_format_skipping_begin,
    $rOpts_format_skipping_end,
    $rOpts_starting_indentation_level,
    $rOpts_indent_columns,
    $rOpts_look_for_hash_bang,
    $rOpts_look_for_autoloader,
    $rOpts_look_for_selfloader,
    $rOpts_trim_qw,
    $rOpts_extended_syntax,
    $rOpts_continuation_indentation,
    $rOpts_outdent_labels,
    $rOpts_maximum_level_errors,
    $rOpts_maximum_unexpected_errors,
    $rOpts_indent_closing_brace,
    $rOpts_non_indenting_braces,
    $rOpts_non_indenting_brace_prefix,
    $rOpts_whitespace_cycle,

    $tabsize,
    %is_END_DATA_format_sub,
    %is_grep_alias,
    %is_sub,
    $guess_if_method,
);

# possible values of operator_expected()
use constant TERM     => -1;
use constant UNKNOWN  => 0;
use constant OPERATOR => 1;

# possible values of context
use constant SCALAR_CONTEXT  => -1;
use constant UNKNOWN_CONTEXT => 0;
use constant LIST_CONTEXT    => 1;

# Maximum number of little messages; probably need not be changed.
use constant MAX_NAG_MESSAGES => 6;

BEGIN {

    # Array index names for $self.
    # Do not combine with other BEGIN blocks (c101).
    my $i = 0;
    use constant {
        _rhere_target_list_                  => $i++,
        _in_here_doc_                        => $i++,
        _here_doc_target_                    => $i++,
        _here_quote_character_               => $i++,
        _in_data_                            => $i++,
        _in_end_                             => $i++,
        _in_format_                          => $i++,
        _in_error_                           => $i++,
        _in_trouble_                         => $i++,
        _warning_count_                      => $i++,
        _html_tag_count_                     => $i++,
        _in_pod_                             => $i++,
        _in_code_skipping_                   => $i++,
        _in_format_skipping_                 => $i++,
        _in_attribute_list_                  => $i++,
        _in_quote_                           => $i++,
        _quote_target_                       => $i++,
        _line_start_quote_                   => $i++,
        _starting_level_                     => $i++,
        _know_starting_level_                => $i++,
        _last_line_number_                   => $i++,
        _saw_perl_dash_P_                    => $i++,
        _saw_perl_dash_w_                    => $i++,
        _saw_use_strict_                     => $i++,
        _saw_brace_error_                    => $i++,
        _hit_bug_                            => $i++,
        _look_for_autoloader_                => $i++,
        _look_for_selfloader_                => $i++,
        _saw_autoloader_                     => $i++,
        _saw_selfloader_                     => $i++,
        _saw_hash_bang_                      => $i++,
        _saw_end_                            => $i++,
        _saw_data_                           => $i++,
        _saw_negative_indentation_           => $i++,
        _started_tokenizing_                 => $i++,
        _debugger_object_                    => $i++,
        _diagnostics_object_                 => $i++,
        _logger_object_                      => $i++,
        _save_logfile_                       => $i++,
        _unexpected_error_count_             => $i++,
        _started_looking_for_here_target_at_ => $i++,
        _nearly_matched_here_target_at_      => $i++,
        _line_of_text_                       => $i++,
        _rlower_case_labels_at_              => $i++,
        _maximum_level_                      => $i++,
        _true_brace_error_count_             => $i++,
        _rOpts_                              => $i++,
        _rinput_lines_                       => $i++,
        _input_line_index_next_              => $i++,
        _rtrimmed_input_lines_               => $i++,
        _rclosing_brace_indentation_hash_    => $i++,
        _show_indentation_table_             => $i++,
        _rnon_indenting_brace_stack_         => $i++,
        _rbareword_info_                     => $i++,
    };
} ## end BEGIN

{    ## closure for subs to count instances

    # methods to count instances
    my $_count = 0;
    sub get_count        { return $_count; }
    sub _increment_count { return ++$_count }
    sub _decrement_count { return --$_count }
}

sub DESTROY {
    my $self = shift;
    _decrement_count();
    return;
}

sub AUTOLOAD {

    # Catch any undefined sub calls so that we are sure to get
    # some diagnostic information.  This sub should never be called
    # except for a programming error.
    our $AUTOLOAD;
    return if ( $AUTOLOAD =~ /\bDESTROY$/ );
    my ( $pkg, $fname, $lno ) = caller();
    my $my_package = __PACKAGE__;
    print {*STDERR} <<EOM;
======================================================================
Error detected in package '$my_package', version $VERSION
Received unexpected AUTOLOAD call for sub '$AUTOLOAD'
Called from package: '$pkg'
Called from File '$fname'  at line '$lno'
This error is probably due to a recent programming change
======================================================================
EOM
    exit 1;
} ## end sub AUTOLOAD

sub Die {
    my ($msg) = @_;
    Perl::Tidy::Die($msg);
    croak "unexpected return from Perl::Tidy::Die";
}

sub Fault {
    my ( $self, $msg ) = @_;

    # This routine is called for errors that really should not occur
    # except if there has been a bug introduced by a recent program change.
    # Please add comments at calls to Fault to explain why the call
    # should not occur, and where to look to fix it.
    my ( $package0_uu, $filename0_uu, $line0,    $subroutine0_uu ) = caller(0);
    my ( $package1_uu, $filename1,    $line1,    $subroutine1 )    = caller(1);
    my ( $package2_uu, $filename2_uu, $line2_uu, $subroutine2 )    = caller(2);
    my $pkg = __PACKAGE__;

    # Catch potential error of Fault not called as a method
    my $input_stream_name;
    if ( !ref($self) ) {
        $msg = "Fault not called as a method - please fix\n";
        if ( $self && length($self) < LONG_MESSAGE ) { $msg .= $self }
        $self              = undef;
        $input_stream_name = "(UNKNOWN)";
    }
    else {
        $input_stream_name = $self->get_input_stream_name();
    }

    Die(<<EOM);
==============================================================================
While operating on input stream with name: '$input_stream_name'
A fault was detected at line $line0 of sub '$subroutine1'
in file '$filename1'
which was called from line $line1 of sub '$subroutine2'
Message: '$msg'
This is probably an error introduced by a recent programming change.
$pkg reports VERSION='$VERSION'.
==============================================================================
EOM

    croak "unexpected return from sub Die";
} ## end sub Fault

sub bad_pattern {
    my ($pattern) = @_;

    # Return true if a regex pattern has an error
    # Note: Formatter.pm also has a copy of this
    my $regex_uu = eval { qr/$pattern/ };
    return $EVAL_ERROR;
} ## end sub bad_pattern

sub make_skipping_pattern {
    my ( $rOpts, $opt_name, $default ) = @_;

    # Make regex patterns for the format-skipping and code-skipping options
    my $param = $rOpts->{$opt_name};
    if ( !$param ) { $param = $default }
    $param =~ s/^\s+//;
    if ( $param !~ /^#/ ) {
        Die("ERROR: the $opt_name parameter '$param' must begin with '#'\n");
    }

    # Note that the ending \s will match a newline
    my $pattern = '^\s*' . $param . '\s';
    if ( bad_pattern($pattern) ) {
        Die(
"ERROR: the $opt_name parameter '$param' causes the invalid regex '$pattern'\n"
        );
    }
    return $pattern;
} ## end sub make_skipping_pattern

sub check_options {

    # Check and pre-process tokenizer parameters
    my $rOpts = shift;

    %is_sub = ();
    $is_sub{'sub'} = 1;

    %is_END_DATA_format_sub = (
        '__END__'  => 1,
        '__DATA__' => 1,
        'format'   => 1,
        'sub'      => 1,
    );

    # Install any aliases to 'sub'
    if ( $rOpts->{'sub-alias-list'} ) {

        # Note that any 'sub-alias-list' has been preprocessed to
        # be a trimmed, space-separated list which includes 'sub'
        # for example, it might be 'sub method fun'
        my @sub_alias_list = split /\s+/, $rOpts->{'sub-alias-list'};
        foreach my $word (@sub_alias_list) {
            $is_sub{$word}                 = 1;
            $is_END_DATA_format_sub{$word} = 1;
        }
    }

    # Set global flag to say if we have to guess if bareword 'method' is
    # a sub when 'method' is in %is_sub. This will be true unless:
    #   (1) the user entered 'method' as sub alias, or
    #   (2) the user set --use-feature=class
    # In these two cases we can assume that 'method' is a sub alias.
    $guess_if_method = 1;
    if ( $is_sub{'method'} ) { $guess_if_method = 0 }

    #------------------------------------------------
    # Update hash values for any -use-feature options
    #------------------------------------------------

    my $use_feature_class = 1;
    if ( $rOpts->{'use-feature'} ) {
        if ( $rOpts->{'use-feature'} =~ /\bnoclass\b/ ) {
            $use_feature_class = 0;
        }
        elsif ( $rOpts->{'use-feature'} =~ /\bclass\b/ ) {
            $guess_if_method = 0;
        }
        else {
            ## neither 'class' nor 'noclass' seen so use default
        }
    }

    # These are the main updates for this option. There are additional
    # changes elsewhere, usually indicated with a comment 'rt145706'

    # Update hash values for use_feature=class, added for rt145706
    # see 'perlclass.pod'

    # IMPORTANT: We are changing global hash values initially set in a BEGIN
    # block.  Values must be defined (true or false) for each of these new
    # words whether true or false. Otherwise, programs using the module which
    # change options between runs (such as test code) will have
    # incorrect settings and fail.

    # There are 4 new keywords:

    # 'class' - treated specially as generalization of 'package'
    # Note: we must not set 'class' to be a keyword to avoid problems
    # with older uses.
    $is_package{'class'} = $use_feature_class;

    # 'method' - treated like sub using the sub-alias-list option
    # Note: we must not set 'method' to be a keyword to avoid problems
    # with older uses.
    if ($use_feature_class) {
        $is_sub{'method'}                 = 1;
        $is_END_DATA_format_sub{'method'} = 1;
    }

    # 'field'  - added as a keyword, and works like 'my'
    $is_keyword{'field'}      = $use_feature_class;
    $is_my_our_state{'field'} = $use_feature_class;

    # 'ADJUST' - added as a keyword and works like 'BEGIN'
    # TODO: if ADJUST gets a paren list, this will need to be updated
    $is_keyword{'ADJUST'}          = $use_feature_class;
    $is_code_block_token{'ADJUST'} = $use_feature_class;

    %is_grep_alias = ();
    if ( $rOpts->{'grep-alias-list'} ) {

        # Note that 'grep-alias-list' has been preprocessed to be a trimmed,
        # space-separated list
        my @q = split /\s+/, $rOpts->{'grep-alias-list'};
        @is_grep_alias{@q} = (1) x scalar(@q);
    }

    $rOpts_starting_indentation_level = $rOpts->{'starting-indentation-level'};
    $rOpts_indent_columns             = $rOpts->{'indent-columns'};
    $rOpts_look_for_hash_bang         = $rOpts->{'look-for-hash-bang'};
    $rOpts_look_for_autoloader        = $rOpts->{'look-for-autoloader'};
    $rOpts_look_for_selfloader        = $rOpts->{'look-for-selfloader'};
    $rOpts_trim_qw                    = $rOpts->{'trim-qw'};
    $rOpts_extended_syntax            = $rOpts->{'extended-syntax'};
    $rOpts_continuation_indentation   = $rOpts->{'continuation-indentation'};
    $rOpts_outdent_labels             = $rOpts->{'outdent-labels'};
    $rOpts_maximum_level_errors       = $rOpts->{'maximum-level-errors'};
    $rOpts_maximum_unexpected_errors  = $rOpts->{'maximum-unexpected-errors'};
    $rOpts_code_skipping              = $rOpts->{'code-skipping'};
    $rOpts_code_skipping_begin        = $rOpts->{'code-skipping-begin'};
    $rOpts_format_skipping            = $rOpts->{'format-skipping'};
    $rOpts_format_skipping_begin      = $rOpts->{'format-skipping-begin'};
    $rOpts_format_skipping_end        = $rOpts->{'format-skipping-end'};
    $rOpts_indent_closing_brace       = $rOpts->{'indent-closing-brace'};
    $rOpts_non_indenting_braces       = $rOpts->{'non-indenting-braces'};
    $rOpts_non_indenting_brace_prefix = $rOpts->{'non-indenting-brace-prefix'};
    $rOpts_whitespace_cycle           = $rOpts->{'whitespace-cycle'};

    # In the Tokenizer, --indent-columns is just used for guessing old
    # indentation, and must be positive.  If -i=0 is used for this run (which
    # is possible) we'll just guess that the old run used 4 spaces per level.
    if ( !$rOpts_indent_columns ) {
        $rOpts_indent_columns = INDENT_COLUMNS_DEFAULT;
    }

    # Define $tabsize, the number of spaces per tab for use in
    # guessing the indentation of source lines with leading tabs.
    # Assume same as for this run if tabs are used, otherwise assume
    # a default value, typically 8
    $tabsize =
        $rOpts->{'entab-leading-whitespace'}
      ? $rOpts->{'entab-leading-whitespace'}
      : $rOpts->{'tabs'} ? $rOpts->{'indent-columns'}
      :                    $rOpts->{'default-tabsize'};
    if ( !$tabsize ) { $tabsize = TAB_SIZE_DEFAULT }

    $code_skipping_pattern_begin =
      make_skipping_pattern( $rOpts, 'code-skipping-begin', '#<<V' );
    $code_skipping_pattern_end =
      make_skipping_pattern( $rOpts, 'code-skipping-end', '#>>V' );

    $format_skipping_pattern_begin =
      make_skipping_pattern( $rOpts, 'format-skipping-begin', '#<<<' );
    $format_skipping_pattern_end =
      make_skipping_pattern( $rOpts, 'format-skipping-end', '#>>>' );

    return;
} ## end sub check_options

sub new {

    my ( $class, @arglist ) = @_;
    if ( @arglist % 2 ) { croak "Odd number of items in arg hash list\n" }

    my %defaults = (
        source_object        => undef,
        debugger_object      => undef,
        diagnostics_object   => undef,
        logger_object        => undef,
        starting_level       => undef,
        starting_line_number => 1,
        rOpts                => {},
    );
    my %args = ( %defaults, @arglist );

    # we are given an object with a get_line() method to supply source lines
    my $source_object = $args{source_object};
    my $rOpts         = $args{rOpts};

    # Check call args
    if ( !defined($source_object) ) {
        Die(
"Perl::Tidy::Tokenizer::new called without a 'source_object' parameter\n"
        );
    }
    if ( !ref($source_object) ) {
        Die(<<EOM);
sub Perl::Tidy::Tokenizer::new received a 'source_object' parameter which is not a reference;
'source_object' must be a reference to a STRING, ARRAY, or object with a 'getline' method
EOM
    }

    my $logger_object = $args{logger_object};

    # Tokenizer state data is as follows:
    # _rhere_target_list_    reference to list of here-doc targets
    # _here_doc_target_      the target string for a here document
    # _here_quote_character_ the type of here-doc quoting (" ' ` or none)
    #                        to determine if interpolation is done
    # _quote_target_         character we seek if chasing a quote
    # _line_start_quote_     line where we started looking for a long quote
    # _in_here_doc_          flag indicating if we are in a here-doc
    # _in_pod_               flag set if we are in pod documentation
    # _in_code_skipping_     flag set if we are in a code skipping section
    # _in_format_skipping_   flag set if we are in a format skipping section
    # _in_error_             flag set if we saw severe error (binary in script)
    # _in_trouble_           set if we saw a troublesome lexical like 'my sub s'
    # _warning_count_        number of calls to logger sub warning
    # _html_tag_count_       number of apparent html tags seen (indicates html)
    # _in_data_              flag set if we are in __DATA__ section
    # _in_end_               flag set if we are in __END__ section
    # _in_format_            flag set if we are in a format description
    # _in_attribute_list_    flag telling if we are looking for attributes
    # _in_quote_             flag telling if we are chasing a quote
    # _starting_level_       indentation level of first line
    # _diagnostics_object_   place to write debugging information
    # _unexpected_error_count_ error count used to limit output
    # _lower_case_labels_at_ line numbers where lower case labels seen
    # _hit_bug_              program bug detected

    my $self = [];
    $self->[_rhere_target_list_]        = [];
    $self->[_in_here_doc_]              = 0;
    $self->[_here_doc_target_]          = EMPTY_STRING;
    $self->[_here_quote_character_]     = EMPTY_STRING;
    $self->[_in_data_]                  = 0;
    $self->[_in_end_]                   = 0;
    $self->[_in_format_]                = 0;
    $self->[_in_error_]                 = 0;
    $self->[_in_trouble_]               = 0;
    $self->[_warning_count_]            = 0;
    $self->[_html_tag_count_]           = 0;
    $self->[_in_pod_]                   = 0;
    $self->[_in_code_skipping_]         = 0;
    $self->[_in_format_skipping_]       = 0;
    $self->[_in_attribute_list_]        = 0;
    $self->[_in_quote_]                 = 0;
    $self->[_quote_target_]             = EMPTY_STRING;
    $self->[_line_start_quote_]         = -1;
    $self->[_starting_level_]           = $args{starting_level};
    $self->[_know_starting_level_]      = defined( $args{starting_level} );
    $self->[_last_line_number_]         = $args{starting_line_number} - 1;
    $self->[_saw_perl_dash_P_]          = 0;
    $self->[_saw_perl_dash_w_]          = 0;
    $self->[_saw_use_strict_]           = 0;
    $self->[_saw_brace_error_]          = 0;
    $self->[_hit_bug_]                  = 0;
    $self->[_look_for_autoloader_]      = $rOpts_look_for_autoloader;
    $self->[_look_for_selfloader_]      = $rOpts_look_for_selfloader;
    $self->[_saw_autoloader_]           = 0;
    $self->[_saw_selfloader_]           = 0;
    $self->[_saw_hash_bang_]            = 0;
    $self->[_saw_end_]                  = 0;
    $self->[_saw_data_]                 = 0;
    $self->[_saw_negative_indentation_] = 0;
    $self->[_started_tokenizing_]       = 0;
    $self->[_debugger_object_]          = $args{debugger_object};
    $self->[_diagnostics_object_]       = $args{diagnostics_object};
    $self->[_logger_object_]            = $logger_object;
    $self->[_unexpected_error_count_]   = 0;
    $self->[_started_looking_for_here_target_at_] = 0;
    $self->[_nearly_matched_here_target_at_]      = undef;
    $self->[_line_of_text_]                       = EMPTY_STRING;
    $self->[_rlower_case_labels_at_]              = undef;
    $self->[_maximum_level_]                      = 0;
    $self->[_true_brace_error_count_]             = 0;
    $self->[_rnon_indenting_brace_stack_]         = [];
    $self->[_show_indentation_table_]             = 0;
    $self->[_rbareword_info_]                     = {};

    $self->[_rclosing_brace_indentation_hash_] = {
        valid                 => undef,
        rhistory_line_number  => [0],
        rhistory_level_diff   => [0],
        rhistory_anchor_point => [1],
    };

    $self->[_rOpts_] = $rOpts;
    $self->[_save_logfile_] =
      defined($logger_object) && $logger_object->get_save_logfile();

    bless $self, $class;

    $self->prepare_for_a_new_file($source_object);
    $self->find_starting_indentation_level();

    # This is not a full class yet, so die if an attempt is made to
    # create more than one object.

    if ( _increment_count() > 1 ) {
        confess
"Attempt to create more than 1 object in $class, which is not a true class yet\n";
    }

    return $self;

} ## end sub new

# Called externally
sub get_unexpected_error_count {
    my ($self) = @_;
    return $self->[_unexpected_error_count_];
}

# Called externally
sub is_keyword {
    my ($str) = @_;
    return $is_keyword{$str};
}

#----------------------------------------------------------------
# Line input routines, previously handled by the LineBuffer class
#----------------------------------------------------------------
sub make_source_array {

    my ( $self, $line_source_object ) = @_;

    # Convert the source into an array of lines
    # Given:
    #   $line_source_object = the input source stream
    # Task:
    #   Convert the source to an array ref and store in $self

    my $rinput_lines = [];

    my $rsource = ref($line_source_object);
    my $source_string;

    if ( !$rsource ) {

        # shouldn't happen: this should have been checked in sub new
        $self->Fault(<<EOM);
sub Perl::Tidy::Tokenizer::new received a 'source_object' parameter which is not a reference;
'source_object' must be a reference to a STRING, ARRAY, or object with a 'getline' method
EOM
    }

    # handle an ARRAY ref
    elsif ( $rsource eq 'ARRAY' ) {
        $rinput_lines  = $line_source_object;
        $source_string = join( EMPTY_STRING, @{$line_source_object} );
    }

    # handle a SCALAR ref
    elsif ( $rsource eq 'SCALAR' ) {
        $source_string = ${$line_source_object};
        my @lines = split /^/, $source_string;
        $rinput_lines = \@lines;
    }

    # handle an object - must have a get_line method
    else {

        # This will die if user's object does have a 'get_line' method
        my $line;
        while ( defined( $line = $line_source_object->get_line() ) ) {
            push( @{$rinput_lines}, $line );
        }
        $source_string = join( EMPTY_STRING, @{$rinput_lines} );
    }

    # Get trimmed lines. It is much faster to strip leading whitespace from
    # the whole input file at once than line-by-line.

    # Add a terminal newline if needed to keep line count unchanged:
    # - avoids problem of losing a last line which is just \r and no \n  (c283)
    # - but check input line count to avoid adding line to an empty file (c286)
    if ( @{$rinput_lines} && $source_string !~ /\n$/ ) {
        $source_string .= "\n";
    }

    # Remove leading whitespace except newlines
    $source_string =~ s/^ [^\S\n]+ //gxm;

    # Then break the string into lines
    my @trimmed_lines = split /^/, $source_string;

    # Safety check - a change in number of lines would be a disaster
    if ( @trimmed_lines != @{$rinput_lines} ) {

        # Shouldn't happen - die in DEVEL_MODE and fix
        my $ntr = @trimmed_lines;
        my $utr = @{$rinput_lines};
        DEVEL_MODE
          && $self->Fault(
            "trimmed / untrimmed line counts differ: $ntr / $utr\n");

        # Otherwise we can safely continue with undefined trimmed lines.  They
        # will be detected and fixed later.
        @trimmed_lines = ();
    }

    $self->[_rinput_lines_]          = $rinput_lines;
    $self->[_rtrimmed_input_lines_]  = \@trimmed_lines;
    $self->[_input_line_index_next_] = 0;
    return;
} ## end sub make_source_array

sub peek_ahead {
    my ( $self, $buffer_index ) = @_;

    # look $buffer_index lines ahead of the current location in the input
    # stream without disturbing the input
    my $line;
    my $rinput_lines = $self->[_rinput_lines_];
    my $line_index   = $buffer_index + $self->[_input_line_index_next_];
    if ( $line_index < @{$rinput_lines} ) {
        $line = $rinput_lines->[$line_index];
    }
    return $line;
} ## end sub peek_ahead

#-----------------------------------------
# interface to Perl::Tidy::Logger routines
#-----------------------------------------
sub warning {

    my ( $self, $msg ) = @_;

    my $logger_object = $self->[_logger_object_];
    $self->[_warning_count_]++;
    if ($logger_object) {
        my $msg_line_number = $self->[_last_line_number_];
        $logger_object->warning( $msg, $msg_line_number );
    }
    return;
} ## end sub warning

sub get_input_stream_name {

    my $self = shift;

    my $input_stream_name = EMPTY_STRING;
    my $logger_object     = $self->[_logger_object_];
    if ($logger_object) {
        $input_stream_name = $logger_object->get_input_stream_name();
    }
    return $input_stream_name;
} ## end sub get_input_stream_name

sub complain {

    my ( $self, $msg ) = @_;

    my $logger_object = $self->[_logger_object_];
    if ($logger_object) {
        my $input_line_number = $self->[_last_line_number_];
        $logger_object->complain( $msg, $input_line_number );
    }
    return;
} ## end sub complain

sub write_logfile_entry {

    my ( $self, $msg ) = @_;

    my $logger_object = $self->[_logger_object_];
    if ($logger_object) {
        $logger_object->write_logfile_entry($msg);
    }
    return;
} ## end sub write_logfile_entry

sub interrupt_logfile {

    my $self = shift;

    my $logger_object = $self->[_logger_object_];
    if ($logger_object) {
        $logger_object->interrupt_logfile();
    }
    return;
} ## end sub interrupt_logfile

sub resume_logfile {

    my $self = shift;

    my $logger_object = $self->[_logger_object_];
    if ($logger_object) {
        $logger_object->resume_logfile();
    }
    return;
} ## end sub resume_logfile

sub brace_warning {
    my ( $self, $msg ) = @_;
    $self->[_saw_brace_error_]++;

    my $logger_object = $self->[_logger_object_];
    if ($logger_object) {
        my $msg_line_number = $self->[_last_line_number_];
        $logger_object->brace_warning( $msg, $msg_line_number );
    }
    return;
} ## end sub brace_warning

sub increment_brace_error {

    # This is same as sub brace_warning but without a message
    my $self = shift;
    $self->[_saw_brace_error_]++;

    my $logger_object = $self->[_logger_object_];
    if ($logger_object) {
        $logger_object->increment_brace_error();
    }
    return;
} ## end sub increment_brace_error

sub get_saw_brace_error {
    my $self = shift;
    return $self->[_saw_brace_error_];
}

sub report_definite_bug {
    my $self = shift;
    $self->[_hit_bug_] = 1;
    my $logger_object = $self->[_logger_object_];
    if ($logger_object) {
        $logger_object->report_definite_bug();
    }
    return;
} ## end sub report_definite_bug

#-------------------------------------
# Interface to Perl::Tidy::Diagnostics
#-------------------------------------
sub write_diagnostics {
    my ( $self, $msg ) = @_;
    my $input_line_number  = $self->[_last_line_number_];
    my $diagnostics_object = $self->[_diagnostics_object_];
    if ($diagnostics_object) {
        $diagnostics_object->write_diagnostics( $msg, $input_line_number );
    }
    return;
} ## end sub write_diagnostics

sub report_tokenization_errors {

    my ($self) = @_;

    # Report any tokenization errors and return a flag '$severe_error'.
    # Set $severe_error = 1 if the tokenization errors are so severe that
    # the formatter should not attempt to format the file. Instead, it will
    # just output the file verbatim.

    # set severe error flag if tokenizer has encountered file reading problems
    # (i.e. unexpected binary characters)
    # or code which may not be formatted correctly (such as 'my sub q')
    # The difference between _in_error_ and _in_trouble_ is that
    # _in_error_ stops the tokenizer immediately whereas
    # _in_trouble_ lets the tokenizer finish so that all errors are seen
    # Both block formatting and cause the input stream to be output verbatim.
    my $severe_error = $self->[_in_error_] || $self->[_in_trouble_];

    # And do not format if it looks like an html file (c209)
    $severe_error ||= $self->[_html_tag_count_] && $self->[_warning_count_];

    # Inform the logger object on length of input stream
    my $logger_object = $self->[_logger_object_];
    if ($logger_object) {
        my $last_line_number = $self->[_last_line_number_];
        $logger_object->set_last_input_line_number($last_line_number);
    }

    my $maxle = $rOpts_maximum_level_errors;
    my $maxue = $rOpts_maximum_unexpected_errors;
    $maxle = 1 unless defined($maxle);
    $maxue = 0 unless defined($maxue);

    my $level = get_indentation_level();
    if ( $level != $self->[_starting_level_] ) {
        $self->warning("final indentation level: $level\n");

        $self->[_show_indentation_table_] = 1;

        my $level_diff = $self->[_starting_level_] - $level;
        if ( $level_diff < 0 ) { $level_diff = -$level_diff }

        # Set severe error flag if the level error is greater than 1.
        # The formatter can function for any level error but it is probably
        # best not to attempt formatting for a high level error.
        if ( $maxle >= 0 && $level_diff > $maxle ) {
            $severe_error = 1;
            $self->warning(<<EOM);
Formatting will be skipped because level error '$level_diff' exceeds -maxle=$maxle; use -maxle=-1 to force formatting
EOM
        }
    }

    $self->check_final_nesting_depths();

    if ( $self->[_show_indentation_table_] ) {
        $self->show_indentation_table();
    }

    # Likewise, large numbers of brace errors usually indicate non-perl
    # scripts, so set the severe error flag at a low number.  This is similar
    # to the level check, but different because braces may balance but be
    # incorrectly interlaced.
    if ( $self->[_true_brace_error_count_] > 2 ) {
        $severe_error = 1;
    }

    if ( $rOpts_look_for_hash_bang
        && !$self->[_saw_hash_bang_] )
    {
        $self->warning(
            "hit EOF without seeing hash-bang line; maybe don't need -x?\n");
    }

    if ( $self->[_in_format_] ) {
        $self->warning("hit EOF while in format description\n");
    }

    if ( $self->[_in_code_skipping_] ) {
        $self->write_logfile_entry(
            "hit EOF while in lines skipped with --code-skipping\n");
    }

    if ( $self->[_in_pod_] ) {

        # Just write log entry if this is after __END__ or __DATA__
        # because this happens to often, and it is not likely to be
        # a parsing error.
        if ( $self->[_saw_data_] || $self->[_saw_end_] ) {
            $self->write_logfile_entry(
"hit eof while in pod documentation (no =cut seen)\n\tthis can cause trouble with some pod utilities\n"
            );
        }

        else {
            $self->complain(
"hit eof while in pod documentation (no =cut seen)\n\tthis can cause trouble with some pod utilities\n"
            );
        }

    }

    if ( $self->[_in_here_doc_] ) {
        $severe_error = 1;
        my $here_doc_target = $self->[_here_doc_target_];
        my $started_looking_for_here_target_at =
          $self->[_started_looking_for_here_target_at_];
        if ($here_doc_target) {
            $self->warning(
"hit EOF in here document starting at line $started_looking_for_here_target_at with target: $here_doc_target\n"
            );
        }
        else {
            $self->warning(<<EOM);
Hit EOF in here document starting at line $started_looking_for_here_target_at with empty target string.
  (Perl will match to the end of file but this may not be intended).
EOM
        }
        my $nearly_matched_here_target_at =
          $self->[_nearly_matched_here_target_at_];
        if ($nearly_matched_here_target_at) {
            $self->warning(
"NOTE: almost matched at input line $nearly_matched_here_target_at except for whitespace\n"
            );
        }
    }

    # Something is seriously wrong if we ended inside a quote
    if ( $self->[_in_quote_] ) {
        $severe_error = 1;
        my $line_start_quote = $self->[_line_start_quote_];
        my $quote_target     = $self->[_quote_target_];
        my $what =
          ( $self->[_in_attribute_list_] )
          ? "attribute list"
          : "quote/pattern";
        $self->warning(
"hit EOF seeking end of $what starting at line $line_start_quote ending in $quote_target\n"
        );
    }

    if ( $self->[_hit_bug_] ) {
        $severe_error = 1;
    }

    # Multiple "unexpected" type tokenization errors usually indicate parsing
    # non-perl scripts, or that something is seriously wrong, so we should
    # avoid formatting them.  This can happen for example if we run perltidy on
    # a shell script or an html file.  But unfortunately this check can
    # interfere with some extended syntaxes, such as RPerl, so it has to be off
    # by default.
    my $ue_count = $self->[_unexpected_error_count_];
    if ( $maxue > 0 && $ue_count > $maxue ) {
        $self->warning(<<EOM);
Formatting will be skipped since unexpected token count = $ue_count > -maxue=$maxue; use -maxue=0 to force formatting
EOM
        $severe_error = 1;
    }

    if ( !$self->[_saw_perl_dash_w_] ) {
        $self->write_logfile_entry("Suggest including 'use warnings;'\n");
    }

    if ( $self->[_saw_perl_dash_P_] ) {
        $self->write_logfile_entry(
            "Use of -P parameter for defines is discouraged\n");
    }

    if ( !$self->[_saw_use_strict_] ) {
        $self->write_logfile_entry("Suggest including 'use strict;'\n");
    }

    # it is suggested that labels have at least one upper case character
    # for legibility and to avoid code breakage as new keywords are introduced
    if ( $self->[_rlower_case_labels_at_] ) {
        my @lower_case_labels_at = @{ $self->[_rlower_case_labels_at_] };
        $self->write_logfile_entry(
            "Suggest using upper case characters in label(s)\n");
        local $LIST_SEPARATOR = ')(';
        $self->write_logfile_entry(
            "  defined at line(s): (@lower_case_labels_at)\n");
    }
    return $severe_error;
} ## end sub report_tokenization_errors

sub show_indentation_table {
    my ($self) = @_;

    # Output indentation table made at closing braces.  This can be helpful for
    # the case of a missing brace in a previously formatted file.

    # skip if -wc is used (rare); it is too complex to use
    return if ($rOpts_whitespace_cycle);

    # skip if non-indenting-brace-prefix (very rare, but could be fixed)
    return if ($rOpts_non_indenting_brace_prefix);

    # skip if starting level is not zero (probably in editor)
    return if ($rOpts_starting_indentation_level);

    # skip if indentation analysis is not valid
    my $rhash = $self->[_rclosing_brace_indentation_hash_];
    return if ( !$rhash->{valid} );

    my $rhistory_line_number  = $rhash->{rhistory_line_number};
    my $rhistory_level_diff   = $rhash->{rhistory_level_diff};
    my $rhistory_anchor_point = $rhash->{rhistory_anchor_point};

    # Remove the first artificial point from the table
    shift @{$rhistory_line_number};
    shift @{$rhistory_level_diff};
    shift @{$rhistory_anchor_point};

    # Remove dubious points at an anchor point = 2 and beyond
    # These can occur when non-indenting braces are used
    my $num_his = @{$rhistory_level_diff};
    foreach my $i ( 0 .. $num_his - 1 ) {
        if ( $rhistory_anchor_point->[$i] == 2 ) {
            $num_his = $i;
            last;
        }
    }
    return if ( $num_his <= 1 );

    # Ignore an ending non-anchor point
    if ( !$rhistory_anchor_point->[-1] ) {
        $num_his -= 1;
    }

    # Ignore an ending point which is the same as the previous point
    if ( $num_his > 1 ) {
        if ( $rhistory_level_diff->[ $num_his - 1 ] ==
            $rhistory_level_diff->[ $num_his - 2 ] )
        {
            $num_his -= 1;
        }
    }

    # skip if the table does not have at least 2 points to pinpoint an error
    return if ( $num_his <= 1 );

    # skip if first point shows a level error - the analysis may not be valid
    return if ( $rhistory_level_diff->[0] );

    # Since the table could be arbitrarily large, we will limit the table to N
    # lines.  If there are more lines than that, we will show N-3 lines, then
    # ..., then the last 2 lines. Allow about 3 lines per error, so a table
    # limit of 10 can localize up to about 3 errors in a file.
    my $nlines_max   = 10;
    my @pre_indexes  = ( 0 .. $num_his - 1 );
    my @post_indexes = ();
    if ( @pre_indexes > $nlines_max ) {
        if ( $nlines_max >= 5 ) {
            @pre_indexes  = ( 0 .. $nlines_max - 4 );
            @post_indexes = ( $num_his - 2, $num_his - 1 );
        }
        else {
            @pre_indexes = ( 0 .. $nlines_max - 1 );
        }
    }

    my @output_lines;
    push @output_lines, <<EOM;
Table of nesting level differences at closing braces.
This might help localize brace errors if the file was previously formatted.
line: error=[new brace level]-[old indentation level]
EOM
    foreach my $i (@pre_indexes) {
        my $lno  = $rhistory_line_number->[$i];
        my $diff = $rhistory_level_diff->[$i];
        push @output_lines, <<EOM;
$lno: $diff
EOM
    }
    if (@post_indexes) {
        push @output_lines, "...\n";
        foreach my $i (@post_indexes) {
            my $lno  = $rhistory_line_number->[$i];
            my $diff = $rhistory_level_diff->[$i];
            push @output_lines, <<EOM;
$lno: $diff
EOM
        }
    }
    push @output_lines, "\n";
    my $output_str = join EMPTY_STRING, @output_lines;

    $self->interrupt_logfile();
    $self->warning($output_str);
    $self->resume_logfile();

    return;
} ## end sub show_indentation_table

sub report_v_string {

    # warn if this version can't handle v-strings
    my ( $self, $tok ) = @_;
    if ( $] < 5.006 ) {
        $self->warning(
"Found v-string '$tok' but v-strings are not implemented in your version of perl; see Camel 3 book ch 2\n"
        );
    }
    return;
} ## end sub report_v_string

sub is_valid_token_type {
    my ($type) = @_;
    return $is_valid_token_type{$type};
}

sub log_numbered_msg {
    my ( $self, $msg ) = @_;

    # write input line number + message to logfile
    my $input_line_number = $self->[_last_line_number_];
    $self->write_logfile_entry("Line $input_line_number: $msg");
    return;
} ## end sub log_numbered_msg

sub get_line {

    my $self = shift;

    # Read the next input line and tokenize it
    # Returns:
    #   $line_of_tokens = ref to hash of info for the tokenized line

    # USES GLOBAL VARIABLES:
    #   $brace_depth, $square_bracket_depth, $paren_depth

    # get the next line from the input array
    my $input_line;
    my $trimmed_input_line;
    my $line_index   = $self->[_input_line_index_next_];
    my $rinput_lines = $self->[_rinput_lines_];
    if ( $line_index < @{$rinput_lines} ) {
        $trimmed_input_line = $self->[_rtrimmed_input_lines_]->[$line_index];
        $input_line         = $rinput_lines->[ $line_index++ ];
        $self->[_input_line_index_next_] = $line_index;
    }

    $self->[_line_of_text_] = $input_line;

    return if ( !defined($input_line) );

    my $input_line_number = ++$self->[_last_line_number_];

    # Find and remove what characters terminate this line, including any
    # control r
    my $input_line_separator = EMPTY_STRING;
    if ( chomp $input_line ) {
        $input_line_separator = $INPUT_RECORD_SEPARATOR;
    }

    # The first test here very significantly speeds things up, but be sure to
    # keep the regex and hash %other_line_endings the same.
    if ( $other_line_endings{ substr( $input_line, -1 ) } ) {
        if ( $input_line =~ s/([\r\035\032])+$// ) {
            $input_line_separator = $1 . $input_line_separator;

            # This could make the trimmed input line incorrect, so the
            # safe thing to do is to make it undef to force it to be
            # recomputed later.
            $trimmed_input_line = undef;
        }
    }

    # For backwards compatibility we keep the line text terminated with
    # a newline character
    $input_line .= "\n";
    $self->[_line_of_text_] = $input_line;

    # create a data structure describing this line which will be
    # returned to the caller.

    # _line_type codes are:
    #   SYSTEM         - system-specific code before hash-bang line
    #   CODE           - line of perl code (including comments)
    #   POD_START      - line starting pod, such as '=head'
    #   POD            - pod documentation text
    #   POD_END        - last line of pod section, '=cut'
    #   HERE           - text of here-document
    #   HERE_END       - last line of here-doc (target word)
    #   FORMAT         - format section
    #   FORMAT_END     - last line of format section, '.'
    #   SKIP           - code skipping section
    #   SKIP_END       - last line of code skipping section, '#>>V'
    #   DATA_START     - __DATA__ line
    #   DATA           - unidentified text following __DATA__
    #   END_START      - __END__ line
    #   END            - unidentified text following __END__
    #   ERROR          - we are in big trouble, probably not a perl script

    # Other variables:
    #   _curly_brace_depth     - depth of curly braces at start of line
    #   _square_bracket_depth  - depth of square brackets at start of line
    #   _paren_depth           - depth of parens at start of line
    #   _starting_in_quote     - this line continues a multi-line quote
    #                            (so don't trim leading blanks!)
    #   _ending_in_quote       - this line ends in a multi-line quote
    #                            (so don't trim trailing blanks!)
    my $line_of_tokens = {
        _line_type                 => 'EOF',
        _line_text                 => $input_line,
        _line_number               => $input_line_number,
        _guessed_indentation_level => 0,
        _curly_brace_depth         => $brace_depth,
        _square_bracket_depth      => $square_bracket_depth,
        _paren_depth               => $paren_depth,
## Skip these needless initializations for efficiency:
##      _rtoken_type               => undef,
##      _rtokens                   => undef,
##      _rlevels                   => undef,
##      _rblock_type               => undef,
##      _rtype_sequence            => undef,
##      _starting_in_quote         => 0,
##      _ending_in_quote           => 0,
    };

    # must print line unchanged if we are in a here document
    if ( $self->[_in_here_doc_] ) {

        $line_of_tokens->{_line_type} = 'HERE';
        my $here_doc_target      = $self->[_here_doc_target_];
        my $here_quote_character = $self->[_here_quote_character_];
        my $candidate_target     = $input_line;
        chomp $candidate_target;

        # Handle <<~ targets, which are indicated here by a leading space on
        # the here quote character
        if ( $here_quote_character =~ /^\s/ ) {
            $candidate_target =~ s/^\s+//;
        }
        if ( $candidate_target eq $here_doc_target ) {
            $self->[_nearly_matched_here_target_at_] = undef;
            $line_of_tokens->{_line_type} = 'HERE_END';
            $self->log_numbered_msg("Exiting HERE document $here_doc_target\n");

            my $rhere_target_list = $self->[_rhere_target_list_];
            if ( @{$rhere_target_list} ) {  # there can be multiple here targets
                ( $here_doc_target, $here_quote_character ) =
                  @{ shift @{$rhere_target_list} };
                $self->[_here_doc_target_]      = $here_doc_target;
                $self->[_here_quote_character_] = $here_quote_character;
                $self->log_numbered_msg(
                    "Entering HERE document $here_doc_target\n");
                $self->[_nearly_matched_here_target_at_] = undef;
                $self->[_started_looking_for_here_target_at_] =
                  $input_line_number;
            }
            else {
                $self->[_in_here_doc_]          = 0;
                $self->[_here_doc_target_]      = EMPTY_STRING;
                $self->[_here_quote_character_] = EMPTY_STRING;
            }
        }

        # check for error of extra whitespace
        # note for PERL6: leading whitespace is allowed
        else {
            $candidate_target =~ s/^ \s+ | \s+ $//gx;    # trim both ends
            if ( $candidate_target eq $here_doc_target ) {
                $self->[_nearly_matched_here_target_at_] = $input_line_number;
            }
        }
        return $line_of_tokens;
    }

    # Print line unchanged if we are in a format section
    elsif ( $self->[_in_format_] ) {

        if ( $input_line =~ /^\.[\s#]*$/ ) {

            # Decrement format depth count at a '.' after a 'format'
            $self->[_in_format_]--;

            # This is the end when count reaches 0
            if ( !$self->[_in_format_] ) {
                $self->log_numbered_msg("Exiting format section\n");
                $line_of_tokens->{_line_type} = 'FORMAT_END';

                # Make the tokenizer mark an opening brace which follows
                # as a code block. Fixes issue c202/t032.
                $last_nonblank_token = ';';
                $last_nonblank_type  = ';';
            }
        }
        else {
            $line_of_tokens->{_line_type} = 'FORMAT';
            if ( $input_line =~ /^\s*format\s+\w+/ ) {

                # Increment format depth count at a 'format' within a 'format'
                # This is a simple way to handle nested formats (issue c019).
                $self->[_in_format_]++;
            }
        }
        return $line_of_tokens;
    }

    # must print line unchanged if we are in pod documentation
    elsif ( $self->[_in_pod_] ) {

        $line_of_tokens->{_line_type} = 'POD';
        if ( $input_line =~ /^=cut/ ) {
            $line_of_tokens->{_line_type} = 'POD_END';
            $self->log_numbered_msg("Exiting POD section\n");
            $self->[_in_pod_] = 0;
        }
        if ( $input_line =~ /^\#\!.*perl\b/ && !$self->[_in_end_] ) {
            $self->warning(
                "Hash-bang in pod can cause older versions of perl to fail! \n"
            );
        }

        return $line_of_tokens;
    }

    # print line unchanged if in skipped section
    elsif ( $self->[_in_code_skipping_] ) {

        $line_of_tokens->{_line_type} = 'SKIP';
        if ( $input_line =~ /$code_skipping_pattern_end/ ) {
            $line_of_tokens->{_line_type} = 'SKIP_END';
            $self->log_numbered_msg("Exiting code-skipping section\n");
            $self->[_in_code_skipping_] = 0;
        }
        elsif ( $input_line =~ /$code_skipping_pattern_begin/ ) {

            # warn of duplicate starting comment lines, git #118
            my $lno = $self->[_in_code_skipping_];
            $self->warning(
                "Already in code-skipping section which started at line $lno\n"
            );
        }
        else {
            # not a code-skipping control line
        }
        return $line_of_tokens;
    }

    # must print line unchanged if we have seen a severe error (i.e., we
    # are seeing illegal tokens and cannot continue.  Syntax errors do
    # not pass this route).  Calling routine can decide what to do, but
    # the default can be to just pass all lines as if they were after __END__
    elsif ( $self->[_in_error_] ) {
        $line_of_tokens->{_line_type} = 'ERROR';
        return $line_of_tokens;
    }

    # print line unchanged if we are __DATA__ section
    elsif ( $self->[_in_data_] ) {

        # ...but look for POD
        # Note that the _in_data and _in_end flags remain set
        # so that we return to that state after seeing the
        # end of a pod section
        if ( $input_line =~ /^=(\w+)\b/ && $1 ne 'cut' ) {
            $line_of_tokens->{_line_type} = 'POD_START';
            $self->log_numbered_msg("Entering POD section\n");
            $self->[_in_pod_] = 1;
            return $line_of_tokens;
        }
        else {
            $line_of_tokens->{_line_type} = 'DATA';
            return $line_of_tokens;
        }
    }

    # print line unchanged if we are in __END__ section
    elsif ( $self->[_in_end_] ) {

        # ...but look for POD
        # Note that the _in_data and _in_end flags remain set
        # so that we return to that state after seeing the
        # end of a pod section
        if ( $input_line =~ /^=(\w+)\b/ && $1 ne 'cut' ) {
            $line_of_tokens->{_line_type} = 'POD_START';
            $self->log_numbered_msg("Entering POD section\n");
            $self->[_in_pod_] = 1;
            return $line_of_tokens;
        }
        else {
            $line_of_tokens->{_line_type} = 'END';
            return $line_of_tokens;
        }
    }
    else {
        # not a special control line
    }

    # check for a hash-bang line if we haven't seen one
    if (   !$self->[_saw_hash_bang_]
        && substr( $input_line, 0, 2 ) eq '#!'
        && $input_line =~ /^\#\!.*perl\b/ )
    {
        $self->[_saw_hash_bang_] = $input_line_number;

        # check for -w and -P flags
        if ( $input_line =~ /^\#\!.*perl\s.*-.*P/ ) {
            $self->[_saw_perl_dash_P_] = 1;
        }

        if ( $input_line =~ /^\#\!.*perl\s.*-.*w/ ) {
            $self->[_saw_perl_dash_w_] = 1;
        }

        if (
            $input_line_number > 1

            # leave any hash bang in a BEGIN block alone
            # i.e. see 'debugger-duck_type.t'
            && !(
                   $last_nonblank_block_type
                && $last_nonblank_block_type eq 'BEGIN'
            )
            && !$rOpts_look_for_hash_bang

            # Try to avoid giving a false alarm at a simple comment.
            # These look like valid hash-bang lines:

            #!/usr/bin/perl -w
            #!   /usr/bin/perl -w
            #!c:\perl\bin\perl.exe

            # These are comments:
            #! I love perl
            #!  sunos does not yet provide a /usr/bin/perl

            # Comments typically have multiple spaces, which suggests
            # the filter
            && $input_line =~ /^\#\!(\s+)?(\S+)?perl/
          )
        {

            # this is helpful for VMS systems; we may have accidentally
            # tokenized some DCL commands
            if ( $self->[_started_tokenizing_] ) {
                $self->warning(
"There seems to be a hash-bang after line 1; do you need to run with -x ?\n"
                );
            }
            else {
                $self->complain("Useless hash-bang after line 1\n");
            }
        }

        # Report the leading hash-bang as a system line
        # This will prevent -dac from deleting it
        else {
            $line_of_tokens->{_line_type} = 'SYSTEM';
            return $line_of_tokens;
        }
    }

    # wait for a hash-bang before parsing if the user invoked us with -x
    if ( $rOpts_look_for_hash_bang
        && !$self->[_saw_hash_bang_] )
    {
        $line_of_tokens->{_line_type} = 'SYSTEM';
        return $line_of_tokens;
    }

    # a first line of the form ': #' will be marked as SYSTEM
    # since lines of this form may be used by tcsh
    if ( $input_line_number == 1 && $input_line =~ /^\s*\:\s*\#/ ) {
        $line_of_tokens->{_line_type} = 'SYSTEM';
        return $line_of_tokens;
    }

    # now we know that it is ok to tokenize the line...
    # the line tokenizer will modify any of these private variables:
    #        _rhere_target_list_
    #        _in_data_
    #        _in_end_
    #        _in_format_
    #        _in_error_
    #        _in_code_skipping_
    #        _in_format_skipping_
    #        _in_pod_
    #        _in_quote_

    $self->tokenize_this_line( $line_of_tokens, $trimmed_input_line );

    # Now finish defining the return structure and return it
    $line_of_tokens->{_ending_in_quote} = $self->[_in_quote_];

    # handle severe error (binary data in script)
    if ( $self->[_in_error_] ) {
        $self->[_in_quote_] = 0;    # to avoid any more messages
        $self->warning("Giving up after error\n");
        $line_of_tokens->{_line_type} = 'ERROR';
        reset_indentation_level(0);    # avoid error messages
        return $line_of_tokens;
    }

    # handle start of pod documentation
    if ( $self->[_in_pod_] ) {

        # This gets tricky..above a __DATA__ or __END__ section, perl
        # accepts '=cut' as the start of pod section. But afterwards,
        # only pod utilities see it and they may ignore an =cut without
        # leading =head.  In any case, this isn't good.
        if ( $input_line =~ /^=cut\b/ ) {
            if ( $self->[_saw_data_] || $self->[_saw_end_] ) {
                $self->complain("=cut while not in pod ignored\n");
                $self->[_in_pod_] = 0;
                $line_of_tokens->{_line_type} = 'POD_END';
            }
            else {
                $line_of_tokens->{_line_type} = 'POD_START';
                if ( !DEVEL_MODE ) {
                    $self->warning(
"=cut starts a pod section .. this can fool pod utilities.\n"
                    );
                }
                $self->log_numbered_msg("Entering POD section\n");
            }
        }

        else {
            $line_of_tokens->{_line_type} = 'POD_START';
            $self->log_numbered_msg("Entering POD section\n");
        }

        return $line_of_tokens;
    }

    # handle start of skipped section
    if ( $self->[_in_code_skipping_] ) {

        $line_of_tokens->{_line_type} = 'SKIP';
        $self->log_numbered_msg("Entering code-skipping section\n");
        return $line_of_tokens;
    }

    # see if this line contains here doc targets
    my $rhere_target_list = $self->[_rhere_target_list_];
    if ( @{$rhere_target_list} ) {

        my ( $here_doc_target, $here_quote_character ) =
          @{ shift @{$rhere_target_list} };
        $self->[_in_here_doc_]          = 1;
        $self->[_here_doc_target_]      = $here_doc_target;
        $self->[_here_quote_character_] = $here_quote_character;
        $self->log_numbered_msg("Entering HERE document $here_doc_target\n");
        $self->[_started_looking_for_here_target_at_] = $input_line_number;
    }

    # NOTE: __END__ and __DATA__ statements are written unformatted
    # because they can theoretically contain additional characters
    # which are not tokenized (and cannot be read with <DATA> either!).
    if ( $self->[_in_data_] ) {
        $line_of_tokens->{_line_type} = 'DATA_START';
        $self->log_numbered_msg("Starting __DATA__ section\n");
        $self->[_saw_data_] = 1;

        # keep parsing after __DATA__ if use SelfLoader was seen
        if ( $self->[_saw_selfloader_] ) {
            $self->[_in_data_] = 0;
            $self->log_numbered_msg(
                "SelfLoader seen, continuing; -nlsl deactivates\n");
        }

        return $line_of_tokens;
    }

    elsif ( $self->[_in_end_] ) {
        $line_of_tokens->{_line_type} = 'END_START';
        $self->log_numbered_msg("Starting __END__ section\n");
        $self->[_saw_end_] = 1;

        # keep parsing after __END__ if use AutoLoader was seen
        if ( $self->[_saw_autoloader_] ) {
            $self->[_in_end_] = 0;
            $self->log_numbered_msg(
                "AutoLoader seen, continuing; -nlal deactivates\n");
        }
        return $line_of_tokens;
    }
    else {
        # not in __END__ or __DATA__
    }

    # now, finally, we know that this line is type 'CODE'
    $line_of_tokens->{_line_type} = 'CODE';

    # remember if we have seen any real code
    if (  !$self->[_started_tokenizing_]
        && $input_line !~ /^\s*$/
        && $input_line !~ /^\s*#/ )
    {
        $self->[_started_tokenizing_] = 1;
    }

    if ( $self->[_debugger_object_] ) {
        $self->[_debugger_object_]->write_debug_entry($line_of_tokens);
    }

    # Note: if keyword 'format' occurs in this line code, it is still CODE
    # (keyword 'format' need not start a line)
    if ( $self->[_in_format_] ) {
        $self->log_numbered_msg("Entering format section\n");
    }

    if ( $self->[_in_quote_]
        and ( $self->[_line_start_quote_] < 0 ) )
    {
        if ( ( my $quote_target = $self->[_quote_target_] ) !~ /^\s*$/ ) {
            $self->[_line_start_quote_] = $input_line_number;
            $self->log_numbered_msg(
                "Start multi-line quote or pattern ending in $quote_target\n");
        }
    }
    elsif ( ( $self->[_line_start_quote_] >= 0 )
        && !$self->[_in_quote_] )
    {
        $self->[_line_start_quote_] = -1;
        $self->log_numbered_msg("End of multi-line quote or pattern\n");
    }
    else {
        # not at the edge of a quote
    }

    # we are returning a line of CODE
    return $line_of_tokens;
} ## end sub get_line

sub find_starting_indentation_level {

    # We need to find the indentation level of the first line of the
    # script being formatted.  Often it will be zero for an entire file,
    # but if we are formatting a local block of code (within an editor for
    # example) it may not be zero.  The user may specify this with the
    # -sil=n parameter but normally doesn't so we have to guess.
    #
    my ($self) = @_;
    my $starting_level = 0;

    # use value if given as parameter
    if ( $self->[_know_starting_level_] ) {
        $starting_level = $self->[_starting_level_];
    }

    # if we know there is a hash_bang line, the level must be zero
    elsif ($rOpts_look_for_hash_bang) {
        $self->[_know_starting_level_] = 1;
    }

    # otherwise figure it out from the input file
    else {
        my $line;
        my $i = 0;

        # keep looking at lines until we find a hash bang or piece of code
        # ( or, for now, an =pod line)
        my $msg = EMPTY_STRING;
        my $in_code_skipping;
        my $line_for_guess;
        while ( defined( $line = $self->peek_ahead( $i++ ) ) ) {

            # if first line is #! then assume starting level is zero
            if ( $i == 1 && $line =~ /^\#\!/ ) {
                $starting_level = 0;
                last;
            }

            # ignore lines fenced off with code-skipping comments
            if ( $line =~ /^\s*#/ ) {

                # use first comment for indentation guess in case of no code
                if ( !defined($line_for_guess) ) { $line_for_guess = $line }

                if ( !$in_code_skipping ) {
                    if (   $rOpts_code_skipping
                        && $line =~ /$code_skipping_pattern_begin/ )
                    {
                        $in_code_skipping = 1;
                        next;
                    }
                }
                else {
                    if ( $line =~ /$code_skipping_pattern_end/ ) {
                        $in_code_skipping = 0;
                    }
                    next;
                }

                # Note that we could also ignore format-skipping lines here
                # but it isn't clear if that would be best.
                # See c326 for example code.

                next;
            }
            next if ($in_code_skipping);

            next if ( $line =~ /^\s*$/ );    # skip past blank lines

            # use first line of code for indentation guess
            $line_for_guess = $line;
            last;
        } ## end while ( defined( $line = ...))

        if ( defined($line_for_guess) ) {
            $starting_level =
              $self->guess_old_indentation_level($line_for_guess);
        }
        $msg = "Line $i implies starting-indentation-level = $starting_level\n";
        $self->write_logfile_entry("$msg");
    }
    $self->[_starting_level_] = $starting_level;
    reset_indentation_level($starting_level);
    return;
} ## end sub find_starting_indentation_level

sub guess_old_indentation_level {
    my ( $self, $line ) = @_;

    # Guess the indentation level of an input line.
    #
    # For the first line of code this result will define the starting
    # indentation level.  It will mainly be non-zero when perltidy is applied
    # within an editor to a local block of code.
    #
    # This is an impossible task in general because we can't know what tabs
    # meant for the old script and how many spaces were used for one
    # indentation level in the given input script.  For example it may have
    # been previously formatted with -i=7 -et=3.  But we can at least try to
    # make sure that perltidy guesses correctly if it is applied repeatedly to
    # a block of code within an editor, so that the block stays at the same
    # level when perltidy is applied repeatedly.
    #
    # USES GLOBAL VARIABLES: (none)
    my $level = 0;

    # find leading tabs, spaces, and any statement label
    my $spaces = 0;
    if ( $line =~ /^(\t+)?(\s+)?(\w+:[^:])?/ ) {

        # If there are leading tabs, we use the tab scheme for this run, if
        # any, so that the code will remain stable when editing.
        if ($1) { $spaces += length($1) * $tabsize }

        if ($2) { $spaces += length($2) }

        # correct for outdented labels
        if (   $3
            && $rOpts_outdent_labels
            && $rOpts_continuation_indentation > 0 )
        {
            $spaces += $rOpts_continuation_indentation;
        }
    }

    $level = int( $spaces / $rOpts_indent_columns );
    return ($level);
} ## end sub guess_old_indentation_level

sub dump_functions {

    # This is an unused debug routine, save for future use

    my $fh = *STDOUT;
    foreach my $pkg ( keys %{$ris_user_function} ) {
        $fh->print("\nnon-constant subs in package $pkg\n");

        foreach my $sub ( keys %{ $ris_user_function->{$pkg} } ) {
            my $msg = EMPTY_STRING;
            if ( $ris_block_list_function->{$pkg}{$sub} ) {
                $msg = 'block_list';
            }

            if ( $ris_block_function->{$pkg}{$sub} ) {
                $msg = 'block';
            }
            $fh->print("$sub $msg\n");
        }
    }

    foreach my $pkg ( keys %{$ris_constant} ) {
        $fh->print("\nconstants and constant subs in package $pkg\n");

        foreach my $sub ( keys %{ $ris_constant->{$pkg} } ) {
            $fh->print("$sub\n");
        }
    }
    return;
} ## end sub dump_functions

sub prepare_for_a_new_file {

    my ( $self, $source_object ) = @_;

    # copy the source object lines to an array of lines
    $self->make_source_array($source_object);

    # previous tokens needed to determine what to expect next
    $last_nonblank_token      = ';';    # the only possible starting state which
    $last_nonblank_type       = ';';    # will make a leading brace a code block
    $last_nonblank_block_type = EMPTY_STRING;

    # scalars for remembering statement types across multiple lines
    $statement_type = EMPTY_STRING;     # '' or 'use' or 'sub..' or 'case..'

    # scalars for remembering where we are in the file
    $current_package = "main";
    $context         = UNKNOWN_CONTEXT;

    # hashes used to remember function information
    $ris_constant             = {};     # user-defined constants
    $ris_user_function        = {};     # user-defined functions
    $ruser_function_prototype = {};     # their prototypes
    $ris_block_function       = {};
    $ris_block_list_function  = {};
    $rsaw_function_definition = {};
    $rsaw_use_module          = {};

    # variables used to track depths of various containers
    # and report nesting errors
    $paren_depth              = 0;
    $brace_depth              = 0;
    $square_bracket_depth     = 0;
    $rcurrent_depth           = [ (0) x scalar(@closing_brace_names) ];
    $total_depth              = 0;
    $rtotal_depth             = [];
    $rcurrent_sequence_number = [];
    $next_sequence_number     = SEQ_ROOT + 1;

    $rparen_type                     = [];
    $rparen_semicolon_count          = [];
    $rparen_vars                     = [];
    $rbrace_type                     = [];
    $rbrace_structural_type          = [];
    $rbrace_context                  = [];
    $rbrace_package                  = [];
    $rsquare_bracket_type            = [];
    $rsquare_bracket_structural_type = [];
    $rdepth_array                    = [];
    $rnested_ternary_flag            = [];
    $rnested_statement_type          = [];
    $rstarting_line_of_current_depth = [];

    $rparen_type->[$paren_depth]            = EMPTY_STRING;
    $rparen_semicolon_count->[$paren_depth] = 0;
    $rparen_vars->[$paren_depth]            = [];
    $rbrace_type->[$brace_depth] = ';';   # identify opening brace as code block
    $rbrace_structural_type->[$brace_depth]        = EMPTY_STRING;
    $rbrace_context->[$brace_depth]                = UNKNOWN_CONTEXT;
    $rbrace_package->[$paren_depth]                = $current_package;
    $rsquare_bracket_type->[$square_bracket_depth] = EMPTY_STRING;
    $rsquare_bracket_structural_type->[$square_bracket_depth] = EMPTY_STRING;

    initialize_tokenizer_state();
    return;
} ## end sub prepare_for_a_new_file

{    ## closure for sub tokenize_this_line

    use constant BRACE          => 0;
    use constant SQUARE_BRACKET => 1;
    use constant PAREN          => 2;
    use constant QUESTION_COLON => 3;

    # TV1: scalars for processing one LINE.
    # Re-initialized on each entry to sub tokenize_this_line.
    my (
        $block_type,        $container_type,    $expecting,
        $i,                 $i_tok,             $input_line,
        $input_line_number, $last_nonblank_i,   $max_token_index,
        $next_tok,          $next_type,         $peeked_ahead,
        $prototype,         $rhere_target_list, $rtoken_map,
        $rtoken_type,       $rtokens,           $tok,
        $type,              $type_sequence,     $indent_flag,
    );

    # TV2: refs to ARRAYS for processing one LINE
    # Re-initialized on each call.
    my $routput_token_list    = [];    # stack of output token indexes
    my $routput_token_type    = [];    # token types
    my $routput_block_type    = [];    # types of code block
    my $routput_type_sequence = [];    # nesting sequential number
    my $routput_indent_flag   = [];    #

    # TV3: SCALARS for quote variables.  These are initialized with a
    # subroutine call and continually updated as lines are processed.
    my ( $in_quote, $quote_type, $quote_character, $quote_pos, $quote_depth,
        $quoted_string_1, $quoted_string_2, $allowed_quote_modifiers );

    # TV4: SCALARS for multi-line identifiers and
    # statements. These are initialized with a subroutine call
    # and continually updated as lines are processed.
    my ( $id_scan_state, $identifier, $want_paren );

    # TV5: SCALARS for tracking indentation level.
    # Initialized once and continually updated as lines are
    # processed.
    my (
        $nesting_token_string, $nesting_block_string,
        $nesting_block_flag,   $level_in_tokenizer,
    );

    # TV6: SCALARS for remembering several previous
    # tokens. Initialized once and continually updated as
    # lines are processed.
    my (
        $last_nonblank_container_type, $last_nonblank_type_sequence,
        $last_last_nonblank_token,     $last_last_nonblank_type,
        $last_nonblank_prototype,
    );

    # ----------------------------------------------------------------
    # beginning of tokenizer variable access and manipulation routines
    # ----------------------------------------------------------------

    sub initialize_tokenizer_state {

        # GV1: initialized once
        # TV1: initialized on each call
        # TV2: initialized on each call
        # TV3:
        $in_quote                = 0;
        $quote_type              = 'Q';
        $quote_character         = EMPTY_STRING;
        $quote_pos               = 0;
        $quote_depth             = 0;
        $quoted_string_1         = EMPTY_STRING;
        $quoted_string_2         = EMPTY_STRING;
        $allowed_quote_modifiers = EMPTY_STRING;

        # TV4:
        $id_scan_state = EMPTY_STRING;
        $identifier    = EMPTY_STRING;
        $want_paren    = EMPTY_STRING;

        # TV5:
        $nesting_token_string = EMPTY_STRING;
        $nesting_block_string = '1';            # initially in a block
        $nesting_block_flag   = 1;
        $level_in_tokenizer   = 0;

        # TV6:
        $last_nonblank_container_type = EMPTY_STRING;
        $last_nonblank_type_sequence  = EMPTY_STRING;
        $last_last_nonblank_token     = ';';
        $last_last_nonblank_type      = ';';
        $last_nonblank_prototype      = EMPTY_STRING;
        return;
    } ## end sub initialize_tokenizer_state

    sub save_tokenizer_state {

        # Global variables:
        my $rGV1 = [
            $brace_depth,
            $context,
            $current_package,
            $last_nonblank_block_type,
            $last_nonblank_token,
            $last_nonblank_type,
            $next_sequence_number,
            $paren_depth,
            $rbrace_context,
            $rbrace_package,
            $rbrace_structural_type,
            $rbrace_type,
            $rcurrent_depth,
            $rcurrent_sequence_number,
            $rdepth_array,
            $ris_block_function,
            $ris_block_list_function,
            $ris_constant,
            $ris_user_function,
            $rnested_statement_type,
            $rnested_ternary_flag,
            $rparen_semicolon_count,
            $rparen_vars,
            $rparen_type,
            $rsaw_function_definition,
            $rsaw_use_module,
            $rsquare_bracket_structural_type,
            $rsquare_bracket_type,
            $rstarting_line_of_current_depth,
            $rtotal_depth,
            $ruser_function_prototype,
            $square_bracket_depth,
            $statement_type,
            $total_depth,

        ];

        # Tokenizer closure variables:
        my $rTV1 = [
            $block_type,        $container_type,    $expecting,
            $i,                 $i_tok,             $input_line,
            $input_line_number, $last_nonblank_i,   $max_token_index,
            $next_tok,          $next_type,         $peeked_ahead,
            $prototype,         $rhere_target_list, $rtoken_map,
            $rtoken_type,       $rtokens,           $tok,
            $type,              $type_sequence,     $indent_flag,
        ];

        my $rTV2 = [
            $routput_token_list, $routput_token_type,
            $routput_block_type, $routput_type_sequence,
            $routput_indent_flag,
        ];

        my $rTV3 = [
            $in_quote,        $quote_type,
            $quote_character, $quote_pos,
            $quote_depth,     $quoted_string_1,
            $quoted_string_2, $allowed_quote_modifiers,
        ];

        my $rTV4 = [ $id_scan_state, $identifier, $want_paren ];

        my $rTV5 = [
            $nesting_token_string, $nesting_block_string,
            $nesting_block_flag,   $level_in_tokenizer,
        ];

        my $rTV6 = [
            $last_nonblank_container_type, $last_nonblank_type_sequence,
            $last_last_nonblank_token,     $last_last_nonblank_type,
            $last_nonblank_prototype,
        ];
        return [ $rGV1, $rTV1, $rTV2, $rTV3, $rTV4, $rTV5, $rTV6 ];
    } ## end sub save_tokenizer_state

    sub restore_tokenizer_state {
        my ($rstate) = @_;
        my ( $rGV1, $rTV1, $rTV2, $rTV3, $rTV4, $rTV5, $rTV6 ) = @{$rstate};

        (
            $brace_depth,
            $context,
            $current_package,
            $last_nonblank_block_type,
            $last_nonblank_token,
            $last_nonblank_type,
            $next_sequence_number,
            $paren_depth,
            $rbrace_context,
            $rbrace_package,
            $rbrace_structural_type,
            $rbrace_type,
            $rcurrent_depth,
            $rcurrent_sequence_number,
            $rdepth_array,
            $ris_block_function,
            $ris_block_list_function,
            $ris_constant,
            $ris_user_function,
            $rnested_statement_type,
            $rnested_ternary_flag,
            $rparen_semicolon_count,
            $rparen_vars,
            $rparen_type,
            $rsaw_function_definition,
            $rsaw_use_module,
            $rsquare_bracket_structural_type,
            $rsquare_bracket_type,
            $rstarting_line_of_current_depth,
            $rtotal_depth,
            $ruser_function_prototype,
            $square_bracket_depth,
            $statement_type,
            $total_depth,

        ) = @{$rGV1};

        (
            $block_type,        $container_type,    $expecting,
            $i,                 $i_tok,             $input_line,
            $input_line_number, $last_nonblank_i,   $max_token_index,
            $next_tok,          $next_type,         $peeked_ahead,
            $prototype,         $rhere_target_list, $rtoken_map,
            $rtoken_type,       $rtokens,           $tok,
            $type,              $type_sequence,     $indent_flag,
        ) = @{$rTV1};

        (
            $routput_token_list, $routput_token_type,
            $routput_block_type, $routput_type_sequence,
            $routput_indent_flag,
        ) = @{$rTV2};

        (
            $in_quote, $quote_type, $quote_character, $quote_pos, $quote_depth,
            $quoted_string_1, $quoted_string_2, $allowed_quote_modifiers,
        ) = @{$rTV3};

        ( $id_scan_state, $identifier, $want_paren ) = @{$rTV4};

        (
            $nesting_token_string, $nesting_block_string,
            $nesting_block_flag,   $level_in_tokenizer,
        ) = @{$rTV5};

        (
            $last_nonblank_container_type, $last_nonblank_type_sequence,
            $last_last_nonblank_token,     $last_last_nonblank_type,
            $last_nonblank_prototype,
        ) = @{$rTV6};
        return;
    } ## end sub restore_tokenizer_state

    sub split_pretoken {

        my ( $self, $numc ) = @_;

        # This provides a way to work around the limitations of the
        # pre-tokenization scheme upon which perltidy is based. It is rarely
        # needed.

        # Split the leading $numc characters from the current token (at
        # index=$i) which is pre-type 'w' and insert the remainder back into
        # the pretoken stream with appropriate settings.  Since we are
        # splitting a pre-type 'w', there are three cases, depending on if the
        # remainder starts with a digit:
        # Case 1: remainder is type 'd', all digits
        # Case 2: remainder is type 'd' and type 'w': digits & other characters
        # Case 3: remainder is type 'w'

        # Examples, for $numc=1:
        #   $tok    => $tok_0 $tok_1 $tok_2
        #   'x10'   => 'x'    '10'                # case 1
        #   'x10if' => 'x'    '10'   'if'         # case 2
        #   '0ne    => 'O'            'ne'        # case 3

        # where:
        #   $tok_1 is a possible string of digits (pre-type 'd')
        #   $tok_2 is a possible word (pre-type 'w')

        # return 1 if successful
        # return undef if error (shouldn't happen)

        # Calling routine should update '$type' and '$tok' if successful.

        my $pretoken = $rtokens->[$i];
        if (   $pretoken
            && length($pretoken) > $numc
            && substr( $pretoken, $numc ) =~ /^(\d*)(.*)$/ )
        {

            # Split $tok into up to 3 tokens:
            my $tok_0 = substr( $pretoken, 0, $numc );
            my $tok_1 = defined($1) ? $1 : EMPTY_STRING;
            my $tok_2 = defined($2) ? $2 : EMPTY_STRING;

            my $len_0 = length($tok_0);
            my $len_1 = length($tok_1);
            my $len_2 = length($tok_2);

            ##my $pre_type_0 = 'w';
            my $pre_type_1 = 'd';
            my $pre_type_2 = 'w';

            my $pos_0 = $rtoken_map->[$i];
            my $pos_1 = $pos_0 + $len_0;
            my $pos_2 = $pos_1 + $len_1;

            my $isplice = $i + 1;

            # Splice in any digits
            if ($len_1) {
                splice @{$rtoken_map},  $isplice, 0, $pos_1;
                splice @{$rtokens},     $isplice, 0, $tok_1;
                splice @{$rtoken_type}, $isplice, 0, $pre_type_1;
                $max_token_index++;
                $isplice++;
            }

            # Splice in any trailing word
            if ($len_2) {
                splice @{$rtoken_map},  $isplice, 0, $pos_2;
                splice @{$rtokens},     $isplice, 0, $tok_2;
                splice @{$rtoken_type}, $isplice, 0, $pre_type_2;
                $max_token_index++;
            }

            $rtokens->[$i] = $tok_0;
            return 1;
        }

        # Shouldn't get here - bad call parameters
        if (DEVEL_MODE) {
            $self->Fault(<<EOM);
While working near line number $input_line_number, bad arg '$tok' passed to sub split_pretoken()
EOM
        }
        return;
    } ## end sub split_pretoken

    sub get_indentation_level {
        return $level_in_tokenizer;
    }

    sub reset_indentation_level {
        $level_in_tokenizer = shift;
        return;
    }

    sub peeked_ahead {
        ( ( my $flag ) ) = @_;

        # get or set the closure flag '$peeked_ahead':
        # - set $peeked_ahead to $flag if given, then
        # - return current value
        $peeked_ahead = defined($flag) ? $flag : $peeked_ahead;
        return $peeked_ahead;
    } ## end sub peeked_ahead

    # ------------------------------------------------------------
    # end of tokenizer variable access and manipulation routines
    # ------------------------------------------------------------

    #------------------------------
    # beginning of tokenizer hashes
    #------------------------------

    my %matching_start_token = ( '}' => '{', ']' => '[', ')' => '(' );

    # These block types terminate statements and do not need a trailing
    # semicolon
    # patched for SWITCH/CASE/
    my %is_zero_continuation_block_type;
    my @q;
    @q = qw( } { BEGIN END CHECK INIT AUTOLOAD DESTROY UNITCHECK continue ;
      if elsif else unless while until for foreach switch case given when );
    @is_zero_continuation_block_type{@q} = (1) x scalar(@q);

    my %is_logical_container;
    @q = qw( if elsif unless while and or err not && ! || for foreach );
    @is_logical_container{@q} = (1) x scalar(@q);

    my %is_binary_type;
    @q = qw( || && );
    @is_binary_type{@q} = (1) x scalar(@q);

    my %is_binary_keyword;
    @q = qw( and or err eq ne cmp );
    @is_binary_keyword{@q} = (1) x scalar(@q);

    # 'L' is token for opening { at hash key
    my %is_opening_type;
    @q = qw< L { ( [ >;
    @is_opening_type{@q} = (1) x scalar(@q);

    my %is_opening_or_ternary_type;
    push @q, '?';
    @is_opening_or_ternary_type{@q} = (1) x scalar(@q);

    # 'R' is token for closing } at hash key
    my %is_closing_type;
    @q = qw< R } ) ] >;
    @is_closing_type{@q} = (1) x scalar(@q);

    my %is_closing_or_ternary_type;
    push @q, ':';
    @is_closing_or_ternary_type{@q} = (1) x scalar(@q);

    my %is_redo_last_next_goto;
    @q = qw( redo last next goto );
    @is_redo_last_next_goto{@q} = (1) x scalar(@q);

    my %is_use_require;
    @q = qw( use require );
    @is_use_require{@q} = (1) x scalar(@q);

    # This hash holds the array index in $self for these keywords:
    # Fix for issue c035: removed 'format' from this hash
    my %is_END_DATA = (
        '__END__'  => _in_end_,
        '__DATA__' => _in_data_,
    );

    my %is_list_end_type;
    @q = qw( ; { } );
    push @q, ',';
    @is_list_end_type{@q} = (1) x scalar(@q);

    # table showing how many quoted things to look for after quote operator..
    # s, y, tr have 2 (pattern and replacement)
    # others have 1 (pattern only)
    my %quote_items = (
        's'  => 2,
        'y'  => 2,
        'tr' => 2,
        'm'  => 1,
        'qr' => 1,
        'q'  => 1,
        'qq' => 1,
        'qw' => 1,
        'qx' => 1,
    );

    my %is_for_foreach;
    @q = qw( for foreach );
    @is_for_foreach{@q} = (1) x scalar(@q);

    # These keywords may introduce blocks after parenthesized expressions,
    # in the form:
    # keyword ( .... ) { BLOCK }
    # patch for SWITCH/CASE: added 'switch' 'case' 'given' 'when'
    # NOTE for --use-feature=class: if ADJUST blocks eventually take a
    # parameter list, then ADJUST might need to be added to this list (see
    # perlclass.pod)
    my %is_blocktype_with_paren;
    @q =
      qw(if elsif unless while until for foreach switch case given when catch);
    @is_blocktype_with_paren{@q} = (1) x scalar(@q);

    my %is_case_default;
    @q = qw( case default );
    @is_case_default{@q} = (1) x scalar(@q);

    #------------------------
    # end of tokenizer hashes
    #------------------------

    # ------------------------------------------------------------
    # beginning of various scanner interface routines
    # ------------------------------------------------------------
    sub scan_replacement_text {

        # check for here-docs in replacement text invoked by
        # a substitution operator with executable modifier 'e'.
        #
        # given:
        #  $replacement_text
        # return:
        #  $rht = reference to any here-doc targets
        my ( $self, $replacement_text ) = @_;

        # quick check
        return if ( $replacement_text !~ /<</ );

        $self->write_logfile_entry(
            "scanning replacement text for here-doc targets\n");

        # save the logger object for error messages
        my $logger_object = $self->[_logger_object_];

        # save all lexical variables
        my $rstate = save_tokenizer_state();
        _decrement_count();    # avoid error check for multiple tokenizers

        # make a new tokenizer
        my $tokenizer = Perl::Tidy::Tokenizer->new(
            source_object        => \$replacement_text,
            logger_object        => $logger_object,
            starting_line_number => $input_line_number,
        );

        # scan the replacement text
        while ( $tokenizer->get_line() ) { }

        # remove any here doc targets
        my $rht = undef;
        if ( $tokenizer->[_in_here_doc_] ) {
            $rht = [];
            push @{$rht},
              [
                $tokenizer->[_here_doc_target_],
                $tokenizer->[_here_quote_character_]
              ];
            if ( $tokenizer->[_rhere_target_list_] ) {
                push @{$rht}, @{ $tokenizer->[_rhere_target_list_] };
                $tokenizer->[_rhere_target_list_] = undef;
            }
            $tokenizer->[_in_here_doc_] = undef;
        }

        # now its safe to report errors
        my $severe_error_uu = $tokenizer->report_tokenization_errors();

        # TODO: Could propagate a severe error up

        # restore all tokenizer lexical variables
        restore_tokenizer_state($rstate);

        # return the here doc targets
        return $rht;
    } ## end sub scan_replacement_text

    sub scan_bare_identifier {
        my $self = shift;
        ( $i, $tok, $type, $prototype ) = $self->scan_bare_identifier_do(

            $input_line,
            $i,
            $tok,
            $type,
            $prototype,
            $rtoken_map,
            $max_token_index
        );
        return;
    } ## end sub scan_bare_identifier

    sub scan_identifier {

        my $self = shift;

        (

            $i,
            $tok,
            $type,
            $id_scan_state,
            $identifier,
            my $split_pretoken_flag

        ) = $self->scan_complex_identifier(

            $i,
            $id_scan_state,
            $identifier,
            $rtokens,
            $max_token_index,
            $expecting,
            $rparen_type->[$paren_depth]
        );

        # Check for signal to fix a special variable adjacent to a keyword,
        # such as '$^One$0'.
        if ($split_pretoken_flag) {

            # Try to fix it by splitting the pretoken
            if (   $i > 0
                && $rtokens->[ $i - 1 ] eq '^'
                && $self->split_pretoken(1) )
            {
                $identifier = substr( $identifier, 0, 3 );
                $tok        = $identifier;
            }
            else {

                # This shouldn't happen ...
                my $var    = substr( $tok, 0, 3 );
                my $excess = substr( $tok, 3 );
                $self->interrupt_logfile();
                $self->warning(<<EOM);
$input_line_number: Trouble parsing at characters '$excess' after special variable '$var'.
A space may be needed after '$var'.
EOM
                $self->resume_logfile();
            }
        }
        return;
    } ## end sub scan_identifier

    use constant VERIFY_FASTSCAN => 0;
    my %fast_scan_context;

    BEGIN {
        %fast_scan_context = (
            '$' => SCALAR_CONTEXT,
            '*' => SCALAR_CONTEXT,
            '@' => LIST_CONTEXT,
            '%' => LIST_CONTEXT,
            '&' => UNKNOWN_CONTEXT,
        );
    } ## end BEGIN

    sub scan_simple_identifier {

        my $self = shift;

        # This is a wrapper for sub scan_identifier. It does a fast preliminary
        # scan for certain common identifiers:
        #   '$var', '@var', %var, *var, &var, '@{...}', '%{...}'
        # If it does not find one of these, or this is a restart, it calls the
        # original scanner directly.

        # This gives the same results as the full scanner in about 1/4 the
        # total runtime for a typical input stream.

        # Notation:
        #     $var * 2
        #     ^^   ^
        #     ||  |
        #     ||  ---- $i_next [= next nonblank pretoken ]
        #     |----$i_plus_1 [= a bareword ]
        #     ---$i_begin [= a sigil]

        my $i_begin   = $i;
        my $tok_begin = $tok;
        my $i_plus_1  = $i + 1;
        my $fast_scan_type;

        #-------------------------------------------------------
        # Do full scan for anything following a pointer, such as
        #      $cref->&*;    # a postderef
        #-------------------------------------------------------
        if ( $last_nonblank_token eq '->' ) {

        }

        #------------------------------
        # quick scan with leading sigil
        #------------------------------
        elsif ( !$id_scan_state
            && $i_plus_1 <= $max_token_index
            && $fast_scan_context{$tok} )
        {
            $context = $fast_scan_context{$tok};

            # look for $var, @var, ...
            if ( $rtoken_type->[$i_plus_1] eq 'w' ) {
                my $pretype_next = EMPTY_STRING;
                if ( $i_plus_1 < $max_token_index ) {
                    my $i_next = $i_plus_1 + 1;
                    if (   $rtoken_type->[$i_next] eq 'b'
                        && $i_next < $max_token_index )
                    {
                        $i_next += 1;
                    }
                    $pretype_next = $rtoken_type->[$i_next];
                }
                if ( $pretype_next ne ':' && $pretype_next ne "'" ) {

                    # Found type 'i' like '$var', '@var', or '%var'
                    $identifier     = $tok . $rtokens->[$i_plus_1];
                    $tok            = $identifier;
                    $type           = 'i';
                    $i              = $i_plus_1;
                    $fast_scan_type = $type;
                }
            }

            # Look for @{ or %{  .
            # But we must let the full scanner handle things ${ because it may
            # keep going to get a complete identifier like '${#}'  .
            elsif (
                $rtoken_type->[$i_plus_1] eq '{'
                && (   $tok_begin eq '@'
                    || $tok_begin eq '%' )
              )
            {

                $identifier     = $tok;
                $type           = 't';
                $fast_scan_type = $type;
            }
            else {
                ## out of tricks
            }
        }

        #---------------------------
        # Quick scan with leading ->
        # Look for ->[ and ->{
        #---------------------------
        elsif (
               $tok eq '->'
            && $i < $max_token_index
            && (   $rtokens->[$i_plus_1] eq '{'
                || $rtokens->[$i_plus_1] eq '[' )
          )
        {
            $type           = $tok;
            $fast_scan_type = $type;
            $identifier     = $tok;
            $context        = UNKNOWN_CONTEXT;
        }
        else {
            ## out of tricks
        }

        #--------------------------------------
        # Verify correctness during development
        #--------------------------------------
        if ( VERIFY_FASTSCAN && $fast_scan_type ) {

            # We will call the full method
            my $identifier_simple = $identifier;
            my $tok_simple        = $tok;
            my $i_simple          = $i;
            my $context_simple    = $context;

            $tok = $tok_begin;
            $i   = $i_begin;
            $self->scan_identifier();

            if (   $tok ne $tok_simple
                || $type ne $fast_scan_type
                || $i != $i_simple
                || $identifier ne $identifier_simple
                || $id_scan_state
                || $context ne $context_simple )
            {
                print {*STDERR} <<EOM;
scan_simple_identifier differs from scan_identifier:
simple:  i=$i_simple, tok=$tok_simple, type=$fast_scan_type, ident=$identifier_simple, context='$context_simple
full:    i=$i, tok=$tok, type=$type, ident=$identifier, context='$context state=$id_scan_state
EOM
            }
        }

        #-------------------------------------------------
        # call full scanner if fast method did not succeed
        #-------------------------------------------------
        if ( !$fast_scan_type ) {
            $self->scan_identifier();
        }
        return;
    } ## end sub scan_simple_identifier

    sub method_ok_here {

        my $self = shift;

        # Return:
        #   false if this is definitely an invalid method declaration
        #   true otherwise (even if not sure)

        # We are trying to avoid problems with old uses of 'method'
        # when --use-feature=class is set (rt145706).
        # For example, this should cause a return of 'false':

        #  method paint => sub {
        #    return;
        #  };

        # from do_scan_sub:
        my $i_beg   = $i + 1;
        my $pos_beg = $rtoken_map->[$i_beg];
        pos($input_line) = $pos_beg;

        # TEST 1: look a valid sub NAME
        if (
            $input_line =~ m{\G\s*
        ((?:\w*(?:'|::))*)  # package - something that ends in :: or '
        (\w+)               # NAME    - required
        }gcx
          )
        {
            # For possible future use..
            ##my $subname = $2;
            ##my $package = $1 ? $1 : EMPTY_STRING;
        }
        else {
            return;
        }

        # TEST 2: look for invalid characters after name, such as here:
        #    method paint => sub {
        #     ...
        #    }
        my $next_char = EMPTY_STRING;
        if ( $input_line =~ m/\s*(\S)/gcx ) { $next_char = $1 }
        if ( !$next_char || $next_char eq '#' ) {
            ( $next_char, my $i_next_uu ) =
              $self->find_next_nonblank_token( $max_token_index,
                $rtokens, $max_token_index );
        }

        if ( !$next_char ) {

            # out of characters - give up
            return;
        }

        # Possibly valid next token types:
        # '(' could start prototype or signature
        # ':' could start ATTRIBUTE
        # '{' cold start BLOCK
        # ';' or '}' could end a statement
        if ( $next_char !~ /^[\(\:\{\;\}]/ ) {

            # This does not match use feature 'class' syntax
            return;
        }

        # We will stop here and assume that this is valid syntax for
        # use feature 'class'.
        return 1;
    } ## end sub method_ok_here

    sub class_ok_here {

        my $self = shift;

        # Return:
        #   false if this is definitely an invalid class declaration
        #   true otherwise (even if not sure)

        # We are trying to avoid problems with old uses of 'class'
        # when --use-feature=class is set (rt145706).  We look ahead
        # see if this use of 'class' is obviously inconsistent with
        # the syntax of use feature 'class'.  This allows the default
        # setting --use-feature=class to work for old syntax too.

        # Valid class declarations look like
        #   class NAME ?ATTRS ?VERSION ?BLOCK
        # where ATTRS VERSION and BLOCK are optional

        # For example, this should produce a return of 'false':
        #
        #   class ExtendsBasicAttributes is BasicAttributes{

        # TEST 1: class stmt can only go where a new statement can start
        if ( !new_statement_ok() ) { return }

        my $i_beg   = $i + 1;
        my $pos_beg = $rtoken_map->[$i_beg];
        pos($input_line) = $pos_beg;

        # TEST 2: look for a valid NAME
        if (
            $input_line =~ m{\G\s*
        ((?:\w*(?:'|::))*)  # package - something that ends in :: or '
        (\w+)               # NAME    - required
        }gcx
          )
        {
            # For possible future use..
            ##my $subname = $2;
            ##my $package = $1 ? $1 : EMPTY_STRING;
        }
        else {
            return;
        }

        # TEST 3: look for valid characters after NAME
        my $next_char = EMPTY_STRING;
        if ( $input_line =~ m/\s*(\S)/gcx ) { $next_char = $1 }
        if ( !$next_char || $next_char eq '#' ) {
            ( $next_char, my $i_next_uu ) =
              $self->find_next_nonblank_token( $max_token_index,
                $rtokens, $max_token_index );
        }
        if ( !$next_char ) {

            # out of characters - give up
            return;
        }

        # Must see one of: ATTRIBUTE, VERSION, BLOCK, or end stmt

        # Possibly valid next token types:
        # ':' could start ATTRIBUTE
        # '\d' could start VERSION
        # '{' cold start BLOCK
        # ';' could end a statement
        # '}' could end statement but would be strange

        if ( $next_char !~ /^[\:\d\{\;\}]/ ) {

            # This does not match use feature 'class' syntax
            return;
        }

        # We will stop here and assume that this is valid syntax for
        # use feature 'class'.
        return 1;
    } ## end sub class_ok_here

    sub scan_id {
        my $self = shift;
        ( $i, $tok, $type, $id_scan_state ) = $self->scan_id_do(

            $input_line,
            $i, $tok,
            $rtokens,
            $rtoken_map,
            $id_scan_state,
            $max_token_index
        );
        return;
    } ## end sub scan_id

    sub scan_number {
        my $self = shift;
        my $number;
        ( $i, $type, $number ) =
          $self->scan_number_do( $input_line, $i, $rtoken_map, $type,
            $max_token_index );
        return $number;
    } ## end sub scan_number

    use constant VERIFY_FASTNUM => 0;

    sub scan_number_fast {

        my $self = shift;

        # This is a wrapper for sub scan_number. It does a fast preliminary
        # scan for a simple integer.  It calls the original scan_number if it
        # does not find one.

        my $i_begin   = $i;
        my $tok_begin = $tok;
        my $number;

        #---------------------------------
        # Quick check for (signed) integer
        #---------------------------------

        # This will be the string of digits:
        my $i_d   = $i;
        my $tok_d = $tok;
        my $typ_d = $rtoken_type->[$i_d];

        # check for signed integer
        my $sign = EMPTY_STRING;
        if (   $typ_d ne 'd'
            && ( $typ_d eq '+' || $typ_d eq '-' )
            && $i_d < $max_token_index )
        {
            $sign = $tok_d;
            $i_d++;
            $tok_d = $rtokens->[$i_d];
            $typ_d = $rtoken_type->[$i_d];
        }

        # Handle integers
        if (
            $typ_d eq 'd'
            && (
                $i_d == $max_token_index
                || (   $i_d < $max_token_index
                    && $rtoken_type->[ $i_d + 1 ] ne '.'
                    && $rtoken_type->[ $i_d + 1 ] ne 'w' )
            )
          )
        {
            # Let let full scanner handle multi-digit integers beginning with
            # '0' because there could be error messages.  For example, '009' is
            # not a valid number.

            if ( $tok_d eq '0' || substr( $tok_d, 0, 1 ) ne '0' ) {
                $number = $sign . $tok_d;
                $type   = 'n';
                $i      = $i_d;
            }
        }

        #--------------------------------------
        # Verify correctness during development
        #--------------------------------------
        if ( VERIFY_FASTNUM && defined($number) ) {

            # We will call the full method
            my $type_simple   = $type;
            my $i_simple      = $i;
            my $number_simple = $number;

            $tok    = $tok_begin;
            $i      = $i_begin;
            $number = $self->scan_number();

            if (   $type ne $type_simple
                || ( $i != $i_simple && $i <= $max_token_index )
                || $number ne $number_simple )
            {
                print {*STDERR} <<EOM;
scan_number_fast differs from scan_number:
simple:  i=$i_simple, type=$type_simple, number=$number_simple
full:  i=$i, type=$type, number=$number
EOM
            }
        }

        #----------------------------------------
        # call full scanner if may not be integer
        #----------------------------------------
        if ( !defined($number) ) {
            $number = $self->scan_number();
        }
        return $number;
    } ## end sub scan_number_fast

    # a sub to warn if token found where term expected
    sub error_if_expecting_TERM {
        my $self = shift;
        if ( $expecting == TERM ) {
            if ( $really_want_term{$last_nonblank_type} ) {
                $self->report_unexpected(
                    {
                        found           => $tok,
                        expecting       => "term",
                        i_tok           => $i_tok,
                        last_nonblank_i => $last_nonblank_i,
                        rpretoken_map   => $rtoken_map,
                        rpretoken_type  => $rtoken_type,
                        input_line      => $input_line,
                    }
                );
                return 1;
            }
        }
        return;
    } ## end sub error_if_expecting_TERM

    # a sub to warn if token found where operator expected
    sub error_if_expecting_OPERATOR {

        my ( $self, ($thing) ) = @_;

        # Issue warning on error if expecting operator
        # Given:
        #   $thing = the unexpected token or issue
        #          = undef to use current pre-token

        if ( $expecting == OPERATOR ) {
            if ( !defined($thing) ) { $thing = $tok }
            $self->report_unexpected(
                {
                    found           => $thing,
                    expecting       => "operator",
                    i_tok           => $i_tok,
                    last_nonblank_i => $last_nonblank_i,
                    rpretoken_map   => $rtoken_map,
                    rpretoken_type  => $rtoken_type,
                    input_line      => $input_line,
                }
            );
            if ( $i_tok == 0 ) {
                $self->interrupt_logfile();
                $self->warning("Missing ';' or ',' above?\n");
                $self->resume_logfile();
            }
            return 1;
        }
        return;
    } ## end sub error_if_expecting_OPERATOR

    # ------------------------------------------------------------
    # end scanner interfaces
    # ------------------------------------------------------------

    #------------------
    # Tokenization subs
    #------------------
    sub do_GREATER_THAN_SIGN {

        my $self = shift;

        # '>'
        $self->error_if_expecting_TERM()
          if ( $expecting == TERM );
        return;
    } ## end sub do_GREATER_THAN_SIGN

    sub do_VERTICAL_LINE {

        my $self = shift;

        # '|'
        $self->error_if_expecting_TERM()
          if ( $expecting == TERM );
        return;
    } ## end sub do_VERTICAL_LINE

    # An identifier in possible indirect object location followed by any of
    # these tokens: -> , ; } (plus others) is not an indirect object. Fix c257.
    my %Z_test_hash;

    BEGIN {
        my @qZ = qw#
          -> ; } ) ]
          => =~ = == !~ || >= != *= .. && |= .= -= += <= %=
          ^= &&= ||= //= <=>
          #;
        push @qZ, ',';
        @Z_test_hash{@qZ} = (1) x scalar(@qZ);
    }

    sub do_DOLLAR_SIGN {

        my $self = shift;

        # '$'
        # start looking for a scalar
        $self->error_if_expecting_OPERATOR("Scalar")
          if ( $expecting == OPERATOR );
        $self->scan_simple_identifier();

        if ( $identifier eq '$^W' ) {
            $self->[_saw_perl_dash_w_] = 1;
        }

        # Check for identifier in indirect object slot
        # (vorboard.pl, sort.t).  Something like:
        #   /^(print|printf|sort|exec|system)$/
        if (
               $is_indirect_object_taker{$last_nonblank_token}
            && $last_nonblank_type eq 'k'
            || ( ( $last_nonblank_token eq '(' )
                && $is_indirect_object_taker{ $rparen_type->[$paren_depth] } )
            || (   $last_nonblank_type eq 'w'
                || $last_nonblank_type eq 'U' )    # possible object
          )
        {

            # An identifier followed by '->' is not indirect object;
            # fixes b1175, b1176. Fix c257: Likewise for other tokens like
            # comma, semicolon, closing brace, and single space.
            my ( $next_nonblank_token, $i_next_uu ) =
              $self->find_next_noncomment_token( $i, $rtokens,
                $max_token_index );
            $type = 'Z' if ( !$Z_test_hash{$next_nonblank_token} );
        }
        return;
    } ## end sub do_DOLLAR_SIGN

    sub do_LEFT_PARENTHESIS {

        my $self = shift;

        # '('
        ++$paren_depth;

        # variable to enable check for brace after closing paren (c230)
        my $want_brace = EMPTY_STRING;

        if ($want_paren) {
            $container_type = $want_paren;
            $want_brace     = $want_paren;
            $want_paren     = EMPTY_STRING;
        }
        elsif ( substr( $statement_type, 0, 3 ) eq 'sub'
            && $statement_type =~ /^sub\b/ )
        {
            $container_type = $statement_type;
        }
        else {
            $container_type = $last_nonblank_token;

            # We can check for a syntax error here of unexpected '(',
            # but this is going to get messy...
            if (
                $expecting == OPERATOR

                # Be sure this is not a method call of the form
                # &method(...), $method->(..), &{method}(...),
                # $ref[2](list) is ok & short for $ref[2]->(list)
                # NOTE: at present, braces in something like &{ xxx }
                # are not marked as a block, we might have a method call.
                # Added ')' to fix case c017, something like ()()()
                && $last_nonblank_token !~ /^(?:[\]\}\)\&]|\-\>)/
              )
            {

                # ref: camel 3 p 703.
                if ( $last_last_nonblank_token eq 'do' ) {
                    $self->complain(
"do SUBROUTINE is deprecated; consider & or -> notation\n"
                    );
                }
                else {

                    # if this is an empty list, (), then it is not an
                    # error; for example, we might have a constant pi and
                    # invoke it with pi() or just pi;
                    my ( $next_nonblank_token, $i_next_uu ) =
                      $self->find_next_nonblank_token( $i, $rtokens,
                        $max_token_index );

                    # Patch for c029: give up error check if
                    # a side comment follows
                    if (   $next_nonblank_token ne ')'
                        && $next_nonblank_token ne '#' )
                    {
                        my $hint;

                        $self->error_if_expecting_OPERATOR('(');

                        if ( $last_nonblank_type eq 'C' ) {
                            $hint =
                              "$last_nonblank_token has a void prototype\n";
                        }
                        elsif ( $last_nonblank_type eq 'i' ) {
                            if (   $i_tok > 0
                                && $last_nonblank_token =~ /^\$/ )
                            {
                                $hint =
                                  "Do you mean '$last_nonblank_token->(' ?\n";
                            }
                        }
                        else {
                            ## no hint
                        }
                        if ($hint) {
                            $self->interrupt_logfile();
                            $self->warning($hint);
                            $self->resume_logfile();
                        }
                    } ## end if ( $next_nonblank_token...
                } ## end else [ if ( $last_last_nonblank_token...
            } ## end if ( $expecting == OPERATOR...
        }

        ( $type_sequence, $indent_flag ) =
          $self->increase_nesting_depth( PAREN, $rtoken_map->[$i_tok] );

        # propagate types down through nested parens
        # for example: the second paren in 'if ((' would be structural
        # since the first is.

        if ( $last_nonblank_token eq '(' ) {
            $type = $last_nonblank_type;
        }

        #     We exclude parens as structural after a ',' because it
        #     causes subtle problems with continuation indentation for
        #     something like this, where the first 'or' will not get
        #     indented.
        #
        #         assert(
        #             __LINE__,
        #             ( not defined $check )
        #               or ref $check
        #               or $check eq "new"
        #               or $check eq "old",
        #         );
        #
        #     Likewise, we exclude parens where a statement can start
        #     because of problems with continuation indentation, like
        #     these:
        #
        #         ($firstline =~ /^#\!.*perl/)
        #         and (print $File::Find::name, "\n")
        #           and (return 1);
        #
        #         (ref($usage_fref) =~ /CODE/)
        #         ? &$usage_fref
        #           : (&blast_usage, &blast_params, &blast_general_params);

        else {
            $type = '{';
        }

        if ( $last_nonblank_type eq ')' ) {
            $self->warning(
                "Syntax error? found token '$last_nonblank_type' then '('\n");
        }

        # git #105: Copy container type and want-brace flag at ') (';
        # propagate the container type onward so that any subsequent brace gets
        # correctly marked.  I have implemented this as a general rule, which
        # should be safe, but if necessary it could be restricted to certain
        # container statement types such as 'for'.
        if ( $last_nonblank_token eq ')' ) {
            my $rvars = $rparen_vars->[$paren_depth];
            if ( defined($rvars) ) {
                $container_type = $rparen_type->[$paren_depth];
                ( my $type_lp_uu, $want_brace ) = @{$rvars};
            }
        }

        $rparen_type->[$paren_depth]            = $container_type;
        $rparen_vars->[$paren_depth]            = [ $type, $want_brace ];
        $rparen_semicolon_count->[$paren_depth] = 0;

        return;

    } ## end sub do_LEFT_PARENTHESIS

    sub do_RIGHT_PARENTHESIS {

        my $self = shift;

        # ')'
        ( $type_sequence, $indent_flag ) =
          $self->decrease_nesting_depth( PAREN, $rtoken_map->[$i_tok] );

        my $rvars = $rparen_vars->[$paren_depth];
        if ( defined($rvars) ) {
            my ( $type_lp, $want_brace_uu ) = @{$rvars};
            if ( $type_lp && $type_lp eq '{' ) {
                $type = '}';
            }
        }

        $container_type = $rparen_type->[$paren_depth];

        # restore statement type as 'sub' at closing paren of a signature
        # so that a subsequent ':' is identified as an attribute
        if ( substr( $container_type, 0, 3 ) eq 'sub'
            && $container_type =~ /^sub\b/ )
        {
            $statement_type = $container_type;
        }

        if ( $is_for_foreach{ $rparen_type->[$paren_depth] } ) {
            my $num_sc = $rparen_semicolon_count->[$paren_depth];
            if ( $num_sc > 0 && $num_sc != 2 ) {
                $self->warning("Expected 2 ';' in 'for(;;)' but saw $num_sc\n");
            }
        }

        if ( $paren_depth > 0 ) { $paren_depth-- }
        return;
    } ## end sub do_RIGHT_PARENTHESIS

    sub do_COMMA {

        my $self = shift;

        # ','
        if ( $last_nonblank_type eq ',' ) {
            $self->complain("Repeated ','s \n");
        }

        # Note that we have to check both token and type here because a
        # comma following a qw list can have last token='(' but type = 'q'
        elsif ( $last_nonblank_token eq '(' && $last_nonblank_type eq '{' ) {
            $self->warning("Unexpected leading ',' after a '('\n");
        }
        else {
            # no complaints about the comma
        }

        # patch for operator_expected: note if we are in the list (use.t)
        if ( $statement_type eq 'use' ) { $statement_type = '_use' }
        return;

    } ## end sub do_COMMA

    sub do_SEMICOLON {

        my $self = shift;

        # ';'
        $context        = UNKNOWN_CONTEXT;
        $statement_type = EMPTY_STRING;
        $want_paren     = EMPTY_STRING;

        if ( $is_for_foreach{ $rparen_type->[$paren_depth] } )
        {    # mark ; in for loop

            # Be careful: we do not want a semicolon such as the
            # following to be included:
            #
            #    for (sort {strcoll($a,$b);} keys %investments) {

            if (   $brace_depth == $rdepth_array->[PAREN][BRACE][$paren_depth]
                && $square_bracket_depth ==
                $rdepth_array->[PAREN][SQUARE_BRACKET][$paren_depth] )
            {

                $type = 'f';
                $rparen_semicolon_count->[$paren_depth]++;
            }
        }
        return;
    } ## end sub do_SEMICOLON

    sub do_QUOTATION_MARK {

        my $self = shift;

        # '"'
        $self->error_if_expecting_OPERATOR("String")
          if ( $expecting == OPERATOR );
        $in_quote                = 1;
        $type                    = 'Q';
        $allowed_quote_modifiers = EMPTY_STRING;
        return;
    } ## end sub do_QUOTATION_MARK

    sub do_APOSTROPHE {

        my $self = shift;

        # "'"
        $self->error_if_expecting_OPERATOR("String")
          if ( $expecting == OPERATOR );
        $in_quote                = 1;
        $type                    = 'Q';
        $allowed_quote_modifiers = EMPTY_STRING;
        return;
    } ## end sub do_APOSTROPHE

    sub do_BACKTICK {

        my $self = shift;

        # '`'
        $self->error_if_expecting_OPERATOR("String")
          if ( $expecting == OPERATOR );
        $in_quote                = 1;
        $type                    = 'Q';
        $allowed_quote_modifiers = EMPTY_STRING;
        return;
    } ## end sub do_BACKTICK

    sub do_SLASH {

        my $self = shift;

        # '/'
        my $is_pattern;

        # a pattern cannot follow certain keywords which take optional
        # arguments, like 'shift' and 'pop'. See also '?'.
        if (
            $last_nonblank_type eq 'k'
            && $is_keyword_rejecting_slash_as_pattern_delimiter{
                $last_nonblank_token}
          )
        {
            $is_pattern = 0;
        }
        elsif ( $expecting == UNKNOWN ) {    # indeterminate, must guess..
            my $msg;
            ( $is_pattern, $msg ) =
              $self->guess_if_pattern_or_division( $i, $rtokens, $rtoken_type,
                $rtoken_map, $max_token_index );

            if ($msg) {
                $self->write_diagnostics("DIVIDE:$msg\n");
                $self->write_logfile_entry($msg);
            }
        }
        else { $is_pattern = ( $expecting == TERM ) }

        if ($is_pattern) {
            $in_quote                = 1;
            $type                    = 'Q';
            $allowed_quote_modifiers = $quote_modifiers{'m'};
        }
        else {    # not a pattern; check for a /= token

            if ( $rtokens->[ $i + 1 ] eq '=' ) {    # form token /=
                $i++;
                $tok  = '/=';
                $type = $tok;
            }

            #DEBUG - collecting info on what tokens follow a divide
            # for development of guessing algorithm
            ##  if (
            ##      $self->is_possible_numerator( $i, $rtokens,
            ##          $max_token_index ) < 0
            ##    )
            ##  {
            ##      $self->write_diagnostics("DIVIDE? $input_line\n");
            ##  }
        }
        return;
    } ## end sub do_SLASH

    sub do_LEFT_CURLY_BRACKET {

        my $self = shift;

        # '{'
        # if we just saw a ')', we will label this block with
        # its type.  We need to do this to allow sub
        # code_block_type to determine if this brace starts a
        # code block or anonymous hash.  (The type of a paren
        # pair is the preceding token, such as 'if', 'else',
        # etc).
        $container_type = EMPTY_STRING;

        # ATTRS: for a '{' following an attribute list, reset
        # things to look like we just saw a sub name
        # Added 'package' (can be 'class') for --use-feature=class (rt145706)
        if ( substr( $statement_type, 0, 3 ) eq 'sub' ) {
            $last_nonblank_token = $statement_type;
            $last_nonblank_type  = 'S';               # c250 change
            $statement_type      = EMPTY_STRING;
        }
        elsif ( substr( $statement_type, 0, 7 ) eq 'package' ) {
            $last_nonblank_token = $statement_type;
            $last_nonblank_type  = 'P';               # c250 change
            $statement_type      = EMPTY_STRING;
        }

        # patch for SWITCH/CASE: hide these keywords from an immediately
        # following opening brace
        elsif ( ( $statement_type eq 'case' || $statement_type eq 'when' )
            && $statement_type eq $last_nonblank_token )
        {
            $last_nonblank_token = ";";
        }

        elsif ( $last_nonblank_token eq ')' ) {
            $last_nonblank_token = $rparen_type->[ $paren_depth + 1 ];

            # defensive move in case of a nesting error (pbug.t)
            # in which this ')' had no previous '('
            # this nesting error will have been caught
            if ( !defined($last_nonblank_token) ) {
                $last_nonblank_token = 'if';
            }

            # Syntax check at '){'
            if ( $is_blocktype_with_paren{$last_nonblank_token} ) {

                my $rvars = $rparen_vars->[ $paren_depth + 1 ];
                if ( defined($rvars) ) {
                    my ( $type_lp_uu, $want_brace ) = @{$rvars};

                    # OLD: Now verify that this is not a trailing form
                    # FIX for git #124: we have to skip this check because
                    # the 'gather' keyword of List::Gather can operate on
                    # a full statement, so it isn't possible to be sure
                    # this is a trailing form.
                    if ( 0 && !$want_brace ) {
                        $self->warning(
"syntax error at ') {', unexpected '{' after closing ')' of a trailing '$last_nonblank_token'\n"
                        );
                    }
                }
            }
            else {
                if ($rOpts_extended_syntax) {

                    # we append a trailing () to mark this as an unknown
                    # block type.  This allows perltidy to format some
                    # common extensions of perl syntax.
                    # This is used by sub code_block_type
                    $last_nonblank_token .= '()';
                }
                else {
                    my $list =
                      join( SPACE, sort keys %is_blocktype_with_paren );
                    $self->warning(
"syntax error at ') {', didn't see one of: <<$list>>; If this code is okay try using the -xs flag\n"
                    );
                }
            }
        }

        # patch for paren-less for/foreach glitch, part 2.
        # see note below under 'qw'
        elsif ($last_nonblank_token eq 'qw'
            && $is_for_foreach{$want_paren} )
        {
            $last_nonblank_token = $want_paren;
            if ( $last_last_nonblank_token eq $want_paren ) {
                $self->warning(
"syntax error at '$want_paren .. {' -- missing \$ loop variable\n"
                );

            }
            $want_paren = EMPTY_STRING;
        }
        else {
            # not special
        }

        # now identify which of the three possible types of
        # curly braces we have: hash index container, anonymous
        # hash reference, or code block.

        # non-structural (hash index) curly brace pair
        # get marked 'L' and 'R'
        if ( is_non_structural_brace() ) {
            $type = 'L';

            # patch for SWITCH/CASE:
            # allow paren-less identifier after 'when'
            # if the brace is preceded by a space
            if (   $statement_type eq 'when'
                && $last_nonblank_type eq 'i'
                && $last_last_nonblank_type eq 'k'
                && ( $i_tok == 0 || $rtoken_type->[ $i_tok - 1 ] eq 'b' ) )
            {
                $type       = '{';
                $block_type = $statement_type;
            }
        }

        # code and anonymous hash have the same type, '{', but are
        # distinguished by 'block_type',
        # which will be blank for an anonymous hash
        else {

            $block_type =
              $self->code_block_type( $i_tok, $rtokens, $rtoken_type,
                $max_token_index );

            # patch to promote bareword type to function taking block
            if (   $block_type
                && $last_nonblank_type eq 'w'
                && $last_nonblank_i >= 0 )
            {
                if ( $routput_token_type->[$last_nonblank_i] eq 'w' ) {
                    $routput_token_type->[$last_nonblank_i] =
                      $is_grep_alias{$block_type} ? 'k' : 'G';
                }
            }

            # patch for SWITCH/CASE: if we find a stray opening block brace
            # where we might accept a 'case' or 'when' block, then take it
            if (   $statement_type eq 'case'
                || $statement_type eq 'when' )
            {
                if ( !$block_type || $block_type eq '}' ) {
                    $block_type = $statement_type;
                }
            }
        }

        $rbrace_type->[ ++$brace_depth ] = $block_type;

        # Patch for CLASS BLOCK definitions: do not update the package for the
        # current depth if this is a BLOCK type definition.
        # TODO: should make 'class' separate from 'package' and only do
        # this for 'class'
        $rbrace_package->[$brace_depth] = $current_package
          if ( substr( $block_type, 0, 8 ) ne 'package ' );

        $rbrace_structural_type->[$brace_depth] = $type;
        $rbrace_context->[$brace_depth]         = $context;
        ( $type_sequence, $indent_flag ) =
          $self->increase_nesting_depth( BRACE, $rtoken_map->[$i_tok] );

        return;
    } ## end sub do_LEFT_CURLY_BRACKET

    sub do_RIGHT_CURLY_BRACKET {

        my $self = shift;

        # '}'
        $block_type = $rbrace_type->[$brace_depth];
        if ($block_type) { $statement_type = EMPTY_STRING }
        if ( defined( $rbrace_package->[$brace_depth] ) ) {
            $current_package = $rbrace_package->[$brace_depth];
        }

        # can happen on brace error (caught elsewhere)
        else {
        }
        ( $type_sequence, $indent_flag ) =
          $self->decrease_nesting_depth( BRACE, $rtoken_map->[$i_tok] );

        if ( $rbrace_structural_type->[$brace_depth] eq 'L' ) {
            $type = 'R';
        }

        # propagate type information for 'do' and 'eval' blocks, and also
        # for smartmatch operator.  This is necessary to enable us to know
        # if an operator or term is expected next.
        if ( $is_block_operator{$block_type} ) {
            $tok = $block_type;
        }

        # pop non-indenting brace stack if sequence number matches
        if ( @{ $self->[_rnon_indenting_brace_stack_] }
            && $self->[_rnon_indenting_brace_stack_]->[-1] eq $type_sequence )
        {
            pop @{ $self->[_rnon_indenting_brace_stack_] };
        }

        $context = $rbrace_context->[$brace_depth];
        if ( $brace_depth > 0 ) { $brace_depth--; }
        return;
    } ## end sub do_RIGHT_CURLY_BRACKET

    sub do_AMPERSAND {

        my $self = shift;

        # '&' = maybe sub call? start looking
        # We have to check for sub call unless we are sure we
        # are expecting an operator.  This example from s2p
        # got mistaken as a q operator in an early version:
        #   print BODY &q(<<'EOT');
        if ( $expecting != OPERATOR ) {

            # But only look for a sub call if we are expecting a term or
            # if there is no existing space after the &.
            # For example we probably don't want & as sub call here:
            #    Fcntl::S_IRUSR & $mode;
            if ( $expecting == TERM || $next_type ne 'b' ) {
                $self->scan_simple_identifier();
            }
        }
        else {
        }
        return;
    } ## end sub do_AMPERSAND

    sub do_LESS_THAN_SIGN {

        my $self = shift;

        # '<' - angle operator or less than?
        if ( $expecting != OPERATOR ) {
            ( $i, $type ) =
              $self->find_angle_operator_termination( $input_line, $i,
                $rtoken_map, $expecting, $max_token_index );
        }
        else {
        }
        return;
    } ## end sub do_LESS_THAN_SIGN

    sub do_QUESTION_MARK {

        my $self = shift;

        # '?' = conditional or starting pattern?
        my $is_pattern;

        # Patch for rt #126965
        # a pattern cannot follow certain keywords which take optional
        # arguments, like 'shift' and 'pop'. See also '/'.
        if (
            $last_nonblank_type eq 'k'
            && $is_keyword_rejecting_question_as_pattern_delimiter{
                $last_nonblank_token}
          )
        {
            $is_pattern = 0;
        }

        # patch for RT#131288, user constant function without prototype
        # last type is 'U' followed by ?.
        elsif ( $last_nonblank_type =~ /^[FUY]$/ ) {
            $is_pattern = 0;
        }
        elsif ( $expecting == UNKNOWN ) {

            # In older versions of Perl, a bare ? can be a pattern
            # delimiter.  In perl version 5.22 this was
            # dropped, but we have to support it in order to format
            # older programs. See:
            ## https://perl.developpez.com/documentations/en/5.22.0/perl5211delta.html
            # For example, the following line worked
            # at one time:
            #      ?(.*)? && (print $1,"\n");
            # In current versions it would have to be written with slashes:
            #      /(.*)/ && (print $1,"\n");
            my $msg;
            ( $is_pattern, $msg ) =
              $self->guess_if_pattern_or_conditional( $i, $rtokens,
                $rtoken_type, $rtoken_map, $max_token_index );

            if ($msg) { $self->write_logfile_entry($msg) }
        }
        else { $is_pattern = ( $expecting == TERM ) }

        if ($is_pattern) {
            $in_quote                = 1;
            $type                    = 'Q';
            $allowed_quote_modifiers = $quote_modifiers{'m'};
        }
        else {
            ( $type_sequence, $indent_flag ) =
              $self->increase_nesting_depth( QUESTION_COLON,
                $rtoken_map->[$i_tok] );
        }
        return;
    } ## end sub do_QUESTION_MARK

    sub do_STAR {

        my $self = shift;

        # '*' = typeglob, or multiply?
        if ( $expecting == UNKNOWN ) {
            if (   $last_nonblank_type eq 'Z'
                && $next_type ne 'b'
                && $next_type ne '('
                && $next_type ne '#' )    # Fix c036
            {
                $expecting = TERM;
            }
        }

        if ( $expecting == TERM ) {
            $self->scan_simple_identifier();
        }
        else {

            if ( $rtokens->[ $i + 1 ] eq '=' ) {
                $tok  = '*=';
                $type = $tok;
                $i++;
            }
            elsif ( $rtokens->[ $i + 1 ] eq '*' ) {
                $tok  = '**';
                $type = $tok;
                $i++;
                if ( $rtokens->[ $i + 1 ] eq '=' ) {
                    $tok  = '**=';
                    $type = $tok;
                    $i++;
                }
            }
            else {
                ## not multiple characters
            }
        }
        return;
    } ## end sub do_STAR

    sub do_DOT {

        my $self = shift;

        # '.' =  what kind of . ?
        if ( $expecting != OPERATOR ) {
            $self->scan_number();
            if ( $type eq '.' ) {
                $self->error_if_expecting_TERM()
                  if ( $expecting == TERM );
            }
        }
        else {
        }
        return;
    } ## end sub do_DOT

    sub do_COLON {

        my $self = shift;

        # ':' = label, ternary, attribute, ?

        # if this is the first nonblank character, call it a label
        # since perl seems to just swallow it
        if ( $input_line_number == 1 && $last_nonblank_i == -1 ) {
            $type = 'J';
        }

        # ATTRS: check for a ':' which introduces an attribute list
        # either after a 'sub' keyword or within a paren list
        # Added 'package' (can be 'class') for --use-feature=class (rt145706)
        elsif ( $statement_type =~ /^(sub|package)\b/ ) {
            $type = 'A';
            $self->[_in_attribute_list_] = 1;
        }

        # Within a signature, unless we are in a ternary.  For example,
        # from 't/filter_example.t':
        #    method foo4 ( $class: $bar ) { $class->bar($bar) }
        elsif ( $rparen_type->[$paren_depth] =~ /^sub\b/
            && !is_balanced_closing_container(QUESTION_COLON) )
        {
            $type = 'A';
            $self->[_in_attribute_list_] = 1;
        }

        # check for scalar attribute, such as
        # my $foo : shared = 1;
        elsif ($is_my_our_state{$statement_type}
            && $rcurrent_depth->[QUESTION_COLON] == 0 )
        {
            $type = 'A';
            $self->[_in_attribute_list_] = 1;
        }

        # Look for Switch::Plain syntax if an error would otherwise occur
        # here. Note that we do not need to check if the extended syntax
        # flag is set because otherwise an error would occur, and we would
        # then have to output a message telling the user to set the
        # extended syntax flag to avoid the error.
        #  case 1: {
        #  default: {
        #  default:
        # Note that the line 'default:' will be parsed as a label elsewhere.
        elsif ( $is_case_default{$statement_type}
            && !is_balanced_closing_container(QUESTION_COLON) )
        {
            # mark it as a perltidy label type
            $type = 'J';
        }

        # mark colon as attribute if an error would occur otherwise; git #162
        elsif ( !$rcurrent_depth->[QUESTION_COLON] ) {
            $type = 'A';
            $self->[_in_attribute_list_] = 1;
        }

        # otherwise, it should be part of a ?/: operator
        else {
            ( $type_sequence, $indent_flag ) =
              $self->decrease_nesting_depth( QUESTION_COLON,
                $rtoken_map->[$i_tok] );
            if ( $last_nonblank_token eq '?' ) {
                $self->warning("Syntax error near ? :\n");
            }
        }
        return;
    } ## end sub do_COLON

    sub do_PLUS_SIGN {

        my $self = shift;

        # '+' = what kind of plus?
        if ( $expecting == TERM ) {
            my $number = $self->scan_number_fast();

            # unary plus is safest assumption if not a number
            if ( !defined($number) ) { $type = 'p'; }
        }
        elsif ( $expecting == OPERATOR ) {
        }
        else {
            if ( $next_type eq 'w' ) { $type = 'p' }
        }
        return;
    } ## end sub do_PLUS_SIGN

    sub do_AT_SIGN {

        my $self = shift;

        # '@' = sigil for array?
        $self->error_if_expecting_OPERATOR("Array")
          if ( $expecting == OPERATOR );
        $self->scan_simple_identifier();
        return;
    } ## end sub do_AT_SIGN

    sub do_PERCENT_SIGN {

        my $self = shift;

        # '%' = hash or modulo?
        # first guess is hash if no following blank or paren
        if ( $expecting == UNKNOWN ) {
            if ( $next_type ne 'b' && $next_type ne '(' ) {
                $expecting = TERM;
            }
        }
        if ( $expecting == TERM ) {
            $self->scan_simple_identifier();
        }
        return;
    } ## end sub do_PERCENT_SIGN

    sub do_LEFT_SQUARE_BRACKET {

        my $self = shift;

        # '['
        $rsquare_bracket_type->[ ++$square_bracket_depth ] =
          $last_nonblank_token;
        ( $type_sequence, $indent_flag ) =
          $self->increase_nesting_depth( SQUARE_BRACKET,
            $rtoken_map->[$i_tok] );

        # It may seem odd, but structural square brackets have
        # type '{' and '}'.  This simplifies the indentation logic.
        if ( !is_non_structural_brace() ) {
            $type = '{';
        }
        $rsquare_bracket_structural_type->[$square_bracket_depth] = $type;
        return;
    } ## end sub do_LEFT_SQUARE_BRACKET

    sub do_RIGHT_SQUARE_BRACKET {

        my $self = shift;

        # ']'
        ( $type_sequence, $indent_flag ) =
          $self->decrease_nesting_depth( SQUARE_BRACKET,
            $rtoken_map->[$i_tok] );

        if ( $rsquare_bracket_structural_type->[$square_bracket_depth] eq '{' )
        {
            $type = '}';
        }

        # propagate type information for smartmatch operator.  This is
        # necessary to enable us to know if an operator or term is expected
        # next.
        if ( $rsquare_bracket_type->[$square_bracket_depth] eq '~~' ) {
            $tok = $rsquare_bracket_type->[$square_bracket_depth];
        }

        if ( $square_bracket_depth > 0 ) { $square_bracket_depth--; }
        return;
    } ## end sub do_RIGHT_SQUARE_BRACKET

    sub do_MINUS_SIGN {

        my $self = shift;

        # '-' = what kind of minus?
        if ( ( $expecting != OPERATOR )
            && $is_file_test_operator{$next_tok} )
        {
            my ( $next_nonblank_token, $i_next_uu ) =
              $self->find_next_nonblank_token( $i + 1, $rtokens,
                $max_token_index );

            # check for a quoted word like "-w=>xx";
            # it is sufficient to just check for a following '='
            if ( $next_nonblank_token eq '=' ) {
                $type = 'm';
            }
            else {
                $i++;
                $tok .= $next_tok;
                $type = 'F';
            }
        }
        elsif ( $expecting == TERM ) {
            my $number = $self->scan_number_fast();

            # maybe part of bareword token? unary is safest
            if ( !defined($number) ) { $type = 'm'; }

        }
        elsif ( $expecting == OPERATOR ) {
        }
        else {
            if ( $next_type eq 'w' ) {
                $type = 'm';
            }
        }
        return;
    } ## end sub do_MINUS_SIGN

    sub do_CARAT_SIGN {

        my $self = shift;

        # '^'
        # check for special variables like ${^WARNING_BITS}
        if ( $expecting == TERM ) {

            if (   $last_nonblank_token eq '{'
                && ( $next_tok !~ /^\d/ )
                && ( $next_tok =~ /^\w/ ) )
            {

                if ( $next_tok eq 'W' ) {
                    $self->[_saw_perl_dash_w_] = 1;
                }
                $tok  = $tok . $next_tok;
                $i    = $i + 1;
                $type = 'w';

                # Optional coding to try to catch syntax errors. This can
                # be removed if it ever causes incorrect warning messages.
                # The '{^' should be preceded by either by a type or '$#'
                # Examples:
                #   $#{^CAPTURE}       ok
                #   *${^LAST_FH}{NAME} ok
                #   @{^HOWDY}          ok
                #   $hash{^HOWDY}      error

                # Note that a type sigil '$' may be tokenized as 'Z'
                # after something like 'print', so allow type 'Z'
                if (   $last_last_nonblank_type ne 't'
                    && $last_last_nonblank_type ne 'Z'
                    && $last_last_nonblank_token ne '$#' )
                {
                    $self->warning("Possible syntax error near '{^'\n");
                }
            }

            else {
                if ( !$self->error_if_expecting_TERM() ) {

                    # Something like this is valid but strange:
                    # undef ^I;
                    $self->complain("The '^' seems unusual here\n");
                }
            }
        }
        return;
    } ## end sub do_CARAT_SIGN

    sub do_DOUBLE_COLON {

        my $self = shift;

        #  '::' = probably a sub call
        $self->scan_bare_identifier();
        return;
    } ## end sub do_DOUBLE_COLON

    sub do_LEFT_SHIFT {

        my $self = shift;

        # '<<' = maybe a here-doc?
        if ( $expecting != OPERATOR ) {
            my ( $found_target, $here_doc_target, $here_quote_character,
                $saw_error );
            (
                $found_target, $here_doc_target, $here_quote_character, $i,
                $saw_error
              )
              = $self->find_here_doc( $expecting, $i, $rtokens, $rtoken_type,
                $rtoken_map, $max_token_index );

            if ($found_target) {
                push @{$rhere_target_list},
                  [ $here_doc_target, $here_quote_character ];
                $type = 'h';
                if ( length($here_doc_target) > 80 ) {
                    my $truncated = substr( $here_doc_target, 0, 80 );
                    $self->complain("Long here-target: '$truncated' ...\n");
                }
                elsif ( !$here_doc_target ) {
                    $self->warning(
                        'Use of bare << to mean <<"" is deprecated' . "\n" )
                      if ( !$here_quote_character );
                }
                elsif ( $here_doc_target !~ /^[A-Z_]\w+$/ ) {
                    $self->complain(
                        "Unconventional here-target: '$here_doc_target'\n");
                }
                else {
                    # nothing to complain about
                }
            }
            elsif ( $expecting == TERM ) {
                if ( !$saw_error ) {

                    # shouldn't happen..arriving here implies an error in
                    # the logic in sub 'find_here_doc'
                    if (DEVEL_MODE) {
                        $self->Fault(<<EOM);
Program bug; didn't find here doc target
EOM
                    }
                    $self->warning(
                        "Possible program error: didn't find here doc target\n"
                    );
                    $self->report_definite_bug();
                }
            }

            # target not found, expecting == UNKNOWN
            else {
                # assume it is a shift
            }
        }
        else {
        }
        return;
    } ## end sub do_LEFT_SHIFT

    sub do_NEW_HERE_DOC {

        # '<<~' = a here-doc, new type added in v26

        my $self = shift;

        return
          if ( $i >= $max_token_index );  # here-doc not possible if end of line
        if ( $expecting != OPERATOR ) {
            my ( $found_target, $here_doc_target, $here_quote_character,
                $saw_error );
            (
                $found_target, $here_doc_target, $here_quote_character, $i,
                $saw_error
              )
              = $self->find_here_doc( $expecting, $i, $rtokens, $rtoken_type,
                $rtoken_map, $max_token_index );

            if ($found_target) {

                if ( length($here_doc_target) > 80 ) {
                    my $truncated = substr( $here_doc_target, 0, 80 );
                    $self->complain("Long here-target: '$truncated' ...\n");
                }
                elsif ( $here_doc_target !~ /^[A-Z_]\w+$/ ) {
                    $self->complain(
                        "Unconventional here-target: '$here_doc_target'\n");
                }
                else {
                    # nothing to complain about
                }

                # Note that we put a leading space on the here quote
                # character indicate that it may be preceded by spaces
                $here_quote_character = SPACE . $here_quote_character;
                push @{$rhere_target_list},
                  [ $here_doc_target, $here_quote_character ];
                $type = 'h';
            }

            # target not found ..
            elsif ( $expecting == TERM ) {
                if ( !$saw_error ) {

                    # shouldn't happen..arriving here implies an error in
                    # the logic in sub 'find_here_doc'
                    if (DEVEL_MODE) {
                        $self->Fault(<<EOM);
Program bug; didn't find here doc target
EOM
                    }
                    $self->warning(
                        "Possible program error: didn't find here doc target\n"
                    );
                    $self->report_definite_bug();
                }
            }

            # Target not found, expecting==UNKNOWN
            else {
                $self->warning("didn't find here doc target after '<<~'\n");
            }
        }
        else {
            $self->error_if_expecting_OPERATOR();
        }
        return;
    } ## end sub do_NEW_HERE_DOC

    sub do_POINTER {

        #  '->'
        return;
    }

    sub do_PLUS_PLUS {

        my $self = shift;

        # '++'
        # type = 'pp' for pre-increment, '++' for post-increment
        if    ( $expecting == OPERATOR ) { $type = '++' }
        elsif ( $expecting == TERM )     { $type = 'pp' }

        # handle ( $expecting == UNKNOWN )
        else {

            # look ahead ..
            my ( $next_nonblank_token, $i_next ) =
              $self->find_next_nonblank_token( $i, $rtokens, $max_token_index );

            # Fix for c042: look past a side comment
            if ( $next_nonblank_token eq '#' ) {
                ( $next_nonblank_token, $i_next ) =
                  $self->find_next_nonblank_token( $max_token_index,
                    $rtokens, $max_token_index );
            }

            if ( $next_nonblank_token eq '$' ) { $type = 'pp' }
        }
        return;
    } ## end sub do_PLUS_PLUS

    sub do_FAT_COMMA {

        my $self = shift;

        # '=>'
        if ( $last_nonblank_type eq $tok ) {
            $self->complain("Repeated '=>'s \n");
        }

        # patch for operator_expected: note if we are in the list (use.t)
        # TODO: make version numbers a new token type
        if ( $statement_type eq 'use' ) { $statement_type = '_use' }
        return;
    } ## end sub do_FAT_COMMA

    sub do_MINUS_MINUS {

        my $self = shift;

        # '--'
        # type = 'mm' for pre-decrement, '--' for post-decrement

        if    ( $expecting == OPERATOR ) { $type = '--' }
        elsif ( $expecting == TERM )     { $type = 'mm' }

        # handle ( $expecting == UNKNOWN )
        else {

            # look ahead ..
            my ( $next_nonblank_token, $i_next ) =
              $self->find_next_nonblank_token( $i, $rtokens, $max_token_index );

            # Fix for c042: look past a side comment
            if ( $next_nonblank_token eq '#' ) {
                ( $next_nonblank_token, $i_next ) =
                  $self->find_next_nonblank_token( $max_token_index,
                    $rtokens, $max_token_index );
            }

            if ( $next_nonblank_token eq '$' ) { $type = 'mm' }
        }

        return;
    } ## end sub do_MINUS_MINUS

    sub do_LOGICAL_AND {

        my $self = shift;

        # '&&'
        $self->error_if_expecting_TERM()
          if ( $expecting == TERM && $last_nonblank_token ne ',' );    #c015
        return;
    } ## end sub do_LOGICAL_AND

    sub do_LOGICAL_OR {

        my $self = shift;

        # '||'
        $self->error_if_expecting_TERM()
          if ( $expecting == TERM && $last_nonblank_token ne ',' );    #c015
        return;
    } ## end sub do_LOGICAL_OR

    sub do_SLASH_SLASH {

        my $self = shift;

        # '//'
        $self->error_if_expecting_TERM()
          if ( $expecting == TERM );
        return;
    } ## end sub do_SLASH_SLASH

    sub do_DIGITS {

        my $self = shift;

        # 'd' = string of digits
        $self->error_if_expecting_OPERATOR("Number")
          if ( $expecting == OPERATOR );

        my $number = $self->scan_number_fast();
        if ( !defined($number) ) {

            # shouldn't happen - we should always get a number
            if (DEVEL_MODE) {
                $self->Fault(<<EOM);
non-number beginning with digit--program bug
EOM
            }
            $self->warning(
                "Unexpected error condition: non-number beginning with digit\n"
            );
            $self->report_definite_bug();
        }
        return;
    } ## end sub do_DIGITS

    sub do_ATTRIBUTE_LIST {

        my ( $self, $next_nonblank_token ) = @_;

        # Called at a bareword encountered while in an attribute list
        # returns 'is_attribute':
        #    true if attribute found
        #    false if an attribute (continue parsing bareword)

        # treat bare word followed by open paren like qw(
        if ( $next_nonblank_token eq '(' ) {

            # For something like:
            #     : prototype($$)
            # we should let do_scan_sub see it so that it can see
            # the prototype.  All other attributes get parsed as a
            # quoted string.
            if ( $tok eq 'prototype' ) {
                $id_scan_state = 'prototype';

                # start just after the word 'prototype'
                my $i_beg = $i + 1;
                ( $i, $tok, $type, $id_scan_state ) = $self->do_scan_sub(
                    {
                        input_line      => $input_line,
                        i               => $i,
                        i_beg           => $i_beg,
                        tok             => $tok,
                        type            => $type,
                        rtokens         => $rtokens,
                        rtoken_map      => $rtoken_map,
                        id_scan_state   => $id_scan_state,
                        max_token_index => $max_token_index,
                    }
                );

                # If successful, mark as type 'q' to be consistent
                # with other attributes.  Type 'w' would also work.
                if ( $i > $i_beg ) {
                    $type = 'q';
                    return 1;
                }

                # If not successful, continue and parse as a quote.
            }

            # All other attribute lists must be parsed as quotes
            # (see 'signatures.t' for good examples)
            $in_quote                = $quote_items{'q'};
            $allowed_quote_modifiers = $quote_modifiers{'q'};
            $type                    = 'q';
            $quote_type              = 'q';
            return 1;
        }

        # handle bareword not followed by open paren
        else {
            $type = 'w';
            return 1;
        }

        # attribute not found
        return;
    } ## end sub do_ATTRIBUTE_LIST

    sub do_X_OPERATOR {

        my $self = shift;

        if ( $tok eq 'x' ) {
            if ( $rtokens->[ $i + 1 ] eq '=' ) {    # x=
                $tok  = 'x=';
                $type = $tok;
                $i++;
            }
            else {
                $type = 'x';
            }
        }
        else {

            # Split a pretoken like 'x10' into 'x' and '10'.
            # Note: In previous versions of perltidy it was marked
            # as a number, $type = 'n', and fixed downstream by the
            # Formatter.
            $type = 'n';
            if ( $self->split_pretoken(1) ) {
                $type = 'x';
                $tok  = 'x';
            }
        }
        return;
    } ## end sub do_X_OPERATOR

    sub do_USE_CONSTANT {

        my $self = shift;

        $self->scan_bare_identifier();
        my ( $next_nonblank_tok2, $i_next2_uu ) =
          $self->find_next_nonblank_token( $i, $rtokens, $max_token_index );

        if ($next_nonblank_tok2) {

            if ( $is_keyword{$next_nonblank_tok2} ) {

                # Assume qw is used as a quote and okay, as in:
                #  use constant qw{ DEBUG 0 };
                # Not worth trying to parse for just a warning

                # NOTE: This warning is deactivated because recent
                # versions of perl do not complain here, but
                # the coding is retained for reference.
                if ( 0 && $next_nonblank_tok2 ne 'qw' ) {
                    $self->warning(
"Attempting to define constant '$next_nonblank_tok2' which is a perl keyword\n"
                    );
                }
            }

            else {
                $ris_constant->{$current_package}{$next_nonblank_tok2} = 1;
            }
        }
        return;
    } ## end sub do_USE_CONSTANT

    sub do_KEYWORD {

        my $self = shift;

        # found a keyword - set any associated flags
        $type = 'k';

        # Since for and foreach may not be followed immediately
        # by an opening paren, we have to remember which keyword
        # is associated with the next '('
        # Previously, before update   c230 : if ( $is_for_foreach{$tok} ) {
        ##(if elsif unless while until for foreach switch case given when catch)
        if ( $is_blocktype_with_paren{$tok} ) {
            if ( new_statement_ok() ) {
                $want_paren = $tok;
            }
        }

        # recognize 'use' statements, which are special
        if ( $is_use_require{$tok} ) {
            $statement_type = $tok;
            $self->error_if_expecting_OPERATOR()
              if ( $expecting == OPERATOR );
        }

        # remember my and our to check for trailing ": shared"
        elsif ( $is_my_our_state{$tok} ) {
            $statement_type = $tok;
        }

        # Check for unexpected 'elsif'
        elsif ( $tok eq 'elsif' ) {
            if (

                !$is_if_elsif_unless{$last_nonblank_block_type}

                # Allow isolated blocks of any kind during editing
                # by checking for a last noblank token of ';' and no
                # sequence numbers having been issued (c272). The check
                # on sequence number is not perfect but good enough.
                && !(
                       $last_nonblank_token eq ';'
                    && $next_sequence_number == SEQ_ROOT + 1
                )

              )
            {
                $self->warning(
                    "expecting '$tok' to follow one of 'if|elsif|unless'\n");
            }
        }

        # Check for unexpected 'else'
        elsif ( $tok eq 'else' ) {

            # patched for SWITCH/CASE
            if (

                !$is_if_elsif_unless_case_when{$last_nonblank_block_type}

                # patch to avoid an unwanted error message for
                # the case of a parenless 'case' (RT 105484):
                # switch ( 1 ) { case x { 2 } else { } }
                && !$is_if_elsif_unless_case_when{$statement_type}

                # Allow isolated blocks of any kind during editing (c272)
                && !(
                       $last_nonblank_token eq ';'
                    && $next_sequence_number == SEQ_ROOT + 1
                )

              )
            {
                $self->warning(
"expecting '$tok' to follow one of 'if|elsif|unless|case|when'\n"
                );
            }
        }

        # patch for SWITCH/CASE if 'case' and 'when are
        # treated as keywords.  Also 'default' for Switch::Plain
        elsif ($tok eq 'when'
            || $tok eq 'case'
            || $tok eq 'default' )
        {
            $statement_type = $tok;    # next '{' is block
        }

        # feature 'err' was removed in Perl 5.10.  So mark this as
        # a bareword unless an operator is expected (see c158).
        elsif ( $tok eq 'err' ) {
            if ( $expecting != OPERATOR ) { $type = 'w' }
        }
        else {
            ## no special treatment needed
        }

        return;
    } ## end sub do_KEYWORD

    sub do_QUOTE_OPERATOR {

        my $self = shift;

        if ( $expecting == OPERATOR ) {

            # Be careful not to call an error for a qw quote
            # where a parenthesized list is allowed.  For example,
            # it could also be a for/foreach construct such as
            #
            #    foreach my $key qw\Uno Due Tres Quadro\ {
            #        print "Set $key\n";
            #    }
            #

            # Or it could be a function call.
            # NOTE: Braces in something like &{ xxx } are not
            # marked as a block, we might have a method call.
            # &method(...), $method->(..), &{method}(...),
            # $ref[2](list) is ok & short for $ref[2]->(list)
            #
            # See notes in 'sub code_block_type' and
            # 'sub is_non_structural_brace'

            my $paren_list_possible = $tok eq 'qw'
              && ( $last_nonblank_token =~ /^([\]\}\&]|\-\>)/
                || $is_for_foreach{$want_paren} );

            if ( !$paren_list_possible ) {
                $self->error_if_expecting_OPERATOR();
            }
        }
        $in_quote                = $quote_items{$tok};
        $allowed_quote_modifiers = $quote_modifiers{$tok};

        # All quote types are 'Q' except possibly qw quotes.
        # qw quotes are special in that they may generally be trimmed
        # of leading and trailing whitespace.  So they are given a
        # separate type, 'q', unless requested otherwise.
        $type =
          ( $tok eq 'qw' && $rOpts_trim_qw )
          ? 'q'
          : 'Q';
        $quote_type = $type;
        return;
    } ## end sub do_QUOTE_OPERATOR

    sub do_UNKNOWN_BAREWORD {

        my ( $self, $next_nonblank_token ) = @_;

        $self->scan_bare_identifier();

        if (   $statement_type eq 'use'
            && $last_nonblank_token eq 'use' )
        {
            $rsaw_use_module->{$current_package}->{$tok} = 1;
        }

        if ( $type eq 'w' ) {

            if ( $expecting == OPERATOR ) {

                # Patch to avoid error message for RPerl overloaded
                # operator functions: use overload
                #    '+' => \&sse_add,
                #    '-' => \&sse_sub,
                #    '*' => \&sse_mul,
                #    '/' => \&sse_div;
                # TODO: this could eventually be generalized
                if (   $rsaw_use_module->{$current_package}->{'RPerl'}
                    && $tok =~ /^sse_(mul|div|add|sub)$/ )
                {

                }

                # patch for Syntax::Operator::In, git #162
                elsif ( $tok eq 'in' && $next_nonblank_token eq ':' ) {

                }

                # Fix part 1 for git #63 in which a comment falls
                # between an -> and the following word.  An
                # alternate fix would be to change operator_expected
                # to return an UNKNOWN for this type.
                elsif ( $last_nonblank_type eq '->' ) {

                }

                # don't complain about possible indirect object
                # notation.
                # For example:
                #   package main;
                #   sub new($) { ... }
                #   $b = new A::;  # calls A::new
                #   $c = new A;    # same thing but suspicious
                # This will call A::new but we have a 'new' in
                # main:: which looks like a constant.
                #
                elsif ( $last_nonblank_type eq 'C' ) {
                    if ( $tok !~ /::$/ ) {
                        $self->complain(<<EOM);
Expecting operator after '$last_nonblank_token' but found bare word '$tok'
       Maybe indirectet object notation?
EOM
                    }
                }
                else {
                    $self->error_if_expecting_OPERATOR("bareword");
                }
            }

            # mark bare words immediately followed by a paren as
            # functions
            $next_tok = $rtokens->[ $i + 1 ];
            if ( $next_tok eq '(' ) {

                # Patch for issue c151, where we are processing a snippet and
                # have not seen that SPACE is a constant.  In this case 'x' is
                # probably an operator. The only disadvantage with an incorrect
                # guess is that the space after it may be incorrect. For example
                #   $str .= SPACE x ( 16 - length($str) ); See also b1410.
                if ( $tok eq 'x' && $last_nonblank_type eq 'w' ) { $type = 'x' }

                # Fix part 2 for git #63.  Leave type as 'w' to keep
                # the type the same as if the -> were not separated
                elsif ( $last_nonblank_type ne '->' ) { $type = 'U' }

                # not a special case
                else { }

            }

            # underscore after file test operator is file handle
            if ( $tok eq '_' && $last_nonblank_type eq 'F' ) {
                $type = 'Z';
            }

            # patch for SWITCH/CASE if 'case' and 'when are
            # not treated as keywords:
            if (
                ( $tok eq 'case' && $rbrace_type->[$brace_depth] eq 'switch' )
                || (   $tok eq 'when'
                    && $rbrace_type->[$brace_depth] eq 'given' )
              )
            {
                $statement_type = $tok;    # next '{' is block
                $type           = 'k';     # for keyword syntax coloring
            }
            if ( $next_nonblank_token eq '(' ) {

                # patch for SWITCH/CASE if switch and given not keywords
                # Switch is not a perl 5 keyword, but we will gamble
                # and mark switch followed by paren as a keyword.  This
                # is only necessary to get html syntax coloring nice,
                # and does not commit this as being a switch/case.
                if ( $tok eq 'switch' || $tok eq 'given' ) {
                    $type = 'k';    # for keyword syntax coloring
                }

                # mark 'x' as operator for something like this (see b1410)
                #  my $line = join( LD_X, map { LD_H x ( $_ + 2 ) } @$widths );
                elsif ( $tok eq 'x' && $last_nonblank_type eq 'w' ) {
                    $type = 'x';
                }
                else {
                    ## not a special case
                }
            }
        }
        return;
    } ## end sub do_UNKNOWN_BAREWORD

    sub sub_attribute_ok_here {

        my ( $self, $tok_kw, $next_nonblank_token, $i_next ) = @_;

        # Decide if a ':' can introduce an attribute. For example,
        # something like 'sub :'

        # Given:
        #   $tok_kw = a bareword token
        #   $next_nonblank_token = a following ':' being examined
        #   $i_next = the index of the following ':'

        # We will decide based on if the colon is followed by a bareword
        # which is not a keyword.  Changed inext+1 to inext to fixed case
        # b1190.
        my $sub_attribute_ok_here;
        if (   $is_sub{$tok_kw}
            && $expecting != OPERATOR
            && $next_nonblank_token eq ':' )
        {
            my ( $nn_nonblank_token, $i_nn_uu ) =
              $self->find_next_nonblank_token( $i_next, $rtokens,
                $max_token_index );
            $sub_attribute_ok_here =
                 $nn_nonblank_token =~ /^\w/
              && $nn_nonblank_token !~ /^\d/
              && !$is_keyword{$nn_nonblank_token};
        }
        return $sub_attribute_ok_here;
    } ## end sub sub_attribute_ok_here

    use constant DEBUG_BAREWORD => 0;

    sub saw_bareword_function {
        my ( $self, $bareword ) = @_;
        $self->[_rbareword_info_]->{$current_package}->{$bareword}
          ->{function_count}++;
        return;
    } ## end sub saw_bareword_function

    sub saw_bareword_constant {
        my ( $self, $bareword ) = @_;
        $self->[_rbareword_info_]->{$current_package}->{$bareword}
          ->{constant_count}++;
        return;
    } ## end sub saw_bareword_constant

    sub get_bareword_counts {
        my ( $self, $bareword ) = @_;

        # Given:
        #   $bareword = a bareword
        # Return:
        #   $function_count = number of times seen as function taking >0 args
        #   $constant_count = number of times seen as function taking  0 args
        # Note:
        #   $function_count > 0 implies that a TERM should come next
        #   $constant_count > 0 implies that an OPERATOR **may** come next,
        #      but this can be incorrect if $bareword can take 0 or more args.
        # This is used to help guess tokenization around unknown barewords.
        my $function_count;
        my $constant_count;
        my $rbareword_info_tok = $self->[_rbareword_info_]->{$current_package};
        if ($rbareword_info_tok) {
            $rbareword_info_tok = $rbareword_info_tok->{$bareword};
            if ($rbareword_info_tok) {
                $function_count = $rbareword_info_tok->{function_count};
                $constant_count = $rbareword_info_tok->{constant_count};

                # a positive function count overrides a constant count
                if ($function_count) { $constant_count = 0 }
            }
        }
        if ( !defined($function_count) ) { $function_count = 0 }
        if ( !defined($constant_count) ) { $constant_count = 0 }
        return ( $function_count, $constant_count );
    } ## end sub get_bareword_counts

    # hashes used to help determine a bareword type
    my %is_wiUC;
    my %is_function_follower;
    my %is_constant_follower;
    my %is_use_require_no;

    BEGIN {
        my @qz = qw( w i U C );
        @is_wiUC{@qz} = (1) x scalar(@qz);

        @qz = qw( use require no );
        @is_use_require_no{@qz} = (1) x scalar(@qz);

        # These pre-token types after a bareword imply that it
        # is not a constant, except when '(' is followed by ')'.
        @qz = qw# ( [ { $ @ " ' m #;
        @is_function_follower{@qz} = (1) x scalar(@qz);

        # These pre-token types after a bareword imply that it
        # MIGHT be a constant, but it also might be a function taking
        # 0 or more call args.
        @qz = qw# ; ) ] } if unless #;
        push @qz, ',';
        @is_constant_follower{@qz} = (1) x scalar(@qz);
    }

    sub do_BAREWORD {

        my ($self) = @_;

        # handle a bareword token:
        # returns
        #    true if this token ends the current line
        #    false otherwise

        my $next_nonblank_token;
        my $i_next = $i + 1;
        if ( $i_next <= $max_token_index && $rtoken_type->[$i_next] eq 'b' ) {
            $i_next++;
        }
        if ( $i_next <= $max_token_index ) {
            $next_nonblank_token = $rtokens->[$i_next];
        }
        else {
            ( $next_nonblank_token, $i_next ) =
              $self->find_next_nonblank_token( $i, $rtokens, $max_token_index );
        }

        # a bare word immediately followed by :: is not a keyword;
        # use $tok_kw when testing for keywords to avoid a mistake
        my $tok_kw = $tok;
        if (   $rtokens->[ $i + 1 ] eq ':'
            && $rtokens->[ $i + 2 ] eq ':' )
        {
            $tok_kw .= '::';
        }

        if ( $self->[_in_attribute_list_] ) {
            my $is_attribute = $self->do_ATTRIBUTE_LIST($next_nonblank_token);
            return if ($is_attribute);
        }

        #----------------------------------------
        # Starting final if-elsif- chain of tests
        #----------------------------------------

        # This is the return flag:
        #   true => this is the last token on the line
        #   false => keep tokenizing the line
        my $is_last;

        # The following blocks of code must update these vars:
        # $type - the final token type, must always be set

        # In addition, if additional pretokens are added:
        # $tok  - the final token
        # $i    - the index of the last pretoken

        # They may also need to check and set various flags

        # Scan a bare word following a -> as an identifier; it could
        # have a long package name.  Fixes c037, c041.
        if ( $last_nonblank_token eq '->' ) {
            $self->scan_bare_identifier();

            # a bareward after '->' gets type 'i'
            $type = 'i';
        }

        # Quote a word followed by => operator
        elsif (
            ( $next_nonblank_token eq '=' && $rtokens->[ $i_next + 1 ] eq '>' )

            # unless the word is __END__ or __DATA__ and is the only word on
            # the line.
            && ( !defined( $is_END_DATA{$tok_kw} )
                || $input_line !~ /^\s*__(?:END|DATA)__\s*$/ )
          )
        {
            # Bareword followed by a fat comma - see 'git18.in'
            # This code was previously sub do_QUOTED_BAREWORD: see c316, c317

            # Older perl:
            #   'v25=>1'   is a v-string key!
            #   '-v25=>1'  is also a v-string key!
            # Deactivated: this is no longer true; see git #165
            if ( 0 && $tok =~ /^v\d+$/ ) {
                $type = 'v';
                $self->complain("v-string used as hash key\n");
                $self->report_v_string($tok);
            }

            # If tok is something like 'x17' then it could
            # actually be operator x followed by number 17.
            # For example, here:
            #     123x17 => [ 792, 1224 ],
            # (a key of 123 repeated 17 times, perhaps not
            # what was intended). We will mark x17 as type
            # 'n' and it will be split. If the previous token
            # was also a bareword then it is not very clear is
            # going on.  In this case we will not be sure that
            # an operator is expected, so we just mark it as a
            # bareword.  Perl is a little murky in what it does
            # with stuff like this, and its behavior can change
            # over time.  Something like
            #    a x18 => [792, 1224], will compile as
            # a key with 18 a's.  But something like
            #    push @array, a x18;
            # is a syntax error.
            elsif (
                   $expecting == OPERATOR
                && substr( $tok, 0, 1 ) eq 'x'
                && ( length($tok) == 1
                    || substr( $tok, 1, 1 ) =~ /^\d/ )
              )
            {
                $type = 'n';
                if ( $self->split_pretoken(1) ) {
                    $type = 'x';
                    $tok  = 'x';
                }
                $self->complain("x operator in hash key\n");
            }
            else {

                # git #18
                $type = 'w';
                $self->error_if_expecting_OPERATOR();
            }
        }

        # quote a bare word within braces..like xxx->{s}; note that we
        # must be sure this is not a structural brace, to avoid
        # mistaking {s} in the following for a quoted bare word:
        #     for(@[){s}bla}BLA}
        # Also treat q in something like var{-q} as a bare word, not
        # a quote operator
        elsif (
            $next_nonblank_token eq '}'
            && (
                $last_nonblank_type eq 'L'
                || (   $last_nonblank_type eq 'm'
                    && $last_last_nonblank_type eq 'L' )
            )
          )
        {
            $type = 'w';
        }

        # handle operator x (now we know it isn't $x=)
        elsif (
               $expecting == OPERATOR
            && substr( $tok, 0, 1 ) eq 'x'
            && ( length($tok) == 1
                || substr( $tok, 1, 1 ) =~ /^\d/ )
          )
        {
            $self->do_X_OPERATOR();
        }
        elsif ( $tok_kw eq 'CORE::' ) {
            $type = $tok = $tok_kw;
            $i += 2;
        }
        elsif ( ( $tok eq 'strict' )
            and ( $last_nonblank_token eq 'use' ) )
        {
            $self->[_saw_use_strict_] = 1;
            $self->scan_bare_identifier();
        }

        elsif ( ( $tok eq 'warnings' )
            and ( $last_nonblank_token eq 'use' ) )
        {
            $self->[_saw_perl_dash_w_] = 1;

            # scan as identifier, so that we pick up something like:
            # use warnings::register
            $self->scan_bare_identifier();
        }

        elsif (
               $tok eq 'AutoLoader'
            && $self->[_look_for_autoloader_]
            && (
                $last_nonblank_token eq 'use'

                # these regexes are from AutoSplit.pm, which we want
                # to mimic
                || $input_line =~ /^\s*(use|require)\s+AutoLoader\b/
                || $input_line =~ /\bISA\s*=.*\bAutoLoader\b/
            )
          )
        {
            $self->write_logfile_entry("AutoLoader seen, -nlal deactivates\n");
            $self->[_saw_autoloader_]      = 1;
            $self->[_look_for_autoloader_] = 0;
            $self->scan_bare_identifier();
        }

        elsif (
               $tok eq 'SelfLoader'
            && $self->[_look_for_selfloader_]
            && (   $last_nonblank_token eq 'use'
                || $input_line =~ /^\s*(use|require)\s+SelfLoader\b/
                || $input_line =~ /\bISA\s*=.*\bSelfLoader\b/ )
          )
        {
            $self->write_logfile_entry("SelfLoader seen, -nlsl deactivates\n");
            $self->[_saw_selfloader_]      = 1;
            $self->[_look_for_selfloader_] = 0;
            $self->scan_bare_identifier();
        }

        elsif ( ( $tok eq 'constant' )
            and ( $last_nonblank_token eq 'use' ) )
        {
            $self->do_USE_CONSTANT();
        }

        # various quote operators
        elsif ( $is_q_qq_qw_qx_qr_s_y_tr_m{$tok} ) {
            $self->do_QUOTE_OPERATOR();
        }

        # check for a statement label
        elsif (
               ( $next_nonblank_token eq ':' )
            && ( $rtokens->[ $i_next + 1 ] ne ':' )
            && ( $i_next <= $max_token_index )    # colon on same line

            # like 'sub : lvalue' ?
            && !$self->sub_attribute_ok_here( $tok_kw, $next_nonblank_token,
                $i_next )
            && new_statement_ok()
          )
        {
            if ( $tok !~ /[A-Z]/ ) {
                push @{ $self->[_rlower_case_labels_at_] }, $input_line_number;
            }
            $type = 'J';
            $tok .= ':';
            $i = $i_next;
        }

        # 'sub' or other sub alias
        elsif ( $is_sub{$tok_kw} ) {

            # Update for --use-feature=class (rt145706):
            # We have to be extra careful to avoid misparsing other uses of
            # 'method' in older scripts.
            if ( $tok_kw eq 'method' && $guess_if_method ) {
                if (   $expecting == OPERATOR
                    || $next_nonblank_token !~ /^[\w\:]/
                    || !$self->method_ok_here() )
                {
                    $self->do_UNKNOWN_BAREWORD($next_nonblank_token);
                }
                else {
                    initialize_subname();
                    $self->scan_id();
                }
            }
            else {
                $self->error_if_expecting_OPERATOR()
                  if ( $expecting == OPERATOR );
                initialize_subname();
                $self->scan_id();
            }
        }

        # 'package'
        elsif ( $is_package{$tok_kw} ) {

            # Update for --use-feature=class (rt145706):
            # We have to be extra careful because 'class' may be used for other
            # purposes on older code; i.e.
            #   class($x)   - valid sub call
            #   package($x) - error
            if ( $tok_kw eq 'class' ) {
                if (   $expecting == OPERATOR
                    || $next_nonblank_token !~ /^[\w\:]/
                    || !$self->class_ok_here() )
                {
                    $self->do_UNKNOWN_BAREWORD($next_nonblank_token);
                }
                else { $self->scan_id() }
            }
            else {
                $self->error_if_expecting_OPERATOR()
                  if ( $expecting == OPERATOR );
                $self->scan_id();
            }
        }

        # Fix for c035: split 'format' from 'is_format_END_DATA' to be
        # more restrictive. Require a new statement to be ok here.
        elsif ( $tok_kw eq 'format' && new_statement_ok() ) {
            $type                = ';';    # make tokenizer look for TERM next
            $self->[_in_format_] = 1;
            $is_last             = 1;      ## is last token on this line
        }

        # Note on token types for format, __DATA__, __END__:
        # It simplifies things to give these type ';', so that when we
        # start rescanning we will be expecting a token of type TERM.
        # We will switch to type 'k' before outputting the tokens.
        elsif ( defined( $is_END_DATA{$tok_kw} ) ) {
            $type = ';';    # make tokenizer look for TERM next

            # Remember that we are in one of these three sections
            $self->[ $is_END_DATA{$tok_kw} ] = 1;
            $is_last = 1;                          ## is last token on this line
        }

        elsif ( $is_keyword{$tok_kw} ) {
            $self->do_KEYWORD();
        }

        # check for inline label following
        #         /^(redo|last|next|goto)$/
        elsif (( $last_nonblank_type eq 'k' )
            && ( $is_redo_last_next_goto{$last_nonblank_token} ) )
        {
            $type = 'j';
        }

        # something else --
        else {
            $self->do_UNKNOWN_BAREWORD($next_nonblank_token);
        }

        #----------------------------------------------------------------
        # Save info for use in later guessing. Even for types 'i' and 'U'
        # because those may be marked as type 'w' (barewords) elsewhere.
        #----------------------------------------------------------------
        if (   $is_wiUC{$type}
            && $statement_type ne 'use'
            && $statement_type ne '_use' )
        {
            my $result = "unknown";

            # Words are marked 'function' if they appear in a role which
            # is not consistent with a constant value. Typically they are
            # function calls.
            if (   $type eq 'U'
                || $is_function_follower{$next_nonblank_token} )
            {

                my $empty_parens = 0;
                if ( $next_nonblank_token eq '(' && $i_next < $max_token_index )
                {
                    my $tok_next_p1 = $rtokens->[ $i_next + 1 ];
                    if ( substr( $tok_next_p1, 0, 1 ) eq SPACE
                        && $i_next + 2 <= $max_token_index )
                    {
                        $tok_next_p1 = $rtokens->[ $i_next + 2 ];
                    }
                    $empty_parens = $tok_next_p1 eq ')';
                }

                if ( !$empty_parens ) {

                    # not a constant term - probably a function
                    $result = "function";
                    $self->saw_bareword_function($tok);
                }
            }

            # Words are marked 'constant' if they appear in a role
            # consistent with a constant value.  However, they may simply
            # be functions which optionally take zero args. So if a word
            # appears as both constant and function, it is not a constant.
            elsif ($type eq 'C'
                || $is_constant_follower{$next_nonblank_token} )
            {

                my $is_hash_key = $next_nonblank_token eq '}'
                  && (
                    $last_nonblank_type eq 'L'
                    || (   $last_nonblank_type eq 'm'
                        && $last_last_nonblank_type eq 'L' )
                  );

                if (

                    # not a hash key like {bareword} or {-bareword}
                    !$is_hash_key

                    # not a package name, etc
                    && ( $last_nonblank_type ne 'k'
                        || !$is_use_require_no{$last_nonblank_token} )

                    # skip arrow calls, which can go either way
                    && $last_nonblank_token ne '->'
                  )
                {
                    # possibly a constant or constant function
                    $result = "constant";
                    $self->saw_bareword_constant($tok);
                }
                else {
                    $result = "other bareword";
                }
            }
            else {
            }

            if ( DEBUG_BAREWORD && $result ne 'other bareword' ) {
                print
"$input_line_number: $result: $tok: type=$type : last_tok=$last_nonblank_token : next_tok='$next_nonblank_token'\n";
            }
        }
        return $is_last;

    } ## end sub do_BAREWORD

    sub do_FOLLOW_QUOTE {

        my $self = shift;

        # Continue following a quote on a new line
        $type = $quote_type;

        if ( !@{$routput_token_list} ) {    # initialize if continuation line
            push( @{$routput_token_list}, $i );
            $routput_token_type->[$i] = $type;

        }

        # scan for the end of the quote or pattern
        (
            $i,
            $in_quote,
            $quote_character,
            $quote_pos,
            $quote_depth,
            $quoted_string_1,
            $quoted_string_2,

        ) = $self->do_quote(

            $i,
            $in_quote,
            $quote_character,
            $quote_pos,
            $quote_depth,
            $quoted_string_1,
            $quoted_string_2,
            $rtokens,
            $rtoken_type,
            $rtoken_map,
            $max_token_index,

        );

        # all done if we didn't find it
        if ($in_quote) { return }

        # save pattern and replacement text for rescanning
        my $qs1 = $quoted_string_1;

        # re-initialize for next search
        $quote_character = EMPTY_STRING;
        $quote_pos       = 0;
        $quote_type      = 'Q';
        $quoted_string_1 = EMPTY_STRING;
        $quoted_string_2 = EMPTY_STRING;
        if ( ++$i > $max_token_index ) { return }

        # look for any modifiers
        if ($allowed_quote_modifiers) {

            # check for exact quote modifiers
            if ( $rtokens->[$i] =~ /^[A-Za-z_]/ ) {
                my $str = $rtokens->[$i];
                my $saw_modifier_e;
                while ( $str =~ /\G$allowed_quote_modifiers/gc ) {
                    my $pos  = pos($str);
                    my $char = substr( $str, $pos - 1, 1 );
                    $saw_modifier_e ||= ( $char eq 'e' );
                }

                # For an 'e' quote modifier we must scan the replacement
                # text for here-doc targets...
                # but if the modifier starts a new line we can skip
                # this because either the here doc will be fully
                # contained in the replacement text (so we can
                # ignore it) or Perl will not find it.
                # See test 'here2.in'.
                if ( $saw_modifier_e && $i_tok >= 0 ) {

                    my $rht = $self->scan_replacement_text($qs1);

                    # Change type from 'Q' to 'h' for quotes with
                    # here-doc targets so that the formatter (see sub
                    # process_line_of_CODE) will not make any line
                    # breaks after this point.
                    if ($rht) {
                        push @{$rhere_target_list}, @{$rht};
                        $type = 'h';
                        if ( $i_tok < 0 ) {
                            my $ilast = $routput_token_list->[-1];
                            $routput_token_type->[$ilast] = $type;
                        }
                    }
                }

                if ( defined( pos($str) ) ) {

                    # matched
                    if ( pos($str) == length($str) ) {
                        if ( ++$i > $max_token_index ) { return }
                    }

                    # Looks like a joined quote modifier
                    # and keyword, maybe something like
                    # s/xxx/yyy/gefor @k=...
                    # Example is "galgen.pl".  Would have to split
                    # the word and insert a new token in the
                    # pre-token list.  This is so rare that I haven't
                    # done it.  Will just issue a warning citation.

                    # This error might also be triggered if my quote
                    # modifier characters are incomplete
                    else {
                        $self->warning(<<EOM);

Partial match to quote modifier $allowed_quote_modifiers at word: '$str'
Please put a space between quote modifiers and trailing keywords.
EOM

                        # print "token $rtokens->[$i]\n";
                        # my $num = length($str) - pos($str);
                        # $rtokens->[$i]=substr($rtokens->[$i],pos($str),$num);
                        # print "continuing with new token $rtokens->[$i]\n";

                        # skipping past this token does least damage
                        if ( ++$i > $max_token_index ) { return }
                    }
                }
                else {

                    # example file: rokicki4.pl
                    # This error might also be triggered if my quote
                    # modifier characters are incomplete
                    $self->write_logfile_entry(
                        "Note: found word $str at quote modifier location\n");
                }
            }

            # re-initialize
            $allowed_quote_modifiers = EMPTY_STRING;
        }
        return;
    } ## end sub do_FOLLOW_QUOTE

    # ------------------------------------------------------------
    # begin hash of code for handling most token types
    # ------------------------------------------------------------
    my $tokenization_code = {

        '>'   => \&do_GREATER_THAN_SIGN,
        '|'   => \&do_VERTICAL_LINE,
        '$'   => \&do_DOLLAR_SIGN,
        '('   => \&do_LEFT_PARENTHESIS,
        ')'   => \&do_RIGHT_PARENTHESIS,
        ','   => \&do_COMMA,
        ';'   => \&do_SEMICOLON,
        '"'   => \&do_QUOTATION_MARK,
        "'"   => \&do_APOSTROPHE,
        '`'   => \&do_BACKTICK,
        '/'   => \&do_SLASH,
        '{'   => \&do_LEFT_CURLY_BRACKET,
        '}'   => \&do_RIGHT_CURLY_BRACKET,
        '&'   => \&do_AMPERSAND,
        '<'   => \&do_LESS_THAN_SIGN,
        '?'   => \&do_QUESTION_MARK,
        '*'   => \&do_STAR,
        '.'   => \&do_DOT,
        ':'   => \&do_COLON,
        '+'   => \&do_PLUS_SIGN,
        '@'   => \&do_AT_SIGN,
        '%'   => \&do_PERCENT_SIGN,
        '['   => \&do_LEFT_SQUARE_BRACKET,
        ']'   => \&do_RIGHT_SQUARE_BRACKET,
        '-'   => \&do_MINUS_SIGN,
        '^'   => \&do_CARAT_SIGN,
        '::'  => \&do_DOUBLE_COLON,
        '<<'  => \&do_LEFT_SHIFT,
        '<<~' => \&do_NEW_HERE_DOC,
        '->'  => \&do_POINTER,
        '++'  => \&do_PLUS_PLUS,
        '=>'  => \&do_FAT_COMMA,
        '--'  => \&do_MINUS_MINUS,
        '&&'  => \&do_LOGICAL_AND,
        '||'  => \&do_LOGICAL_OR,
        '//'  => \&do_SLASH_SLASH,

        # No special code for these types yet, but syntax checks
        # could be added.
        ##  '!'   => undef,
        ##  '!='  => undef,
        ##  '!~'  => undef,
        ##  '%='  => undef,
        ##  '&&=' => undef,
        ##  '&='  => undef,
        ##  '+='  => undef,
        ##  '-='  => undef,
        ##  '..'  => undef,
        ##  '..'  => undef,
        ##  '...' => undef,
        ##  '.='  => undef,
        ##  '<<=' => undef,
        ##  '<='  => undef,
        ##  '<=>' => undef,
        ##  '<>'  => undef,
        ##  '='   => undef,
        ##  '=='  => undef,
        ##  '=~'  => undef,
        ##  '>='  => undef,
        ##  '>>'  => undef,
        ##  '>>=' => undef,
        ##  '\\'  => undef,
        ##  '^='  => undef,
        ##  '|='  => undef,
        ##  '||=' => undef,
        ##  '//=' => undef,
        ##  '~'   => undef,
        ##  '~~'  => undef,
        ##  '!~~' => undef,

    };

    # ------------------------------------------------------------
    # end hash of code for handling individual token types
    # ------------------------------------------------------------

    use constant DEBUG_TOKENIZE => 0;

    my %is_arrow_or_Z;

    BEGIN {
        my @qZ = qw( -> Z );
        @is_arrow_or_Z{@qZ} = (1) x scalar(@qZ);
    }

    sub tokenize_this_line {

        my ( $self, $line_of_tokens, $trimmed_input_line ) = @_;

        # This routine tokenizes one line. The results are stored in
        # the hash ref '$line_of_tokens'.

        # Given:
        #   $line_of_tokens = ref to hash of values being filled for this line
        #   $trimmed_input_line
        #        = the input line without leading whitespace, OR
        #        = undef if not available
        # Returns:
        #   nothing

        my $untrimmed_input_line = $line_of_tokens->{_line_text};

        # Extract line number for use in error messages
        $input_line_number = $line_of_tokens->{_line_number};

        #-------------------------------------
        # Check for start of pod documentation
        #-------------------------------------
        if ( substr( $untrimmed_input_line, 0, 1 ) eq '='
            && $untrimmed_input_line =~ /^=[A-Za-z_]/ )
        {

            # Must not be in multi-line quote
            # and must not be in an equation
            my $blank_after_Z = 1;
            if (
                !$in_quote
                && ( $self->operator_expected( '=', 'b', $blank_after_Z ) ==
                    TERM )
              )
            {
                $self->[_in_pod_] = 1;
                return;
            }
        }

        #--------------------------
        # Trim leading whitespace ?
        #--------------------------
        # Use untrimmed line if we are continuing in a type 'Q' quote
        if ( $in_quote && $quote_type eq 'Q' ) {
            $line_of_tokens->{_starting_in_quote} = 1;
            $input_line = $untrimmed_input_line;
            chomp $input_line;
        }

        # Trim start of this line if we are not continuing a quoted line.
        # Do not trim end because we might end in a quote (test: deken4.pl)
        # Perl::Tidy::Formatter will delete needless trailing blanks
        else {
            $line_of_tokens->{_starting_in_quote} = 0;

            # Use the pre-computed trimmed line if defined (most efficient)
            $input_line = $trimmed_input_line;

            # otherwise trim the raw input line (much less efficient)
            if ( !defined($input_line) ) {
                $input_line = $untrimmed_input_line;
                $input_line =~ s/^\s+//;
            }

            chomp $input_line;

            # define 'guessed_indentation_level' if logfile will be saved
            if ( $self->[_save_logfile_] && length($input_line) ) {
                my $guess =
                  $self->guess_old_indentation_level($untrimmed_input_line);
                $line_of_tokens->{_guessed_indentation_level} = $guess;
            }
        }

        #------------
        # Blank lines
        #------------
        if ( !length($input_line) ) {
            $line_of_tokens->{_line_type}        = 'CODE';
            $line_of_tokens->{_rtokens}          = [];
            $line_of_tokens->{_rtoken_type}      = [];
            $line_of_tokens->{_rlevels}          = [];
            $line_of_tokens->{_rblock_type}      = [];
            $line_of_tokens->{_nesting_tokens_0} = $nesting_token_string;
            $line_of_tokens->{_nesting_blocks_0} = $nesting_block_string;
            return;
        }

        #---------
        # Comments
        #---------
        if ( !$in_quote && substr( $input_line, 0, 1 ) eq '#' ) {

            # and check for skipped section
            if (
                (
                    substr( $input_line, 0, 4 ) eq '#<<V'
                    || $rOpts_code_skipping_begin
                )
                && $rOpts_code_skipping

                # note that the code_skipping_patterns require a newline
                && $input_line . "\n" =~ /$code_skipping_pattern_begin/
              )
            {
                $self->[_in_code_skipping_] = $self->[_last_line_number_];
                return;
            }

            if ( !$self->[_in_format_skipping_] ) {
                if (
                    (
                        substr( $input_line, 0, 4 ) eq '#<<<'
                        || $rOpts_format_skipping_begin
                    )
                    && $rOpts_format_skipping

                    # note that the code_skipping_patterns require a newline
                    && $input_line . "\n" =~ /$format_skipping_pattern_begin/
                  )
                {
                    $self->[_in_format_skipping_] = $self->[_last_line_number_];
                }
            }
            else {
                if (
                    (
                        substr( $input_line, 0, 4 ) eq '#>>>'
                        || $rOpts_format_skipping_end
                    )

                    # note that the code_skipping_patterns require a newline
                    && $input_line . "\n" =~ /$format_skipping_pattern_end/
                  )
                {
                    $self->[_in_format_skipping_] = 0;
                }
            }

            # Optional fast processing of a block comment
            $line_of_tokens->{_line_type}        = 'CODE';
            $line_of_tokens->{_rtokens}          = [$input_line];
            $line_of_tokens->{_rtoken_type}      = ['#'];
            $line_of_tokens->{_rlevels}          = [$level_in_tokenizer];
            $line_of_tokens->{_rblock_type}      = [EMPTY_STRING];
            $line_of_tokens->{_nesting_tokens_0} = $nesting_token_string;
            $line_of_tokens->{_nesting_blocks_0} = $nesting_block_string;
            return;
        }

        #-------------------------------------
        # Loop to find all tokens on this line
        #-------------------------------------

        # Update the copy of the line for use in error messages
        # This must be exactly what we give the pre_tokenizer
        $self->[_line_of_text_] = $input_line;

        # re-initialize for the main loop
        $routput_token_list    = [];    # stack of output token indexes
        $routput_token_type    = [];    # token types
        $routput_block_type    = [];    # types of code block
        $routput_type_sequence = [];    # nesting sequential number

        $rhere_target_list = [];

        $tok             = $last_nonblank_token;
        $type            = $last_nonblank_type;
        $prototype       = $last_nonblank_prototype;
        $last_nonblank_i = -1;
        $block_type      = $last_nonblank_block_type;
        $container_type  = $last_nonblank_container_type;
        $type_sequence   = $last_nonblank_type_sequence;
        $indent_flag     = 0;
        $peeked_ahead    = 0;

        $self->tokenizer_main_loop();

        #-------------------------------------------------
        # Done tokenizing this line ... package the result
        #-------------------------------------------------
        $self->tokenizer_wrapup_line($line_of_tokens);

        return;
    } ## end sub tokenize_this_line

    sub tokenizer_main_loop {

        my ($self) = @_;

        # Break one input line into tokens
        # We are working on closure variables.

        # Start by breaking the line into pre-tokens
        ( $rtokens, $rtoken_map, $rtoken_type ) = pre_tokenize($input_line);

        # Verify that all leading whitespace has been trimmed
        # except for quotes of type 'Q' (c273).
        if (   @{$rtokens}
            && $rtoken_type->[0] eq 'b'
            && !( $in_quote && $quote_type eq 'Q' ) )
        {

            # Shouldn't happen if calling sub did trim operation correctly.
            DEVEL_MODE && $self->Fault(<<EOM);
leading blank at line
$input_line
EOM

            # Fix by removing the leading blank token.  This fix has been
            # tested and works correctly even if no whitespaces was trimmed.
            # But it is an inefficient way to do things because, for example,
            # it forces all comments to be processed by sub pre_tokenize.
            # And it may cause indented code-skipping comments to be missed.
            shift @{$rtokens};
            shift @{$rtoken_map};
            shift @{$rtoken_type};
        }

        $max_token_index = scalar( @{$rtokens} ) - 1;
        push( @{$rtokens}, SPACE, SPACE, SPACE )
          ;    # extra whitespace simplifies logic
        push( @{$rtoken_map},  0,   0,   0 );     # shouldn't be referenced
        push( @{$rtoken_type}, 'b', 'b', 'b' );

        # initialize for main loop
        if (0) { #<<< this is not necessary
        foreach my $ii ( 0 .. $max_token_index + 3 ) {
            $routput_token_type->[$ii]    = EMPTY_STRING;
            $routput_block_type->[$ii]    = EMPTY_STRING;
            $routput_type_sequence->[$ii] = EMPTY_STRING;
            $routput_indent_flag->[$ii]   = 0;
        }
        }

        $i     = -1;
        $i_tok = -1;

        #-----------------------
        # main tokenization loop
        #-----------------------

        # we are looking at each pre-token of one line and combining them
        # into tokens
        while ( ++$i <= $max_token_index ) {

            # continue looking for the end of a quote
            if ($in_quote) {
                $self->do_FOLLOW_QUOTE();
                last if ( $in_quote || $i > $max_token_index );
            }

            if ( $type ne 'b' && $type ne 'CORE::' ) {

                # try to catch some common errors
                if ( ( $type eq 'n' ) && ( $tok ne '0' ) ) {

                    if ( $last_nonblank_token eq 'eq' ) {
                        $self->complain("Should 'eq' be '==' here ?\n");
                    }
                    elsif ( $last_nonblank_token eq 'ne' ) {
                        $self->complain("Should 'ne' be '!=' here ?\n");
                    }
                    else {
                        # that's all
                    }
                }

                # fix c090, only rotate vars if a new token will be stored
                if ( $i_tok >= 0 ) {

                    $last_last_nonblank_token = $last_nonblank_token;
                    $last_last_nonblank_type  = $last_nonblank_type;

                    $last_nonblank_prototype      = $prototype;
                    $last_nonblank_block_type     = $block_type;
                    $last_nonblank_container_type = $container_type;
                    $last_nonblank_type_sequence  = $type_sequence;
                    $last_nonblank_i              = $i_tok;
                    $last_nonblank_token          = $tok;
                    $last_nonblank_type           = $type;
                }

                # Check for patches
                if ( $is_arrow_or_Z{$last_last_nonblank_type} ) {

                    # Patch for c030: Fix things in case a '->' got separated
                    # from the subsequent identifier by a side comment.  We
                    # need the last_nonblank_token to have a leading -> to
                    # avoid triggering an operator expected error message at
                    # the next '('. See also fix for git #63.
                    if ( $last_last_nonblank_type eq '->' ) {
                        if (   $last_nonblank_type eq 'w'
                            || $last_nonblank_type eq 'i' )
                        {
                            $last_nonblank_token = '->' . $last_nonblank_token;
                            $last_nonblank_type  = 'i';
                        }
                    }

                    # Fix part #3 for git82: propagate type 'Z' though L-R pair
                    elsif ( $last_last_nonblank_type eq 'Z' ) {
                        if ( $last_nonblank_type eq 'R' ) {
                            $last_nonblank_type  = $last_last_nonblank_type;
                            $last_nonblank_token = $last_last_nonblank_token;
                        }
                    }
                    else {
                        # No other patches
                    }
                }
            }

            # store previous token type
            if ( $i_tok >= 0 ) {
                $routput_token_type->[$i_tok]    = $type;
                $routput_block_type->[$i_tok]    = $block_type;
                $routput_type_sequence->[$i_tok] = $type_sequence;
                $routput_indent_flag->[$i_tok]   = $indent_flag;
            }

            # get the next pre-token and type
            # $tok and $type will be modified to make the output token
            my $pre_tok  = $tok  = $rtokens->[$i];      # get the next pre-token
            my $pre_type = $type = $rtoken_type->[$i];  # and type

            # re-initialize various flags for the next output token
            (

                # remember the starting index of this token; we will update $i
                $i_tok,
                $block_type,
                $container_type,
                $type_sequence,
                $indent_flag,
                $prototype,
              )
              = (

                $i,
                EMPTY_STRING,
                EMPTY_STRING,
                EMPTY_STRING,
                0,
                EMPTY_STRING,
              );

            # this pre-token will start an output token
            push( @{$routput_token_list}, $i_tok );

            #---------------------------------------------------
            # The token search leads to one of 5 main END NODES:
            #---------------------------------------------------

            #-----------------------
            # END NODE 1: whitespace
            #-----------------------
            next if ( $pre_type eq 'b' );

            #----------------------
            # END NODE 2: a comment
            #----------------------
            if ( $pre_type eq '#' ) {

                # push non-indenting brace stack Look for a possible
                # non-indenting brace.  This is only used to give a hint in
                # case the file is unbalanced.
                # Hardwired to '#<<<' for efficiency.  We will not use the
                # result later if the pattern has been changed (very unusual).
                if (   $last_nonblank_token eq '{'
                    && $last_nonblank_block_type
                    && $last_nonblank_type_sequence
                    && !$self->[_in_format_skipping_]
                    && $rOpts_non_indenting_braces )
                {
                    my $offset = $rtoken_map->[$i_tok];
                    my $text   = substr( $input_line, $offset, 5 );
                    my $len    = length($text);
                    if (   $len == 4 && $text eq '#<<<'
                        || $len > 4 && $text eq '#<<< ' )
                    {
                        push @{ $self->[_rnon_indenting_brace_stack_] },
                          $last_nonblank_type_sequence;
                    }
                }
                last;
            }

            # continue gathering identifier if necessary
            if ($id_scan_state) {

                if ( $is_sub{$id_scan_state} || $is_package{$id_scan_state} ) {
                    $self->scan_id();
                }
                else {
                    $self->scan_identifier();
                }

                if ($id_scan_state) {

                    # Still scanning ...
                    # Check for side comment between sub and prototype (c061)

                    # done if nothing left to scan on this line
                    last if ( $i > $max_token_index );

                    my ( $next_nonblank_token_uu, $i_next ) =
                      find_next_nonblank_token_on_this_line( $i, $rtokens,
                        $max_token_index );

                    # done if it was just some trailing space
                    last if ( $i_next > $max_token_index );

                    # something remains on the line ... must be a side comment
                    next;
                }

                next if ( ( $i > 0 ) || $type );

                # didn't find any token; start over
                $type = $pre_type;
                $tok  = $pre_tok;
            }

            #-----------------------------------------------------------
            # Combine pre-tokens into digraphs and trigraphs if possible
            #-----------------------------------------------------------

            # See if we can make a digraph...
            # The following tokens are excluded and handled specially:
            # '/=' is excluded because the / might start a pattern.
            # 'x=' is excluded since it might be $x=, with $ on previous line
            # '**' and *= might be typeglobs of punctuation variables
            # I have allowed tokens starting with <, such as <=,
            # because I don't think these could be valid angle operators.
            # test file: storrs4.pl
            if (   $can_start_digraph{$tok}
                && $i < $max_token_index
                && $is_digraph{ $tok . $rtokens->[ $i + 1 ] } )
            {

                my $combine_ok = 1;
                my $test_tok   = $tok . $rtokens->[ $i + 1 ];

                # check for special cases which cannot be combined

                # '//' must be defined_or operator if an operator is expected.
                # TODO: Code for other ambiguous digraphs (/=, x=, **, *=)
                # could be migrated here for clarity

                # Patch for RT#102371, misparsing a // in the following snippet:
                #     state $b //= ccc();
                # The solution is to always accept the digraph (or trigraph)
                # after type 'Z' (possible file handle).  The reason is that
                # sub operator_expected gives TERM expected here, which is
                # wrong in this case.
                if ( $test_tok eq '//' && $last_nonblank_type ne 'Z' ) {

                    # note that here $tok = '/' and the next tok and type is '/'
                    my $blank_after_Z;
                    $expecting =
                      $self->operator_expected( $tok, '/', $blank_after_Z );

                    # Patched for RT#101547, was 'unless ($expecting==OPERATOR)'
                    $combine_ok = 0 if ( $expecting == TERM );
                }

                # Patch for RT #114359: mis-parsing of "print $x ** 0.5;
                # Accept the digraphs '**' only after type 'Z'
                # Otherwise postpone the decision.
                if ( $test_tok eq '**' ) {
                    if ( $last_nonblank_type ne 'Z' ) { $combine_ok = 0 }
                }

                if (

                    # still ok to combine?
                    $combine_ok

                    && ( $test_tok ne '/=' )    # might be pattern
                    && ( $test_tok ne 'x=' )    # might be $x
                    && ( $test_tok ne '*=' )    # typeglob?

                    # Moved above as part of fix for
                    # RT #114359: Missparsing of "print $x ** 0.5;
                    # && ( $test_tok ne '**' )    # typeglob?
                  )
                {
                    $tok = $test_tok;
                    $i++;

                    # Now try to assemble trigraphs.  Note that all possible
                    # perl trigraphs can be constructed by appending a character
                    # to a digraph.
                    $test_tok = $tok . $rtokens->[ $i + 1 ];

                    if ( $is_trigraph{$test_tok} ) {
                        $tok = $test_tok;
                        $i++;
                    }

                    # The only current tetragraph is the double diamond operator
                    # and its first three characters are NOT a trigraph, so
                    # we do can do a special test for it
                    else {
                        if ( $test_tok eq '<<>' ) {
                            $test_tok .= $rtokens->[ $i + 2 ];
                            if ( $is_tetragraph{$test_tok} ) {
                                $tok = $test_tok;
                                $i += 2;
                            }
                        }
                    }
                }
            }

            $type      = $tok;
            $next_tok  = $rtokens->[ $i + 1 ];
            $next_type = $rtoken_type->[ $i + 1 ];

            # expecting an operator here? first try table lookup, then function
            $expecting = $op_expected_table{$last_nonblank_type};
            if ( !defined($expecting) ) {
                my $blank_after_Z = $last_nonblank_type eq 'Z'
                  && ( $i == 0 || $rtoken_type->[ $i - 1 ] eq 'b' );
                $expecting =
                  $self->operator_expected( $tok, $next_type, $blank_after_Z );
            }

            DEBUG_TOKENIZE && do {
                local $LIST_SEPARATOR = ')(';
                my @debug_list = (
                    $last_nonblank_token,         $tok,
                    $next_tok,                    $brace_depth,
                    $rbrace_type->[$brace_depth], $paren_depth,
                    $rparen_type->[$paren_depth],
                );
                print {*STDOUT} "TOKENIZE:(@debug_list)\n";
            };

            # The next token is '$tok'.
            # Now we have to define its '$type'

            #------------------------
            # END NODE 3: a bare word
            #------------------------
            if ( $pre_type eq 'w' ) {
                my $is_last = $self->do_BAREWORD();
                last if ($is_last);
                next;
            }

            # Turn off attribute list on first non-blank, non-bareword,
            # and non-comment (added to fix c038)
            $self->[_in_attribute_list_] = 0;

            #-------------------------------
            # END NODE 4: a string of digits
            #-------------------------------
            if ( $pre_type eq 'd' ) {
                $self->do_DIGITS();
                next;
            }

            #------------------------------------------
            # END NODE 5: everything else (punctuation)
            #------------------------------------------
            my $code = $tokenization_code->{$tok};
            if ($code) {
                $code->($self);
                redo if $in_quote;
            }
        }    ## End main tokenizer loop

        # Store the final token
        if ( $i_tok >= 0 ) {
            $routput_token_type->[$i_tok]    = $type;
            $routput_block_type->[$i_tok]    = $block_type;
            $routput_type_sequence->[$i_tok] = $type_sequence;
            $routput_indent_flag->[$i_tok]   = $indent_flag;
        }

        # Remember last nonblank values
        if ( $type ne 'b' && $type ne '#' ) {

            $last_last_nonblank_token = $last_nonblank_token;
            $last_last_nonblank_type  = $last_nonblank_type;

            $last_nonblank_prototype      = $prototype;
            $last_nonblank_block_type     = $block_type;
            $last_nonblank_container_type = $container_type;
            $last_nonblank_type_sequence  = $type_sequence;
            $last_nonblank_token          = $tok;
            $last_nonblank_type           = $type;
        }

        # reset indentation level if necessary at a sub or package
        # in an attempt to recover from a nesting error
        if ( $level_in_tokenizer < 0 ) {
            if ( $input_line =~ /^\s*(sub|package)\s+(\w+)/ ) {
                reset_indentation_level(0);
                $self->brace_warning("resetting level to 0 at $1 $2\n");
            }
        }

        $self->[_in_quote_] = $in_quote;
        $self->[_quote_target_] =
            $in_quote
          ? $matching_end_token{$quote_character}
              ? $matching_end_token{$quote_character}
              : $quote_character
          : EMPTY_STRING;
        $self->[_rhere_target_list_] = $rhere_target_list;

        return;
    } ## end sub tokenizer_main_loop

    sub tokenizer_wrapup_line {
        my ( $self, $line_of_tokens ) = @_;

        #---------------------------------------------------------
        # Package a line of tokens for shipping back to the caller
        #---------------------------------------------------------

        # Arrays to hold token values for this line:
        my (
            @output_levels,     @output_block_type, @output_type_sequence,
            @output_token_type, @output_tokens
        );

        $line_of_tokens->{_nesting_tokens_0} = $nesting_token_string;

        # Remember starting nesting block string
        my $nesting_block_string_0 = $nesting_block_string;

        #-----------------
        # Loop over tokens
        #-----------------
        # $i is the index of the pretoken which starts this full token
        foreach my $ii ( @{$routput_token_list} ) {

            my $type_i = $routput_token_type->[$ii];

            #----------------------------------------
            # Section 1. Handle a non-sequenced token
            #----------------------------------------
            if ( !$routput_type_sequence->[$ii] ) {

                #-------------------------------
                # Section 1.1. types ';' and 't'
                #-------------------------------
                # - output anonymous 'sub' as keyword (type 'k')
                # - output __END__, __DATA__, and format as type 'k' instead
                #   of ';' to make html colors correct, etc.
                if ( $is_semicolon_or_t{$type_i} ) {
                    my $tok_i = $rtokens->[$ii];
                    if ( $is_END_DATA_format_sub{$tok_i} ) {
                        $type_i = 'k';
                    }
                }

                #----------------------------------------------
                # Section 1.2. Check for an invalid token type.
                #----------------------------------------------
                # This can happen by running perltidy on non-scripts although
                # it could also be bug introduced by programming change.  Perl
                # silently accepts a 032 (^Z) and takes it as the end
                elsif ( !$is_valid_token_type{$type_i} ) {
                    my $val = ord($type_i);
                    $self->warning(
"unexpected character decimal $val ($type_i) in script\n"
                    );
                    $self->[_in_error_] = 1;
                }
                else {
                    # valid token type other than ; and t
                }

                #----------------------------------------------------
                # Section 1.3. Store values for a non-sequenced token
                #----------------------------------------------------
                push( @output_levels,        $level_in_tokenizer );
                push( @output_block_type,    EMPTY_STRING );
                push( @output_type_sequence, EMPTY_STRING );
                push( @output_token_type,    $type_i );

            }

            #------------------------------------
            # Section 2. Handle a sequenced token
            #    One of { [ ( ? : ) ] }
            #------------------------------------
            else {

                # $level_i is the level we will store.  Levels of braces are
                # set so that the leading braces have a HIGHER level than their
                # CONTENTS, which is convenient for indentation.
                my $level_i = $level_in_tokenizer;

                # $tok_i is the PRE-token.  It only equals the token for symbols
                my $tok_i = $rtokens->[$ii];

                # $routput_indent_flag->[$ii] indicates that we need a change
                # in level at a nested ternary, as follows
                #     1 => at a nested ternary ?
                #    -1 => at a nested ternary :
                #     0 => otherwise

                #--------------------------------------------
                # Section 2.1 Handle a level-increasing token
                #--------------------------------------------
                if ( $is_opening_or_ternary_type{$type_i} ) {

                    if ( $type_i eq '?' ) {

                        if ( $routput_indent_flag->[$ii] > 0 ) {
                            $level_in_tokenizer++;

                            # break BEFORE '?' in a nested ternary
                            $level_i = $level_in_tokenizer;
                            $nesting_block_string .= "$nesting_block_flag";

                        }
                    }
                    else {

                        $nesting_token_string .= $tok_i;

                        if ( $type_i eq '{' || $type_i eq 'L' ) {

                            $level_in_tokenizer++;

                            if ( $routput_block_type->[$ii] ) {
                                $nesting_block_flag = 1;
                                $nesting_block_string .= '1';
                            }
                            else {
                                $nesting_block_flag = 0;
                                $nesting_block_string .= '0';
                            }
                        }
                    }
                }

                #---------------------------------------------
                # Section 2.2. Handle a level-decreasing token
                #---------------------------------------------
                elsif ( $is_closing_or_ternary_type{$type_i} ) {

                    if ( $type_i ne ':' ) {
                        my $char = chop $nesting_token_string;
                        if ( $char ne $matching_start_token{$tok_i} ) {
                            $nesting_token_string .= $char . $tok_i;
                        }
                    }

                    if (
                           $type_i eq '}'
                        || $type_i eq 'R'

                        # only the second and higher ? : have levels
                        || $type_i eq ':' && $routput_indent_flag->[$ii] < 0
                      )
                    {

                        $level_i = --$level_in_tokenizer;

                        if ( $level_in_tokenizer < 0 ) {
                            if ( !$self->[_saw_negative_indentation_] ) {
                                $self->[_saw_negative_indentation_] = 1;
                                $self->warning(
                                    "Starting negative indentation\n");
                            }
                        }

                        # restore previous level values
                        if ( length($nesting_block_string) > 1 )
                        {    # true for valid script
                            chop $nesting_block_string;
                            $nesting_block_flag =
                              substr( $nesting_block_string, -1 ) eq '1';
                        }

                    }
                }

                #-----------------------------------------------------
                # Section 2.3. Unexpected sequenced token type - error
                #-----------------------------------------------------
                else {

                    # The tokenizer should only be assigning sequence numbers
                    # to types { [ ( ? ) ] } :
                    DEVEL_MODE && $self->Fault(<<EOM);
unexpected sequence number on token type $type_i with pre-tok=$tok_i
EOM
                }

                #------------------------------------------------
                # Section 2.4. Store values for a sequenced token
                #------------------------------------------------

                # The starting nesting block string, which is used in any .LOG
                # output, should include the first token of the line
                if ( !@output_levels ) {
                    $nesting_block_string_0 = $nesting_block_string;
                }

                # Store values for a sequenced token
                push( @output_levels,        $level_i );
                push( @output_block_type,    $routput_block_type->[$ii] );
                push( @output_type_sequence, $routput_type_sequence->[$ii] );
                push( @output_token_type,    $type_i );

            }
        }    ## End loop to over tokens

        #---------------------
        # Post-loop operations
        #---------------------

        $line_of_tokens->{_nesting_blocks_0} = $nesting_block_string_0;

        # Form and store the tokens
        if (@output_levels) {

            my $im     = shift @{$routput_token_list};
            my $offset = $rtoken_map->[$im];
            foreach my $ii ( @{$routput_token_list} ) {
                my $numc = $rtoken_map->[$ii] - $offset;
                push( @output_tokens, substr( $input_line, $offset, $numc ) );
                $offset += $numc;

                # programming note: it seems most efficient to 'next' out of
                # a critical loop like this as early as possible. So instead
                # of 'if ( DEVEL_MODE && $numc < 0 )' we write:
                next unless DEVEL_MODE;
                next if ( $numc > 0 );

                # Should not happen unless @{$rtoken_map} is corrupted
                $self->Fault(
                    "number of characters is '$numc' but should be >0\n");
            }

            # Form and store the final token of this line
            my $numc = length($input_line) - $offset;
            push( @output_tokens, substr( $input_line, $offset, $numc ) );

            if (DEVEL_MODE) {
                if ( $numc <= 0 ) {

                    # check '$rtoken_map' and '$routput_token_list'
                    $self->Fault(
                        "Number of Characters is '$numc' but should be >0\n");
                }

                # Make sure we didn't gain or lose any characters
                my $test_line = join EMPTY_STRING, @output_tokens;
                if ( $test_line ne $input_line ) {
                    my $len_input = length($input_line);
                    my $len_test  = length($test_line);

                    # check '$rtoken_map' and '$routput_token_list'
                    $self->Fault(<<EOM);
Reconstruted line difers from input; input_length=$len_input test_length=$len_test
input:'$input_line'
test :'$test_line'
EOM
                }
            }
        }

        # Wrap up this line of tokens for shipping to the Formatter
        $line_of_tokens->{_rtoken_type}    = \@output_token_type;
        $line_of_tokens->{_rtokens}        = \@output_tokens;
        $line_of_tokens->{_rblock_type}    = \@output_block_type;
        $line_of_tokens->{_rtype_sequence} = \@output_type_sequence;
        $line_of_tokens->{_rlevels}        = \@output_levels;

        #-----------------------------------------------------------------
        # Compare input indentation with computed levels at closing braces
        #-----------------------------------------------------------------
        # This may provide a useful hint for error location if the file
        # is not balanced in braces.  Closing braces are used because they
        # have a well-defined indentation and can be processed efficiently.
        if ( $output_tokens[0] eq '}' ) {

            my $blk = $output_block_type[0];
            if (
                (
                    # builtin block types without continuation indentation
                    $is_zero_continuation_block_type{$blk}

                    # or a named sub, but skip sub aliases for efficiency,
                    # since this is just for diagnostic info
                    || substr( $blk, 0, 4 ) eq 'sub '
                )

                # and we are not in format skipping
                && !$self->[_in_format_skipping_]
              )
            {

                # subtract 1 space for newline in untrimmed line
                my $untrimmed_input_line = $line_of_tokens->{_line_text};
                my $space_count =
                  length($untrimmed_input_line) - length($input_line) - 1;

                # check for tabs
                if ( $space_count
                    && ord( substr( $untrimmed_input_line, 0, 1 ) ) == ORD_TAB )
                {
                    if ( $untrimmed_input_line =~ /^(\t+)?(\s+)?/ ) {
                        if ($1) { $space_count += length($1) * $tabsize }
                        if ($2) { $space_count += length($2) }
                    }
                }

                # '$guess' = the level according to indentation
                my $guess = int( $space_count / $rOpts_indent_columns );

                # subtract 1 level from guess for --indent-closing-brace
                $guess -= 1 if ($rOpts_indent_closing_brace);

                # subtract 1 from $level for each non-indenting brace level
                my $adjust = @{ $self->[_rnon_indenting_brace_stack_] };

                my $level = $output_levels[0];

                # find the difference between expected and indentation guess
                my $level_diff = $level - $adjust - $guess;

                my $rhash = $self->[_rclosing_brace_indentation_hash_];

                # results are only valid if we guess correctly at the
                # first spaced brace
                if ( $space_count && !defined( $rhash->{valid} ) ) {
                    $rhash->{valid} = !$level_diff;
                }

                # save the result
                my $rhistory_line_number  = $rhash->{rhistory_line_number};
                my $rhistory_level_diff   = $rhash->{rhistory_level_diff};
                my $rhistory_anchor_point = $rhash->{rhistory_anchor_point};

                if ( $rhistory_level_diff->[-1] != $level_diff ) {

                    # Patch for non-indenting-braces: if we guess zero and
                    # match before all non-indenting braces have been found,
                    # it means that we would need negative indentation to
                    # match if/when the brace is found. So we have a problem
                    # from here on. We indicate this with a value 2 instead
                    # of 1 as a signal to stop outputting the table here.
                    my $anchor = 1;
                    if ( $guess == 0 && $adjust > 0 ) { $anchor = 2 }

                    # add an anchor point
                    push @{$rhistory_level_diff},   $level_diff;
                    push @{$rhistory_line_number},  $input_line_number;
                    push @{$rhistory_anchor_point}, $anchor;
                }
                else {

                    # add a movable point following an anchor point
                    if ( $rhistory_anchor_point->[-1] ) {
                        push @{$rhistory_level_diff},   $level_diff;
                        push @{$rhistory_line_number},  $input_line_number;
                        push @{$rhistory_anchor_point}, 0;
                    }

                    # extend a movable point
                    else {
                        $rhistory_line_number->[-1] = $input_line_number;
                    }
                }
            }
        }

        return;
    } ## end sub tokenizer_wrapup_line

} ## end tokenize_this_line

#######################################################################
# Tokenizer routines which assist in identifying token types
#######################################################################

# Define Global '%op_expected_table'
#  = hash table of operator expected values based on last nonblank token

# exceptions to perl's weird parsing rules after type 'Z'
my %is_weird_parsing_rule_exception;

my %is_paren_dollar;

my %is_n_v;

BEGIN {

    # Always expecting TERM following these types:
    # note: this is identical to '@value_requestor_type' defined later.
    # Fix for c250: add new type 'P' for package (expecting VERSION or {}
    # after package NAMESPACE, so expecting TERM)
    # Fix for c250: add new type 'S' for sub (not expecting operator)
    my @q = qw#
      ; ! + x & ?  F J - p / Y : % f U ~ A G j L P S * . | ^ < = [ m { \ > t
      || >= != mm *= => .. !~ == && |= .= pp -= =~ += <= %= ^= x= ~~ ** << /=
      &= // >> ~. &. |. ^.
      ... **= <<= >>= &&= ||= //= <=> !~~ &.= |.= ^.= <<~
      #;
    push @q, ',';
    push @q, '(';     # for completeness, not currently a token type
    push @q, '->';    # was previously in UNKNOWN
    @op_expected_table{@q} = (TERM) x scalar(@q);

    # No UNKNOWN table types:
    #  removed '->' for c030, now always TERM
    #  removed 'w' for c392 to allow use of 'function_count' info in the sub

    # Always expecting OPERATOR ...
    # 'n' and 'v' are currently excluded because they might be VERSION numbers
    # 'i' is currently excluded because it might be a package
    # 'q' is currently excluded because it might be a prototype
    # Fix for c030: removed '->' from this list:
    # Fix for c250: added 'i' because new type 'P' was added
    @q = qw( -- C h R ++ ] Q <> i );
    push @q, ')';
    @op_expected_table{@q} = (OPERATOR) x scalar(@q);

    # Fix for git #62: added '*' and '%'
    @q = qw( < ? * % );
    @is_weird_parsing_rule_exception{@q} = (1) x scalar(@q);

    @q = qw<) $>;
    @is_paren_dollar{@q} = (1) x scalar(@q);

    @q = qw( n v );
    @is_n_v{@q} = (1) x scalar(@q);

} ## end BEGIN

use constant DEBUG_OPERATOR_EXPECTED => 0;

sub operator_expected {

    my ( $self, $tok, $next_type, $blank_after_Z ) = @_;

    # Returns a parameter indicating what types of tokens can occur next

    # Call format:
    #    $op_expected =
    #      $self->operator_expected( $tok, $next_type, $blank_after_Z );
    # where
    #    $tok is the current token
    #    $next_type is the type of the next token (blank or not)
    #    $blank_after_Z = flag for guessing after a type 'Z':
    #       true  if $tok follows type 'Z' with intermediate blank
    #       false if $tok follows type 'Z' with no intermediate blank
    #       ignored if $tok does not follow type 'Z'

    # Many perl symbols have two or more meanings.  For example, '<<'
    # can be a shift operator or a here-doc operator.  The
    # interpretation of these symbols depends on the current state of
    # the tokenizer, which may either be expecting a term or an
    # operator.  For this example, a << would be a shift if an OPERATOR
    # is expected, and a here-doc if a TERM is expected.  This routine
    # is called to make this decision for any current token.  It returns
    # one of three possible values:
    #
    #     OPERATOR - operator expected (or at least, not a term)
    #     UNKNOWN  - can't tell
    #     TERM     - a term is expected (or at least, not an operator)
    #
    # The decision is based on what has been seen so far.  This
    # information is stored in the "$last_nonblank_type" and
    # "$last_nonblank_token" variables.  For example, if the
    # $last_nonblank_type is '=~', then we are expecting a TERM, whereas
    # if $last_nonblank_type is 'n' (numeric), we are expecting an
    # OPERATOR.
    #
    # If a UNKNOWN is returned, the calling routine must guess. A major
    # goal of this tokenizer is to minimize the possibility of returning
    # UNKNOWN, because a wrong guess can spoil the formatting of a
    # script.
    #
    # Adding NEW_TOKENS: it is critically important that this routine be
    # updated to allow it to determine if an operator or term is to be
    # expected after the new token.  Doing this simply involves adding
    # the new token character to one of the regexes in this routine or
    # to one of the hash lists
    # that it uses, which are initialized in the BEGIN section.
    # USES GLOBAL VARIABLES: $last_nonblank_type, $last_nonblank_token,
    # $statement_type

    # When possible, token types should be selected such that we can determine
    # the 'operator_expected' value by a simple hash lookup.  If there are
    # exceptions, that is an indication that a new type is needed.

    #--------------------------------------------
    # Section 1: Table lookup will get most cases
    #--------------------------------------------

    # Many types are can be obtained by a table lookup.  This typically handles
    # more than half of the calls.  For speed, the caller may try table lookup
    # first before calling this sub.
    my $op_expected = $op_expected_table{$last_nonblank_type};
    if ( defined($op_expected) ) {
        DEBUG_OPERATOR_EXPECTED
          && print {*STDOUT}
"OPERATOR_EXPECTED: Table Lookup; returns $op_expected for last type $last_nonblank_type token $last_nonblank_token\n";
        return $op_expected;
    }

    DEBUG_OPERATOR_EXPECTED
      && print {*STDOUT}
"OPERATOR_EXPECTED: in hardwired table for last type $last_nonblank_type token $last_nonblank_token\n";

    #---------------------------------------------
    # Section 2: Handle special cases if necessary
    #---------------------------------------------

    # Types 'k', '}' and 'Z' depend on context
    # Types 'n', 'v', 'q' also depend on context.

    # identifier...
    # Fix for c250: removed coding for type 'i' because 'i' and new type 'P'
    # are now done by hash table lookup

    #--------------------
    # Section 2A: keyword
    #--------------------
    if ( $last_nonblank_type eq 'k' ) {

        # keywords expecting TERM:
        if ( $expecting_term_token{$last_nonblank_token} ) {

            # Exceptions from TERM:

            # // may follow perl functions which may be unary operators
            # see test file dor.t (defined or);
            if (
                   $tok eq '/'
                && $next_type eq '/'
                && $is_keyword_rejecting_slash_as_pattern_delimiter{
                    $last_nonblank_token}
              )
            {
                return OPERATOR;
            }

            # Patch to allow a ? following 'split' to be a deprecated pattern
            # delimiter.  This patch is coordinated with the omission of split
            # from the list
            # %is_keyword_rejecting_question_as_pattern_delimiter. This patch
            # will force perltidy to guess.
            if (   $tok eq '?'
                && $last_nonblank_token eq 'split' )
            {
                return UNKNOWN;
            }

            return TERM;
        }

        # keywords expecting OPERATOR:
        if ( $expecting_operator_token{$last_nonblank_token} ) {
            return OPERATOR;
        }

        return TERM;

    } ## end type 'k'

    #------------------------------------
    # Section 2B: Closing container token
    #------------------------------------

    # Note that the actual token for type '}' may also be a ')'.

    # Also note that $last_nonblank_token is not the token corresponding to
    # $last_nonblank_type when the type is a closing container.  In that
    # case it is the token before the corresponding opening container token.
    # So for example, for this snippet
    #       $a = do { BLOCK } / 2;
    # the $last_nonblank_token is 'do' when $last_nonblank_type eq '}'.

    if ( $last_nonblank_type eq '}' ) {

        # handle something after 'do' and 'eval'
        if ( $is_block_operator{$last_nonblank_token} ) {

            # something like $a = do { BLOCK } / 2;
            return OPERATOR;    # block mode following }
        }

        #       $last_nonblank_token =~ /^(\)|\$|\-\>)/
        if ( $is_paren_dollar{ substr( $last_nonblank_token, 0, 1 ) }
            || substr( $last_nonblank_token, 0, 2 ) eq '->' )
        {
            if ( $last_nonblank_token eq '$' ) { return UNKNOWN }
            return OPERATOR;
        }

        # Check for smartmatch operator before preceding brace or square
        # bracket.  For example, at the ? after the ] in the following
        # expressions we are expecting an operator:
        #
        # qr/3/ ~~ ['1234'] ? 1 : 0;
        # map { $_ ~~ [ '0', '1' ] ? 'x' : 'o' } @a;
        if ( $last_nonblank_token eq '~~' ) {
            return OPERATOR;
        }

        # A right brace here indicates the end of a simple block.  All
        # non-structural right braces have type 'R' all braces associated with
        # block operator keywords have been given those keywords as
        # "last_nonblank_token" and caught above.  (This statement is order
        # dependent, and must come after checking $last_nonblank_token).

        # patch for dor.t (defined or).
        if (   $tok eq '/'
            && $next_type eq '/'
            && $last_nonblank_token eq ']' )
        {
            return OPERATOR;
        }

        # Patch for RT #116344: misparse a ternary operator after an
        # anonymous hash, like this:
        #   return ref {} ? 1 : 0;
        # The right brace should really be marked type 'R' in this case,
        # and it is safest to return an UNKNOWN here. Expecting a TERM will
        # cause the '?' to always be interpreted as a pattern delimiter
        # rather than introducing a ternary operator.
        if ( $tok eq '?' ) {
            return UNKNOWN;
        }
        return TERM;

    } ## end type '}'

    #-------------------------------
    # Section 2C: number or v-string
    #-------------------------------
    # An exception is for VERSION numbers a 'use' statement. It has the format
    #     use Module VERSION LIST
    # We could avoid this exception by writing a special sub to parse 'use'
    # statements and perhaps mark these numbers with a new type V (for VERSION)
    if ( $is_n_v{$last_nonblank_type} ) {
        if ( $statement_type eq 'use' ) {
            return UNKNOWN;
        }
        return OPERATOR;
    }

    #---------------------
    # Section 2D: qw quote
    #---------------------
    # TODO: labeled prototype words would better be given type 'A' or maybe
    # 'J'; not 'q'; or maybe mark as type 'Y'?
    if ( $last_nonblank_type eq 'q' ) {
        if ( $last_nonblank_token eq 'prototype' ) {
            return TERM;
        }

        # update for --use-feature=class (rt145706):
        # Look for class VERSION after possible attribute, as in
        #    class Example::Subclass : isa(Example::Base) 1.345 { ... }
        if ( $statement_type =~ /^package\b/ ) {
            return TERM;
        }

        # everything else
        return OPERATOR;
    }

    # Section 2E: bareword
    if ( $last_nonblank_type eq 'w' ) {

        # see if this has been seen in the role of a function taking args
        my $rinfo = $self->[_rbareword_info_]->{$current_package};
        if ($rinfo) {
            $rinfo = $rinfo->{$last_nonblank_token};
            if ($rinfo) {
                my $function_count = $rinfo->{function_count};
                if ( $function_count && $function_count > 0 ) { return TERM }
            }
        }
        return UNKNOWN;
    }

    #-----------------------------------
    # Section 2F: file handle or similar
    #-----------------------------------
    if ( $last_nonblank_type eq 'Z' ) {

        # angle.t
        if ( $last_nonblank_token =~ /^\w/ ) {
            return UNKNOWN;
        }

        # Exception to weird parsing rules for 'x(' ... see case b1205:
        # In something like 'print $vv x(...' the x is an operator;
        # Likewise in 'print $vv x$ww' the x is an operator (case b1207)
        # otherwise x follows the weird parsing rules.
        if ( $tok eq 'x' && $next_type =~ /^[\(\$\@\%]$/ ) {
            return OPERATOR;
        }

        # The 'weird parsing rules' of next section do not work for '<' and '?'
        # It is best to mark them as unknown.  Test case:
        #  print $fh <DATA>;
        if ( $is_weird_parsing_rule_exception{$tok} ) {
            return UNKNOWN;
        }

        # For possible file handle like "$a", Perl uses weird parsing rules.
        # For example:
        # print $a/2,"/hi";   - division
        # print $a / 2,"/hi"; - division
        # print $a/ 2,"/hi";  - division
        # print $a /2,"/hi";  - pattern (and error)!
        # Some examples where this logic works okay, for '&','*','+':
        #    print $fh &xsi_protos(@mods);
        #    my $x = new $CompressClass *FH;
        #    print $OUT +( $count % 15 ? ", " : "\n\t" );
        if (   $blank_after_Z
            && $next_type ne 'b' )
        {
            return TERM;
        }

        # Note that '?' and '<' have been moved above
        # ( $tok =~ /^([x\/\+\-\*\%\&\.\?\<]|\>\>)$/ ) {
        if ( $tok =~ /^([x\/\+\-\*\%\&\.]|\>\>)$/ ) {

            # Do not complain in 'use' statements, which have special syntax.
            # For example, from RT#130344:
            #   use lib $FindBin::Bin . '/lib';
            if ( $statement_type ne 'use' ) {
                $self->complain(
"operator in possible indirect object location not recommended\n"
                );
            }
            return OPERATOR;
        }

        # all other cases

        return UNKNOWN;
    }

    #--------------------------
    # Section 2F: anything else
    #--------------------------
    return UNKNOWN;

} ## end sub operator_expected

sub new_statement_ok {

    # Returns:
    #   true if a new statement can begin here
    #   false otherwise

    # USES GLOBAL VARIABLES: $last_nonblank_token, $last_nonblank_type,
    # $brace_depth, $rbrace_type

    # Uses:
    # - See if a 'class' statement can occur here
    # - See if a keyword begins at a new statement; i.e. is an 'if' a
    #   block if or a trailing if?  Also see if 'format' starts a statement.
    # - Decide if a ':' is part of a statement label (not a ternary)

    # Curly braces are tricky because some small blocks do not get marked as
    # blocks..

    # if it follows an opening curly brace..
    if ( $last_nonblank_token eq '{' ) {

        # The safe thing is to return true in all cases because:
        # - a ternary ':' cannot occur here
        # - an 'if' here, for example, cannot be a trailing if
        # See test case c231 for an example.
        # This works but could be improved, if necessary, by returning
        #   'false' at obvious non-blocks.
        return 1;
    }

    # if it follows a closing code block curly brace..
    elsif ($last_nonblank_token eq '}'
        && $last_nonblank_type eq $last_nonblank_token )
    {

        # a new statement can follow certain closing block braces ...
        # FIXME: The following has worked well but returns true in some cases
        # where it really should not.  We could fix this by either excluding
        # certain blocks, like sort/map/grep/eval/asub or by just including
        # certain blocks.
        return $rbrace_type->[$brace_depth];
    }

    # otherwise, it is a label if and only if it follows a ';' (real or fake)
    # or another label
    else {
        return ( $last_nonblank_type eq ';' || $last_nonblank_type eq 'J' );
    }
} ## end sub new_statement_ok

sub code_block_type {

    my ( $self, $i, $rtokens, $rtoken_type, $max_token_index ) = @_;

    # Decide if this is a block of code, and its type.
    # Must be called only when $type = $token = '{'
    # The problem is to distinguish between the start of a block of code
    # and the start of an anonymous hash reference
    # Returns "" if not code block, otherwise returns 'last_nonblank_token'
    # to indicate the type of code block.  (For example, 'last_nonblank_token'
    # might be 'if' for an if block, 'else' for an else block, etc).
    # USES GLOBAL VARIABLES: $last_nonblank_token, $last_nonblank_type,
    # $last_nonblank_block_type, $brace_depth, $rbrace_type

    # handle case of multiple '{'s

# print "BLOCK_TYPE EXAMINING: type=$last_nonblank_type tok=$last_nonblank_token\n";

    if (   $last_nonblank_token eq '{'
        && $last_nonblank_type eq $last_nonblank_token )
    {

        # opening brace where a statement may appear is probably
        # a code block but might be and anonymous hash reference
        if ( $rbrace_type->[$brace_depth] ) {
            return $self->decide_if_code_block( $i, $rtokens, $rtoken_type,
                $max_token_index );
        }

        # cannot start a code block within an anonymous hash
        else {
            return EMPTY_STRING;
        }
    }

    elsif ( $last_nonblank_token eq ';' ) {

        # an opening brace where a statement may appear is probably
        # a code block but might be and anonymous hash reference
        return $self->decide_if_code_block( $i, $rtokens, $rtoken_type,
            $max_token_index );
    }

    # handle case of '}{'
    elsif ($last_nonblank_token eq '}'
        && $last_nonblank_type eq $last_nonblank_token )
    {

        # a } { situation ...
        # could be hash reference after code block..(blktype1.t)
        if ($last_nonblank_block_type) {
            return $self->decide_if_code_block( $i, $rtokens, $rtoken_type,
                $max_token_index );
        }

        # must be a block if it follows a closing hash reference
        else {
            return $last_nonblank_token;
        }
    }

    #--------------------------------------------------------------
    # NOTE: braces after type characters start code blocks, but for
    # simplicity these are not identified as such.  See also
    # sub is_non_structural_brace.
    #--------------------------------------------------------------

##    elsif ( $last_nonblank_type eq 't' ) {
##       return $last_nonblank_token;
##    }

    # brace after label:
    elsif ( $last_nonblank_type eq 'J' ) {
        return $last_nonblank_token;
    }

    # otherwise, see if a block must follow the previous token (such as 'if'):
    elsif ($is_code_block_token{$last_nonblank_token}
        || $is_grep_alias{$last_nonblank_token} )
    {

        # Bug Patch: Note that the opening brace after the 'if' in the following
        # snippet is an anonymous hash ref and not a code block!
        #   print 'hi' if { x => 1, }->{x};
        # We can identify this situation because the last nonblank type
        # will be a keyword (instead of a closing paren)
        if (
            $last_nonblank_type eq 'k'
            && (   $last_nonblank_token eq 'if'
                || $last_nonblank_token eq 'unless' )
          )
        {
            return EMPTY_STRING;
        }
        else {
            return $last_nonblank_token;
        }
    }

    # or a sub or package BLOCK
    # Fixed for c250 to include new package type 'P', and change 'i' to 'S'
    elsif (
           $last_nonblank_type eq 'P'
        || $last_nonblank_type eq 'S'
        || ( $last_nonblank_type eq 't'
            && substr( $last_nonblank_token, 0, 3 ) eq 'sub' )
      )
    {
        return $last_nonblank_token;
    }

    elsif ( $statement_type =~ /^(sub|package)\b/ ) {
        return $statement_type;
    }

    # user-defined subs with block parameters (like grep/map/eval)
    elsif ( $last_nonblank_type eq 'G' ) {
        return $last_nonblank_token;
    }

    # check bareword
    elsif ( $last_nonblank_type eq 'w' ) {

        # check for syntax 'use MODULE LIST'
        # This fixes b1022 b1025 b1027 b1028 b1029 b1030 b1031
        return EMPTY_STRING if ( $statement_type eq 'use' );

        return $self->decide_if_code_block( $i, $rtokens, $rtoken_type,
            $max_token_index );
    }

    # Patch for bug # RT #94338 reported by Daniel Trizen
    # for-loop in a parenthesized block-map triggering an error message:
    #    map( { foreach my $item ( '0', '1' ) { print $item} } qw(a b c) );
    # Check for a code block within a parenthesized function call
    elsif ( $last_nonblank_token eq '(' ) {
        my $paren_type = $rparen_type->[$paren_depth];

        #                   /^(map|grep|sort)$/
        if ( $paren_type && $is_sort_map_grep{$paren_type} ) {

            # We will mark this as a code block but use type 't' instead
            # of the name of the containing function.  This will allow for
            # correct parsing but will usually produce better formatting.
            # Braces with block type 't' are not broken open automatically
            # in the formatter as are other code block types, and this usually
            # works best.
            return 't';    # (Not $paren_type)
        }
        else {
            return EMPTY_STRING;
        }
    }

    # handle unknown syntax ') {'
    # we previously appended a '()' to mark this case
    elsif ( $last_nonblank_token =~ /\(\)$/ ) {
        return $last_nonblank_token;
    }

    # anything else must be anonymous hash reference
    else {
        return EMPTY_STRING;
    }
} ## end sub code_block_type

sub decide_if_code_block {

    # USES GLOBAL VARIABLES: $last_nonblank_token
    my ( $self, $i, $rtokens, $rtoken_type, $max_token_index ) = @_;

    my ( $next_nonblank_token, $i_next_uu ) =
      $self->find_next_nonblank_token( $i, $rtokens, $max_token_index );

    # we are at a '{' where a statement may appear.
    # We must decide if this brace starts an anonymous hash or a code
    # block.
    # return "" if anonymous hash, and $last_nonblank_token otherwise

    # initialize to be code BLOCK
    my $code_block_type = $last_nonblank_token;

    # Check for the common case of an empty anonymous hash reference:
    # Maybe something like sub { { } }
    if ( $next_nonblank_token eq '}' ) {
        $code_block_type = EMPTY_STRING;
    }

    else {

        # To guess if this '{' is an anonymous hash reference, look ahead
        # and test as follows:
        #
        # it is a hash reference if next come:
        #   - a string or digit followed by a comma or =>
        #   - bareword followed by =>
        # otherwise it is a code block
        #
        # Examples of anonymous hash ref:
        # {'aa',};
        # {1,2}
        #
        # Examples of code blocks:
        # {1; print "hello\n", 1;}
        # {$a,1};

        # We are only going to look ahead one more (nonblank/comment) line.
        # Strange formatting could cause a bad guess, but that's unlikely.
        my @pre_types;
        my @pre_tokens;

        # Ignore the rest of this line if it is a side comment
        if ( $next_nonblank_token ne '#' ) {
            @pre_types  = @{$rtoken_type}[ $i + 1 .. $max_token_index ];
            @pre_tokens = @{$rtokens}[ $i + 1 .. $max_token_index ];
        }

        # Here 20 is arbitrary but generous, and prevents wasting lots of time
        # in mangled files
        my ( $rpre_tokens, $rpre_types ) =
          $self->peek_ahead_for_n_nonblank_pre_tokens(20);
        if ( defined($rpre_types) && @{$rpre_types} ) {
            push @pre_types,  @{$rpre_types};
            push @pre_tokens, @{$rpre_tokens};
        }

        # put a sentinel token to simplify stopping the search
        push @pre_types, '}';
        push @pre_types, '}';

        my $jbeg = 0;
        $jbeg = 1 if $pre_types[0] eq 'b';

        # first look for one of these
        #  - bareword
        #  - bareword with leading -
        #  - digit
        #  - quoted string
        my $j = $jbeg;
        if ( $pre_types[$j] =~ /^[\'\"]/ ) {

            # find the closing quote; don't worry about escapes
            my $quote_mark = $pre_types[$j];
            foreach my $k ( $j + 1 .. @pre_types - 2 ) {
                if ( $pre_types[$k] eq $quote_mark ) {
                    $j = $k + 1;
                    last;
                }
            }
        }
        elsif ( $pre_types[$j] eq 'd' ) {
            $j++;
        }
        elsif ( $pre_types[$j] eq 'w' ) {
            $j++;
        }
        elsif ( $pre_types[$j] eq '-' && $pre_types[ ++$j ] eq 'w' ) {
            $j++;
        }
        else {
            # none of the above
        }
        if ( $j > $jbeg ) {

            $j++ if $pre_types[$j] eq 'b';

            # Patched for RT #95708
            if (

                # it is a comma which is not a pattern delimiter except for qw
                (
                    $pre_types[$j] eq ','
                    && !$is_q_qq_qx_qr_s_y_tr_m{ $pre_tokens[$jbeg] }
                )

                # or a =>
                || ( $pre_types[$j] eq '=' && $pre_types[ ++$j ] eq '>' )
              )
            {
                $code_block_type = EMPTY_STRING;
            }
        }

        if ($code_block_type) {

            # Patch for cases b1085 b1128: It is uncertain if this is a block.
            # If this brace follows a bareword, then append a space as a signal
            # to the formatter that this may not be a block brace.  To find the
            # corresponding code in Formatter.pm search for 'b1085'.
            $code_block_type .= SPACE if ( $code_block_type =~ /^\w/ );
        }
    }

    return $code_block_type;
} ## end sub decide_if_code_block

sub report_unexpected {

    # report unexpected token type and show where it is
    # USES GLOBAL VARIABLES: (none)
    my ( $self, $rcall_hash ) = @_;

    my $found           = $rcall_hash->{found};
    my $expecting       = $rcall_hash->{expecting};
    my $i_tok           = $rcall_hash->{i_tok};
    my $last_nonblank_i = $rcall_hash->{last_nonblank_i};
    my $rpretoken_map   = $rcall_hash->{rpretoken_map};
    my $rpretoken_type  = $rcall_hash->{rpretoken_type};
    my $input_line      = $rcall_hash->{input_line};

    if ( ++$self->[_unexpected_error_count_] <= MAX_NAG_MESSAGES ) {
        my $msg = "found $found where $expecting expected";
        my $pos = $rpretoken_map->[$i_tok];
        $self->interrupt_logfile();
        my $input_line_number = $self->[_last_line_number_];
        my ( $offset, $numbered_line, $underline ) =
          make_numbered_line( $input_line_number, $input_line, $pos );
        $underline = write_on_underline( $underline, $pos - $offset, '^' );

        my $trailer = EMPTY_STRING;
        if ( ( $i_tok > 0 ) && ( $last_nonblank_i >= 0 ) ) {
            my $pos_prev = $rpretoken_map->[$last_nonblank_i];
            my $num;
            if ( $rpretoken_type->[ $i_tok - 1 ] eq 'b' ) {
                $num = $rpretoken_map->[ $i_tok - 1 ] - $pos_prev;
            }
            else {
                $num = $pos - $pos_prev;
            }
            if ( $num > 40 ) { $num = 40; $pos_prev = $pos - 40; }

            $underline =
              write_on_underline( $underline, $pos_prev - $offset, '-' x $num );
            $trailer = " (previous token underlined)";
        }
        $underline =~ s/\s+$//;
        $self->warning( $numbered_line . "\n" );
        $self->warning( $underline . "\n" );
        $self->warning( $msg . $trailer . "\n" );
        $self->resume_logfile();
    }
    return;
} ## end sub report_unexpected

my %is_sigil_or_paren;
my %is_R_closing_sb;

BEGIN {

    my @q = qw< $ & % * @ ) >;
    @is_sigil_or_paren{@q} = (1) x scalar(@q);

    @q = qw( R ] );
    @is_R_closing_sb{@q} = (1) x scalar(@q);
} ## end BEGIN

sub is_non_structural_brace {

    # Decide if a brace or bracket is structural or non-structural
    # by looking at the previous token and type
    # USES GLOBAL VARIABLES: $last_nonblank_type, $last_nonblank_token

    # EXPERIMENTAL: Mark slices as structural; idea was to improve formatting.
    # Tentatively deactivated because it caused the wrong operator expectation
    # for this code:
    #      $user = @vars[1] / 100;
    # Must update sub operator_expected before re-implementing.
    # if ( $last_nonblank_type eq 'i' && $last_nonblank_token =~ /^@/ ) {
    #    return 0;
    # }

    #--------------------------------------------------------------
    # NOTE: braces after type characters start code blocks, but for
    # simplicity these are not identified as such.  See also
    # sub code_block_type
    #--------------------------------------------------------------

    ##if ($last_nonblank_type eq 't') {return 0}

    # otherwise, it is non-structural if it is decorated
    # by type information.
    # For example, the '{' here is non-structural:   ${xxx}
    # Removed '::' to fix c074
    ## $last_nonblank_token =~ /^([\$\@\*\&\%\)]|->|::)/
    return (
        ## $last_nonblank_token =~ /^([\$\@\*\&\%\)]|->)/
        $is_sigil_or_paren{ substr( $last_nonblank_token, 0, 1 ) }
          || substr( $last_nonblank_token, 0, 2 ) eq '->'

          # or if we follow a hash or array closing curly brace or bracket
          # For example, the second '{' in this is non-structural: $a{'x'}{'y'}
          # because the first '}' would have been given type 'R'
          ##|| $last_nonblank_type =~ /^([R\]])$/
          || $is_R_closing_sb{$last_nonblank_type}
    );
} ## end sub is_non_structural_brace

#######################################################################
# Tokenizer routines for tracking container nesting depths
#######################################################################

# The following routines keep track of nesting depths of the nesting
# types, ( [ { and ?.  This is necessary for determining the indentation
# level, and also for debugging programs.  Not only do they keep track of
# nesting depths of the individual brace types, but they check that each
# of the other brace types is balanced within matching pairs.  For
# example, if the program sees this sequence:
#
#         {  ( ( ) }
#
# then it can determine that there is an extra left paren somewhere
# between the { and the }.  And so on with every other possible
# combination of outer and inner brace types.  For another
# example:
#
#         ( [ ..... ]  ] )
#
# which has an extra ] within the parens.
#
# The brace types have indexes 0 .. 3 which are indexes into
# the matrices.
#
# The pair ? : are treated as just another nesting type, with ? acting
# as the opening brace and : acting as the closing brace.
#
# The matrix
#
#  $rdepth_array->[$a][$b][ $rcurrent_depth->[$a] ] = $rcurrent_depth->[$b];
#
# saves the nesting depth of brace type $b (where $b is either of the other
# nesting types) when brace type $a enters a new depth.  When this depth
# decreases, a check is made that the current depth of brace types $b is
# unchanged, or otherwise there must have been an error.  This can
# be very useful for localizing errors, particularly when perl runs to
# the end of a large file (such as this one) and announces that there
# is a problem somewhere.
#
# A numerical sequence number is maintained for every nesting type,
# so that each matching pair can be uniquely identified in a simple
# way.

sub increase_nesting_depth {
    my ( $self, $aa, $pos ) = @_;

    # Given:
    #   $aa = integer code of container type, 0-3
    #   $pos = position of character, for error message

    # USES GLOBAL VARIABLES: $rcurrent_depth,
    # $rcurrent_sequence_number, $rdepth_array,
    # $rstarting_line_of_current_depth, $statement_type
    my $cd_aa = ++$rcurrent_depth->[$aa];
    $total_depth++;
    $rtotal_depth->[$aa][$cd_aa] = $total_depth;
    my $input_line_number = $self->[_last_line_number_];
    my $input_line        = $self->[_line_of_text_];

    # Sequence numbers increment by number of items.  This keeps
    # a unique set of numbers but still allows the relative location
    # of any type to be determined.

    # make a new unique sequence number
    my $seqno = $next_sequence_number++;

    $rcurrent_sequence_number->[$aa][$cd_aa] = $seqno;

    $rstarting_line_of_current_depth->[$aa][$cd_aa] =
      [ $input_line_number, $input_line, $pos ];

    for my $bb ( 0 .. @closing_brace_names - 1 ) {
        next if ( $bb == $aa );
        $rdepth_array->[$aa][$bb][$cd_aa] = $rcurrent_depth->[$bb];
    }

    # set a flag for indenting a nested ternary statement
    my $indent = 0;
    if ( $aa == QUESTION_COLON ) {
        $rnested_ternary_flag->[$cd_aa] = 0;
        if ( $cd_aa > 1 ) {
            if ( $rnested_ternary_flag->[ $cd_aa - 1 ] == 0 ) {
                my $pdepth = $rtotal_depth->[$aa][ $cd_aa - 1 ];
                if ( $pdepth == $total_depth - 1 ) {
                    $indent = 1;
                    $rnested_ternary_flag->[ $cd_aa - 1 ] = -1;
                }
            }
        }
    }

    # Fix part #1 for git82: save last token type for propagation of type 'Z'
    $rnested_statement_type->[$aa][$cd_aa] =
      [ $statement_type, $last_nonblank_type, $last_nonblank_token ];
    $statement_type = EMPTY_STRING;
    return ( $seqno, $indent );
} ## end sub increase_nesting_depth

sub is_balanced_closing_container {

    my ($aa) = @_;

    # Return true if a closing container can go here without error
    # Return false if not
    # Given:
    #   $aa = integer code of container type, 0-3

    # cannot close if there was no opening
    my $cd_aa = $rcurrent_depth->[$aa];
    return if ( $cd_aa <= 0 );

    # check that any other brace types $bb contained within would be balanced
    for my $bb ( 0 .. @closing_brace_names - 1 ) {
        next if ( $bb == $aa );
        return
          if ( $rdepth_array->[$aa][$bb][$cd_aa] != $rcurrent_depth->[$bb] );
    }

    # OK, everything will be balanced
    return 1;
} ## end sub is_balanced_closing_container

sub decrease_nesting_depth {

    my ( $self, $aa, $pos ) = @_;

    # Given:
    #   $aa = integer code of container type, 0-3
    #   $pos = position of character, for error message

    # USES GLOBAL VARIABLES: $rcurrent_depth,
    # $rcurrent_sequence_number, $rdepth_array, $rstarting_line_of_current_depth
    # $statement_type
    my $seqno             = 0;
    my $input_line_number = $self->[_last_line_number_];
    my $input_line        = $self->[_line_of_text_];

    my $outdent = 0;
    $total_depth--;
    my $cd_aa = $rcurrent_depth->[$aa];
    if ( $cd_aa > 0 ) {

        # set a flag for un-indenting after seeing a nested ternary statement
        $seqno = $rcurrent_sequence_number->[$aa][$cd_aa];
        if ( $aa == QUESTION_COLON ) {
            $outdent = $rnested_ternary_flag->[$cd_aa];
        }

        # Fix part #2 for git82: use saved type for propagation of type 'Z'
        # through type L-R braces.  Perl seems to allow ${bareword}
        # as an indirect object, but nothing much more complex than that.
        ( $statement_type, my $saved_type, my $saved_token_uu ) =
          @{ $rnested_statement_type->[$aa][ $rcurrent_depth->[$aa] ] };
        if (   $aa == BRACE
            && $saved_type eq 'Z'
            && $last_nonblank_type eq 'w'
            && $rbrace_structural_type->[$brace_depth] eq 'L' )
        {
            $last_nonblank_type = $saved_type;
        }

        # check that any brace types $bb contained within are balanced
        for my $bb ( 0 .. @closing_brace_names - 1 ) {
            next if ( $bb == $aa );

            if ( $rdepth_array->[$aa][$bb][$cd_aa] != $rcurrent_depth->[$bb] ) {
                my $diff =
                  $rcurrent_depth->[$bb] - $rdepth_array->[$aa][$bb][$cd_aa];

                # don't whine too many times
                my $saw_brace_error = $self->get_saw_brace_error();
                if (
                    $saw_brace_error <= MAX_NAG_MESSAGES

                    # if too many closing types have occurred, we probably
                    # already caught this error
                    && ( ( $diff > 0 ) || ( $saw_brace_error <= 0 ) )
                  )
                {
                    $self->interrupt_logfile();
                    my $rsl = $rstarting_line_of_current_depth->[$aa][$cd_aa];
                    my $sl  = $rsl->[0];
                    my $rel = [ $input_line_number, $input_line, $pos ];
                    my $el  = $rel->[0];
                    my ($ess);

                    if ( $diff == 1 || $diff == -1 ) {
                        $ess = EMPTY_STRING;
                    }
                    else {
                        $ess = 's';
                    }
                    my $bname =
                      ( $diff > 0 )
                      ? $opening_brace_names[$bb]
                      : $closing_brace_names[$bb];
                    $self->write_error_indicator_pair( @{$rsl}, '^' );
                    my $msg = <<"EOM";
Found $diff extra $bname$ess between $opening_brace_names[$aa] on line $sl and $closing_brace_names[$aa] on line $el
EOM

                    if ( $diff > 0 ) {
                        my $rml =
                          $rstarting_line_of_current_depth->[$bb]
                          [ $rcurrent_depth->[$bb] ];
                        my $ml = $rml->[0];
                        $msg .=
"    The most recent un-matched $bname is on line $ml\n";
                        $self->write_error_indicator_pair( @{$rml}, '^' );
                    }
                    $self->write_error_indicator_pair( @{$rel}, '^' );
                    $self->warning($msg);
                    $self->resume_logfile();
                }
                $self->increment_brace_error();
                if ( $bb eq BRACE ) { $self->[_show_indentation_table_] = 1 }
            }
        }
        $rcurrent_depth->[$aa]--;
    }
    else {

        my $saw_brace_error = $self->get_saw_brace_error();
        if ( $saw_brace_error <= MAX_NAG_MESSAGES ) {
            my $msg = <<"EOM";
There is no previous $opening_brace_names[$aa] to match a $closing_brace_names[$aa] on line $input_line_number
EOM
            $self->indicate_error( $msg, $input_line_number, $input_line, $pos,
                '^' );
        }
        $self->increment_brace_error();
        if ( $aa eq BRACE ) { $self->[_show_indentation_table_] = 1 }

        # keep track of errors in braces alone (ignoring ternary nesting errors)
        $self->[_true_brace_error_count_]++
          if ( $closing_brace_names[$aa] ne "':'" );
    }
    return ( $seqno, $outdent );
} ## end sub decrease_nesting_depth

sub check_final_nesting_depths {

    # USES GLOBAL VARIABLES: $rcurrent_depth, $rstarting_line_of_current_depth
    my $self = shift;

    for my $aa ( 0 .. @closing_brace_names - 1 ) {

        my $cd_aa = $rcurrent_depth->[$aa];
        if ($cd_aa) {
            my $rsl = $rstarting_line_of_current_depth->[$aa][$cd_aa];
            my $sl  = $rsl->[0];
            my $msg = <<"EOM";
Final nesting depth of $opening_brace_names[$aa]s is $cd_aa
The most recent un-matched $opening_brace_names[$aa] is on line $sl
EOM
            $self->indicate_error( $msg, @{$rsl}, '^' );
            $self->increment_brace_error();
            if ( $aa eq BRACE ) { $self->[_show_indentation_table_] = 1 }
        }
    }
    return;
} ## end sub check_final_nesting_depths

#######################################################################
# Tokenizer routines for looking ahead in input stream
#######################################################################

sub peek_ahead_for_n_nonblank_pre_tokens {

    my ( $self, $max_pretokens ) = @_;

    # Given:
    #   $max_pretokens = number of pretokens wanted
    # Return:
    #   next $max_pretokens pretokens if they exist
    #   undef's if hits eof without seeing any pretokens

    # USES GLOBAL VARIABLES: (none)
    my $line;
    my $i = 0;
    my ( $rpre_tokens, $rmap, $rpre_types );

    while ( defined( $line = $self->peek_ahead( $i++ ) ) ) {
        $line =~ s/^\s+//;                 # trim leading blanks
        next if ( length($line) <= 0 );    # skip blank
        next if ( $line =~ /^#/ );         # skip comment
        ( $rpre_tokens, $rmap, $rpre_types ) =
          pre_tokenize( $line, $max_pretokens );
        last;
    } ## end while ( defined( $line = ...))
    return ( $rpre_tokens, $rpre_types );
} ## end sub peek_ahead_for_n_nonblank_pre_tokens

# look ahead for next non-blank, non-comment line of code
sub peek_ahead_for_nonblank_token {

    my ( $self, $rtokens, $max_token_index ) = @_;

    # Given:
    #   $rtokens = ref to token array
    #   $max_token_index = index of last token in $rtokens
    # Task:
    #   Update $rtokens with next nonblank token

    # USES GLOBAL VARIABLES: (none)
    my $line;
    my $i = 0;

    while ( defined( $line = $self->peek_ahead( $i++ ) ) ) {
        $line =~ s/^\s+//;                 # trim leading blanks
        next if ( length($line) <= 0 );    # skip blank
        next if ( $line =~ /^#/ );         # skip comment

        # Updated from 2 to 3 to get trigraphs, added for case b1175
        my ( $rtok, $rmap_uu, $rtype_uu ) = pre_tokenize( $line, 3 );
        my $j = $max_token_index + 1;

        foreach my $tok ( @{$rtok} ) {
            last if ( $tok =~ "\n" );
            $rtokens->[ ++$j ] = $tok;
        }
        last;
    } ## end while ( defined( $line = ...))
    return;
} ## end sub peek_ahead_for_nonblank_token

#######################################################################
# Tokenizer guessing routines for ambiguous situations
#######################################################################

sub guess_if_pattern_or_conditional {

    my ( $self, $i, $rtokens, $rtoken_type, $rtoken_map_uu, $max_token_index )
      = @_;

    # This routine is called when we have encountered a ? following an
    # unknown bareword, and we must decide if it starts a pattern or not
    # Given:
    #   $i - token index of the ? starting possible pattern
    #   $rtokens ... = the token arrays
    # Return:
    #   $is_pattern = 0 if probably not pattern,  =1 if probably a pattern
    #   msg = a warning or diagnostic message

    # USES GLOBAL VARIABLES: $last_nonblank_token

    my $is_pattern = 0;
    my $msg        = "guessing that ? after '$last_nonblank_token' starts a ";

    if ( $i >= $max_token_index ) {
        $msg .= "conditional (no end to pattern found on the line)\n";
        $is_pattern = 0;
        return ( $is_pattern, $msg );
    }

    my $ibeg = $i;
    $i = $ibeg + 1;
    ##my $next_token = $rtokens->[$i];    # first token after ?

    # look for a possible ending ? on this line..
    my $in_quote        = 1;
    my $quote_depth     = 0;
    my $quote_character = EMPTY_STRING;
    my $quote_pos       = 0;
    my $quoted_string;
    (

        $i,
        $in_quote,
        $quote_character,
        $quote_pos,
        $quote_depth,
        $quoted_string,

    ) = $self->follow_quoted_string(

        $ibeg,
        $in_quote,
        $rtokens,
        $rtoken_type,
        $quote_character,
        $quote_pos,
        $quote_depth,
        $max_token_index,

    );

    if ($in_quote) {

        # we didn't find an ending ? on this line,
        # so we bias towards conditional
        $is_pattern = 0;
        $msg .= "conditional (no ending ? on this line)\n";
        return ( $is_pattern, $msg );
    }

    # we found an ending ?, so we bias towards a pattern

    # Watch out for an ending ? in quotes, like this
    #    my $case_flag = File::Spec->case_tolerant ? '(?i)' : '';
    my $s_quote = 0;
    my $d_quote = 0;
    my $colons  = 0;
    foreach my $ii ( $ibeg + 1 .. $i - 1 ) {
        my $tok = $rtokens->[$ii];
        if ( $tok eq ":" ) { $colons++ }
        if ( $tok eq "'" ) { $s_quote++ }
        if ( $tok eq '"' ) { $d_quote++ }
    }
    if ( $s_quote % 2 || $d_quote % 2 || $colons ) {
        $is_pattern = 0;
        $msg .= "found ending ? but unbalanced quote chars\n";
        return ( $is_pattern, $msg );
    }
    if ( $self->pattern_expected( $i, $rtokens, $max_token_index ) >= 0 ) {
        $is_pattern = 1;
        $msg .= "pattern (found ending ? and pattern expected)\n";
        return ( $is_pattern, $msg );
    }
    $msg .= "pattern (uncertain, but found ending ?)\n";
    return ( $is_pattern, $msg );
} ## end sub guess_if_pattern_or_conditional

my %is_known_constant;
my %is_known_function;

BEGIN {

    # Constants like 'pi' in Trig.pm are common
    my @q = qw( pi pi2 pi4 pip2 pip4 );
    @is_known_constant{@q} = (1) x scalar(@q);

    # parenless calls of 'ok' are common
    @q = qw( ok );
    @is_known_function{@q} = (1) x scalar(@q);
} ## end BEGIN

sub guess_if_pattern_or_division {

    my ( $self, $i, $rtokens, $rtoken_type, $rtoken_map, $max_token_index ) =
      @_;

    # This routine is called when we have encountered a / following an
    # unknown bareword, and we must decide if it starts a pattern or is a
    # division.
    # Given:
    #   $i - token index of the / starting possible pattern
    #   $rtokens ... = the token arrays
    # Return:
    #   $is_pattern = 0 if probably division,  =1 if probably a pattern
    #   msg = a warning or diagnostic message
    # USES GLOBAL VARIABLES: $last_nonblank_token
    my $msg        = "guessing that / after '$last_nonblank_token' starts a ";
    my $ibeg       = $i;
    my $is_pattern = 0;

    my $divide_possible =
      $self->is_possible_numerator( $i, $rtokens, $max_token_index );

    if ( $divide_possible < 0 ) {
        $msg .= "pattern (division not possible here)\n";
        $is_pattern = 1;
        $self->saw_bareword_function($last_nonblank_token);
        return ( $is_pattern, $msg );
    }
    if ( $divide_possible == 4 ) {
        $msg .= "division (pattern not possible here)\n";
        $is_pattern = 0;
        return ( $is_pattern, $msg );
    }

    # anything left on line?
    if ( $i >= $max_token_index ) {
        $msg .= "division (line ends with this /)\n";
        $is_pattern = 0;
        return ( $is_pattern, $msg );
    }

    # quick check for no pattern-ending slash on this line
    my $pos_beg    = $rtoken_map->[$ibeg];
    my $input_line = $self->[_line_of_text_];
    if ( index( $input_line, '/', $pos_beg + 1 ) < 0 ) {
        $msg .= "division (no ending / on this line)\n";
        $is_pattern = 0;
        return ( $is_pattern, $msg );
    }

    # Setup spacing rule before we change $i below..
    $i = $ibeg + 1;
    my $next_token = $rtokens->[$i];    # first token after slash

    # There are four possible spacings around the first slash:
    #
    #     return pi/two;#/;     -/-
    #     return pi/ two;#/;    -/+
    #     return pi / two;#/;   +/+
    #     return pi /two;#/;    +/-   <-- possible pattern
    #
    # Spacing rule: a space before the slash but not after the slash
    # usually indicates a pattern.  We can use this to break ties.
    # Note: perl seems to take a newline as a space in this rule (c243)
    my $space_before          = $i < 2 || $rtokens->[ $i - 2 ] =~ m/^\s/;
    my $space_after           = $next_token                    =~ m/^\s/;
    my $is_pattern_by_spacing = $space_before && !$space_after;

    # Make an accurate search for a possible terminating / on this line..
    my $in_quote        = 1;
    my $quote_depth     = 0;
    my $quote_character = EMPTY_STRING;
    my $quote_pos       = 0;
    my $quoted_string;
    (

        $i,
        $in_quote,
        $quote_character,
        $quote_pos,
        $quote_depth,
        $quoted_string
      )
      = $self->follow_quoted_string(

        $ibeg,
        $in_quote,
        $rtokens,
        $rtoken_type,
        $quote_character,
        $quote_pos,
        $quote_depth,
        $max_token_index
      );

    # if we didn't find an ending / on this line ..
    if ($in_quote) {
        $is_pattern = 0;
        $msg .= "division (no ending / on this line)\n";
        return ( $is_pattern, $msg );
    }

    # we found an ending /, see if it might terminate a pattern
    my $pattern_expected =
      $self->pattern_expected( $i, $rtokens, $max_token_index );

    if ( $pattern_expected < 0 ) {
        $is_pattern = 0;
        $msg .= "division (pattern not possible)\n";
        return ( $is_pattern, $msg );
    }

    # Both pattern and divide can work here...
    # Check for known constants in the numerator, like 'pi'
    if ( $is_known_constant{$last_nonblank_token} ) {
        $msg .=
"division (pattern works too but saw known constant '$last_nonblank_token')\n";
        $is_pattern = 0;
        return ( $is_pattern, $msg );
    }

    # Check for known functions like 'ok'
    if ( $is_known_function{$last_nonblank_token} ) {
        $msg .= "pattern (division works too but saw '$last_nonblank_token')\n";
        $is_pattern = 1;
        return ( $is_pattern, $msg );
    }

    # If one rule is more probable, use it
    if ( $divide_possible > $pattern_expected ) {
        $msg .= "division (more likely based on following tokens)\n";
        $is_pattern = 0;
        return ( $is_pattern, $msg );
    }

    # finally, we have to use the spacing rule
    if ($is_pattern_by_spacing) {
        $msg .= "pattern (guess on spacing, but division possible too)\n";
        $is_pattern = 1;
    }
    else {
        $msg .= "division (guess on spacing, but pattern is possible too)\n";
        $is_pattern = 0;
    }

    return ( $is_pattern, $msg );
} ## end sub guess_if_pattern_or_division

sub guess_if_here_doc {

    my ( $self, $next_token ) = @_;

    # Try to resolve here-doc vs. shift by looking ahead for
    # non-code or the end token (currently only looks for end token)

    # Given:
    #   $next_token = the next token after '<<'

    # Return:
    #   1 if it is probably a here doc
    #   0 if not

    # USES GLOBAL VARIABLES: $current_package $ris_constant,

    # This is how many lines we will search for a target as part of the
    # guessing strategy.  There is probably little reason to change it.
    my $HERE_DOC_WINDOW = 40;

    my $here_doc_expected = 0;
    my $line;
    my $k   = 0;
    my $msg = "checking <<";

    while ( defined( $line = $self->peek_ahead( $k++ ) ) ) {
        chomp $line;
        if ( $line eq $next_token ) {
            $msg .= " -- found target $next_token ahead $k lines\n";
            $here_doc_expected = 1;    # got it
            last;
        }
        last if ( $k >= $HERE_DOC_WINDOW );
    } ## end while ( defined( $line = ...))

    if ( !$here_doc_expected ) {

        if ( !defined($line) ) {
            $here_doc_expected = -1;    # hit eof without seeing target
            $msg .= " -- must be shift; target $next_token not in file\n";

        }
        else {                          # still unsure..taking a wild guess

            if ( !$ris_constant->{$current_package}{$next_token} ) {
                $here_doc_expected = 1;
                $msg .=
                  " -- guessing it's a here-doc ($next_token not a constant)\n";
            }
            else {
                $msg .=
                  " -- guessing it's a shift ($next_token is a constant)\n";
            }
        }
    }
    $self->write_logfile_entry($msg);
    return $here_doc_expected;
} ## end sub guess_if_here_doc

#######################################################################
# Tokenizer Routines for scanning identifiers and related items
#######################################################################

sub scan_bare_identifier_do {

    my (

        $self,

        $input_line,
        $i,
        $tok,
        $type,
        $prototype,
        $rtoken_map,
        $max_token_index

    ) = @_;

    # This routine is called to scan a token starting with an alphanumeric
    # variable or package separator, :: or '.

    # Given:
    #   current scan state variables

    # USES GLOBAL VARIABLES: $current_package, $last_nonblank_token,
    # $last_nonblank_type, $rparen_type, $paren_depth

    my $package = undef;

    my $i_beg = $i;

    # we have to back up one pretoken at a :: since each : is one pretoken
    if ( $tok eq '::' ) { $i_beg-- }
    my $pos_beg = $rtoken_map->[$i_beg];
    pos($input_line) = $pos_beg;

    #  Examples:
    #   A::B::C
    #   A::
    #   ::A
    #   A'B
    if (
        $input_line =~ m{
         \G\s*                # start at pos
         ( (?:\w*(?:'|::))* ) # $1 = maybe package name like A:: A::B:: or A'
         (\w+)?               # $2 = maybe followed by sub name
        }gcx
      )
    {
        my $pos  = pos($input_line);
        my $numc = $pos - $pos_beg;
        $tok = substr( $input_line, $pos_beg, $numc );

        # type 'w' includes anything without leading type info
        # ($,%,@,*) including something like abc::def::ghi
        $type = 'w';

        my $sub_name = EMPTY_STRING;
        if ( defined($2) ) { $sub_name = $2; }
        if ( defined($1) && length($1) ) {
            $package = $1;

            # patch: check for package call A::B::C->
            # in this case, C is part of the package name
            if ($sub_name) {
                if ( $input_line =~ m{ \G\s*(?:->) }gcx ) {
                    $package .= $sub_name;
                    $sub_name = EMPTY_STRING;
                }
                pos($input_line) = $pos;
            }

            # patch: don't allow isolated package name which just ends
            # in the old style package separator (single quote).  Example:
            #   use CGI':all';
            if ( !($sub_name) && substr( $package, -1, 1 ) eq '\'' ) {
                $pos--;
            }

            $package =~ s/\'/::/g;
            if ( $package =~ /^\:/ ) { $package = 'main' . $package }
            $package =~ s/::$//;
        }
        else {
            $package = $current_package;

            # patched for c043, part 1: keyword does not follow '->'
            if ( $is_keyword{$tok} && $last_nonblank_type ne '->' ) {
                $type = 'k';
            }
        }

        # if it is a bareword..  patched for c043, part 2: not following '->'
        if ( $type eq 'w' && $last_nonblank_type ne '->' ) {

            # check for v-string with leading 'v' type character
            # (This seems to have precedence over filehandle, type 'Y')
            if ( substr( $tok, 0, 1 ) eq 'v' && $tok =~ /^v\d[_\d]*$/ ) {

                # we only have the first part - something like 'v101' -
                # look for more
                if ( $input_line =~ m/\G(\.\d[_\d]*)+/gc ) {
                    $pos  = pos($input_line);
                    $numc = $pos - $pos_beg;
                    $tok  = substr( $input_line, $pos_beg, $numc );
                }
                $type = 'v';
                $self->report_v_string($tok);
            }

            # bareword after sort has implied empty prototype; for example:
            # @sorted = sort numerically ( 53, 29, 11, 32, 7 );
            # This has priority over whatever the user has specified.
            elsif ($last_nonblank_token eq 'sort'
                && $last_nonblank_type eq 'k' )
            {
                $type = 'Z';
            }

            # issue c382: this elsif statement moved from above because
            # previous check for type 'Z' after sort has priority.
            elsif ( $ris_constant->{$package}{$sub_name} ) {
                $type = 'C';
            }

            # Note: strangely, perl does not seem to really let you create
            # functions which act like eval and do, in the sense that eval
            # and do may have operators following the final }, but any operators
            # that you create with prototype (&) apparently do not allow
            # trailing operators, only terms.  This seems strange.
            # If this ever changes, here is the update
            # to make perltidy behave accordingly:

            # elsif ( $ris_block_function->{$package}{$tok} ) {
            #    $tok='eval'; # patch to do braces like eval  - doesn't work
            #    $type = 'k';
            #}
            # TODO: This could become a separate type to allow for different
            # future behavior:
            elsif ( $ris_block_function->{$package}{$sub_name} ) {
                $type = 'G';
            }
            elsif ( $ris_block_list_function->{$package}{$sub_name} ) {
                $type = 'G';
            }
            elsif ( $ris_user_function->{$package}{$sub_name} ) {
                $type      = 'U';
                $prototype = $ruser_function_prototype->{$package}{$sub_name};
            }

            # check for indirect object
            elsif (

                # added 2001-03-27: must not be followed immediately by '('
                # see fhandle.t
                ( $input_line !~ m/\G\(/gc )

                # and
                && (

                    # preceded by keyword like 'print', 'printf' and friends
                    $is_indirect_object_taker{$last_nonblank_token}

                    # or preceded by something like 'print(' or 'printf('
                    || (
                        ( $last_nonblank_token eq '(' )
                        && $is_indirect_object_taker{
                            $rparen_type->[$paren_depth]
                        }

                    )
                )
              )
            {

                # may not be indirect object unless followed by a space;
                # updated 2021-01-16 to consider newline to be a space.
                # updated for case b990 to look for either ';' or space
                if ( pos($input_line) == length($input_line)
                    || $input_line =~ m/\G[;\s]/gc )
                {
                    $type = 'Y';

                    # Abandon Hope ...
                    # Perl's indirect object notation is a very bad
                    # thing and can cause subtle bugs, especially for
                    # beginning programmers.  And I haven't even been
                    # able to figure out a sane warning scheme which
                    # doesn't get in the way of good scripts.

                    # Complain if a filehandle has any lower case
                    # letters.  This is suggested good practice.
                    # Use 'sub_name' because something like
                    # main::MYHANDLE is ok for filehandle
                    if ( $sub_name =~ /[a-z]/ ) {

                        # could be bug caused by older perltidy if
                        # followed by '('
                        if ( $input_line =~ m/\G\s*\(/gc ) {
                            $self->complain(
"Caution: unknown word '$tok' in indirect object slot\n"
                            );
                        }
                    }
                }

                # bareword not followed by a space -- may not be filehandle
                # (may be function call defined in a 'use' statement)
                else {
                    $type = 'Z';
                }
            }

            # none of the above special types
            else {
            }
        }

        # Now we must convert back from character position
        # to pre_token index.
        # I don't think an error flag can occur here ..but who knows
        my $error;
        ( $i, $error ) =
          inverse_pretoken_map( $i, $pos, $rtoken_map, $max_token_index );
        if ($error) {
            $self->warning(
                "scan_bare_identifier: Possibly invalid tokenization\n");
        }
    }

    # no match but line not blank - could be syntax error
    # perl will take '::' alone without complaint
    else {
        $type = 'w';

        # change this warning to log message if it becomes annoying
        $self->warning("didn't find identifier after leading ::\n");
    }
    return ( $i, $tok, $type, $prototype );
} ## end sub scan_bare_identifier_do

sub scan_id_do {

    my (

        $self,

        $input_line,
        $i,
        $tok,
        $rtokens,
        $rtoken_map,
        $id_scan_state,
        $max_token_index

    ) = @_;

    # Scan identifier following a type token.
    # Given:
    #   current scan state variables

    # This is the new scanner and may eventually replace scan_identifier.
    # Only type 'sub' and 'package' are implemented.
    # Token types $ * % @ & -> are not yet implemented.
    #
    # The type of call depends on $id_scan_state: $id_scan_state = ''
    # for starting call, in which case $tok must be the token defining
    # the type.
    #
    # If the type token is the last nonblank token on the line, a value
    # of $id_scan_state = $tok is returned, indicating that further
    # calls must be made to get the identifier.  If the type token is
    # not the last nonblank token on the line, the identifier is
    # scanned and handled and a value of '' is returned.

    use constant DEBUG_NSCAN => 0;
    my $type = EMPTY_STRING;
    my $i_beg;

    #print "NSCAN:entering i=$i, tok=$tok, type=$type, state=$id_scan_state\n";
    #my ($a,$b,$c) = caller;
    #print "NSCAN: scan_id called with tok=$tok $a $b $c\n";

    # on re-entry, start scanning at first token on the line
    if ($id_scan_state) {
        $i_beg = $i;
        $type  = EMPTY_STRING;
    }

    # on initial entry, start scanning just after type token
    else {
        $i_beg         = $i + 1;
        $id_scan_state = $tok;
        $type          = 't';
    }

    # find $i_beg = index of next nonblank token,
    # and handle empty lines
    my $blank_line          = 0;
    my $next_nonblank_token = $rtokens->[$i_beg];
    if ( $i_beg > $max_token_index ) {
        $blank_line = 1;
    }
    else {

        # only a '#' immediately after a '$' is not a comment
        if ( $next_nonblank_token eq '#' ) {
            if ( $tok ne '$' ) {
                $blank_line = 1;
            }
        }

        if ( $next_nonblank_token =~ /^\s/ ) {
            ( $next_nonblank_token, $i_beg ) =
              find_next_nonblank_token_on_this_line( $i_beg, $rtokens,
                $max_token_index );
            if ( $next_nonblank_token =~ /(^#|^\s*$)/ ) {
                $blank_line = 1;
            }
        }
    }

    # handle non-blank line; identifier, if any, must follow
    if ( !$blank_line ) {

        if ( $is_sub{$id_scan_state} ) {
            ( $i, $tok, $type, $id_scan_state ) = $self->do_scan_sub(
                {
                    input_line      => $input_line,
                    i               => $i,
                    i_beg           => $i_beg,
                    tok             => $tok,
                    type            => $type,
                    rtokens         => $rtokens,
                    rtoken_map      => $rtoken_map,
                    id_scan_state   => $id_scan_state,
                    max_token_index => $max_token_index,
                }
            );
        }

        elsif ( $is_package{$id_scan_state} ) {
            ( $i, $tok, $type ) = $self->do_scan_package(
                {
                    input_line      => $input_line,
                    i               => $i,
                    i_beg           => $i_beg,
                    tok             => $tok,
                    type            => $type,
                    rtokens         => $rtokens,
                    rtoken_map      => $rtoken_map,
                    max_token_index => $max_token_index,
                }
            );
            $id_scan_state = EMPTY_STRING;
        }

        else {
            $self->warning("invalid token in scan_id: $tok\n");
            $id_scan_state = EMPTY_STRING;
        }
    }

    if ( $id_scan_state && ( !defined($type) || !$type ) ) {

        # shouldn't happen:
        if (DEVEL_MODE) {
            $self->Fault(<<EOM);
Program bug in scan_id: undefined type but scan_state=$id_scan_state
EOM
        }
        $self->warning(
"Possible program bug in sub scan_id: undefined type but scan_state=$id_scan_state\n"
        );
        $self->report_definite_bug();
    }

    DEBUG_NSCAN && do {
        print {*STDOUT}
          "NSCAN: returns i=$i, tok=$tok, type=$type, state=$id_scan_state\n";
    };
    return ( $i, $tok, $type, $id_scan_state );
} ## end sub scan_id_do

sub check_prototype {
    my ( $proto, $package, $subname ) = @_;

    # Classify a sub based on its prototype
    return if ( !defined($package) );
    return if ( !defined($subname) );
    if ( defined($proto) ) {
        $proto =~ s/^\s*\(\s*//;
        $proto =~ s/\s*\)$//;
        if ($proto) {
            $ris_user_function->{$package}{$subname}        = 1;
            $ruser_function_prototype->{$package}{$subname} = "($proto)";

            # prototypes containing '&' must be treated specially..
            if ( $proto =~ /\&/ ) {

                # right curly braces of prototypes ending in
                # '&' may be followed by an operator
                if ( $proto =~ /\&$/ ) {
                    $ris_block_function->{$package}{$subname} = 1;
                }

                # right curly braces of prototypes NOT ending in
                # '&' may NOT be followed by an operator
                else {
                    $ris_block_list_function->{$package}{$subname} = 1;
                }
            }
        }
        else {
            $ris_constant->{$package}{$subname} = 1;
        }
    }
    else {
        $ris_user_function->{$package}{$subname} = 1;
    }
    return;
} ## end sub check_prototype

sub do_scan_package {

    my ( $self, $rcall_hash ) = @_;

    my $input_line      = $rcall_hash->{input_line};
    my $i               = $rcall_hash->{i};
    my $i_beg           = $rcall_hash->{i_beg};
    my $tok             = $rcall_hash->{tok};
    my $type            = $rcall_hash->{type};
    my $rtokens         = $rcall_hash->{rtokens};
    my $rtoken_map      = $rcall_hash->{rtoken_map};
    my $max_token_index = $rcall_hash->{max_token_index};

    # Parse a package name.
    # This is called with $i_beg equal to the index of the first nonblank
    # token following a 'package' token.
    # USES GLOBAL VARIABLES: $current_package,

    # package NAMESPACE
    # package NAMESPACE VERSION
    # package NAMESPACE BLOCK
    # package NAMESPACE VERSION BLOCK
    #
    # If VERSION is provided, package sets the $VERSION variable in the given
    # namespace to a version object with the VERSION provided. VERSION must be
    # a "strict" style version number as defined by the version module: a
    # positive decimal number (integer or decimal-fraction) without
    # exponentiation or else a dotted-decimal v-string with a leading 'v'
    # character and at least three components.
    # reference http://perldoc.perl.org/functions/package.html

    my $package = undef;
    my $pos_beg = $rtoken_map->[$i_beg];
    pos($input_line) = $pos_beg;

    # handle non-blank line; package name, if any, must follow
    if ( $input_line =~ m/\G\s*((?:\w*(?:'|::))*\w*)/gc ) {
        $package = $1;
        $package = ( defined($1) && $1 ) ? $1 : 'main';
        $package =~ s/\'/::/g;
        if ( $package =~ /^\:/ ) { $package = 'main' . $package }
        $package =~ s/::$//;
        my $pos  = pos($input_line);
        my $numc = $pos - $pos_beg;
        $tok  = 'package ' . substr( $input_line, $pos_beg, $numc );
        $type = 'P';    # Fix for c250, previously 'i'

        # Now we must convert back from character position
        # to pre_token index.
        # I don't think an error flag can occur here ..but ?
        my $error;
        ( $i, $error ) =
          inverse_pretoken_map( $i, $pos, $rtoken_map, $max_token_index );
        if ($error) { $self->warning("Possibly invalid package\n") }
        $current_package = $package;

        # we should now have package NAMESPACE
        # now expecting VERSION, BLOCK, or ; to follow ...
        # package NAMESPACE VERSION
        # package NAMESPACE BLOCK
        # package NAMESPACE VERSION BLOCK
        my ( $next_nonblank_token, $i_next_uu ) =
          $self->find_next_nonblank_token( $i, $rtokens, $max_token_index );

        # check that something recognizable follows, but do not parse.
        # A VERSION number will be parsed later as a number or v-string in the
        # normal way.  What is important is to set the statement type if
        # everything looks okay so that the operator_expected() routine
        # knows that the number is in a package statement.
        # Examples of valid primitive tokens that might follow are:
        #  1235  . ; { } v3  v
        # FIX: added a '#' since a side comment may also follow
        # Added ':' for class attributes (for --use-feature=class, rt145706)
        if ( $next_nonblank_token =~ /^([v\.\d;\{\}\#\:])|v\d|\d+$/ ) {
            $statement_type = $tok;
        }
        else {
            $self->warning(
                "Unexpected '$next_nonblank_token' after package name '$tok'\n"
            );
        }
    }

    # no match but line not blank --
    # could be a label with name package, like package:  , for example.
    else {
        $type = 'k';
    }

    return ( $i, $tok, $type );
} ## end sub do_scan_package

{    ## begin closure for sub scan_complex_identifier

    use constant DEBUG_SCAN_ID => 0;

    # Constant hash:
    my %is_special_variable_char;

    BEGIN {

        # These are the only characters which can (currently) form special
        # variables, like $^W: (issue c066).
        my @q =
          qw{ ? A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ };
        @is_special_variable_char{@q} = (1) x scalar(@q);
    } ## end BEGIN

    # These are the possible states for this scanner:
    my $scan_state_SIGIL     = '$';
    my $scan_state_ALPHA     = 'A';
    my $scan_state_COLON     = ':';
    my $scan_state_LPAREN    = '(';
    my $scan_state_RPAREN    = ')';
    my $scan_state_AMPERSAND = '&';
    my $scan_state_SPLIT     = '^';

    # Only these non-blank states may be returned to caller:
    my %is_returnable_scan_state = (
        $scan_state_SIGIL     => 1,
        $scan_state_AMPERSAND => 1,
    );

    # USES GLOBAL VARIABLES:
    #    $context, $last_nonblank_token, $last_nonblank_type

    #-----------
    # call args:
    #-----------
    my ( $i, $id_scan_state, $identifier, $rtokens, $max_token_index,
        $expecting, $container_type );

    #-------------------------------------------
    # my variables, re-initialized on each call:
    #-------------------------------------------
    my $i_begin;                # starting index $i
    my $type;                   # returned identifier type
    my $tok_begin;              # starting token
    my $tok;                    # returned token
    my $id_scan_state_begin;    # starting scan state
    my $identifier_begin;       # starting identifier
    my $i_save;                 # a last good index, in case of error
    my $message;                # hold error message for log file
    my $tok_is_blank;
    my $last_tok_is_blank;
    my $in_prototype_or_signature;
    my $saw_alpha;
    my $saw_type;
    my $allow_tick;

    sub initialize_my_scan_id_vars {

        # Initialize all 'my' vars on entry
        $i_begin   = $i;
        $type      = EMPTY_STRING;
        $tok_begin = $rtokens->[$i_begin];
        $tok       = $tok_begin;
        if ( $tok_begin eq ':' ) { $tok_begin = '::' }
        $id_scan_state_begin = $id_scan_state;
        $identifier_begin    = $identifier;
        $i_save              = undef;

        $message           = EMPTY_STRING;
        $tok_is_blank      = undef;          # a flag to speed things up
        $last_tok_is_blank = undef;

        $in_prototype_or_signature =
          $container_type && $container_type =~ /^sub\b/;

        # these flags will be used to help figure out the type:
        $saw_alpha = undef;
        $saw_type  = undef;

        # allow old package separator (') except in 'use' statement
        $allow_tick = ( $last_nonblank_token ne 'use' );
        return;
    } ## end sub initialize_my_scan_id_vars

    #----------------------------------
    # Routines for handling scan states
    #----------------------------------
    sub do_id_scan_state_dollar {

        my $self = shift;

        # We saw a sigil, now looking to start a variable name
        if ( $tok eq '$' ) {

            $identifier .= $tok;

            # we've got a punctuation variable if end of line (punct.t)
            if ( $i == $max_token_index ) {
                $type          = 'i';
                $id_scan_state = EMPTY_STRING;
            }
        }
        elsif ( $tok =~ /^\w/ ) {    # alphanumeric ..
            $saw_alpha = 1;
            $identifier .= $tok;

            # now need :: except for special digit vars like '$1' (c208)
            $id_scan_state = $tok =~ /^\d/ ? EMPTY_STRING : $scan_state_COLON;
        }
        elsif ( $tok eq '::' ) {
            $id_scan_state = $scan_state_ALPHA;
            $identifier .= $tok;
        }

        # POSTDEFREF ->@ ->% ->& ->*
        elsif ( ( $tok =~ /^[\@\%\&\*]$/ ) && $identifier =~ /\-\>$/ ) {
            $identifier .= $tok;
        }
        elsif ( $tok eq "'" && $allow_tick ) {    # alphanumeric ..
            $saw_alpha     = 1;
            $id_scan_state = $scan_state_COLON;    # now need ::
            $identifier .= $tok;

            # Perl will accept leading digits in identifiers,
            # although they may not always produce useful results.
            # Something like $main::0 is ok.  But this also works:
            #
            #  sub howdy::123::bubba{ print "bubba $54321!\n" }
            #  howdy::123::bubba();
            #
        }
        elsif ( $tok eq '#' ) {

            my $is_punct_var = $identifier eq '$$';

            # side comment or identifier?
            if (

                # A '#' starts a comment if it follows a space. For example,
                # the following is equivalent to $ans=40.
                #   my $ #
                #     ans = 40;
                !$last_tok_is_blank

                # a # inside a prototype or signature can only start a
                # comment
                && !$in_prototype_or_signature

                # these are valid punctuation vars: *# %# @# $#
                # May also be '$#array' or POSTDEFREF ->$#
                && (   $identifier =~ /^[\%\@\$\*]$/
                    || $identifier =~ /\$$/ )

                # but a '#' after '$$' is a side comment; see c147
                && !$is_punct_var

              )
            {
                $identifier .= $tok;    # keep same state, a $ could follow
            }
            else {

                # otherwise it is a side comment
                if    ( $identifier eq '->' )                 { }
                elsif ($is_punct_var)                         { $type = 'i' }
                elsif ( $id_scan_state eq $scan_state_SIGIL ) { $type = 't' }
                else                                          { $type = 'i' }
                $i             = $i_save;
                $id_scan_state = EMPTY_STRING;
            }
        }

        elsif ( $tok eq '{' ) {

            # check for something like ${#} or ${?}, where ? is a special char
            if (
                (
                       $identifier eq '$'
                    || $identifier eq '@'
                    || $identifier eq '$#'
                )
                && $i + 2 <= $max_token_index
                && $rtokens->[ $i + 2 ] eq '}'
                && $rtokens->[ $i + 1 ] !~ /[\s\w]/
              )
            {
                my $next2 = $rtokens->[ $i + 2 ];
                my $next1 = $rtokens->[ $i + 1 ];
                $identifier .= $tok . $next1 . $next2;
                $i += 2;
                $id_scan_state = EMPTY_STRING;
            }
            else {

                # skip something like ${xxx} or ->{
                $id_scan_state = EMPTY_STRING;

                # if this is the first token of a line, any tokens for this
                # identifier have already been accumulated
                if ( $identifier eq '$' || $i == 0 ) {
                    $identifier = EMPTY_STRING;
                }
                $i = $i_save;
            }
        }

        # space ok after leading $ % * & @
        elsif ( $tok =~ /^\s*$/ ) {

            $tok_is_blank = 1;

            # note: an id with a leading '&' does not actually come this way
            if ( $identifier =~ /^[\$\%\*\&\@]/ ) {

                if ( length($identifier) > 1 ) {
                    $id_scan_state = EMPTY_STRING;
                    $i             = $i_save;
                    $type          = 'i';    # probably punctuation variable
                }
                else {

                    # fix c139: trim line-ending type 't'
                    if ( $i == $max_token_index ) {
                        $i    = $i_save;
                        $type = 't';
                    }

                    # spaces after $'s are common, and space after @
                    # is harmless, so only complain about space
                    # after other type characters. Space after $ and
                    # @ will be removed in formatting.  Report space
                    # after % and * because they might indicate a
                    # parsing error.  In other words '% ' might be a
                    # modulo operator.  Delete this warning if it
                    # gets annoying.
                    elsif ( $identifier !~ /^[\@\$]$/ ) {
                        $message =
                          "Space in identifier, following $identifier\n";
                    }
                    else {
                        # silently accept space after '$' and '@' sigils
                    }
                }
            }

            elsif ( $identifier eq '->' ) {

                # space after '->' is ok except at line end ..
                # so trim line-ending in type '->' (fixes c139)
                if ( $i == $max_token_index ) {
                    $i    = $i_save;
                    $type = '->';
                }
            }

            # stop at space after something other than -> or sigil
            # Example of what can arrive here:
            #   eval { $MyClass->$$ };
            else {
                $id_scan_state = EMPTY_STRING;
                $i             = $i_save;
                $type          = 'i';
            }
        }
        elsif ( $tok eq '^' ) {

            # check for some special variables like $^ $^W
            if ( $identifier =~ /^[\$\*\@\%]$/ ) {
                $identifier .= $tok;
                $type = 'i';

                # There may be one more character, not a space, after the ^
                my $next1 = $rtokens->[ $i + 1 ];
                my $chr   = substr( $next1, 0, 1 );
                if ( $is_special_variable_char{$chr} ) {

                    # It is something like $^W
                    # Test case (c066) : $^Oeq'linux'
                    $i++;
                    $identifier .= $next1;

                    # If pretoken $next1 is more than one character long,
                    # set a flag indicating that it needs to be split.
                    $id_scan_state =
                      ( length($next1) > 1 ) ? $scan_state_SPLIT : EMPTY_STRING;
                }
                else {

                    # it is just $^
                    # Simple test case (c065): '$aa=$^if($bb)';
                    $id_scan_state = EMPTY_STRING;
                }
            }
            else {
                $id_scan_state = EMPTY_STRING;
                $i             = $i_save;
            }
        }
        else {    # something else

            if ( $in_prototype_or_signature && $tok =~ /^[\),=#]/ ) {

                # We might be in an extrusion of
                #     sub foo2 ( $first, $, $third ) {
                # looking at a line starting with a comma, like
                #   $
                #   ,
                # in this case the comma ends the signature variable
                # '$' which will have been previously marked type 't'
                # rather than 'i'.
                if ( $i == $i_begin ) {
                    $identifier = EMPTY_STRING;
                    $type       = EMPTY_STRING;
                }

                # at a # we have to mark as type 't' because more may
                # follow, otherwise, in a signature we can let '$' be an
                # identifier here for better formatting.
                # See 'mangle4.in' for a test case.
                else {
                    $type = 'i';
                    if ( $id_scan_state eq $scan_state_SIGIL && $tok eq '#' ) {
                        $type = 't';
                    }
                    $i = $i_save;
                }
                $id_scan_state = EMPTY_STRING;
            }

            # check for various punctuation variables
            elsif ( $identifier =~ /^[\$\*\@\%]$/ ) {
                $identifier .= $tok;
            }

            # POSTDEFREF: Postfix reference ->$* ->%*  ->@* ->** ->&* ->$#*
            elsif ($tok eq '*'
                && $identifier =~ /\-\>([\@\%\$\*\&]|\$\#)$/ )
            {
                $identifier .= $tok;
            }

            elsif ( $identifier eq '$#' ) {

                if ( $tok eq '{' ) { $type = 'i'; $i = $i_save }

                # perl seems to allow just these: $#: $#- $#+
                elsif ( $tok =~ /^[\:\-\+]$/ ) {
                    $type = 'i';
                    $identifier .= $tok;
                }
                else {
                    $i = $i_save;
                    $self->write_logfile_entry(
                        'Use of $# is deprecated' . "\n" );
                }
            }
            elsif ( $identifier eq '$$' ) {

                # perl does not allow references to punctuation
                # variables without braces.  For example, this
                # won't work:
                #  $:=\4;
                #  $a = $$:;
                # You would have to use
                #  $a = ${$:};

                # '$$' alone is punctuation variable for PID
                $i = $i_save;
                if   ( $tok eq '{' ) { $type = 't' }
                else                 { $type = 'i' }
            }
            elsif ( $identifier eq '->' ) {
                $i = $i_save;
            }
            else {
                $i = $i_save;
                if ( length($identifier) == 1 ) {
                    $identifier = EMPTY_STRING;
                }
            }
            $id_scan_state = EMPTY_STRING;
        }
        return;
    } ## end sub do_id_scan_state_dollar

    sub do_id_scan_state_alpha {

        my $self = shift;

        # looking for alphanumeric after ::
        $tok_is_blank = $tok =~ /^\s*$/;

        if ( $tok =~ /^\w/ ) {    # found it
            $identifier .= $tok;
            $id_scan_state = $scan_state_COLON;    # now need ::
            $saw_alpha     = 1;
        }
        elsif ( $tok eq "'" && $allow_tick ) {
            $identifier .= $tok;
            $id_scan_state = $scan_state_COLON;    # now need ::
            $saw_alpha     = 1;
        }
        elsif ( $tok_is_blank && $identifier =~ /^sub / ) {
            $id_scan_state = $scan_state_LPAREN;
            $identifier .= $tok;
        }
        elsif ( $tok eq '(' && $identifier =~ /^sub / ) {
            $id_scan_state = $scan_state_RPAREN;
            $identifier .= $tok;
        }
        else {
            $id_scan_state = EMPTY_STRING;
            $i             = $i_save;
        }
        return;
    } ## end sub do_id_scan_state_alpha

    sub do_id_scan_state_colon {

        my $self = shift;

        # looking for possible :: after alphanumeric

        $tok_is_blank = $tok =~ /^\s*$/;

        if ( $tok eq '::' ) {    # got it
            $identifier .= $tok;
            $id_scan_state = $scan_state_ALPHA;    # now require alpha
        }
        elsif ( $tok =~ /^\w/ ) {    # more alphanumeric is ok here
            $identifier .= $tok;
            $id_scan_state = $scan_state_COLON;    # now need ::
            $saw_alpha     = 1;
        }
        elsif ( $tok eq "'" && $allow_tick ) {     # tick

            if ( $is_keyword{$identifier} ) {
                $id_scan_state = EMPTY_STRING;     # that's all
                $i             = $i_save;
            }
            else {
                $identifier .= $tok;
            }
        }
        elsif ( $tok_is_blank && $identifier =~ /^sub / ) {
            $id_scan_state = $scan_state_LPAREN;
            $identifier .= $tok;
        }
        elsif ( $tok eq '(' && $identifier =~ /^sub / ) {
            $id_scan_state = $scan_state_RPAREN;
            $identifier .= $tok;
        }
        else {
            $id_scan_state = EMPTY_STRING;    # that's all
            $i             = $i_save;
        }
        return;
    } ## end sub do_id_scan_state_colon

    sub do_id_scan_state_left_paren {

        my $self = shift;

        # looking for possible '(' of a prototype

        if ( $tok eq '(' ) {    # got it
            $identifier .= $tok;
            $id_scan_state = $scan_state_RPAREN;    # now find the end of it
        }
        elsif ( $tok =~ /^\s*$/ ) {                 # blank - keep going
            $identifier .= $tok;
            $tok_is_blank = 1;
        }
        else {
            $id_scan_state = EMPTY_STRING;          # that's all - no prototype
            $i             = $i_save;
        }
        return;
    } ## end sub do_id_scan_state_left_paren

    sub do_id_scan_state_right_paren {

        my $self = shift;

        # looking for a ')' of prototype to close a '('

        $tok_is_blank = $tok =~ /^\s*$/;

        if ( $tok eq ')' ) {    # got it
            $identifier .= $tok;
            $id_scan_state = EMPTY_STRING;    # all done
        }
        elsif ( $tok =~ /^[\s\$\%\\\*\@\&\;]/ ) {
            $identifier .= $tok;
        }
        else {    # probable error in script, but keep going
            $self->warning(
                "Unexpected '$tok' while seeking end of prototype\n");
            $identifier .= $tok;
        }
        return;
    } ## end sub do_id_scan_state_right_paren

    sub do_id_scan_state_ampersand {

        my $self = shift;

        # Starting sub call after seeing an '&'
        if ( $tok =~ /^[\$\w]/ ) {    # alphanumeric ..
            $id_scan_state = $scan_state_COLON;    # now need ::
            $saw_alpha     = 1;
            $identifier .= $tok;
        }
        elsif ( $tok eq "'" && $allow_tick ) {     # alphanumeric ..
            $id_scan_state = $scan_state_COLON;    # now need ::
            $saw_alpha     = 1;
            $identifier .= $tok;
        }
        elsif ( $tok =~ /^\s*$/ ) {                # allow space
            $tok_is_blank = 1;

            # fix c139: trim line-ending type 't'
            if ( length($identifier) == 1 && $i == $max_token_index ) {
                $i    = $i_save;
                $type = 't';
            }
        }
        elsif ( $tok eq '::' ) {                   # leading ::
            $id_scan_state = $scan_state_ALPHA;    # accept alpha next
            $identifier .= $tok;
        }
        elsif ( $tok eq '{' ) {
            if ( $identifier eq '&' || $i == 0 ) {
                $identifier = EMPTY_STRING;
            }
            $i             = $i_save;
            $id_scan_state = EMPTY_STRING;
        }
        elsif ( $tok eq '^' ) {
            if ( $identifier eq '&' ) {

                # Special variable (c066)
                $identifier .= $tok;
                $type = 'i';

                # To be a special $^ variable, there may be one more character,
                # not a space, after the ^
                my $next1 = $rtokens->[ $i + 1 ];
                my $chr   = substr( $next1, 0, 1 );
                if ( $is_special_variable_char{$chr} ) {

                    # It is something like &^O
                    $i++;
                    $identifier .= $next1;

                    # If pretoken $next1 is more than one character long,
                    # set a flag indicating that it needs to be split.
                    $id_scan_state =
                      ( length($next1) > 1 ) ? $scan_state_SPLIT : EMPTY_STRING;
                }
                else {

                    # It is &^.  This is parsed by perl as a call to sub '^',
                    # even though it would be difficult to create a sub '^'.
                    # So we mark it as an identifier (c068).
                    $id_scan_state = EMPTY_STRING;
                }
            }
            else {
                $identifier = EMPTY_STRING;
                $i          = $i_save;
            }
        }
        else {

            # punctuation variable?
            # testfile: cunningham4.pl
            #
            # We have to be careful here.  If we are in an unknown state,
            # we will reject the punctuation variable.  In the following
            # example the '&' is a binary operator but we are in an unknown
            # state because there is no sigil on 'Prima', so we don't
            # know what it is.  But it is a bad guess that
            # '&~' is a function variable.
            # $self->{text}->{colorMap}->[
            #   Prima::PodView::COLOR_CODE_FOREGROUND
            #   & ~tb::COLOR_INDEX ] =
            #   $sec->{ColorCode}

            # Fix for case c033: a '#' here starts a side comment
            if ( $identifier eq '&' && $expecting && $tok ne '#' ) {
                $identifier .= $tok;
            }
            else {
                $identifier = EMPTY_STRING;
                $i          = $i_save;
                $type       = '&';
            }
            $id_scan_state = EMPTY_STRING;
        }
        return;
    } ## end sub do_id_scan_state_ampersand

    #-------------------
    # hash of scanner subs
    #-------------------
    my $scan_identifier_code = {
        $scan_state_SIGIL     => \&do_id_scan_state_dollar,
        $scan_state_ALPHA     => \&do_id_scan_state_alpha,
        $scan_state_COLON     => \&do_id_scan_state_colon,
        $scan_state_LPAREN    => \&do_id_scan_state_left_paren,
        $scan_state_RPAREN    => \&do_id_scan_state_right_paren,
        $scan_state_AMPERSAND => \&do_id_scan_state_ampersand,
    };

    sub scan_complex_identifier {

        (
            my $self,

            $i,
            $id_scan_state,
            $identifier,
            $rtokens,
            $max_token_index,
            $expecting,
            $container_type

        ) = @_;

        # This routine assembles tokens into identifiers.  It maintains a
        # scan state, id_scan_state.  It updates id_scan_state based upon
        # current id_scan_state and token, and returns an updated
        # id_scan_state and the next index after the identifier.

        # This routine now serves a a backup for sub scan_simple_identifier
        # which handles most identifiers.

        # Note that $self must be a 'my' variable and not be a closure
        # variables like the other args. Otherwise it will not get
        # deleted by a DESTROY call at the end of a file. Then an
        # attempt to create multiple tokenizers can occur when multiple
        # files are processed, causing an error.

        # return flag telling caller to split the pretoken
        my $split_pretoken_flag;

        #-------------------
        # Initialize my vars
        #-------------------

        initialize_my_scan_id_vars();

        #--------------------------------------------------------
        # get started by defining a type and a state if necessary
        #--------------------------------------------------------

        if ( !$id_scan_state ) {
            $context = UNKNOWN_CONTEXT;

            # fixup for digraph
            if ( $tok eq '>' ) {
                $tok       = '->';
                $tok_begin = $tok;
            }
            $identifier = $tok;

            if ( $last_nonblank_token eq '->' ) {
                $identifier    = '->' . $identifier;
                $id_scan_state = $scan_state_SIGIL;
            }
            elsif ( $tok eq '$' || $tok eq '*' ) {
                $id_scan_state = $scan_state_SIGIL;
                $context       = SCALAR_CONTEXT;
            }
            elsif ( $tok eq '%' || $tok eq '@' ) {
                $id_scan_state = $scan_state_SIGIL;
                $context       = LIST_CONTEXT;
            }
            elsif ( $tok eq '&' ) {
                $id_scan_state = $scan_state_AMPERSAND;
            }
            elsif ( $tok eq 'sub' or $tok eq 'package' ) {
                $saw_alpha     = 0;    # 'sub' is considered type info here
                $id_scan_state = $scan_state_SIGIL;
                $identifier .=
                  SPACE;    # need a space to separate sub from sub name
            }
            elsif ( $tok eq '::' ) {
                $id_scan_state = $scan_state_ALPHA;
            }
            elsif ( $tok =~ /^\w/ ) {
                $id_scan_state = $scan_state_COLON;
                $saw_alpha     = 1;
            }
            elsif ( $tok eq '->' ) {
                $id_scan_state = $scan_state_SIGIL;
            }
            else {

                # shouldn't happen: bad call parameter
                my $msg =
"Program bug detected: scan_complex_identifier received bad starting token = '$tok'\n";
                if (DEVEL_MODE) { $self->Fault($msg) }
                if ( !$self->[_in_error_] ) {
                    $self->warning($msg);
                    $self->[_in_error_] = 1;
                }
                $id_scan_state = EMPTY_STRING;

                # emergency return
                goto RETURN;
            }
            $saw_type = !$saw_alpha;
        }
        else {
            $i--;
            $saw_alpha = ( $tok =~ /^\w/ );
            $saw_type  = ( $tok =~ /([\$\%\@\*\&])/ );

            # check for a valid starting state
            if ( DEVEL_MODE && !$is_returnable_scan_state{$id_scan_state} ) {
                $self->Fault(<<EOM);
Unexpected starting scan state in sub scan_complex_identifier: '$id_scan_state'
EOM
            }
        }

        #------------------------------
        # loop to gather the identifier
        #------------------------------

        $i_save = $i;

        while ( $i < $max_token_index && $id_scan_state ) {

            # Be sure we have code to handle this state before we proceed
            my $code = $scan_identifier_code->{$id_scan_state};
            if ( !$code ) {

                if ( $id_scan_state eq $scan_state_SPLIT ) {
                    ## OK: this is the signal to exit and split the pretoken
                }

                # unknown state - should not happen
                else {
                    if (DEVEL_MODE) {
                        $self->Fault(<<EOM);
Unknown scan state in sub scan_complex_identifier: '$id_scan_state'
Scan state at sub entry was '$id_scan_state_begin'
EOM
                    }
                    $id_scan_state = EMPTY_STRING;
                    $i             = $i_save;
                }
                last;
            }

            # Remember the starting index for progress check below
            my $i_start_loop = $i;

            $last_tok_is_blank = $tok_is_blank;
            if   ($tok_is_blank) { $tok_is_blank = undef }
            else                 { $i_save       = $i }

            $tok = $rtokens->[ ++$i ];

            # patch to make digraph :: if necessary
            if ( ( $tok eq ':' ) && ( $rtokens->[ $i + 1 ] eq ':' ) ) {
                $tok = '::';
                $i++;
            }

            $code->($self);

            # check for forward progress: a decrease in the index $i
            # implies that scanning has finished
            last if ( $i <= $i_start_loop );

        } ## end while ( $i < $max_token_index...)

        #-------------
        # Check result
        #-------------

        # Be sure a valid state is returned
        if ($id_scan_state) {

            if ( !$is_returnable_scan_state{$id_scan_state} ) {

                if ( $id_scan_state eq $scan_state_SPLIT ) {
                    $split_pretoken_flag = 1;
                }

                if ( $id_scan_state eq $scan_state_RPAREN ) {
                    $self->warning(
                        "Hit end of line while seeking ) to end prototype\n");
                }

                $id_scan_state = EMPTY_STRING;
            }

            # Patch: the deprecated variable $# does not combine with anything
            # on the next line.
            if ( $identifier eq '$#' ) { $id_scan_state = EMPTY_STRING }
        }

        # Be sure the token index is valid
        if ( $i < 0 ) { $i = 0 }

        # Be sure a token type is defined
        if ( !$type ) {

            if ($saw_type) {

                if ($saw_alpha) {

                  # The type without the -> should be the same as with the -> so
                  # that if they get separated we get the same bond strengths,
                  # etc.  See b1234
                    if (   $identifier =~ /^->/
                        && $last_nonblank_type eq 'w'
                        && substr( $identifier, 2, 1 ) =~ /^\w/ )
                    {
                        $type = 'w';
                    }
                    else { $type = 'i' }
                }
                elsif ( $identifier eq '->' ) {
                    $type = '->';
                }
                elsif (
                    ( length($identifier) > 1 )

                    # In something like '@$=' we have an identifier '@$'
                    # In something like '$${' we have type '$$' (and only
                    # part of an identifier)
                    && !( $identifier =~ /\$$/ && $tok eq '{' )
                    && $identifier ne 'sub '
                    && $identifier ne 'package '
                  )
                {
                    $type = 'i';
                }
                else { $type = 't' }
            }
            elsif ($saw_alpha) {

                # type 'w' includes anything without leading type info
                # ($,%,@,*) including something like abc::def::ghi
                $type = 'w';

                # Fix for b1337, if restarting scan after line break between
                # '->' or sigil and identifier name, use type 'i'
                if (   $id_scan_state_begin
                    && $identifier =~ /^([\$\%\@\*\&]|->)/ )
                {
                    $type = 'i';
                }
            }
            else {
                $type = EMPTY_STRING;
            }    # this can happen on a restart
        }

        # See if we formed an identifier...
        if ($identifier) {
            $tok = $identifier;
            if ($message) { $self->write_logfile_entry($message) }
        }

        # did not find an identifier, back  up
        else {
            $tok = $tok_begin;
            $i   = $i_begin;
        }

      RETURN:

        DEBUG_SCAN_ID && do {
            my ( $a, $b, $c ) = caller();
            print {*STDOUT}
"SCANID: called from $a $b $c with tok, i, state, identifier =$tok_begin, $i_begin, $id_scan_state_begin, $identifier_begin\n";
            print {*STDOUT}
"SCANID: returned with tok, i, state, identifier =$tok, $i, $id_scan_state, $identifier\n";
        };

        return (

            $i,
            $tok,
            $type,
            $id_scan_state,
            $identifier,
            $split_pretoken_flag
        );
    } ## end sub scan_complex_identifier
} ## end closure for sub scan_complex_identifier

{    ## closure for sub do_scan_sub

    my %warn_if_lexical;

    BEGIN {

        # lexical subs with these names can cause parsing errors in this version
        my @q = qw( m q qq qr qw qx s tr y );
        @warn_if_lexical{@q} = (1) x scalar(@q);
    } ## end BEGIN

    # saved package and subnames in case prototype is on separate line
    my ( $package_saved, $subname_saved );

    # initialize subname each time a new 'sub' keyword is encountered
    sub initialize_subname {
        $package_saved = EMPTY_STRING;
        $subname_saved = EMPTY_STRING;
        return;
    }

    use constant {
        SUB_CALL       => 1,
        PAREN_CALL     => 2,
        PROTOTYPE_CALL => 3,
    };

    sub do_scan_sub {

        my ( $self, $rcall_hash ) = @_;

        my $input_line      = $rcall_hash->{input_line};
        my $i               = $rcall_hash->{i};
        my $i_beg           = $rcall_hash->{i_beg};
        my $tok             = $rcall_hash->{tok};
        my $type            = $rcall_hash->{type};
        my $rtokens         = $rcall_hash->{rtokens};
        my $rtoken_map      = $rcall_hash->{rtoken_map};
        my $id_scan_state   = $rcall_hash->{id_scan_state};
        my $max_token_index = $rcall_hash->{max_token_index};

        # Parse a sub name and prototype.

        # At present there are three basic CALL TYPES which are
        # distinguished by the starting value of '$tok':
        # 1. $tok='sub', id_scan_state='sub'
        #    it is called with $i_beg equal to the index of the first nonblank
        #    token following a 'sub' token.
        # 2. $tok='(', id_scan_state='sub',
        #    it is called with $i_beg equal to the index of a '(' which may
        #    start a prototype.
        # 3. $tok='prototype', id_scan_state='prototype'
        #    it is called with $i_beg equal to the index of a '(' which is
        #    preceded by ': prototype' and has $id_scan_state eq 'prototype'

        # Examples:

        # A single type 1 call will get both the sub and prototype
        #   sub foo1 ( $$ ) { }
        #   ^

        # The subname will be obtained with a 'sub' call
        # The prototype on line 2 will be obtained with a '(' call
        #   sub foo1
        #   ^                    <---call type 1
        #     ( $$ ) { }
        #     ^                  <---call type 2

        # The subname will be obtained with a 'sub' call
        # The prototype will be obtained with a 'prototype' call
        #   sub foo1 ( $x, $y ) : prototype ( $$ ) { }
        #   ^ <---type 1                    ^ <---type 3

        # TODO: add future error checks to be sure we have a valid
        # sub name.  For example, 'sub &doit' is wrong.  Also, be sure
        # a name is given if and only if a non-anonymous sub is
        # appropriate.
        # USES GLOBAL VARS: $current_package, $last_nonblank_token,
        # $rsaw_function_definition,
        # $statement_type

        my $i_entry = $i;

        # Determine the CALL TYPE
        # 1=sub
        # 2=(
        # 3=prototype
        my $call_type =
            $tok eq 'prototype' ? PROTOTYPE_CALL
          : $tok eq '('         ? PAREN_CALL
          :                       SUB_CALL;

        $id_scan_state = EMPTY_STRING;  # normally we get everything in one call
        my $subname = $subname_saved;
        my $package = $package_saved;
        my $proto   = undef;
        my $attrs   = undef;
        my $match;

        my $pos_beg = $rtoken_map->[$i_beg];
        pos($input_line) = $pos_beg;

        # Look for the sub NAME if this is a SUB call
        if (
               $call_type == SUB_CALL
            && $input_line =~ m{\G\s*
        ((?:\w*(?:'|::))*)  # package - something that ends in :: or '
        (\w+)               # NAME    - required
        }gcx
          )
        {
            $match   = 1;
            $subname = $2;

            my $is_lexical_sub =
              $last_nonblank_type eq 'k' && $last_nonblank_token eq 'my';
            if ( $is_lexical_sub && $1 ) {
                $self->warning("'my' sub $subname cannot be in package '$1'\n");
                $is_lexical_sub = 0;
            }

            if ($is_lexical_sub) {

                # lexical subs use the block sequence number as a package name
                my $seqno =
                  $rcurrent_sequence_number->[BRACE]
                  [ $rcurrent_depth->[BRACE] ];
                $seqno   = 1 if ( !defined($seqno) );
                $package = $seqno;
                if ( $warn_if_lexical{$subname} ) {
                    $self->warning(
"'my' sub '$subname' matches a builtin name and may not be handled correctly in this perltidy version.\n"
                    );

                    # This may end badly, it is safest to block formatting
                    # For an example, see perl527/lexsub.t (issue c203)
                    $self->[_in_trouble_] = 1;
                }
            }
            else {
                $package = ( defined($1) && $1 ) ? $1 : $current_package;
                $package =~ s/\'/::/g;
                if ( $package =~ /^\:/ ) { $package = 'main' . $package }
                $package =~ s/::$//;
            }

            my $pos  = pos($input_line);
            my $numc = $pos - $pos_beg;
            $tok  = 'sub ' . substr( $input_line, $pos_beg, $numc );
            $type = 'S';    ## Fix for c250, was 'i';

            # remember the sub name in case another call is needed to
            # get the prototype
            $package_saved = $package;
            $subname_saved = $subname;
        }

        # Now look for PROTO ATTRS for all call types
        # Look for prototype/attributes which are usually on the same
        # line as the sub name but which might be on a separate line.
        # For example, we might have an anonymous sub with attributes,
        # or a prototype on a separate line from its sub name

        # NOTE: We only want to parse PROTOTYPES here. If we see anything that
        # does not look like a prototype, we assume it is a SIGNATURE and we
        # will stop and let the the standard tokenizer handle it.  In
        # particular, we stop if we see any nested parens, braces, or commas.
        # Also note, a valid prototype cannot contain any alphabetic character
        #  -- see https://perldoc.perl.org/perlsub
        # But it appears that an underscore is valid in a prototype, so the
        # regex below uses [A-Za-z] rather than \w
        # This is the old regex which has been replaced:
        # $input_line =~ m/\G(\s*\([^\)\(\}\{\,#]*\))?  # PROTO
        # Added '=' for issue c362
        my $saw_opening_paren = $input_line =~ /\G\s*\(/;
        if (
            $input_line =~ m{\G(\s*\([^\)\(\}\{\,#A-Za-z=]*\))?  # PROTO
            (\s*:)?                              # ATTRS leading ':'
            }gcx
            && ( $1 || $2 )
          )
        {
            $proto = $1;
            $attrs = $2;

            # Append the prototype to the starting token if it is 'sub' or
            # 'prototype'.  This is not necessary but for compatibility with
            # previous versions when the -csc flag is used:
            if ( $proto && ( $match || $call_type == PROTOTYPE_CALL ) ) {
                $tok .= $proto;
            }

            # If we just entered the sub at an opening paren on this call, not
            # a following :prototype, label it with the previous token.  This is
            # necessary to propagate the sub name to its opening block.
            elsif ( $call_type == PAREN_CALL ) {
                $tok = $last_nonblank_token;
            }
            else {
            }

            $match ||= 1;

            # Patch part #1 to fixes cases b994 and b1053:
            # Mark an anonymous sub keyword without prototype as type 'k', i.e.
            #    'sub : lvalue { ...'
            $type = 'S';    ## C250, was 'i';
            if ( $tok eq 'sub' && !$proto ) { $type = 'k' }
        }

        if ($match) {

            # ATTRS: if there are attributes, back up and let the ':' be
            # found later by the scanner.
            my $pos = pos($input_line);
            if ($attrs) {
                $pos -= length($attrs);
            }

            my $next_nonblank_token = $tok;

            # catch case of line with leading ATTR ':' after anonymous sub
            if ( $pos == $pos_beg && $tok eq ':' ) {
                $type = 'A';
                $self->[_in_attribute_list_] = 1;
            }

            # Otherwise, if we found a match we must convert back from
            # string position to the pre_token index for continued parsing.
            else {

                # I don't think an error flag can occur here ..but ?
                my $error;
                ( $i, $error ) = inverse_pretoken_map( $i, $pos, $rtoken_map,
                    $max_token_index );
                if ($error) { $self->warning("Possibly invalid sub\n") }

                # Patch part #2 to fixes cases b994 and b1053:
                # Do not let spaces be part of the token of an anonymous sub
                # keyword which we marked as type 'k' above...i.e. for
                # something like:
                #    'sub : lvalue { ...'
                # Back up and let it be parsed as a blank
                if (   $type eq 'k'
                    && $attrs
                    && $i > $i_entry
                    && substr( $rtokens->[$i], 0, 1 ) =~ m/\s/ )
                {
                    $i--;
                }

                # check for multiple definitions of a sub
                ( $next_nonblank_token, my $i_next_uu ) =
                  find_next_nonblank_token_on_this_line( $i, $rtokens,
                    $max_token_index );
            }

            if ( $next_nonblank_token =~ /^(\s*|#)$/ )
            {    # skip blank or side comment
                my ( $rpre_tokens, $rpre_types_uu ) =
                  $self->peek_ahead_for_n_nonblank_pre_tokens(1);
                if ( defined($rpre_tokens) && @{$rpre_tokens} ) {
                    $next_nonblank_token = $rpre_tokens->[0];
                }
                else {
                    $next_nonblank_token = '}';
                }
            }

            # See what's next...
            if ( $next_nonblank_token eq '{' ) {
                if ($subname) {

                    # Check for multiple definitions of a sub, but
                    # it is ok to have multiple sub BEGIN, etc,
                    # so we do not complain if name is all caps
                    if (   $rsaw_function_definition->{$subname}{$package}
                        && $subname !~ /^[A-Z]+$/ )
                    {
                        my $lno =
                          $rsaw_function_definition->{$subname}{$package};
                        if ( $package =~ /^\d/ ) {
                            $self->warning(
"already saw definition of lexical 'sub $subname' at line $lno\n"
                            );

                        }
                        else {
                            if ( !DEVEL_MODE ) {
                                $self->warning(
"already saw definition of 'sub $subname' in package '$package' at line $lno\n"
                                );
                            }
                        }
                    }
                    $rsaw_function_definition->{$subname}{$package} =
                      $self->[_last_line_number_];
                }
            }
            elsif ( $next_nonblank_token eq ';' ) {
            }
            elsif ( $next_nonblank_token eq '}' ) {
            }

            # ATTRS - if an attribute list follows, remember the name
            # of the sub so the next opening brace can be labeled.
            # Setting 'statement_type' causes any ':'s to introduce
            # attributes.
            elsif ( $next_nonblank_token eq ':' ) {
                if ( $call_type == SUB_CALL ) {
                    $statement_type =
                      substr( $tok, 0, 3 ) eq 'sub' ? $tok : 'sub';
                }
            }

            # if we stopped before an open paren ...
            elsif ( $next_nonblank_token eq '(' ) {

                # If we DID NOT see this paren above then it must be on the
                # next line so we will set a flag to come back here and see if
                # it is a PROTOTYPE

                # Otherwise, we assume it is a SIGNATURE rather than a
                # PROTOTYPE and let the normal tokenizer handle it as a list
                if ( !$saw_opening_paren ) {
                    $id_scan_state = 'sub';    # we must come back to get proto
                }
                if ( $call_type == SUB_CALL ) {
                    $statement_type =
                      substr( $tok, 0, 3 ) eq 'sub' ? $tok : 'sub';
                }
            }

            # something else..
            elsif ($next_nonblank_token) {

                if ( $rcall_hash->{tok} eq 'method' && $call_type == SUB_CALL )
                {
                    # For a method call, silently ignore this error (rt145706)
                    # to avoid needless warnings. Example which can produce it:
                    #     test(method Pack (), "method");

                    # TODO: scan for use feature 'class' and:
                    # - if we saw 'use feature 'class' then issue the warning.
                    # - if we did not see use feature 'class' then issue the
                    #   warning and suggest turning off --use-feature=class
                }
                else {
                    $subname = EMPTY_STRING unless defined($subname);
                    $self->warning(
"expecting ':' or ';' or '{' after definition or declaration of sub '$subname' but saw '$next_nonblank_token'\n"
                    );
                }
            }

            # EOF technically ok
            else {
            }

            check_prototype( $proto, $package, $subname );
        }

        # no match to either sub name or prototype, but line not blank
        else {

        }
        return ( $i, $tok, $type, $id_scan_state );
    } ## end sub do_scan_sub
}

#########################################################################
# Tokenizer utility routines which may use CONSTANTS but no other GLOBALS
#########################################################################

sub find_next_nonblank_token {
    my ( $self, $i, $rtokens, $max_token_index ) = @_;

    # Returns the next nonblank token after the token at index $i
    # To skip past a side comment, and any subsequent block comments
    # and blank lines, call with i=$max_token_index

    # Skip any ending blank (fix c258). It would be cleaner if caller passed
    # $rtoken_map, so we could check for type 'b', and avoid a regex test, but
    # benchmarking shows that this test does not take significant time.  So
    # that would be a nice update but not essential.  Also note that ending
    # blanks will not occur for text previously processed by perltidy.
    if (   $i == $max_token_index - 1
        && $rtokens->[$max_token_index] =~ /^\s+$/ )
    {
        $i++;
    }

    if ( $i >= $max_token_index ) {
        if ( !peeked_ahead() ) {
            peeked_ahead(1);
            $self->peek_ahead_for_nonblank_token( $rtokens, $max_token_index );
        }
    }

    my $next_nonblank_token = $rtokens->[ ++$i ];

    # Any more tokens?
    return ( SPACE, $i )
      if ( !defined($next_nonblank_token) || !length($next_nonblank_token) );

    # Skip over whitespace
    my $ord = ord( substr( $next_nonblank_token, 0, 1 ) );
    if (

        ( $ord <= ORD_PRINTABLE_MIN || $ord >= ORD_PRINTABLE_MAX )

        # Quick test for ascii space or tab
        && (
            ( $ord == ORD_SPACE || $ord == ORD_TAB )

            # Slow test to for something else identified as whitespace
            || $next_nonblank_token =~ /^\s+$/
        )
      )
    {
        $next_nonblank_token = $rtokens->[ ++$i ];
        return ( SPACE, $i ) unless defined($next_nonblank_token);
    }

    # We should be at a nonblank now
    return ( $next_nonblank_token, $i );

} ## end sub find_next_nonblank_token

sub find_next_noncomment_token {
    my ( $self, $i, $rtokens, $max_token_index ) = @_;

    # Given the current character position, look ahead past any comments
    # and blank lines and return the next token, including digraphs and
    # trigraphs.

    my ( $next_nonblank_token, $i_next ) =
      $self->find_next_nonblank_token( $i, $rtokens, $max_token_index );

    # skip past any side comment
    if ( $next_nonblank_token eq '#' ) {
        ( $next_nonblank_token, $i_next ) =
          $self->find_next_nonblank_token( $i_next, $rtokens,
            $max_token_index );
    }

    # check for a digraph
    if (   $next_nonblank_token
        && $next_nonblank_token ne SPACE
        && defined( $rtokens->[ $i_next + 1 ] ) )
    {
        my $test2 = $next_nonblank_token . $rtokens->[ $i_next + 1 ];
        if ( $is_digraph{$test2} ) {
            $next_nonblank_token = $test2;
            $i_next              = $i_next + 1;

            # check for a trigraph
            if ( defined( $rtokens->[ $i_next + 1 ] ) ) {
                my $test3 = $next_nonblank_token . $rtokens->[ $i_next + 1 ];
                if ( $is_trigraph{$test3} ) {
                    $next_nonblank_token = $test3;
                    $i_next              = $i_next + 1;
                }
            }
        }
    }

    return ( $next_nonblank_token, $i_next );
} ## end sub find_next_noncomment_token

sub is_possible_numerator {

    my ( $self, $i, $rtokens, $max_token_index ) = @_;

    # Look at the next non-comment character and decide if it could be a
    # numerator. Returns the following code:
    #   -1 - division not possible
    #    0 - can't tell if division possible
    #    1 - division possible
    #    2 - division probable: number follows
    #    3 - division very probable: number and one of ; ] } follow
    #    4 - is division, not pattern: number and ) follow

    my $divide_possible_code = 0;

    my $next_token = $rtokens->[ $i + 1 ];
    if ( $next_token eq '=' ) { $i++; }    # handle /=
    my ( $next_nonblank_token, $i_next ) =
      $self->find_next_nonblank_token( $i, $rtokens, $max_token_index );

    if ( $next_nonblank_token eq '#' ) {
        ( $next_nonblank_token, $i_next ) =
          $self->find_next_nonblank_token( $max_token_index, $rtokens,
            $max_token_index );
    }

    if ( $next_nonblank_token =~ / [ \( \$ \w \. \@ ] /x ) {
        $divide_possible_code = 1;

        # look ahead one more token for some common patterns, such as
        #   pi/2)   pi/2;   pi/2}
        if ( $next_nonblank_token =~ /^\d/ ) {
            my ( $next_next_nonblank_token, $i_next_next_uu ) =
              $self->find_next_nonblank_token( $i_next, $rtokens,
                $max_token_index );
            if ( $next_next_nonblank_token eq ')' ) {
                $divide_possible_code = 4;
            }
            elsif ($next_next_nonblank_token eq ';'
                || $next_next_nonblank_token eq ']'
                || $next_next_nonblank_token eq '}' )
            {
                $divide_possible_code = 3;
            }
            else {
                $divide_possible_code = 2;
            }
        }
    }
    elsif ( $next_nonblank_token =~ /^\s*$/ ) {
        $divide_possible_code = 0;
    }
    else {
        $divide_possible_code = -1;
    }

    return $divide_possible_code;
} ## end sub is_possible_numerator

{    ## closure for sub pattern_expected
    my %pattern_test;

    BEGIN {

        # List of tokens which may follow a pattern.  Note that we will not
        # have formed digraphs at this point, so we will see '&' instead of
        # '&&' and '|' instead of '||'

        # /(\)|\}|\;|\&\&|\|\||and|or|while|if|unless)/
        my @q = qw( & && | || ? : + - * and or while if unless );
        push @q, ')', '}', ']', '>', ',', ';';
        @pattern_test{@q} = (1) x scalar(@q);
    } ## end BEGIN

    sub pattern_expected {

        my ( $self, $i, $rtokens, $max_token_index ) = @_;

        # This a filter for a possible pattern.
        # It looks at the token after a possible pattern and tries to
        # determine if that token could end a pattern.
        # returns -
        #   1 - yes
        #   0 - can't tell
        #  -1 - no
        my $is_pattern = 0;

        my $next_token = $rtokens->[ $i + 1 ];

        # skip a possible quote modifier
        my $possible_modifiers = $quote_modifiers{'m'};
        if ( $next_token =~ /^$possible_modifiers/ ) {
            $i++;
        }

        my ( $next_nonblank_token, $i_next_uu ) =
          $self->find_next_nonblank_token( $i, $rtokens, $max_token_index );

        if ( $pattern_test{$next_nonblank_token} ) {
            $is_pattern = 1;
        }
        else {

            # Added '#' to fix issue c044
            if (   $next_nonblank_token =~ /^\s*$/
                || $next_nonblank_token eq '#' )
            {
                $is_pattern = 0;
            }
            else {
                $is_pattern = -1;
            }
        }
        return $is_pattern;
    } ## end sub pattern_expected
}

sub find_next_nonblank_token_on_this_line {
    my ( $i, $rtokens, $max_token_index ) = @_;
    my $next_nonblank_token;

    if ( $i < $max_token_index ) {
        $next_nonblank_token = $rtokens->[ ++$i ];

        if ( $next_nonblank_token =~ /^\s*$/ ) {

            if ( $i < $max_token_index ) {
                $next_nonblank_token = $rtokens->[ ++$i ];
            }
        }
    }
    else {
        $next_nonblank_token = EMPTY_STRING;
    }
    return ( $next_nonblank_token, $i );
} ## end sub find_next_nonblank_token_on_this_line

sub find_angle_operator_termination {

    my ( $self, $input_line, $i_beg, $rtoken_map, $expecting, $max_token_index )
      = @_;

    # We are looking at a '<' and want to know if it is an angle operator.
    # Return:
    #   $i = pretoken index of ending '>' if found, current $i otherwise
    #   $type = 'Q' if found, '>' otherwise

    my $i    = $i_beg;
    my $type = '<';
    pos($input_line) = 1 + $rtoken_map->[$i];

    my $filter;

    my $expecting_TERM = $expecting == TERM;

    # we just have to find the next '>' if a term is expected
    if ($expecting_TERM) { $filter = '[\>]' }

    # we have to guess if we don't know what is expected
    elsif ( $expecting == UNKNOWN ) { $filter = '[\>\;\=\#\|\<]' }

    # shouldn't happen - we shouldn't be here if operator is expected
    else {
        if (DEVEL_MODE) {
            $self->Fault(<<EOM);
Bad call to find_angle_operator_termination
EOM
        }
        return ( $i, $type );
    }

    # To illustrate what we might be looking at, in case we are
    # guessing, here are some examples of valid angle operators
    # (or file globs):
    #  <tmp_imp/*>
    #  <FH>
    #  <$fh>
    #  <*.c *.h>
    #  <_>
    #  <jskdfjskdfj* op/* jskdjfjkosvk*> ( glob.t)
    #  <${PREFIX}*img*.$IMAGE_TYPE>
    #  <img*.$IMAGE_TYPE>
    #  <Timg*.$IMAGE_TYPE>
    #  <$LATEX2HTMLVERSIONS${dd}html[1-9].[0-9].pl>
    #
    # Here are some examples of lines which do not have angle operators:
    #  return unless $self->[2]++ < $#{$self->[1]};
    #  < 2  || @$t >
    #
    # the following line from dlister.pl caused trouble:
    #  print'~'x79,"\n",$D<1024?"0.$D":$D>>10,"K, $C files\n\n\n";
    #
    # If the '<' starts an angle operator, it must end on this line and
    # it must not have certain characters like ';' and '=' in it.  I use
    # this to limit the testing.  This filter should be improved if
    # possible.

    if ( $input_line =~ /($filter)/g ) {

        if ( $1 eq '>' ) {

            # We MAY have found an angle operator termination if we get
            # here, but we need to do more to be sure we haven't been
            # fooled.
            my $pos = pos($input_line);

            my $pos_beg = $rtoken_map->[$i];
            my $str     = substr( $input_line, $pos_beg, ( $pos - $pos_beg ) );

            # Test for '<' after possible filehandle, issue c103
            # print $fh <>;          # syntax error
            # print $fh <DATA>;      # ok
            # print $fh < DATA>;     # syntax error at '>'
            # print STDERR < DATA>;  # ok, prints word 'DATA'
            # print BLABLA <DATA>;   # ok; does nothing unless BLABLA is defined
            if ( $last_nonblank_type eq 'Z' ) {

                # $str includes brackets; something like '<DATA>'
                if (   substr( $last_nonblank_token, 0, 1 ) !~ /[A-Za-z_]/
                    && substr( $str, 1, 1 ) !~ /[A-Za-z_]/ )
                {
                    return ( $i, $type );
                }
            }

            # Reject if the closing '>' follows a '-' as in:
            # if ( VERSION < 5.009 && $op-> name eq 'assign' ) { }
            if ( $expecting eq UNKNOWN ) {
                my $check = substr( $input_line, $pos - 2, 1 );
                if ( $check eq '-' ) {
                    return ( $i, $type );
                }
            }

            ######################################debug#####
            #$self->write_diagnostics( "ANGLE? :$str\n");
            #print "ANGLE: found $1 at pos=$pos str=$str check=$check\n";
            ######################################debug#####
            $type = 'Q';
            my $error;
            ( $i, $error ) =
              inverse_pretoken_map( $i, $pos, $rtoken_map, $max_token_index );

            # It may be possible that a quote ends midway in a pretoken.
            # If this happens, it may be necessary to split the pretoken.
            if ($error) {
                if (DEVEL_MODE) {
                    $self->Fault(<<EOM);
unexpected error condition returned by inverse_pretoken_map
EOM
                }
                $self->warning(
                    "Possible tokinization error..please check this line\n");
            }

            # Check for accidental formatting of a markup language doc...
            # Formatting will be skipped if we set _html_tag_count_ and
            # also set a warning of any kind.
            my $is_html_tag;
            my $is_first_string =
              $i_beg == 0 && $self->[_last_line_number_] == 1;

            # html comment '<!...' of any type
            if ( $str =~ /^<\s*!/ ) {
                $is_html_tag = 1;
                if ($is_first_string) {
                    $self->warning(
"looks like a markup language, continuing error checks\n"
                    );
                }
            }

            # html end tag, something like </h1>
            elsif ( $str =~ /^<\s*\/\w+\s*>$/ ) {
                $is_html_tag = 1;
            }

            # xml prolog?
            elsif ( $str =~ /^<\?xml\s.*\?>$/i && $is_first_string ) {
                $is_html_tag = 1;
                $self->warning(
                    "looks like a markup language, continuing error checks\n");
            }
            else {
                ## doesn't look like a markup tag
            }

            if ($is_html_tag) {
                $self->[_html_tag_count_]++;
            }

            # count blanks on inside of brackets
            my $blank_count = 0;
            $blank_count++ if ( $str =~ /<\s+/ );
            $blank_count++ if ( $str =~ /\s+>/ );

            # Now let's see where we stand....
            # OK if math op not possible
            if ($expecting_TERM) {
            }

            elsif ($is_html_tag) {
            }

            # OK if there are no more than 2 non-blank pre-tokens inside
            # (not possible to write 2 token math between < and >)
            # This catches most common cases
            elsif ( $i <= $i_beg + 3 + $blank_count ) {

                # No longer any need to document this common case
                ## $self->write_diagnostics("ANGLE(1 or 2 tokens): $str\n");
            }

            # OK if there is some kind of identifier inside
            #   print $fh <tvg::INPUT>;
            elsif ( $str =~ /^<\s*\$?(\w|::|\s)+\s*>$/ ) {
                $self->write_diagnostics("ANGLE (contains identifier): $str\n");
            }

            # Not sure..
            else {

                # Let's try a Brace Test: any braces inside must balance
                my $br = $str =~ tr/\{/{/ - $str =~ tr/\}/}/;
                my $sb = $str =~ tr/\[/[/ - $str =~ tr/\]/]/;
                my $pr = $str =~ tr/\(/(/ - $str =~ tr/\)/)/;

                # if braces do not balance - not angle operator
                if ( $br || $sb || $pr ) {
                    $i    = $i_beg;
                    $type = '<';
                    $self->write_diagnostics(
                        "NOT ANGLE (BRACE={$br ($pr [$sb ):$str\n");
                }

                # we should keep doing more checks here...to be continued
                # Tentatively accepting this as a valid angle operator.
                # There are lots more things that can be checked.
                else {
                    $self->write_diagnostics(
                        "ANGLE-Guessing yes: $str expecting=$expecting\n");
                    $self->write_logfile_entry(
                        "Guessing angle operator here: $str\n");
                }
            }
        }

        # didn't find ending >
        else {
            if ($expecting_TERM) {
                $self->warning("No ending > for angle operator\n");
            }
        }
    }
    return ( $i, $type );
} ## end sub find_angle_operator_termination

sub scan_number_do {

    my ( $self, $input_line, $i, $rtoken_map, $input_type, $max_token_index ) =
      @_;

    #  Scan a number in any of the formats that Perl accepts
    #  Underbars (_) are allowed in decimal numbers.
    #  Given:
    #      $input_line  - the string to scan
    #      $i           - pre_token index to start scanning
    #    $rtoken_map    - reference to the pre_token map giving starting
    #                    character position in $input_line of token $i
    #  Return:
    #    $i            - last pre_token index of the number just scanned
    #    $type         - the token type ('v' or 'n')
    #    number        - the number (characters); or undef if not a number

    my $pos_beg = $rtoken_map->[$i];
    my $pos;
    ##my $i_begin = $i;
    my $number = undef;
    my $type   = $input_type;

    my $first_char = substr( $input_line, $pos_beg, 1 );

    # Look for bad starting characters; Shouldn't happen..
    if ( $first_char !~ /[\d\.\+\-Ee]/ ) {
        if (DEVEL_MODE) {
            $self->Fault(<<EOM);
Program bug - scan_number given bad first character = '$first_char'
EOM
        }
        return ( $i, $type, $number );
    }

    # handle v-string without leading 'v' character ('Two Dot' rule)
    # (vstring.t)
    # Here is the format prior to including underscores:
    ## if ( $input_line =~ /\G((\d+)?\.\d+(\.\d+)+)/g ) {
    pos($input_line) = $pos_beg;
    if ( $input_line =~ /\G((\d[_\d]*)?\.[\d_]+(\.[\d_]+)+)/g ) {
        $pos = pos($input_line);
        my $numc = $pos - $pos_beg;
        $number = substr( $input_line, $pos_beg, $numc );
        $type   = 'v';
    }

    # handle octal, hex, binary
    if ( !defined($number) ) {
        pos($input_line) = $pos_beg;

        # Perl 5.22 added floating point literals, like '0x0.b17217f7d1cf78p0'
        # For reference, the format prior to hex floating point is:
        #   /\G[+-]?0(([xX][0-9a-fA-F_]+)|([0-7_]+)|([bB][01_]+))/g )
        #             (hex)               (octal)   (binary)
        if (
            $input_line =~ m{

            \G[+-]?0(                   # leading [signed] 0

           # a hex float, i.e. '0x0.b17217f7d1cf78p0'
           ([xX][0-9a-fA-F_]*            # X and optional leading digits
           (\.([0-9a-fA-F][0-9a-fA-F_]*)?)?   # optional decimal and fraction
           [Pp][+-]?[0-9a-fA-F]          # REQUIRED exponent with digit
           [0-9a-fA-F_]*)                # optional Additional exponent digits

           # or hex integer
           |([xX][0-9a-fA-F_]+)

           # or octal fraction
           |([oO]?[0-7_]+          # string of octal digits
           (\.([0-7][0-7_]*)?)?    # optional decimal and fraction
           [Pp][+-]?[0-7]          # REQUIRED exponent, no underscore
           [0-7_]*)                # Additional exponent digits with underscores

           # or octal integer
           |([oO]?[0-7_]+)         # string of octal digits

           # or a binary float
           |([bB][01_]*            # 'b' with string of binary digits
           (\.([01][01_]*)?)?      # optional decimal and fraction
           [Pp][+-]?[01]           # Required exponent indicator, no underscore
           [01_]*)                 # additional exponent bits

           # or binary integer
           |([bB][01_]+)           # 'b' with string of binary digits

           )}gx
          )
        {
            $pos = pos($input_line);
            my $numc = $pos - $pos_beg;
            $number = substr( $input_line, $pos_beg, $numc );
            $type   = 'n';
        }
    }

    # handle decimal
    if ( !defined($number) ) {
        pos($input_line) = $pos_beg;

        if ( $input_line =~ /\G([+-]?[\d_]*(\.[\d_]*)?([Ee][+-]?(\d+))?)/g ) {
            $pos = pos($input_line);

            # watch out for things like 0..40 which would give 0. by this;
            if (   ( substr( $input_line, $pos - 1, 1 ) eq '.' )
                && ( substr( $input_line, $pos, 1 ) eq '.' ) )
            {
                $pos--;
            }
            my $numc = $pos - $pos_beg;
            $number = substr( $input_line, $pos_beg, $numc );
            $type   = 'n';
        }
    }

    # filter out non-numbers like e + - . e2  .e3 +e6
    # the rule: at least one digit, and any 'e' must be preceded by a digit
    if (
        $number !~ /\d/    # no digits
        || (   $number =~ /^(.*)[eE]/
            && $1 !~ /\d/ )    # or no digits before the 'e'
      )
    {
        $number = undef;
        $type   = $input_type;
        return ( $i, $type, $number );
    }

    # Found a number; now we must convert back from character position
    # to pre_token index. An error here implies user syntax error.
    # An example would be an invalid octal number like '009'.
    my $error;
    ( $i, $error ) =
      inverse_pretoken_map( $i, $pos, $rtoken_map, $max_token_index );
    if ($error) { $self->warning("Possibly invalid number\n") }

    return ( $i, $type, $number );
} ## end sub scan_number_do

sub inverse_pretoken_map {

    # Starting with the current pre_token index $i, scan forward until
    # finding the index of the next pre_token whose position is $pos.
    my ( $i, $pos, $rtoken_map, $max_token_index ) = @_;
    my $error = 0;

    while ( ++$i <= $max_token_index ) {

        if ( $pos <= $rtoken_map->[$i] ) {

            # Let the calling routine handle errors in which we do not
            # land on a pre-token boundary.  It can happen by running
            # perltidy on some non-perl scripts, for example.
            if ( $pos < $rtoken_map->[$i] ) { $error = 1 }
            $i--;
            last;
        }
    } ## end while ( ++$i <= $max_token_index)
    return ( $i, $error );
} ## end sub inverse_pretoken_map

sub find_here_doc {

    my (

        $self,

        $expecting,
        $i,
        $rtokens,
        $rtoken_type,
        $rtoken_map_uu,
        $max_token_index

    ) = @_;

    # Find the target of a here document, if any
    # Given:
    #   $i - token index of the second < of <<
    #   ($i must be less than the last token index if this is called)
    # Return:
    #   $found_target = 0 didn't find target; =1 found target
    #   HERE_TARGET - the target string (may be empty string)
    #   $i - unchanged if not here doc,
    #    or index of the last token of the here target
    #   $saw_error - flag noting unbalanced quote on here target
    my $ibeg                 = $i;
    my $found_target         = 0;
    my $here_doc_target      = EMPTY_STRING;
    my $here_quote_character = EMPTY_STRING;
    my $saw_error            = 0;
    my ( $next_nonblank_token, $i_next_nonblank, $next_token );
    $next_token = $rtokens->[ $i + 1 ];

    # perl allows a backslash before the target string (heredoc.t)
    my $backslash = 0;
    if ( $next_token eq BACKSLASH ) {
        $backslash  = 1;
        $next_token = $rtokens->[ $i + 2 ];
    }

    ( $next_nonblank_token, $i_next_nonblank ) =
      find_next_nonblank_token_on_this_line( $i, $rtokens, $max_token_index );

    if ( $next_nonblank_token =~ /[\'\"\`]/ ) {

        my $in_quote    = 1;
        my $quote_depth = 0;
        my $quote_pos   = 0;
        my $quoted_string;

        (

            $i,
            $in_quote,
            $here_quote_character,
            $quote_pos,
            $quote_depth,
            $quoted_string
          )
          = $self->follow_quoted_string(

            $i_next_nonblank,
            $in_quote,
            $rtokens,
            $rtoken_type,
            $here_quote_character,
            $quote_pos,
            $quote_depth,
            $max_token_index
          );

        if ($in_quote) {    # didn't find end of quote, so no target found
            $i = $ibeg;
            if ( $expecting == TERM ) {
                $self->warning(
"Did not find here-doc string terminator ($here_quote_character) before end of line \n"
                );
                $saw_error = 1;
            }
        }
        else {              # found ending quote
            $found_target = 1;

            my $tokj;
            foreach my $j ( $i_next_nonblank + 1 .. $i - 1 ) {
                $tokj = $rtokens->[$j];

                # we have to remove any backslash before the quote character
                # so that the here-doc-target exactly matches this string
                next
                  if ( $tokj eq "\\"
                    && $j < $i - 1
                    && $rtokens->[ $j + 1 ] eq $here_quote_character );
                $here_doc_target .= $tokj;
            }
        }
    }

    elsif ( ( $next_token =~ /^\s*$/ ) and ( $expecting == TERM ) ) {
        $found_target = 1;
        $self->write_logfile_entry(
            "found blank here-target after <<; suggest using \"\"\n");
        $i = $ibeg;
    }
    elsif ( $next_token =~ /^\w/ ) {    # simple bareword or integer after <<

        my $here_doc_expected;
        if ( $expecting == UNKNOWN ) {
            $here_doc_expected = $self->guess_if_here_doc($next_token);
        }
        else {
            $here_doc_expected = 1;
        }

        if ($here_doc_expected) {
            $found_target    = 1;
            $here_doc_target = $next_token;
            $i               = $ibeg + 1;
        }

    }
    else {

        if ( $expecting == TERM ) {
            $found_target = 1;
            $self->write_logfile_entry("Note: bare here-doc operator <<\n");
        }
        else {
            $i = $ibeg;
        }
    }

    # patch to neglect any prepended backslash
    if ( $found_target && $backslash ) { $i++ }

    return ( $found_target, $here_doc_target, $here_quote_character, $i,
        $saw_error );
} ## end sub find_here_doc

sub do_quote {

    my (

        $self,

        $i,
        $in_quote,
        $quote_character,
        $quote_pos,
        $quote_depth,
        $quoted_string_1,
        $quoted_string_2,
        $rtokens,
        $rtoken_type,
        $rtoken_map_uu,
        $max_token_index,

    ) = @_;

    # Follow (or continue following) quoted string(s)
    # $in_quote = return code:
    #   0 - ok, found end
    #   1 - still must find end of quote whose target is $quote_character
    #   2 - still looking for end of first of two quotes
    #
    # Returns updated strings:
    #  $quoted_string_1 = quoted string seen while in_quote=1
    #  $quoted_string_2 = quoted string seen while in_quote=2

    my $quoted_string;
    if ( $in_quote == 2 ) {    # two quotes/quoted_string_1s to follow
        my $ibeg = $i;
        (

            $i,
            $in_quote,
            $quote_character,
            $quote_pos,
            $quote_depth,
            $quoted_string
          )
          = $self->follow_quoted_string(

            $ibeg,
            $in_quote,
            $rtokens,
            $rtoken_type,
            $quote_character,
            $quote_pos,
            $quote_depth,
            $max_token_index
          );
        $quoted_string_2 .= $quoted_string;
        if ( $in_quote == 1 ) {
            if ( $quote_character =~ /[\{\[\<\(]/ ) { $i++; }
            $quote_character = EMPTY_STRING;
        }
        else {
            $quoted_string_2 .= "\n";
        }
    }

    if ( $in_quote == 1 ) {    # one (more) quote to follow
        my $ibeg = $i;
        (

            $i,
            $in_quote,
            $quote_character,
            $quote_pos,
            $quote_depth,
            $quoted_string
          )
          = $self->follow_quoted_string(

            $ibeg,
            $in_quote,
            $rtokens,
            $rtoken_type,
            $quote_character,
            $quote_pos,
            $quote_depth,
            $max_token_index
          );
        $quoted_string_1 .= $quoted_string;
        if ( $in_quote == 1 ) {
            $quoted_string_1 .= "\n";
        }
    }
    return (

        $i,
        $in_quote,
        $quote_character,
        $quote_pos,
        $quote_depth,
        $quoted_string_1,
        $quoted_string_2,

    );
} ## end sub do_quote

# Some possible non-word quote delimiters, for preliminary checking
my %is_punct_char;

BEGIN {

    my @q = qw# / " ' { } ( ) [ ] < > ; + - * | % ! x ~ = ? : . ^ & #;
    push @q, '#';
    push @q, ',';
    @is_punct_char{@q} = (1) x scalar(@q);
}

sub follow_quoted_string {

    my (

        $self,

        $i_beg,
        $in_quote,
        $rtokens,
        $rtoken_type,
        $beginning_tok,
        $quote_pos,
        $quote_depth,
        $max_token_index,

    ) = @_;

    # Scan for a specific token, skipping escaped characters.
    # If the quote character is blank, use the first non-blank character.
    # Given:
    #   $rtokens = reference to the array of tokens
    #   $i = the token index of the first character to search
    #   $in_quote = number of quoted strings being followed
    #   $beginning_tok = the starting quote character
    #   $quote_pos = index to check next for alphanumeric delimiter
    # Return:
    #   $i = the token index of the ending quote character
    #   $in_quote = decremented if found end, unchanged if not
    #   $beginning_tok = the starting quote character
    #   $quote_pos = index to check next for alphanumeric delimiter
    #   $quote_depth = nesting depth, since delimiters '{ ( [ <' can be nested.
    #   $quoted_string = the text of the quote (without quotation tokens)
    my ( $tok, $end_tok );
    my $i             = $i_beg - 1;
    my $quoted_string = EMPTY_STRING;

    0 && do {
        print {*STDOUT}
"QUOTE entering with quote_pos = $quote_pos i=$i beginning_tok =$beginning_tok\n";
    };

    # for a non-blank token, get the corresponding end token
    if (
        $is_punct_char{$beginning_tok}
        || ( length($beginning_tok)
            && $beginning_tok !~ /^\s+$/ )
      )
    {
        $end_tok =
            $matching_end_token{$beginning_tok}
          ? $matching_end_token{$beginning_tok}
          : $beginning_tok;
    }

    # for a blank token, find and use the first non-blank one
    else {
        my $allow_quote_comments = ( $i < 0 ) ? 1 : 0; # i<0 means we saw a <cr>

        while ( $i < $max_token_index ) {
            $tok = $rtokens->[ ++$i ];

            if ( $rtoken_type->[$i] ne 'b' ) {

                if ( ( $tok eq '#' ) && ($allow_quote_comments) ) {
                    $i = $max_token_index;
                }
                else {

                    if ( length($tok) > 1 ) {
                        if ( $quote_pos <= 0 ) { $quote_pos = 1 }
                        $beginning_tok = substr( $tok, $quote_pos - 1, 1 );
                    }
                    else {
                        $beginning_tok = $tok;
                        $quote_pos     = 0;
                    }
                    $end_tok =
                        $matching_end_token{$beginning_tok}
                      ? $matching_end_token{$beginning_tok}
                      : $beginning_tok;
                    $quote_depth = 1;
                    last;
                }
            }
            else {
                $allow_quote_comments = 1;
            }
        } ## end while ( $i < $max_token_index)
    }

    # There are two different loops which search for the ending quote
    # character.  In the rare case of an alphanumeric quote delimiter, we
    # have to look through alphanumeric tokens character-by-character, since
    # the pre-tokenization process combines multiple alphanumeric
    # characters, whereas for a non-alphanumeric delimiter, only tokens of
    # length 1 can match.

    #----------------------------------------------------------------
    # Case 1 (rare): loop for case of alphanumeric quote delimiter..
    # "quote_pos" is the position the current word to begin searching
    #----------------------------------------------------------------
    if ( !$is_punct_char{$beginning_tok} && $beginning_tok =~ /\w/ ) {

        # Note this because it is not recommended practice except
        # for obfuscated perl contests
        if ( $in_quote == 1 ) {
            $self->write_logfile_entry(
                "Note: alphanumeric quote delimiter ($beginning_tok) \n");
        }

        # Note: changed < to <= here to fix c109. Relying on extra end blanks.
        while ( $i <= $max_token_index ) {

            if ( $quote_pos == 0 || ( $i < 0 ) ) {
                $tok = $rtokens->[ ++$i ];

                if ( $tok eq BACKSLASH ) {

                    # retain backslash unless it hides the end token
                    $quoted_string .= $tok
                      unless ( $rtokens->[ $i + 1 ] eq $end_tok );
                    $quote_pos++;
                    last if ( $i >= $max_token_index );
                    $tok = $rtokens->[ ++$i ];
                }
            }
            my $old_pos = $quote_pos;

            $quote_pos = 1 + index( $tok, $end_tok, $quote_pos );

            if ( $quote_pos > 0 ) {

                $quoted_string .=
                  substr( $tok, $old_pos, $quote_pos - $old_pos - 1 );

                # NOTE: any quote modifiers will be at the end of '$tok'. If we
                # wanted to check them, this is the place to get them.  But
                # this quote form is rarely used in practice, so it isn't
                # worthwhile.

                $quote_depth--;

                if ( $quote_depth == 0 ) {
                    $in_quote--;
                    last;
                }
            }
            else {
                if ( $old_pos <= length($tok) ) {
                    $quoted_string .= substr( $tok, $old_pos );
                }
            }
        } ## end while ( $i <= $max_token_index)
    }

    #-----------------------------------------------------------------------
    # Case 2 (normal): loop for case of a non-alphanumeric quote delimiter..
    #-----------------------------------------------------------------------
    else {

        while ( $i < $max_token_index ) {
            $tok = $rtokens->[ ++$i ];

            if ( $tok eq $end_tok ) {
                $quote_depth--;

                if ( $quote_depth == 0 ) {
                    $in_quote--;
                    last;
                }
            }
            elsif ( $tok eq $beginning_tok ) {
                $quote_depth++;
            }
            elsif ( $tok eq BACKSLASH ) {

                # retain backslash unless it hides the beginning or end token
                $tok = $rtokens->[ ++$i ];
                $quoted_string .= BACKSLASH
                  if ( $tok ne $end_tok && $tok ne $beginning_tok );
            }
            else {
                ## nothing special
            }
            $quoted_string .= $tok;
        } ## end while ( $i < $max_token_index)
    }
    if ( $i > $max_token_index ) { $i = $max_token_index }
    return (

        $i,
        $in_quote,
        $beginning_tok,
        $quote_pos,
        $quote_depth,
        $quoted_string,

    );
} ## end sub follow_quoted_string

sub indicate_error {
    my ( $self, $msg, $line_number, $input_line, $pos, $caret ) = @_;

    # write input line and line with carat's showing where error was detected
    $self->interrupt_logfile();
    $self->warning($msg);
    $self->write_error_indicator_pair( $line_number, $input_line, $pos,
        $caret );
    $self->resume_logfile();
    return;
} ## end sub indicate_error

sub write_error_indicator_pair {
    my ( $self, $line_number, $input_line, $pos, $caret ) = @_;
    my ( $offset, $numbered_line, $underline ) =
      make_numbered_line( $line_number, $input_line, $pos );
    $underline = write_on_underline( $underline, $pos - $offset, $caret );
    $self->warning( $numbered_line . "\n" );
    $underline =~ s/\s+$//;
    $self->warning( $underline . "\n" );
    return;
} ## end sub write_error_indicator_pair

sub make_numbered_line {

    my ( $lineno, $str, $pos ) = @_;

    #  Given:
    #     $lineno=line number
    #     $str = an input line
    #     $pos = character position of interest
    # Create a string not longer than 80 characters of the form:
    #     $lineno: sub_string
    # such that the sub_string of $str contains the position of interest
    #
    #  Here is an example of what we want, in this case we add trailing
    #  '...' because the line is long.
    #
    # 2: (One of QAML 2.0's authors is a member of the World Wide Web Con ...
    #
    #  Here is another example, this time in which we used leading '...'
    #  because of excessive length:
    #
    # 2: ... er of the World Wide Web Consortium's
    #
    #  input parameters are:
    #   $lineno = line number
    #   $str = the text of the line
    #   $pos = position of interest (the error) : 0 = first character
    #
    #   We return :
    #     - $offset = an offset which corrects the position in case we only
    #       display part of a line, such that $pos-$offset is the effective
    #       position from the start of the displayed line.
    #     - $numbered_line = the numbered line as above,
    #     - $underline = a blank 'underline' which is all spaces with the same
    #       number of characters as the numbered line.

    my $offset = ( $pos < 60 ) ? 0 : $pos - 40;
    my $excess = length($str) - $offset - 68;
    my $numc   = ( $excess > 0 ) ? 68 : undef;

    if ( defined($numc) ) {
        if ( $offset == 0 ) {
            $str = substr( $str, $offset, $numc - 4 ) . " ...";
        }
        else {
            $str = "... " . substr( $str, $offset + 4, $numc - 4 ) . " ...";
        }
    }
    else {

        if ( $offset == 0 ) {
        }
        else {
            $str = "... " . substr( $str, $offset + 4 );
        }
    }

    my $numbered_line = sprintf( "%d: ", $lineno );
    $offset -= length($numbered_line);
    $numbered_line .= $str;
    my $underline = SPACE x length($numbered_line);
    return ( $offset, $numbered_line, $underline );
} ## end sub make_numbered_line

sub write_on_underline {

    my ( $underline, $pos, $pos_chr ) = @_;

    # The "underline" is a string that shows where an error is; it starts
    # out as a string of blanks with the same length as the numbered line of
    # code above it, and we have to add marking to show where an error is.
    # In the example below, we want to write the string '--^' just below
    # the line of bad code:
    #
    # 2: (One of QAML 2.0's authors is a member of the World Wide Web Con ...
    #                 ---^
    # We are given the current underline string, plus a position and a
    # string to write on it.
    #
    # In the above example, there will be 2 calls to do this:
    # First call:  $pos=19, pos_chr=^
    # Second call: $pos=16, pos_chr=---
    #
    # This is a trivial thing to do with substr, but there is some
    # checking to do.

    # check for error..shouldn't happen
    if ( $pos < 0 || $pos > length($underline) ) {
        return $underline;
    }
    my $excess = length($pos_chr) + $pos - length($underline);
    if ( $excess > 0 ) {
        $pos_chr = substr( $pos_chr, 0, length($pos_chr) - $excess );
    }
    substr( $underline, $pos, length($pos_chr), $pos_chr );
    return ($underline);
} ## end sub write_on_underline

sub pre_tokenize {

    my ( $str, ($max_tokens_wanted) ) = @_;

    # Input parameters:
    #  $str = string to be parsed
    #  $max_tokens_wanted > 0  to stop on reaching this many tokens.
    #                     = undef or 0 means get all tokens

    # Break a string, $str, into a sequence of preliminary tokens (pre-tokens).
    # We look for these types of tokens:
    #   words       (type='w'),               example: 'max_tokens_wanted'
    #   digits      (type = 'd'),             example: '0755'
    #   whitespace  (type = 'b'),             example: '   '
    #   single character punct (type = char)  example: '='

    # Later operations will combine one or more of these pre-tokens into final
    # tokens.  We cannot do better than this yet because we might be in a
    # quoted string or pattern.

    # An advantage of doing this pre-tokenization step is that it keeps almost
    # all of the regex parsing very simple and localized right here.  A
    # disadvantage is that in some extremely rare instances we will have to go
    # back and split a pre-token.

    # Return parameters:
    my @tokens    = ();     # array of the tokens themselves
    my @token_map = (0);    # string position of start of each token
    my @type      = ();     # 'b'=whitespace, 'd'=digits, 'w'=alpha, or punct

    if ( !$max_tokens_wanted ) { $max_tokens_wanted = -1 }

    while ( $max_tokens_wanted-- ) {

        if (
            $str =~ m{
             \G(
               (\s+) #     type 'b'  = whitespace - this must come before \W
             | (\W)  #  or type=char = single-character, non-whitespace punct
             | (\d+) #  or type 'd'  = sequence of digits - must come before \w
             | (\w+) #  or type 'w'  = words not starting with a digit
             )
            }gcx
          )
        {
            push @tokens, $1;
            push @type,
              defined($2) ? 'b' : defined($3) ? $1 : defined($4) ? 'd' : 'w';
            push @token_map, pos($str);
        }

        # that's all..
        else {
            return ( \@tokens, \@token_map, \@type );
        }
    } ## end while ( $max_tokens_wanted...)

    return ( \@tokens, \@token_map, \@type );
} ## end sub pre_tokenize

sub show_tokens {

    # This is an uncalled debug routine, saved for reference
    my ( $rtokens, $rtoken_map ) = @_;
    my $num = scalar( @{$rtokens} );

    foreach my $i ( 0 .. $num - 1 ) {
        my $len = length( $rtokens->[$i] );
        print {*STDOUT} "$i:$len:$rtoken_map->[$i]:$rtokens->[$i]:\n";
    }
    return;
} ## end sub show_tokens

sub dump_token_types {
    my ( $class, $fh ) = @_;

    # This should be the latest list of token types in use
    # adding NEW_TOKENS: add a comment here
    $fh->print(<<'END_OF_LIST');

Here is a list of the token types currently used for lines of type 'CODE'.
For the following tokens, the "type" of a token is just the token itself.

.. :: << >> ** && .. || // -> => += -= .= %= &= |= ^= *= <>
( ) <= >= == =~ !~ != ++ -- /= x=
... **= <<= >>= &&= ||= //= <=>
, + - / * | % ! x ~ = \ ? : . < > ^ & ^^

The following additional token types are defined:

 type    meaning
    b    blank (white space)
    {    indent: opening structural curly brace or square bracket or paren
         (code block, anonymous hash reference, or anonymous array reference)
    }    outdent: right structural curly brace or square bracket or paren
    [    left non-structural square bracket (enclosing an array index)
    ]    right non-structural square bracket
    (    left non-structural paren (all but a list right of an =)
    )    right non-structural paren
    L    left non-structural curly brace (enclosing a key)
    R    right non-structural curly brace
    ;    terminal semicolon
    f    indicates a semicolon in a "for" statement
    h    here_doc operator <<
    #    a comment
    Q    indicates a quote or pattern
    q    indicates a qw quote block
    k    a perl keyword
    C    user-defined constant or constant function (with void prototype = ())
    U    user-defined function taking parameters
    G    user-defined function taking block parameter (like grep/map/eval)
    S    sub definition     (reported as type 'i' in older versions)
    P    package definition (reported as type 'i' in older versions)
    t    type indicator such as %,$,@,*,&,sub
    w    bare word (perhaps a subroutine call)
    i    identifier of some type (with leading %, $, @, *, &, sub, -> )
    n    a number
    v    a v-string
    F    a file test operator (like -e)
    Y    File handle
    Z    identifier in indirect object slot: may be file handle, object
    J    LABEL:  code block label
    j    LABEL after next, last, redo, goto
    p    unary +
    m    unary -
    pp   pre-increment operator ++
    mm   pre-decrement operator --
    A    : used as attribute separator

    Here are the '_line_type' codes used internally:
    SYSTEM         - system-specific code before hash-bang line
    CODE           - line of perl code (including comments)
    POD_START      - line starting pod, such as '=head'
    POD            - pod documentation text
    POD_END        - last line of pod section, '=cut'
    HERE           - text of here-document
    HERE_END       - last line of here-doc (target word)
    FORMAT         - format section
    FORMAT_END     - last line of format section, '.'
    SKIP           - code skipping section
    SKIP_END       - last line of code skipping section, '#>>V'
    DATA_START     - __DATA__ line
    DATA           - unidentified text following __DATA__
    END_START      - __END__ line
    END            - unidentified text following __END__
    ERROR          - we are in big trouble, probably not a perl script
END_OF_LIST

    return;
} ## end sub dump_token_types

#------------------
# About Token Types
#------------------

# The array "valid_token_types" in the BEGIN section has an up-to-date list
# of token types.  Sub 'dump_token_types' should be kept up to date with
# token types.

# Ideally, tokens are the smallest pieces of text
# such that a newline may be inserted between any pair of tokens without
# changing or invalidating the program. This version comes close to this,
# although there are necessarily a few exceptions which must be caught by
# the formatter.  Many of these involve the treatment of bare words.
#
# To simplify things, token types are either a single character, or they
# are identical to the tokens themselves.
#
# As a debugging aid, the -D flag creates a file containing a side-by-side
# comparison of the input string and its tokenization for each line of a file.
# This is an invaluable debugging aid.
#
# In addition to tokens, and some associated quantities, the tokenizer
# also returns flags indication any special line types.  These include
# quotes, here_docs, formats.
#
#------------------
# Adding NEW_TOKENS
#------------------
#
# Here are some notes on the minimal steps.  I wrote these notes while
# adding the 'v' token type for v-strings, which are things like version
# numbers 5.6.0, and ip addresses, and will use that as an example.  ( You
# can use your editor to search for the string "NEW_TOKENS" to find the
# appropriate sections to change):

# *. For another example, search for the smartmatch operator '~~'
# with your editor to see where updates were made for it.

# *. For another example, search for the string 'c250', which shows
# locations where changes for new types 'P' and 'S' were made.

# *. Think of a new, unused character for the token type, and add to
# the array @valid_token_types in the BEGIN section of this package.
# For example, I used 'v' for v-strings.
#
# *. Implement coding to recognize the $type of the token in this routine.
# This is the hardest part, and is best done by imitating or modifying
# some of the existing coding.  For example, to recognize v-strings, I
# patched 'sub scan_bare_identifier' to recognize v-strings beginning with
# 'v' and 'sub scan_number' to recognize v-strings without the leading 'v'.
#
# *. Update sub operator_expected.  This update is critically important but
# the coding is trivial.  Look at the comments in that routine for help.
# For v-strings, which should behave like numbers, I just added 'v' to the
# regex used to handle numbers and strings (types 'n' and 'Q').
#
# *. Implement a 'bond strength' rule in sub set_bond_strengths in
# Perl::Tidy::Formatter for breaking lines around this token type.  You can
# skip this step and take the default at first, then adjust later to get
# desired results.  For adding type 'v', I looked at sub bond_strength and
# saw that number type 'n' was using default strengths, so I didn't do
# anything.  I may tune it up someday if I don't like the way line
# breaks with v-strings look.
#
# *. Implement a 'whitespace' rule in sub set_whitespace_flags in
# Perl::Tidy::Formatter.  For adding type 'v', I looked at this routine
# and saw that type 'n' used spaces on both sides, so I just added 'v'
# to the array @spaces_both_sides.
#
# *. Update HtmlWriter package so that users can colorize the token as
# desired.  This is quite easy; see comments identified by 'NEW_TOKENS' in
# that package.  For v-strings, I initially chose to use a default color
# equal to the default for numbers, but it might be nice to change that
# eventually.
#
# *. Update comments in Perl::Tidy::Tokenizer::dump_token_types.
#
# *. Run lots and lots of debug tests.  Start with special files designed
# to test the new token type.  Run with the -D flag to create a .DEBUG
# file which shows the tokenization.  When these work ok, test as many old
# scripts as possible.  Start with all of the '.t' files in the 'test'
# directory of the distribution file.  Compare .tdy output with previous
# version and updated version to see the differences.  Then include as
# many more files as possible. My own technique has been to collect a huge
# number of perl scripts (thousands!) into one directory and run perltidy
# *, then run diff between the output of the previous version and the
# current version.

BEGIN {

    # These names are used in error messages
    @opening_brace_names = qw# '{' '[' '(' '?' #;
    @closing_brace_names = qw# '}' ']' ')' ':' #;

    my @q;

    my @digraphs = qw#
      .. :: << >> ** && || // -> => += -= .= %= &= |= ^= *= <>
      <= >= == =~ !~ != ++ -- /= x= ~~ ~. |. &. ^. ^^
      #;
    @is_digraph{@digraphs} = (1) x scalar(@digraphs);

    @q = qw(
      . : < > * & | / - = + -  %  ^ !  x ~
    );
    @can_start_digraph{@q} = (1) x scalar(@q);

    my @trigraphs = qw( ... **= <<= >>= &&= ||= //= <=> !~~ &.= |.= ^.= <<~ );
    @is_trigraph{@trigraphs} = (1) x scalar(@trigraphs);

    my @tetragraphs = qw( <<>> );
    @is_tetragraph{@tetragraphs} = (1) x scalar(@tetragraphs);

    # make a hash of all valid token types for self-checking the tokenizer
    # (adding NEW_TOKENS : select a new character and add to this list)
    # fix for c250: added new token type 'P' and 'S'
    my @valid_token_types = qw#
      A b C G L R f h Q k t w i q n p m F pp mm U j J Y Z v P S
      { } ( ) [ ] ; + - / * | % ! x ~ = \ ? : . < > ^ &
      #;
    push( @valid_token_types, @digraphs );
    push( @valid_token_types, @trigraphs );
    push( @valid_token_types, @tetragraphs );
    push( @valid_token_types, ( '#', ',', 'CORE::' ) );
    @is_valid_token_type{@valid_token_types} = (1) x scalar(@valid_token_types);

    # a list of file test letters, as in -e (Table 3-4 of 'camel 3')
    my @file_test_operators =
      qw( A B C M O R S T W X b c d e f g k l o p r s t u w x z );
    @is_file_test_operator{@file_test_operators} =
      (1) x scalar(@file_test_operators);

    # these functions have prototypes of the form (&), so when they are
    # followed by a block, that block MAY BE followed by an operator.
    # Smartmatch operator ~~ may be followed by anonymous hash or array ref
    @q = qw( do eval );
    @is_block_operator{@q} = (1) x scalar(@q);

    # these functions allow an identifier in the indirect object slot
    @q = qw( print printf sort exec system say );
    @is_indirect_object_taker{@q} = (1) x scalar(@q);

    # Note: 'field' will be added by sub check_options if --use-feature=class
    @q = qw( my our state );
    @is_my_our_state{@q} = (1) x scalar(@q);

    # These tokens may precede a code block
    # patched for SWITCH/CASE/CATCH.  Actually these could be removed
    # now and we could let the extended-syntax coding handle them.
    # Added 'default' for Switch::Plain.
    # Note: 'ADJUST' will be added by sub check_options if --use-feature=class
    @q = qw(
      BEGIN     END      CHECK INIT   AUTOLOAD DESTROY
      UNITCHECK continue if    elsif  else     unless
      do        while    until eval   for      foreach
      map       grep     sort  switch case     given
      when      default  catch try    finally
    );
    @is_code_block_token{@q} = (1) x scalar(@q);

    # Note: this hash was formerly named '%is_not_zero_continuation_block_type'
    # to contrast it with the block types in '%is_zero_continuation_block_type'
    @q = qw( sort map grep eval do );
    @is_sort_map_grep_eval_do{@q} = (1) x scalar(@q);

    @q = qw( sort map grep );
    @is_sort_map_grep{@q} = (1) x scalar(@q);

    %is_grep_alias = ();

    # I'll build the list of keywords incrementally
    my @Keywords = ();

    # keywords and tokens after which a value or pattern is expected,
    # but not an operator.  In other words, these should consume terms
    # to their right, or at least they are not expected to be followed
    # immediately by operators.
    my @value_requestor = qw(
      AUTOLOAD         BEGIN         CHECK        DESTROY
      END              EQ            GE           GT
      INIT             LE            LT           NE
      UNITCHECK        abs           accept       alarm
      and              atan2         bind         binmode
      bless            break         caller       chdir
      chmod            chomp         chop         chown
      chr              chroot        close        closedir
      cmp              connect       continue     cos
      crypt            dbmclose      dbmopen      defined
      delete           die           dump         each
      else             elsif         eof          eq
      evalbytes        exec          exists       exit
      exp              fc            fcntl        fileno
      flock            for           foreach      formline
      ge               getc          getgrgid     getgrnam
      gethostbyaddr    gethostbyname getnetbyaddr getnetbyname
      getpeername      getpgrp       getpriority  getprotobyname
      getprotobynumber getpwnam      getpwuid     getservbyname
      getservbyport    getsockname   getsockopt   glob
      gmtime           goto          grep         gt
      hex              if            index        int
      ioctl            join          keys         kill
      last             lc            lcfirst      le
      length           link          listen       local
      localtime        lock          log          lstat
      lt               map           mkdir        msgctl
      msgget           msgrcv        msgsnd       my
      ne               next          no           not
      oct              open          opendir      or
      ord              our           pack         pipe
      pop              pos           print        printf
      prototype        push          quotemeta    rand
      read             readdir       readlink     readline
      readpipe         recv          redo         ref
      rename           require       reset        return
      reverse          rewinddir     rindex       rmdir
      scalar           seek          seekdir      select
      semctl           semget        semop        send
      sethostent       setnetent     setpgrp      setpriority
      setprotoent      setservent    setsockopt   shift
      shmctl           shmget        shmread      shmwrite
      shutdown         sin           sleep        socket
      socketpair       sort          splice       split
      sprintf          sqrt          srand        stat
      state            study         substr       symlink
      syscall          sysopen       sysread      sysseek
      system           syswrite      tell         telldir
      tie              tied          truncate     uc
      ucfirst          umask         undef        unless
      unlink           unpack        unshift      untie
      until            use           utime        values
      vec              waitpid       warn         while
      write            xor           case         catch
      default          err           given        isa
      say              switch        when
    );

    # Note: 'ADJUST', 'field' are added by sub check_options
    # if --use-feature=class

    # patched above for SWITCH/CASE given/when err say
    # 'err' is a fairly safe addition.
    # Added 'default' for Switch::Plain. Note that we could also have
    # a separate set of keywords to include if we see 'use Switch::Plain'
    push( @Keywords, @value_requestor );

    # These are treated the same but are not keywords:
    my @extra_vr = qw( constant vars );
    push( @value_requestor, @extra_vr );

    @expecting_term_token{@value_requestor} = (1) x scalar(@value_requestor);

    # this list contains keywords which do not look for arguments,
    # so that they might be followed by an operator, or at least
    # not a term.
    my @operator_requestor = qw(
      endgrent    endhostent endnetent  endprotoent
      endpwent    endservent fork       getgrent
      gethostent  getlogin   getnetent  getppid
      getprotoent getpwent   getservent setgrent
      setpwent    time       times      wait
      wantarray
    );

    push( @Keywords, @operator_requestor );

    # These are treated the same but are not considered keywords:
    my @extra_or = qw( STDERR STDIN STDOUT );

    push( @operator_requestor, @extra_or );

    @expecting_operator_token{@operator_requestor} =
      (1) x scalar(@operator_requestor);

    # these token TYPES expect trailing operator but not a term
    # note: ++ and -- are post-increment and decrement, 'C' = constant
    my @operator_requestor_types = qw( ++ -- C <> q );

    # NOTE: This hash is available but not currently used
    @expecting_operator_types{@operator_requestor_types} =
      (1) x scalar(@operator_requestor_types);

    # these token TYPES consume values (terms)
    # note: pp and mm are pre-increment and decrement
    # f=semicolon in for,  F=file test operator
    my @value_requestor_type = qw#
      L { ( [ ~ !~ =~ ; . .. ... A : && ! || // = + - x
      **= += -= .= /= *= %= x= &= |= ^= <<= >>= &&= ||= //=
      <= >= == != => \ > < % * / ? & | ** <=> ~~ !~~ <<~
      f F pp mm Y p m U J G j >> << ^ t
      ~. ^. |. &. ^.= |.= &.= ^^
      #;
    push( @value_requestor_type, ',' )
      ;    # (perl doesn't like a ',' in a qw block)

    # NOTE: This hash is available but not currently used
    @expecting_term_types{@value_requestor_type} =
      (1) x scalar(@value_requestor_type);

    # Note: the following valid token types are not assigned here to
    # hashes requesting to be followed by values or terms, but are
    # instead currently hard-coded into sub operator_expected:
    # ) -> :: Q R Z ] b h i k n v w } #

    # For simple syntax checking, it is nice to have a list of operators which
    # will really be unhappy if not followed by a term.  This includes most
    # of the above...
    @really_want_term{@value_requestor_type} =
      (1) x scalar(@value_requestor_type);

    # with these exceptions...
    delete $really_want_term{'U'}; # user sub, depends on prototype
    delete $really_want_term{'F'}; # file test works on $_ if no following term
    delete $really_want_term{'Y'}; # indirect object, too risky to check syntax;
                                   # let perl do it
    @q = qw( q qq qx qr s y tr m );
    @is_q_qq_qx_qr_s_y_tr_m{@q} = (1) x scalar(@q);

    # Note added 'qw' here
    @q = qw( q qq qw qx qr s y tr m );
    @is_q_qq_qw_qx_qr_s_y_tr_m{@q} = (1) x scalar(@q);

    # Quote modifiers:
    # original ref: camel 3 p 147,
    # but perl may accept undocumented flags
    # perl 5.10 adds 'p' (preserve)
    # Perl version 5.22 added 'n'
    # From http://perldoc.perl.org/perlop.html we have
    # /PATTERN/msixpodualngc or m?PATTERN?msixpodualngc
    # s/PATTERN/REPLACEMENT/msixpodualngcer
    # y/SEARCHLIST/REPLACEMENTLIST/cdsr
    # tr/SEARCHLIST/REPLACEMENTLIST/cdsr
    # qr/STRING/msixpodualn
    %quote_modifiers = (
        's'  => '[msixpodualngcer]',
        'y'  => '[cdsr]',
        'tr' => '[cdsr]',
        'm'  => '[msixpodualngc]',
        'qr' => '[msixpodualn]',
        'q'  => EMPTY_STRING,
        'qq' => EMPTY_STRING,
        'qw' => EMPTY_STRING,
        'qx' => EMPTY_STRING,
    );

    # Note: 'class' will be added by sub check_options if -use-feature=class
    @q = qw( package );
    @is_package{@q} = (1) x scalar(@q);

    @q = qw( if elsif unless );
    @is_if_elsif_unless{@q} = (1) x scalar(@q);

    @q = qw( ; t );
    @is_semicolon_or_t{@q} = (1) x scalar(@q);

    @q = qw( if elsif unless case when );
    @is_if_elsif_unless_case_when{@q} = (1) x scalar(@q);

    # Hash of other possible line endings which may occur.
    # Keep these coordinated with the regex where this is used.
    # Note: chr(13) = chr(015)="\r".
    @q = ( chr(13), chr(29), chr(26) );
    @other_line_endings{@q} = (1) x scalar(@q);

    # These keywords are handled specially in the tokenizer code:
    my @special_keywords =
      qw( do eval format m package q qq qr qw qx s sub tr y );
    push( @Keywords, @special_keywords );

    # Keywords after which list formatting may be used
    # WARNING: do not include |map|grep|eval or perl may die on
    # syntax errors (map1.t).
    my @keyword_taking_list = qw(
      and        chmod      chomp      chop
      chown      dbmopen    die        elsif
      exec       fcntl      for        foreach
      formline   getsockopt given      if
      index      ioctl      join       kill
      local      msgctl     msgrcv     msgsnd
      my         open       or         our
      pack       print      printf     push
      read       readpipe   recv       return
      reverse    rindex     seek       select
      semctl     semget     send       setpriority
      setsockopt shmctl     shmget     shmread
      shmwrite   socket     socketpair sort
      splice     split      sprintf    state
      substr     syscall    sysopen    sysread
      sysseek    system     syswrite   tie
      unless     unlink     unpack     unshift
      until      vec        warn       when
      while
    );

    # NOTE: This hash is available but not currently used
    @is_keyword_taking_list{@keyword_taking_list} =
      (1) x scalar(@keyword_taking_list);

    # perl functions which may be unary operators.

    # This list is used to decide if a pattern delimited by slashes, /pattern/,
    # can follow one of these keywords.
    @q = qw( chomp eof eval fc lc pop shift uc undef );

    @is_keyword_rejecting_slash_as_pattern_delimiter{@q} =
      (1) x scalar(@q);

    # These are keywords for which an arg may optionally be omitted.  They are
    # currently only used to disambiguate a ? used as a ternary from one used
    # as a (deprecated) pattern delimiter.  In the future, they might be used
    # to give a warning about ambiguous syntax before a /.
    # Note: split has been omitted (see note below).
    my @keywords_taking_optional_arg = qw(
      abs      alarm    caller    chdir     chomp   chop
      chr      chroot   close     cos       defined die
      eof      eval     evalbytes exit      exp     fc
      getc     glob     gmtime    hex       int     last
      lc       lcfirst  length    localtime log     lstat
      mkdir    next     oct       ord       pop     pos
      print    printf   prototype quotemeta rand    readline
      readlink readpipe redo      ref       require reset
      reverse  rmdir    say       select    shift   sin
      sleep    sqrt     srand     stat      study   tell
      uc       ucfirst  umask     undef     unlink  warn
      write
    );
    @is_keyword_taking_optional_arg{@keywords_taking_optional_arg} =
      (1) x scalar(@keywords_taking_optional_arg);

    # This list is used to decide if a pattern delimited by question marks,
    # ?pattern?, can follow one of these keywords.  Note that from perl 5.22
    # on, a ?pattern? is not recognized, so we can be much more strict than
    # with a /pattern/. Note that 'split' is not in this list. In current
    # versions of perl a question following split must be a ternary, but
    # in older versions it could be a pattern.  The guessing algorithm will
    # decide.  We are combining two lists here to simplify the test.
    @q = ( @keywords_taking_optional_arg, @operator_requestor );
    @is_keyword_rejecting_question_as_pattern_delimiter{@q} =
      (1) x scalar(@q);

    # These are not used in any way yet
    #    my @unused_keywords = qw(
    #     __FILE__
    #     __LINE__
    #     __PACKAGE__
    #     );

    #  The list of keywords was originally extracted from function 'keyword' in
    #  perl file toke.c version 5.005.03, using this utility, plus a
    #  little editing: (file getkwd.pl):
    #  while (<>) { while (/\"(.*)\"/g) { print "$1\n"; } }
    #  Add 'get' prefix where necessary, then split into the above lists.
    #  This list should be updated as necessary.
    #  The list should not contain these special variables:
    #  ARGV DATA ENV SIG STDERR STDIN STDOUT
    #  __DATA__ __END__

    @is_keyword{@Keywords} = (1) x scalar(@Keywords);

    %matching_end_token = (
        '{' => '}',
        '(' => ')',
        '[' => ']',
        '<' => '>',
    );
} ## end BEGIN

} ## end package Perl::Tidy::Tokenizer
1;
 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 #####################################################################
#
# The Perl::Tidy::FileWriter class writes the output file created
# by the formatter. It receives each output line and performs some
# important monitoring services. These include:
#
# - Verifying that lines do not go out with tokens in the wrong order
# - Checking for obvious iteration convergence when all output tokens
#   match all input tokens
# - Keeping track of consecutive blank and non-blank lines
# - Looking for line lengths which exceed the maximum requested length
# - Reporting results to the log file
#
#####################################################################

package Perl::Tidy::FileWriter;
use strict;
use warnings;
our $VERSION = '20250105';
use Carp;

use constant DEVEL_MODE   => 0;
use constant EMPTY_STRING => q{};

# A limit on message length when a fault is detected
use constant LONG_MESSAGE => 256;

# Maximum number of little messages; probably need not be changed.
use constant MAX_NAG_MESSAGES => 6;

sub AUTOLOAD {

    # Catch any undefined sub calls so that we are sure to get
    # some diagnostic information.  This sub should never be called
    # except for a programming error.
    our $AUTOLOAD;
    return if ( $AUTOLOAD =~ /\bDESTROY$/ );
    my ( $pkg, $fname, $lno ) = caller();
    my $my_package = __PACKAGE__;
    print {*STDERR} <<EOM;
======================================================================
Error detected in package '$my_package', version $VERSION
Received unexpected AUTOLOAD call for sub '$AUTOLOAD'
Called from package: '$pkg'
Called from File '$fname'  at line '$lno'
This error is probably due to a recent programming change
======================================================================
EOM
    exit 1;
} ## end sub AUTOLOAD

sub DESTROY {

    # required to avoid call to AUTOLOAD in some versions of perl
}

BEGIN {

    # Array index names for variables.
    # Do not combine with other BEGIN blocks (c101).
    my $i = 0;
    use constant {
        _logger_object_               => $i++,
        _rOpts_                       => $i++,
        _output_line_number_          => $i++,
        _consecutive_blank_lines_     => $i++,
        _consecutive_nonblank_lines_  => $i++,
        _consecutive_new_blank_lines_ => $i++,
        _first_line_length_error_     => $i++,
        _max_line_length_error_       => $i++,
        _last_line_length_error_      => $i++,
        _first_line_length_error_at_  => $i++,
        _max_line_length_error_at_    => $i++,
        _last_line_length_error_at_   => $i++,
        _line_length_error_count_     => $i++,
        _max_output_line_length_      => $i++,
        _max_output_line_length_at_   => $i++,
        _rK_checklist_                => $i++,
        _K_arrival_order_matches_     => $i++,
        _K_sequence_error_msg_        => $i++,
        _K_last_arrival_              => $i++,
        _save_logfile_                => $i++,
        _routput_string_              => $i++,
        _input_stream_name_           => $i++,
    };
} ## end BEGIN

sub Die {
    my ($msg) = @_;
    Perl::Tidy::Die($msg);
    croak "unexpected return from Perl::Tidy::Die";
}

sub Fault {
    my ( $self, $msg ) = @_;

    # This routine is called for errors that really should not occur
    # except if there has been a bug introduced by a recent program change.
    # Please add comments at calls to Fault to explain why the call
    # should not occur, and where to look to fix it.
    my ( $package0_uu, $filename0_uu, $line0,    $subroutine0_uu ) = caller(0);
    my ( $package1_uu, $filename1,    $line1,    $subroutine1 )    = caller(1);
    my ( $package2_uu, $filename2_uu, $line2_uu, $subroutine2 )    = caller(2);
    my $pkg = __PACKAGE__;

    # Catch potential error of Fault not called as a method
    my $input_stream_name;
    if ( !ref($self) ) {
        $input_stream_name = "(UNKNOWN)";
        $msg               = "Fault not called as a method - please fix\n";
        if ( $self && length($self) < LONG_MESSAGE ) { $msg .= $self }
        $self = undef;
    }
    else {
        $input_stream_name = $self->[_input_stream_name_];
    }

    Die(<<EOM);
==============================================================================
While operating on input stream with name: '$input_stream_name'
A fault was detected at line $line0 of sub '$subroutine1'
in file '$filename1'
which was called from line $line1 of sub '$subroutine2'
Message: '$msg'
This is probably an error introduced by a recent programming change.
$pkg reports VERSION='$VERSION'.
==============================================================================
EOM

    croak "unexpected return from sub Die";
} ## end sub Fault

sub warning {
    my ( $self, $msg ) = @_;

    # log a warning message from any caller
    my $logger_object = $self->[_logger_object_];
    if ($logger_object) { $logger_object->warning($msg); }
    return;
} ## end sub warning

sub write_logfile_entry {
    my ( $self, $msg ) = @_;
    my $logger_object = $self->[_logger_object_];
    if ($logger_object) {
        $logger_object->write_logfile_entry($msg);
    }
    return;
} ## end sub write_logfile_entry

sub new {
    my ( $class, $line_sink_object, $rOpts, $logger_object ) = @_;

    my $self = [];
    bless $self, $class;
    $self->[_logger_object_]               = $logger_object;
    $self->[_rOpts_]                       = $rOpts;
    $self->[_output_line_number_]          = 1;
    $self->[_consecutive_blank_lines_]     = 0;
    $self->[_consecutive_nonblank_lines_]  = 0;
    $self->[_consecutive_new_blank_lines_] = 0;
    $self->[_first_line_length_error_]     = 0;
    $self->[_max_line_length_error_]       = 0;
    $self->[_last_line_length_error_]      = 0;
    $self->[_first_line_length_error_at_]  = 0;
    $self->[_max_line_length_error_at_]    = 0;
    $self->[_last_line_length_error_at_]   = 0;
    $self->[_line_length_error_count_]     = 0;
    $self->[_max_output_line_length_]      = 0;
    $self->[_max_output_line_length_at_]   = 0;
    $self->[_rK_checklist_]                = [];
    $self->[_K_arrival_order_matches_]     = 0;
    $self->[_K_sequence_error_msg_]        = EMPTY_STRING;
    $self->[_K_last_arrival_]              = -1;
    $self->[_save_logfile_] =
      defined($logger_object) && $logger_object->get_save_logfile();

    # '$line_sink_object' is a SCALAR ref which receives the lines.
    my $ref = ref($line_sink_object);
    if ( !$ref ) {
        $self->Fault("FileWriter expects line_sink_object to be a ref\n");
    }
    elsif ( $ref eq 'SCALAR' ) {
        $self->[_routput_string_] = $line_sink_object;
    }
    else {
        my $str = $ref;
        if ( length($str) > 63 ) { $str = substr( $str, 0, 60 ) . '...' }
        $self->Fault(<<EOM);
FileWriter expects 'line_sink_object' to be ref to SCALAR but it is ref to:
$str
EOM
    }

    my $input_stream_name = EMPTY_STRING;
    if ($logger_object) {
        $input_stream_name = $logger_object->get_input_stream_name();
    }
    $self->[_input_stream_name_] = $input_stream_name;

    return $self;
} ## end sub new

sub setup_convergence_test {
    my ( $self, $rlist ) = @_;

    # Setup the convergence test,

    # Given:
    #  $rlist = a reference to a list of line-ending token indexes 'K' of
    #  the input stream. We will compare these with the line-ending token
    #  indexes of the output stream. If they are identical, then we have
    #  convergence.
    if ( @{$rlist} ) {

        # We are going to destroy the list, so make a copy and put in
        # reverse order so we can pop values as they arrive
        my @list = @{$rlist};
        if ( $list[0] < $list[-1] ) {
            @list = reverse @list;
        }
        $self->[_rK_checklist_] = \@list;
    }

    # We will zero this flag on any error in arrival order:
    $self->[_K_arrival_order_matches_] = 1;
    $self->[_K_sequence_error_msg_]    = EMPTY_STRING;
    $self->[_K_last_arrival_]          = -1;
    return;
} ## end sub setup_convergence_test

sub get_convergence_check {
    my ($self) = @_;

    # converged if:
    # - all expected indexes arrived
    # - and in correct order
    return !@{ $self->[_rK_checklist_] }
      && $self->[_K_arrival_order_matches_];

} ## end sub get_convergence_check

sub get_output_line_number {
    my $self = shift;
    return $self->[_output_line_number_];
}

sub decrement_output_line_number {
    my $self = shift;
    $self->[_output_line_number_]--;
    return;
}

sub get_consecutive_nonblank_lines {
    my $self = shift;
    return $self->[_consecutive_nonblank_lines_];
}

sub get_consecutive_blank_lines {
    my $self = shift;
    return $self->[_consecutive_blank_lines_];
}

sub reset_consecutive_blank_lines {
    my $self = shift;
    $self->[_consecutive_blank_lines_] = 0;
    return;
}

sub want_blank_line {
    my $self = shift;
    if ( !$self->[_consecutive_blank_lines_] ) {
        $self->write_blank_code_line();
    }
    return;
} ## end sub want_blank_line

sub require_blank_code_lines {
    my ( $self, $count ) = @_;

    # Given:
    #   $count = number of blank lines to write
    # Write out $count blank lines regardless of the value of -mbl
    # unless -mbl=0.  This allows extra blank lines to be written for subs and
    # packages even with the default -mbl=1
    my $need   = $count - $self->[_consecutive_blank_lines_];
    my $rOpts  = $self->[_rOpts_];
    my $forced = $rOpts->{'maximum-consecutive-blank-lines'} > 0;
    foreach ( 0 .. $need - 1 ) {
        $self->write_blank_code_line($forced);
    }
    return;
} ## end sub require_blank_code_lines

sub write_blank_code_line {
    my ( $self, ($forced) ) = @_;

    # Write a blank line of code, given:
    #  $forced = optional flag which, if set, forces the blank line
    #    to be written. This allows the -mbl flag to be temporarily
    #    exceeded.

    my $rOpts = $self->[_rOpts_];
    return
      if (!$forced
        && $self->[_consecutive_blank_lines_] >=
        $rOpts->{'maximum-consecutive-blank-lines'} );

    $self->[_consecutive_nonblank_lines_] = 0;

    # Balance old blanks against new (forced) blanks instead of writing them.
    # This fixes case b1073.
    if ( !$forced && $self->[_consecutive_new_blank_lines_] > 0 ) {
        $self->[_consecutive_new_blank_lines_]--;
        return;
    }

    ${ $self->[_routput_string_] } .= "\n";

    $self->[_output_line_number_]++;
    $self->[_consecutive_blank_lines_]++;
    $self->[_consecutive_new_blank_lines_]++ if ($forced);

    return;
} ## end sub write_blank_code_line

use constant MAX_PRINTED_CHARS => 80;

sub write_code_line {
    my ( $self, $str, $K ) = @_;

    # Write a line of code, given
    #  $str = the line of code
    #  $K   = an optional check integer which, if if given, must
    #       increase monotonically. This was added to catch cache
    #       sequence errors in the vertical aligner.

    $self->[_consecutive_blank_lines_]     = 0;
    $self->[_consecutive_new_blank_lines_] = 0;
    $self->[_consecutive_nonblank_lines_]++;
    $self->[_output_line_number_]++;

    ${ $self->[_routput_string_] } .= $str;

    if ( $self->[_save_logfile_] ) { $self->check_line_lengths($str) }

    #----------------------------
    # Convergence and error check
    #----------------------------
    if ( defined($K) ) {

        # Convergence check: we are checking if all defined K values arrive in
        # the order which was defined by the caller.  Quit checking if any
        # unexpected K value arrives.
        if ( $self->[_K_arrival_order_matches_] ) {
            my $Kt = pop @{ $self->[_rK_checklist_] };
            if ( !defined($Kt) || $Kt != $K ) {
                $self->[_K_arrival_order_matches_] = 0;
            }
        }

        # Check for out-of-order arrivals of index K. The K values are the
        # token indexes of the last token of code lines, and they should come
        # out in increasing order.  Otherwise something is seriously wrong.
        # Most likely a recent programming change to VerticalAligner.pm has
        # caused lines to go out in the wrong order.  This could happen if
        # either the cache or buffer that it uses are emptied in the wrong
        # order.
        if ( $K < $self->[_K_last_arrival_]
            && !$self->[_K_sequence_error_msg_] )
        {
            my $K_prev = $self->[_K_last_arrival_];

            chomp $str;
            if ( length($str) > MAX_PRINTED_CHARS ) {
                $str = substr( $str, 0, MAX_PRINTED_CHARS ) . "...";
            }

            my $msg = <<EOM;
Lines have arrived out of order in sub 'write_code_line'
as detected by token index K=$K arriving after index K=$K_prev in the following line:
$str
This is probably due to a recent programming change and needs to be fixed.
EOM

            # Always die during development, this needs to be fixed
            if (DEVEL_MODE) { $self->Fault($msg) }

            # Otherwise warn if string is not empty (added for b1378)
            $self->warning($msg) if ( length($str) );

            # Only issue this warning once
            $self->[_K_sequence_error_msg_] = $msg;

        }
        $self->[_K_last_arrival_] = $K;
    }
    return;
} ## end sub write_code_line

sub write_line {
    my ( $self, $str ) = @_;

    # Write a line directly to the output, without any counting of blank or
    # non-blank lines.

    # Given:
    #   $str = line of text to write

    ${ $self->[_routput_string_] } .= $str;

    if ( chomp $str )              { $self->[_output_line_number_]++; }
    if ( $self->[_save_logfile_] ) { $self->check_line_lengths($str) }

    return;
} ## end sub write_line

sub check_line_lengths {
    my ( $self, $str ) = @_;

    # Collect info on line lengths for logfile
    # Given:
    #   $str = line of text being written

    # This calculation of excess line length ignores any internal tabs
    my $rOpts = $self->[_rOpts_];
    chomp $str;
    my $len_str = length($str);
    my $exceed  = $len_str - $rOpts->{'maximum-line-length'};
    if ( $str && substr( $str, 0, 1 ) eq "\t" && $str =~ /^\t+/g ) {
        $exceed += pos($str) * $rOpts->{'indent-columns'};
    }

    # Note that we just incremented output line number to future value
    # so we must subtract 1 for current line number
    if ( $len_str > $self->[_max_output_line_length_] ) {
        $self->[_max_output_line_length_] = $len_str;
        $self->[_max_output_line_length_at_] =
          $self->[_output_line_number_] - 1;
    }

    if ( $exceed > 0 ) {
        my $output_line_number = $self->[_output_line_number_];
        $self->[_last_line_length_error_]    = $exceed;
        $self->[_last_line_length_error_at_] = $output_line_number - 1;
        if ( $self->[_line_length_error_count_] == 0 ) {
            $self->[_first_line_length_error_]    = $exceed;
            $self->[_first_line_length_error_at_] = $output_line_number - 1;
        }

        if ( $self->[_last_line_length_error_] >
            $self->[_max_line_length_error_] )
        {
            $self->[_max_line_length_error_]    = $exceed;
            $self->[_max_line_length_error_at_] = $output_line_number - 1;
        }

        if ( $self->[_line_length_error_count_] < MAX_NAG_MESSAGES ) {
            $self->write_logfile_entry(
                "Line length exceeded by $exceed characters\n");
        }
        $self->[_line_length_error_count_]++;
    }
    return;
} ## end sub check_line_lengths

sub report_line_length_errors {
    my $self = shift;

    # Write summary info about line lengths to the log file

    my $rOpts                   = $self->[_rOpts_];
    my $line_length_error_count = $self->[_line_length_error_count_];
    if ( $line_length_error_count == 0 ) {
        $self->write_logfile_entry(
            "No lines exceeded $rOpts->{'maximum-line-length'} characters\n");
        my $max_output_line_length    = $self->[_max_output_line_length_];
        my $max_output_line_length_at = $self->[_max_output_line_length_at_];
        $self->write_logfile_entry(
"  Maximum output line length was $max_output_line_length at line $max_output_line_length_at\n"
        );

    }
    else {

        my $word = ( $line_length_error_count > 1 ) ? "s" : EMPTY_STRING;
        $self->write_logfile_entry(
"$line_length_error_count output line$word exceeded $rOpts->{'maximum-line-length'} characters:\n"
        );

        $word = ( $line_length_error_count > 1 ) ? "First" : EMPTY_STRING;
        my $first_line_length_error    = $self->[_first_line_length_error_];
        my $first_line_length_error_at = $self->[_first_line_length_error_at_];
        $self->write_logfile_entry(
" $word at line $first_line_length_error_at by $first_line_length_error characters\n"
        );

        if ( $line_length_error_count > 1 ) {
            my $max_line_length_error    = $self->[_max_line_length_error_];
            my $max_line_length_error_at = $self->[_max_line_length_error_at_];
            my $last_line_length_error   = $self->[_last_line_length_error_];
            my $last_line_length_error_at =
              $self->[_last_line_length_error_at_];
            $self->write_logfile_entry(
" Maximum at line $max_line_length_error_at by $max_line_length_error characters\n"
            );
            $self->write_logfile_entry(
" Last at line $last_line_length_error_at by $last_line_length_error characters\n"
            );
        }
    }
    return;
} ## end sub report_line_length_errors
1;
 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

package TidyAll::OTOBO;

use strict;
use warnings;
use v5.24;
use utf8;

use File::Basename qw(dirname);
use lib dirname(__FILE__) . '/Plugin/OTOBO';    # Find our Perl::Critic policies

use Moo;

extends qw(Code::TidyAll);

# core modules
use File::Basename;
use File::Temp ();
use IO::File;
use POSIX ":sys_wait_h";
use Term::ANSIColor qw(colored);
use Time::HiRes qw(sleep);

# CPAN modules, Require some needed modules here for clarity / better error messages.
use Code::TidyAll 0.56;
use Perl::Critic 1.140;
use Perl::Tidy;

our $FrameworkVersionMajor = 0;
our $FrameworkVersionMinor = 0;
our $ThirdpartyModule      = 0;
our @FileList              = ();    # all files in current repository

# handle coloring
#   environment variable ANSI_COLORS_DISABLED is used by Term::ANSIColor
if ( !(-t STDOUT) || $ENV{OTOBOCODEPOLICY_NOCOLOR} ) {
    $ENV{ANSI_COLORS_DISABLED} = 1;
}

sub new_from_conf_file {
    my ( $Class, $ConfigFile, %Param ) = @_;

    my $Self = $Class->SUPER::new_from_conf_file(
        $ConfigFile,
        %Param,
        no_cache   => 1,
        no_backups => 1,
    );

    # Reset when a new object is created
    $FrameworkVersionMajor = 0;
    $FrameworkVersionMinor = 0;
    $ThirdpartyModule      = 0;
    @FileList              = ();

    return $Self;
}

sub DetermineFrameworkVersionFromDirectory {
    my ( $Self, %Param ) = @_;

    # First check if we have an OTOBO directory, use RELEASE info then.
    if ( -r $Self->{root_dir} . '/RELEASE' ) {
        my $FileHandle = IO::File->new( $Self->{root_dir} . '/RELEASE', 'r' );
        my @Content    = $FileHandle->getlines();

        my ( $VersionMajor, $VersionMinor ) = $Content[1] =~ m{^VERSION\s+=\s+(\d+)\.(\d+)\.}xms;
        $FrameworkVersionMajor = $VersionMajor;
        $FrameworkVersionMinor = $VersionMinor;
    }
    else {
        # Now check if we have a module directory with an SOPM file in it.
        my @SOPMFiles = glob $Self->{root_dir} . "/*.sopm";
        if (@SOPMFiles) {

            # Use the highest framework version from the first SOPM file.
            my $FileHandle = IO::File->new( $SOPMFiles[0], 'r' );
            my @Content    = $FileHandle->getlines();
            for my $Line (@Content) {
                if ( $Line =~ m{ <Framework (?: [ ]+ [^<>]* )? > }xms ) {
                    my ( $VersionMajor, $VersionMinor ) = $Line =~ m{ <Framework (?: [ ]+ [^<>]* )? > (\d+) \. (\d+) \. [^<*]+ <\/Framework> }xms;
                    if (
                        $VersionMajor > $FrameworkVersionMajor
                        || (
                            $VersionMajor == $FrameworkVersionMajor
                            && $VersionMinor > $FrameworkVersionMinor
                        )
                        )
                    {
                        $FrameworkVersionMajor = $VersionMajor;
                        $FrameworkVersionMinor = $VersionMinor;
                    }
                }
                elsif ( $Line =~ m{<Vendor>} && $Line !~ m{Rother OSS} ) {
                    $ThirdpartyModule = 1;
                }
            }
        }
    }

    if ($FrameworkVersionMajor) {
        print "Found OTOBO version $FrameworkVersionMajor.$FrameworkVersionMinor.\n";
    }
    else {
        print "Could not determine OTOBO version (assuming latest version)!\n";
    }

    if ($ThirdpartyModule) {
        print
            "This seems to be a module not copyrighted by Rother OSS GmbH. File copyright will not be changed.\n";
    }
    else {
        print
            "This module seems to be copyrighted by Rother OSS GmbH. File copyright will automatically be assigned to Rother OSS GmbH.\n";
        print
            "  If this is not correct, you can change the <Vendor> tag in your SOPM.\n";
    }

    return;
}

#
# Process a list of file paths in parallel with forking (if needed).
#
sub ProcessPathsParallel {
    my ( $Self, %Param ) = @_;

    my $Processes = $Param{Processes} // $ENV{OTOBOCODEPOLICY_PROCESSES} // 6;
    my @Files     = @{ $Param{FilePaths} // [] };

    # No parallel processing needed: execute directly.
    if ( $Processes <= 1 ) {
        return $Self->process_paths(@Files);
    }

    # Parallel processing. We chunk the data and execute the chunks in parallel.
    #
    # TidyAll's built-in --jobs flag is not used, it seems to be way too slow,
    #   perhaps because of forking for each single job.

    my %ActiveChildPID;

    my $Stop = sub {

        # Propagate kill signal to all forks
        for my $PID ( sort keys %ActiveChildPID ) {
            kill 9, $PID;
        }

        print "Stopped by user!\n";
        return 1;
    };

    local $SIG{INT}  = sub { $Stop->() };
    local $SIG{TERM} = sub { $Stop->() };

    my @GlobalResults;

    print "OTOBOCodePolicy will use up to $Processes parallel processes.\n";

    # To store results from child processes.
    my $TempDirectory = File::Temp->newdir() || die "Could not create temporary directory: $!";

    # split chunks of files for every process
    my @Chunks;
    my $ItemCount = 0;

    for my $File (@Files) {
        push @{ $Chunks[ $ItemCount++ % $Processes ] }, $File;
    }

    CHUNK:
    for my $Chunk (@Chunks) {

        # Create a child process.
        my $PID = fork;

        # Child process could not be created.
        if ( $PID < 0 ) {
            die "Unable to fork a child process for tiding!";
        }

        # Child process.
        if ( !$PID ) {

            my @Results = $Self->process_paths( @{$Chunk} );

            my $ChildPID = $$;
            Storable::store( \@Results, "$TempDirectory/$ChildPID.tmp" );

            # Close child process at the end.
            exit 0;
        }

        # Parent process.
        $ActiveChildPID{$PID} = {
            PID => $PID,
        };
    }

    # Check the status of all child processes every 0.1 seconds.
    # Wait for all child processes to be finished.
    WAIT:
    while (1) {

        last WAIT if !%ActiveChildPID;
        sleep 0.1;

        PID:
        for my $PID ( sort keys %ActiveChildPID ) {

            my $WaitResult = waitpid( $PID, WNOHANG );

            die "Child process '$PID' exited with errors: $?" if $WaitResult == -1;

            if ($WaitResult) {

                my $TempFile = "$TempDirectory/$PID.tmp";
                my $Results;

                if ( !-e $TempFile ) {
                    die "Could not read results of process $PID.\n";
                }

                $Results = Storable::retrieve($TempFile);
                unlink $TempFile;

                # Join the child results.
                @GlobalResults = ( @GlobalResults, @{ $Results || [] } );

                delete $ActiveChildPID{$PID};
            }
        }
    }

    return @GlobalResults;
}

#
# Print a useful summary and die in case of errors.
#
sub HandleResults {
    my ( $Self, %Param ) = @_;

    my @GlobalResults = @{ $Param{Results} // [] };

    my @ErrorResults = grep { $_->error() } @GlobalResults;
    if (@ErrorResults) {
        my $ErrorCount   = scalar(@ErrorResults);
        my $ErrorMessage = sprintf(
            _ReplaceColorTags("\n<red>Error: %d file(s) did not pass validation.</red>\n"),
            $ErrorCount,
        );
        if ( $ErrorCount < 10 ) {
            for my $Error (@ErrorResults) {
                $ErrorMessage .= " - " . $Error->path() . "\n";
            }
        }
        die "$ErrorMessage\n";
    }

    my @TidiedResults = grep { $_->state() eq 'tidied' } @GlobalResults;
    if (@TidiedResults) {
        printf(
            _ReplaceColorTags("\n<green>Validation finished,</green> <yellow>%d file(s) were tidied.</yellow>\n"),
            scalar(@TidiedResults),
        );

    }
    else {
        print _ReplaceColorTags("\n<green>Validation finished, no problems found.</green>\n");
    }

    return 1;
}

#
# Get a list (almost) all relative file paths from the root directory. This list is used in some plugins to make validation decisions,
#   not for the actual decision which files are to be validated.
#
sub GetFileListFromDirectory {
    my ( $Self, %Param ) = @_;

    # Only run once.
    return if @FileList;

    @FileList = $Self->FindFilesInDirectory( Directory => $Self->{root_dir} );

    return;
}

#
# Get a list of all relative file paths in a directory with some global ignores for speed's sake.
#
sub FindFilesInDirectory {
    my ( $Self, %Param ) = @_;

    my $Directory = $Param{Directory};

    my @Files;

    my $Wanted = sub {

        # Skip non-regular files and directories.
        return if ( !-f $File::Find::name );

        # Also skip symbolic links, TidyAll does not like them.
        return if ( -l $File::Find::name );

        # Some global hard ignores that are meant to speed up the loading process,
        #   as applying the TidyAll ignore/select rules can be quite slow.
        return if $File::Find::name =~ m{/\.git/};
        return if $File::Find::name =~ m{/\.tidyall.d/};
        return if $File::Find::name =~ m{/\.vscode/};
        return if $File::Find::name =~ m{/node_modules/};
        return if $File::Find::name =~ m{/js-cache/};
        return if $File::Find::name =~ m{/css-cache/};
        return if $File::Find::name =~ m{/var/tmp/} && $File::Find::name !~ m{.*\.sample$};
        return if $File::Find::name =~ m{/var/public/dist/};

        push @Files, File::Spec->abs2rel( $File::Find::name, $Self->{root_dir} );
    };

    File::Find::find(
        $Wanted,
        $Directory,
    );

    return @Files;
}

#
# Filter relative file paths for only the files that are matched by at least one plugin.
#
sub FilterMatchedFiles {
    my ( $Self, %Param ) = @_;

    return grep { $Self->plugins_for_path($_) } @{ $Param{Files} };
}

sub _ReplaceColorTags {
    my ($Text) = @_;

    $Text //= '';

    $Text =~ s{<(green|yellow|red)>(.*?)</\1>}{colored($2, $1)}gsmxe;

    return $Text;
}

1;
 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6Ok9UT0JPOjpHaXQ6OlByZUNvbW1pdDsKCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCj1oZWFkMSBTWU5PUFNJUwoKVGhpcyBjb21taXQgaG9vayBsb2FkcyB0aGUgT1RPQk8gdmVyc2lvbiBvZiBDb2RlOjpUaWR5QWxsCndpdGggdGhlIGN1c3RvbSBwbHVnaW5zLCBleGVjdXRlcyBpdCBmb3IgYW55IG1vZGlmaWVkIGZpbGVzCmFuZCByZXR1cm5zIGEgY29ycmVzcG9uZGluZyBzdGF0dXMgY29kZS4KCj1jdXQKCnVzZSBDd2Q7CnVzZSBGaWxlOjpTcGVjOwp1c2UgRmlsZTo6QmFzZW5hbWU7Cgp1c2UgQ29kZTo6VGlkeUFsbDsKdXNlIElQQzo6U3lzdGVtOjpTaW1wbGUgcXcoY2FwdHVyZXggcnVuKTsKdXNlIFRyeTo6VGlueTsKdXNlIFRpZHlBbGw6Ok9UT0JPOwp1c2UgTW9vOwoKc3ViIFJ1biB7CiAgICBteSAkU2VsZiA9IEBfOwoKICAgIHByaW50ICJPVE9CT0NvZGVQb2xpY3kgY29tbWl0IGhvb2sgc3RhcnRpbmcuLi5cbiI7CgogICAgbXkgJEVycm9yTWVzc2FnZTsKCiAgICB0cnkgewogICAgICAgICMgRmluZCBjb25mIGZpbGUgYXQgZ2l0IHJvb3QKICAgICAgICBteSAkUm9vdERpciA9IGNhcHR1cmV4KCAnZ2l0JywgInJldi1wYXJzZSIsICItLXNob3ctdG9wbGV2ZWwiICk7CiAgICAgICAgY2hvbXAoJFJvb3REaXIpOwoKICAgICAgICAjIEdhdGhlciBmaWxlIHBhdGhzIHRvIGJlIGNvbW1pdHRlZAogICAgICAgIG15ICRPdXRwdXQgPSBjYXB0dXJleCggJ2dpdCcsICJzdGF0dXMiLCAiLS1wb3JjZWxhaW4iICk7CgogICAgICAgICMgRmV0Y2ggb25seSBzdGFnZWQgZmlsZXMgdGhhdCB3aWxsIGJlIGNvbW1pdHRlZC4KICAgICAgICBteSBAQ2hhbmdlZEZpbGVzID0gZ3JlcCB7IC1mICYmICEtbCB9ICggJE91dHB1dCA9fiAvXltNQV0rXHMrKC4qKS9nbSApOwogICAgICAgIHB1c2ggQENoYW5nZWRGaWxlcywgZ3JlcCB7IC1mICYmICEtbCB9ICggJE91dHB1dCA9fiAvXlxzKlJNPytccysoLio/KVxzKy0+XHMrKC4qKS9nbSApOwogICAgICAgIHJldHVybiBpZiAhQENoYW5nZWRGaWxlczsKCiAgICAgICAgIyBBbHdheXMgaW5jbHVkZSBhbGwgU09QTSBmaWxlcyB0byB2ZXJpZnkgdGhlIGZpbGUgbGlzdC4KICAgICAgICBmb3IgbXkgJFNPUE1GaWxlICggbWFwIHsgRmlsZTo6U3BlYy0+YWJzMnJlbCggJF8sICRSb290RGlyICkgfSBnbG9iKCIkUm9vdERpci8qLnNvcG0iKSApIHsKICAgICAgICAgICAgaWYgKCAhZ3JlcCB7ICRfIGVxICRTT1BNRmlsZSB9IEBDaGFuZ2VkRmlsZXMgKSB7CiAgICAgICAgICAgICAgICBwdXNoIEBDaGFuZ2VkRmlsZXMsICRTT1BNRmlsZTsKICAgICAgICAgICAgfQogICAgICAgIH0KCiAgICAgICAgIyBGaW5kIE9UT0JPQ29kZVBvbGljeSBjb25maWd1cmF0aW9uCiAgICAgICAgbXkgJFNjcmlwdERpcmVjdG9yeTsKICAgICAgICBpZiAoIC1sICQwICkgewogICAgICAgICAgICAkU2NyaXB0RGlyZWN0b3J5ID0gZGlybmFtZSggcmVhZGxpbmsoJDApICk7CiAgICAgICAgfQogICAgICAgIGVsc2UgewogICAgICAgICAgICAkU2NyaXB0RGlyZWN0b3J5ID0gZGlybmFtZSgkMCk7CiAgICAgICAgfQogICAgICAgIG15ICRDb25maWdGaWxlID0gJFNjcmlwdERpcmVjdG9yeSAuICcvLi4vdGlkeWFsbHJjJzsKCiAgICAgICAgbXkgJFRpZHlBbGwgPSBUaWR5QWxsOjpPVE9CTy0+bmV3X2Zyb21fY29uZl9maWxlKAogICAgICAgICAgICAkQ29uZmlnRmlsZSwKICAgICAgICAgICAgY2hlY2tfb25seSA9PiAxLAogICAgICAgICAgICBtb2RlICAgICAgID0+ICdjb21taXQnLAogICAgICAgICAgICByb290X2RpciAgID0+ICRSb290RGlyLAogICAgICAgICAgICBkYXRhX2RpciAgID0+IEZpbGU6OlNwZWMtPnRtcGRpcigpLAogICAgICAgICk7CiAgICAgICAgJFRpZHlBbGwtPkRldGVybWluZUZyYW1ld29ya1ZlcnNpb25Gcm9tRGlyZWN0b3J5KCk7CiAgICAgICAgJFRpZHlBbGwtPkdldEZpbGVMaXN0RnJvbURpcmVjdG9yeSgpOwoKICAgICAgICBteSBAQ2hlY2tSZXN1bHRzID0gJFRpZHlBbGwtPlByb2Nlc3NQYXRoc1BhcmFsbGVsKAogICAgICAgICAgICBGaWxlUGF0aHMgPT4gWyBtYXAgeyIkUm9vdERpci8kXyJ9IEBDaGFuZ2VkRmlsZXMgXSwKICAgICAgICApOwoKICAgICAgICAkVGlkeUFsbC0+SGFuZGxlUmVzdWx0cygKICAgICAgICAgICAgUmVzdWx0cyA9PiBcQENoZWNrUmVzdWx0cywKICAgICAgICApOwogICAgfQogICAgY2F0Y2ggewogICAgICAgIG15ICRFeGNlcHRpb24gPSAkXzsKICAgICAgICBkaWUgIkVycm9yIGR1cmluZyBwcmUtY29tbWl0IGhvb2sgKHVzZSAtLW5vLXZlcmlmeSB0byBza2lwIGhvb2spOlxuJEV4Y2VwdGlvbiI7CiAgICB9OwogICAgaWYgKCRFcnJvck1lc3NhZ2UpIHsKICAgICAgICBkaWUgIiRFcnJvck1lc3NhZ2VcbllvdSBjYW4gdXNlIC0tbm8tdmVyaWZ5IHRvIHNraXAgdGhlIGhvb2tcbiI7CiAgICB9Cn0KCjE7Cg== # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

package TidyAll::OTOBO::Git::PreReceive;

use strict;
use warnings;

=head1 SYNOPSIS

This pre receive hook loads the OTOBO version of Code::TidyAll
with the custom plugins, executes it for any modified files
and returns a corresponding status code.

=cut

use Cwd;
use File::Spec;
use File::Basename;

use Code::TidyAll;
use IPC::System::Simple qw(capturex run);
use Try::Tiny;
use TidyAll::OTOBO;
use Moo;

# Ignore these repositories on the server so that we can always push to them.
my %IgnoreRepositories = (
    'codepolicy.git' => 1,
);

sub Run {
    my ( $Self, %Param ) = @_;

    my $ErrorMessage;
    try {

        print "OTOBOCodePolicy pre receive hook starting...\n";

        my $Input = $Param{Input};
        if ( !$Input ) {
            $Input = do { local $/ = undef; <> };
        }

        # Debug
        #print "Got data:\n$Input";

        my $RootDirectory = Cwd::realpath();
        local $ENV{GIT_DIR} = $RootDirectory;

        my $RepositoryName = [ split m{/}, $RootDirectory ]->[-1];
        if ( $IgnoreRepositories{$RepositoryName} ) {
            print "Skipping checks for repository $RepositoryName.\n";
            return;
        }

        $ErrorMessage = $Self->HandleInput($Input);
    }
    catch {
        my $Exception = $_;
        print STDERR "*** Error running pre-receive hook (allowing push to proceed):\n$Exception";
    };
    if ($ErrorMessage) {
        print STDERR "$ErrorMessage\n";
        print STDERR "\n*** Push contains files which do not satisfy the CodePolicy! ***\n";
        exit 1;
    }
}

sub HandleInput {
    my ( $Self, $Input ) = @_;

    my @Lines = split( m/\n/, $Input );

    my (@Results);

    LINE:
    for my $Line (@Lines) {
        chomp($Line);
        my ( $Base, $Commit, $Ref ) = split( m/\s+/, $Line );

        if ( $Commit =~ m/^0+$/ ) {

            # No target commit (branch / tag delete).
            next LINE;
        }

        if ( substr( $Ref, 0, 9 ) eq 'refs/tags' ) {

            # Only allow "rel-*" as name for new and updated tags.
            if ( $Ref !~ m{ \A refs/tags/rel-\d+_\d+_\d+ (_alpha\d+ | _beta\d+ | _rc\d+)? \z }xms ) {

                my $ErrorMessage = "Error: found invalid tag '$Ref' - please only use rel-A_B_C or rel-A_B_C_(alpha|beta|rc)D.";
                return $ErrorMessage;
            }

            # Valid tag.
            next LINE;
        }

        print "Checking framework version for $Ref... ";

        my @FileList = $Self->GetGitFileList($Commit);

        # Create tidyall for each branch separately
        my $TidyAll = $Self->CreateTidyAll( $Commit, \@FileList );

        my @ChangedFiles = $Self->GetChangedFiles( $Base, $Commit );

        # Always include all SOPM files to verify the file list.
        for my $SOPMFile ( grep { $_ =~ m{\.sopm$} } @FileList ) {
            if ( !grep { $_ eq $SOPMFile } @ChangedFiles ) {
                push @ChangedFiles, $SOPMFile;
            }
        }

        FILE:
        for my $File (@ChangedFiles) {

            # Don't try to validate deleted files.
            if ( !grep { $_ eq $File } @FileList ) {
                print "$File was deleted, ignoring.\n";
                next FILE;
            }

            # Get file from git repository.
            my $Contents = $Self->GetGitFileContents( $File, $Commit );

            # Only validate files which actually have some content.
            if ( $Contents =~ /\S/ && $Contents =~ /\n/ ) {
                push( @Results, $TidyAll->process_source( $Contents, $File ) );
            }
        }
    }

    if ( my @ErrorResults = grep { $_->error() } @Results ) {
        return sprintf( "Error: %d file(s) did not pass validation", scalar(@ErrorResults) );
    }

    return;
}

sub CreateTidyAll {
    my ( $Self, $Commit, $FileList ) = @_;

    # Find OTOBOCodePolicy configuration
    my $ConfigFile = dirname(__FILE__) . '/../../tidyallrc';

    my $TidyAll = TidyAll::OTOBO->new_from_conf_file(
        $ConfigFile,
        check_only => 1,
        mode       => 'commit',
    );

    # We cannot use these functions here because we have a bare git repository,
    #   so we have to do it on our own.
    #$TidyAll->DetermineFrameworkVersionFromDirectory();
    #$TidyAll->GetFileListFromDirectory();

    # Set the list of files to be checked
    @TidyAll::OTOBO::FileList = @{$FileList};

    # Now we try to determine the OTOBO version from the commit

    # Look for a RELEASE file first to determine the framework version
    if ( grep { $_ eq 'RELEASE' } @{$FileList} ) {
        my @Content = split /\n/, $Self->GetGitFileContents( 'RELEASE', $Commit );

        my ( $VersionMajor, $VersionMinor ) = $Content[1] =~ m{^VERSION\s+=\s+(\d+)\.(\d+)\.}xms;
        $TidyAll::OTOBO::FrameworkVersionMajor = $VersionMajor;
        $TidyAll::OTOBO::FrameworkVersionMinor = $VersionMinor;
    }

    # Look for any SOPM files
    else {
        FILE:
        for my $File ( @{$FileList} ) {
            if ( substr( $File, -5, 5 ) eq '.sopm' ) {
                my @Content = split /\n/, $Self->GetGitFileContents( $File, $Commit );

                for my $Line (@Content) {
                    if ( $Line =~ m{ <Framework (?: [ ]+ [^<>]* )? > }xms ) {
                        my ( $VersionMajor, $VersionMinor ) = $Line =~ m{ <Framework (?: [ ]+ [^<>]* )? > (\d+) \. (\d+) \. [^<*]+ <\/Framework> }xms;
                        if (
                            $VersionMajor > $TidyAll::OTOBO::FrameworkVersionMajor
                            || (
                                $VersionMajor == $TidyAll::OTOBO::FrameworkVersionMajor
                                && $VersionMinor > $TidyAll::OTOBO::FrameworkVersionMinor
                            )
                            )
                        {
                            $TidyAll::OTOBO::FrameworkVersionMajor = $VersionMajor;
                            $TidyAll::OTOBO::FrameworkVersionMinor = $VersionMinor;
                        }
                    }
                    elsif ( $Line =~ m{<Vendor>} && $Line !~ m{Rother OSS} ) {
                        $TidyAll::OTOBO::ThirdpartyModule = 1;
                    }
                }

                last FILE;
            }
        }
    }

    if ($TidyAll::OTOBO::FrameworkVersionMajor) {
        print
            "Found OTOBO version $TidyAll::OTOBO::FrameworkVersionMajor.$TidyAll::OTOBO::FrameworkVersionMinor\n";
    }
    else {
        print "Could not determine OTOBO version (assuming latest version)!\n";
    }

    if ($TidyAll::OTOBO::ThirdpartyModule) {
        print
            "This seems to be a module not copyrighted by Rother OSS GmbH. File copyright will not be changed.\n";
    }
    else {
        print
            "This module seems to be copyrighted by Rother OSS GmbH. File copyright will automatically be assigned to Rother OSS GmbH.\n";
        print
            "  If this is not correct, you can change the <Vendor> tag in your SOPM.\n";
    }

    return $TidyAll;
}

sub GetGitFileContents {
    my ( $Self, $File, $Commit ) = @_;
    my $Content = capturex( "git", "show", "$Commit:$File" );
    return $Content;
}

sub GetGitFileList {
    my ( $Self, $Commit ) = @_;
    my $Output = capturex( "git", "ls-tree", "--name-only", "-r", "$Commit" );
    return split /\n/, $Output;
}

sub GetChangedFiles {
    my ( $Self, $Base, $Commit ) = @_;

    # Only use the last commit if we have a new branch.
    #   This is not perfect, but otherwise quite complicated.
    if ( $Base =~ m/^0+$/ ) {
        my $Output = capturex( 'git', 'diff-tree', '--no-commit-id', '--name-only', '-r', $Commit );
        my @Files  = grep {/\S/} split( m/\n/, $Output );
        return @Files;
    }

    my $Output = capturex( 'git', "diff", "--numstat", "--name-only", "$Base..$Commit" );
    my @Files  = grep {/\S/} split( m/\n/, $Output );
    return @Files;
}

1;
 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

package TidyAll::Plugin::OTOBO::Common::Origin;

use strict;
use warnings;

use File::Basename;

use Moo;

extends qw(TidyAll::Plugin::OTOBO::Base);

=head1 SYNOPSIS

This plugin checks that only valid OTOBO origins are used
in customized/derived files.

=cut

sub transform_source {
    my ( $Self, $Code ) = @_;

    return $Code if $Self->IsPluginDisabled( Code => $Code );

    # Remove former-origin because it's not needed any more
    $Code =~ s{ ^ [ ]* (?: \# | \/\/ ) [ ]+ (?: \$ )* former-origin: .+? $ \n }{}xmsg;

    my $Origin = '$origin:';

    # Transfers the old origin
    #
    # # $origin: https://github.com/OTOBO/ITSMIncidentProblemManagement/blob/74efccbc7821537134b520b508a116afdd489ad4/Kernel/Modules/AgentTicketActionCommon.pm
    #
    # to the new
    #
    # # $origin: ITSMIncidentProblemManagement - 74efccbc7821537134b520b508a116afdd489ad4 - Kernel/Modules/AgentTicketActionCommon.pm
    #
    $Code =~ s{
        ^
        ( [ ]* (?: \# [ ]+  | \/\/ [ ]+ | <Git> ) )
        (?: \$ | ) origin: [ ]+ http (?: s | ) :\/\/ github \. com \/ OTOBO \/
        ( [^\/ \n]+ )
        \/ (?: blob\/ | commit\/ |  )
        ( [a-z0-9]+ )
        \/
        ( .+? )
        $
    }{$1$Origin $2 - $3 - $4}xms;

    # Transfers the old origin
    #
    # # $origin: https://git.otobo.com/otobo/ITSMIncidentProblemManagement/blobs/74efccbc7821537134b520b508a116afdd489ad4/Kernel/Modules/AgentTicketActionCommon.pm
    #
    # to the new
    #
    # # $origin: ITSMIncidentProblemManagement - 74efccbc7821537134b520b508a116afdd489ad4 - Kernel/Modules/AgentTicketActionCommon.pm
    #
    $Code =~ s{
        ^
        ( [ ]* (?: \# | \/\/ ) )
        [ ]+ (?: \$ | ) origin: [ ]+ http (?: s | ) :\/\/ git \. otobo \. com \/ otobo \/
        ( [^\/ \n]+ )
        \/ blobs \/
        ( [a-z0-9]+ )
        \/
        ( .+? )
        $
    }{$1 $Origin $2 - $3 - $4}xms;

    # Transfers an CVS OldId
    #
    # # $OldId: AgentTicketEmail.dtl,v 1.142.2.1 2011/09/07 20:53:50 en Exp $
    #
    # to the new origin
    #
    # # $origin: otobo - 0000000000000000000000000000000000000000 - AgentTicketEmail.dtl
    #

    if ( my ($FileString) = $Code =~ m{ ^ [ ]* (?: \# | \/\/ ) [ ]+ \$OldId: [ ]+ ( [^\n]+? ) ,v [ ]+ [^\n]+ \n }xms ) {

        my $FilePath = $FileString;

        if ( $FileString =~ m{ ^ [^\n]+ \. dtl $ }xms ) {
            $FilePath = 'Kernel/Output/HTML/Standard/' . $FileString;
        }
        elsif ( $FileString =~ m{ ^ [^\n]+ \. js $ }xms ) {
            $FilePath = 'var/httpd/htdocs/js/' . $FileString;
        }
        elsif ( $FileString =~ m{ ^ (?: Layout | NavBar | NotificationAgent | TicketOverview | TicketMenu | ToolBar | Dashboard ) [^\n]+ \. pm $ }xms ) {
            $FilePath = 'Kernel/Output/HTML/' . $FileString;
        }
        elsif ( $FileString =~ m{ ^ (?: Agent | Customer | Public ) [^\n]+ \. pm $ }xms ) {
            $FilePath = 'Kernel/Modules/' . $FileString;
        }
        elsif ( $FileString =~ m{ ^ [^\n]+ \. pm $ }xms ) {
            $FilePath = 'Kernel/System/' . $FileString;
        }

        $Code =~ s{
            ^ ( [ ]* (?: \# | \/\/ ) ) [ ]+ \$OldId: [ ]+ [^\n]+? ,v [ ]+ [^\n]+ \n
        }{$1 $Origin otobo - 0000000000000000000000000000000000000000 - $FilePath\n}xms;
    }


    # Check the origin if customization markers are found
    if ( $Code =~ m{ ^ [ ]* (?: \# | \/\/ ) [ ]+ --- [ ]* $ }xms ) {

        my $FoundOrigin;
        my $LineCounter = 0;
        ORIGINLINE:
        for my $Line ( split /\n/, $Code ) {
            $LineCounter++;

            last ORIGINLINE if $LineCounter > 10;

            next ORIGINLINE if $Line !~ m{ ^ [ ]* (?: \# | \/\/ ) [ ]+ \$origin: [ ]+ [^\n]+ $ }xms;

            $FoundOrigin = 1;
        }

        if ( !$FoundOrigin ) {

            my $PackageCounter = 0;

            PACKAGELINE:
            for my $Line ( split /\n/, $Code ) {

                next PACKAGELINE if $Line !~ m{ ^ package [ ]+ ( [A-Za-z0-9\:]+ ) \; $ }xms;

                # count lines with any 'package..;'
                $PackageCounter++;
            }

            return $Code if $PackageCounter == 0;

            # only one 'package' allowed per file - split first if there are more packages combined.
            if ($PackageCounter > 1) {
                return $Self->DieWithError("$PackageCounter package lines found.\n");
            }

            my ($FilePath) = $Code =~ m{ ^ package [ ]+ ( [A-Za-z0-9\:]+ ) \; $ }xms;

            # just allow Kernel and scripts::tests to be modified automatically
            return $Code if $FilePath !~ m{ ^ ( Kernel | scripts \:\: tests )? \:\: }xms;

            $FilePath =~ s{ \:\: }{/}gsmx;

            my $NewOrigin = $Origin . ' otobo - 0000000000000000000000000000000000000000 - ' . $FilePath . '.pm';

            # place new origin after Copyright
            $Code =~ s{ ( \# [ ]+ Copyright .* \/ \n \# [ ]+ -- \n \# [ ]+ ) }{$1$NewOrigin\n# --\n# }xms;
        }
    }

    return $Code;
}

sub validate_source {
    my ( $Self, $Code ) = @_;

    return $Code if $Self->IsPluginDisabled( Code => $Code );

    # Check the origin if customization markers are found
    if ( $Code =~ m{ ^ [ ]* (?: \# | \/\/ ) [ ]+ --- [ ]* $ }xms ) {

        my $FoundOrigin;
        my $Counter = 0;
        LINE:
        for my $Line ( split /\n/, $Code ) {

            $Counter++;

            last LINE if $Counter > 10;

            next LINE if $Line !~ m{ ^ [ ]* (?: \# | \/\/ ) [ ]+ \$origin: [ ]+ [^\n]+ $ }xms;

            $FoundOrigin = 1;
        }

        if (!$FoundOrigin) {
            return $Self->DieWithError("Customization markers found but no origin present.\n");
        }
    }

    return $Code;
}

sub validate_file {
    my ( $Self, $Filename ) = @_;

    return if $Self->IsPluginDisabled( Filename => $Filename );

    my $Code = $Self->_GetFileContents($Filename);

    # Check if all files in the Custom directory has an origin
    if ( $Filename =~ m{ \/Custom\/ }xms ) {

        # Check if an origin exist.
        if ( $Code !~ m{ ^ [ ]* (?: \# | \/\/ ) [ ]+ \$origin: [ ]+ [^\n]+ $ }xms ) {
            return $Self->DieWithError("File is in Custom directory but no origin present.\n");
        }
    }

    if ( $Filename =~ m{ .* \.css }xmsi ) {

        # Check if a CSS file is overritten in Custom directory.
        if ( $Filename =~ m{ \/Custom\/var\/ }xms ) {

            return $Self->DieWithError(<<"EOF");
Forbidden to have a CSS file in Custom folder, because it's not allowed to override an existing CSS file.
Use a new one to override existing CSS classes.
EOF
        }

        # Check if an origin exist.
        if ( $Code =~ m{ ^ [ ]* (?: \# | \/\/ | \* ) [ ]+ (?: \$ | \@ ) origin: [ ]+ [^\n]+ $ }xms ) {

            return $Self->DieWithError(<<"EOF");
Forbidden to have an origin in a CSS file, because it's not allowed to override an existing CSS file.
Use a new one to override existing CSS classes.
EOF
        }

        # Check if customization markers exists.
        if ( $Code =~ m{ ^ [ ]* (?: \# | \/\/ | \* | \/\* ) [ ]+ --- [ ]* $ }xms ) {

            return $Self->DieWithError(<<"EOF");
Forbidden to have customization markers in a CSS file, because it's not allowed to override an existing CSS file.
Use a new one to override existing CSS classes.
EOF
        }
    }

    return;
}

1;
 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 b3RvYm8KaXRzbQpzbGEK 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 aW1wb3J0IGdsb2JhbHMgZnJvbSAiZ2xvYmFscyI7CmltcG9ydCBwbHVnaW5KcyBmcm9tICJAZXNsaW50L2pzIgoKLy8gSW1wb3J0IGN1c3RvbSBydWxlcwppbXBvcnQgbm9XaW5kb3cgZnJvbSAiLi9SdWxlcy9uby13aW5kb3cubWpzIjsKCi8qKiBAdHlwZSB7aW1wb3J0KCdlc2xpbnQnKS5MaW50ZXIuQ29uZmlnW119ICovCmV4cG9ydCBkZWZhdWx0IFsKICBwbHVnaW5Kcy5jb25maWdzLnJlY29tbWVuZGVkLAogIHsKICAgIGxhbmd1YWdlT3B0aW9uczogeyAKICAgICAgc291cmNlVHlwZTogImNvbW1vbmpzIiwgCiAgICAgIGdsb2JhbHM6IHsKICAgICAgICAuLi5nbG9iYWxzLmJyb3dzZXIsIAogICAgICAgIC4uLmdsb2JhbHMuanF1ZXJ5LAogICAgICAgIGlzSlF1ZXJ5T2JqZWN0OiAicmVhZG9ubHkiLAogICAgICAgIENLRWRpdG9yNVdyYXBwZXI6ICJyZWFkb25seSIsCiAgICAgICAgQ0tFZGl0b3I1UGx1Z2luczogInJlYWRvbmx5IiwKICAgICAgICBDS0VkaXRvcjVDb3JlVHJhbnNsYXRpb25zOiAicmVhZG9ubHkiLAogICAgICAgIENLRWRpdG9ySW5zdGFuY2VzOiAicmVhZG9ubHkiLAogICAgICAgIFFVbml0OiAicmVhZG9ubHkiLAogICAgICAgIENvZGVNaXJyb3I6ICJyZWFkb25seSIKICAgICAgfQogICAgfSwKICAgIGlnbm9yZXM6IFsKICAgICAgInZhci9odHRwZC9odGRvY3MvanMvdGhpcmRwYXJ0eS8qKiIsCiAgICAgICJ2YXIvaHR0cGQvaHRkb2NzL2pzL2pzLWNhY2hlLyoqIiwKICAgICAgInZhci9odHRwZC9odGRvY3MvanMvQ29yZS5VSS5DS0VkaXRvcjVXcmFwcGVyLmpzIiAgLy8gaGFzIHRvIGJlIGlnbm9yZWQgZHVlIHRvIHVzaW5nIGltcG9ydC9leHBvcnQgaW4gYSBub24tbW9kdWxlIGZpbGUKICAgIF0sCiAgICBmaWxlczogWyIqKi8qLmpzIl0sIAogICAgcGx1Z2luczogewogICAgICBvdG9ibzogewogICAgICAgIHJ1bGVzOiB7CiAgICAgICAgICAnbm8td2luZG93Jzogbm9XaW5kb3cKICAgICAgICB9CiAgICAgIH0KICAgIH0sCiAgICBydWxlczogewogICAgICAnb3RvYm8vbm8td2luZG93JzogJ2Vycm9yJywKICAgICAgJ2NhbWVsY2FzZSc6ICd3YXJuJywKICAgICAgLy8gVGhlIGZvbGxvd2luZyBydWxlcyBhcmUgdGVtcGFyb3JpbHkgc2V0IHRvICd3YXJuJyB0byBhdm9pZCBicmVha2luZyBleGlzdGluZyBjb2RlCgogICAgICAnbm8tcHJvdG90eXBlLWJ1aWx0aW5zJzogJ3dhcm4nLAogICAgICAnbm8tdW51c2VkLXZhcnMnOiAnd2FybicsCiAgICAgICduby1yZWRlY2xhcmUnOiAnd2FybicsCiAgICAgICduby11bmRlZic6ICd3YXJuJywKICAgICAgJ25vLXVzZWxlc3MtZXNjYXBlJzogJ3dhcm4nCgogICAgfQogIH0KXTs= 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 Ly8gLS0KLy8gT1RPQk8gaXMgYSB3ZWItYmFzZWQgdGlja2V0aW5nIHN5c3RlbSBmb3Igc2VydmljZSBvcmdhbmlzYXRpb25zLgovLyAtLQovLyBDb3B5cmlnaHQgKEMpIDIwMDEtMjAyMCBPVFJTIEFHLCBodHRwczovL290cnMuY29tLwovLyBDb3B5cmlnaHQgKEMpIDIwMTktMjAyNSBSb3RoZXIgT1NTIEdtYkgsIGh0dHBzOi8vb3RvYm8uaW8vCi8vIC0tCi8vIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOiB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0IHVuZGVyCi8vIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCi8vIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi8vIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVAovLyBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUwovLyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLy8gWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLy8gYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uIElmIG5vdCwgc2VlIDxodHRwczovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uCi8vIC0tCgovKgogKiBOT1RFOiBJbiBvcmRlciBmb3IgbGludGluZyB0byB3b3JrLCB5b3Ugd2lsbCBuZWVkIGZvbGxvd2luZyBnbG9iYWxseSBpbnN0YWxsZWQgTlBNIG1vZHVsZXMKICoKICogICBucG0gaW5zdGFsbCAtZyBlc2xpbnRANSBlc2xpbnQtcGx1Z2luLWltcG9ydCBlc2xpbnQtY29uZmlnLWFpcmJuYi1iYXNlIGVzbGludC1wbHVnaW4tdnVlIGJhYmVsLWVzbGludCBlc2xpbnQtcGx1Z2luLWplc3QKICoKICogRklYTUU6IFdlIGhhdmUgdG8gcGluIHRoZSBFU0xpbnQgdmVyc2lvbiB0byA1Lnggc2luY2Ugbm90IGFsbCBwbHVnaW5zIHdlIHVzZSBhcmUgY29tcGF0aWJsZSB3aXRoIDYueCBqdXN0IHlldC4KICovCgptb2R1bGUuZXhwb3J0cyA9IHsKCiAgICBwYXJzZXJPcHRpb25zOiB7CiAgICAgICAgcGFyc2VyOiAnYmFiZWwtZXNsaW50JywKICAgICAgICBzb3VyY2VUeXBlOiAnbW9kdWxlJwogICAgfSwKCiAgICBwbHVnaW5zOiBbCiAgICAgICAgJ2plc3QnLAogICAgXSwKCiAgICBlbnY6IHsKICAgICAgICBicm93c2VyOiB0cnVlLAogICAgICAgICdqZXN0L2dsb2JhbHMnOiB0cnVlLAogICAgfSwKCiAgICBleHRlbmRzOiBbCiAgICAgICAgJ2FpcmJuYi1iYXNlJywKICAgICAgICAncGx1Z2luOnZ1ZS9yZWNvbW1lbmRlZCcsCiAgICBdLAoKICAgIGdsb2JhbHM6IHsKICAgICAgICAndHJhbnNsYXRhYmxlJzogdHJ1ZSwKICAgIH0sCgogICAgcnVsZXM6IHsKCiAgICAgICAgLyoKICAgICAgICAgKiBBaXJCbkIgSlMgcnVsZSBvdmVycmlkZXMuCiAgICAgICAgICovCgogICAgICAgIC8vIEVuZm9yY2UgY29uc2lzdGVudCBpbmRlbnRhdGlvbi4KICAgICAgICAnaW5kZW50JzogWyAnZXJyb3InLCA0LCB7CiAgICAgICAgICAgICdTd2l0Y2hDYXNlJzogMSwKICAgICAgICAgICAgLy8gRml4IGlzc3VlIHdpdGggYENhbm5vdCByZWFkIHByb3BlcnR5ICdyYW5nZScgb2YgbnVsbGAgZXJyb3JzLiBQbGVhc2Ugc2VlCiAgICAgICAgICAgIC8vICAgaHR0cHM6Ly9zdGFja292ZXJmbG93LmNvbS9xdWVzdGlvbnMvNDgzOTE5MTMvZXNsaW50LWVycm9yLWNhbm5vdC1yZWFkLXByb3BlcnR5LXJhbmdlLW9mLW51bGwKICAgICAgICAgICAgLy8gICBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KICAgICAgICAgICAgJ2lnbm9yZWROb2Rlcyc6IFsgJ1RlbXBsYXRlTGl0ZXJhbCcgXSwKICAgICAgICB9XSwKCiAgICAgICAgLy8gRml4IGlzc3VlIHdpdGggYENhbm5vdCByZWFkIHByb3BlcnR5ICdyYW5nZScgb2YgbnVsbGAgZXJyb3JzLiBQbGVhc2Ugc2VlCiAgICAgICAgLy8gICBodHRwczovL3N0YWNrb3ZlcmZsb3cuY29tL3F1ZXN0aW9ucy80ODM5MTkxMy9lc2xpbnQtZXJyb3ItY2Fubm90LXJlYWQtcHJvcGVydHktcmFuZ2Utb2YtbnVsbAogICAgICAgIC8vICAgZm9yIG1vcmUgaW5mb3JtYXRpb24uCiAgICAgICAgJ3RlbXBsYXRlLWN1cmx5LXNwYWNpbmcnOiAnb2ZmJywKCiAgICAgICAgLy8gQWxsb3cgdW5uZWNlc3NhcmlseSBxdW90ZWQgcHJvcGVydGllcy4KICAgICAgICAncXVvdGUtcHJvcHMnOiAnb2ZmJywKCiAgICAgICAgLy8gQWxsb3cgZGFuZ2xpbmcgdW5kZXJzY29yZXMgdG8gaW5kaWNhdGUgcHJpdmF0ZSBtZXRob2RzIChsaWtlIF9pbnRlcm5hbE1ldGhvZCgpKS4KICAgICAgICAnbm8tdW5kZXJzY29yZS1kYW5nbGUnOiAnb2ZmJywKCiAgICAgICAgLy8gRW5mb3JjZSBhIG1heGltdW0gbGluZSBsZW5ndGguCiAgICAgICAgJ21heC1sZW4nOiBbICdlcnJvcicsIHsgJ2NvZGUnOiAxMjAgfSBdLAoKICAgICAgICAvLyBEb24ndCB0cnkgdG8gcmVzb2x2ZSB0aGUgZGVwZW5kZW5jaWVzLgogICAgICAgICdpbXBvcnQvbm8tdW5yZXNvbHZlZCc6ICdvZmYnLAoKICAgICAgICAvLyBBbGxvdyBmb3IgbWlzc2luZyBmaWxlIGV4dGVuc2lvbnMgaW4gaW1wb3J0IHN0YXRlbWVudHMuCiAgICAgICAgJ2ltcG9ydC9leHRlbnNpb25zJzogJ29mZicsCgogICAgICAgIC8vIFJlcXVpcmUgYSBzcGFjZSBiZWZvcmUgZnVuY3Rpb24gcGFyZW50aGVzaXMuCiAgICAgICAgJ3NwYWNlLWJlZm9yZS1mdW5jdGlvbi1wYXJlbic6IFsgJ2Vycm9yJywgJ2Fsd2F5cycgXSwKCiAgICAgICAgLy8gUmVxdWlyZSAiU3Ryb3VzdHJ1cCIgYnJhY2Ugc3R5bGUuCiAgICAgICAgJ2JyYWNlLXN0eWxlJzogWyAnZXJyb3InLCAnc3Ryb3VzdHJ1cCcgXSwKCiAgICAgICAgLy8gRW5mb3JjZSBzcGFjZXMgaW5zaWRlIG9mIGJyYWNrZXRzLgogICAgICAgICdhcnJheS1icmFja2V0LXNwYWNpbmcnOiBbICdlcnJvcicsICdhbHdheXMnIF0sCgogICAgICAgIC8vIERvIG5vdCBlbmZvcmNlIHRoYXQgY2xhc3MgbWV0aG9kcyB1dGlsaXplIHRoaXMuCiAgICAgICAgJ2NsYXNzLW1ldGhvZHMtdXNlLXRoaXMnOiAnb2ZmJywKCiAgICAgICAgLy8gQWxsb3cgdGhlIHVuYXJ5IG9wZXJhdG9ycyArKyBhbmQgLS0uCiAgICAgICAgJ25vLXBsdXNwbHVzJzogJ29mZicsCgogICAgICAgIC8vIEFsbG93IFJlYXNzaWdubWVudCBvZiBGdW5jdGlvbiBQYXJhbWV0ZXJzLgogICAgICAgICduby1wYXJhbS1yZWFzc2lnbic6ICdvZmYnLAoKICAgICAgICAvLyBFbmZvcmNlIGNvbnNpc3RlbnQgbGluZSBicmVha3MgaW5zaWRlIGZ1bmN0aW9uIHBhcmVudGhlc2VzLgogICAgICAgICdmdW5jdGlvbi1wYXJlbi1uZXdsaW5lJzogWyAnZXJyb3InLCAnY29uc2lzdGVudCcgXSwKCiAgICAgICAgLy8gSWdub3JlIHRyYWlsaW5nIGNvbW1hcyBpbiB0aGUgaW1wb3J0cywgZXhwb3J0cyBhbmQgZnVuY3Rpb25zLCBidXQgcmVxdWlyZSBpdCBpbiBhcnJheXMgYW5kIG9iamVjdAogICAgICAgIC8vICAgZGVmaW5pdGlvbnMuCiAgICAgICAgJ2NvbW1hLWRhbmdsZSc6IFsKICAgICAgICAgICAgJ2Vycm9yJywKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgJ2FycmF5cyc6ICdhbHdheXMtbXVsdGlsaW5lJywKICAgICAgICAgICAgICAgICdvYmplY3RzJzogJ2Fsd2F5cy1tdWx0aWxpbmUnLAogICAgICAgICAgICAgICAgJ2ltcG9ydHMnOiAnaWdub3JlJywKICAgICAgICAgICAgICAgICdleHBvcnRzJzogJ2lnbm9yZScsCiAgICAgICAgICAgICAgICAnZnVuY3Rpb25zJzogJ2lnbm9yZScsCiAgICAgICAgICAgIH0sCiAgICAgICAgXSwKCiAgICAgICAgLy8gRG8gbm90IGZvcmNlIHRoZSB1c2Ugb2YgdGhlIG9iamVjdCBzcHJlYWQganVzdCB5ZXQgKHRhcmdldCBFUzIwMTgpLgogICAgICAgICdwcmVmZXItb2JqZWN0LXNwcmVhZCc6ICdvZmYnLAoKICAgICAgICAvLyBEbyBub3QgZm9yY2UgcGFyZW50aGVzZXMgb24gYXJyb3cgZnVuY3Rpb25zIHdpdGggc2luZ2xlIGFyZ3VtZW50cy4KICAgICAgICAnYXJyb3ctcGFyZW5zJzogJ29mZicsCgogICAgICAgIC8vIEFsbG93IHJlcXVpcmUoKSBjYWxscyB3aXRoIGV4cHJlc3Npb25zIChkeW5hbWljIGltcG9ydHMpLgogICAgICAgICdpbXBvcnQvbm8tZHluYW1pYy1yZXF1aXJlJzogJ29mZicsCgogICAgICAgIC8qCiAgICAgICAgICogVnVlLmpzIHJ1bGUgb3ZlcnJpZGVzLgogICAgICAgICAqLwoKICAgICAgICAvLyBFbmZvcmNlIGNvbnNpc3RlbnQgaW5kZW50YXRpb24gaW4gPHRlbXBsYXRlPi4KICAgICAgICAndnVlL2h0bWwtaW5kZW50JzogWyAnZXJyb3InLCA0IF0sCgogICAgICAgIC8vIEVuZm9yY2Ugdi1iaW5kIGRpcmVjdGl2ZSB1c2FnZSBpbiBsb25nIGZvcm0uCiAgICAgICAgJ3Z1ZS92LWJpbmQtc3R5bGUnOiBbICdlcnJvcicsICdsb25nZm9ybScgXSwKCiAgICAgICAgLy8gRW5mb3JjZSB2LW9uIGRpcmVjdGl2ZSB1c2FnZSBpbiBsb25nIGZvcm0uCiAgICAgICAgJ3Z1ZS92LW9uLXN0eWxlJzogIFsgJ2Vycm9yJywgJ2xvbmdmb3JtJyBdLAoKICAgICAgICAvLyBEb24ndCByZXF1aXJlIGRlZmF1bHQgdmFsdWUgZm9yIHByb3BzLgogICAgICAgICd2dWUvcmVxdWlyZS1kZWZhdWx0LXByb3AnOiAnb2ZmJywKCiAgICAgICAgLy8gRG9uJ3Qgd2FybiBhYm91dCB1bnVzZWQgY29tcG9uZW50cy4gVGhpcyBpcyBzb21ldGltZSBuZWVkZWQgZm9yIGR5bmFtaWMgY29tcG9uZW50IHVzYWdlLgogICAgICAgICd2dWUvbm8tdW51c2VkLWNvbXBvbmVudHMnOiAnb2ZmJywKCiAgICAgICAgLy8gRG9uJ3QgY29ycmVjdCBjYXNpbmcgb2YgY29tcG9uZW50IG5hbWVzIGZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5IHJlYXNvbnMuCiAgICAgICAgJ3Z1ZS9jb21wb25lbnQtbmFtZS1pbi10ZW1wbGF0ZS1jYXNpbmcnOiAnb2ZmJywKCiAgICAgICAgLy8gRG9uJ3QgY29ycmVjdCBjbG9zaW5nIGJyYWNrZXQgcG9zaXRpb24gb2YgSFRNTCB0YWdzIGZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5IHJlYXNvbnMuCiAgICAgICAgJ3Z1ZS9odG1sLWNsb3NpbmctYnJhY2tldC1uZXdsaW5lJzogJ29mZicsCgogICAgICAgIC8vIERvbid0IGNvcnJlY3QgbmV3IGxpbmVzIGluIHNpbmdsZSBsaW5lIEhUTUwgZWxlbWVudHMgZm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgcmVhc29ucy4KICAgICAgICAndnVlL3NpbmdsZWxpbmUtaHRtbC1lbGVtZW50LWNvbnRlbnQtbmV3bGluZSc6ICdvZmYnLAogICAgfSwKfTsK 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OkphdmFTY3JpcHQ6OlVubG9hZEV2ZW50OwoKdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKdXNlIE1vbzsKCmV4dGVuZHMgcXcoVGlkeUFsbDo6UGx1Z2luOjpPVE9CTzo6QmFzZSk7CgpzdWIgdmFsaWRhdGVfc291cmNlIHsKICAgIG15ICggJFNlbGYsICRDb2RlICkgPSBAXzsKCiAgICByZXR1cm4gaWYgJFNlbGYtPklzUGx1Z2luRGlzYWJsZWQoIENvZGUgPT4gJENvZGUgKTsKCiAgICBteSAkRXJyb3JNZXNzYWdlOwogICAgbXkgJENvdW50ZXI7CgogICAgZm9yIG15ICRMaW5lICggc3BsaXQoIC9cbi8sICRDb2RlICkgKSB7CiAgICAgICAgJENvdW50ZXIrKzsKICAgICAgICBpZiAoICRMaW5lID1+IG17IFwuYmluZFwoWyciXXVubG9hZCB9eG1zIHx8ICRMaW5lID1+IG17IFwub25cKFsnIl11bmxvYWQgfXhtcyApIHsKICAgICAgICAgICAgJEVycm9yTWVzc2FnZQogICAgICAgICAgICAgICAgLj0gIkVSUk9SOiBGb3VuZCB3aW5kb3cgdW5sb2FkIGV2ZW50IGluIGxpbmUoICRDb3VudGVyICk6ICRMaW5lXG4iOwogICAgICAgICAgICAkRXJyb3JNZXNzYWdlIC49ICJQbGVhc2UgdXNlIENvcmUuQXBwLkJpbmRXaW5kb3dVbmxvYWRFdmVudCgpIGZvciBjcm9zcy1icm93c2VyIGNvbXBhdGliaWxpdHkuXG4iOwogICAgICAgIH0KICAgIH0KCiAgICBpZiAoJEVycm9yTWVzc2FnZSkgewogICAgICAgIHJldHVybiAkU2VsZi0+RGllV2l0aEVycm9yKCIkRXJyb3JNZXNzYWdlIik7CiAgICB9Cn0KCjE7Cg== # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

package TidyAll::Plugin::OTOBO::Legal::LicenseValidator;
## nofilter(TidyAll::Plugin::OTOBO::Common::CustomizationMarkers)
## nofilter(TidyAll::Plugin::OTOBO::Legal::LicenseValidator)

use strict;
use warnings;

use Moo;

extends qw(TidyAll::Plugin::OTOBO::Base);

sub transform_source {
    my ( $Self, $Code ) = @_;

    return $Code if $Self->IsPluginDisabled( Code => $Code );

    # insert license header transformations

    return $Code;
}

sub validate_file {
    my ( $Self, $Filename ) = @_;

    return if $Self->IsPluginDisabled( Filename => $Filename );

    my $Code = $Self->_GetFileContents($Filename);

    # extract the last part of the extension,
    # e.g. 'dist' from DockerConfig.xml.dist
    my ($Filetype) = $Filename =~ m{ .* \. ( .+ ) }xmsi;
    $Filetype ||= '';

    # in some cases the next to last extension part is the relevant part,
    # e.g. 'xml' from DockerConfig.xml.dist
    if ( $Filetype eq 'skel' ) {
        ($Filetype) = $Filename =~ m{ .* \. ( .+ ) \.skel }xmsi;
    }
    elsif ( $Filetype eq 'dist' ) {
        my ($NextToLastFiletype) = $Filename =~ m{ .* \. ( .+ ) \.dist }xmsi;
        $Filetype = $NextToLastFiletype // 'dist';
    }

    # Check a javascript license header.
    if ( lc $Filetype eq 'js' ) {

        my $Description   = _DescJS();
        my $GPLJavaScript = _GPLJavaScript();

        if ( $Code !~ m{\Q$GPLJavaScript\E} ) {
            return $Self->DieWithError("Found no valid javascript license header!");
        }
        if ( $Code !~ m{\Q$Description\E} ) {
            return $Self->DieWithError("Found no valid description in javascript license header!");
        }
    }

    # Check a perl script license header.
    elsif ( lc $Filetype eq 'pl' || lc $Filetype eq 'psgi' || lc $Filetype eq 'sh' || lc $Filetype eq 't' ) {

        my $Description   = _DescPerl();
        my $GPLPerlScript = _GPLPerlScript();

        if ( $Code !~ m{\Q$GPLPerlScript\E} ) {
            return $Self->DieWithError("Found no valid perl script license header!");
        }
        if ( $Code !~ m{\Q$Description\E} ) {
            return $Self->DieWithError("Found no valid description in perl license header!");
        }
    }

    # Check css license header.
    elsif ( lc $Filetype eq 'css' || lc $Filetype eq 'scss' ) {

        my $Description = _DescCss();
        my $GPLCss      = _GPLCss();

        if ( $Code !~ m{\Q$GPLCss\E} ) {
            return $Self->DieWithError("Found no valid css license header!");
        }
        if ( $Code !~ m{\Q$Description\E} ) {
            return $Self->DieWithError("Found no valid description in css license header!");
        }
    }

    # Check vue license header.
    elsif ( lc $Filetype eq 'vue' ) {

        my $GPLVue = _GPLVue();

        if ( $Code !~ m{\Q$GPLVue\E} ) {
            return $Self->DieWithError("Found no valid vue license header!");
        }
    }

    # Check xml license tag.
    elsif ( lc $Filetype eq 'xml' ) {

        # Do not validate XML files, because there a so many different content (config XML, documentation XML, ...)
    }

    # Check opm and sopm license tag.
    elsif ( lc $Filetype eq 'sopm' || lc $Filetype eq 'opm' ) {

        my $GPLOPM = _GPLOPM();

        if ( $Code !~ m{\Q$GPLOPM\E} ) {
            return $Self->DieWithError("Found no valid OPM license header!");
        }
    }

    # Check generic license header.
    else {

        my $GPLGeneric = _GPLGeneric();

        if ( $Code !~ m{\Q$GPLGeneric\E} ) {
            return $Self->DieWithError("Found no valid license header!");
        }
    }

    # Check perldoc license header.
    if ( lc $Filetype eq 'pl' || lc $Filetype eq 'pm' ) {

        if ( $Code =~ m{ =head1 \s+ TERMS \s+ AND \s+ CONDITIONS \n+ This \s+ software \s+ is \s+ part }smx ) {

            my $GPLPerldoc = _GPLPerldoc();

            if ( $Code !~ m{\Q$GPLPerldoc\E} ) {
                return $Self->DieWithError("Found no valid perldoc license header!");
            }
        }
    }

}

sub _GPLPerlScript {
    return <<'END_GPLPERLSCRIPT';
# --
# 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/>.
# --
END_GPLPERLSCRIPT
}

sub _GPLJavaScript {
    return <<'END_GPLJAVASCRIPT';
// --
// 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/>.
// --
END_GPLJAVASCRIPT
}

sub _GPLCss {
    return <<'END_GPLCSS';

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/>.
*/
END_GPLCSS
}

sub _GPLVue {
    return <<'END_GPLVUE';

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/>.
-->
END_GPLVUE
}

sub _GPLOPM {
    return '<License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>';
}

sub _GPLGeneric {
    return <<'END_GPLGENERIC';
# --
# 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/>.
# --
END_GPLGENERIC
}

sub _GPLPerldoc {

    # avoid that CodePolicy incorrectly detects real POD
    return '=head1 ' . <<'END_GPLPERLDOC';
TERMS AND CONDITIONS

This software is part of the OTOBO project (L<https://otobo.org/>).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see L<https://www.gnu.org/licenses/gpl-3.0.txt>.
END_GPLPERLDOC

}

sub _DescPerl {
    return <<'END_DESCPERLSCRIPT';
# --
# OTOBO is a web-based ticketing system for service organisations.
# --
END_DESCPERLSCRIPT
}

sub _DescJS {
    return <<'END_DESCJS';
// --
// OTOBO is a web-based ticketing system for service organisations.
// --
END_DESCJS
}

sub _DescCss {
    return <<'END_DESCCSS';
/* OTOBO is a web-based ticketing system for service organisations.

END_DESCCSS
}

1;
 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86Ok1pZ3JhdGlvbnM6Ok9UT0JPMTA6OlRpbWVab25lT2Zmc2V0OwoKdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKdXNlIE1vbzsKCmV4dGVuZHMgcXcoVGlkeUFsbDo6UGx1Z2luOjpPVE9CTzo6QmFzZSk7CgpzdWIgdmFsaWRhdGVfc291cmNlIHsKICAgIG15ICggJFNlbGYsICRDb2RlICkgPSBAXzsKCiAgICByZXR1cm4gaWYgJFNlbGYtPklzUGx1Z2luRGlzYWJsZWQoIENvZGUgPT4gJENvZGUgKTsKCiAgICAjIGFjdGl2ZSBvbmx5IGZvciBPVE9CTyAxMAogICAgcmV0dXJuIHVubGVzcyAkU2VsZi0+SXNGcmFtZXdvcmtWZXJzaW9uTGVzc1RoYW4oIDExLCAwICk7CgogICAgbXkgKCAkQ291bnRlciwgJEVycm9yTWVzc2FnZSApOwoKICAgIGZvciBteSAkTGluZSAoIHNwbGl0IC9cbi8sICRDb2RlICkgewogICAgICAgICRDb3VudGVyKys7CgogICAgICAgICMgTG9vayBmb3IgY29kZSB0aGF0IG1pZ2h0IGNvbnRhaW4gb2xkIHRpbWUgem9uZSBvZmZzZXQgY2FsY3VsYXRpb25zCiAgICAgICAgaWYgKAogICAgICAgICAgICAkTGluZSA9fiBteyh0aW1lem9uZXx0aW1lIHpvbmUpfXNtaQogICAgICAgICAgICAmJiAkTGluZSA9fiBtezM2MDB9c21pCiAgICAgICAgICAgICkKICAgICAgICB7CiAgICAgICAgICAgICRFcnJvck1lc3NhZ2UgLj0gIkxpbmUgJENvdW50ZXI6ICRMaW5lXG4iOwogICAgICAgIH0KICAgIH0KCiAgICBpZiAoJEVycm9yTWVzc2FnZSkgewogICAgICAgIHJldHVybiAkU2VsZi0+RGllV2l0aEVycm9yKDw8IkVPRiIpOwpDb2RlIG1pZ2h0IGNvbnRhaW4gZGVwcmVjYXRlZCB0aW1lIHpvbmUgb2Zmc2V0IGNhbGN1bGF0aW9ucy4gT25seSB1c2UgbWV0aG9kcyBwcm92aWRlZCBieSBLZXJuZWw6OlN5c3RlbTo6RGF0ZVRpbWUgdG8gY2hhbmdlIHRpbWUgem9uZXMgYW5kIGNhbGN1bGF0ZSBkYXRlL3RpbWUuCiRFcnJvck1lc3NhZ2UKRU9GCiAgICB9CgogICAgcmV0dXJuOwp9CgoxOwo= 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw7Cgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7CnVzZSB2NS4yNDsKdXNlIHV0Zjg7Cgp1c2UgTW9vOwoKZXh0ZW5kcyBxdyhUaWR5QWxsOjpQbHVnaW46Ok9UT0JPOjpCYXNlKTsKCnVzZSBQb2Q6OlN0cmlwKCk7CgojIFByb2Nlc3MgUGVybCBjb2RlIGFuZCByZXBsYWNlIGFsbCBQb2Qgc2VjdGlvbnMgd2l0aCBjb21tZW50cy4Kc3ViIFN0cmlwUG9kIHsKICAgIG15ICggJFNlbGYsICVQYXJhbSApID0gQF87CgogICAgbXkgJFBvZFN0cmlwID0gUG9kOjpTdHJpcC0+bmV3KCk7CiAgICAkUG9kU3RyaXAtPnJlcGxhY2Vfd2l0aF9jb21tZW50cygxKTsKICAgIG15ICRDb2RlOwogICAgJFBvZFN0cmlwLT5vdXRwdXRfc3RyaW5nKCBcJENvZGUgKTsKICAgICRQb2RTdHJpcC0+cGFyc2Vfc3RyaW5nX2RvY3VtZW50KCAkUGFyYW17Q29kZX0gKTsKICAgIHJldHVybiAkQ29kZTsKfQoKc3ViIFN0cmlwQ29tbWVudHMgewogICAgbXkgKCAkU2VsZiwgJVBhcmFtICkgPSBAXzsKCiAgICBteSAkQ29kZSA9ICRQYXJhbXtDb2RlfTsKICAgICRDb2RlID1+IHMvXiBccyogXCMgLio/ICQvXG4vc214ZzsKICAgIHJldHVybiAkQ29kZTsKfQoKMTsK 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFBlcmw6OkNyaXRpYzo6UG9saWN5OjpPVE9CTzo6UHJvaGliaXRHb3RvOwoKdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKdXNlIFBlcmw6OkNyaXRpYzo6VXRpbHMgcXd7fTsKdXNlIHBhcmVudCAnUGVybDo6Q3JpdGljOjpQb2xpY3knOwoKb3VyICRWRVJTSU9OID0gJzAuMDEnOwoKbXkgJERlc2NyaXB0aW9uID0gcXtEb24ndCB1c2UgImdvdG8iIGluIFBlcmwgY29kZS59OwpteSAkRXhwbGFuYXRpb24gPSBxe307CgpzdWIgc3VwcG9ydGVkX3BhcmFtZXRlcnMgeyByZXR1cm47IH0Kc3ViIGRlZmF1bHRfc2V2ZXJpdHkgICAgIHsgcmV0dXJuICRQZXJsOjpDcml0aWM6OlV0aWxzOjpTRVZFUklUWV9ISUdIRVNUOyB9CnN1YiBkZWZhdWx0X3RoZW1lcyAgICAgICB7IHJldHVybiBxdyggb3RvYm8gKSB9CnN1YiBhcHBsaWVzX3RvICAgICAgICAgICB7IHJldHVybiAnUFBJOjpUb2tlbjo6V29yZCcgfQoKc3ViIHZpb2xhdGVzIHsKICAgIG15ICggJFNlbGYsICRFbGVtZW50ICkgPSBAXzsKCiAgICByZXR1cm4gaWYgJEVsZW1lbnQgbmUgJ2dvdG8nOwogICAgcmV0dXJuICRTZWxmLT52aW9sYXRpb24oICREZXNjcmlwdGlvbiwgJEV4cGxhbmF0aW9uLCAkRWxlbWVudCApOwp9CgoxOwo= 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6OkZvck15OwoKdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKdXNlIEZpbGU6OkJhc2VuYW1lOwoKdXNlIE1vbzsKCmV4dGVuZHMgcXcoVGlkeUFsbDo6UGx1Z2luOjpPVE9CTzo6UGVybCk7CgpzdWIgdmFsaWRhdGVfc291cmNlIHsKICAgIG15ICggJFNlbGYsICRDb2RlICkgPSBAXzsKCiAgICByZXR1cm4gJENvZGUgaWYgJFNlbGYtPklzUGx1Z2luRGlzYWJsZWQoIENvZGUgPT4gJENvZGUgKTsKCiAgICBteSAoICRDb3VudGVyLCAkRXJyb3JNZXNzYWdlICk7CgogICAgZm9yIG15ICRMaW5lICggc3BsaXQgL1xuLywgJENvZGUgKSB7CiAgICAgICAgJENvdW50ZXIrKzsKCiAgICAgICAgaWYgKCAkTGluZSA9fiBte14gXHMqIGZvciAoZWFjaCk/IFxzKyBcJC4rIFxzKyBcKCAgfXhtcyApIHsKICAgICAgICAgICAgJEVycm9yTWVzc2FnZSAuPSAiTGluZSAkQ291bnRlcjogJExpbmVcbiI7CiAgICAgICAgfQogICAgfQoKICAgIGlmICgkRXJyb3JNZXNzYWdlKSB7CiAgICAgICAgcmV0dXJuICRTZWxmLT5EaWVXaXRoRXJyb3IoPDwiRU9GIik7ClBsZWFzZSB1c2UgbXkgdG8gZGVjbGFyZSB0aGUga2V5IHZhcmlhYmxlIGluCiRFcnJvck1lc3NhZ2UKRU9GCiAgICB9CgogICAgcmV0dXJuOwp9CgoxOwo= IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6OkZvcmVhY2hUb0ZvcjsKCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCnVzZSBGaWxlOjpCYXNlbmFtZTsKCnVzZSBNb287CgpleHRlbmRzIHF3KFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmwpOwoKc3ViIHRyYW5zZm9ybV9zb3VyY2UgewogICAgbXkgKCAkU2VsZiwgJENvZGUgKSA9IEBfOwoKICAgIHJldHVybiAkQ29kZSBpZiAkU2VsZi0+SXNQbHVnaW5EaXNhYmxlZCggQ29kZSA9PiAkQ29kZSApOwoKICAgICMgVGhlIGZvbGxvd2luZyB0ZXN0IG1hdGNoZXMgb25seSBmb3IgYSBmb3JlYWNoIHdpdGhvdXQgYSAiIyIgaW4gdGhlCiAgICAjIGJlZ2lubmluZyBvZiBhIGxpbmUuIFRoZSBmb3JlYWNoIGhhcyB0byBiZSB0aGUgZmlyc3QgZXhwcmVzc2lvbiBpbiBhCiAgICAjIGxpbmUsIHNwYWNlcyBkbyBub3QgbWF0dGVyLiBUaGUgZm9yZWFjaCBpcyByZXBsYWNlZCB3aXRoIGZvci4KICAgICMgQ29tbWVudHMgYW5kIG90aGVyIGxpbmVzIHdpdGggb3RoZXIgY2hhcnMgYmVmb3JlIHRoZSBmb3JlYWNoIGFyZQogICAgIyBpZ25vcmVkLgoKICAgICRDb2RlID1+IHN7XiAoW14jXSBcc3swLDIwMH0pIGZvcmVhY2ggKC4qPykgfXskMWZvciQyfXhtc2c7CgogICAgcmV0dXJuICRDb2RlOwp9CgoxOwo= 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6Ok1vZHVsZUZvcm1hdDsKCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCnVzZSBGaWxlOjpCYXNlbmFtZTsKCnVzZSBNb287CgpleHRlbmRzIHF3KFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmwpOwoKc3ViIHZhbGlkYXRlX3NvdXJjZSB7CiAgICBteSAoICRTZWxmLCAkQ29kZSApID0gQF87CgogICAgcmV0dXJuICRDb2RlIGlmICRTZWxmLT5Jc1BsdWdpbkRpc2FibGVkKCBDb2RlID0+ICRDb2RlICk7CgogICAgIyBDaGVjayBmb3IgYWJzZW5zZSBvZiBzaGViYW5nIGxpbmUKICAgIGlmICggJENvZGUgPX4gbXtcQVwjIX14bXMgKSB7CiAgICAgICAgcmV0dXJuICRTZWxmLT5EaWVXaXRoRXJyb3IoPDwiRU9GIik7ClBlcmwgbW9kdWxlcyBzaG91bGQgbm90IGhhdmUgYSBzaGViYW5nIGxpbmUgKCMhL3Vzci9iaW4vcGVybCkuCkVPRgogICAgfQoKICAgIHJldHVybjsKfQoKMTsK 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6OlBhcmFtT2JqZWN0OwoKdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKdXNlIEZpbGU6OkJhc2VuYW1lOwoKdXNlIE1vbzsKCmV4dGVuZHMgcXcoVGlkeUFsbDo6UGx1Z2luOjpPVE9CTzo6UGVybCk7CgpzdWIgdmFsaWRhdGVfc291cmNlIHsKICAgIG15ICggJFNlbGYsICRDb2RlICkgPSBAXzsKCiAgICByZXR1cm4gJENvZGUgaWYgJFNlbGYtPklzUGx1Z2luRGlzYWJsZWQoIENvZGUgPT4gJENvZGUgKTsKCiAgICAkQ29kZSA9ICRTZWxmLT5TdHJpcFBvZCggQ29kZSA9PiAkQ29kZSApOwogICAgJENvZGUgPSAkU2VsZi0+U3RyaXBDb21tZW50cyggQ29kZSA9PiAkQ29kZSApOwoKICAgIGlmICggJENvZGUgPX4gbXtQYXJhbU9iamVjdH14bXMgKSB7CiAgICAgICAgcmV0dXJuICRTZWxmLT5EaWVXaXRoRXJyb3IoPDwiRU9GIik7CkRvbid0IHVzZSB0aGUgUGFyYW1PYmplY3QgaW4gYmluLyBvciBpbiBLZXJuZWwvU3lzdGVtLgpFT0YKICAgIH0KCiAgICByZXR1cm47Cn0KCjE7Cg== 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 YWdwbApncGwKb3RvYm8Kb3RycwpzbGEKCmFzY2lpCmh0bWwKY2dpCnBncApzbWltZQpDQQoKcGFyYW0KcGFyYW1zCnByb3Zpc2lvbmVyCgpkb2Nib29rCmV0Ywp1dGY4CmlkCmlkcwpzbGEKc2xhcwpBQ0wKY3N2CnNxbApkYm1zCmZldGNobWFpbAp0bXAKaXBjCm9wbQpzb3BtCml0c20KcGRmCnhtbApzdGF0CnN0YXRzCnV0ZgpmYXEKdW5pbnN0YWxsCnVuaW5zdGFsbHMKc3lzY29uZmlnCmltcG9ydGFibGUKaW52b2tlcgppbnZva2VycwptaW5pZmllZApkZWNyeXB0CmRlY3J5cHRlZAp1bm1hbmFnZWQKcHJlc2VsZWN0CmlDYWxlbmRhcgoKUE9TVERBVEEKUEFUQ0hEQVRBClBVVERBVEEKRU8K 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6OlN1YkRlY2xhcmF0aW9uOwoKdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKdXNlIEZpbGU6OkJhc2VuYW1lOwoKdXNlIE1vbzsKCmV4dGVuZHMgcXcoVGlkeUFsbDo6UGx1Z2luOjpPVE9CTzo6UGVybCk7Cgo9aGVhZDEgU1lOT1BTSVMKClRoaXMgbW9kdWxlIGNoZWNrcyBmb3Igc3ViIGRlY2xhcmF0aW9ucyB3aXRoIHRoZSBicmFjZSBpbiB0aGUgZm9sbG93aW5nCmxpbmUgYW5kIGNvcnJlY3RzIHRoZW0uCgogICAgc3ViIGFiYwogICAgewogICAgICAgIC4uLgogICAgfQoKd2lsbCBiZWNvbWU6CgogICAgc3ViIGFiYyB7CiAgICAgICAgLi4uCiAgICB9Cgo9Y3V0CgpzdWIgdHJhbnNmb3JtX3NvdXJjZSB7CiAgICBteSAoICRTZWxmLCAkQ29kZSApID0gQF87CgogICAgcmV0dXJuICRDb2RlIGlmICRTZWxmLT5Jc1BsdWdpbkRpc2FibGVkKCBDb2RlID0+ICRDb2RlICk7CgogICAgaWYgKCAkQ29kZSA9fiBtfF5zdWIgXHMrIFx3KyBccyogXHI/XG4gXHsgfHNteCApIHsKICAgICAgICAkQ29kZSA9fiBzfF4oc3ViIFxzKyBcdyspIFxzKiBccj9cbiBceyB8JDEge3xzbXhnOwogICAgfQoKICAgIHJldHVybiAkQ29kZTsKfQoKMTsK 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6OlRlc3RzOjpIZWxwZXI7Cgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7Cgp1c2UgTW9vOwoKZXh0ZW5kcyBxdyhUaWR5QWxsOjpQbHVnaW46Ok9UT0JPOjpQZXJsKTsKCnN1YiB2YWxpZGF0ZV9zb3VyY2UgewogICAgbXkgKCAkU2VsZiwgJENvZGUgKSA9IEBfOwoKICAgIHJldHVybiBpZiAkU2VsZi0+SXNQbHVnaW5EaXNhYmxlZCggQ29kZSA9PiAkQ29kZSApOwoKICAgIG15ICVNYXRjaFJlZ2V4ZXMgPSAoCiAgICAgICAgSGVscGVyT2JqZWN0UGFyYW1zICAgICAgICAgICAgICAgPT4gcXJ7LT5PYmplY3RQYXJhbUFkZFwoXHMqJ0tlcm5lbDo6U3lzdGVtOjpVbml0VGVzdDo6SGVscGVyJ314bXMsCiAgICAgICAgSGVscGVyT2JqZWN0RmxhZ1Jlc3RvcmVEYXRhYmFzZSAgPT4gcXJ7UmVzdG9yZURhdGFiYXNlXHMqPT5ccyoxfXhtcywKICAgICAgICBIZWxwZXJPYmplY3RGbGFnUEdQRW52aXJvbm1lbnQgICA9PiBxcntQcm92aWRlVGVzdFBHUEVudmlyb25tZW50XHMqPT5ccyoxfXhtcywKICAgICAgICBIZWxwZXJPYmplY3RGbGFnU01JTUVFbnZpcm9ubWVudCA9PiBxcntQcm92aWRlVGVzdFNNSU1FRW52aXJvbm1lbnRccyo9PlxzKjF9eG1zLAogICAgICAgIEhlbHBlckluc3RhbnRpYXRpb24gICAgICAgICAgICAgID0+IHFyey0+R2V0XCgnS2VybmVsOjpTeXN0ZW06OlVuaXRUZXN0OjpIZWxwZXInfXhtcywKICAgICAgICBTZWxlbml1bUluc3RhbnRpYXRpb24gICAgICAgICAgICA9PiBxcnstPkdldFwoJ0tlcm5lbDo6U3lzdGVtOjpVbml0VGVzdDo6U2VsZW5pdW0nfXhtcywKICAgICAgICBQR1BJbnN0YW50aWF0aW9uICAgICAgICAgICAgICAgICA9PiBxcnstPkdldFwoJ0tlcm5lbDo6U3lzdGVtOjpDcnlwdDo6UEdQJ314bXMsCiAgICAgICAgU01JTUVJbnN0YW50aWF0aW9uICAgICAgICAgICAgICAgPT4gcXJ7LT5HZXRcKCdLZXJuZWw6OlN5c3RlbTo6Q3J5cHQ6OlNNSU1FJ314bXMsCiAgICApOwoKICAgIG15ICVNYXRjaFBvc2l0aW9uczsKCiAgICBmb3IgbXkgJEtleSAoIHNvcnQga2V5cyAlTWF0Y2hSZWdleGVzICkgewogICAgICAgIGlmICggJENvZGUgPX4gJE1hdGNoUmVnZXhlc3skS2V5fSApIHsKCiAgICAgICAgICAgICMgU3RvcmUgdGhlIHBvc2l0aW9uIG9mIHRoZSBmaXJzdCBtYXRjaC4KICAgICAgICAgICAgJE1hdGNoUG9zaXRpb25zeyRLZXl9ID0gJC1bMF07CiAgICAgICAgfQogICAgfQoKICAgIHJldHVybiBpZiAhJE1hdGNoUG9zaXRpb25ze0hlbHBlckluc3RhbnRpYXRpb259OwoKICAgIGlmICggJE1hdGNoUG9zaXRpb25ze1NlbGVuaXVtSW5zdGFudGlhdGlvbn0gJiYgJE1hdGNoUG9zaXRpb25ze0hlbHBlck9iamVjdFBhcmFtc30gKSB7CiAgICAgICAgaWYgKCAkTWF0Y2hQb3NpdGlvbnN7U2VsZW5pdW1JbnN0YW50aWF0aW9ufSA8ICRNYXRjaFBvc2l0aW9uc3tIZWxwZXJPYmplY3RQYXJhbXN9ICkgewogICAgICAgICAgICByZXR1cm4gJFNlbGYtPkRpZVdpdGhFcnJvcig8PCJFT0YiKTsKUGxlYXNlIGFsd2F5cyBzZXQgdGhlIEhlbHBlciBvYmplY3QgcGFyYW1zIGJlZm9yZSBjcmVhdGluZyB0aGUgU2VsZW5pdW0gb2JqZWN0IHRvIG1ha2Ugc3VyZSBhbnkgY29uc3RydWN0b3IgZmxhZ3MgYXJlIHByb3Blcmx5IHNldCBhbmQgcHJvY2Vzc2VkLiBUaGlzIG5lZWRzIHRvIGJlIGRvbmUgYmVjYXVzZSBTZWxlbml1bTo6bmV3KCkgYWxyZWFkeSBtYXkgY3JlYXRlIHRoZSBIZWxwZXIuCkVPRgogICAgICAgIH0KICAgIH0KCiAgICBpZiAoICRNYXRjaFBvc2l0aW9uc3tTZWxlbml1bUluc3RhbnRpYXRpb259ICYmICRNYXRjaFBvc2l0aW9uc3tIZWxwZXJPYmplY3RGbGFnUmVzdG9yZURhdGFiYXNlfSApIHsKICAgICAgICByZXR1cm4gJFNlbGYtPkRpZVdpdGhFcnJvcig8PCJFT0YiKTsKRG9uJ3QgdXNlIHRoZSBIZWxwZXIgZmxhZyAnUmVzdG9yZURhdGFiYXNlJyBpbiAgU2VsZW5pdW0gdGVzdHMsIGFzIHRoZSB3ZWIgc2VydmVyIGNhbm5vdCBhY2Nlc3MgdGhlIHRlc3QgdHJhbnNhY3Rpb24uCkVPRgogICAgfQoKICAgIHJldHVybjsKfQoKMTsK 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6OlRyYW5zbGF0aW9uRW5jb2Rpbmc7Cgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7Cgp1c2UgRmlsZTo6QmFzZW5hbWU7Cgp1c2UgTW9vOwoKZXh0ZW5kcyBxdyhUaWR5QWxsOjpQbHVnaW46Ok9UT0JPOjpQZXJsKTsKCnN1YiB2YWxpZGF0ZV9zb3VyY2UgewogICAgbXkgKCAkU2VsZiwgJENvZGUgKSA9IEBfOwoKICAgIHJldHVybiAkQ29kZSBpZiAkU2VsZi0+SXNQbHVnaW5EaXNhYmxlZCggQ29kZSA9PiAkQ29kZSApOwoKICAgIGlmICggJENvZGUgIX4gbXteWyBcdF0qdXNlXHMrdXRmODt9bXggKSB7CiAgICAgICAgcmV0dXJuICRTZWxmLT5EaWVXaXRoRXJyb3IoPDwiRU9GIik7CkFsbCBsYW5ndWFnZSBmaWxlcyBtdXN0IGJlIGVuY29kZWQgaW4gInV0Zi04IiwgYW5kIGluY2x1ZGUgdGhlICJ1c2UgdXRmODsiIFBlcmwgcHJhZ21hLgpFT0YKICAgIH0KCiAgICByZXR1cm47Cn0KCjE7Cg== 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6OlVzZVBhcmVudDsKCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCnVzZSBNb287CgpleHRlbmRzIHF3KFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmwpOwoKc3ViIHRyYW5zZm9ybV9zb3VyY2UgewogICAgbXkgKCAkU2VsZiwgJENvZGUgKSA9IEBfOwoKICAgIHJldHVybiAkQ29kZSBpZiAkU2VsZi0+SXNQbHVnaW5EaXNhYmxlZCggQ29kZSA9PiAkQ29kZSApOwoKICAgICRDb2RlID1+IHN7IF4gXHMqIFxLIHVzZSBccysgYmFzZSBcYiB9e3VzZSBwYXJlbnR9c214ZzsKCiAgICByZXR1cm4gJENvZGU7Cn0KCjE7Cg== IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6OlVzZVdhcm5pbmdzOwoKdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKdXNlIEZpbGU6OkJhc2VuYW1lOwoKdXNlIE1vbzsKCmV4dGVuZHMgcXcoVGlkeUFsbDo6UGx1Z2luOjpPVE9CTzo6UGVybCk7CgojIFBlcmw6OkNyaXRpYyB3aWxsIG1ha2Ugc3VyZSB0aGF0IHVzZSBzdHJpY3QgaXMgZW5hYmxlZC4KIyBOb3cgd2UgY2hlY2sgdGhhdCB1c2Ugd2FybmluZ3MgaXMgYWxzby4Kc3ViIHRyYW5zZm9ybV9zb3VyY2UgewogICAgbXkgKCAkU2VsZiwgJENvZGUgKSA9IEBfOwoKICAgIHJldHVybiAkQ29kZSBpZiAkU2VsZi0+SXNQbHVnaW5EaXNhYmxlZCggQ29kZSA9PiAkQ29kZSApOwoKICAgICMgQ2hlY2sgaWYgdXNlIHdhcm5pbmdzIGlzIHByZXNlbnQsIG90aGVyd2lzZSBhZGQgaXQKICAgIGlmICggJENvZGUgIX4gbXteWyBcdF0qdXNlXHMrd2FybmluZ3M7fW14ICkgewogICAgICAgICRDb2RlID1+IHN7XlsgXHRdKnVzZVxzK3N0cmljdDt9e3VzZSBzdHJpY3Q7XG51c2Ugd2FybmluZ3M7fW14OwogICAgfQoKICAgIHJldHVybiAkQ29kZTsKfQoKMTsK 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 LWw9MTYwICAgICAgICAgICAgICAgICAgICAgICAgICAjIGxpbmUgbGVuZ3RoCi12bWxsICAgICAgICAgICAgICAgICAgICAgICAgICAgIyB2YXJpYWJsZSBtYXhpbXVtIGxpbmUgbGVuZ3RoCi1pPTQgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBpbmRlbnRhdGlvbiB3aWR0aAotY2k9NCAgICAgICAgICAgICAgICAgICAgICAgICAgICMgY29udGludW91cyBpbmRlbnRhdGlvbiB3aWR0aAoteGNpICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgZXh0ZW5kZWQgY29udGludW91cyBpbmRlbnRhdGlvbgotdnQ9MCAgICAgICAgICAgICAgICAgICAgICAgICAgICMgdmVydGljYWwgdGlnaHRuZXNzCi12dGM9MCAgICAgICAgICAgICAgICAgICAgICAgICAgIyB2ZXJ0aWNhbCB0aWdodG5lc3MgY2xvc2luZwotY3RpPTAgICAgICAgICAgICAgICAgICAgICAgICAgICMgY2xvc2luZyB0b2tlbiBpbmRlbnRhdGlvbgotcHQ9MSAgICAgICAgICAgICAgICAgICAgICAgICAgICMgcGFyZW4gdGlnaHRuZXNzCi1idD0xICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBicmFjZSB0aWdodG5lc3MKLXNidD0xICAgICAgICAgICAgICAgICAgICAgICAgICAjIHNxdWFyZSBicmFja2V0cyB0aWdodG5lc3MKLWJidD0xICAgICAgICAgICAgICAgICAgICAgICAgICAjIGJsb2NrIGJyYWNlIHRpZ2h0bmVzcwotbnNmcyAgICAgICAgICAgICAgICAgICAgICAgICAgICMgbm8gc3BhY2UgZm9yIHNlbWljb2xvbgotbm9scSAgICAgICAgICAgICAgICAgICAgICAgICAgICMgbm8gb3V0ZGVudCBsb25nIHF1b3RlcwotYmJhbyAgICAgICAgICAgICAgICAgICAgICAgICAgICMgYnJlYWsgYmVmb3JlIGFsbCBvcGVyYXRvcnMKLW5vbGEgICAgICAgICAgICAgICAgICAgICAgICAgICAjIG5vIG91dGRlbnQgbGFiZWxzCi1uZG5sICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBubyBkZWxldGUgb2xkIG5ld2xpbmVzCi1jYWI9MCAgICAgICAgICAgICAgICAgICAgICAgICAgIyBjb21tYSBhcnJvdyBicmVha3BvaW50cwotc2JjcD0iXiMgKFJvdGhlciBPU1N8RU8pIiAgICAgICMgdHJlYXQgcGF0dGVybnMgIiMgUm90aGVyIE9TUyIgYW5kICIjIEVPIiAocGFja2FnZSBtYXJrZXJzKSBhcyBzdGF0aWMgYmxvY2sgY29tbWVudHMKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjICAgc2VlIHNlY3Rpb24gJ1N0YXRpYyBCbG9jayBDb21tZW50cycgaW4gcGVybHRpZHkgZG9jdW1lbnRhdGlvbiBmb3IgbW9yZSBpbmZvCi0tY2hhcmFjdGVyLWVuY29kaW5nPW5vbmUK # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

package TidyAll::Plugin::OTOBO::PO::DocbookLint;

#
# Perform some quality checks on po files.
#

use strict;
use warnings;

use Moo;

extends qw(TidyAll::Plugin::OTOBO::Base);

use Locale::PO  ();
use XML::Parser ();

sub validate_file {
    my ( $Self, $Filename ) = @_;

    return if $Self->IsPluginDisabled( Filename => $Filename );

    my $IsDocbookTranslation = $Filename =~ m{/doc-}smx;
    my $Strings              = Locale::PO->load_file_asarray($Filename);

    my $ErrorMessage;

    STRING:
    for my $String ( @{ $Strings // [] } ) {

        next STRING if $String->fuzzy();

        my $Source = $String->dequote( $String->msgid() );
        next STRING if !$Source;
        my $Translation = $String->dequote( $String->msgstr() );
        next STRING if !$Translation;

        if ($IsDocbookTranslation) {

            # # Don't validate contents of <screen> tags, they should have CDATA
            #next STRING if $String->automatic() && $String->automatic =~ m{<screen>$}smx;
            next STRING if $String->automatic() && $String->automatic() =~ m{CDATA$}smx;

            # Obsolete strings might loose CDATA comments
            next STRING if $String->obsolete();

            my $Parser = XML::Parser->new();
            if ( !eval { $Parser->parse("<book>$Translation</book>") } ) {
                $ErrorMessage .= "Invalid XML translation found in Line: "
                    . $String->loaded_line_number() . "\n";
                $ErrorMessage .= "  Source: $Source\n";
                $ErrorMessage .= "  Translation: $Translation\n";
                $ErrorMessage .= "  XML::Parser produced errors: $@\n";
                next STRING;
            }

            my $StrippedSource = $Source;
            $StrippedSource =~ s{<!--.*-->}{}smxg;

            my @SourceTags = $StrippedSource =~ m{<[^>]*>}smg;
            next STRING if !@SourceTags;
            my %SourceTagCount;
            @SourceTags = map { $_ =~ s{^<([/a-zA-Z_0-9]+).*}{$1}esmxg; $_ } @SourceTags;    ## no critic qw(ControlStructures::ProhibitMutatingListFunctions)

            # Some tags which do not have to be validated as long as the xml structure is still valid.
            my %IgnoreTags = (
                'emphasis'   => 1,
                '/emphasis'  => 1,
                'citetitle'  => 1,
                '/citetitle' => 1,
                'ulink'      => 1,
                '/ulink'     => 1,
                'link'       => 1,
                '/link'      => 1,
                'filename'   => 1,
                '/filename'  => 1,
            );

            SOURCE_TAG:
            for my $SourceTag (@SourceTags) {
                next SOURCE_TAG if $IgnoreTags{$SourceTag};
                $SourceTagCount{$SourceTag}++;

            }

            for my $SourceTag ( sort keys %SourceTagCount ) {
                my @TranslatedTags     = $Translation =~ m{<$SourceTag[>| ]}smg;
                my $TranslatedTagCount = scalar @TranslatedTags;
                if ( $TranslatedTagCount != $SourceTagCount{$SourceTag} ) {
                    $ErrorMessage .= "Invalid XML translation found in Line: "
                        . $String->loaded_line_number() . "\n";
                    $ErrorMessage .= "  Source: $Source\n";
                    $ErrorMessage .= "  Translation: $Translation\n";
                    $ErrorMessage
                        .= "  Tag <$SourceTag> was expected $SourceTagCount{$SourceTag} but found $TranslatedTagCount times.\n";
                }
            }

            # Source and translation should have the same linkend definitions.
            my @SourceLinkEnds = $Source      =~ m{<link[^>]+linkend=["']([^'"]+)['"]}smxg;
            my @TargetLinkEnds = $Translation =~ m{<link[^>]+linkend=["']([^'"]+)['"]}smxg;

            my $LinkEndsAreDifferent = $Self->_DataDiff(
                Data1 => [ sort { $a cmp $b } @SourceLinkEnds ],
                Data2 => [ sort { $a cmp $b } @TargetLinkEnds ],
            );

            if ($LinkEndsAreDifferent) {
                $ErrorMessage .= "Linkend definitions are different.\nSource:\n$Source\nTranslation:\n$Translation\n\n";
            }
        }
    }

    if ($ErrorMessage) {
        return $Self->DieWithError("$ErrorMessage");
    }
}

sub _DataDiff {
    my ( $Self, %Param ) = @_;

    for (qw(Data1 Data2)) {
        if ( !defined $Param{$_} ) {
            print STDERR "Need $_!\n";
            return;
        }
    }

    # ''
    if ( ref $Param{Data1} eq '' && ref $Param{Data2} eq '' ) {

        # do nothing, it's ok
        return if !defined $Param{Data1} && !defined $Param{Data2};

        # return diff, because its different
        return 1 if !defined $Param{Data1} || !defined $Param{Data2};

        # return diff, because its different
        return 1 if $Param{Data1} ne $Param{Data2};

        # return, because its not different
        return;
    }

    # SCALAR
    if ( ref $Param{Data1} eq 'SCALAR' && ref $Param{Data2} eq 'SCALAR' ) {

        # do nothing, it's ok
        return if !defined ${ $Param{Data1} } && !defined ${ $Param{Data2} };

        # return diff, because its different
        return 1 if !defined ${ $Param{Data1} } || !defined ${ $Param{Data2} };

        # return diff, because its different
        return 1 if ${ $Param{Data1} } ne ${ $Param{Data2} };

        # return, because its not different
        return;
    }

    # ARRAY
    if ( ref $Param{Data1} eq 'ARRAY' && ref $Param{Data2} eq 'ARRAY' ) {
        my @A = @{ $Param{Data1} };
        my @B = @{ $Param{Data2} };

        # check if the count is different
        return 1 if $#A ne $#B;

        # compare array
        COUNT:
        for my $Count ( 0 .. $#A ) {

            # do nothing, it's ok
            next COUNT if !defined $A[$Count] && !defined $B[$Count];

            # return diff, because its different
            return 1 if !defined $A[$Count] || !defined $B[$Count];

            if ( $A[$Count] ne $B[$Count] ) {
                if ( ref $A[$Count] eq 'ARRAY' || ref $A[$Count] eq 'HASH' ) {
                    return 1 if $Self->_DataDiff(
                        Data1 => $A[$Count],
                        Data2 => $B[$Count]
                    );
                    next COUNT;
                }
                return 1;
            }
        }
        return;
    }

    # HASH
    if ( ref $Param{Data1} eq 'HASH' && ref $Param{Data2} eq 'HASH' ) {
        my %A = %{ $Param{Data1} };
        my %B = %{ $Param{Data2} };

        # compare %A with %B and remove it if checked
        KEY:
        for my $Key ( sort keys %A ) {

            # Check if both are undefined
            if ( !defined $A{$Key} && !defined $B{$Key} ) {
                delete $A{$Key};
                delete $B{$Key};
                next KEY;
            }

            # return diff, because its different
            return 1 if !defined $A{$Key} || !defined $B{$Key};

            if ( $A{$Key} eq $B{$Key} ) {
                delete $A{$Key};
                delete $B{$Key};
                next KEY;
            }

            # return if values are different
            if ( ref $A{$Key} eq 'ARRAY' || ref $A{$Key} eq 'HASH' ) {
                return 1 if $Self->_DataDiff(
                    Data1 => $A{$Key},
                    Data2 => $B{$Key}
                );
                delete $A{$Key};
                delete $B{$Key};
                next KEY;
            }
            return 1;
        }

        # check rest
        return 1 if %B;
        return;
    }

    if ( ref $Param{Data1} eq 'REF' && ref $Param{Data2} eq 'REF' ) {
        return 1 if $Self->_DataDiff(
            Data1 => ${ $Param{Data1} },
            Data2 => ${ $Param{Data2} }
        );
        return;
    }

    return 1;
}

1;
 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlNPUE06Ok5hbWU7Cgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7Cgp1c2UgRmlsZTo6QmFzZW5hbWU7Cgp1c2UgTW9vOwoKZXh0ZW5kcyBxdyhUaWR5QWxsOjpQbHVnaW46Ok9UT0JPOjpCYXNlKTsKCnN1YiB2YWxpZGF0ZV9maWxlIHsKICAgIG15ICggJFNlbGYsICRGaWxlbmFtZSApID0gQF87CgogICAgcmV0dXJuIGlmICRTZWxmLT5Jc1BsdWdpbkRpc2FibGVkKCBGaWxlbmFtZSA9PiAkRmlsZW5hbWUgKTsKICAgIG15ICRDb2RlID0gJFNlbGYtPl9HZXRGaWxlQ29udGVudHMoJEZpbGVuYW1lKTsKCiAgICBteSAoJE5hbWVPZlRhZykgPSAkQ29kZSA9fiBtLzxOYW1lPihbXjw+XSspPFwvTmFtZT4vOwogICAgbXkgJE5hbWVPZkZpbGUgPSBzdWJzdHIoIGJhc2VuYW1lKCRGaWxlbmFtZSksIDAsIC01ICk7ICAgICAjIGN1dCBvZmYgLnNvcG0KCiAgICBpZiAoICROYW1lT2ZUYWcgbmUgJE5hbWVPZkZpbGUgKSB7CiAgICAgICAgcmV0dXJuICRTZWxmLT5EaWVXaXRoRXJyb3IoPDwiRU9GIik7ClRoZSBtb2R1bGUgbmFtZSAkTmFtZU9mVGFnIGlzIG5vdCBlcXVhbCB0byB0aGUgbmFtZSBvZiB0aGUgLnNvcG0gZmlsZSAoJE5hbWVPZkZpbGUpLgpFT0YKICAgIH0KfQoKMTsK IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlNPUE06OlBhY2thZ2VSZXF1aXJlZDsKCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCnVzZSBNb287CgpleHRlbmRzIHF3KFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OkJhc2UpOwoKc3ViIHZhbGlkYXRlX3NvdXJjZSB7CiAgICBteSAoICRTZWxmLCAkQ29kZSApID0gQF87CgogICAgcmV0dXJuIGlmICRTZWxmLT5Jc1BsdWdpbkRpc2FibGVkKCBDb2RlID0+ICRDb2RlICk7CgogICAgaWYgKCAkQ29kZSA9fiBtezxQYWNrYWdlUmVxdWlyZWQ+fXNteCApIHsKICAgICAgICByZXR1cm4gJFNlbGYtPkRpZVdpdGhFcnJvcig8PCJFT0YiKTsKWW91IHVzZSB0aGUgYXR0cmlidXRlIFBhY2thZ2VSZXF1aXJlZCB3aXRob3V0IGEgdmVyc2lvbiB0YWcuClVzZTogXCI8UGFja2FnZVJlcXVpcmVkIFZlcnNpb249IjEuMS4xIj5OZXdQYWNrYWdlPC9QYWNrYWdlUmVxdWlyZWQ+CkVPRgogICAgfQp9CgoxOwo= # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

package TidyAll::Plugin::OTOBO::SOPM::RequiredElements;

use strict;
use warnings;

use Moo;

extends qw(TidyAll::Plugin::OTOBO::Base);

sub transform_source {
    my ( $Self, $Code ) = @_;

    return $Code if $Self->IsPluginDisabled( Code => $Code );

    # Replace OTOBO GmbH with Rother OSS GmbH
    $Code =~ s{ OTOBO [ ]+ GmbH }{Rother OSS GmbH}xmsg;

    # get vendor
    my $Vendor = '';
    if ( $Code =~ /<Vendor>(?<Vendor>[^<>]+)<\/Vendor>/ ) {
        $Vendor = $+{Vendor};
    }

    # Replace <URL>http://otobo.org/</URL> with <URL>https://otobo.org/</URL>
    if ( $Vendor eq 'Rother OSS GmbH' ) {
        $Code =~ s{ ^ ( \s* ) \< URL \> .+? \< \/ URL \> }{$1<URL>https://otobo.io/</URL>}xmsg;
    }

    # Replace Version
    $Code =~ s{ <Version> [^<>\n]* <\/Version> }{<Version>0.0.0</Version>}xmsg;

    # cleanup file tags
    $Code =~ s{ "\/> }{" \/>}xmsg;
    $Code =~ s{ "><\/File> }{" \/>}xmsg;
    $Code =~ s{
        ^ ( [ ]* <File ) [ ]+ ( Location=" [^ <>\n]+ " ) [ ]+ ( Permission="\d\d\d" ) [ ]+ ( \/> )
    }{$1 $3 $2 $4}xmsg;

    # Remove BuildHost and BuildDate tags
    $Code =~ s{ <BuildHost> [^<>\n]* <\/BuildHost> }{}xmsg;
    $Code =~ s{ <BuildDate> [^<>\n]* <\/BuildDate> }{}xmsg;

    # Remove ChangeLog tags
    $Code =~ s{ <ChangeLog> [^<>\n]* <\/ChangeLog> }{}xmsg;

    return $Code;
}

sub validate_source {
    my ( $Self, $Code ) = @_;

    return if $Self->IsPluginDisabled( Code => $Code );

    my $ErrorMessage;

    my $Name            = 0;
    my $Version         = 0;
    my $Counter         = 0;
    my $Framework       = 0;
    my $Vendor          = 0;
    my $URL             = 0;
    my $License         = 0;
    my $BuildDate       = 0;
    my $BuildHost       = 0;
    my $DescriptionEN   = 0;
    my $Table           = 0;
    my $DatabaseUpgrade = 0;
    my $NameLength      = 0;
    my $DownloadFlag    = 0;
    my $BuildFlag       = 0;
    my $PackageName     = '';

    my $TableNameLength = 30;

    my @CodeLines = split /\n/, $Code;

    for my $Line (@CodeLines) {
        $Counter++;
        if ( $Line =~ /<Name>([^<>]+)<\/Name>/ ) {

            $Name        = 1;
            $PackageName = $1;
        }
        elsif ( $Line =~ /<Description Lang="en">[^<>]+<\/Description>/ ) {
            $DescriptionEN = 1;
        }
        elsif ( $Line =~ /<License>([^<>]+)<\/License>/ ) {
            $License = 1;
        }
        elsif ( $Line =~ /<URL>([^<>]+)<\/URL>/ ) {
            $URL = 1;
        }
        elsif ( $Line =~ /<BuildHost>[^<>]*<\/BuildHost>/ ) {
            $BuildHost = 1;
        }
        elsif ( $Line =~ /<BuildDate>[^<>]*<\/BuildDate>/ ) {
            $BuildDate = 1;
        }
        elsif ( $Line =~ /<Vendor>([^<>]+)<\/Vendor>/ ) {
            $Vendor = 1;
        }
        elsif ( $Line =~ m{ <Framework (?: [ ]+ [^<>]* )? > ( [^<>]+ ) <\/Framework> }xms ) {
            $Framework = 1;

            my $FrameworkVersion = $1;

            if ( $FrameworkVersion !~ m{ \d+ \. \d+ \. [x\d]+ }xms ) {
                $ErrorMessage .= "Version needs to have the format 0.0.x or 0.0.0!\n";
            }
        }
        elsif ( $Line =~ /<Version>([^<>]+)<\/Version>/ ) {
            $Version = 1;
        }
        elsif ( $Line =~ /<File([^<>]+)>([^<>]*)<\/File>/ ) {
            my $Attributes = $1;
            my $Content    = $2;
            if ( $Content ne '' ) {
                $ErrorMessage .= "Don't insert something between <File><\/File>!\n";
            }
            if ( $Attributes =~ /(Type|Encode)=/ ) {
                $ErrorMessage .= "Don't use the attribute 'Type' or 'Encode' in <File>Tags!\n";
            }
            if ( $Attributes =~ /Location=.+?\.sopm/ ) {
                $ErrorMessage .= "It is senseless to include .sopm-files in a opm! -> $Line";
            }
        }
        elsif ( $Line =~ /(<Table .+?>|<\/Table>)/ ) {
            $Table = 1;
        }
        elsif ( $Line =~ /<DatabaseUpgrade>/ ) {
            $DatabaseUpgrade = 1;
        }
        elsif ( $Line =~ /<\/DatabaseUpgrade>/ ) {
            $DatabaseUpgrade = 0;
        }
        elsif ( $Line =~ /<Table.+?>/ ) {
            if ( $DatabaseUpgrade && $Line =~ /<Table/ && $Line !~ /Version=/ ) {
                $ErrorMessage
                    .= "If you use <Table... in a <DatabaseUpgrade> context you need to have a Version attribute with the beginning version where this change is needed (e. g. <TableAlter Name=\"some_table\" Version=\"1.0.6\">)!\n";
            }
        }

        if ( $Line =~ /<(Column.*|TableCreate.*) Name="(.+?)"/ ) {
            $Name = $2;
            if ( length $Name > $TableNameLength ) {
                $NameLength .= "Line $Counter: $Name\n";
            }
        }

        # OTOBO 7: Check PackageIsDownloadable + PackageIsBuildable flags.
        if ( $Line =~ m{ <PackageIsDownloadable>(?: \d )<\/PackageIsDownloadable> }xms ) {

            $DownloadFlag = 1;
        }

        if ( $Line =~ m{ <PackageIsBuildable>(?: \d )<\/PackageIsBuildable> }xms ) {
            $BuildFlag = 1;
        }
    }

    # check for multi-line english description
    if ( $Code =~ /<Description Lang="en"><!\[CDATA\[[^<>]+\]\]><\/Description>/s ) {
        $DescriptionEN = 1;
    }

    if ($Table) {
        $ErrorMessage
            .= "The Element <Table> is not allowed in sopm-files. Perhaps you mean <TableCreate>!\n";
    }
    if ($BuildDate) {
        $ErrorMessage .= "<BuildDate> no longer used in .sopms!\n";
    }
    if ($BuildHost) {
        $ErrorMessage .= "<BuildHost> no longer used in .sopms!\n";
    }
    if ( !$DescriptionEN ) {
        $ErrorMessage .= "You have forgot to use the element <Description Lang=\"en\">!\n";
    }
    if ( !$Name ) {
        $ErrorMessage .= "You have forgot to use the element <Name>!\n";
    }
    if ( !$Version ) {
        $ErrorMessage .= "You have forgot to use the element <Version>!\n";
    }
    if ( !$Framework ) {
        $ErrorMessage .= "You have forgot to use the element <Framework>!\n";
    }
    if ( !$Vendor ) {
        $ErrorMessage .= "You have forgot to use the element <Vendor>!\n";
    }
    if ( !$URL ) {
        $ErrorMessage .= "You have forgot to use the element <URL>!\n";
    }
    if ( !$License ) {
        $ErrorMessage .= "You have forgot to use the element <License>!\n";
    }
    if ($NameLength) {
        $ErrorMessage
            .= "Please use Column and Tablenames with less than $TableNameLength letters!\n";
        $ErrorMessage .= $NameLength;
    }

    if ($ErrorMessage) {
        return $Self->DieWithError($ErrorMessage);
    }

    return;
}

sub IsRestrictedPackage {
    my ( $Self, %Param ) = @_;

    my %RestrictedPackages = (

        # OTOBO Freebie Features (otobo.org)
        FAQ                      => 1,
        iPhoneHandle             => 1,
        MasterSlave              => 1,
        OTOBOAppointmentCalendar => 1,
        OTOBOCodePolicy          => 1,
        OTOBOMasterSlave         => 1,
        Support                  => 1,
        Survey                   => 1,
        SystemMonitoring         => 1,
        TimeAccounting           => 1,

        # ITSM packages (itsm.otobo.org)
        GeneralCatalog                => 1,
        ImportExport                  => 1,
        ITSM                          => 1,
        ITSMChangeManagement          => 1,
        ITSMConfigurationManagement   => 1,
        ITSMCore                      => 1,
        ITSMIncidentProblemManagement => 1,
        ITSMServiceLevelManagement    => 1,

        # STORM packages (storm.otobo.org)
        OTOBOSTORM => 1,
    );
    return 1 if $RestrictedPackages{ $Param{Package} };

    # All packages which start with "OTOBO".
    return 1 if $Param{Package} =~ m{ \A OTOBO .+ }xms;

    return 0;
}

1;
 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

package TidyAll::Plugin::OTOBO::SQL::ReservedWords;

use strict;
use warnings;

use Moo;

extends qw(TidyAll::Plugin::OTOBO::Base);

sub validate_source {
    my ( $Self, $Code ) = @_;

    return if $Self->IsPluginDisabled( Code => $Code );

    my $TableCreate = 0;
    my $Counter;

    for my $Line ( split( /\n/, $Code ) ) {
        $Counter++;
        if ( $Line =~ /<Table/ ) {
            $TableCreate = 1;
        }
        if ( $TableCreate && $Line =~ /<Column.+?Name="(.+?)".*?\/>/i ) {
            if ( !$1 ) {
                return $Self->DieWithError(<<"EOF");
Found an empty column name!
Line $Counter: $Line
EOF
            }

            for my $ReservedWord (
                qw(
                    add all alter and
                    any as asc backup
                    begin between bigint binary
                    bit bottom break bulk by cache
                    call capability cascade case
                    cast char char_convert character
                    check checkpoint close comment
                    commit connect constraint contains
                    continue convert create cross
                    cube current current_timestamp current_user
                    cursor date dbspace deallocate
                    dec decimal declare default
                    delete deleting desc distinct
                    do double drop dynamic each
                    else elseif encrypted end
                    endif escape except exception
                    exec execute existing exists
                    externlogin fetch first float
                    for force foreign forward
                    from full goto grant
                    group having holdlock identified
                    if in index index_lparen
                    inner inout insensitive insert
                    inserting install instead int
                    integer integrated intersect into
                    iq is isolation join
                    key lateral left like
                    lock long match
                    membership message mode modify
                    natural new no noholdlock
                    not notify null numeric
                    of off on open
                    option options or order
                    others out outer over
                    passthrough precision prepare primary
                    print privileges proc procedure
                    publication raiserror readtext real
                    references release remote
                    remove rename reorganize resource
                    restore restrict return revoke
                    right role rollback rollup row rule save
                    savepoint scroll select sensitive
                    session set setuser share
                    smallint some sqlcode sqlstate
                    start stop subtrans subtransaction
                    synchronize syntax_error table temporary
                    then time timestamp tinyint
                    to top tran trigger
                    truncate tsequal unbounded undo union
                    unique unknown unsigned update
                    updating user using validate
                    values varbinary varchar variable
                    varying view wait waitfor
                    when where while window
                    with with_cube with_lparen with_rollup
                    within work writetext
                    NOMONITORING RECORDS_PER_BLOCK NOWAIT DYNAMIC_SAMPLING COLUMN_STATS GROUPS
                    NO_PX_JOIN_FILTER NO_STATS_GSETS SWAP_JOIN_INPUTS NOORDER TRIGGERS DEMAND
                    LOB GBY_CONC_ROLLUP ROWDEPENDENCIES NOSTRICT PRIVILEGE SEMIJOIN RAW USE_NL_WITH_INDEX
                    INFORMATIONAL DENSE_RANK NO_QUERY_TRANSFORMATION POINT TRACING NO_XML_QUERY_REWRITE
                    NOPARALLEL_INDEX LINK REF TIMEZONE_ABBR PIV_SSF TX READS DELAY BFILE PRIVATE MAXLOGMEMBERS
                    USE_SEMI COST EVALNAME NO_CARTESIAN TABNO TRACE PLAN HINTSET_END CONTAINER ADMIN COLUMN
                    SYSTEM TZ_OFFSET NLS_LENGTH_SEMANTICS DICTIONARY SCN_ASCENDING FIC_CIV NOOVERRIDE INDICATOR
                    BINARY_FLOAT_NAN ROWID SESSION_CACHED_CURSORS OBJNO SQL_TRACE BLOB RELATIONAL BIGFILE
                    AVAILABILITY GUARD GROUP_BY ADVISE MERGE QUOTA CFILE MEMBER THAN SALT DUMP EXTERNALLY
                    BOTH GUARANTEED EXTENT SECURITY SCALE SYS_DL_CURSOR TYPE DEREF_NO_REWRITE AUTO ESTIMATE
                    POWER USE_STORED_OUTLINES SID VARRAY LESS VALUE XMLFOREST MAXLOGHISTORY STORE REDUNDANCY
                    DEQUEUE DBA MATCHED PRESENT CPU_PER_CALL DEFINER UPD_JOININDEX NESTED_TABLE_SET_REFS
                    EXPAND_GSET_TO_UNION INDEX_SS_ASC EXTRACT ORDERED_PREDICATES ALIAS NO_USE_HASH PRIOR
                    X_DYN_PRUNE COMPOSITE_LIMIT OBJNO_REUSE REVERSE DISABLE CURRENT_DATE INITIAL MINIMUM
                    INTERMEDIATE PARTITION_LIST BYTE MOUNT PREBUILT SOURCE MODEL_PBY BITMAP_TREE LOGFILE
                    ROLES DEGREE INVALIDATE TABLESPACE PASSWORD_VERIFY_FUNCTION COLUMNS CHOOSE SMALLFILE LEVEL
                    OLD_PUSH_PRED DYNAMIC_SAMPLING_EST_CDN NLS_DATE_LANGUAGE SERVERERROR NESTED_TABLE_FAST_INSERT
                    STREAMS NL_SJ ELIMINATE_OUTER_JOIN ENTERPRISE DISASSOCIATE GROUPING PACKAGE DATE_MODE CHILD
                    NO_PRUNE_GSETS REJECT NORESETLOGS NO_CONNECT_BY_COST_BASED CHUNK OID RETENTION MAXTRANS
                    FBTSCAN NONE PARAMETERS ONLINE OUT_OF_LINE GLOBAL_NAME SPACE HINTSET_BEGIN PASSWORD_GRACE_TIME
                    NOCACHE FINAL YEAR RBA ERRORS CLASS USE_NL CONNECT_BY_COST_BASED BINARY_DOUBLE DEFINED
                    EVALUATION PURGE HOUR LENGTH PRECEDING DECREMENT SUBMULTISET INDEX_ROWS SCHEDULER
                    AUTHENTICATION NUMBER OIDINDEX OPAQUE SAMPLE UPDATABLE ORA_ROWSCN INTERPRETED
                    MATERIALIZED INDEX_COMBINE OPAQUE_XCANONICAL INLINE_XMLTYPE_NT RETURNING QUERY
                    OPT_ESTIMATE CLOB NO_EXPAND DETACHED PASSWORD_LOCK_TIME VECTOR_READ DATAFILE REPLACE
                    NLS_CHARACTERSET NO_ELIMINATE_JOIN BROADCAST CIV_GB HASH QB_NAME AFTER SYSDBA ACCOUNT
                    SEVERE PRECOMPUTE_SUBQUERY FUNCTION INDEXTYPES FLOB MULTISET NLS_SPECIAL_CHARS SKIP
                    IGNORE_OPTIM_EMBEDDED_HINTS INDEX_SS NOGUARANTEE LOCALTIMESTAMP DBA_RECYCLEBIN FILE THROUGH
                    PLSQL_WARNINGS MANAGE DRIVING_SITE FAILED SCAN_INSTANCES COMPLETE HIGH TRANSITIONAL
                    NO_SEMIJOIN DAY NOPARALLEL XMLATTRIBUTES MOVE NATIONAL REQUIRED SKIP_EXT_OPTIMIZER
                    NOREPAIR REBUILD JOB SEED POLICY USERS TOPLEVEL BITMAP DATAFILES HASH_AJ INITRANS
                    BLOCKSIZE FAST MINIMIZE SESSIONTZNAME SESSIONS_PER_USER SYS_OP_BITVEC NO_ELIMINATE_OBY
                    UBA DATA SUBPARTITION_REL SETS PRIVATE_SGA BINARY_FLOAT ENFORCED TABLE_STATS FLAGGER
                    TEMP_TABLE ARCHIVE NO_PUSH_SUBQ RECYCLE DATAOBJNO QUEUE_ROWP SQL CHAINED EMPTY
                    SAVE_AS_INTERVALS BITMAPS OPTIMIZER_FEATURES_ENABLE FUNCTIONS AUTOMATIC SECOND
                    NO_FILTERING NAMED SUSPEND LIKEC NO_BUFFER PQ_NOMAP NLS_LANG ADVISOR
                    FRESH NO_CONNECT_BY_FILTERING NOSORT PASSWORD HASHKEYS EXCLUDING INDEX_RRS DISK
                    BITS CACHE_CB USE STAR CURSOR_SPECIFIC_SEGMENT SB4 DISTRIBUTED HEAP MINEXTENTS DML
                    ATTRIBUTES NORELY KEYSIZE LEADING XMLCOLATTVAL FREELIST FAILED_LOGIN_ATTEMPTS
                    SHARED_POOL USE_ANTI BYPASS_RECURSIVE_CHECK ANTIJOIN ABORT INDEX_FILTER ROLLING
                    ITERATION_NUMBER COALESCE NO_SQL_TUNE CLUSTER PROTECTED PARTITION_HASH ERROR
                    NO_MULTIMV_REWRITE UB2 THREAD SINGLE SYS_PARALLEL_TXN INDEX_ASC PARTITION
                    DISMOUNT HIERARCHY STRIP NLS_DATE_FORMAT CORRUPTION STORAGE COMMITTED RECYCLEBIN
                    PARITY CACHE_TEMP_TABLE ENCRYPTION LOCALTIME REWRITE_OR_ERROR DBMS_STATS CHAR_CS
                    EXCEPTIONS EXPIRE AUDIT LDAP_REG_SYNC_INTERVAL NOMINVALUE LIBRARY COMPILE MAXVALUE
                    NAN NOSEGMENT NOLOGGING NOROWDEPENDENCIES PATH NOFORCE FINISH FIC_PIV MAX SYSAUX
                    DIMENSION ORGANIZATION NOSWITCH WRITE MINUS KILL OFFLINE TRANSACTION FACT BECOME
                    UNBOUND TIV_SSF OLD TEMPFILE EXPLOSION REFRESH MIRROR REF_CASCADE_CURSOR
                    OPCODE OVERFLOW CURSOR_SHARING_EXACT PUSH_SUBQ CARDINALITY USE_PRIVATE_OUTLINES
                    LIKE4 TYPES NOTHING TIMEZONE_HOUR UNQUIESCE RESIZE COLLECT INSTANCE SETTINGS EXPORT
                    DOMAIN_INDEX_NO_SORT MERGE_SJ LIMIT SYS_OP_EXTRACT LIKE2 STANDALONE LAST
                    CONNECT_BY_FILTERING RESTRICT_ALL_REF_CONS MERGE_CONST_ON UNIFORM SCAN WITHOUT
                    CPU_PER_SESSION PROGRAM SEG_FILE APPLY PASSWORD_LIFE_TIME DML_UPDATE ALLOW
                    SKIP_UNQ_UNUSABLE_IDX NO_MERGE CLOSE_CACHED_OPEN_CURSORS NESTED_TABLE_GET_REFS
                    SPECIFICATION CONSISTENT USE_CONCAT SYS_OP_NTCIMG$ PQ_MAP SHUTDOWN DEFERRABLE
                    FOLLOWING SPLIT UNPROTECTED TIME_ZONE SHRINK INDEX_SKIP_SCAN LOGICAL
                    MODEL_MIN_ANALYSIS XMLROOT SD_SHOW CREATE_STORED_OUTLINES RAPIDLY USE_MERGE QUEUE_CURR
                    STRICT MV_MERGE NO_ORDER_ROLLUPS TREAT UNLIMITED TUNING CHANGE PCTUSED MOVEMENT
                    NO_REWRITE ANCILLARY CLUSTERING_FACTOR BLOCK_RANGE SEQUENTIAL GLOBALLY XMLTYPE INTERVAL
                    SEQUENCED SWITCHOVER AT NOMAXVALUE SYS_FBT_INSDEL KERBEROS TIMEZONE_OFFSET
                    INDEX_SS_DESC RECOVERY NLS_TERRITORY SIZE FAILGROUP ELEMENT INSTANCES DIRECTORY
                    IDGENERATORS PRESERVE_OID NO_PARALLEL SUBPARTITIONS EXEMPT INDEX_JOIN BEGIN_OUTLINE_DATA
                    NETWORK LOCAL UNUSED NOAUDIT PHYSICAL WRAPPED FREEPOOLS PCTINCREASE FILTER
                    GATHER_PLAN_STATISTICS SYSOPER SD_INHIBIT SEGMENT DISABLE_RPKE NLS_SORT PATHS
                    ENTRY LDAP_REGISTRATION_ENABLED DISKS OBJECT INCREMENTAL REGEXP_LIKE OVERFLOW_NOMOVE
                    SUBQUERIES NO_PARALLEL_INDEX XID INITIALIZED STATISTICS ENCRYPT AUTOALLOCATE TEMPLATE
                    LDAP_REGISTRATION NO_UNNEST NO_PARTIAL_COMMIT ORDINALITY NLS_COMP NOCOMPRESS RULES
                    IMMEDIATE MAIN REFERENCING ENQUEUE SEG_BLOCK UNRECOVERABLE NO_MONITORING NO_ACCESS
                    RESOLVER TIMEZONE_MINUTE NO_ELIMINATE_OUTER_JOIN NO_INDEX UNNEST GUARANTEE BEHALF
                    ALWAYS TEST PERMANENT REGISTER CONFORMING SYNONYM SKIP_UNUSABLE_INDEXES USE_HASH
                    OPERATOR NO_PULL_PRED USE_TTT_FOR_GSETS SERIALIZABLE MIGRATE ITERATE PLSQL_CCFLAGS
                    IGNORE_WHERE_CLAUSE CPU_COSTING TRAILING LOCAL_INDEXES OVERLAPS EXTENDS NOAPPEND
                    METHOD REWRITE UNPACKED COLUMN_VALUE DATABASE EXCHANGE NO_TEMP_TABLE UPSERT YES
                    REBALANCE CONTEXT SPFILE NESTED TRACKING RESOLVE PFILE MAXDATAFILES GLOBAL
                    AUTHENTICATED NESTED_TABLE_ID INDEXES XMLNAMESPACES NO_REF_CASCADE SYSDATE OR_EXPAND
                    ASSOCIATE MODEL_COMPILE_SUBQUERY INITIALLY PARTIALLY XMLSCHEMA MINVALUE PIV_GB HEADER
                    RESTORE_AS_INTERVALS MANAGED BLOCK SINGLETASK DETERMINES PCTVERSION EXPLAIN AND_EQUAL
                    CLONE NO_USE_HASH_AGGREGATION BUFFER_CACHE XMLTABLE EXTERNAL NEVER IDENTIFIER PULL_PRED
                    INDEXED LOGICAL_READS_PER_CALL STARTUP FREELISTS UPD_INDEXES MATERIALIZE LOGON SCHEMA
                    NO_INDEX_SS NO_BASETABLE_MULTIMV_REWRITE IN_MEMORY_METADATA STRUCTURE MAXEXTENTS
                    RECOVERABLE REFERENCED NO_SET_TO_JOIN STAR_TRANSFORMATION CONNECT_BY_ISCYCLE ROWNUM
                    SNAPSHOT EXCLUSIVE CURRENT_TIME KEEP PASSWORD_REUSE_MAX WHENEVER INTERNAL_USE PX_JOIN_FILTER
                    PQ_DISTRIBUTE INLINE HWM_BROKERED FIRST_ROWS MODEL_NO_ANALYSIS NO_PUSH_PRED MODEL_PUSH_REF
                    COMPRESS NOREVERSE NO_INDEX_FFS GENERATED NATIVE LIKE_EXPAND RELY PACKAGES READ IGNORE
                    SQLLDR DISKGROUP FLUSH BYPASS_UJVC RESETLOGS SYS_OP_NOEXPAND PROTECTION BEFORE
                    INSTANTIABLE XMLELEMENT SUBPARTITION XMLPARSE FALSE ADMINISTER SELECTIVITY PCTTHRESHOLD
                    NEXT ERROR_ON_OVERLAP_TIME REKEY QUIESCE PX_GRANULE LOGOFF SCOPE BINDING NLS_CURRENCY
                    THE XMLPI PASSWORD_REUSE_TIME XMLQUERY PARTITIONS NO_QKN_BUFF MODEL_DYNAMIC_SUBQUERY
                    LOCATOR NLS_NCHAR_CONV_EXCP NO_STAR_TRANSFORMATION NOREWRITE TABLESPACE_NO ADMINISTRATOR
                    SEMIJOIN_DRIVER INDEX_FFS REDUCED KEYS LOCKED BUFFER VALIDATION FLASHBACK END_OUTLINE_DATA
                    TO_CHAR MASTER SYS_RID_ORDER PUBLIC MINUS_NULL NVARCHAR2 BOUND RBO_OUTLINE ACTIVATE VARCHAR2
                    MAXSIZE DECRYPT UID MLSLABEL UNTIL AUTOEXTEND ELIMINATE_JOIN RANDOM SEQUENCE NAV CONTENTS
                    USAGE ONLY REUSE MANUAL DOCUMENT CONNECT_BY_ISLEAF CONSIDER ENFORCE REMOTE_MAPPED
                    LIST MAXARCHLOGS ROW_LENGTH NULLS SHARED WELLFORMED INCLUDING APPEND FORCE_XML_QUERY_REWRITE
                    ISOLATION_LEVEL ACCESSED NLS_ISO_CURRENCY SUCCESSFUL CURRENT_SCHEMA ROWS DANGLING TRUE ZONE
                    NLS_NUMERIC_CHARACTERS DEBUG UPDATED RESTRICTED NO_EXPAND_GSET_TO_UNION STATEMENT_ID
                    NOCPU_COSTING AUTHORIZATION NO_USE_MERGE OPAQUE_TRANSFORM ARRAY MEASURES MODEL
                    CONNECT_TIME OPTIMIZER_GOAL SUPPLEMENTAL PCTFREE ANALYZE RECOVER DB_ROLE_CHANGE
                    BLOCKS MAXINSTANCES DDL NOVALIDATE PRESERVE OPT_PARAM CLEAR COARSE IDLE_TIME WALLET
                    SCALE_ROWS ARCHIVELOG CERTIFICATE NORMAL NO_MODEL_PUSH_REF TABLES UPGRADE INFINITE
                    NOARCHIVELOG CONTROLFILE IDENTITY PERFORMANCE INSTANTLY MAPPING ENABLE
                    LOGICAL_READS_PER_SESSION USE_HASH_AGGREGATION DEFERRED REPAIR NO_SWAP_JOIN_INPUTS
                    GLOBAL_TOPIC_ENABLED ELIMINATE_OBY SUBSTITUTABLE STANDBY NLS_CALENDAR LAYER BATCH KEY_LENGTH
                    INCREMENT BUILD ORDERED MONTH NCLOB EXPR_CORR_CHECK MEMORY UROWID EVENTS ALL_ROWS
                    SYS_OP_ENFORCE_NOT_NULL$ SD_ALL COMPUTE USE_WEAK_NAME_RESL NOMINIMIZE SPREADSHEET
                    NL_AJ BUFFER_POOL MERGE_AJ SIBLINGS CONSTRAINTS USER_DEFINED LOG IMPORT NESTED_TABLE_SET_SETID
                    LEVELS PERCENT PUSH_PRED RESUME NO_CPU_COSTING SIMPLE DISCONNECT WHITESPACE
                    UNLOCK NOMAPPING AUTHID ALLOCATE NCHAR_CS USER_RECYCLEBIN DOMAIN_INDEX_SORT QUERY_BLOCK
                    CYCLE HASH_SJ UNDROP LOGGING OWN PASSING MIN SWITCH SORT BINARY_DOUBLE_NAN NODELAY
                    PLSQL_OPTIMIZE_LEVEL PARTITION_RANGE TIMEZONE_REGION CACHE_INSTANCES SUMMARY
                    INDEX_STATS DISTINGUISHED INTERNAL_CONVERT NO_USE_NL DBTIMEZONE SYS_OP_CAST DOWNGRADE
                    RESET INDEX_DESC NOCYCLE POST_TRANSACTION PLSQL_CODE_TYPE E PARENT MAXLOGFILES
                    NO_FACT UNUSABLE XMLSERIALIZE JAVA NCHAR DEREF OUTLINE SET_TO_JOIN NEEDED VERSIONS
                    INDEX_SCAN EXTENTS SESSIONTIMEZONE PLSQL_DEBUG MONITORING BINARY_DOUBLE_INFINITY STATIC
                    RESUMABLE RANGE MANAGEMENT COMPATIBILITY ATTRIBUTE MAXIMIZE UNDER PARALLEL TIV_GB COMPACT
                    OPTIMAL CUBE_GB INCLUDE_VERSION PARALLEL_INDEX FINE SYSTIMESTAMP INDEXTYPE OUTLINE_LEAF
                    CONNECT_BY_ROOT VECTOR_READ_TRACE NLS_LANGUAGE STRING BINARY_FLOAT_INFINITY UNARCHIVED
                    PROFILE SCN MINUTE MODEL_DONTVERIFY_UNIQUENESS ACCESS
                )
                )
            {
                # the following words are removed of stefans list, because they don't merge
                # at with http://www.petefreitag.com/tools/sql_reserved_words_checker/
                # ID CATEGORY NAME CONTENT VERSION QUEUE BODY TIMEOUT REFERENCE NOTIFICATION PROJECT TRUSTED
                # all reserved sql-words with small letters are from
                # http://www.petefreitag.com/tools/sql_reserved_words_checker/
                # and http://www.ianywhere.com/developer/product_manuals/sqlanywhere/0901/de/html/dbrfde9/00000010.htm
                # 'reference' and 'login' seems to be allowed (checked by www.petefreitag.com)

                if ( $1 && $1 =~ /^$ReservedWord$/i ) {
                    die <<"EOF";
You use a reserved SQL-Word!
Line $Counter: $Line
You can use the following tool for your own checking:
http://www.petefreitag.com/tools/sql_reserved_words_checker/
EOF
                }
            }
            if ( $Line =~ /<\/Table/ ) {
                $TableCreate = 0;
            }
        }
    }

    return;
}

1;
 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 48974
0/nm
0th/pt
1/n1
1st/p
1th/tc
2/nm
2nd/p
2th/tc
3/nm
3rd/p
3th/tc
4/nm
4th/pt
5/nm
5th/pt
6/nm
6th/pt
7/nm
7th/pt
8/nm
8th/pt
9/nm
9th/pt
A/SM
AA/M
AAA
AB/M
ABA
ABC/SM
ABM/SM
ABS
AC/M
ACLU/M
ACT
ACTH/M
AD/M
ADC
ADD
ADM
ADP/M
AF
AFAIK
AFB
AFC/M
AFDC
AFN
AFT
AI/SM
AIDS/M
AK
AL
AM/M
AMA
AMD/M
ANSI/S
ANZUS/M
AOL/M
AP/M
APB
APC
API
APO
APR
AR
ARC
ASAP
ASCII/SM
ASL/M
ASPCA
ATM/M
ATP/M
ATV
AV
AVI
AWACS/M
AWOL/M
AZ/M
AZT/M
Aachen/M
Aaliyah/M
Aaron/M
Abbas/M
Abbasid/M
Abbott/M
Abby/M
Abdul/M
Abe/M
Abel/M
Abelard/M
Abelson/M
Aberdeen/M
Abernathy/M
Abidjan/M
Abigail/M
Abilene/M
Abner/M
Aborigine/MS
Abraham/M
Abram/MS
Abrams/M
Absalom/M
Abuja/M
Abyssinia/M
Abyssinian/M
Ac/M
Acadia/M
Acapulco/M
Accenture/M
Accra/M
Acevedo/M
Achaean/M
Achebe/M
Achernar/M
Acheson/M
Achilles/M
Aconcagua/M
Acosta/M
Acropolis
Acrux/M
Actaeon/M
Acton/M
Acts/M
Acuff/M
Ada/SM
Adam/SM
Adams/M
Adan/M
Adana/M
Adar/M
Addams/M
Adderley/M
Addie/M
Addison/M
Adela/M
Adelaide/M
Adele/M
Adeline/M
Aden/M
Adenauer/M
Adhara/M
Adidas/M
Adirondack/SM
Adirondacks/M
Adkins/M
Adler/M
Adm
Admiralty
Adolf/M
Adolfo/M
Adolph/M
Adonis/MS
Adrenalin/MS
Adrian/M
Adriana/M
Adriatic/M
Adrienne/M
Advent/MS
Adventist/MS
Advil/M
Aegean/M
Aelfric/M
Aeneas/M
Aeneid/M
Aeolus/M
Aeroflot/M
Aeschylus/M
Aesculapius/M
Aesop/M
Afghan/SM
Afghani/M
Afghanistan/M
Afr
Africa/M
African/SM
Afrikaans/M
Afrikaner/SM
Afro/SM
Afrocentric
Afrocentrism/M
Ag/M
Agamemnon/M
Agana
Agassi/M
Agassiz/M
Agatha/M
Aggie/M
Aglaia/M
Agnes/M
Agnew/M
Agni/M
Agra/M
Agricola/M
Agrippa/M
Agrippina/M
Aguascalientes
Aguilar/M
Aguinaldo/M
Aguirre/M
Agustin/M
Ahab/M
Ahmad/M
Ahmadabad/M
Ahmadinejad/M
Ahmed/M
Ahriman/M
Aida/M
Aiken/M
Aileen/M
Aimee/M
Ainu/M
Airedale/MS
Aires/M
Aisha/M
Ajax/M
Akbar/M
Akhmatova/M
Akihito/M
Akita/M
Akiva/M
Akkad/M
Akron/M
Al/M
Ala/S
Alabama/M
Alabaman/MS
Alabamian/SM
Aladdin/M
Alamo/M
Alamogordo/M
Alan/M
Alana/M
Alar/M
Alaric/M
Alaska/M
Alaskan/MS
Alba/M
Albania/M
Albanian/MS
Albany/M
Albee/M
Alberio/M
Albert/M
Alberta/M
Albertan
Alberto/M
Albigensian/M
Albion/M
Albireo/M
Albuquerque/M
Alcatraz/M
Alcestis/M
Alcibiades/M
Alcindor/M
Alcmena/M
Alcoa/M
Alcott/M
Alcuin/M
Alcyone/M
Aldan/M
Aldebaran/M
Alden/M
Alderamin/M
Aldo/M
Aldrin/M
Alec/M
Aleichem/M
Alejandra/M
Alejandro/M
Alembert/M
Aleppo/M
Aleut/MS
Aleutian/SM
Alex/M
Alexander/MS
Alexandra/M
Alexandria/M
Alexandrian
Alexei/M
Alexis/M
Alfonso/M
Alfonzo/M
Alford/M
Alfred/M
Alfreda/M
Alfredo/M
Algenib/M
Alger/M
Algeria/M
Algerian/SM
Algieba/M
Algiers/M
Algol/M
Algonquian/SM
Algonquin/MS
Alhambra/M
Alhena/M
Ali/M
Alice/M
Alicia/M
Alighieri/M
Aline/M
Alioth/M
Alisa/M
Alisha/M
Alison/M
Alissa/M
Alistair/M
Alkaid/M
Allah/M
Allahabad/M
Allan/M
Alleghenies/M
Allegheny/SM
Allegra/M
Allen/M
Allende/M
Allentown/M
Allhallows/M
Allie/MS
Allison/M
Allstate/M
Allyson/M
Alma/M
Almach/M
Almaty/M
Almighty/M
Almohad/M
Almoravid/M
Alnilam/M
Alnitak/M
Alonzo/M
Alpert/M
Alphard/M
Alphecca/M
Alpheratz/M
Alphonse/M
Alphonso/M
Alpine/M
Alpo/M
Alps/M
Alsace/M
Alsatian/SM
Alsop/M
Alston/M
Alta/M
Altai/M
Altaic/M
Altair/M
Altamira/M
Althea/M
Altiplano/M
Altman/M
Altoids/M
Alton/M
Aludra/M
Alva/M
Alvarado/M
Alvarez/M
Alvaro/M
Alvin/M
Alyce/M
Alyson/M
Alyssa/M
Alzheimer/M
Am/MNR
Amadeus/M
Amado/M
Amalia/M
Amanda/M
Amarillo/M
Amaru/M
Amaterasu/M
Amati/M
Amazon/SM
Amazonian
Amber/M
Amelia/M
Amen/M
Amenhotep/M
Amerasian/M
America/SM
American/MS
Americana/M
Americanism/MS
Americanization/MS
Americanize/GDS
Amerind/SM
Amerindian/MS
Ameslan/M
Amharic/M
Amherst/M
Amie/M
Amiga/M
Amish/M
Amman/M
Amoco/M
Amos/M
Amparo/M
Ampere/M
Amritsar/M
Amsterdam/M
Amtrak/M
Amundsen/M
Amur/M
Amway/M
Amy/M
Ana/M
Anabaptist/M
Anabel/M
Anacin/M
Anacreon/M
Anaheim/M
Analects/M
Ananias/M
Anasazi/M
Anastasia/M
Anatole/M
Anatolia/M
Anatolian/M
Anaxagoras/M
Anchorage/M
Andalusia/M
Andalusian/M
Andaman/M
Andean/M
Andersen/M
Anderson/M
Andes/M
Andorra/M
Andorran/SM
Andre/MS
Andrea/M
Andrei/M
Andres/M
Andretti/M
Andrew/SM
Andrews/M
Andrianampoinimerina/M
Android/M
Andromache/M
Andromeda/M
Andropov/M
Andy/M
Angara/M
Angel/M
Angela/M
Angeles/M
Angelia/M
Angelica/M
Angelico/M
Angelina/M
Angeline/M
Angelique/M
Angelita/M
Angelo/M
Angelou/M
Angevin/M
Angie/M
Angkor/M
Angle/MS
Anglia/M
Anglican/SM
Anglicanism/MS
Anglicism/MS
Anglicization
Anglicize
Anglo/M
Anglophile/M
Anglophobe
Angola/M
Angolan/MS
Angora/SM
Angstrom/M
Anguilla/M
Angus/M
Aniakchak/M
Anibal/M
Anita/M
Ankara/M
Ann/M
Anna/M
Annabel/M
Annabelle/M
Annam/M
Annapolis/M
Annapurna/M
Anne/M
Annette/M
Annie/M
Annmarie/M
Annunciation/SM
Anouilh/M
Anselm/M
Anselmo/M
Anshan/M
Antaeus/M
Antananarivo/M
Antarctic/M
Antarctica/M
Antares/M
Anthony/M
Anthropocene
Antichrist/SM
Antietam/M
Antigone/M
Antigua/M
Antillean
Antilles/M
Antioch/M
Antipas/M
Antipodes
Antofagasta/M
Antoine/M
Antoinette/M
Anton/M
Antone/M
Antonia/M
Antoninus/M
Antonio/M
Antonius/M
Antony/M
Antwan/M
Antwerp/M
Anubis/M
Anzac/M
Apache/SM
Apalachicola/M
Apatosaurus
Apennines/M
Aphrodite/M
Apia/M
Apocalypse/M
Apocrypha/M
Apollinaire/M
Apollo/SM
Apollonian/M
Apostle/M
Appalachia/M
Appalachian/SM
Appalachians/M
Appaloosa/SM
Apple/M
Appleseed/M
Appleton/M
Appomattox/M
Apr/M
April/MS
Apuleius/M
Aquafresh/M
Aquarian
Aquarius/MS
Aquila/M
Aquinas/M
Aquino/M
Aquitaine/M
Ar/M
Ara/M
Arab/SM
Arabia/M
Arabian/MS
Arabic/M
Arabist/MS
Araby/M
Araceli/M
Arafat/M
Aragon
Araguaya/M
Aral/M
Aramaic/M
Aramco/M
Arapaho/MS
Arapahoes
Ararat/M
Araucanian/M
Arawak/M
Arawakan/M
Arbitron/M
Arcadia/M
Arcadian/M
Archean/M
Archibald/M
Archie/M
Archimedes/M
Arctic/M
Arcturus/M
Ardabil
Arden/M
Arequipa/M
Ares/M
Argentina/M
Argentine/M
Argentinean
Argentinian/MS
Argo/SM
Argonaut/MS
Argonne/M
Argos/M
Argus/M
Ariadne/M
Arianism/M
Ariel/M
Aries/MS
Ariosto/M
Aristarchus/M
Aristides/M
Aristophanes/M
Aristotelian/M
Aristotle/M
Arius/M
Ariz
Arizona/M
Arizonan/SM
Arizonian/MS
Arjuna/M
Ark/M
Arkansan/MS
Arkansas/M
Arkhangelsk/M
Arkwright/M
Arlene/M
Arline/M
Arlington/M
Armageddon/SM
Armagnac/M
Armand/M
Armando/M
Armani/M
Armenia/M
Armenian/SM
Arminius/M
Armonk/M
Armour/M
Armstrong/M
Arneb/M
Arnhem/M
Arno/M
Arnold/M
Arnulfo/M
Aron/M
Arrhenius/M
Arron/M
Art/M
Artaxerxes/M
Artemis/M
Arthur/M
Arthurian/M
Artie/M
Arturo/M
Aruba/M
Aryan/MS
As/M
Asama/M
Ascella/M
Ascension/M
Asgard/M
Ashanti/M
Ashcroft/M
Ashe/M
Ashgabat
Ashikaga/M
Ashkenazim/M
Ashkhabad/M
Ashlee/M
Ashley/M
Ashmolean/M
Ashurbanipal/M
Asia/M
Asiago
Asian/MS
Asiatic/SM
Asimov/M
Asmara/M
Asoka/M
Aspell/M
Aspen/M
Asperger/M
Aspidiske/M
Asquith/M
Assad/M
Assam/M
Assamese/M
Assembly
Assisi/M
Assyria/M
Assyrian/SM
Astaire/M
Astana/M
Astarte/M
Aston/M
Astor/M
Astoria/M
Astrakhan/M
AstroTurf/M
Asturias/M
Asuncion/M
Aswan/M
At/SM
Atacama/M
Atahualpa/M
Atalanta/M
Atari/M
Ataturk/M
Athabasca/M
Athabaskan/SM
Athanasius
Athena/M
Athene/M
Athenian/SM
Athens/M
Atkins/M
Atkinson/M
Atlanta/M
Atlantes
Atlantic/M
Atlantis/M
Atlas/MS
Atman/M
Atonement
Atreus/M
Atria/M
Atropos/M
Attic/M
Attica/M
Attila/M
Attlee/M
Attn
Attucks/M
Atwood/M
Au/M
Aubrey/M
Auckland/M
Auden/M
Audi/M
Audion/M
Audra/M
Audrey/M
Audubon/M
Aug/M
Augean/M
Augsburg/M
August/MS
Augusta/M
Augustan/M
Augustine/M
Augustinian/MS
Augustus/M
Aurangzeb/M
Aurelia/M
Aurelio/M
Aurelius/M
Aureomycin/M
Auriga/M
Aurora/M
Auschwitz/M
Aussie/MS
Austen/M
Austerlitz/M
Austin/MS
Australasia/M
Australasian
Australia/M
Australian/SM
Australoid/M
Australopithecus/M
Austria/M
Austrian/SM
Austronesian/M
Autumn/M
Av/M
Ava/M
Avalon/M
Ave/M
Aventine/M
Avernus/M
Averroes/M
Avery/M
Avesta/M
Avicenna/M
Avignon/M
Avila/M
Avior/M
Avis/M
Avogadro/M
Avon/M
Axis
Axum/M
Ayala/M
Ayers/M
Aymara/M
Ayrshire/M
Ayurveda/M
Ayyubid/M
Azana/M
Azania/M
Azazel/M
Azerbaijan/M
Azerbaijani/MS
Azores/M
Azov/M
Aztec/SM
Aztecan/M
Aztlan/M
B/MNT
BA/M
BASIC/SM
BB/M
BBB/M
BBC/M
BBQ
BBS
BBSes
BC/M
BFF
BIA
BIOS
BITNET
BLT/SM
BM/M
BMW/M
BO
BP/M
BPOE
BR
BS/M
BSA
BSD/SM
BTU
BTW
BYOB
Ba/M
Baal/SM
Baath/M
Baathist/M
Babbage/M
Babbitt/M
Babel/MS
Babylon/MS
Babylonia/M
Babylonian/SM
Bacall/M
Bacardi/M
Bacchanalia/M
Bacchic
Bacchus/M
Bach/M
Backus/M
Bacon/M
Bactria/M
Baden/M
Badlands/M
Baedeker/MS
Baez/M
Baffin/M
Baggies/M
Baghdad/M
Baguio/M
Baha'i/M
Baha'ullah/M
Bahama/SM
Bahamanian
Bahamas/M
Bahamian/MS
Bahia/M
Bahrain/M
Baikal/M
Bailey/M
Baird/M
Bakelite/M
Baker/M
Bakersfield/M
Baku/M
Bakunin/M
Balanchine/M
Balaton/M
Balboa/M
Balder/M
Baldwin/SM
Balearic/M
Balfour/M
Bali/M
Balinese/M
Balkan/MS
Balkans/M
Balkhash/M
Ball/M
Ballard/M
Balthazar/M
Baltic/M
Baltimore/M
Baluchistan/M
Balzac/M
Bamako/M
Bambi/M
Banach/M
Bancroft/M
Bandung/M
Bangalore/M
Bangkok/M
Bangladesh/M
Bangladeshi/SM
Bangor/M
Bangui/M
Banjarmasin/M
Banjul/M
Banks/M
Banneker/M
Bannister/M
Banting/M
Bantu/MS
Baotou/M
Baptist/SM
Baptiste/M
Barabbas/M
Barack/M
Barbadian/SM
Barbados/M
Barbara/M
Barbarella/M
Barbarossa/M
Barbary/M
Barber/M
Barbie/M
Barbour/M
Barbra/M
Barbuda/M
Barcelona/M
Barclay/SM
Barclays/M
Bardeen/M
Barents/M
Barker/M
Barkley/M
Barlow/M
Barnabas/M
Barnaby/M
Barnard/M
Barnaul/M
Barnes/M
Barnett/M
Barney/M
Barnum/M
Baroda/M
Barquisimeto/M
Barr/M
Barranquilla/M
Barrera/M
Barrett/M
Barrie/M
Barron/M
Barry/M
Barrymore/M
Bart/M
Barth/MS
Bartholdi/M
Bartholomew/M
Bartlett/M
Bartok/M
Barton/M
Baruch/M
Baryshnikov/M
Basel/M
Basho/M
Basie/M
Basil/M
Basque/MS
Basra/M
Bass/M
Basseterre/M
Bastille/M
Basutoland/M
Bataan/M
Bates/M
Bathsheba/M
Batista/M
Batman/M
Battle/M
Batu/M
Baudelaire/M
Baudouin/M
Baudrillard/M
Bauer/M
Bauhaus/M
Baum/M
Bavaria/M
Bavarian/M
Baxter/M
Bayamon
Bayer/M
Bayes/M
Bayesian/M
Bayeux/M
Baylor/M
Bayonne/M
Bayreuth/M
Baywatch/M
Be/MH
Beach/M
Beadle/M
Bean/M
Beard/M
Beardmore/M
Beardsley/M
Bearnaise/M
Beasley/M
Beatlemania/M
Beatles/M
Beatrice/M
Beatrix/M
Beatriz/M
Beatty/M
Beau/M
Beaufort/M
Beaujolais/M
Beaumarchais/M
Beaumont/M
Beauregard/M
Beauvoir/M
Bechtel/M
Beck/MR
Becker/M
Becket/M
Beckett/M
Becky/M
Becquerel/M
Bede/M
Bedouin/SM
Beebe/M
Beecher/M
Beefaroni/M
Beelzebub/M
Beerbohm/M
Beethoven/M
Beeton/M
Begin/M
Behan/M
Behring/M
Beiderbecke/M
Beijing/M
Beirut/M
Bekesy/M
Bela/M
Belarus/M
Belau/M
Belem/M
Belfast/M
Belg
Belgian/SM
Belgium/M
Belgrade/M
Belinda/M
Belize/M
Bell/M
Bella/M
Bellamy/M
Bellatrix/M
Belleek/M
Bellini/M
Bellow/M
Belmont/M
Belmopan/M
Belorussian/MS
Belshazzar/M
Beltane/M
Belushi/M
Ben/M
Benacerraf/M
Benchley/M
Bender/M
Bendix/M
Benedict/M
Benedictine/MS
Benelux/M
Benet/M
Benetton/M
Bengal/SM
Bengali/M
Benghazi/M
Benin/M
Beninese/M
Benita/M
Benito/M
Benjamin/M
Bennett/M
Bennie/M
Benny/M
Benson/M
Bentham/M
Bentley/M
Benton/M
Benz/M
Benzedrine/M
Beowulf/M
Berber/SM
Berenice/M
Beretta/M
Berg/MNR
Bergen/M
Berger/M
Bergerac/M
Bergman/M
Bergson/M
Beria/M
Bering/M
Berkeley/M
Berkshire/SM
Berkshires/M
Berle/M
Berlin/SZMR
Berliner/M
Berlioz/M
Berlitz/M
Bermuda/SM
Bermudan/SM
Bermudian/SM
Bern/M
Bernadette/M
Bernadine/M
Bernanke/M
Bernard/M
Bernardo/M
Bernays/M
Bernbach/M
Bernese
Bernhardt/M
Bernice/M
Bernie/M
Bernini/M
Bernoulli/M
Bernstein/M
Berra/M
Berry/M
Bert/M
Berta/M
Bertelsmann/M
Bertha/M
Bertie/M
Bertillon/M
Bertram/M
Bertrand/M
Beryl/M
Berzelius/M
Bess/M
Bessel/M
Bessemer/M
Bessie/M
Best/M
Betelgeuse/M
Beth/M
Bethany/M
Bethe/M
Bethesda/M
Bethlehem/M
Bethune/M
Betsy/M
Bette/M
Bettie/M
Betty/M
Bettye/M
Beulah/M
Beveridge
Beverley/M
Beverly/M
Beyer/M
Bharat/M
Bhopal/M
Bhutan/M
Bhutanese/M
Bhutto/M
Bi/M
Bialystok/M
Bianca/M
Bib
Bible/MS
Bic/M
Biddle/M
Biden/M
Bierce/M
Bigfoot/M
Biggles/M
Biko/M
Bilbao/M
Bilbo/M
Bill/MJ
Billie/M
Billings/M
Billy/M
Bimini/M
Bioko/M
Bird/M
Birdseye/M
Birkenstock/M
Birmingham/M
Biro/M
Biscay/M
Biscayne/M
Bishkek/M
Bishop/M
Bismarck/M
Bismark/M
Bisquick/M
Bissau/M
BitTorrent/M
Bizet/M
Bjerknes/M
Bjork/M
Bk/M
BlackBerry/M
Blackbeard/M
Blackburn/M
Blackfeet/M
Blackfoot/M
Blackpool/M
Blackshirt/M
Blackstone/M
Blackwell/M
Blaine/M
Blair/M
Blake/M
Blanca/M
Blanchard/M
Blanche/M
Blankenship/M
Blantyre/M
Blatz/M
Blavatsky/M
Blenheim/M
Blevins/M
Bligh/M
Bloch/M
Blockbuster/M
Bloemfontein/M
Blondel/M
Blondie/M
Bloom/MR
Bloomer/M
Bloomfield/M
Bloomingdale/M
Bloomsbury/M
Blu
Blucher/M
Bluebeard/M
Bluetooth/M
Blvd
Blythe/M
Boadicea
Boas/M
Bob/M
Bobbi/M
Bobbie/M
Bobbitt/M
Bobby/M
Boccaccio/M
Bodhidharma/M
Bodhisattva/M
Bodleian
Boeing/M
Boeotia/M
Boeotian/M
Boer/SM
Boethius/M
Bogart/M
Bogota/M
Bohemia/M
Bohemian/SM
Bohr/M
Boise/M
Bojangles/M
Boleyn/M
Bolivar/M
Bolivia/M
Bolivian/MS
Bollywood/M
Bologna/M
Bolshevik/SM
Bolsheviki
Bolshevism/M
Bolshevist/M
Bolshoi/M
Bolton/M
Boltzmann/M
Bombay/M
Bonaparte/M
Bonaventure/M
Bond/M
Bonhoeffer/M
Boniface/M
Bonita/M
Bonn/MR
Bonner/M
Bonneville/M
Bonnie/M
Bono/M
Booker/M
Boole/M
Boolean/M
Boone/M
Bootes/M
Booth/M
Bordeaux/M
Borden/M
Bordon/M
Boreas/M
Borg/SM
Borges/M
Borgia/M
Borglum/M
Boris/M
Bork/M
Borlaug/M
Born/M
Borneo/M
Borobudur/M
Borodin/M
Boru/M
Bosch/M
Bose/M
Bosnia/M
Bosnian
Bosporus/M
Boston/MS
Bostonian/M
Boswell/M
Botox
Botswana/M
Botticelli/M
Boulder/M
Boulez/M
Bourbaki/M
Bourbon/SM
Bournemouth/M
Bovary/M
Bowditch/M
Bowell/M
Bowen/M
Bowers/M
Bowery/M
Bowie/M
Bowman/M
Boyd/M
Boyer/M
Boyle/M
Br/MT
Brad/MY
Bradbury/M
Braddock/M
Bradford/M
Bradley/M
Bradly/M
Bradshaw/M
Bradstreet/M
Brady/M
Bragg/M
Brahe/M
Brahma/MS
Brahmagupta/M
Brahman/MS
Brahmani
Brahmanism/SM
Brahmaputra/M
Brahms/M
Braille/MS
Brain/M
Brampton/M
Bran/M
Branch/M
Brandeis/M
Branden/M
Brandenburg/M
Brandi/M
Brandie/M
Brando/M
Brandon/M
Brandt/M
Brandy/M
Brant/M
Braque/M
Brasilia/M
Bratislava/M
Brattain/M
Bray/M
Brazil/M
Brazilian/MS
Brazos/M
Brazzaville/M
Breakspear/M
Breathalyzer
Brecht/M
Breckenridge/M
Bremen/M
Brenda/M
Brendan/M
Brennan/M
Brenner/M
Brent/M
Brenton/M
Brest/M
Bret/M
Breton/M
Brett/M
Brewer/M
Brewster/M
Brezhnev/M
Brian/M
Briana/M
Brianna/M
Brice/M
Bridalveil/M
Bridgeport/M
Bridger/M
Bridges/M
Bridget/M
Bridgetown/M
Bridgett/M
Bridgette/M
Bridgman/M
Brie/SM
Brigadoon/M
Briggs/M
Brigham/M
Bright/M
Brighton/M
Brigid/M
Brigitte/M
Brillo/M
Brinkley/M
Brisbane/M
Bristol/M
Brit/SM
Britain/M
Britannia/M
Britannic/M
Britannica/M
Briticism/SM
British/MRZ
Britisher/M
Britney/M
Briton/MS
Britt/MN
Brittany/SM
Britten/M
Brittney/M
Brno/M
Broadway/SM
Brobdingnag/M
Brobdingnagian/M
Brock/M
Brokaw/M
Bronson/M
Bronte/M
Brontosaurus
Bronx/M
Brooke/MS
Brooklyn/M
Brooks/M
Bros
Brown/MG
Browne/M
Brownian/M
Brownie/S
Browning/M
Brownshirt/M
Brownsville/M
Brubeck/M
Bruce/M
Bruckner/M
Bruegel
Brummel/M
Brunei/M
Bruneian/MS
Brunelleschi/M
Brunhilde/M
Bruno/M
Brunswick/M
Brussels/M
Brut/M
Brutus/M
Bryan/M
Bryant/M
Bryce/M
Brynner/M
Bryon/M
Brzezinski/M
Btu/M
Buber/M
Buchanan/M
Bucharest/M
Buchenwald/M
Buchwald/M
Buck/M
Buckingham/M
Buckley/M
Buckner/M
Bud/M
Budapest/M
Buddha/SM
Buddhism/SM
Buddhist/SM
Buddy/M
Budweiser/M
Buffalo/M
Buffy/M
Buford/M
Bugatti/M
Bugzilla/M
Buick/M
Bujumbura/M
Bukhara/M
Bukharin/M
Bulawayo/M
Bulfinch/M
Bulganin/M
Bulgar/M
Bulgari/M
Bulgaria/M
Bulgarian/SM
Bullock/M
Bullwinkle/M
Bultmann/M
Bumppo/M
Bunche/M
Bundesbank/M
Bundestag/M
Bunin/M
Bunker/M
Bunsen/M
Bunuel/M
Bunyan/M
Burbank/M
Burberry/M
Burch/M
Burger/M
Burgess/M
Burgoyne/M
Burgundian/M
Burgundy/SM
Burke/M
Burks/M
Burl/M
Burlington/M
Burma/M
Burmese/M
Burnett/M
Burns/M
Burnside/M
Burr/M
Burris/M
Burroughs/M
Bursa/M
Burt/M
Burton/M
Burundi/M
Burundian/MS
Busch/M
Bush/M
Bushido/M
Bushnell/M
Butler/M
Butterfingers/M
Buxtehude/M
Byblos/M
Byers/M
Byrd/M
Byron/M
Byronic/M
Byzantine/MS
Byzantium/M
C/SM
CA
CAD/M
CAI
CAM
CAP
CARE
CATV
CB
CBC/M
CBS/M
CCTV
CCU
CD/M
CDC
CDT
CEO/M
CF
CFC/M
CFO
CGI
CIA/M
CID
CNN/M
CNS/M
CO/M
COBOL/SM
COD
COL
COLA
CPA/M
CPI/M
CPO
CPR/M
CPU/M
CRT/SM
CST/M
CT/M
CV
CVS/M
CZ
Ca/M
Cabernet/M
Cabot/M
Cabral/M
Cabrera/M
Cabrini/M
Cadette
Cadillac/M
Cadiz/M
Caedmon/M
Caerphilly/M
Caesar/SM
Cage/M
Cagney/M
Cahokia/M
Caiaphas/M
Cain/SM
Cairo/M
Caitlin/M
Cajun/MS
Cal/M
Calais/M
Calcutta/M
Calder/M
Calderon/M
Caldwell/M
Caleb/M
Caledonia/M
Calgary/M
Calhoun/M
Cali/M
Caliban/M
Calif
California/M
Californian/SM
Caligula/M
Callaghan/M
Callahan/M
Callao/M
Callas/M
Callie/M
Calliope/M
Callisto/M
Caloocan/M
Calvary/M
Calvert/M
Calvin/M
Calvinism/MS
Calvinist/MS
Calvinistic
Camacho/M
Cambodia/M
Cambodian/SM
Cambrian/SM
Cambridge/M
Camden/M
Camel/M
Camelopardalis/M
Camelot/MS
Camembert/MS
Cameron/M
Cameroon/SM
Cameroonian/MS
Camilla/M
Camille/M
Camoens/M
Campanella/M
Campbell/M
Campinas/M
Campos/M
Camry/M
Camus/M
Can/M
Canaan/M
Canaanite/MS
Canad
Canada/M
Canadian/SM
Canadianism
Canaletto/M
Canaries/M
Canaveral/M
Canberra/M
Cancer/SM
Cancun/M
Candace/M
Candice/M
Candide/M
Candy/M
Cannes/M
Cannon/M
Canon/M
Canopus/M
Cantabrigian/M
Canterbury/M
Canton/M
Cantonese/M
Cantor/M
Cantrell/M
Cantu/M
Canute/M
Capablanca/M
Capek/M
Capella/M
Capet/M
Capetian/M
Capetown/M
Caph/M
Capistrano/M
Capitol/SM
Capitoline/M
Capone/M
Capote/M
Capra/M
Capri/M
Capricorn/MS
Capt
Capuchin/M
Capulet/M
Cara/M
Caracalla/M
Caracas/M
Caravaggio/M
Carboloy/M
Carboniferous/M
Carborundum/M
Cardenas/M
Cardiff/M
Cardin/M
Cardozo/M
Carey/M
Carib/MS
Caribbean/MS
Carina/M
Carissa/M
Carl/M
Carla/M
Carlene/M
Carlin/M
Carlo/MS
Carlos/M
Carlsbad/M
Carlson/M
Carlton/M
Carly/M
Carlyle/M
Carmela/M
Carmella/M
Carmelo/M
Carmen/M
Carmichael/M
Carmine/M
Carnap/M
Carnation/M
Carnegie/M
Carney/M
Carnot/M
Carol/M
Carole/M
Carolina/M
Caroline/M
Carolingian/M
Carolinian/M
Carolyn/M
Carpathian/SM
Carpathians/M
Carpenter/M
Carr/M
Carranza/M
Carrie/RM
Carrier/M
Carrillo/M
Carroll/M
Carson/M
Carter/M
Cartesian/M
Carthage/M
Carthaginian/MS
Cartier/M
Cartwright/M
Caruso/M
Carver/M
Cary/M
Casablanca/M
Casals/M
Casandra/M
Casanova/SM
Cascades/M
Case/M
Casey/M
Cash/M
Casio/M
Caspar/M
Caspian/M
Cassandra/SM
Cassatt/M
Cassidy/M
Cassie/M
Cassiopeia/M
Cassius/M
Castaneda/M
Castilian
Castillo/M
Castlereagh/M
Castor/M
Castries/M
Castro/M
Catalan/SM
Catalina/M
Catalonia/M
Catawba/M
Caterpillar/M
Cathay/M
Cather/M
Catherine/M
Cathleen/M
Catholic/MS
Catholicism/MS
Cathryn/M
Cathy/M
Catiline/M
Cato/M
Catskill/SM
Catskills/M
Catt/M
Catullus/M
Caucasian/MS
Caucasoid
Caucasus/M
Cauchy/M
Cavendish/M
Cavour/M
Caxton/M
Cayenne/M
Cayman/M
Cayuga/SM
Cayuse
Cb
Cd/M
Ce/M
Ceausescu/M
Cebu/M
Cebuano/M
Cecelia/M
Cecil/M
Cecile/M
Cecilia/M
Cecily/M
Cedric/M
Celeste/M
Celia/M
Celina/M
Cellini/M
Celsius/M
Celt/SM
Celtic/SM
Cenozoic/M
Centaurus/M
Centigrade
Central
Cepheid/M
Cepheus/M
Cerberus/M
Cerenkov/M
Ceres/M
Cerf/M
Cervantes/M
Cesar/M
Cesarean/M
Cessna/M
Cetus/M
Ceylon/M
Ceylonese
Cezanne/M
Cf/M
Ch'in/M
Ch/N
Chablis/M
Chad/M
Chadian/MS
Chadwick/M
Chagall/M
Chaitanya/M
Chaitin/M
Chaldea
Chaldean/M
Challenger/M
Chalmers
Chamberlain/M
Chambers/M
Champlain/M
Champollion/M
Chan/M
Chance/M
Chancellorsville/M
Chandigarh/M
Chandler/M
Chandon/M
Chandra/M
Chandragupta/M
Chandrasekhar/M
Chanel/M
Chaney/M
Chang/M
Changchun/M
Changsha/M
Chantilly/M
Chaplin/M
Chaplinesque
Chapman/M
Chappaquiddick/M
Chapultepec/M
Charbray/M
Chardonnay/M
Charity/M
Charlemagne/M
Charlene/M
Charles/M
Charleston/MS
Charley/M
Charlie/M
Charlotte/M
Charlottetown/M
Charmaine/M
Charmin/M
Charolais/M
Charon/M
Chartism/M
Chartres/M
Charybdis/M
Chase/M
Chasity/M
Chateaubriand/M
Chattahoochee/M
Chattanooga/M
Chatterley/M
Chatterton/M
Chaucer/M
Chauncey/M
Chautauqua/M
Chavez/M
Chayefsky/M
Che/M
Chechen/M
Chechnya/M
Cheddar/M
Cheer/M
Cheerios/M
Cheetos/M
Cheever/M
Chekhov/M
Chekhovian
Chelsea/M
Chelyabinsk/M
Chen/M
Cheney/M
Chengdu/M
Chennai/M
Cheops/M
Cheri/M
Cherie/M
Chernenko/M
Chernobyl/M
Chernomyrdin/M
Cherokee/MS
Cherry/M
Cheryl/M
Chesapeake/M
Cheshire/M
Chester/M
Chesterfield/M
Chesterton/M
Chevalier/M
Cheviot/M
Chevrolet/M
Chevron/M
Chevy/M
Cheyenne/SM
Chi/M
Chianti/MS
Chiba/M
Chibcha/M
Chicago/M
Chicagoan/M
Chicana/M
Chicano/M
Chickasaw/MS
Chiclets/M
Chihuahua/MS
Chile/M
Chilean/MS
Chimborazo/M
Chimera/MS
Chimu/M
Chin/M
China/M
Chinatown/M
Chinese/M
Chinook/MS
Chipewyan/M
Chippendale/M
Chippewa/SM
Chiquita/M
Chirico/M
Chisholm/M
Chisinau/M
Chittagong/M
Chivas/M
Chloe/M
Choctaw/SM
Chomsky/M
Chongqing/M
Chopin/M
Chopra/M
Chou/M
Chretien/M
Chris/M
Christ/MS
Christa/M
Christchurch/M
Christendom/MS
Christensen/M
Christi/M
Christian/SM
Christianity/SM
Christianize
Christie/M
Christina/M
Christine/M
Christlike
Christmas/MS
Christmastide/MS
Christmastime/MS
Christoper/M
Christopher/M
Chronicles
Chrysler/M
Chrysostom/M
Chrystal/M
Chuck/M
Chukchi/M
Chumash/M
Chung/M
Church/M
Churchill/M
Churriguera/M
Chuvash/M
Ci/M
Cicero/M
Cid/M
Cimabue/M
Cincinnati/M
Cinderella/MS
Cindy/M
CinemaScope/M
Cinerama/M
Cipro/M
Circe/M
Cisco/M
Citibank/M
Citigroup/M
Citroen/M
Cl/MV
Claiborne/M
Clair/M
Claire/M
Clairol/M
Clancy/M
Clapeyron/M
Clapton/M
Clara/M
Clare/M
Clarence/M
Clarendon/M
Clarice/M
Clarissa/M
Clark/M
Clarke/M
Claude/M
Claudette/M
Claudia/M
Claudine/M
Claudio/M
Claudius/M
Claus/M
Clausewitz/M
Clausius/M
Clay/M
Clayton/M
Clearasil/M
Clem/XM
Clemenceau/M
Clemens/M
Clement/MS
Clementine/M
Clements/M
Clemons/M
Clemson/M
Cleo/M
Cleopatra/M
Cleveland/M
Cliburn/M
Cliff/M
Clifford/M
Clifton/M
Cline/M
Clint/M
Clinton/M
Clio/M
Clive/M
Clorets/M
Clorox/M
Closure/M
Clotho/M
Clouseau/M
Clovis/M
Clyde/M
Clydesdale/M
Clytemnestra/M
Cm/M
Cmdr
Co/M
Cobain/M
Cobb/M
Cochabamba/M
Cochin/M
Cochise/M
Cochran/M
Cockney/M
Cocteau/M
Cod
Cody/M
Coffey/M
Cognac/M
Cohan/M
Cohen/M
Coimbatore/M
Cointreau/M
Coke/SM
Col/M
Colbert/M
Colby/M
Cole/M
Coleen/M
Coleman/M
Coleridge/M
Colette/M
Colfax/M
Colgate/M
Colin/M
Colleen/M
Collier/M
Collin/SM
Collins/M
Colo
Cologne/M
Colombia/M
Colombian/MS
Colombo/M
Colon/M
Coloradan/SM
Colorado/M
Coloradoan
Colosseum/M
Colt/M
Coltrane/M
Columbia/M
Columbine/M
Columbus/M
Com
Comanche/MS
Combs/M
Comdr
Comintern/M
Commandment
Commons/M
Commonwealth
Communion/SM
Communism
Communist/SM
Como/M
Comoran
Comoros/M
Compaq/M
Compton/M
CompuServe/M
Comte/M
Conakry/M
Conan/M
Concepcion/M
Concetta/M
Concord/SM
Concorde/M
Condillac/M
Condorcet/M
Conestoga/M
Confederacy/M
Confederate/MS
Confucian/SM
Confucianism/MS
Confucius/M
Cong/M
Congo/M
Congolese/M
Congregational
Congregationalist/MS
Congress/MS
Congressional
Congreve/M
Conley/M
Conn/MR
Connecticut/M
Connemara/M
Conner/M
Connery/M
Connie/M
Connolly/M
Connors/M
Conrad/M
Conrail/M
Conservative
Constable/M
Constance/M
Constantine/M
Constantinople/M
Constitution
Consuelo/M
Continent/M
Continental/M
Contreras/M
Conway/M
Cook/M
Cooke/M
Cooley/M
Coolidge/M
Cooper/M
Cooperstown/M
Coors/M
Copacabana/M
Copeland/M
Copenhagen/M
Copernican/M
Copernicus/M
Copland/M
Copley/M
Copperfield/M
Coppertone/M
Coppola/M
Coptic/M
Cora/M
Cordelia/M
Cordilleras/M
Cordoba/M
Corey/M
Corfu/M
Corina/M
Corine/M
Corinne/M
Corinth/M
Corinthian/MS
Corinthians/M
Coriolanus/M
Coriolis/M
Cork
Corleone/M
Cormack/M
Corneille/M
Cornelia/M
Cornelius/M
Cornell/M
Corning/M
Cornish/MS
Cornwall/M
Cornwallis/M
Coronado/M
Corot/M
Corp
Correggio/M
Corrine/M
Corsica/M
Corsican/M
Cortes/MS
Cortland/M
Corvallis/M
Corvette/M
Corvus/M
Cory/M
Cosby/M
Cossack/M
Costco/M
Costello/M
Costner/M
Cote/M
Cotonou/M
Cotopaxi/M
Cotswold/M
Cotton/M
Coulomb/M
Coulter/M
Couperin/M
Courbet/M
Courtney/M
Cousteau/M
Coventry/SM
Coward/M
Cowell/M
Cowley/M
Cowper/M
Cox/M
Coy/M
Cozumel/M
Cpl
Cr/MT
Crabbe/M
Craft/M
Craig/M
Cranach/M
Crane/M
Cranmer/M
Crater/M
Crawford/M
Cray/M
Crayola/M
Creation/M
Creator/M
Crecy/M
Cree/DSM
Creek/SM
Creighton/M
Creole/SM
Creon/M
Cressida/M
Crest/M
Cretaceous/M
Cretan/SM
Crete/M
Crichton/M
Crick/M
Crimea/M
Crimean/M
Criollo/M
Crisco/M
Cristina/M
Croat/SM
Croatia/M
Croatian/MS
Croce/M
Crockett/M
Croesus/M
Cromwell/M
Cromwellian/M
Cronin/M
Cronkite/M
Cronus/M
Crookes/M
Crosby/M
Cross/M
Crow/SM
Crowley/M
Crucifixion/MS
Cruikshank/M
Cruise/M
Crusades's
Crusoe/M
Crux/M
Cruz/M
Cryptozoic/M
Crystal/M
Csonka/M
Ct
Ctesiphon/M
Cthulhu/M
Cu/M
Cuba/M
Cuban/SM
Cuchulain/M
Cuisinart/M
Culbertson/M
Cullen/M
Cumberland/M
Cummings/M
Cunard/M
Cunningham/M
Cupid/M
Curacao/M
Curie/M
Curitiba/M
Currier/M
Curry/RM
Curt/M
Curtis/M
Custer/M
Cuvier/M
Cuzco/M
Cybele/M
Cyclades/M
Cyclopes/M
Cyclops/M
Cygnus/M
Cymbeline/M
Cynthia/M
Cyprian/M
Cypriot/MS
Cyprus/M
Cyrano/M
Cyril/M
Cyrillic/M
Cyrus/M
Czech/M
Czechoslovak
Czechoslovakia/M
Czechoslovakian/SM
Czechs
Czerny/M
D/M
DA/M
DAR
DAT/M
DBMS/M
DC/M
DD/M
DDS/M
DDT/S
DE
DEA
DEC/SD
DH
DHS
DI
DJ
DMCA
DMD/M
DMZ
DNA/M
DOA
DOB
DOD
DOE
DOS/M
DOT
DP/SM
DPT
DST
DTP
DUI
DVD
DVR/SM
DWI
Dachau/M
Dacron/SM
Dada/M
Dadaism/M
Daedalus/M
Daguerre/M
Dagwood/M
Dahomey/M
Daimler/M
Daisy/M
Dakar/M
Dakota/SM
Dakotan/M
Dalai
Dale/M
Daley/M
Dali/M
Dalian/M
Dallas/M
Dalmatia/M
Dalmatian/SM
Dalton/M
Damascus/M
Dame/MN
Damian/M
Damien/M
Damion/M
Damocles/M
Damon/M
Dan/M
Dana/M
Danae/M
Dane/SM
Danelaw/M
Dangerfield/M
Danial/M
Daniel/SM
Danielle/M
Daniels/M
Danish/M
Dannie/M
Danny/M
Danone/M
Dante/M
Danton/M
Danube/M
Danubian/M
Daphne/M
Darby/M
Darcy/M
Dardanelles/M
Dare/M
Daren/M
Darfur/M
Darin/M
Dario/M
Darius/M
Darjeeling/M
Darla/M
Darlene/M
Darling/M
Darnell/M
Darrel/M
Darrell/M
Darren/M
Darrin/M
Darrow/M
Darryl/M
Darth/M
Dartmoor/M
Dartmouth/M
Darvon/M
Darwin/M
Darwinian/M
Darwinism/SM
Darwinist
Daryl/M
Datamation
Daugherty/M
Daumier/M
Davao/M
Dave/M
Davenport/M
David/MS
Davidson/M
Davies/M
Davis/M
Davy/SM
Dawes/M
Dawkins
Dawn/M
Dawson/M
Day/M
Dayan
Dayton/M
DeGeneres/M
Deadhead/M
Dean/M
Deana/M
Deandre/M
Deann/M
Deanna/M
Deanne/M
Death/M
Debbie/M
Debby/M
Debian/M
Debora/M
Deborah/M
Debouillet/M
Debra/M
Debs/M
Debussy/M
Dec/M
Decalogue/M
Decatur/M
Decca/M
Deccan/M
December/SM
Decker/M
Dedekind/M
Dee/M
Deena/M
Deere/M
Defoe/M
Degas/M
Deidre/M
Deimos/M
Deirdre/M
Deity
Dejesus/M
Del/M
Delacroix/M
Delacruz/M
Delaney/M
Delano/M
Delaware/MS
Delawarean/SM
Delbert/M
Deleon/M
Delgado/M
Delhi/M
Delia/M
Delibes/M
Delicious/M
Delilah/M
Delilahs
Delius/M
Dell/M
Della/M
Delmar/M
Delmarva/M
Delmer/M
Delmonico/M
Delores/M
Deloris/M
Delphi/M
Delphic/M
Delphinus/M
Delta/M
Dem/G
Demavend/M
Demerol/M
Demeter/M
Demetrius/M
Deming/M
Democrat/SM
Democratic
Democritus/M
Demosthenes/M
Dempsey/M
Dena/M
Denali
Deneb/M
Denebola/M
Deng/M
Denis/M
Denise/M
Denmark/M
Dennis/M
Denny/M
Denver/M
Deon/M
Depp/M
Derby/M
Derek/M
Derick/M
Dermot/M
Derrick/M
Derrida/M
Descartes/M
Desdemona/M
Desiree/M
Desmond/M
Detroit/M
Deuteronomy/M
Devanagari/M
Devi/M
Devin/M
Devon/M
Devonian/M
Dewar/M
Dewayne/M
Dewey/M
Dewitt/M
Dexedrine/M
Dexter/M
Dhaka/M
Dhaulagiri/M
Di/SM
DiCaprio/M
DiMaggio/M
Diaghilev/M
Dial/M
Diana/M
Diane/M
Diann/M
Dianna/M
Dianne/M
Dias
Diaspora/MS
Dick/XM
Dickens/M
Dickensian
Dickerson/M
Dickinson/M
Dickson/M
Dictaphone/SM
Diderot/M
Dido/M
Didrikson/M
Diefenbaker/M
Diego/M
Diem/M
Dietrich/M
Dijkstra/M
Dijon/M
Dilbert/MS
Dillard/M
Dillinger/M
Dillon/M
Dina/M
Dinah/M
Dino/M
Diocletian/M
Diogenes/M
Dion/M
Dionne/M
Dionysian/M
Dionysus/M
Diophantine/M
Dior/M
Dipper/M
Dir
Dirac/M
Dirichlet/M
Dirk/M
Dis/M
Disney/M
Disneyland/M
Disraeli/M
Divine/M
Diwali/M
Dix/M
Dixie/M
Dixiecrat/M
Dixieland/SM
Dixon/M
Djibouti/M
Dmitri/M
Dnepropetrovsk/M
Dniester/M
Dobbin/M
Doberman/M
Dobro/M
Doctor
Doctorow/M
Dodge/M
Dodgson/M
Dodoma/M
Dodson/M
Doe/M
Doha/M
Dolby/M
Dole/M
Dollie/M
Dolly/M
Dolores/M
Domesday/M
Domingo/M
Dominguez/M
Dominic/M
Dominica/M
Dominican/MS
Dominick/M
Dominion
Dominique/M
Domitian/M
Don/SM
Dona/M
Donahue/M
Donald/M
Donaldson/M
Donatello/M
Donetsk/M
Donizetti/M
Donn/MR
Donna/M
Donne/M
Donnell/M
Donner/M
Donnie/M
Donny/M
Donovan/M
Dooley/M
Doolittle/M
Doonesbury/M
Doppler/M
Dora/M
Dorcas/M
Doreen/M
Dorian/M
Doric/M
Doris/M
Doritos/M
Dorothea/M
Dorothy/M
Dorset/M
Dorsey/M
Dorthy/M
Dortmund/M
Dostoevsky/M
Dot/M
Dotson/M
Douala/M
Douay/M
Doubleday/M
Doug/M
Douglas/M
Douglass/M
Douro/M
Dover/M
Dow/M
Downs/M
Downy/M
Doyle/M
Dr
Draco/M
Draconian/M
Dracula/M
Drake/M
Dramamine/SM
Drambuie/M
Drano/M
Dravidian/M
Dreiser/M
Dresden/M
Drew/M
Dreyfus/M
Dristan/M
Dropbox/M
Drudge/M
Dryden/M
Dschubba/M
Du
DuPont/M
Duane/M
Dubai/M
Dubcek/M
Dubhe/M
Dublin/M
Dubrovnik/M
Duchamp/M
Dudley/M
Duffy/M
Duisburg/M
Duke/M
Dulles/M
Duluth/M
Dumas/M
Dumbledore/M
Dumbo/M
Dumpster/M
Dunant/M
Dunbar/M
Duncan/M
Dundee
Dunedin/M
Dunkirk/M
Dunlap/M
Dunn/M
Dunne/M
Duracell/M
Duran/M
Durant/M
Durante/M
Durban/M
Durer/M
Durex/M
Durham/MS
Durkheim/M
Duroc/M
Durocher/M
Duse/M
Dushanbe/M
Dusseldorf/M
Dustbuster/M
Dustin/M
Dusty/M
Dutch/M
Dutchman/M
Dutchmen/M
Dutchwoman
Duvalier/M
Dvina/M
Dvorak/M
Dwayne/M
Dwight/M
Dy/M
Dyer/M
Dylan/M
Dyson/M
Dzerzhinsky/M
Dzungaria/M
E/SM
EC
ECG/M
ECMAScript/M
EDP/M
EDT
EEC/M
EEG/M
EEO
EEOC
EFL
EFT
EKG/M
ELF/M
EM
EMT
ENE/M
EOE
EPA/M
ER
ERA
ESE/M
ESL
ESP/M
ESPN/M
ESR
EST/M
ET
ETA
ETD
EU
EULA/S
Eakins/M
Earhart/M
Earl/M
Earle/M
Earlene/M
Earline/M
Earnest/M
Earnestine/M
Earnhardt/M
Earp/M
East/SZMR
Easter/M
Eastern/R
Eastman/M
Eastwood/M
Eaton/M
Eben/M
Ebeneezer/M
Ebert/M
Ebola/M
Ebonics/M
Ebony/M
Ebro/M
Ecclesiastes/M
Eco/M
Ecstasy
Ecuador/M
Ecuadoran/SM
Ecuadorean
Ecuadorian/SM
Ed/MNX
Edam/SM
Edda/M
Eddie/M
Eddington/M
Eddy/M
Eden/M
Edgar/M
Edgardo/M
Edinburgh/M
Edison/M
Edith/M
Edmond/M
Edmonton/M
Edmund/M
Edna/M
Edsel/M
Eduardo/M
Edward/SM
Edwardian/M
Edwardo/M
Edwards/M
Edwin/M
Edwina/M
Eeyore/M
Effie/M
Efrain/M
Efren/M
Eggo/M
Egypt/M
Egyptian/MS
Egyptology/M
Ehrenberg/M
Ehrlich/M
Eichmann/M
Eiffel/M
Eileen/M
Einstein/MS
Eire/M
Eisenhower/M
Eisenstein/M
Eisner/M
Elaine/M
Elam/M
Elanor/M
Elastoplast/M
Elba/M
Elbe/M
Elbert/M
Elbrus/M
Eldon/M
Eleanor/M
Eleazar/M
Electra/M
Elena/M
Elgar/M
Eli/M
Elias/M
Elijah/M
Elinor/M
Eliot/M
Elisa/M
Elisabeth/M
Elise/M
Eliseo/M
Elisha/M
Eliza/M
Elizabeth/M
Elizabethan/SM
Ella/M
Ellen/M
Ellesmere/M
Ellie/M
Ellington/M
Elliot/M
Elliott/M
Ellis/M
Ellison/M
Elma/M
Elmer/M
Elmo/M
Elnath/M
Elnora/M
Elohim/M
Eloise/M
Eloy/M
Elroy/M
Elsa/M
Elsie/M
Elsinore/M
Eltanin/M
Elton/M
Elul/M
Elva/M
Elvia/M
Elvin/M
Elvira/M
Elvis/M
Elway/M
Elwood/M
Elysee/M
Elysian/M
Elysium/SM
Emacs/M
Emanuel/M
Emerson/M
Emery/M
Emil/M
Emile/M
Emilia/M
Emilio/M
Emily/M
Eminem/M
Eminence
Emma/M
Emmanuel/M
Emmett/M
Emmy/M
Emory/M
Encarta/M
Endymion/M
Eng/M
Engels/M
England/M
English/MRS
Englishman/M
Englishmen/M
Englishwoman/M
Englishwomen/M
Enid/M
Enif/M
Eniwetok/M
Enkidu/M
Enoch/M
Enos/M
Enrico/M
Enrique/M
Enron/M
Enterprise/M
Eocene/M
Epcot/M
Ephesian/MS
Ephesus/M
Ephraim/M
Epictetus/M
Epicurean/M
Epicurus/M
Epimethius/M
Epiphany/SM
Episcopal
Episcopalian/MS
Epistle
Epsom/M
Epson/M
Epstein/M
Equuleus/M
Er/M
Erasmus/M
Erato/M
Eratosthenes/M
Erebus/M
Erector/M
Erewhon/M
Erhard/M
Eric/M
Erica/M
Erich/M
Erick/M
Ericka/M
Erickson/M
Eridanus/M
Erie/M
Erik/M
Erika/M
Erin/M
Eris/MS
Eritrea/M
Eritrean/SM
Erlenmeyer/M
Erma/M
Erna/M
Ernest/M
Ernestine/M
Ernesto/M
Ernie/M
Ernst/M
Eros/MS
Errol/M
Erse/M
ErvIn/M
Erwin/M
Esau/M
Escher/M
Escherichia/M
Escondido
Eskimo/MS
Esmeralda/M
Esperanto/M
Esperanza/M
Espinoza/M
Esq/M
Esquire/MS
Essen/M
Essene/M
Essequibo/M
Essex/M
Essie/M
Establishment
Esteban/M
Estela/M
Estella/M
Estelle/M
Ester/M
Esterhazy/M
Estes/M
Esther/M
Estonia/M
Estonian/SM
Estrada/M
Ethan/M
Ethel/M
Ethelred/M
Ethernet/M
Ethiopia/M
Ethiopian/SM
Etna/M
Eton/M
Etruria/M
Etruscan/M
Etta/M
Eu/M
Eucharist/MS
Eucharistic
Euclid/M
Eugene/M
Eugenia/M
Eugenie/M
Eugenio/M
Eula/M
Euler/M
Eumenides/M
Eunice/M
Euphrates/M
Eur
Eurasia/M
Eurasian/MS
Euripides/M
Eurodollar/SM
Europa/M
Europe/M
European/MS
Eurydice/M
Eustachian/M
Euterpe/M
Eva/M
Evan/SM
Evangelical
Evangelina/M
Evangeline/M
Evangelist/M
Evans/M
Evansville/M
Eve/M
Evelyn/M
Evenki/M
EverReady/M
Everest/M
Everett/M
Everette/M
Everglades/M
Evert/M
Evian/M
Evita/M
Ewing/M
Excalibur/M
Excedrin/M
Excellency/SM
Exchequer
Exercycle/M
Exocet/M
Exodus/M
Exxon/M
Eyck/M
Eyre/M
Eysenck/M
Ezekiel/M
Ezra/M
F/MD
FAA
FAQ/SM
FBI/M
FCC
FD
FDA
FDIC/M
FDR/M
FHA/M
FICA/M
FIFO
FL
FM/SM
FNMA/M
FOFL
FORTRAN/M
FPO
FSF/M
FSLIC
FTC
FUD/S
FWD
FWIW
FY
FYI
Faberge/M
Fabian/MS
Facebook/M
Faeroe/M
Fafnir/M
Fagin/M
Fahd/M
Fahrenheit/M
Fairbanks/M
Faisal/M
Faisalabad/M
Faith/M
Falasha/M
Falkland/SM
Falklands/M
Fallopian/M
Falstaff/M
Falwell/M
Fannie/M
Fanny/M
Faraday/M
Fargo/M
Farley/M
Farmer/M
Farragut/M
Farrakhan/M
Farrell/M
Farrow/M
Farsi/M
Fassbinder/M
Fatah/M
Fates/M
Father/SM
Fatima/M
Fatimid/M
Faulkner/M
Faulknerian/M
Fauntleroy/M
Faust/M
Faustian/M
Faustino/M
Faustus/M
Fawkes/M
Fay/M
Faye/M
Fe/M
Feb/M
February/SM
Fed/SM
FedEx/M
Federal/MS
Federalist/M
Federico/M
Feds/M
Felecia/M
Felice/M
Felicia/M
Felicity/M
Felipe/M
Felix/M
Fellini/M
Fenian/M
Ferber/M
Ferdinand/M
Fergus/M
Ferguson/M
Ferlinghetti/M
Fermat/M
Fermi/M
Fern/M
Fernandez/M
Fernando/M
Ferrari/M
Ferraro/M
Ferrell/M
Ferris/M
Feynman/M
Fez/M
Fiat/M
Fiberglas/M
Fibonacci/M
Fichte/M
Fidel/M
Fido/M
Fielding/M
Fields/M
Figaro/M
Figueroa/M
Fiji/M
Fijian/MS
Filipino/MS
Fillmore/M
Filofax/M
Finch/M
Finland/M
Finley/M
Finn/SM
Finnbogadottir/M
Finnegan/M
Finnish/M
Fiona/M
Firefox/M
Firestone/M
Fischer/M
Fisher/M
Fisk/M
Fitch/M
Fitzgerald/M
Fitzpatrick/M
Fitzroy/M
Fizeau/M
Fla
Flanagan/M
Flanders/M
Flathead
Flatt/M
Flaubert/M
Fleischer/M
Fleming/M
Flemish/M
Fletcher/M
Flint/M
Flintstones/M
Flo/M
Flora/M
Florence/M
Florentine/M
Flores/M
Florida/M
Floridan/M
Floridian/SM
Florine/M
Florsheim/M
Flory/M
Flossie/M
Flowers/M
Floyd/M
Flynn/M
Fm/M
Foch/M
Fokker/M
Foley/M
Folgers/M
Folsom/M
Fomalhaut/M
Fonda/M
Foosball/M
Forbes/M
Ford/M
Foreman/M
Forest/MR
Forester/M
Formica/MS
Formosa/M
Formosan/M
Forrest/M
Forster/M
Fortaleza/M
Fosse/M
Foster/M
Fotomat/M
Foucault/M
Fourier/M
Fourneyron/M
Fourth
Fowler/M
Fox/MS
Fr/MD
Fragonard/M
Fran/M
France/SM
Frances/M
Francesca/M
Francine/M
Francis/M
Francisca/M
Franciscan/MS
Francisco/M
Franck/M
Franco/M
Francois/M
Francoise/M
Francophile
Franglais/M
Frank/SM
Frankel/M
Frankenstein/M
Frankfort/M
Frankfurt/MR
Frankfurter/M
Frankie/M
Frankish
Franklin/M
Franks/M
Franny/M
Franz/M
Fraser/M
Frau/MN
Fraulein
Frazier/M
Fred/M
Freda/M
Freddie/M
Freddy/M
Frederic/M
Frederick/M
Fredericton/M
Fredric/M
Fredrick/M
Freeman/M
Freemason/SM
Freemasonry/SM
Freetown/M
Freida/M
Fremont/M
French/MS
Frenchman/M
Frenchmen/M
Frenchwoman/M
Frenchwomen/M
Freon/M
Fresnel/M
Fresno/M
Freud/M
Freudian/M
Frey/M
Freya/M
Fri/M
Friday/SM
Frieda/M
Friedan/M
Friedman/M
Friend/SM
Frigga/M
Frigidaire/M
Frisbee/M
Frisco/M
Frisian/MS
Frito/M
Fritz/M
Frobisher/M
Frodo/M
Froissart/M
Fromm/M
Fronde/M
Frontenac/M
Frost/M
Frostbelt/M
Frunze/M
Fry/M
Frye/M
Fuchs/M
Fuentes/M
Fugger/M
Fuji/M
Fujitsu/M
Fujiwara/M
Fujiyama/M
Fukuoka/M
Fukuyama/M
Fulani/M
Fulbright/M
Fuller/M
Fullerton/M
Fulton/M
Funafuti/M
Fundy/M
Furies/M
Furtwangler/M
Fushun/M
Fuzhou/M
Fuzzbuster/M
G/MNRB
GA
GAO
GATT/M
GB/M
GCC/M
GDP/M
GE/M
GED
GHQ/M
GHz
GI
GIF
GIGO
GM/M
GMAT
GMO
GMT/M
GNP/M
GNU/M
GOP/M
GP/M
GPA
GPO
GPS
GPU
GSA
GTE/M
GU
GUI/M
Ga/M
Gable/M
Gabon/M
Gabonese/M
Gaborone/M
Gabriel/M
Gabriela/M
Gabrielle/M
Gacrux/M
Gadsden/M
Gaea/M
Gael/SM
Gaelic/M
Gagarin/M
Gage/M
Gaia/M
Gail/M
Gaiman/M
Gaines/M
Gainsborough/M
Galahad/SM
Galapagos/M
Galatea/M
Galatia/M
Galatians/M
Galaxy
Galbraith/M
Gale/M
Galen/M
Galibi/M
Galilean/SM
Galilee/M
Galileo/M
Gall/M
Gallagher/M
Gallegos/M
Gallic/M
Gallicism/SM
Gallo/M
Galloway/M
Gallup/M
Galois/M
Galsworthy/M
Galvani/M
Galveston/M
Gama
Gamay/M
Gambia/M
Gambian/SM
Gamble/M
Gamow/M
Gandalf/M
Gandhi/M
Gandhian/M
Ganesha/M
Ganges/M
Gangtok/M
Gantry/M
Ganymede/M
Gap/M
Garbo/M
Garcia/M
Gardner/M
Gareth/M
Garfield/M
Garfunkel/M
Gargantua/M
Garibaldi/M
Garland/M
Garner/M
Garrett/M
Garrick/M
Garrison/M
Garry/M
Garth/M
Garvey/M
Gary/M
Garza/M
Gascony/M
Gasser/M
Gastroenterology
Gates/M
Gatling/M
Gatorade/M
Gatsby/M
Gatun/M
Gauguin/M
Gaul/SM
Gaulish
Gauss/M
Gaussian/M
Gautama/M
Gautier/M
Gavin/M
Gawain/M
Gay/M
Gayle/M
Gaza/M
Gaziantep/M
Gd/M
Gdansk/M
Ge/M
Geffen/M
Gehenna/M
Gehrig/M
Geiger/M
Gelbvieh/M
Geller/M
Gemini/MS
Gen/M
Gena/M
Genaro/M
Gene/M
Genesis/M
Genet/M
Geneva/M
Genevieve/M
Genghis/M
Genoa/SM
Gentoo/M
Gentry/M
Geo/M
Geoffrey/M
George/MS
Georgetown/M
Georgette/M
Georgia/M
Georgian/MS
Georgina/M
Ger/M
Gerald/M
Geraldine/M
Gerard/M
Gerardo/M
Gerber/M
Gere/M
Geritol/M
German/MS
Germanic/M
Germany/M
Geronimo/M
Gerry/M
Gershwin/M
Gertrude/M
Gestapo/SM
Gethsemane/M
Getty/M
Gettysburg/M
Gewurztraminer/M
Ghana/M
Ghanaian
Ghats/M
Ghazvanid/M
Ghent/M
Ghibelline/M
Giacometti/M
Giannini/M
Giauque/M
Gibbon/M
Gibbs/M
Gibraltar/MS
Gibson/M
Gide/M
Gideon/M
Gielgud/M
Gienah/M
Gil/M
Gila/M
Gilbert/M
Gilberto/M
Gilchrist/M
Gilda/M
Gilead/M
Giles/M
Gilgamesh/M
Gill/M
Gillespie/M
Gillette/M
Gilliam/M
Gillian/M
Gilligan/M
Gilman
Gilmore/M
Gina/M
Ginger/M
Gingrich/M
Ginny/M
Gino/M
Ginsberg/M
Ginsburg/M
Ginsu/M
Giorgione/M
Giotto/M
Giovanni/M
Giraudoux/M
Giselle/M
Gish/M
GitHub/M
Giuliani/M
Giuseppe/M
Giza/M
Gk
Gladstone/MS
Gladys/M
Glaser/M
Glasgow/M
Glass/M
Glastonbury/M
Glaswegian/SM
Glaxo/M
Gleason/M
Glen/M
Glenda/M
Glendale
Glenlivet/M
Glenn/M
Glenna/M
Gloria/M
Gloucester/M
Glover/M
Gnostic/M
Gnosticism/M
GnuPG
Goa/M
Gobi/M
God/M
Godard/M
Goddard/M
Godel/M
Godhead/M
Godiva/M
Godot/M
Godspeed/SM
Godthaab/M
Godunov/M
Godzilla/M
Goebbels/M
Goering/M
Goethals/M
Goethe/M
Goff/M
Gog/M
Gogol/M
Goiania/M
Golan/M
Golconda/M
Golda/M
Goldberg/M
Golden/M
Goldie/M
Goldilocks/M
Golding/M
Goldman/M
Goldsmith/M
Goldwater/M
Goldwyn/M
Golgi/M
Golgotha/M
Goliath/M
Gomez/M
Gomorrah/M
Gompers/M
Gomulka/M
Gondwanaland/M
Gonzales/M
Gonzalez/M
Gonzalo/M
Good/M
Goodall/M
Goodman/M
Goodrich/M
Goodwill/M
Goodwin/M
Goodyear/M
Google/M
Goolagong/M
Gopher
Gorbachev/M
Gordian/M
Gordimer/M
Gordon/M
Gore/M
Goren/M
Gorey/M
Gorgas/M
Gorgon/M
Gorgonzola/M
Gorky/M
Gospel/MS
Goteborg/M
Goth/M
Gotham/M
Gothic/MS
Goths
Gouda/SM
Gould/M
Gounod/M
Governor
Goya/M
Gr/B
Grable/M
Gracchus/M
Grace/M
Graceland/M
Gracie/M
Graciela/M
Grady/M
Graffias/M
Grafton/M
Graham/M
Grahame/M
Grail/M
Grammy/M
Grampians/M
Granada/M
Grant/M
Grass/M
Graves/M
Gray/M
Grecian/M
Greece/M
Greek/SM
Greeley/M
Green/SM
Greene/M
Greenland/M
Greenlandic
Greenpeace/M
Greensboro/M
Greensleeves/M
Greenspan/M
Greenwich/M
Greer/M
Greg/M
Gregg/M
Gregorian/M
Gregorio/M
Gregory/M
Grenada/M
Grenadian/MS
Grenadines/M
Grendel/M
Grenoble/M
Gresham/M
Greta/M
Gretchen/M
Gretel/M
Gretzky/M
Grey/M
Grieg/M
Griffin/M
Griffith/M
Grimes/M
Grimm/M
Grinch/M
Gris/M
Gromyko/M
Gropius/M
Gross/M
Grosz/M
Grotius/M
Grover/M
Grozny
Grumman/M
Grundy/M
Grunewald/M
Grus/M
Gruyere/SM
Guadalajara/M
Guadalcanal/M
Guadalquivir/M
Guadalupe/M
Guadeloupe/M
Guallatiri/M
Guam/M
Guamanian
Guangzhou/M
Guantanamo/M
Guarani/M
Guarnieri/M
Guatemala/M
Guatemalan/MS
Guayaquil/M
Gucci/M
Guelph/M
Guernsey/MS
Guerra/M
Guerrero/M
Guevara/M
Guggenheim/M
Guiana/M
Guido
Guillermo/M
Guinea/M
Guinean/MS
Guinevere/M
Guinness/M
Guiyang/M
Guizot/M
Gujarat/M
Gujarati/M
Gujranwala/M
Gullah/M
Gulliver/M
Gumbel/M
Gunther/M
Guofeng/M
Gupta/M
Gurkha/M
Gus/M
Gustav/M
Gustavo/M
Gustavus/M
Gutenberg/M
Guthrie/M
Gutierrez/M
Guy/M
Guyana/M
Guyanese/M
Guzman/M
Gwalior/M
Gwen/M
Gwendoline/M
Gwendolyn/M
Gwyn/M
Gypsy/SM
H/M
HBO/M
HDD
HDMI
HDTV
HF/M
HHS
HI
HIV/M
HM
HMO/M
HMS
HOV
HP/M
HPV
HQ/M
HR
HRH
HS
HSBC/M
HST
HT
HTML/M
HTTP
HUD/M
Ha/M
Haas/M
Habakkuk/M
Haber/M
Hadar/M
Hades/M
Hadrian/M
Hafiz/M
Hagar/M
Haggai/M
Hagiographa/M
Hague/M
Hahn/M
Haida/SM
Haifa/M
Haiphong/M
Haiti/M
Haitian/MS
Hakka/M
Hakluyt/M
Hal/SM
Haldane/M
Hale/M
Haleakala/M
Haley/M
Halifax/M
Hall/M
Halley/M
Halliburton/M
Hallie/M
Hallmark/M
Halloween/MS
Hallstatt/M
Halon/M
Hals/M
Halsey/M
Ham/M
Haman/M
Hamburg/MS
Hamhung/M
Hamilcar/M
Hamill/M
Hamilton/M
Hamiltonian/M
Hamitic/M
Hamlet/M
Hamlin/M
Hammarskjold/M
Hammerstein/M
Hammett/M
Hammond/M
Hammurabi/M
Hampshire/M
Hampton/M
Hamsun/M
Han/SM
Hancock/M
Handel/M
Handy/M
Haney/M
Hangul/M
Hangzhou/M
Hank/M
Hanna/M
Hannah/M
Hannibal/M
Hanoi/M
Hanover/M
Hanoverian/M
Hans/MN
Hansel/M
Hansen/M
Hanson/M
Hanuka
Hanukkah/M
Hanukkahs
Hapsburg/M
Harare/M
Harbin/M
Hardin/M
Harding/M
Hardy/M
Hargreaves/M
Harlan/M
Harlem/M
Harlequin/M
Harley/M
Harlow/M
Harmon/M
Harold/M
Harper/M
Harpy/SM
Harrell/M
Harriet/M
Harriett/M
Harrington/M
Harris/M
Harrisburg/M
Harrison/M
Harrods/M
Harry/M
Hart/M
Harte/M
Hartford/M
Hartline/M
Hartman/M
Harvard/M
Harvey/M
Hasbro/M
Hasidim/M
Haskell/M
Hastings/M
Hatfield/M
Hathaway/M
Hatsheput/M
Hatteras/M
Hattie/M
Hauptmann/M
Hausa/M
Hausdorff/M
Havana/MS
Havarti/M
Havel/M
Havoline/M
Haw
Hawaii/M
Hawaiian/SM
Hawking/M
Hawkins/M
Hawks
Hawthorne/M
Hay/SM
Hayden/M
Haydn/M
Hayek/M
Hayes/M
Haynes/M
Hays/M
Hayward/M
Haywood/M
Hayworth/M
Hazel/M
Hazlitt/M
He/M
Head/M
Hearst/M
Heath/MR
Heather/M
Heaviside/M
Heb
Hebe/M
Hebert/M
Hebraic/M
Hebraism/SM
Hebrew/MS
Hebrews/M
Hebrides/M
Hecate/M
Hector/M
Hecuba/M
Heep/M
Hefner/M
Hegel/M
Hegelian/M
Hegira/M
Heidegger/M
Heidelberg/M
Heidi/M
Heifetz/M
Heimlich/M
Heine/M
Heineken/M
Heinlein/M
Heinrich/M
Heinz/M
Heisenberg/M
Heisman/M
Helen/M
Helena/M
Helene/M
Helga/M
Helicon/M
Heliopolis/M
Helios/M
Hellene/SM
Hellenic/M
Hellenism/MS
Hellenist
Hellenistic/M
Hellenization/M
Hellenize/M
Heller/M
Hellespont/M
Hellman/M
Helmholtz/M
Heloise/M
Helsinki/M
Helvetian
Helvetius/M
Hemingway/M
Hench/M
Henderson/M
Hendrick/MS
Hendricks/M
Hendrix/M
Henley/M
Hennessy/M
Henri/M
Henrietta/M
Henrik/M
Henry/M
Hensley/M
Henson/M
Hepburn/M
Hephaestus/M
Hepplewhite/M
Hera/M
Heracles/M
Heraclitus/M
Herakles/M
Herbart/M
Herbert/M
Herculaneum/M
Herculean
Hercules/M
Herder/M
Hereford/SM
Herero/M
Heriberto/M
Herman/M
Hermaphroditus/M
Hermes/M
Herminia/M
Hermitage/M
Hermite/M
Hermosillo/M
Hernandez/M
Herod/M
Herodotus/M
Herr/MG
Herrera/M
Herrick/M
Herring/M
Herschel/M
Hersey/M
Hershel/M
Hershey/M
Hertz/M
Hertzsprung/M
Herzegovina/M
Herzl/M
Heshvan/M
Hesiod/M
Hesperus/M
Hess/M
Hesse/M
Hessian/M
Hester/M
Heston/M
Hettie/M
Hewitt/M
Hewlett/M
Heyerdahl/M
Heywood/M
Hezbollah/M
Hezekiah/M
Hf/M
Hg/M
Hialeah/M
Hiawatha/M
Hibernia/M
Hibernian
Hickman/M
Hickok/M
Hicks/M
Hieronymus/M
Higashiosaka
Higgins/M
Highlander/SM
Highlands
Highness/M
Hilario/M
Hilary/M
Hilbert/M
Hilda/M
Hildebrand/M
Hilfiger/M
Hill/M
Hillary/M
Hillel/M
Hilton/M
Himalaya/SM
Himalayan
Himalayas/M
Himmler/M
Hinayana/M
Hindemith/M
Hindenburg/M
Hindi/M
Hindu/SM
Hinduism/SM
Hindustan/M
Hindustani/SM
Hines/M
Hinton/M
Hipparchus/M
Hippocrates/M
Hippocratic/M
Hiram/M
Hirobumi/M
Hirohito/M
Hiroshima/M
Hispanic/SM
Hispaniola/M
Hiss/M
Hitachi/M
Hitchcock/M
Hitler/MS
Hittite/SM
Hmong/M
Ho/M
Hobart/M
Hobbes/M
Hobbs/M
Hockney/M
Hodge/SM
Hodges/M
Hodgkin/M
Hoff/M
Hoffa/M
Hoffman/M
Hofstadter/M
Hogan/M
Hogarth/M
Hogwarts/M
Hohenlohe/M
Hohenstaufen/M
Hohenzollern/M
Hohhot/M
Hohokam/M
Hokkaido/M
Hokusai/M
Holbein/M
Holcomb/M
Holden/M
Holder/M
Holiday/M
Holiness
Holland/ZSMR
Hollander/M
Hollerith/M
Holley/M
Hollie/M
Hollis/M
Holloway/M
Holly/M
Hollywood/M
Holman/M
Holmes/M
Holocaust/M
Holocene/M
Holst/M
Holstein/SM
Holt/M
Homer/M
Homeric/M
Hon
Honda/M
Honduran/MS
Honduras/M
Honecker/M
Honeywell/M
Hong
Honiara/M
Honolulu/M
Honorable
Honshu/M
Hood/M
Hooke/RM
Hooker/M
Hooper/M
Hoosier/MS
Hooters/M
Hoover/MS
Hope/M
Hopewell/M
Hopi/SM
Hopkins/M
Hopper/M
Horace/M
Horacio/M
Horatio/M
Hormel/M
Hormuz/M
Horn/M
Hornblower/M
Horne/M
Horowitz/M
Horthy/M
Horton/M
Horus/M
Hosea/M
Host/SM
Hotpoint/M
Hottentot/SM
Houdini/M
House/M
Housman/M
Houston/M
Houyhnhnm/M
Hovhaness/M
Howard/M
Howe/M
Howell/MS
Howells/M
Howrah
Hoyle/M
Hrothgar/M
Hts
Huang/M
Hubbard/M
Hubble/M
Huber/M
Hubert/M
Huck/M
Huddersfield
Hudson/M
Huerta/M
Huey/M
Huff/M
Huffman/M
Huggins/M
Hugh/MS
Hughes/M
Hugo/M
Huguenot/MS
Hui/M
Huitzilopotchli/M
Hull/M
Humberto/M
Humboldt/M
Hume/M
Hummer/M
Humphrey/SM
Humvee/M
Hun/SM
Hung/M
Hungarian/SM
Hungary/M
Hunspell/M
Hunt/MR
Hunter/M
Huntington/M
Huntley/M
Huntsville/M
Hurley/M
Huron/M
Hurst/M
Hus/M
Hussein/M
Husserl/M
Hussite/M
Huston/M
Hutchinson/M
Hutton/M
Hutu/M
Huxley/M
Huygens/M
Hyades/M
Hyde/M
Hyderabad/M
Hydra/M
Hymen/M
Hyperion/M
Hyundai/M
Hz/M
I'd
I'll
I'm
I've
I/M
IA
IBM/M
ICBM/SM
ICC
ICU
ID/SM
IDE
IE
IED
IEEE
IKEA/M
IL
IMF/M
IMHO
IMNSHO
IMO
IN
ING/M
INRI
INS
IOU/M
IP
IPA
IPO
IQ/M
IRA/SM
IRC
IRS/M
ISBN
ISIS
ISO/M
ISP
ISS
IT
IUD
IV/SM
IVF
Ia
Iaccoca/M
Iago/M
Ian/M
Iapetus/M
Ibadan/M
Iberia/M
Iberian/M
Ibiza/M
Iblis/M
Ibo/M
Ibsen/M
Icahn/M
Icarus/M
Ice
Iceland/MRZ
Icelander/M
Icelandic/M
Ida/M
Idaho/SM
Idahoan/MS
Idahoes
Ieyasu/M
Ignacio/M
Ignatius/M
Igor/M
Iguassu/M
Ijsselmeer/M
Ike/M
Ikhnaton/M
Ila/M
Ilene/M
Iliad/SM
Ill
Illinois/M
Illinoisan/MS
Illuminati/M
Ilyushin/M
Imelda/M
Imhotep/M
Imodium/M
Imogene/M
Imus/M
In/M
Ina/M
Inc
Inca/SM
Inchon/M
Incorporated
Ind
Independence/M
India/M
Indian/MS
Indiana/M
Indianan/SM
Indianapolis/M
Indianian
Indies/M
Indira/M
Indochina/M
Indochinese/M
Indonesia/M
Indonesian/SM
Indore/M
Indra/M
Indus/M
Indy/SM
Ines/M
Inez/M
Inge/M
Inglewood
Ingram/M
Ingres/M
Ingrid/M
Innocent/M
Innsbruck
Inonu/M
Inquisition/M
Inst
Instagram/M
Instamatic/M
Intel/M
Intelsat/M
Internationale/M
Internet/SM
Interpol/M
Inuit/MS
Inuktitut/M
Invar/M
Io/M
Ionesco/M
Ionian/MS
Ionic/SM
Iowa/SM
Iowan/MS
Iphigenia/M
Ipswich
Iqaluit/M
Iqbal/M
Iquitos/M
Ir/M
Ira/M
Iran/M
Iranian/SM
Iraq/M
Iraqi/MS
Ireland/M
Irene/M
Iris/M
Irish/MR
Irishman/M
Irishmen/M
Irishwoman/M
Irishwomen/M
Irkutsk/M
Irma/M
Iroquoian/SM
Iroquois/M
Irrawaddy/M
Irtish/M
Irvin/M
Irvine/M
Irving/M
Irwin/M
Isaac/M
Isabel/M
Isabella/M
Isabelle/M
Isaiah/M
Iscariot/M
Isfahan/M
Isherwood/M
Ishim/M
Ishmael/M
Ishtar/M
Isiah/M
Isidro/M
Isis/M
Islam/MS
Islamabad/M
Islamic/M
Islamism/M
Islamist/M
Islamophobia
Islamophobic
Ismael/M
Ismail/M
Isolde/M
Ispell/M
Israel/SM
Israeli/SM
Israelite/M
Issac/M
Issachar/M
Istanbul/M
Isuzu/M
It
Itaipu/M
Ital
Italian/SM
Italianate
Italy/M
Itasca/M
Ithaca/M
Ithacan/M
Ito/M
Iva/M
Ivan/M
Ivanhoe/M
Ives/M
Ivorian
Ivory/M
Ivy/M
Iyar/M
Izaak/M
Izanagi/M
Izanami/M
Izhevsk/M
Izmir/M
Izod/M
Izvestia/M
J/MD
JCS
JD
JFK/M
JP
JPEG
JV
Jack/M
Jackie/M
Jacklyn/M
Jackson/M
Jacksonian/M
Jacksonville/M
Jacky/M
Jaclyn/M
Jacob/SM
Jacobean/M
Jacobi/M
Jacobin/M
Jacobite/M
Jacobs/M
Jacobson/M
Jacquard/M
Jacqueline/M
Jacquelyn/M
Jacques/M
Jacuzzi/M
Jagger/M
Jagiellon/M
Jaguar/M
Jahangir/M
Jaime/M
Jain/M
Jainism/M
Jaipur/M
Jakarta/M
Jake/M
Jamaal/M
Jamaica/M
Jamaican/SM
Jamal/M
Jamar/M
Jame/SM
Jamel/M
James/M
Jamestown/M
Jami/M
Jamie/M
Jan/M
Jana/M
Janacek/M
Jane/M
Janell/M
Janelle/M
Janet/M
Janette/M
Janice/M
Janie/M
Janine/M
Janis/M
Janissary/M
Janjaweed/M
Janna/M
Jannie/M
Jansen/M
Jansenist/M
January/SM
Janus/M
Jap/SM
Japan/M
Japanese/MS
Japura/M
Jared/M
Jarlsberg/M
Jarred/M
Jarrett/M
Jarrod/M
Jarvis/M
Jasmine/M
Jason/M
Jasper/M
Jataka/M
Java/SM
JavaScript/M
Javanese/M
Javier/M
Jaxartes/M
Jay/M
Jayapura/M
Jayawardene/M
Jaycee/MS
Jaycees/M
Jayne/M
Jayson/M
Jean/M
Jeanette/M
Jeanie/M
Jeanine/M
Jeanne/M
Jeannette/M
Jeannie/M
Jeannine/M
Jed/M
Jedi/M
Jeep/M
Jeeves/M
Jeff/M
Jefferey/M
Jefferson/M
Jeffersonian/M
Jeffery/M
Jeffrey/M
Jeffry/M
Jehoshaphat/M
Jehovah/M
Jekyll/M
Jenifer/M
Jenkins/M
Jenna/M
Jenner/M
Jennie/M
Jennifer/M
Jennings/M
Jenny/M
Jensen/M
Jephthah/M
Jerald/M
Jeremiah/M
Jeremiahs
Jeremy/M
Jeri/M
Jericho/M
Jermaine/M
Jeroboam/M
Jerold/M
Jerome/M
Jerri/M
Jerrod/M
Jerrold/M
Jerry/M
Jersey/MS
Jerusalem/M
Jess/M
Jesse/M
Jessica/M
Jessie/M
Jesuit/MS
Jesus/M
Jetway/M
Jew/SM
Jewel/M
Jewell/M
Jewess/MS
Jewish/PM
Jewry/M
Jezebel/SM
Jidda/M
Jilin/M
Jill/M
Jillian/M
Jim/M
Jimenez/M
Jimmie/M
Jimmy/M
Jinan/M
Jinnah/M
Jinny/M
Jivaro/M
Jo/M
Joan/M
Joann/M
Joanna/M
Joanne/M
Joaquin/M
Job/SM
Jobs/M
Jocasta/M
Jocelyn/M
Jock/M
Jockey/M
Jodi/M
Jodie/M
Jody/M
Joe/M
Joel/M
Joey/M
Jogjakarta/M
Johann/M
Johanna/M
Johannes/M
Johannesburg/M
John/SM
Johnathan/M
Johnathon/M
Johnie/M
Johnnie/M
Johnny/M
Johns/M
Johnson/M
Johnston/M
Jolene/M
Jolson/M
Jon/M
Jonah/M
Jonahs
Jonas/M
Jonathan/M
Jonathon/M
Jones/M
Joni/M
Jonson/M
Joplin/M
Jordan/M
Jordanian/MS
Jorge/M
Jose/M
Josef/M
Josefa/M
Josefina/M
Joseph/M
Josephine/M
Josephs
Josephson/M
Josephus/M
Josh/M
Joshua/M
Josiah/M
Josie/M
Josue/M
Joule/M
Jove/M
Jovian/M
Joy/M
Joyce/M
Joycean/M
Joyner/M
Jpn
Jr/M
Juan/M
Juana/M
Juanita/M
Juarez/M
Jubal/M
Judaeo
Judah/M
Judaic
Judaical
Judaism/MS
Judas/MS
Judd/M
Jude/M
Judea/M
Judges
Judith/M
Judson/M
Judy/M
Juggernaut/M
Jul
Jules/M
Julia/M
Julian/M
Juliana/M
Julianne/M
Julie/M
Juliet/M
Juliette/M
Julio/M
Julius/M
Julliard/M
July/SM
Jun/M
June/SM
Juneau/M
Jung/M
Jungfrau/M
Jungian/M
Junior/SM
Junker/SM
Juno/M
Jupiter/M
Jurassic/M
Jurua/M
Justice/M
Justin/M
Justine/M
Justinian/M
Jutland/M
Juvenal/M
K/SMNGJ
KB/M
KC
KFC/M
KGB/M
KIA
KKK/M
KO/M
KP
KS
KY
Kaaba/M
Kabul/M
Kafka/M
Kafkaesque/M
Kagoshima/M
Kahlua/M
Kaifeng/M
Kaiser/MS
Kaitlin/M
Kalahari/M
Kalamazoo/M
Kalashnikov/M
Kalb/M
Kalevala/M
Kalgoorlie/M
Kali/M
Kalmyk/M
Kama/M
Kamchatka/M
Kamehameha/M
Kampala/M
Kampuchea/M
Kan/SM
Kanchenjunga/M
Kandahar/M
Kandinsky/M
Kane/M
Kannada/M
Kano/M
Kanpur/M
Kansan/MS
Kansas/M
Kant/M
Kantian/M
Kaohsiung/M
Kaposi/M
Kara/M
Karachi/M
Karaganda/M
Karakorum/M
Karamazov/M
Kareem/M
Karen/M
Karenina/M
Kari/M
Karin/M
Karina/M
Karl/M
Karla/M
Karloff/M
Karo/M
Karol/M
Karroo/M
Karyn/M
Kasai/M
Kasey/M
Kashmir/SM
Kasparov/M
Kate/M
Katelyn/M
Katharine/M
Katherine/M
Katheryn/M
Kathiawar/M
Kathie/M
Kathleen/M
Kathmandu/M
Kathrine/M
Kathryn/M
Kathy/M
Katie/M
Katina/M
Katmai/M
Katowice/M
Katrina/M
Katy/M
Kauai/M
Kaufman/M
Kaunas/M
Kaunda/M
Kawabata/M
Kawasaki/M
Kay/M
Kaye/M
Kayla/M
Kazakh/M
Kazakhs
Kazakhstan/M
Kazan/M
Kazantzakis/M
Kb/M
Keaton/M
Keats/M
Keck/M
Keenan/M
Keewatin/M
Keillor/M
Keisha/M
Keith/M
Keller/M
Kelley/M
Kelli/M
Kellie/M
Kellogg/M
Kelly/M
Kelsey/M
Kelvin/M
Kemerovo/M
Kemp/M
Kempis/M
Ken/M
Kendall/M
Kendra/M
Kendrick/M
Kenmore/M
Kennan/M
Kennedy/M
Kenneth/M
Kennith/M
Kenny/M
Kent/M
Kenton/M
Kentuckian/MS
Kentucky/M
Kenya/M
Kenyan/SM
Kenyatta/M
Kenyon/M
Keogh/M
Keokuk/M
Kepler/M
Kerensky/M
Keri/M
Kermit/M
Kern/M
Kerouac/M
Kerr/M
Kerri/M
Kerry/M
Kettering/M
Keven/M
Kevin/M
Kevlar/M
Kevorkian/M
Kewpie/M
Key/M
Keynes/M
Keynesian/M
Khabarovsk/M
Khachaturian/M
Khalid/M
Khan/M
Kharkov/M
Khartoum/M
Khayyam/M
Khazar/M
Khmer/M
Khoikhoi/M
Khoisan/M
Khomeini/M
Khorana/M
Khrushchev/M
Khufu/M
Khulna/M
Khwarizmi/M
Khyber/M
Kickapoo/M
Kidd/M
Kiel/M
Kierkegaard/M
Kieth/M
Kiev/M
Kigali/M
Kikuyu/M
Kilauea/M
Kilimanjaro/M
Kilroy/M
Kim/M
Kimberley/M
Kimberly/M
King/M
Kingston/M
Kingstown/M
Kinko's
Kinney/M
Kinsey/M
Kinshasa/M
Kiowa/MS
Kip/M
Kipling/M
Kirby/M
Kirchhoff/M
Kirchner/M
Kirghistan/M
Kirghiz/M
Kirghizia/M
Kiribati/M
Kirinyaga/M
Kirk/M
Kirkland/M
Kirkpatrick/M
Kirov/M
Kirsten/M
Kisangani/M
Kishinev/M
Kislev/M
Kissinger/M
Kit/M
Kitakyushu/M
Kitchener/M
Kitty/M
Kiwanis/M
Klan/M
Klansman/M
Klaus/M
Klee/M
Kleenex/MS
Klein/M
Klimt/M
Kline/M
Klingon/M
Klondike/MS
Kmart/M
Knapp/M
Knesset/M
Kngwarreye/M
Knickerbocker/M
Knievel/M
Knight/M
Knopf/M
Knossos/M
Knowles/M
Knox/M
Knoxville/M
Knudsen/M
Knuth/M
Knuths
Kobe/M
Koch/M
Kochab/M
Kodachrome/M
Kodak/M
Kodaly/M
Kodiak/M
Koestler/M
Kohinoor/M
Kohl/M
Koizumi/M
Kojak/M
Kolyma/M
Kommunizma/M
Kong/M
Kongo/M
Konrad/M
Koontz/M
Koppel/M
Koran/MS
Koranic
Korea/M
Korean/SM
Kornberg/M
Kory/M
Korzybski/M
Kosciusko/M
Kossuth/M
Kosygin/M
Koufax/M
Kowloon/M
Kr/M
Kraft/M
Krakatoa/M
Krakow/M
Kramer/M
Krasnodar/M
Krasnoyarsk/M
Krebs/M
Kremlin/M
Kremlinologist
Kremlinology
Kresge/M
Kringle/M
Kris/M
Krishna/M
Krishnamurti/M
Krista/M
Kristen/M
Kristi/M
Kristie/M
Kristin/M
Kristina/M
Kristine/M
Kristopher/M
Kristy/M
Kroc/M
Kroger/M
Kronecker/M
Kropotkin/M
Kruger/M
Krugerrand/M
Krupp/M
Krystal/M
Kshatriya/M
Kublai/M
Kubrick/M
Kuhn/M
Kuibyshev/M
Kulthumm/M
Kunming/M
Kuomintang/M
Kurd/M
Kurdish/M
Kurdistan/M
Kurosawa/M
Kurt/M
Kurtis/M
Kusch/M
Kutuzov/M
Kuwait/M
Kuwaiti/SM
Kuznets/M
Kuznetsk/M
Kwakiutl/M
Kwan/M
Kwangju/M
Kwanzaa/MS
Ky/MH
Kyle/M
Kyoto/M
Kyrgyzstan/M
Kyushu/M
L'Amour/M
L'Enfant
L'Oreal/M
L'Ouverture/M
L/MN
LA
LAN/M
LBJ/M
LC
LCD/M
LCM
LDC
LED/M
LG/M
LGBT
LIFO
LL
LLB/M
LLD/M
LNG
LOGO
LP/M
LPG
LPN/SM
LSAT
LSD/M
LVN
La/SM
Lab
Laban/M
Labrador/SM
Labradorean
Lacey/M
Lachesis/M
Lacy/M
Ladoga/M
Ladonna/M
Lady/M
Ladyship/MS
Lafayette/M
Lafitte/M
Lagos/M
Lagrange/M
Lagrangian/M
Lahore/M
Laius/M
Lajos/M
Lakeisha/M
Lakewood
Lakisha/M
Lakota/M
Lakshmi/M
Lamaism/SM
Lamar/M
Lamarck/M
Lamaze/M
Lamb/M
Lambert/M
Lamborghini/M
Lambrusco/M
Lamentations
Lamont/M
Lana/M
Lanai/M
Lancashire/M
Lancaster/M
Lance/M
Lancelot/M
Land/M
Landon/M
Landry/M
Landsat/M
Landsteiner/M
Lane/M
Lang/M
Langerhans/M
Langland/M
Langley/M
Langmuir/M
Lanka/M
Lankan/M
Lanny/M
Lansing/M
Lanzhou/M
Lao/SM
Laocoon/M
Laos/M
Laotian/SM
Laplace/M
Lapland/MR
Lapp/SM
Lara/M
Laramie/M
Lardner/M
Laredo/M
Larousse/M
Larry/M
Lars/MN
Larsen/M
Larson/M
Lascaux/M
Lassa/M
Lassen/M
Lassie/M
Lat/M
Latasha/M
Lateran/M
Latham/M
Latin/MRS
Latina
Latino/SM
Latisha/M
Latonya/M
Latoya/M
Latrobe/M
Latvia/M
Latvian/MS
Laud/MR
Lauder/M
Laue/M
Laundromat/M
Laura/M
Laurasia/M
Laurel/M
Lauren/M
Laurence/M
Laurent/M
Lauri/M
Laurie/M
Laval/M
Lavern/M
Laverne/M
Lavoisier/M
Lavonne/M
Lawanda/M
Lawrence/M
Lawson/M
Layamon/M
Layla/M
Lazaro/M
Lazarus/M
Le/SM
Lea/M
Leach/M
Leadbelly/M
Leah/M
Leakey/M
Lean/M
Leander/M
Leann/M
Leanna/M
Leanne/M
Lear/M
Learjet/M
Leary/M
Leavenworth/M
Lebanese/M
Lebanon/M
Lebesgue/M
Leblanc/M
Leda/M
Lederberg/M
Lee/M
Leeds/M
Leeuwenhoek/M
Leeward/M
Left
Legendre/M
Leger/M
Leghorn/M
Lego/M
Legree/M
Lehman/M
Leibniz/M
Leicester/SM
Leiden/M
Leif/M
Leigh/M
Leila/M
Leipzig/M
Lela/M
Leland/M
Lelia/M
Lemaitre/M
Lemuel/M
Lemuria/M
Len/M
Lena/M
Lenard/M
Lenin/M
Leningrad/M
Leninism/M
Leninist/M
Lennon/M
Lenny/M
Leno/M
Lenoir/M
Lenora/M
Lenore/M
Lent/SMN
Lenten/M
Leo/SM
Leola/M
Leon/M
Leona/M
Leonard/M
Leonardo/M
Leoncavallo/M
Leonel/M
Leonid/M
Leonidas/M
Leonor/M
Leopold/M
Leopoldo/M
Lepidus/M
Lepke/M
Lepus/M
Lerner/M
Leroy/M
Les/M
Lesa/M
Lesley/M
Leslie/M
Lesotho/M
Lesseps/M
Lessie/M
Lester/M
Lestrade/M
Leta/M
Letha/M
Lethe/M
Leticia/M
Letitia/M
Letterman/M
Levant/M
Levesque/M
Levi/SM
Leviathan/M
Levine/M
Leviticus/M
Levitt/M
Levy/M
Lew/M
Lewinsky/M
Lewis/M
Lexington/M
Lexus/M
Lhasa/MS
Lhotse/M
Li/MY
Libby/M
Liberace/M
Liberal
Liberia/M
Liberian/SM
Libra/MS
LibreOffice/M
Libreville/M
Librium/M
Libya/M
Libyan/SM
Lichtenstein/M
Lidia/M
Lie/M
Lieberman/M
Liebfraumilch/M
Liechtenstein/ZMR
Liechtensteiner/M
Liege/M
Lieut
Lila/M
Lilia/M
Lilian/M
Liliana/M
Lilith/M
Liliuokalani/M
Lille/M
Lillian/M
Lillie/M
Lilliput/M
Lilliputian/MS
Lilly/M
Lilongwe/M
Lily/M
Lima/M
Limbaugh/M
Limbo
Limburger/M
Limoges/M
Limousin/M
Limpopo/M
Lin/M
Lina/M
Lincoln/MS
Lind/M
Linda/M
Lindbergh/M
Lindsay/M
Lindsey/M
Lindy/M
Linnaeus/M
Linotype/M
Linton/M
Linus/M
Linux/MS
Linwood/M
Lionel/M
Lipizzaner/M
Lippi/M
Lippmann/M
Lipscomb/M
Lipton/M
Lisa/M
Lisbon/M
Lissajous/M
Lister/M
Listerine/M
Liston/M
Liszt/M
Lithuania/M
Lithuanian/MS
Little/M
Litton/M
Liverpool/M
Liverpudlian/SM
Livia/M
Livingston/M
Livingstone/M
Livonia/M
Livy/M
Liz/M
Liza/M
Lizzie/M
Lizzy/M
Ljubljana/M
Llewellyn/M
Lloyd/M
Ln
Loafer/SM
Lobachevsky/M
Lochinvar/M
Locke/M
Lockean/M
Lockheed/M
Lockwood/M
Lodge/M
Lodz/M
Loewe/M
Loewi/M
Loews/M
Logan/M
Lohengrin/M
Loire/M
Lois/M
Loki/M
Lola/M
Lolita/M
Lollard/M
Lollobrigida/M
Lombard/M
Lombardi/M
Lombardy/M
Lome/M
Lon/M
London/MRZ
Londoner/M
Long/M
Longfellow/M
Longstreet/M
Longueuil
Lonnie/M
Lopez/M
Lora/M
Loraine/M
Lord/SM
Lordship/SM
Lorelei/M
Loren/M
Lorena/M
Lorene/M
Lorentz/M
Lorenz/M
Lorenzo/M
Loretta/M
Lori/M
Lorie/M
Lorna/M
Lorraine/M
Lorre/M
Lorrie/M
Los
Lot/M
Lothario/SM
Lott/M
Lottie/M
Lou/M
Louella/M
Louie/M
Louis/M
Louisa/M
Louise/M
Louisiana/M
Louisianan/MS
Louisianian/MS
Louisville/M
Lourdes/M
Louvre/M
Love/M
Lovecraft/M
Lovelace/M
Lowe/M
Lowell/M
Lowenbrau/M
Lowery/M
Lowlands
Loyang/M
Loyd/M
Loyola/M
Lr
Lt
Ltd
Lu/M
Luanda/M
Luann/M
Lubavitcher/M
Lubbock/M
Lubumbashi/M
Lucas/M
Luce/M
Lucia/M
Lucian/M
Luciano/M
Lucien/M
Lucifer/M
Lucile/M
Lucille/M
Lucinda/M
Lucio/M
Lucite/SM
Lucius/M
Lucknow/M
Lucretia/M
Lucretius/M
Lucy/M
Luddite/MS
Ludhiana/M
Ludwig/M
Luella/M
Lufthansa/M
Luftwaffe/M
Luger/M
Lugosi/M
Luigi/M
Luis/M
Luisa/M
Luke/M
Lula/M
Lully/M
Lulu/M
Lumiere/M
Luna/M
Lupe/M
Lupercalia/M
Lupus/M
Luria/M
Lusaka/M
Lusitania/M
Luther/M
Lutheran/SM
Lutheranism/MS
Luvs/M
Luxembourg/ZMR
Luxembourger/M
Luxembourgian
Luz/M
Luzon/M
Lvov/M
LyX/M
Lyallpur
Lycra/M
Lycurgus/M
Lydia/M
Lydian/SM
Lyell/M
Lyle/M
Lyly/M
Lyman/M
Lyme/M
Lynch/M
Lynda/M
Lyndon/M
Lynette/M
Lynn/M
Lynne/M
Lynnette/M
Lyon/SM
Lyons/M
Lyra/M
Lysenko/M
Lysistrata/M
Lysol/M
M/SMGB
MA/M
MASH
MB/M
MBA/M
MC
MCI/M
MD/M
MDT
ME
MEGO/S
MFA/M
MGM/M
MHz
MI/M
MIA
MIDI/M
MIPS
MIRV
MIT/M
MM
MN
MO
MOOC
MP/M
MPEG
MRI/M
MS/M
MSG/M
MST/M
MSW
MT/M
MTV/M
MVP/M
MW
Maalox/M
Mabel/M
Mable/M
Mac/M
MacArthur/M
MacBride/M
MacDonald/M
MacLeish/M
Macao/M
Macaulay/M
Macbeth/M
Maccabees
Maccabeus/M
Mace/M
Macedon/M
Macedonia/M
Macedonian/SM
Mach/M
Machiavelli/M
Machiavellian/M
Macias/M
Macintosh/M
Mack/M
Mackenzie/M
Mackinac/M
Mackinaw/M
Macmillan/M
Macon/M
Macumba/M
Macy/M
Madagascan/SM
Madagascar/M
Madam
Madden/M
Maddox/M
Madeira/SM
Madeleine/M
Madeline/M
Madelyn/M
Madge/M
Madison/M
Madonna/SM
Madras/M
Madrid/M
Madurai/M
Mae/M
Maeterlinck/M
Mafia/MS
Mafioso/M
Magdalena/M
Magdalene/M
Magellan/M
Magellanic/M
Maggie/M
Maghreb/M
Magi
Maginot/M
Magnitogorsk/M
Magog/M
Magoo/M
Magritte/M
Magsaysay/M
Magus
Magyar/SM
Mahabharata/M
Maharashtra/M
Mahavira/M
Mahayana/M
Mahayanist/M
Mahdi/M
Mahfouz/M
Mahican/SM
Mahler/M
Mai/M
Maidenform/M
Maigret/M
Mailer/M
Maillol/M
Maiman/M
Maimonides/M
Maine/MZR
Mainer/M
Maisie/M
Maitreya/M
Maj
Majesty
Major/M
Majorca/M
Majuro/M
Makarios/M
Maker/M
Malabar/M
Malabo/M
Malacca/M
Malachi/M
Malagasy/M
Malamud/M
Malaprop/M
Malawi/M
Malawian/SM
Malay/MS
Malaya/M
Malayalam/M
Malayan/MS
Malaysia/M
Malaysian/MS
Malcolm/M
Maldive/MS
Maldives/M
Maldivian/MS
Maldonado/M
Male/M
Mali/M
Malian/SM
Malibu/M
Malinda/M
Malinowski/M
Mallarme/M
Mallomars/M
Mallory/M
Malone/M
Malory/M
Malplaquet/M
Malraux/M
Malta/M
Maltese/M
Malthus/M
Malthusian/SM
Mameluke/M
Mamet/M
Mamie/M
Mamore/M
Man/M
Managua/M
Manama/M
Manasseh/M
Manchester/M
Manchu/SM
Manchuria/M
Manchurian/M
Mancini/M
Mancunian/MS
Mandalay/M
Mandarin/M
Mandela/M
Mandelbrot/M
Mandingo/M
Mandrell/M
Mandy/M
Manet/M
Manfred/M
Manhattan/SM
Mani/M
Manichean/M
Manila/SM
Manitoba/M
Manitoulin/M
Manley/M
Mann/GM
Mannheim/M
Manning/M
Mansfield/M
Manson/M
Mantegna/M
Mantle/M
Manuel/M
Manuela/M
Manx/M
Mao/M
Maoism/SM
Maoist/SM
Maori/MS
Mapplethorpe/M
Maputo/M
Mar/SM
Mara/M
Maracaibo/M
Marat/M
Maratha/M
Marathi/M
Marathon/M
Marc/M
Marceau/M
Marcel/M
Marcelino/M
Marcella/M
Marcelo/M
March/MS
Marci/M
Marcia/M
Marciano/M
Marcie/M
Marco/MS
Marconi/M
Marcos/M
Marcus/M
Marcuse
Marcy/M
Marduk/M
Margaret/M
Margarita/M
Margarito/M
Marge/M
Margery/M
Margie/M
Margo/M
Margot
Margret/M
Margrethe/M
Marguerite/M
Mari/SM
Maria/M
Marian/M
Mariana/SM
Marianas/M
Marianne/M
Mariano/M
Maribel/M
Maricela/M
Marie/M
Marietta/M
Marilyn/M
Marin/M
Marina/M
Marine/SM
Mario/M
Marion/M
Maris/M
Marisa/M
Marisol/M
Marissa/M
Maritain/M
Maritza/M
Mariupol
Marius/M
Marjorie/M
Marjory/M
Mark/SM
Markab/M
Markham/M
Markov/M
Marks/M
Marla/M
Marlboro/M
Marlborough/M
Marlene/M
Marley/M
Marlin/M
Marlon/M
Marlowe/M
Marmara/M
Marne/M
Maronite/M
Marple/M
Marquesas/M
Marquette/M
Marquez/M
Marquis/M
Marquita/M
Marrakesh/M
Marriott/M
Mars/MS
Marsala/M
Marseillaise/MS
Marseilles/M
Marsh/M
Marsha/M
Marshall/M
Marta/M
Martel/M
Martha/M
Martial/M
Martian/SM
Martin/M
Martina/M
Martinez/M
Martinique/M
Marty/M
Marva/M
Marvell/M
Marvin/M
Marx/M
Marxian
Marxism/SM
Marxist/SM
Mary/M
Maryann/M
Maryanne/M
Maryellen/M
Maryland/MR
Marylander/M
Marylou/M
Masada/M
Masai/M
Masaryk/M
Mascagni/M
Masefield/M
Maserati/M
Maseru/M
Mashhad/M
Mason/MS
Masonic/M
Masonite/M
Mass/MS
Massachusetts/M
Massasoit/M
Massenet/M
Massey/M
Master/S
MasterCard/M
Masters/M
Mather/M
Mathew/SM
Mathews/M
Mathewson/M
Mathias/M
Mathis/M
Matilda/M
Matisse/M
Matt/M
Mattel/M
Matterhorn/M
Matthew/SM
Matthews/M
Matthias/M
Mattie/M
Maud/M
Maude/M
Maugham/M
Maui/M
Maupassant/M
Maura/M
Maureen/M
Mauriac/M
Maurice/M
Mauricio/M
Maurine/M
Mauritania/M
Mauritanian/SM
Mauritian/SM
Mauritius/M
Mauro/M
Maurois/M
Mauryan/M
Mauser/M
Mavis/M
Max/M
Maximilian/M
Maxine/M
Maxwell/M
May/SMR
Maya/SM
Mayan/MS
Mayer/M
Mayfair/M
Mayflower/M
Maynard/M
Mayo/M
Maypole
Mayra/M
Mays/M
Maytag/M
Mazama/M
Mazarin/M
Mazatlan/M
Mazda/M
Mazola/M
Mazzini/M
Mb/M
Mbabane/M
Mbini/M
McAdam/M
McBride/M
McCain/M
McCall/M
McCarthy/M
McCarthyism/M
McCartney/M
McCarty/M
McClain/M
McClellan/M
McClure/M
McConnell/M
McCormick/M
McCoy/M
McCray/M
McCullough/M
McDaniel/M
McDonald/M
McDonnell/M
McDowell/M
McEnroe/M
McFadden/M
McFarland/M
McGee/M
McGovern/M
McGowan/M
McGuffey/M
McGuire/M
McIntosh/M
McIntyre/M
McKay/M
McKee/M
McKenzie/M
McKinley/M
McKinney/M
McKnight/M
McLaughlin/M
McLean/M
McLeod/M
McLuhan/M
McMahon/M
McMillan/M
McNamara/M
McNaughton/M
McNeil/M
McPherson/M
McQueen/M
McVeigh/M
Md/M
Me
Mead/M
Meade/M
Meadows/M
Meagan/M
Meany/M
Mecca/MS
Medan/M
Medea/M
Medellin/M
Media/M
Medicaid/SM
Medicare/SM
Medici/M
Medina/M
Mediterranean/MS
Medusa/M
Meg/M
Megan/M
Meghan/M
Meier/M
Meighen/M
Meiji/M
Meir/M
Mejia/M
Mekong/M
Mel/M
Melanesia/M
Melanesian/M
Melanie/M
Melba/M
Melbourne/M
Melchior/M
Melchizedek/M
Melendez/M
Melinda/M
Melisa/M
Melisande/M
Melissa/M
Mellon/M
Melody/M
Melpomene/M
Melton/M
Melva/M
Melville/M
Melvin/M
Memling/M
Memphis/M
Menander/M
Mencius/M
Mencken/M
Mendel/M
Mendeleev/M
Mendelian/M
Mendelssohn/M
Mendez/M
Mendocino/M
Mendoza/M
Menelaus/M
Menelik/M
Menes/M
Mengzi
Menkalinan/M
Menkar/M
Menkent/M
Mennen/M
Mennonite/MS
Menominee/M
Menotti/M
Mensa/M
Mentholatum/M
Menuhin/M
Menzies/M
Mephisto
Mephistopheles/M
Merak/M
Mercado/M
Mercator/M
Mercedes/M
Mercer/M
Mercia/M
Merck/M
Mercurochrome/M
Mercury/SM
Meredith/M
Merino/M
Merle/M
Merlin/M
Merlot/M
Merovingian/M
Merriam/M
Merrick/M
Merrill/M
Merrimack/M
Merritt/M
Merthiolate/M
Merton/M
Mervin/M
Mesa/M
Mesabi/M
Mesmer/M
Mesolithic/M
Mesopotamia/M
Mesopotamian
Mesozoic/M
Messerschmidt/M
Messiaen/M
Messiah/M
Messiahs
Messianic
Messieurs
Metallica/M
Metamucil/M
Methodism/SM
Methodist/SM
Methuselah/M
Metternich/M
Meuse/M
Mex
Mexicali/M
Mexican/MS
Mexico/M
Meyer/MS
Meyerbeer/M
Meyers/M
Mfume/M
Mg/M
Mgr
MiG/M
Mia/M
Miami/MS
Miaplacidus/M
Micah/M
Micawber/M
Mich/M
Michael/M
Michaelmas/MS
Micheal/M
Michel/M
Michelangelo/M
Michele/M
Michelin/M
Michelle/M
Michelob/M
Michelson/M
Michigan/M
Michigander/MS
Michiganite
Mick/M
Mickey/M
Mickie/M
Micky/M
Micmac/SM
Micronesia/M
Micronesian/M
Microsoft/M
Midas/M
Middleton/M
Mideast
Mideastern
Midland/MS
Midway/M
Midwest/M
Midwestern/MR
Miguel/M
Mike/M
Mikhail/M
Mikoyan/M
Milagros/M
Milan/M
Milanese
Mildred/M
Miles/M
Milford/M
Milken/M
Mill/SMR
Millard/M
Millay/M
Miller/M
Millet/M
Millicent/M
Millie/M
Millikan/M
Mills/M
Milne/M
Milo/M
Milosevic/M
Milquetoast/M
Miltiades/M
Milton/M
Miltonic/M
Miltown/M
Milwaukee/M
Mimi/M
Mimosa/M
Min/M
Minamoto/M
Mindanao/M
Mindoro/M
Mindy/M
Minerva/M
Ming/M
Mingus/M
Minn
Minneapolis/M
Minnelli/M
Minnesota/M
Minnesotan/SM
Minnie/M
Minoan/MS
Minolta/M
Minos/M
Minot/M
Minotaur/M
Minsk/M
Minsky/M
Mintaka/M
Minuit/M
Minuteman/M
Miocene/M
Mir/M
Mira/M
Mirabeau/M
Mirach/M
Miranda/M
Mirfak/M
Miriam/M
Miro/M
Mirzam/M
Miskito/M
Miss
Mississauga/M
Mississippi/M
Mississippian/SM
Missouri/M
Missourian/MS
Missy/M
Mistassini/M
Mister
Mistress
Misty/M
Mitch/M
Mitchel/M
Mitchell/M
Mitford/M
Mithra/M
Mithridates/M
Mitsubishi/M
Mitterrand/M
Mitty/M
Mitzi/M
Mixtec/M
Mizar/M
Mk
Mlle
Mme/S
Mn/M
Mnemosyne/M
Mo/M
Mobil/M
Mobile/M
Mobutu/M
Modesto/M
Modigliani/M
Moe/M
Moet/M
Mogadishu/M
Mogul/MS
Mohacs/M
Mohamed/M
Mohammad/M
Mohammedan/SM
Mohammedanism/SM
Mohave/SM
Mohawk/SM
Mohegan
Moho/M
Mohorovicic/M
Moira/M
Moises/M
Moiseyev/M
Mojave/SM
Moldavia/M
Moldavian
Moldova/M
Moldovan
Moliere/M
Molina/M
Moll/M
Mollie/M
Molly/M
Molnar/M
Moloch/M
Molokai/M
Molotov/M
Moluccas/M
Mombasa/M
Mon/SM
Mona/M
Monacan
Monaco/M
Mondale/M
Monday/SM
Mondrian/M
Monegasque/SM
Monera/M
Monet/M
Mongol/SM
Mongolia/M
Mongolian/SM
Mongolic/M
Mongoloid
Monica/M
Monique/M
Monk/M
Monmouth/M
Monongahela/M
Monroe/M
Monrovia/M
Monsanto/M
Monsieur/M
Monsignor/SM
Mont/M
Montague/M
Montaigne/M
Montana/M
Montanan/SM
Montcalm/M
Monte/M
Montenegrin/M
Montenegro/M
Monterrey/M
Montesquieu/M
Montessori/M
Monteverdi/M
Montevideo/M
Montezuma/M
Montgolfier/M
Montgomery/M
Monticello/M
Montoya/M
Montpelier/M
Montrachet/M
Montreal/M
Montserrat/M
Monty/M
Moody/M
Moog/M
Moon/M
Mooney/M
Moor/SM
Moore/M
Moorish/M
Morales/M
Moran/M
Moravia/M
Moravian/M
Mordred/M
More/M
Moreno/M
Morgan/SM
Moriarty/M
Morin/M
Morison/M
Morita/M
Morley/M
Mormon/SM
Mormonism/SM
Moro/M
Moroccan/SM
Morocco/M
Moroni/M
Morpheus/M
Morphy/M
Morris/M
Morrison/M
Morrow/M
Morse/M
Mort/M
Mortimer/M
Morton/M
Mosaic/M
Moscow/M
Moseley/M
Moselle/M
Moses/M
Mosley/M
Moss/M
Mosul/M
Motorola/M
Motown/M
Motrin/M
Mott/M
Moulton/M
Mount/M
Mountbatten/M
Mountie/MS
Moussorgsky/M
Mouthe/M
Mouton/M
Mowgli/M
Mozambican/SM
Mozambique/M
Mozart/M
Mozilla/M
Mr/SM
Ms/S
Msgr
Mt
Muawiya/M
Mubarak/M
Mueller/M
Muenster/MS
Mugabe/M
Muhammad/M
Muhammadan/MS
Muhammadanism/SM
Muir/M
Mujib/M
Mulder/M
Mullen/M
Muller/M
Mulligan/M
Mullikan/M
Mullins/M
Mulroney/M
Multan/M
Multics
Mumbai/M
Mumford/M
Munch/M
Munchhausen/M
Munich/M
Munoz/M
Munro/M
Munster/M
Muppet/M
Murasaki/M
Murat/M
Murchison/M
Murcia
Murdoch/M
Muriel/M
Murillo/M
Murine/M
Murmansk/M
Murphy/M
Murray/M
Murrow/M
Murrumbidgee/M
Muscat/M
Muscovite/M
Muscovy/M
Muse/M
Musharraf/M
Musial/M
Muskogee/M
Muslim/MS
Mussolini/M
Mussorgsky/M
Mutsuhito/M
Muzak/M
MySpace/M
Myanmar/M
Mycenae/M
Mycenaean/M
Myers/M
Mylar/MS
Myles/M
Myra/M
Myrdal/M
Myrna/M
Myron/M
Myrtle/M
Mysore/M
Myst/M
N'Djamena
N/MD
NAACP/M
NAFTA/M
NASA/M
NASCAR/M
NASDAQ/M
NATO/M
NB
NBA/M
NBC/M
NBS
NC
NCAA/M
NCO
ND
NE/M
NEH
NF
NFC
NFL/M
NH
NHL/M
NIH
NIMBY
NJ
NLRB
NM
NORAD/M
NOW
NP
NPR/M
NR
NRA
NRC
NS
NSA/M
NSC
NSF
NSFW
NT
NV
NW/M
NWT
NY
NYC
NYSE
NZ
Na/M
Nabisco/M
Nabokov/M
Nader/M
Nadia/M
Nadine/M
Nagasaki/M
Nagoya/M
Nagpur/M
Nagy/M
Nahuatl/MS
Nahum/M
Naipaul/M
Nair/M
Nairobi/M
Naismith/M
Nam/M
Namath/M
Namibia/M
Namibian/MS
Nan/M
Nanak/M
Nanchang/M
Nancy/M
Nanette/M
Nanjing/M
Nannie/M
Nanook/M
Nansen/M
Nantes/M
Nantucket/M
Naomi/M
Naphtali/M
Napier/M
Naples/M
Napoleon/MS
Napoleonic/M
Napster/M
Narcissus/M
Narmada/M
Narnia/M
Narraganset
Narragansett/M
Nash/M
Nashua/M
Nashville/M
Nassau/M
Nasser/M
Nat/M
Natalia/M
Natalie/M
Natasha/M
Natchez/M
Nate/MN
Nathan/SM
Nathaniel/M
Nathans/M
Nation/M
Nationwide/M
Nativity/M
Naugahyde/M
Nauru/M
Nautilus/M
Navajo/SM
Navajoes
Navarre/M
Navarro/M
Navratilova/M
Navy
Nazarene/M
Nazareth/M
Nazca/M
Nazi/SM
Nazism/MS
Nb/M
Nd/M
Ndjamena/M
Ne/M
NeWS
NeWSes
Neal/M
Neanderthal/SM
Neapolitan/M
Neb
Nebr
Nebraska/M
Nebraskan/MS
Nebuchadnezzar/M
Ned/M
Nefertiti/M
Negev/M
Negress/MS
Negritude
Negro/MS
Negroes
Negroid/SM
Negros/M
Nehemiah/M
Nehru/M
Neil/M
Nelda/M
Nell/M
Nellie/M
Nelly/M
Nelsen/M
Nelson/M
Nembutal/M
Nemesis/M
Neogene/M
Neolithic
Nepal/M
Nepalese/M
Nepali/MS
Neptune/M
Nereid/M
Nerf/M
Nero/M
Neruda/M
Nescafe/M
Nesselrode/M
Nestle/M
Nestor/M
Nestorius/M
Netflix/M
Netherlander/SM
Netherlands/M
Netscape/M
Nettie/M
Netzahualcoyotl/M
Nev/M
Neva/M
Nevada/M
Nevadan/SM
Nevadian
Nevis/M
Nevsky/M
Newark/M
Newcastle/M
Newfoundland/MRS
Newman/M
Newport/M
Newsweek/M
Newton/M
Newtonian/M
Nexis/M
Ngaliema/M
Nguyen/M
Ni/M
Niagara/M
Niamey/M
Nibelung/M
Nicaea/M
Nicaragua/M
Nicaraguan/SM
Niccolo/M
Nice/M
Nicene/M
Nichiren/M
Nicholas/M
Nichole/M
Nichols/M
Nicholson/M
Nick/M
Nickelodeon/M
Nicklaus/M
Nickolas/M
Nicobar/M
Nicodemus/M
Nicola/SM
Nicolas/M
Nicole/M
Nicosia/M
Niebuhr/M
Nielsen/M
Nietzsche/M
Nieves/M
Nigel/M
Niger/M
Nigeria/M
Nigerian/MS
Nigerien/M
Nightingale/M
Nijinsky/M
Nike/M
Nikita/M
Nikkei/M
Nikki/M
Nikolai/M
Nikon/M
Nile/M
Nimitz/M
Nimrod/M
Nina/M
Nineveh/M
Nintendo/M
Niobe/M
Nippon/M
Nipponese/M
Nirenberg/M
Nirvana/M
Nisan/M
Nisei/M
Nissan/M
Nita/M
Nivea/M
Nixon/M
Nkrumah/M
No/SM
NoDoz/M
Noah/M
Nobel/M
Nobelist/MS
Noble/M
Noe/M
Noel/SM
Noelle/M
Noemi/M
Nokia/M
Nola/M
Nolan/M
Nome/M
Nona/M
Nootka/M
Nora/M
Norbert/M
Norberto/M
Nordic/MS
Noreen/M
Norfolk/M
Noriega/M
Norma/M
Norman/MS
Normand/M
Normandy/M
Norplant/M
Norris/M
Norse/M
Norseman/M
Norsemen/M
North/M
Northampton/M
Northeast/MS
Northerner/M
Northrop/M
Northrup/M
Norths
Northwest/SM
Norton/M
Norw
Norway/M
Norwegian/SM
Norwich/M
Nosferatu/M
Nostradamus/M
Nottingham/M
Nouakchott/M
Noumea/M
Nov/M
Nova/M
Novartis/M
November/MS
Novgorod/M
Novocain/MS
Novocaine
Novokuznetsk/M
Novosibirsk/M
Noxzema/M
Noyce/M
Noyes/M
Np/M
Nubia/M
Nubian/M
Nukualofa/M
Numbers/M
Nunavut/M
Nunez/M
Nunki/M
Nuremberg/M
Nureyev/M
NutraSweet/M
NyQuil/M
Nyasa/M
Nyerere/M
O'Brien/M
O'Casey/M
O'Connell/M
O'Connor/M
O'Donnell/M
O'Hara/M
O'Higgins/M
O'Keeffe/M
O'Neil/M
O'Neill/M
O'Rourke/M
O'Toole/M
O/SM
OAS/M
OB
OCR
OD/SM
OE
OED
OH
OHSA/M
OJ
OK/SMDG
OMB/M
ON
OPEC/M
OR
OS/M
OSHA/M
OSes
OT
OTB
OTC
OTOH
Oahu/M
Oakland/M
Oakley/M
Oates/M
Oaxaca/M
Ob/M
Obadiah/M
Obama/M
Obamacare
Oberlin/M
Oberon/M
Occam/M
Occident
Occidental/MS
Oceania/M
Oceanside
Oceanus/M
Ochoa/M
Oct/M
Octavia/M
Octavian/M
Octavio/M
October/SM
Odell/M
Oder/M
Odessa/M
Odets/M
Odin/M
Odis/M
Odom/M
Odysseus/M
Odyssey/M
Oedipal/M
Oedipus/M
Oersted/M
Ofelia/M
Offenbach/M
OfficeMax/M
Ogbomosho/M
Ogden/M
Ogilvy/M
Oglethorpe/M
Ohio/M
Ohioan/SM
Oise/M
Ojibwa/SM
Okayama
Okeechobee/M
Okefenokee/M
Okhotsk/M
Okinawa/M
Okinawan
Okla
Oklahoma/M
Oklahoman/M
Oktoberfest/M
Ola/M
Olaf/M
Olajuwon/M
Olav/M
Oldenburg/M
Oldfield/M
Oldsmobile/M
Olduvai/M
Olen/M
Olenek/M
Olga/M
Oligocene/M
Olin/M
Olive/MR
Oliver/M
Olivetti/M
Olivia/M
Olivier/M
Ollie/M
Olmec/M
Olmsted/M
Olsen/M
Olson/M
Olympia/SM
Olympiad/MS
Olympian/MS
Olympic/SM
Olympics/M
Olympus/M
Omaha/MS
Oman/M
Omani/MS
Omar/M
Omayyad/M
Omdurman/M
Omnipotent
Omsk/M
Onassis/M
Oneal/M
Onega/M
Onegin/M
Oneida/MS
Onion/M
Ono/M
Onondaga/MS
Onsager/M
Ont
Ontarian
Ontario/M
Oort/M
Opal/M
Opel/M
OpenOffice/M
Ophelia/M
Ophiuchus/M
Oppenheimer/M
Opposition
Oprah/M
Ora/M
Oracle/M
Oran/M
Orange/M
Oranjestad/M
Orbison/M
Ordovician/M
Ore/N
Oreg
Oregon/M
Oregonian/SM
Oreo/M
Orestes/M
Orient/M
Oriental/MS
Orientalism
Orin/M
Orinoco/M
Orion/M
Oriya/M
Orizaba/M
Orkney/M
Orlando/M
Orleans/M
Orlon/MS
Orly/M
Orpheus/M
Orphic/M
Orr/M
Ortega/M
Orthodox
Ortiz/M
Orval/M
Orville/M
Orwell/M
Orwellian/M
Os/M
Osage/MS
Osaka/M
Osbert/M
Osborn/M
Osborne/M
Oscar/MS
Osceola/M
Osgood/M
Oshawa/M
Oshkosh/M
Osiris/M
Oslo/M
Osman/M
Ostrogoth/M
Ostwald/M
Osvaldo/M
Oswald/M
Othello/M
Otis/M
Ottawa/SM
Otto/M
Ottoman/M
Ouagadougou/M
Ouija/MS
Ovid/M
Owen/SM
Owens/M
Oxford/SM
Oxnard/M
Oxonian/M
Oxus/M
Oxycontin/M
Oz/M
Ozark/MS
Ozarks/M
Ozymandias/M
Ozzie/M
P/MN
PA/M
PAC/M
PARC/S
PASCAL
PBS/M
PBX
PC/SM
PCB
PCMCIA
PCP/M
PD
PDF
PDQ
PDT
PE
PET/M
PFC
PG
PGP
PIN
PJ's
PLO/M
PM/SMDG
PMS/M
PO
POW/M
PP
PPS
PR
PRC/M
PRO
PS/M
PST/M
PT
PTA/M
PTO
PVC/M
PW
PX
Pa/M
Paar/M
Pablo/M
Pablum/M
Pabst/M
Pace/M
Pacheco/M
Pacific/M
Pacino/M
Packard/M
Padang
Paderewski/M
Padilla/M
Paganini/M
Page/M
Paglia/M
Pahlavi/M
Paige/M
Paine/M
Paiute/SM
Pakistan/M
Pakistani/SM
Palembang/M
Paleocene/M
Paleogene/M
Paleolithic/M
Paleozoic/M
Palermo/M
Palestine/M
Palestinian/SM
Palestrina/M
Paley/M
Palikir/M
Palisades/M
Palladio/M
Palmer/M
Palmerston/M
Palmolive/M
Palmyra/M
Palomar/M
Pam/M
Pamela/M
Pamirs/M
Pampers/M
Pan/M
Panama/SM
Panamanian/MS
Panasonic/M
Pandora/M
Pangaea/M
Pankhurst/M
Panmunjom/M
Pansy/M
Pantagruel/M
Pantaloon/M
Pantheon/M
Panza/M
Paracelsus/M
Paraclete/M
Paradise
Paraguay/M
Paraguayan/MS
Paralympic/S
Paramaribo/M
Paramount/M
Parana/M
Parcheesi/M
Pareto/M
Paris/M
Parisian/MS
Park/SMR
Parker/M
Parkinson/M
Parkinsonism
Parkman/M
Parks/M
Parliament/M
Parmenides
Parmesan/MS
Parnassus/MS
Parnell/M
Parr/M
Parrish/M
Parsifal/M
Parsons/M
Parthenon/M
Parthia/M
Pasadena/M
Pascal/SM
Pasquale/M
Passion/SM
Passover/MS
Pasternak/M
Pasteur/M
Pat/M
Patagonia/M
Patagonian/M
Pate/M
Patel/M
Paterson/M
Patna/M
Patrica/M
Patrice/M
Patricia/M
Patrick/M
Patsy/M
Patterson/M
Patti/M
Patton/M
Patty/M
Paul/GM
Paula/M
Paulette/M
Pauli/M
Pauline/M
Pauling/M
Pavarotti/M
Pavlov/M
Pavlova/M
Pavlovian/M
Pawnee/SM
PayPal/M
Payne/M
Pb/M
Pd/M
Peabody/M
Peace/M
Peale/M
Pearl/M
Pearlie/M
Pearson/M
Peary/M
Pechora/M
Peck/M
Peckinpah/M
Pecos/M
Pedro/M
Peel/M
Peg/M
Pegasus/MS
Peggy/M
Pei/M
Peiping/M
Peking/SM
Pekingese/SM
Pele/M
Pelee/M
Peloponnese/M
Pembroke/M
Pen/M
Pena/M
Penderecki/M
Penelope/M
Penn/M
Penna
Penney/M
Pennington/M
Pennsylvania/M
Pennsylvanian/MS
Penny/M
Pennzoil/M
Pensacola/M
Pentagon/M
Pentateuch/M
Pentax/M
Pentecost/SM
Pentecostal/MS
Pentecostalism
Pentium/SM
Peoria/M
Pepin/M
Pepsi/M
Pepys/M
Pequot/M
Percheron/M
Percival/M
Percy/M
Perelman/M
Perez/M
Periclean/M
Pericles/M
Perkins/M
Perl/SM
Perm/M
Permalloy/M
Permian/M
Pernod/M
Peron/M
Perot/M
Perrier/M
Perry/RM
Perseid/M
Persephone/M
Persepolis/M
Perseus/M
Pershing/M
Persia/M
Persian/SM
Perth/M
Peru/M
Peruvian/MS
Peshawar/M
Petain/M
Pete/RMZ
Peter/M
Peters/MN
Petersen/M
Peterson/M
Petra/M
Petrarch/M
Petty/M
Peugeot/M
Pfc
Pfizer/M
PhD/M
Phaedra/M
Phaethon/M
Phanerozoic/M
Pharaoh/M
Pharaohs
Pharisaic
Pharisaical
Pharisee/MS
Phekda/M
Phelps/M
Phidias/M
Phil/MY
Philadelphia/M
Philby/M
Philemon/M
Philip/MS
Philippe/M
Philippians/M
Philippine/SM
Philippines/M
Philips/M
Philistine/M
Phillip/SM
Phillipa/M
Phillips/M
Philly/M
Phipps/M
Phobos/M
Phoebe/M
Phoenicia/M
Phoenician/SM
Phoenix/M
Photostat/MS
Photostatted
Photostatting
Phrygia/M
Phyllis/M
Piaf/M
Piaget/M
Pianola/M
Picasso/M
Piccadilly/M
Pickering/M
Pickett/M
Pickford/M
Pickwick/M
Pict/M
Piedmont/M
Pierce/M
Pierre/M
Pierrot/M
Pike/M
Pilate/MS
Pilates/M
Pilcomayo/M
Pilgrim/SM
Pillsbury/M
Pinatubo/M
Pincus/M
Pindar/M
Pinkerton/M
Pinocchio/M
Pinochet/M
Pinter/M
Pinyin
Pippin/M
Piraeus/M
Pirandello/M
Pisa/M
Pisces/M
Pisistratus/M
Pissaro/M
Pitcairn/M
Pitt/SM
Pittman/M
Pitts/M
Pittsburgh/M
Pius/M
Pizarro/M
Pkwy
Pl
Planck/M
Plano
Plantagenet/M
Plasticine/M
Plataea/M
Plath/M
Plato/M
Platonic
Platonism/M
Platonist/M
Platte/M
Plautus/M
PlayStation/M
Playboy/M
Playtex/M
Pleiades/M
Pleistocene/M
Plexiglas/MS
Pliny/M
Pliocene/SM
Plutarch/M
Pluto/M
Plymouth/M
Pm/M
Po/M
Pocahontas/M
Pocono/SM
Poconos/M
Podgorica/M
Podhoretz/M
Podunk/M
Poe/M
Pogo/M
Poincare/M
Poiret/M
Poirot/M
Poisson/M
Poitier/M
Pokemon/M
Pol/MY
Poland/M
Polanski/M
Polaris/M
Polaroid/MS
Pole/SM
Polish/M
Politburo/M
Polk/M
Pollard/M
Pollock/M
Pollux/M
Polly/M
Pollyanna/M
Polo/M
Poltava/M
Polyhymnia/M
Polynesia/M
Polynesian/MS
Polyphemus/M
Pomerania/M
Pomeranian/M
Pomona/M
Pompadour/M
Pompeian
Pompeii/M
Pompey/M
Ponce/M
Pontchartrain/M
Pontiac/M
Pontianak/M
Pooh/M
Poole/M
Poona/M
Pope/M
Popeye/M
Popocatepetl/M
Popper/M
Poppins/M
Popsicle/M
Porfirio/M
Porrima/M
Porsche/M
Port/MR
Porter/M
Portia/M
Portland/M
Porto/M
Portsmouth/M
Portugal/M
Portuguese/M
Poseidon/M
Post/M
Potemkin/M
Potomac/M
Potsdam/M
Pottawatomie/M
Potter/M
Potts/M
Pound/M
Poussin/M
Powell/M
PowerPC/M
PowerPoint/M
Powers/M
Powhatan/M
Poznan/M
Pr/M
Prada/M
Prado/M
Praetorian/M
Prague/M
Praia/M
Prakrit/M
Pratchett/M
Pratt/M
Pravda/M
Praxiteles/M
Preakness/M
Precambrian/M
Preminger/M
Premyslid/M
Prensa/M
Prentice/M
Pres
Presbyterian/SM
Presbyterianism/MS
Prescott/M
Presley/M
Preston/M
Pretoria/M
Priam/M
Pribilof/M
Price/M
Priestley/M
Prince/M
Princeton/M
Principe/M
Priscilla/M
Prius/M
Private
Procrustean/M
Procrustes/M
Procter/M
Procyon/M
Prof
Prohibition
Prokofiev/M
Promethean/M
Prometheus/M
Prophets
Proserpina/M
Proserpine/M
Protagoras/M
Proterozoic/M
Protestant/MS
Protestantism/SM
Proteus/M
Proudhon/M
Proust/M
Provencal/MS
Provence/M
Proverbs
Providence/SM
Provo/M
Prozac/MS
Prudence/M
Prudential/M
Pruitt/M
Prussia/M
Prussian/MS
Prut/M
Pryor/M
Psalms/M
Psalter/MS
Psyche/M
Pt/M
Ptah/M
Ptolemaic/M
Ptolemy/SM
Pu/M
Puccini/M
Puck/M
Puckett/M
Puebla/M
Pueblo/M
Puerto
Puget/M
Pugh/M
Pulaski/M
Pulitzer/M
Pullman/MS
Punch/M
Punic/M
Punjab/M
Punjabi/M
Purana/M
Purcell/M
Purdue/M
Purim/MS
Purina/M
Puritan/M
Puritanism/MS
Purus/M
Pusan/M
Pusey/M
Pushkin/M
Pushtu/M
Putin/M
Putnam/M
Puzo/M
Pvt
Pygmalion/M
Pygmy/SM
Pyle/M
Pym/M
Pynchon/M
Pyongyang/M
Pyotr/M
Pyrenees/M
Pyrex/MS
Pyrrhic/M
Pythagoras/M
Pythagorean/M
Pythias/M
Python/M
Q
QA
QB
QC
QED
QM
QWERTY
Qaddafi/M
Qantas/M
Qatar/M
Qatari/MS
Qingdao/M
Qiqihar/M
Qom/M
Quaalude/M
Quaker/MS
Quakerism/SM
Quaoar/M
Quasimodo/M
Quaternary/M
Quayle/M
Que
Quebec/M
Quebecois/M
Quechua/M
Queen/MS
Queens/M
Queensland/M
Quentin/M
Quetzalcoatl/M
Quezon/M
Quincy/M
Quinn/M
Quintilian/M
Quinton/M
Quirinal/M
Quisling/M
Quito/M
Quixote/M
Quixotism/M
Qumran/M
Quonset/M
R/M
RAF/M
RAM/SM
RBI
RC
RCA/M
RCMP
RD
RDA
REIT
REM/SM
RF
RFC/S
RFD
RI
RIF
RIP
RISC
RN/M
RNA/M
ROFL
ROM/M
ROTC/M
RP
RR
RSFSR
RSI
RSV
RSVP
RTFM
RV/SM
Ra/M
Rabat/M
Rabelais/M
Rabelaisian/M
Rabin/M
Rachael/M
Rachel/M
Rachelle/M
Rachmaninoff/M
Racine/M
Radcliffe/M
Rae/M
Rafael/M
Raffles/M
Ragnarok/M
Rainier/M
Raleigh/M
Ralph/M
Rama/M
Ramada/M
Ramadan/MS
Ramakrishna/M
Ramanujan/M
Ramayana/M
Rambo/M
Ramirez/M
Ramiro/M
Ramon/M
Ramona/M
Ramos/M
Ramsay/M
Ramses/M
Ramsey/M
Rand/M
Randal/M
Randall/M
Randell/M
Randi/M
Randolph/M
Randy/M
Rangoon/M
Rankin/M
Rankine/M
Raoul/M
Raphael/M
Rappaport/M
Rapunzel/M
Raquel/M
Rasalgethi/M
Rasalhague/M
Rasmussen/M
Rasputin/M
Rasta
Rastaban/M
Rastafarian/MS
Rastafarianism
Rather/M
Ratliff/M
Raul/M
Ravel/M
Rawalpindi/M
Ray/M
RayBan/M
Rayburn/M
Rayleigh/M
Raymond/M
Raymundo/M
Rb/M
Rd
Re/M
Reading/M
Reagan/M
Reaganomics/M
Realtor/M
Reasoner/M
Reba/M
Rebekah/M
Recife/M
Reconstruction/M
Redeemer/M
Redford/M
Redgrave/M
Redmond/M
Reebok/M
Reed/M
Reese/M
Reeves/M
Reformation/MS
Refugio/M
Reggie/M
Regina/M
Reginae/M
Reginald/M
Regor/M
Regulus/M
Rehnquist/M
Reich/M
Reichstag's
Reid/M
Reilly/M
Reinaldo/M
Reinhardt/M
Reinhold/M
Remarque/M
Rembrandt/M
Remington/M
Remus/M
Rena/M
Renaissance/SM
Renascence
Renault/M
Rene/M
Renee/M
Reno/M
Renoir/M
Rep
Representative
Republican/SM
Republicanism
Requiem/MS
Resistance
Restoration/M
Resurrection
Reuben/M
Reunion/M
Reuters/M
Reuther/M
Rev
Reva/M
Revelation/SM
Revelations/M
Revere/M
Reverend/M
Revlon/M
Rex/M
Reyes/M
Reykjavik/M
Reyna/M
Reynaldo/M
Reynolds/M
Rf/M
Rh/M
Rhea/M
Rhee/M
Rheingau/M
Rhenish/M
Rhiannon/M
Rhine/M
Rhineland/M
Rhoda/M
Rhode/S
Rhodes/M
Rhodesia/M
Rhodesian
Rhonda/M
Rhone/M
Ribbentrop/M
Ricardo/M
Rice/M
Rich/M
Richard/MS
Richards/M
Richardson/M
Richelieu/M
Richie/M
Richmond/M
Richter/M
Richthofen/M
Rick/M
Rickenbacker/M
Rickey/M
Rickie/M
Rickover/M
Ricky/M
Rico/M
Riddle/M
Ride/M
Riefenstahl/M
Riel/M
Riemann/M
Riesling/MS
Riga/M
Rigel/M
Riggs/M
Right
Rigoberto/M
Rigoletto/M
Riley/M
Rilke/M
Rimbaud/M
Ringling/M
Ringo/M
Rio/SM
Rios/M
Ripley/M
Risorgimento/M
Rita/M
Ritalin/M
Ritz/M
Rivas/M
Rivera/M
Rivers/M
Riverside
Riviera/MS
Riyadh/M
Rizal/M
Rn/M
Roach/M
Roanoke/M
Rob/M
Robbie/M
Robbin/MS
Robbins/M
Robby/M
Roberson/M
Robert/MS
Roberta/M
Roberto/M
Roberts/M
Robertson/M
Robeson/M
Robespierre/M
Robin/M
Robinson/M
Robitussin/M
Robles/M
Robson/M
Robt/M
Robyn/M
Rocco/M
Rocha/M
Rochambeau/M
Roche/M
Rochelle/M
Rochester/M
Rock/M
Rockefeller/M
Rockford/M
Rockies/M
Rockne/M
Rockwell/M
Rocky/SM
Rod/M
Roddenberry/M
Roderick/M
Rodger/MS
Rodgers/M
Rodin/M
Rodney/M
Rodolfo/M
Rodrick/M
Rodrigo/M
Rodriguez/M
Rodriquez/M
Roeg/M
Roentgen
Rogelio/M
Roger/MS
Rogers/M
Roget/M
Rojas/M
Roku/M
Rolaids/M
Roland/M
Rolando/M
Rolex/M
Rolland/M
Rollerblade/M
Rollins/M
Rolodex/M
Rolvaag/M
Rom
Roman/MS
Romanesque/MS
Romania/M
Romanian/MS
Romano/M
Romanov/M
Romans/M
Romansh/M
Romanticism
Romany/SM
Rome/SM
Romeo/M
Romero/M
Rommel/M
Romney/M
Romulus/M
Ron/M
Ronald/M
Ronda/M
Ronnie/M
Ronny/M
Ronstadt/M
Rontgen
Rooney/M
Roosevelt/M
Root/M
Roquefort/SM
Rorschach/M
Rory/M
Rosa/M
Rosales/M
Rosalie/M
Rosalind/M
Rosalinda/M
Rosalyn/M
Rosanna/M
Rosanne/M
Rosario/M
Roscoe/M
Rose/M
Roseann/M
Roseau/M
Rosecrans/M
Rosella/M
Rosemarie/M
Rosemary/M
Rosenberg/M
Rosendo/M
Rosenzweig/M
Rosetta/M
Rosicrucian/M
Rosie/M
Roslyn/M
Ross/M
Rossetti/M
Rossini/M
Rostand/M
Rostov/M
Rostropovich/M
Roswell/M
Rotarian/M
Roth/M
Rothko/M
Rothschild/M
Rotterdam/M
Rottweiler/M
Rouault/M
Rourke/M
Rousseau/M
Rove/RM
Rover/M
Rowe/M
Rowena/M
Rowland/M
Rowling/M
Roxanne/M
Roxie/M
Roxy/M
Roy/M
Royal/M
Royce/M
Rozelle/M
Rte
Ru/MH
Rubaiyat/M
Rubbermaid/M
Ruben/SM
Rubens/M
Rubicon/MS
Rubik/M
Rubin/M
Rubinstein/M
Ruby/M
Ruchbah/M
Rudolf/M
Rudolph/M
Rudy/M
Rudyard/M
Rufus/M
Ruhr/M
Ruiz/M
Rukeyser/M
Rumpelstiltskin/M
Rumsfeld/M
Runnymede/M
Runyon/M
Rupert/M
Rush/M
Rushdie/M
Rushmore/M
Ruskin/M
Russ/M
Russel/M
Russell/M
Russia/M
Russian/SM
Russo/M
Rustbelt/M
Rusty/M
Rutan/M
Rutgers/M
Ruth/M
Rutherford/M
Ruthie/M
Rutledge/M
Rwanda/MS
Rwandan/SM
Rwy
Rx
Ry
Ryan/M
Rydberg/M
Ryder/M
Ryukyu/M
S/MN
SA
SAC
SALT/M
SAM/M
SAP/M
SARS/M
SASE
SAT
SBA
SC/M
SCSI/M
SD
SDI
SE/M
SEATO
SEC/M
SF
SGML/M
SIDS/M
SJ
SJW
SK
SLR
SO/S
SOB/M
SOP/M
SOS/M
SOSes
SPCA
SPF
SQL
SRO
SS
SSA
SSE/M
SSS
SST
SSW/M
ST
STD
STOL
SUSE/M
SUV
SVN/M
SW/M
SWAK
SWAT
Saab/M
Saar/M
Saarinen/M
Saatchi/M
Sabbath/M
Sabbaths
Sabik/M
Sabin/M
Sabina/M
Sabine/M
Sabre/M
Sabrina/M
Sacajawea/M
Sacco/M
Sachs/M
Sacramento/M
Sadat/M
Saddam/M
Sadducee/M
Sade/M
Sadie/M
Sadr/M
Safavid/M
Safeway/M
Sagan/M
Saginaw/M
Sagittarius/MS
Sahara/M
Saharan/M
Sahel/M
Saigon/M
Saiph/M
Sakai/M
Sakha/M
Sakhalin/M
Sakharov/M
Saki/M
Saks/M
Sal/MY
Saladin/M
Salado/M
Salamis/M
Salas/M
Salazar/M
Salem/M
Salerno/M
Salinas/M
Salinger/M
Salisbury/M
Salish/M
Salk/M
Sallie/M
Sallust/M
Sally/M
Salome/M
Salonika/M
Salton/M
Salvador/M
Salvadoran/SM
Salvadorean/MS
Salvadorian/MS
Salvatore/M
Salween/M
Salyut/M
Sam/M
Samantha/M
Samar/M
Samara/M
Samaritan/MS
Samarkand/M
Sammie/M
Sammy/M
Samoa/M
Samoan/SM
Samoset/M
Samoyed/M
Sampson/M
Samson/M
Samsonite/M
Samsung/M
Samuel/M
Samuelson/M
San'a
San/M
Sana/M
Sanchez/M
Sancho/M
Sand/ZM
Sandburg/M
Sanders/M
Sandinista/M
Sandoval/M
Sandra/M
Sandy/M
Sanford/M
Sanforized/M
Sang/MR
Sanger/M
Sanhedrin/M
Sanka/M
Sankara/M
Sanskrit/M
Santa/M
Santana/M
Santayana/M
Santeria/M
Santiago/M
Santos/M
Sappho/M
Sapporo/M
Sara/M
Saracen/MS
Saragossa/M
Sarah/M
Sarajevo/M
Saran/M
Sarasota/M
Saratov/M
Sarawak/M
Sardinia/M
Sargasso/M
Sargent/M
Sargon/M
Sarnoff/M
Saroyan/M
Sarto/M
Sartre/M
Sasha/M
Sask
Saskatchewan/M
Saskatoon/M
Sasquatch/MS
Sassanian/M
Sassoon/M
Sat/M
Satan/M
Satanism/M
Satanist/M
Saturday/MS
Saturn/M
Saturnalia/M
Saudi/MS
Saul/M
Saunders/M
Saundra/M
Saussure/M
Sauternes
Savage/M
Savannah/M
Savior/M
Savonarola/M
Savoy/M
Savoyard/M
Sawyer/M
Saxon/MS
Saxony/M
Sayers/M
Sb/M
Sc/M
Scala/M
Scan
Scandinavia/M
Scandinavian/MS
Scaramouch/M
Scarborough/M
Scarlatti/M
Scheat/M
Schedar/M
Scheherazade/M
Schelling/M
Schenectady/M
Schiaparelli/M
Schick/M
Schiller/M
Schindler/M
Schlesinger/M
Schliemann/M
Schlitz/M
Schmidt/M
Schnabel/M
Schnauzer/M
Schneider/M
Schoenberg/M
Schopenhauer/M
Schrieffer/M
Schrodinger/M
Schroeder/M
Schubert/M
Schultz/M
Schulz/M
Schumann/M
Schumpeter/M
Schuyler/M
Schuylkill/M
Schwartz/M
Schwarzenegger/M
Schwarzkopf/M
Schweitzer/M
Schweppes/M
Schwinger/M
Schwinn/M
Scientologist/SM
Scientology/M
Scipio/M
Scopes/M
Scorpio/SM
Scorpius/M
Scorsese/M
Scot/SM
Scotch/MS
Scotchman/M
Scotchmen/M
Scotchwoman/M
Scotchwomen/M
Scotia/M
Scotland/M
Scotsman/M
Scotsmen/M
Scotswoman/M
Scotswomen/M
Scott/M
Scottie/SM
Scottish/M
Scottsdale/M
Scrabble/MS
Scranton/M
Scriabin/M
Scribner/M
Scripture/SM
Scrooge/M
Scruggs/M
Scud/M
Sculley/M
Scylla/M
Scythia/M
Scythian/M
Se/MH
Seaborg/M
Seagram/M
Sean/M
Sears/M
Seattle/M
Sebastian/M
Sec
Seconal/M
Secretariat/M
Secretary
Seder/MS
Sedna/M
Seebeck/M
Seeger/M
Sega/M
Segovia/M
Segre/M
Segundo/M
Seiko/M
Seine/M
Seinfeld/M
Sejong/M
Selassie/M
Selectric/M
Selena/M
Seleucid/M
Seleucus/M
Selim/M
Seljuk/M
Selkirk/M
Sellers/M
Selma/M
Selznick/M
Semarang/M
Seminole/MS
Semiramis/M
Semite/MS
Semitic/SM
Semtex/M
Senate/MS
Sendai/M
Seneca/MS
Senegal/M
Senegalese/M
Senghor/M
Senior/M
Sennacherib/M
Sennett/M
Sensurround/M
Seoul/M
Sep
Sephardi/M
Sepoy/M
Sept/M
September/MS
Septuagint/MS
Sequoya/M
Serb/SM
Serbia/M
Serbian/MS
Serena/M
Serengeti/M
Sergei/M
Sergio/M
Serpens/M
Serra/M
Serrano/M
Set/M
Seth/M
Seton/M
Seurat/M
Seuss/M
Sevastopol/M
Severn/M
Severus/M
Seville/M
Sevres/M
Seward/M
Sextans/M
Sexton/M
Seychelles/M
Seyfert/M
Seymour/M
Sgt
Shackleton/M
Shaffer/M
Shah/M
Shaka/M
Shaker
Shakespeare/M
Shakespearean/M
Shana/M
Shane/M
Shanghai/M
Shankara/M
Shanna/M
Shannon/M
Shantung/M
Shapiro/M
Shari'a/M
Shari/M
Sharif/M
Sharlene/M
Sharon/M
Sharp/M
Sharpe/M
Sharron/M
Shasta/M
Shaula/M
Shaun/M
Shauna/M
Shavian/M
Shavuot/M
Shaw/M
Shawn/M
Shawna/M
Shawnee/SM
Shcharansky/M
Shea/M
Sheba/M
Shebeli/M
Sheena/M
Sheetrock/M
Sheffield/M
Sheila/M
Shelby/M
Sheldon/M
Shelia/M
Shell/M
Shelley/M
Shelly/M
Shelton/M
Shenandoah/M
Shenyang/M
Sheol/M
Shepard/M
Shepherd/M
Sheppard/M
Sheratan/M
Sheraton/M
Sheree/M
Sheri/M
Sheridan/M
Sherlock/M
Sherman/M
Sherpa/M
Sherri/M
Sherrie/M
Sherry/M
Sherwood/M
Sheryl/M
Shetland/SM
Shetlands/M
Shevardnadze/M
Shevat/M
Shi'ite/M
Shields/M
Shiite/MS
Shijiazhuang/M
Shikoku/M
Shillong/M
Shiloh/M
Shinto/MS
Shintoism/MS
Shintoist/MS
Shiraz/M
Shirley/M
Shiva/M
Shockley/M
Short/M
Shorthorn/M
Shoshone/SM
Shostakovitch/M
Shrek/M
Shreveport/M
Shriner/M
Shropshire/M
Shula/M
Shylock/M
Shylockian/M
Si/M
Siam/M
Siamese/M
Sibelius/M
Siberia/M
Siberian/MS
Sibyl/M
Sicilian/SM
Sicily/M
Sid/M
Siddhartha/M
Sidney/M
Siegfried/M
Siemens/M
Sierpinski/M
Sierras
Sigismund/M
Sigmund/M
Sigurd/M
Sihanouk/M
Sikh/M
Sikhism
Sikhs
Sikkim/M
Sikkimese/M
Sikorsky/M
Silas/M
Silesia/M
Silurian/SM
Silva/M
Silvia/M
Simenon/M
Simmental/M
Simmons/M
Simon/M
Simone/M
Simpson/SM
Simpsons/M
Sims/M
Sinai/M
Sinatra/M
Sinbad/M
Sinclair/M
Sindbad/M
Sindhi/M
Singapore/M
Singaporean/SM
Singer/M
Singh/M
Singleton/M
Sinhalese/M
Sinkiang/M
Sioux/M
Sir/SM
Sirius/M
Sistine/M
Sisyphean/M
Sisyphus/M
Siva/M
Sivan/M
Sjaelland/M
Skinner/M
Skippy/M
Skopje/M
Skye/M
Skylab/M
Skype/M
Slackware/M
Slashdot/M
Slater/M
Slav/SM
Slavic/M
Slavonic/M
Slinky/M
Sloan/M
Sloane/M
Slocum/M
Slovak/SM
Slovakia/M
Slovakian
Slovene/SM
Slovenia/M
Slovenian/MS
Slurpee/M
Sm/M
Small/M
Smetana/M
Smirnoff/M
Smith/M
Smithson/M
Smithsonian/M
Smokey/M
Smolensk/M
Smollett/M
Smuts/M
Smyrna
Sn/M
Snake/M
Snapple/M
Snead/M
Snell/M
Snickers/M
Snider/M
Snoopy/M
Snow/M
Snowbelt/M
Snyder/M
Soave/M
Soc
Socorro/M
Socrates/M
Socratic/M
Soddy/M
Sodom/M
Sofia/M
Soho/M
Sol/M
Solis/M
Solomon/M
Solon/M
Solzhenitsyn/M
Somali/SM
Somalia/M
Somalian/MS
Somme/M
Somoza/M
Son/M
Sondheim/M
Sondra/M
Songhai/M
Songhua/M
Sonia/M
Sonja/M
Sonny/M
Sonora/M
Sontag/M
Sony/M
Sonya/M
Sophia/M
Sophie/M
Sophoclean/M
Sophocles/M
Sopwith/M
Sorbonne/M
Sosa/M
Soto/M
Souphanouvong/M
Sourceforge/M
Sousa/M
South/M
Southampton/M
Southeast/MS
Southerner/SM
Southey/M
Souths
Southwest/MS
Soviet/M
Soweto/M
Soyinka/M
Soyuz/M
Sp
Spaatz/M
Spackle/M
Spahn/M
Spain/M
Spam/M
Span
Spanglish
Spaniard/SM
Spanish/M
Sparks/M
Sparta/M
Spartacus/M
Spartan/MS
Spears/M
Speer/M
Spence/RM
Spencer/M
Spencerian/M
Spengler/M
Spenglerian/M
Spenser/M
Spenserian/M
Sperry/M
Sphinx/M
Spica/M
Spielberg/M
Spillane/M
Spinoza/M
Spinx/M
Spiro/M
Spirograph/M
Spitsbergen/M
Spitz/M
Spock/M
Spokane/M
Springfield/M
Springsteen/M
Sprint/M
Sprite/M
Sputnik/M
Sq
Squanto/M
Squibb/M
Sr/M
Srinagar/M
Srivijaya/M
St
Sta
Stacey/M
Staci/M
Stacie/M
Stacy/M
Stael/M
Stafford/M
StairMaster/M
Stalin/M
Stalingrad/M
Stalinist/M
Stallone/M
Stamford/M
Stan/M
Standish/M
Stanford/M
Stanislavsky/M
Stanley/M
Stanton/M
Staples/M
Starbucks/M
Stark/M
Starkey/M
Starr/M
Staten/M
States
Staubach/M
Ste
Steadicam/M
Steele/M
Stefan/M
Stefanie/M
Stein/MR
Steinbeck/M
Steinem/M
Steiner/M
Steinmetz/M
Steinway/M
Stella/M
Stendhal/M
Stengel/M
Stephan/M
Stephanie/M
Stephen/MS
Stephens/M
Stephenson/M
Sterling/M
Stern/M
Sterne/M
Sterno/M
Stetson/M
Steuben/M
Steve/M
Steven/MS
Stevens/M
Stevenson/M
Stevie/M
Stewart/M
Stieglitz/M
Stilton/SM
Stimson/M
Stine/M
Stirling/M
Stockhausen/M
Stockholm/M
Stockton/M
Stoic/SM
Stoicism/MS
Stokes/M
Stolichnaya/M
Stolypin/M
Stone/M
Stonehenge/M
Stoppard/M
Stout/M
Stowe/M
Strabo/M
Stradivari
Stradivarius/M
Strasbourg/M
Strauss/M
Stravinsky/M
Streisand/M
Strickland/M
Strindberg/M
Stromboli/M
Strong/M
Stu/M
Stuart/MS
Studebaker/M
Stuttgart/M
Stuyvesant/M
Stygian/M
Styrofoam/SM
Styron/M
Styx/M
Suarez/M
Subaru/M
Sucre/M
Sucrets/M
Sudan/M
Sudanese/M
Sudetenland/M
Sudoku/M
Sudra/M
Sue/M
Suetonius/M
Suez/M
Suffolk/M
Sufi/M
Sufism/M
Suharto/M
Sui/M
Sukarno/M
Sukkot
Sulawesi/M
Suleiman/M
Sulla/M
Sullivan/M
Sumatra/M
Sumatran/SM
Sumeria/M
Sumerian/SM
Summer/MS
Summers/M
Sumner/M
Sumter/M
Sun/SM
Sunbeam/M
Sunbelt/M
Sundanese/M
Sundas/M
Sunday/MS
Sung/M
Sunkist/M
Sunni/SM
Sunnite/MS
Sunnyvale/M
Superbowl/M
Superfund/M
Superglue/M
Superior/M
Superman/M
Supt
Surabaya/M
Surat/M
Suriname/M
Surinamese
Surya/M
Susan/M
Susana/M
Susanna/M
Susanne/M
Susie/M
Susquehanna/M
Sussex/M
Sutherland/M
Sutton/M
Suva/M
Suwanee/M
Suzanne/M
Suzette/M
Suzhou/M
Suzuki/M
Suzy/M
Svalbard/M
Sven/M
Svengali/M
Sverdlovsk
Swahili/SM
Swammerdam/M
Swanee/M
Swansea/M
Swanson/M
Swazi/SM
Swaziland/M
Swed/N
Swede/SM
Sweden/M
Swedenborg/M
Swedish/M
Sweeney/M
Sweet/M
Swift/M
Swinburne/M
Swiss/MS
Swissair/M
Switz
Switzerland/M
Sybil/M
Sydney/M
Sykes/M
Sylvester/M
Sylvia/M
Sylvie/M
Synge/M
Syracuse/M
Syria/M
Syriac/M
Syrian/MS
Szilard/M
Szymborska/M
T'ang/M
T/MDG
TA
TARP
TB/M
TBA
TD
TDD
TEFL
TELNET/S
TELNETTed
TELNETTing
TESL
TESOL
TGIF
THC
TKO/M
TLC/M
TM
TN
TNT/M
TOEFL
TQM
TV/SM
TVA
TWA/M
TWX
TX
Ta/M
Tabasco/SM
Tabatha/M
Tabernacle/MS
Tabitha/M
Tabriz/MS
Tacitus/M
Tacoma/M
Tad/M
Tadzhik/M
Taegu/M
Taejon/M
Taft/M
Tagalog/SM
Tagore/M
Tagus/M
Tahiti/M
Tahitian/MS
Tahoe/M
Taichung/M
Tainan
Taine/M
Taipei/M
Taiping/M
Taiwan/M
Taiwanese/M
Taiyuan/M
Tajikistan/M
Taklamakan/M
Talbot/M
Taliban/M
Taliesin/M
Tallahassee/M
Tallchief/M
Talley/M
Talleyrand/M
Tallinn/M
Talmud/MS
Talmudic
Talmudist
Tamara/M
Tameka/M
Tamera/M
Tamerlane/M
Tami/M
Tamika/M
Tamil/MS
Tammany/M
Tammi/M
Tammie/M
Tammuz/M
Tammy/M
Tampa/M
Tampax/M
Tamra/M
Tamworth/M
Tancred/M
Taney/M
Tanganyika/M
Tangier/MS
Tangshan/M
Tania/M
Tanisha/M
Tanner/M
Tannhauser/M
Tantalus/M
Tanya/M
Tanzania/M
Tanzanian/SM
Tao/M
Taoism/MS
Taoist/MS
Tara/M
Tarantino/M
Tarawa/M
Tarazed/M
Tarbell/M
Target/M
Tarim/M
Tarkenton/M
Tarkington/M
Tartary/M
Tartuffe/M
Tarzan/M
Tasha/M
Tashkent/M
Tasman/M
Tasmania/M
Tasmanian/M
Tass/M
Tatar/MS
Tate/M
Tatum/M
Taurus/MS
Tawney/M
Taylor/M
Tb/M
Tbilisi/M
Tc/M
Tchaikovsky/M
Te/M
TeX
TeXes
Teasdale/M
Technicolor/M
Tecumseh/M
Ted/M
Teddy/M
Teflon/MS
Tegucigalpa/M
Tehran
TelePrompTer
TelePrompter/M
Telemachus/M
Telemann/M
Teletype
Tell/MR
Teller/M
Telugu/M
Tempe
Templar/M
Tenn/M
Tennessean/SM
Tennessee/M
Tennyson/M
Tenochtitlan/M
Teotihuacan/M
Terence/M
Teresa/M
Tereshkova/M
Teri/M
Terkel/M
Terpsichore/M
Terr/M
Terra/M
Terran/M
Terrance/M
Terrell/M
Terrence/M
Terri/M
Terrie/M
Terry/M
Tertiary/M
Tesla/M
Tess/M
Tessa/M
Tessie/M
Tet/M
Tethys/M
Tetons/M
Teuton/MS
Teutonic/M
Tevet/M
Tex/M
Texaco/M
Texan/MS
Texas/M
Th/M
Thackeray/M
Thad/M
Thaddeus/M
Thai/SM
Thailand/M
Thales/M
Thalia/M
Thames/M
Thanh/M
Thanksgiving/MS
Thant/M
Thar/M
Tharp/M
Thatcher/M
Thea/M
Thebes/M
Theiler/M
Thelma/M
Themistocles/M
Theocritus/M
Theodora/M
Theodore/M
Theodoric/M
Theodosius/M
Theosophy/M
Theravada/M
Theresa/M
Therese/M
Thermopylae/M
Thermos
Theron/M
Theseus/M
Thespian/M
Thespis/M
Thessalonian/SM
Thessaloniki/M
Thessaly/M
Thieu/M
Thimbu/M
Thimphu
Thomas/M
Thomism/M
Thomistic/M
Thompson/M
Thomson/M
Thor/M
Thorazine/M
Thoreau/M
Thornton/M
Thoroughbred/M
Thorpe/M
Thoth/M
Thrace/M
Thracian/M
Thu
Thucydides/M
Thule/M
Thunderbird/M
Thur/S
Thurber/M
Thurman/M
Thurmond/M
Thursday/SM
Thutmose/M
Ti/M
Tia/M
Tianjin/M
Tiber/M
Tiberius/M
Tibet/M
Tibetan/MS
Ticketmaster/M
Ticonderoga/M
Tide/M
Tienanmen/M
Tiffany/M
Tigris/M
Tijuana/M
Tillich/M
Tillman/M
Tilsit/M
Tim/M
Timbuktu/M
Timex/M
Timmy/M
Timon/M
Timor/M
Timothy/M
Timur/M
Timurid/M
Tina/M
Ting/M
Tinkerbell/M
Tinkertoy/M
Tinseltown/M
Tintoretto/M
Tippecanoe/M
Tipperary/M
Tirane
Tiresias/M
Tirol/M
Tirolean
Tisha/M
Tishri/M
Titan/SM
Titania/M
Titanic/M
Titian/M
Titicaca/M
Tito/M
Titus/M
Tl/M
Tlaloc/M
Tlingit/M
Tm/M
Tobago/M
Tobit/M
Toby/M
Tocantins/M
Tocqueville/M
Tod/M
Todd/M
Togo/M
Togolese/M
Tojo/M
Tokay/M
Tokugawa/M
Tokyo/M
Tokyoite
Toledo/MS
Tolkien/M
Tolstoy/M
Toltec/M
Tolyatti/M
Tom/M
Tomas/M
Tombaugh/M
Tomlin/M
Tommie/M
Tommy/M
Tompkins/M
Tomsk/M
Tonga/M
Tongan/MS
Toni/M
Tonia/M
Tonto/M
Tony/M
Tonya/M
Topeka/M
Topsy/M
Torah/M
Torahs
Toronto/M
Torquemada/M
Torrance/M
Torrens/M
Torres/M
Torricelli/M
Tortola/M
Tortuga/M
Torvalds/M
Tory/SM
Tosca/M
Toscanini/M
Toshiba/M
Toto/M
Toulouse/M
Townes/M
Townsend/M
Toynbee/M
Toyoda/M
Toyota/M
Tracey/M
Traci/M
Tracie/M
Tracy/M
Trafalgar/M
Trailways/M
Trajan/M
Tran/M
Transcaucasia/M
Transvaal/M
Transylvania/M
Transylvanian/M
Trappist/SM
Travis/M
Travolta/M
Treasury/SM
Treblinka/M
Trekkie/M
Trent/M
Trenton/M
Trevelyan/M
Trevino/M
Trevor/M
Trey/M
Triangulum/M
Triassic/M
Tricia/M
Trident/M
Trieste/M
Trimurti/M
Trina/M
Trinidad/M
Trinidadian/MS
Trinity/SM
Tripitaka/M
Tripoli/M
Trippe/M
Trisha/M
Tristan/M
Triton/M
Trobriand/M
Troilus/M
Trojan/MS
Trollope/M
Trondheim/M
Tropicana/M
Trotsky/M
Troy/M
Troyes
Truckee/M
Trudeau/M
Trudy/M
Truffaut/M
Trujillo/M
Truman/M
Trumbull/M
Trump/M
Truth/M
Tsimshian/M
Tsiolkovsky/M
Tsitsihar/M
Tsongkhapa/M
Tswana/M
Tu/M
Tuamotu/M
Tuareg/M
Tubman/M
Tucker/M
Tucson/M
Tucuman/M
Tudor/SM
Tue/S
Tues/M
Tuesday/MS
Tulane/M
Tull/M
Tulsa/M
Tulsidas/M
Tums/M
Tungus/M
Tunguska/M
Tunis/M
Tunisia/M
Tunisian/MS
Tunney/M
Tupi/M
Tupperware/M
Tupungato/M
Turgenev/M
Turin/M
Turing/M
Turk/SM
Turkestan/M
Turkey/M
Turkic/MS
Turkish/M
Turkmenistan/M
Turner/M
Turpin/M
Tuscaloosa/M
Tuscan/M
Tuscany/M
Tuscarora/MS
Tuscon/M
Tuskegee/M
Tussaud/M
Tut/M
Tutankhamen/M
Tutsi/M
Tutu/M
Tuvalu/M
Tuvaluan
Twain/M
Tweed/M
Tweedledee/M
Tweedledum/M
Twila/M
Twinkies/M
Twitter/M
Twizzlers/M
Twp
Ty/M
Tycho/M
Tylenol/M
Tyler/M
Tyndale/M
Tyndall/M
Tyre/M
Tyree/M
Tyrolean
Tyrone/M
Tyson/M
U/M
UAR
UAW
UBS/M
UCLA/M
UFO/SM
UHF/M
UK/M
UL
UN/M
UNESCO/M
UNICEF/M
UNIX/M
UPC
UPI/M
UPS/M
URL/S
US/M
USA/M
USAF
USB
USCG
USDA/M
USIA
USMC
USN
USO
USP
USPS
USS
USSR/M
UT/M
UTC
UV/M
Ubangi/M
Ubuntu/M
Ucayali/M
Uccello/M
Udall/M
Ufa/M
Uganda/M
Ugandan/MS
Uighur/M
Ujungpandang/M
Ukraine/M
Ukrainian/SM
Ulster/M
Ultrasuede/M
Ulyanovsk/M
Ulysses/M
Umbriel/M
Underwood/M
Ungava/M
Unicode/M
Unilever/M
Union/SM
Unionist
Uniroyal/M
Unitarian/MS
Unitarianism/MS
Unitas/M
Unix/S
Unukalhai/M
Upanishads/M
Updike/M
Upjohn/M
Upton/M
Ur/M
Ural/SM
Urals/M
Urania/M
Uranus/M
Urban/M
Urdu/M
Urey/M
Uriah/M
Uriel/M
Uris/M
Urquhart/M
Ursa/M
Ursula/M
Ursuline/M
Uruguay/M
Uruguayan/MS
Urumqi/M
Usenet/MS
Ustinov/M
Ut
Utah/M
Utahan/MS
Ute/SM
Utopia/SM
Utopian/SM
Utrecht/M
Utrillo/M
Uzbek/M
Uzbekistan/M
Uzi/SM
V/M
VA
VAT/M
VAX
VAXes
VCR/M
VD/M
VDT
VDU
VF
VFW/M
VG
VGA
VHF/M
VHS
VI/M
VIP/SM
VISTA
VJ
VLF/M
VOA
VP
VT
VTOL
Va/M
Vader/M
Vaduz/M
Val/M
Valarie/M
Valdez/M
Valencia/SM
Valenti/M
Valentin/M
Valentine/M
Valentino/M
Valenzuela/M
Valeria/M
Valerian/M
Valerie/M
Valery/M
Valhalla/M
Valium/MS
Valkyrie/SM
Vallejo
Valletta/M
Valois/M
Valparaiso/M
Valvoline/M
Van/M
Vance/M
Vancouver/M
Vandal/MS
Vanderbilt/M
Vandyke/M
Vanessa/M
Vang/M
Vanuatu/M
Vanzetti/M
Varanasi/M
Varese/M
Vargas/M
Vaseline/SM
Vasquez/M
Vassar/M
Vatican/M
Vauban/M
Vaughan/M
Vaughn/M
Vazquez/M
Veblen/M
Veda/SM
Vedanta/M
Vega/SM
Vegas/M
Vegemite/M
Vela/M
Velasquez/M
Velazquez/M
Velcro/MS
Velez/M
Velma/M
Velveeta/M
Venetian/SM
Venezuela/M
Venezuelan/SM
Venice/M
Venn/M
Ventolin/M
Venus/MS
Venusian/M
Vera/M
Veracruz/M
Verde/M
Verdi/M
Verdun/M
Verizon/M
Verlaine/M
Vermeer/M
Vermont/ZMR
Vermonter/M
Vern/M
Verna/M
Verne/M
Vernon/M
Verona/M
Veronese/M
Veronica/M
Versailles/M
Vesalius/M
Vespasian/M
Vespucci/M
Vesta/M
Vesuvius/M
Viacom/M
Viagra/M
Vic/M
Vicente/M
Vichy/M
Vicki/M
Vickie/M
Vicksburg/M
Vicky/M
Victor/M
Victoria/M
Victorian/MS
Victorianism
Victrola/M
Vidal/M
Vienna/M
Viennese/M
Vientiane/M
Vietcong/M
Vietminh/M
Vietnam/M
Vietnamese/M
Vijayanagar/M
Vijayawada/M
Viking/MS
Vila/M
Villa/M
Villarreal/M
Villon/M
Vilma/M
Vilnius/M
Vilyui/M
Vince/M
Vincent/M
Vindemiatrix/M
Vinson/M
Viola/M
Violet/M
Virgie/M
Virgil/M
Virginia/M
Virginian/SM
Virgo/SM
Visa/M
Visayans/M
Vishnu/M
Visigoth/M
Visigoths
Vistula/M
Vitim/M
Vito/M
Vitus/M
Vivaldi/M
Vivekananda/M
Vivian/M
Vivienne/M
Vlad/M
Vladimir/M
Vladivostok/M
Vlaminck/M
Vlasic/M
VoIP
Vogue/M
Volcker/M
Voldemort/M
Volga/M
Volgograd/M
Volkswagen/M
Volstead/M
Volta/M
Voltaire/M
Volvo/M
Vonda/M
Vonnegut/M
Voronezh/M
Vorster/M
Voyager/M
Vt
Vuitton/M
Vulcan/M
Vulg
Vulgate/SM
W/MDT
WA
WAC
WASP/M
WATS/M
WC
WHO/M
WI
WMD
WNW/M
WP
WSW/M
WTO
WV
WW
WWI
WWII
WWW/M
WY
WYSIWYG
Wabash/M
Wac
Waco/M
Wade/M
Wagner/M
Wagnerian/M
Wahhabi/M
Waikiki/M
Waite/M
Wake/M
Waksman/M
Wald/MN
Waldemar/M
Walden/M
Waldensian/M
Waldheim/M
Waldo/M
Waldorf/M
Wales/M
Walesa/M
Walgreen/M
Walker/M
Walkman/M
Wall/SMR
Wallace/M
Wallenstein/M
Waller/M
Wallis/M
Walloon/M
Walls/M
Walmart/M
Walpole/M
Walpurgisnacht/M
Walsh/M
Walt/MRZ
Walter/M
Walters/M
Walton/M
Wanamaker/M
Wanda/M
Wang/M
Wankel/M
Ward/M
Ware/MG
Warhol/M
Waring/M
Warner/M
Warren/M
Warsaw/M
Warwick/M
Wasatch/M
Wash/M
Washington/M
Washingtonian/MS
Wassermann/M
Waterbury/M
Waterford/M
Watergate/M
Waterloo/MS
Waters/M
Watkins/M
Watson/M
Watt/SM
Watteau/M
Watts/M
Watusi/M
Waugh/M
Wave
Wayne/M
Weaver/M
Web/MR
Webb/M
Weber/M
Webern/M
Webster/MS
Wed/M
Weddell/M
Wedgwood/M
Wednesday/MS
Weeks/M
Wehrmacht/M
Wei/M
Weierstrass/M
Weill/M
Weinberg/M
Weiss/M
Weissmuller/M
Weizmann/M
Weldon/M
Welland/M
Weller/M
Welles/M
Wellington/SM
Wells/M
Welsh/M
Welshman/M
Welshmen/M
Welshwoman
Wendell/M
Wendi/M
Wendy/M
Wesak/M
Wesley/M
Wesleyan/M
Wessex/M
Wesson/M
West/SM
Western/MRS
Westinghouse/M
Westminster/M
Weston/M
Westphalia/M
Weyden/M
Wezen/M
Wharton/M
Wheaties/M
Wheatstone/M
Wheeler/M
Wheeling/M
Whig/SM
Whipple/M
Whirlpool/M
Whistler/M
Whitaker/M
White/SM
Whitefield/M
Whitehall/M
Whitehead/M
Whitehorse/M
Whiteley/M
Whitfield/M
Whitley/M
Whitman/M
Whitney/M
Whitsunday/MS
Whittier/M
WiFi
Wicca/M
Wichita/M
Wiemar/M
Wiesel/M
Wiesenthal/M
Wiggins/M
Wigner/M
Wii/M
Wikileaks
Wikipedia/M
Wilberforce/M
Wilbert/M
Wilbur/M
Wilburn/M
Wilcox/M
Wilda/M
Wilde/MR
Wilder/M
Wiles/M
Wiley/M
Wilford/M
Wilfred/M
Wilfredo/M
Wilhelm/M
Wilhelmina/M
Wilkerson/M
Wilkes/M
Wilkins/M
Wilkinson/M
Will/M
Willa/M
Willamette/M
Willard/M
Willemstad/M
William/SM
Williams/M
Williamson/M
Willie/M
Willis/M
Willy/M
Wilma/M
Wilmer/M
Wilmington/M
Wilson/M
Wilsonian/M
Wilton/M
Wimbledon/M
Wimsey/M
Winchell/M
Winchester/MS
Windbreaker/M
Windex/M
Windhoek/M
Windows/M
Windsor/SM
Windward/M
Winesap/M
Winfred/M
Winfrey/M
Winifred/M
Winkle/M
Winnebago/M
Winnie/M
Winnipeg/M
Winston/M
Winters/M
Winthrop/M
Wis
Wisc
Wisconsin/M
Wisconsinite/MS
Wise/M
Witt/M
Wittgenstein/M
Witwatersrand/M
Wm/M
Wobegon/M
Wodehouse/M
Wolf/M
Wolfe/M
Wolff/M
Wolfgang/M
Wollongong/M
Wollstonecraft/M
Wolsey/M
Wolverhampton
Wonder/M
Wonderbra/M
Wong/M
Wood/SM
Woodard/M
Woodhull/M
Woodrow/M
Woods/M
Woodstock/M
Woodward/M
Woolf/M
Woolite/M
Woolongong/M
Woolworth/M
Wooster/M
Wooten/M
Worcester/SM
Worcestershire/M
Wordsworth/M
Workman/M
Worms/M
Wotan/M
Wovoka/M
Wozniak/M
Wozzeck/M
Wrangell/M
Wren/M
Wright/M
Wrigley/M
Wroclaw/M
Wu/M
Wuhan/M
Wurlitzer/M
Wyatt/M
Wycherley/M
Wycliffe/M
Wyeth/M
Wylie/M
Wynn/M
Wyo
Wyoming/M
Wyomingite/SM
X/M
XEmacs/M
XL/M
XML
XS
XXL
Xanadu/M
Xanthippe/M
Xavier/M
Xe/SM
Xenakis/M
Xenia/M
Xenophon/M
Xerox/MS
Xerxes/M
Xhosa/M
Xi'an/M
Xian/SM
Xiaoping/M
Ximenes/M
Xingu/M
Xiongnu/M
Xmas/MS
Xochipilli/M
Xuzhou/M
Y/M
YMCA/M
YMHA
YMMV
YT
YWCA/M
YWHA
Yacc/M
Yahoo/M
Yahtzee/M
Yahweh/M
Yakima/M
Yakut/M
Yakutsk/M
Yale/M
Yalow/M
Yalta/M
Yalu/M
Yamagata/M
Yamaha/M
Yamoussoukro/M
Yang/M
Yangon/M
Yangtze/M
Yank/SM
Yankee/SM
Yaobang/M
Yaounde/M
Yaqui/M
Yaren
Yaroslavl/M
Yataro/M
Yates/M
Yb/M
Yeager/M
Yeats/M
Yekaterinburg/M
Yellowknife/M
Yellowstone/M
Yeltsin/M
Yemen/M
Yemeni/SM
Yemenite
Yenisei/M
Yerevan/M
Yerkes/M
Yesenia/M
Yevtushenko/M
Yggdrasil/M
Yiddish/M
Ymir/M
Yoda/M
Yoknapatawpha/M
Yoko/M
Yokohama/M
Yolanda/M
Yong/M
Yonkers/M
York/M
Yorkie/M
Yorkshire/MS
Yorktown/M
Yoruba/M
Yosemite/M
Yossarian/M
YouTube/M
Young/M
Youngstown/M
Ypres/M
Ypsilanti/M
Yuan/M
Yucatan/M
Yugo/M
Yugoslav/MS
Yugoslavia/M
Yugoslavian/SM
Yukon/M
Yule/SM
Yuletide/MS
Yuma/SM
Yunnan/M
Yuri/M
Yves/M
Yvette/M
Yvonne/M
Z/SMNXT
Zachariah/M
Zachary/M
Zachery/M
Zagreb/M
Zaire/M
Zairian
Zambezi/M
Zambia/M
Zambian/SM
Zamboni/M
Zamenhof/M
Zamora/M
Zane/M
Zanuck/M
Zanzibar/M
Zapata/M
Zaporozhye/M
Zapotec/M
Zappa/M
Zara/M
Zarathustra/M
Zealand/M
Zebedee/M
Zechariah/M
Zedekiah/M
Zedong/M
Zeffirelli/M
Zeke/M
Zelig/M
Zelma/M
Zen/M
Zenger/M
Zeno/M
Zephaniah/M
Zephyrus/M
Zest/M
Zeus/M
Zhdanov
Zhengzhou/M
Zhivago/M
Zhukov/M
Zibo/M
Ziegfeld/M
Ziegler/M
Ziggy/M
Zika
Zimbabwe/M
Zimbabwean/SM
Zimmerman/M
Zinfandel/M
Zion/SM
Zionism/SM
Zionist/SM
Ziploc/M
Zn/M
Zoe/M
Zola/M
Zollverein/M
Zoloft/M
Zomba/M
Zorn/M
Zoroaster/M
Zoroastrian/MS
Zoroastrianism/SM
Zorro/M
Zosma/M
Zr/M
Zsigmondy/M
Zubenelgenubi/M
Zubeneschamali/M
Zukor/M
Zulu/SM
Zululand
Zuni/M
Zurich/M
Zwingli/M
Zworykin/M
Zyrtec/M
Zyuganov/M
Zzz
a/S
aah
aardvark/SM
ab/SDY
aback
abacus/MS
abaft
abalone/SM
abandon/LSDG
abandonment/M
abase/LGDS
abasement/M
abash/GLDS
abashed/UY
abashment/M
abate/LGDS
abated/U
abatement/M
abattoir/MS
abbe/SM
abbess/MS
abbey/MS
abbot/MS
abbr
abbrev/S
abbreviate/DSGNX
abbreviation/M
abdicate/GNDSX
abdication/M
abdomen/SM
abdominal
abduct/DSG
abductee/MS
abduction/SM
abductor/MS
abeam
aberrant
aberration/MS
aberrational
abet/S
abetted
abetting
abettor/SM
abeyance/M
abhor/S
abhorred
abhorrence/M
abhorrent/Y
abhorring
abidance/M
abide/GS
abiding/Y
ability/IEMS
abject/YP
abjection/M
abjectness/M
abjuration/SM
abjuratory
abjure/ZGDRS
abjurer/M
ablate/XGNVDS
ablation/M
ablative/MS
ablaze
able/UT
abler
abloom
ablution/SM
abnegate/GNDS
abnegation/M
abnormal/Y
abnormality/SM
aboard
abode/MS
abolish/GDS
abolition/M
abolitionism/M
abolitionist/SM
abominable
abominably
abominate/DSGNX
abomination/M
aboriginal/MS
aborigine/SM
aborning
abort/GVDS
abortion/MS
abortionist/MS
abortive/Y
abound/DSG
about
above/M
aboveboard
abracadabra/M
abrade/GDS
abrasion/MS
abrasive/MYPS
abrasiveness/M
abreast
abridge/DSG
abridgment/MS
abroad
abrogate/XGNDS
abrogation/M
abrogator/MS
abrupt/TPRY
abruptness/M
abs/M
abscess/MDSG
abscissa/SM
abscission/M
abscond/ZGSDR
absconder/M
abseil/MDSG
absence/SM
absent/DYSG
absentee/MS
absenteeism/M
absentminded/YP
absentmindedness/M
absinthe/M
absolute/PMYTNS
absoluteness/M
absolution/M
absolutism/M
absolutist/MS
absolve/DSG
absorb/AGDS
absorbance
absorbency/M
absorbent/SM
absorbing/Y
absorption/M
absorptive
abstain/DRZGS
abstainer/M
abstemious/PY
abstemiousness/M
abstention/MS
abstinence/M
abstinent
abstract/GSPMDY
abstracted/YP
abstractedness/M
abstraction/SM
abstractness/MS
abstruse/YP
abstruseness/M
absurd/TPRY
absurdist/MS
absurdity/SM
absurdness/M
abundance/SM
abundant/Y
abuse's
abuse/EGVDS
abuser/MS
abusive/YP
abusiveness/M
abut/SL
abutment/MS
abutted
abutting
abuzz
abysmal/Y
abyss/MS
abyssal
ac
acacia/MS
academe/M
academia/M
academic/SM
academical/Y
academician/MS
academy/SM
acanthus/MS
accede/GDS
accelerate/GNXDS
acceleration/M
accelerator/SM
accent/MDSG
accented/U
accentual
accentuate/GNDS
accentuation/M
accept/DSBG
acceptability/M
acceptableness/M
acceptably/U
acceptance/SM
acceptation/MS
accepted/U
access/MDSG
accessibility/IM
accessible/I
accessibly/I
accession/MDGS
accessorize/DSG
accessory/SM
accident/MS
accidental/SMY
acclaim/MDGS
acclamation/M
acclimate/DSGN
acclimation/M
acclimatization/M
acclimatize/DSG
acclivity/SM
accolade/SM
accommodate/XGNDS
accommodating/Y
accommodation/M
accompanied/U
accompaniment/MS
accompanist/SM
accompany/DSG
accomplice/SM
accomplish/DSLG
accomplished/U
accomplishment/MS
accord/GMDS
accordance/M
accordant
according/Y
accordion/MS
accordionist/MS
accost/GMDS
account/MDSBG
accountability/M
accountable/U
accountancy/M
accountant/MS
accounted/U
accounting/M
accouter/SGD
accouterments/M
accredit/SGD
accreditation/M
accredited/U
accretion/MS
accrual/MS
accrue/GDS
acct
acculturate/DSGN
acculturation/M
accumulate/XGNVDS
accumulation/M
accumulator/MS
accuracy/IM
accurate/IY
accurateness/M
accursed/P
accursedness/M
accusation/MS
accusative/MS
accusatory
accuse/ZGDRS
accuser/M
accusing/Y
accustom/DSG
accustomed/U
ace/DSMG
acerbate/DSG
acerbic
acerbically
acerbity/M
acetaminophen/M
acetate/MS
acetic
acetone/M
acetonic
acetyl
acetylene/M
ache/DSMG
achene/MS
achieve/BLZGDRS
achievement/SM
achiever/M
aching/Y
achoo/M
achromatic
achy/TR
acid/SMY
acidic
acidify/GDS
acidity/M
acidosis/M
acidulous
acknowledge/DSG
acknowledged/U
acknowledgment/SM
acme/SM
acne/M
acolyte/MS
aconite/MS
acorn/MS
acoustic/S
acoustical/Y
acoustics/M
acquaint/AGSD
acquaintance/SM
acquaintanceship/M
acquainted/U
acquiesce/DSG
acquiescence/M
acquiescent/Y
acquire/ZGBDRSL
acquirement/M
acquisition/MS
acquisitive/YP
acquisitiveness/M
acquit/S
acquittal/MS
acquitted
acquitting
acre/SM
acreage/MS
acrid/PTRY
acridity/M
acridness/M
acrimonious/YP
acrimoniousness/M
acrimony/M
acrobat/MS
acrobatic/S
acrobatically
acrobatics/M
acronym/MS
acrophobia/M
acropolis/MS
across
acrostic/SM
acrylamide
acrylic/MS
act's
act/ASDGV
acting/M
actinium/M
action/ASM
actionable
activate/ICANGSD
activation/ICAM
activator/MS
active's
active/IKY
activeness/M
actives
activism/M
activist/MS
activities
activity/IM
actor/AMS
actress/MS
actual/Y
actuality/SM
actualization/M
actualize/GDS
actuarial
actuary/SM
actuate/GNDS
actuation/M
actuator/SM
acuity/M
acumen/M
acupressure/M
acupuncture/M
acupuncturist/SM
acute/PMYTRS
acuteness/M
acyclovir/M
acyl
ad/SM
adage/MS
adagio/MS
adamant/MY
adapt/BZGVDRS
adaptability/M
adaptation/MS
adapter/M
adaption/S
add/SDRBZG
addend/MS
addenda
addendum/M
adder/M
addict/GVMDS
addiction/SM
addition/SM
additional/Y
additive/SM
addle/GDS
address's
address/AGDS
addressable
addressed/U
addressee/SM
adduce/GDS
adenine/M
adenocarcinoma
adenoid/SM
adenoidal
adept/MYPS
adeptness/M
adequacy/IM
adequate/IY
adequateness/M
adhere/GDS
adherence/M
adherent/SM
adhesion/M
adhesive/PSM
adhesiveness/M
adiabatic
adieu/MS
adios
adipose
adj
adjacency/M
adjacent/Y
adjectival/Y
adjective/MS
adjoin/GDS
adjourn/DGLS
adjournment/SM
adjudge/GDS
adjudicate/GNVXDS
adjudication/M
adjudicator/SM
adjudicatory
adjunct/MS
adjuration/MS
adjure/GDS
adjust/AGDSL
adjustable
adjuster/SM
adjustment/AMS
adjutant/SM
adman/M
admen
admin/S
administer/DGS
administrate/XDSGNV
administration/M
administrative/Y
administrator/MS
admirably
admiral/MS
admiralty/M
admiration/M
admire/BZGDRS
admirer/M
admiring/Y
admissibility/IM
admissible/I
admissibly
admission/AM
admissions
admit/AS
admittance/M
admitted/Y
admitting/A
admix/GDS
admixture/SM
admonish/LDSG
admonishment/MS
admonition/MS
admonitory
ado/M
adobe/MS
adolescence/SM
adolescent/SM
adopt/AGVDS
adoptable
adopter/MS
adoption/SM
adorableness/M
adorably
adoration/M
adore/BZGDRS
adorer/M
adoring/Y
adorn/LGDS
adorned/U
adornment/MS
adrenal/MS
adrenalin's
adrenaline/M
adrenergic
adrift
adroit/PY
adroitness/M
adsorb/SDG
adsorbent/MS
adsorption/SM
adulate/DSGN
adulation/M
adulator/MS
adulatory
adult/MS
adulterant/MS
adulterate/GNDS
adulterated/U
adulteration/M
adulterer/SM
adulteress/MS
adulterous
adultery/SM
adulthood/M
adumbrate/GNDS
adumbration/M
adv
advance/LDSMG
advancement/SM
advantage/EDSMG
advantageous/EY
advent/SM
adventitious/Y
adventure/DRSMZG
adventurer/M
adventuresome
adventuress/MS
adventurism
adventurist/S
adventurous/YP
adventurousness/M
adverb/SM
adverbial/SMY
adversarial
adversary/SM
adverse/PRYT
adverseness/M
adversity/SM
advert/SMDG
advertise/LZGDRS
advertised/U
advertisement/MS
advertiser/M
advertising/M
advertorial/SM
advice/M
advisability/IM
advisable/I
advisably
advise/LDRSZGB
advised/UY
advisement/M
adviser/M
advisory/SM
advocacy/M
advocate/MGDS
advt
adware
adze/SM
aegis/M
aerate/DSGN
aeration/M
aerator/SM
aerial/SMY
aerialist/MS
aerie/MS
aerobatic/S
aerobatics/M
aerobic/S
aerobically
aerobics/M
aerodrome/MS
aerodynamic/S
aerodynamically
aerodynamics/M
aerogram/S
aeronautic/S
aeronautical
aeronautics/M
aerosol/MS
aerospace/M
aesthete/MS
aesthetic/S
aesthetically
aestheticism/M
aesthetics/M
afar
affability/M
affable
affably
affair/MS
affect's
affect/EGDS
affectation/SM
affected/UY
affecting/Y
affection/EM
affectionate/Y
affections
afferent
affiance/GDS
affidavit/SM
affiliate's
affiliate/EGNDS
affiliated/U
affiliation/EM
affiliations
affinity/SM
affirm/AGDS
affirmation/AMS
affirmative/MYS
affix/GMDS
afflatus/M
afflict/GDS
affliction/SM
affluence/M
affluent/Y
afford/GDSB
affordability
affordably
afforest/EGSD
afforestation/M
affray/MS
affront/GMDS
afghan/MS
aficionado/MS
afield
afire
aflame
afloat
aflutter
afoot
aforementioned
aforesaid
aforethought
afoul
afraid/U
afresh
aft/RZ
afterbirth/M
afterbirths
afterburner/MS
aftercare/M
aftereffect/MS
afterglow/SM
afterimage/MS
afterlife/M
afterlives
aftermarket/MS
aftermath/M
aftermaths
afternoon/MS
aftershave/SM
aftershock/SM
aftertaste/SM
afterthought/SM
afterward/S
afterword/MS
again
against
agape/M
agar/M
agate/MS
agave/M
age/DSMGJ
ageism/M
ageist/SM
ageless/YP
agelessness/M
agency/SM
agenda/SM
agent/AMS
ageratum/M
agglomerate/DSMGNX
agglomeration/M
agglutinate/DSXGN
agglutination/M
aggrandize/GLDS
aggrandizement/M
aggravate/GNXDS
aggravating/Y
aggravation/M
aggregate/MGNDSX
aggregation/M
aggression/M
aggressive/PY
aggressiveness/M
aggressor/SM
aggrieve/DSG
aggro
aghast
agile/Y
agility/M
aging/M
agitate/XGNDS
agitation/M
agitator/MS
agitprop/M
agleam
aglitter
aglow
agnostic/MS
agnosticism/M
ago
agog
agonist/S
agonize/GDS
agonizing/Y
agony/SM
agoraphobia/M
agoraphobic/MS
agrarian/MS
agrarianism/M
agree/EBLDS
agreeableness/EM
agreeably/E
agreeing/E
agreement/ESM
agribusiness/MS
agricultural/Y
agriculturalist/MS
agriculture/M
agriculturist/MS
agronomic
agronomist/MS
agronomy/M
aground
ague/M
ah
aha
ahchoo
ahead
ahem
ahoy
aid/SMDG
aide/SM
aided/U
aigrette/MS
ail/SDLG
aileron/SM
ailment/SM
aim/SMDG
aimless/YP
aimlessness/M
ain't
air/SMDJG
airbag/MS
airbase/SM
airbed/S
airborne
airbrush/MDSG
airbus/MS
aircraft/M
aircraftman
aircraftmen
aircrew/S
airdrome/S
airdrop/SM
airdropped
airdropping
airfare/SM
airfield/SM
airflow/M
airfoil/SM
airfreight/M
airguns
airhead/SM
airily
airiness/M
airing/M
airless/P
airlessness/M
airletters
airlift/SGMD
airline/RSMZ
airliner/M
airlock/SM
airmail/GSMD
airman/M
airmen
airplane/MS
airplay/M
airport/SM
airship/SM
airshow/S
airsick/P
airsickness/M
airspace/M
airspeed
airstrike/MS
airstrip/SM
airtight
airtime/M
airwaves/M
airway/MS
airwoman
airwomen
airworthiness/M
airworthy/P
airy/PTR
aisle/MS
aitch/MS
ajar
aka
akimbo
akin
alabaster/M
alack
alacrity/M
alarm/GMDS
alarming/Y
alarmist/SM
alas
alb/SM
albacore/SM
albatross/MS
albeit
albinism/M
albino/MS
album/MNS
albumen/M
albumin/M
albuminous
alchemist/SM
alchemy/M
alcohol/SM
alcoholic/MS
alcoholically
alcoholism/M
alcove/MS
alder/MS
alderman/M
aldermen
alderwoman/M
alderwomen
ale/SMV
aleatory
alehouse/SM
alembic/SM
alert/GMDYPS
alertness/M
alewife/M
alewives
alfalfa/M
alfresco
alga/M
algae
algal
algebra/SM
algebraic
algebraically
algorithm/SM
algorithmic
alias/GMDS
alibi/GMDS
alien/BGMDS
alienable/IU
alienate/DSGN
alienation/M
alienist/SM
alight/GDS
align/ALGDS
aligned/U
aligner/MS
alignment/AMS
alike/U
aliment/MDSG
alimentary
alimony/M
aliveness/M
aliyah/M
aliyahs
alkali/M
alkalies
alkaline
alkalinity/M
alkalize/DSG
alkaloid/SM
alkyd/MS
all/M
allay/GDS
allegation/MS
allege/GDS
alleged/Y
allegiance/MS
allegoric
allegorical/Y
allegorist/MS
allegory/SM
allegretto/MS
allegro/MS
allele/MS
alleluia/SM
allergen/SM
allergenic
allergic
allergically
allergist/SM
allergy/SM
alleviate/DSGN
alleviation/M
alley/MS
alleyway/SM
alliance/SM
alligator/MS
alliterate/DSXGNV
alliteration/M
alliterative/Y
allocate/ADSGN
allocation/AM
allocations
allot/LS
allotment/SM
allotted
allotting
allover
allow/EGDS
allowable/U
allowably
allowance/SM
alloy/GMDS
alloyed/U
allspice/M
allude/GDS
allure/MGLDS
allurement/MS
alluring/Y
allusion/SM
allusive/PY
allusiveness/M
alluvial/M
alluvium/SM
ally/GDSM
almanac/SM
almighty
almond/MS
almoner/SM
almost
alms/M
almshouse/MS
aloe/SM
aloft
aloha/MS
alone
along
alongshore
alongside
aloof/PY
aloofness/M
aloud
alp/SM
alpaca/MS
alpha/MS
alphabet/SM
alphabetic
alphabetical/Y
alphabetization/SM
alphabetize/ZGDRS
alphabetizer/M
alphanumeric
alphanumerical/Y
alpine/S
already
alright
also
alt/S
altar/MS
altarpiece/SM
alter/GDBS
alterable/U
alteration/MS
altercation/SM
altered/U
alternate/DSMYGNVX
alternation/M
alternative/MYS
alternator/SM
although
altimeter/MS
altitude/MS
alto/SM
altogether
altruism/M
altruist/SM
altruistic
altruistically
alum/SM
alumina/M
aluminum/M
alumna/M
alumnae
alumni
alumnus/M
alveolar/S
always
am/N
amalgam/SM
amalgamate/XGNDS
amalgamation/M
amanuenses
amanuensis/M
amaranth/M
amaranths
amaretto/M
amaryllis/MS
amass/GDS
amateur/SM
amateurish/YP
amateurishness/M
amateurism/M
amatory
amaze/LMGDS
amazement/M
amazing/Y
amazon/MS
amazonian
ambassador/SM
ambassadorial
ambassadorship/MS
ambassadress/MS
amber/M
ambergris/M
ambiance/MS
ambidexterity/M
ambidextrous/Y
ambient
ambiguity/SM
ambiguous/UY
ambit
ambition/MS
ambitious/YP
ambitiousness/M
ambivalence/M
ambivalent/Y
amble/MZGDRS
ambler/M
ambrosia/M
ambrosial
ambulance/MS
ambulanceman
ambulancemen
ambulancewoman
ambulancewomen
ambulant
ambulate/DSXGN
ambulation/M
ambulatory/SM
ambuscade/MGDS
ambush/GMDS
ameliorate/GNVDS
amelioration/M
amen/B
amenability/M
amenably
amend/BLGDS
amendment/SM
amenity/SM
amerce/GLDS
amercement/SM
americium/M
amethyst/SM
amiability/M
amiable
amiably
amicability/M
amicable
amicably
amid
amide/MS
amidship/S
amigo/MS
amino
amiss
amity/M
ammeter/SM
ammo/M
ammonia/M
ammonium
ammunition/M
amnesia/M
amnesiac/MS
amnesic/SM
amnesty/GDSM
amniocenteses
amniocentesis/M
amnion/MS
amniotic
amoeba/MS
amoebae
amoebic
amok
among
amontillado/SM
amoral/Y
amorality/M
amorous/YP
amorousness/M
amorphous/PY
amorphousness/M
amortization/SM
amortize/DSGB
amount/GMDS
amour/MS
amoxicillin
amp/SMY
amperage/M
ampere/MS
ampersand/MS
amphetamine/SM
amphibian/MS
amphibious/Y
amphitheater/SM
amphora/M
amphorae
ampicillin
ample/TR
amplification/M
amplifier/M
amplify/NDRSXZG
amplitude/SM
ampule/MS
amputate/GNDSX
amputation/M
amputee/MS
amt
amulet/MS
amuse/LGDS
amusement/MS
amusing/Y
amylase/M
an/CS
anabolism/M
anachronism/SM
anachronistic
anachronistically
anaconda/SM
anaerobe/SM
anaerobic
anaerobically
anagram/MS
anal/Y
analgesia/M
analgesic/SM
analog/MS
analogical/Y
analogize/GDS
analogous/YP
analogousness/M
analogue/SM
analogy/SM
analysand/MS
analyses/A
analysis/AM
analyst/SM
analytic
analytical/Y
analyzable
analyze/ADSG
analyzer/SM
anapest/SM
anapestic/MS
anarchic
anarchically
anarchism/M
anarchist/MS
anarchistic
anarchy/M
anathema/SM
anathematize/DSG
anatomic
anatomical/Y
anatomist/SM
anatomize/DSG
anatomy/SM
ancestor/SM
ancestral/Y
ancestress/MS
ancestry/SM
anchor/MDGS
anchorage/MS
anchorite/MS
anchorman/M
anchormen
anchorpeople
anchorperson/SM
anchorwoman/M
anchorwomen
anchovy/SM
ancient/SPMRYT
ancientness/M
ancillary/SM
and
andante/SM
andiron/SM
androgen/M
androgenic
androgynous
androgyny/M
android/SM
anecdotal/Y
anecdote/MS
anemia/M
anemic
anemically
anemometer/SM
anemone/SM
anent
anesthesia/M
anesthesiologist/SM
anesthesiology/M
anesthetic/SM
anesthetist/MS
anesthetization/M
anesthetize/GDS
aneurysm/SM
anew
angel/MS
angelfish/MS
angelic
angelica/M
angelical/Y
anger/GMDS
angina/M
angioplasty/SM
angiosperm/SM
angle/MZGDRS
angler/M
angleworm/MS
anglicism/S
anglicize/GDS
angling/M
anglophile/S
anglophone/S
angora/MS
angostura
angrily
angry/TR
angst/M
angstrom/MS
anguish/GMDS
angular
angularity/SM
angulation
anhydrous
aniline/M
animadversion/MS
animadvert/GSD
animal/MS
animalcule/SM
animate/ADSGN
animated/Y
animation/AM
animations
animator/MS
anime/M
animism/M
animist/SM
animistic
animosity/SM
animus/M
anion/MS
anionic
anise/M
aniseed/M
anisette/M
ankh/M
ankhs
ankle/MS
anklebone/MS
anklet/MS
annalist/SM
annals/M
anneal/GDS
annelid/MS
annex/GMDS
annexation/MS
annihilate/DSGN
annihilation/M
annihilator/SM
anniversary/SM
annotate/DSXGNV
annotation/M
annotator/MS
announce/DRSLZG
announced/U
announcement/MS
announcer/M
annoy/GDS
annoyance/MS
annoying/Y
annual/MYS
annualized
annuitant/SM
annuity/SM
annul/LS
annular
annulled
annulling
annulment/SM
annunciation/SM
anode/MS
anodize/GDS
anodyne/MS
anoint/GDLS
anointment/M
anomalous/Y
anomaly/SM
anon/S
anonymity/M
anonymous/Y
anopheles/M
anorak/MS
anorectic/SM
anorexia/M
anorexic/MS
another
answer/BMDGS
answerable/U
answered/U
answerphone/S
ant/SMD
antacid/SM
antagonism/SM
antagonist/SM
antagonistic
antagonistically
antagonize/DSG
antarctic
ante/SM
anteater/MS
antebellum
antecedence/M
antecedent/SM
antechamber/SM
antedate/GDS
antediluvian
anteing
antelope/MS
antenatal
antenna/SM
antennae
anterior
anteroom/MS
anthem/MS
anther/MS
anthill/SM
anthologist/SM
anthologize/DSG
anthology/SM
anthracite/M
anthrax/M
anthropocentric
anthropoid/MS
anthropological/Y
anthropologist/SM
anthropology/M
anthropomorphic
anthropomorphically
anthropomorphism/M
anthropomorphize
anthropomorphous
anti/SM
antiabortion
antiabortionist/MS
antiaircraft
antibacterial/MS
antibiotic/MS
antibody/SM
antic/MS
anticancer
anticipate/GNXDS
anticipated/U
anticipation/M
anticipatory
anticked
anticking
anticlerical
anticlimactic
anticlimactically
anticlimax/MS
anticline/SM
anticlockwise
anticoagulant/MS
anticommunism/M
anticommunist/SM
anticyclone/SM
anticyclonic
antidemocratic
antidepressant/MS
antidote/MS
antifascist/MS
antifreeze/M
antigen/SM
antigenic
antigenicity/M
antihero/M
antiheroes
antihistamine/SM
antiknock/M
antilabor
antilogarithm/SM
antimacassar/MS
antimalarial
antimatter/M
antimicrobial
antimissile
antimony/M
antinuclear
antioxidant/MS
antiparticle/SM
antipasti
antipasto/MS
antipathetic
antipathy/SM
antipersonnel
antiperspirant/SM
antiphon/SM
antiphonal/MYS
antipodal/S
antipodean/MS
antipodes/M
antipollution
antipoverty
antiquarian/SM
antiquarianism/M
antiquary/SM
antiquate/GDS
antique/DSMG
antiquity/SM
antirrhinum/S
antiscience
antisemitic
antisemitism/M
antisepsis/M
antiseptic/SM
antiseptically
antiserum/MS
antislavery
antisocial/Y
antispasmodic/MS
antisubmarine
antitank
antitheses
antithesis/M
antithetic
antithetical/Y
antitoxin/MS
antitrust
antivenin/MS
antivenom
antiviral/MS
antivirus
antivivisectionist/MS
antiwar
antler/MDS
antonym/SM
antonymous
antrum
antsy/TR
anus/MS
anvil/MS
anxiety/SM
anxious/YP
anxiousness/M
any
anybody/SM
anyhow
anymore
anyone/M
anyplace
anything/SM
anytime
anyway/S
anywhere
anywise
aorta/MS
aortic
apace
apart
apartheid/M
apartment/MS
apathetic
apathetically
apathy/M
apatite/M
ape/DSMG
apelike
aperitif/MS
aperture/SM
apex/MS
aphasia/M
aphasic/MS
aphelia
aphelion/SM
aphid/MS
aphorism/MS
aphoristic
aphoristically
aphrodisiac/SM
apiarist/SM
apiary/SM
apical/Y
apiece
apish/Y
aplenty
aplomb/M
apocalypse/SM
apocalyptic
apocrypha/M
apocryphal/Y
apogee/MS
apolitical/Y
apologetic/U
apologetically
apologia/SM
apologist/MS
apologize/GDS
apology/SM
apoplectic
apoplexy/SM
apoptosis
apoptotic
apostasy/SM
apostate/SM
apostatize/GDS
apostle/MS
apostleship/M
apostolic
apostrophe/MS
apothecary/SM
apothegm/SM
apotheoses
apotheosis/M
app/SM
appall/GDS
appalling/Y
appaloosa/MS
apparatchik/S
apparatus/MS
apparel/MDGS
apparent/Y
apparition/SM
appeal/GMDS
appealing/UY
appear/AESDG
appearance/EAMS
appease/LZGDRS
appeasement/SM
appeaser/M
appellant/SM
appellate/XN
appellation/M
append/GDS
appendage/SM
appendectomy/SM
appendices
appendicitis/M
appendix/MS
appertain/GDS
appetite/SM
appetizer/MS
appetizing/Y
applaud/ZGDRS
applauder/M
applause/M
apple/MS
applejack/M
applesauce/M
applet/MS
appliance/SM
applicability/M
applicable/I
applicably
applicant/SM
application/AM
applicator/SM
applier/MS
applique/DSM
appliqueing
apply/ANXGDS
appoint/AELSVGD
appointee/SM
appointment's/A
appointment/ESM
apportion/AGDLS
apportionment/AM
appose/GDS
apposite/YNVP
appositeness/M
apposition/M
appositive/SM
appraisal/AMS
appraise/ADSG
appraiser/MS
appreciable/I
appreciably/I
appreciate/DSXGNV
appreciated/U
appreciation/M
appreciative/Y
appreciator/MS
appreciatory
apprehend/GDS
apprehension/MS
apprehensive/YP
apprehensiveness/M
apprentice/DSMG
apprenticeship/MS
apprise/GDS
approach/GBMDS
approachable/UI
approbation/EM
approbations
appropriate/PYGNXDS
appropriated/U
appropriateness/IM
appropriation/M
appropriator/SM
approval/EM
approvals
approve/EGDS
approved/U
approving/EY
approx
approximate/DSXYGN
approximation/M
appurtenance/SM
appurtenant
apricot/MS
apron/MS
apropos
apse/SM
apt/IYPT
apter
aptitude/SM
aptness/IM
aqua/SM
aquaculture/M
aqualung/MS
aquamarine/SM
aquanaut/MS
aquaplane/MGDS
aquarium/MS
aquatic/SM
aquatically
aquatics/M
aquatint/S
aquavit/M
aqueduct/MS
aqueous
aquifer/SM
aquiline
arabesque/MS
arability/M
arachnid/MS
arachnophobia
arbiter/SM
arbitrage/MZGDRS
arbitrager/M
arbitrageur/SM
arbitrament/SM
arbitrarily
arbitrariness/M
arbitrary/P
arbitrate/GNDS
arbitration/M
arbitrator/MS
arbor/MS
arboreal
arboretum/SM
arborvitae/SM
arbutus/MS
arc/SMDG
arcade/MS
arcane
arch/PZTGVMDRSY
archaeological/Y
archaeologist/SM
archaeology/M
archaic
archaically
archaism/MS
archaist/MS
archangel/MS
archbishop/SM
archbishopric/SM
archdeacon/SM
archdiocesan
archdiocese/MS
archduchess/MS
archduke/MS
archenemy/SM
archer/M
archery/M
archetypal
archetype/MS
archfiend/MS
archiepiscopal
archipelago/MS
architect/SM
architectonic/S
architectonics/M
architectural/Y
architecture/MS
architrave/SM
archival
archive/DSMG
archivist/MS
archness/M
archway/SM
arctic/MS
ardent/Y
ardor/MS
arduous/YP
arduousness/M
are/SMB
area/SM
areal
aren't
arena/MS
argent/M
arginine
argon/M
argosy/SM
argot/MS
arguable/IU
arguably/U
argue/ZGDRS
arguer/M
argument/MS
argumentation/M
argumentative/PY
argumentativeness/M
argyle/MS
aria/SM
arid/Y
aridity/M
aright
arise/GS
arisen
aristocracy/SM
aristocrat/SM
aristocratic
aristocratically
arithmetic/M
arithmetical/Y
arithmetician/MS
ark/SM
arm's
arm/EAGDS
armada/MS
armadillo/SM
armament/AEM
armaments
armature/MS
armband/MS
armchair/MS
armed/U
armful/MS
armhole/SM
armistice/SM
armlet/MS
armload/S
armor/ZGMDRS
armored/U
armorer/M
armorial
armory/SM
armpit/MS
armrest/SM
army/SM
aroma/MS
aromatherapist/MS
aromatherapy/M
aromatic/MS
aromatically
arose
around
arousal/M
arouse/GDS
arpeggio/MS
arr
arraign/DGSL
arraignment/SM
arrange/AESDLG
arrangement's/E
arrangement/ASM
arranger/SM
arrant
arras/MS
array/EGMDS
arrears/M
arrest/AGMDS
arrhythmia/M
arrhythmic
arrhythmical
arrival/MS
arrive/GDS
arrogance/M
arrogant/Y
arrogate/GNDS
arrogation/M
arrow/MS
arrowhead/MS
arrowroot/M
arroyo/MS
arsed
arsenal/MS
arsenic/M
arsing
arson/M
arsonist/SM
art/SM
arterial
arteriole/MS
arteriosclerosis/M
artery/SM
artful/PY
artfulness/M
arthritic/MS
arthritis/M
arthropod/MS
arthroscope/SM
arthroscopic
arthroscopy
artichoke/SM
article/MDS
articulacy/I
articular
articulate/YGNPDSX
articulateness/IM
articulation/M
artifact/SM
artifice/RSMZ
artificer/M
artificial/Y
artificiality/M
artillery/M
artilleryman/M
artillerymen
artiness/M
artisan/MS
artist/MS
artiste/MS
artistic/I
artistically
artistry/M
artless/PY
artlessness/M
artsy/TR
artwork/MS
arty/PTR
arugula
arum/SM
asap
asbestos/M
ascend/AGDS
ascendance/M
ascendancy/M
ascendant/SM
ascension/MS
ascent/MS
ascertain/GDSBL
ascertainment/M
ascetic/MS
ascetically
asceticism/M
ascot/MS
ascribe/GBDS
ascription/M
aseptic
aseptically
asexual/Y
asexuality/M
ash/MDNSG
ashamed/UY
ashcan/MS
ashlar/MS
ashore
ashram/MS
ashtray/SM
ashy/TR
aside/MS
asinine/Y
asininity/SM
ask/SDG
askance
asked/U
askew
aslant
asleep
asocial
asp/SMNX
asparagus/M
aspartame/M
aspect/MS
aspen/M
asperity/SM
aspersion/MS
asphalt/MDGS
asphodel/SM
asphyxia/M
asphyxiate/DSXGN
asphyxiation/M
aspic/MS
aspidistra/MS
aspirant/MS
aspirate/MGNDSX
aspiration/M
aspirator/SM
aspire/GDS
aspirin/MS
ass/MS
assail/GBDS
assailable/U
assailant/SM
assassin/SM
assassinate/GNXDS
assassination/M
assault/MDRGS
assay/ZGMDRS
assayer/M
assemblage/SM
assemble/AEGSD
assembler/MS
assemblies
assembly/AM
assemblyman/M
assemblymen
assemblywoman/M
assemblywomen
assent/GMDS
assert/AGVDS
assertion/AM
assertions
assertive/YP
assertiveness/M
assess/ALGDS
assessment/ASM
assessor/MS
asset/MS
asseverate/DSGN
asseveration/M
asshole/MS!
assiduity/M
assiduous/PY
assiduousness/M
assign's
assign/ALGDS
assignable
assignation/MS
assigned/U
assignee/M
assigner/MS
assignment/AMS
assignor/MS
assimilate/DSGN
assimilation/M
assist/GMDS
assistance/M
assistant/SM
assisted/U
assize/MS
assn
assoc
associate's
associate/EDSGNV
association/EM
associations
assonance/M
assonant/MS
assort/GLDS
assortment/MS
asst
assuage/GDS
assume/BGDS
assumption/SM
assumptive
assurance/ASM
assure/AGDS
assured/MYS
astatine/M
aster/EMS
asterisk/GMDS
astern
asteroid/MS
asthma/M
asthmatic/SM
asthmatically
astigmatic
astigmatism/SM
astir
astonish/DSLG
astonishing/Y
astonishment/M
astound/GDS
astounding/Y
astraddle
astrakhan/M
astral
astray
astride
astringency/M
astringent/SMY
astrolabe/SM
astrologer/SM
astrological/Y
astrologist/MS
astrology/M
astronaut/MS
astronautic/S
astronautical
astronautics/M
astronomer/SM
astronomic
astronomical/Y
astronomy/M
astrophysical
astrophysicist/MS
astrophysics/M
astute/PYTR
astuteness/M
asunder
asylum/SM
asymmetric
asymmetrical/Y
asymmetry/SM
asymptomatic
asymptotic
asymptotically
asynchronous/Y
at
atavism/M
atavist/SM
atavistic
ataxia/M
ataxic/MS
ate
atelier/SM
atheism/M
atheist/MS
atheistic
atherosclerosis/M
atherosclerotic
athirst
athlete/MS
athletic/S
athletically
athleticism
athletics/M
athwart
atilt
atishoo
atlas/MS
atmosphere/MS
atmospheric/S
atmospherically
atmospherics/M
atoll/MS
atom/SM
atomic
atomically
atomize/ZGDRS
atomizer/M
atonal/Y
atonality/M
atone/LGDS
atonement/M
atop
atria
atrial
atrioventricular
atrium/M
atrocious/PY
atrociousness/M
atrocity/SM
atrophy/DSMG
atropine/M
attach/ALGDS
attache/BM
attached/U
attachment/AM
attachments
attack/ZGMDRS
attacker/M
attain/AGDS
attainability/M
attainable/U
attainder/M
attainment/SM
attar/M
attempt's
attempt/ASDG
attend/SDRZG
attendance/SM
attendant/SM
attended/U
attendee/SM
attention/IM
attentions
attentive/IPY
attentiveness/IM
attenuate/DSGN
attenuation/M
attest/SDG
attestation/SM
attested/U
attic/SM
attire/DSMG
attitude/SM
attitudinal
attitudinize/GDS
attn
attorney/MS
attract/SGVDB
attractant/MS
attraction/MS
attractive/UY
attractiveness/M
attribute/DSMGNVBX
attributed/U
attribution/M
attributive/MYS
attrition/M
attune/DSG
atty
atwitter
atypical/Y
aubergine/S
auburn/M
auction/MDGS
auctioneer/SM
audacious/YP
audaciousness/M
audacity/M
audibility/IM
audible/MS
audibly/I
audience/MS
audio/MS
audiological
audiologist/SM
audiology/M
audiometer/SM
audiophile/SM
audiotape/SM
audiovisual/S
audiovisuals/M
audit/GMDS
audition/SMDG
auditor/MS
auditorium/SM
auditory
auger/MS
aught/MS
augment/DRZGS
augmentation/MS
augmentative
augmenter/M
augur/GMDS
augury/SM
august/PTRY
augustness/M
auk/SM
aunt/SM
auntie/SM
aura/MS
aural/Y
aureole/SM
aureus
auricle/SM
auricular
aurora/SM
auscultate/GNDSX
auscultation/M
auspice/SM
auspicious/IY
auspiciousness/M
austere/RYT
austerity/SM
austral
authentic/IU
authentically
authenticate/XGNDS
authenticated/U
authentication/M
authenticity/M
author/SMDG
authoress/MS
authorial
authoritarian/MS
authoritarianism/M
authoritative/YP
authoritativeness/M
authority/SM
authorization/MS
authorize/AGDS
authorized/U
authorship/M
autism/M
autistic
auto/MS
autobahn/SM
autobiographer/SM
autobiographic
autobiographical/Y
autobiography/SM
autoclave/MS
autocracy/SM
autocrat/SM
autocratic
autocratically
autocross
autodidact/SM
autograph/MDG
autographs
autoimmune
autoimmunity/M
automaker/SM
automate/GNDS
automatic/SM
automatically
automation/M
automatism/M
automatize/GDS
automaton/SM
automobile/DSMG
automotive
autonomic
autonomous/Y
autonomy/M
autopilot/SM
autopsy/GDSM
autosuggestion
autoworker/MS
autumn/SM
autumnal
aux
auxiliary/SM
auxin/M
av/RZ
avail/BGMDS
availability/UM
available/U
avalanche/SM
avarice/M
avaricious/Y
avast
avatar/MS
avaunt
avdp
ave
avenge/ZGDRS
avenger/M
avenue/MS
average/MYGDS
averred
averring
averse/XN
aversion/M
avert/GDS
avg
avian
aviary/SM
aviation/M
aviator/MS
aviatrices
aviatrix/MS
avid/Y
avidity/M
avionic/S
avionics/M
avitaminosis/M
avocado/SM
avocation/MS
avocational
avoid/SDGB
avoidable/U
avoidably/U
avoidance/M
avoirdupois/M
avouch/DSG
avow/EDGS
avowal/ESM
avowed/Y
avuncular/Y
aw
await/GDS
awake/GS
awaken/AGDS
awakening/SM
award/GMDS
awardee/S
aware/UP
awareness/UM
awash
away
awe/DSMG
aweigh
awesome/YP
awesomeness/M
awestruck
awful/YP
awfuller
awfullest
awfulness/M
awhile
awkward/RYPT
awkwardness/M
awl/SM
awn/GJSM
awning/M
awoke
awoken
awry
ax/MDSG
axial/Y
axiom/SM
axiomatic
axiomatically
axis/M
axle/MS
axletree/SM
axolotl/SM
axon/MS
ayah/M
ayahs
ayatollah/M
ayatollahs
aye/SM
azalea/SM
azimuth/M
azimuths
azure/SM
b/KDT
baa/SMDG
babble/MZGDRS
babbler/M
babe/SM
babel/MS
baboon/MS
babushka/SM
baby/TGDRSM
babyhood/M
babyish
babysat
babysit/S
babysitter/MS
babysitting/M
baccalaureate/SM
baccarat/M
bacchanal/MS
bacchanalia/M
bacchanalian/MS
baccy
bachelor/SM
bachelorhood/M
bacillary
bacilli
bacillus/M
back/SJZGMDR
backache/MS
backbench/S
backbit
backbite/ZGRS
backbiter/M
backbitten
backboard/SM
backbone/MS
backbreaking
backchat
backcloth
backcloths
backcomb/DSG
backdate/GDS
backdoor
backdrop/MS
backer/M
backfield/SM
backfire/MGDS
backgammon/M
background/MRZS
backgrounder/M
backhand/MDRSZG
backhanded/Y
backhander/M
backhoe/MS
backing/M
backlash/MS
backless
backlog/MS
backlogged
backlogging
backpack/ZGMDRS
backpacker/M
backpacking/M
backpedal/SDG
backrest/SM
backroom/S
backscratching/M
backseat/SM
backside/SM
backslapper/SM
backslapping/M
backslash/MS
backslid
backslide/RSZG
backslider/M
backspace/DSMG
backspin/M
backstabber/MS
backstabbing
backstage/M
backstair/S
backstop/SM
backstopped
backstopping
backstory/S
backstreet/S
backstretch/MS
backstroke/MGDS
backtalk/M
backtrack/SDG
backup/MS
backward/PSY
backwardness/M
backwash/M
backwater/SM
backwoods/M
backwoodsman/M
backwoodsmen
backyard/SM
bacon/M
bacteria/M
bacterial
bactericidal
bactericide/SM
bacteriologic
bacteriological
bacteriologist/SM
bacteriology/M
bacterium/M
bad/MYP
badder
baddest
baddie/MS
bade
badge/MZRS
badger/GMD
badinage/M
badlands/M
badman/M
badmen
badminton/M
badmouth/GD
badmouths
badness/M
baffle/MZGDRSL
bafflement/M
baffler/M
bag/SM
bagatelle/SM
bagel/MS
bagful/MS
baggage/M
bagged
baggie/M
baggily
bagginess/M
bagging
baggy/PTRS
bagpipe/MZRS
bagpiper/M
baguette/MS
bah
baht/SM
bail/SBGMD
bailey/S
bailiff/S
bailiwick/MS
bailout/SM
bailsman/M
bailsmen
bairn/MS
bait/SGMD
baize/M
bake/DRSMZG
baked/U
baker/M
bakery/SM
bakeshop/MS
baklava/M
baksheesh/M
balaclava/MS
balalaika/MS
balance's
balance/UDSG
balboa/SM
balcony/SM
bald/STGPDRY
balderdash/M
baldfaced
baldness/M
baldric/SM
baldy/S
bale/DRSMZG
baleen/M
baleful/PY
balefulness/M
baler/M
balk/SGMD
balky/RT
ball/SGMD
ballad/SM
balladeer/MS
balladry/M
ballast/GSMD
ballcock/MS
ballerina/SM
ballet/SM
balletic
ballgame/MS
ballgirl/S
ballgown/S
ballistic/S
ballistics/M
balloon/SGMD
balloonist/MS
ballot/SMDG
ballpark/MS
ballplayer/MS
ballpoint/MS
ballroom/MS
balls/DSG
ballsy/RT
bally
ballyhoo/SMDG
balm/SM
balminess/M
balmy/RTP
baloney/M
balsa/MS
balsam/SM
balsamic
baluster/SM
balustrade/MS
bamboo/SM
bamboozle/DSG
ban/SM
banal/Y
banality/SM
banana/SM
band's
band/ESGD
bandage/DSMG
bandanna/MS
bandbox/MS
bandeau/M
bandeaux
bandit/SM
banditry/M
bandleader/S
bandmaster/SM
bandoleer/SM
bandsman/M
bandsmen
bandstand/SM
bandwagon/SM
bandwidth
bandwidths
bandy/DRSTG
bane/SM
baneful
bang/SGMDR
bangle/SM
bani
banish/GLDS
banishment/M
banister/SM
banjo/MS
banjoist/SM
bank/SZGBMDR
bankbook/SM
bankcard/SM
banker/M
banking/M
banknote/SM
bankroll/SGMD
bankrupt/SGMD
bankruptcy/SM
banned
banner/SM
banning
bannock/MS
banns/M
banquet/ZGMDRS
banqueter/M
banquette/SM
banshee/MS
bantam/SM
bantamweight/SM
banter/GSMD
bantering/Y
banyan/SM
banzai/SM
baobab/SM
bap/S
baptism/MS
baptismal
baptist/S
baptistery/SM
baptize/ZGDRS
baptized/U
baptizer/M
bar's
bar/ECUTS
barb/SZGMDR
barbacoa
barbarian/SM
barbarianism/MS
barbaric
barbarically
barbarism/SM
barbarity/SM
barbarize/DSG
barbarous/Y
barbecue/DSMG
barbel/SM
barbell/MS
barber/GMD
barberry/SM
barbershop/MS
barbie/S
barbiturate/SM
barbwire/M
barcarole/SM
bard/SM
bardic
bare/DRSPYG
bareback/D
barefaced/Y
barefoot/D
barehanded
bareheaded
barelegged
bareness/M
barf/SGMDY
barfly/SM
bargain/MDRZGS
bargainer/M
barge/MGDS
bargeman/M
bargemen
barhop/S
barhopped
barhopping
barista/MS
baritone/MS
barium/M
bark's
bark/CSGD
barkeep/ZMRS
barkeeper/M
barker/SM
barley/M
barmaid/MS
barman/M
barmen
barmy/RT
barn/SM
barnacle/MDS
barney/S
barnstorm/SDRZG
barnstormer/M
barnyard/SM
barometer/MS
barometric
barometrically
baron/MS
baronage/MS
baroness/MS
baronet/MS
baronetcy/SM
baronial
barony/SM
baroque/M
barque/SM
barrack/MDGS
barracuda/SM
barrage/MGDS
barre/MGJDS
barred/UEC
barrel/GSMD
barren/TPSMR
barrenness/M
barrette/SM
barricade/MGDS
barrier/MS
barring/ECU
barrio/SM
barrister/MS
barroom/MS
barrow/SM
bartender/SM
barter/ZGSMDR
barterer/M
baryon/SM
basal/Y
basalt/M
basaltic
base's
base/CDSLTG
baseball/SM
baseboard/MS
baseless
baseline/MS
basely
baseman/M
basemen
basement/CMS
baseness/M
baser
bash/GMDS
bashful/PY
bashfulness/M
bashing/M
basic/MS
basically
basil/M
basilica/MS
basilisk/MS
basin/MS
basinful/MS
basis/M
bask/SGD
basket/SM
basketball/MS
basketry/M
basketwork/M
basque/S
bass/MS
basset/SM
bassinet/MS
bassist/MS
basso/MS
bassoon/MS
bassoonist/SM
basswood/MS
bast/M
bastard/MS
bastardization/MS
bastardize/GDS
bastardy/M
baste/ZGNXDRS
baster/M
bastion/M
bat/SM
batch/MDSG
bate/KACGSD
bath/ZGMDRS
bathe/M
bather/M
bathetic
bathhouse/MS
bathing/M
bathmat/MS
bathos/M
bathrobe/SM
bathroom/SM
baths
bathtub/MS
bathwater
bathyscaphe/SM
bathysphere/MS
batik/MS
batiste/M
batman/M
batmen
baton/MS
batsman/M
batsmen
battalion/SM
batted
batten/GSMD
batter/JZGSMDR
batterer/M
battery/SM
batting/M
battle/LDRSMZG
battleaxe/MS
battledore/SM
battledress
battlefield/MS
battlefront/MS
battleground/MS
battlement/SM
battler/M
battleship/SM
batty/RT
bauble/SM
baud/SM
bauxite/M
bawd/SM
bawdily
bawdiness/M
bawdy/PRT
bawl/SGMD
bay/SMDG
bayberry/SM
bayonet/SMDG
bayou/MS
bazaar/SM
bazillion/S
bazooka/SM
bbl
bdrm
be
beach/MDSG
beachcomber/SM
beachfront
beachhead/MS
beachwear/M
beacon/SM
bead/SGMD
beading/M
beadle/SM
beady/RT
beagle/SM
beak/SZMDR
beaker/M
beam/SGMD
bean/SGMD
beanbag/MS
beanfeast/S
beanie/SM
beanpole/MS
beansprout/S
beanstalk/MS
bear/SZGBJMR
bearable/U
bearably/U
beard/MDGS
beardless
bearer/M
bearing/M
bearish/PY
bearishness/M
bearlike
bearskin/MS
beast/MS
beastliness/M
beastly/TPRM
beat/SZGBMNRJ
beatable/U
beaten/U
beater/M
beatific
beatifically
beatification/M
beatify/GXNDS
beating/M
beatitude/SM
beatnik/MS
beau/SM
beaut/MS
beauteous/Y
beautician/SM
beautification/M
beautifier/M
beautiful/Y
beautify/NDRSZG
beauty/SM
beaver/SGMD
bebop/MS
becalm/GSD
became
because
beck/SM
beckon/SGD
becloud/GDS
become/S
becoming/UY
becquerel/S
bed/SM
bedaub/GSD
bedazzle/GDSL
bedazzlement/M
bedbug/SM
bedchamber/S
bedclothes/M
bedded
bedder
bedding/M
bedeck/GSD
bedevil/LGDS
bedevilment/M
bedfellow/SM
bedhead/S
bedim/S
bedimmed
bedimming
bedizen/GDS
bedlam/SM
bedpan/SM
bedpost/SM
bedraggle/GDS
bedridden
bedrock/SM
bedroll/SM
bedroom/SM
bedside/SM
bedsit/S
bedsitter/S
bedsore/SM
bedspread/SM
bedstead/SM
bedtime/SM
bee/RSMZGJ
beebread/M
beech/MS
beechnut/MS
beef/SGMD
beefburger/SM
beefcake/MS
beefiness/M
beefsteak/MS
beefy/RPT
beehive/MS
beekeeper/MS
beekeeping/M
beeline/MS
been
beep/SZGMDR
beeper/M
beer/M
beery/TR
beeswax/M
beet/SM
beetle/MGDS
beetroot/S
beeves
befall/SGN
befell
befit/S
befitted
befitting/Y
befog/S
befogged
befogging
before
beforehand
befoul/DGS
befriend/SGD
befuddle/GLDS
befuddlement/M
beg/S
began
begat
beget/S
begetter/S
begetting
beggar/MDYGS
beggary/M
begged
begging
begin/S
beginner/SM
beginning/MS
begone
begonia/SM
begot
begotten
begrime/DSG
begrudge/DSG
begrudging/Y
beguile/DRSZGL
beguilement/M
beguiler/M
beguiling/Y
beguine/SM
begum/MS
begun
behalf/M
behalves
behave/GDS
behavior/SM
behavioral/Y
behaviorism/M
behaviorist/MS
behead/DGS
beheld
behemoth/M
behemoths
behest/MS
behind/MS
behindhand
behold/NRZGS
beholder/M
behoove/DSG
beige/M
being/M
bejewel/SDG
belabor/SDG
belated/Y
belay/GDS
belch/GMDS
beleaguer/GSD
belfry/SM
belie/DS
belief/EUM
beliefs
believable/U
believably/U
believe/EDRSZG
believer/EUMS
believing/U
belittle/LDSG
belittlement/M
bell/SGMD
belladonna/M
bellboy/SM
belle/MS
belled/A
belletrist/MS
belletristic
bellhop/SM
bellicose
bellicosity/M
belligerence/M
belligerency/M
belligerent/MYS
belling/A
bellman/M
bellmen
bellow/MDGS
bellwether/MS
belly/GDSM
bellyache/MGDS
bellybutton/SM
bellyful/MS
belong/JDGS
belonging/M
beloved/SM
below
belt/SGMD
beltway/SM
beluga/MS
belying
bemire/GDS
bemoan/DGS
bemuse/LGDS
bemused/Y
bemusement/M
bench/GMDS
benchmark/MS
bend/BSZGMR
bender/M
bendy/TR
beneath
benedictine
benediction/SM
benedictory
benefaction/SM
benefactor/MS
benefactress/MS
benefice/SM
beneficence/M
beneficent/Y
beneficial/Y
beneficiary/SM
benefit/SMDG
benevolence/SM
benevolent/Y
benighted/Y
benign/Y
benignant
benignity/M
bent/SM
bentwood/M
benumb/DSG
benzene/M
benzine/M
benzyl
bequeath/DG
bequeaths
bequest/MS
berate/GDS
bereave/DSLG
bereavement/MS
bereft
beret/MS
berg/SM
beriberi/M
berk/S
berkelium/M
berm/SM
berry/GDSM
berrylike
berserk
berth/GMD
berths
beryl/MS
beryllium/M
beseech/ZGRS
beseecher/M
beseeching/Y
beseem/DSG
beset/S
besetting
beside/S
besiege/ZGDRS
besieger/M
besmear/DSG
besmirch/GDS
besom/MS
besot/S
besotted
besotting
besought
bespangle/DSG
bespatter/GSD
bespeak/SG
bespectacled
bespoke
bespoken
best/SGMD
bestial/Y
bestiality/M
bestiary/SM
bestir/S
bestirred
bestirring
bestow/DGS
bestowal/SM
bestrew/SDG
bestrewn
bestridden
bestride/SG
bestrode
bestseller/MS
bestselling
bet/SM
beta/SM
betake/GS
betaken
betcha
betel/M
bethink/SG
bethought
betide/GDS
betimes
betoken/GDS
betook
betray/DRZGS
betrayal/SM
betrayer/M
betroth/DG
betrothal/SM
betrothed/M
betroths
better/MDGLS
betterment/M
betting
bettor/MS
between
betwixt
bevel/GMDS
beverage/SM
bevvy/S
bevy/SM
bewail/DGS
beware/GDS
bewhiskered
bewigged
bewilder/LSGD
bewildering/Y
bewilderment/M
bewitch/GLDS
bewitching/Y
bewitchment/M
bey/SM
beyond
bezel/MS
bf
bhaji
bi/SMRZ
biannual/Y
bias/GMDS
biased/U
biathlon/SM
bib/SM
bible/MS
biblical
bibliographer/MS
bibliographic
bibliographical/Y
bibliography/SM
bibliophile/SM
bibulous
bicameral
bicameralism/M
bicarb/MS
bicarbonate/MS
bicentenary/SM
bicentennial/SM
bicep/MS
biceps/M
bicker/MDRZGS
bickerer/M
biconcave
biconvex
bicuspid/MS
bicycle/DRSMZG
bicycler/M
bicyclist/SM
bid/SMG
biddable
bidden/U
bidder/MS
bidding/M
biddy/SM
bide/S
bidet/MS
bidirectional/Y
biennial/MYS
biennium/MS
bier/M
biff/SGD
bifocal/S
bifocals/M
bifurcate/XDSGN
bifurcation/M
big/P
bigamist/SM
bigamous
bigamy/M
bigger
biggest
biggie/MS
biggish
bighead/SM
bighearted/P
bigheartedness/M
bighorn/SM
bight/MS
bigmouth/M
bigmouths
bigness/M
bigot/MDS
bigotry/SM
bigwig/MS
bijou/M
bijoux
bike/DRSMZG
biker/M
bikini/MS
bilabial/MS
bilateral/Y
bilberry/S
bile/M
bilge/MS
bilingual/SMY
bilingualism/M
bilious/P
biliousness/M
bilirubin
bilk/SZGDR
bilker/M
bill/SBJGMD
billboard/MS
billet/GMDS
billfold/SM
billhook/S
billiard/S
billiards/M
billing/M
billingsgate/M
billion/MHS
billionaire/SM
billionth/M
billionths
billow/GMDS
billowy
billy/SM
billycan/S
bimbo/MS
bimetallic/SM
bimetallism/M
bimonthly/SM
bin/SM
binary/SM
bind's
bind/AUGS
binder/MS
bindery/SM
binding/MS
bindweed/M
binge/MDS
bingo/M
binman
binmen
binnacle/SM
binned
binning
binocular/MS
binomial/SM
bio/SM
biochemical/SMY
biochemist/MS
biochemistry/M
biodegradability/M
biodegrade/DSGB
biodiversity/M
bioethics/M
biofeedback/M
biog
biographer/SM
biographic
biographical/Y
biography/SM
biol
biologic
biological/Y
biologist/MS
biology/M
biomass/M
biomedical
bionic/S
bionically
bionics/M
biophysical
biophysicist/MS
biophysics/M
biopic/MS
biopsy/GDSM
bioreactor/S
biorhythm/MS
biosensor/S
biosphere/SM
biosynthesis
biotech
biotechnological
biotechnology/M
biotin/M
bipartisan
bipartisanship/M
bipartite
biped/MS
bipedal
biplane/MS
bipolar
bipolarity/M
biracial
birch/GMDS
bird/SZGMDR
birdbath/M
birdbaths
birdbrain/SMD
birdcage/S
birder/M
birdhouse/MS
birdie/MDS
birdieing
birdlike
birdlime/M
birdseed/M
birdsong
birdwatcher/SM
birdying
biretta/SM
birth/ZGMDR
birthday/MS
birther/M
birthmark/MS
birthplace/MS
birthrate/MS
birthright/MS
births/A
birthstone/SM
biscuit/SM
bisect/DGS
bisection/MS
bisector/SM
bisexual/MYS
bisexuality/M
bishop/MS
bishopric/SM
bismuth/M
bison/M
bisque/M
bistro/MS
bit/CSMG
bitch/GMDS
bitchily
bitchiness/M
bitchy/PRT
bitcoin/SM
bite/RSMZ
biter/M
biting/Y
bitmap/S
bitten
bitter/PMRYTS
bittern/SM
bitterness/M
bitters/M
bittersweet/MS
bitty/TR
bitumen/M
bituminous
bivalent
bivalve/SM
bivouac/MS
bivouacked
bivouacking
biweekly/SM
biyearly
biz/M
bizarre/Y
bk
bl/DG
blab/SM
blabbed
blabber/DGS
blabbermouth/M
blabbermouths
blabbing
black/PXTGMDNRYS
blackamoor/MS
blackball/SGMD
blackberry/GSM
blackbird/SM
blackboard/MS
blackcurrant/S
blacken/DG
blackface
blackguard/SM
blackhead/MS
blacking/M
blackish
blackjack/MDGS
blackleg/S
blacklist/MDSG
blackmail/MDRSZG
blackmailer/M
blackness/M
blackout/SM
blacksmith/M
blacksmiths
blacksnake/SM
blackthorn/SM
blacktop/SM
blacktopped
blacktopping
bladder/MS
blade/MDS
blag/S
blagged
blagging
blah/M
blahs/M
blame/BMGDRS
blameless/YP
blamelessness/M
blameworthiness/M
blameworthy/P
blammo
blanch/GDS
blancmange/MS
bland/PTRY
blandish/DSLG
blandishment/SM
blandness/M
blank/TGPMDRYS
blanket/GMDS
blankness/M
blare/MGDS
blarney/SMDG
blase
blaspheme/ZGDRS
blasphemer/M
blasphemous/Y
blasphemy/SM
blast/ZGMDRS
blaster/M
blastoff/MS
blat/S
blatancy/SM
blatant/Y
blather/SMDG
blaze/MZGDRS
blazer/M
blazon/MDGS
bldg
bleach/MDRSZG
bleached/U
bleacher/M
bleak/TPRY
bleakness/M
blear
blearily
bleariness/M
bleary/PRT
bleat/GMDS
bleed/ZGRS
bleeder/M
bleeding/M
bleep/ZGMDRS
bleeper/M
blemish/GMDS
blemished/U
blench/DSG
blend/ZGMDRS
blender/M
bless/GDSJ
blessed/YP
blessedness/M
blessing/M
bletch
blew
blight/ZGMDRS
blimey
blimp/MS
blimpish
blind/PZTGMDRYS
blinder/M
blindfold/SMDG
blinding/Y
blindness/M
blindside/DSG
blini/MS
blink/ZGMDRS
blinker/MDG
blintz/MS
blintze/M
blip/SM
bliss/M
blissful/YP
blissfulness/M
blister/GMDS
blistering/Y
blistery
blithe/PYTR
blitheness/M
blither/G
blithesome
blitz/GMDS
blitzkrieg/MS
blivet/S
blizzard/SM
bloat/ZGDRS
bloatware
blob/SM
blobbed
blobbing
bloc/SM
block's
block/UGDS
blockade/MZGDRS
blockader/M
blockage/MS
blockbuster/SM
blockbusting/M
blocker/MS
blockhead/SM
blockhouse/MS
blog/SM
blogged
blogger/MS
blogging
bloke/MS
blokish
blond/PTMRS
blonde/MS
blondish
blondness/M
blood/GMDS
bloodbath/M
bloodbaths
bloodcurdling
bloodhound/SM
bloodily
bloodiness/M
bloodless/YP
bloodlessness/M
bloodletting/M
bloodline/SM
bloodmobile/MS
bloodshed/M
bloodshot
bloodstain/SMD
bloodstock/M
bloodstream/SM
bloodsucker/SM
bloodsucking
bloodthirstily
bloodthirstiness/M
bloodthirsty/RPT
bloody/PTGDRS
bloom/ZGMDRS
bloomer/M
bloop/ZGMDRS
blooper/M
blossom/GMDS
blossomy
blot/SM
blotch/GMDS
blotchy/TR
blotted
blotter/MS
blotting
blotto
blouse/MGDS
blow/SZGMR
blower/M
blowfly/SM
blowgun/MS
blowhard/MS
blowhole/S
blowjob
blowlamp/S
blown
blowout/SM
blowpipe/SM
blowtorch/MS
blowup/MS
blowy/TR
blowzy/RT
blubber/GSMD
blubbery
bludgeon/MDGS
blue/DRSPMTG
bluebell/MS
blueberry/SM
bluebird/MS
bluebonnet/SM
bluebottle/SM
bluefish/MS
bluegill/MS
bluegrass/M
blueish
bluejacket/SM
bluejeans/M
blueness/M
bluenose/MS
bluepoint/MS
blueprint/MDGS
bluestocking/SM
bluesy/RT
bluet/MS
bluff/ZTGPMDRYS
bluffer/M
bluffness/M
bluing/M
bluish
blunder/MDRZGS
blunderbuss/MS
blunderer/M
blunt/PTGDRYS
bluntness/M
blur/SM
blurb/MS
blurred
blurriness/M
blurring
blurry/TRP
blurt/GDS
blush/ZGMDRS
blusher/M
bluster/MDRSZG
blusterer/M
blusterous
blustery
blvd
boa/SM
boar/SM
board/ZGMDRS
boarder/M
boarding/M
boardinghouse/MS
boardroom/MS
boardwalk/MS
boast/ZGMDRS
boaster/M
boastful/PY
boastfulness/M
boat/SZGMDR
boater/M
boathouse/MS
boating/M
boatload/S
boatman/M
boatmen
boatswain/SM
boatyard/S
bob/SM
bobbed
bobbin/MS
bobbing
bobble/MGDS
bobby/SM
bobbysoxer/SM
bobcat/MS
bobolink/SM
bobsled/SM
bobsledded
bobsledder/MS
bobsledding
bobsleigh/M
bobsleighs
bobtail/SM
bobwhite/MS
boccie/M
bock/M
bod/SMDG
bodacious
bode/S
bodega/MS
bodge/GDS
bodice/MS
bodily
bodkin/MS
body/DSM
bodybuilder/SM
bodybuilding/M
bodyguard/MS
bodysuit/SM
bodywork/M
boffin/S
boffo
bog/SM
boga
bogey/GMDS
bogeyman/M
bogeymen
bogged
bogging
boggle/GDS
boggy/TR
bogie/MS
bogon
bogosity
bogus
bogyman/M
bogymen
bohemian/SM
bohemianism/M
boil/SJZGMDR
boiler/M
boilermaker/SM
boilerplate/M
boink/GDS
boisterous/YP
boisterousness/M
bola/SM
bold/PTRY
boldface/DM
boldness/M
bole/SM
bolero/MS
bolivar/MS
bolivares
boll/SM
bollard/S
bollix/GMDS
bollocking/S
bollocks
bologna/M
bolshie
bolster/GMDS
bolt's
bolt/USGD
bolthole/S
bolus/MS
bomb/SJZGMDR
bombard/GDLS
bombardier/MS
bombardment/SM
bombast/M
bombastic
bombastically
bomber/M
bombproof
bombshell/SM
bombsite/S
bonanza/MS
bonbon/MS
bonce/S
bond/SGMD
bondage/M
bondholder/MS
bonding/M
bondman/M
bondmen
bondsman/M
bondsmen
bondwoman/M
bondwomen
bone/DRSMZG
bonehead/SMD
boneless
boner/M
boneshaker/S
boneyard
bonfire/MS
bong/SGMD
bongo/MS
bonhomie/M
boniness/M
bonito/MS
bonk/SZGD
bonnet/MS
bonny/TR
bonobo/MS
bonsai/M
bonus/MS
bony/PTR
boo/SMDHG
boob/SGMD
booby/SM
boodle/MS
booger/S
boogeyman/M
boogeymen
boogie/MDS
boogieing
boogieman/M
boohoo/GMDS
book/SBJGMD
bookbinder/SM
bookbindery/SM
bookbinding/M
bookcase/MS
bookend/MS
bookie/MS
booking/M
bookish
bookkeeper/MS
bookkeeping/M
booklet/MS
bookmaker/SM
bookmaking/M
bookmark/SMDG
bookmobile/SM
bookplate/MS
bookseller/MS
bookshelf/M
bookshelves
bookshop/SM
bookstall/S
bookstore/MS
bookworm/SM
boom/SZGMDR
boombox/MS
boomerang/MDGS
boon/SM
boondocks/M
boondoggle/MZGDRS
boondoggler/M
boonies/M
boor/SM
boorish/PY
boorishness/MS
boost/ZGMDRS
booster/M
boot's
boot/ASGD
bootblack/SM
bootee/MS
booth/M
booths
bootlace/S
bootleg/MS
bootlegged
bootlegger/MS
bootlegging/M
bootless
bootstrap/MS
bootstrapped
bootstrapping
booty/SM
booze/MZGDRS
boozer/M
boozy/TR
bop/SM
bopped
bopping
borax/M
bordello/MS
border/GMDS
borderland/MS
borderline/MS
bore/DRSMZG
boredom/M
borehole/S
borer/M
boring/Y
born/IAU
borne
boron/M
borough/M
boroughs
borrow/SDRZGJ
borrower/M
borrowing/M
borscht/M
borstal/S
borzoi/SM
bosh/M
bosom's
bosom/US
bosomy
boss/DSGM
bossily
bossiness/M
bossism/M
bossy/RTP
bot/S
botanic
botanical/Y
botanist/SM
botany/M
botch/DRSZGM
botcher/M
both
bother/SMDG
botheration
bothersome
botnet/SM
bottle/DRSMZG
bottleneck/MS
bottler/M
bottom/SMDG
bottomless
botulinum
botulism/M
boudoir/SM
bouffant/SM
bougainvillea/MS
bough/M
boughs
bought
bouillabaisse/SM
bouillon/MS
boulder/SM
boules
boulevard/SM
bounce/DRSMZG
bouncer/M
bouncily
bounciness/M
bouncy/RTP
bound/ASMGD
boundary/SM
bounden
bounder/SM
boundless/PY
boundlessness/M
bounteous/YP
bounteousness/M
bountiful/YP
bountifulness/M
bounty/SM
bouquet/SM
bourbon/SM
bourgeois/M
bourgeoisie/M
boustrophedon
bout/MS
boutique/SM
boutonniere/MS
bouzouki/MS
bovine/SM
bovver
bow/ZGSMDR
bowdlerization/MS
bowdlerize/DSG
bowed/U
bowel/SM
bower/M
bowl/MDRZGS
bowleg/SM
bowlegged
bowler/M
bowlful/SM
bowline/SM
bowling/M
bowman/M
bowmen
bowsprit/SM
bowstring/SM
bowwow/SM
box/ZGMDNRS
boxcar/SM
boxer/M
boxing/M
boxlike
boxroom/S
boxwood/M
boxy/RT
boy/SM
boycott/SGMD
boyfriend/MS
boyhood/SM
boyish/YP
boyishness/M
boysenberry/SM
bozo/MS
bpm
bps
bra/SM
brace/MZGDRS
bracelet/MS
bracer/M
bracero/MS
bracken/M
bracket/GMDS
brackish/P
brackishness/M
bract/MS
brad/SM
bradawl/S
bradycardia
brae/SM
brag/SM
braggadocio/SM
braggart/SM
bragged
bragger/MS
bragging
braid/GMDS
braiding/M
braille/M
brain/GMDS
brainchild/M
brainchildren/M
braininess/M
brainless/Y
brainpower
brainstorm/SMDG
brainstorming/M
brainteaser/SM
brainwash/DSG
brainwashing/M
brainwave/S
brainy/PTR
braise/GDS
brake/MGDS
brakeman/M
brakemen
bramble/MS
brambly
bran/M
branch/GMDS
branchlike
brand/ZGMDRS
branded/U
brander/M
brandish/DSG
brandy/GDSM
brash/PTRY
brashness/M
brass/MS
brasserie/MS
brassiere/MS
brassily
brassiness/M
brassy/PTR
brat/SM
bratty/RT
bratwurst/SM
bravado/M
brave/GPMYDTRS
braveness/M
bravery/M
bravo/SM
bravura/SM
brawl/SDRZGM
brawler/M
brawn/M
brawniness/M
brawny/RTP
bray/DGSM
braze/DRSZG
brazen/SDYGP
brazenness/M
brazer/M
brazier/SM
breach/GMDS
bread/GMDHS
breadbasket/SM
breadboard/SM
breadbox/MS
breadcrumb/MS
breadfruit/SM
breadline/MS
breadth/M
breadths
breadwinner/SM
break/BMZGRS
breakable/MS
breakage/MS
breakaway/MS
breakdown/MS
breaker/M
breakfast/MDGS
breakfront/MS
breakneck
breakout/MS
breakpoints
breakthrough/M
breakthroughs
breakup/SM
breakwater/SM
bream/MS
breast/SMDG
breastbone/MS
breastfed
breastfeed/GS
breastplate/SM
breaststroke/SM
breastwork/MS
breath/MDRSZGB
breathalyze/ZGDRS
breathe
breather/M
breathing/M
breathless/PY
breathlessness/M
breaths
breathtaking/Y
breathy/RT
bred/I
breech/MS
breed/SRZGM
breeder/M
breeding/IM
breeze/DSMG
breezeway/SM
breezily
breeziness/M
breezy/RTP
brethren
breve/SM
brevet/SM
brevetted
brevetting
breviary/SM
brevity/M
brew/MDRZGS
brewer/M
brewery/SM
brewpub/SM
bribe/DRSMZG
briber/M
bribery/M
brick/SMDG
brickbat/SM
brickie/S
bricklayer/MS
bricklaying/M
brickwork/M
brickyard/S
bridal/SM
bride/SM
bridegroom/SM
bridesmaid/MS
bridge/DSMG
bridgeable/U
bridgehead/SM
bridgework/M
bridle/DSMG
bridled/U
bridleway/S
brie/MZR
brief's
brief/CSDTGJ
briefcase/SM
briefer
briefing/CM
briefly
briefness/M
brier/M
brig/MS
brigade/SM
brigadier/MS
brigand/SM
brigandage/M
brigantine/MS
bright/SPNRYXT
brighten/DRZG
brightener/M
brightness/M
brights/M
brill
brilliance/M
brilliancy/M
brilliant/MYS
brilliantine/M
brim/MS
brimful
brimless
brimmed
brimming
brimstone/M
brindle/DM
brine/M
bring/SRZG
bringer/M
brininess/M
brink/SM
brinkmanship/M
briny/RTP
brioche/SM
briquette/MS
brisk/SDRYTGP
brisket/SM
briskness/M
bristle/DSMG
bristly/TR
britches/M
brittle/PRMT
brittleness/M
bro/SMH
broach/MDSG
broad/SMNRYXTP
broadband/M
broadcast/AMGS
broadcaster/MS
broadcasting/M
broadcloth/M
broaden/DG
broadloom/M
broadminded
broadness/M
broadsheet/SM
broadside/MGDS
broadsword/SM
brocade/DSMG
broccoli/M
brochette/SM
brochure/MS
brogan/SM
brogue/SM
broil/SMDRZG
broiler/M
broke
broken/YP
brokenhearted/Y
brokenness/M
broker/SMDG
brokerage/MS
brolly/S
bromide/SM
bromidic
bromine/M
bronc/SM
bronchi
bronchial
bronchitic
bronchitis/M
bronchus/M
bronco/SM
broncobuster/SM
brontosaur/MS
brontosaurus/MS
bronze/DSMG
brooch/MS
brood/SMDRZG
brooder/M
broodily
brooding/MY
broodmare/MS
broody/RMPT
brook/SMDG
brooklet/SM
broom/SM
broomstick/MS
broth/MRZ
brothel/MS
brother/MY
brotherhood/MS
brotherliness/M
broths
brougham/SM
brought
brouhaha/SM
brow/MS
browbeat/SNG
brown/SMDRPTG
brownfield
brownie/MS
brownish
brownness/M
brownout/SM
brownstone/MS
browse/DRSMZG
browser/M
brr
bruin/SM
bruise/DRSMZG
bruiser/M
bruising/M
bruit/SDG
brunch/MDSG
brunet/SM
brunette/MS
brunt/M
brush/MDSG
brushoff/SM
brushstroke/S
brushwood/M
brushwork/M
brusque/RPYT
brusqueness/M
brutal/Y
brutality/SM
brutalization/M
brutalize/GDS
brute/SM
brutish/PY
brutishness/M
bu
bub/SM
bubble/DSMG
bubblegum/M
bubbly/RMT
bubo/M
buboes
buccaneer/SGMD
buck/MDGS
buckaroo/SM
buckboard/MS
bucket/SGMD
bucketful/MS
buckeye/MS
buckle's
buckle/UDSG
buckler/MS
buckram/M
bucksaw/MS
buckshot/M
buckskin/MS
buckteeth
bucktooth/MD
buckwheat/M
buckyball/SM
bucolic/MS
bucolically
bud/SM
budded
budding/S
buddy/SM
budge/DSG
budgerigar/MS
budget/SGMD
budgetary
budgie/SM
buff/AMDGS
buffalo/MDG
buffaloes
buffer/SMDG
buffet/SMDGJ
buffoon/SM
buffoonery/M
buffoonish
bug's
bug/CS
bugaboo/SM
bugbear/SM
bugged/C
bugger/SMDG
buggery
bugging/C
buggy/RSMT
bugle/DRSMZG
bugler/M
build/SMRZGJ
builder/M
building/M
buildup/SM
built/AI
builtin
bulb/MS
bulbous
bulge/DSMG
bulgy/RT
bulimarexia/M
bulimia/M
bulimic/SM
bulk/MDGS
bulkhead/MS
bulkiness/M
bulky/RTP
bull/MDGS
bulldog/SM
bulldogged
bulldogging
bulldoze/ZGDRS
bulldozer/M
bullet/SM
bulletin/MDGS
bulletproof/SDG
bullfight/SMRZG
bullfighter/M
bullfighting/M
bullfinch/MS
bullfrog/MS
bullhead/MDS
bullheaded/PY
bullheadedness/M
bullhorn/MS
bullion/M
bullish/YP
bullishness/M
bullock/SM
bullpen/SM
bullring/MS
bullshit/MS!
bullshitted/!
bullshitter/SM!
bullshitting/!
bullwhip/S
bully/DSMG
bulrush/MS
bulwark/MS
bum/SM
bumbag/S
bumble/DRSZG
bumblebee/SM
bumbler/M
bumf
bummed
bummer/SM
bummest
bumming
bump/MDRZGS
bumper/M
bumph
bumpiness/M
bumpkin/MS
bumptious/PY
bumptiousness/M
bumpy/PRT
bun/SM
bunch/MDSG
bunchy/RT
bunco/SMDG
bundle/DSMG
bung/MDGS
bungalow/MS
bungee/SM
bunghole/MS
bungle/DRSMZG
bungler/M
bunion/SM
bunk's
bunk/CDGS
bunker/SM
bunkhouse/SM
bunkum/M
bunny/SM
bunt/MDGSJ
bunting/M
buoy/MDGS
buoyancy/M
buoyant/Y
bur/SMY
burble/DSMG
burbs/M
burden's
burden/USGD
burdensome
burdock/M
bureau/SM
bureaucracy/SM
bureaucrat/MS
bureaucratic
bureaucratically
bureaucratization/M
bureaucratize/GDS
burg/MRZS
burgeon/DSG
burger/M
burgh/MRZ
burgher/M
burghs
burglar/MS
burglarize/GDS
burglarproof
burglary/SM
burgle/DSG
burgomaster/SM
burgundy/SM
burial/ASM
burka/SM
burl/MDS
burlap/M
burlesque/MGDS
burliness/M
burly/RPT
burn/MDRZGSB
burnable/SM
burner/M
burnish/ZGMDRS
burnisher/M
burnoose/MS
burnout/MS
burnt
burp/MDGS
burqa/SM
burr/MDGS
burrito/MS
burro/SM
burrow/SMDRZG
burrower/M
bursa/M
bursae
bursar/SM
bursary/SM
bursitis/M
burst/SMG
bury/ADSG
bus/AMS
busboy/SM
busby/SM
bused
busgirl/MS
bush/MDSGJ
bushel/SGMD
bushiness/M
bushing/M
bushman/M
bushmaster/SM
bushmen
bushwhack/DRSZG
bushwhacker/M
bushy/RPT
busily
business/MS
businesslike
businessman/M
businessmen
businessperson/SM
businesswoman/M
businesswomen
busing/M
busk/DRZGS
buskin/SM
busload/S
buss/M
bust/MDRZGS
buster/M
bustle/DSMG
busty/RZT
busy/DRSTGP
busybody/SM
busyness/M
busywork/M
but/ACS
butane/M
butch/MRSZ
butcher/MDG
butchery/SM
butler/SM
butt/MDRZGS
butte/SM
butted/A
butter/MDG
butterball/MS
buttercream
buttercup/SM
butterfat/M
butterfingered
butterfingers/M
butterfly/GDSM
buttermilk/M
butternut/SM
butterscotch/M
buttery/TRSM
butting/A
buttock/SM
button's
button/USDG
buttonhole/DSMG
buttonwood/MS
buttress/MDSG
butty/S
buxom
buy/ZGSMR
buyback/SM
buyer/M
buyout/SM
buzz/MDRSZG
buzzard/MS
buzzer/M
buzzkill/SM
buzzword/SM
bx
bxs
by/M
bye/SM
bygone/SM
bylaw/SM
byline/SM
bypass/GMDS
bypath/M
bypaths
byplay/M
byproduct/MS
byre/S
byroad/SM
bystander/MS
byte/MS
byway/SM
byword/SM
byzantine
c/IES
ca
cab/SMRZ
cabal/MS
cabala's
caballero/MS
cabana/SM
cabaret/SM
cabbage/MS
cabbed
cabbing
cabby/SM
cabdriver/SM
cabin/MS
cabinet/SM
cabinetmaker/MS
cabinetmaking/M
cabinetry/M
cabinetwork/M
cable/MGDS
cablecast/GMS
cablegram/MS
cabochon/SM
caboodle/M
caboose/SM
cabriolet/SM
cabstand/SM
cacao/MS
cache/MGDS
cachepot/SM
cachet/MS
cackle/MZGDRS
cackler/M
cacophonous
cacophony/SM
cacti
cactus/M
cad/SM
cadaver/SM
cadaverous
caddie/MDS
caddish/YP
caddishness/M
caddying
cadence/DSM
cadenza/SM
cadet/MS
cadge/ZGDRS
cadger/M
cadmium/M
cadre/MS
caducei
caduceus/M
caesura/SM
cafe/SM
cafeteria/MS
cafetiere/S
caff/CS
caffeinated
caffeine/M
caftan/MS
cage/DSMG
cagey
cagier
cagiest
cagily
caginess/M
cagoule/S
cahoot/MS
caiman/MS
cairn/MS
caisson/SM
caitiff/SM
cajole/ZGLDRS
cajolement/M
cajoler/M
cajolery/M
cake/DSMG
cakewalk/SM
cal
calabash/MS
calaboose/SM
calamari/SM
calamine/M
calamitous/Y
calamity/SM
calcareous
calciferous
calcification/M
calcify/GNDS
calcimine/DSMG
calcine/DSG
calcite/M
calcium/M
calculable/I
calculate/AGNVDSX
calculated/Y
calculating/Y
calculation/AM
calculator/SM
calculi
calculus/M
caldera/SM
calendar/MDGS
calender's
calf/M
calfskin/M
caliber/SM
calibrate/GNDSX
calibration/M
calibrator/SM
calico/M
calicoes
californium/M
caliper/SGMD
caliph/M
caliphate/MS
caliphs
calisthenic/S
calisthenics/M
calk/SGMD
call/ASGMD
calla/MS
callable
callback/MS
called/U
caller/MS
calligrapher/SM
calligraphic
calligraphist/MS
calligraphy/M
calling/SM
calliope/MS
callosity/SM
callous/PGDSY
callousness/M
callow/RPT
callowness/M
callus/MDSG
calm/PSTGMDRY
calmness/M
caloric
calorie/MS
calorific
calumet/MS
calumniate/GNDS
calumniation/M
calumniator/MS
calumnious
calumny/SM
calve/GDS
calypso/MS
calyx/MS
cam/SM
camaraderie/M
camber/MDSG
cambial
cambium/SM
cambric/M
camcorder/SM
came
camel/MS
camelhair
camellia/MS
cameo/MS
camera/MS
cameraman/M
cameramen
camerawoman/M
camerawomen
camerawork
camiknickers
camisole/SM
camouflage/MZGDRS
camouflager/M
camp's
camp/CSGD
campaign/SMDRZG
campaigner/M
campanile/SM
campanologist/MS
campanology/M
camper/MS
campfire/SM
campground/SM
camphor/M
camping/M
campsite/SM
campus/MS
campy/TR
camshaft/SM
can't
can/SMDRZG
canal/MS
canalization/M
canalize/GDS
canape/MS
canard/MS
canary/SM
canasta/M
cancan/MS
cancel/DRSZG
canceler/M
cancellation/SM
cancer/MS
cancerous
candelabra/SM
candelabrum/M
candid/YP
candida
candidacy/SM
candidate/MS
candidature/SM
candidness/M
candle/MZGDRS
candlelight/M
candlelit
candlepower/M
candler/M
candlestick/MS
candlewick/SM
candor/M
candy/GDSM
candyfloss
cane/SM
canebrake/MS
caner/M
canine/MS
canister/SM
canker/GMDS
cankerous
cannabis/MS
canned
cannelloni/M
cannery/SM
cannibal/SM
cannibalism/M
cannibalistic
cannibalization/M
cannibalize/GDS
cannily/U
canniness/M
canning
cannon/GMDS
cannonade/MGDS
cannonball/SM
cannot
canny/UTR
canoe/MDS
canoeing
canoeist/SM
canola/M
canon/MS
canonical/Y
canonization/SM
canonize/DSG
canoodle/DSG
canopy/GDSM
canst
cant's
cant/CZRDGS
cantabile
cantaloupe/SM
cantankerous/PY
cantankerousness/M
cantata/MS
canteen/MS
canter/CM
cantered
cantering
canticle/MS
cantilever/MDGS
canto/MS
canton/MLS
cantonal
cantonment/MS
cantor/MS
canvas/MGDS
canvasback/SM
canvass/MDRSZG
canvasser/M
canyon/MGS
cap/SMDRBZ
capabilities
capability/IM
capable/I
capably/I
capacious/PY
capaciousness/M
capacitance/M
capacities
capacitor/SM
capacity/IM
caparison/MDGS
cape/SM
caper/GMD
capeskin/M
capillarity/M
capillary/SM
capital/MSY
capitalism/M
capitalist/SM
capitalistic
capitalistically
capitalization/M
capitalize/ADSG
capitation/CSM
capitol/SM
capitulate/ADSXGN
capitulation/AM
caplet/MS
capo/SM
capon/MS
capped/UA
capping/UA
cappuccino/SM
caprice/SM
capricious/PY
capriciousness/M
capsicum/SM
capsize/DSG
capstan/SM
capstone/MS
capsular
capsule/DSMG
capsulize/DSG
capt
captain/SMDG
captaincy/SM
caption/SMDG
captious/YP
captiousness/M
captivate/DSGN
captivation/M
captivator/SM
captive/SM
captivity/SM
captor/MS
capture/ADSMG
car/SMDRZG
carafe/MS
caramel/SM
caramelize/DSG
carapace/SM
carat/MS
caravan/SM
caravansary/SM
caravel/SM
caraway/SM
carbide/SM
carbine/SM
carbohydrate/SM
carbolic
carbon/MS
carbonaceous
carbonate/MGNDS
carbonation/M
carboniferous
carbonize/GDS
carborundum/M
carboy/MS
carbs
carbuncle/SM
carbuncular
carburetor/SM
carcass/MS
carcinogen/SM
carcinogenic/MS
carcinogenicity/M
carcinoma/MS
card/ESGMD
cardamom/SM
cardamon/S
cardboard/M
carder/MS
cardholder/S
cardiac
cardie/S
cardigan/SM
cardinal/SMY
cardio
cardiogram/SM
cardiograph/M
cardiographs
cardiologist/MS
cardiology/M
cardiomyopathy
cardiopulmonary
cardiovascular
cardsharp/MRZS
cardsharper/M
care/SM
careen/DGS
career/MDGS
careerism
careerist/SM
carefree
careful/YP
carefuller
carefullest
carefulness/M
caregiver/SM
careless/PY
carelessness/M
carer/M
caress/MDSG
caret/MS
caretaker/MS
careworn
carfare/M
cargo/M
cargoes
carhop/MS
caribou/SM
caricature/MGDS
caricaturist/SM
caries/M
carillon/SM
caring/M
carious
carjack/JSDRZG
carjacker/M
carjacking/M
carload/SM
carmine/SM
carnage/M
carnal/Y
carnality/M
carnation/IMS
carnelian/MS
carnival/MS
carnivora
carnivore/SM
carnivorous/PY
carnivorousness/M
carny/SM
carob/MS
carol/ZGMDRS
caroler/M
carom/GMDS
carotene/M
carotid/SM
carousal/SM
carouse/DRSMZG
carousel/SM
carouser/M
carp/SZGMDR
carpal/MS
carpel/MS
carpenter/MDGS
carpentry/M
carper/M
carpet/MDGS
carpetbag/MS
carpetbagged
carpetbagger/MS
carpetbagging
carpeting/M
carpi
carpool/SMDG
carport/SM
carpus/M
carrel/MS
carriage/SM
carriageway/S
carrier/M
carrion/M
carrot/MS
carroty
carry/ZGDRSM
carryall/SM
carrycot/S
carryout
carryover/MS
carsick/P
carsickness/M
cart/SZGMDR
cartage/M
cartel/MS
carter/M
carthorse/SM
cartilage/SM
cartilaginous
cartload/SM
cartographer/SM
cartographic
cartography/M
carton/MS
cartoon/SMDG
cartoonist/MS
cartridge/MS
cartwheel/GMDS
carve/JZGDRS
carver/M
carvery/S
carving/M
caryatid/MS
casaba/MS
cascade/DSMG
cascara/SM
case/LDSJMG
casebook/S
cased/U
caseharden/DGS
casein/M
caseload/MS
casement/MS
casework/ZMR
caseworker/M
cash/GMDS
cashback/M
cashbook/MS
cashew/MS
cashier/GSMD
cashless
cashmere/M
casing/M
casino/MS
cask/SM
casket/MS
cassava/SM
casserole/DSMG
cassette/MS
cassia/MS
cassock/SM
cassowary/SM
cast/ASGM
castanet/MS
castaway/MS
caste/JMZRS
castellated
caster/M
castigate/DSGN
castigation/M
castigator/SM
casting/AM
castle/MGDS
castoff/SM
castor/MS
castrate/GNXDS
castration/M
casual/PMYS
casualness/M
casualty/SM
casuist/SM
casuistic
casuistry/M
cat/SM
cataclysm/MS
cataclysmal
cataclysmic
catacomb/SM
catafalque/MS
catalepsy/M
cataleptic/MS
catalog/ZGSMDR
cataloger/M
catalpa/SM
catalyses
catalysis/M
catalyst/MS
catalytic/M
catalyze/GDS
catamaran/SM
catapult/GMDS
cataract/MS
catarrh/M
catastrophe/MS
catastrophic
catastrophically
catatonia/M
catatonic/SM
catbird/SM
catboat/SM
catcall/GSMD
catch/ZGJLMRS
catchall/MS
catcher/M
catchment/MS
catchpenny
catchphrase/SM
catchword/MS
catchy/RT
catechism/SM
catechist/SM
catechize/DSG
categorical/Y
categorization/MS
categorize/GDS
category/SM
cater/ZGJDRS
catercorner
caterer/M
caterpillar/MS
caterwaul/SMDG
catfish/MS
catgut/M
catharses
catharsis/M
cathartic/SM
cathedral/SM
catheter/SM
catheterize/DSG
cathode/SM
cathodic
catholic
catholicity/M
cation/MS
catkin/MS
catlike
catnap/MS
catnapped
catnapping
catnip/M
catsuit/S
cattail/SM
catted
cattery/S
cattily
cattiness/M
catting
cattle/M
cattleman/M
cattlemen
catty/TPR
catwalk/SM
caucus/MDSG
caudal/Y
caught/U
cauldron/MS
cauliflower/SM
caulk/ZGMDRS
caulker/M
causal/Y
causality/SM
causation/M
causative
cause/MZGDRS
causeless
causer/M
causerie/SM
causeway/SM
caustic/SM
caustically
causticity/M
cauterization/M
cauterize/GDS
caution/SMDG
cautionary
cautious/IY
cautiousness/M
cavalcade/MS
cavalier/SMY
cavalry/SM
cavalryman/M
cavalrymen
cave/DRSMZG
caveat/MS
caveman/M
cavemen
cavern/MS
cavernous/Y
caviar/M
cavil/ZGJMDRS
caviler/M
caving/M
cavity/FSM
cavort/DGS
caw/SMDG
cay/CSM
cayenne/M
cayuse/MS
cc
cease/CMGDS
ceasefire/MS
ceaseless/YP
ceaselessness/M
ceca
cecal
cecum/M
cedar/MS
cede/FAGSD
ceder/MS
cedilla/SM
ceilidh
ceilidhs
ceiling/MS
celandine/M
celeb/S
celebrant/SM
celebrate/DSGNX
celebration/M
celebrator/SM
celebratory
celebrity/SM
celeriac
celerity/M
celery/M
celesta/MS
celestial/Y
celibacy/M
celibate/MS
cell/SMD
cellar/MS
cellist/SM
cellmate/SM
cello/MS
cellophane/M
cellphone/MS
cellular/SM
cellulite/M
cellulitis
celluloid/M
cellulose/M
cement/MDRZGS
cementer/M
cementum/M
cemetery/SM
cenobite/MS
cenobitic
cenotaph/M
cenotaphs
censer/MS
censor/MDGS
censored/U
censorial
censorious/PY
censoriousness/M
censorship/M
censure/BDRSMZG
censurer/M
census/MDSG
cent/SZMR
centaur/SM
centavo/SM
centenarian/MS
centenary/SM
centennial/MYS
center/MDG
centerboard/SM
centerfold/MS
centerpiece/MS
centigrade
centigram/SM
centiliter/MS
centime/SM
centimeter/MS
centipede/SM
central/SMY
centralism
centralist
centrality/M
centralization/CM
centralize/CGDS
centralizer/MS
centrifugal/Y
centrifuge/DSMG
centripetal/Y
centrism/M
centrist/MS
centurion/SM
century/SM
cephalic
ceramic/SM
ceramicist/SM
ceramics/M
ceramist/MS
cereal/MS
cerebellar
cerebellum/SM
cerebra
cerebral
cerebrate/GNDS
cerebration/M
cerebrovascular
cerebrum/MS
cerement/MS
ceremonial/SMY
ceremonious/UY
ceremoniousness/M
ceremony/SM
cerise/M
cerium/M
cermet/M
cert/S
certain/UY
certainty/USM
certifiable
certifiably
certificate/MGNXDS
certification/M
certify/DSG
certitude/IM
certitudes
cerulean/M
cervical
cervices
cervix/M
cesarean/MS
cesium/M
cessation/MS
cession/KAFSM
cesspit/S
cesspool/MS
cetacean/MS
cf
cg
ch/IFVT
chad/S
chafe/GDS
chaff/GMDS
chaffinch/MS
chagrin/GSMD
chain's
chain/UGDS
chainsaw/MDGS
chair/GMDS
chairlift/MS
chairman/M
chairmanship/SM
chairmen
chairperson/SM
chairwoman/M
chairwomen
chaise/MS
chalcedony/M
chalet/MS
chalice/SM
chalk/GMDS
chalkboard/SM
chalkiness/M
chalky/PRT
challenge/DRSMZG
challenged/U
challenger/M
challis/M
chamber/SMD
chamberlain/MS
chambermaid/MS
chambray/M
chameleon/SM
chamois/M
chamomile/MS
champ/ZGMDS
champagne/MS
champion/GMDS
championship/MS
chance/MGDS
chancel/SM
chancellery/SM
chancellor/MS
chancellorship/M
chancery/SM
chanciness/M
chancre/SM
chancy/PRT
chandelier/SM
chandler/MS
change/MZGDRS
changeability/M
changeable/P
changeableness/M
changeably
changed/U
changeless/Y
changeling/SM
changeover/SM
changer/M
changing/U
channel/GSMD
channelization/M
channelize/DSG
chanson/SM
chant/ZGMDRS
chanter/M
chanteuse/MS
chantey/SM
chanticleer/MS
chaos/M
chaotic
chaotically
chap/SM
chaparral/SM
chapati/S
chapatti/S
chapbook/MS
chapeau/SM
chapel/MS
chaperon/MDGS
chaperonage/M
chaperoned/U
chaplain/MS
chaplaincy/SM
chaplet/SM
chapped
chapping
chappy/S
chapter/SM
char/SM
charabanc/MS
character/MS
characterful
characteristic/SM
characteristically/U
characterization/MS
characterize/DSG
characterless
charade/SM
charbroil/GDS
charcoal/MS
chard/M
chardonnay/SM
charge/AESDGM
chargeable/A
charged/U
charger/SM
charily
chariness/M
chariot/SM
charioteer/MS
charisma/M
charismatic/MS
charitable/P
charitableness/M
charitably/U
charity/SM
charlady/S
charlatan/SM
charlatanism/M
charlatanry/M
charlie/S
charm/ZGMDRS
charmer/M
charming/Y
charmless
charred
charring
chart/GMDS
charted/U
charter's
charter/ASGD
charterer/MS
chartreuse/M
charwoman/M
charwomen
chary/TRP
chase/MZGDRS
chaser/M
chasm/MS
chassis/M
chaste/PYTR
chasten/DGS
chasteness/M
chastise/DRSZGL
chastisement/SM
chastiser/M
chastity/M
chasuble/SM
chat/SM
chateau/SM
chateaux
chatelaine/SM
chatline/S
chatroom/M
chatted
chattel/MS
chatter/MDRZGS
chatterbox/MS
chatterer/M
chattily
chattiness/M
chatting
chatty/TPR
chauffeur/GMDS
chauvinism/M
chauvinist/SM
chauvinistic
chauvinistically
cheap/PXTNRY
cheapen/DG
cheapness/M
cheapo
cheapskate/MS
cheat/ZGMDRS
cheater/M
check/AGMDS
checkbook/SM
checkbox
checked/U
checker/MDGS
checkerboard/SM
checkers/M
checklist/MS
checkmate/MGDS
checkoff/SM
checkout/SM
checkpoint/SM
checkroom/MS
checksum
checkup/MS
cheddar/M
cheek/GMDS
cheekbone/SM
cheekily
cheekiness/M
cheeky/TPR
cheep/GMDS
cheer/ZGMDRS
cheerer/M
cheerful/YP
cheerfuller
cheerfullest
cheerfulness/M
cheerily
cheeriness/M
cheerio/MS
cheerleader/SM
cheerless/PY
cheerlessness/M
cheery/TPR
cheese/MGDS
cheeseboard/S
cheeseburger/SM
cheesecake/SM
cheesecloth/M
cheeseparing/M
cheesiness/M
cheesy/TPR
cheetah/M
cheetahs
chef/SM
chem
chemical/SMY
chemise/MS
chemist/MS
chemistry/M
chemo/M
chemotherapeutic
chemotherapy/M
chemurgy/M
chenille/M
cherish/DSG
cheroot/MS
cherry/SM
chert/M
cherub/MS
cherubic
cherubim
chervil/M
chess/M
chessboard/MS
chessman/M
chessmen
chest/MDS
chesterfield/SM
chestful/SM
chestnut/SM
chesty/TR
chevalier/SM
cheviot/M
chevron/MS
chew/SZGMDR
chewer/M
chewiness/M
chewy/PTR
chg
chge
chi/SM
chiaroscuro/M
chic/PTMR
chicane/MS
chicanery/SM
chichi/MS
chick/XMNS
chickadee/SM
chicken/MDG
chickenfeed/M
chickenhearted
chickenpox/M
chickenshit/S!
chickpea/SM
chickweed/M
chicle/M
chicness/M
chicory/SM
chide/GDS
chiding/Y
chief/TMRYS
chiefdom/M
chieftain/MS
chieftainship/SM
chiffon/M
chiffonier/MS
chigger/MS
chignon/MS
chihuahua/SM
chilblain/SM
child/M
childbearing/M
childbirth/M
childbirths
childcare/M
childhood/SM
childish/YP
childishness/M
childless/P
childlessness/M
childlike
childminder/S
childminding
childproof/GSD
children/M
chili/M
chilies
chill/JPZTGMDRS
chiller/M
chilliness/M
chilling/Y
chillness/M
chilly/TPR
chime/MZGDRS
chimer/M
chimera/MS
chimeric
chimerical
chimney/MS
chimp/MS
chimpanzee/SM
chin/SM
china/M
chinaware/M
chinchilla/MS
chine/MS
chink/GMDS
chinless
chinned
chinning
chino/MS
chinstrap/MS
chintz/M
chintzy/RT
chinwag/S
chip/SM
chipboard
chipmunk/SM
chipolata/S
chipped
chipper/MS
chippie
chipping/S
chippy/S
chirography/M
chiropodist/MS
chiropody/M
chiropractic/SM
chiropractor/SM
chirp/GMDS
chirpily
chirpy/PTR
chirrup/GMDS
chisel/ZGMDRS
chiseler/M
chit/SM
chitchat/SM
chitchatted
chitchatting
chitin/M
chitinous
chitosan
chitterlings/M
chivalrous/PY
chivalrousness/M
chivalry/M
chive/MS
chivy/GDS
chlamydia/MS
chlamydiae
chloral/M
chlordane/M
chloride/MS
chlorinate/GNDS
chlorination/M
chlorine/M
chlorofluorocarbon/SM
chloroform/SGMD
chlorophyll/M
chloroplast/MS
chm
choc/S
chock/GMDS
chockablock
chocoholic/SM
chocolate/MS
chocolaty
choice/MTRS
choir/MS
choirboy/MS
choirmaster/SM
choke/MZGDRS
chokecherry/SM
choker/M
cholecystectomy
cholecystitis
choler/M
cholera/M
choleric
cholesterol/M
chomp/ZGMDRS
choose/ZGRS
chooser/M
choosiness/M
choosy/TPR
chop/SM
chophouse/SM
chopped
chopper/MDGS
choppily
choppiness/M
chopping
choppy/TPR
chopstick/SM
choral/MYS
chorale/MS
chord/MS
chordal
chordate/SM
chore/MS
chorea/M
choreograph/DRZG
choreographer/M
choreographic
choreographically
choreographs
choreography/M
chorister/SM
choroid/MS
chortle/MZGDRS
chortler/M
chorus/GMDS
chose
chosen
chow/SGMD
chowder/MS
chrism/M
christen/ASGD
christening/MS
christian/U
christology
chromatic
chromatically
chromatin/M
chromatography
chrome/MGDS
chromium/M
chromosomal
chromosome/MS
chronic
chronically
chronicle/DRSMZG
chronicler/M
chronograph/M
chronographs
chronological/Y
chronologist/MS
chronology/SM
chronometer/SM
chrysalis/MS
chrysanthemum/MS
chub/SM
chubbiness/M
chubby/TPR
chuck/GMDS
chuckhole/SM
chuckle/MGDS
chuffed
chug/SM
chugged
chugging
chukka/MS
chum/SM
chummed
chummily
chumminess/M
chumming
chummy/PTR
chump/MS
chunder/GDS
chunk/GMDS
chunkiness/M
chunky/PTR
chunter/DGS
church/MS
churchgoer/SM
churchgoing/M
churchman/M
churchmen
churchwarden/MS
churchwoman
churchwomen
churchyard/SM
churl/MS
churlish/PY
churlishness/M
churn/ZGMDRS
churner/M
chute/MS
chutney/MS
chutzpah/M
chyme/M
ciabatta/SM
ciao/S
cicada/MS
cicatrices
cicatrix/M
cicerone/SM
ciceroni
cider's
cider/S
cigar/MS
cigarette/MS
cigarillo/MS
cilantro/M
cilia
cilium/M
cinch/GMDS
cinchona/SM
cincture/SM
cinder/GMDS
cine
cinema/MS
cinematic
cinematographer/MS
cinematographic
cinematography/M
cinnabar/M
cinnamon/M
cipher's
cipher/CGDS
cir
circa
circadian
circle/MGDS
circlet/MS
circuit/MDGS
circuital
circuitous/YP
circuitousness/M
circuitry/M
circuity/M
circular/SMY
circularity/M
circularize/DSG
circulate/ADSG
circulation/SM
circulatory
circumcise/XDSGN
circumcised/U
circumcision/M
circumference/MS
circumferential
circumflex/MS
circumlocution/MS
circumlocutory
circumnavigate/XGNDS
circumnavigation/M
circumpolar
circumscribe/GDS
circumscription/MS
circumspect/Y
circumspection/M
circumstance/MGDS
circumstantial/Y
circumvent/DSG
circumvention/M
circus/MS
cirque/MS
cirrhosis/M
cirrhotic/SM
cirri
cirrus/M
cistern/MS
cit
citadel/MS
citation/AMS
cite's
cite/IAGSD
citified
citizen/MS
citizenry/M
citizenship/M
citric
citron/MS
citronella/M
citrus/MS
city/SM
citywide
civet/MS
civic/S
civically
civics/M
civil/UY
civilian/MS
civility/ISM
civilization/MS
civilize/GDS
civilized/U
civvies/M
ck
cl
clack/GMDS
clad/U
cladding/M
claim's
claim/CKEAGDS
claimable/A
claimant/MS
claimed/U
claimer/ECSM
clairvoyance/M
clairvoyant/MS
clam/SM
clambake/MS
clamber/ZGMDRS
clamberer/M
clammed
clammily
clamminess/M
clamming
clammy/PTR
clamor/GMDS
clamorous
clamp/GMDS
clampdown/MS
clan/SM
clandestine/Y
clang/ZGMDRS
clangor/M
clangorous/Y
clank/GMDS
clannish/P
clannishness/M
clansman/M
clansmen
clanswoman
clanswomen
clap/SM
clapboard/MDGS
clapped
clapper/MS
clapperboard/S
clapping/M
claptrap/M
claque/MS
claret/MS
clarification/M
clarify/XDSNG
clarinet/SM
clarinetist/SM
clarion/MDGS
clarity/M
clash/GMDS
clasp's
clasp/UGDS
class/GMDS
classic/MS
classical/MY
classicism/M
classicist/MS
classifiable
classification/CAM
classifications
classified's
classified/U
classifieds
classifier/MS
classify/ACSDGN
classiness/M
classless/P
classmate/MS
classroom/MS
classwork/M
classy/TRP
clatter/GMDS
clausal
clause/MS
claustrophobia/M
claustrophobic
clavichord/SM
clavicle/MS
clavier/MS
claw's
claw/CSGD
clay/M
clayey
clayier
clayiest
clean/BJPZTGDRYS
cleaner/M
cleaning/M
cleanliness/UM
cleanly/UTPR
cleanness/UM
cleanse/ZGDRS
cleanser/M
cleanup/MS
clear/JPTGMDRYS
clearance/SM
clearheaded
clearing/M
clearinghouse/SM
clearness/M
clearway/S
cleat/MS
cleavage/MS
cleave/ZGDRS
cleaver/M
clef/SM
cleft/MS
clematis/MS
clemency/IM
clement/Y
clementine/S
clench/GMDS
clerestory/SM
clergy/SM
clergyman/M
clergymen
clergywoman/M
clergywomen
cleric/MS
clerical/Y
clericalism/M
clerk/GMDS
clerkship/M
clever/PTRY
cleverness/M
clevis/MS
clew/SGMD
cliche/MDS
click/BZGMDRS
clicker/M
client/MS
clientele/MS
cliff/MS
cliffhanger/SM
cliffhanging
clifftop/S
clii
climacteric/M
climactic
climate/SM
climatic
climatically
climatologist/SM
climatology/M
climax/MDSG
climb/SMDRZGB
climber/M
climbing/M
clime/SM
clinch/MDRSZG
clincher/M
cling/SMRZG
clinger/M
clingfilm
clingy/RT
clinic/SM
clinical/Y
clinician/SM
clink/SMDRZG
clinker/M
cliometric/S
cliometrician/MS
cliometrics/M
clip/SM
clipboard/MS
clipped
clipper/SM
clipping/SM
clique/SM
cliquey
cliquish/YP
cliquishness/M
clit/SM
clitoral
clitorides
clitoris/MS
clix
cloaca/M
cloacae
cloak's
cloak/USDG
cloakroom/MS
clobber/SMDG
cloche/SM
clock/SMDG
clockwise
clockwork/SM
clod/MS
cloddish
clodhopper/MS
clog's
clog/US
clogged/U
clogging/U
cloisonne/M
cloister/SMDG
cloistral
clomp/SDG
clonal
clone/DSMG
clonk/SMDG
clop/MS
clopped
clopping
close/DRSMYTGJP
closefisted
closemouthed
closeness/M
closeout/MS
closet/SMDG
closeup/SM
closing/M
closure/ESM
clot/MS
cloth/M
clothe/UDSG
clotheshorse/MS
clothesline/SM
clothespin/SM
clothier/MS
clothing/M
cloths
clotted
clotting
cloture/SM
cloud/SMDG
cloudburst/SM
clouded/U
cloudiness/M
cloudless
cloudy/RPT
clout/SMDG
clove/RSMZ
cloven
clover/M
cloverleaf/SM
cloverleaves
clown/SMDG
clownish/YP
clownishness/M
cloy/DGS
cloying/Y
club/MS
clubbable
clubbed
clubber/S
clubbing
clubfeet
clubfoot/MD
clubhouse/SM
clubland
cluck/SMDG
clue/MGDS
clueless
clump/SMDG
clumpy/TR
clumsily
clumsiness/M
clumsy/TRP
clung
clunk/SMDRZG
clunker/M
clunky/TR
cluster/MDSG
clutch/GMDS
clutter/MDSG
cluttered/U
clvi
clvii
clxi
clxii
clxiv
clxix
clxvi
clxvii
cm
cnidarian/MS
co/ESD
coach/MDSG
coachload/S
coachman/M
coachmen
coachwork
coadjutor/MS
coagulant/MS
coagulate/GNDS
coagulation/M
coagulator/MS
coal/MDGS
coalesce/GDS
coalescence/M
coalescent
coalface/MS
coalfield/S
coalition/MS
coalitionist/MS
coalmine/S
coarse/RYTP
coarsen/SDG
coarseness/M
coast/SMDRZG
coastal
coaster/M
coastguard/S
coastline/MS
coat/MDGJS
coating/M
coatroom/S
coattail/SM
coauthor/MDGS
coax/DRSZG
coaxer/M
coaxial
coaxing/Y
cob/SM
cobalt/M
cobber/S
cobble/DRSMZG
cobbler/M
cobblestone/SM
cobnut/S
cobra/SM
cobweb/SM
cobwebbed
cobwebby/RT
coca/M
cocaine/M
cocci/S
coccus/M
coccyges
coccyx/M
cochineal/M
cochlea/SM
cochleae
cochlear
cock/MDGS
cockade/SM
cockamamie
cockatoo/SM
cockatrice/SM
cockchafer/S
cockcrow/SM
cockerel/SM
cockeyed
cockfight/MGS
cockfighting/M
cockily
cockiness/M
cockle/SM
cockleshell/SM
cockney/SM
cockpit/SM
cockroach/MS
cockscomb/SM
cocksucker/MS!
cocksure
cocktail/MS
cocky/RTP
coco/MS
cocoa/SM
coconut/SM
cocoon/SMDG
cod/SM
coda/MS
codded
codding
coddle/DSG
code's
code/CZGDRS
codeine/M
codependency/M
codependent/SM
coder/CM
codex/M
codfish/MS
codger/SM
codices
codicil/SM
codification/M
codifier/M
codify/XDRSNZG
codon/S
codpiece/MS
codswallop
coed/MS
coeducation/M
coeducational
coefficient/MS
coelenterate/MS
coequal/MYS
coerce/DRSZGNV
coercer/M
coercion/M
coeval/SMY
coexist/DSG
coexistence/M
coexistent
coextensive
coffee/SM
coffeecake/SM
coffeehouse/MS
coffeemaker/SM
coffeepot/MS
coffer/SM
cofferdam/MS
coffin/SMDG
cog/SM
cogency/M
cogent/Y
cogitate/DSXGNV
cogitation/M
cogitator/MS
cognac/SM
cognate/MS
cognition/AM
cognitional
cognitive/Y
cognizable
cognizance/AM
cognizant
cognomen/SM
cognoscente/M
cognoscenti
cogwheel/SM
cohabit/SGD
cohabitant/MS
cohabitation/M
coheir/SM
cohere/DSG
coherence/IM
coherency/M
coherent/IY
cohesion/M
cohesive/YP
cohesiveness/M
coho/MS
cohort/SM
coif/MS
coiffed
coiffing
coiffure/DSMG
coil's/A
coil/UADGS
coin/MDRZGS
coinage/SM
coincide/DSG
coincidence/MS
coincident
coincidental/Y
coiner/M
coinsurance/M
coir
coital
coitus/M
coke/MGDS
col/S
cola/MS
colander/SM
cold/MRYTPS
coldblooded
coldness/M
coleslaw/M
coleus/MS
coley/S
colic/M
colicky
coliseum/MS
colitis/M
coll
collaborate/DSXGNV
collaboration/M
collaborationist
collaborative/Y
collaborator/MS
collage/SM
collagen
collapse/MGDS
collapsible
collar/SMDG
collarbone/SM
collard/SM
collarless
collate/DSXGN
collateral/MY
collateralize
collation/M
collator/MS
colleague/MS
collect's
collect/ASGVD
collected/U
collectedly
collectible/SM
collection/AMS
collective/MYS
collectivism/M
collectivist/SM
collectivization/M
collectivize/DSG
collector/MS
colleen/SM
college/SM
collegiality/M
collegian/MS
collegiate
collide/DSG
collie/RSMZ
collier/M
colliery/SM
collision/SM
collocate/MGNDSX
collocation/M
colloid/SM
colloidal
colloq
colloquial/Y
colloquialism/SM
colloquies
colloquium/MS
colloquy/M
collude/DSG
collusion/M
collusive
cologne/SM
colon/SM
colonel/SM
colonelcy/M
colones
colonial/SMY
colonialism/M
colonialist/MS
colonist/SM
colonization/ACM
colonize/CAGSD
colonizer/MS
colonnade/MDS
colonoscopy/SM
colony/SM
colophon/SM
color's
color/AEGDS
colorant/SM
coloration/EM
coloratura/MS
colorblind/P
colorblindness/M
colored's
colored/U
coloreds
colorfast/P
colorfastness/M
colorful/PY
colorfulness/M
coloring's
colorist/S
colorization/M
colorize/DSG
colorless/PY
colorlessness/M
colorway/S
colossal/Y
colossi
colossus/M
colostomy/SM
colostrum/M
colt/MS
coltish
columbine/SM
column/SMD
columnar
columnist/SM
com/JL
coma/MS
comaker/SM
comatose
comb/MDRZGJS
combat/SMDGV
combatant/SM
combativeness/M
combed/U
comber/M
combination/SM
combine's
combine/ADSG
combined/U
combiner/MS
combings/M
combo/SM
combustibility/M
combustible/MS
combustion/M
combustive
come/IMZGRS
comeback/MS
comedian/MS
comedic
comedienne/MS
comedown/MS
comedy/SM
comeliness/M
comely/RPT
comer's
comestible/SM
comet/SM
comeuppance/SM
comfit's
comfit/ES
comfort/ESMDG
comfortable/P
comfortableness/M
comfortably/U
comforter/MS
comforting/Y
comfortless
comfy/RT
comic/SM
comical/Y
comicality/M
coming/M
comity/M
comm
comma/SM
command/SMDRLZG
commandant/MS
commandeer/GDS
commander/M
commandment/MS
commando/SM
commemorate/XGNVDS
commemoration/M
commemorator/MS
commence/ADSLG
commencement/AM
commencements
commend/ASDBG
commendably
commendation/AMS
commendatory
commensurable
commensurate/IY
comment/GSMD
commentary/SM
commentate/DSG
commentator/SM
commerce/M
commercial/SMY
commercialism/M
commercialization/M
commercialize/GDS
commie/SM
commingle/DSG
commiserate/GNVDSX
commiseration/M
commissar/SM
commissariat/SM
commissary/SM
commission's
commission/ACSGD
commissionaire/S
commissioner/SM
commit/AS
commitment/MS
committal/SM
committed/AU
committee/SM
committeeman/M
committeemen
committeewoman/M
committeewomen
committer/S
committing/A
commode's
commode/EIS
commodification
commodious/Y
commodity/SM
commodore/SM
common's
common/UPRYT
commonality/S
commonalty/M
commoner/MS
commonness/UM
commonplace/MS
commons
commonsense
commonweal/MH
commonwealth/M
commonwealths
commotion/SM
communal/Y
commune/XDSMGN
communicability/M
communicable/I
communicably
communicant/MS
communicate/GNVDSX
communication/M
communicative/U
communicator/SM
communion/M
communique/SM
communism/M
communist/SM
communistic
community/SM
commutation/MS
commutative
commutator/SM
commute/BDRSMZG
commuter/M
comp/MDYGS
compact/TGSMDRYP
compaction
compactness/M
compactor/SM
companion/SBM
companionably
companionship/M
companionway/MS
company/SM
comparability/M
comparable/I
comparably/I
comparative/MYS
compare/BDSMG
comparison/MS
compartment/SM
compartmental
compartmentalization/M
compartmentalize/DSG
compass/GMDS
compassion/M
compassionate/Y
compatibility/IM
compatible/IMS
compatibly/I
compatriot/MS
compeer/SM
compel/S
compelled
compelling/Y
compendious
compendium/SM
compensate/DSXGN
compensated/U
compensation/M
compensatory
compere/DSG
compete/DSG
competence/IM
competences
competencies
competency/IM
competent/IY
competition/SM
competitive/PY
competitiveness/M
competitor/SM
compilation/SM
compile/DRSZG
compiler/M
complacence/M
complacency/M
complacent/Y
complain/DRZGS
complainant/MS
complainer/M
complaint/SM
complaisance/M
complaisant/Y
complected
complement/SGMD
complementary
complete/PYTGNXDRS
completed/U
completeness/IM
completion/M
complex/MSY
complexion/MDS
complexional
complexity/SM
compliance/M
compliant/Y
complicate/GDS
complicated/Y
complication/M
complicit
complicity/M
compliment/MDGS
complimentary/U
comply/NDSXG
compo/S
component/SM
comport/LSGD
comportment/M
compose/AECGSD
composedly
composer/MS
composite/MYGNXDS
composition/CM
compositor/SM
compost/SGMD
composure/EM
compote/SM
compound/GMDBS
compounded/U
comprehend/SDG
comprehensibility/IM
comprehensible/I
comprehensibly/I
comprehension/IM
comprehensions
comprehensive/PMYS
comprehensiveness/M
compress's
compress/CGDS
compressed/U
compressible
compression/CM
compressor/SM
comprise/GDS
compromise/MGDS
comptroller/MS
compulsion/MS
compulsive/YP
compulsiveness/M
compulsorily
compulsory/SM
compunction/SM
computation/SM
computational/Y
compute/ADSG
computer/MS
computerate
computerization/M
computerize/GDS
computing/M
comrade/SMY
comradeship/M
con/GSM
concatenate/XDSGN
concatenation/M
concave/YP
concaveness/M
conceal/SDRZGBL
concealed/U
concealer/M
concealment/M
conceit/SMD
conceited/PY
conceitedness/M
conceivable/I
conceivably/I
conceive/DSGB
concentrate/DSMGNX
concentration/M
concentric
concentrically
concept/SM
conception/SM
conceptional
conceptual/Y
conceptualization/MS
conceptualize/DSG
concern/UMD
concerned/UY
concerning
concerns
concert's
concert/ESDG
concerted/Y
concertgoer/S
concertina/SGMD
concertize/DSG
concertmaster/MS
concerto/SM
concessionaire/MS
concessional
concessionary
conch/M
conchie/S
conchs
concierge/MS
conciliate/DSGN
conciliation/AM
conciliator/SM
conciliatory
concise/RPYTN
conciseness/M
concision/M
conclave/SM
conclude/DSG
conclusion/MS
conclusive/IYP
conclusiveness/IM
concoct/SDG
concoction/MS
concomitant/MYS
concord/M
concordance/SM
concordant
concordat/SM
concourse/SM
concrete/DSPMYGNX
concreteness/M
concretion/M
concubinage/M
concubine/MS
concupiscence/M
concupiscent
concur/S
concurred
concurrence/SM
concurrency
concurring
concuss/V
concussion/SM
condemn/SDRZG
condemnation/MS
condemnatory
condemner/M
condensate/MNXS
condensation/M
condense/DRSZG
condenser/M
condescending/Y
condescension/M
condign
condiment/MS
condition's
condition/AGSD
conditional/SMY
conditioned/U
conditioner/SM
conditioning/M
condo/SM
condolence/SM
condom/SM
condominium/MS
condone/DSG
condor/SM
conduce/DSGV
conduct/MDGV
conductance/M
conductibility/M
conductible
conduction/M
conductivity/M
conductor/MS
conductress/MS
conduit/SM
cone/M
coneys
confab/SM
confabbed
confabbing
confabulate/XDSGN
confabulation/M
confection/SZMR
confectioner/M
confectionery/SM
confederacy/SM
confederate/M
confer/S
conferee/SM
conference/MGS
conferrable
conferral/M
conferred
conferrer/MS
conferring
confessed/Y
confession/SM
confessional/SM
confessor/MS
confetti/M
confidant/MS
confidante/SM
confide/DRSZG
confidence/SM
confident/Y
confidential/Y
confidentiality/M
confider/M
confiding/Y
configuration/S
configure/B
confined/U
confinement/MS
confirm/ASDG
confirmation/ASM
confirmatory
confirmed/U
confiscate/DSGNX
confiscation/M
confiscator/SM
confiscatory
conflagration/MS
conflate/XDSGN
conflation/M
conflict/SGMD
confluence/MS
confluent
conform/ZB
conformable/U
conformance/M
conformism/M
conformist/SM
conformity/M
confrere/MS
confrontation/SM
confrontational
confuse/RZ
confused/Y
confusing/Y
confutation/M
confute/DSG
conga/SMDG
congeal/SLDG
congealment/M
conger/SM
congeries/M
congest/SDGV
congestion/M
conglomerate/DSXMGN
conglomeration/M
congrats/M
congratulate/XGNDS
congratulation/M
congratulatory
congregant/MS
congregate/GNDSX
congregation/M
congregational
congregationalism/M
congregationalist/MS
congress/MS
congressional
congressman/M
congressmen
congresspeople
congressperson/MS
congresswoman/M
congresswomen
congruence/M
congruent/Y
congruity/ISM
congruous
conic/SM
conical/Y
conifer/SM
coniferous
conjectural
conjecture/MGDS
conjoint
conjugal/Y
conjugate/DSXGN
conjugation/M
conjunct/VMS
conjunctiva/SM
conjunctive/SM
conjunctivitis/M
conjuration/MS
conjure/DRSZG
conjurer/M
conk/MDRZ
conman
connect/AEDVGS
connectable
connected/U
connection/EMS
connective/MS
connectivity/M
connector/MS
conned
conning
conniption/MS
connivance/M
connive/DRSZG
conniver/M
connoisseur/SM
connotative
connubial
conquer/ASDG
conquerable/U
conquered/U
conqueror/MS
conquest/AM
conquistador/SM
cons/DSG
consanguineous
consanguinity/M
conscienceless
conscientious/PY
conscientiousness/M
conscious/UYP
consciousness/UM
consciousnesses
conscription/M
consecrate/ADSGN
consecrated/U
consecration/AM
consecrations
consecutive/Y
consensual
consensus/MS
consent/SMDG
consequence/SM
consequent/Y
consequential/IY
conservancy/SM
conservation/M
conservationism/M
conservationist/SM
conservatism/M
conservative/MYS
conservatoire/S
conservator/SM
conservatory/SM
consider/AGSD
considerable/I
considerably
considerate/IPYN
considerateness/IM
consideration/AIM
considerations
considered/U
consign/ASDG
consignee/MS
consignment/MS
consist/SDG
consistence/MS
consistency/ISM
consistent/IY
consistory/SM
consolable/I
consolation/MS
consolatory
consolidate/XDSGN
consolidated/U
consolidation/M
consolidator/MS
consoling/Y
consomme/M
consonance/SM
consonant/SMY
consortia
consortium/M
conspectus/MS
conspicuous/IPY
conspicuousness/IM
conspiracy/SM
conspirator/MS
conspiratorial/Y
conspire/GD
constable/SM
constabulary/SM
constancy/IM
constant/MYS
constellation/SM
consternation/M
constipate/GNDS
constipation/M
constituency/SM
constituent/SM
constitute/ADSGNV
constitution/AM
constitutional/MYS
constitutionalism
constitutionality/UM
constitutions
constrained/U
constraint/SM
constrict/GVSD
constriction/SM
constrictor/SM
construable
construct's
construct/CADVGS
construction/CAMS
constructional
constructionist's
constructionist/CS
constructive/YP
constructiveness/M
constructor/MS
construe/GDS
consul/KSM
consular/K
consulate/SM
consulship/M
consult/GSD
consultancy/SM
consultant/MS
consultation/MS
consultative
consumable/SM
consume/BDRSZG
consumed/U
consumer/M
consumerism/M
consumerist/MS
consummate/YGNXDS
consummated/U
consumption/M
consumptive/SM
cont
contact/ASDG
contactable
contagion/MS
contagious/PY
contagiousness/M
contain/SBLDRZG
container/M
containerization/M
containerize/DSG
containment/M
contaminant/SM
contaminate/ACDSG
contaminated/U
contamination/CM
contaminator/SM
contd
contemn/SDG
contemplate/DSGNV
contemplation/M
contemplative/SMY
contemporaneity/M
contemporaneous/Y
contempt/M
contemptible
contemptibly
contemptuous/YP
contemptuousness/M
contender/MS
content/ESLMDG
contented/EY
contentedness/M
contention/SM
contentious/YP
contentiousness/M
contently
contentment/EM
conterminous/Y
contestable/I
contestant/MS
contested/U
contextualization
contextualize/DSG
contiguity/M
contiguous/Y
continence/IM
continent/SM
continental/SM
contingency/SM
contingent/SMY
continua
continual/Y
continuance/EMS
continuation/EMS
continue/EGDS
continuity/ESM
continuous/EY
continuum/M
contort/GD
contortion/MS
contortionist/SM
contraband/M
contrabassoon/S
contraception/M
contraceptive/SM
contract/MDG
contractible
contractile
contractility
contraction/S
contractual/Y
contradict/SDG
contradiction/SM
contradictory
contradistinction/MS
contraflow/S
contrail/MS
contraindicate/GNXDS
contraindication/M
contralto/SM
contraption/SM
contrapuntal/Y
contrarian/SM
contrarianism
contrariety/M
contrarily
contrariness/M
contrariwise
contrary/PSM
contrast/MDGS
contravene/GDS
contravention/SM
contretemps/M
contribute/XGND
contribution/M
contributor/MS
contributory
contrition/M
contrivance/MS
contrive/ZGDRS
contriver/M
control's
control/CS
controllable/U
controlled/UC
controller/MS
controlling/C
controversial/Y
controversy/SM
controvert/DSG
controvertible/I
contumacious/Y
contumacy/M
contumelious
contumely/SM
contuse/XDSGN
contusion/M
conundrum/SM
conurbation/MS
convalesce/DSG
convalescence/MS
convalescent/SM
convection/M
convectional
convective
convector/S
convene/ADSG
convener/MS
convenience/IMS
convenient/IY
convent/SM
conventicle/MS
convention/SM
conventional/UY
conventionality/UM
conventionalize/GDS
conventioneer/S
convergence/MS
convergent
conversant
conversation/MS
conversational/Y
conversationalist/SM
converse/Y
convert's
convert/AGSD
converted/U
converter/SM
convertibility/M
convertible/SM
convex/Y
convexity/M
convey/SBDG
conveyance/MGS
conveyor/MS
convict/GSMD
conviction/MS
convince/GDS
convinced/U
convincing/UY
convivial/Y
conviviality/M
convoke/DSG
convoluted
convolution/MS
convoy/SMDG
convulse/GNVXDS
convulsion/M
convulsive/Y
cony/M
coo/GSMD
cook's
cook/ADGS
cookbook/MS
cooked/U
cooker/SM
cookery/SM
cookhouse/S
cookie/SM
cooking/M
cookout/SM
cookware/SM
cool/MDRYZTGPS
coolant/SM
cooler/M
coolie/SM
coolness/M
coon/MS!
coonskin/MS
coop/MDRZGS
cooper/MDG
cooperage/M
cooperate/DSGNV
cooperation/M
cooperative/PMYS
cooperativeness/M
cooperator/SM
coordinate/DSMYGN
coordinated/U
coordination/M
coordinator/MS
coot/MS
cootie/SM
cop/GJSMD
copacetic
copay/M
cope/MS
copier/SM
copilot/SM
coping/M
copious/PY
copiousness/M
copped
copper/SM
copperhead/SM
copperplate/M
coppery
copping
copra/M
copse/SM
copter/SM
copula/SM
copulate/GNVDS
copulation/M
copulative/SM
copy's
copy/ADSG
copybook/SM
copycat/MS
copycatted
copycatting
copyist/MS
copyleft
copyright/GSMD
copywriter/MS
coquetry/SM
coquette/DSMG
coquettish/Y
cor
coracle/SM
coral/SM
corbel/SM
cord/EASGDM
cordage/M
cordial/SMY
cordiality/M
cordillera/MS
cordite/M
cordless
cordon/SMDG
cordovan/M
corduroy/MS
corduroys/M
core/MZGDRS
coreligionist/S
corer/M
corespondent/MS
corgi/SM
coriander/M
cork's
cork/UDGS
corkage
corker/SM
corkscrew/SMDG
corm/MS
cormorant/SM
corn/MDRZGS
cornball/MS
cornbread/M
corncob/MS
corncrake/S
cornea/SM
corneal
corner/GMD
cornerstone/SM
cornet/SM
cornfield/S
cornflakes/M
cornflour
cornflower/SM
cornice/MS
cornily
corniness/M
cornmeal/M
cornrow/MDGS
cornstalk/SM
cornstarch/M
cornucopia/MS
corny/PRT
corolla/MS
corollary/SM
corona/SM
coronal/MS
coronary/SM
coronation/SM
coroner/MS
coronet/MS
corp
corpora
corporal/SM
corporate/XYN
corporation/IM
corporatism
corporeal/Y
corporeality/M
corps/MS
corpse/M
corpsman/M
corpsmen
corpulence/M
corpulent
corpus/M
corpuscle/MS
corpuscular
corr
corral/SM
corralled
corralling
correct/DRYTGVSBP
corrected/U
correction/SM
correctional
corrective/SM
correctness/IM
corrector
correlate/XDSMGNV
correlated/U
correlation/M
correlative/MS
correspond/SDG
correspondence/SM
correspondent/SM
corresponding/Y
corridor/SM
corrie/S
corroborate/GNVDSX
corroborated/U
corroboration/M
corroborator/SM
corroboratory
corrode/GDS
corrosion/M
corrosive/SMY
corrugate/GNXDS
corrugation/M
corrupt/DRYPSTG
corruptibility/IM
corruptible/I
corruption/MS
corruptness/M
corsage/MS
corsair/MS
corset/SGMD
cortege/MS
cortex/M
cortical
cortices
cortisone/M
corundum/M
coruscate/GNDS
coruscation/M
corvette/SM
cos/M
cosh/DSG
cosign/ZGSDR
cosignatory/SM
cosigner/M
cosine/SM
cosmetic/SM
cosmetically
cosmetician/MS
cosmetologist/MS
cosmetology/M
cosmic
cosmically
cosmogonist/SM
cosmogony/SM
cosmological
cosmologist/SM
cosmology/SM
cosmonaut/SM
cosmopolitan/MS
cosmopolitanism/M
cosmos/MS
cosplay
cosponsor/GSMD
cosset/SGD
cossetted
cossetting
cost/MDYGSJ
costar/SM
costarred
costarring
costliness/M
costly/PTR
costume/MZGDRS
costumer/M
costumier/S
cot/SM
cotangent/MS
cote/MS
coterie/MS
coterminous
cotillion/SM
cottage/MZGRS
cottager/M
cottar/SM
cotter/SM
cotton/SGMD
cottonmouth/M
cottonmouths
cottonseed/MS
cottontail/MS
cottonwood/SM
cottony
cotyledon/MS
couch/MDSG
couchette/S
cougar/SM
cough/MDG
coughs
could
could've
couldn't
coulee/SM
coulis
coulomb/MS
council/MS
councilman/M
councilmen
councilor/MS
councilperson/SM
councilwoman/M
councilwomen
counsel/JMDGS
counselor/MS
count/EASMDG
countable/U
countably
countdown/MS
counted/U
countenance's
countenance/EGDS
counter/EMS
counteract/SGVD
counteraction/MS
counterargument/S
counterattack/GMDS
counterbalance/MGDS
counterblast/S
counterclaim/GSMD
counterclockwise
counterculture/SM
countered
counterespionage/M
counterexample/S
counterfactual
counterfeit/ZGMDRS
counterfeiter/M
counterfoil/MS
countering
counterinsurgency/SM
counterintelligence/M
counterman/M
countermand/GMDS
countermeasure/SM
countermelody/S
countermen
countermove/S
counteroffensive/SM
counteroffer/SM
counterpane/SM
counterpart/SM
counterpetition
counterpoint/MDGS
counterpoise/MGDS
counterproductive
counterrevolution/SM
counterrevolutionary/SM
countersign/GSMD
countersignature/MS
countersink/GSM
counterspy/SM
countersunk
countertenor/MS
countervail/GSD
counterweight/MS
countess/MS
countless
countrified
country/SM
countryman/M
countrymen
countryside/MS
countrywide
countrywoman/M
countrywomen
county/SM
countywide
coup's
coup/AS
coupe/SM
couple's
couple/UCGSD
couplet/MS
coupling/SM
coupon/SM
courage/M
courageous/YP
courageousness/M
courgette/S
courier/MDSG
course/EDGMS
coursebook/S
courser/MS
coursework
court/SMDYG
courteous/EY
courteousness/M
courtesan/SM
courtesy/ESM
courthouse/MS
courtier/SM
courtliness/M
courtly/PRT
courtroom/MS
courtship/MS
courtyard/MS
couscous/M
cousin/SM
couture/M
couturier/MS
cove/MS
coven/SM
covenant/MDSG
cover's
cover/AEUGDS
coverage/M
coverall/MS
covering's
coverings
coverlet/MS
covert/SPMY
covertness/M
covet/SDG
covetous/YP
covetousness/M
covey/SM
cow/ZGSMDR
coward/SMY
cowardice/M
cowardliness/M
cowbell/MS
cowbird/MS
cowboy/SM
cowcatcher/MS
cower/DG
cowgirl/MS
cowhand/MS
cowherd/MS
cowhide/MS
cowl/MGSJ
cowlick/MS
cowling/M
cowman/M
cowmen
coworker/MS
cowpat/S
cowpoke/MS
cowpox/M
cowpuncher/SM
cowrie/SM
cowshed/S
cowslip/SM
cox/GDS
coxcomb/MS
coxswain/MS
coy/TPRY
coyness/M
coyote/SM
coypu/SM
cozen/SDG
cozenage/M
cozily
coziness/M
cozy/RSMTP
cpd
cpl
cps
crab/MS
crabbed
crabber/SM
crabbily
crabbiness/M
crabbing
crabby/PRT
crabgrass/M
crablike
crabwise
crack/SMDRYZGJ
crackdown/MS
cracker/M
crackerjack/MS
crackhead/MS
crackle/DSJMG
crackling/M
crackpot/MS
crackup/SM
cradle/DSMG
craft/SMDG
craftily
craftiness/M
craftsman/M
craftsmanship/M
craftsmen
craftspeople
craftswoman/M
craftswomen
crafty/RTP
crag/MS
cragginess/M
craggy/RPT
cram/S
crammed
crammer/S
cramming
cramp/SMDG
cramping/M
crampon/SM
cranberry/SM
crane/DSMG
cranial
cranium/SM
crank/SMDG
crankcase/SM
crankily
crankiness/M
crankshaft/MS
cranky/PRT
cranny/DSM
crap/MS
crape/SM
crapped
crapper/S
crappie/RSMT
crapping
crappy
craps/M
crapshooter/MS
crash/MDSG
crass/RYTP
crassness/M
crate/DRSMZG
crater/MDG
cravat/SM
crave/DSGJ
craven/SMYP
cravenness/M
craving/M
craw/MS
crawdad/SM
crawl/SMDRZG
crawler/M
crawlspace/SM
crawly/TRSM
cray/S
crayfish/MS
crayola/S
crayon/GSMD
craze/DSMG
crazily
craziness/M
crazy/PRSMT
creak/SMDG
creakily
creakiness/M
creaky/RPT
cream/SMDRZG
creamer/M
creamery/SM
creamily
creaminess/M
creamy/RPT
crease/ICGMSD
create/KADSGNV
creation's/K
creation/ASM
creationism/SM
creationist/SM
creative/SMYP
creativeness/M
creativity/M
creator/MS
creature/SM
creche/SM
cred
credence/M
credential/SGMD
credenza/SM
credibility/IM
credible/I
credibly/I
credit/EGSBMD
creditably/E
creditor/SM
creditworthy/P
credo/SM
credulity/IM
credulous/IY
credulousness/M
creed/SM
creek/SM
creel/SM
creep/SMRZG
creeper/M
creepily
creepiness/M
creepy/TPR
cremains/M
cremate/GNDSX
cremation/M
crematoria
crematorium/MS
crematory/SM
creme/SM
crenelate/XGNDS
crenelation/M
creole/SM
creosote/MGDS
crepe/SM
crept
crepuscular
crescendo/CSM
crescent/MS
cress/M
crest/SMDG
crestfallen
crestless
cretaceous
cretin/SM
cretinism/M
cretinous
cretonne/M
crevasse/SM
crevice/MS
crew/MDGS
crewel/M
crewelwork/M
crewman/M
crewmen
crib/MS
cribbage/M
cribbed
cribber/MS
cribbing
crick/SMDG
cricket/MRSZG
cricketer/M
crier/M
crikey
crime/SM
criminal/MYS
criminality/M
criminalize/CGDS
criminologist/MS
criminology/M
crimp/SMDG
crimson/SMDG
cringe/DSMG
crinkle/DSMG
crinkly/RT
crinoline/SM
cripes
cripple/DRSMZG
crippler/M
crippleware
crippling/Y
crises
crisis/M
crisp/SMDRYTGP
crispbread/S
crispiness/M
crispness/M
crispy/PRT
crisscross/GMDS
criteria
criterion/M
critic/SM
critical/UY
criticism/MS
criticize/ZGDRS
criticizer/M
critique/MGDS
critter/SM
croak/SMDG
croaky/RT
crochet/SMDRZG
crocheter/M
crocheting/M
crock/SMD
crockery/M
crocodile/SM
crocus/MS
croft/SRZG
croissant/MS
crone/SM
crony/SM
cronyism/M
crook/SMDG
crooked/PTRY
crookedness/M
crookneck/SM
croon/SMDRZG
crooner/M
crop/MS
cropland/SM
cropped
cropper/MS
cropping
croquet/M
croquette/SM
crosier/MS
cross's
cross/AUGTSD
crossbar/SM
crossbeam/MS
crossbones/M
crossbow/SM
crossbowman/M
crossbowmen
crossbred
crossbreed/SGM
crosscheck/SMDG
crosscurrent/MS
crosscut/SM
crosscutting
crosser
crossfire/MS
crosshatch/GDS
crossing/SM
crossly
crossness/M
crossover/MS
crosspatch/MS
crosspiece/SM
crossroad/MS
crossroads/M
crosstown
crosswalk/MS
crosswind/MS
crosswise
crossword/MS
crotch/MS
crotchet/SM
crotchety
crouch/GMDS
croup/M
croupier/M
croupy/ZTR
crouton/MS
crow/MDGS
crowbar/MS
crowd/SMDG
crowded/U
crowdfund/SDG
crowfeet
crowfoot/SM
crown/SMDG
crowned/U
crucial/Y
crucible/SM
crucifix/MS
crucifixion/SM
cruciform/SM
crucify/DSG
crud/M
cruddy/TR
crude/RMYTP
crudeness/M
crudites/M
crudity/SM
cruel/RYPT
cruelness/M
cruelty/SM
cruet/SM
cruft/SD
crufty
cruise/DRSMZG
cruiser/M
cruller/MS
crumb/SMDYG
crumble/MGDS
crumbliness/M
crumbly/TPR
crumby/TR
crumminess/M
crummy/PTR
crumpet/MS
crumple/MGDS
crunch/GMDRS
crunchiness/M
crunchy/TRP
crupper/MS
crusade/MZGDRS
crusader/M
cruse/SM
crush/MDRSZG
crusher/M
crushing/Y
crust/SMDG
crustacean/SM
crustal
crustily
crustiness/M
crusty/TRP
crutch/MS
crux/MS
cry/ZGJDRSM
crybaby/SM
cryogenic/S
cryogenics/M
cryonics
cryosurgery/M
crypt/SM
cryptic
cryptically
cryptogram/SM
cryptographer/SM
cryptography/M
crystal/SM
crystalline
crystallization/M
crystallize/ADSG
crystallographic
crystallography
ct
ctn
ctr
cu
cub/ZGSMDR
cubbyhole/MS
cube/MS
cuber/M
cubic
cubical
cubicle/MS
cubism/M
cubist/SM
cubit/SM
cuboid/S
cuckold/MDSG
cuckoldry/M
cuckoo/SM
cucumber/SM
cud/SM
cuddle/DSMG
cuddly/TR
cudgel/SGMDJ
cue/DSMG
cuff/MDGS
cuisine/SM
culinary
cull/MDGS
culminate/XDSGN
culmination/M
culotte/SM
culpability/M
culpable/I
culpably
culprit/SM
cult/MS
cultism/M
cultist/MS
cultivable
cultivar/S
cultivate/BDSGN
cultivated/U
cultivation/M
cultivator/MS
cultural/Y
culture/MGDS
cultured/U
culvert/MS
cum/SM
cumber/SDG
cumbersome/P
cumbersomeness/M
cumbrous
cumin/M
cummerbund/MS
cumming
cumulative/Y
cumuli
cumulonimbi
cumulonimbus/M
cumulus/M
cuneiform/M
cunnilingus/M
cunning/MRYT
cunt/MS!
cup/SM
cupboard/SM
cupcake/MS
cupful/SM
cupid/SM
cupidity/M
cupola/SMD
cuppa/S
cupped
cupping
cupric
cur/SMY
curability/M
curacao
curacy/SM
curare/M
curate/DSMGV
curative/MS
curator/KMS
curatorial
curb/MDGS
curbing/M
curbside
curbstone/SM
curd/MS
curdle/DSG
cure's
cure/KZGBDRS
cured/U
curer/KM
curettage/M
curfew/SM
curia/M
curiae
curie/SM
curio/SM
curiosity/SM
curious/YP
curiousness/M
curium/M
curl's
curl/UDGS
curler/SM
curlew/SM
curlicue/DSMG
curliness/M
curling/M
curly/RPT
curmudgeon/MYS
currant/MS
currency/SM
current's
current/FAY
currents
curricula
curricular
curriculum/M
curry/DSMG
currycomb/SGMD
curse/DSMGV
cursed/Y
cursive's
cursive/EAY
cursor/SM
cursorily
cursoriness/M
cursory/P
curt/RYTP
curtail/GDSL
curtailment/SM
curtain/GMDS
curtness/M
curtsy/GDSM
curvaceous/P
curvaceousness/M
curvature/SM
curve/DSMG
curvy/RT
cushion/MDSG
cushy/RT
cusp/MS
cuspid/SM
cuspidor/SM
cuss's
cuss/FEGSD
cussed/PY
custard/MS
custodial
custodian/MS
custodianship/M
custody/M
custom/SZMR
customarily
customary/U
customer/M
customhouse/SM
customization/M
customize/DSG
cut/TSMR
cutaneous
cutaway/MS
cutback/MS
cute/YP
cuteness/M
cutesy/TR
cutey/S
cuticle/MS
cutie/SM
cutlass/MS
cutler/SM
cutlery/M
cutlet/SM
cutoff/SM
cutout/SM
cutter/SM
cutthroat/SM
cutting/MYS
cuttlefish/MS
cutup/SM
cutworm/MS
cw
cwt
cyan/M
cyanide/M
cyberbully/SM
cybercafe/S
cybernetic/S
cybernetics/M
cyberpunk/SM
cybersex
cyberspace/MS
cyborg/SM
cyclamen/MS
cycle/ADSMG
cyclic
cyclical/Y
cyclist/MS
cyclometer/MS
cyclone/MS
cyclonic
cyclopedia/MS
cyclopes
cyclops/M
cyclotron/MS
cygnet/MS
cylinder/MS
cylindrical
cymbal/MS
cymbalist/MS
cynic/SM
cynical/Y
cynicism/M
cynosure/MS
cypress/MS
cyst/MS
cystic
cystitis
cytokines
cytologist/SM
cytology/M
cytoplasm/M
cytoplasmic
cytosine/M
czar/MS
czarina/SM
czarism
czarist/SM
d'Arezzo/M
d'Estaing/M
d/NXGJ
dB
dab/SM
dabbed
dabber/MS
dabbing
dabble/ZGDRS
dabbler/M
dace/SM
dacha/MS
dachshund/MS
dactyl/MS
dactylic/MS
dad/SM
dadaism/M
dadaist/MS
daddy/SM
dado/M
dadoes
daemon/MS
daemonic
daffiness/M
daffodil/SM
daffy/PTR
daft/PTRY
daftness/M
dag/S
dagger/MS
dago/S
dagoes
daguerreotype/DSMG
dahlia/MS
dailiness/M
daily/PSM
daintily
daintiness/M
dainty/RSMTP
daiquiri/MS
dairy/GSM
dairying/M
dairymaid/MS
dairyman/M
dairymen
dairywoman/M
dairywomen
dais/MS
daisy/SM
dale/SM
dalliance/MS
dallier/M
dally/ZGDRS
dalmatian/MS
dam/SM
damage/MGDS
damageable
damaged/U
damages/M
damask/MDGS
dame/SM
dammed
damming
dammit
damn/SBGMD
damnably
damnation/M
damned/T
damp/SPXZTGMDNRY
dampen/ZGDR
dampener/M
damper/M
dampness/M
damsel/MS
damselfly/SM
damson/MS
dance/MZGDRS
dancer/M
dancing/M
dandelion/SM
dander/M
dandify/GDS
dandle/GDS
dandruff/M
dandy/TRSM
dang/SZGDR
danger/M
dangerous/Y
dangle/ZGDRS
dangler/M
danish/MS
dank/PTRY
dankness/M
danseuse/MS
dapper/TR
dapple/MGDS
dare/DRSMZG
daredevil/MS
daredevilry/M
darer/M
daresay
daring/MY
dark/PXTMNRY
darken/ZGDR
darkener/M
darkie/S
darkness/M
darkroom/MS
darling/MS
darn/SZGMDR
darned/TR
darner/M
dart/SZGMDR
dartboard/MS
darter/M
dash/ZGMDRS
dashboard/SM
dasher/M
dashiki/MS
dashing/Y
dastard/MYS
dastardliness/M
data
database/SM
datatype
date/DRSMZGV
datebook/S
dated/U
dateless
dateline/MGDS
dater/M
dative/MS
datum/M
daub/SZGMDR
dauber/M
daughter/SMY
daunt/GDS
daunting/Y
dauntless/YP
dauntlessness/M
dauphin/MS
davenport/MS
davit/MS
dawdle/ZGDRS
dawdler/M
dawn/SGMD
day/SM
daybed/MS
daybreak/M
daycare/M
daydream/MDRZGS
daydreamer/M
daylight/MS
daylights/M
daylong
daytime/M
daze/DSMG
dazed/Y
dazzle/MZGDRS
dazzler/M
dazzling/Y
db
dbl
dc
dd/SDG
dded/K
dding/K
deacon/MS
deaconess/MS
dead/XTMNRY
deadbeat/MS
deadbolt/SM
deaden/GD
deadhead/SDG
deadline/SM
deadliness/M
deadlock/GSMD
deadly/TPR
deadpan/MS
deadpanned
deadpanning
deadwood/M
deaf/PXTNR
deafen/GD
deafening/Y
deafness/M
deal/SJZGMR
dealer/M
dealership/SM
dealing/M
dealt
dean/M
deanery/SM
deanship/M
dear/SPTMRYH
dearest/S
dearness/M
dearth/M
dearths
deary/SM
death/MY
deathbed/SM
deathblow/MS
deathless/Y
deathlike
deaths
deathtrap/MS
deathwatch/MS
deaves
deb/SM
debacle/MS
debarkation/M
debarment/M
debate/BMZR
debater/M
debating/M
debauch/MDSG
debauchee/MS
debauchery/SM
debenture/MS
debilitate/DSGN
debilitation/M
debility/SM
debit/D
debonair/PY
debonairness/M
debouch/GDS
debridement
debris/M
debt/SM
debtor/MS
debugger/S
debut/GMD
debutante/SM
decade/MS
decadence/M
decadency/M
decadent/MYS
decaf/MS
decaffeinate/DSG
decagon/MS
decal/MS
decampment/M
decapitate/XGNDS
decapitator/MS
decathlete/S
decathlon/SM
decay/GD
deceased/M
decedent/MS
deceit/MS
deceitful/YP
deceitfulness/M
deceive/UGDS
deceiver/MS
deceiving/Y
decelerate/GNDS
deceleration/M
decelerator/SM
decency/ISM
decennial/SM
decent/IY
deception/MS
deceptive/YP
deceptiveness/M
decibel/MS
decidable/U
decide/BZGDRS
decided/Y
deciduous
deciliter/MS
decimal/SM
decimalization
decimate/DSGN
decimation/M
decimeter/MS
decipherable/UI
decision/IM
decisions
decisive/IPY
decisiveness/IM
deck/SGMD
deckchair/S
deckhand/SM
deckle/S
declamation/MS
declamatory
declaration/MS
declarative
declaratory
declare/DRSZGB
declared/U
declarer/M
declension/SM
declination/M
decline/DRSMZG
decliner/M
declivity/SM
decolletage/SM
decollete
decongestant/MS
deconstructionism
decor/MS
decorate/AGNVDS
decorating/M
decoration/AM
decorations
decorative/Y
decorator/MS
decorous/IY
decorousness/M
decorum/M
decoupage/DSMG
decoy/GMDS
decreasing/Y
decree/MDS
decreeing
decremented
decrements
decrepit
decrepitude/M
decriminalization/M
decry/GDS
decryption
dedicate/AGDS
dedication/SM
dedicator/SM
dedicatory
deduce/GDS
deducible
deduct/GVD
deductible/SM
deduction/SM
deductive/Y
deed/GD
deejay/MS
deem/ASGD
deep/SPXTMNRY
deepen/GD
deepness/M
deer/M
deerskin/M
deerstalker/S
def/Z
defacement/M
defacer/SM
defalcate/DSXGN
defalcation/M
defamation/M
defamatory
defame/ZGDRS
defamer/M
defaulter/SM
defeat/MDRZGS
defeated/U
defeater/M
defeatism/M
defeatist/MS
defecate/GNDS
defecation/M
defect/MDGVS
defection/MS
defective/MPYS
defectiveness/M
defector/MS
defendant/SM
defended/U
defenestration/S
defense/DSMGV
defenseless/YP
defenselessness/M
defensible/I
defensibly/I
defensive/MYP
defensiveness/M
deference/M
deferential/Y
deferral/MS
deferred
deferring
deffer
deffest
defiant/Y
defibrillation
defibrillator/S
deficiency/SM
deficient
deficit/SM
defilement/M
definable/IU
define/AGDS
defined/U
definer/MS
definite/IYVP
definiteness/IM
definition/AM
definitions
definitive/Y
deflate/GNDS
deflation/M
deflationary
deflect/DGVS
deflection/MS
deflector/SM
defogger/SM
defoliant/SM
defoliate/DSGN
defoliation/M
defoliator/MS
deformity/SM
defraud/DRZGS
defrauder/M
defrayal/M
defrock/DG
defroster/MS
deft/PTRY
deftness/M
defunct
defy/GDS
deg
degeneracy/M
degenerate/MV
degrade/B
degree/MS
dehydrator/SM
dehydrogenase
deicer/MS
deification/M
deify/NGDS
deign/GDS
deist/MS
deistic
deity/SM
deject/GDS
dejected/Y
dejection/M
delay/ZDR
delectable
delectably
delectation/M
delegate/GD
delete/XGNDS
deleterious
deletion/M
delft/M
delftware/M
deli/SM
deliberate/XYVP
deliberateness/M
delicacy/ISM
delicate/IY
delicateness/M
delicatessen/SM
delicious/PY
deliciousness/M
delighted/Y
delightful/Y
deliminator
delineate/GNXDS
delineation/M
delinquency/SM
delinquent/SMY
deliquesce/DSG
deliquescent
delirious/YP
deliriousness/M
delirium/SM
deliver/ADGS
deliverable
deliverance/M
delivered/U
deliverer/SM
dell/SM
delphinium/MS
delta/MS
delude/GDS
deluge/MGDS
delusion/MS
delusional
delusive/Y
deluxe
delve/ZGDRS
delver/M
demagogic
demagogically
demagogue/SM
demagoguery/M
demagogy/M
demand/GMDS
demanding/U
demarcate/DSGNX
demarcation/M
demean/GDS
demeanor/M
demented/Y
dementia/M
demesne/MS
demigod/MS
demigoddess/MS
demijohn/SM
demimondaine/SM
demimonde/M
demise/MGDS
demitasse/MS
demo/GMD
democracy/SM
democrat/MS
democratic/U
democratically
democratization/M
democratize/GDS
demode
demographer/SM
demographic/SM
demographically
demographics/M
demography/M
demolish/DSG
demolition/MS
demon/MS
demonetization/M
demoniac
demoniacal/Y
demonic
demonically
demonize/GDS
demonology/SM
demonstrability
demonstrable/I
demonstrably
demonstrate/XGNVDS
demonstration/M
demonstrative/MYSP
demonstrativeness/M
demonstrator/MS
demote/GD
demotic
demount
demulcent/SM
demur/TMRS
demure/PY
demureness/M
demurral/SM
demurred
demurrer/SM
demurring
den/M
denationalization
denaturation
denature/DG
dendrite/SM
dengue/M
deniability
deniable/U
denial/MS
denier/M
denigrate/DSGN
denigration/M
denim/MS
denitrification
denizen/MS
denominational
denotative
denouement/MS
denounce/LDSG
denouncement/SM
dense/PYTR
denseness/M
density/SM
dent/ISGMD
dental/Y
dentifrice/SM
dentin/M
dentist/MS
dentistry/M
dentition/M
denture/IMS
denuclearize/GDS
denudation/M
denude/GDS
denunciation/SM
deny/ZGDRS
deodorant/SM
deodorization/M
deodorize/DRSZG
deodorizer/M
departed/M
department/MS
departmental/Y
departmentalization/M
departmentalize/GDS
departure/SM
dependability/M
dependable/U
dependably
dependence/IM
dependency/SM
dependent/IMYS
depict/GDS
depiction/MS
depilatory/SM
deplete/GNDS
depletion/M
deplorably
deplore/BGDS
deploy/ALGDS
deployment/AM
deployments
deponent/MS
deportation/MS
deportee/MS
deportment/M
deposit/AGMDS
depositor/MS
depository/SM
deprave/GDS
depravity/SM
deprecate/GNDS
deprecating/Y
deprecation/M
deprecatory
depreciate/DSGN
depreciation/M
depredation/SM
depressant/SM
depressing/Y
depression/SM
depressive/SM
depressor/MS
depressurization
deprive/GDS
deprogramming
depth/M
depths
deputation/MS
depute/DSG
deputize/DSG
deputy/SM
derailleur/SM
derailment/SM
derangement/M
derby/SM
derelict/MS
dereliction/M
deride/GDS
derision/M
derisive/PY
derisiveness/M
derisory
derivation/MS
derivative/MS
derive/B
dermal
dermatitis/M
dermatological
dermatologist/SM
dermatology/M
dermis/M
derogate/DSGN
derogation/M
derogatorily
derogatory
derrick/SM
derriere/SM
derringer/SM
derv
dervish/MS
desalinate/GNDS
desalination/M
desalinization/M
desalinize/GDS
descant/M
descend/FGDS
descendant/MS
descender
describable/I
describe/BZGDR
describer/M
description/SM
descriptive/PY
descriptiveness/M
descriptor/S
descry/GDS
desecrate/DSGN
desecration/M
deselection
desert/SDRZGM
deserter/M
desertification
desertion/SM
deserved/UY
deserving/U
desiccant/SM
desiccate/DSGN
desiccation/M
desiccator/SM
desiderata
desideratum/M
design/ASDG
designate/DSGNX
designation/M
desirability/UM
desirableness/M
desirably/U
desire/B
desired/U
desirous
desist/SDG
desk/SM
deskill/G
desktop/SM
desolate/PDSYGN
desolateness/M
desolation/M
despair/SMDG
despairing/Y
desperado/M
desperadoes
desperate/YNP
desperateness/M
desperation/M
despicable
despicably
despise/DSG
despite
despoilment/M
despondence/M
despondency/M
despondent/Y
despotic
despotically
despotism/M
dessert/SM
dessertspoon/S
dessertspoonful/S
destination/SM
destine/DSG
destiny/SM
destitute/N
destitution/M
destroy/SZGDR
destroyer/M
destruct/GVMDS
destructibility/IM
destructible/I
destruction/M
destructive/PY
destructiveness/M
desuetude/M
desultorily
desultory
detach/BLGDS
detachment/MS
detain/LGDS
detainee/MS
detainment/M
detect/SDGVB
detectable/U
detected/U
detection/M
detective/SM
detector/SM
detente/SMNX
detention/M
deter/SL
detergent/SM
deteriorate/DSGN
deterioration/M
determent/M
determinable/I
determinant/SM
determinate
determine/AGDS
determined/U
determinedly
determiner/SM
determinism/M
deterministic
deterred/U
deterrence/M
deterrent/MS
deterring
detestably
detestation/M
dethrone/DSLG
dethronement/M
detonate/GNDSX
detonation/M
detonator/SM
detox/MDSG
detoxification/M
detoxify/DSGN
detract/GD
detriment/SM
detrimental/Y
detritus/M
deuce/SM
deuterium/M
devastate/GNDS
devastating/Y
devastation/M
devastator/MS
develop/ASGDL
developed/U
developer/SM
development/ASM
developmental/Y
deviance/M
deviancy/M
deviant/SM
deviate/DSMGNX
deviating/U
deviation/M
devil/SMDGL
devilish/YP
devilishness/M
devilment/M
devilry/SM
deviltry/SM
devious/YP
deviousness/M
devoid
devolution/M
devolve/DSG
devoted/Y
devotee/SM
devotion/MS
devotional/SM
devour/SDG
devout/PRYT
devoutness/M
dew/M
dewberry/SM
dewclaw/SM
dewdrop/SM
dewiness/M
dewlap/SM
dewy/RTP
dexterity/M
dexterous/YP
dexterousness/M
dextrose/M
dharma
dhoti/SM
dhow/MS
diabetes/M
diabetic/SM
diabolic
diabolical/Y
diacritic/MS
diacritical
diadem/SM
diaereses
diaeresis/M
diagnose/DSG
diagnosis/M
diagnostic/S
diagnostically
diagnostician/SM
diagnostics/M
diagonal/SMY
diagram/SM
diagrammatic
diagrammatically
diagrammed
diagramming
dial/AMDGS
dialect/SM
dialectal
dialectic/SM
dialectical
dialectics/M
dialing/S
dialog
dialogue/SM
dialyses
dialysis/M
dialyzes
diam
diamante
diameter/SM
diametric
diametrical/Y
diamond/SM
diamondback/MS
diapason/SM
diaper/SMDG
diaphanous
diaphragm/SM
diaphragmatic
diarist/SM
diarrhea/M
diary/SM
diaspora/SM
diastase/M
diastole/M
diastolic
diathermy/M
diatom/SM
diatomic
diatonic
diatribe/SM
dibble/DSMG
dibs/M
dice/GDS
dices/I
dicey
dichotomous
dichotomy/SM
dicier
diciest
dick/MRXZS
dicker/DG
dickey/SM
dickhead/S
dickybird/S
dicotyledon/MS
dicotyledonous
dict
dicta
dictate/DSMGNX
dictation/M
dictator/SM
dictatorial/Y
dictatorship/SM
diction/M
dictionary/SM
dictum/M
did/AU
didactic
didactically
diddle/DRSZG
diddler/M
diddly
diddlysquat
diddums
didgeridoo/S
didn't
dido/M
didoes
didst
die/DSM
dielectric/MS
diereses
dieresis/M
diesel/SMDG
diet/MDRZGS
dietary/SM
dieter/M
dietetic/S
dietetics/M
dietitian/MS
diff/DRZGS
differ/DG
difference/IM
differences
different/IY
differential/SM
differentiate/DSGN
differentiated/U
differentiation/M
difficult/Y
difficulty/SM
diffidence/M
diffident/Y
diffract/GSD
diffraction/M
diffuse/DSYGNVP
diffuseness/M
diffusion/M
dig/SM
digerati/M
digest/SMDGV
digested/U
digestibility/M
digestible/I
digestion/IM
digestions
digestive/S
digger/SM
digging/S
diggings/M
digicam/S
digit/SM
digital/Y
digitalis/M
digitization
digitize/GDS
dignified/U
dignify/DSG
dignitary/SM
dignity/ISM
digraph/M
digraphs
digress/GVDS
digression/MS
dike/MGDS
diktat/S
dilapidated
dilapidation/M
dilatation/M
dilate/DSGN
dilation/M
dilator/SM
dilatory
dildo/S
dilemma/MS
dilettante/SM
dilettantish
dilettantism/M
diligence/M
diligent/Y
dill/MS
dilly/SM
dillydally/DSG
dilute/DSGNX
diluted/U
dilution/M
dim/PSRY
dime/MS
dimension/SM
dimensional
dimensionless
diminish/GDS
diminished/U
diminuendo/SM
diminution/SM
diminutive/SM
dimity/M
dimmed/U
dimmer/SM
dimmest
dimming
dimness/M
dimple/DSMG
dimply
dimwit/SM
dimwitted
din/ZGSMDR
dinar/SM
dine/S
diner/M
dinette/MS
ding/MDG
dingbat/MS
dinghy/SM
dingily
dinginess/M
dingle/SM
dingo/M
dingoes
dingus/MS
dingy/RPT
dink/R
dinky/RSMT
dinned
dinner/SMDG
dinnertime/M
dinnerware/M
dinning
dinosaur/SM
dint/M
diocesan/MS
diocese/MS
diode/SM
diorama/SM
dioxide/SM
dioxin/SM
dip/SM
diphtheria/M
diphthong/SM
diploid/SM
diploma/SM
diplomacy/M
diplomat/MS
diplomata
diplomatic/U
diplomatically
diplomatist/MS
diplopia
dipole/SM
dipped
dipper/SM
dipping
dippy/RT
dipso/S
dipsomania/M
dipsomaniac/MS
dipstick/SM
dipterous
diptych/M
diptychs
dire/YTR
direct/ASDGVT
directer
direction/IM
directional
directionless
directions
directive/SM
directly
directness/IM
director/MS
directorate/SM
directorial
directorship/SM
directory/SM
direful
dirge/SM
dirigible/MS
dirk/MS
dirndl/SM
dirt/M
dirtball/S
dirtily
dirtiness/M
dirty/DRSTGP
dis/M
disable/DSGL
disablement/M
disambiguate/N
disappointing/Y
disarming/Y
disassembly
disastrous/Y
disbandment/M
disbarment/M
disbelieving/Y
disbursal/M
disburse/DSGL
disbursement/MS
disc/M
discern/LSDG
discernible/I
discernibly
discerning/Y
discernment/M
discharged/U
disciple/SM
discipleship/M
disciplinarian/SM
disciplinary
discipline/DSMG
disciplined/U
disclose/DSG
disclosed/U
disco/MG
discography/SM
discoloration/S
discombobulate/DSGN
discombobulation/M
discomfit/DG
discomfiture/M
discommode/DG
disconcerting/Y
disconnected/PY
disconnectedness/M
disconsolate/Y
discordance/M
discordant/Y
discotheque/SM
discourage/LGDS
discouragement/SM
discouraging/Y
discover/ASDG
discovered/U
discoverer/MS
discovery/ASM
discreet/PRYT
discreetness/M
discrepancy/SM
discrepant
discrete/PYN
discreteness/M
discretion/IM
discretionary
discriminant
discriminate/GNDS
discriminating/U
discrimination/M
discriminator/MS
discriminatory
discursiveness/M
discus/MS
discussant/SM
discussion/SM
disdain/SMDG
disdainful/Y
disembowel/SDLG
disembowelment/M
disfigurement/SM
disfranchisement/M
disgorgement/M
disgruntle/LGDS
disgruntlement/M
disguise/GD
disguised/U
disgusted/Y
disgusting/Y
dish/MDSG
dishabille/M
disharmonious
dishcloth/M
dishcloths
disheartening/Y
dishevel/DGLS
dishevelment/M
dishpan/SM
dishrag/SM
dishtowel/MS
dishware/M
dishwasher/MS
dishwater/M
dishy
disillusion/GLD
disillusionment/M
disinfectant/MS
disinfection/M
disinterested/PY
disinterestedness/M
disjointed/YP
disjointedness/M
disjunctive
disjuncture
disk/MS
diskette/MS
dislodge/GDS
dismal/Y
dismantlement/M
dismay/SMDG
dismayed/U
dismember/LGD
dismemberment/M
dismissive/Y
disorder/Y
disorganization/M
disparage/DSGL
disparagement/M
disparaging/Y
disparate/Y
dispatcher/MS
dispel/S
dispelled
dispelling
dispensary/SM
dispensation/MS
dispense/BZGDRS
dispenser/M
dispersal/M
disperse/GNDS
dispersion/M
dispirit/GDS
displeasure/M
disposable/SM
disposal/SM
disposed/I
disposition/ISM
dispossession/M
disproof/SM
disproportional
disprove/B
disputable/I
disputably/I
disputant/MS
disputation/SM
disputatious/Y
dispute/DRSMZGB
disputed/U
disputer/M
disquiet/GSMD
disquisition/MS
disregardful
disrepair/M
disrepute/MB
disrupt/GVSD
disruption/SM
disruptive/Y
dissect/SDG
dissed
dissemblance/M
dissemble/ZGDRS
dissembler/M
disseminate/GNDS
dissemination/M
dissension/SM
dissent/SMDRZG
dissenter/M
dissertation/SM
dissidence/M
dissident/MS
dissimilar
dissimilitude/S
dissing
dissipate/GNDS
dissipation/M
dissociate/GNDS
dissociation/M
dissoluble/I
dissolute/YNP
dissoluteness/M
dissolve/AGDS
dissolved/U
dissonance/SM
dissonant
dissuade/GDS
dissuasive
dist
distaff/SM
distal/Y
distance/DSMG
distant/Y
distaste/SM
distemper/M
distention/SM
distillate/SMNX
distillation/M
distillery/SM
distinct/IYTVP
distincter
distinction/SM
distinctive/YP
distinctiveness/M
distinctness/IM
distinguish/GDSB
distinguishable/I
distinguished/U
distort/GDR
distortion/MS
distract/DG
distracted/Y
distraction/S
distrait
distraught
distress/DG
distressful
distressing/Y
distribute/AGNVDS
distributed/U
distribution/AM
distributional
distributions
distributive/Y
distributor's
distributor/AS
distributorship/S
district's
district/AS
disturb/ZGSDR
disturbance/SM
disturbed/U
disturber/M
disturbing/Y
disunion/M
disyllabic
ditch/MDSG
dither/SMDRZG
ditherer/M
ditransitive
ditsy
ditto/SMDG
ditty/SM
ditz/MS
diuretic/MS
diurnal/Y
div
diva/MS
divalent
divan/SM
dive/MZTGDRS
diver/M
diverge/DSG
divergence/MS
divergent
diverse/XYNP
diverseness/M
diversification/M
diversify/GNDS
diversion/M
diversionary
diversity/SM
divert/SDG
diverticulitis/M
divest/SLDG
divestiture/MS
divestment/M
divide/DRSMZGB
divided/U
dividend/MS
divider/M
divination/M
divine/DRSMYZTG
diviner/M
diving/M
divinity/SM
divisibility/IM
divisible/I
division/MS
divisional
divisive/PY
divisiveness/M
divisor/SM
divorce/DSLMG
divorcee/MS
divorcement/MS
divot/SM
divulge/GDS
divvy/DSMG
dixieland/M
dizzily
dizziness/M
dizzy/DRSPTG
djellaba/MS
do/SJMRHZG
doable
dob/S
dobbed
dobbin/SM
dobbing
doberman/MS
dobro
doc/SM
docent/SM
docile/Y
docility/M
dock/MDRZGS
docket/SMDG
dockland/S
dockside
dockworker/MS
dockyard/MS
doctor/SMDG
doctoral
doctorate/MS
doctrinaire/MS
doctrinal
doctrine/MS
docudrama/SM
document/GMDS
documentary/SM
documentation/SM
documented/U
dodder/SMDG
doddery
doddle
dodge/DRSMZG
dodgem/S
dodger/M
dodgy/RT
dodo/MS
doe/SM
doer/M
does/AU
doeskin/MS
doesn't
doff/DGS
dog/SM
dogcart/SM
dogcatcher/SM
doge/MS
dogeared
dogfight/SM
dogfish/MS
dogged/PY
doggedness/M
doggerel/M
dogging
doggone/TGRS
doggy/RSMT
doghouse/SM
dogie/SM
dogleg/SM
doglegged
doglegging
doglike
dogma/SM
dogmatic
dogmatically
dogmatism/M
dogmatist/SM
dognapper
dogsbody/S
dogsled/S
dogtrot/MS
dogtrotted
dogtrotting
dogwood/MS
doily/SM
doing/USM
doldrums/M
dole's
dole/FGDS
doleful/YP
dolefulness/M
doll/MDGS
dollar/SM
dollhouse/SM
dollop/SGMD
dolly/SM
dolmen/SM
dolomite/M
dolor/M
dolorous/Y
dolphin/MS
dolt/MS
doltish/YP
doltishness/M
domain/SM
dome/MGDS
domestic/SM
domestically
domesticate/DSGN
domesticated/U
domestication/M
domesticity/M
domicile/DSMG
domiciliary
dominance/M
dominant/SMY
dominate/DSGN
domination/M
dominatrices
dominatrix/M
domineer/SGD
domineering/Y
dominion/SM
domino/M
dominoes
don't
don/SM
dona/MS
donate/DSXGN
donation/M
done/FAU
dong/MDGS
dongle/SM
donkey/SM
donned
donning
donnish
donnybrook/MS
donor/SM
donuts
doodad/SM
doodah
doodahs
doodle/DRSMZG
doodlebug/SM
doodler/M
doohickey/SM
doolally
doom/MDGS
doomsayer/MS
doomsday/M
doomster/S
door's
door/IS
doorbell/MS
doorjamb/S
doorkeeper/MS
doorknob/MS
doorknocker/S
doorman/M
doormat/SM
doormen
doorplate/SM
doorpost/S
doorstep/MS
doorstepped
doorstepping
doorstop/MS
doorway/SM
dooryard/MS
dopa/M
dopamine
dope/MZGDRS
doper/M
dopey
dopier
dopiest
dopiness/M
doping/M
doppelganger/S
dork/MS
dorky/RT
dorm/MRZS
dormancy/M
dormant
dormer/M
dormice
dormitory/SM
dormouse/M
dorsal/Y
dory/SM
dosage/SM
dose/MGDS
dosh
dosimeter/SM
doss/DRSZG
dosshouse/S
dossier/MS
dost
dot/ZGSMDR
dotage/M
dotard/SM
dotcom/SM
dote/S
doter/M
doting/Y
dotted
dotting
dotty/RT
double's
double/ADSG
doubleheader/MS
doublespeak/M
doublet/MS
doubloon/SM
doubly
doubt/SMDRZG
doubter/M
doubtful/PY
doubtfulness/M
doubting/Y
doubtless/Y
douche/DSMG
dough/M
doughnut/SM
doughty/RT
doughy/TR
dour/RYTP
dourness/M
douse/DSG
dove/MS
dovecot/S
dovecote/SM
dovetail/MDSG
dovish
dowager/MS
dowdily
dowdiness/M
dowdy/RSPT
dowel/SMDG
dower/SMDG
down/MDRZGS
downbeat/SM
downcast
downdraft/MS
downer/M
downfall/SMN
downfield
downgrade/DSMG
downhearted/PY
downheartedness/M
downhill/MS
download/MDBSG
downmarket
downplay/DSG
downpour/MS
downrange
downright
downriver
downscale
downshift/SGD
downside/MS
downsize/GDS
downsizing/M
downspout/MS
downstage
downstairs/M
downstate/M
downstream
downswing/MS
downtime/M
downtown/M
downtrend/MS
downtrodden
downturn/MS
downward/S
downwind
downy/RT
dowry/SM
dowse/DRSZG
dowser/M
doxology/SM
doyen/SM
doyenne/MS
doz/XGDNS
doze/M
dozen/MH
dozily
dozy/RTP
dpi
dpt
drab/MYSP
drabber
drabbest
drabness/M
drachma/MS
draconian
draft's
draft/ASDG
draftee/SM
drafter/SM
draftily
draftiness/M
drafting/M
draftsman/M
draftsmanship/M
draftsmen
draftswoman/M
draftswomen
drafty/RTP
drag/MS
dragged
dragging
draggy/TR
dragnet/SM
dragon/SM
dragonfly/SM
dragoon/SMDG
dragster/S
drain/SMDRZG
drainage/M
drainboard/SM
drainer/M
drainpipe/MS
drake/SM
dram/MS
drama/SM
dramatic/S
dramatically
dramatics/M
dramatist/SM
dramatization/SM
dramatize/DSG
drank
drape/DRSMZG
draper/M
drapery/SM
drastic
drastically
drat
dratted
draughtboard/S
draw/MRZGSJ
drawback/MS
drawbridge/MS
drawer/M
drawing/M
drawl/SMDG
drawn/A
drawstring/MS
dray/MS
dread/SMDG
dreadful/PY
dreadfulness/M
dreadlocks/M
dreadnought/MS
dream/SMDRZG
dreamboat/MS
dreamed/U
dreamer/M
dreamily
dreaminess/M
dreamland/M
dreamless
dreamlike
dreamworld/SM
dreamy/RPT
drear
drearily
dreariness/M
dreary/RPT
dredge/DRSMZG
dredger/M
dregs/M
drench/GDS
dress/AUGSDM
dressage/M
dresser/MS
dressiness/M
dressing/SM
dressmaker/SM
dressmaking/M
dressy/TPR
drew/A
dribble/MZGDRS
dribbler/M
driblet/MS
drier/M
drift/SMDRZG
drifter/M
driftnet/S
driftwood/M
drill/SMDRZG
driller/M
drillmaster/SM
drink/SMRBJZG
drinkable/U
drinker/M
drip/MS
dripped
dripping/SM
drippy/TR
drive/RSMZGJ
drivel/SZGMDR
driveler/M
driven
driver/M
driveshaft/SM
driveway/MS
drizzle/MGDS
drizzly
drogue/SM
droid/S
droll/RPT
drollery/SM
drollness/M
drolly
dromedary/SM
drone/DSMG
drool/SMDG
droop/GSMD
droopiness/M
droopy/TPR
drop/MS
dropkick/MS
droplet/SM
dropout/SM
dropped
dropper/SM
dropping/S
droppings/M
dropsical
dropsy/M
dross/M
drought/SM
drove/RSMZ
drover/M
drown/GSJD
drowning/M
drowse/MGDS
drowsily
drowsiness/M
drowsy/RTP
drub/S
drubbed
drubber/SM
drubbing/MS
drudge/MGDS
drudgery/M
drug/MS
drugged
druggie/SM
drugging
druggist/SM
druggy
drugstore/MS
druid/SM
druidism/M
drum/MS
drumbeat/SM
drumlin/SM
drummed
drummer/SM
drumming
drumstick/SM
drunk/STMNR
drunkard/MS
drunken/PY
drunkenness/M
drupe/SM
druthers/M
dry/ZTGDRSMY
dryad/SM
dryer/SM
dryness/M
drys
drywall/M
dual
dualism/M
duality/M
dub/SM
dubbed
dubber/SM
dubbin/M
dubbing
dubiety/M
dubious/YP
dubiousness/M
ducal
ducat/SM
duchess/MS
duchy/SM
duck/MDGS
duckbill/SM
duckboards
duckling/SM
duckpins/M
duckweed/M
ducky/TRSM
duct's/K
duct/CKIFS
ductile
ductility/M
ducting
ductless
dud/GSMD
dude/MS
dudgeon/M
due/SM
duel/MDRJZGS
dueler/M
duelist/SM
duenna/MS
duet/MS
duff/MDRZGS
duffer/M
dug
dugout/MS
duh
duke/MS
dukedom/SM
dulcet
dulcimer/MS
dull/DRPTGS
dullard/SM
dullness/M
dully
duly/U
dumb/RYPT
dumbbell/SM
dumbfound/SDG
dumbness/M
dumbo/S
dumbstruck
dumbwaiter/SM
dumdum/MS
dummy/SM
dump/MDRZGS
dumpiness/M
dumpling/SM
dumpsite/S
dumpster/SM
dumpy/PTR
dun/SM
dunce/SM
dunderhead/MS
dune/MS
dung/MDGS
dungaree/MS
dungeon/SM
dunghill/MS
dunk/MDGS
dunned
dunner
dunnest
dunning
dunno
duo/SM
duodecimal
duodena
duodenal
duodenum/M
duopoly/S
dupe/MZGDRS
duper/M
duple
duplex/MS
duplicate's
duplicate/AGNDS
duplication/AM
duplicator/MS
duplicitous
duplicity/M
durability/M
durable
durably
durance/M
duration/M
duress/M
during
durst
durum/M
dusk/M
duskiness/M
dusky/RTP
dust/MDRZGS
dustbin/SM
dustcart/S
duster/M
dustiness/M
dustless
dustman
dustmen
dustpan/SM
dustsheet/S
dusty/RTP
dutch
duteous/Y
dutiable
dutiful/YP
dutifulness/M
duty/SM
duvet/SM
dwarf/SGMD
dwarfish
dwarfism/M
dweeb/SM
dwell/SJZGR
dweller/M
dwelling/M
dwelt/I
dwindle/DSG
dyadic
dybbuk/SM
dybbukim
dye/DRSMZG
dyeing/A
dyer/M
dyestuff/M
dying/M
dyke/MS
dynamic/MS
dynamical/Y
dynamics/M
dynamism/M
dynamite/MZGDRS
dynamiter/M
dynamo/SM
dynastic
dynasty/SM
dysentery/M
dysfunction/MS
dysfunctional
dyslectic/SM
dyslexia/M
dyslexic/SM
dyspepsia/M
dyspeptic/MS
dysphagia
dysprosium/M
dystonia
dz
e'en
e'er
e/FDST
eBay/M
eMusic/M
ea
each
eager/PTRY
eagerness/M
eagle/MS
eaglet/MS
ear/SMDY
earache/SM
earbud/SM
eardrum/SM
earful/SM
earl/MS
earldom/SM
earliness/M
earlobe/SM
early/RTP
earmark/SMDG
earmuff/SM
earn/DRZTGJS
earned/U
earner/M
earnest/SMYP
earnestness/M
earnings/M
earphone/MS
earpiece/S
earplug/SM
earring/SM
earshot/M
earsplitting
earth's
earth/UDYG
earthbound
earthen
earthenware/M
earthiness/M
earthling/MS
earthly/RT
earthquake/SM
earths/U
earthshaking
earthward/S
earthwork/MS
earthworm/MS
earthy/RTP
earwax/M
earwig/SM
ease/EDSM
easel/SM
easement/SM
easily/U
easiness/UM
easing
east/M
eastbound
easterly/SM
eastern/ZR
easterner/M
easternmost
eastward/S
easy/URTP
easygoing
eat/ZGBSNR
eatable/SM
eaten/U
eater/M
eatery/SM
eave/MS
eavesdrop/S
eavesdropped
eavesdropper/SM
eavesdropping
ebb/SMDG
ebony/SM
ebullience/M
ebullient/Y
ebullition/M
eccentric/SM
eccentrically
eccentricity/SM
eccl
ecclesial
ecclesiastic/SM
ecclesiastical/Y
echelon/SM
echinoderm/SM
echo's
echo/ADG
echoes/A
echoic
echolocation/M
echos
eclair/SM
eclat/M
eclectic/SM
eclectically
eclecticism/M
eclipse/DSMG
ecliptic/M
eclogue/SM
ecocide/M
ecol
ecologic
ecological/Y
ecologist/MS
ecology/M
econ
econometric
economic/S
economical/UY
economics/M
economist/SM
economize/DRSZG
economizer/M
economy/SM
ecosystem/MS
ecotourism/M
ecotourist/MS
ecru/M
ecstasy/SM
ecstatic
ecstatically
ecu/S
ecumenical/Y
ecumenicism/M
ecumenism/M
eczema/M
ed/ACSM
edamame
eddy/DSMG
edelweiss/M
edema/SM
edge/MZGJDRS
edger/M
edgewise
edgily
edginess/M
edging/M
edgy/RTP
edibility/M
edible/SMP
edibleness/M
edict/SM
edification/M
edifice/SM
edifier/M
edify/DRSZGN
edifying/U
edit's
edit/ADGS
editable
edited/U
edition/MS
editor/SM
editorial/SMY
editorialize/DSG
editorship/M
educ
educability/M
educable/I
educate/ADSGNV
educated/U
education/AM
educational/Y
educationalist/S
educationist/S
educations
educator/MS
educe/DSGB
edutainment/M
eek
eel/SM
eerie/RT
eerily
eeriness/M
eff/GSD
efface/DSLG
effacement/M
effect/SMDGV
effective/IPY
effectiveness/IM
effectual/IY
effectuate/DSG
effeminacy/M
effeminate/Y
effendi/SM
efferent
effervesce/GDS
effervescence/M
effervescent/Y
effete/YP
effeteness/M
efficacious/Y
efficacy/IM
efficiency/ISM
efficient/IY
effigy/SM
efflorescence/M
efflorescent
effluence/M
effluent/MS
effluvia
effluvium/M
effort/SM
effortless/YP
effortlessness/M
effrontery/M
effulgence/M
effulgent
effuse/DSGNVX
effusion/M
effusive/YP
effusiveness/M
egad
egalitarian/SM
egalitarianism/M
egg/GSMD
eggbeater/MS
eggcup/SM
egghead/SM
eggnog/M
eggplant/MS
eggshell/SM
eglantine/SM
ego/SM
egocentric/MS
egocentrically
egocentricity/M
egoism/M
egoist/SM
egoistic
egoistical/Y
egomania/M
egomaniac/MS
egotism/M
egotist/SM
egotistic
egotistical/Y
egregious/PY
egregiousness/M
egress/MS
egret/SM
eh
eider/SM
eiderdown/MS
eigenvalue/S
eight/SM
eighteen/MHS
eighteenth/M
eighteenths
eighth/M
eighths
eightieth/M
eightieths
eighty/SMH
einsteinium/M
eisteddfod/S
either
ejaculate/GNXDS
ejaculation/M
ejaculatory
eject/SDG
ejection/MS
ejector/SM
eke/DSG
elaborate/YGNDSPX
elaborateness/M
elaboration/M
elan/M
eland/SM
elapse/DSG
elastic/MS
elastically
elasticated
elasticity/M
elasticize/DSG
elate/DSGN
elated/Y
elation/M
elbow/SMDG
elbowroom/M
elder/SMY
elderberry/SM
eldercare/M
eldest
eldritch
elect's
elect/ASDGV
electable
election/AMS
electioneer/DGS
elective/MS
elector/MS
electoral/Y
electorate/MS
electric/S
electrical/Y
electrician/MS
electricity/M
electrification/M
electrifier/M
electrify/ZGNDRS
electrocardiogram/MS
electrocardiograph/M
electrocardiographs
electrocardiography/M
electrocute/DSXGN
electrocution/M
electrode/SM
electrodynamics
electroencephalogram/MS
electroencephalograph/M
electroencephalographic
electroencephalographs
electroencephalography/M
electrologist/SM
electrolysis/M
electrolyte/MS
electrolytic
electromagnet/MS
electromagnetic
electromagnetically
electromagnetism/M
electromotive
electron/MS
electronic/S
electronica/M
electronically
electronics/M
electroplate/DSG
electroscope/SM
electroscopic
electroshock/M
electrostatic/S
electrostatics/M
electrotype/MS
eleemosynary
elegance/IM
elegant/IY
elegiac/MS
elegiacal
elegy/SM
elem
element/MS
elemental/Y
elementary
elephant/SM
elephantiasis/M
elephantine
elev
elevate/XDSGN
elevation/M
elevator/MS
eleven/SMH
elevens/S
eleventh/M
elevenths
elf/M
elfin
elfish
elicit/SDG
elicitation/M
elide/DSG
eligibility/IM
eligible
eliminate/XDSGN
elimination/M
eliminator/S
elision/MS
elite/SM
elitism/M
elitist/MS
elixir/SM
elk/SM
ell/SM
ellipse/MS
ellipsis/M
ellipsoid/SM
ellipsoidal
elliptic
elliptical/Y
elm/SM
elocution/M
elocutionary
elocutionist/SM
elodea/SM
elongate/DSGNX
elongation/M
elope/DSGL
elopement/MS
eloquence/M
eloquent/Y
else
elsewhere
elucidate/DSGNX
elucidation/M
elude/DSG
elusive/YP
elusiveness/M
elver/SM
elves
elvish
em's
em/S
emaciate/GNDS
emaciation/M
email/SMDG
emanate/XDSGN
emanation/M
emancipate/DSGN
emancipation/M
emancipator/MS
emasculate/GNDS
emasculation/M
embalm/SZGDR
embalmer/M
embank/SLGD
embankment/SM
embargo/MDG
embargoes
embark/AEGDS
embarkation/EM
embarkations
embarrass/GLDS
embarrassed/U
embarrassing/Y
embarrassment/SM
embassy/SM
embattled
embed/S
embedded
embedding
embellish/LGDS
embellishment/SM
ember/SM
embezzle/ZGLDRS
embezzlement/M
embezzler/M
embitter/GLDS
embitterment/M
emblazon/GDLS
emblazonment/M
emblem/SM
emblematic
emblematically
embodiment/EM
embody/AEGSD
embolden/DGS
embolism/MS
embolization
emboss/DRSZG
embosser/M
embouchure/M
embower/SGD
embrace/DSMG
embraceable
embrasure/MS
embrocation/MS
embroider/SDRZG
embroiderer/M
embroidery/SM
embroil/DGLS
embroilment/M
embryo/SM
embryological
embryologist/MS
embryology/M
embryonic
emcee/DSM
emceeing
emend/SDG
emendation/MS
emerald/MS
emerge/ADSG
emergence/AM
emergency/SM
emergent
emerita
emeritus
emery/M
emetic/SM
emf/S
emigrant/SM
emigrate/DSXGN
emigration/M
emigre/SM
eminence/MS
eminent/Y
emir/MS
emirate/MS
emissary/SM
emission/SM
emit/S
emitted
emitter/MS
emitting
emo/SM
emoji/SM
emollient/MS
emolument/MS
emote/XDSGNV
emoticon/SM
emotion/M
emotional/UY
emotionalism/M
emotionalize/GDS
emotionless
emotive/Y
empathetic
empathize/DSG
empathy/M
emperor/MS
emphases
emphasis/M
emphasize/AGDS
emphatic/U
emphatically
emphysema/M
empire/SM
empiric
empirical/Y
empiricism/M
empiricist/SM
emplacement/SM
employ's
employ/ADGLS
employable/U
employee/SM
employer/SM
employment/UAM
employments
emporium/SM
empower/SDGL
empowerment/M
empress/MS
emptily
emptiness/M
empty/TGPDRSM
empyrean/M
emu/SM
emulate/DSGNVX
emulation/M
emulator/SM
emulsification/M
emulsifier/M
emulsify/NDRSZG
emulsion/MS
en/SM
enable/DRSZG
enabler/M
enact/ASLDG
enactment/ASM
enamel/JSZGMDR
enameler/M
enamelware/M
enamor/SGD
enc
encamp/LSGD
encampment/MS
encapsulate/XGNDS
encapsulation/M
encase/LDSG
encasement/M
encephalitic
encephalitis/M
enchain/DGS
enchant/ELDGS
enchanter/MS
enchanting/Y
enchantment/EM
enchantments
enchantress/MS
enchilada/SM
encipher/SGD
encircle/DSGL
encirclement/M
encl
enclave/MS
enclose/GDS
enclosed/U
enclosure/SM
encode/DRSZG
encoder/M
encomium/MS
encompass/GDS
encore/DSMG
encounter/GSMD
encourage/DSLG
encouragement/SM
encouraging/Y
encroach/GLDS
encroachment/SM
encrust/DGS
encrustation/SM
encrypt/DGS
encryption
encumber/EGSD
encumbered/U
encumbrance/MS
ency
encyclical/SM
encyclopedia/MS
encyclopedic
encyst/LSGD
encystment/M
end/GVSJMD
endanger/SGDL
endangerment/M
endear/SGLD
endearing/Y
endearment/SM
endeavor/GSMD
endemic/MS
endemically
endgame/S
ending/M
endive/SM
endless/PY
endlessness/M
endmost
endocarditis
endocrine/MS
endocrinologist/MS
endocrinology/M
endogenous/Y
endometrial
endometriosis
endometrium
endorphin/MS
endorse/LZGDRS
endorsement/MS
endorser/M
endoscope/MS
endoscopic
endoscopy/M
endothelial
endothermic
endow/SDLG
endowment/MS
endpoint/SM
endue/DSG
endurable/U
endurance/M
endure/DSBG
endways
enema/SM
enemy/SM
energetic
energetically
energize/ZGDRS
energizer/M
energy/SM
enervate/GNDS
enervation/M
enfeeble/GDSL
enfeeblement/M
enfilade/DSMG
enfold/SGD
enforce/LZGDRS
enforceable/U
enforced/U
enforcement/M
enforcer/M
enfranchise/EGDSL
enfranchisement/EM
engage/EADSG
engagement/EMS
engagingly
engender/SGD
engine/SM
engineer/MDGS
engineering/M
engorge/LGDS
engorgement/M
engram/SM
engrave/ZGJDRS
engraver/M
engraving/M
engross/GLDS
engrossment/M
engulf/SLGD
engulfment/M
enhance/LZGDRS
enhancement/SM
enigma/SM
enigmatic
enigmatically
enjambment/SM
enjoin/SGD
enjoy/GBLSD
enjoyably
enjoyment/SM
enlarge/LZGDRS
enlargeable
enlargement/MS
enlarger/M
enlighten/SGLD
enlightened/U
enlightenment/M
enlist/ADGSL
enlistee/SM
enlistment/AM
enlistments
enliven/SLDG
enlivenment/M
enmesh/DSGL
enmeshment/M
enmity/SM
ennoble/DSGL
ennoblement/M
ennui/M
enormity/SM
enormous/PY
enormousness/M
enough/M
enplane/DSG
enquirer/S
enquiringly
enrage/GDS
enrapture/DSG
enrich/DSLG
enrichment/M
enroll/DLSG
enrollment/MS
ensconce/DSG
ensemble/SM
enshrine/GLDS
enshrinement/M
enshroud/DGS
ensign/MS
ensilage/M
enslave/DSGL
enslavement/M
ensnare/DSLG
ensnarement/M
ensue/DSG
ensure/ZGDRS
ensurer/M
entail/DSGL
entailment/M
entangle/EDSLG
entanglement/EM
entanglements
entente/SM
enter/ASGD
enteric
enteritis/M
enterprise/MGS
enterprising/Y
entertain/ZGDRSL
entertainer/M
entertaining/MY
entertainment/MS
enthrall/GDSL
enthrallment/M
enthrone/GDSL
enthronement/SM
enthuse/DSG
enthusiasm/MS
enthusiast/MS
enthusiastic/U
enthusiastically
entice/GDSL
enticement/MS
enticing/Y
entire/Y
entirety/M
entitle/DSGL
entitlement/SM
entity/SM
entomb/DSGL
entombment/M
entomological
entomologist/MS
entomology/M
entourage/SM
entr'acte
entrails/M
entrance/LDSMG
entrancement/M
entrancing/Y
entrant/SM
entrap/LS
entrapment/M
entrapped
entrapping
entreat/GSD
entreating/Y
entreaty/SM
entree/MS
entrench/DSGL
entrenchment/MS
entrepreneur/SM
entrepreneurial
entrepreneurship
entropy/M
entrust/SGD
entry/ASM
entryphone/S
entryway/MS
entwine/DSG
enumerable
enumerate/DSGNX
enumeration/M
enumerator/SM
enunciate/DSGN
enunciation/M
enuresis/M
envelop/SLDRZG
envelope/SM
enveloper/M
envelopment/M
envenom/SDG
enviable/U
enviably
envious/PY
enviousness/M
environment/MS
environmental/Y
environmentalism/M
environmentalist/SM
environs/M
envisage/GDS
envision/DGS
envoy/SM
envy/DSMG
envying/Y
enzymatic
enzyme/SM
eolian
eon/SM
eosinophil/S
eosinophilic
epaulet/SM
epee/MS
ephedrine/M
ephemera/M
ephemeral/Y
epic/MS
epicenter/MS
epicure/SM
epicurean/MS
epidemic/SM
epidemically
epidemiological
epidemiologist/SM
epidemiology/M
epidermal
epidermic
epidermis/MS
epidural/S
epiglottis/MS
epigram/SM
epigrammatic
epigraph/M
epigraphs
epigraphy/M
epilepsy/M
epileptic/SM
epilogue/MS
epinephrine/M
epiphany/SM
episcopacy/M
episcopal
episcopate/M
episode/SM
episodic
episodically
epistemic
epistemological
epistemology
epistle/SM
epistolary
epitaph/M
epitaphs
epithelial
epithelium/M
epithet/SM
epitome/SM
epitomize/GDS
epoch/M
epochal
epochs
eponymous
epoxy/DSMG
epsilon/SM
equability/M
equable
equably
equal/SMDYG
equality/IM
equalization/M
equalize/ZGDRS
equalizer/M
equanimity/M
equate/DSGNBX
equation/M
equator/SM
equatorial
equerry/SM
equestrian/SM
equestrianism/M
equestrienne/SM
equidistant/Y
equilateral/SM
equilibrium/EM
equine/SM
equinoctial
equinox/MS
equip/AS
equipage/MS
equipment/M
equipoise/M
equipped/UA
equipping/A
equitable/I
equitably/I
equitation/M
equity/ISM
equiv
equivalence/MS
equivalency/SM
equivalent/MYS
equivocal/UY
equivocalness/M
equivocate/GNXDS
equivocation/M
equivocator/SM
er/C
era/SM
eradicable/I
eradicate/DSGN
eradication/M
eradicator/MS
erase/DRSBZG
eraser/M
erasure/SM
erbium/M
ere
erect/PSGDY
erectile
erection/SM
erectness/M
erector/MS
erelong
eremite/MS
erg/SM
ergo
ergonomic/S
ergonomically
ergonomics/M
ergosterol/M
ergot/M
ermine/SM
erode/DSG
erodible
erogenous
erosion/M
erosive
erotic/S
erotica/M
erotically
eroticism/M
err/GSD
errand/SM
errant/I
errata/SM
erratic
erratically
erratum/M
erroneous/Y
error/SM
ersatz/MS
erst
erstwhile
eruct/SDG
eructation/SM
erudite/YN
erudition/M
erupt/SDGV
eruption/MS
erysipelas/M
erythrocyte/SM
erythromycin
escalate/CDSGN
escalation/CM
escalations
escalator/MS
escallop/SGMD
escalope/S
escapade/MS
escape/LMGDS
escapee/MS
escapement/SM
escapism/M
escapist/MS
escapologist/S
escapology
escargot/MS
escarole/MS
escarpment/MS
eschatological
eschatology
eschew/SDG
escort/SMDG
escritoire/MS
escrow/SM
escudo/SM
escutcheon/SM
esophageal
esophagi
esophagus/M
esoteric
esoterically
esp
espadrille/MS
espalier/MDSG
especial/Y
espionage/M
esplanade/MS
espousal/M
espouse/GDS
espresso/MS
esprit/M
espy/DSG
esquire/SM
essay/SMDRZG
essayer/M
essayist/SM
essence/SM
essential/IMS
essentially
establish/AESDGL
establishment/AEM
establishments
estate/SM
esteem/ESMDG
ester/SM
estimable/I
estimate/MGNDSX
estimation/M
estimator/SM
estoppel
estrange/LDSG
estrangement/MS
estrogen/M
estrous
estrus/MS
estuary/SM
eta/SM
etc
etch/DRSZGJ
etcher/M
etching/M
eternal/YP
eternalness/M
eternity/SM
ethane/M
ethanol/M
ether/M
ethereal/Y
ethic/SM
ethical/UY
ethics/M
ethnic/SM
ethnically
ethnicity/M
ethnocentric
ethnocentrism/M
ethnographer/S
ethnographic
ethnographically
ethnography
ethnological/Y
ethnologist/SM
ethnology/M
ethological
ethologist/MS
ethology/M
ethos/M
ethyl/M
ethylene/M
etiolated
etiologic
etiological
etiology/SM
etiquette/M
etude/SM
etymological/Y
etymologist/SM
etymology/SM
eucalypti
eucalyptus/MS
euchre/DSMG
euclidean
eugenic/S
eugenically
eugenicist/MS
eugenics/M
eulogist/MS
eulogistic
eulogize/ZGDRS
eulogizer/M
eulogy/SM
eunuch/M
eunuchs
euphemism/SM
euphemistic
euphemistically
euphonious/Y
euphony/M
euphoria/M
euphoric
euphorically
eureka
euro/MS
europium/M
eutectic
euthanasia/M
euthanize/DSG
euthenics/M
evacuate/XDSGN
evacuation/M
evacuee/MS
evade/DRSZG
evader/M
evaluate/AGNVDSX
evaluation/AM
evanescence/M
evanescent
evangelic
evangelical/SMY
evangelicalism/M
evangelism/M
evangelist/MS
evangelistic
evangelize/GDS
evaporate/GNDS
evaporation/M
evaporator/SM
evasion/SM
evasive/YP
evasiveness/M
eve/ASM
even/MDRYTGSJP
evenhanded/Y
evening/M
evenness/UM
evensong/M
event/SM
eventful/UY
eventfulness/M
eventide/M
eventual/Y
eventuality/SM
eventuate/GDS
ever
everglade/SM
evergreen/SM
everlasting/MYS
evermore
every
everybody/M
everyday
everyone/M
everyplace
everything/M
everywhere
evict/SDG
eviction/MS
evidence/MGDS
evident/Y
evil/MRYTSP
evildoer/SM
evildoing/M
eviller
evillest
evilness/M
evince/DSG
eviscerate/DSGN
evisceration/M
evocation/MS
evocative/Y
evoke/DSG
evolution/M
evolutionary
evolutionist/SM
evolve/DSG
ewe/RSMZ
ewer/M
ex/MS
exabyte/MS
exacerbate/GNDS
exacerbation/M
exact/SPDRYTG
exacting/Y
exaction/M
exactitude/M
exactness/IM
exaggerate/XDSGN
exaggerated/Y
exaggeration/M
exaggerator/MS
exalt/SDG
exaltation/M
exam/MS
examination/AMS
examine/AGDS
examiner/MS
example/MGDS
exampled/U
exasperate/DSGN
exasperated/Y
exasperating/Y
exasperation/M
excavate/GNDSX
excavation/M
excavator/SM
exceed/GSD
exceeding/Y
excel/S
excelled
excellence/M
excellency/SM
excellent/Y
excelling
excelsior/M
except/GSD
exception/BSM
exceptionable/U
exceptional/UY
exceptionalism
excerpt/MDGS
excess/VMS
excessive/Y
exchange/DSMG
exchangeable
exchequer/SM
excise/XDSMGN
excision/M
excitability/M
excitably
excitation/M
excite/BDRSLZG
excited/Y
excitement/SM
exciter/M
exciting/Y
excl
exclaim/DGS
exclamation/SM
exclamatory
exclude/GDS
exclusion/MS
exclusionary
exclusive/PMYS
exclusiveness/M
exclusivity/M
excommunicate/GNDSX
excommunication/M
excoriate/DSGNX
excoriation/M
excrement/M
excremental
excrescence/MS
excrescent
excreta/M
excrete/XGNDS
excretion/M
excretory
excruciating/Y
exculpate/DSGN
exculpation/M
exculpatory
excursion/MS
excursionist/MS
excursive/YP
excursiveness/M
excusable/I
excusably/I
excuse/DSBMG
excused/U
exec/MS
execrable
execrably
execrate/DSGN
execration/M
execute/BXGNVDS
execution/ZMR
executioner/M
executive/SM
executor/MS
executrices
executrix/M
exegeses
exegesis/M
exegetic
exegetical
exemplar/SM
exemplary
exemplification/M
exemplify/GDSXN
exempt/SGD
exemption/SM
exercise/DRSMZG
exerciser/M
exert/SDG
exertion/MS
exeunt
exfoliate/GNDS
exhalation/MS
exhale/DSG
exhaust/GVMDS
exhaustible/I
exhaustion/M
exhaustive/YP
exhaustiveness/M
exhibit/GMDS
exhibition/MS
exhibitionism/M
exhibitionist/MS
exhibitor/SM
exhilarate/DSGN
exhilaration/M
exhort/SDG
exhortation/MS
exhumation/MS
exhume/DSG
exigence/MS
exigency/SM
exigent
exiguity/M
exiguous
exile/DSMG
exist/SDG
existence/MS
existent
existential/Y
existentialism/M
existentialist/MS
exit/MDGS
exobiology/M
exodus/MS
exogenous
exon
exonerate/GNDS
exoneration/M
exoplanet/MS
exorbitance/M
exorbitant/Y
exorcise/DSG
exorcism/SM
exorcist/SM
exoskeleton/SM
exosphere/SM
exothermic
exotic/SM
exotica
exotically
exoticism/M
exp
expand/BGSD
expanse/XMNVS
expansible
expansion/M
expansionary
expansionism/M
expansionist/MS
expansive/YP
expansiveness/M
expat/S
expatiate/GNDS
expatiation/M
expatriate/DSMGN
expatriation/M
expect/GSD
expectancy/M
expectant/Y
expectation/SM
expectorant/SM
expectorate/DSGN
expectoration/M
expedience/IM
expediences
expediencies
expediency/IM
expedient/SMY
expedite/DRSZGNX
expediter/M
expedition/M
expeditionary
expeditious/PY
expeditiousness/M
expel/S
expelled
expelling
expend/GSBD
expendable/SM
expenditure/SM
expense/MS
expensive/IYP
expensiveness/IM
experience/IMD
experiences
experiencing
experiential
experiment/MDRSZG
experimental/Y
experimentation/M
experimenter/M
expert/SPMY
expertise/M
expertness/M
expiate/GNDS
expiation/M
expiatory
expiration/M
expire/DSG
expired/U
expiry/M
explain/ADGS
explainable
explained/U
explanation/MS
explanatory
expletive/MS
explicable/I
explicate/XGNDS
explication/M
explicit/PY
explicitness/M
explode/GDS
exploit/ZGBMDRS
exploitation/M
exploitative
exploited/U
exploiter/M
exploration/MS
exploratory
explore/ZGDRS
explored/U
explorer/M
explosion/SM
explosive/SPMY
explosiveness/M
expo/MS
exponent/MS
exponential/Y
exponentiation
export/BSZGMDR
exportation/M
exporter/M
expose/DSMG
exposed/U
exposition/SM
expositor/SM
expository
expostulate/GNXDS
expostulation/M
exposure/MS
expound/ZGDRS
expounder/M
express/GVMDSY
expressed/U
expressible/I
expression/SM
expressionism/M
expressionist/SM
expressionistic
expressionless/Y
expressive/PY
expressiveness/M
expressway/SM
expropriate/GNXDS
expropriation/M
expropriator/SM
expulsion/MS
expunge/GDS
expurgate/DSGNX
expurgated/U
expurgation/M
exquisite/YP
exquisiteness/M
ext
extant
extemporaneous/PY
extemporaneousness/M
extempore
extemporization/M
extemporize/GDS
extend/SZGDRB
extender/M
extensible
extension/SM
extensional
extensive/YP
extensiveness/M
extent/SM
extenuate/DSGN
extenuation/M
exterior/MS
exterminate/DSXGN
extermination/M
exterminator/MS
external/MYS
externalization/SM
externalize/DSG
extinct/GDS
extinction/MS
extinguish/ZGBDRS
extinguishable/I
extinguisher/M
extirpate/GNDS
extirpation/M
extol/S
extolled
extolling
extort/SGD
extortion/MRZ
extortionate/Y
extortioner/M
extortionist/MS
extra/SM
extracellular
extract/MDGS
extraction/SM
extractor/MS
extracurricular
extradite/GNBXDS
extradition/M
extrajudicial
extralegal
extramarital
extramural
extraneous/Y
extraordinaire
extraordinarily
extraordinary
extrapolate/XGNDS
extrapolation/M
extrasensory
extraterrestrial/MS
extraterritorial
extraterritoriality/M
extravagance/MS
extravagant/Y
extravaganza/MS
extravehicular
extreme/PMYTRS
extremeness/M
extremism/M
extremist/MS
extremity/SM
extricable/I
extricate/GNDS
extrication/M
extrinsic
extrinsically
extroversion/M
extrovert/SMD
extrude/GDS
extrusion/SM
extrusive
exuberance/M
exuberant/Y
exudation/M
exude/DSG
exult/SDG
exultant/Y
exultation/M
exurb/SM
exurban
exurbanite/SM
exurbia/M
eye/DSM
eyeball/GMDS
eyebrow/SM
eyedropper/SM
eyeful/SM
eyeglass/MS
eyeing
eyelash/MS
eyeless
eyelet/SM
eyelid/SM
eyeliner/MS
eyeopener/MS
eyeopening
eyepiece/MS
eyesight/M
eyesore/MS
eyestrain/M
eyeteeth
eyetooth/M
eyewash/M
eyewitness/MS
f/CIAVTR
fa/M
fab
fable/DSM
fabric/SM
fabricate/DSGNX
fabrication/M
fabricator/SM
fabulous/Y
facade/SM
face's
face/ACSDG
facecloth/M
facecloths
faceless
facet/SMDG
facetious/YP
facetiousness/M
facial/SMY
facile/Y
facilitate/GNDS
facilitation/M
facilitator/MS
facility/SM
facing/SM
facsimile/DSM
facsimileing
fact/MS
faction/SM
factional
factionalism/M
factious
factitious
factoid/SM
factor's
factor/ASDG
factorial/MS
factorization
factorize/GDS
factory/SM
factotum/SM
factual/Y
faculty/SM
fad/GSMD
faddish/P
faddist/MS
faddy/P
fade/MS
fading/U
faerie/SM
faff/DGS
fag/SM
fagged
fagging
faggot/SM
fagot/SMG
faience/M
fail/MDGJS
failing/M
faille/M
failure/SM
fain/RT
faint/SMDRYTGP
fainthearted
faintness/M
fair/MRYTGJPS
fairground/MS
fairing/M
fairness/UM
fairway/SM
fairy/SM
fairyland/SM
faith/M
faithful's
faithful/UPY
faithfulness/UM
faithfuls
faithless/PY
faithlessness/M
faiths
fajita/SM
fajitas/M
fake/MZGDRS
faker/M
fakir/SM
falcon/SMRZ
falconer/M
falconry/M
fall/MNGS
fallacious/Y
fallacy/SM
fallback
fallibility/IM
fallible/P
fallibleness/M
fallibly/I
falloff/SM
fallout/M
fallow/SMDG
false/PRYT
falsehood/SM
falseness/M
falsetto/SM
falsie/SM
falsifiable
falsification/M
falsifier/M
falsify/DRSZGNX
falsity/SM
falter/GSJMD
faltering/Y
fame's
fame/D
familial
familiar/MYS
familiarity/UM
familiarization/M
familiarize/GDS
family/SM
famine/SM
famish/DSG
famous/IY
fan/SM
fanatic/SM
fanatical/Y
fanaticism/M
fanboy/SM
fanciable
fancier/M
fanciful/YP
fancifulness/M
fancily
fanciness/M
fancy/DRSMZTGP
fancywork/M
fandango/MS
fandom
fanfare/SM
fang/MDS
fanlight/SM
fanned
fanning
fanny/SM
fantail/MS
fantasia/SM
fantasist/S
fantasize/GDS
fantastic
fantastical/Y
fantasy/DSMG
fanzine/MS
far
farad/SM
faradize/DG
faraway
farce/SM
farcical/Y
fare/MGDS
farewell/SM
farina/M
farinaceous
farm/MDRZGSJ
farmer/M
farmhand/SM
farmhouse/SM
farming/M
farmland/MS
farmstead/MS
farmyard/MS
faro/M
farrago/M
farragoes
farrier/MS
farrow/SMDG
farseeing
farsighted/P
farsightedness/M
fart/MDGS
farther
farthermost
farthest
farthing/SM
fascia/SM
fascicle/SM
fascinate/GNDSX
fascinating/Y
fascination/M
fascism/M
fascist/MS
fascistic
fashion/ZGBMDRS
fashionable/U
fashionably/U
fashioner/M
fashionista/MS
fast/MDRTGSP
fastback/SM
fastball/SM
fasten/UAGDS
fastener/SM
fastening/MS
fastidious/PY
fastidiousness/M
fastness/MS
fat/GSPMD
fatal/Y
fatalism/M
fatalist/SM
fatalistic
fatalistically
fatality/SM
fatback/M
fate/MS
fateful/YP
fatefulness/M
fathead/MDS
father/SGMDY
fatherhood/M
fatherland/MS
fatherless
fathom/SMDGB
fathomable/U
fathomless
fatigue/MDSG
fatigues/M
fatness/M
fatso/S
fatten/SDG
fatter
fattest
fattiness/M
fatty/RSMTP
fatuity/M
fatuous/YP
fatuousness/M
fatwa/SM
faucet/SM
fault/CSMDG
faultfinder/SM
faultfinding/M
faultily
faultiness/M
faultless/PY
faultlessness/M
faulty/PRT
faun/MS
fauna/SM
fauvism/M
fauvist/SM
faux
fave/S
favor/ESMDG
favorable/U
favorably/U
favorite/SM
favoritism/M
fawn/MDRZGS
fawner/M
fax/GMDS
fay/TSMR
faze/GDS
fazed/U
fealty/M
fear/MDGS
fearful/YP
fearfulness/M
fearless/PY
fearlessness/M
fearsome
feasibility/M
feasible/IU
feasibly
feast/SMDRZG
feaster/M
feat/MS
feather/SGMD
featherbedding/M
featherbrained
featherless
featherweight/MS
feathery/TR
feature/DSMG
featureless
febrile
fecal
feces/M
feckless/PY
fecund
fecundate/GNDS
fecundation/M
fecundity/M
fed/SM
federal/SMY
federalism/M
federalist/MS
federalization/M
federalize/GDS
federate/FXDSGN
federation/FM
fedora/SM
fee/SM
feeble/RTP
feebleness/M
feebly
feed/MRZGSJ
feedback/M
feedbag/SM
feeder/M
feeding/M
feedlot/SM
feel/MRZGSJ
feeler/M
feelgood
feeling/MY
feet
feign/SDG
feigned/U
feint/SMDG
feisty/TR
feldspar/M
felicitate/GNXDS
felicitation/M
felicitous/Y
felicity/ISM
feline/SM
fell/MDRZTGS
fella/S
fellatio/M
fellow/SM
fellowman/M
fellowmen
fellowship/MS
felon/SM
felonious
felony/SM
felt/MDGS
fem
female/PSM
femaleness/M
feminine/SMY
femininity/M
feminism/M
feminist/SM
feminize/DSG
femoral
femur/SM
fen/SM
fence/DRSMZG
fencer/M
fencing/M
fend/CDRZGS
fender/CM
fenestration/M
fennel/M
feral
ferment/FCMS
fermentation/M
fermented
fermenting
fermium/M
fern/MS
ferny/RT
ferocious/PY
ferociousness/M
ferocity/M
ferret/GSMD
ferric
ferromagnetic
ferrous
ferrule/MS
ferry/DSMG
ferryboat/SM
ferryman/M
ferrymen
fertile/I
fertility/IM
fertilization/M
fertilize/DRSZG
fertilized/U
fertilizer/M
ferule/SM
fervency/M
fervent/Y
fervid/Y
fervor/M
fess/FKGSD
fest/MRZVS
festal
fester/GMD
festival/SM
festive/YP
festiveness/M
festivity/SM
festoon/GMDS
feta/M
fetal
fetch/DRSZG
fetcher/M
fetching/Y
fete/MGDS
fetid/P
fetidness/M
fetish/MS
fetishism/M
fetishist/SM
fetishistic
fetlock/MS
fetter's
fetter/USGD
fettle/M
fettuccine/M
fetus/MS
feud/MDGS
feudal
feudalism/M
feudalistic
fever/SMD
feverish/YP
feverishness/M
few/TPMR
fewness/M
fey
fez/M
fezzes
ff
fiance/CM
fiancee/MS
fiances
fiasco/M
fiascoes
fiat/MS
fib/ZSMR
fibbed
fibber/SM
fibbing
fiber/M
fiberboard/M
fiberfill/M
fiberglass/M
fibril/SM
fibrillate/GNDS
fibrillation/M
fibrin/M
fibroid
fibrosis/M
fibrous
fibula/M
fibulae
fibular
fiche/SM
fichu/SM
fickle/RPT
fickleness/M
fiction/MS
fictional/Y
fictionalization/SM
fictionalize/DSG
fictitious/Y
fictive
ficus/M
fiddle/DRSMZG
fiddler/M
fiddlesticks
fiddly/TR
fidelity/IM
fidget/SGMD
fidgety
fiduciary/SM
fie
fief/MS
fiefdom/MS
field/ISMRZ
fielded
fielder/IM
fielding
fieldsman
fieldsmen
fieldwork/MRZ
fieldworker/M
fiend/SM
fiendish/Y
fierce/PRYT
fierceness/M
fieriness/M
fiery/RPT
fiesta/SM
fife/MZRS
fifer/M
fifteen/MHS
fifteenth/M
fifteenths
fifth/MY
fifths
fiftieth/M
fiftieths
fifty/SMH
fig/SLM
fight/SMRZG
fightback
fighter/IMS
fighting/IM
figment/MS
figuration/FM
figurative/Y
figure's
figure/FEGSD
figurehead/SM
figurine/MS
filament/MS
filamentous
filbert/MS
filch/DSG
file's/KC
file/CAKGDS
filename/S
filer/CSM
filet
filial
filibuster/MDRSZG
filibusterer/M
filigree/DSM
filigreeing
filing's
filings
fill's
fill/AIDGS
filled/U
filler/MS
fillet/MDGS
filling/SM
fillip/MDGS
filly/SM
film/MDGS
filminess/M
filmmaker/SM
filmstrip/MS
filmy/TPR
filo
filter/MDRBSZG
filtered/U
filterer/M
filth/M
filthily
filthiness/M
filthy/RPT
filtrate's
filtrate/IGNDS
filtration/IM
fin/SMR
finagle/DRSZG
finagler/M
final/SMY
finale/MS
finalist/SM
finality/M
finalization/M
finalize/DSG
finance's
finance/ADSG
financial/Y
financier/MS
financing/M
finch/MS
find/JMRZGS
finder/M
finding/M
findings/M
fine's/F
fine/CAFTGDS
finely
fineness/M
finery/AM
finespun
finesse/DSMG
finger/MDGSJ
fingerboard/SM
fingering/M
fingerling/SM
fingermark/S
fingernail/SM
fingerprint/SGMD
fingertip/MS
finial/MS
finical
finickiness/M
finicky/RPT
finis/MS
finish's
finish/ADSG
finished/U
finisher/MS
finite/IY
fink/MDGS
finned
finny
fir/ZGSJMDRH
fire/MS
firearm/SM
fireball/MS
firebomb/MDSJG
firebox/MS
firebrand/SM
firebreak/SM
firebrick/SM
firebug/SM
firecracker/SM
firedamp/M
firefight/MRSZG
firefighter/M
firefighting/M
firefly/SM
fireguard/S
firehouse/SM
firelight/ZMR
fireman/M
firemen
fireplace/SM
fireplug/MS
firepower/M
fireproof/DSG
firer/M
firescreen/S
fireside/MS
firestorm/MS
firetrap/MS
firetruck/MS
firewall/MS
firewater/M
firewood/M
firework/SM
firm/MDRYPTGS
firmament/SM
firmness/M
firmware/M
first/SMY
firstborn/SM
firsthand
firth/M
firths
fiscal/MYS
fish/MDRSZG
fishbowl/SM
fishcake/SM
fisher/M
fisherman/M
fishermen
fishery/SM
fishhook/SM
fishily
fishiness/M
fishing/M
fishmonger/MS
fishnet/SM
fishpond/MS
fishtail/DGS
fishwife/M
fishwives
fishy/TRP
fissile
fission/BM
fissure/SM
fist/MS
fistfight/MS
fistful/SM
fisticuffs/M
fistula/SM
fistulous/M
fit/KAMS
fitful/YP
fitfulness/M
fitly
fitment/S
fitness/UM
fitted/UA
fitter/MS
fittest
fitting/SMY
five/MZRS
fix/ZGBJMDRS
fixate/GNVDSX
fixation/M
fixative/MS
fixed/Y
fixer/M
fixings/M
fixity/M
fixture/MS
fizz/MDSG
fizzle/DSMG
fizzy/RT
fjord/SM
fl/JDG
flab/M
flabbergast/SGD
flabbily
flabbiness/M
flabby/RPT
flaccid/Y
flaccidity/M
flack/SM
flag/MS
flagella
flagellant/S
flagellate/GNDS
flagellation/M
flagellum/M
flagged
flagging/U
flagman/M
flagmen
flagon/MS
flagpole/SM
flagrance/M
flagrancy/M
flagrant/Y
flagship/SM
flagstaff/MS
flagstone/MS
flail/SGMD
flair/SM
flak/M
flake/DSMG
flakiness/M
flaky/TRP
flamage
flambe/MS
flambeed
flambeing
flamboyance/M
flamboyancy/M
flamboyant/Y
flame/DRSJMZG
flamenco/MS
flameproof/DGS
flamethrower/SM
flamingo/MS
flammability/IM
flammable/SM
flan/MS
flange/MS
flank/SZGMDR
flanker/M
flannel/SGMD
flannelette/M
flap/MS
flapjack/MS
flapped
flapper/SM
flapping
flare/DSMG
flareup/SM
flash/ZTGMDRS
flashback/SM
flashbulb/SM
flashcard/SM
flashcube/SM
flasher/M
flashgun/SM
flashily
flashiness/M
flashing/M
flashlight/MS
flashy/RTP
flask/SM
flat/MYPS
flatbed/SM
flatboat/SM
flatbread
flatcar/SM
flatfeet
flatfish/MS
flatfoot/SMD
flatiron/SM
flatland/M
flatlet/S
flatmate/S
flatness/M
flatted
flatten/SDG
flatter/SDRZG
flatterer/M
flattering/Y
flattery/M
flattest
flatting
flattish
flattop/SM
flatulence/M
flatulent
flatus/M
flatware/M
flatworm/SM
flaunt/MDSG
flaunting/Y
flavor/MDSGJ
flavored/U
flavorful
flavoring/M
flavorless
flavorsome
flaw/MDGS
flawless/PY
flawlessness/M
flax/MN
flay/DGS
flea/MS
fleabag/SM
fleabite/S
fleapit/S
fleck/SGMD
fledged/U
fledgling/MS
flee/S
fleece/MZGDRS
fleecer/M
fleeciness/M
fleecy/RTP
fleeing
fleet/STGMDRYP
fleetingly/M
fleetingness/M
fleetness/M
flesh/GMDSY
fleshly/TR
fleshpot/MS
fleshy/RT
flew
flex/AMS
flexed
flexibility/IM
flexible/I
flexibly/I
flexing
flexion
flextime/M
flibbertigibbet/SM
flick/SZGMDR
flicker/GMD
flier/M
flight/MS
flightiness/M
flightless
flighty/PTR
flimflam/SM
flimflammed
flimflamming
flimsily
flimsiness/M
flimsy/TRP
flinch/GMDS
fling/GM
flint/SM
flintlock/SM
flinty/TR
flip/MS
flippancy/M
flippant/Y
flipped
flipper/MS
flippest
flipping
flippy/S
flirt/SGMD
flirtation/MS
flirtatious/YP
flirtatiousness/M
flirty
flit/MS
flitted
flitting
float/SMDRZG
floater/M
flock/SMDG
flocking/M
floe/MS
flog/S
flogged
flogger/SM
flogging/MS
flood/SMDRG
floodgate/MS
floodlight/MDSG
floodlit
floodplain/MS
floodwater/MS
floor/SMDG
floorboard/MS
flooring/M
floorwalker/SM
floozy/SM
flop/MS
flophouse/MS
flopped
floppily
floppiness/M
flopping
floppy/PRSMT
flora/SM
floral
florescence/IM
florescent/I
floret/SM
florid/PY
floridness/M
florin/SM
florist/SM
floss/MDSG
flossy/RT
flotation/SM
flotilla/MS
flotsam/M
flounce/DSMG
flouncy
flounder/MDSG
flour/SMDG
flourish/GMDS
floury
flout/SMDRZG
flouter/M
flow/MDGS
flowchart/SM
flower's
flower/CSDG
flowerbed/MS
floweriness/M
flowering/S
flowerless
flowerpot/MS
flowery/PTR
flown
flt
flu/M
flub/MS
flubbed
flubbing
fluctuate/GNDSX
fluctuation/M
flue/MS
fluency/M
fluent/Y
fluff/SMDG
fluffiness/M
fluffy/RPT
fluid/SMY
fluidity/M
fluke/SM
fluky/RT
flume/SM
flummox/DSG
flung
flunk/SMDG
flunky/SM
fluoresce/DSG
fluorescence/M
fluorescent
fluoridate/GNDS
fluoridation/M
fluoride/SM
fluorine/M
fluorite/M
fluorocarbon/MS
fluoroscope/SM
fluoroscopic
flurry/GDSM
flush/MDRSTG
fluster/MDSG
flute/DSMG
fluting/M
flutist/MS
flutter/MDSG
fluttery
fluvial
flux/IMS
fluxed
fluxing
fly/ZTGBDRSM
flyaway
flyblown
flyby/M
flybys
flycatcher/MS
flying/M
flyleaf/M
flyleaves
flyover/MS
flypaper/SM
flypast/S
flysheet/S
flyspeck/GMDS
flyswatter/MS
flytrap/S
flyway/SM
flyweight/SM
flywheel/MS
foal/MDGS
foam/MDGS
foaminess/M
foamy/RTP
fob/SM
fobbed
fobbing
focal/Y
focus's
focus/ADSG
focused/U
fodder/SM
foe/SM
fog's
fog/CS
fogbound
fogged/C
foggily
fogginess/M
fogging/C
foggy/RTP
foghorn/MS
fogy/SM
fogyish
foible/SM
foil/MDGS
foist/SDG
fol
fold's
fold/AUSGD
foldaway
folder/SM
foldout/MS
foliage/M
folic
folio/SM
folk/MS
folklore/M
folkloric
folklorist/MS
folksiness/M
folksinger/SM
folksinging/M
folksy/PTR
folktale/MS
folkway/MS
foll
follicle/MS
follow/SDRZGJ
follower/M
following/M
followup/S
folly/SM
foment/SGD
fomentation/M
fond/RYTP
fondant/MS
fondle/DSG
fondness/M
fondue/SM
font/MS
fontanel/MS
foo
foobar
food/MS
foodie/SM
foodstuff/SM
fool/MDGS
foolery/SM
foolhardily
foolhardiness/M
foolhardy/TPR
foolish/YP
foolishness/M
foolproof
foolscap/M
foot/MDRZGSJ
footage/M
football/MRZGS
footballer/M
footbridge/SM
footfall/MS
foothill/MS
foothold/MS
footie
footing/M
footless
footlights/M
footling/MS
footlocker/SM
footloose
footman/M
footmen
footnote/MGDS
footpath/M
footpaths
footplate/S
footprint/SM
footrace/MS
footrest/MS
footsie/SM
footslogging
footsore
footstep/MS
footstool/SM
footwear/M
footwork/M
footy
fop/SM
foppery/M
foppish/P
foppishness/M
for/H
fora
forage/DRSMZG
forager/M
foray/SMDG
forbade
forbear/SMG
forbearance/M
forbid/S
forbidden
forbidding/YS
forbore
forborne
force/DSMG
forced/U
forceful/PY
forcefulness/M
forceps/M
forcible
forcibly
ford/MDGSB
fore/MS
forearm/GSMD
forebear/MS
forebode/GJDS
foreboding/M
forecast/MRZGS
forecaster/M
forecastle/MS
foreclose/DSG
foreclosure/MS
forecourt/SM
foredoom/DGS
forefather/MS
forefeet
forefinger/SM
forefoot/M
forefront/SM
forego/G
foregoes
foregone
foreground/GMDS
forehand/MS
forehead/MS
foreign/ZRP
foreigner/M
foreignness/M
foreknew
foreknow/GS
foreknowledge/M
foreknown
foreleg/SM
forelimb/MS
forelock/MS
foreman/M
foremast/MS
foremen
foremost
forename/MDS
forenoon/MS
forensic/MS
forensically
forensics/M
foreordain/GSD
forepart/MS
foreperson/SM
foreplay/M
forequarter/MS
forerunner/MS
foresail/MS
foresaw
foresee/RSBZ
foreseeable/U
foreseeing
foreseen/U
foreseer/M
foreshadow/GDS
foreshore/S
foreshorten/DSG
foresight/MD
foresightedness/M
foreskin/MS
forest's
forest/ACGDS
forestall/SGD
forestation/ACM
forester/MS
forestland/M
forestry/M
foretaste/DSMG
foretell/GS
forethought/M
foretold
forever/M
forevermore
forewarn/DSG
forewent
forewoman/M
forewomen
foreword/MS
forfeit/GSMD
forfeiture/SM
forgather/SDG
forgave
forge/DRSMZGVJ
forger/M
forgery/SM
forget/S
forgetful/YP
forgetfulness/M
forgettable/U
forgetting
forging/M
forgivable/U
forgive/BRSZGP
forgiven
forgiveness/M
forgiver/M
forgiving/U
forgo/RZG
forgoer/M
forgoes
forgone
forgot
forgotten/U
fork/MDGS
forkful/SM
forklift/MS
forlorn/Y
form's
form/CAIFDGS
formal/SMY
formaldehyde/M
formalin
formalism/M
formalist/MS
formalities
formality/IM
formalization/M
formalize/GDS
format/SMV
formation/CFASM
formatted/A
formatting/M
formed/U
former/FIAM
formerly
formfitting
formic
formidable
formidably
formless/PY
formlessness/M
formula/MS
formulaic
formulate/ADSGNX
formulated/U
formulation/AM
formulator/SM
fornicate/GNDS
fornication/M
fornicator/MS
forsake/GS
forsaken
forsook
forsooth
forswear/SG
forswore
forsworn
forsythia/SM
fort/MS
forte/SM
forthcoming/M
forthright/YP
forthrightness/M
forthwith
fortieth/M
fortieths
fortification/M
fortified/U
fortifier/M
fortify/DRSNZGX
fortissimo
fortitude/M
fortnight/MYS
fortress/MS
fortuitous/YP
fortuitousness/M
fortuity/M
fortunate/UY
fortune/MS
fortuneteller/SM
fortunetelling/M
forty/SMH
forum/SM
forward/MDRYZTGSP
forwarder/M
forwardness/M
forwent
fossa
fossil/SM
fossilization/M
fossilize/GDS
foster/GSD
fought
foul/MDRYTGSP
foulard/M
foulmouthed
foulness/M
found/FSDG
foundation/SM
founded/U
founder/GMDS
foundling/SM
foundry/SM
fount/SM
fountain/SM
fountainhead/MS
four/MHS
fourfold
fourposter/SM
fourscore/M
foursome/SM
foursquare
fourteen/SMH
fourteenth/M
fourteenths
fourth/MY
fourths
fowl/MDGS
fox/GMDS
foxfire/M
foxglove/SM
foxhole/MS
foxhound/SM
foxhunt/GS
foxily
foxiness/M
foxtrot/MS
foxtrotted
foxtrotting
foxy/RTP
foyer/SM
fps
fr
fracas/MS
frack/SDG
fractal/SM
fraction/ISM
fractional/Y
fractious/YP
fractiousness/M
fracture/MGDS
frag/S
fragile/RT
fragility/M
fragment/GMDS
fragmentary/M
fragmentation/M
fragrance/MS
fragrant/Y
frail/RYTP
frailness/M
frailty/SM
frame/DRSMZG
framed/U
framer/M
framework/SM
franc/SM
franchise's
franchise/EDSG
franchisee/SM
franchiser/SM
francium/M
francophone
frangibility/M
frangible
frank/SMDRYTGP
frankfurter/MS
frankincense/M
frankness/M
frantic
frantically
frappe/SM
frat/MS
fraternal/Y
fraternity/FSM
fraternization/M
fraternize/ZGDRS
fraternizer/M
fratricidal
fratricide/MS
fraud's
fraud/S
fraudster/S
fraudulence/M
fraudulent/Y
fraught
fray's
fray/CDGS
frazzle/MGDS
freak/SMDG
freakish/YP
freakishness/M
freaky/RT
freckle/DSMG
freckly
free/YTDRS
freebase/MGDS
freebie/SM
freebooter/SM
freeborn
freedman/M
freedmen
freedom/SM
freehand
freehold/ZMRS
freeholder/M
freeing
freelance/DRSMZG
freelancer/M
freeload/SDRZG
freeloader/M
freeman/M
freemasonry
freemen
freephone
freesia/S
freestanding
freestone/SM
freestyle/SM
freethinker/SM
freethinking/M
freeware/M
freeway/MS
freewheel/DGS
freewill
freezable
freeze's
freeze/UAGS
freezer/MS
freezing's
freight/MDRZGS
freighter/M
french
frenetic
frenetically
frenzied/Y
frenzy/DSM
freq
frequencies
frequency/IM
frequent/DRYSZTG
frequented/U
frequenter/M
fresco/M
frescoes
fresh/PNRYXZT
freshen/ZGDR
freshener/M
freshet/MS
freshman/M
freshmen
freshness/M
freshwater/M
fret/MS
fretful/YP
fretfulness/M
fretsaw/MS
fretted
fretting
fretwork/M
friable
friar/SM
friary/SM
fricassee/DSM
fricasseeing
fricative/SM
friction/SM
frictional
fridge/SM
friedcake/MS
friend's
friend/UGSDY
friendless
friendlies
friendliness/UM
friendly's
friendly/UPTR
friendship/MS
frieze/SM
frig/S
frigate/MS
frigged
frigging
fright/SXGMDN
frighten/DG
frightening/Y
frightful/PY
frightfulness/M
frigid/YP
frigidity/M
frigidness/M
frill/SMD
frilly/TR
fringe's
fringe/IDSG
frippery/SM
frisk/SDG
friskily
friskiness/M
frisky/TRP
frisson/S
fritter/MDSG
fritz/M
frivolity/SM
frivolous/PY
frivolousness/M
frizz/MDSYG
frizzle/MGDS
frizzy/TR
fro
frock's
frock/CUS
frog/MS
frogging/S
frogman/M
frogmarch/GDS
frogmen
frogspawn
frolic/SM
frolicked
frolicker/SM
frolicking
frolicsome
from
frond/SM
front's
front/FSDG
frontage/MS
frontal/Y
frontbench/ZRS
frontier/MS
frontiersman/M
frontiersmen
frontierswoman
frontierswomen
frontispiece/MS
frontward/S
frosh/M
frost's
frost/CSDG
frostbit
frostbite/MGS
frostbitten
frostily
frostiness/M
frosting/SM
frosty/TPR
froth/MDG
frothiness/M
froths
frothy/TPR
froufrou/M
froward/P
frowardness/M
frown/SMDG
frowzily
frowziness/M
frowzy/TPR
froze/AU
frozen/UA
fructify/DSG
fructose/M
frugal/Y
frugality/M
fruit/SMDG
fruitcake/MS
fruiterer/S
fruitful/YP
fruitfulness/M
fruitiness/M
fruition/M
fruitless/PY
fruitlessness/M
fruity/TPR
frump/SM
frumpish
frumpy/TR
frustrate/GNXDS
frustrating/Y
frustration/M
frustum/MS
fry/GDSM
fryer/SM
ft
ftp/ZGS
fuchsia/MS
fuck/SMGDRZ!
fucker/M!
fuckhead/S!
fuddle/DSMG
fudge/DSMG
fuehrer/MS
fuel's
fuel/ADGS
fug
fugal
fuggy
fugitive/MS
fugue/SM
fuhrer/SM
fulcrum/MS
fulfill/LDGS
fulfilled/U
fulfilling/U
fulfillment/M
full/MDRZTGSP
fullback/MS
fuller/M
fullness/M
fully
fulminate/DSXGN
fulmination/M
fulsome/PY
fulsomeness/M
fum/S
fumble/DRSMZG
fumbler/M
fumbling/Y
fume/MGDS
fumigant/MS
fumigate/GNDS
fumigation/M
fumigator/SM
fumy/RT
fun/M
function/MDGS
functional/Y
functionalism
functionalist/S
functionality/S
functionary/SM
fund/AMDGS
fundamental/SMY
fundamentalism/M
fundamentalist/SM
funded/U
funding/M
fundraiser/MS
fundraising
funeral/MS
funerary
funereal/Y
funfair/S
fungal
fungi
fungible/MS
fungicidal
fungicide/MS
fungoid
fungous
fungus/M
funicular/SM
funk/MDGS
funkiness/M
funky/PRT
funnel/MDGS
funner
funnest
funnily
funniness/M
funny/TPRSM
funnyman/M
funnymen
fur/SM
furbelow/M
furbish/ADSG
furious/Y
furl's
furl/UDGS
furlong/SM
furlough/GMD
furloughs
furn
furnace/SM
furnish/ADSG
furnished/U
furnishings/M
furniture/M
furor/SM
furred
furrier/M
furriness/M
furring/M
furrow/MDSG
furry/ZTRP
further/SGD
furtherance/M
furthermore
furthermost
furthest
furtive/YP
furtiveness/M
fury/SM
furze/M
fuse's/A
fuse/CAIFGDS
fusee/SM
fuselage/SM
fusibility/M
fusible
fusilier/SM
fusillade/MS
fusion/IFKSM
fuss/MDSG
fussbudget/MS
fussily
fussiness/M
fusspot/SM
fussy/TRP
fustian/M
fustiness/M
fusty/TRP
fut
futile/Y
futility/M
futon/SM
future/MS
futurism/M
futurist/MS
futuristic
futurity/SM
futurologist/MS
futurology/M
futz/DSG
fuzz/MDSG
fuzzball/S
fuzzily
fuzziness/M
fuzzy/PTR
fwd
fwy
g/SNXVB
gab/SM
gabardine/SM
gabbed
gabbiness/M
gabbing
gabble/DSMG
gabby/RTP
gaberdine/SM
gabfest/MS
gable/DSM
gad/S
gadabout/SM
gadded
gadder/SM
gadding
gadfly/SM
gadget/SM
gadgetry/M
gadolinium/M
gaff/MDRZGS
gaffe/SM
gaffer/M
gag/SM
gaga
gagged
gagging
gaggle/SM
gaiety/M
gaily
gain's
gain/ADGS
gainer/SM
gainful/Y
gainsaid
gainsay/ZGRS
gainsayer/M
gait/MRZS
gaiter/M
gal/SM
gala/MS
galactic
galaxy/SM
gale's
gale/AS
galena/M
gall/MDGS
gallant/SMY
gallantry/M
gallbladder/MS
galleon/SM
galleria/MS
gallery/SM
galley/SM
gallimaufry/SM
gallium/M
gallivant/GSD
gallon/SM
gallop/SMDG
gallows/M
gallstone/MS
galoot/SM
galore
galosh/MS
galumph/DG
galumphs
galvanic
galvanism/M
galvanization/M
galvanize/DSG
galvanometer/MS
gambit/SM
gamble/DRSMZG
gambler/M
gambling/M
gambol/SMDG
game/MYTGDRSP
gamecock/MS
gamekeeper/MS
gameness/M
gamesmanship/M
gamester/MS
gamete/SM
gametic
gamin/SM
gamine/SM
gaminess/M
gaming/M
gamma/SM
gammon/M
gammy
gamut/SM
gamy/RTP
gander/SM
gang/MDGS
gangbusters/M
gangland/M
ganglia
gangling
ganglion/M
ganglionic
gangplank/SM
gangrene/DSMG
gangrenous
gangsta/S
gangster/SM
gangway/MS
ganja
gannet/SM
gantlet/MS
gantry/SM
gap/GSMD
gape/MS
gar/SLM
garage/DSMG
garb/MDGS
garbage/M
garbageman
garbanzo/SM
garble/DSG
garcon/SM
garden/SZGMDR
gardener/M
gardenia/MS
gardening/M
garfish/MS
gargantuan
gargle/DSMG
gargoyle/SM
garish/PY
garishness/M
garland/MDGS
garlic/M
garlicky
garment/MS
garner/SGD
garnet/SM
garnish/GLMDS
garnishee/DSM
garnisheeing
garnishment/SM
garret/SM
garrison/MDSG
garrote/MZGDRS
garroter/M
garrulity/M
garrulous/PY
garrulousness/M
garter/SM
gas's
gas/CS
gasbag/SM
gaseous
gash/MDSG
gasholder/S
gasket/SM
gaslight/MS
gasman
gasmen
gasohol/M
gasoline/M
gasometer/S
gasp/MDGS
gassed/C
gasses
gassing/C
gassy/RT
gastric
gastritis/M
gastroenteritis/M
gastrointestinal
gastronome/S
gastronomic
gastronomical/Y
gastronomy/M
gastropod/SM
gasworks/M
gate/MGDS
gateau
gateaux
gatecrash/DRSZG
gatecrasher/M
gatehouse/SM
gatekeeper/MS
gatepost/MS
gateway/MS
gather/SJZGMDR
gatherer/M
gathering/M
gator/SM
gauche/RPYT
gaucheness/M
gaucherie/M
gaucho/SM
gaudily
gaudiness/M
gaudy/RPT
gauge/DSMG
gaunt/RPT
gauntlet/MS
gauntness/M
gauze/M
gauziness/M
gauzy/RPT
gave
gavel/SM
gavotte/MS
gawd
gawk/DGS
gawkily
gawkiness/M
gawky/RPT
gawp/DGS
gay/TSPMR
gayness/M
gaze/MZGDRS
gazebo/SM
gazelle/MS
gazer/M
gazette/MGDS
gazetteer/MS
gazillion/S
gazpacho/M
gazump/DGS
gear/MDGS
gearbox/MS
gearing/M
gearshift/MS
gearwheel/SM
gecko/SM
geddit
gee/DS
geeing
geek/MS
geeky/RT
geese
geezer/MS
geisha/M
gel/SM
gelatin/M
gelatinous
gelcap/M
geld/DJGS
gelding/M
gelid
gelignite/M
gelled
gelling
gem/SM
gemological
gemologist/MS
gemology/M
gemstone/MS
gendarme/MS
gender/MDS
gene/MS
genealogical/Y
genealogist/MS
genealogy/SM
genera
general/SMY
generalissimo/MS
generalist/MS
generality/SM
generalization/MS
generalize/GDS
generalship/M
generate/CAVNGSD
generation/ACM
generational
generations
generator/SM
generic/SM
generically
generosity/SM
generous/PY
generousness/M
genes/S
genesis/M
genetic/S
genetically
geneticist/MS
genetics/M
genial/FY
geniality/FM
geniculate
genie/SM
genii
genital/FY
genitalia/M
genitals/M
genitive/MS
genitourinary
genius/MS
genned
genning
genocidal
genocide/MS
genome/MS
genomics
genre/SM
gent/AMS
genteel/YP
genteelness/M
gentian/SM
gentile/SM
gentility/M
gentle/TGDRSP
gentlefolk/MS
gentlefolks/M
gentleman/MY
gentlemanly/U
gentlemen
gentleness/M
gentlewoman/M
gentlewomen
gently
gentrification/M
gentrify/DSGN
gentry/SM
genuflect/DGS
genuflection/MS
genuine/PY
genuineness/M
genus/M
geocache/DSG
geocentric
geocentrically
geochemistry/M
geode/SM
geodesic/SM
geodesy/M
geodetic
geoengineering
geog
geographer/SM
geographic
geographical/Y
geography/SM
geologic
geological/Y
geologist/MS
geology/SM
geom
geomagnetic
geomagnetism/M
geometer
geometric
geometrical/Y
geometry/SM
geophysical
geophysicist/SM
geophysics/M
geopolitical
geopolitics/M
geostationary
geosynchronous
geosyncline/MS
geothermal
geothermic
geranium/MS
gerbil/MS
geriatric/S
geriatrician/S
geriatrics/M
germ/MS
germane
germanium/M
germicidal
germicide/MS
germinal/M
germinate/GNDS
germination/M
gerontological
gerontologist/MS
gerontology/M
gerrymander/GMDS
gerrymandering/M
gerund/MS
gestalt/S
gestapo/MS
gestate/GNDS
gestation/M
gestational
gesticulate/DSGNX
gesticulation/M
gestural
gesture/MGDS
gesundheit
get/S
getaway/SM
getting
getup/M
gewgaw/SM
geyser/SM
ghastliness/M
ghastly/TPR
ghat/MS
ghee
gherkin/MS
ghetto/SM
ghettoize/GDS
ghost/SMDYG
ghostliness/M
ghostly/RTP
ghostwrite/ZGRS
ghostwriter/M
ghostwritten
ghostwrote
ghoul/SM
ghoulish/YP
ghoulishness/M
giant/SM
giantess/MS
gibber/GDS
gibberish/M
gibbet/GMDS
gibbon/MS
gibbous
gibe/MGDS
giblet/SM
giddily
giddiness/M
giddy/RTP
gift/MDGS
gig/SM
gigabit/SM
gigabyte/MS
gigahertz/M
gigantic
gigantically
gigapixel/MS
gigawatt/SM
gigged
gigging
giggle/DRSMZG
giggler/M
giggly/RT
gigolo/SM
gild/MDRZGS
gilder/M
gilding/M
gill/MS
gillie/S
gillion/S
gilt/MS
gimbals/M
gimcrack/SM
gimcrackery/M
gimlet/GSMD
gimme/SM
gimmick/MS
gimmickry/M
gimmicky
gimp/MDGS
gimpy
gin/SM
ginger/GSMDY
gingerbread/M
gingersnap/SM
gingery
gingham/M
gingivitis/M
ginkgo/M
ginkgoes
ginned
ginning
ginormous
ginseng/M
giraffe/MS
gird/DRZGS
girder/M
girdle/DSMG
girl/MS
girlfriend/MS
girlhood/SM
girlish/YP
girlishness/M
girly
giro/S
girt/MDGS
girth/M
girths
gist/M
git/S
gite/S
give/ZGJRS
giveaway/MS
giveback/MS
given/SM
giver/M
gizmo/SM
gizzard/MS
glace/S
glaceed
glaceing
glacial/Y
glaciate/XGNDS
glaciation/M
glacier/MS
glad/MYSP
gladden/GDS
gladder
gladdest
glade/SM
gladiator/SM
gladiatorial
gladiola/SM
gladioli
gladiolus/M
gladness/M
gladsome
glam
glamorization/M
glamorize/DSG
glamorous/Y
glamour/GMDS
glance/DSMG
gland/SM
glandes
glandular
glans/M
glare/DSMG
glaring/Y
glasnost/M
glass/MDSG
glassblower/MS
glassblowing/M
glassful/SM
glasshouse/S
glassily
glassiness/M
glassware/M
glassy/RTP
glaucoma/M
glaze/DSMG
glazier/SM
glazing/M
gleam/SMDGJ
glean/SDRZGJ
gleaner/M
gleanings/M
glee/M
gleeful/YP
gleefulness/M
glen/MS
glenohumeral
glenoid
glib/YP
glibber
glibbest
glibness/M
glide/DRSMZG
glider/M
gliding/M
glimmer/MDGJS
glimmering/M
glimpse/MGDS
glint/SMDG
glissandi
glissando/M
glisten/MDSG
glister/DSG
glitch/GMDS
glitter/MDSG
glitterati
glittery
glitz/M
glitzy/TR
gloaming/SM
gloat/SMDG
gloating/Y
glob/MDGS
global/Y
globalism/M
globalist/MS
globalization/M
globalize/GDS
globe/SM
globetrotter/MS
globetrotting
globular
globule/MS
globulin/M
glockenspiel/SM
gloom/M
gloomily
gloominess/M
gloomy/TRP
glop/M
gloppy
glorification/M
glorify/GDSN
glorious/IY
glory/DSMG
gloss/MDSG
glossary/SM
glossily
glossiness/M
glossolalia/M
glossy/PTRSM
glottal
glottis/MS
glove/DSMG
glow/MDRZGS
glower/GMD
glowing/Y
glowworm/MS
glucagon
glucose/M
glue/MGDS
glued/U
gluey
gluier
gluiest
glum/YP
glummer
glummest
glumness/M
glut/MNS
gluten/M
glutenous
glutinous/Y
glutted
glutting
glutton/MS
gluttonous/Y
gluttony/M
glycerin/M
glycerol/M
glycogen/M
glyph
gm
gnarl/SMDG
gnarly/TR
gnash/MDSG
gnat/MS
gnaw/DGS
gneiss/M
gnocchi
gnome/SM
gnomic
gnomish
gnu/SM
go/JMRHZG
goad/MDGS
goal/MS
goalie/SM
goalkeeper/MS
goalkeeping/M
goalless
goalmouth
goalmouths
goalpost/MS
goalscorer/S
goaltender/MS
goat/MS
goatee/SM
goatherd/MS
goatskin/MS
gob/SM
gobbed
gobbet/SM
gobbing
gobble/DRSMZG
gobbledygook/M
gobbler/M
goblet/SM
goblin/SM
gobsmacked
gobstopper/S
god/SM
godawful
godchild/M
godchildren/M
goddammit
goddamn/D
goddaughter/MS
goddess/MS
godfather/SM
godforsaken
godhead/M
godhood/M
godless/PY
godlessness/M
godlike
godliness/UM
godly/URTP
godmother/SM
godparent/SM
godsend/SM
godson/SM
godspeed
goer/M
goes
gofer/SM
goggle/DSMG
goggles/M
going/M
goiter/SM
gold/MNS
goldbrick/ZGSMDR
goldbricker/M
golden/TR
goldenrod/M
goldfield/S
goldfinch/MS
goldfish/MS
goldmine/SM
goldsmith/M
goldsmiths
golf/MDRZGS
golfer/M
golliwog/S
golly/SM
gonad/SM
gonadal
gondola/MS
gondolier/SM
gone/ZR
goner/M
gong/MDGS
gonk/S
gonna
gonorrhea/M
gonorrheal
gonzo
goo/M
goober/SM
good/MYSP
goodbye/MS
goodhearted
goodish
goodly/TR
goodness/M
goodnight
goods/M
goodwill/M
goody/SM
gooey
goof/MDGS
goofball/SM
goofiness/M
goofy/RPT
google/DSMG
googly/S
gooier
gooiest
gook/MS
goon/MS
goop/M
goose/DSMG
gooseberry/SM
goosebumps/M
goosestep/S
goosestepped
goosestepping
gopher/SM
gore/MGDS
gorge's
gorge/EDSG
gorgeous/YP
gorgeousness/M
gorgon/SM
gorilla/MS
gorily
goriness/M
gormandize/DRSZG
gormandizer/M
gormless
gorp/MS
gorse/M
gory/RTP
gosh
goshawk/MS
gosling/SM
gospel/MS
gossamer/M
gossip/MDRZGS
gossiper/M
gossipy
got
gotcha/S
goths
gotta
gotten
gouache/S
gouge/DRSMZG
gouger/M
goulash/MS
gourd/SM
gourde/MS
gourmand/SM
gourmet/SM
gout/M
gouty/TR
gov
govern/DGSBL
governable/U
governance/M
governed/U
governess/MS
government/MS
governmental
governor/SM
governorship/M
govt
gown/MDGS
gr
grab/MS
grabbed
grabber/MS
grabbing
grabby/TR
grace/EDSMG
graceful/EPY
gracefulness/EM
graceless/PY
gracelessness/M
gracious/UY
graciousness/M
grackle/MS
grad/MRZSB
gradate/XGNDS
gradation/CM
grade's
grade/CADSG
graded/U
grader/M
gradient/MS
gradual/PY
gradualism/M
gradualness/M
graduate/XMGNDS
graduation/M
graffiti
graffito/M
graft/SMDRZG
grafter/M
graham/S
grail
grain/ISMD
graininess/M
grainy/PTR
gram/KMS
grammar/MS
grammarian/SM
grammatical/UY
gramophone/MS
grampus/MS
gran/S
granary/SM
grand/SMRYPT
grandam/MS
grandaunt/MS
grandchild/M
grandchildren/M
granddad/SM
granddaddy/SM
granddaughter/SM
grandee/MS
grandeur/M
grandfather/GMDYS
grandiloquence/M
grandiloquent
grandiose/Y
grandiosity/M
grandma/MS
grandmother/MYS
grandnephew/MS
grandness/M
grandniece/MS
grandpa/MS
grandparent/MS
grandson/MS
grandstand/SGMD
granduncle/SM
grange/SM
granite/M
granitic
granny/SM
granola/M
grant/SMDRZG
grantee/MS
granter/M
grantsmanship/M
granular
granularity/M
granulate/GNDS
granulation/M
granule/MS
grape/SM
grapefruit/MS
grapeshot/M
grapevine/SM
graph/MDG
graphic/MS
graphical/Y
graphite/M
graphologist/MS
graphology/M
graphs
grapnel/MS
grapple/MGDS
grasp/SMDBG
grass/MDSG
grasshopper/MS
grassland/MS
grassroots
grassy/TR
grate/DRSMZGJ
grateful/UYP
gratefulness/UM
grater/M
gratification/M
gratify/GNXDS
gratifying/Y
gratin/S
grating/MY
gratis
gratitude/IM
gratuitous/YP
gratuitousness/M
gratuity/SM
gravamen/MS
grave/DRSMYTGP
gravedigger/SM
gravel/SGMDY
graven
graveness/M
graveside/MS
gravestone/SM
graveyard/MS
gravid
gravimeter/MS
gravitas
gravitate/GNDS
gravitation/M
gravitational
gravity/M
gravy/SM
gray/MDRTGSP
graybeard/SM
grayish
grayness/M
graze/DRSMZG
grazer/M
grease/DRSMZG
greasepaint/M
greasily
greasiness/M
greasy/PTR
great/SMRYPT
greatcoat/SM
greathearted
greatness/M
grebe/SM
greed/M
greedily
greediness/M
greedy/PTR
green/GPSMDRYT
greenback/MS
greenbelt/MS
greenery/M
greenfield
greenfly/S
greengage/MS
greengrocer/SM
greenhorn/SM
greenhouse/SM
greenish
greenmail/M
greenness/M
greenroom/SM
greensward/M
greenwood/M
greet/ZGJSDR
greeter/M
greeting/M
gregarious/PY
gregariousness/M
gremlin/SM
grenade/SM
grenadier/MS
grenadine/M
grep/S
grepped
grepping
grew/A
greyhound/SM
gribble/S
grid/MS
griddle/SM
griddlecake/SM
gridiron/SM
gridlock/SMD
grief/SM
grievance/MS
grieve/ZGDRS
griever/M
grievous/PY
grievousness/M
griffin/SM
griffon/SM
grill/SGMDJ
grille/MS
grim/DYPG
grimace/DSMG
grime/SM
griminess/M
grimmer
grimmest
grimness/M
grimy/TRP
grin/MS
grind/SZGMRJ
grinder/M
grindstone/MS
gringo/MS
grinned
grinning
grip/MDRSZG
gripe/SM
griper/M
grippe/MZGDR
gripper/M
grisliness/M
grisly/RTP
grist/MY
gristle/M
gristmill/MS
grit/MS
grits/M
gritted
gritter/SM
grittiness/M
gritting
gritty/RTP
grizzle/DSG
grizzly/TRSM
groan/SGMD
groat/SM
grocer/MS
grocery/SM
grog/M
groggily
grogginess/M
groggy/PRT
groin/SM
grok/S
grokked
grokking
grommet/SM
groom/SZGMDR
groomer/M
grooming/M
groomsman/M
groomsmen
groove/MGDS
groovy/RT
grope/DRSMZG
groper/M
grosbeak/MS
grosgrain/M
gross/PTGMDRSY
grossness/M
grotesque/SPMY
grotesqueness/M
grotto/M
grottoes
grotty/TR
grouch/GMDS
grouchily
grouchiness/M
grouchy/RTP
ground/ZGMDRJS
groundbreaking/MS
groundcloth
groundcloths
grounder/M
groundhog/MS
grounding/M
groundless/Y
groundnut/MS
groundsheet/S
groundskeeper/S
groundsman
groundsmen
groundswell/SM
groundwater/M
groundwork/M
group/JSZGMDR
grouper/M
groupie/MS
grouping/M
groupware/M
grouse/MZGDRS
grouser/M
grout/SGMD
grove/SM
grovel/ZGDRS
groveler/M
grovelled
grovelling
grow/AHSG
grower/MS
growing/I
growl/SZGMDR
growler/M
grown/AI
grownup/MS
growth/AM
growths
grub/MS
grubbed
grubber/MS
grubbily
grubbiness/M
grubbing
grubby/TRP
grubstake/M
grudge/MGDS
grudging/Y
grue/S
gruel/GJM
grueling/Y
gruesome/RYTP
gruesomeness/M
gruff/TPRY
gruffness/M
grumble/DRSMZGJ
grumbler/M
grump/SM
grumpily
grumpiness/M
grumpy/PRT
grunge/MS
grungy/RT
grunion/SM
grunt/SGMD
gt
guacamole/M
guanine/M
guano/M
guarani/MS
guarantee/MDS
guaranteeing
guarantor/MS
guaranty/GDSM
guard/SZGMDR
guarded/Y
guarder/M
guardhouse/SM
guardian/SM
guardianship/M
guardrail/SM
guardroom/SM
guardsman/M
guardsmen
guava/SM
gubernatorial
guerrilla/SM
guess/ZGBMDRS
guesser/M
guesstimate/DSMG
guesswork/M
guest/SGMD
guestbook/SM
guesthouse/S
guestroom/S
guff/M
guffaw/MDGS
guidance/M
guide/DRSMZG
guidebook/SM
guided/U
guideline/SM
guidepost/SM
guider/M
guild/SZMR
guilder/M
guildhall/MS
guile/M
guileful
guileless/YP
guilelessness/M
guillemot/S
guillotine/DSMG
guilt/M
guiltily
guiltiness/M
guiltless
guilty/PRT
guinea/MS
guise/ESM
guitar/MS
guitarist/SM
gulag/SM
gulch/MS
gulden/MS
gulf/MS
gull/MDSG
gullet/MS
gullibility/M
gullible
gully/SM
gulp/MDRSZG
gulper/M
gum/SM
gumball/S
gumbo/SM
gumboil/SM
gumboot/S
gumdrop/SM
gummed
gumming
gummy/TR
gumption/M
gumshoe/MDS
gumshoeing
gun/SM
gunboat/SM
gunfight/MRZS
gunfighter/M
gunfire/M
gunge
gungy
gunk/M
gunky
gunman/M
gunmen
gunmetal/M
gunned
gunnel/MS
gunner/MS
gunnery/M
gunning
gunny/M
gunnysack/MS
gunpoint/M
gunpowder/M
gunrunner/MS
gunrunning/M
gunship/MS
gunshot/MS
gunslinger/SM
gunsmith/M
gunsmiths
gunwale/MS
guppy/SM
gurgle/MGDS
gurney/MS
guru/MS
gush/MDRSZG
gusher/M
gushing/Y
gushy/TR
gusset/MSDG
gussy/DSG
gust/EMDSG
gustatory
gustily
gusto/M
gusty/RT
gut/SM
gutless/P
gutlessness/M
gutsy/RT
gutted
gutter/SMDG
guttersnipe/MS
gutting
guttural/MS
gutty/RT
guv/S
guvnor/S
guy/SGMD
guzzle/DRSZG
guzzler/M
gym/SM
gymkhana/MS
gymnasium/MS
gymnast/MS
gymnastic/S
gymnastically
gymnastics/M
gymnosperm/SM
gymslip/S
gynecologic
gynecological
gynecologist/SM
gynecology/M
gyp/SM
gypped
gypper/SM
gypping
gypster/SM
gypsum/M
gypsy/SM
gyrate/DSGNX
gyration/M
gyrator/SM
gyrfalcon/MS
gyro/MS
gyroscope/MS
gyroscopic
gyve/MGDS
h'm
h/NRSXZGVJ
ha/SH
haberdasher/SM
haberdashery/SM
habiliment/SM
habit's
habit/ISB
habitability/M
habitat/SM
habitation/MS
habitual/YP
habitualness/M
habituate/GNDS
habituation/M
habitue/SM
hacienda/SM
hack/MDRZGS
hacker/M
hacking/M
hackish
hackle/MS
hackney/SMDG
hacksaw/SM
hacktivist/MS
hackwork/M
had
haddock/SM
hadn't
hadst
hafnium/M
haft/MS
hag/SM
haggard/YP
haggardness/M
haggis/MS
haggish
haggle/MZGDRS
haggler/M
hagiographer/SM
hagiography/SM
hahnium/M
haiku/M
hail/MDGS
hailstone/MS
hailstorm/MS
hair/MDS
hairball/MS
hairband/S
hairbreadth/M
hairbreadths
hairbrush/MS
haircloth/M
haircut/SM
hairdo/MS
hairdresser/SM
hairdressing/M
hairdryer/MS
hairgrip/S
hairiness/M
hairless
hairlike
hairline/SM
hairnet/SM
hairpiece/MS
hairpin/SM
hairsbreadth/M
hairsbreadths
hairsplitter/SM
hairsplitting/M
hairspray/S
hairspring/MS
hairstyle/MS
hairstylist/SM
hairy/TRP
haj
hajj/M
hajjes
hajji/SM
hake/MS
halal/M
halberd/SM
halcyon
hale/ITGDRS
half/M
halfback/SM
halfhearted/PY
halfheartedness/M
halfpence
halfpenny/SM
halftime/MS
halftone/MS
halfway
halfwit/SM
halibut/SM
halite/M
halitosis/M
hall/MS
hallelujah/M
hallelujahs
hallmark/GMDS
halloo/MSG
hallow/DSG
hallowed/U
hallucinate/GNXDS
hallucination/M
hallucinatory
hallucinogen/SM
hallucinogenic/SM
hallway/SM
halo/MDGS
halogen/SM
halon
halt/MDRZGS
halter/GMD
halterneck/S
halting/Y
halve/DSG
halyard/MS
ham/SM
hamburg/SZMR
hamburger/M
hamlet/MS
hammed
hammer/MDRSJZG
hammerer/M
hammerhead/SM
hammerlock/SM
hammertoe/MS
hamming
hammock/SM
hammy/TR
hamper/GMDS
hampered/U
hamster/MS
hamstring/GSM
hamstrung
hand's
hand/UDGS
handbag/SM
handball/MS
handbarrow/SM
handbill/MS
handbook/MS
handbrake/S
handcar/SM
handcart/MS
handclasp/MS
handcraft/SMDG
handcuff/MDGS
handed/P
handful/SM
handgun/SM
handheld/MS
handhold/MS
handicap/MS
handicapped
handicapper/MS
handicapping
handicraft/MS
handily
handiness/M
handiwork/M
handkerchief/MS
handle/MZGDRS
handlebar/MS
handler/M
handmade
handmaid/XMNS
handmaiden/M
handout/SM
handover/S
handpick/GDS
handrail/MS
handsaw/SM
handset/SM
handshake/JMGS
handsome/PYTR
handsomeness/M
handspring/MS
handstand/SM
handwork/M
handwoven
handwriting/M
handwritten
handy/UTR
handyman/M
handymen
hang/MDRJZGS
hangar/MS
hangdog
hanger/M
hanging/M
hangman/M
hangmen
hangnail/MS
hangout/SM
hangover/MS
hangup/MS
hank/MRZS
hanker/GJD
hankering/M
hankie/MS
hansom/MS
hap/MY
haphazard/YP
haphazardness/M
hapless/YP
haplessness/M
haploid/MS
happen/SDGJ
happening/M
happenstance/SM
happily/U
happiness/UM
happy/URTP
harangue/MGDS
harass/LZGDRS
harasser/M
harassment/M
harbinger/SM
harbor/GMDS
harbormaster/S
hard/NRYXTP
hardback/MS
hardball/M
hardboard/M
hardbound
hardcore
hardcover/SM
harden/ZGDR
hardened/U
hardener/M
hardhat/MS
hardheaded/PY
hardheadedness/M
hardhearted/PY
hardheartedness/M
hardihood/M
hardily
hardiness/M
hardliner/MS
hardness/M
hardscrabble
hardship/SM
hardstand/SM
hardtack/M
hardtop/SM
hardware/M
hardwired
hardwood/SM
hardworking
hardy/PTR
hare/MGDS
harebell/MS
harebrained
harelip/SM
harelipped
harem/SM
haricot/S
hark/DGS
harlequin/SM
harlot/SM
harlotry/M
harm/MDGS
harmed/U
harmful/YP
harmfulness/M
harmless/PY
harmlessness/M
harmonic/SM
harmonica/MS
harmonically
harmonies
harmonious/PY
harmoniousness/M
harmonium/MS
harmonization/M
harmonize/ZGDRS
harmonizer/M
harmony/EM
harness's
harness/UDSG
harp/MDGS
harpist/SM
harpoon/ZGSMDR
harpooner/M
harpsichord/MS
harpsichordist/SM
harpy/SM
harridan/MS
harrier/M
harrow/SMDG
harrumph/GD
harrumphs
harry/DRSZG
harsh/RYTP
harshness/M
hart/MS
harvest/SMDRZG
harvested/U
harvester/M
hash/AMDSG
hashish/M
hashtag/SM
hasn't
hasp/MS
hassle/DSMG
hassock/SM
hast/DNXG
haste/SM
hasten/DG
hastily
hastiness/M
hasty/RTP
hat/ZGSMDR
hatband/S
hatbox/MS
hatch/MDSG
hatchback/MS
hatcheck/SM
hatched/U
hatchery/SM
hatchet/SM
hatching/M
hatchway/SM
hate/MS
hateful/PY
hatefulness/M
hatemonger/MS
hater/M
hatpin/S
hatred/SM
hatstand/S
hatted
hatter/SM
hatting
hauberk/SM
haughtily
haughtiness/M
haughty/PRT
haul/MDRZGS
haulage/M
hauler/M
haulier/S
haunch/MS
haunt/SMDRZG
haunter/M
haunting/Y
hauteur/M
have/MGS
haven't
haven/SM
haversack/SM
havoc/M
haw/GSMD
hawk/MDRZGS
hawker/M
hawkish/P
hawkishness/M
hawser/SM
hawthorn/MS
hay/GSMD
haycock/SM
hayloft/SM
haymaking
haymow/SM
hayrick/MS
hayride/MS
hayseed/MS
haystack/SM
haywire
hazard/SMDG
hazardous/Y
haze/MZGJDRS
hazel/SM
hazelnut/MS
hazer/M
hazily
haziness/M
hazing/M
hazmat
hazy/RTP
hdqrs
he'd
he'll
he/M
head/MDRZGJS
headache/MS
headband/MS
headbanger/S
headbanging
headboard/SM
headbutt/DSG
headcase/S
headcheese
headcount/S
headdress/MS
header/M
headfirst
headgear/M
headhunt/DRSZG
headhunter/M
headhunting/M
headily
headiness/M
heading/M
headlamp/MS
headland/MS
headless
headlight/MS
headline/MZGDRS
headliner/M
headlock/MS
headlong
headman/M
headmaster/SM
headmen
headmistress/MS
headphone/MS
headpiece/MS
headpin/SM
headquarter/SDG
headquarters/M
headrest/MS
headroom/M
headscarf
headscarves
headset/SM
headship/SM
headshrinker/SM
headsman/M
headsmen
headstall/SM
headstand/SM
headstone/SM
headstrong
headteacher/S
headwaiter/SM
headwaters/M
headway/M
headwind/SM
headword/SM
heady/RTP
heal/DRHZGS
healed/U
healer/M
health/M
healthcare
healthful/PY
healthfulness/M
healthily/U
healthiness/UM
healthy/UTRP
heap/MDGS
hear/AHGJS
heard/AU
hearer/SM
hearing/AM
hearken/SGD
hearsay/M
hearse's
hearse/AS
heart/SM
heartache/MS
heartbeat/MS
heartbreak/SMG
heartbroken
heartburn/M
hearten/ESGD
heartfelt
hearth/M
hearthrug/S
hearths
hearthstone/SM
heartily
heartiness/M
heartland/MS
heartless/PY
heartlessness/M
heartrending/Y
heartsick/P
heartsickness/M
heartstrings/M
heartthrob/MS
heartwarming
heartwood/M
hearty/RSMPT
heat's
heat/ADGS
heated/U
heatedly
heater/SM
heath/MNRX
heathen/M
heathendom/M
heathenish
heathenism/M
heather/M
heaths
heating/M
heatproof
heatstroke/M
heatwave/S
heave/DRSMZG
heaven/SMY
heavenly/TR
heavens/M
heavenward/S
heaver/M
heavily
heaviness/M
heavy/RSMTP
heavyhearted
heavyset
heavyweight/MS
heck/M
heckle/DRSMZG
heckler/M
heckling/M
hectare/SM
hectic
hectically
hectogram/SM
hectometer/MS
hector/SMDG
hedge/DRSMZG
hedgehog/MS
hedgehop/S
hedgehopped
hedgehopping
hedger/M
hedgerow/SM
hedonism/M
hedonist/MS
hedonistic
heed/MDGS
heeded/U
heedful/Y
heedless/PY
heedlessness/M
heehaw/SMDG
heel/MDGS
heelless
heft/MDGS
heftily
heftiness/M
hefty/PRT
hegemonic
hegemony/M
hegira/SM
heifer/SM
height/XSMN
heighten/DG
heinous/YP
heinousness/M
heir/MS
heiress/MS
heirloom/SM
heist/SMDG
held
helical
helices
helicopter/SGMD
heliocentric
heliotrope/SM
helipad/S
heliport/MS
helium/M
helix/M
hell/M
hellbent
hellcat/MS
hellebore/M
hellfire
hellhole/MS
hellion/MS
hellish/YP
hellishness/M
hello/SM
helluva
helm/MS
helmet/SMD
helmsman/M
helmsmen
helot/SM
help/MDRZGSJ
helper/M
helpful/UY
helpfulness/M
helping/M
helpless/PY
helplessness/M
helpline/SM
helpmate/SM
helve/SM
hem/SM
hematite/M
hematologic
hematological
hematologist/MS
hematology/M
heme/M
hemisphere/SM
hemispheric
hemispherical
hemline/SM
hemlock/SM
hemmed
hemmer/SM
hemming
hemoglobin/M
hemophilia/M
hemophiliac/MS
hemorrhage/MGDS
hemorrhagic
hemorrhoid/MS
hemostat/MS
hemp/MN
hemstitch/MDSG
hen/M
hence
henceforth
henceforward
henchman/M
henchmen
henna/SMDG
henpeck/GSD
hep
heparin/M
hepatic
hepatitis/M
hepatocyte/S
hepper
heppest
heptagon/MS
heptagonal
heptathlon/SM
herald/SMDG
heralded/U
heraldic
heraldry/M
herb/MS
herbaceous
herbage/M
herbal/S
herbalist/MS
herbicidal
herbicide/MS
herbivore/SM
herbivorous
herculean
herd/MDRZGS
herder/M
herdsman/M
herdsmen
here/M
hereabout/S
hereafter/SM
hereby
hereditary
heredity/M
herein
hereinafter
hereof
hereon
heresy/SM
heretic/SM
heretical
hereto
heretofore
hereunto
hereupon
herewith
heritable/I
heritage/MS
hermaphrodite/SM
hermaphroditic
hermetic
hermetical/Y
hermit/SM
hermitage/MS
hernia/SM
hernial
herniate/GNDS
herniation/M
hero/M
heroes
heroic/S
heroically
heroics/M
heroin/SM
heroine/SM
heroism/M
heron/SM
herpes/M
herpetologist/SM
herpetology/M
herring/MS
herringbone/M
herself
hertz/M
hesitance/M
hesitancy/M
hesitant/Y
hesitate/DSGNX
hesitating/UY
hesitation/M
hessian
hetero/SM
heterodox
heterodoxy/M
heterogeneity/M
heterogeneous/Y
heterosexual/MYS
heterosexuality/M
heuristic/MS
heuristically
heuristics/M
hew/ZGSDR
hewer/M
hex/GMDS
hexadecimal/S
hexagon/MS
hexagonal
hexagram/SM
hexameter/SM
hey
heyday/SM
hf
hgt
hgwy
hi/SD
hiatus/MS
hibachi/MS
hibernate/GNDS
hibernation/M
hibernator/MS
hibiscus/MS
hiccough/DG
hiccoughs
hiccup/GSMD
hick/MS
hickey/SM
hickory/SM
hid
hidden
hide/MZGJDRS
hideaway/SM
hidebound
hideous/YP
hideousness/M
hideout/MS
hider/M
hiding/M
hie/S
hieing
hierarchic
hierarchical/Y
hierarchy/SM
hieroglyph/M
hieroglyphic/MS
hieroglyphs
high/MRYZTP
highball/SM
highborn
highboy/MS
highbrow/SM
highchair/MS
highfalutin
highhanded/PY
highhandedness/M
highland/MRZS
highlander/M
highlight/SMDRZG
highlighter/M
highness/M
highroad/MS
highs
hightail/DSG
highway/MS
highwayman/M
highwaymen
hijab
hijack/SJZGMDR
hijacker/M
hijacking/M
hike/MZGDRS
hiker/M
hiking/M
hilarious/PY
hilariousness/M
hilarity/M
hill/MS
hillbilly/SM
hilliness/M
hillock/MS
hillside/SM
hilltop/MS
hilly/PRT
hilt/MS
him/S
himself
hind/MRZS
hinder/GD
hindered/U
hindmost
hindquarter/MS
hindrance/SM
hindsight/M
hinge's
hinge/UDSG
hint/MDRZGS
hinter/M
hinterland/SM
hip/SPM
hipbath
hipbaths
hipbone/MS
hiphuggers
hipness/M
hipped
hipper
hippest
hippie/SM
hipping
hippo/SM
hippodrome/SM
hippopotamus/MS
hippy
hipster/MS
hiragana
hire's
hire/AGDS
hireling/MS
hirsute/P
hirsuteness/M
hiss/MDSG
hist
histamine/MS
histogram/MS
histologist/SM
histology/M
historian/MS
historic
historical/Y
historicity/M
historiographer/MS
historiography/M
history/SM
histrionic/S
histrionically
histrionics/M
hit/SM
hitch's
hitch/UDSG
hitcher/MS
hitchhike/DRSMZG
hitchhiker/M
hither
hitherto
hitter/SM
hitting
hive/MGDS
hiya
hmm
ho/SMDRYZ
hoagie/MS
hoard/SZGMDRJ
hoarder/M
hoarding/M
hoarfrost/M
hoariness/M
hoarse/YTRP
hoarseness/M
hoary/TRP
hoax/MDRSZG
hoaxer/M
hob/SM
hobbit/S
hobble/MZGDRS
hobbler/M
hobby/SM
hobbyhorse/MS
hobbyist/SM
hobgoblin/MS
hobnail/SGMD
hobnob/S
hobnobbed
hobnobbing
hobo/MS
hock/MDSG
hockey/M
hockshop/MS
hod/SM
hodgepodge/SM
hoe/SM
hoecake/SM
hoedown/SM
hoeing
hoer/M
hog/SM
hogan/SM
hogback/SM
hogged
hogging
hoggish/Y
hogshead/SM
hogtie/DS
hogtying
hogwash/M
hoick/SGD
hoist/SGMD
hoke/GDS
hokey
hokier
hokiest
hokum/M
hold/MRJSZG
holdall/S
holder/M
holding/M
holdout/SM
holdover/SM
holdup/MS
hole/MGDS
holey
holiday/SMDG
holidaymaker/S
holiness/UM
holism
holistic
holistically
holler/MDGS
hollow/MDRYPSTG
hollowness/M
holly/SM
hollyhock/MS
holmium/M
holocaust/SM
hologram/MS
holograph/M
holographic
holographs
holography/M
hols
holster/SMDG
holy/URPT
homage/MS
hombre/MS
homburg/SM
home/MYZGDRS
homebody/SM
homeboy/SM
homecoming/SM
homegrown
homeland/MS
homeless/MP
homelessness/M
homelike
homeliness/M
homely/PRT
homemade
homemaker/SM
homemaking/M
homeopath/M
homeopathic
homeopaths
homeopathy/M
homeostasis/M
homeostatic
homeowner/MS
homepage/MS
homer/GMD
homeroom/MS
homeschooling/M
homesick/P
homesickness/M
homespun/M
homestead/SMDRZG
homesteader/M
homestretch/MS
hometown/MS
homeward/S
homework/MRZG
homewrecker/SM
homey/SMP
homeyness/M
homicidal
homicide/MS
homier
homiest
homiletic
homily/SM
hominid/SM
hominoid/S
hominy/M
homo/MS
homoerotic
homogeneity/M
homogeneous/Y
homogenization/M
homogenize/DSG
homograph/M
homographs
homologous
homonym/SM
homophobia/M
homophobic
homophone/MS
homosexual/SM
homosexuality/M
hon/SZTGMDR
honcho/MS
hone/MS
honer/M
honest/EYT
honester
honesty/EM
honey/SGMD
honeybee/SM
honeycomb/MDSG
honeydew/SM
honeylocust/M
honeymoon/ZGMDRS
honeymooner/M
honeypot/S
honeysuckle/SM
honk/MDRSZG
honker/M
honky/SM
honor/ESGMDB
honorableness/M
honorably/E
honorarily
honorarium/MS
honorary
honoree/SM
honorer/SM
honorific/MS
hooch/M
hood/MDSG
hoodie/MS
hoodlum/SM
hoodoo/MDSG
hoodwink/DGS
hooey/M
hoof/MDRSZG
hook's
hook/UDSG
hookah/M
hookahs
hooker/MS
hookup/MS
hookworm/MS
hooky/M
hooligan/MS
hooliganism/M
hoop/MDSG
hoopla/M
hooray
hoosegow/SM
hoot/MDRSZG
hootenanny/SM
hooter/M
hoover/DSG
hooves
hop/SGMD
hope/MS
hopeful/PSMY
hopefulness/M
hopeless/YP
hopelessness/M
hopped
hopper/MS
hopping
hopscotch/MDSG
hora/MS
horde/DSMG
horehound/SM
horizon/SM
horizontal/SMY
hormonal
hormone/SM
horn/MDS
hornblende/M
hornet/MS
hornless
hornlike
hornpipe/MS
horny/TR
horologic
horological
horologist/MS
horology/M
horoscope/SM
horrendous/Y
horrible/P
horribleness/M
horribly
horrid/Y
horrific
horrifically
horrify/DSG
horrifying/Y
horror/MS
horse's
horse/UDSG
horseback/M
horsebox/S
horseflesh/M
horsefly/SM
horsehair/M
horsehide/M
horselaugh/M
horselaughs
horseless
horseman/M
horsemanship/M
horsemen
horseplay/M
horsepower/M
horseradish/MS
horseshit/!
horseshoe/DSM
horseshoeing
horsetail/SM
horsetrading
horsewhip/SM
horsewhipped
horsewhipping
horsewoman/M
horsewomen
horsey
horsier
horsiest
hortatory
horticultural
horticulturalist/S
horticulture/M
horticulturist/MS
hosanna/SM
hose/MGDS
hosepipe/S
hosier/MS
hosiery/M
hosp
hospholipase
hospice/MS
hospitable/I
hospitably/I
hospital/SM
hospitality/M
hospitalization/SM
hospitalize/DSG
host/MDSG
hostage/MS
hostel/ZGMDRS
hosteler/M
hostelry/SM
hostess/MDSG
hostile/MYS
hostilities/M
hostility/SM
hostler/MS
hot/SYP
hotbed/MS
hotblooded
hotbox/MS
hotcake/SM
hotel/SM
hotelier/MS
hotfoot/MDGS
hothead/DSM
hotheaded/YP
hotheadedness/M
hothouse/SM
hotkey/S
hotlink/S
hotness/M
hotplate/SM
hotpot/S
hots/M
hotshot/MS
hotted
hotter
hottest
hottie/S
hotting
hound/SGMD
hour/MYS
hourglass/MS
houri/SM
house's
house/ADSG
houseboat/SM
housebound
houseboy/SM
housebreak/RSZG
housebreaker/M
housebreaking/M
housebroke
housebroken
houseclean/DSG
housecleaning/M
housecoat/SM
housefly/SM
houseful/SM
household/SMRZ
householder/M
househusband/SM
housekeeper/MS
housekeeping/M
houselights/M
housemaid/SM
houseman/M
housemaster/S
housemate/S
housemen
housemistress/S
housemother/SM
houseparent/SM
houseplant/MS
houseproud
houseroom
housetop/SM
housewares/M
housewarming/SM
housewife/MY
housewives
housework/M
housing/MS
hove
hovel/SM
hover/SGD
hovercraft/M
how'd
how're
how/SM
howbeit
howdah/M
howdahs
howdy
however
howitzer/SM
howl/MDRSZG
howler/M
howsoever
hoyden/MS
hoydenish
hp
hr/S
ht
huarache/SM
hub/SM
hubbub/SM
hubby/SM
hubcap/SM
hubris/M
huckleberry/SM
huckster/SGMD
hucksterism/M
huddle/DSMG
hue/DSM
huff/MDSG
huffily
huffiness/M
huffy/PRT
hug/STMR
huge/YP
hugeness/M
hugged
hugging
huh
hula/MS
hulk/MSG
hull/MDRSZG
hullabaloo/SM
huller/M
hum/SM
human/SMRYTP
humane/PY
humaneness/M
humanism/M
humanist/SM
humanistic
humanitarian/MS
humanitarianism/M
humanities/M
humanity/ISM
humanization/CM
humanize/CDSG
humanizer/SM
humankind/M
humanness/M
humanoid/SM
humble/DRSZTGJP
humbleness/M
humbler/M
humbly
humbug/SM
humbugged
humbugging
humdinger/MS
humdrum/M
humeral
humeri
humerus/M
humid/Y
humidification/M
humidifier/CM
humidify/CZGDRS
humidity/M
humidor/SM
humiliate/DSGNX
humiliating/Y
humiliation/M
humility/M
hummed
hummer/SM
humming
hummingbird/SM
hummock/SM
hummocky
hummus/M
humongous
humor/SMDG
humoresque
humorist/MS
humorless/YP
humorlessness/M
humorous/PY
humorousness/M
hump/MDSG
humpback/MDS
humph/DG
humphs
humus/M
hunch/MDSG
hunchback/SMD
hundred/SMH
hundredfold
hundredth/M
hundredths
hundredweight/SM
hung
hunger/SMDG
hungover
hungrily
hungriness/M
hungry/PRT
hunk/MRSZ
hunker/DG
hunky/RT
hunt/MDRSZG
hunter/M
hunting/M
huntress/MS
huntsman/M
huntsmen
hurdle/DRSMZG
hurdler/M
hurdling/M
hurl/MDRSZG
hurler/M
hurling/M
hurrah/GMD
hurrahs
hurricane/MS
hurried/UY
hurry/DSMG
hurt/MSG
hurtful/YP
hurtfulness/M
hurtle/DSG
husband/GMDS
husbandman/M
husbandmen
husbandry/M
hush/MDSG
husk/MDRSZG
husker/M
huskily
huskiness/M
husky/PRSMT
hussar/SM
hussy/SM
hustings/M
hustle/DRSMZG
hustler/M
hut/SM
hutch/MS
huzzah/MDG
huzzahs
hwy
hyacinth/M
hyacinths
hybrid/SM
hybridism/M
hybridization/M
hybridize/DSG
hydra/SM
hydrangea/SM
hydrant/MS
hydrate's
hydrate/CGNDS
hydration/CM
hydraulic/S
hydraulically
hydraulics/M
hydro/M
hydrocarbon/MS
hydrocephalus/M
hydrodynamic/S
hydrodynamics/M
hydroelectric
hydroelectrically
hydroelectricity/M
hydrofoil/MS
hydrogen/M
hydrogenate/CGDS
hydrogenation/M
hydrogenous
hydrologist/MS
hydrology/M
hydrolyses
hydrolysis/M
hydrolyze/DSG
hydrometer/SM
hydrometry/M
hydrophobia/M
hydrophobic
hydrophone/SM
hydroplane/GDSM
hydroponic/S
hydroponically
hydroponics/M
hydrosphere/M
hydrotherapy/M
hydrous
hydroxide/SM
hyena/SM
hygiene/M
hygienic/U
hygienically
hygienist/MS
hygrometer/SM
hying
hymen/SM
hymeneal
hymn/MDSG
hymnal/MS
hymnbook/SM
hype/MGDRS
hyperactive
hyperactivity/M
hyperbola/SM
hyperbole/M
hyperbolic
hypercritical/Y
hyperglycemia/M
hyperinflation
hyperlink/GSMD
hypermarket/S
hypermedia/M
hyperparathyroidism
hypersensitive/P
hypersensitiveness/M
hypersensitivity/SM
hyperspace/S
hypertension/M
hypertensive/SM
hypertext/M
hyperthyroid/M
hyperthyroidism/M
hypertrophy/DSMG
hyperventilate/GNDS
hyperventilation/M
hyphen/MDSG
hyphenate/XDSMGN
hyphenation/M
hypnoses
hypnosis/M
hypnotherapist/S
hypnotherapy/M
hypnotic/SM
hypnotically
hypnotism/M
hypnotist/MS
hypnotize/GDS
hypo/MS
hypoallergenic
hypochondria/M
hypochondriac/SM
hypocrisy/SM
hypocrite/MS
hypocritical/Y
hypodermic/MS
hypoglycemia/M
hypoglycemic/SM
hypotenuse/MS
hypothalami
hypothalamus/M
hypothermia/M
hypotheses
hypothesis/M
hypothesize/DSG
hypothetical/Y
hypothyroid/M
hypothyroidism/M
hyssop/M
hysterectomy/SM
hysteresis
hysteria/M
hysteric/SM
hysterical/Y
hysterics/M
i/US
iPad/M
iPhone/M
iPod/M
iTunes/M
iamb/MS
iambi
iambic/SM
iambus/MS
ibex/MS
ibid
ibidem
ibis/MS
ibuprofen/M
ice's
ice/CDSG
iceberg/SM
iceboat/SM
icebound
icebox/MS
icebreaker/SM
icecap/SM
iceman/M
icemen
ichthyologist/MS
ichthyology/M
icicle/SM
icily
iciness/M
icing/SM
icky/RT
icon/MS
iconic
iconoclasm/M
iconoclast/SM
iconoclastic
iconography/M
ictus/M
icy/TPR
id/SMY
idea/MS
ideal/SMY
idealism/M
idealist/SM
idealistic
idealistically
idealization/MS
idealize/DSG
idem
idempotent
identical/Y
identifiable/U
identification/M
identified/U
identify/ZGNDRSX
identikit/S
identity/SM
ideogram/SM
ideograph/M
ideographs
ideological/Y
ideologist/SM
ideologue/MS
ideology/SM
ides/M
idiocy/SM
idiom/SM
idiomatic/U
idiomatically
idiopathic
idiosyncrasy/SM
idiosyncratic
idiosyncratically
idiot/SM
idiotic
idiotically
idle/MZTGDRSP
idleness/M
idler/M
idol/MS
idolater/SM
idolatress/MS
idolatrous
idolatry/M
idolization/M
idolize/GDS
idyll/SM
idyllic
idyllically
if/SM
iffiness/M
iffy/RTP
igloo/SM
igneous
ignitable
ignite/AGDS
ignition/MS
ignoble
ignobly
ignominious/Y
ignominy/SM
ignoramus/MS
ignorance/M
ignorant/Y
ignore/GDS
iguana/MS
ii
iii
ilea
ileitis/M
ileum/M
ilia
ilium/M
ilk/SM
ill/SMP
illegal/MYS
illegality/SM
illegibility/M
illegible
illegibly
illegitimacy/M
illegitimate/Y
illiberal/Y
illiberality/M
illicit/YP
illicitness/M
illimitable
illiteracy/M
illiterate/MYS
illness/MS
illogical/Y
illogicality/M
illuminate/GNXDS
illuminating/Y
illumination/M
illumine/DSBG
illus/V
illusion/EMS
illusionist/SM
illusory
illustrate/GNVXDS
illustration/M
illustrative/Y
illustrator/SM
illustrious/PY
illustriousness/M
image/DSMG
imagery/M
imaginable/U
imaginably/U
imaginal
imaginary
imagination/MS
imaginative/UY
imagine/DSBJG
imago/M
imagoes
imam/MS
imbalance/DSM
imbecile/MS
imbecilic
imbecility/SM
imbibe/ZGDRS
imbiber/M
imbrication/M
imbroglio/SM
imbue/DSG
imitable/I
imitate/DSGNVX
imitation/M
imitative/PY
imitativeness/M
imitator/SM
immaculate/PY
immaculateness/M
immanence/M
immanency/M
immanent/Y
immaterial/YP
immateriality/M
immaterialness/M
immature/Y
immaturity/M
immeasurable
immeasurably
immediacies/M
immediacy/SM
immediate/PY
immediateness/M
immemorial/Y
immense/Y
immensity/SM
immerse/XDSGNV
immersible
immersion/M
immigrant/SM
immigrate/DSGN
immigration/M
imminence/M
imminent/Y
immobile
immobility/M
immobilization/M
immobilize/ZGDRS
immoderate/Y
immodest/Y
immodesty/M
immolate/DSGN
immolation/M
immoral/Y
immorality/SM
immortal/MYS
immortality/M
immortalize/DSG
immovability/M
immovable
immovably
immune
immunity/M
immunization/SM
immunize/GDS
immunodeficiency/M
immunodeficient
immunoglobulin/S
immunologic
immunological
immunologist/MS
immunology/M
immure/DSG
immutability/M
immutable
immutably
imp/SMR
impact/SMDG
impair/SDGL
impaired/U
impairment/MS
impala/SM
impale/DSGL
impalement/M
impalpable
impalpably
impanel/SDG
impart/SDG
impartial/Y
impartiality/M
impassably
impasse/BSMV
impassibility/M
impassible
impassibly
impassioned
impassive/YP
impassiveness/M
impassivity/M
impasto/M
impatience/MS
impatiens/M
impatient/Y
impeach/ZGBLDRS
impeachable/U
impeacher/M
impeachment/SM
impeccability/M
impeccable
impeccably
impecunious/PY
impecuniousness/M
impedance/M
impede/DSG
impeded/U
impediment/SM
impedimenta/M
impel/S
impelled
impeller/MS
impelling
impend/SDG
impenetrability/M
impenetrable
impenetrably
impenitence/M
impenitent/Y
imperative/SMY
imperceptibility/M
imperceptible
imperceptibly
imperceptive
imperf
imperfect/SMYP
imperfection/MS
imperfectness/M
imperial/MYS
imperialism/M
imperialist/SM
imperialistic
imperialistically
imperil/GSLD
imperilment/M
imperious/PY
imperiousness/M
imperishable
imperishably
impermanence/M
impermanent/Y
impermeability/M
impermeable
impermeably
impermissible
impersonal/Y
impersonate/GNXDS
impersonation/M
impersonator/SM
impertinence/MS
impertinent/Y
imperturbability/M
imperturbable
imperturbably
impervious/Y
impetigo/M
impetuosity/M
impetuous/YP
impetuousness/M
impetus/MS
impiety/SM
impinge/LDSG
impingement/M
impious/PY
impiousness/M
impish/YP
impishness/M
implacability/M
implacable
implacably
implant/BSGMD
implantation/M
implausibility/SM
implausible
implausibly
implement/GBMDRS
implementable/U
implementation/SM
implemented/U
implicate/DSG
implication/M
implicit/PY
implicitness/M
implode/DSG
implore/DSG
imploring/Y
implosion/MS
implosive
imply/XDSGN
impolite/YP
impoliteness/MS
impolitic
imponderable/MS
import/ZGBSMDR
importance/M
important/Y
importation/MS
importer/M
importunate/Y
importune/GDS
importunity/M
impose/ADSG
imposer/MS
imposing/U
imposingly
imposition/MS
impossibility/SM
impossible/S
impossibly
impost/SM
impostor/SM
imposture/MS
impotence/M
impotency/M
impotent/Y
impound/DGS
impoverish/DSLG
impoverishment/M
impracticability
impracticable
impracticably
impractical/Y
impracticality/M
imprecate/DSXGN
imprecation/M
imprecise/PYN
impreciseness/M
imprecision/M
impregnability/M
impregnable
impregnably
impregnate/GNDS
impregnation/M
impresario/SM
impress/MDSGV
impressed/U
impressibility/M
impressible
impression/BSM
impressionability/M
impressionism/M
impressionist/SM
impressionistic
impressive/PY
impressiveness/M
imprimatur/SM
imprint/MDRZGS
imprinter/M
imprison/SDLG
imprisonment/SM
improbability/SM
improbable
improbably
impromptu/SM
improper/Y
impropriety/SM
improve/GBDSL
improved/U
improvement/MS
improvidence/M
improvident/Y
improvisation/SM
improvisational
improvise/ZGDRS
improviser/M
imprudence/M
imprudent/Y
impudence/M
impudent/Y
impugn/ZGSDR
impugner/M
impulse/MGNVDS
impulsion/M
impulsive/PY
impulsiveness/M
impunity/M
impure/RYT
impurity/SM
imputation/SM
impute/BDSG
in/ASM
inaccuracy/S
inaction/M
inadequacy/S
inadvertence/M
inadvertent/Y
inalienability/M
inalienably
inamorata/SM
inane/RYT
inanimate/PY
inanimateness/M
inanity/SM
inappropriate/Y
inarticulate/Y
inasmuch
inaudible
inaugural/SM
inaugurate/XGNDS
inauguration/M
inboard/MS
inbound
inbox/MS
inbreed/S
inc/TGD
incalculably
incandescence/M
incandescent/Y
incantation/SM
incapacitate/GDS
incarcerate/XDSGN
incarceration/M
incarnadine/DSG
incarnate/AXGNDS
incarnation/AM
incendiary/SM
incense/MGDS
incentive's
incentive/ES
inception/SM
incessant/Y
incest/M
incestuous/PY
incestuousness/M
inch/MDSG
inchoate
inchworm/SM
incidence/SM
incident/SM
incidental/MYS
incinerate/DSGN
incineration/M
incinerator/MS
incipience/M
incipient/Y
incise/XGNVDS
incision/M
incisive/PY
incisiveness/M
incisor/MS
incitement/MS
inciter/MS
incl
inclement
inclination/EM
inclinations
incline's
incline/EGDS
include/GDS
inclusion/MS
inclusive/YP
inclusiveness/M
incognito/MS
incombustible
incommode/GD
incommodious
incommunicado
incompatibility/S
incompetent/MS
incomplete/Y
inconceivability/M
incongruous/PY
incongruousness/M
inconsolably
inconstant/Y
incontestability/M
incontestably
incontinent
incontrovertibly
inconvenience/GD
incorporate/ADSGN
incorporated/U
incorporation/AM
incorporeal
incorrect/Y
incorrigibility/M
incorrigible
incorrigibly
incorruptibly
increasing/Y
increment/SMD
incremental/Y
incrementalism
incrementalist/SM
incriminate/GNDS
incrimination/M
incriminatory
incrustation/SM
incubate/GNDS
incubation/M
incubator/SM
incubus/MS
inculcate/DSGN
inculcation/M
inculpate/DSG
incumbency/SM
incumbent/SM
incunabula
incunabulum/M
incur/SB
incurable/MS
incurably
incurious
incurred
incurring
incursion/MS
ind
indebted/P
indebtedness/M
indeed
indefatigable
indefatigably
indefeasible
indefeasibly
indefinably
indelible
indelibly
indemnification/M
indemnify/GDSXN
indemnity/SM
indentation/MS
indention/M
indenture/DG
indescribably
indestructibly
indeterminably
indeterminacy/M
indeterminate/Y
index/ZGMDRS
indexation/SM
indexer/M
indicate/XDSGNV
indication/M
indicative/SMY
indicator/MS
indict/GDSBL
indictment/SM
indie/S
indigence/M
indigenous
indigent/SMY
indignant/Y
indignation/M
indigo/M
indirect/Y
indiscipline
indiscreet/Y
indiscretion/S
indiscriminate/Y
indispensability/M
indispensable/MS
indispensably
indissolubility
indissolubly
indistinguishably
indite/GDS
indium/M
individual/MYS
individualism/M
individualist/MS
individualistic
individualistically
individuality/M
individualization/M
individualize/GDS
individuate/DSGN
individuation/M
indivisibly
indoctrinate/GNDS
indoctrination/M
indolence/M
indolent/Y
indomitable
indomitably
indubitable
indubitably
induce/DRSZGL
inducement/SM
inducer/M
induct/DGV
inductance/M
inductee/SM
induction/MS
inductive/Y
indulge/DSG
indulgence/SM
indulgent/Y
industrial/Y
industrialism/M
industrialist/SM
industrialization/M
industrialize/DSG
industrious/YP
industriousness/M
industry/SM
indwell/SG
inebriate/MGNDS
inebriation/M
inedible
ineffability/M
ineffable
ineffably
inelastic
ineligible/MS
ineligibly
ineluctable
ineluctably
inept/YP
ineptitude/M
ineptness/M
inequality/S
inert/YP
inertia/M
inertial
inertness/M
inescapable
inescapably
inestimably
inevitability/M
inevitable/M
inevitably
inexact/Y
inexhaustibly
inexorability
inexorable
inexorably
inexpedient
inexpert/Y
inexpiable
inexplicably
inexpressibly
inexpressive
inextricably
inf/ZT
infallible
infamy/SM
infancy/M
infant/MS
infanticide/MS
infantile
infantry/SM
infantryman/M
infantrymen
infarct/MS
infarction/M
infatuate/DSXGN
infatuation/M
infect/AESDG
infected/U
infection/ASM
infectious/PY
infectiousness/M
infelicitous
inference/SM
inferential
inferior/MS
inferiority/M
infernal/Y
inferno/MS
inferred
inferring
infest/GDS
infestation/MS
infidel/MS
infidelity/S
infiltrator/SM
infinite/MV
infinitesimal/SMY
infinitival
infinitive/MS
infinitude/M
infinity/SM
infirm
infirmary/SM
infirmity/SM
infix
inflame/DSG
inflammable
inflammation/SM
inflammatory
inflatable/SM
inflate/DSGNB
inflation/EM
inflationary
inflect/SDG
inflection/MS
inflectional
inflict/SDGV
infliction/M
inflow/SM
influence/MGDS
influenced/U
influential/Y
influenza/M
info/M
infomercial/SM
inform/Z
informal/Y
informant/SM
information/EM
informational
informative/PY
informativeness/M
informed/U
infotainment/M
infra
infrared/M
infrasonic
infrastructural
infrastructure/SM
infrequence/M
infrequent/Y
infringement/MS
infuriate/GDS
infuriating/Y
infuser/SM
ingenious/PY
ingeniousness/M
ingenue/SM
ingenuity/M
ingenuous/EY
ingenuousness/M
ingest/SDG
ingestion/M
inglenook/SM
ingot/SM
ingrain/G
ingrate/SM
ingratiate/GNDS
ingratiating/Y
ingratiation/M
ingredient/MS
ingress/MS
inguinal
inhabit/DG
inhabitable/U
inhabitant/SM
inhabited/U
inhalant/SM
inhalation/MS
inhalator/MS
inhaler/SM
inharmonious
inhere/DSG
inherent/Y
inherit/EGSD
inheritance/EM
inheritances
inheritor/SM
inhibit/GSD
inhibition/SM
inhibitor/SM
inhibitory
inhuman/Y
inhumane/Y
inimical/Y
inimitably
iniquitous/Y
iniquity/SM
initial/SGMDY
initialism
initialization
initialize/DSG
initialized/AU
initiate/XMGNVDS
initiated/U
initiation/M
initiative/SM
initiator/MS
initiatory
inject/SDG
injection/SM
injector/SM
injure/DRSZG
injured/U
injurer/M
injurious
ink/MD
inkblot/SM
inkiness/M
inkling/SM
inkstand/SM
inkwell/MS
inky/RTP
inland/M
inline
inmate/SM
inmost
inn/SGMRJ
innards/M
innate/PY
innateness/M
innermost
innersole/SM
innerspring
innervate/GNDS
innervation/M
inning/M
innit
innkeeper/MS
innocence/M
innocent/MYS
innocuous/PY
innocuousness/M
innovate/XDSGNV
innovation/M
innovator/MS
innovatory
innuendo/SM
innumerably
innumerate
inoculate/AGDS
inoculation/MS
inoperative
inordinate/Y
inorganic
inquire/ZGDR
inquirer/M
inquiring/Y
inquiry/SM
inquisition/MS
inquisitional
inquisitive/YP
inquisitiveness/M
inquisitor/SM
inquisitorial
inrush/MS
insane/T
insatiability/M
insatiably
inscribe/ZGDR
inscriber/M
inscription/MS
inscrutability/M
inscrutable/P
inscrutableness/M
inscrutably
inseam/SM
insecticidal
insecticide/MS
insectivore/MS
insectivorous
insecure/Y
inseminate/DSGN
insemination/M
insensate
insensible
insensitive/Y
inseparable/MS
insert's
insert/AGSD
insertion/AM
insertions
insetting
inshore
inside/RSMZ
insider/M
insidious/YP
insidiousness/M
insight/MS
insightful
insignia/M
insinuate/GNVDSX
insinuation/M
insinuator/SM
insipid/PY
insipidity/M
insist/SGD
insistence/M
insistent/Y
insisting/Y
insofar
insole/SM
insolence/M
insolent/Y
insoluble
insolubly
insolvency/S
insomnia/M
insomniac/SM
insomuch
insouciance/M
insouciant
inspect/AGDS
inspection/SM
inspector/MS
inspectorate/MS
inspiration/MS
inspirational
inspired/U
inspiring/U
inst
instability/S
installation/MS
installer/UMS
installment/SM
instance/GD
instant/MRYS
instantaneous/Y
instantiate/DSG
instar
instate/AGDS
instead
instigate/DSGN
instigation/M
instigator/MS
instillation/M
instinct/VMS
instinctive/Y
instinctual
institute/XMZGNDRS
instituter/M
institution/M
institutional/Y
institutionalization/M
institutionalize/DSG
instr
instruct/SDGV
instructed/U
instruction/MS
instructional
instructive/Y
instructor/MS
instrument/MDSG
instrumental/MYS
instrumentalist/SM
instrumentality/M
instrumentation/M
insubordinate
insufferable
insufferably
insular
insularity/M
insulate/GNDS
insulation/M
insulator/MS
insulin/M
insult/SMDG
insulting/Y
insuperable
insuperably
insurance/SM
insure/DRSZGB
insured/SM
insurer/M
insurgence/SM
insurgency/SM
insurgent/MS
insurmountably
insurrection/SM
insurrectionist/SM
int
intact
intaglio/MS
integer/MS
integral/SMY
integrate/AEVNGSD
integration/EAM
integrator
integrity/M
integument/SM
intellect/MS
intellectual/MYS
intellectualism/M
intellectualize/GDS
intelligence/M
intelligent/Y
intelligentsia/M
intelligibility/M
intelligible/U
intelligibly/U
intended/SM
intense/YTVR
intensification/M
intensifier/M
intensify/DRSZGN
intensity/S
intensive/MYPS
intensiveness/M
intent/SMYP
intention/MS
intentional/UY
intentness/M
inter/ESL
interact/SGVD
interaction/SM
interactive/Y
interactivity
interbred
interbreed/GS
intercede/GDS
intercept/GMDS
interception/MS
interceptor/SM
intercession/SM
intercessor/MS
intercessory
interchange/DSMG
interchangeability
interchangeable
interchangeably
intercity
intercollegiate
intercom/SM
intercommunicate/DSGN
intercommunication/M
interconnect/GDS
interconnection/SM
intercontinental
intercourse/M
intercultural
interdenominational
interdepartmental
interdependence/M
interdependent/Y
interdict/GMDS
interdiction/M
interdisciplinary
interest/ESMD
interested/U
interesting/Y
interface/MGDS
interfaith
interfere/GDS
interference/M
interferon/M
interfile/GDS
intergalactic
intergovernmental
interim/M
interior/SM
interj
interject/GDS
interjection/SM
interlace/GDS
interlard/DGS
interleave/DSG
interleukin/M
interline/GDSJ
interlinear
interlining/M
interlink/DSG
interlock/GMDS
interlocutor/SM
interlocutory
interlope/ZGDRS
interloper/M
interlude/MGDS
intermarriage/SM
intermarry/GDS
intermediary/SM
intermediate/MYS
interment/EM
interments
intermezzi
intermezzo/MS
interminably
intermingle/DSG
intermission/SM
intermittent/Y
intermix/GDS
intern/GDL
internal/SY
internalization/M
internalize/GDS
international/SMY
internationalism/M
internationalist/SM
internationalization
internationalize/DSG
internecine
internee/SM
internet
internist/MS
internment/M
internship/MS
interoffice
interpenetrate/DSGN
interpersonal
interplanetary
interplay/M
interpolate/XDSGN
interpolation/M
interpose/GDS
interposition/M
interpret/AGVDS
interpretation/AMS
interpretative
interpreted/U
interpreter/MS
interracial
interred/E
interregnum/SM
interrelate/XDSGN
interrelation/M
interrelationship/MS
interring/E
interrogate/DSGNVX
interrogation/M
interrogative/MYS
interrogator/SM
interrogatory/SM
interrupt/ZGMDRS
interrupter/M
interruption/MS
interscholastic
intersect/GDS
intersection/SM
intersession/SM
intersex
intersperse/GNDS
interspersion/M
interstate/MS
interstellar
interstice/MS
interstitial
intertwine/GDS
interurban
interval/SM
intervene/GDS
intervention/SM
interventionism/M
interventionist/SM
interview/ZGMDRS
interviewee/MS
interviewer/M
intervocalic
interwar
interweave/GS
interwove
interwoven
intestacy/M
intestate
intestinal
intestine/MS
intimacy/SM
intimate/MYGNDSX
intimation/M
intimidate/GNDS
intimidating/Y
intimidation/M
intonation/SM
intoxicant/SM
intoxicate/DSGN
intoxication/M
intracranial
intramural
intramuscular
intranet/MS
intransigence/M
intransigent/MYS
intrastate
intrauterine
intravenous/MSY
intrepid/Y
intrepidity/M
intricacy/SM
intricate/Y
intrigue/DRSMZG
intriguer/M
intriguing/Y
intrinsic
intrinsically
intro/SM
introduce/AGDS
introduction/AM
introductions
introductory
introit/SM
introspect/GVDS
introspection/M
introspective/Y
introversion/M
introvert/MDS
intrude/DRSZG
intruder/M
intrusion/SM
intrusive/YP
intrusiveness/M
intuit/SDGV
intuition/S
intuitive/PY
intuitiveness/M
inundate/XDSGN
inundation/M
inure/DSG
invade/DRSZG
invader/M
invalid/GMDYS
invalidism/M
invaluable
invaluably
invariant
invasion/MS
invasive
invective/M
inveigh/GD
inveighs
inveigle/ZGDRS
inveigler/M
invent/ASGVD
invention/AMS
inventive/PY
inventiveness/M
inventor/MS
inventory/DSMG
inverse/SMY
invert/SMDG
invest/ASDGL
investigate/GNVDSX
investigation/M
investigator/SM
investigatory
investiture/MS
investment/AEM
investor/SM
inveteracy/M
inveterate
invidious/YP
invidiousness/M
invigilate/GNDS
invigilator/S
invigorate/ADSG
invigorating/Y
invigoration/M
invincibility/M
invincibly
inviolability/M
inviolably
inviolate
invitation/SM
invitational/SM
invite/DSMG
invited/U
invitee/SM
inviting/Y
invoke/DSG
involuntariness/M
involuntary/P
involution/M
involve/LDSG
involvement/SM
inward/SY
ioctl
iodide/SM
iodine/M
iodize/DSG
ion/USM
ionic
ionization/UM
ionize/UDSG
ionizer/MS
ionosphere/MS
ionospheric
iota/MS
ipecac/SM
irascibility/M
irascible
irascibly
irate/YP
irateness/M
ire/M
ireful
irenic
irides
iridescence/M
iridescent/Y
iridium/M
iris/MS
irk/SGD
irksome/YP
irksomeness/M
iron/MDSG
ironclad/MS
ironic
ironical/Y
ironing/M
ironmonger/S
ironmongery
ironstone/M
ironware/M
ironwood/MS
ironwork/M
irony/SM
irradiate/DSGN
irradiation/M
irrational/SMY
irrationality/M
irreclaimable
irreconcilability/M
irreconcilable
irreconcilably
irrecoverable
irrecoverably
irredeemable
irredeemably
irreducible
irreducibly
irrefutable
irrefutably
irregardless
irregular/MYS
irregularity/SM
irrelevance/MS
irrelevancy/MS
irrelevant/Y
irreligion
irreligious
irremediable
irremediably
irremovable
irreparable
irreparably
irreplaceable
irrepressible
irrepressibly
irreproachable
irreproachably
irresistible
irresistibly
irresolute/PYN
irresoluteness/M
irresolution/M
irrespective
irresponsibility/M
irresponsible
irresponsibly
irretrievable
irretrievably
irreverence/M
irreverent/Y
irreversible
irreversibly
irrevocable
irrevocably
irrigable
irrigate/DSGN
irrigation/M
irritability/M
irritable
irritably
irritant/SM
irritate/DSXGN
irritating/Y
irritation/M
irrupt/DGVS
irruption/SM
ischemia
ischemic
isinglass/M
isl
island/SZMR
islander/M
isle/MS
islet/SM
ism/CM
isms
isn't
isobar/MS
isobaric
isolate/DSMGN
isolation/M
isolationism/M
isolationist/SM
isomer/MS
isomeric
isomerism/M
isometric/S
isometrically
isometrics/M
isomorphic
isosceles
isotherm/SM
isotope/SM
isotopic
isotropic
issuance/M
issue/ADSMG
issuer/MS
isthmian
isthmus/MS
it'd
it'll
it/USM
ital
italic/SM
italicization/M
italicize/GDS
italics/M
itch/MDSG
itchiness/M
itchy/RPT
item/MS
itemization/M
itemize/GDS
iterate/AXGNVDS
iteration/AM
iterator/S
itinerant/SM
itinerary/SM
itself
iv/U
ivory/SM
ivy/DSM
ix
j/F
jab/SM
jabbed
jabber/SMDRZG
jabberer/M
jabbing
jabot/SM
jacaranda/MS
jack/MDGS
jackal/SM
jackass/MS
jackboot/SMD
jackdaw/MS
jacket/SMD
jackhammer/MS
jackknife/MGDS
jackknives
jackpot/MS
jackrabbit/MS
jackstraw/MS
jacquard/M
jade/MGDS
jaded/PY
jadedness/M
jadeite/M
jag/SM
jagged/TPRY
jaggedness/M
jaggies
jaguar/SM
jail/MDRZGS
jailbird/SM
jailbreak/SM
jailer/M
jailhouse/S
jalapeno/MS
jalopy/SM
jalousie/MS
jam/SM
jamb/MS
jambalaya/M
jamboree/MS
jammed
jamming
jammy/RT
jangle/DRSMZG
jangler/M
janitor/SM
janitorial
japan/SM
japanned
japanning
jape/MGDS
jar/SM
jardiniere/SM
jarful/MS
jargon/M
jarred
jarring/Y
jasmine/SM
jasper/M
jato/MS
jaundice/DSMG
jaunt/SGMD
jauntily
jauntiness/M
jaunty/RPT
java/M
javelin/SM
jaw/SGMD
jawbone/DSMG
jawbreaker/MS
jawline/S
jay/SM
jaybird/SM
jaywalk/DRSZG
jaywalker/M
jaywalking/M
jazz/MDSG
jazzy/TR
jct
jealous/Y
jealousy/SM
jean/MS
jeans/M
jeep/MS
jeer/MDSG
jeering/MY
jeez
jejuna
jejune
jejunum/M
jell/DSG
jello/S
jelly/GDSM
jellybean/MS
jellyfish/MS
jellylike
jellyroll/SM
jemmy/GDS
jennet/MS
jenny/SM
jeopardize/GDS
jeopardy/M
jeremiad/MS
jerk/MDSG
jerkily
jerkin/MS
jerkiness/M
jerkwater
jerky/TRMP
jeroboam/S
jerrybuilt
jerrycan/S
jersey/MS
jest/MDRSZG
jester/M
jesting/Y
jet/SM
jetliner/SM
jetport/MS
jetsam/M
jetted
jetting
jettison/MDSG
jetty/SM
jew
jewel/SZGMDR
jeweler/M
jewelry/SM
jg
jib/SGMD
jibbed
jibbing
jibe/MS
jiff/MS
jiffy/SM
jig's
jig/AS
jigged/A
jigger's
jigger/ASDG
jigging/A
jiggle/DSMG
jiggly
jigsaw/SMDG
jihad/SM
jihadist/SM
jilt/MDSG
jimmy/DSMG
jimsonweed/M
jingle/DSMG
jingly
jingoism/M
jingoist/SM
jingoistic
jink/DSG
jinn
jinni/M
jinrikisha/SM
jinx/MDSG
jitney/SM
jitterbug/MS
jitterbugged
jitterbugger/M
jitterbugging
jitters/M
jittery/RT
jive/MGDS
job/SM
jobbed
jobber/SM
jobbing
jobholder/MS
jobless/P
joblessness/M
jobshare/S
jobsworth
jobsworths
jock/MS
jockey/SGMD
jockstrap/MS
jocose/PY
jocoseness/M
jocosity/M
jocular/Y
jocularity/M
jocund/Y
jocundity/M
jodhpurs/M
joey/S
jog/SM
jogged
jogger/SM
jogging/M
joggle/DSMG
john/MS
johnny/SM
johnnycake/MS
join's
join/AFDSG
joiner/FMS
joinery/M
joint's
joint/EGSD
jointly/F
joist/SM
jojoba
joke/MZGDRS
joker/M
jokey
jokier
jokiest
joking/Y
jollification/SM
jollily
jolliness/M
jollity/M
jolly/TGPDRSM
jolt/MDRSZG
jolter/M
jonquil/SM
josh/MDRSZG
josher/M
jostle/MGDS
jot/SM
jotted
jotter/MS
jotting/MS
joule/SM
jounce/MGDS
jouncy
journal/MS
journalese/M
journalism/M
journalist/SM
journalistic
journey/ZGMDRS
journeyer/M
journeyman/M
journeymen
journo/S
joust/SZGMDR
jouster/M
jousting/M
jovial/Y
joviality/M
jowl/MS
jowly/TR
joy/SGMD
joyful/YP
joyfuller
joyfullest
joyfulness/M
joyless/PY
joylessness/M
joyous/YP
joyousness/M
joyridden
joyride/RSMZG
joyrider/M
joyriding/M
joyrode
joystick/SM
jr
jubilant/Y
jubilation/M
jubilee/SM
judder/GDS
judge's
judge/ADSG
judgeship/M
judgment/SM
judgmental/Y
judicatory/SM
judicature/M
judicial/Y
judiciary/SM
judicious/IYP
judiciousness/IM
judo/M
jug/SM
jugful/MS
jugged
juggernaut/SM
jugging
juggle/MZGDRS
juggler/M
jugglery/M
jugular/SM
juice/DRSMZG
juicer/M
juicily
juiciness/M
juicy/PTR
jujitsu/M
jujube/MS
jukebox/MS
julep/SM
julienne
jumble/MGDS
jumbo/SM
jump/MDRSZG
jumper/M
jumpily
jumpiness/M
jumpsuit/MS
jumpy/TRP
jun
junco/SM
junction/FISM
juncture/FMS
jungle/MS
junior/MS
juniper/SM
junk/MDRSZG
junker/M
junket/MDSG
junketeer/MS
junkie/MTRS
junkyard/MS
junta/SM
juridic
juridical/Y
jurisdiction/SM
jurisdictional
jurisprudence/M
jurist/MS
juristic
juror/SM
jury/ISM
juryman/M
jurymen
jurywoman/M
jurywomen
just/RYPT
justice/IMS
justifiable/U
justifiably/U
justification/M
justified/U
justify/XGDSN
justness/M
jut/SM
jute/M
jutted
jutting
juvenile/SM
juxtapose/DSG
juxtaposition/SM
k/IFGS
kHz
kW
kWh
kabbalah
kaboom
kabuki/M
kaddish/MS
kaffeeklatch/MS
kaffeeklatsch/MS
kahuna/S
kaiser/MS
kale/M
kaleidoscope/MS
kaleidoscopic
kaleidoscopically
kamikaze/MS
kana
kangaroo/MS
kanji
kaolin/M
kapok/M
kappa/SM
kaput
karakul/M
karaoke/MS
karat/SM
karate/M
karma/M
karmic
kart/MS
katakana
katydid/SM
kayak/SMDG
kayaking/M
kayo/MDSG
kazoo/SM
kc
kebab/SM
kedgeree
keel/MDSG
keelhaul/DGS
keen/MDRYSTGP
keenness/M
keep/MRSZG
keeper/M
keeping/M
keepsake/MS
keg/SM
kelp/M
kelvin/SM
ken/SM
kenned
kennel/SGMD
kenning
keno/M
kepi/MS
kept
keratin/M
keratitis
kerbside
kerchief/SM
kerfuffle/S
kernel/SM
kerosene/M
kestrel/MS
ketch/MS
ketchup/M
kettle/SM
kettledrum/SM
key/SGMD
keybinding/S
keyboard/ZGSMDR
keyboarder/M
keyboardist/SM
keyhole/MS
keynote/MZGDRS
keynoter/M
keypad/SM
keypunch/ZGMDRS
keypuncher/M
keystone/MS
keystroke/SM
keyword/MS
kg
khaki/SM
khan/MS
kibble/DSMG
kibbutz/MS
kibbutzim
kibitz/ZGDRS
kibitzer/M
kibosh/M
kick/MDRSZG
kickback/SM
kickball/M
kickboxing
kicker/M
kickoff/MS
kickstand/MS
kicky/RT
kid/SM
kidded
kidder/SM
kiddie/SM
kidding
kiddish
kiddo/SM
kidnap/S
kidnapped
kidnapper/MS
kidnapping/MS
kidney/SM
kidskin/M
kielbasa/MS
kielbasi
kike/S
kill/JMDRSZG
killdeer/SM
killer/M
killing/M
killjoy/SM
kiln/MDSG
kilo/MS
kilobyte/SM
kilocycle/SM
kilogram/SM
kilohertz/M
kiloliter/MS
kilometer/MS
kiloton/SM
kilowatt/SM
kilt/MDRS
kilter/M
kimono/MS
kin/M
kinase
kind's
kind/UPRYT
kinda
kindergarten/MS
kindergartner/SM
kindhearted/PY
kindheartedness/M
kindle/AGDS
kindliness/M
kindling/M
kindly/URT
kindness/UM
kindnesses
kindred/M
kinds
kine/S
kinematic/S
kinematics/M
kinetic/S
kinetically
kinetics/M
kinfolk/SM
kinfolks/M
king/MYS
kingdom/SM
kingfisher/SM
kingly/RT
kingmaker/S
kingpin/SM
kingship/M
kink/MDSG
kinkily
kinkiness/M
kinky/TPR
kinsfolk/M
kinship/M
kinsman/M
kinsmen
kinswoman/M
kinswomen
kiosk/SM
kip/SM
kipped
kipper/MDGS
kipping
kirsch/MS
kismet/M
kiss/MDRSBZG
kisser/M
kissoff/SM
kissogram/S
kit/SGMD
kitchen/SM
kitchenette/MS
kitchenware/M
kite/MS
kith/M
kitsch/M
kitschy
kitted
kitten/MS
kittenish
kitting
kitty/SM
kiwi/MS
kiwifruit/MS
kl
klaxon/S
kleptocracy
kleptomania/M
kleptomaniac/SM
kludge/GDS
kluge/DS
klutz/MS
klutziness/M
klutzy/TRP
km
kn
knack/SZMR
knacker/GD
knapsack/MS
knave/SM
knavery/M
knavish/Y
knead/SZGDR
kneader/M
knee/MDS
kneecap/SM
kneecapped
kneecapping
kneeing
kneel/SG
knell/SGMD
knelt
knew
knicker/S
knickerbockers/M
knickers/M
knickknack/MS
knife/DSMG
knight/MDYSG
knighthood/MS
knightliness/M
knish/MS
knit/MS
knitted
knitter/SM
knitting/M
knitwear/M
knives
knob/MS
knobbly
knobby/TR
knock/SZGMDR
knockabout
knockdown/SM
knocker/M
knockoff/SM
knockout/SM
knockwurst/SM
knoll/SM
knot/MS
knothole/SM
knotted
knotting
knotty/TR
know/SB
knowing/UYS
knowledge/M
knowledgeable
knowledgeably
known
knuckle/DSMG
knuckleduster/S
knucklehead/MS
knurl/SGMD
koala/SM
koan/S
kohl
kohlrabi/M
kohlrabies
kola/MS
kook/MS
kookaburra/SM
kookiness/M
kooky/TPR
kopeck/MS
korma
kosher/DSG
kowtow/GMDS
kph
kraal/SM
kraut/SM!
krill/M
krona/M
krone/RM
kronor
kronur
krypton/M
kt
kuchen/SM
kudos/M
kudzu/SM
kumquat/MS
kvetch/ZGMDRS
kvetcher/M
kw
l/SDXTGJ
la/M
lab/SM
label's
label/ASDG
labeled/U
labia
labial/SM
labile
labium/M
labor/SMDRZG
laboratory/SM
laborer/M
laborious/PY
laboriousness/M
laborsaving
laburnum/MS
labyrinth/M
labyrinthine
labyrinths
lac/M
lace's
lace/UGDS
lacerate/DSGNX
laceration/M
lacewing/SM
lacework/M
lachrymal
lachrymose
lack/MDSG
lackadaisical/Y
lackey/SM
lackluster
laconic
laconically
lacquer/GMDS
lacrosse/M
lactate/GNDS
lactation/M
lacteal
lactic
lactose/M
lacuna/M
lacunae
lacy/RT
lad/SGMDNJ
ladder/GSMD
laddie/SM
laddish/P
lade/S
laden/U
lading/M
ladle/DSMG
lady/SM
ladybird/SM
ladybug/MS
ladyfinger/MS
ladylike/U
ladylove/MS
ladyship/MS
laetrile/M
lag/SZMR
lager/M
laggard/MYS
lagged
lagging/M
lagniappe/SM
lagoon/SM
laid/IA
lain
lair/MS
laird/SM
laity/M
lake/MS
lakefront/S
lakeside
lam/SM
lama/MS
lamasery/SM
lamb/MDSG
lambada/MS
lambaste/GDS
lambda/SM
lambency/M
lambent/Y
lambkin/SM
lambskin/SM
lambswool
lame/MYZTGDRSP
lamebrain/MDS
lameness/M
lament/BSMDG
lamentably
lamentation/MS
lamina/M
laminae
laminar
laminate/MGNDS
lamination/M
lammed
lamming
lamp/MS
lampblack/M
lamplight/MRZ
lamplighter/M
lampoon/SGMD
lamppost/SM
lamprey/MS
lampshade/SM
lanai/SM
lance/DRSMZG
lancer/M
lancet/SM
land/MDRSGJ
landau/SM
landfall/MS
landfill/MS
landholder/SM
landholding/MS
landing/M
landlady/SM
landless/M
landline/MS
landlocked
landlord/MS
landlubber/MS
landmark/MS
landmass/MS
landmine/S
landowner/MS
landownership
landowning/SM
landscape/MZGDRS
landscaper/M
landslid
landslide/MGS
landslip/S
landsman/M
landsmen
landward/S
lane/MS
language/MS
languid/PY
languidness/M
languish/DSG
languor/SM
languorous/Y
lank/RYTP
lankiness/M
lankness/M
lanky/RTP
lanolin/M
lantern/MS
lanthanum/M
lanyard/MS
lap/SM
laparoscopic
laparoscopy
laparotomy
lapboard/SM
lapdog/SM
lapel/SM
lapidary/SM
lapin/SM
lapped
lappet/SM
lapping
lapse/AKGMSD
laptop/SM
lapwing/MS
larboard/SM
larcenist/SM
larcenous
larceny/SM
larch/MS
lard/MDRSZG
larder/M
lardy/RT
large/RSPMYT
largehearted
largeness/M
largess/M
largish
largo/SM
lariat/SM
lark/MDSG
larkspur/SM
larva/M
larvae
larval
laryngeal
larynges
laryngitis/M
larynx/M
lasagna/MS
lascivious/YP
lasciviousness/M
lase/ZGDRS
laser/M
lash/MDSGJ
lashing/M
lass/MS
lassie/SM
lassitude/M
lasso/SMDG
last/MDYSG
lasting/Y
lat/S
latch's
latch/UDSG
latchkey/SM
late/YTRP
latecomer/MS
latency/M
lateness/M
latent
lateral/MDYSG
latest/M
latex/M
lath/MDRSZG
lathe/M
lather/GMD
lathery
laths
latices
latish
latitude/MS
latitudinal
latitudinarian/MS
latrine/MS
latte/RSM
latter/MY
lattice/MDS
latticework/SM
laud/MDSGB
laudably
laudanum/M
laudatory
laugh/BMDG
laughably
laughing/MY
laughingstock/SM
laughs
laughter/M
launch/AGMDS
launcher/SM
launchpad/SM
launder/DRZGS
launderer/M
launderette/SM
laundress/MS
laundromat/MS
laundry/SM
laundryman/M
laundrymen
laundrywoman/M
laundrywomen
laureate/MS
laureateship/M
laurel/SM
lav/SGD
lava/M
lavage/M
lavaliere/SM
lavatorial
lavatory/SM
lave/S
lavender/SM
lavish/PTGDRSY
lavishness/M
law/SM
lawbreaker/SM
lawbreaking/M
lawful/UPY
lawfulness/UM
lawgiver/MS
lawless/PY
lawlessness/M
lawmaker/MS
lawmaking/M
lawman/M
lawmen
lawn/MS
lawnmower/SM
lawrencium/M
lawsuit/MS
lawyer/SM
lax/TRYP
laxative/MS
laxity/M
laxness/M
lay/AICSGM
layabout/S
layaway/M
layer/CSM
layered
layering/M
layette/MS
layman/M
laymen
layoff/SM
layout/SM
layover/MS
laypeople
layperson/MS
layup/SM
laywoman/M
laywomen
laze/MGDS
lazily
laziness/M
lazy/DRSTGP
lazybones/M
lb/S
lbw
lea/SM
leach/DSG
lead/MDNRSZG
leader/M
leaderless
leadership/SM
leading/M
leaf/MDSG
leafage/M
leafless
leaflet/GMDS
leafstalk/MS
leafy/RT
league/DSMG
leak/MDSG
leakage/MS
leakiness/M
leaky/PRT
lean/MDRSTGJP
leaning/M
leanness/M
leap/MDRSZG
leaper/M
leapfrog/MS
leapfrogged
leapfrogging
learn/AUGDS
learnedly
learner/MS
learning's
lease/ADSMG
leaseback/SM
leasehold/MRSZ
leaseholder/M
leaser/SM
leash's
leash/UDSG
least/M
leastwise
leather/MS
leatherette/M
leatherneck/MS
leathery
leave/DRSMZGJ
leaven/SGMD
leavened/U
leavening/M
leaver/M
leavings/M
lech/MDRSZG
lecher/M
lecherous/PY
lecherousness/M
lechery/M
lecithin/M
lectern/MS
lecture/MZGDRS
lecturer/M
lectureship/SM
ledge/RSMZ
ledger/M
lee/RSMZ
leech/MDSG
leek/MS
leer/MDG
leeriness/M
leery/RPT
leeward/SM
leeway/M
left/MRST
leftism/M
leftist/SM
leftmost
leftover/SM
leftward/S
lefty/SM
leg/SM
legacy/SM
legal/SMY
legalese/M
legalism/MS
legalistic
legalistically
legality/SM
legalization/M
legalize/GDS
legate/CXMNS
legatee/MS
legation's/AC
legato/SM
legend/SM
legendarily
legendary
legerdemain/M
legged
legginess/M
legging/MS
leggy/RPT
leghorn/MS
legibility/M
legible
legibly
legion/SM
legionary/SM
legionnaire/SM
legislate/DSGNV
legislation/M
legislative/Y
legislator/MS
legislature/SM
legit
legitimacy/M
legitimate/DSYG
legitimatize/GDS
legitimization/M
legitimize/DSG
legless
legman/M
legmen
legroom/SM
legume/MS
leguminous
legwarmer/S
legwork/M
lei/SM
leisure/DMY
leisureliness/M
leisurewear/M
leitmotif/MS
leitmotiv/MS
lemma/S
lemme/JG
lemming/M
lemon/SM
lemonade/SM
lemongrass
lemony
lemur/SM
lend/RSZG
lender/M
length/MNX
lengthen/GD
lengthily
lengthiness/M
lengths
lengthwise
lengthy/PRT
lenience/M
leniency/M
lenient/Y
lenitive
lens/MS
lent
lentil/MS
lento
leonine
leopard/SM
leopardess/MS
leotard/SM
leper/SM
leprechaun/MS
leprosy/M
leprous
lepta
lepton/MS
lesbian/SM
lesbianism/M
lesion/MS
less/MNRX
lessee/MS
lessen/GD
lesson/MS
lessor/MS
let/ISM
letdown/SM
lethal/Y
lethargic
lethargically
lethargy/M
letter/ZGMDRS
letterbomb/S
letterbox/S
lettered/U
letterer/M
letterhead/MS
lettering/M
letterpress/M
letting/S
lettuce/MS
letup/SM
leucine
leucotomy/S
leukemia/M
leukemic/SM
leukocyte/MS
levee/SM
level/PSZGMDRY
leveler/M
levelheaded/P
levelheadedness/M
levelness/M
lever/SGMD
leverage's
leverage/CDSG
leviathan/MS
levier/M
levitate/DSGN
levitation/M
levity/M
levy/DRSMZG
lewd/RYPT
lewdness/M
lexer/S
lexical
lexicographer/MS
lexicographic
lexicographical
lexicography/M
lexicon/SM
lexis
lg
liabilities
liability/AM
liable/A
liaise/GDS
liaison/MS
liar/MS
lib/M
libation/SM
libber/MS
libel/SZGMDR
libeler/M
libelous
liberal/MYPS
liberalism/M
liberality/M
liberalization/SM
liberalize/GDS
liberalness/M
liberate/CDSGN
liberation/CM
liberator/MS
libertarian/SM
libertine/MS
liberty/SM
libidinal
libidinous
libido/MS
librarian/MS
librarianship
library/SM
librettist/MS
libretto/SM
lice
license/MGDS
licensed/U
licensee/MS
licentiate/SM
licentious/YP
licentiousness/M
lichen/MS
licit/Y
lick/MDJSG
licking/M
licorice/SM
lid/SM
lidded
lidless
lido/MS
lie/DSM
lied/MR
lief/RT
liege/SM
lien/MS
lieu/M
lieutenancy/M
lieutenant/MS
life/MZR
lifebelt/S
lifeblood/M
lifeboat/MS
lifebuoy/MS
lifeforms
lifeguard/SM
lifeless/YP
lifelessness/M
lifelike
lifeline/MS
lifelong
lifer/M
lifesaver/SM
lifesaving/M
lifespan/S
lifestyle/SM
lifetime/MS
lifework/MS
lift/MDRSZG
lifter/M
liftoff/SM
ligament/MS
ligate/GNDS
ligation/M
ligature/MGDS
light's/C
light/CASTGD
lighted/U
lighten/SDRZG
lightener/M
lighter/SM
lightface/MD
lightheaded
lighthearted/YP
lightheartedness/M
lighthouse/MS
lighting's
lightly
lightness/M
lightning/MDS
lightproof
lightship/MS
lightweight/SM
ligneous
lignin
lignite/M
lii
likability/M
likable/P
likableness/M
like/EMGDST
likelihood/UM
likelihoods
likeliness/UM
likely/UPRT
liken/SGD
likeness/UM
likenesses
liker
likewise
liking/M
lilac/SM
lilliputian
lilo/S
lilt/MDSG
lily/SM
limb/MS
limber/UDSG
limberness/M
limbless
limbo/SM
lime/MGDS
limeade/SM
limelight/M
limerick/SM
limescale
limestone/M
limey/S
limit's
limit/CSZGDR
limitation/CM
limitations
limited/U
limiter's
limiting/S
limitless/P
limitlessness/M
limn/DSG
limo/MS
limousine/MS
limp/MDRYSPTG
limpet/MS
limpid/YP
limpidity/M
limpidness/M
limpness/M
limy/RT
linage/M
linchpin/SM
linden/MS
line/MZGDRSJ
lineage/MS
lineal/Y
lineament/SM
linear/Y
linearity/M
linebacker/MS
lined/U
linefeed
lineman/M
linemen
linen/SM
linens/M
liner/M
linesman/M
linesmen
lineup/MS
ling/M
linger/ZGJDRS
lingerer/M
lingerie/M
lingering/Y
lingo/M
lingoes
lingual
linguine/M
linguist/SM
linguistic/S
linguistically
linguistics/M
liniment/SM
lining/M
link/MDRSG
linkage/MS
linkman
linkmen
linkup/MS
linnet/MS
lino
linoleum/M
linseed/M
lint's
lint/CDG
lintel/MS
lints
linty/TR
lion/MS
lioness/MS
lionhearted
lionization/M
lionize/GDS
lip/SM
lipid/SM
liposuction/M
lipped
lippy
lipread/GRS
lipreader/M
lipreading/M
lipstick/MDSG
liq
liquefaction/M
liquefy/DSG
liqueur/SM
liquid/MS
liquidate/XGNDS
liquidation/M
liquidator/MS
liquidity/M
liquidize/ZGDRS
liquidizer/M
liquor/MDGS
lira/M
lire
lisle/M
lisp/MDRSZG
lisper/M
lissome
list/MDNSJXG
listed/U
listen/BMDRZG
listener/M
listeria
listing/M
listless/YP
listlessness/M
lit/ZR
litany/SM
litchi/MS
lite
liter/M
literacy/M
literal/SMYP
literalness/M
literariness/M
literary/P
literate/SMY
literati/M
literature/M
lithe/RPYT
litheness/M
lithesome
lithium/M
lithograph/MDRZG
lithographer/M
lithographic
lithographically
lithographs
lithography/M
lithosphere/SM
litigant/SM
litigate/DSGN
litigation/M
litigator/MS
litigious/P
litigiousness/M
litmus/M
litotes/M
litter/MDRSZG
litterateur/MS
litterbug/MS
litterer/M
little/MTRP
littleness/M
littoral/SM
liturgical/Y
liturgist/SM
liturgy/SM
livability/M
livable/U
live/ATGDSB
livelihood/SM
liveliness/M
livelong/S
lively/PRT
liven/SGD
liver's
liver/S
liveried
liverish
liverwort/MS
liverwurst/M
livery/CSM
liveryman/CM
liverymen/C
livestock/M
liveware
livid/Y
living/MS
lix/K
lizard/MS
ll
llama/SM
llano/SM
lo
load's
load/AUGSD
loadable
loader/MS
loading's
loaf/MDRSZG
loafer/M
loam/M
loamy/TR
loan/MDRSZG
loaner/M
loansharking/M
loanword/MS
loath/JZGDRS
loathe
loather/M
loathing/M
loathsome/PY
loathsomeness/M
loaves
lob/SMD
lobar
lobbed
lobber/MS
lobbing
lobby/GDSM
lobbyist/MS
lobe/MS
lobotomize/DSG
lobotomy/SM
lobster/MS
local/SMY
locale/MS
locality/SM
localization/M
localize/DSG
locate/EAGNDS
location's/A
location/ESM
locator/MS
locavore/SM
loci
lock/MDRSBZG
locker/M
locket/MS
lockjaw/M
lockout/MS
locksmith/M
locksmiths
lockstep/M
lockup/MS
loco/S
locomotion/M
locomotive/MS
locoweed/SM
locum/S
locus/M
locust/SM
locution/MS
lode/MS
lodestar/MS
lodestone/MS
lodge/DRSJMZG
lodger/M
lodging/M
lodgings/M
loft/MDSG
loftily
loftiness/M
lofty/PRT
log/SM
loganberry/SM
logarithm/SM
logarithmic
logbook/SM
loge/MS
logged
logger/SM
loggerhead/SM
loggia/SM
logging/M
logic/M
logical/Y
logicality/M
logician/MS
login/SM
logistic/S
logistical/Y
logistics/M
logjam/SM
logo/MS
logoff/SM
logon/SM
logotype/SM
logout/SM
logrolling/M
logy/RT
loin/MS
loincloth/M
loincloths
loiter/ZGSDR
loiterer/M
loitering/M
lolcat/SM
loll/DSG
lollipop/SM
lollop/GSD
lolly/S
lollygag/S
lollygagged
lollygagging
lone/YZR
loneliness/M
lonely/PTR
loner/M
lonesome/YP
lonesomeness/M
long's
long/KDSTG
longboat/MS
longbow/MS
longer
longevity/M
longhair/MS
longhand/M
longhorn/MS
longhouse/S
longing/MYS
longish
longitude/MS
longitudinal/Y
longshoreman/M
longshoremen
longsighted
longstanding
longtime
longueur/SM
longways
loo
loofah/M
loofahs
look/MDRSZG
lookalike/MS
looker/M
lookout/MS
lookup
loom/MDSG
loon/MS
loonie/M
loony/RSMT
loop/MDSG
loophole/MS
loopy/RT
loos/NRX
loose/UDSTG
loosely
loosen/UGSD
looseness/M
loot/MDRSZG
looter/M
looting/M
lop/S
lope/MGDS
lopped
lopping
lopsided/YP
lopsidedness/M
loquacious/PY
loquaciousness/M
loquacity/M
lord/MDYSG
lordliness/M
lordly/TPR
lordship/SM
lore/M
lorgnette/SM
loris/MS
lorn
lorry/SM
lose/ZGRSJ
loser/M
losing/M
loss/MS
lossless
lost
lot/SM
lotion/SM
lottery/SM
lotto/M
lotus/MS
louche
loud/RYTP
loudhailer/SM
loudmouth/MD
loudmouths
loudness/M
loudspeaker/MS
lough
loughs
lounge/MZGDRS
lounger/M
lour/DSG
louse's
louse/CDSG
lousily
lousiness/M
lousy/TPR
lout/MS
loutish/PY
louver/MDS
lovableness/M
lovably
love/MYZGDRSB
lovebird/SM
lovechild/M
loved/U
loveless
loveliness/M
lovelorn
lovely/RSMTP
lovemaking/M
lover/M
lovesick
lovey/S
loving/Y
low/SZTGMDRYP
lowborn
lowboy/MS
lowbrow/SM
lowdown/M
lower/GD
lowercase/M
lowermost
lowish
lowland/SZMR
lowlander/M
lowlife/SM
lowliness/M
lowly/TPR
lowness/M
lox/M
loyal/ETY
loyaler
loyalism/M
loyalist/SM
loyalties
loyalty/EM
lozenge/SM
ltd
luau/MS
lubber/MYS
lube/MGDS
lubricant/SM
lubricate/DSGN
lubrication/M
lubricator/MS
lubricious/Y
lubricity/M
lucid/PY
lucidity/M
lucidness/M
luck/MDSG
luckily/U
luckiness/UM
luckless
lucky/UPTR
lucrative/YP
lucrativeness/M
lucre/M
lucubrate/GNDS
lucubration/M
ludicrous/YP
ludicrousness/M
ludo
luff/DSG
lug/SM
luge/S
luggage/M
lugged
lugger/MS
lugging
lughole/S
lugsail/SM
lugubrious/YP
lugubriousness/M
lukewarm/YP
lukewarmness/M
lull/MDSG
lullaby/SM
lulu/S
lumbago/M
lumbar
lumber/MDRZGS
lumberer/M
lumbering/M
lumberjack/SM
lumberman/M
lumbermen
lumberyard/SM
luminary/SM
luminescence/M
luminescent
luminosity/M
luminous/Y
lummox/MS
lump/MDNSG
lumpectomy/S
lumpiness/M
lumpish
lumpy/TRP
lunacy/SM
lunar
lunatic/SM
lunch/GMDS
lunchbox/S
luncheon/SM
luncheonette/SM
lunchroom/MS
lunchtime/MS
lung/MDSG
lunge/SM
lungfish/MS
lungful/S
lunkhead/MS
lupine/MS
lupus/M
lurch/GMDS
lure/MGDS
lurgy
lurid/PY
luridness/M
lurk/DRSZG
luscious/PY
lusciousness/M
lush/MRSYPT
lushness/M
lust/MDRSG
luster/M
lusterless
lustful/Y
lustily
lustiness/M
lustrous/Y
lusty/PTR
lutanist/SM
lute/MS
lutenist/SM
lutetium/M
luxuriance/M
luxuriant/Y
luxuriate/DSGN
luxuriation/M
luxurious/PY
luxuriousness/M
luxury/SM
lvi
lvii
lxi
lxii
lxiv
lxix
lxvi
lxvii
lyceum/MS
lychgate/S
lye/MG
lying/M
lymph/M
lymphatic/SM
lymphocyte/SM
lymphoid
lymphoma/SM
lynch/JZGDRS
lyncher/M
lynching/M
lynx/MS
lyre/MS
lyrebird/MS
lyric/SM
lyrical/Y
lyricism/M
lyricist/SM
lysosomal
lysosomes
m/KAS
ma'am
ma/SMH
mac/SGMD
macabre
macadam/M
macadamia/SM
macadamize/GDS
macaque/MS
macaroni/MS
macaroon/MS
macaw/SM
mace/MS
macerate/DSGN
maceration/M
mach/M
machete/SM
machinate/GNDSX
machination/M
machine/DSMGB
machinery/M
machinist/MS
machismo/M
macho/M
mackerel/SM
mackinaw/SM
mackintosh/MS
macrame/M
macro/SM
macrobiotic/S
macrobiotics/M
macrocosm/SM
macroeconomic/S
macroeconomics/M
macrology/S
macron/MS
macrophages
macroscopic
mad/SMYP
madam/SM
madame/M
madcap/MS
madden/DGS
maddening/Y
madder/MS
maddest
madding
made/AU
mademoiselle/MS
madhouse/SM
madman/M
madmen
madness/M
madras/MS
madrasa/SM
madrasah/M
madrasahs
madrassa/SM
madrigal/SM
madwoman/M
madwomen
maelstrom/SM
maestro/SM
mafia/SM
mafiosi
mafioso/M
mag/SM
magazine/SM
mage/MS
magenta/M
maggot/MS
maggoty
magi/M
magic/SM
magical/Y
magician/SM
magicked
magicking
magisterial/Y
magistracy/M
magistrate/SM
magma/M
magnanimity/M
magnanimous/Y
magnate/SM
magnesia/M
magnesium/M
magnet/MS
magnetic
magnetically
magnetism/M
magnetite/M
magnetizable
magnetization/CM
magnetize/CGDS
magneto/SM
magnetometer/SM
magnetosphere
magnification/M
magnificence/M
magnificent/Y
magnifier/M
magnify/ZGXDRSN
magniloquence/M
magniloquent
magnitude/SM
magnolia/MS
magnum/MS
magpie/MS
magus/M
maharajah/M
maharajahs
maharani/SM
maharishi/SM
mahatma/SM
mahogany/SM
mahout/MS
maid/MNSX
maiden/MY
maidenhair/M
maidenhead/SM
maidenhood/M
maidservant/SM
mail/JMDRSZG
mailbag/SM
mailbomb/GSD
mailbox/MS
mailer/M
mailing/M
maillot/SM
mailman/M
mailmen
mailshot/S
maim/DSG
main/MYS
mainframe/SM
mainland/MS
mainline/MGDS
mainmast/MS
mainsail/MS
mainspring/MS
mainstay/MS
mainstream/SMDG
maintain/ZGBDRS
maintainability
maintenance/M
maintop/SM
maisonette/MS
maize/SM
majestic
majestically
majesty/SM
majolica/M
major/SGMDY
majordomo/MS
majorette/MS
majoritarian/SM
majoritarianism
majority/SM
make's/A
make/UAGS
makeover/MS
maker/SM
makeshift/SM
makeup/MS
makeweight/S
making/MS
makings/M
malachite/M
maladjusted
maladjustment/M
maladministration
maladroit/PY
maladroitness/M
malady/SM
malaise/M
malamute/MS
malapropism/SM
malaria/M
malarial
malarkey/M
malathion/M
malcontent/MS
male/MPS
malediction/SM
malefaction/M
malefactor/SM
malefic
maleficence/M
maleficent
maleness/M
malevolence/M
malevolent/Y
malfeasance/M
malformation/SM
malformed
malfunction/MDSG
malice/M
malicious/PY
maliciousness/M
malign/DSG
malignancy/SM
malignant/Y
malignity/M
malinger/ZGSDR
malingerer/M
mall/MS
mallard/SM
malleability/M
malleable
mallet/MS
mallow/MS
malnourished
malnutrition/M
malocclusion/M
malodorous
malpractice/SM
malt/MDSG
malted/MS
maltose/M
maltreat/GLDS
maltreatment/M
malty/TR
malware/M
mam/S
mama/MS
mamba/SM
mambo/SGMD
mamma/M
mammal/MS
mammalian/MS
mammary
mammogram/MS
mammography/M
mammon/M
mammoth/M
mammoths
mammy/SM
man's/F
man/USY
manacle/DSMG
manage/ZGDRSL
manageability/M
manageable/U
management/MS
manager/M
manageress/S
managerial
manana/MS
manatee/SM
mandala/SM
mandamus/MS
mandarin/MS
mandate/DSMG
mandatory
mandible/MS
mandibular
mandolin/MS
mandrake/MS
mandrel/SM
mandrill/MS
mane/MDS
manege/M
maneuver/MDGSBJ
maneuverability/M
manful/Y
manga/M
manganese/M
mange/DRMZ
manger/M
mangetout/S
manginess/M
mangle/MZGDRS
mango/M
mangoes
mangrove/MS
mangy/TRP
manhandle/GDS
manhole/SM
manhood/M
manhunt/SM
mania/SM
maniac/MS
maniacal/Y
manic/SM
manically
manicure/MGDS
manicurist/MS
manifest/MDYSG
manifestation/SM
manifesto/SM
manifold/GMDS
manikin/SM
manila/M
manioc/MS
manipulable
manipulate/XGNVDS
manipulation/M
manipulative/Y
manipulator/MS
mankind/M
manky
manlike
manliness/M
manly/UTR
manna/M
manned/U
mannequin/SM
manner/MDYS
mannerism/SM
mannerly/U
manning/U
mannish/YP
mannishness/M
manometer/SM
manor/SM
manorial
manpower/M
manque
mansard/MS
manse/SXMN
manservant/M
mansion/M
manslaughter/M
manta/SM
mantel/MS
mantelpiece/SM
mantelshelf
mantelshelves
mantes
mantilla/SM
mantis/MS
mantissa/SM
mantle's
mantle/EGDS
mantra/MS
manual/MYS
manufacture/DRSMZG
manufacturer/M
manufacturing/M
manumission/SM
manumit/S
manumitted
manumitting
manure/MGDS
manuscript/MS
many/M
map's
map/AS
maple/SM
mapmaker/SM
mapped/A
mapper/MS
mapping/S
mar/S
marabou/MS
marabout/SM
maraca/MS
maraschino/MS
marathon/SMRZ
marathoner/M
maraud/ZGDRS
marauder/M
marble/MGDS
marbleize/GDS
marbling/M
march/ZGMDRS
marcher/M
marchioness/MS
mare/MS
margarine/M
margarita/MS
marge
margin/MS
marginal/YS
marginalia/M
marginalization/M
marginalize/GDS
maria/M
mariachi/MS
marigold/MS
marijuana/M
marimba/SM
marina/MS
marinade/DSMG
marinara/M
marinate/DSGN
marination/M
marine/MZRS
mariner/M
marionette/MS
marital/Y
maritime
marjoram/M
mark/AMDSG
markdown/SM
marked/U
markedly
marker/MS
market/MDRZGBS
marketability/M
marketable/U
marketeer/SM
marketer/M
marketing/M
marketplace/SM
marking/SM
markka/M
markkaa
marksman/M
marksmanship/M
marksmen
markup/MS
marl/M
marlin/MS
marlinespike/SM
marmalade/M
marmoreal
marmoset/SM
marmot/MS
maroon/MDGS
marque/MS
marquee/SM
marquess/MS
marquetry/M
marquis/MS
marquise/M
marquisette/M
marred/U
marriage/ASM
marriageability/M
marriageable
married/SM
marring
marrow/MS
marry/AGDS
marsh/MS
marshal/SMDG
marshland/SM
marshmallow/SM
marshy/RT
marsupial/MS
mart/MNSX
marten/M
martensite
martial/Y
martian/S
martin/MS
martinet/MS
martingale/MS
martini/SM
martyr/MDGS
martyrdom/M
marvel/MDGS
marvelous/Y
marzipan/M
masc
mascara/GMDS
mascot/MS
masculine/SM
masculinity/M
maser/SM
mash/MDRSZG
masher/M
mashup/MS
mask's
mask/UDSG
masker/MS
masochism/M
masochist/SM
masochistic
masochistically
mason/SM
masonic
masonry/M
masque/MS
masquerade/DRSMZG
masquerader/M
mass/MDSGV
massacre/MGDS
massage/DSMG
masseur/SM
masseuse/MS
massif/MS
massive/PY
massiveness/M
mast/MDS
mastectomy/SM
master's
master/ADGS
masterclass/S
masterful/Y
masterly
mastermind/SGMD
masterpiece/MS
masterstroke/SM
masterwork/MS
mastery/M
masthead/MS
mastic/M
masticate/GNDS
mastication/M
mastiff/SM
mastitis
mastodon/SM
mastoid/SM
masturbate/GNDS
masturbation/M
masturbatory
mat/SZGMDR
matador/SM
match/AMS
matchbook/SM
matchbox/MS
matched/U
matching
matchless
matchlock/SM
matchmaker/MS
matchmaking/M
matchstick/MS
matchwood/M
mate/MS
material/SMY
materialism/M
materialist/SM
materialistic
materialistically
materialization/M
materialize/DSG
materiel/M
maternal/Y
maternity/M
matey/S
math/M
mathematical/Y
mathematician/SM
mathematics/M
maths
matinee/SM
mating/M
matins/M
matriarch/M
matriarchal
matriarchs
matriarchy/SM
matrices
matricidal
matricide/MS
matriculate/DSGN
matriculation/M
matrimonial
matrimony/M
matrix/M
matron/MYS
matte/DRSMZG
matter/MDG
matting/M
mattock/SM
mattress/MS
maturate/GNDS
maturation/M
mature/YTGDRS
maturity/SM
matzo/SMH
matzoh/M
matzohs
matzot
maudlin
maul/MDRSZG
mauler/M
maunder/SDG
mausoleum/SM
mauve/M
maven/SM
maverick/SM
maw/SM
mawkish/PY
mawkishness/M
max/GMDS
maxi/MS
maxilla/M
maxillae
maxillary
maxim/SM
maximal/Y
maximization/M
maximize/GDS
maximum/SM
may/M
maybe/SM
mayday/MS
mayflower/MS
mayfly/SM
mayhem/M
mayn't
mayo/M
mayonnaise/M
mayor/SM
mayoral
mayoralty/M
mayoress/MS
maypole/SM
mayst
maze/MS
mazurka/MS
mdse
me/DSH
mead/M
meadow/MS
meadowlark/MS
meager/PY
meagerness/M
meal/MS
mealiness/M
mealtime/SM
mealy/TPR
mealybug/SM
mealymouthed
mean/MRYJPSTG
meander/SMDJG
meanderings/M
meanie/M
meaning/M
meaningful/PY
meaningfulness/M
meaningless/YP
meaninglessness/M
meanness/M
meant/U
meantime/M
meanwhile/M
meany/SM
meas
measles/M
measly/RT
measurable
measurably
measure's
measure/ADSG
measured/U
measureless
measurement/MS
meat/MS
meatball/MS
meathead/MS
meatiness/M
meatless
meatloaf/M
meatloaves
meatpacking/M
meaty/TPR
mecca/SM
mechanic/MS
mechanical/Y
mechanics/M
mechanism/SM
mechanistic
mechanistically
mechanization/M
mechanize/DSG
medal/SM
medalist/MS
medallion/SM
meddle/ZGDRS
meddler/M
meddlesome
media/SM
medial/AY
median/MS
mediate/DSGN
mediated/U
mediation/AM
mediator/MS
medic/SM
medicaid/M
medical/SMY
medicament/M
medicare/M
medicate/GNXDS
medication/M
medicinal/Y
medicine/MS
medico/MS
medieval
medievalist/MS
mediocre
mediocrity/SM
meditate/DSGNVX
meditation/M
meditative/Y
medium/MS
medley/MS
medulla/SM
medusa
medusae
meed/M
meek/RYPT
meekness/M
meerschaum/SM
meet/MJSG
meeting/M
meetinghouse/SM
meetup
meg/S
mega
megabit/SM
megabucks/M
megabyte/MS
megachurch/MS
megacycle/SM
megadeath/M
megadeaths
megahertz/M
megalith/M
megalithic
megaliths
megalomania/M
megalomaniac/SM
megalopolis/MS
megaphone/DSMG
megapixel/SM
megastar/S
megaton/SM
megawatt/MS
meh
meiosis/M
meiotic
melamine/M
melancholia/M
melancholic/S
melancholy/M
melange/MS
melanin/M
melanoma/SM
meld/MDSG
melee/SM
meliorate/GNVDS
melioration/M
mellifluous/PY
mellifluousness/M
mellow/PTGDRYS
mellowness/M
melodic
melodically
melodious/YP
melodiousness/M
melodrama/MS
melodramatic/S
melodramatically
melodramatics/M
melody/SM
melon/SM
melt's
melt/ADSG
meltdown/SM
member's
member/EAS
membership/SM
membrane/SM
membranous
meme/MS
memento/MS
memo/MS
memoir/MS
memorabilia/M
memorability/M
memorable/U
memorably
memorandum/MS
memorial/SM
memorialize/DSG
memorization/M
memorize/DSG
memory/SM
memsahib/S
men/M
menace/MGDS
menacing/Y
menage/MS
menagerie/MS
mend/MDRSZG
mendacious/Y
mendacity/M
mendelevium/M
mender/M
mendicancy/M
mendicant/SM
mending/M
menfolk/MS
menfolks/M
menhaden/M
menial/MYS
meningeal
meninges
meningitis/M
meninx/M
menisci
meniscus/M
menopausal
menopause/M
menorah/M
menorahs
mensch/MS
menservants
menses/M
menstrual
menstruate/GNDS
menstruation/M
mensurable
mensuration/M
menswear/M
mental/Y
mentalist/SM
mentality/SM
menthol/M
mentholated
mention/GSMD
mentioned/U
mentor/MDSG
menu/MS
meow/MDSG
mercantile
mercantilism/M
mercenary/SM
mercer/MS
mercerize/GDS
merchandise/MZGDRS
merchandiser/M
merchandising/M
merchant/MBS
merchantman/M
merchantmen
merciful/UY
merciless/PY
mercilessness/M
mercurial/Y
mercuric
mercury/M
mercy/SM
mere/MYTS
meretricious/YP
meretriciousness/M
merganser/MS
merge/DRSZG
merger/M
meridian/MS
meringue/MS
merino/MS
merit/CSM
merited/U
meriting
meritocracy/SM
meritocratic
meritorious/PY
meritoriousness/M
mermaid/SM
merman/M
mermen
merrily
merriment/M
merriness/M
merry/TRP
merrymaker/MS
merrymaking/M
mesa/MS
mescal/MS
mescalin
mescaline/M
mesdames
mesdemoiselles
mesh/MDSG
mesmeric
mesmerism/M
mesmerize/ZGDRS
mesmerizer/M
mesomorph/M
mesomorphs
meson/SM
mesosphere/SM
mesquite/SM
mess/MDSG
message/MGDS
messeigneurs
messenger/SM
messiah/M
messiahs
messianic
messieurs
messily
messiness/M
messmate/SM
messy/PTR
mestizo/MS
met
meta
metabolic
metabolically
metabolism/SM
metabolite/SM
metabolize/DSG
metacarpal/SM
metacarpi
metacarpus/M
metadata
metal/SMD
metalanguage/MS
metallic
metallurgic
metallurgical
metallurgist/MS
metallurgy/M
metalwork/MRZG
metalworker/M
metalworking/M
metamorphic
metamorphism/M
metamorphose/GDS
metamorphosis/M
metaphor/MS
metaphoric
metaphorical/Y
metaphysical/Y
metaphysics/M
metastases
metastasis/M
metastasize/DSG
metastatic
metatarsal/MS
metatarsi
metatarsus/M
metatheses
metathesis/M
mete/MZGDRS
metempsychoses
metempsychosis/M
meteor/MS
meteoric
meteorically
meteorite/SM
meteoroid/SM
meteorologic
meteorological
meteorologist/SM
meteorology/M
meter/GMD
methadone/M
methamphetamine/M
methane/M
methanol/M
methinks
method/MS
methodical/YP
methodicalness/M
methodological/Y
methodology/SM
methotrexate
methought
meths
methyl/M
meticulous/YP
meticulousness/M
metier/MS
metric/S
metrical/Y
metricate/GNDS
metrication/M
metricize/GDS
metro/SM
metronome/MS
metropolis/MS
metropolitan
mettle/M
mettlesome
mew/SGMD
mewl/DSG
mews/M
mezzanine/MS
mezzo/SM
mfg
mfr/S
mg
mgr
mi/MNX
miasma/MS
mic/S
mica/M
mice
mick/S
mickey/MS
micro/SM
microaggression/SM
microbe/MS
microbial
microbiological
microbiologist/MS
microbiology/M
microbrewery/SM
microchip/MS
microcircuit/SM
microcode
microcomputer/MS
microcosm/MS
microcosmic
microdot/SM
microeconomics/M
microelectronic/S
microelectronics/M
microfiber/MS
microfiche/M
microfilm/GMDS
microfloppies
microgroove/SM
microlight/MS
microloan/MS
micromanage/GDSL
micromanagement/M
micrometeorite/SM
micrometer/MS
micron/MS
microorganism/MS
microphone/SM
microprocessor/MS
microscope/SM
microscopic
microscopical/Y
microscopy/M
microsecond/MS
microsurgery/M
microwave/DSMGB
microwaveable
mid
midair/M
midday/M
midden/MS
middle/MGS
middlebrow/SM
middleman/M
middlemen
middlemost
middleweight/MS
middy/SM
midfield/RZ
midge/SM
midget/MS
midi/MS
midland/MS
midlife/M
midmost
midnight/M
midpoint/MS
midrib/MS
midriff/MS
midsection/MS
midshipman/M
midshipmen
midships
midsize
midst/M
midstream/M
midsummer/M
midterm/MS
midtown/M
midway/MS
midweek/MS
midwife/MGDS
midwifery/SM
midwinter/M
midwives
midyear/MS
mien/M
miff/DSG
might've
might/M
mightily
mightiness/M
mightn't
mighty/TRP
mignonette/SM
migraine/MS
migrant/MS
migrate/AGDS
migration/SM
migratory
mikado/MS
mike/MGDS
mil/SZMR
milady/SM
milch
mild/MRYTP
mildew/SMDG
mildness/M
mile/MS
mileage/SM
milepost/MS
miler/M
milestone/MS
milf/MS
milieu/SM
militancy/M
militant/MYS
militarily
militarism/M
militarist/SM
militaristic
militarization/CM
militarize/CDSG
military/M
militate/GDS
militia/SM
militiaman/M
militiamen
milk/MDRSZG
milker/M
milkiness/M
milkmaid/MS
milkman/M
milkmen
milkshake/SM
milksop/MS
milkweed/SM
milky/RTP
mill/MDRSZGJ
millage/M
millennia
millennial/M
millennium/MS
miller/M
millet/M
milliard/MS
millibar/MS
milligram/MS
milliliter/MS
millimeter/MS
milliner/MS
millinery/M
milling/M
million/HSM
millionaire/SM
millionairess/S
millionth/M
millionths
millipede/SM
millisecond/SM
millpond/SM
millrace/SM
millstone/SM
millstream/MS
millwright/SM
milometer/S
milquetoast/SM
milt/MDSG
mime/MGDS
mimeograph/GMD
mimeographs
mimetic
mimic/SM
mimicked
mimicker/SM
mimicking
mimicry/SM
mimosa/SM
min
minaret/MS
minatory
mince/DRSMZG
mincemeat/M
mincer/M
mind's
mind/ADRSZG
mindbogglingly
minded/P
mindful/YP
mindfulness/M
mindless/YP
mindlessness/M
mindset/MS
mine/MZGNDRSX
minefield/SM
miner/M
mineral/MS
mineralogical
mineralogist/MS
mineralogy/M
minestrone/M
minesweeper/SM
mingle/DSG
mingy
mini/MS
miniature/MS
miniaturist/MS
miniaturization/M
miniaturize/GDS
minibar/S
minibike/SM
minibus/MS
minicab/S
minicam/MS
minicomputer/SM
minifloppies
minim/SM
minimal/Y
minimalism/M
minimalist/MS
minimization/M
minimize/DSG
minimum/MS
mining/M
minion/M
miniseries/M
miniskirt/MS
minister/SGMD
ministerial
ministrant/MS
ministration/MS
ministry/SM
minivan/MS
mink/MS
minnesinger/MS
minnow/SM
minor/SMDG
minority/SM
minoxidil/M
minster/MS
minstrel/SM
minstrelsy/M
mint/MDRSZG
mintage/M
minter/M
minty/RT
minuend/MS
minuet/SM
minus/MS
minuscule/MS
minute/PDRSMYTG
minuteman/M
minutemen
minuteness/M
minutia/M
minutiae
minx/MS
miracle/MS
miraculous/Y
mirage/SM
mire/MGDS
mirror/GSMD
mirth/M
mirthful/PY
mirthfulness/M
mirthless/Y
miry/RT
misaddress/DSG
misadventure/MS
misaligned
misalignment/M
misalliance/MS
misanthrope/SM
misanthropic
misanthropically
misanthropist/MS
misanthropy/M
misapplication/M
misapply/DSGNX
misapprehend/GSD
misapprehension/MS
misappropriate/XDSGN
misappropriation/M
misbegotten
misbehave/GDS
misbehavior/M
misc
miscalculate/DSXGN
miscalculation/M
miscall/DSG
miscarriage/MS
miscarry/GDS
miscast/SG
miscegenation/M
miscellaneous/Y
miscellany/SM
mischance/SM
mischief/M
mischievous/YP
mischievousness/M
miscibility/M
miscible
miscommunication/S
misconceive/GDS
misconception/SM
misconduct/MDGS
misconstruction/MS
misconstrue/GDS
miscount/MDSG
miscreant/SM
miscue/DSMG
misdeal/GMS
misdealt
misdeed/MS
misdemeanor/MS
misdiagnose/GDS
misdiagnosis/M
misdid
misdirect/SDG
misdirection/M
misdo/JG
misdoes
misdoing/M
misdone
miser/SBMY
miserableness/M
miserably
miserliness/M
misery/SM
misfeasance/M
misfeature/S
misfile/GDS
misfire/MGDS
misfit/SM
misfitted
misfitting
misfortune/SM
misgiving/MS
misgovern/SDGL
misgovernment/M
misguidance/M
misguide/DSG
misguided/Y
mishandle/DSG
mishap/SM
mishear/GS
misheard
mishit/S
mishitting
mishmash/MS
misidentify/GDS
misinform/DGS
misinformation/M
misinterpret/SGD
misinterpretation/SM
misjudge/DSG
misjudgment/SM
mislabel/GSD
mislaid
mislay/GS
mislead/GS
misleading/Y
misled
mismanage/LGDS
mismanagement/M
mismatch/GMDS
misname/GDS
misnomer/MS
misogamist/MS
misogamy/M
misogynist/SM
misogynistic
misogynous
misogyny/M
misplace/GLDS
misplacement/M
misplay/GMDS
misprint/GMDS
misprision/M
mispronounce/DSG
mispronunciation/SM
misquotation/MS
misquote/MGDS
misread/GJS
misreading/M
misreport/MDGS
misrepresent/GDS
misrepresentation/MS
misrule/MGDS
miss's
miss/EDSGV
missal/ESM
missed/U
misshape/GDS
misshapen
missile/MS
missilery/M
mission/AMS
missionary/SM
missioner/SM
missive/MS
misspeak/GS
misspell/GDJS
misspelling/M
misspend/GS
misspent
misspoke
misspoken
misstate/GDSL
misstatement/SM
misstep/MS
missus/MS
mist's
mist/CDRSZG
mistakable/U
mistake/BMGS
mistaken/Y
mister's
mistily
mistime/GDS
mistiness/M
mistletoe/M
mistook
mistral/MS
mistranslated
mistreat/LDGS
mistreatment/M
mistress/MS
mistrial/MS
mistrust/MDSG
mistrustful/Y
misty/PRT
mistype/GS
misunderstand/SGJ
misunderstanding/M
misunderstood
misuse/DSMG
mite/MZRS
miter/MDG
mitigate/DSGN
mitigated/U
mitigation/M
mitochondria
mitochondrial
mitochondrion
mitoses
mitosis/M
mitotic
mitral
mitt/MNSX
mitten/M
mix/ZGMDRSB
mixed/U
mixer/M
mixture/SM
mizzen/MS
mizzenmast/SM
mkay
mks
ml
mm
mnemonic/MS
mnemonically
mo/CKHS
moan/MDRSZG
moaner/M
moat/MDS
mob's
mob/CS
mobbed/C
mobbing/C
mobile/MS
mobility/M
mobilization/CM
mobilizations
mobilize/CDSG
mobilizer/SM
mobster/SM
moccasin/SM
mocha/SM
mock/DRSZG
mocker/M
mockery/SM
mocking/Y
mockingbird/SM
mod/STM
modal/SM
modality/S
modded
modding
mode/MS
model/ZGSJMDR
modeler/M
modeling/M
modem/SM
moderate/MYGNPDS
moderateness/M
moderation/M
moderator/SM
modern/MYPS
modernism/M
modernist/SM
modernistic
modernity/M
modernization/M
modernize/DRSZG
modernizer/M
modernness/M
modest/Y
modesty/M
modicum/SM
modifiable
modification/M
modified/U
modifier/M
modify/DRSXZGN
modish/YP
modishness/M
modular
modulate/CGNDS
modulation/CM
modulations
modulator/MS
module/MS
modulo
modulus
moggy
mogul/SM
mohair/M
moi
moiety/SM
moil/MDSG
moire/SM
moist/XTPNRY
moisten/DRZG
moistener/M
moistness/M
moisture/M
moisturize/ZGDRS
moisturizer/M
molar/SM
molasses/M
mold/MDRJSZG
moldboard/SM
molder/GMD
moldiness/M
molding/M
moldy/TPR
mole/MS
molecular
molecularity/M
molecule/SM
molehill/SM
moleskin/M
molest/DRZGS
molestation/M
molested/U
molester/M
moll/MS
mollification/M
mollify/DSNG
molluscan
mollusk/SM
molly/SM
mollycoddle/DSMG
molt/MDNRSZG
molter/M
molybdenum/M
mom/SM
moment/MS
momenta
momentarily
momentariness/M
momentary/P
momentous/PY
momentousness/M
momentum/M
mommy/SM
monarch/M
monarchic
monarchical
monarchism/M
monarchist/MS
monarchistic
monarchs
monarchy/SM
monastery/SM
monastic/MS
monastical/Y
monasticism/M
monaural
monetarily
monetarism/M
monetarist/MS
monetary
monetize/CGDS
money/SMD
moneybag/MS
moneybox/S
moneylender/SM
moneymaker/SM
moneymaking/M
monger/MDGS
mongol/S
mongolism/M
mongoloid/MS
mongoose/MS
mongrel/SM
monies
moniker/SM
monism/M
monist/MS
monition/SM
monitor/SMDG
monitory
monk/MS
monkey/MDGS
monkeyshine/SM
monkish
monkshood/SM
mono/M
monochromatic
monochrome/MS
monocle/DSM
monoclonal
monocotyledon/SM
monocotyledonous
monocular
monodic
monodist/SM
monody/SM
monogamist/MS
monogamous/Y
monogamy/M
monogram/SM
monogrammed
monogramming
monograph/M
monographs
monolingual/MS
monolith/M
monolithic
monoliths
monologist/SM
monologue/SM
monomania/M
monomaniac/MS
monomaniacal
monomer/SM
mononucleosis/M
monophonic
monoplane/SM
monopolist/SM
monopolistic
monopolization/M
monopolize/DRSZG
monopolizer/M
monopoly/SM
monorail/MS
monosyllabic
monosyllable/MS
monotheism/M
monotheist/SM
monotheistic
monotone/MS
monotonic
monotonically
monotonous/PY
monotonousness/M
monotony/M
monounsaturated
monoxide/MS
monseigneur/M
monsieur/M
monsignor/SM
monsoon/SM
monsoonal
monster/SM
monstrance/ASM
monstrosity/SM
monstrous/Y
montage/SM
month/MY
monthly/SM
months
monument/MS
monumental/Y
moo/SGMD
mooch/ZGMDRS
moocher/M
mood/MS
moodily
moodiness/M
moody/TPR
moon/MDSG
moonbeam/MS
moonless
moonlight/SMDRZG
moonlighter/M
moonlighting/M
moonlit
moonscape/SM
moonshine/MZRS
moonshiner/M
moonshot/MS
moonstone/MS
moonstruck
moonwalk/MS
moor/MDJSG
moorhen/S
mooring/M
moorland/MS
moose/M
moot/DSG
mop/SZGMDR
mope/MS
moped/SM
moper/M
mopey
mopier
mopiest
mopish
mopped
moppet/MS
mopping
moraine/SM
moral/SMY
morale/M
moralist/MS
moralistic
moralistically
moralities
morality/UM
moralization/CM
moralize/CGDS
moralizer/MS
morass/MS
moratorium/SM
moray/SM
morbid/YP
morbidity/M
morbidness/M
mordancy/M
mordant/SMY
more/MS
moreish
morel/SM
moreover
mores/M
morgue/MS
moribund
morn/MJSG
morning/M
morocco/M
moron/SM
moronic
moronically
morose/YP
moroseness/M
morph/GD
morpheme/MS
morphemic
morphia/M
morphine/M
morphing/M
morphological
morphology/M
morphs
morrow/MS
morsel/MS
mortal/MYS
mortality/M
mortar/MDSG
mortarboard/SM
mortgage's
mortgage/AGDS
mortgagee/MS
mortgagor/MS
mortician/MS
mortification/M
mortify/NGDS
mortise/DSMG
mortuary/SM
mosaic/MS
mosey/SGD
mosh/DSG
mosque/MS
mosquito/M
mosquitoes
moss/MS
mossback/SM
mossy/TR
most/MY
mot/SM
mote's
mote/KCXSVN
motel/SM
motet/SM
moth/M
mothball/GMDS
mother/MDYSG
motherboard/SM
motherfucker/MS!
motherfucking/!
motherhood/M
motherland/MS
motherless
motherliness/M
moths
motif/SM
motile/S
motility/M
motion/KCM
motioned
motioning
motionless/YP
motionlessness/M
motivate/CDSG
motivated/U
motivation/SM
motivational
motivator/SM
motive/MS
motiveless
motley/MS
motlier
motliest
motocross/MS
motor/SGMD
motorbike/MGDS
motorboat/MS
motorcade/MS
motorcar/SM
motorcycle/DSMG
motorcyclist/MS
motorist/SM
motorization/M
motorize/DSG
motorman/M
motormen
motormouth/M
motormouths
motorway/SM
mottle/GDS
motto/M
mottoes
moue/MS
mound/SGMD
mount/EASGMD
mountable
mountain/SM
mountaineer/SMDG
mountaineering/M
mountainous
mountainside/SM
mountaintop/SM
mountebank/MS
mounted/U
mounter/MS
mounting/SM
mourn/SZGDR
mourned/U
mourner/M
mournful/YP
mournfulness/M
mourning/M
mouse/DRSMZG
mouser/M
mousetrap/SM
mousetrapped
mousetrapping
mousiness/M
moussaka/S
mousse/MGDS
mousy/PTR
mouth/GMD
mouthfeel
mouthful/MS
mouthiness/M
mouthpiece/MS
mouths
mouthwash/MS
mouthwatering
mouthy/PTR
mouton/M
movable/SM
move/AMZGDRSB
moved/U
movement/SM
mover/AM
movie/SM
moviegoer/SM
moving/Y
mow/SZGMDR
mower/M
moxie/M
mozzarella/M
mp
mpg
mph
mt
mtg
mtge
mu/SM
much/M
mucilage/M
mucilaginous
muck/MDSG
muckrake/DRSZG
muckraker/M
mucky/TR
mucous
mucus/M
mud/M
muddily
muddiness/M
muddle/MGDS
muddleheaded
muddy/PTGDRS
mudflap/S
mudflat/MS
mudguard/SM
mudpack/S
mudroom/MS
mudslide/MS
mudslinger/SM
mudslinging/M
muenster/M
muesli
muezzin/MS
muff/MDSG
muffin/MS
muffle/ZGDRS
muffler/M
mufti/SM
mug/SM
mugful/MS
mugged
mugger/MS
mugginess/M
mugging/MS
muggins
muggle/MS
muggy/PTR
mugshot/MS
mugwump/MS
mujaheddin
mukluk/MS
mulatto/M
mulattoes
mulberry/SM
mulch/GMDS
mulct/SGMD
mule/MS
muleskinner/MS
muleteer/MS
mulish/PY
mulishness/M
mull/DSG
mullah/M
mullahs
mullein/M
mullet/MS
mulligan/SM
mulligatawny/M
mullion/SMD
multi
multicolored
multicultural
multiculturalism/M
multidimensional
multidisciplinary
multifaceted
multifamily
multifarious/PY
multifariousness/M
multiform
multigrain
multilateral/Y
multilayered
multilevel
multilingual
multilingualism/M
multimedia/M
multimillionaire/SM
multinational/SM
multiparty
multiplayer/M
multiple/MS
multiplex/ZGMDRS
multiplexer/M
multiplicand/MS
multiplication/M
multiplicative
multiplicity/SM
multiplier/M
multiply/NZGDRSX
multiprocessing
multiprocessor/SM
multipurpose
multiracial
multistage
multistory
multitask/GS
multitasking/M
multitude/SM
multitudinous
multivariate
multiverse/SM
multivitamin/MS
multiyear
mum/SM
mumble/MZGDRS
mumbler/M
mumbletypeg/M
mummer/MS
mummery/M
mummification/M
mummify/GNDS
mummy/SM
mumps/M
mun
munch/GDS
munchies/M
munchkin/SM
mundane/SY
mung/DSG
municipal/SMY
municipality/SM
munificence/M
munificent/Y
munition/MDGS
mural/SM
muralist/SM
murder/ZGMDRS
murderer/M
murderess/MS
murderous/Y
murk/MS
murkily
murkiness/M
murky/PTR
murmur/ZGJMDRS
murmurer/M
murmuring/M
murmurous
murrain/M
muscat/MS
muscatel/SM
muscle/MGDS
musclebound
muscleman
musclemen
muscly
muscular/Y
muscularity/M
musculature/M
muse/MGDSJ
musette/MS
museum/MS
mush/MDRSZG
mushiness/M
mushroom/GSMD
mushy/PTR
music/SM
musical/MYS
musicale/MS
musicality/M
musician/SMY
musicianship/M
musicological
musicologist/MS
musicology/M
musing/MY
musk/M
muskeg/MS
muskellunge/MS
musket/MS
musketeer/MS
musketry/M
muskie/M
muskiness/M
muskmelon/SM
muskox/MN
muskrat/MS
musky/PTRS
muslin/M
muss/MDSG
mussel/MS
mussy/TR
must've
must/MRSZ
mustache/MDS
mustachio/SMD
mustang/MS
mustard/M
muster/GMD
mustily
mustiness/M
mustn't
musty/PTR
mutability/M
mutably
mutagen/MS
mutant/MS
mutate/XGNVDS
mutation/M
mutational
mute/MYTGDRSPB
muteness/M
mutilate/DSGNX
mutilation/M
mutilator/SM
mutineer/SM
mutinous/Y
mutiny/GDSM
mutt/MS
mutter/ZGJMDRS
mutterer/M
muttering/M
mutton/M
muttonchops/M
muttony
mutual/Y
mutuality/M
muumuu/MS
muzak
muzzily
muzzle/DSMG
muzzy/P
my
mycologist/SM
mycology/M
myelitis/M
myna/MS
myocardial
myocardium
myopia/M
myopic
myopically
myriad/SM
myrmidon/MS
myrrh/M
myrtle/SM
mys
myself
mysterious/PY
mysteriousness/M
mystery/SM
mystic/SM
mystical/Y
mysticism/M
mystification/CM
mystify/CDSGN
mystique/M
myth/M
mythic
mythical
mythological
mythologist/SM
mythologize/DSG
mythology/SM
myths
myxomatosis
n/IKTH
naan/S
nab/S
nabbed
nabbing
nabob/SM
nacelle/SM
nacho/SM
nacre/M
nacreous
nadir/SM
nae
naff/RT
nag/SM
nagged
nagger/MS
nagging
nagware
nah
naiad/SM
naif/MS
nail/MDSG
nailbrush/MS
naive/RYT
naivete/M
naivety/M
naked/PY
nakedness/M
name's
name/AGDS
nameable/U
named/U
namedrop
namedropping/M
nameless/Y
namely
nameplate/MS
namesake/SM
nanny/SM
nanobot/S
nanosecond/SM
nanotechnology/SM
nap/SM
napalm/MDSG
nape/MS
naphtha/M
naphthalene/M
napkin/MS
napless
napoleon/SM
napped
napper/MS
napping
nappy/TRSM
narc/MS
narcissism/M
narcissist/MS
narcissistic
narcissus/M
narcolepsy/M
narcoleptic
narcoses
narcosis/M
narcotic/SM
narcotization/M
narcotize/GDS
nark
narky
narrate/GNVDSX
narration/M
narrative/SM
narrator/SM
narrow/PTGMDRYS
narrowness/M
narwhal/MS
nary
nasal/SMY
nasality/M
nasalization/M
nasalize/DSG
nascence/AM
nascent/A
nastily
nastiness/M
nasturtium/SM
nasty/PTR
natal
natch
nation/MS
national/MYS
nationalism/M
nationalist/SM
nationalistic
nationalistically
nationality/SM
nationalization/MS
nationalize/CDSG
nationhood/M
nationwide
native/MS
nativity/SM
natl
natter/GMDS
nattily
nattiness/M
natty/PTR
natural's
natural/UPY
naturalism/M
naturalist/SM
naturalistic
naturalization/M
naturalize/DSG
naturalness/UM
naturals
nature's
nature/CS
naturism
naturist/S
naught/MS
naughtily
naughtiness/M
naughty/PTR
nausea/M
nauseate/GDS
nauseating/Y
nauseous/PY
nauseousness/M
nautical/Y
nautilus/MS
naval
nave/MS
navel/SM
navigability/M
navigable
navigate/DSGN
navigation/M
navigational
navigator/MS
navvy/S
navy/SM
nay/SM
naysayer/MS
ne'er
neanderthal/MS
neap/MS
near/DRYSPTG
nearby
nearness/M
nearshore
nearside
nearsighted/YP
nearsightedness/M
neat/NRYPXT
neaten/GD
neath
neatness/M
nebula/M
nebulae
nebular
nebulous/PY
nebulousness/M
necessarily/U
necessary/SM
necessitate/DSG
necessitous
necessity/SM
neck/MDSG
neckband/S
neckerchief/MS
necking/M
necklace/MGDSJ
neckline/MS
necktie/MS
necrology/M
necromancer/SM
necromancy/M
necrophilia
necrophiliac/S
necropolis/MS
necroses
necrosis/M
necrotic
nectar/M
nectarine/MS
nee
need/MDSG
needed/U
needful/Y
neediness/M
needle/MGDS
needlepoint/M
needless/YP
needlessness/M
needlewoman/M
needlewomen
needlework/M
needn't
needy/PTR
nefarious/YP
nefariousness/M
neg
negate/DSGNVX
negation/M
negative/MYGPDS
negativeness/M
negativism/M
negativity/M
neglect/SGMD
neglectful/YP
neglectfulness/M
negligee/MS
negligence/M
negligent/Y
negligible
negligibly
negotiability/M
negotiable/A
negotiate/ADSGN
negotiation/AM
negotiations
negotiator/MS
negritude/M
negro
negroid
neigh/MDG
neighbor/SMDYG
neighborhood/SM
neighborliness/M
neighs
neither
nelson/SM
nematode/SM
nemeses
nemesis/M
neoclassic
neoclassical
neoclassicism/M
neocolonialism/M
neocolonialist/MS
neocon/SM
neoconservative/SM
neodymium/M
neolithic
neologism/SM
neon/M
neonatal
neonate/MS
neophilia
neophyte/MS
neoplasm/MS
neoplastic
neoprene/M
nepenthe/M
nephew/SM
nephrite/M
nephritic
nephritis/M
nephropathy
nepotism/M
nepotist/SM
nepotistic
neptunium/M
nerd/MS
nerdy/RT
nerve's
nerve/UDSG
nerveless/YP
nervelessness/M
nerviness/M
nervous/YP
nervousness/M
nervy/TPR
nest/MDSG
nestle/GJDS
nestling/M
net/SM
netball
netbook/MS
nether
nethermost
netherworld/M
netiquette/S
netted
netter/S
netting/M
nettle/MGDS
nettlesome
network/SGMD
networking/M
neural/Y
neuralgia/M
neuralgic
neurasthenia/M
neurasthenic/MS
neuritic/MS
neuritis/M
neurological/Y
neurologist/SM
neurology/M
neuron/MS
neuronal
neuroses
neurosis/M
neurosurgeon/MS
neurosurgery/M
neurosurgical
neurotic/MS
neurotically
neurotransmitter/SM
neut
neuter/MDGS
neutral/SMY
neutralism/M
neutralist/SM
neutrality/M
neutralization/M
neutralize/DRSZG
neutralizer/M
neutrino/SM
neutron/SM
never
nevermore
nevertheless
nevi
nevus/M
new/STMRYP
newbie/MS
newborn/SM
newcomer/SM
newel/SM
newfangled
newfound
newline/S
newlywed/SM
newness/M
news/M
newsagent/S
newsboy/SM
newscast/SMRZ
newscaster/M
newsdealer/SM
newsflash/S
newsgirl/SM
newsgroup/MS
newshound/S
newsletter/MS
newsman/M
newsmen
newspaper/MS
newspaperman/M
newspapermen
newspaperwoman/M
newspaperwomen
newspeak
newsprint/M
newsreader/S
newsreel/MS
newsroom/MS
newsstand/SM
newsweekly/SM
newswoman/M
newswomen
newsworthiness/M
newsworthy/P
newsy/TR
newt/MS
newton/MS
next/M
nexus/MS
niacin/M
nib/SM
nibble/MZGDRS
nibbler/M
nice/PYTR
niceness/M
nicety/SM
niche/SM
nick/MDRSZG
nickel/MS
nickelodeon/SM
nicker/MDG
nickle/S
nickname/DSMG
nicotine/M
niece/SM
niff
niffy
nifty/TR
nigga/SM
niggard/SMY
niggardliness/M
niggaz
nigger/SM!
niggle/MZGDRS
niggler/M
nigh/RT
night/SMY
nightcap/SM
nightclothes/M
nightclub/SM
nightclubbed
nightclubbing
nightdress/MS
nightfall/M
nightgown/SM
nighthawk/SM
nightie/SM
nightingale/SM
nightlife/M
nightlight/S
nightlong
nightmare/SM
nightmarish
nightshade/SM
nightshirt/SM
nightspot/MS
nightstand/SM
nightstick/SM
nighttime/M
nightwatchman
nightwatchmen
nightwear/M
nihilism/M
nihilist/MS
nihilistic
nil/M
nimbi
nimble/TPR
nimbleness/M
nimbly
nimbus/M
nimby
nimrod/MS
nincompoop/SM
nine/MS
ninepin/MS
ninepins/M
nineteen/SMH
nineteenth/M
nineteenths
ninetieth/M
ninetieths
ninety/HSM
ninja/SM
ninny/SM
ninth/M
ninths
niobium/M
nip/SM
nipped
nipper/MS
nippiness/M
nipping
nipple/MS
nippy/TPR
nirvana/M
nisei/M
nit/SMR
niter/M
nitpick/SZGDR
nitpicker/M
nitpicking/M
nitrate/DSMGN
nitration/M
nitrification/M
nitrite/SM
nitro
nitrocellulose/M
nitrogen/M
nitrogenous
nitroglycerin/M
nitwit/MS
nix/GMDS
no/SM
nob/SY
nobble/GDS
nobelium/M
nobility/M
noble/RSPMT
nobleman/M
noblemen
nobleness/M
noblewoman/M
noblewomen
nobody/SM
nocturnal/Y
nocturne/MS
nod/SM
nodal
nodded
nodding
noddle/MS
noddy
node/MS
nodular
nodule/MS
noel/MS
noes
noggin/MS
nohow
noise/DSMG
noiseless/PY
noiselessness/M
noisemaker/MS
noisily
noisiness/M
noisome
noisy/PTR
nomad/SM
nomadic
nomenclature/MS
nominal/Y
nominate/ACGNVDS
nomination's/A
nomination/CSM
nominative/SM
nominator/CSM
nominee/MS
non
nonabrasive
nonabsorbent/SM
nonacademic
nonacceptance/M
nonacid
nonactive/MS
nonaddictive
nonadhesive
nonadjacent
nonadjustable
nonadministrative
nonage/MS
nonagenarian/MS
nonaggression/M
nonalcoholic
nonaligned
nonalignment/M
nonallergic
nonappearance/MS
nonassignable
nonathletic
nonattendance/M
nonautomotive
nonavailability/M
nonbasic
nonbeliever/MS
nonbelligerent/MS
nonbinding
nonbreakable
nonburnable
noncaloric
noncancerous
nonce/M
nonchalance/M
nonchalant/Y
nonchargeable
nonclerical/MS
nonclinical
noncollectable
noncom/MS
noncombat
noncombatant/MS
noncombustible
noncommercial/MS
noncommittal/Y
noncommunicable
noncompeting
noncompetitive
noncompliance/M
noncomplying
noncomprehending
nonconducting
nonconductor/MS
nonconforming
nonconformism
nonconformist/MS
nonconformity/M
nonconsecutive
nonconstructive
noncontagious
noncontinuous
noncontributing
noncontributory
noncontroversial
nonconvertible
noncooperation/M
noncorroding
noncorrosive
noncredit
noncriminal/SM
noncritical
noncrystalline
noncumulative
noncustodial
nondairy
nondeductible/M
nondelivery/SM
nondemocratic
nondenominational
nondepartmental
nondepreciating
nondescript
nondestructive
nondetachable
nondisciplinary
nondisclosure/M
nondiscrimination/M
nondiscriminatory
nondramatic
nondrinker/MS
nondrying
none
noneducational
noneffective
nonelastic
nonelectric
nonelectrical
nonempty
nonenforceable
nonentity/SM
nonequivalent/MS
nonessential
nonesuch/MS
nonetheless
nonevent/MS
nonexchangeable
nonexclusive
nonexempt/M
nonexistence/M
nonexistent
nonexplosive/MS
nonfactual
nonfading
nonfat
nonfatal
nonfattening
nonferrous
nonfiction/M
nonfictional
nonflammable
nonflowering
nonfluctuating
nonflying
nonfood/M
nonfreezing
nonfunctional
nongovernmental
nongranular
nonhazardous
nonhereditary
nonhuman
nonidentical
noninclusive
nonindependent
nonindustrial
noninfectious
noninflammatory
noninflationary
noninflected
nonintellectual/MS
noninterchangeable
noninterference/M
nonintervention/M
nonintoxicating
noninvasive
nonirritating
nonissue
nonjudgmental
nonjudicial
nonlegal
nonlethal
nonlinear
nonliterary
nonliving/M
nonmagnetic
nonmalignant
nonmember/MS
nonmetal/SM
nonmetallic
nonmigratory
nonmilitant
nonmilitary
nonnarcotic/SM
nonnative/MS
nonnegotiable
nonnuclear
nonnumerical
nonobjective
nonobligatory
nonobservance/M
nonobservant
nonoccupational
nonoccurence
nonofficial
nonoperational
nonoperative
nonparallel/MS
nonpareil/MS
nonparticipant/MS
nonparticipating
nonpartisan/SM
nonpaying
nonpayment/SM
nonperformance/M
nonperforming
nonperishable
nonperson/MS
nonphysical/Y
nonplus/S
nonplussed
nonplussing
nonpoisonous
nonpolitical
nonpolluting
nonporous
nonpracticing
nonprejudicial
nonprescription
nonproductive
nonprofessional/SM
nonprofit/SMB
nonproliferation/M
nonpublic
nonpunishable
nonracial
nonradioactive
nonrandom
nonreactive
nonreciprocal/SM
nonreciprocating
nonrecognition/M
nonrecoverable
nonrecurring
nonredeemable
nonrefillable
nonrefundable
nonreligious
nonrenewable
nonrepresentational
nonresident/MS
nonresidential
nonresidual/M
nonresistance/M
nonresistant
nonrestrictive
nonreturnable/MS
nonrhythmic
nonrigid
nonsalaried
nonscheduled
nonscientific
nonscoring
nonseasonal
nonsectarian
nonsecular
nonsegregated
nonsense/M
nonsensical/Y
nonsensitive
nonsexist
nonsexual
nonskid
nonslip
nonsmoker/SM
nonsmoking
nonsocial
nonspeaking
nonspecialist/MS
nonspecializing
nonspecific
nonspiritual/SM
nonstaining
nonstandard
nonstarter/MS
nonstick
nonstop
nonstrategic
nonstriking
nonstructural
nonsuccessive
nonsupport/GM
nonsurgical
nonsustaining
nonsympathizer/M
nontarnishable
nontaxable
nontechnical
nontenured
nontheatrical
nonthinking
nonthreatening
nontoxic
nontraditional
nontransferable
nontransparent
nontrivial
nontropical
nonuniform
nonunion
nonuser/MS
nonvenomous
nonverbal
nonviable
nonviolence/M
nonviolent/Y
nonvirulent
nonvocal
nonvocational
nonvolatile
nonvoter/MS
nonvoting
nonwhite/MS
nonworking
nonyielding
nonzero
noodle/MGDS
nook/MS
nookie
nooky
noon/M
noonday/M
noontide/M
noontime/M
noose/SM
nope
nor
nor'easter
norm/MS
normal/MY
normalcy/M
normality/M
normalization/M
normalize/DSG
normative
north/ZMR
northbound
northeast/MRZ
northeaster/MY
northeastern
northeastward/S
norther/MY
northerly/SM
northern/ZR
northerner/M
northernmost
northward/S
northwest/ZMR
northwester/MY
northwestern
northwestward/S
nose/MGDS
nosebag/S
nosebleed/MS
nosecone/SM
nosedive/DSMG
nosegay/SM
nosh/MDRSZG
nosher/M
nosily
nosiness/M
nostalgia/M
nostalgic
nostalgically
nostril/MS
nostrum/MS
nosy/RPT
not/B
notability/SM
notable/SM
notably
notarial
notarization/M
notarize/GDS
notary/SM
notate/GDS
notation/FCSM
notch/GMDS
note's
note/FCSDG
notebook/MS
notelet/S
notepad/S
notepaper/M
noteworthiness/M
noteworthy/P
nothing/PSM
nothingness/M
notice/MGDS
noticeable/U
noticeably
noticeboard/S
noticed/U
notifiable
notification/M
notifier/M
notify/NDRSXZG
notion/MS
notional/Y
notoriety/M
notorious/Y
notwithstanding
notwork/S
nougat/MS
noun/KMS
nourish/DSLG
nourishment/M
nous
nova/MS
novae
novel/SM
novelette/SM
novelist/SM
novelization/MS
novelize/DSG
novella/MS
novelty/SM
novena/MS
novene
novice/MS
novitiate/MS
now/M
nowadays/M
noway/S
nowhere/M
nowise
nowt
noxious
nozzle/MS
nu/SM
nuance/MDS
nub/SM
nubbin/MS
nubby/TR
nubile
nuclear/K
nucleate/DSGN
nucleation/M
nuclei
nucleic
nucleoli
nucleolus/M
nucleon/SM
nucleoside
nucleotide
nucleus/M
nude/MTRS
nudge/GDSM
nudism/M
nudist/SM
nudity/M
nugatory
nugget/SM
nuisance/MS
nuke/MGDS
null/S
nullification/M
nullify/NDSG
nullity/M
numb/ZTGPDRYS
number's
number/ASDG
numbered/U
numberless
numbness/M
numerable/I
numeracy/IM
numeral/SM
numerate/XGNDS
numeration/M
numerator/MS
numeric
numerical/Y
numerologist/MS
numerology/M
numerous/Y
numinous
numismatic/S
numismatics/M
numismatist/SM
numskull/MS
nun/SM
nuncio/SM
nunnery/SM
nuptial/MS
nurse/MZGDRS
nurselings
nursemaid/MS
nurser/M
nursery/SM
nurseryman/M
nurserymen
nursing/M
nursling/SM
nurture/DRSMZG
nurturer/M
nut/SM
nutcase/S
nutcracker/MS
nuthatch/MS
nuthouse/S
nutmeat/SM
nutmeg/SM
nutpick/SM
nutria/SM
nutrient/MS
nutriment/MS
nutrition/M
nutritional/Y
nutritionist/SM
nutritious/YP
nutritiousness/M
nutritive
nutshell/MS
nutted
nutter/S
nuttiness/M
nutting
nutty/RTP
nuzzle/DRSMZG
nuzzler/M
nybble/S
nylon/MS
nylons/M
nymph/M
nymphet/MS
nympho/S
nymphomania/M
nymphomaniac/SM
nymphs
o
o'clock
o'er
oaf/SM
oafish/PY
oafishness/M
oak/SMN
oakum/M
oar/SGMD
oarlock/SM
oarsman/M
oarsmen
oarswoman/M
oarswomen
oases
oasis/M
oat/SMN
oatcake/SM
oath/M
oaths
oatmeal/M
oats/M
ob/S
obbligato/MS
obduracy/M
obdurate/PY
obdurateness/M
obedience/EM
obedient/EY
obeisance/SM
obeisant
obelisk/MS
obese
obesity/M
obey/EDSG
obfuscate/GNXDS
obfuscation/M
obi/SM
obit/MS
obituary/SM
obj
object/SGVMD
objectify/NGDS
objection/SMB
objectionable/U
objectionably
objective/SMYP
objectiveness/M
objectivity/M
objector/MS
objurgate/XGNDS
objurgation/M
oblate/NX
oblation/M
obligate/DSXGN
obligation/M
obligatorily
obligatory
oblige/EGDS
obliging/Y
oblique/SMYP
obliqueness/M
obliquity/M
obliterate/DSGN
obliteration/M
oblivion/M
oblivious/YP
obliviousness/M
oblong/MS
obloquy/M
obnoxious/YP
obnoxiousness/M
oboe/MS
oboist/MS
obscene/RYT
obscenity/SM
obscurantism/M
obscurantist/SM
obscure/DRSYTG
obscurity/SM
obsequies
obsequious/PY
obsequiousness/M
obsequy/M
observably
observance/MS
observant/Y
observation/SM
observational
observatory/SM
observe/DRSBZG
observed/U
observer/M
obsess/DSGV
obsession/SM
obsessional/Y
obsessive/PSMY
obsessiveness/M
obsidian/M
obsolesce/DSG
obsolescence/M
obsolescent
obsolete/GDS
obstacle/MS
obstetric/S
obstetrical
obstetrician/SM
obstetrics/M
obstinacy/M
obstinate/Y
obstreperous/YP
obstreperousness/M
obstruct/DGVS
obstructed/U
obstruction/SM
obstructionism/M
obstructionist/MS
obstructive/YP
obstructiveness/M
obtain/DBLGS
obtainable/U
obtainment/M
obtrude/DSG
obtrusion/M
obtrusive/UPY
obtrusiveness/UM
obtuse/YTRP
obtuseness/M
obverse/SM
obviate/DSGN
obviation/M
obvious/PY
obviousness/M
ocarina/MS
occasion/GMDS
occasional/Y
occidental/SM
occlude/GDS
occlusion/SM
occlusive
occult/M
occultism/M
occultist/SM
occupancy/M
occupant/SM
occupation/AM
occupational/Y
occupations
occupied/U
occupier/SM
occupy/ADSG
occur/AS
occurred/A
occurrence/SM
occurring/A
ocean/SM
oceanfront/SM
oceangoing
oceanic/M
oceanographer/SM
oceanographic
oceanography/M
oceanology/M
ocelot/MS
och/R
ocher/M
ocker/S
octagon/MS
octagonal
octal
octane/MS
octave/MS
octavo/MS
octet/SM
octogenarian/SM
octopus/MS
ocular/MS
oculist/SM
odalisque/SM
odd/STRYLP
oddball/SM
oddity/SM
oddment/SM
oddness/M
odds/M
ode/SM
odious/YP
odiousness/M
odium/M
odometer/MS
odor/MDS
odoriferous
odorless
odorous
odyssey/MS
oedipal
oenology/M
oenophile/SM
oeuvre/MS
of
off/SZGDRJ
offal/M
offbeat/MS
offend/ZGDRS
offender/M
offense/MS
offensive's
offensive/IPY
offensiveness/IM
offensives
offer/JGMD
offering/M
offertory/SM
offhand
offhanded/PY
offhandedness/M
office/MZRS
officeholder/SM
officer/M
official/MYS
officialdom/M
officialese
officialism/M
officiant/SM
officiate/DSG
officiator/MS
officious/PY
officiousness/M
offing/M
offish
offline
offload/SDG
offprint/SM
offset/MS
offsetting
offshoot/MS
offshore/G
offside
offsite
offspring/M
offstage/S
offtrack
oft
often/TR
oftentimes
ofttimes
ogle/MZGDRS
ogler/M
ogre/MS
ogreish
ogress/MS
oh/M
ohm/SM
ohmmeter/MS
oho
ohs
oi
oik/S
oil/SGMD
oilcan/S
oilcloth/M
oilcloths
oilfield/S
oiliness/M
oilman
oilmen
oilskin/MS
oilskins/M
oily/RPT
oink/MDSG
ointment/SM
okapi/SM
okay/MSG
okra/MS
old/TMNRP
oldie/SM
oldish
oldness/M
oldster/MS
ole/SMV
oleaginous
oleander/MS
oleo/M
oleomargarine/M
olfactory/SM
oligarch/M
oligarchic
oligarchical
oligarchs
oligarchy/SM
oligonucleotide/S
oligopoly/SM
olive/SM
om/SMNX
ombudsman/M
ombudsmen
omega/SM
omelet/MS
omen/M
omicron/MS
ominous/YP
ominousness/M
omission/MS
omit/S
omitted
omitting
omnibus/MS
omnipotence/M
omnipotent
omnipresence/M
omnipresent
omniscience/M
omniscient
omnivore/MS
omnivorous/PY
omnivorousness/M
on/Y
once/M
oncogene/SM
oncologist/SM
oncology/M
oncoming
one/SXMNP
oneness/M
onerous/PY
onerousness/M
oneself
onetime
ongoing
onion/M
onionskin/M
online
onlooker/SM
onlooking
onomatopoeia/M
onomatopoeic
onomatopoetic
onrush/MSG
onscreen
onset/MS
onshore
onside
onsite
onslaught/MS
onstage
onto
ontogeny/M
ontological
ontology/M
onus/MS
onward
onyx/MS
oodles/M
ooh/GD
oohs
oomph
oops
ooze/MGDS
oozy/TR
op/SMDG
opacity/M
opal/MS
opalescence/M
opalescent
opaque/PYTGDRS
opaqueness/M
opcode/S
ope/S
open/ZTGJPMDRYS
opencast
opened/U
opener/M
openhanded/P
openhandedness/M
openhearted
opening/M
openness/M
openwork/M
opera/MS
operable/I
operand/S
operate/DSGNVX
operatic
operatically
operation/M
operational/Y
operative/SM
operator/SM
operetta/SM
ophthalmic
ophthalmologist/SM
ophthalmology/M
opiate/SM
opine/GNXDS
opinion/M
opinionated
opium/M
opossum/MS
opp
opponent/SM
opportune/IY
opportunism/M
opportunist/SM
opportunistic
opportunistically
opportunity/SM
oppose/DSG
opposed/U
opposite/SMYNX
opposition/M
oppress/DSGV
oppression/M
oppressive/YP
oppressiveness/M
oppressor/MS
opprobrious/Y
opprobrium/M
opt/SGD
optic/MS
optical/Y
optician/SM
optics/M
optima
optimal/Y
optimism/SM
optimist/SM
optimistic
optimistically
optimization/MS
optimize/DRSG
optimum/SM
option/SMDG
optional/Y
optometrist/MS
optometry/M
opulence/M
opulent/Y
opus/MS
or
oracle/SM
oracular
oral/MYS
orange/SMP
orangeade/MS
orangery/SM
orangutan/SM
orate/GNXDS
oration/M
orator/SM
oratorical/Y
oratorio/MS
oratory/SM
orb/SM
orbicular
orbit/MDRZGS
orbital/SM
orbiter/M
orc/SM
orchard/SM
orchestra/MS
orchestral
orchestrate/DSXGN
orchestration/M
orchid/SM
ordain/SDLG
ordainment/M
ordeal/SM
order/EAMDGS
orderings
orderliness/EM
orderly/PSM
ordinal/SM
ordinance/SM
ordinarily
ordinariness/M
ordinary/SMP
ordinate/MNSX
ordination/M
ordnance/M
ordure/M
ore/SM
oregano/M
org
organ/MS
organdy/M
organelle/MS
organic/SM
organically/I
organism/MS
organismic
organist/MS
organization/ASM
organizational/Y
organize/AESDG
organized/U
organizer/MS
organza/M
orgasm/SM
orgasmic
orgiastic
orgy/SM
oriel/MS
orient's
orient/AEDGS
oriental/MS
orientalist/S
orientate/EDSGN
orientation/AEM
orientations
orienteering
orifice/MS
orig
origami/M
origin/SM
original/MYS
originality/M
originate/DSGN
origination/M
originator/SM
oriole/SM
orison/SM
ormolu/M
ornament/SGMD
ornamental
ornamentation/M
ornate/YP
ornateness/M
orneriness/M
ornery/PRT
ornithological
ornithologist/MS
ornithology/M
orotund
orotundity/SM
orphan/SMDG
orphanage/MS
orris/MS
orthodontia/M
orthodontic/S
orthodontics/M
orthodontist/SM
orthodox/U
orthodoxy/SM
orthogonal
orthogonality
orthographic
orthographically
orthography/SM
orthopedic/S
orthopedics/M
orthopedist/MS
orzo/M
oscillate/GNDSX
oscillation/M
oscillator/SM
oscillatory
oscilloscope/MS
osculate/DSXGN
osculation/M
osier/MS
osmium/M
osmosis/M
osmotic
osprey/SM
ossification/M
ossify/NGDS
ostensible
ostensibly
ostentation/M
ostentatious/Y
osteoarthritis/M
osteopath/M
osteopathic
osteopaths
osteopathy/M
osteoporosis/M
ostler/S
ostracism/M
ostracize/GDS
ostrich/MS
other/SP
otherwise
otherworldly
otiose
otter/MS
ottoman/MS
oubliette/MS
ouch
ought
oughtn't
ounce/MS
our/S
ourselves
oust/ZGDRS
ouster/M
out/SJGMDR
outage/SM
outargue/GDS
outback/MS
outbalance/DSG
outbid/S
outbidding
outboard/MS
outboast/DSG
outbound
outbox/MS
outbreak/MS
outbuilding/MS
outburst/SM
outcast/MS
outclass/DSG
outcome/MS
outcrop/MS
outcropped
outcropping/SM
outcry/SM
outdated
outdid
outdistance/GDS
outdo/G
outdoes
outdone
outdoor/S
outdoors/M
outdoorsy
outdraw/GS
outdrawn
outdrew
outermost
outerwear/M
outface/GDS
outfall/S
outfield/SMRZ
outfielder/M
outfight/SG
outfit/SM
outfitted
outfitter/MS
outfitting
outflank/GSD
outflow/MS
outfought
outfox/GDS
outgo/MJG
outgoes
outgrew
outgrow/HGS
outgrown
outgrowth/M
outgrowths
outguess/GDS
outgun/S
outgunned
outgunning
outhit/S
outhitting
outhouse/SM
outing/M
outlaid
outlandish/PY
outlandishness/M
outlast/DSG
outlaw/SGMD
outlay/SGM
outlet/SM
outline/MGDS
outlive/GDS
outlook/MS
outlying
outmaneuver/GDS
outmatch/GDS
outmoded
outnumber/DSG
outpace/GDS
outpatient/MS
outperform/GSD
outplace/L
outplacement/M
outplay/GDS
outpoint/DGS
outpost/MS
outpouring/MS
outproduce/DSG
output/SM
outputted
outputting
outrace/GDS
outrage/MGDS
outrageous/Y
outran
outrank/GDS
outre
outreach/MDSG
outrider/MS
outrigger/SM
outright
outrun/S
outrunning
outscore/GDS
outsell/GS
outset/SM
outshine/GS
outshone
outshout/GDS
outside/MZRS
outsider/M
outsize/MS
outskirt/MS
outsmart/GDS
outsold
outsource/DSG
outsourcing/M
outspend/SG
outspent
outspoken/YP
outspokenness/M
outspread/GS
outstanding/Y
outstation/MS
outstay/DGS
outstretch/DSG
outstrip/S
outstripped
outstripping
outta
outtake/MS
outvote/GDS
outward/YS
outwear/GS
outweigh/GD
outweighs
outwit/S
outwith
outwitted
outwitting
outwore
outwork/MDRSZG
outworn
ouzo/MS
ova
oval/MS
ovarian
ovary/SM
ovate/NX
ovation/M
oven/MS
ovenbird/SM
ovenproof
ovenware
over/MYS
overabundance/M
overabundant
overachieve/ZGDRS
overachiever/M
overact/GVSD
overage/SM
overaggressive
overall/SM
overalls/M
overambitious
overanxious
overarching
overarm/GSD
overate
overattentive
overawe/DSG
overbalance/MGDS
overbear/GS
overbearing/Y
overbid/SM
overbidding
overbite/MS
overblown
overboard
overbold
overbook/DGS
overbore
overborne
overbought
overbuild/SG
overbuilt
overburden/GSD
overbuy/GS
overcame
overcapacity/M
overcapitalize/DSG
overcareful
overcast/MGS
overcautious
overcharge/DSMG
overclock/GD
overcloud/SGD
overcoat/MS
overcome/GS
overcompensate/DSGN
overcompensation/M
overconfidence/M
overconfident
overconscientious
overcook/DGS
overcritical
overcrowd/SDG
overcrowding/M
overdecorate/DSG
overdependent
overdevelop/SDG
overdid
overdo/G
overdoes
overdone
overdose/MGDS
overdraft/SM
overdraw/GS
overdrawn
overdress/GMDS
overdrew
overdrive/SM
overdub/SM
overdubbed
overdubbing
overdue
overeager
overeat/GSN
overemotional
overemphasis/M
overemphasize/GDS
overenthusiastic
overestimate/MGNDS
overestimation/M
overexcite/DSG
overexercise/GDS
overexert/SDG
overexertion/M
overexpose/GDS
overexposure/M
overextend/DGS
overfed
overfeed/GS
overfill/DGS
overflew
overflight/MS
overflow/MDSG
overflown
overfly/GS
overfond
overfull
overgeneralize/DSG
overgenerous
overgraze/DSG
overgrew
overground
overgrow/HSG
overgrown
overgrowth/M
overhand/MDS
overhang/MSG
overhasty
overhaul/MDSG
overhead/MS
overhear/SG
overheard
overheat/DSG
overhung
overindulge/GDS
overindulgence/M
overindulgent
overjoy/GSD
overkill/M
overladen
overlaid
overlain
overland
overlap/SM
overlapped
overlapping
overlarge
overlay/GSM
overleaf
overlie
overload/GMDS
overlong
overlook/GMDS
overlord/MS
overly/SG
overmanned
overmanning
overmaster/SDG
overmodest
overmuch/S
overnice
overnight/MS
overoptimism/M
overoptimistic
overpaid
overparticular
overpass/MS
overpay/GS
overplay/GDS
overpopulate/GNDS
overpopulation/M
overpower/SDG
overpowering/Y
overpraise/DSG
overprecise
overprice/DSG
overprint/SMDG
overproduce/GDS
overproduction/M
overprotect/SDGV
overqualified
overran
overrate/GDS
overreach/GDS
overreact/SDG
overreaction/SM
overrefined
overridden
override/MGS
overripe/M
overrode
overrule/GDS
overrun/SM
overrunning
oversampling
oversaw
oversea/S
oversee/RSZ
overseeing
overseen
overseer/M
oversell/GS
oversensitive/P
oversensitiveness/M
oversexed
overshadow/DSG
overshare/DSG
overshoe/MS
overshoot/GS
overshot
oversight/SM
oversimple
oversimplification/M
oversimplify/DSNGX
oversize
oversleep/GS
overslept
oversold
overspecialization/M
overspecialize/GDS
overspend/SG
overspent
overspread/GS
overstaffed
overstate/DSLG
overstatement/MS
overstay/DSG
overstep/S
overstepped
overstepping
overstimulate/DSG
overstock/GSD
overstretch/GDS
overstrict
overstrung
overstuffed
oversubscribe/DSG
oversubtle
oversupply/GDS
oversuspicious
overt/Y
overtake/GS
overtaken
overtax/GDS
overthink/SG
overthought
overthrew
overthrow/SMG
overthrown
overtime/MS
overtire/GDS
overtone/MS
overtook
overture/MS
overturn/DSG
overuse/DSMG
overvaluation/S
overvalue/DSG
overview/MS
overweening/Y
overweight/M
overwhelm/SGD
overwhelming/Y
overwinter/SDG
overwork/GMDS
overwrite/GS
overwritten
overwrote
overwrought
overzealous
oviduct/SM
oviparous
ovoid/MS
ovular
ovulate/DSGN
ovulation/M
ovule/MS
ovum/M
ow
owe/DSG
owl/SM
owlet/MS
owlish/Y
own/ESGD
owner/MS
ownership/M
ox/MN
oxblood/M
oxbow/MS
oxcart/SM
oxford/SM
oxidant/MS
oxidase
oxidation/M
oxide/MS
oxidization/M
oxidize/ZGDRS
oxidizer/M
oxtail/S
oxyacetylene/M
oxygen/M
oxygenate/DSGN
oxygenation/M
oxymora
oxymoron/M
oyster/SM
oz
ozone/M
p/NRXTGJ
pH
pa/SMH
pablum/M
pabulum/M
pace/MZGDRS
pacemaker/SM
pacer/M
pacesetter/SM
pacey
pachyderm/MS
pachysandra/MS
pacific
pacifically
pacification/M
pacifier/M
pacifism/M
pacifist/SM
pacifistic
pacify/ZGDRSN
pack's
pack/AUGSD
package's
package/AGDS
packager/SM
packaging/M
packer/MS
packet/MS
packing's
packinghouse/SM
packsaddle/MS
pact/MS
pacy/RT
pad/SM
padded
padding/M
paddle/MZGDRS
paddler/M
paddock/MDGS
paddy/SM
padlock/MDSG
padre/SM
paean/SM
paella/MS
pagan/SM
paganism/M
page/MZGDRS
pageant/MS
pageantry/M
pageboy/SM
pager/M
paginate/DSGN
pagination/M
pagoda/MS
pah
paid/AU
pail/MS
pailful/SM
pain/MDSG
painful/PY
painfuller
painfullest
painfulness/M
painkiller/MS
painkilling
painless/PY
painlessness/M
painstaking/MY
paint/SZGJMDR
paintball
paintbox/MS
paintbrush/MS
painted/U
painter/MY
painting/M
paintwork
pair/AMDSG
paired/U
pairing/S
pairwise
paisley/SM
pajama/S
pajamas/M
pal/SMY
palace/MS
paladin/SM
palanquin/SM
palatable/U
palatal/SM
palatalization/M
palatalize/GDS
palate/MBS
palatial/Y
palatinate/MS
palatine/MS
palaver/GSMD
palazzi
palazzo
pale/MYTGPDRSJ
paleface/MS
paleness/M
paleographer/MS
paleography/M
paleolithic
paleontologist/SM
paleontology/M
palette/SM
palfrey/SM
palimony/M
palimpsest/MS
palindrome/MS
palindromic
paling/M
palisade/SM
palish
pall/MDSG
palladium/M
pallbearer/MS
pallet/MS
palliate/DSGNV
palliation/M
palliative/SM
pallid/YP
pallidness/M
pallor/M
palm/MDSG
palmate
palmetto/SM
palmist/SM
palmistry/M
palmtop/SM
palmy/TR
palomino/MS
palpable
palpably
palpate/DSGN
palpation/M
palpitate/XGNDS
palpitation/M
palsy/GDSM
paltriness/M
paltry/RPT
pampas/M
pamper/DSG
pamphlet/MS
pamphleteer/MS
pan/SM
panacea/SM
panache/M
panama/MS
panatella/S
pancake/DSMG
panchromatic
pancreas/MS
pancreatic
pancreatitis
panda/SM
pandemic/SM
pandemonium/M
pander/MDRZGS
panderer/M
pane/KM
panegyric/SM
panel/SGJMD
paneling/M
panelist/MS
panes
pang/MS
panhandle/DRSMZG
panhandler/M
panic/SM
panicked
panicking
panicky
panned
pannier/SM
panning
panoply/SM
panorama/SM
panoramic
panpipes/M
pansy/SM
pant/MDSG
pantaloons/M
pantechnicon/S
pantheism/M
pantheist/SM
pantheistic
pantheon/SM
panther/MS
pantie/MS
panto/S
pantomime/MGDS
pantomimic
pantomimist/SM
pantry/SM
pantsuit/SM
pantyhose/M
pantyliner/M
pantywaist/SM
pap/SM
papa/MS
papacy/SM
papal
paparazzi/M
paparazzo
papaya/MS
paper/SZGMDR
paperback/SM
paperbark/S
paperboard/M
paperboy/SM
paperclip/S
paperer/M
papergirl/SM
paperhanger/SM
paperhanging/M
paperless
paperweight/MS
paperwork/M
papery
papilla/M
papillae
papillary
papist/MS
papoose/MS
pappy/SM
paprika/M
papyri
papyrus/M
par/SZGMDRBJ
para/MS
parable/MS
parabola/SM
parabolic
paracetamol/S
parachute/DSMG
parachutist/MS
parade/MZGDRS
parader/M
paradigm/SM
paradigmatic
paradisaical
paradise/SM
paradox/MS
paradoxical/Y
paraffin/M
paragliding
paragon/MS
paragraph/GMD
paragraphs
parakeet/SM
paralegal/MS
parallax/MS
parallel/SGMD
paralleled/U
parallelism/MS
parallelogram/SM
paralyses
paralysis/M
paralytic/SM
paralyze/DSG
paralyzing/Y
paramecia
paramecium/M
paramedic/MS
paramedical/MS
parameter/MS
parametric
paramilitary/SM
paramount
paramountcy
paramour/SM
paranoia/M
paranoiac/MS
paranoid/SM
paranormal
parapet/MS
paraphernalia/M
paraphrase/DSMG
paraplegia/M
paraplegic/SM
paraprofessional/MS
parapsychologist/MS
parapsychology/M
paraquat/M
parasailing
parascending
parasite/SM
parasitic
parasitical/Y
parasitism/M
parasol/MS
parasympathetic/S
parathion/M
parathyroid/MS
paratroop/RZS
paratrooper/M
paratroops/M
paratyphoid/M
parboil/DSG
parcel/GMDS
parch/LGDS
parchment/SM
pardner/S
pardon/ZGMDRBS
pardonable/U
pardonably/U
pardoner/M
pare/S
paregoric/M
parent/GMDS
parentage/M
parental
parentheses
parenthesis/M
parenthesize/DSG
parenthetic
parenthetical/Y
parenthood/M
parenting/M
parer/M
pares/S
paresis/M
parfait/MS
pariah/M
pariahs
parietal
parimutuel/MS
paring/M
parish/MS
parishioner/MS
parity/ESM
park/MDSG
parka/SM
parking/M
parkland
parkour
parkway/MS
parky
parlance/M
parlay/GMDS
parley/GMDS
parliament/SM
parliamentarian/SM
parliamentary
parlor/MS
parlous
parmigiana
parochial/Y
parochialism/M
parodist/SM
parody/GDSM
parole/MGDS
parolee/MS
parotid
paroxysm/SM
paroxysmal
parquet/MDSG
parquetry/M
parred
parricidal
parricide/MS
parring
parrot/GMDS
parry/GDSM
parse/DRSG
parsec/MS
parsimonious/Y
parsimony/M
parsley/M
parsnip/MS
parson/MS
parsonage/MS
part's
part/CDSG
partake/ZGRS
partaken
partaker/M
parterre/SM
parthenogenesis/M
partial/MYS
partiality/M
participant/SM
participate/DSGN
participation/M
participator/MS
participatory
participial/M
participle/MS
particle/SM
particleboard/M
particular/SMY
particularity/SM
particularization/M
particularize/DSG
particulate/SM
parting/MS
partisan/SM
partisanship/M
partition/GMDS
partitive/MS
partly
partner/MDSG
partnership/MS
partook
partridge/SM
parturition/M
partway
party/GDSM
parvenu/MS
pascal/MS
paschal
pasha/SM
pass/M
passably
passage/MS
passageway/MS
passbook/MS
passe/DRSBXZGNV
passel/MS
passenger/SM
passer/M
passerby/M
passersby
passim
passing/MY
passion/EM
passionate/EY
passionflower/SM
passionless
passive/PMYS
passiveness/M
passivity/M
passivization
passivize/DSG
passkey/MS
passphrase/S
passport/MS
password/MS
past/AMS
pasta/SM
paste/DSMG
pasteboard/M
pastel/MS
pastern/MS
pasteurization/M
pasteurize/ZGDRS
pasteurized/U
pasteurizer/M
pastiche/MS
pastie
pastille/MS
pastime/MS
pastiness/M
pastor/MS
pastoral/MS
pastorate/MS
pastrami/M
pastry/SM
pasturage/M
pasture/DSMG
pastureland/M
pasty/PTRSM
pat/SM
patch/EGMDS
patchily
patchiness/M
patchouli
patchwork/SM
patchy/TPR
pate/MS
patella/MS
patellae
patent/GMDYS
paterfamilias/MS
paternal/Y
paternalism/M
paternalist/S
paternalistic
paternity/M
paternoster/MS
path/M
pathetic
pathetically
pathfinder/SM
pathless
pathogen/SM
pathogenic
pathological/Y
pathologist/SM
pathology/M
pathos/M
paths
pathway/MS
patience/M
patient/IMST
patienter
patiently
patina/MS
patine
patio/SM
patisserie/S
patois/M
patresfamilias
patriarch/M
patriarchal
patriarchate/MS
patriarchs
patriarchy/SM
patrician/SM
patricide/SM
patrimonial
patrimony/SM
patriot/SM
patriotic/U
patriotically
patriotism/M
patrol/MS
patrolled
patrolling
patrolman/M
patrolmen
patrolwoman/M
patrolwomen
patron/MS
patronage/MS
patroness/MS
patronize/ZGDRS
patronizer/M
patronizing/Y
patronymic/SM
patronymically
patroon/SM
patsy/SM
patted
patter/MDGS
pattern/SMDG
patting
patty/SM
paucity/M
paunch/MS
paunchy/RT
pauper/MS
pauperism/M
pauperize/DSG
pause/DSMG
pave/AGDS
paved/U
pavement/MS
pavilion/SM
paving/MS
pavlova/S
paw/SGMD
pawl/MS
pawn/MDSG
pawnbroker/MS
pawnbroking/M
pawnshop/MS
pawpaw/MS
pay's
pay/ASGBL
payback/SM
paycheck/MS
payday/MS
payed
payee/SM
payer/SM
payload/SM
paymaster/SM
payment/ASM
payoff/MS
payola/M
payout/MS
payphone/S
payroll/SM
payslip/SM
paywall/SM
payware
pct
pd
pea/SM
peace/SM
peaceable
peaceably
peaceful/PY
peacefulness/M
peacekeeper/SM
peacekeeping/M
peacemaker/MS
peacemaking/M
peacetime/M
peach/MS
peachy/TR
peacock/MS
peafowl/MS
peahen/MS
peak/MDSG
peaky
peal/AMDSG
peanut/MS
pear/MYS
pearl/SGMD
pearly/RT
peasant/SM
peasantry/M
peashooter/SM
peat/M
peaty/TR
pebble/MGDS
pebbly
pecan/SM
peccadillo/M
peccadilloes
peccary/SM
peck/MDRSZG
peckish
pecs
pectic
pectin/M
pectoral/MS
peculate/GNDS
peculation/M
peculator/SM
peculiar/Y
peculiarity/SM
pecuniary
pedagogic
pedagogical/Y
pedagogue/SM
pedagogy/M
pedal/SGMD
pedalo/S
pedant/MS
pedantic
pedantically
pedantry/M
peddle/ZGDRS
peddler/M
pederast/MS
pederasty/M
pedestal/MS
pedestrian/SM
pedestrianization
pedestrianize/GDS
pediatric/S
pediatrician/MS
pediatrics/M
pedicab/SM
pedicure/MGDS
pedicurist/MS
pedigree/MDS
pediment/MS
pedometer/MS
pedophile/S
pedophilia
peduncle/MS
pee/DRSMZ
peeing
peek/MDSG
peekaboo/M
peel/MDRSJZG
peeled/U
peeler/M
peeling/M
peen/MS
peep/MDRSZG
peepbo
peeper/M
peephole/MS
peepshow/MS
peer/MDG
peerage/SM
peeress/MS
peerless
peeve/DSMG
peevish/PY
peevishness/M
peewee/MS
peewit/S
peg/SM
pegboard/MS
pegged
pegging
peignoir/SM
pejoration/M
pejorative/SMY
peke/MS
pekineses
pekingese/SM
pekoe/M
pelagic
pelf/M
pelican/MS
pellagra/M
pellet/GMDS
pellucid
pelmet/S
pelt/MDSG
pelvic
pelvis/MS
pemmican/M
pen/M
penal
penalization/M
penalize/DSG
penalty/SM
penance/MS
pence
penchant/SM
pencil/GMDJS
pend/CDSG
pendant/MS
pendent/MS
pendulous
pendulum/MS
penetrability/M
penetrable
penetrate/DSGNVX
penetrating/Y
penetration/M
penfriend/S
penguin/MS
penicillin/M
penile
peninsula/SM
peninsular
penis/MS
penitence/M
penitent/SMY
penitential
penitentiary/SM
penknife/M
penknives
penlight/SM
penman/M
penmanship/M
penmen
pennant/MS
penned
penniless
penning
pennon/MS
penny/SM
pennyweight/MS
pennyworth
penologist/MS
penology/M
pension/BZGMDRS
pensioner/M
pensive/PY
pensiveness/M
pent
pentacle/MS
pentagon/MS
pentagonal
pentagram/SM
pentameter/SM
pentathlete/MS
pentathlon/MS
penthouse/SM
penuche/M
penultimate/SM
penumbra/MS
penumbrae
penurious/PY
penuriousness/M
penury/M
peon/MS
peonage/M
peony/SM
people/MGDS
pep/SM
pepped
pepper/GMDS
peppercorn/SM
peppermint/SM
pepperoni/MS
peppery
peppiness/M
pepping
peppy/TPR
pepsin/M
peptic/MS
peptide/S
peradventure/M
perambulate/XGNDS
perambulation/M
perambulator/MS
percale/MS
perceive/BGDS
perceived/U
percent/MS
percentage/SM
percentile/SM
perceptible
perceptibly
perception/SM
perceptional
perceptive/PY
perceptiveness/M
perceptual/Y
perch/GMDS
perchance
percipience/M
percipient
percolate/GNDS
percolation/M
percolator/SM
percussion/AM
percussionist/MS
percussive
perdition/M
perdurable
peregrinate/DSXGN
peregrination/M
peregrine/MS
peremptorily
peremptory
perennial/SMY
perestroika/M
perfect/PTGMDRYS
perfecta/MS
perfectibility/M
perfectible
perfection/SM
perfectionism/M
perfectionist/SM
perfectness/M
perfidious/Y
perfidy/SM
perforate/GNXDS
perforation/M
perforce
perform/SDRZG
performance/SM
performative
performed/U
performer/M
perfume/DRSMZG
perfumer/M
perfumery/SM
perfunctorily
perfunctory
perfusion
pergola/SM
perhaps
pericardia
pericardial
pericarditis
pericardium/M
perigee/SM
perihelia
perihelion/M
peril/SGMD
perilous/Y
perimeter/SM
perinatal
perinea
perineum/M
period/MS
periodic
periodical/SMY
periodicity/M
periodontal
periodontics/M
periodontist/SM
peripatetic/MS
peripheral/MYS
periphery/SM
periphrases
periphrasis/M
periphrastic
periscope/SM
perish/BDRSZG
perishable/MS
peristalses
peristalsis/M
peristaltic
peristyle/SM
peritoneal
peritoneum/MS
peritonitis/M
periwig/SM
periwinkle/SM
perjure/DRSZG
perjurer/M
perjury/SM
perk/MDSG
perkily
perkiness/M
perky/TPR
perm/MDSG
permafrost/M
permanence/M
permanency/M
permanent/SMY
permeability/M
permeable
permeate/GNDS
permeation/M
permissible
permissibly
permission/MS
permissive/PY
permissiveness/M
permit/MS
permitted
permitting
permutation/SM
permute/DSG
pernicious/YP
perniciousness/M
peroration/MS
peroxide/MGDS
perpendicular/SMY
perpendicularity/M
perpetrate/DSGN
perpetration/M
perpetrator/MS
perpetual/SMY
perpetuate/DSGN
perpetuation/M
perpetuity/M
perplex/GDS
perplexed/Y
perplexity/SM
perquisite/SM
persecute/GNXDS
persecution/M
persecutor/SM
perseverance/M
persevere/DSG
persiflage/M
persimmon/SM
persist/SGD
persistence/M
persistent/Y
persnickety
person/UMS
persona/SM
personable
personae
personage/MS
personal/MYS
personality/SM
personalize/CDSG
personalty/M
personification/M
personify/GDSNX
personnel/M
perspective/MS
perspex
perspicacious/Y
perspicacity/M
perspicuity/M
perspicuous
perspiration/M
perspire/GDS
persuade/BZGDRS
persuaded/U
persuader/M
persuasion/SM
persuasive/PY
persuasiveness/M
pert/RYPT
pertain/GSD
pertinacious/Y
pertinacity/M
pertinence/M
pertinent/Y
pertness/M
perturb/DGS
perturbation/SM
perturbed/U
pertussis/M
peruke/MS
perusal/MS
peruse/GDS
perv/S
pervade/DSG
pervasive/PY
pervasiveness/M
perverse/PXYN
perverseness/M
perversion/M
perversity/M
pervert/SGMD
peseta/MS
peskily
peskiness/M
pesky/TPR
peso/MS
pessary/S
pessimal
pessimism/M
pessimist/SM
pessimistic
pessimistically
pest/MRSZ
pester/GD
pesticide/MS
pestiferous
pestilence/SM
pestilent
pestilential
pestle/MGDS
pesto/M
pet/SZMR
petabyte/MS
petal/SMD
petard/MS
petcock/SM
peter/GMD
petiole/SM
petite/MS
petition/ZGMDRS
petitioner/M
petrel/MS
petrifaction/M
petrify/DSG
petrochemical/SM
petrodollar/MS
petrol/M
petrolatum/M
petroleum/M
petrologist/SM
petrology/M
petted
petticoat/MS
pettifog/S
pettifogged
pettifogger/SM
pettifoggery/M
pettifogging
pettily
pettiness/M
petting/M
pettish/Y
petty/PTR
petulance/M
petulant/Y
petunia/MS
pew/SM
pewee/SM
pewit/SM
pewter/MS
peyote/M
pf
pfennig/MS
pg
phaeton/MS
phage/S
phagocyte/SM
phalanger/SM
phalanges
phalanx/MS
phalli
phallic
phallocentric
phallocentrism
phallus/M
phantasm/MS
phantasmagoria/MS
phantasmagorical
phantasmal
phantom/SM
pharaoh/M
pharaohs
pharisaic
pharisee/SM
pharmaceutic/MS
pharmaceutical/SM
pharmaceutics/M
pharmacist/MS
pharmacologic
pharmacological
pharmacologist/SM
pharmacology/M
pharmacopoeia/MS
pharmacy/SM
pharyngeal
pharynges
pharyngitis/M
pharynx/M
phase/DSMG
phaseout/SM
phat
pheasant/MS
phenacetin/M
phenobarbital/M
phenol/M
phenom/MS
phenomena
phenomenal/Y
phenomenological
phenomenology
phenomenon/MS
phenotype
pheromone/MS
phew
phi/SM
phial/SM
philander/ZGDRS
philanderer/M
philandering/M
philanthropic
philanthropically
philanthropist/MS
philanthropy/SM
philatelic
philatelist/MS
philately/M
philharmonic/SM
philippic/MS
philistine/MS
philistinism/M
philodendron/SM
philological
philologist/MS
philology/M
philosopher/MS
philosophic
philosophical/Y
philosophize/DRSZG
philosophizer/M
philosophy/SM
philter/MS
phish/ZGDR
phisher/M
phlebitis/M
phlegm/M
phlegmatic
phlegmatically
phloem/M
phlox/M
phobia/MS
phobic/MS
phoebe/MS
phoenix/MS
phone/DSMG
phonecard/S
phoneme/MS
phonemic
phonemically
phonetic/S
phonetically
phonetician/SM
phonetics/M
phoneyed
phoneying
phonic/S
phonically
phonics/M
phoniness/M
phonograph/M
phonographic
phonographs
phonological/Y
phonologist/MS
phonology/M
phony/PTGDRSM
phooey
phosphate/MS
phosphodiesterase
phosphor/MS
phosphorescence/M
phosphorescent/Y
phosphoric
phosphorous
phosphorus/M
phosphorylation
photo/SGMD
photocell/MS
photocopier/M
photocopy/DRSMZG
photoelectric
photoelectrically
photoengrave/DRSJZG
photoengraver/M
photoengraving/M
photofinishing/M
photogenic
photogenically
photograph/MDRZG
photographer/M
photographic
photographically
photographs/A
photography/M
photojournalism/M
photojournalist/SM
photometer/MS
photon/MS
photosensitive
photostat/SM
photostatic
photostatted
photostatting
photosynthesis/M
photosynthesize/GDS
photosynthetic
phototropic
phototropism
phototypesetter
phototypesetting
phrasal
phrase's
phrase/AGDS
phrasebook/S
phraseology/M
phrasing/MS
phreaking
phrenologist/SM
phrenology/M
phyla
phylactery/SM
phylogeny/M
phylum/M
phys
physic/SM
physical/MYS
physicality
physician/SM
physicist/SM
physicked
physicking
physics/M
physio/S
physiognomy/SM
physiography/M
physiologic
physiological/Y
physiologist/MS
physiology/M
physiotherapist/MS
physiotherapy/M
physique/MS
pi/SMDRHZG
pianissimo/SM
pianist/MS
piano/SM
pianoforte/SM
pianola/S
piaster/MS
piazza/MS
pibroch/M
pibrochs
pic/SM
pica/M
picador/MS
picante
picaresque
picayune
piccalilli/M
piccolo/MS
pick/MDRSJZG
pickax/GMDS
picker/M
pickerel/MS
picket/ZGMDRS
pickings/M
pickle/MGDS
pickpocket/SM
pickup/MS
picky/PTR
picnic/MS
picnicked
picnicker/SM
picnicking
picot/SM
pictograph/M
pictographs
pictorial/MYS
picture/MGDS
picturesque/PY
picturesqueness/M
piddle/MGDS
piddly
pidgin/MS
pie/SM
piebald/MS
piece/DSMG
piecemeal
piecework/MRZ
pieceworker/M
piecrust/SM
pieing
pier/M
pierce/JGDS
piercing/MY
piety/M
piezoelectric
piffle/MG
pig/SML
pigeon/MS
pigeonhole/DSMG
pigged
piggery/S
pigging
piggish/PY
piggishness/M
piggy/TRSM
piggyback/MDSG
pigheaded/PY
pigheadedness/M
piglet/MS
pigment/MDS
pigmentation/M
pigpen/MS
pigskin/MS
pigsty/SM
pigswill
pigtail/MS
pike/MZGDRS
piker/M
pikestaff/SM
pilaf/SM
pilaster/MS
pilchard/MS
pile/MGDSJ
pileup/MS
pilfer/ZGDRS
pilferage/M
pilferer/M
pilgrim/MS
pilgrimage/MS
piling/M
pill/MDSG
pillage/MZGDRS
pillager/M
pillar/MDS
pillbox/MS
pillion/MS
pillock/S
pillory/GDSM
pillow/GMDS
pillowcase/MS
pillowslip/MS
pilot/DGSM
pilothouse/SM
pimento/MS
pimiento/MS
pimp/GMDYS
pimpernel/MS
pimple/DSM
pimply/RT
pin/SM
pinafore/MS
pinata/MS
pinball/M
pincer/MS
pinch/GMDS
pincushion/MS
pine's
pine/AGDS
pineapple/MS
pinewood/S
piney
pinfeather/SM
ping/GMD
pinhead/SM
pinhole/SM
pinier
piniest
pinion/SMDG
pink/TGPMDRS
pinkeye/M
pinkie/SM
pinkish
pinkness/M
pinko/MS
pinnacle/SM
pinnate
pinned/U
pinning/U
pinny/S
pinochle/M
pinon/MS
pinpoint/SGMD
pinprick/MS
pinsetter/SM
pinstripe/DSM
pint/MS
pinto/MS
pinup/MS
pinwheel/GSMD
pinyin/M
pinyon/SM
pioneer/SGMD
pious/YP
piousness/M
pip/SZGMDR
pipe/MS
pipeline/SM
piper/M
pipette/SM
pipework
piping/M
pipit/MS
pipped
pippin/SM
pipping
pipsqueak/SM
piquancy/M
piquant/Y
pique/MGDS
piracy/M
piranha/SM
pirate/DSMG
piratical/Y
pirogi/M
piroshki/M
pirouette/DSMG
piscatorial
pismire/SM
piss/ZGMDRS
pissoir/S
pistachio/SM
piste/S
pistil/SM
pistillate
pistol/SM
piston/SM
pit/SM
pita/MS
pitapat/SM
pitch/MDRSZG
pitchblende/M
pitcher/M
pitchfork/MDSG
pitchman/M
pitchmen
piteous/YP
piteousness/M
pitfall/SM
pith/M
pithead/S
pithily
pithiness/M
pithy/RTP
pitiable
pitiably
pitiful/Y
pitiless/PY
pitilessness/M
piton/MS
pitta/S
pittance/MS
pitted
pitting
pituitary/SM
pity/GDSM
pitying/Y
pivot/MDGS
pivotal
pix/M
pixel/MS
pixie/MS
pizza/MS
pizzazz/M
pizzeria/SM
pizzicati
pizzicato/M
pj's
pk
pkg
pkt
pkwy
pl
placard/SMDG
placate/DSGN
placation/M
placatory
place's
place/AESDLG
placebo/SM
placed/U
placeholder/MS
placekick/MDRZGS
placekicker/M
placement/EASM
placenta/SM
placental/S
placer/SM
placid/Y
placidity/M
placings
placket/SM
plagiarism/SM
plagiarist/SM
plagiarize/DRSZG
plagiarizer/M
plagiary/M
plague/DSMG
plaice
plaid/MS
plain/MRYTSP
plainchant
plainclothes
plainclothesman/M
plainclothesmen
plainness/M
plainsman/M
plainsmen
plainsong/M
plainspoken
plaint/SMV
plaintiff/SM
plaintive/Y
plait/MDGS
plan/ZMRS
planar
plane's
plane/CGDS
planeload/MS
planer/M
planet/SM
planetarium/SM
planetary
plangency/M
plangent
plank/MDGS
planking/M
plankton/M
planned/U
planner/SM
planning/S
plant/MDRZGSJ
plantain/SM
plantar
plantation/MS
planter/M
planting/M
plantlike
plaque/SM
plash/MDSG
plasma/M
plaster/SZGMDR
plasterboard/M
plasterer/M
plastic/SM
plasticity/M
plasticize/DSG
plastique
plat/XGMDNS
plate/MS
plateau/SMDG
plateful/SM
platelet/SM
platen/M
platform/SGMD
plating/M
platinum/M
platitude/SM
platitudinous
platonic
platoon/SGMD
platted
platter/SM
platting
platy/M
platypus/MS
platys
plaudit/SM
plausibility/M
plausible
plausibly
play/AEGMDS
playable/EU
playact/SGD
playacting/M
playback/MS
playbill/MS
playbook/MS
playboy/SM
player/SM
playfellow/SM
playful/PY
playfulness/M
playgirl/MS
playgoer/MS
playground/SM
playgroup/S
playhouse/MS
playlist/MS
playmate/MS
playoff/SM
playpen/SM
playroom/SM
playschool/S
plaything/SM
playtime/M
playwright/SM
plaza/MS
plea/MS
plead/DRZGSJ
pleader/M
pleading/MY
pleasant/UTYP
pleasanter
pleasantness/UM
pleasantry/SM
please/EDSG
pleasing/YS
pleasurably
pleasure/MGDSB
pleasureful
pleat/MDGS
pleb/S
plebby
plebe/MS
plebeian/MS
plebiscite/MS
plectra
plectrum/MS
pledge/DSMG
plenary/SM
plenipotentiary/SM
plenitude/SM
plenteous
plentiful/Y
plenty/M
plenum/S
pleonasm/MS
plethora/M
pleura/M
pleurae
pleurisy/M
plexus/MS
pliability/M
pliable
pliancy/M
pliant/Y
pliers/M
plight/SMDG
plimsoll/S
plinth/M
plinths
plod/S
plodded
plodder/MS
plodding/S
plonk/DRSZG
plop/MS
plopped
plopping
plosive/S
plot/MS
plotted
plotter/SM
plotting
plover/SM
plow/GMDS
plowman/M
plowmen
plowshare/MS
ploy's
ploy/S
pluck/MDSG
pluckily
pluckiness/M
plucky/RPT
plug's
plug/US
plugged/U
plugging/U
plughole/S
plugin/SM
plum/GMDS
plumage/M
plumb/MDRSZGJ
plumbed/U
plumber/M
plumbing/M
plume/MS
plummet/SGMD
plummy
plump/MDRYSTGP
plumpness/M
plumy/RT
plunder/SZGMDR
plunderer/M
plunge/DRSMZG
plunger/M
plunk/MDSG
pluperfect/SM
plural/SM
pluralism/M
pluralist/MS
pluralistic
plurality/SM
pluralization/M
pluralize/GDS
plus/MS
plush/MRYTP
plushness/M
plushy/RT
plutocracy/SM
plutocrat/SM
plutocratic
plutonium/M
pluvial
ply/AGDSM
plywood/M
pm
pneumatic
pneumatically
pneumococcal
pneumococci
pneumococcus
pneumonia/M
poach/DRSZG
poacher/M
poaching/M
pock/GMDS
pocket/SMDG
pocketbook/SM
pocketful/SM
pocketknife/M
pocketknives
pockmark/MDGS
pod/SM
podcast/SMG
podded
podding
podiatrist/SM
podiatry/M
podium/SM
poem/MS
poesy/M
poet/MS
poetaster/MS
poetess/MS
poetic/S
poetical/Y
poetry/M
pogrom/SM
poi/M
poignancy/M
poignant/Y
poinciana/SM
poinsettia/SM
point/MDRSZG
pointblank
pointed/Y
pointer/M
pointillism/M
pointillist/SM
pointless/PY
pointlessness/M
pointy/TR
poise/MGDS
poison/SJZGMDR
poisoner/M
poisoning/M
poisonous/Y
poke/MZGDRS
poker/M
pokey/MS
poky/TR
pol/SGMD
polar
polarity/SM
polarization/CM
polarize/CDSG
pole/MS
poleaxe/GDS
polecat/MS
polemic/MS
polemical/Y
polemicist/SM
polemics/M
polestar/SM
police/DSMG
policeman/M
policemen
policewoman/M
policewomen
policy/SM
policyholder/MS
policymaker/S
polio/MS
poliomyelitis/M
polish/ZGMDRS
polished/U
polisher/M
politburo/MS
polite/RYTP
politeness/M
politesse/M
politic/S
political/Y
politician/SM
politicization/M
politicize/CDSG
politicking/M
politico/SM
politics/M
polity/SM
polka/MDSG
poll/GMDNS
pollack/MS
pollard/S
pollen/M
pollinate/GNDS
pollination/M
pollinator/SM
polling/M
polliwog/SM
pollster/SM
pollutant/MS
pollute/ZGNDRS
polluted/U
polluter/M
pollution/M
polo/M
polonaise/SM
polonium/M
poltergeist/MS
poltroon/SM
poly
polyacrylamide
polyamory/S
polyandrous
polyandry/M
polyclinic/SM
polyester/MS
polyethylene/M
polygamist/MS
polygamous
polygamy/M
polyglot/SM
polygon/SM
polygonal
polygraph/GMD
polygraphs
polyhedral
polyhedron/SM
polymath/M
polymaths
polymer/SM
polymeric
polymerization/M
polymerize/GDS
polymorphic
polymorphous
polynomial/MS
polyp/MS
polyphonic
polyphony/M
polypropylene/M
polys
polysemous
polystyrene/M
polysyllabic
polysyllable/MS
polytechnic/MS
polytheism/M
polytheist/SM
polytheistic
polythene
polyunsaturate/DS
polyurethane/MS
polyvinyl
pom/S
pomade/DSMG
pomander/SM
pomegranate/MS
pommel/SGMD
pommy/S
pomp/M
pompadour/SMD
pompano/MS
pompom/SM
pomposity/M
pompous/YP
pompousness/M
ponce/GDS
poncho/SM
poncy
pond/MS
ponder/SZGDR
ponderer/M
ponderous/YP
ponderousness/M
pone/MS
pong/GDS
pongee/M
poniard/MS
pontiff/SM
pontifical/Y
pontificate/DSMG
pontoon/SM
pony/GDSM
ponytail/MS
poo/SGD
pooch/MDSG
poodle/SM
poof/MS
poofter/S
pooh/GMD
poohs
pool/GMDS
poolroom/MS
poolside/S
poop/GMDS
poor/TRYP
poorboy/M
poorhouse/SM
poorness/M
pop/SM
popcorn/M
pope/MS
popgun/SM
popinjay/MS
poplar/SM
poplin/M
popover/SM
poppa/MS
poppadom/S
popped
popper/SM
poppet/S
popping
poppy/SM
poppycock/M
populace/MS
popular/Y
popularity/UM
popularization/M
popularize/DSG
populate/ACGDS
population/CM
populations
populism/M
populist/MS
populous/P
populousness/M
popup/MS
porcelain/SM
porch/MS
porcine
porcupine/SM
pore/MGDS
porgy/SM
pork/ZMR
porker/M
porky/RSMT
porn/M
porno/M
pornographer/MS
pornographic
pornographically
pornography/M
porosity/M
porous/P
porousness/M
porphyritic
porphyry/M
porpoise/MGDS
porridge/M
porringer/SM
port's/A
port/CAEGDS
portability/M
portable/MS
portage/DSMG
portal/SM
portcullis/MS
portend/SGD
portent/SM
portentous/YP
porter/ASM
porterhouse/SM
portfolio/MS
porthole/MS
portico/M
porticoes
portiere/MS
portion/KSGMD
portliness/M
portly/RPT
portmanteau/MS
portrait/MS
portraitist/SM
portraiture/M
portray/SGD
portrayal/MS
portulaca/M
pose's/A
pose/CAKEGDS
poser/EKSM
poseur/SM
posh/TR
posit/DSGV
position/CKEMS
positional/K
positioned/K
positioning/K
positive/MYPS
positiveness/M
positivism
positivist/S
positron/MS
poss
posse/MS
possess/AEVGSD
possession/ASM
possessive/SMYP
possessiveness/M
possessor/SM
possibility/SM
possible/SM
possibly
possum/SM
post/ZGMDRSJ
postage/M
postal
postbag/S
postbox/S
postcard/SM
postcode/S
postcolonial
postconsonantal
postdate/DSG
postdoc/MS
postdoctoral
poster/M
posterior/SM
posterity/M
postgraduate/SM
posthaste
posthumous/Y
posthypnotic
postie/S
postilion/SM
postindustrial
posting/M
postlude/SM
postman/M
postmark/SMDG
postmaster/MS
postmen
postmenopausal
postmeridian
postmistress/MS
postmodern
postmodernism/M
postmodernist/MS
postmortem/SM
postnasal
postnatal
postoperative
postpaid
postpartum
postpone/DSGL
postponement/SM
postprandial
postscript/SM
postseason/SM
postsynaptic
postulate/XDSMGN
postulation/M
postural
posture/MGJDS
posturing/M
postwar
postwoman
postwomen
posy/SM
pot/CSM
potability/M
potable/SM
potash/M
potassium/M
potato/M
potatoes
potbelly/DSM
potboiler/SM
potency/M
potent/Y
potentate/MS
potential/MYS
potentiality/SM
potentiate/GDS
potful/SM
pothead/SM
pother/SMDG
potherb/SM
potholder/MS
pothole/DRSMZG
pothook/SM
potion/SM
potluck/MS
potpie/SM
potpourri/SM
potsherd/SM
potshot/MS
pottage/M
potted
potter/GSMD
pottery/SM
potting
potty/PRSMT
pouch/MDSG
pouf/S
pouffe/S
poulterer/MS
poultice/DSMG
poultry/M
pounce/DSMG
pound's
pound/KDSG
poundage/M
pounding/SM
pour/GDSJ
pout/ZGMDRS
pouter/M
poverty/M
pow
powder/GSMD
powdery
power/MDSG
powerboat/MS
powerful/Y
powerhouse/SM
powerless/PY
powerlessness/M
powwow/SGMD
pox/MS
pp
ppm
ppr
pr
practicability/M
practicably
practical/SMY
practicality/SM
practice/DSMGB
practiced/U
practicum/SM
practitioner/SM
praetor/SM
praetorian
pragmatic/MS
pragmatical/Y
pragmatism/M
pragmatist/MS
prairie/SM
praise/EDSMG
praiseworthiness/M
praiseworthy/P
praline/SM
pram/MS
prance/DRSMZG
prancer/M
prancing/Y
prang/DSG
prank/MS
prankster/SM
praseodymium/M
prat/S
prate/MZGDRS
prater/M
pratfall/SM
prattle/DRSMZG
prattler/M
prawn/MDSG
pray/ZGDRS
prayer/M
prayerful/Y
preach/DRSZGL
preacher/M
preachment/M
preachy/RT
preadolescence/SM
preamble/MGDS
prearrange/LGDS
prearrangement/M
preassigned
precancel/SMDG
precancerous
precarious/PY
precariousness/M
precast
precaution/MS
precautionary
precede/DSG
precedence/M
precedent/SM
precept/SM
preceptor/SM
precinct/MS
preciosity/M
precious/YP
preciousness/M
precipice/SM
precipitant/MS
precipitate/XMYGNDS
precipitation/M
precipitous/Y
precis/M
precise/DRSYTGNP
preciseness/M
precision/M
preclude/GDS
preclusion/M
precocious/YP
precociousness/M
precocity/M
precognition/M
precognitive
precolonial
preconceive/GDS
preconception/SM
precondition/MDGS
precook/GSD
precursor/SM
precursory
predate/DSG
predator/MS
predatory
predawn
predecease/GDS
predecessor/SM
predefined
predesignate/GDS
predestination/M
predestine/DSG
predetermination/M
predetermine/ZGDRS
predeterminer/M
predicable
predicament/MS
predicate/MGNVDS
predication/M
predicative/Y
predict/BGVSD
predictability/UM
predictable/U
predictably/U
prediction/SM
predictor/MS
predigest/GDS
predilection/SM
predispose/GDS
predisposition/MS
predominance/M
predominant/Y
predominate/YGDS
preemie/SM
preeminence/M
preeminent/Y
preempt/GVSD
preemption/M
preemptive/Y
preen/DSG
preexist/DGS
preexistence/M
pref
prefab/SM
prefabbed
prefabbing
prefabricate/DSGN
prefabrication/M
preface/DSMG
prefatory
prefect/SM
prefecture/MS
prefer/SBL
preferably
preference/MS
preferential/Y
preferment/M
preferred
preferring
prefigure/GDS
prefix/MDSG
preform/GSD
prefrontal
pregame/SM
pregnancy/SM
pregnant
preheat/GSD
prehensile
prehistorian/S
prehistoric
prehistorical/Y
prehistory/M
prehuman
prejudge/GDS
prejudgment/SM
prejudice/MGDS
prejudiced/U
prejudicial
prekindergarten/SM
prelacy/M
prelate/SM
prelim/SM
preliminary/SM
preliterate
prelude/MS
premarital
premature/Y
premed/SM
premedical
premeditate/DSGN
premeditated/U
premeditation/M
premenstrual
premier/SGMD
premiere/MS
premiership/MS
premise/DSMG
premium/SM
premix/GDS
premolar/SM
premonition/MS
premonitory
prenatal/Y
prenup/SM
prenuptial
preoccupation/SM
preoccupy/DSG
preoperative
preordain/GDS
prep/MS
prepackage/DSG
prepacked
prepaid
preparation/SM
preparatory
prepare/GDS
prepared/UP
preparedness/UM
prepay/GSL
prepayment/MS
preponderance/SM
preponderant/Y
preponderate/GDS
preposition/SM
prepositional/Y
prepossess/GDS
prepossessing/U
prepossession/SM
preposterous/Y
prepped
prepping
preppy/TRSM
prepubescence/M
prepubescent/SM
prepuce/MS
prequel/MS
prerecord/GSD
preregister/SGD
preregistration/M
prerequisite/MS
prerogative/SM
pres
presage/MGDS
presbyopia/M
presbyter/SM
presbytery/SM
preschool/SZMR
preschooler/M
prescience/M
prescient/Y
prescribe/DSG
prescript/SVM
prescription/SM
prescriptive/Y
preseason/SM
presence/SM
present/LMDRYZGSB
presentably
presentation/ASM
presenter/M
presentiment/SM
presentment/SM
preservation/M
preservationist/SM
preservative/SM
preserve/BDRSMZG
preserver/M
preset/S
presetting
preshrank
preshrink/GS
preshrunk
preside/GDS
presidency/SM
president/MS
presidential
presidium/M
presort/DGS
press's
press/ACGSD
pressed/U
presser/MS
pressie/S
pressing/SMY
pressman/M
pressmen
pressure/DSMG
pressurization/M
pressurize/CGDS
pressurizer/SM
prestidigitation/M
prestige/M
prestigious
presto/SM
presumably
presume/GDSB
presumption/SM
presumptive
presumptuous/YP
presumptuousness/M
presuppose/DSG
presupposition/MS
pretax
preteen/MS
pretend/DRZGS
pretender/M
pretense/SXMN
pretension/M
pretentious/UY
pretentiousness/M
preterit/SM
preterm
preternatural/Y
pretest/DGS
pretext/MS
pretrial/S
prettify/GDS
prettily
prettiness/M
pretty/TGDRSMP
pretzel/MS
prevail/DGS
prevalence/M
prevalent
prevaricate/DSGNX
prevarication/M
prevaricator/SM
prevent/DBSGV
preventable/U
preventative/MS
prevention/M
preventive/SM
preview/MDRSZG
previous/Y
prevision/MS
prewar
prey/GMDS
prezzie/S
priapic
price's
price/AGDS
priceless
pricey
pricier
priciest
prick/MDRYSZG
pricker/M
prickle/MGDS
prickliness/M
prickly/PRT
pride/MGDS
prideful/Y
prier/M
priest/SMY
priestess/MS
priesthood/SM
priestliness/M
priestly/RTP
prig/MS
priggish/P
priggishness/M
prim/ZGDRYP
primacy/M
primal
primarily
primary/SM
primate/MS
prime/MS
primer/M
primeval
priming/M
primitive/SPMY
primitiveness/M
primmer
primmest
primness/M
primogenitor/SM
primogeniture/M
primordial/Y
primp/DSG
primrose/SM
primula/S
prince/SMY
princedom/SM
princeliness/M
princely/PRT
princess/MS
principal/SMY
principality/SM
principle/DSM
principled/U
print/AMDSG
printable/U
printer/MS
printing/SM
printmaking
printout/SM
prion/S
prior/MS
prioress/MS
prioritization
prioritize/DSG
priority/SM
priory/SM
prism/MS
prismatic
prison/SZMR
prisoner/M
prissily
prissiness/M
prissy/PTR
pristine
prithee
privacy/M
private/XMYTNRS
privateer/SM
privation/CSM
privatization/SM
privatize/DSG
privet/SM
privilege/DSMG
privileged/U
privily
privy/RSMT
prize/MGDS
prized/A
prizefight/ZGSMR
prizefighter/M
prizefighting/M
prizewinner/MS
prizewinning
pro/SM
probabilistic
probability/SM
probable/SM
probably
probate/MN
probation/ZMR
probational
probationary
probationer/M
probe/MGDSBJ
probity/M
problem/MS
problematic
problematical/Y
probosces
proboscis/MS
procaine/M
procedural
procedure/SM
proceed/GJDS
proceeding/M
proceeds/M
process's
process/AGDS
processed/U
procession/GD
processional/MS
processor/SM
proclamation/MS
proclivity/SM
procrastinate/DSGN
procrastination/M
procrastinator/MS
procreate/V
proctor/GMDS
procurement/M
prod/MS
prodigal/MYS
prodigality/M
prodigious/Y
prodigy/SM
produce's
produce/AZGDRS
producer/AM
producible/A
production/ASM
productive/UY
productiveness/M
productivity/M
prof/MS
profanation/MS
profane/PYGDS
profaneness/M
profanity/SM
professed/Y
profession/SM
professional/MYS
professionalism/M
professionalization
professionalize/DSG
professor/SM
professorial/Y
professorship/SM
proffer/GMDS
proficiency/M
proficient/MYS
profit/BGD
profitability/M
profitable/U
profitably/U
profiteer/MDGS
profiteering/M
profiterole/SM
profitless
profligacy/M
profligate/SMY
proforma
profound/RYTP
profoundness/M
profundity/SM
profuse/PY
profuseness/M
progenitor/SM
progeny/M
progesterone/M
progestin/S
prognathous
prognoses
prognosis/M
prognostic/MS
prognosticate/XGNDS
prognostication/M
prognosticator/MS
program/CAS
programmable/MS
programmatic
programmed/AC
programmer/MS
programming/SM
progress/MDSGV
progression/MS
progressive/PMYS
progressiveness/M
prohibit/DGVS
prohibition/SM
prohibitionist/MS
prohibitive/Y
prohibitory
project/GMDS
projectile/SM
projection/SM
projectionist/SM
projector/MS
prokaryotic
prole/S
proletarian/MS
proletariat/M
proliferate/DSGN
proliferation/M
prolific
prolifically
prolix/Y
prolixity/M
prologue/SM
prolongation/SM
prom/M
promenade/MGDS
promethium/M
prominence/M
prominent/Y
promiscuity/M
promiscuous/Y
promise/DSMG
promising/Y
promissory
promo/M
promontory/SM
promote/DRZG
promoter/M
promotional
prompt/JPSMDRYZTG
prompted/U
prompter/M
prompting/M
promptitude/M
promptness/M
promulgate/GNDS
promulgation/M
promulgator/MS
prone/P
proneness/M
prong/MDS
pronghorn/MS
pronominal/M
pronounce/DSLG
pronounceable/U
pronouncement/SM
pronto
pronunciation/MS
proof/ADGSM
proofread/SRZG
proofreader/M
prop/MS
propaganda/M
propagandist/MS
propagandize/GDS
propagate/DSGN
propagation/M
propagator/SM
propel/S
propellant/MS
propelled
propeller/SM
propelling
propensity/SM
proper/MRYT
property/DSM
prophecy/SM
prophesier/M
prophesy/DRSMZG
prophet/SM
prophetess/MS
prophetic
prophetical/Y
prophylactic/SM
prophylaxes
prophylaxis/M
propinquity/M
propitiate/DSGN
propitiation/M
propitiatory
propitious/Y
proponent/SM
proportion/ESM
proportional/YS
proportionality
proportionate/EY
proposal/MS
propped
propping
proprietary/SM
proprieties/M
proprietor/SM
proprietorial/Y
proprietorship/M
proprietress/MS
propriety/SM
propulsion/M
propulsive
prorate/DSG
prorogation/M
prorogue/GD
prosaic
prosaically
proscenium/SM
prosciutto/M
proscribe/DG
proscription/MS
prose/M
prosecute/DSXGN
prosecution/M
prosecutor/MS
proselyte/DSMG
proselytism/M
proselytize/DRSZG
proselytizer/M
prosody/SM
prospect/MDGVS
prospective/Y
prospector/SM
prospectus/MS
prosper/GSD
prosperity/M
prosperous/Y
prostate/MS
prostheses
prosthesis/M
prosthetic
prostitute/MGNDS
prostitution/M
prostrate/GNXDS
prostration/M
prosy/RT
protactinium/M
protagonist/SM
protean
protect/GVSD
protected/U
protection/SM
protectionism/M
protectionist/MS
protective/PY
protectiveness/M
protector/MS
protectorate/MS
protege/SM
protegee/S
protein/SM
protestant/S
protestation/MS
protocol/MS
proton/SM
protoplasm/M
protoplasmic
prototype/MGS
prototypical
protozoa
protozoan/MS
protozoic
protract/GD
protrude/GDS
protrusile
protrusion/MS
protuberance/MS
protuberant
proud/RYT
prov/NB
provability/M
provably
prove/EAGDS
proved/U
proven/U
provenance/SM
provender/M
provenience/M
proverbial/Y
provide/DRSZG
provided/U
providence/M
provident/Y
providential/Y
provider/M
province/MS
provincial/SMY
provincialism/M
provisional/Y
proviso/SM
provocateur/S
provocative/PY
provocativeness/M
provoke/DRSZG
provoked/U
provoker/M
provoking/Y
provolone/M
provost/SM
prow/MS
prowess/M
prowl/MDRSZG
prowler/M
proximal
proximate
proximity/M
proxy/SM
prude/MS
prudence/M
prudent/Y
prudential/Y
prudery/M
prudish/YP
prudishness/M
prune/MZGDRS
pruner/M
prurience/M
prurient/Y
pry/ZTGDRSM
psalm/MS
psalmist/SM
psaltery/SM
psephologist/S
psephology
pseud/S
pseudo/S
pseudonym/SM
pseudonymous
pseudoscience/MS
pseudy
pshaw/MS
psi/SM
psittacosis/M
psoriasis/M
psst
psych/MDSG
psyche/M
psychedelia
psychedelic/SM
psychedelically
psychiatric
psychiatrist/SM
psychiatry/M
psychic/MS
psychical/Y
psycho/SM
psychoactive
psychoanalyses
psychoanalysis/M
psychoanalyst/SM
psychoanalytic
psychoanalytical/Y
psychoanalyze/DSG
psychobabble/M
psychodrama/MS
psychogenic
psychokinesis
psychokinetic
psychological/Y
psychologist/MS
psychology/SM
psychometric
psychoneuroses
psychoneurosis/M
psychopath/M
psychopathic
psychopathology
psychopaths
psychopathy/M
psychopharmacology
psychos/S
psychosis/M
psychosomatic
psychotherapist/MS
psychotherapy/SM
psychotic/SM
psychotically
psychotropic/MS
psychs
pt/C
ptarmigan/MS
pterodactyl/MS
ptomaine/SM
pub/SM
pubertal
puberty/M
pubes/M
pubescence/M
pubescent
pubic
pubis/M
public/AM
publican/AMS
publication/ASM
publicist/MS
publicity/M
publicize/GDS
publicly
publish/AGDS
publishable
published/U
publisher/MS
publishing/M
puce/M
puck/ZMRS
pucker/MDG
puckish/YP
puckishness/M
pud/S
pudding/SM
puddle/DSMG
puddling/M
pudenda
pudendum/M
pudginess/M
pudgy/PRT
pueblo/SM
puerile
puerility/M
puerperal
puff/ZGMDRS
puffball/SM
puffer/M
puffin/SM
puffiness/M
puffy/PRT
pug/SM
pugilism/M
pugilist/SM
pugilistic
pugnacious/YP
pugnaciousness/M
pugnacity/M
puke/MGDS
pukka
pulchritude/M
pulchritudinous
pule/GDS
pull/ZGMDRS
pullback/MS
puller/M
pullet/SM
pulley/SM
pullout/MS
pullover/SM
pulmonary
pulp/GMDS
pulpiness/M
pulpit/SM
pulpwood/M
pulpy/RPT
pulsar/SM
pulsate/XGNDS
pulsation/M
pulse/AMGDS
pulverization/M
pulverize/DSG
puma/MS
pumice/SM
pummel/SGD
pump/ZGMDRS
pumper/M
pumpernickel/M
pumpkin/MS
pun/SM
punch/MDRSZG
punchbag/S
puncheon/MS
puncher/M
punchline/S
punchy/TR
punctilio/M
punctilious/PY
punctiliousness/M
punctual/Y
punctuality/M
punctuate/GNDS
punctuation/M
puncture/DSMG
pundit/SM
punditry/M
pungency/M
pungent/Y
puniness/M
punish/BLGDS
punished/U
punishing/Y
punishment/MS
punitive/Y
punk/TMRS
punned
punnet/S
punning
punster/SM
punt/ZGMDRS
punter/M
puny/TRP
pup/SM
pupa/M
pupae
pupal
pupate/DSG
pupil/MS
pupped
puppet/MS
puppeteer/SM
puppetry/M
pupping
puppy/SM
purblind
purchase/DRSMZGB
purchaser/M
purdah/M
pure/PYTR
purebred/SM
puree/MDS
pureeing
pureness/M
purgative/SM
purgatorial
purgatory/SM
purge/MZGDRS
purger/M
purification/M
purifier/M
purify/NDRSZG
purine/MS
purism/M
purist/MS
puristic
puritan/SM
puritanical/Y
puritanism/M
purity/M
purl/GMDS
purlieu/SM
purloin/SGD
purple/MTRS
purplish
purport/SMDG
purported/Y
purpose/DSMYG
purposeful/YP
purposefulness/M
purposeless/PY
purr/GMDS
purse/MZGDRS
purser/M
pursuance/M
pursuant
pursue/ZGDRS
pursuer/M
pursuit/SM
purulence/M
purulent
purvey/DSG
purveyance/M
purveyor/SM
purview/M
pus/M
push/ZGMDRS
pushbike/S
pushcart/SM
pushchair/S
pusher/M
pushily
pushiness/M
pushover/MS
pushpin/S
pushy/TRP
pusillanimity/M
pusillanimous/Y
puss/MS
pussy/TRSM
pussycat/MS
pussyfoot/DSG
pustular
pustule/SM
put/ISM
putative
putout/MS
putrefaction/M
putrefactive
putrefy/GDS
putrescence/M
putrescent
putrid
putsch/MS
putt/ZGMDRS
putted/I
puttee/MS
putter/MDRZG
putterer/M
putting/I
putty/GDSM
putz/S
puzzle/MZGDRSL
puzzlement/M
puzzler/M
pvt
pwn/SGD
pyelonephritis
pygmy/SM
pylon/SM
pylori
pyloric
pylorus/M
pyorrhea/M
pyramid/GSMD
pyramidal
pyre/MS
pyrimidine/MS
pyrite/SM
pyrites/M
pyromania/M
pyromaniac/SM
pyrotechnic/S
pyrotechnical
pyrotechnics/M
pyruvate
python/SM
pyx/MS
pzazz
q
qr
qt/S
qty
qua
quack/GMDS
quackery/M
quad/MS
quadrangle/SM
quadrangular
quadrant/MS
quadraphonic
quadratic/MS
quadrature
quadrennial
quadrennium/MS
quadriceps/MS
quadrilateral/SM
quadrille/XMNS
quadrillion/M
quadriplegia/M
quadriplegic/SM
quadrivium/M
quadruped/MS
quadrupedal
quadruple/MGDS
quadruplet/MS
quadruplicate/MGNDS
quadruplication/M
quaff/GMDS
quagmire/SM
quahog/MS
quail/GMDS
quaint/PRYT
quaintness/M
quake/MGDS
quaky
qualification/EM
qualified/U
qualifier/SM
qualify/EGXNDS
qualitative/Y
quality/SM
qualm/MS
qualmish
quandary/SM
quango/S
quanta
quantifiable
quantification/M
quantifier/M
quantify/NDRSZG
quantitative/Y
quantity/SM
quantum/M
quarantine/MGDS
quark/MS
quarrel/SZGMDR
quarreler/M
quarrelsome/P
quarrelsomeness/M
quarry/DSMG
quart/MS
quarter/SGMDY
quarterback/GMDS
quarterdeck/MS
quarterfinal/SM
quarterly/SM
quartermaster/MS
quarterstaff/M
quarterstaves
quartet/SM
quarto/MS
quartz/M
quasar/MS
quash/GDS
quasi
quatrain/MS
quaver/MDSG
quavery
quay/MS
quayside/S
queasily
queasiness/M
queasy/TPR
queen/GMDYS
queenly/RT
queer/PTGMDRYS
queerness/M
quell/GDS
quench/ZGDRSB
quenchable/U
quencher/M
quenchless
querulous/YP
querulousness/M
query/DSMG
ques
quesadilla/MS
quest/IFAMS
quested
questing
question/SMDRZGBJ
questionable/U
questionably/U
questioned/U
questioner/M
questioning/MY
questionnaire/SM
queue/MDSG
quibble/DRSMZG
quibbler/M
quiche/SM
quick/MNRYXTP
quicken/DG
quickfire
quickie/SM
quicklime/M
quickness/M
quicksand/MS
quicksilver/M
quickstep/MS
quid/MS
quiescence/M
quiescent/Y
quiet/SMDNRYXTGP
quieten/DG
quietism
quietness/M
quietude/IEM
quietus/MS
quiff/S
quill/SM
quilt/SMDRZG
quilter/M
quilting/M
quin/S
quince/SM
quine/S
quinine/M
quinoa
quinsy/M
quint/SM
quintessence/SM
quintessential/Y
quintet/SM
quintuple/MGDS
quintuplet/MS
quip/MS
quipped
quipping
quipster/SM
quire's
quire/IAS
quirk/SMDG
quirkiness/M
quirky/RTP
quirt/SM
quisling/SM
quit/S
quitclaim/MS
quite
quittance/M
quitter/SM
quitting
quiver/SMDG
quivery
quixotic
quixotically
quiz/M
quizzed
quizzer/SM
quizzes
quizzical/Y
quizzing
quo/H
quoin/SM
quoit/SMDG
quondam
quorate/I
quorum/SM
quot/B
quota/SM
quotability/M
quotation/SM
quote's
quote/UDSG
quotidian
quotient/SM
qwerty
r/S
rabbet/GMDS
rabbi/SM
rabbinate/M
rabbinic
rabbinical
rabbit/GMDS
rabble/MS
rabid/PY
rabidness/M
rabies/M
raccoon/M
race/MZGDRS
racecourse/SM
racegoer/S
racehorse/MS
raceme/MS
racer/M
racetrack/MS
raceway/MS
racial/Y
racialism/M
racialist/MS
racily
raciness/M
racing/M
racism/M
racist/SM
rack/GMDS
racket/SMDG
racketeer/SMDG
racketeering/M
raconteur/SM
racquetball/SM
racy/PRT
rad/SM
radar/SM
radarscope/SM
raddled
radial/SMY
radiance/M
radiant/Y
radiate/DSGNX
radiation/M
radiator/SM
radical/SMY
radicalism/M
radicalization/M
radicalize/DSG
radicchio/M
radii
radio/MDGS
radioactive/Y
radioactivity/M
radiocarbon/M
radiogram/MS
radiographer/SM
radiography/M
radioisotope/MS
radiologist/SM
radiology/M
radioman/M
radiomen
radiometer/MS
radiometric
radiometry/M
radiophone/SM
radioscopy/M
radiosonde/SM
radiosurgery
radiotelegraph/M
radiotelegraphs
radiotelegraphy/M
radiotelephone/MS
radiotherapist/MS
radiotherapy/M
radish/MS
radium/M
radius/M
radon/M
raffia/M
raffish/YP
raffishness/M
raffle/DSMG
raft/ZGMDRS
rafter/M
rafting/M
rag/SGMD
raga/MS
ragamuffin/MS
ragbag/M
rage/MS
ragga
ragged/RYTP
raggedness/M
raggedy/RT
ragging
raging/Y
raglan/SM
ragout/SM
ragtag/S
ragtime/M
ragweed/M
ragwort
rah
raid/ZGMDRS
raider/M
rail's
rail/CGDS
railcard/S
railing/SM
raillery/SM
railroad/SZGMDR
railroader/M
railroading/M
railway/SM
railwayman
railwaymen
raiment/M
rain/GMDS
rainbow/SM
raincoat/SM
raindrop/SM
rainfall/SM
rainmaker/SM
rainmaking/M
rainproof
rainstorm/MS
rainwater/M
rainy/RT
raise/MZGDRS
raiser/M
raisin/SM
rajah/M
rajahs
rake/MGDS
rakish/YP
rakishness/M
rally/DSMG
ram/SM
ramble/DRSMZGJ
rambler/M
rambunctious/PY
rambunctiousness/M
ramekin/SM
ramie/M
ramification/M
ramify/DSXNG
ramjet/SM
rammed
ramming
ramp/GMS
rampage/DSMG
rampancy/M
rampant/Y
rampart/SM
ramrod/SM
ramrodded
ramrodding
ramshackle
ran/A
ranch/MDRSZG
rancher/M
ranching/M
rancid/P
rancidity/M
rancidness/M
rancor/M
rancorous/Y
rand/M
randiness/M
random/PSY
randomization/M
randomize/DSG
randomness/MS
randy/RTP
ranee/MS
rang/ZR
range's
range/CGDS
rangefinder/S
ranger/M
ranginess/M
rangy/RTP
rank/TGJPMDRYS
ranking/M
rankle/DSG
rankness/M
ransack/SGD
ransom/SZGMDR
ransomer/M
ransomware
rant/ZGMDJRS
ranter/M
rap/SZGMDR
rapacious/PY
rapaciousness/M
rapacity/M
rape/MS
raper/M
rapeseed/M
rapid/PMRYTS
rapidity/M
rapidness/M
rapier/SM
rapine/M
rapist/SM
rapped
rappel/SM
rappelled
rappelling
rapper/SM
rapping
rapport/MS
rapporteur/S
rapprochement/SM
rapscallion/MS
rapt/YP
raptness/M
raptor/S
rapture/MS
rapturous/Y
rare/YTGPDRS
rarebit/MS
rarefaction/M
rarefy/GDS
rareness/M
rarity/SM
rascal/SMY
rash/ZTMRSYP
rasher/M
rashness/M
rasp/GMDS
raspberry/SM
raspy/RT
raster
rat/SM
ratatouille/M
ratbag/S
ratchet/GMDS
rate/JXMZGNDRS
rated/U
ratepayer/S
rater/M
rather
rathskeller/SM
ratification/M
ratifier/M
ratify/NDRSZG
rating/M
ratio/MS
ratiocinate/GNDS
ratiocination/M
ration/MDG
rational/SMY
rationale/MS
rationalism/M
rationalist/SM
rationalistic
rationality/M
rationalization/MS
rationalize/DSG
ratlike
ratline/SM
rattan/SM
ratted
ratter/SM
ratting
rattle/DRSMZGJ
rattlebrain/SMD
rattler/M
rattlesnake/SM
rattletrap/SM
rattly
rattrap/SM
ratty/RT
raucous/YP
raucousness/M
raunchily
raunchiness/M
raunchy/TRP
ravage/DRSMZG
ravager/M
ravages/M
rave/JMZGDRS
ravel's
ravel/UDSG
raveling/S
raven/MDSG
ravenous/Y
ravine/SM
raving/M
ravioli/SM
ravish/DRSZGL
ravisher/M
ravishing/Y
ravishment/M
raw/PTMR
rawboned
rawhide/M
rawness/M
ray/SM
rayon/M
raze/GDS
razor/MS
razorback/MS
razz/GMDS
razzmatazz/M
rcpt
rd
re/DSMYTGVJ
reach/MDSGB
reachable/U
reacquire/DSG
react/V
reactant/SM
reactionary/SM
reactivity
read/ZGMRBJS
readability/SM
reader/M
readership/SM
readily
readiness/M
reading/M
readmitted
readout/SM
ready/DRSTGP
reafforestation
real/TMRYPS
realism/M
realist/SM
realistic/U
realistically/U
realities
reality/UM
realization/MS
realize/DSBG
realized/U
realm/MS
realness/M
realpolitik/M
realty/M
ream/ZGMDRS
reamer/M
reap/ZGDRS
reaper/M
rear/GMDS
rearguard/MS
rearmost
rearward/S
reason/SMDRZGB
reasonable/UP
reasonableness/UM
reasonably/U
reasoner/M
reasoning/M
reassuring/Y
rebate/M
rebel/MS
rebellion/MS
rebellious/YP
rebelliousness/M
rebid/S
rebidding
rebirth/M
reboil/SDG
rebuild/SG
rebuke/DSMG
rebuking/Y
rebuttal/MS
rec'd
rec/M
recalcitrance/M
recalcitrant
recant/SDG
recantation/SM
recap/MS
recapitalization
recce/S
recd
receipt/SMDG
receivables/M
receive/DRSZGB
receiver/M
receivership/M
recent/RYTP
recentness/M
receptacle/SM
reception/MS
receptionist/SM
receptive/PY
receptiveness/M
receptivity/M
receptor/SM
recess/MDSGV
recessional/SM
recessionary
recessive/SM
recherche
recidivism/M
recidivist/SM
recipe/SM
recipient/SM
reciprocal/SMY
reciprocate/GNDS
reciprocation/M
reciprocity/M
recital/SM
recitalist/MS
recitative/MS
reciter/SM
reckless/YP
recklessness/M
reckon/SJDG
reckoning/M
reclamation/M
recline/DRSZG
recliner/M
recluse/SMV
recognizable/U
recognizably
recognize/DRSGB
recognized/U
recombination
recompense/DSMG
recompilation
recompile/GD
recon/S
reconcile/GDSB
reconciliation/S
recondite
reconfiguration
reconfigure/D
reconnaissance/MS
reconnoiter/DGS
reconstruct/V
reconstructed/U
recorded/U
recorder/MS
recording/MS
recoup/DG
recourse/M
recoverable/U
recovery/SM
recreant/MS
recreational
recriminate/DSGNX
recrimination/M
recriminatory
recrudesce/GDS
recrudescence/M
recrudescent
recruit/LSMDRZG
recruiter/M
recruitment/M
rectal/Y
rectangle/MS
rectangular
rectifiable
rectification/M
rectifier/M
rectify/XNDRSZG
rectilinear
rectitude/M
recto/MS
rector/SM
rectory/SM
rectum/SM
recumbent
recuperate/GNVDS
recuperation/M
recur/S
recurred
recurrence/SM
recurring
recursion/S
recuse
recyclable/SM
recycling/M
red/PSM
redact/SDG
redaction/M
redactor/SM
redbird/SM
redbreast/MS
redbrick
redcap/SM
redcoat/SM
redcurrant/S
redden/SDG
redder
reddest
reddish
redeem/RZB
redeemer/M
redemption/M
redemptive
redhead/SMD
redirection
redistrict/GD
redivide/GDS
redlining/M
redneck/SM
redness/M
redo/G
redolence/M
redolent
redoubt/SBM
redoubtably
redound/SDG
redraw/SG
redskin/SM
reduce/DRSZG
reducer/M
reducible
reductase
reduction/SM
reductionist
reductive
redundancy/SM
redundant/Y
redwood/SM
redye/DS
reediness/M
reedy/RTP
reef/ZGMDRS
reefer/M
reek/GMDS
reel's
reel/UGDS
reeve/G
reexport/SDG
ref/SZM
refashion/DGS
refection/M
refectory/SM
refer/B
referee/DSM
refereeing
reference/MGDS
referendum/MS
referent/SM
referential
referral/SM
referred
referrer/SM
referring
reffed
reffing
refill/BM
refined/U
refinement/SM
refiner/SM
refinery/S
refitting
reflate/XDSGN
reflationary
reflect/GVSD
reflection/MS
reflective/Y
reflector/MS
reflexive/SMY
reflexology
reforge/DSG
reform/MZ
reformat/V
reformatory/SM
reformatting
reformed/U
reformist/S
refortify/GDS
refract/SGVD
refraction/M
refractory/SM
refrain/SGMD
refresh/ZGLDRS
refresher/M
refreshing/Y
refreshment/SM
refreshments/M
refrigerant/SM
refrigerate/DSGN
refrigeration/M
refrigerator/MS
refuge/SM
refugee/SM
refulgence/M
refulgent
refund/B
refurbishment/MS
refusal/MS
refutation/MS
refute/BDRSZG
refuter/M
reg
regal/DYG
regalement/M
regalia/M
regard/ESMDG
regardless
regards/M
regather/DGS
regatta/SM
regency/SM
regeneracy/M
regenerate/V
regex/M
regexp/S
reggae/M
regicide/MS
regime/SM
regimen/SM
regiment/MDGS
regimental
regimentation/M
region/SM
regional/Y
regionalism/MS
register/GMDS
registered/U
registrant/MS
registrar/MS
registration/SM
registry/SM
regnant
regress/MDSGV
regression/MS
regret/SM
regretful/Y
regrettable
regrettably
regretted
regretting
regrind/GS
reground
regroup/DGS
regular/MYS
regularity/SM
regularization/M
regularize/DSG
regulate/CDSGNV
regulated/U
regulation/CM
regulations
regulator/MS
regulatory
regurgitate/DSGN
regurgitation/M
rehab/MS
rehabbed
rehabbing
rehabilitate/GNVDS
rehabilitation/M
rehang/SDG
rehears/GD
rehearsal/MS
rehearsed/U
rehi
rehung
reign/MDSG
reimburse/BDSGL
reimbursement/MS
rein/GD
reindeer/M
reinforce/LGDS
reinforcement/SM
reinitialize
reinstall/DG
reinstatement/M
reinsurance
reiterate/V
reject/GSMD
rejection/SM
rejoice/JGDS
rejoicing/M
rejoinder/SM
rejuvenate/DSGN
rejuvenation/M
rel
relate/DRSXZGNV
relatedness/M
relater/M
relation/M
relational
relationship/MS
relative/MYS
relativism/M
relativist/S
relativistic
relativity/M
relax/DRSZG
relaxant/MS
relaxation/SM
relaxer/M
relay/D
release/B
released/U
relegate/GNDS
relent/SGD
relentless/PY
relentlessness/M
relevance/M
relevancy/M
relevant/Y
reliability/UM
reliable/U
reliably/U
reliance/M
reliant
relic/MS
relief/SM
relieve/ZGDRS
reliever/M
religion/SM
religiosity
religious/MYP
religiousness/M
reline/DSG
relinquish/LDSG
relinquishment/M
reliquary/SM
relish/GMDS
relist/SGD
relocate/B
reluctance/M
reluctant/Y
rely/GDS
rem/M
remain/SGD
remainder/GMDS
remand/SGD
remapping
remark/B
remarkableness/M
remarkably
remarked/U
remediable
remedy/GDSM
remember/DG
remembered/U
remembrance/MS
reminder/M
reminisce/GDS
reminiscence/MS
reminiscent/Y
remiss/PY
remissness/M
remit/S
remittance/SM
remitted
remitting/U
remix/DSG
remnant/MS
remodel/GDS
remold/SGD
remonstrant/SM
remonstrate/DSG
remorse/M
remorseful/Y
remorseless/PY
remorselessness/M
remote/RSMYTP
remoteness/M
removal/SM
remunerate/GNVXDS
remuneration/M
renaissance/MS
renal
renascence/S
rend/GS
render/SGMDJ
rendering/M
rendezvous/GMDS
rendition/MS
renegade/DSMG
renege/DRSZG
reneger/M
renew/DSBG
renewal/MS
rennet/M
rennin/M
renounce/LDSG
renouncement/M
renovate/DSXGN
renovation/M
renovator/MS
renown/MD
rent/ZGMDRS
rental/SM
renter/M
renunciation/SM
reopen/SDG
reorg/MDSG
rep/SM
repaint/GDS
repair/BZR
repairer/M
repairman/M
repairmen
reparable
reparation/MS
reparations/M
repartee/M
repatriate/XDSMGN
repatriation/M
repeat/SMDRZGB
repeatable/U
repeatably
repeated/Y
repeater/M
repeating/M
repel/S
repelled
repellent/SM
repelling
repent/SDG
repentance/M
repentant/Y
repercussion/S
repertoire/MS
repertory/SM
repetition/MS
repetitious/YP
repetitiousness/M
repetitive/YP
repetitiveness/M
rephotograph/DG
replaceable
replant/GSD
replenish/LGDS
replenishment/M
replete/PDSGN
repleteness/M
repletion/M
replica/SM
replicate/DSGNX
replication/M
replicator/S
reportage/M
reported/Y
reportorial
reposeful
repository/SM
reprehend/DGS
reprehensibility/M
reprehensible
reprehensibly
reprehension/M
represent/GDS
representational
representative/MS
represented/U
repression/MS
repressive/PY
reprieve/DSMG
reprimand/GSMD
reprisal/SM
reprise/SMG
reproach/GMDSB
reproachful/Y
reprobate/MS
reproductive
reprogramming
reproving/Y
reptile/SM
reptilian/MS
republic/S
republicanism/M
repudiate/XGNDS
repudiation/M
repudiator/MS
repugnance/M
repugnant
repulsion/M
repulsive/YP
repulsiveness/M
repurchase/GDS
reputability/M
reputably/E
reputation/MS
repute/DSMGB
reputed/Y
request/GDR
requiem/SM
require/LDG
requirement/MS
requisite/XMNS
requisition/GMD
requital/M
requite/DRSZG
requited/U
requiter/M
reread/SG
rerecord/GDS
rerunning
resat
rescind/SDG
rescission/M
rescue/DRSMZG
rescuer/M
reseal/B
resell/SG
resemble/DSG
resend
resent/LSDG
resentful/YP
resentfulness/M
resentment/MS
reserpine/M
reservation/MS
reserved/UY
reservedness/M
reservist/SM
reservoir/SM
resetting
reshipping
residence/SM
residency/SM
resident/MS
residential
residua
residual/MS
residue/SM
residuum/M
resignation/SM
resigned/Y
resilience/M
resiliency/M
resilient/Y
resinous
resist/SMDRZG
resistance/SM
resistant/U
resistible
resistless
resistor/MS
resit/S
resitting
resold
resole/DSG
resolute/PY
resoluteness/M
resolve/RBM
resolved/U
resonance/SM
resonant/Y
resonate/GDS
resonator/SM
resorption/M
resound/SGD
resounding/Y
resourceful/YP
resourcefulness/M
resp
respect/ESGVMD
respectability/M
respectable
respectably
respectful/EY
respectfulness/M
respective/Y
respell/SGD
respiration/M
respirator/SM
respiratory
respire/DG
resplendence/M
resplendent/Y
respond/SGD
respondent/SM
response/MS
responsibility/SM
responsible
responsibly
responsive/UYP
responsiveness/UM
rest/GVMDS
restate/GDS
restaurant/SM
restaurateur/MS
restful/YP
restfuller
restfullest
restfulness/M
restitution/M
restive/YP
restiveness/M
restless/PY
restlessness/M
restoration/SM
restorative/SM
restorer/SM
restrained/U
restraint/MS
restrict/SDGV
restricted/U
restriction/MS
restrictive/YP
restrictiveness/M
restring/SG
restroom/SM
restructuring/SM
result/GSMD
resultant/SM
resume/DSMG
resumption/MS
resupply/DSG
resurgence/MS
resurgent
resurrect/GSD
resurrection/MS
resuscitate/GNDS
resuscitation/M
resuscitator/SM
retailer/MS
retain/SDRZG
retainer/M
retake/G
retaliate/DSGNVX
retaliation/M
retaliatory
retard/SMDRZG
retardant/SM
retardation/M
retarder/M
retch/DSG
reteach/GS
retention/M
retentive/YP
retentiveness/M
rethink/SGM
rethought
reticence/M
reticent/Y
reticulated
reticulation/MS
retina/SM
retinal
retinue/SM
retiree/SM
retirement/MS
retort/GMD
retrace/GDS
retract/DBG
retractile
retraction/S
retrain/DGS
retread/D
retrenchment/MS
retribution/MS
retributive
retrieval/SM
retrieve/DRSMZGB
retriever/M
retro/MS
retroactive/Y
retrofire/GDS
retrofit/SM
retrofitted
retrofitting
retrograde/DSG
retrogress/GVDS
retrogression/M
retrorocket/MS
retrospect/MDSGV
retrospection/M
retrospective/MYS
retrovirus/MS
retsina/M
returnable/SM
returnee/SM
rev/ZVM
revamping/M
reveal/GJSD
revealed/U
revealing/Y
reveille/M
revel/JMDRSZG
revelation/SM
reveler/M
revelry/SM
revenge/MGDS
revenuer/SM
reverb
reverberate/DSGNX
reverberation/M
revere/DSG
reverence/DSMG
reverend/SM
reverent/Y
reverential/Y
reverie/MS
revers/M
reversal/SM
reverse/Y
reversibility
reversible
reversibly
revert/GSD
revertible
revetment/SM
revile/DRSLZG
revilement/M
reviler/M
reviser/MS
revision/SM
revisionism/M
revisionist/SM
revival/MS
revivalism/M
revivalist/SM
revive/DSG
revivification/M
revocable
revoke/DSG
revolt/GD
revolting/Y
revolution/SM
revolutionary/SM
revolutionist/SM
revolutionize/DSG
revolve/BZGDRS
revolver/M
revue/MS
revulsion/M
revved
revving
rewarded/U
rewarding/U
rewarm/GSD
rewash/GDS
reweave/GS
rewedding
rewind/MB
rewound
rewrite/MGS
rhapsodic
rhapsodical
rhapsodize/GDS
rhapsody/SM
rhea/MS
rhenium/M
rheostat/SM
rhesus/MS
rhetoric/M
rhetorical/Y
rhetorician/SM
rheum/M
rheumatic/MS
rheumatically
rheumatism/M
rheumatoid
rheumy
rhinestone/SM
rhinitis/M
rhino/MS
rhinoceros/MS
rhinoplasty
rhinovirus/MS
rhizome/MS
rho/SM
rhodium/M
rhododendron/SM
rhomboid/SM
rhomboidal
rhombus/MS
rhubarb/MS
rhyme/MZGDRS
rhymer/M
rhymester/MS
rhythm/SM
rhythmic
rhythmical/Y
rial/MS
rib/SM
ribald
ribaldry/M
ribbed
ribber/SM
ribbing
ribbon/SM
riboflavin/M
rice/MZGDRS
ricer/M
rich/TMRSYP
richness/M
rick/GMDS
rickets/M
rickety/RT
rickrack/M
rickshaw/MS
ricochet/GMDS
ricotta/M
rid/S
riddance/M
ridden
ridding
riddle/DSMG
ride/MZGRS
rider/M
riderless
ridership/M
ridge/MGDS
ridgepole/SM
ridgy
ridicule/MGDS
ridiculous/YP
ridiculousness/M
riding/M
rife/TR
riff/GMDS
riffle/DSMG
riffraff/M
rifle/MZGDRS
rifleman/M
riflemen
rifler/M
rifling/M
rift/GMDS
rig/SM
rigatoni/M
rigged
rigger/SM
rigging/M
right/MDRYSPTG
righteous/UP
righteously
righteousness/UM
rightful/PY
rightfulness/M
rightism/M
rightist/SM
rightmost
rightness/M
righto
rightsize/DSG
rightward/S
rigid/YP
rigidity/M
rigidness/M
rigmarole/MS
rigor/MS
rigorous/YP
rigorousness/M
rile/GDS
rill/MS
rim/SGMD
rime/MS
rimless
rimmed
rimming
rind/MS
ring/ZGMDRJ
ringer/M
ringgit/MS
ringleader/MS
ringlet/MS
ringlike
ringmaster/MS
ringside/M
ringtone/SM
ringworm/M
rink/MS
rinse/MGDS
riot/ZGMDRS
rioter/M
rioting/M
riotous/PY
rip/SXTMNR
riparian
ripcord/MS
ripe/YP
ripen/DG
ripened/U
ripeness/M
ripoff/SM
riposte/MGDS
ripped
ripper/SM
ripping
ripple/DSMG
ripply
ripsaw/SM
riptide/MS
rise/JMZGRS
risen
riser/M
risibility/M
risible
rising/M
risk/GMDS
riskily
riskiness/M
risky/RPT
risotto/MS
risque
rissole/S
rite/MS
ritual/SMY
ritualism/M
ritualistic
ritualistically
ritualized
ritzy/RT
riv/ZNR
rival/MDSG
rivaled/U
rivalry/SM
rive/CGDS
river/M
riverbank/SM
riverbed/MS
riverboat/SM
riverfront
riverside/MS
rivet/MDRSZG
riveter/M
riviera/S
rivulet/MS
riyal/MS
rm
roach/GMDS
road/IMS
roadbed/SM
roadblock/MDSG
roadhouse/SM
roadie/MS
roadkill/M
roadrunner/SM
roadshow/SM
roadside/SM
roadster/SM
roadway/SM
roadwork/SM
roadworthy
roam/ZGDRS
roamer/M
roaming/M
roan/MS
roar/ZGMDRS
roarer/M
roaring/M
roast/ZGMDRSJ
roaster/M
roasting/M
rob/S
robbed
robber/MS
robbery/SM
robbing
robe's
robe/EGDS
robin/MS
robocall/SGMD
robot/MS
robotic/S
robotics/M
robotize/GDS
robust/RYPT
robustness/M
rock/ZGMDRS
rockabilly/M
rockbound
rocker/M
rockery/S
rocket/MDSG
rocketry/M
rockfall/SM
rockiness/M
rocky/TRP
rococo/M
rod/SM
rode
rodent/MS
rodeo/MS
roe/SM
roebuck/SM
roentgen/MS
roger/GDS
rogue's
rogue/KS
roguery/M
roguish/YP
roguishness/M
roil/GDS
roister/ZGDRS
roisterer/M
role/MS
roll/MDRZGJS
rollback/SM
roller/M
rollerblading
rollerskating/M
rollick/SDG
rollicking/M
rollmop/S
rollover/SM
romaine/MS
roman/M
romance/MZGDRS
romancer/M
romantic/MS
romantically
romanticism/M
romanticist/SM
romanticize/DSG
romeo/MS
romp/MDRZGS
romper/M
rondo/SM
rood/MS
roof/MDRZGS
roofer/M
roofing/M
roofless
rooftop/SM
rook/MDGS
rookery/SM
rookie/SM
room/MDRZGS
roomer/M
roomette/SM
roomful/SM
roominess/M
roommate/SM
roomy/RTP
roost/SMDRZG
rooster/M
root/MDRZGS
rooter/M
rootkit/SM
rootless/P
rootlet/SM
rope/MZGDRS
roper/M
ropy/RT
rosary/SM
rose/MS
roseate
rosebud/SM
rosebush/MS
rosemary/M
rosette/SM
rosewater/M
rosewood/MS
rosily
rosin/SMDG
rosiness/M
roster/SM
rostrum/MS
rosy/RTP
rot/SM
rota/S
rotary/SM
rotate/DSGNX
rotation/M
rotational
rotatory
rote/M
rotgut/M
rotisserie/SM
rotogravure/MS
rotor/SM
rototiller/MS
rotted
rotten/TPRY
rottenness/M
rotter/S
rotting
rottweiler/S
rotund/P
rotunda/MS
rotundity/M
rotundness/M
roue/MS
rouge/DSMG
rough/MDNRYXTGP
roughage/M
roughcast
roughen/GD
roughhouse/MGDS
roughneck/GMDS
roughness/M
roughs
roughshod
roulette/M
round/PSMDRYZTG
roundabout/SM
roundel/S
roundelay/MS
roundhouse/SM
roundish
roundness/M
roundup/MS
roundworm/SM
rouse/DSG
roust/SDG
roustabout/SM
rout/MRZS
route's
route/ADSG
routeing
router/M
routine/MYS
routinize/GDS
roux
rove/ZGDRS
rover/M
row/SZGMDR
rowan/S
rowboat/MS
rowdily
rowdiness/M
rowdy/PRSMT
rowdyism/M
rowel/SMDG
rower/M
rowing/M
rowlock/S
royal/SMY
royalist/SM
royalties/M
royalty/SM
rpm
rps
rt
rte
rub/SM
rubato/SM
rubbed
rubber/SM
rubberize/GDS
rubberneck/MDRSZG
rubbernecker/M
rubbery
rubbing/S
rubbish/MDSG
rubbishy
rubble/M
rubdown/SM
rube/MS
rubella/M
rubicund
rubidium/M
ruble/SM
rubric/SM
ruby/RSMT
ruched
ruck/DGS
rucksack/MS
ruckus/MS
ructions
rudder/SM
rudderless
ruddiness/M
ruddy/RTP
rude/YTRP
rudeness/M
rudiment/SM
rudimentary
rue/DSMG
rueful/PY
ruefulness/M
ruff/MDYGS
ruffian/MYS
ruffle/DSMG
ruffled/U
rug/SM
rugby/M
rugged/PTRY
ruggedness/M
rugger
rugrat/SM
ruin/MDGS
ruination/M
ruinous/Y
rule/MZGJDRS
ruler/M
ruling/M
rum/SM
rumba/SMDG
rumble/DSJMG
rumbling/M
rumbustious
ruminant/MS
ruminate/XGNVDS
rumination/M
ruminative/Y
rummage/DSMG
rummer
rummest
rummy/M
rumor/SMDG
rumormonger/SM
rump/MYS
rumple/DSMG
rumpus/MS
run/ASM
runabout/MS
runaround/SM
runaway/MS
rundown/SM
rune/MS
rung/MS
runic
runlet/SM
runnel/SM
runner/SM
running/M
runny/RT
runoff/SM
runt/MS
runty/RT
runway/SM
rupee/SM
rupiah/M
rupiahs
rupture/MGDS
rural
ruse/MS
rush/MDRSZG
rusher/M
rushy
rusk/MS
russet/SM
rust/MDGS
rustic/SM
rustically
rusticate/GDS
rustication/M
rusticity/M
rustiness/M
rustle/DRSJMZG
rustler/M
rustproof/SDG
rusty/RPNT
rut/SM
rutabaga/SM
ruthenium/M
rutherfordium/M
ruthless/YP
ruthlessness/M
rutted
rutting
rutty/RT
rye/M
s/NYXB
sabbath/M
sabbaths
sabbatical/SM
saber/MS
sable/MS
sabot/MS
sabotage/DSMG
saboteur/SM
sabra/MS
sac/SM
saccharin/M
saccharine
sacerdotal
sachem/SM
sachet/SM
sack/ZGMDRJS
sackcloth/M
sacker/M
sackful/MS
sacking/M
sacra
sacrament/MS
sacramental
sacred/YP
sacredness/M
sacrifice/DSMG
sacrificial/Y
sacrilege/MS
sacrilegious/Y
sacristan/MS
sacristy/SM
sacroiliac/MS
sacrosanct/P
sacrosanctness/M
sacrum/M
sad/PY
sadden/SDG
sadder
saddest
saddle's
saddle/UDSG
saddlebag/MS
saddler/S
saddlery
sades
sadhu/S
sadism/M
sadist/SM
sadistic
sadistically
sadness/M
sadomasochism/M
sadomasochist/MS
sadomasochistic
safari/SGMD
safe/MYTPRS
safeguard/SMDG
safekeeping/M
safeness/M
safety/SM
safflower/MS
saffron/MS
sag/SM
saga/MS
sagacious/Y
sagacity/M
sage/MYTRS
sagebrush/M
sagged
sagging
saggy/RT
sago/M
saguaro/MS
sahib/MS
said/U
sail/GMDSJ
sailboard/MRZGS
sailboarder/M
sailboarding/M
sailboat/MS
sailcloth/M
sailfish/MS
sailing/M
sailor/SM
sailplane/MS
saint/MDYS
sainthood/M
saintlike
saintliness/M
saintly/PRT
saith
sake/M
salaam/SMDG
salable/U
salacious/PY
salaciousness/M
salacity/M
salad/MS
salamander/SM
salami/SM
salary/DSM
sale/ABMS
saleroom/S
salesclerk/SM
salesgirl/SM
saleslady/SM
salesman/M
salesmanship/M
salesmen
salespeople/M
salesperson/MS
salesroom/S
saleswoman/M
saleswomen
salience/M
salient/SMY
saline/SM
salinity/M
saliva/M
salivary
salivate/GNDS
salivation/M
sallow/RTP
sallowness/M
sally/DSMG
salmon/SM
salmonella/M
salmonellae
salon/MS
saloon/SM
salsa/MS
salt's
salt/CTGDS
saltbox/MS
saltcellar/SM
salted/U
salter
saltine/SM
saltiness/M
saltpeter/M
saltshaker/SM
saltwater/M
salty/RTP
salubrious/I
salutary
salutation/MS
salutatorian/MS
salutatory
salute/DSMG
salvage/DSMG
salvageable
salvation/M
salve/MZGDRS
salver/M
salvo/MS
samarium/M
samba/MDSG
same/SP
sameness/M
samey
samizdat/S
samosa/S
samovar/SM
sampan/SM
sample/DRSMZGJ
sampler/M
sampling/M
samurai/SM
sanatorium/SM
sanctification/M
sanctify/GDSN
sanctimonious/YP
sanctimoniousness/M
sanctimony/M
sanction/GSMD
sanctioned/U
sanctity/M
sanctuary/SM
sanctum/SM
sand/ZGMDRS
sandal/SM
sandalwood/M
sandbag/SM
sandbagged
sandbagger/SM
sandbagging
sandbank/MS
sandbar/SM
sandblast/ZGMDRS
sandblaster/M
sandbox/MS
sandcastle/MS
sander/M
sandhog/SM
sandiness/M
sandlot/SM
sandlotter/MS
sandman/M
sandmen
sandpaper/GMDS
sandpiper/MS
sandpit/S
sandstone/M
sandstorm/SM
sandwich/MDSG
sandy/RTP
sane/IYTR
saneness/M
sang/S
sangfroid/M
sangria/M
sanguinary
sanguine/Y
sanitarian/SM
sanitarium/SM
sanitary/IU
sanitation/M
sanitize/GDS
sanity/IM
sank
sans
sanserif
sap/SM
sapience/M
sapiens
sapient
sapless
sapling/MS
sapped
sapper/S
sapphire/SM
sappiness/M
sapping
sappy/PRT
saprophyte/SM
saprophytic
sapsucker/SM
sapwood/M
saran/M
sarcasm/MS
sarcastic
sarcastically
sarcoma/MS
sarcophagi
sarcophagus/M
sardine/MS
sardonic
sardonically
sarge/MS
sari/MS
sarky
sarnie/S
sarong/SM
sarsaparilla/MS
sartorial/Y
sash/MS
sashay/SGMD
sass/GMDS
sassafras/MS
sassy/RT
sat
satanic
satanical/Y
satanism/M
satanist/MS
satay
satchel/MS
sate/GDS
sateen/M
satellite/DSMG
satiable/I
satiate/GNDS
satiation/M
satiety/M
satin/M
satinwood/SM
satiny
satire/SM
satiric
satirical/Y
satirist/SM
satirize/DSG
satisfaction/EM
satisfactions
satisfactorily/U
satisfactory/U
satisfied/U
satisfy/EDSG
satisfying/U
satisfyingly
satori/M
satrap/SM
satsuma/S
saturate/DSGN
saturated/U
saturation/M
saturnine
satyr/MS
satyriasis/M
satyric
sauce/MZGDRS
saucepan/SM
saucer/M
saucily
sauciness/M
saucy/RPT
sauerkraut/M
sauna/MDSG
saunter/MDGS
saurian
sauropod/SM
sausage/MS
saute/MS
sauteed
sauteing
savage/DRSMYTGP
savageness/M
savagery/SM
savanna/MS
savant/SM
save/BJMZGDRS
saved/U
saver/M
saving/M
savings/M
savior/SM
savor/MDSG
savoriness/M
savory/PTRSM
savoy/MS
savvy/DRSMTG
saw/SGMD
sawbones/M
sawbuck/MS
sawdust/M
sawfly/SM
sawhorse/SM
sawmill/MS
sawyer/SM
sax/MS
saxifrage/SM
saxophone/MS
saxophonist/SM
say's
say/USG
saying/SM
scab/MS
scabbard/MS
scabbed
scabbiness/M
scabbing
scabby/PTR
scabies/M
scabrous
scad/MS
scaffold/SMG
scaffolding/M
scag/S
scagged
scalar/S
scalawag/MS
scald/MDSG
scale's
scale/CGDS
scaleless
scalene
scaliness/M
scallion/MS
scallop/GSMD
scalp/MDRSZG
scalpel/SM
scalper/M
scaly/RTP
scam/MS
scammed
scammer/S
scamming
scamp/MRSZ
scamper/GMD
scampi/M
scan/MS
scandal/SM
scandalize/DSG
scandalmonger/SM
scandalous/Y
scandium/M
scanned
scanner/SM
scanning
scansion/M
scant/CDSTG
scanter
scantily
scantiness/M
scantly
scantness/M
scanty/RSPT
scapegoat/SGMD
scapegrace/MS
scapula/M
scapulae
scapular/SM
scar/GMDS
scarab/SM
scarce/RYTP
scarceness/M
scarcity/SM
scare/MS
scarecrow/MS
scaremonger/SMG
scarf/MDSG
scarification/M
scarify/NDSG
scarily
scariness/M
scarlatina/M
scarlet/M
scarp/MDRSZG
scarper/DG
scarred
scarring
scarves
scary/RTP
scat/MS
scathing/Y
scatological
scatology/M
scatted
scatter/GJSMD
scatterbrain/SMD
scattering/M
scattershot
scatting
scatty
scavenge/ZGDRS
scavenger/M
scenario/MS
scenarist/MS
scene/MS
scenery/M
scenic
scenically
scent/CMS
scented/U
scenting
scentless
scepter/MS
sch
schadenfreude
schedule's
schedule/ADSG
scheduled/U
scheduler/S
schema
schemata
schematic/SM
schematically
schematize/GDS
scheme/DRSMZG
schemer/M
scherzo/MS
schilling/MS
schism/SM
schismatic/SM
schist/M
schizo/SM
schizoid/MS
schizophrenia/M
schizophrenic/SM
schlemiel/SM
schlep/SM
schlepped
schlepping
schlock/M
schmaltz/M
schmaltzy/TR
schmo/M
schmoes
schmooze/DRSZG
schmuck/MS
schnapps/M
schnauzer/SM
schnitzel/SM
schnook/MS
schnoz/MS
schnozzle/SM
scholar/MYS
scholarship/MS
scholastic
scholastically
scholasticism
school/SGMD
schoolbag/MS
schoolbook/SM
schoolboy/MS
schoolchild/M
schoolchildren/M
schooldays
schooled/U
schoolfellow/SM
schoolgirl/SM
schoolhouse/SM
schooling/M
schoolkid/S
schoolmarm/SM
schoolmarmish
schoolmaster/MS
schoolmate/SM
schoolmistress/MS
schoolroom/SM
schoolteacher/MS
schoolwork/M
schoolyard/SM
schooner/SM
schuss/GMDS
schussboomer/MS
schwa/MS
sci
sciatic
sciatica/M
science/FMS
scientific/U
scientifically/U
scientist/SM
scimitar/SM
scintilla/MS
scintillate/DSGN
scintillation/M
scion/MS
scissor/GDS
scleroses
sclerosis/M
sclerotic
scoff/MDRSZG
scoffer/M
scofflaw/MS
scold/MDSGJ
scolding/M
scoliosis/M
sconce/SM
scone/MS
scoop/MDSG
scoopful/MS
scoot/DRSZG
scooter/M
scope/MGDS
scorbutic
scorch/MDRSZG
scorcher/M
score/MZGDRS
scoreboard/SM
scorecard/MS
scorekeeper/MS
scoreless
scoreline/S
scorer/M
scorn/MDRSZG
scorner/M
scornful/Y
scorpion/MS
scotch/MDSG
scotchs
scoundrel/MS
scour/DRSZG
scourer/M
scourge/DSMG
scout/MDRSZG
scouting/M
scoutmaster/MS
scow/MS
scowl/MDSG
scrabble/MZGDRS
scrabbler/M
scrag/MS
scraggly/RT
scraggy/TR
scram/S
scramble's
scramble/UGDS
scrambler/MS
scrammed
scramming
scrap/MDRSZGJ
scrapbook/SM
scrape/SM
scraper/M
scrapheap/SM
scrapie
scrapped
scrapper/MS
scrapping
scrappy/TR
scrapyard/SM
scratch/GMDS
scratchcard/S
scratched/U
scratchily
scratchiness/M
scratchpad/S
scratchy/PRT
scrawl/SMDG
scrawly
scrawniness/M
scrawny/PTR
scream/SMDRZG
screamer/M
screaming/Y
scree/MDS
screech/GMDS
screechy/TR
screed/S
screen/SJMDG
screening/M
screenplay/SM
screensaver
screenshot/S
screenwriter/SM
screenwriting/M
screw's
screw/UDSG
screwball/MS
screwdriver/MS
screwiness/M
screwworm/SM
screwy/PRT
scribal
scribble/MZGDRS
scribbler/M
scribe's
scribe/CKIS
scrim/MS
scrimmage/MGDS
scrimp/SDG
scrimshaw/MDGS
scrip/MS
script/FSMDG
scripted/U
scriptural
scripture/MS
scriptwriter/SM
scrivener/SM
scrod/M
scrofula/M
scrofulous
scrog/S
scroll/GSMD
scrooge/MS
scrota
scrotal
scrotum/M
scrounge/DRSZG
scrounger/M
scroungy/TR
scrub/MS
scrubbed
scrubber/SM
scrubbing
scrubby/RT
scruff/SM
scruffily
scruffiness/M
scruffy/RPT
scrum/S
scrumhalf
scrumhalves
scrummage/S
scrummed
scrumming
scrump/SGD
scrumptious/Y
scrumpy
scrunch/MDSG
scrunchy/SM
scruple/MGDS
scrupulosity/M
scrupulous/UPY
scrupulousness/UM
scrutineer/S
scrutinize/GDS
scrutiny/M
scuba/MDSG
scud/MS
scudded
scudding
scuff/MDSG
scuffle/MGDS
scull/MDRSZG
sculler/M
scullery/SM
scullion/SM
sculpt/SGD
sculptor/SM
sculptress/MS
sculptural
sculpture/DSMG
scum/MS
scumbag/MS
scummed
scumming
scummy/TR
scupper/MDGS
scurf/M
scurfy
scurrility/M
scurrilous/PY
scurrilousness/M
scurry/GDSM
scurvily
scurvy/TRM
scutcheon/SM
scuttle/MGDS
scuttlebutt/M
scuzzy/TR
scythe/DSMG
sea/SM
seabed/SM
seabird/MS
seaboard/SM
seaborne
seacoast/SM
seafarer/SM
seafaring/M
seafloor/SM
seafood/M
seafront/SM
seagoing
seagull/MS
seahorse/MS
seal's
seal/AUSDG
sealant/MS
sealer/SM
sealskin/M
seam/GMDNS
seaman/M
seamanship/M
seamless/Y
seamount/MS
seamstress/MS
seamy/RT
seance/SM
seaplane/SM
seaport/MS
sear/GMDS
search/AZGMDRS
searcher/AM
searching/Y
searchlight/MS
searing/Y
seascape/SM
seashell/SM
seashore/SM
seasick/P
seasickness/M
seaside/MS
season/SGMDBJ
seasonable/U
seasonably/U
seasonal/Y
seasonality
seasoned/U
seasoning/M
seat's
seat/UGDS
seating/M
seatmate/SM
seawall/MS
seaward/MS
seawater/M
seaway/SM
seaweed/MS
seaworthiness/M
seaworthy/P
sebaceous
seborrhea/M
sebum
sec'y
sec/SM
secant/SM
secateurs
secede/DSG
secession/M
secessionist/MS
seclude/GDS
seclusion/M
seclusive
second/SLZGMDRY
secondarily
secondary/SM
seconder/M
secondhand
secondment/S
secrecy/M
secret/SGVMDY
secretarial
secretariat/MS
secretary/SM
secretaryship/M
secrete/XNS
secretion/M
secretive/PY
secretiveness/M
secretory
sect/IMS
sectarian/MS
sectarianism/M
sectary/SM
section/AESM
sectional/MS
sectionalism/M
sectioned
sectioning
sector/ESM
secular
secularism/M
secularist/SM
secularization/M
secularize/DSG
secure/DRSYTG
secured/U
security/ISM
secy
sedan/MS
sedate/DRSYTGNVP
sedateness/M
sedation/M
sedative/SM
sedentary
sedge/M
sedgy
sediment/MS
sedimentary
sedimentation/M
sedition/M
seditious
seduce/DRSZG
seducer/M
seduction/SM
seductive/YP
seductiveness/M
seductress/MS
sedulous/Y
see/RSMZ
seed's
seed/AGDS
seedbed/MS
seedcase/MS
seeded/U
seeder/SM
seediness/M
seedless
seedling/MS
seedpod/MS
seedy/RPT
seeing/S
seek/ZGRS
seeker/M
seem/GDS
seeming/Y
seemliness/UM
seemly/URTP
seen/U
seep/GDS
seepage/M
seer/M
seersucker/M
seesaw/SMDG
seethe/DSG
segfault/S
segment/GSMD
segmentation/M
segmented/U
segregate/CDSGN
segregated/U
segregation/CM
segregationist/MS
segue/MGDS
segueing
seigneur/SM
seignior/SM
seine/MZGDRS
seiner/M
seismic
seismically
seismograph/ZMR
seismographer/M
seismographic
seismographs
seismography/M
seismologic
seismological
seismologist/MS
seismology/M
seize/GDS
seizure/MS
seldom
select/CSGVD
selection/SM
selective/Y
selectivity/M
selectman/M
selectmen
selectness/M
selector/MS
selenium/M
selenographer/MS
selenography/M
self/M
selfie/SM
selfish/UYP
selfishness/UM
selfless/PY
selflessness/M
selfsame
sell/ZGMRS
seller/M
selloff/MS
sellotape/DSG
sellout/MS
seltzer/MS
selvage/MS
selves
semantic/S
semantically
semanticist/MS
semantics/M
semaphore/DSMG
semblance/ASM
semen/M
semester/SM
semi/MS
semiannual/Y
semiarid
semiautomatic/MS
semibreve/S
semicircle/SM
semicircular
semicolon/MS
semiconducting
semiconductor/MS
semiconscious
semidarkness/M
semidetached
semifinal/SM
semifinalist/MS
semigloss/S
semimonthly/SM
seminal
seminar/MS
seminarian/SM
seminary/SM
semiofficial
semiotic/S
semiotics/M
semipermeable
semiprecious
semiprivate
semipro/S
semiprofessional/SM
semiquaver/S
semiretired
semiskilled
semisolid
semisweet
semitone/SM
semitrailer/MS
semitransparent
semitropical
semivowel/SM
semiweekly/SM
semiyearly
semolina/M
sempstress/MS
senate/SM
senator/MS
senatorial
send/ZGRS
sender/M
sendoff/MS
senescence/M
senescent
senile
senility/M
senior/SM
seniority/M
senna/M
senor/MS
senora/SM
senorita/SM
sensation/MS
sensational/Y
sensationalism/M
sensationalist/MS
sensationalize/GDS
sense/MGDS
senseless/PY
senselessness/M
sensibilities
sensibility/IM
sensible/P
sensibleness/M
sensibly/I
sensitive/SMYP
sensitiveness/M
sensitivities
sensitivity/IM
sensitization/CM
sensitize/CDSG
sensor/SM
sensory
sensual/Y
sensualist/SM
sensuality/M
sensuous/YP
sensuousness/M
sent/FAU
sentence/MGDS
sententious/Y
sentience/IM
sentient/I
sentiment/SM
sentimental/Y
sentimentalism/M
sentimentalist/MS
sentimentality/M
sentimentalization/M
sentimentalize/GDS
sentinel/MS
sentry/SM
sepal/MS
separability/IM
separable
separably/I
separate/XMYGNVDSP
separateness/M
separation/M
separatism/M
separatist/MS
separator/MS
sepia/M
sepsis/M
septa
septal
septet/SM
septic
septicemia/M
septicemic
septuagenarian/MS
septum/M
sepulcher/GMDS
sepulchral
seq
sequel/SM
sequence/MZGDRS
sequencing/M
sequential/FY
sequester/SDG
sequestrate/XGNDS
sequestration/M
sequin/SMD
sequinned
sequitur
sequoia/MS
seraglio/MS
serape/SM
seraph/M
seraphic
seraphs
sere/TR
serenade/MGDS
serendipitous
serendipity/M
serene/RPYT
sereneness/M
serenity/M
serf/MS
serfdom/M
serge/M
sergeant/MS
serial/SMY
serialization/SM
serialize/GDS
series/M
serif/MS
serigraph/M
serigraphs
serine
serious/PY
seriousness/M
sermon/SM
sermonize/GDS
serology/M
serotonin
serous
serpent/MS
serpentine/M
serrate/XND
serration/M
serried
serum/MS
servant/MS
serve's/AF
serve/FACGDS
server/SM
servery/S
service/EMS
serviceability/M
serviceable
serviced
serviceman/M
servicemen
servicewoman/M
servicewomen
servicing
serviette/MS
servile
servility/M
serving's
servings
servitor/MS
servitude/M
servo/MS
servomechanism/SM
servomotor/MS
sesame/SM
sesquicentennial/MS
session/MS
set/AISM
setback/MS
setscrew/SM
setsquare/S
sett/BJZGRS
settee/MS
setter/M
setting/M
settle's
settle/AUGDS
settlement/AM
settlements
settler/SM
setup/MS
seven/MHS
seventeen/SMH
seventeenth/M
seventeenths
seventh/M
sevenths
seventieth/M
seventieths
seventy/SMH
sever/ETGDS
several/MY
severance/SM
severe/YPR
severeness/M
severity/M
sew/ASGD
sewage/M
sewer/MS
sewerage/M
sewing/M
sewn/A
sex/GMDS
sexagenarian/SM
sexily
sexiness/M
sexism/M
sexist/MS
sexless
sexologist/SM
sexology/M
sexpot/MS
sextant/SM
sextet/MS
sexting
sexton/MS
sextuplet/SM
sexual/Y
sexuality/M
sexy/PTR
sf
sh
shabbily
shabbiness/M
shabby/PTR
shack/MDSG
shackle's
shackle/UGDS
shad/GMDSJ
shade/MS
shadily
shadiness/M
shading/M
shadow/SGMD
shadowbox/GDS
shadowy/RT
shady/RPT
shaft/MDSG
shag/MS
shagged
shagginess/M
shagging
shaggy/TPR
shah/M
shahs
shake/MZGRS
shakedown/SM
shaken/U
shakeout/MS
shaker/M
shakeup/MS
shakily
shakiness/M
shaky/RPT
shale/M
shall
shallot/MS
shallow/TPMRYS
shallowness/M
shalom
shalt
sham/GMDS
shaman/SM
shamanic
shamanism
shamanistic
shamble/MGDS
shambles/M
shambolic
shame/MS
shamefaced/Y
shameful/PY
shamefulness/M
shameless/YP
shamelessness/M
shammed
shamming
shampoo/ZGMDRS
shampooer/M
shamrock/MS
shan't
shandy/S
shanghai/DSG
shank/MS
shantung/M
shanty/SM
shantytown/SM
shape's
shape/AGDS
shaped/U
shapeless/YP
shapelessness/M
shapeliness/M
shapely/PTR
shard/MS
share/MZGDRS
shareable
sharecrop/S
sharecropped
sharecropper/MS
sharecropping
shareholder/SM
shareholding/S
sharer/M
shareware/M
sharia/M
shariah
shark/MDSG
sharkskin/M
sharp/MDNRYSPXZTG
sharpen/ADGS
sharpener/MS
sharper/M
sharpie/MS
sharpish
sharpness/M
sharpshooter/SM
sharpshooting/M
shatter/GMDS
shatterproof
shave/MZGDRSJ
shaven/U
shaver/M
shaving/M
shawl/MS
shay/MS
she'd
she'll
she/DSM
sheaf/M
shear/MDRSZG
shearer/M
sheath/JM
sheathe/UGDS
sheathing/M
sheaths
sheave/DSMG
shebang/MS
shebeen/S
shed/MS
shedding
sheen/M
sheeny/TR
sheep/M
sheepdog/MS
sheepfold/SM
sheepherder/MS
sheepish/YP
sheepishness/M
sheepskin/MS
sheer/MDRSPTG
sheerness/M
sheet/MSG
sheeting/M
sheetlike
sheikdom/MS
sheikh/M
sheikhs
sheila/S
shekel/SM
shelf/M
shell/MDRSG
shellac/MS
shellacked
shellacking/MS
shellfire/M
shellfish/MS
shelter/GMDS
shelve/GDS
shelving/M
shenanigan/SM
shepherd/SMDG
shepherdess/MS
sherbet/SM
sheriff/SM
sherry/SM
shew/GDS
shewn
shh
shiatsu/M
shibboleth/M
shibboleths
shield/MDGS
shift/GMDS
shiftily
shiftiness/M
shiftless/PY
shiftlessness/M
shifty/RPT
shiitake/SM
shill/GMDSJ
shillelagh/M
shillelaghs
shilling/M
shim/MS
shimmed
shimmer/SMDG
shimmery
shimming
shimmy/DSMG
shin/ZGMDRS
shinbone/SM
shindig/SM
shine/MS
shiner/M
shingle/DSMG
shinguard/M
shininess/M
shinned
shinning
shinny/DSG
shinsplints/M
shiny/TRP
ship's
ship/ALS
shipboard/MS
shipbuilder/SM
shipbuilding/M
shipload/SM
shipmate/SM
shipment/AM
shipments
shipowner/MS
shipped/A
shipper/SM
shipping/M
shipshape
shipwreck/GMDS
shipwright/MS
shipyard/SM
shire/MS
shirk/ZGDRS
shirker/M
shirr/GMDSJ
shirring/M
shirt/GMDS
shirtfront/SM
shirting/M
shirtless
shirtsleeve/SM
shirttail/SM
shirtwaist/MS
shirty
shit/SM!
shitfaced/!
shithead/S!
shitload/!
shitted/!
shitting/!
shitty/RT!
shiv/ZMRS
shiver/MDG
shivery
shoal/GMDS
shoat/MS
shock/ZGMDRS
shocker/M
shocking/Y
shockproof
shod/U
shoddily
shoddiness/M
shoddy/PRMT
shoe/MS
shoehorn/GMDS
shoeing
shoelace/MS
shoemaker/SM
shoeshine/SM
shoestring/SM
shoetree/MS
shogun/MS
shogunate/M
shone
shoo/GDS
shook
shoot/ZGMRSJ
shooter/M
shooting/M
shootout/MS
shop/MS
shopaholic/MS
shopfitter/S
shopfitting
shopfront/S
shopkeeper/MS
shoplift/DRZGS
shoplifter/M
shoplifting/M
shoppe/MZGDRS
shopper/M
shopping/M
shoptalk/M
shopworn
shore/MGDS
shorebird/SM
shoreline/MS
shoring/M
short/XTGMDNRYSP
shortage/MS
shortbread/M
shortcake/MS
shortchange/DSG
shortcoming/MS
shortcrust
shortcut/MS
shorten/JGD
shortening/M
shortfall/MS
shorthand/MD
shorthorn/MS
shortish
shortlist/DGS
shortness/M
shortsighted/PY
shortsightedness/M
shortstop/MS
shortwave/MS
shorty/SM
shot/MS
shotgun/SM
shotgunned
shotgunning
should
should've
shoulder/MDGS
shouldn't
shout/ZGMDRS
shouter/M
shove/MGDS
shovel/MDSG
shovelful/SM
show/JZGMDRS
showbiz/M
showboat/MDGS
showcase/MGDS
showdown/MS
shower/MDG
showerproof
showery
showgirl/MS
showground/S
showily
showiness/M
showing/M
showjumping
showman/M
showmanship/M
showmen
shown
showoff/SM
showpiece/SM
showplace/SM
showroom/MS
showstopper/MS
showstopping
showtime
showy/TRP
shpt
shrank
shrapnel/M
shred/MS
shredded
shredder/MS
shredding
shrew/MS
shrewd/RYPT
shrewdness/M
shrewish
shriek/MDSG
shrift/M
shrike/MS
shrill/DRSPTG
shrillness/M
shrilly
shrimp/MDRSZG
shrine/MS
shrink/MSBG
shrinkage/M
shrive/GDS
shrivel/SGD
shriven
shroud/GMDS
shrub/MS
shrubbery/SM
shrubby/RT
shrug/MS
shrugged
shrugging
shrunk/N
shtick/MS
shuck/GMDS
shucks/S
shudder/MDSG
shuffle/AMGDS
shuffleboard/SM
shuffler/SM
shun/S
shunned
shunning
shunt/MSDG
shush/DSG
shut/S
shutdown/SM
shuteye/M
shutoff/SM
shutout/SM
shutter/SMDG
shutterbug/MS
shutting
shuttle/DSMG
shuttlecock/GMDS
shy/TGDRSMY
shyer
shyest
shyness/M
shyster/SM
sibilant/SM
sibling/SM
sibyl/MS
sibylline
sic/S
sicced
siccing
sick/PXTGDNRYS
sickbay/S
sickbed/SM
sicken/DG
sickening/Y
sickie/MS
sickish
sickle/MS
sickly/RT
sickness/MS
sicko/MS
sickout/SM
sickroom/MS
side's
side/AGDS
sidearm/SM
sidebar/SM
sideboard/SM
sideburns/M
sidecar/SM
sidekick/SM
sidelight/MS
sideline/DSMG
sidelong
sideman/M
sidemen
sidepiece/MS
sidereal
sidesaddle/MS
sideshow/MS
sidesplitting
sidestep/MS
sidestepped
sidestepping
sidestroke/DSMG
sideswipe/DSMG
sidetrack/SMDG
sidewalk/MS
sidewall/MS
sideways
sidewinder/SM
siding/MS
sidle/MGDS
siege/MS
sienna/M
sierra/MS
siesta/MS
sieve/MGDS
sift/ZGDRS
sifted/U
sifter/M
sigh/GMD
sighs
sight/GMDYSJ
sighting/M
sightless
sightly/UTR
sightread
sightseeing/M
sightseer/MS
sigma/MS
sign's/C
sign/AFCGDS
signage/M
signal/MDRYSZG
signaler/M
signalization/M
signalize/GDS
signalman/M
signalmen
signatory/SM
signature/MS
signboard/MS
signed/U
signer/CMS
signet/MS
significance/IM
significant/IY
signification/M
signify/XDSNG
signing's/C
signings
signor/FMS
signora/SM
signore
signori
signorina/MS
signorine
signpost/GSMD
silage/M
silence/DRSMZG
silencer/M
silent/MRYST
silhouette/DSMG
silica/M
silicate/MS
siliceous
silicon/SM
silicone/M
silicosis/M
silk/MNS
silkily
silkiness/M
silkscreen/SM
silkworm/MS
silky/TRP
sill/MS
silliness/M
silly/TRSMP
silo/MS
silt/GMDS
silty/TR
silver/GMDS
silverfish/MS
silversmith/M
silversmiths
silverware/M
silvery
sim/SM
simian/MS
similar/Y
similarity/ESM
simile/MS
similitude/EM
simmer/GMDS
simonize/DSG
simony/M
simpatico
simper/GMDS
simpering/Y
simple/TRP
simpleminded
simpleness/M
simpleton/SM
simplex
simplicity/M
simplification/M
simplify/DSXNG
simplistic
simplistically
simply
simulacra
simulacrum/S
simulate/EDSGN
simulation/EM
simulations
simulator/EMS
simulcast/GMDS
simultaneity/M
simultaneous/Y
sin/ASM
since
sincere/IYT
sincerer
sincerity/IM
sine/MS
sinecure/MS
sinew/MS
sinewy
sinful/PY
sinfulness/M
sing/BZGMDRYS
singalong/S
singe/MS
singeing
singer/M
singing/M
single/PMGDS
singleness/M
singles/M
singlet/S
singleton/SM
singletree/SM
singsong/SMDG
singular/SMY
singularity/SM
sinister
sink/BZGMRS
sinkable/U
sinker/M
sinkhole/SM
sinless
sinned
sinner/MS
sinning
sinology
sinuosity/M
sinuous/Y
sinus/MS
sinusitis/M
sinusoidal
sip/SM
siphon/GMDS
sipped
sipper/SM
sipping
sir/SXMN
sire/CMGDS
siren/M
sirloin/SM
sirocco/SM
sirrah
sirree/M
sis/MS
sisal/M
sissified
sissy/RSMT
sister/ASM
sisterhood/MS
sisterliness/M
sisterly/P
sit/S
sitar/SM
sitarist/MS
sitcom/SM
site/MGDS
sitemap/SM
sitter/SM
sitting/SM
situate/DSXGN
situation/M
situational
six/MSH
sixfold
sixpence/MS
sixshooter/M
sixteen/SMH
sixteenth/M
sixteenths
sixth/M
sixths
sixtieth/M
sixtieths
sixty/SMH
sizable
size's
size/AGDS
sizer
sizing/M
sizzle/DRSMZG
ska/M
skate/MZGDRS
skateboard/MDRSZG
skateboarder/M
skateboarding/M
skater/M
skating/M
skedaddle/MGDS
skeet/ZMR
skein/MS
skeletal
skeleton/SM
skeptic/SM
skeptical/Y
skepticism/M
sketch/MDRSZG
sketchbook/S
sketcher/M
sketchily
sketchiness/M
sketchpad/S
sketchy/RTP
skew/MDRZGS
skewbald/S
skewer/MDG
ski/SZGMDR
skibob/S
skid/MS
skidded
skidding
skidpan/S
skier/M
skiff/SM
skiffle
skiing/M
skilfully
skill's
skill/CSD
skilled/U
skillet/SM
skillful/UY
skillfulness/M
skim/MS
skimmed
skimmer/SM
skimming
skimp/SDG
skimpily
skimpiness/M
skimpy/RTP
skin/MS
skincare/M
skinflint/MS
skinful
skinhead/MS
skinless
skinned
skinniness/M
skinning
skinny/RMTP
skint
skintight
skip/MS
skipped
skipper/SMDG
skipping
skirmish/ZGMDRS
skirt/SMDG
skit/MS
skitter/GSD
skittish/YP
skittishness/M
skittle/S
skive/DRSZG
skivvy/DSMG
skoal/SM
skua/S
skulduggery/M
skulk/SDRZG
skulker/M
skull/SM
skullcap/MS
skunk/SMDG
sky/GSM
skycap/SM
skydive/DRSZG
skydiver/M
skydiving/M
skyjack/JZGSDR
skyjacker/M
skyjacking/M
skylark/SGMD
skylight/MS
skyline/SM
skyrocket/GSMD
skyscraper/SM
skyward/S
skywriter/SM
skywriting/M
slab/MS
slabbed
slabbing
slack/PXZTGMDNRYS
slacken/DG
slacker/M
slackness/M
slacks/M
slag/MS
slagged
slagging
slagheap/S
slain
slake/GDS
slalom/MSDG
slam/MS
slammed
slammer/SM
slamming
slander/MZGDRS
slanderer/M
slanderous
slang/M
slangy/RT
slant/MSDG
slanting/Y
slantwise
slap/MS
slapdash
slaphappy
slapped
slapper/S
slapping
slapstick/M
slash/MDRSZG
slasher/M
slat/MDGS
slate/SM
slather/SDG
slatted
slattern/SMY
slaughter/MDRZGS
slaughterer/M
slaughterhouse/MS
slave/DRSMZG
slaveholder/MS
slaver/MDG
slavery/M
slavish/PY
slavishness/M
slaw/M
slay/DRZGJS
slayer/M
slaying/M
sleaze/SM
sleazebag/S
sleazeball/S
sleazily
sleaziness/M
sleazy/PRT
sled/MS
sledded
sledder/SM
sledding
sledge/DSMG
sledgehammer/GSMD
sleek/SDRYTGP
sleekness/M
sleep/SMRZG
sleeper/M
sleepily
sleepiness/M
sleepless/PY
sleeplessness/M
sleepover/SM
sleepwalk/ZGSDR
sleepwalker/M
sleepwalking/M
sleepwear/M
sleepy/RPT
sleepyhead/MS
sleet/SMDG
sleety
sleeve/DSM
sleeveless
sleigh/MDG
sleighs
sleight/SM
slender/PRT
slenderize/DSG
slenderness/M
slept
sleuth/MG
sleuths
slew/MDGS
slice/DRSMZG
slicer/M
slick/SMDRYZTGP
slicker/M
slickness/M
slid
slide/RSMZG
slider/M
slideshow/MS
slight/SMDRYTGP
slightness/M
slim/PS
slime/M
sliminess/M
slimline
slimmed
slimmer/S
slimmest
slimming/M
slimness/M
slimy/RTP
sling/SMG
slingback/S
slingshot/SM
slink/SG
slinky/RT
slip/MS
slipcase/MS
slipcover/MS
slipknot/MS
slippage/MS
slipped
slipper/SM
slipperiness/M
slippery/PRT
slipping
slippy
slipshod
slipstream/SM
slipway/SM
slit/MS
slither/SGMD
slithery
slitter
slitting
sliver/GSMD
slob/MS
slobbed
slobber/MDSG
slobbery
slobbing
sloe/MS
slog/MS
slogan/SM
sloganeering
slogged
slogging
sloop/SM
slop/MDGS
slope/SM
slopped
sloppily
sloppiness/M
slopping
sloppy/PTR
slops/M
slosh/DSG
slot/MS
sloth/M
slothful/YP
slothfulness/M
sloths
slotted
slotting
slouch/ZGMDRS
sloucher/M
slouchy/TR
slough/GMD
sloughs
sloven/SMY
slovenliness/M
slovenly/PTR
slow/DRYTGSP
slowcoach/S
slowdown/SM
slowness/M
slowpoke/SM
sludge/M
sludgy/RT
slue/MGDS
slug/MS
sluggard/MS
slugged
slugger/SM
slugging
sluggish/PY
sluggishness/M
sluice/DSMG
slum/MS
slumber/GSMD
slumberous
slumdog/SM
slumlord/MS
slummed
slummer
slumming
slummy/RT
slump/SMDG
slung
slunk
slur/MS
slurp/SMDG
slurred
slurring
slurry/M
slush/M
slushiness/M
slushy/RPT
slut/MS
sluttish
slutty/RT
sly/TRY
slyness/M
smack/SMDRZG
smacker/M
small/SMRTP
smallholder/S
smallholding/S
smallish
smallness/M
smallpox/M
smarmy/RT
smart/SMDNRYXTGP
smarten/DG
smartness/M
smartphone/SM
smarts/M
smartwatch/MS
smarty/SM
smartypants/M
smash/MDRSZG
smasher/M
smashup/SM
smattering/MS
smear/SMDG
smeary/RT
smell/SMDG
smelliness/M
smelly/RPT
smelt/SMDRZG
smelter/M
smidgen/MS
smilax/M
smile/DSMG
smiley/SM
smiling/Y
smirch/GMDS
smirk/SMDG
smite/SG
smith/M
smithereens/M
smiths
smithy/SM
smitten
smock/SMDG
smocking/M
smog/MS
smoggy/RT
smoke/DRSMZG
smokehouse/MS
smokeless
smoker/M
smokescreen/SM
smokestack/SM
smokey
smokiness/M
smoking/M
smoky/RTP
smolder/SGMD
smooch/MDSG
smoochy
smooth/PDRYTG
smoothie/MS
smoothness/M
smooths
smorgasbord/SM
smote
smother/GSMD
smudge/DSMG
smudgy/TR
smug/YP
smugger
smuggest
smuggle/ZGDRS
smuggler/M
smuggling/M
smugness/M
smurf/S
smut/MS
smuttiness/M
smutty/TRP
snack/SMDG
snaffle/DSMG
snafu/SM
snag/MS
snagged
snagging
snail/SMDG
snake/DSMG
snakebite/MS
snakelike
snakeskin
snaky/RT
snap's
snap/US
snapdragon/SM
snapped/U
snapper/MS
snappily
snappiness/M
snapping/U
snappish/YP
snappishness/M
snappy/TRP
snapshot/SM
snare/DSMG
snarf/SDG
snark/S
snarky/TR
snarl's
snarl/USDG
snarling/Y
snarly/TR
snatch/ZGMDRS
snatcher/M
snazzily
snazzy/TR
sneak/SMDRZG
sneaker/M
sneakily
sneakiness/M
sneaking/Y
sneaky/TRP
sneer/SJMDG
sneering/Y
sneeze/DSMG
snick/SDRZG
snicker/MDG
snide/RYT
sniff/SMDRZG
sniffer/M
sniffle/DSMG
sniffy/RT
snifter/SM
snip/MDRZGS
snipe/SM
sniper/M
snipped
snippet/SM
snipping
snippy/RT
snips/M
snit/MS
snitch/MDSG
snivel/SMDRZG
sniveler/M
snob/MS
snobbery/M
snobbish/PY
snobbishness/M
snobby/RT
snog/S
snogged
snogging
snood/SM
snooker/MDSG
snoop/SMDRZG
snooper/M
snoopy/TR
snoot/SM
snootily
snootiness/M
snooty/PTR
snooze/DSMG
snore/DRSMZG
snorer/M
snorkel/ZGMDRS
snorkeler/M
snorkeling/M
snort/SMDRZG
snorter/M
snot/MS
snottily
snottiness/M
snotty/TPR
snout/SM
snow/MDGS
snowball/GSMD
snowbank/SM
snowbird/SM
snowblower/MS
snowboard/ZGMDRS
snowboarder/M
snowboarding/M
snowbound
snowdrift/SM
snowdrop/SM
snowfall/SM
snowfield/SM
snowflake/SM
snowiness/M
snowline
snowman/M
snowmen
snowmobile/DSMG
snowplow/SGMD
snowshed
snowshoe/SM
snowshoeing
snowstorm/SM
snowsuit/SM
snowy/PRT
snub/MS
snubbed
snubbing
snuff/SMDRYZG
snuffbox/MS
snuffer/M
snuffle/MGDS
snug/MYSP
snugged
snugger
snuggest
snugging
snuggle/MGDS
snugness/M
so
soak/MDGSJ
soaking/M
soap/MDGS
soapbox/MS
soapiness/M
soapstone/M
soapsuds/M
soapy/RPT
soar/MDGS
sob/SM
sobbed
sobbing/Y
sober/SDRYPTG
soberness/M
sobriety/IM
sobriquet/SM
soc
soccer/M
sociability/M
sociable/SM
sociably
social/SMY
socialism/M
socialist/SM
socialistic
socialite/SM
socialization/M
socialize/DSG
societal
society/SM
socioeconomic
socioeconomically
sociological/Y
sociologist/SM
sociology/M
sociopath/M
sociopaths
sociopolitical
sock/MDGS
socket/SM
sockeye/SM
sod/SM
soda/MS
sodded
sodden/Y
sodding
sodium/M
sodomite/MS
sodomize/GDS
sodomy/M
soever
sofa/MS
soft/NRYXTP
softback
softball/MS
softbound
softcover
soften/DRZG
softener/M
softhearted
softness/M
software/M
softwood/SM
softy/SM
soggily
sogginess/M
soggy/RTP
soigne
soignee
soil/MDGS
soiled/U
soiree/SM
sojourn/ZGMDRS
sojourner/M
sol/SM
solace/DSMG
solar
solaria
solarium/M
sold
solder/ZGSMDR
solderer/M
soldier/MDYSG
soldiery/M
sole/FSDGM
solecism/SM
solely
solemn/PTRY
solemness/M
solemnify/DSG
solemnity/SM
solemnization/M
solemnize/DSG
solemnness/M
solenoid/MS
solicit/GDS
solicitation/SM
solicited/U
solicitor/SM
solicitous/PY
solicitousness/M
solicitude/M
solid/PSMRYT
solidarity/M
solidi
solidification/M
solidify/DSNG
solidity/M
solidness/M
solidus/M
soliloquies
soliloquize/DSG
soliloquy/M
solipsism/M
solipsistic
solitaire/MS
solitariness/M
solitary/SMP
solitude/M
solo/MDGS
soloist/MS
solstice/MS
solubility/IM
soluble/MS
solute's
solute/AXN
solutes
solution's/AE
solvable/IU
solve/EADSG
solved/U
solvency/IM
solvent/IMS
solver/SM
somatic
somber/PY
somberness/M
sombrero/MS
some
somebody/SM
someday
somehow
someone/MS
someplace
somersault/MDGS
somerset/SM
somersetted
somersetting
something/SM
sometime/S
someway/S
somewhat/S
somewhere
somnambulism/M
somnambulist/SM
somnolence/M
somnolent
son/SM
sonar/SM
sonata/SM
sonatina/SM
song/MS
songbird/SM
songbook/SM
songfest/SM
songster/MS
songstress/MS
songwriter/SM
songwriting
sonic
sonnet/SM
sonny/SM
sonogram/SM
sonority/M
sonorous/YP
sonorousness/M
sonsofbitches
soon/RT
soot/M
sooth/MDRSZG
soothe
soother/M
soothing/Y
soothsayer/MS
soothsaying/M
sooty/RT
sop/SM
soph
sophism/M
sophist/MS
sophistic
sophistical
sophisticate/DSMGN
sophisticated/U
sophistication/M
sophistry/SM
sophomore/MS
sophomoric
soporific/MS
soporifically
sopped
sopping
soppy/RT
soprano/MS
sorbet/SM
sorcerer/MS
sorceress/MS
sorcery/M
sordid/PY
sordidness/M
sore/MYTRSP
sorehead/MS
soreness/M
sorghum/M
sorority/SM
sorrel/SM
sorrily
sorriness/M
sorrow/SMDG
sorrowful/YP
sorrowfulness/M
sorry/RTP
sort/FASGDM
sorta
sorted/U
sorter/SM
sortie/DSM
sortieing
sot/SM
sottish
sou'wester
sou/SMH
souffle/SM
sough/MDG
soughs
sought/U
souk/S
soul/MS
soulful/YP
soulfulness/M
soulless/YP
soulmate/SM
sound/JPSMDRYZTG
soundalike/S
soundbar/S
soundbite/S
soundboard/MS
soundcheck/S
sounder/M
sounding/M
soundless/Y
soundness/UM
soundproof/GDS
soundproofing/M
soundscape/S
soundtrack/SM
soup/MDGS
soupcon/MS
soupy/RT
sour/MDRYTGSP
source/ADSMG
sourdough/M
sourdoughs
sourish
sourness/M
sourpuss/MS
sousaphone/MS
souse/DSMG
south/M
southbound
southeast/ZMR
southeaster/MY
southeastern
southeastward/S
southerly/SM
southern/SZMR
southerner/M
southernmost
southpaw/SM
southward/MS
southwest/ZMR
southwester/MY
southwestern
southwestward/S
souvenir/SM
sovereign/SM
sovereignty/M
soviet/SM
sow's
sow/ASGD
sower/SM
sown/A
soy/M
soybean/MS
sozzled
spa/SM
space/DRSMZG
spacecraft/MS
spaceflight/MS
spaceman/M
spacemen
spaceport/SM
spacer/M
spaceship/SM
spacesuit/SM
spacewalk/SGMD
spacewoman/M
spacewomen
spacey
spacial
spacier
spaciest
spaciness/M
spacing/M
spacious/YP
spaciousness/M
spade/DSMG
spadeful/MS
spadework/M
spadices
spadix/M
spaghetti/M
spake
spam/MS
spammed
spammer/SM
spamming
span/MS
spandex/M
spangle/DSMG
spangly
spaniel/SM
spank/SMDGJ
spanking/M
spanned
spanner/SM
spanning
spar/MS
spare/DRSMYTGP
spareness/M
spareribs/M
sparing/UY
spark/SMDYG
sparkle/DRSMZG
sparkler/M
sparky/RT
sparred
sparring
sparrow/SM
sparrowhawk/S
sparse/RYTP
sparseness/M
sparsity/M
spartan
spasm/SM
spasmodic
spasmodically
spastic/SM
spat/MS
spate/SM
spathe/SM
spatial/Y
spatted
spatter/SGMD
spatting
spatula/SM
spavin/MD
spawn/SMDG
spay/DGS
speak/SRZGJ
speakeasy/SM
speaker/M
speakerphone/S
spear/SMDG
spearfish/GMDS
speargun
spearhead/GMDS
spearmint/M
spec/MS
special/SMY
specialism/S
specialist/MS
specialization/MS
specialize/GDS
specialty/SM
specie/SM
species/M
specif
specifiable
specific/MS
specifically
specification/M
specificity/M
specified/U
specify/XNZDRSG
specimen/SM
specious/YP
speciousness/M
speck/SMDG
speckle/MGDS
specs/M
spectacle/SM
spectacles/M
spectacular/MYS
spectate/DSG
spectator/SM
specter/AMS
spectra
spectral
spectrometer/MS
spectroscope/MS
spectroscopic
spectroscopy/M
spectrum/M
speculate/DSXGNV
speculation/M
speculative/Y
speculator/MS
sped
speech/MS
speechify/DSG
speechless/YP
speechlessness/M
speechwriter/S
speed/SMRZG
speedboat/SM
speeder/M
speedily
speediness/M
speeding/M
speedometer/MS
speedster/SM
speedup/MS
speedway/SM
speedwell/M
speedy/TPR
speleological
speleologist/MS
speleology/M
spell/JSMDRZG
spellbind/ZGRS
spellbinder/M
spellbound
spellcheck/MDRZGS
spellchecker/M
spelldown/SM
speller/M
spelling/M
spelunker/MS
spelunking/M
spend/BSRZG
spender/M
spending/M
spendthrift/MS
spent/U
sperm/SM
spermatozoa
spermatozoon/M
spermicidal
spermicide/MS
spew/MDRZGS
spewer/M
sphagnum/MS
sphere/SM
spherical/Y
spheroid/SM
spheroidal
sphincter/MS
sphinx/MS
spic/S
spice/DSMG
spicily
spiciness/M
spicule/MS
spicy/PRT
spider/SM
spiderweb/MS
spidery
spiel/SMDG
spiff/SDG
spiffy/TR
spigot/SM
spike/DSMG
spikiness/M
spiky/RPT
spill/SMDG
spillage/MS
spillover/SM
spillway/MS
spin/MS
spinach/M
spinal/SMY
spindle/MGDS
spindly/TR
spine/SM
spineless/YP
spinet/SM
spinnaker/SM
spinner/MS
spinneret/SM
spinney/S
spinning/M
spinster/SM
spinsterhood/M
spinsterish
spiny/RT
spiracle/SM
spiral/SGMDY
spire's
spire/IFAS
spirea/SM
spirit's
spirit/ISGD
spirited/Y
spiritless
spiritual/MYS
spiritualism/M
spiritualist/MS
spiritualistic
spirituality/M
spirituous
spirochete/SM
spiry
spit/MDGS
spitball/SM
spite/ASM
spiteful/PY
spitefuller
spitefullest
spitefulness/M
spitfire/SM
spitted
spitting
spittle/M
spittoon/MS
spiv/S
splash/GMDS
splashdown/MS
splashily
splashiness/M
splashy/RTP
splat/SM
splatted
splatter/GSMD
splatting
splay/SMDG
splayfeet
splayfoot/MD
spleen/SM
splendid/RYT
splendor/MS
splendorous
splenectomy
splenetic
splice/DRSMZG
splicer/M
spliff/S
spline/S
splint/SZGMDR
splinter/MDG
splintery
split/SM
splitting/MS
splodge/S
splosh/DSG
splotch/MDSG
splotchy/TR
splurge/DSMG
splutter/GMDS
spoil's
spoil/CSDRZG
spoilage/M
spoiled/U
spoiler/CM
spoilsport/MS
spoke/SM
spoken/U
spokesman/M
spokesmen
spokespeople
spokesperson/MS
spokeswoman/M
spokeswomen
spoliation/CM
sponge/DRSMZG
spongecake/M
sponger/M
sponginess/M
spongy/RPT
sponsor/MDGS
sponsorship/M
spontaneity/M
spontaneous/Y
spoof/SMDG
spook/SMDG
spookiness/M
spooky/RPT
spool/SMDG
spoon/SMDG
spoonbill/MS
spoonerism/MS
spoonful/SM
spoor/SMDG
sporadic
sporadically
spore/DSMG
sporran/S
sport/SMDGV
sportiness/M
sporting/Y
sportive/Y
sportscast/MRZGS
sportscaster/M
sportsman/M
sportsmanlike/U
sportsmanship/M
sportsmen
sportspeople
sportsperson
sportswear/M
sportswoman/M
sportswomen
sportswriter/SM
sporty/TPR
spot/CMS
spotless/PY
spotlessness/M
spotlight/GSMD
spotlit
spotted
spotter/MS
spottily
spottiness/M
spotting
spotty/TPR
spousal/MS
spouse/SM
spout/SMDG
sprain/GSMD
sprang
sprat/SM
sprawl/GSMD
spray's
spray/ASDG
sprayer/MS
spread/ZGBSMR
spreadeagled
spreader/M
spreadsheet/MS
spree/DSM
spreeing
sprig/SM
sprigged
sprightliness/M
sprightly/RTP
spring/GSM
springboard/MS
springbok/MS
springily
springiness/M
springlike
springtime/M
springy/RPT
sprinkle/DRSJMZG
sprinkler/M
sprinkling/M
sprint/ZGSMDR
sprinter/M
sprite/SM
spritz/ZGMDRS
spritzer/M
sprocket/MS
sprog/S
sprout/GSMD
spruce/DRSPMYTG
spruceness/M
sprung
spry/RYT
spryness/M
spud/MS
spume/DSMG
spumoni/M
spumy
spun
spunk/SM
spunky/TR
spur/MS
spurge/M
spurious/PY
spuriousness/M
spurn/SDG
spurred
spurring
spurt/SMDG
sputa
sputnik/MS
sputter/MDGS
sputum/M
spy/GDSM
spyglass/MS
spymaster/S
spyware/M
sq
sqq
squab/SM
squabble/MZGDRS
squabbler/M
squad/SM
squadron/MS
squalid/PTRY
squalidness/M
squall/SGMD
squally
squalor/M
squamous
squander/GDS
square/PDRSMYTG
squareness/M
squarish
squash/GMDS
squashy/TR
squat/SMP
squatness/M
squatted
squatter/MS
squattest
squatting
squaw/SM
squawk/SZGMDR
squawker/M
squeak/SZGMDR
squeaker/M
squeakily
squeakiness/M
squeaky/TRP
squeal/SZGMDR
squealer/M
squeamish/PY
squeamishness/M
squeegee/MDS
squeegeeing
squeeze/BMZGDRS
squeezebox/S
squeezer/M
squelch/GMDS
squelchy
squib/SM
squid/SM
squidgy
squiffy
squiggle/DSMG
squiggly
squint/STGMDR
squire/DSMG
squirm/SGMD
squirmy/RT
squirrel/SGMD
squirt/SGMD
squish/GMDS
squishy/RT
sriracha
ssh
st
stab/MYS
stabbed
stabber/MS
stabbing/MS
stability/IM
stabilization/CM
stabilize/CDSG
stabilizer/MS
stable/DRSMTG
stableman/M
stablemate/S
stablemen
stably/U
staccato/MS
stack/SMDG
stadium/MS
staff's
staff/ASDG
staffer/MS
staffing/M
stag/MDGSJ
stage/SM
stagecoach/MS
stagecraft/M
stagehand/MS
stagestruck
stagflation/M
stagger/MDGS
staggering/Y
staging/M
stagnancy/M
stagnant/Y
stagnate/DSGN
stagnation/M
stagy/RT
staid/PRYT
staidness/M
stain/SMDG
stained/U
stainless/M
stair/SM
staircase/MS
stairway/MS
stairwell/SM
stake/DSMG
stakeholder/MS
stakeout/SM
stalactite/MS
stalagmite/MS
stale/DRSTGP
stalemate/DSMG
staleness/M
stalk/SMDRJZG
stalker/M
stalking/M
stall's
stall/ISDG
stallholder/S
stallion/MS
stalwart/MYS
stamen/SM
stamina/M
stammer/ZGMDRS
stammerer/M
stammering/Y
stamp/SMDRZG
stampede/MGDS
stamper/M
stance/ISM
stanch/TGDRS
stanchion/SM
stand/SMRJZG
standalone
standard/MS
standardization/M
standardize/DSG
standby/M
standbys
standee/MS
stander/M
standing/M
standoff/MS
standoffish
standout/MS
standpipe/SM
standpoint/MS
standstill/MS
stank
stanza/SM
staph/M
staphylococcal
staphylococci
staphylococcus/M
staple/DRSMZG
stapler/M
star/MDRZGS
starboard/M
starburst/S
starch/GMDS
starchily
starchiness/M
starchy/PTR
stardom/M
stardust/M
stare/SM
starer/M
starfish/MS
starfruit
stargaze/DRSZG
stargazer/M
stark/RYPZT
starkness/M
starless
starlet/MS
starlight/M
starling/SM
starlit
starred
starring
starry/TR
starstruck
start/ASMDG
starter/MS
startle/GDS
startling/Y
startup/MS
starvation/M
starve/DSJG
starveling/MS
stash/MDSG
stasis
stat/MS
state/DRSMYGNLX
statecraft/M
stated/U
statehood/M
statehouse/MS
stateless/P
statelessness/M
stateliness/M
stately/PRT
statement/AMS
statemented
statementing
stateroom/MS
stateside
statesman/M
statesmanlike
statesmanship/M
statesmen
stateswoman/M
stateswomen
statewide
static/SM
statically
station/MDRZG
stationary
stationer/M
stationery/M
stationmaster/S
statistic/MS
statistical/Y
statistician/SM
statuary/M
statue/SM
statuesque
statuette/MS
stature/MS
status/MS
statute/MS
statutorily
statutory
staunch/PDRSYTG
staunchness/M
stave/DSMG
stay/MDRZGS
std
stdio
stead/SM
steadfast/YP
steadfastness/M
steadily/U
steadiness/UM
steady/TGPDRSM
steak/SM
steakhouse/SM
steal/SMHG
stealth/M
stealthily
stealthiness/M
stealthy/TPR
steam/SMDRZG
steamboat/MS
steamer/M
steamfitter/SM
steamfitting/M
steaminess/M
steampunk
steamroll/ZGDRS
steamroller/MDG
steamship/MS
steamy/TPR
steed/SM
steel/SMDG
steeliness/M
steelmaker/S
steelworker/SM
steelworks/M
steely/PTR
steelyard/SM
steep/SMDNRYPXTG
steepen/GD
steeple/MS
steeplechase/MS
steeplejack/SM
steepness/M
steer/SMDBG
steerage/M
steering/M
steersman/M
steersmen
stegosauri
stegosaurus/MS
stein/SM
stellar
stem/MS
stemless
stemmed
stemming
stemware/M
stench/MS
stencil/GMDS
steno/SM
stenographer/SM
stenographic
stenography/M
stenosis
stent/SM
stentorian
step/IMS
stepbrother/SM
stepchild/M
stepchildren/M
stepdad/MS
stepdaughter/SM
stepfather/SM
stepladder/MS
stepmom/MS
stepmother/SM
stepparent/SM
steppe/DRSMZG
stepper/M
steppingstone/SM
stepsister/MS
stepson/MS
stereo/SM
stereophonic
stereoscope/MS
stereoscopic
stereotype/DSMG
stereotypical
sterile
sterility/M
sterilization/SM
sterilize/DRSZG
sterilizer/M
sterling/M
stern/SMRYPT
sternness/M
sternum/MS
steroid/MS
steroidal
stertorous
stet/S
stethoscope/MS
stetson/MS
stetted
stetting
stevedore/SM
stew/MDGS
steward/GMDS
stewardess/MS
stewardship/M
stick/SMRZG
sticker/M
stickily
stickiness/M
stickleback/SM
stickler/MS
stickpin/MS
stickup/MS
sticky/PTRSM
stiff/SMDNRYPXTG
stiffen/ZGDR
stiffener/M
stiffening/M
stiffness/M
stifle/DSJG
stifling/Y
stigma/SM
stigmata
stigmatic
stigmatization/M
stigmatize/GDS
stile/SM
stiletto/SM
still's
still/ITGSD
stillbirth/M
stillbirths
stillborn
stiller
stillness/M
stilt/SMD
stilted/Y
stimulant/SM
stimulate/DSGNV
stimulation/M
stimuli
stimulus/M
sting/ZGSMR
stinger/M
stingily
stinginess/M
stingray/SM
stingy/RTP
stink/ZGSMR
stinkbug/SM
stinker/M
stinky/RT
stint/GSMD
stipend/SM
stipendiary/S
stipple/DSMG
stippling/M
stipulate/XDSGN
stipulation/M
stir/MS
stirred
stirrer/SM
stirring/SY
stirrup/SM
stitch's
stitch/ADSG
stitchery/M
stitching/M
stoat/SM
stochastic
stock's
stock/AGSD
stockade/DSMG
stockbreeder/MS
stockbroker/SM
stockbroking/M
stockholder/SM
stockily
stockiness/M
stockinette/M
stocking/SM
stockist/S
stockpile/MGDS
stockpot/SM
stockroom/MS
stocktaking/M
stocky/RTP
stockyard/MS
stodge
stodgily
stodginess/M
stodgy/RTP
stogie/MS
stoic/SM
stoical/Y
stoicism/M
stoke/DRSZG
stoker/M
stole/SM
stolen
stolid/RYTP
stolidity/M
stolidness/M
stolon/MS
stomach/MDRZG
stomachache/SM
stomacher/M
stomachs
stomp/GSMD
stone/DRSMZG
stonemason/MS
stoner/M
stonewall/GSD
stoneware/M
stonewashed
stonework/M
stonily
stoniness/M
stonkered
stonking
stony/TRP
stood
stooge/MS
stool/SM
stoop/GSMD
stop's
stop/US
stopcock/SM
stopgap/SM
stoplight/MS
stopover/MS
stoppable/U
stoppage/MS
stopped/U
stopper/GSMD
stopping/U
stopple/DSMG
stopwatch/MS
storage/M
store's
store/ADSG
storefront/MS
storehouse/MS
storekeeper/SM
storeroom/SM
stork/SM
storm/GSMD
stormily
storminess/M
stormy/RPT
story/DSM
storyboard/MS
storybook/SM
storyteller/MS
storytelling/M
stoup/SM
stout/TSMRYP
stouthearted
stoutness/M
stove/SM
stovepipe/SM
stow/DGS
stowage/M
stowaway/MS
straddle/DRSMZG
straddler/M
strafe/MGDS
straggle/DRSZG
straggler/M
straggly/TR
straight/SPXTMNRY
straightaway/SM
straightedge/SM
straighten/ZGDR
straightener/M
straightforward/YPS
straightforwardness/M
straightness/M
straightway
strain's
strain/FADSG
strainer/ASM
strait/MNSX
straiten/GD
straitjacket/SGMD
straitlaced
strand/MDSG
strange/PRYZT
strangeness/M
stranger/M
strangle/ZGDRS
stranglehold/SM
strangler/M
strangulate/GNDS
strangulation/M
strap's
strap/US
strapless/MS
strapped/U
strapping/M
strata
stratagem/SM
strategic/S
strategical/Y
strategics/M
strategist/SM
strategy/SM
strati
stratification/M
stratify/DSGN
stratosphere/SM
stratospheric
stratum/M
stratus/M
straw/GSMD
strawberry/SM
stray/GSMD
streak/MDRSZG
streaker/M
streaky/TR
stream/MDRSZG
streamer/M
streamline/DSG
street/MS
streetcar/MS
streetlamp/S
streetlight/SM
streetwalker/SM
streetwise
strength/M
strengthen/AGDS
strengthener/MS
strengths
strenuous/PY
strenuousness/M
strep/M
streptococcal
streptococci
streptococcus/M
streptomycin/M
stress/MDSG
stressed/U
stressful
stretch/BZGMDRS
stretcher/MDG
stretchmarks
stretchy/TR
strew/GSDH
strewn
stria/M
striae
striated
striation/MS
stricken
strict/RYPT
strictness/M
stricture/SM
stridden
stride/MGS
stridency/M
strident/Y
strife/M
strike/MZGRSJ
strikebound
strikebreaker/SM
strikebreaking
strikeout/MS
striker/M
striking/Y
string/MDRSZG
stringency/M
stringent/Y
stringer/M
stringiness/M
stringy/PTR
strip/GSMD
stripe/MS
stripey
stripling/MS
stripped
stripper/MS
stripping
striptease/MZGDRS
stripteaser/M
stripy
strive/GS
striven
strobe/MS
stroboscope/MS
stroboscopic
strode
stroke/MGDS
stroll/MDRSZG
stroller/M
strong/RYT
strongbox/MS
stronghold/MS
strongman/M
strongmen
strongroom/S
strontium/M
strop/SM
strophe/SM
strophic
stropped
stroppily
stropping
stroppy/TRP
strove
struck
structural/Y
structuralism
structuralist/S
structure's
structure/AGDS
structured/U
strudel/SM
struggle/MGDS
strum/SM
strummed
strumming
strumpet/MS
strung/UA
strut/SM
strutted
strutting
strychnine/M
stub/MS
stubbed
stubbing
stubble/M
stubbly
stubborn/RYPT
stubbornness/M
stubby/RT
stucco/MDG
stuccoes
stuck/U
stud/MYS
studbook/MS
studded
studding/M
student/SM
studentship/S
studied/U
studiedly
studio/MS
studious/PY
studiousness/M
studly/RT
study's
study/AGDS
stuff/GSMDJ
stuffily
stuffiness/M
stuffing/M
stuffy/RPT
stultification/M
stultify/DSNG
stumble/DRSMZG
stumbler/M
stump/GSMD
stumpy/TR
stun/S
stung
stunk
stunned
stunner/S
stunning/Y
stunt/GSMD
stuntman
stuntmen
stupefaction/M
stupefy/DSG
stupendous/Y
stupid/TMRYS
stupidity/SM
stupor/MS
sturdily
sturdiness/M
sturdy/TRP
sturgeon/SM
stutter/MDRSZG
stutterer/M
sty/SM
style's
style/ADSG
styli
stylish/PY
stylishness/M
stylist/SM
stylistic/S
stylistically
stylize/DSG
stylus/MS
stymie/MDS
stymieing
styptic/SM
suasion/EM
suave/RYTP
suaveness/M
suavity/M
sub/SM
subaltern/MS
subaqua
subarctic
subarea/MS
subatomic
subbasement/SM
subbed
subbing
subbranch/MS
subcategory/SM
subclass
subcommittee/SM
subcompact/SM
subconscious/PMY
subconsciousness/M
subcontinent/SM
subcontinental
subcontract/MDSG
subcontractor/MS
subculture/MS
subcutaneous/Y
subdivide/GDS
subdivision/SM
subdominant
subdue/DSG
subeditor/S
subfamily/SM
subfreezing
subgroup/MS
subhead/GJMS
subheading/M
subhuman/MS
subj
subject/GVMDS
subjection/M
subjective/Y
subjectivity/M
subjoin/GDS
subjugate/GNDS
subjugation/M
subjunctive/SM
sublease/MGDS
sublet/SM
subletting
sublieutenant/S
sublimate/GNDS
sublimation/M
sublime/YTGDRS
subliminal/Y
sublimity/M
sublingual
submarginal
submarine/MZRS
submariner/M
submerge/GDS
submergence/M
submerse/GNDS
submersible/MS
submersion/M
submicroscopic
submission/MS
submissive/PY
submissiveness/M
submit/AS
submitted/A
submitter
submitting/A
subnormal
suborbital
suborder/MS
subordinate/DSMGN
subordination/IM
suborn/SGD
subornation/M
subparagraph
subplot/MS
subpoena/GMDS
subprime
subprofessional/SM
subprogram/S
subroutine/SM
subscribe/UASDG
subscriber/MS
subscript/MS
subscription/MS
subsection/MS
subsequent/Y
subservience/M
subservient/Y
subset/SM
subside/GDS
subsidence/M
subsidiarity
subsidiary/SM
subsidization/M
subsidize/ZGDRS
subsidizer/M
subsidy/SM
subsist/SDG
subsistence/M
subsoil/M
subsonic
subspace
subspecies/M
substance/SM
substandard
substantial/IY
substantiate/GNDSX
substantiated/U
substantiation/FM
substantive/SMY
substation/MS
substituent
substitute/XMGNDS
substitution/M
substrata
substrate/MS
substratum/M
substructure/SM
subsume/DSG
subsumption
subsurface/M
subsystem/SM
subteen/SM
subtenancy/M
subtenant/SM
subtend/SDG
subterfuge/SM
subterranean
subtext/SM
subtitle/DSMG
subtle/TR
subtlety/SM
subtly
subtopic/SM
subtotal/SGMD
subtract/GSD
subtraction/SM
subtrahend/SM
subtropic/S
subtropical
subtropics/M
suburb/MS
suburban/SM
suburbanite/SM
suburbia/M
subvention/SM
subversion/M
subversive/SPMY
subversiveness/M
subvert/SDG
subway/MS
subzero
succeed/GDS
success/VMS
successful/UY
succession/SM
successive/Y
successor/SM
succinct/RYTP
succinctness/M
succor/SGMD
succotash/M
succubi
succubus
succulence/M
succulency/M
succulent/SM
succumb/GDS
such
suchlike
suck/MDRZGS
sucker/GMD
suckle/DSJG
suckling/M
sucrose/M
suction/SMDG
sudden/PY
suddenness/M
suds/M
sudsy/TR
sue/DSG
suede/M
suet/M
suety
suffer/DRZGSJ
sufferance/M
sufferer/M
suffering/M
suffice/DSG
sufficiency/IM
sufficient/IY
suffix/MDSG
suffixation/M
suffocate/GNDS
suffocation/M
suffragan/MS
suffrage/M
suffragette/SM
suffragist/MS
suffuse/DSGN
suffusion/M
sugar/GSMD
sugarcane/M
sugarcoat/GDS
sugarless
sugarplum/MS
sugary/RT
suggest/GVSDR
suggestibility/M
suggestible
suggestion/SM
suggestive/YP
suggestiveness/M
suicidal
suicide/SM
suit/BMDGS
suitability/UM
suitableness/M
suitably/U
suitcase/SM
suite/SM
suited/U
suiting/M
suitor/MS
sukiyaki/M
sulfa/M
sulfate/SM
sulfide/SM
sulfonamides
sulfur/MDSG
sulfuric
sulfurous
sulk/MDGS
sulkily
sulkiness/M
sulky/TRSMP
sullen/RYPT
sullenness/M
sullied/U
sully/GDS
sultan/MS
sultana/SM
sultanate/MS
sultrily
sultriness/M
sultry/RPT
sum/SM
sumac/M
summarily
summarize/GDS
summary/SM
summat
summation/FMS
summed
summer/MDSG
summerhouse/SM
summertime/M
summery
summing
summit/MS
summitry/M
summon/DRSZG
summoner/M
summons/GMDS
sumo/M
sump/MS
sumptuous/PY
sumptuousness/M
sun/SM
sunbath/ZGMDRS
sunbathe
sunbather/M
sunbathing/M
sunbaths
sunbeam/SM
sunbed/S
sunbelt/SM
sunblock/MS
sunbonnet/SM
sunburn/SGMD
sunburst/MS
sundae/MS
sundeck/S
sunder/DSG
sundial/SM
sundown/SM
sundress/S
sundries/M
sundry/S
sunfish/MS
sunflower/MS
sung/U
sunglasses/M
sunhat/S
sunk/N
sunlamp/SM
sunless
sunlight/M
sunlit
sunned
sunniness/M
sunning
sunny/TRP
sunrise/SM
sunroof/SM
sunscreen/MS
sunset/MS
sunshade/MS
sunshine/M
sunshiny
sunspot/SM
sunstroke/M
suntan/MS
suntanned
suntanning
suntrap/S
sunup/M
sup/SZMR
super/M
superabundance/MS
superabundant
superannuate/GNDS
superannuation/M
superb/RYT
supercargo/M
supercargoes
supercharge/ZGDRS
supercharger/M
supercilious/PY
superciliousness/M
supercity/SM
supercomputer/MS
superconducting
superconductive
superconductivity/M
superconductor/SM
superego/MS
supererogation/M
supererogatory
superficial/Y
superficiality/M
superfine
superfluity/M
superfluous/YP
superfluousness/M
superglue
supergrass/S
superhero/MS
superheroes
superhighway/SM
superhuman
superimpose/GDS
superimposition/M
superintend/DSG
superintendence/M
superintendency/M
superintendent/SM
superior/MS
superiority/M
superlative/SMY
superman/M
supermarket/SM
supermen
supermodel/SM
supermom/MS
supernal
supernatural/SY
supernova/MS
supernovae
supernumerary/SM
superpose/GDS
superposition/M
superpower/SM
supersaturate/GNDS
supersaturation/M
superscribe/GDS
superscript/MS
superscription/M
supersede/GDS
supersize/GDS
supersonic
superstar/MS
superstate/S
superstition/MS
superstitious/Y
superstore/MS
superstructure/MS
supertanker/MS
superuser/S
supervene/GDS
supervention/M
supervise/XGNDS
supervised/U
supervision/M
supervisor/MS
supervisory
superwoman/M
superwomen
supine/Y
supp/DRZG
supper/M
suppertime
suppl
supplant/SDG
supple/TLPR
supplement/MDGS
supplemental
supplementary
supplementation/M
suppleness/M
suppliant/SM
supplicant/MS
supplicate/GDS
supplication/M
supplier/M
supply/ZGDRSMXN
support/MDRSBZGV
supportable/UI
supported/U
supporter/M
suppose/GDS
supposed/Y
supposition/MS
suppository/SM
suppress/GDS
suppressant/MS
suppressible
suppression/M
suppressor/SM
suppurate/DSGN
suppuration/M
supra
supranational
supremacist/MS
supremacy/M
supreme/Y
supremo/S
supt
surcease/DSMG
surcharge/DSMG
surcingle/SM
sure/PYTR
surefire
surefooted
sureness/M
surety/SM
surf/MDRZGS
surface's
surface/AGDS
surfboard/MDSG
surfeit/MDSG
surfer/M
surfing/M
surge/DSMG
surgeon/MS
surgery/SM
surgical/Y
surliness/M
surly/PTR
surmise/MGDS
surmount/DGSB
surmountable/I
surname/MS
surpass/GDS
surpassed/U
surplice/MS
surplus/MS
surplussed
surplussing
surprise/DSMGJ
surprising/UY
surreal
surrealism/M
surrealist/SM
surrealistic
surrealistically
surrender/MDSG
surreptitious/PY
surreptitiousness/M
surrey/MS
surrogacy/M
surrogate/SM
surround/GSDJ
surrounding/M
surroundings/M
surtax/MDSG
surtitle/S
surveillance/M
survey's
survey/ADGS
surveying/M
surveyor/SM
survival/SM
survivalist/SM
survive/DSGB
survivor/SM
susceptibility/SM
susceptible/I
sushi/M
suspect/SMDG
suspected/U
suspend/SDRZG
suspender/M
suspense/XMN
suspenseful
suspension/M
suspicion/SM
suspicious/Y
suss/DSG
sustain/SDBG
sustainability
sustainable/U
sustenance/M
sutler/MS
suttee
suture/MGDS
suzerain/MS
suzerainty/M
svelte/TR
swab/MS
swabbed
swabbing
swaddle/DSG
swag/MS
swagged
swagger/SMDRG
swagging
swain/SM
swallow/GSMD
swallowtail/MS
swam
swami/SM
swamp/GSMD
swampland/M
swampy/RT
swan/MS
swank/TGSMDR
swankily
swankiness/M
swanky/RPT
swanned
swanning
swansong/S
swap/MS
swapped
swapping
sward/SM
swarm/GSMD
swarthy/TR
swash/GMDS
swashbuckler/SM
swashbuckling/M
swastika/SM
swat/MS
swatch/MS
swath/GMDS
swathe/M
swaths
swatted
swatter/SMDG
swatting
sway/MDGS
swayback/MD
swayed/U
swear/ZGSR
swearer/M
swearword/MS
sweat/ZGSMDR
sweatband/MS
sweater/M
sweatpants/M
sweats/M
sweatshirt/SM
sweatshop/MS
sweatsuit/S
sweaty/RT
swede/SM
sweep/ZGSMRJ
sweeper/M
sweeping/MY
sweepings/M
sweepstakes/M
sweet/XTSMNRYP
sweetbread/SM
sweetbrier/SM
sweetcorn
sweetened/U
sweetener/MS
sweetening/M
sweetheart/SM
sweetie/SM
sweetish
sweetmeat/MS
sweetness/M
swell/TGSMDRJ
swellhead/MDS
swelling/M
swelter/SGMD
swept
sweptback
swerve/MGDS
swerving/U
swift/PTSMRY
swiftness/M
swig/MS
swigged
swigging
swill/GSMD
swim/MS
swimmer/SM
swimming/MY
swimsuit/SM
swimwear
swindle/DRSMZG
swindler/M
swine/SM
swineherd/SM
swing/ZGSMR
swingeing
swinger/M
swinish
swipe/DSMG
swirl/GSMD
swirly
swish/TGMDRS
switch/MDRSZGB
switchback/MS
switchblade/SM
switchboard/SM
switcher/M
swivel/MDGS
swiz
swizz
swizzle/DSG
swollen
swoon/SGMD
swoop/SGMD
swoosh/MDSG
sword/SM
swordfish/MS
swordplay/M
swordsman/M
swordsmanship/M
swordsmen
swore
sworn
swot/S
swotted
swotting
swum
swung
sybarite/SM
sybaritic
sycamore/MS
sycophancy/M
sycophant/SM
sycophantic
syllabic
syllabicate/GNDS
syllabication/M
syllabification/M
syllabify/DSNG
syllable/MS
syllabub/S
syllabus/MS
syllogism/MS
syllogistic
sylph/M
sylphic
sylphlike
sylphs
sylvan
symbioses
symbiosis/M
symbiotic
symbiotically
symbol/MS
symbolic
symbolical/Y
symbolism/M
symbolization/M
symbolize/DSG
symmetric
symmetrical/Y
symmetry/SM
sympathetic/U
sympathetically/U
sympathies/M
sympathize/ZGDRS
sympathizer/M
sympathy/SM
symphonic
symphony/SM
symposium/MS
symptom/MS
symptomatic
symptomatically
syn/H
synagogal
synagogue/SM
synapse/MS
synaptic
sync/MDSG
synchronicity
synchronization/SM
synchronize/GDS
synchronous/Y
syncopate/DSGN
syncopation/M
syncope/M
syndicalism
syndicalist/S
syndicate/DSMGN
syndication/M
syndrome/SM
synergism/M
synergistic
synergy/SM
synfuel/MS
synod/SM
synonym/SM
synonymous
synonymy/M
synopses
synopsis/M
synoptic
synovial
syntactic
syntactical/Y
syntax/M
syntheses
synthesis/M
synthesize/ZGDRS
synthesizer/M
synthetic/SM
synthetically
synths
syphilis/M
syphilitic/SM
syringe/DSMG
syrup/SM
syrupy
sysadmin/S
sysop/S
system/SM
systematic/U
systematical/Y
systematization/M
systematize/GDS
systemic/MS
systemically
systole/SM
systolic
t/SDNXGBJ
ta
tab/SM
tabbed
tabbing
tabbouleh/M
tabby/SM
tabernacle/SM
tabla/MS
table/MGDS
tableau/M
tableaux
tablecloth/M
tablecloths
tableland/SM
tablespoon/SM
tablespoonful/SM
tablet/SM
tabletop/MS
tableware/M
tabloid/SM
taboo/MDSG
tabor/MS
tabular
tabulate/DSGNX
tabulation/M
tabulator/SM
tachograph
tachographs
tachometer/SM
tachycardia/M
tachyon
tacit/PY
tacitness/M
taciturn/Y
taciturnity/M
tack/ZGMDRS
tacker/M
tackiness/M
tackle/DRSMZG
tackler/M
tacky/RTP
taco/MS
tact/FM
tactful/YP
tactfulness/M
tactic/SM
tactical/Y
tactician/MS
tactile
tactility/M
tactless/PY
tactlessness/M
tad/SM
tadpole/MS
taffeta/M
taffrail/SM
taffy/SM
tag/SM
tagged
tagger/SM
tagging
tagliatelle
tagline/MS
taiga/MS
tail/ACSDMG
tailback/MS
tailboard/S
tailbone/S
tailcoat/MS
tailgate/MZGDRS
tailgater/M
tailless
taillight/MS
tailor/SGMD
tailoring/M
tailpiece/S
tailpipe/SM
tailspin/SM
tailwind/SM
taint/MDSG
tainted/U
take/AIMS
takeaway/S
taken/A
takeoff/MS
takeout/MS
takeover/SM
taker/MS
taking/SM
takings/M
talc/M
talcum/M
tale/MS
talebearer/MS
talent/SMD
talented/U
tali
talisman/MS
talk/ZGMDRS
talkative/PY
talkativeness/M
talker/M
talkie/RSMT
talky
tall/TRP
tallboy/MS
tallier/M
tallish
tallness/M
tallow/M
tallowy
tally/DRSMZG
tallyho/MDGS
talon/MS
talus/MS
tam/SM
tamale/SM
tamarack/MS
tamarind/MS
tambourine/MS
tame/BYZTGDRSP
tamed/U
tameness/M
tamer/M
tamoxifen
tamp/ZGDRS
tamper/ZGDR
tamperer/M
tampon/SM
tan/SM
tanager/MS
tanbark/M
tandem/SM
tandoori/M
tang/MS
tangelo/MS
tangent/MS
tangential/Y
tangerine/MS
tangibility/IM
tangible/IMS
tangibleness/M
tangibly/I
tangle's
tangle/UDSG
tango/MDSG
tangy/RT
tank/ZGMDRS
tankard/MS
tanker/M
tankful/MS
tanned/U
tanner/SM
tannery/SM
tannest
tannin/M
tanning/M
tansy/M
tantalization/M
tantalize/ZGDRS
tantalizer/M
tantalizing/Y
tantalum/M
tantamount
tantra/M
tantrum/SM
tap/SZGMDR
tapas
tape/MS
tapeline/MS
taper/MDG
tapestry/SM
tapeworm/MS
tapioca/M
tapir/MS
tapped/U
tapper/MS
tappet/MS
tapping
taproom/SM
taproot/SM
tar/SGMD
taramasalata
tarantella/MS
tarantula/SM
tarball/S
tardily
tardiness/M
tardy/TPR
tare/MS
target/MDGS
tariff/MS
tarmac/MS
tarmacadam
tarmacked
tarmacking
tarn/MS
tarnish/GMDS
tarnished/U
taro/MS
tarot/MS
tarp/MS
tarpaulin/MS
tarpon/MS
tarragon/SM
tarred
tarring
tarry/TGDRS
tarsal/MS
tarsi
tarsus/M
tart/PTGMDRYS
tartan/MS
tartar/MS
tartaric
tartness/M
tarty/T
taser/GMDS
task/GMDS
taskmaster/MS
taskmistress/MS
tassel/MDSG
taste/JMZGDRS
tasted/U
tasteful/EPY
tastefulness/EM
tasteless/PY
tastelessness/M
taster/M
tastily
tastiness/M
tasting/M
tasty/TRP
tat/SZR
tatami/MS
tater/M
tatted
tatter/MDSG
tatterdemalion/MS
tattie
tatting/M
tattle/MZGDRS
tattler/M
tattletale/MS
tattoo/MDRSZG
tattooer/M
tattooist/SM
tatty/TRS
tau/SM
taught/UA
taunt/ZGMDRS
taunter/M
taunting/Y
taupe/M
taut/PXTNRY
tauten/DG
tautness/M
tautological/Y
tautologous
tautology/SM
tavern/MS
tawdrily
tawdriness/M
tawdry/RTP
tawny/TRM
tax/BZGMDRS
taxa
taxation/M
taxer/M
taxi/GMDS
taxicab/SM
taxidermist/SM
taxidermy/M
taximeter/MS
taxiway/S
taxman
taxmen
taxon
taxonomic
taxonomist/MS
taxonomy/SM
taxpayer/MS
taxpaying
tb/S
tbsp
tea/SM
teabag/S
teacake/SM
teach/ZGRSBJ
teachable/U
teacher/M
teaching/M
teacup/MS
teacupful/MS
teak/MS
teakettle/SM
teal/MS
tealight/MS
team/GMDS
teammate/MS
teamster/MS
teamwork/M
teapot/MS
tear/GMDS
tearaway/S
teardrop/SM
tearful/Y
teargas/MS
teargassed
teargassing
tearjerker/MS
tearoom/SM
teary/TR
tease/MZGDRS
teasel/MS
teaser/M
teasing/Y
teaspoon/SM
teaspoonful/SM
teat/MS
teatime/S
tech/M
techie/S
technetium/M
technical/Y
technicality/SM
technician/SM
technicolor
technique/SM
techno
technobabble
technocracy/SM
technocrat/MS
technocratic
technological/Y
technologist/MS
technology/SM
technophobe/S
techs
tectonic/S
tectonics/M
ted/S
teddy/S
tedious/PY
tediousness/M
tedium/M
tee/DSMH
teeing
teem/GDS
teen/MS
teenage/RZ
teenager/M
teeny/TR
teenybopper/MS
teeter/MDSG
teethe/GDS
teething/M
teetotal/RZ
teetotaler/M
teetotalism/M
tektite/SM
tel
telecast/SZGMR
telecaster/M
telecommunication/MS
telecommunications/M
telecommute/ZGDRS
telecommuter/M
telecommuting/M
teleconference/MGDS
teleconferencing/M
telegenic
telegram/MS
telegraph/MDRZG
telegrapher/M
telegraphese
telegraphic
telegraphically
telegraphist/SM
telegraphs
telegraphy/M
telekinesis/M
telekinetic
telemarketer/SM
telemarketing/M
telemeter/SM
telemetry/SM
teleological
teleology
telepathic
telepathically
telepathy/M
telephone/DRSMZG
telephoner/M
telephonic
telephonist/S
telephony/M
telephoto/SM
telephotography/M
teleplay/MS
teleport
teleportation
teleprinter/MS
teleprocessing/M
teleprompter/SM
telesales
telescope/DSMG
telescopic
telescopically
teletext/MS
telethon/MS
teletype/S
teletypewriter/MS
televangelism/M
televangelist/MS
televise/XGNDS
television/M
teleworker/S
teleworking
telex/MDSG
tell/AGS
teller/SM
telling/Y
telltale/SM
tellurium/M
telly/SM
telnet
temblor/MS
temerity/M
temp/MDRZTGS
temper/MDG
tempera/LSM
temperament/MS
temperamental/Y
temperance/IM
temperate/IY
temperateness/M
temperature/SM
tempest/SM
tempestuous/YP
tempestuousness/M
template's
template/S
temple/SM
tempo/SM
temporal/Y
temporarily
temporariness/M
temporary/FSM
temporize/ZGDRS
temporizer/M
tempt/SDRZG
temptation/MS
tempter/M
tempting/Y
temptress/MS
tempura/M
ten/BMH
tenability/M
tenable/U
tenably
tenacious/YP
tenaciousness/M
tenacity/M
tenancy/SM
tenant/SMDG
tenanted/U
tenantry/M
tench
tend/IEFDGS
tended/U
tendency/SM
tendentious/YP
tendentiousness/M
tender/SMDRYTGP
tenderfoot/MS
tenderhearted/P
tenderheartedness/M
tenderize/ZGDRS
tenderizer/M
tenderloin/SM
tenderness/M
tendinitis/M
tendon/SM
tendril/SM
tenement/SM
tenet/SM
tenfold
tenner/S
tennis/M
tenon/SMDG
tenor/SM
tenpin/SM
tenpins/M
tense/DRSMYTGNXP
tenseness/M
tensile
tension/ESM
tensity/IM
tensor/S
tent/DGSM
tentacle/DSM
tentative/PY
tentativeness/M
tenterhook/MS
tenth/MY
tenths
tenuity/M
tenuous/PY
tenuousness/M
tenure/DSMG
tepee/SM
tepid/YP
tepidity/M
tepidness/M
tequila/SM
terabit/SM
terabyte/MS
terahertz/M
terapixel/MS
terbium/M
tercentenary/SM
tercentennial/SM
teriyaki
term/MDYGS
termagant/MS
terminable/IC
terminal/MYS
terminate/DSGNX
termination/CSM
terminator/S
termini
terminological/Y
terminology/SM
terminus/M
termite/SM
tern/IMS
ternary/SM
terr
terrace/DSMG
terracotta/M
terrain/SM
terrapin/MS
terrarium/SM
terrazzo/MS
terrestrial/SMY
terrible/P
terribleness/M
terribly
terrier/M
terrific
terrifically
terrify/GDS
terrifying/Y
terrine/S
territorial/MS
territoriality
territory/SM
terror/SM
terrorism/M
terrorist/SM
terrorize/DSG
terry/RMZ
terrycloth/M
terse/RYTP
terseness/M
tertiary
tessellate/DSXGN
tessellation/M
test's/AFK
test/AKFCDGS
testable/CF
testament/MS
testamentary
testate/S
testator/MS
testatrices
testatrix/M
tested/U
tester/KSM
testes
testicle/MS
testicular
testifier/M
testify/ZGDRS
testily
testimonial/MS
testimony/SM
testiness/M
testings
testis/M
testosterone/M
testy/PRT
tetanus/M
tetchily
tetchy/PRT
tether/SMDG
tetra/SM
tetracycline/M
tetrahedral
tetrahedron/MS
tetrameter/SM
text/FMS
textbook/SM
texted
textile/MS
texting
textual/FY
textural
texture/MGDS
thalami
thalamus/M
thalidomide/M
thallium/M
than
thane/SM
thank/SDG
thankful/YP
thankfulness/M
thankless/PY
thanklessness/M
thanksgiving/SM
that/M
thatch/MDRSZG
thatcher/M
thatching/M
thaw/MDGS
the/JG
theater/SM
theatergoer/SM
theatrical/YS
theatricality/M
theatricals/M
theatrics/M
thee/S
theft/SM
their/S
theism/M
theist/SM
theistic
them
thematic
thematically
theme/DSM
themselves
then/M
thence
thenceforth
thenceforward
theocracy/SM
theocratic
theodolite/S
theologian/SM
theological/Y
theology/SM
theorem/MS
theoretic
theoretical/Y
theoretician/SM
theorist/SM
theorize/DSG
theory/SM
theosophic
theosophical
theosophist/SM
theosophy/M
therapeutic/S
therapeutically
therapeutics/M
therapist/SM
therapy/SM
there/M
thereabout/S
thereafter
thereat
thereby
therefor
therefore
therefrom
therein
theremin/SM
thereof
thereon
thereto
theretofore
thereunto
thereupon
therewith
therm/SM
thermal/MYS
thermionic
thermodynamic/S
thermodynamics/M
thermometer/MS
thermometric
thermonuclear
thermoplastic/SM
thermos/MS
thermostat/MS
thermostatic
thermostatically
thesauri
thesaurus/MS
these/S
thesis/M
thespian/SM
theta/SM
thew/MS
they
they'd
they'll
they're
they've
thiamine/M
thick/PMNRYXT
thicken/DRJZG
thickener/M
thickening/M
thicket/MS
thickheaded/M
thickness/MS
thicko/S
thickset
thief/M
thieve/DSG
thievery/M
thieving/M
thievish
thigh/M
thighbone/MS
thighs
thimble/MS
thimbleful/SM
thin/YSP
thine
thing/M
thingamabob/SM
thingamajig/SM
thingumabob/S
thingummy/S
thingy/S
think/SRBZG
thinkable/U
thinker/M
thinking's
thinned
thinner/MS
thinness/M
thinnest
thinning
third/SMY
thirst/SGMD
thirstily
thirstiness/M
thirsty/TPR
thirteen/SMH
thirteenth/M
thirteenths
thirtieth/M
thirtieths
thirty/HSM
this
thistle/MS
thistledown/M
thither
tho
thole/SM
thong/SM
thoracic
thorax/MS
thorium/M
thorn/SM
thorniness/M
thorny/PRT
thorough/RYPT
thoroughbred/MS
thoroughfare/MS
thoroughgoing
thoroughness/M
those
thou/MS
though
thought/SM
thoughtful/YP
thoughtfulness/M
thoughtless/PY
thoughtlessness/M
thousand/MHS
thousandfold
thousandth/M
thousandths
thrall/SMDG
thralldom/M
thrash/JMDRSZG
thrasher/M
thrashing/M
thread/SMDRZG
threadbare
threader/M
threadlike
thready/TR
threat/SMNX
threaten/DG
threatening/Y
three/SM
threefold
threepence/M
threescore/MS
threesome/SM
threnody/SM
thresh/MDRSZG
thresher/M
threshold/SM
threw
thrice
thrift/SM
thriftily
thriftiness/M
thriftless
thrifty/PTR
thrill/SMDRZG
thriller/M
thrilling/Y
thrive/DSG
throat/SM
throatily
throatiness/M
throaty/RTP
throb/SM
throbbed
throbbing
throe/SM
thrombi
thrombolytic
thromboses
thrombosis/M
thrombotic
thrombus/M
throne's
throne/S
throng/GSMD
throttle/DRSMZG
throttler/M
through
throughout
throughput/M
throw/SMRZG
throwaway/SM
throwback/SM
thrower/M
thrown
thru
thrum/SM
thrummed
thrumming
thrush/MS
thrust/GSM
thruway/MS
thud/MS
thudded
thudding
thug/MS
thuggery/M
thuggish
thulium/M
thumb/SMDG
thumbnail/SM
thumbprint/SM
thumbscrew/SM
thumbtack/SM
thump/SMDG
thumping/M
thunder/ZGMDRS
thunderbolt/SM
thunderclap/SM
thundercloud/MS
thunderer/M
thunderhead/SM
thunderous/Y
thundershower/SM
thunderstorm/SM
thunderstruck
thundery
thunk/S
thus
thwack/ZGSMDR
thwacker/M
thwart/GSMD
thy
thyme/M
thymine/M
thymus/MS
thyroid/MS
thyroidal
thyself
ti/MRZ
tiara/SM
tibia/M
tibiae
tibial
tic/SM
tick/MDRZGS
ticker/M
ticket/GSMD
ticking/M
tickle/DRSMZG
tickler/M
ticklish/YP
ticklishness/M
ticktacktoe/M
ticktock/MS
tidal/Y
tidbit/SM
tiddler/S
tiddly
tiddlywink/S
tiddlywinks/M
tide/MGJDS
tideland/SM
tidemark/S
tidewater/MS
tideway/MS
tidily/U
tidiness/UM
tidings/M
tidy/DRSMTGP
tie's
tie/AUSD
tieback/MS
tiebreak/RSZ
tiebreaker/M
tiepin/S
tier/MD
tiff/MDGS
tiger/SM
tigerish
tight/SNRYPXT
tighten/ZGDR
tightener/M
tightfisted
tightness/M
tightrope/MS
tights/M
tightwad/MS
tigress/MS
til
tilapia
tilde/SM
tile/MZGDRS
tiler/M
tiling/M
till's
till/EDRZGS
tillable
tillage/M
tiller/EM
tilt/MDGS
timber/SMDG
timberland/M
timberline/MS
timbre/SM
timbrel/SM
time/MYZGJDRS
timekeeper/MS
timekeeping/M
timeless/PY
timelessness/M
timeline/MS
timeliness/UM
timely/UPRT
timeout/SM
timepiece/MS
timer/M
timescale/S
timeserver/SM
timeserving/M
timeshare/S
timetable/DSMG
timeworn
timezone
timid/RYTP
timidity/M
timidness/M
timing/M
timorous/PY
timorousness/M
timothy/M
timpani/M
timpanist/SM
tin/SM
tincture/MGDS
tinder/M
tinderbox/MS
tine/MS
tinfoil/M
ting/MDYG
tinge/SM
tingeing
tingle/DSMGJ
tingling/M
tininess/M
tinker/ZGSMDR
tinkerer/M
tinkle/DSMG
tinned
tinniness/M
tinning
tinnitus/M
tinny/PRT
tinplate/M
tinpot
tinsel/GSMD
tinsmith/M
tinsmiths
tint/MDGS
tintinnabulation/MS
tintype/MS
tinware/M
tiny/RTP
tip/SM
tipped
tipper/SM
tippet/SM
tippex/GDS
tipping
tipple/DRSMZG
tippler/M
tipsily
tipsiness/M
tipster/MS
tipsy/RPT
tiptoe/DSM
tiptoeing
tiptop/SM
tirade/SM
tiramisu/MS
tire's
tire/AGDS
tired/PRYT
tiredness/M
tireless/YP
tirelessness/M
tiresome/PY
tiresomeness/M
tissue/SM
tit/SM
titan/SM
titanic
titanium/M
titch/S
titchy
tithe/DRSMZG
tither/M
titian/M
titillate/DSGN
titillating/Y
titillation/M
titivate/DSGN
titivation/M
title/DSMG
titled/U
titleholder/MS
titlist/MS
titmice
titmouse/M
titter/SGMD
tittle/SM
titty/S
titular
tizz
tizzy/SM
tn
tnpk
to/IU
toad/MS
toadstool/MS
toady/DSMG
toadyism/M
toast/SMDRZG
toaster/M
toastmaster/SM
toastmistress/MS
toasty/TRS
tobacco/MS
tobacconist/SM
toboggan/ZGSMDR
tobogganer/M
tobogganing/M
toccata/S
tocsin/SM
today/M
toddle/DRSMZG
toddler/M
toddy/SM
toe/DSM
toecap/SM
toehold/MS
toeing
toenail/MS
toerag/S
toff/S
toffee/SM
tofu/M
tog/SM
toga/MDS
together/P
togetherness/M
togged
togging
toggle/DSMG
togs/M
toil/MDRZGS
toiler/M
toilet/MDGS
toiletry/SM
toilette/M
toilsome
toke/MGDS
token/SM
tokenism/M
told/AU
tole/M
tolerable/I
tolerably/I
tolerance/IM
tolerances
tolerant/IY
tolerate/GNDS
toleration/M
toll/MDGS
tollbooth/M
tollbooths
tollgate/SM
tollway/SM
toluene/M
tom/SM
tomahawk/SGMD
tomato/M
tomatoes
tomb/MDGS
tombola/S
tomboy/MS
tomboyish
tombstone/MS
tomcat/MS
tome/MS
tomfoolery/SM
tomographic
tomography/M
tomorrow/MS
tomtit/MS
ton/SM
tonal/Y
tonality/SM
tone's
tone/IZGDRS
tonearm/SM
toneless/Y
toner/IM
tong/MDGS
tongue/MGDS
tongueless
tonic/SM
tonight/M
tonnage/SM
tonne/SM
tonsil/MS
tonsillectomy/SM
tonsillitis/M
tonsorial
tonsure/DSMG
tony/RT
too
took/A
tool's
tool/ADGS
toolbar/M
toolbox/MS
toolkit
toolmaker/MS
toot/MDRZGS
tooter/M
tooth/MD
toothache/MS
toothbrush/MS
toothily
toothless
toothpaste/SM
toothpick/SM
toothsome
toothy/RT
tootle/GDS
tootsie/S
top/SM
topaz/MS
topcoat/SM
topdressing/SM
topee/S
topflight
topi
topiary/M
topic/SM
topical/Y
topicality/M
topknot/SM
topless
topmast/SM
topmost
topnotch
topographer/SM
topographic
topographical/Y
topography/SM
topological/Y
topology
topped
topper/MS
topping/SM
topple/GDS
topsail/SM
topside/SM
topsoil/M
topspin/M
toque/SM
tor/SM
torch/GMDS
torchbearer/MS
torchlight/M
tore
toreador/MS
torment/SMDG
tormenting/Y
tormentor/MS
torn
tornado/M
tornadoes
torpedo/GMD
torpedoes
torpid/Y
torpidity/M
torpor/M
torque/MGDS
torrent/SM
torrential
torrid/YP
torridity/M
torridness/M
torsion/M
torsional
torso/SM
tort's
tort/FEAS
torte/SM
tortellini/M
tortilla/MS
tortoise/MS
tortoiseshell/SM
tortoni/M
tortuous/PY
tortuousness/M
torture/DRSMZG
torturer/M
torturous
torus
tosh
toss/MDRSZG
tossup/MS
tot/SGMD
total/GSMDY
totalitarian/SM
totalitarianism/M
totality/SM
totalizator/SM
tote/MS
totem/SM
totemic
totted
totter/ZGMDRS
totterer/M
totting
toucan/MS
touch/AGMDS
touchdown/SM
touche/BJ
touched/U
touchily
touchiness/M
touching/Y
touchline/S
touchpaper/S
touchscreen/MS
touchstone/MS
touchy/RPT
tough/XTGMDNRYP
toughen/ZGDR
toughener/M
toughie/SM
toughness/M
toughs
toupee/MS
tour/CFSGDM
tourism/M
tourist/MS
touristic
touristy
tourmaline/M
tournament/SM
tourney/MS
tourniquet/MS
tousle/GDS
tout/MDGS
tow/SZGMDR
toward/S
towboat/MS
towel/JGSMD
towelette/SM
toweling/M
tower/GMD
towhead/MDS
towhee/MS
towline/MS
town/MS
townee/S
townhouse/MS
townie/MS
townsfolk/M
township/MS
townsman/M
townsmen
townspeople/M
townswoman/M
townswomen
towpath/M
towpaths
towrope/SM
toxemia/M
toxic
toxicity/SM
toxicological
toxicologist/SM
toxicology/M
toxin/SM
toy/SGMD
toyboy/S
tr
trabecula
trabecular
trabecule
trace/JDRSMZG
traceable/U
tracer/M
tracery/SM
trachea/M
tracheae
tracheal
tracheotomy/SM
tracing/M
track/ZGSMDR
trackball/SM
tracker/M
trackless
tracksuit/S
tract's
tract/CEKFAS
tractability/IM
tractable/I
tractably/I
traction/EFACKM
tractor/FCKMS
trad
trade/JDRSMZG
trademark/SGMD
trader/M
tradesman/M
tradesmen
tradespeople/M
tradeswoman/M
tradeswomen
trading/M
tradition/MS
traditional/Y
traditionalism/M
traditionalist/SM
traduce/DRSZG
traducer/M
traffic/SM
trafficked
trafficker/SM
trafficking/M
tragedian/SM
tragedienne/MS
tragedy/SM
tragic
tragically
tragicomedy/SM
tragicomic
trail/ZGSMDR
trailblazer/MS
trailblazing/M
trailer/M
train/ZGSMDRB
trained/U
trainee/SM
trainer/M
training/M
trainload/MS
trainman/M
trainmen
trainspotter/S
trainspotting
traipse/DSMG
trait/SM
traitor/SM
traitorous/Y
trajectory/SM
tram/MS
tramcar/S
tramlines
trammed
trammel/SGMD
trammeled/U
tramming
tramp/ZGSMDR
tramper/M
trample/DRSMZG
trampler/M
trampoline/MGDS
tramway/S
trance/MS
tranche/S
tranquil/RYT
tranquility/M
tranquilize/ZGDRS
tranquilizer/M
trans/I
transact/DGS
transaction/SM
transactor/MS
transatlantic
transceiver/SM
transcend/GSD
transcendence/M
transcendent
transcendental/Y
transcendentalism/M
transcendentalist/SM
transcontinental
transcribe/ZGDRS
transcriber/M
transcript/MS
transcription/SM
transducer/MS
transect/DSG
transept/MS
transfer/MBS
transferal/MS
transference/M
transferred
transferring
transfiguration/M
transfigure/GDS
transfinite
transfix/DSG
transform/BSZGMDR
transformation/SM
transformer/M
transfuse/DSXGN
transfusion/M
transgender/S
transgenic
transgress/GDS
transgression/SM
transgressor/SM
transience/M
transiency/M
transient/SMY
transistor/SM
transistorize/DSG
transit/SGMD
transition/GSMD
transitional/Y
transitive/ISMY
transitiveness/M
transitivity/M
transitory
transl
translatable/U
translate/DSGNBX
translated/U
translation/M
translator/SM
transliterate/DSGNX
transliteration/M
translocation
translucence/M
translucency/M
translucent/Y
transmigrate/GNDS
transmigration/M
transmissible
transmission/MS
transmit/S
transmittable
transmittal/M
transmittance/M
transmitted
transmitter/SM
transmitting
transmogrification/M
transmogrify/DSNG
transmutation/SM
transmute/BDSG
transnational/MS
transoceanic
transom/SM
transpacific
transparency/SM
transparent/Y
transpiration/M
transpire/DSG
transplant/MDGS
transplantation/M
transpolar
transponder/SM
transport/BSZGMDR
transportation/M
transporter/M
transpose/DSG
transposition/MS
transsexual/SM
transsexualism/M
transship/SL
transshipment/M
transshipped
transshipping
transubstantiation/M
transverse/MYS
transvestism/M
transvestite/MS
trap/MS
trapdoor/MS
trapeze/SM
trapezium/SM
trapezoid/SM
trapezoidal
trappable
trapped
trapper/SM
trapping/S
trappings/M
trapshooting/M
trash/GMDS
trashcan/MS
trashiness/M
trashy/RPT
trauma/MS
traumatic
traumatically
traumatize/GDS
travail/SGMD
travel/MDRSZGJ
traveled/U
traveler/M
traveling/M
travelogue/MS
traversal/SM
traverse/DSMG
travesty/GDSM
trawl/ZGSMDR
trawler/M
tray/MS
treacherous/PY
treacherousness/M
treachery/SM
treacle/M
treacly
tread/AGSM
treadle/DSMG
treadmill/MS
treas
treason/BM
treasonous
treasure/DRSMZG
treasurer/M
treasury/SM
treat/AGSMD
treatable
treated/U
treatise/SM
treatment/MS
treaty/SM
treble/MGDS
tree/MDS
treeing
treeless
treelike
treeline
treetop/SM
trefoil/SM
trek/MS
trekked
trekker/SM
trekking
trellis/GMDS
trematode/MS
tremble/DSMG
tremendous/Y
tremolo/SM
tremor/MS
tremulous/PY
tremulousness/M
trench's
trench/ADSG
trenchancy/M
trenchant/Y
trencher/MS
trencherman/M
trenchermen
trend/GSMD
trendily
trendiness/M
trendsetter/S
trendsetting
trendy/RSMPT
trepidation/M
trespass/MDRSZG
trespasser/M
tress/EMS
trestle/MS
trews
trey/MS
triad/SM
triage/M
trial/ASM
trialed
trialing
triangle/SM
triangular/Y
triangulate/GNDS
triangulation/M
triathlete/S
triathlon/SM
tribal
tribalism/M
tribe/SM
tribesman/M
tribesmen
tribeswoman/M
tribeswomen
tribulation/SM
tribunal/SM
tribune/MS
tributary/SM
tribute's
tribute/FS
trice/M
tricentennial/MS
triceps/MS
triceratops/M
trichina/M
trichinae
trichinosis/M
trick/GSMD
trickery/M
trickily
trickiness/M
trickle/MGDS
trickster/SM
tricky/TRP
tricolor/SM
tricycle/SM
trident/MS
tried/U
triennial/MYS
trier/SM
trifecta/SM
trifle/MZGDRS
trifler/M
trifocals/M
trig/M
trigger/MDSG
triglyceride/MS
trigonometric
trigonometrical
trigonometry/M
trike/SM
trilateral/S
trilby/SM
trill/GSMD
trillion/SMH
trillionth/M
trillionths
trillium/M
trilobite/SM
trilogy/SM
trim/PMYS
trimaran/MS
trimester/SM
trimmed/U
trimmer/SM
trimmest
trimming/SM
trimmings/M
trimness/M
trimonthly
trinitrotoluene/M
trinity/SM
trinket/SM
trio/MS
trip/MYS
tripartite
tripe/M
triple/MGDS
triplet/SM
triplex/MS
triplicate/MGDS
tripod/MS
tripodal
tripos
tripped
tripper/SM
tripping
triptych/M
triptychs
tripwire/S
trireme/SM
trisect/SDG
trisection/M
trite/FPYT
triteness/FM
triter
tritium/M
triumph/GMD
triumphal
triumphalism
triumphalist
triumphant/Y
triumphs
triumvir/MS
triumvirate/SM
trivalent
trivet/MS
trivia/M
trivial/Y
triviality/SM
trivialization/M
trivialize/GDS
trivium/M
trochaic
trochee/SM
trod/AU
trodden/A
troglodyte/SM
troika/MS
troll/SGMD
trolley/SM
trolleybus/MS
trollop/SM
trombone/MS
trombonist/MS
tromp/SGD
tron/S
troop/SZGMDR
trooper/M
troopship/MS
trope/SM
trophy/SM
tropic/MS
tropical/Y
tropics/M
tropism/SM
troposphere/SM
trot/MS
troth/M
trotted
trotter/SM
trotting
troubadour/MS
trouble/DSMG
troubled/U
troublemaker/MS
troubleshoot/DRZGS
troubleshooter/M
troubleshooting/M
troubleshot
troublesome/Y
trough/M
troughs
trounce/DRSZG
trouncer/M
troupe/MZGDRS
trouper/M
trouser/SM
trousers/M
trousseau/M
trousseaux
trout/SM
trove/SM
trow/DSG
trowel/MDSG
troy/S
truancy/M
truant/GMDS
truce/SM
truck/SZGMDR
trucker/M
trucking/M
truckle/MGDS
truckload/SM
truculence/M
truculent/Y
trudge/MGDS
true/MTGDRS
truelove/SM
truffle/MS
trug/S
truism/MS
truly/U
trump/SGMD
trumpery/M
trumpet/ZGMDRS
trumpeter/M
truncate/GNDS
truncation/M
truncheon/SM
trundle/MZGDRS
trundler/M
trunk/SGM
truss/GMDS
trust/ESGMD
trustee/MS
trusteeship/SM
trustful/EY
trustfulness/M
trusting/Y
trustworthiness/M
trustworthy/TPR
trusty/TRSM
truth/ZMR
truther/M
truthful/UYP
truthfulness/UM
truthiness
truths/U
try's
try/AGDS
trying/Y
tryout/SM
tryptophan
tryst/SMDG
tsarists
tsetse/MS
tsp
tsunami/SM
ttys
tub/SZGMDR
tuba/MS
tubal
tubby/TR
tube/MS
tubeless/M
tuber/M
tubercle/SM
tubercular
tuberculin/M
tuberculosis/M
tuberculous
tuberose/M
tuberous
tubful/MS
tubing/M
tubular
tubule/MS
tuck/MDRSZG
tucker/MDG
tuft/MDRSZG
tufter/M
tug/SM
tugboat/MS
tugged
tugging
tuition/IM
tularemia/M
tulip/SM
tulle/M
tum/S
tumble/DRSMZG
tumbledown
tumbler/M
tumbleweed/SM
tumbling/M
tumbrel/SM
tumescence/M
tumescent
tumid
tumidity/M
tummy/SM
tumor/SM
tumorous
tumult/SM
tumultuous/Y
tun/SZGMDR
tuna/MS
tundra/SM
tune/MS
tuneful/YP
tunefulness/M
tuneless/Y
tuner/M
tuneup/SM
tungsten/M
tunic/SM
tunnel/JSMDRZG
tunneler/M
tunny/SM
tuple/S
tuppence
tuppenny
tuque/SM
turban/SMD
turbid
turbidity/M
turbine/SM
turbo/SM
turbocharge/ZGDRS
turbocharger/M
turbofan/SM
turbojet/SM
turboprop/SM
turbot/SM
turbulence/M
turbulent/Y
turd/MS
turducken/SM
tureen/SM
turf/MDSG
turfy
turgid/Y
turgidity/M
turkey/SM
turmeric/SM
turmoil/MS
turn/AMDRSZG
turnabout/SM
turnaround/SM
turnbuckle/SM
turncoat/SM
turner/AM
turning/MS
turnip/SM
turnkey/MS
turnoff/MS
turnout/MS
turnover/MS
turnpike/MS
turnstile/SM
turntable/SM
turpentine/M
turpitude/M
turps
turquoise/SM
turret/SMD
turtle/SM
turtledove/SM
turtleneck/SMD
tush/MS
tusk/MDS
tussle/DSMG
tussock/MS
tussocky
tut/SM
tutelage/M
tutelary
tutor/SMDG
tutored/U
tutorial/SM
tutorship/M
tutted
tutti/SM
tutting
tutu/MS
tux/MS
tuxedo/SM
twaddle/MZGDRS
twaddler/M
twain/M
twang/SMDG
twangy/RT
twas
twat/S
tweak/SMDG
twee
tweed/SM
tweeds/M
tweedy/RT
tween
tweet's
tweet/ASDG
tweeter/SM
tweezers/M
twelfth/M
twelfths
twelve/SM
twelvemonth/M
twelvemonths
twentieth/M
twentieths
twenty/SMH
twerk/SDG
twerp/SM
twice
twiddle/MGDS
twiddly
twig/MS
twigged
twigging
twiggy/TR
twilight/M
twilit
twill/MD
twin/MDRSZG
twine/SM
twiner/M
twinge/DSMG
twink/SY
twinkle/MGJDS
twinkling/M
twinned
twinning
twinset/S
twirl/SMDRZG
twirler/M
twirly
twist's
twist/USDG
twister/MS
twisty/TR
twit/MS
twitch/GMDS
twitchy/RT
twitted
twitter/MDSG
twittery
twitting
twixt
two/SM
twofer/SM
twofold
twopence/SM
twopenny
twosome/SM
twp
tycoon/SM
tying/AU
tyke/MS
tympani/M
tympanic
tympanist/MS
tympanum/SM
type's
type/AGDS
typecast/GS
typeface/MS
typescript/MS
typeset/S
typesetter/MS
typesetting/M
typewrite/RSZG
typewriter/M
typewriting/M
typewritten
typewrote
typhoid/M
typhoon/MS
typhus/M
typical/UY
typicality/M
typification/M
typify/NGDS
typing/M
typist/SM
typo/MS
typographer/SM
typographic
typographical/Y
typography/M
typology/SM
tyrannic
tyrannical/Y
tyrannize/GDS
tyrannosaur/MS
tyrannosaurus/MS
tyrannous
tyranny/SM
tyrant/SM
tyro/MS
u/S
ubiquitous/Y
ubiquity/M
udder/SM
ufologist/SM
ufology/M
ugh
ugliness/M
ugly/RTP
uh
uhf
ukase/SM
ukulele/SM
ulcer/SM
ulcerate/XDSGN
ulceration/M
ulcerous
ulna/M
ulnae
ulnar
ulster/MS
ult
ulterior
ultimate/MY
ultimatum/MS
ultimo
ultra/SM
ultraconservative/SM
ultrahigh
ultralight/SM
ultramarine/M
ultramodern
ultrasonic
ultrasonically
ultrasound/MS
ultraviolet/M
ululate/DSGNX
ululation/M
um
umbel/SM
umber/M
umbilical
umbilici
umbilicus/M
umbra/SM
umbrage/M
umbrella/SM
umiak/SM
umlaut/MS
ump/SGMD
umpire/MGDS
umpteen/H
unabridged/MS
unacceptability
unacceptable
unaccommodating
unaccountably
unadventurous
unaesthetic
unalterably
unambitious
unanimity/M
unanimous/Y
unapparent
unappetizing
unappreciative
unassertive
unassuming/Y
unavailing/Y
unaware/S
unbeknownst
unbend/SG
unbent
unbid
unblinking/Y
unblushing/Y
unbosom/DG
unbound/D
unbreakable
unbroken
uncanny/T
uncap/S
uncaring
uncatalogued
unceasing/Y
unchangeable
uncharacteristic
uncharitable
unchaste/RT
uncial/M
uncle/SM
unclean/DRPT
uncleanly/T
unclear/DRT
uncomfortable
uncommon/T
uncomplaining/Y
uncomplicated
uncomprehending/Y
uncompromising/Y
unconditional/Y
uncongenial
unconscionable
unconscionably
unconscious/M
unconstitutional/Y
uncontrollably
uncontroversial
uncool
uncooperative
uncouth/Y
uncrushable
unction/SM
unctuous/YP
unctuousness/M
uncut
undaunted/Y
undecided/SM
undemonstrative/Y
undeniably
under
underachieve/LZGDRS
underachiever/M
underact/SDG
underage
underappreciated
underarm/SM
underbelly/SM
underbid/S
underbidding
underbrush/M
undercarriage/MS
undercharge/MGDS
underclass/MS
underclassman/M
underclassmen
underclothes/M
underclothing/M
undercoat/GJSMD
undercoating/M
undercover
undercurrent/SM
undercut/SM
undercutting
underdeveloped
underdevelopment/M
underdog/SM
underdone
underemployed
underemployment/M
underestimate/DSMGNX
underestimation/M
underexpose/GDS
underexposure/MS
underfed
underfeed/GS
underfloor
underflow
underfoot
underfunded
underfur/M
undergarment/SM
undergo/G
undergoes
undergone
undergrad/S
undergraduate/SM
underground/MS
undergrowth/M
underhand
underhanded/PY
underhandedness/M
underlain
underlay/SM
underlie/S
underline/MGDS
underling/MS
underlip/SM
underlying
undermanned
undermentioned
undermine/GDS
undermost
underneath/M
underneaths
undernourished
undernourishment/M
underpaid
underpants/M
underpart/MS
underpass/MS
underpay/GSL
underpayment/SM
underpin/S
underpinned
underpinning/MS
underplay/DGS
underpopulated
underprivileged
underproduction/M
underrate/GDS
underrepresented
underscore/DSMG
undersea/S
undersecretary/SM
undersell/GS
undersexed
undershirt/SM
undershoot/SG
undershorts/M
undershot
underside/MS
undersign/DGS
undersigned/M
undersized
underskirt/SM
undersold
understaffed
understand/SGBJ
understandably
understanding/MY
understate/DSLG
understatement/SM
understood
understudy/GDSM
undertake/ZGJRS
undertaken
undertaker/M
undertaking/M
underthings/M
undertone/MS
undertook
undertow/SM
underused
underutilized
undervaluation/M
undervalue/DSG
underwater
underway
underwear/M
underweight/M
underwent
underwhelm/DGS
underwire/DS
underworld/MS
underwrite/ZGRS
underwriter/M
underwritten
underwrote
undesirable/MS
undies/M
undo
undoubted/Y
undramatic
undue
undulant
undulate/DSXGN
undulation/M
undying
unearthliness/M
unease/M
uneasy/T
uneatable
uneconomic
unemployed/M
unending
unenterprising
unequal/DY
unerring/Y
unessential
uneven/Y
unexceptionably
unexcited
unexciting
unexpected/YP
unexpectedness/M
unfailing/Y
unfair/PTRY
unfaltering
unfamiliar
unfathomably
unfed
unfeeling/Y
unfeminine
unfit/S
unfitting
unfix/GDS
unflagging/Y
unflappability/M
unflappable
unflappably
unflattering
unflinching/Y
unforgettably
unforgivably
unfortunate/MS
unfriendly/T
unfrock/DG
unfruitful
unfunny
ungainliness/M
ungainly/RPT
ungenerous
ungentle
ungodly/T
ungraceful/Y
ungrudging
unguarded
unguent/SM
ungulate/MS
unhandy/T
unhappy/T
unhealthful
unhealthy/T
unhistorical
unholy/T
unhurt
unicameral
unicellular
unicorn/SM
unicycle/SM
unidirectional
unification/AM
uniform/SMDYG
uniformity/M
unify/AGDSN
unilateral/Y
unilateralism
unimportant
unimpressive
uninformative
uninhibited/Y
uninstall/BSZGDR
uninsured
unintelligent
unintended
uninteresting
uninterrupted/Y
uninterruptible
uninviting
union/ASM
unionism/M
unionist/MS
unique/YTRP
uniqueness/M
unisex/M
unison/M
unitary
unite/AEGSD
unitedly
unities
unitize/DSG
unity/EM
univalent
univalve/SM
universal/MYS
universality/M
universalize/DSG
universe/SM
university/SM
unjust/Y
unkempt
unkind/T
unkindly/T
unknowable/M
unknown/SM
unleaded/M
unless
unlike/PB
unlikely/T
unlit
unlock/DSG
unlovable
unlovely/TR
unloving
unlucky/T
unmanly/T
unmarried
unmeaning
unmentionable/MS
unmentionables/M
unmet
unmindful
unmissable
unmistakably
unmoral
unmovable
unmusical
unnecessary
unnerving/Y
unobservant
unoffensive
unofficial/Y
unoriginal
unpeople
unperceptive
unpersuasive
unpick/GDS
unpin/S
unpleasing
unpolitical
unpopular
unpractical
unprecedented/Y
unprofessional/Y
unpromising
unpropitious
unquestioning/Y
unquiet/TR
unread/B
unready
unreal
unreasoning
unregenerate
unrelated
unrelenting/Y
unrelieved/Y
unremarkable
unremitting/Y
unrepentant
unreported
unrepresentative
unrest/M
unripe/TR
unroll/GDS
unromantic
unruliness/M
unruly/RTP
unsafe/YTR
unsaleable
unsavory
unscathed
unsearchable
unseeing/Y
unseemly/T
unseen/M
unsentimental
unset
unshakable
unshakably
unshapely
unshockable
unshorn
unsightliness/M
unsightly/PT
unsmiling
unsociable
unsocial
unsold
unsound/PRYT
unspeakable
unspeakably
unspecific
unspectacular
unsporting
unstable
unsteady/TRP
unstinting/Y
unstrapping
unsubstantial
unsubtle
unsuitable
unsure
unsuspecting/Y
unsymmetrical
untactful
unthinkably
unthinking/Y
untidy/PTR
until
untimely/T
untiring/Y
untouchable/MS
untoward
untrue/RT
untrustworthy
untruth/M
unutterable
unutterably
unwarrantable
unwary/T
unwavering
unwed
unwelcome/G
unwell
unwieldiness/M
unwieldy/TRP
unwise/RYT
unworried
unworthy/T
unwound
unwrapping
unyielding
up/S
upbeat/MS
upbraid/SGD
upbringing/MS
upchuck/SGD
upcoming
upcountry/M
update/MGDRS
updraft/MS
upend/SGD
upfront
upgrade/MGDS
upheaval/MS
upheld
uphill/MS
uphold/ZGRS
upholder/M
upholster/ASGD
upholsterer/MS
upholstery/M
upkeep/M
upland/MS
uplift/JSMDG
upload/SDG
upmarket
upmost
upon
upped
upper/SM
uppercase/M
upperclassman/M
upperclassmen
upperclasswoman
upperclasswomen
uppercut/MS
uppercutting
uppermost
upping
uppish
uppity
upraise/DSG
uprear/GSD
upright/MYPS
uprightness/M
uprising/SM
upriver
uproar/SM
uproarious/Y
uproot/GSD
upscale
upset/SM
upsetting
upshot/SM
upside/SM
upsilon/MS
upstage/GDS
upstairs
upstanding
upstart/MDSG
upstate/M
upstream
upstroke/SM
upsurge/MGDS
upswing/MS
uptake/SM
uptempo
upthrust/GSM
uptick/SM
uptight
uptown/M
uptrend
upturn/GSMD
upward/SY
upwind
uracil/M
uranium/M
urban
urbane/RYT
urbanity/M
urbanization/M
urbanize/DSG
urbanologist/MS
urbanology/M
urchin/SM
urea/M
uremia/M
uremic
ureter/SM
urethane/M
urethra/M
urethrae
urethral
urge/MGDS
urgency/M
urgent/Y
uric
urinal/SM
urinalyses
urinalysis/M
urinary
urinate/GNDS
urination/M
urine/M
urn/SM
urogenital
urological
urologist/MS
urology/M
ursine
urticaria/M
usability/M
usable/UA
usage/SM
use/AEDSMG
used/U
useful/PY
usefulness/M
useless/YP
uselessness/M
user/MS
username/MS
usher/SMDG
usherette/SM
usu
usual's
usual/UY
usurer/SM
usurious
usurp/SDRZG
usurpation/M
usurper/M
usury/M
utensil/SM
uteri
uterine
uterus/M
utilitarian/MS
utilitarianism/M
utility/SM
utilization/M
utilize/GBDS
utmost/M
utopia/SM
utter/SDYG
utterance/SM
uttermost/M
uveitis
uvula/SM
uvular/MS
uxorious
v/AS
vac/S
vacancy/SM
vacant/Y
vacate/DSG
vacation/ZGMDRS
vacationer/M
vacationist/SM
vaccinate/GNDSX
vaccination/M
vaccine/SM
vacillate/XGNDS
vacillation/M
vacuity/M
vacuole/MS
vacuous/YP
vacuousness/M
vacuum/GSMD
vagabond/SMDG
vagabondage/M
vagarious
vagary/SM
vagina/SM
vaginae
vaginal/Y
vagrancy/M
vagrant/MS
vague/RYTP
vagueness/M
vagus
vain/RYT
vainglorious/Y
vainglory/M
val
valance/MS
vale/MS
valediction/MS
valedictorian/SM
valedictory/SM
valence/MS
valency/SM
valentine/SM
valet/SMDG
valetudinarian/MS
valetudinarianism/M
valiance/M
valiant/Y
valid/Y
validate/IGNDS
validation/IM
validations
validity/IM
validness/M
valise/SM
valley/SM
valor/M
valorous/Y
valuable/MS
valuate/DSG
valuation/CAMS
value's
value/CAGSD
valueless
valuer/SM
valve/DSMG
valveless
valvular
vamoose/DSG
vamp/AMDGS
vampire/SM
van/SM
vanadium/M
vandal/SM
vandalism/M
vandalize/DSG
vane/MS
vanguard/MS
vanilla/SM
vanish/JDSG
vanity/SM
vanned
vanning
vanquish/ZGDRS
vanquisher/M
vantage/SM
vape/GDS
vapid/YP
vapidity/M
vapidness/M
vapor/SM
vaporization/M
vaporize/DRSZG
vaporizer/M
vaporous
vaporware
vapory
vaquero/MS
var/S
variability/IM
variable/ISM
variably/I
variance/SM
variant/MS
variate/NX
variation/M
varicolored
varicose
varied/U
variegate/DSGN
variegation/M
varietal/SM
variety/SM
various/Y
varlet/SM
varmint/MS
varnish/GMDS
varnished/U
varsity/SM
vary/DSG
varying/U
vascular
vase/MS
vasectomy/SM
vasoconstriction
vasomotor
vassal/SM
vassalage/M
vast/MRYTSP
vastness/M
vat/SM
vatted
vatting
vaudeville/M
vaudevillian/MS
vault/SMDRZG
vaulter/M
vaulting/M
vaunt/SMDG
vb
veal/M
vector/SGMD
veejay/SM
veep/MS
veer/MDGS
veg/M
vegan/SM
veganism
vegeburger/S
veges
vegetable/SM
vegetarian/SM
vegetarianism/M
vegetate/GNVDS
vegetation/M
vegged
vegges
veggie/SM
veggieburger/S
vegging
vehemence/M
vehemency/M
vehement/Y
vehicle/MS
vehicular
veil's
veil/UDGS
vein/MDGS
vela
velar/SM
veld/MS
vellum/M
velocipede/MS
velocity/SM
velodrome/S
velour/MS
velum/M
velvet/M
velveteen/M
velvety
venal/Y
venality/M
venation/M
vend/DGS
vendetta/SM
vendible
vendor/MS
veneer/MDGS
venerability/M
venerable
venerate/DSGN
veneration/M
venereal
vengeance/M
vengeful/AY
venial
venireman/M
veniremen
venison/M
venom/M
venomous/Y
venous
vent's
vent/DGS
ventilate/GNDS
ventilation/M
ventilator/SM
ventral
ventricle/SM
ventricular
ventriloquism/M
ventriloquist/SM
ventriloquy/M
venture/DSMG
venturesome/PY
venturesomeness/M
venturous/PY
venturousness/M
venue/ASM
veracious/Y
veracity/M
veranda/SM
verb/KMS
verbal/MYS
verbalization/M
verbalize/GDS
verbatim
verbena/SM
verbiage/MS
verbose/Y
verbosity/M
verboten
verdant/Y
verdict/SM
verdigris/GMDS
verdure/M
verge's
verge/FDSG
verger/MS
verifiable/U
verification/M
verified/U
verify/DSNG
verily
verisimilitude/M
veritable
veritably
verity/SM
vermicelli/M
vermiculite/M
vermiform
vermilion/M
vermin/M
verminous
vermouth/M
vernacular/MS
vernal
vernier/SM
veronica/M
verruca/SM
verrucae
versa
versatile
versatility/M
verse/AFNGMSDX
versed/U
versification/M
versifier/M
versify/ZGNDRS
version/AFIMS
versioned
versioning
verso/SM
versus
vert/A
vertebra/M
vertebrae
vertebral
vertebrate/IMS
vertex/MS
vertical/MYS
vertices
vertiginous
vertigo/M
verve/M
very/RT
vesicle/SM
vesicular
vesiculate
vesper/MS
vessel/MS
vest's
vest/ILDGS
vestal/MS
vestibule/MS
vestige/SM
vestigial/Y
vesting/M
vestment/IMS
vestry/SM
vestryman/M
vestrymen
vet/SM
vetch/MS
veteran/SM
veterinarian/MS
veterinary/SM
veto/MDG
vetoes
vetted
vetting
vex/GDS
vexation/SM
vexatious/Y
vhf
vi
via
viability/M
viable
viably
viaduct/SM
vial/MS
viand/SM
vibe/MS
vibes/M
vibraharp/SM
vibrancy/M
vibrant/Y
vibraphone/MS
vibraphonist/MS
vibrate/GNDSX
vibration/M
vibrato/MS
vibrator/SM
vibratory
viburnum/SM
vicar/SM
vicarage/SM
vicarious/YP
vicariousness/M
vice/CMS
viced
vicegerent/SM
vicennial
viceregal
viceroy/MS
vichyssoise/M
vicing
vicinity/M
vicious/YP
viciousness/M
vicissitude/SM
victim/MS
victimization/M
victimize/GDS
victor/MS
victorious/Y
victory/SM
victual/SMDG
vicuna/MS
videlicet
video/GSMD
videocassette/SM
videoconferencing
videodisc/MS
videophone/MS
videotape/DSMG
videotex
vie/DS
view/AMDRSZG
viewer/AM
viewership/M
viewfinder/SM
viewing/SM
viewpoint/MS
vigesimal
vigil/SM
vigilance/M
vigilant/Y
vigilante/SM
vigilantism/M
vigilantist/M
vignette/DSMG
vignettist/MS
vigor/M
vigorous/Y
vii
viii
viking/MS
vile/YTPR
vileness/M
vilification/M
vilify/DSNG
villa/SM
village/RSMZ
villager/M
villain/SM
villainous
villainy/SM
villein/SM
villeinage/M
villi
villus/M
vim/M
vinaigrette/M
vincible/I
vindicate/XDSGN
vindication/M
vindicator/MS
vindictive/PY
vindictiveness/M
vine/MS
vinegar/M
vinegary
vineyard/MS
vino/M
vinous
vintage/MS
vintner/MS
vinyl/SM
viol/MBS
viola/SM
violable/I
violate/GNDSX
violation/M
violator/SM
violence/M
violent/Y
violet/MS
violin/MS
violincello/S
violinist/SM
violist/MS
violoncellist/SM
violoncello/MS
viper/SM
viperous
virago/M
viragoes
viral
vireo/SM
virgin/MS
virginal/SM
virginity/M
virgule/MS
virile
virility/M
virologist/SM
virology/M
virtual/Y
virtualization
virtue/SM
virtuosity/M
virtuoso/M
virtuous/YP
virtuousness/M
virulence/M
virulent/Y
virus/MS
visa/MDSG
visage/MS
viscera
visceral/Y
viscid
viscose/M
viscosity/M
viscount/SM
viscountcy/SM
viscountess/MS
viscous
viscus/M
vise/ACMGDS
visibility/IM
visible/I
visibly/I
vision/KGDSM
visionary/SM
visit's
visit/ASGD
visitant/MS
visitation/MS
visitor/MS
visor/SM
vista/SM
visual/SMY
visualization/SM
visualize/DRSZG
visualizer/M
vita/M
vitae
vital/SY
vitality/M
vitalization/AM
vitalize/CAGSD
vitals/M
vitamin/MS
vitiate/GNDS
vitiation/M
viticulture/M
viticulturist/MS
vitreous
vitrifaction/M
vitrification/M
vitrify/GNDS
vitrine/SM
vitriol/M
vitriolic
vitriolically
vittles/M
vituperate/GNVDS
vituperation/M
viva/MS
vivace
vivacious/PY
vivaciousness/M
vivacity/M
vivaria
vivarium/SM
vivid/RYTP
vividness/M
vivify/ADSG
viviparous
vivisect/DGS
vivisection/M
vivisectional
vivisectionist/SM
vixen/SM
vixenish/Y
viz
vizier/SM
vlf
vocab
vocable/MS
vocabulary/SM
vocal/SMY
vocalic
vocalist/SM
vocalization/MS
vocalize/DSG
vocation/FIKASM
vocational/Y
vocative/MS
vociferate/DSGN
vociferation/M
vociferous/YP
vociferousness/M
vodka/SM
vogue/SM
voguish
voice/IDSMG
voiced/U
voiceless/PY
voicelessness/M
voicemail/SM
void/MDSGB
voila
voile/M
vol/S
volatile
volatility/M
volatilize/DSG
volcanic
volcano/M
volcanoes
vole/MS
volition/M
volitional
volley/GSMD
volleyball/MS
volt/AMS
voltage/MS
voltaic
voltmeter/SM
volubility/M
voluble
volubly
volume/SM
voluminous/YP
voluminousness/M
voluntarily/I
voluntarism/M
voluntary/SM
volunteer/SGMD
volunteerism/M
voluptuary/SM
voluptuous/PY
voluptuousness/M
volute/SM
vomit/SMDG
voodoo/GSMD
voodooism/M
voracious/PY
voraciousness/M
voracity/M
vortex/MS
votary/SM
vote's
vote/CGVDS
voter/SM
vouch/DRSZG
voucher/M
vouchsafe/DSG
vow/SGMD
vowel/SM
voyage/MZGDRS
voyager/M
voyageur/SM
voyeur/MS
voyeurism/M
voyeuristic
vulcanization/M
vulcanize/GDS
vulgar/RYT
vulgarian/MS
vulgarism/MS
vulgarity/SM
vulgarization/M
vulgarize/ZGDRS
vulgarizer/M
vulnerabilities
vulnerability/IM
vulnerable/I
vulnerably/I
vulpine
vulture/SM
vulturous
vulva/M
vulvae
vuvuzela/MS
vying
w/DNXTGVJ
wabbit/S
wack/MRTS
wackiness/M
wacko/SM
wacky/RPT
wad/SZGMDR
wadded
wadding/M
waddle/DSMG
wade/MS
wader/M
waders/M
wadge/S
wadi/MS
wafer/SM
waffle/MZGDRS
waffler/M
waft/MDGS
wag/SZGMDR
wage/MS
waged/U
wager/ZGMDR
wagerer/M
wagged
waggery/SM
wagging
waggish/YP
waggishness/M
waggle/MGDS
wagon/ZSMR
wagoner/M
wagtail/SM
waif/MS
wail/MDRZGS
wailer/M
wailing/M
wain/MS
wainscot/SJMDG
wainscoting/M
wainwright/MS
waist/SM
waistband/MS
waistcoat/MS
waistline/MS
wait/MDRZGS
waiter/M
waiting/M
waitperson/MS
waitress/MS
waitstaff/M
waive/DRSZG
waiver/M
wake/MGJDS
wakeful/PY
wakefulness/M
waken/GSD
waldo/S
waldoes
wale/MGDS
walk/MDRZGS
walkabout/S
walkaway/MS
walker/M
walkies
walking/M
walkout/SM
walkover/MS
walkway/SM
wall/MDGS
wallaby/SM
wallah
wallahs
wallboard/M
wallet/MS
walleye/DSM
wallflower/MS
wallop/MDSJG
walloping/M
wallow/MDSG
wallpaper/SMDG
wally/S
walnut/MS
walrus/MS
waltz/ZGMDRS
waltzer/M
wampum/M
wan/GPDY
wand/MS
wander/DRSJZG
wanderer/M
wanderings/M
wanderlust/SM
wane/MS
wangle/MZGDRS
wangler/M
wank/DRZGS
wanna
wannabe/SM
wannabee/S
wanner
wanness/M
wannest
want/MDGS
wanted/U
wanton/MDYSPG
wantonness/M
wapiti/MS
war/SM
warble/MZGDRS
warbler/M
warbonnet/SM
ward/AMDGS
warden/MS
warder/MS
wardress/S
wardrobe/SM
wardroom/SM
ware/MS
warehouse/DSMG
warez
warfare/M
warhead/MS
warhorse/SM
warily/U
wariness/UM
warlike
warlock/MS
warlord/MS
warm/PDRYHZTGS
warmblooded
warmer/M
warmhearted/P
warmheartedness/M
warmish
warmness/M
warmonger/SMG
warmongering/M
warmth/M
warn/JDGS
warning/M
warp/MDGS
warpaint
warpath/M
warpaths
warplane/MS
warrant/GMDS
warranted/U
warranty/DSMG
warred
warren/MS
warring
warrior/SM
warship/SM
wart/MS
warthog/SM
wartime/M
warty/TR
wary/UPRT
was
wasabi
wash/BJMDRSZG
washable/SM
washbasin/SM
washboard/SM
washbowl/SM
washcloth/M
washcloths
washed/U
washer/M
washerwoman/M
washerwomen
washing/M
washout/MS
washrag/MS
washroom/MS
washstand/SM
washtub/MS
washy/TR
wasn't
wasp/MS
waspish/YP
waspishness/M
wassail/SMDG
wast
wastage/M
waste/DRSMZG
wastebasket/MS
wasteful/PY
wastefulness/M
wasteland/SM
wastepaper/M
waster/M
wastewater
wastrel/SM
watch/BZGMDRS
watchable/U
watchband/MS
watchdog/SM
watcher/M
watchful/YP
watchfulness/M
watchmaker/MS
watchmaking/M
watchman/M
watchmen
watchstrap/S
watchtower/SM
watchword/MS
water/GSMD
waterbed/MS
waterbird/SM
waterboard/MDJSG
waterboarding/M
waterborne
watercolor/MS
watercourse/SM
watercraft/M
watercress/M
waterfall/SM
waterfowl/SM
waterfront/MS
waterhole/SM
wateriness/M
waterlily/SM
waterline/MS
waterlogged
watermark/MDGS
watermelon/SM
watermill/MS
waterproof/SMDG
waterproofing/M
waters/M
watershed/MS
waterside/MS
waterspout/SM
watertight
waterway/MS
waterwheel/SM
waterworks/M
watery/PTR
watt/MS
wattage/M
wattle/MGDS
wave/MZGDRS
waveband/S
waveform
wavelength/M
wavelengths
wavelet/SM
wavelike
waver/ZGMDR
waverer/M
wavering/Y
waviness/M
wavy/PRT
wax/GMDNS
waxiness/M
waxwing/SM
waxwork/SM
waxy/RPT
way/SM
waybill/SM
wayfarer/MS
wayfaring/SM
waylaid
waylay/RSZG
waylayer/M
wayside/SM
wayward/PY
waywardness/M
wazoo/S
we
we'd
we'll
we're
we've
weak/PNRYXT
weaken/DRZG
weakener/M
weakfish/MS
weakish
weakling/SM
weakness/MS
weal/MHS
wealth/M
wealthiness/M
wealthy/TRP
wean/DGS
weapon/MS
weaponize
weaponless
weaponry/M
wear/MRBJSZG
wearable/U
wearer/M
wearied/U
wearily
weariness/M
wearisome/Y
weary/TGDRSP
weasel/MDYSG
weather/SMDG
weatherboard/SG
weathercock/MS
weathering/M
weatherization/M
weatherize/DSG
weatherman/M
weathermen
weatherperson/MS
weatherproof/GSD
weatherstrip/S
weatherstripped
weatherstripping/M
weave/DRSMZG
weaver/M
weaving/M
web/SM
webbed
webbing/M
webcam/MS
webcast/SMG
webfeet
webfoot/M
webinar/SM
webisode/MS
weblog/MS
webmaster/SM
webmistress/MS
website/SM
wed/AS
wedded/A
wedder
wedding/SM
wedge/DSMG
wedgie/MS
wedlock/M
wee/RSMT
weed/MDRSZG
weeder/M
weedkiller/S
weedless
weedy/TR
weeing
week/MYS
weekday/SM
weekend/SZGMDR
weekly/SM
weeknight/SM
ween/DSG
weenie/MTRS
weensy/RT
weeny
weep/MRJSZG
weeper/M
weepie
weepy/TRSM
weevil/MS
weft/MS
weigh's
weigh/AGD
weighbridge/S
weighs/A
weight/MDSJG
weighted/U
weightily
weightiness/M
weightless/YP
weightlessness/M
weightlifter/MS
weightlifting/M
weighty/PTR
weir/MS
weird/PTRY
weirdie/MS
weirdness/M
weirdo/MS
welcome/MGDS
weld/MDRBSZG
welder/M
welfare/M
welkin/M
well/MDPSG
wellhead/SM
wellie
wellington/MS
wellness/M
wellspring/MS
welly/S
welsh/ZGDRS
welsher/M
welt/MDRSZG
welter/GMD
welterweight/SM
wen/M
wench/MS
wend/DSG
went
wept
were
weren't
werewolf/M
werewolves
west/M
westbound
westerly/SM
western/SZMR
westerner/M
westernization/M
westernize/GDS
westernmost
westward/S
wet/SMYP
wetback/SM
wetland/SM
wetness/M
wetter/SM
wettest
wetting
wetware/S
whack/SJZGMDR
whacker/M
whale/DRSMZG
whaleboat/MS
whalebone/M
whaler/M
whaling/M
wham/MS
whammed
whamming
whammy/SM
wharf/M
wharves
what/MS
whatchamacallit/MS
whatever
whatnot/M
whatshername
whatshisname
whatsit/S
whatsoever
wheal/SM
wheat/MN
wheatgerm
wheatmeal
whee
wheedle/DRSZG
wheedler/M
wheel/SMDRG
wheelbarrow/SM
wheelbase/SM
wheelchair/SM
wheelhouse/MS
wheelie/SM
wheelwright/MS
wheeze/DSMG
wheezily
wheeziness/M
wheezy/PRT
whelk/SMD
whelm/SDG
whelp/SMDG
when/MS
whence
whenever
whensoever
where/SM
whereabouts/M
whereas
whereat
whereby
wherefore/MS
wherein
whereof
whereon
wheresoever
whereto
whereupon
wherever
wherewith
wherewithal/M
wherry/SM
whet/S
whether
whetstone/SM
whetted
whetting
whew
whey/M
which
whichever
whiff/SMDG
whiffletree/MS
while/DSMG
whilom
whilst
whim/MS
whimper/MDGS
whimsical/Y
whimsicality/M
whimsy/SM
whine/DRSMZG
whiner/M
whinge/DRSZG
whingeing
whinny/GDSM
whiny/RT
whip/MS
whipcord/M
whiplash/MS
whipped
whipper/MS
whippersnapper/MS
whippet/MS
whipping/SM
whippletree/SM
whippoorwill/MS
whipsaw/MDGS
whir/MS
whirl/SMDG
whirligig/MS
whirlpool/MS
whirlwind/MS
whirlybird/SM
whirred
whirring
whisk/SMDRZG
whisker/MD
whiskery
whiskey/MS
whiskys
whisper/MDRSZG
whisperer/M
whist/M
whistle/MZGDRS
whistler/M
whit/MDNRSXTGJ
white/SPM
whitebait
whiteboard/S
whitecap/SM
whitefish/MS
whitehead/MS
whiten/ZGDRJ
whitener/M
whiteness/M
whitening/M
whiteout/SM
whitetail/MS
whitewall/SM
whitewash/MDSG
whitewater/M
whitey/SM
whither
whiting/M
whitish
whittle/ZGDRS
whittler/M
whiz/M
whizkid/M
whizzbang/MS
whizzed
whizzes
whizzing
who'd
who'll
who're
who've
who/M
whoa
whodunit/MS
whoever
whole/SMP
wholefood/S
wholegrain
wholehearted/YP
wholeheartedness/M
wholemeal
wholeness/M
wholesale/MZGDRS
wholesaler/M
wholesome/UP
wholesomely
wholesomeness/UM
wholewheat
wholly
whom
whomever
whomsoever
whoop/SMDRZG
whoopee/S
whooper/M
whoosh/MDSG
whop/S
whopped
whopper/SM
whopping
whore/SMG
whorehouse/MS
whoreish
whorish
whorl/SMD
whose
whoso
whosoever
whup/S
whupped
whupping
why'd
why/M
whys
wick/MDRSZ
wicked/TPRY
wickedness/M
wicker/M
wickerwork/M
wicket/SM
wide/YTRP
widemouthed
widen/SDRZG
widener/M
wideness/M
widescreen/MS
widespread
widget/S
widow/SMDRZG
widower/M
widowhood/M
width/M
widths
wield/SDRZG
wielder/M
wiener/SM
wienie/SM
wife/MY
wifeless
wig/SM
wigeon/M
wigged
wigging
wiggle/DRSMZG
wiggler/M
wiggly/TR
wight/SM
wiglet/SM
wigwag/SM
wigwagged
wigwagging
wigwam/SM
wiki/MS
wild/MRYSTP
wildcard
wildcat/MS
wildcatted
wildcatter/MS
wildcatting
wildebeest/MS
wilderness/MS
wildfire/MS
wildflower/SM
wildfowl/M
wildlife/M
wildness/M
wilds/M
wile/MGDS
wiliness/M
will/MDS
willful/PY
willfulness/M
willies/M
willing/UPY
willingness/UM
williwaw/MS
willow/SM
willowy
willpower/M
willy/S
wilt/MDSG
wily/RTP
wimp/MDSG
wimpish
wimple/DSMG
wimpy/RT
win/SGMD
wince/DSMG
winch/MDSG
wind's
wind/UASG
windbag/SM
windblown
windbreak/SZMR
windbreaker/M
windburn/MD
windcheater/S
windchill/M
winded
winder/SM
windfall/MS
windflower/MS
windily
windiness/M
winding's
windjammer/SM
windlass/MS
windless
windmill/MDGS
window/SMDG
windowless
windowpane/SM
windowsill/SM
windpipe/MS
windproof
windrow/SM
windscreen/SM
windshield/SM
windsock/MS
windstorm/MS
windsurf/ZGDRS
windsurfer/M
windsurfing/M
windswept
windup/SM
windward/M
windy/RTP
wine/MS
wineglass/MS
winegrower/MS
winemaker/MS
winery/SM
wing/MDRZG
wingding/MS
wingless
winglike
wingnut/SM
wingspan/MS
wingspread/SM
wingtip/SM
wink/MDRSZG
winker/M
winkle/DSMG
winnable/U
winner/SM
winning/MYS
winnow/ZGSDR
winnower/M
wino/MS
winsome/YTRP
winsomeness/M
winter/GSMD
wintergreen/M
winterize/GDS
wintertime/M
wintry/TR
winy/RT
wipe/MZGDRS
wiper/M
wire's
wire/AGDS
wired/S
wirehair/MS
wireless/MS
wiretap/MS
wiretapped
wiretapper/SM
wiretapping/M
wiriness/M
wiring/M
wiry/RTP
wisdom/M
wise/MYTGDRS
wiseacre/SM
wisecrack/MDSG
wiseguy/S
wish/MDRSZG
wishbone/SM
wisher/M
wishful/Y
wishlist's
wisp/MS
wispy/RT
wist
wisteria/SM
wistful/YP
wistfulness/M
wit/SM
witch/MDSG
witchcraft/M
witchery/M
with
withal
withdraw/SG
withdrawal/MS
withdrawn
withdrew
withe/DRSMZG
wither/JGD
withering/Y
withers/M
withheld
withhold/SG
withholding/M
within/M
without
withstand/GS
withstood
witless/PY
witlessness/M
witness/MDSG
wits/M
witted
witter/SGD
witticism/SM
wittily
wittiness/M
witting/UY
witty/RPT
wive/GDS
wiz
wizard/SMY
wizardry/M
wizened
wk/Y
woad/M
wobble/MGDS
wobbliness/M
wobbly/RTP
wodge/S
woe/SM
woebegone
woeful/YP
woefuller
woefullest
woefulness/M
wog/S
wok/SMN
woke
wold/MS
wolf/MDSG
wolfhound/SM
wolfish
wolfram/M
wolverine/SM
wolves
woman/M
womanhood/M
womanish
womanize/DRSZG
womanizer/M
womankind/M
womanlike/M
womanliness/M
womanly/RPT
womb/MS
wombat/MS
womble/S
women/M
womenfolk/SM
womenfolks/M
won't
won/M
wonder/MDGLS
wonderful/YP
wonderfulness/M
wondering/Y
wonderland/MS
wonderment/M
wondrous/Y
wonk/MS
wonky/TR
wont/MD
wonted/U
woo/SZGDR
wood/MDNSG
woodbine/M
woodblock/MS
woodcarver/MS
woodcarving/SM
woodchuck/MS
woodcock/SM
woodcraft/M
woodcut/SM
woodcutter/SM
woodcutting/M
wooden/RYTP
woodenness/M
woodiness/M
woodland/SM
woodlice
woodlot/SM
woodlouse
woodman/M
woodmen
woodpecker/MS
woodpile/SM
woods/M
woodshed/SM
woodsiness/M
woodsman/M
woodsmen
woodsy/RTP
woodwind/MS
woodwork/MRZG
woodworker/M
woodworking/M
woodworm/S
woody/TPRSM
wooer/M
woof/MDRSZG
woofer/M
wool/MNX
woolen/M
woolgathering/M
wooliness
woolliness/M
woolly/RSMPT
woozily
wooziness/M
woozy/TRP
wop/S!
word's
word/ADSG
wordage/M
wordbook/SM
wordily
wordiness/M
wording/SM
wordless/Y
wordplay/M
wordsmith
wordsmiths
wordy/TPR
wore
work's
work/ADJSG
workable/U
workaday
workaholic/SM
workaround/S
workbasket/S
workbench/MS
workbook/MS
workday/SM
worker/MS
workfare/M
workflow/MS
workforce/M
workhorse/SM
workhouse/SM
working's
workingman/M
workingmen
workings/M
workingwoman/M
workingwomen
workload/MS
workman/M
workmanlike
workmanship/M
workmate/S
workmen
workout/SM
workplace/MS
workroom/MS
works/M
worksheet/MS
workshop/MS
workshy
workstation/MS
worktable/MS
worktop/S
workup/MS
workweek/SM
world/SM
worldlier
worldliness/UM
worldly/UTP
worldview/SM
worldwide
worm/MDSG
wormhole/MS
wormwood/M
wormy/TR
worn/U
worried/Y
worrier/M
worriment/M
worrisome
worry/ZGDRSMJ
worrying/Y
worrywart/SM
worse/M
worsen/DSG
worship/ZGSMDR
worshiper/M
worshipful
worst/SGMD
worsted/M
wort/M
worth/M
worthies
worthily/U
worthiness/UM
worthless/PY
worthlessness/M
worthwhile
worthy's
worthy/UPRT
wot
wotcha
would've
would/S
wouldn't
wouldst
wound/SGMDR
wove/A
woven/AU
wow/SGMD
wpm
wrack/GSMD
wraith/M
wraiths
wrangle/DRSMZGJ
wrangler/M
wrap's
wrap/US
wraparound/SM
wrapped/U
wrapper/SM
wrapping/MS
wrasse/MS
wrath/M
wrathful/Y
wreak/SGD
wreath/MDSG
wreathe
wreaths
wreck/SZGMDR
wreckage/M
wrecker/M
wren/MS
wrench/MDSG
wrest/SGMD
wrestle/MZGDRS
wrestler/M
wrestling/M
wretch/MS
wretched/TPRY
wretchedness/M
wriggle/MZGDRS
wriggler/M
wriggly
wright/MS
wring/SZGMR
wringer/M
wrinkle/MGDS
wrinkled/U
wrinkly/TRSM
wrist/SM
wristband/MS
wristwatch/MS
writ/MRBJSZG
write/S
writer/M
writhe/MGDS
writing/M
written/AU
wrong/STGMPDRY
wrongdoer/SM
wrongdoing/SM
wrongful/PY
wrongfulness/M
wrongheaded/YP
wrongheadedness/M
wrongness/M
wrote/A
wroth
wrought
wrung
wry/Y
wryer
wryest
wryness/M
wt
wunderkind/S
wurst/SM
wuss/MS
wussy/RSMT
x
xci
xcii
xciv
xcix
xcvi
xcvii
xenon/M
xenophobe/MS
xenophobia/M
xenophobic
xerographic
xerography/M
xerox/MDSG
xi/SM
xii
xiii
xiv
xix
xor
xref/S
xterm/M
xv
xvi
xvii
xviii
xx
xxi
xxii
xxiii
xxiv
xxix
xxv
xxvi
xxvii
xxviii
xxx
xxxi
xxxii
xxxiii
xxxiv
xxxix
xxxv
xxxvi
xxxvii
xxxviii
xylem/M
xylene
xylophone/SM
xylophonist/MS
y'all
y/F
ya
yacht/SMDG
yachting/M
yachtsman/M
yachtsmen
yachtswoman/M
yachtswomen
yahoo/SM
yak/SM
yakked
yakking
yam/SM
yammer/SZGMDR
yammerer/M
yang/M
yank/MDSG
yap/SM
yapped
yapping
yard/MS
yardage/MS
yardarm/MS
yardman/M
yardmaster/MS
yardmen
yardstick/MS
yarmulke/SM
yarn/MS
yarrow/M
yashmak/S
yaw/SGMD
yawl/MS
yawn/MDRSZG
yawner/M
yaws/M
yd
ye/RST
yea/SM
yeah/M
yeahs
year/MYS
yearbook/MS
yearling/MS
yearlong
yearly/SM
yearn/GSJD
yearning/M
yeast/SM
yeasty/RT
yegg/MS
yell/MDSG
yellow/MDRTGPS
yellowhammer/S
yellowish
yellowness/M
yellowy
yelp/MDSG
yen/SM
yeoman/M
yeomanry/M
yeomen
yep/SM
yes/MS
yeshiva/SM
yessed
yessing
yesterday/MS
yesteryear/M
yet
yeti/MS
yew/SM
yid/S
yield/JSGMD
yikes
yin/M
yip/SM
yipe
yipped
yippee
yipping
yo
yob/S
yobbo/S
yodel/SMDRZG
yodeler/M
yoga/M
yogi/MS
yogic
yogurt/SM
yoke's
yoke/UGDS
yokel/SM
yolk/MDS
yon
yonder
yonks
yore/M
you'd
you'll
you're
you've
you/SMH
young/TMR
youngish
youngster/MS
your/S
yourself
yourselves
youth/M
youthful/YP
youthfulness/M
youths
yow
yowl/MDSG
yr/S
ytterbium/M
yttrium/M
yuan/M
yucca/SM
yuck
yucky/TR
yuk/SM
yukked
yukking
yukky
yule/M
yuletide/M
yum
yummy/TR
yup/SM
yuppie/MS
yuppify/GDS
yurt/MS
z/DNXTGJ
zaniness/M
zany/RSMPT
zap/SM
zapped
zapper/MS
zapping
zappy
zeal/M
zealot/MS
zealotry/M
zealous/YP
zealousness/M
zebra/SM
zebu/MS
zed/SM
zeitgeist/SM
zenith/M
zeniths
zenned
zeolite/S
zephyr/MS
zeppelin/MS
zero/MDHSG
zeroes
zest/MS
zestful/YP
zestfulness/M
zesty/RT
zeta/MS
zigzag/SM
zigzagged
zigzagging
zilch/M
zillion/MS
zinc/MS
zincked
zincking
zine/S
zinfandel/M
zing/MDRZG
zinger/M
zingy/RT
zinnia/MS
zip's
zip/US
zipped/U
zipper/MDGS
zipping/U
zippy/TR
zircon/MS
zirconium/M
zit/SM
zither/MS
zloty/SM
zlotys
zodiac/MS
zodiacal
zombie/MS
zonal/Y
zone's
zone/AGDS
zoning/M
zonked
zoo/SM
zookeeper/SM
zoological/Y
zoologist/SM
zoology/M
zoom/MDSG
zoophyte/SM
zoophytic
zooplankton
zorch
zoster
zounds
zucchini/MS
zwieback/M
zydeco/M
zygote/SM
zygotic
zymurgy/M
 VGFrZW4gZnJvbSBodHRwczovL2NnaXQuZnJlZWRlc2t0b3Aub3JnL2xpYnJlb2ZmaWNlL2RpY3Rpb25hcmllcy8uCg== <?xml version="1.0" encoding="UTF-8" standalone="no"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
    <xs:import namespace="http://www.w3.org/XML/1998/namespace"/>

    <xs:element name="otobo_config">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="Setting" type="SettingType" minOccurs="0" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="version" use="required" type="xs:string"/>
            <xs:attribute name="init" use="required">
                <xs:simpleType>
                    <xs:restriction base="xs:string">
                        <xs:enumeration value="Framework"/>
                        <xs:enumeration value="Application"/>
                        <xs:enumeration value="Config"/>
                        <xs:enumeration value="Changes"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
        </xs:complexType>
    </xs:element>

    <xs:simpleType name="BooleanAttribute">
        <xs:restriction base="xs:string">
            <xs:enumeration value="0"/>
            <xs:enumeration value="1"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:complexType name="SettingType">
        <xs:sequence>
            <xs:element name="Description">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="xs:string">
                            <xs:attribute name="Translatable" use="optional" type="BooleanAttribute"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="Navigation" type="xs:string" />
            <xs:element name="Value"      type="ValueType"/>
        </xs:sequence>
        <xs:attribute name="Name" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:maxLength value="250" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>

        <xs:attribute name="Required"                 use="required" type="BooleanAttribute" />
        <xs:attribute name="Valid"                    use="required" type="BooleanAttribute"/>
        <xs:attribute name="ReadOnly"                 use="optional" type="BooleanAttribute" />
        <xs:attribute name="Invisible"                use="optional" type="BooleanAttribute" />
        <xs:attribute name="UserModificationPossible" use="optional" type="BooleanAttribute" />
        <xs:attribute name="UserModificationActive"   use="optional" type="BooleanAttribute" />

        <xs:attribute name="ConfigLevel" use="optional" type="xs:int"/>

        <xs:attribute name="UserPreferencesGroup" use="optional" type="xs:string"/>
    </xs:complexType>

    <xs:complexType name="ValueType">
        <xs:choice>
            <xs:element name="Item"  type="ItemType"/>
            <xs:element name="Hash"  type="HashType"/>
            <xs:element name="Array" type="ArrayType"/>
        </xs:choice>
    </xs:complexType>

    <xs:complexType mixed="true" name="ItemType">
        <xs:choice>
            <xs:element name="Array" type="ArrayType"/>
            <xs:element name="Hash"  type="HashType"/>
            <xs:sequence>
                <xs:element name="Item" minOccurs="0" maxOccurs="unbounded" type="ItemType"/>
            </xs:sequence>
        </xs:choice>
        <xs:attribute name="Translatable" type="BooleanAttribute" use="optional" />
        <!-- allow for arbitrary unspecified value-type specific attributes -->
        <xs:anyAttribute processContents="skip"/>
    </xs:complexType>

    <xs:complexType name="HashType">
        <xs:sequence>
            <xs:element name="DefaultItem" type="ItemType" minOccurs="0" maxOccurs="1"/>
            <xs:element name="Item" type="ItemType" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute name="MinItems" type="xs:int" use="optional" />
        <xs:attribute name="MaxItems" type="xs:int" use="optional" />
    </xs:complexType>

    <xs:complexType name="ArrayType">
        <xs:sequence>
            <xs:element name="DefaultItem" type="DefaultItemType" minOccurs="0" maxOccurs="1"/>
            <xs:element name="Item" type="ItemType" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute name="MinItems" type="xs:int" use="optional" />
        <xs:attribute name="MaxItems" type="xs:int" use="optional" />
    </xs:complexType>

    <xs:complexType mixed="true" name="DefaultItemType">
        <xs:choice>
            <xs:element name="Array" type="DefaultArrayType"/>
            <xs:element name="Hash"  type="DefaultHashType"/>
            <xs:sequence>
                <xs:element name="Item" minOccurs="0" maxOccurs="unbounded" type="ItemType"/>
            </xs:sequence>
        </xs:choice>
        <xs:attribute name="Translatable" type="BooleanAttribute" use="optional" />
        <!-- allow for arbitrary unspecified value-type specific attributes -->
        <xs:anyAttribute processContents="skip"/>
    </xs:complexType>

    <!-- Hashes in DefaultItems can only contain other DefaultItems, not real Items. -->
    <xs:complexType name="DefaultHashType">
        <xs:sequence>
            <xs:element name="DefaultItem" type="DefaultItemType" minOccurs="0" maxOccurs="1"/>
        </xs:sequence>
        <xs:attribute name="MinItems" type="xs:int" use="optional" />
        <xs:attribute name="MaxItems" type="xs:int" use="optional" />
    </xs:complexType>

    <!-- Arrays in DefaultItems can only contain other DefaultItems, not real Items. -->
    <xs:complexType name="DefaultArrayType">
        <xs:sequence>
            <xs:element name="DefaultItem" type="DefaultItemType" minOccurs="0" maxOccurs="1"/>
        </xs:sequence>
        <xs:attribute name="MinItems" type="xs:int" use="optional" />
        <xs:attribute name="MaxItems" type="xs:int" use="optional" />
    </xs:complexType>
</xs:schema>
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
    <xs:import namespace="http://www.w3.org/XML/1998/namespace"/>

    <!-- OTOBO schema files -->
    <xs:element name="database">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="Table" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableCreate" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableAlter" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableDrop" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="Insert" minOccurs="0" maxOccurs="unbounded" />
            </xs:choice>
            <xs:attribute name="Name" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <!-- OTOBO package files (.sopm) -->
    <xs:element name="DatabaseInstall">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="TableCreate" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableAlter" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableDrop" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="Insert" minOccurs="0" maxOccurs="unbounded" />
            </xs:choice>
            <xs:attribute name="Type" use="optional" type="xs:token"/>
            <xs:attribute name="IfPackage" use="optional" type="xs:token"/>
            <xs:attribute name="IfNotPackage" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>
    <xs:element name="DatabaseUninstall">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="TableCreate" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableAlter" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableDrop" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="Insert" minOccurs="0" maxOccurs="unbounded" />
            </xs:choice>
            <xs:attribute name="Type" use="optional" type="xs:token"/>
            <xs:attribute name="IfPackage" use="optional" type="xs:token"/>
            <xs:attribute name="IfNotPackage" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>
    <xs:element name="DatabaseReinstall">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="TableCreate" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableAlter" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableDrop" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="Insert" minOccurs="0" maxOccurs="unbounded" />
            </xs:choice>
            <xs:attribute name="Type" use="optional" type="xs:token"/>
            <xs:attribute name="IfPackage" use="optional" type="xs:token"/>
            <xs:attribute name="IfNotPackage" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>
    <xs:element name="DatabaseUpgrade">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="TableCreate" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableAlter" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="TableDrop" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="Insert" minOccurs="0" maxOccurs="unbounded" />
            </xs:choice>
            <xs:attribute name="Type" use="optional" type="xs:token"/>
            <xs:attribute name="IfPackage" use="optional" type="xs:token"/>
            <xs:attribute name="IfNotPackage" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <!-- Oracle allows table names up to 30 characters only. -->
    <xs:simpleType name="TableName">
        <xs:restriction base="xs:token">
          <xs:maxLength value="30" />
          <xs:pattern value="[a-zA-Z0-9_-]+"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:element name="Table">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="Column" maxOccurs="unbounded" />
                <xs:element ref="ForeignKey" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="Index" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="Unique" minOccurs="0" maxOccurs="unbounded" />
            </xs:choice>
            <xs:attribute name="Name" use="optional" type="TableName"/>
            <xs:attribute name="Version" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="TableCreate">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="Column" maxOccurs="unbounded" />
                <xs:element ref="ForeignKey" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="Index" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="Unique" minOccurs="0" maxOccurs="unbounded" />
            </xs:choice>
            <xs:attribute name="Name" use="optional" type="TableName"/>
            <xs:attribute name="Version" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="TableAlter">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="ColumnAdd" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="ColumnChange" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="ColumnDrop" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="ForeignKeyCreate" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="ForeignKeyDrop" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="IndexCreate" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="IndexDrop" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="UniqueCreate" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="UniqueDrop" minOccurs="0" maxOccurs="unbounded" />
            </xs:choice>
            <xs:attribute name="Name" use="optional" type="TableName"/>
            <xs:attribute name="NameOld" use="optional" type="xs:token"/>
            <xs:attribute name="NameNew" use="optional" type="xs:token"/>
            <xs:attribute name="Version" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="TableDrop">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Name" use="required" type="TableName"/>
                    <xs:attribute name="Version" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <!-- Columns -->

    <!-- Oracle allows column names up to 30 characters only. -->
    <xs:simpleType name="ColumnName">
        <xs:restriction base="xs:token">
          <xs:maxLength value="30" />
          <xs:pattern value="[a-zA-Z0-9_-]+"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="ColumnType">
        <xs:restriction base="xs:string">
            <xs:enumeration value="DATE"/>
            <xs:enumeration value="SMALLINT"/>
            <xs:enumeration value="BIGINT"/>
            <xs:enumeration value="INTEGER"/>
            <xs:enumeration value="DECIMAL"/>
            <xs:enumeration value="VARCHAR"/>
            <xs:enumeration value="LONGBLOB"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:element name="Column">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="optional" type="ColumnType"/>
                    <xs:attribute name="AutoIncrement" use="optional" type="xs:token"/>
                    <xs:attribute name="Name" use="required" type="ColumnName"/>
                    <xs:attribute name="Required" use="optional" type="xs:token"/>
                    <xs:attribute name="Size" use="optional" type="xs:token"/>
                    <xs:attribute name="PrimaryKey" use="optional" type="xs:token"/>
                    <xs:attribute name="Default" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="ColumnAdd">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="optional" type="ColumnType"/>
                    <xs:attribute name="AutoIncrement" use="optional" type="xs:token"/>
                    <xs:attribute name="Name" use="required" type="ColumnName"/>
                    <xs:attribute name="Required" use="optional" type="xs:token"/>
                    <xs:attribute name="Size" use="optional" type="xs:token"/>
                    <xs:attribute name="PrimaryKey" use="optional" type="xs:token"/>
                    <xs:attribute name="Default" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="ColumnChange">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="optional" type="ColumnType"/>
                    <xs:attribute name="AutoIncrement" use="optional" type="xs:token"/>
                    <xs:attribute name="PrimaryKey" use="optional" type="xs:token"/>
                    <xs:attribute name="Default" use="optional" type="xs:token"/>
                    <xs:attribute name="NameOld" use="optional" type="ColumnName"/>
                    <xs:attribute name="NameNew" use="optional" type="ColumnName"/>
                    <xs:attribute name="Required" use="optional" type="xs:token"/>
                    <xs:attribute name="Size" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="ColumnDrop">
        <xs:complexType>
            <xs:attribute name="Name" use="required" type="ColumnName"/>
        </xs:complexType>
    </xs:element>

    <!-- Foreign Keys -->

    <xs:element name="ForeignKey">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="Reference" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="ForeignTable" use="required" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="ForeignKeyCreate">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="Reference" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="ForeignTable" use="required" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="ForeignKeyDrop">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="Reference" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="ForeignTable" use="required" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="Reference">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Local" use="required" type="xs:token"/>
                    <xs:attribute name="Foreign" use="required" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <!-- Unique columns -->

    <xs:element name="Unique">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="UniqueColumn" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="Name" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="UniqueColumn">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Name" use="required" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <xs:element name="UniqueCreate">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="UniqueColumn" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="Name" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="UniqueDrop">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Name" use="required" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <!-- Index columns -->

    <xs:element name="Index">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="IndexColumn" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="Name" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="IndexColumn">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Name" use="required" type="xs:token"/>
                    <xs:attribute name="Size" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <xs:element name="IndexCreate">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="IndexColumn" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="Name" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="IndexDrop">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Name" use="required" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <!-- Insert stuff into database -->

    <xs:element name="Insert">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="Data" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="Type" use="optional" type="xs:token"/>
            <xs:attribute name="Table" use="required" type="xs:token"/>
            <xs:attribute name="Version" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:complexType name="TranslatableString">
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Translatable" use="optional">
                    <xs:simpleType>
                        <xs:restriction base="xs:string">
                            <xs:enumeration value="0"/>
                            <xs:enumeration value="1"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:attribute>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>

    <xs:element name="Data">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="TranslatableString">
                    <xs:attribute name="Key" use="optional" type="xs:token"/>
                    <xs:attribute name="Type" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

</xs:schema>
 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook CALS Table Model V4.3CR3 ........................................ -->
<!-- File calstblx.mod .................................................... -->
<!--
  Copyright 1992-2002 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  This DTD is based on the CALS Table Model
  PUBLIC "-//USA-DOD//DTD Table Model 951010//EN"
  
  $Id: calstblx.dtd,v 1.19 2004/01/21 18:54:21 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the CALS Table Model
  converted to XML. It has been modified slightly for use in the
  combined HTML/CALS models supported by DocBook V4.3.
-->
<!--
  These definitions are not directly related to the table model, but are
  used in the default CALS table model and are usually defined elsewhere
  (and prior to the inclusion of this table module) in a CALS DTD.
-->
<!--
  no if zero(s),
  yes if any other digits value
-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <xs:simpleType name="yesorno">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:group name="titles">
    <xs:sequence>
      <xs:element minOccurs="0" ref="title"/>
    </xs:sequence>
  </xs:group>
  <!-- default for use in entry content -->
  <!--
    The parameter entities as defined below provide the CALS table model
    as published (as part of the Example DTD) in MIL-HDBK-28001.
    
    These following declarations provide the CALS-compliant default definitions
    for these entities.  However, these entities can and should be redefined
    (by giving the appropriate parameter entity declaration(s) prior to the
    reference to this Table Model declaration set entity) to fit the needs
    of the current application.
  -->
  <xs:group name="tbl.table-titles.mdl">
    <xs:sequence>
      <xs:group ref="titles"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="tbl.table-main.mdl">
    <xs:choice>
      <xs:element maxOccurs="unbounded" ref="tgroup"/>
      <xs:element maxOccurs="unbounded" ref="graphic"/>
    </xs:choice>
  </xs:group>
  <xs:complexType name="tbl.tgroup.mdl">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="spanspec"/>
      <xs:element minOccurs="0" ref="thead"/>
      <xs:element minOccurs="0" ref="tfoot"/>
      <xs:element ref="tbody"/>
    </xs:sequence>
  </xs:complexType>
  <xs:attributeGroup name="tbl.tgroup.att">
    <xs:attribute name="tgroupstyle"/>
  </xs:attributeGroup>
  <xs:complexType name="tbl.row.mdl">
    <xs:choice maxOccurs="unbounded">
      <xs:element ref="entry"/>
      <xs:element ref="entrytbl"/>
    </xs:choice>
  </xs:complexType>
  <xs:complexType name="tbl.entrytbl.mdl">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="spanspec"/>
      <xs:element minOccurs="0" ref="thead"/>
      <xs:element ref="tbody"/>
    </xs:sequence>
  </xs:complexType>
  <!-- =====  Element and attribute declarations follow. ===== -->
  <xs:element name="table" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.table.mdl">
          <xs:attributeGroup ref="table.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="table.attlist">
    <xs:attribute name="frame" type="tbl.frame.attval"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attributeGroup ref="tbl.table.att"/>
    <xs:attributeGroup ref="bodyatt"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="tgroup">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.tgroup.mdl">
          <xs:attributeGroup ref="tgroup.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tgroup.attlist">
    <xs:attribute name="cols" use="required"/>
    <xs:attributeGroup ref="tbl.tgroup.att"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="colspec">
    <xs:complexType>
      <xs:attributeGroup ref="colspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="colspec.attlist">
    <xs:attribute name="colnum"/>
    <xs:attribute name="colname"/>
    <xs:attribute name="colwidth"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <xs:element name="spanspec">
    <xs:complexType>
      <xs:attributeGroup ref="spanspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="spanspec.attlist">
    <xs:attribute name="namest" use="required"/>
    <xs:attribute name="nameend" use="required"/>
    <xs:attribute name="spanname" use="required"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <xs:element name="thead">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.hdft.mdl">
          <xs:attributeGroup ref="thead.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="thead.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="tfoot">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.hdft.mdl">
          <xs:attributeGroup ref="tfoot.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tfoot.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="tbody">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.tbody.mdl">
          <xs:attributeGroup ref="tbody.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tbody.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="row">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.row.mdl">
          <xs:attributeGroup ref="row.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="row.attlist">
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="entrytbl">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.entrytbl.mdl">
          <xs:attributeGroup ref="entrytbl.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="entrytbl.attlist">
    <xs:attribute name="cols" use="required"/>
    <xs:attributeGroup ref="tbl.tgroup.att"/>
    <xs:attribute name="colname"/>
    <xs:attribute name="spanname"/>
    <xs:attribute name="namest"/>
    <xs:attribute name="nameend"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="entry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="tbl.entry.mdl"/>
      <xs:attributeGroup ref="entry.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="entry.attlist">
    <xs:attribute name="colname"/>
    <xs:attribute name="namest"/>
    <xs:attribute name="nameend"/>
    <xs:attribute name="spanname"/>
    <xs:attribute name="morerows"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attribute name="rotate" type="yesorno"/>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
</xs:schema>
<!-- End of DocBook CALS Table Model V4.3CR3 ................................. -->
<!-- ...................................................................... -->
 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook document hierarchy module V4.3CR3 ............................... -->
<!-- File dbhierx.mod ..................................................... -->
<!--
  Copyright 1992-2002 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: dbhierx.mod,v 1.28 2004/01/21 18:54:21 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the overall document
  hierarchies of DocBook documents.  It covers computer documentation
  manuals and manual fragments, as well as reference entries (such as
  man pages) and technical journals or anthologies containing
  articles.
  
  This module depends on the DocBook information pool module.  All
  elements and entities referenced but not defined here are assumed
  to be defined in the information pool module.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % dbhier PUBLIC
  "-//OASIS//ELEMENTS DocBook Document Hierarchy V4.3CR3//EN"
  "dbhierx.mod">
  %dbhier;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ...................................................................... -->
<!-- Entities for module inclusions ....................................... -->
<!-- ...................................................................... -->
<!-- Entities for element classes ......................................... -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <xs:element name="appendix.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="appendixinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="appendix.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="article.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="articleinfo"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="lot"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:group ref="nav.class"/>
          <xs:element ref="appendix.class"/>
          <xs:element ref="ackno"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="article.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="book.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="bookinfo"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="dedication"/>
          <xs:element ref="toc"/>
          <xs:element ref="lot"/>
          <xs:element ref="glossary"/>
          <xs:element ref="bibliography"/>
          <xs:element ref="preface"/>
          <xs:element ref="chapter.class"/>
          <xs:element ref="reference"/>
          <xs:element ref="part"/>
          <xs:element ref="article.class"/>
          <xs:element ref="appendix.class"/>
          <xs:group ref="index.class"/>
          <xs:element ref="colophon"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="book.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="chapter.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="chapterinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="chapter.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:group name="index.class">
    <xs:choice>
      <xs:element ref="index"/>
      <xs:element ref="setindex"/>
    </xs:choice>
  </xs:group>
  <xs:element name="refentry.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" ref="refentryinfo"/>
        <xs:element minOccurs="0" ref="refmeta"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="remark"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
        <xs:element maxOccurs="unbounded" ref="refnamediv"/>
        <xs:element minOccurs="0" ref="refsynopsisdiv"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="refsect1"/>
          <xs:element maxOccurs="unbounded" ref="refsection"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="section.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sectioninfo"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="section.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="section.class"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="section.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:group name="nav.class">
    <xs:choice>
      <xs:element ref="toc"/>
      <xs:element ref="lot"/>
      <xs:element ref="index"/>
      <xs:element ref="glossary"/>
      <xs:element ref="bibliography"/>
    </xs:choice>
  </xs:group>
  <!-- Redeclaration placeholder ............................................ -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- ...................................................................... -->
  <!-- Entities for element mixtures ........................................ -->
  <!-- The DocBook TC may produce an official forms module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:group name="divcomponent.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refcomponent.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="indexdivcomponent.mix">
    <xs:choice>
      <xs:element ref="itemizedlist"/>
      <xs:element ref="orderedlist"/>
      <xs:element ref="variablelist"/>
      <xs:element ref="simplelist"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="anchor"/>
      <xs:element ref="remark"/>
      <xs:element ref="link.char.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refname.char.mix">
    <xs:sequence>
      <xs:element minOccurs="0" ref="tech.char.class"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="partcontent.mix">
    <xs:choice>
      <xs:element ref="appendix.class"/>
      <xs:element ref="chapter.class"/>
      <xs:group ref="nav.class"/>
      <xs:element ref="article.class"/>
      <xs:element ref="preface"/>
      <xs:element ref="refentry.class"/>
      <xs:element ref="reference"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refinline.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="refclass.char.mix">
    <xs:sequence>
      <xs:element minOccurs="0" ref="application"/>
    </xs:sequence>
  </xs:group>
  <!-- Redeclaration placeholder 2 .......................................... -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- ...................................................................... -->
  <!-- Entities for content models .......................................... -->
  <xs:group name="div.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="bookcomponent.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="sect.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="refsect.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="bookcomponent.content">
    <xs:choice>
      <xs:sequence>
        <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect1"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="section.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="sect1"/>
        <xs:element maxOccurs="unbounded" ref="refentry.class"/>
        <xs:element maxOccurs="unbounded" ref="simplesect"/>
        <xs:element maxOccurs="unbounded" ref="section.class"/>
      </xs:choice>
    </xs:choice>
  </xs:group>
  <!-- ...................................................................... -->
  <!-- Set and SetInfo ...................................................... -->
  <xs:attributeGroup name="set.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="set">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="setinfo"/>
        <xs:element minOccurs="0" ref="toc"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="set"/>
          <xs:element ref="book.class"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="setindex"/>
      </xs:sequence>
      <xs:attributeGroup ref="set.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of set.element -->
  <!-- FPI: SGML formal public identifier -->
  <xs:attributeGroup name="set.attlist">
    <xs:attribute name="fpi"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="set.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of set.attlist -->
  <!-- end of set.module -->
  <xs:attributeGroup name="setinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="setinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="setinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setinfo.element -->
  <!--
    Contents: IDs of the ToC, Books, and SetIndex that comprise
    the set, in the order of their appearance
  -->
  <xs:attributeGroup name="setinfo.attlist">
    <xs:attribute name="contents" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="setinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setinfo.attlist -->
  <!-- end of setinfo.module -->
  <!-- end of set.content.module -->
  <!-- ...................................................................... -->
  <!-- Book and BookInfo .................................................... -->
  <xs:attributeGroup name="book.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="book" substitutionGroup="book.class"/>
  <!-- end of book.element -->
  <!-- FPI: SGML formal public identifier -->
  <xs:attributeGroup name="book.attlist">
    <xs:attribute name="fpi"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="book.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of book.attlist -->
  <!-- end of book.module -->
  <xs:attributeGroup name="bookinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bookinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="bookinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bookinfo.element -->
  <!--
    Contents: IDs of the ToC, LoTs, Prefaces, Parts, Chapters,
    Appendixes, References, GLossary, Bibliography, and indexes
    comprising the Book, in the order of their appearance
  -->
  <xs:attributeGroup name="bookinfo.attlist">
    <xs:attribute name="contents" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bookinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bookinfo.attlist -->
  <!-- end of bookinfo.module -->
  <!-- end of book.content.module -->
  <!-- ...................................................................... -->
  <!-- Dedication, ToC, and LoT ............................................. -->
  <xs:attributeGroup name="dedication.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="dedication">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="legalnotice.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="dedication.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of dedication.element -->
  <xs:attributeGroup name="dedication.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="dedication.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of dedication.attlist -->
  <!-- end of dedication.module -->
  <xs:attributeGroup name="colophon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="colophon">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="textobject.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="colophon.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of colophon.element -->
  <xs:attributeGroup name="colophon.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="colophon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of colophon.attlist -->
  <!-- end of colophon.module -->
  <xs:attributeGroup name="toc.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toc">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocfront"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="tocpart"/>
          <xs:element ref="tocchap"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocback"/>
      </xs:sequence>
      <xs:attributeGroup ref="toc.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toc.element -->
  <xs:attributeGroup name="toc.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toc.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toc.attlist -->
  <!-- end of toc.module -->
  <xs:attributeGroup name="tocfront.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocfront">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocfront.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocfront.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocfront.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocfront.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocfront.attlist -->
  <!-- end of tocfront.module -->
  <xs:attributeGroup name="tocentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocentry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocentry.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocentry.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocentry.attlist -->
  <!-- end of tocentry.module -->
  <xs:attributeGroup name="tocpart.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocpart">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocchap"/>
      </xs:sequence>
      <xs:attributeGroup ref="tocpart.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocpart.element -->
  <xs:attributeGroup name="tocpart.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocpart.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocpart.attlist -->
  <!-- end of tocpart.module -->
  <xs:attributeGroup name="tocchap.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocchap">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel1"/>
      </xs:sequence>
      <xs:attributeGroup ref="tocchap.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocchap.element -->
  <xs:attributeGroup name="tocchap.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocchap.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocchap.attlist -->
  <!-- end of tocchap.module -->
  <xs:attributeGroup name="toclevel1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel1">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel2"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel1.element -->
  <xs:attributeGroup name="toclevel1.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel1.attlist -->
  <!-- end of toclevel1.module -->
  <xs:attributeGroup name="toclevel2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel2">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel3"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel2.element -->
  <xs:attributeGroup name="toclevel2.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel2.attlist -->
  <!-- end of toclevel2.module -->
  <xs:attributeGroup name="toclevel3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel3">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel4"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel3.element -->
  <xs:attributeGroup name="toclevel3.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel3.attlist -->
  <!-- end of toclevel3.module -->
  <xs:attributeGroup name="toclevel4.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel4">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel5"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel4.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel4.element -->
  <xs:attributeGroup name="toclevel4.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel4.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel4.attlist -->
  <!-- end of toclevel4.module -->
  <xs:attributeGroup name="toclevel5.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel5">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel5.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel5.element -->
  <xs:attributeGroup name="toclevel5.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel5.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel5.attlist -->
  <!-- end of toclevel5.module -->
  <xs:attributeGroup name="tocback.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocback">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocback.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocback.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocback.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocback.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocback.attlist -->
  <!-- end of tocback.module -->
  <!-- end of toc.content.module -->
  <xs:attributeGroup name="lot.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lot">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="lotentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="lot.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lot.element -->
  <xs:attributeGroup name="lot.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lot.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lot.attlist -->
  <!-- end of lot.module -->
  <xs:attributeGroup name="lotentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lotentry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="lotentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lotentry.element -->
  <!--
    SrcCredit: Information about the source of the entry,
    as for a list of illustrations
  -->
  <!-- linkend: to element that this entry represents -->
  <xs:attributeGroup name="lotentry.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attribute name="srccredit"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lotentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lotentry.attlist -->
  <!-- end of lotentry.module -->
  <!-- end of lot.content.module -->
  <!-- ...................................................................... -->
  <!-- Appendix, Chapter, Part, Preface, Reference, PartIntro ............... -->
  <xs:attributeGroup name="appendix.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="appendix" substitutionGroup="appendix.class"/>
  <!-- end of appendix.element -->
  <xs:attributeGroup name="appendix.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="appendix.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of appendix.attlist -->
  <!-- end of appendix.module -->
  <xs:attributeGroup name="chapter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="chapter" substitutionGroup="chapter.class"/>
  <!-- end of chapter.element -->
  <xs:attributeGroup name="chapter.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="chapter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of chapter.attlist -->
  <!-- end of chapter.module -->
  <!--
    Note that Part was to have its content model reduced in V4.3CR3.  This
    change will not be made after all.
  -->
  <xs:attributeGroup name="part.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="part">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="partinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" ref="partintro"/>
        <xs:group maxOccurs="unbounded" ref="partcontent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="part.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of part.element -->
  <xs:attributeGroup name="part.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="part.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of part.attlist -->
  <!-- ELEMENT PartIntro (defined below) -->
  <!-- end of part.module -->
  <xs:attributeGroup name="preface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="preface">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="prefaceinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="preface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of preface.element -->
  <xs:attributeGroup name="preface.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="preface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of preface.attlist -->
  <!-- end of preface.module -->
  <xs:attributeGroup name="reference.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="reference">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="referenceinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" ref="partintro"/>
        <xs:element maxOccurs="unbounded" ref="refentry.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="reference.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of reference.element -->
  <xs:attributeGroup name="reference.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="reference.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of reference.attlist -->
  <!-- ELEMENT PartIntro (defined below) -->
  <!-- end of reference.module -->
  <xs:attributeGroup name="partintro.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="partintro">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:group ref="bookcomponent.content"/>
      </xs:sequence>
      <xs:attributeGroup ref="partintro.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of partintro.element -->
  <xs:attributeGroup name="partintro.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="partintro.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of partintro.attlist -->
  <!-- end of partintro.module -->
  <!-- ...................................................................... -->
  <!-- Other Info elements .................................................. -->
  <xs:attributeGroup name="appendixinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="appendixinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="appendixinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of appendixinfo.element -->
  <xs:attributeGroup name="appendixinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="appendixinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of appendixinfo.attlist -->
  <!-- end of appendixinfo.module -->
  <xs:attributeGroup name="bibliographyinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliographyinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="bibliographyinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliographyinfo.element -->
  <xs:attributeGroup name="bibliographyinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliographyinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliographyinfo.attlist -->
  <!-- end of bibliographyinfo.module -->
  <xs:attributeGroup name="chapterinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="chapterinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="chapterinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of chapterinfo.element -->
  <xs:attributeGroup name="chapterinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="chapterinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of chapterinfo.attlist -->
  <!-- end of chapterinfo.module -->
  <xs:attributeGroup name="glossaryinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossaryinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="glossaryinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossaryinfo.element -->
  <xs:attributeGroup name="glossaryinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossaryinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossaryinfo.attlist -->
  <!-- end of glossaryinfo.module -->
  <xs:attributeGroup name="indexinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="indexinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexinfo.element -->
  <xs:attributeGroup name="indexinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexinfo.attlist -->
  <!-- end of indexinfo.module -->
  <xs:attributeGroup name="setindexinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="setindexinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="setindexinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setindexinfo.element -->
  <xs:attributeGroup name="setindexinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="setindexinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setindexinfo.attlist -->
  <!-- end of setindexinfo.module -->
  <xs:attributeGroup name="partinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="partinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="partinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of partinfo.element -->
  <xs:attributeGroup name="partinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="partinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of partinfo.attlist -->
  <!-- end of partinfo.module -->
  <xs:attributeGroup name="prefaceinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="prefaceinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="prefaceinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of prefaceinfo.element -->
  <xs:attributeGroup name="prefaceinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="prefaceinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of prefaceinfo.attlist -->
  <!-- end of prefaceinfo.module -->
  <xs:attributeGroup name="refentryinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refentryinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refentryinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refentryinfo.element -->
  <xs:attributeGroup name="refentryinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentryinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentryinfo.attlist -->
  <!-- end of refentryinfo.module -->
  <xs:attributeGroup name="refsectioninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsectioninfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsectioninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsectioninfo.element -->
  <xs:attributeGroup name="refsectioninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsectioninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsectioninfo.attlist -->
  <!-- end of refsectioninfo.module -->
  <xs:attributeGroup name="refsect1info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect1info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect1info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect1info.element -->
  <xs:attributeGroup name="refsect1info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect1info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect1info.attlist -->
  <!-- end of refsect1info.module -->
  <xs:attributeGroup name="refsect2info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect2info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect2info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect2info.element -->
  <xs:attributeGroup name="refsect2info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect2info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect2info.attlist -->
  <!-- end of refsect2info.module -->
  <xs:attributeGroup name="refsect3info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect3info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect3info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect3info.element -->
  <xs:attributeGroup name="refsect3info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect3info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect3info.attlist -->
  <!-- end of refsect3info.module -->
  <xs:attributeGroup name="refsynopsisdivinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsynopsisdivinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsynopsisdivinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsynopsisdivinfo.element -->
  <xs:attributeGroup name="refsynopsisdivinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsynopsisdivinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsynopsisdivinfo.attlist -->
  <!-- end of refsynopsisdivinfo.module -->
  <xs:attributeGroup name="referenceinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="referenceinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="referenceinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of referenceinfo.element -->
  <xs:attributeGroup name="referenceinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="referenceinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of referenceinfo.attlist -->
  <!-- end of referenceinfo.module -->
  <xs:attributeGroup name="sect1info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect1info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect1info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect1info.element -->
  <xs:attributeGroup name="sect1info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect1info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect1info.attlist -->
  <xs:attributeGroup name="sect2info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect2info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect2info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect2info.element -->
  <xs:attributeGroup name="sect2info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect2info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect2info.attlist -->
  <xs:attributeGroup name="sect3info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect3info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect3info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect3info.element -->
  <xs:attributeGroup name="sect3info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect3info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect3info.attlist -->
  <xs:attributeGroup name="sect4info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect4info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect4info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect4info.element -->
  <xs:attributeGroup name="sect4info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect4info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect4info.attlist -->
  <xs:attributeGroup name="sect5info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect5info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect5info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect5info.element -->
  <xs:attributeGroup name="sect5info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect5info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect5info.attlist -->
  <!-- ...................................................................... -->
  <!-- Section (parallel to Sect*) ......................................... -->
  <xs:attributeGroup name="section.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="section" substitutionGroup="section.class"/>
  <!-- end of section.element -->
  <xs:attributeGroup name="section.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="section.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of section.attlist -->
  <!-- end of section.module -->
  <xs:attributeGroup name="sectioninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sectioninfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sectioninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sectioninfo.element -->
  <xs:attributeGroup name="sectioninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sectioninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sectioninfo.attlist -->
  <!-- end of sectioninfo.module -->
  <!-- end of section.content.module -->
  <!-- ...................................................................... -->
  <!-- Sect1, Sect2, Sect3, Sect4, Sect5 .................................... -->
  <xs:attributeGroup name="sect1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect1">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect1info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect2"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect2"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect1.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect1.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect1.attlist -->
  <!-- end of sect1.module -->
  <xs:attributeGroup name="sect2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect2">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect2info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect3"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect3"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect2.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect2.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect2.attlist -->
  <!-- end of sect2.module -->
  <xs:attributeGroup name="sect3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect3">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect3info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect4"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect4"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect3.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect3.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect3.attlist -->
  <!-- end of sect3.module -->
  <xs:attributeGroup name="sect4.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect4">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect4info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect5"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect5"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect4.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect4.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect4.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect4.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect4.attlist -->
  <!-- end of sect4.module -->
  <xs:attributeGroup name="sect5.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect5">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect5info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect5.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect5.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect5.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect5.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect5.attlist -->
  <!-- end of sect5.module -->
  <xs:attributeGroup name="simplesect.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simplesect">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplesect.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplesect.element -->
  <xs:attributeGroup name="simplesect.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplesect.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplesect.attlist -->
  <!-- end of simplesect.module -->
  <!-- ...................................................................... -->
  <!-- Bibliography ......................................................... -->
  <xs:attributeGroup name="bibliography.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliography">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="bibliographyinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="bibliodiv"/>
          <xs:choice maxOccurs="unbounded">
            <xs:element ref="biblioentry"/>
            <xs:element ref="bibliomixed"/>
          </xs:choice>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="bibliography.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliography.element -->
  <xs:attributeGroup name="bibliography.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliography.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliography.attlist -->
  <!-- end of bibliography.module -->
  <xs:attributeGroup name="bibliodiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliodiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="biblioentry"/>
          <xs:element ref="bibliomixed"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="bibliodiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliodiv.element -->
  <xs:attributeGroup name="bibliodiv.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliodiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliodiv.attlist -->
  <!-- end of bibliodiv.module -->
  <!-- end of bibliography.content.module -->
  <!-- ...................................................................... -->
  <!-- Glossary ............................................................. -->
  <xs:attributeGroup name="glossary.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossary">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="glossaryinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="glossdiv"/>
          <xs:element maxOccurs="unbounded" ref="glossentry"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="bibliography"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossary.element -->
  <xs:attributeGroup name="glossary.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossary.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossary.attlist -->
  <!-- end of glossary.module -->
  <xs:attributeGroup name="glossdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:element maxOccurs="unbounded" ref="glossentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossdiv.element -->
  <xs:attributeGroup name="glossdiv.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossdiv.attlist -->
  <!-- end of glossdiv.module -->
  <!-- end of glossary.content.module -->
  <!-- ...................................................................... -->
  <!-- Index and SetIndex ................................................... -->
  <xs:attributeGroup name="indexes.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="index">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="indexinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexdiv"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="index.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of index.element -->
  <xs:attributeGroup name="index.attlist">
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexes.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of index.attlist -->
  <xs:element name="setindex">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="setindexinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexdiv"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="setindex.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setindex.element -->
  <xs:attributeGroup name="setindex.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexes.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setindex.attlist -->
  <!-- end of indexes.module -->
  <!--
    SegmentedList in this content is useful for marking up permuted
    indices.
  -->
  <xs:attributeGroup name="indexdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:sequence>
          <xs:group minOccurs="0" maxOccurs="unbounded" ref="indexdivcomponent.mix"/>
          <xs:choice>
            <xs:element maxOccurs="unbounded" ref="indexentry"/>
            <xs:element ref="segmentedlist"/>
          </xs:choice>
        </xs:sequence>
      </xs:sequence>
      <xs:attributeGroup ref="indexdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexdiv.element -->
  <xs:attributeGroup name="indexdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexdiv.attlist -->
  <!-- end of indexdiv.module -->
  <!-- Index entries appear in the index, not the text. -->
  <xs:attributeGroup name="indexentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="primaryie"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="seeie"/>
          <xs:element ref="seealsoie"/>
        </xs:choice>
        <xs:sequence minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="secondaryie"/>
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="seeie"/>
            <xs:element ref="seealsoie"/>
            <xs:element ref="tertiaryie"/>
          </xs:choice>
        </xs:sequence>
      </xs:sequence>
      <xs:attributeGroup ref="indexentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexentry.element -->
  <xs:attributeGroup name="indexentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexentry.attlist -->
  <!-- end of indexentry.module -->
  <xs:attributeGroup name="primsecterie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="primaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="primaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of primaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="primaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of primaryie.attlist -->
  <xs:element name="secondaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="secondaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of secondaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="secondaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of secondaryie.attlist -->
  <xs:element name="tertiaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="tertiaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tertiaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="tertiaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tertiaryie.attlist -->
  <!-- end of primsecterie.module -->
  <xs:attributeGroup name="seeie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seeie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seeie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seeie.element -->
  <!-- to IndexEntry to look up -->
  <xs:attributeGroup name="seeie.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seeie.attlist -->
  <!-- end of seeie.module -->
  <xs:attributeGroup name="seealsoie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seealsoie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seealsoie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seealsoie.element -->
  <!-- to related IndexEntries -->
  <xs:attributeGroup name="seealsoie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seealsoie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seealsoie.attlist -->
  <!-- end of seealsoie.module -->
  <!-- end of index.content.module -->
  <!-- ...................................................................... -->
  <!-- RefEntry ............................................................. -->
  <xs:attributeGroup name="refentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refentry" substitutionGroup="refentry.class"/>
  <!-- end of refentry.element -->
  <xs:attributeGroup name="refentry.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentry.attlist -->
  <!-- end of refentry.module -->
  <xs:attributeGroup name="refmeta.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refmeta">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element ref="refentrytitle"/>
        <xs:element minOccurs="0" ref="manvolnum"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="refmiscinfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="refmeta.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refmeta.element -->
  <xs:attributeGroup name="refmeta.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refmeta.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refmeta.attlist -->
  <!-- end of refmeta.module -->
  <xs:attributeGroup name="refmiscinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refmiscinfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="refmiscinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refmiscinfo.element -->
  <!-- Class: Freely assignable parameter; no default -->
  <xs:attributeGroup name="refmiscinfo.attlist">
    <xs:attribute name="class"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refmiscinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refmiscinfo.attlist -->
  <!-- end of refmiscinfo.module -->
  <xs:attributeGroup name="refnamediv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refnamediv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refdescriptor"/>
        <xs:element maxOccurs="unbounded" ref="refname"/>
        <xs:element ref="refpurpose"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="refclass"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="remark"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refnamediv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refnamediv.element -->
  <xs:attributeGroup name="refnamediv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refnamediv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refnamediv.attlist -->
  <!-- end of refnamediv.module -->
  <xs:attributeGroup name="refdescriptor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refdescriptor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refname.char.mix"/>
      <xs:attributeGroup ref="refdescriptor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refdescriptor.element -->
  <xs:attributeGroup name="refdescriptor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refdescriptor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refdescriptor.attlist -->
  <!-- end of refdescriptor.module -->
  <xs:attributeGroup name="refname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refname.char.mix"/>
      <xs:attributeGroup ref="refname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refname.element -->
  <xs:attributeGroup name="refname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refname.attlist -->
  <!-- end of refname.module -->
  <xs:attributeGroup name="refpurpose.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refpurpose">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refinline.char.mix"/>
      <xs:attributeGroup ref="refpurpose.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refpurpose.element -->
  <xs:attributeGroup name="refpurpose.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refpurpose.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refpurpose.attlist -->
  <!-- end of refpurpose.module -->
  <xs:attributeGroup name="refclass.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refclass">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refclass.char.mix"/>
      <xs:attributeGroup ref="refclass.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refclass.element -->
  <xs:attributeGroup name="refclass.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refclass.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refclass.attlist -->
  <!-- end of refclass.module -->
  <xs:attributeGroup name="refsynopsisdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsynopsisdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsynopsisdivinfo"/>
        <xs:group minOccurs="0" ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect2"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect2"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsynopsisdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsynopsisdiv.element -->
  <xs:attributeGroup name="refsynopsisdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsynopsisdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsynopsisdiv.attlist -->
  <!-- end of refsynopsisdiv.module -->
  <xs:attributeGroup name="refsection.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsection">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsectioninfo"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsection"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsection"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsection.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsection.element -->
  <xs:attributeGroup name="refsection.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsection.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsection.attlist -->
  <!-- end of refsection.module -->
  <xs:attributeGroup name="refsect1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect1">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect1info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect2"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect2"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsect1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect1.element -->
  <xs:attributeGroup name="refsect1.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect1.attlist -->
  <!-- end of refsect1.module -->
  <xs:attributeGroup name="refsect2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect2">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect2info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect3"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect3"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsect2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect2.element -->
  <xs:attributeGroup name="refsect2.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect2.attlist -->
  <!-- end of refsect2.module -->
  <xs:attributeGroup name="refsect3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect3">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect3info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="refsect3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect3.element -->
  <xs:attributeGroup name="refsect3.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect3.attlist -->
  <!-- end of refsect3.module -->
  <!-- end of refentry.content.module -->
  <!-- ...................................................................... -->
  <!-- Article .............................................................. -->
  <!--
    An Article is a chapter-level, stand-alone document that is often,
    but need not be, collected into a Book.
  -->
  <xs:attributeGroup name="article.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="article" substitutionGroup="article.class"/>
  <!-- end of article.element -->
  <!--
    Class: Indicates the type of a particular article;
    all articles have the same structure and general purpose.
    No default.
  -->
  <!-- ParentBook: ID of the enclosing Book -->
  <xs:attributeGroup name="article.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="journalarticle"/>
          <xs:enumeration value="productsheet"/>
          <xs:enumeration value="whitepaper"/>
          <xs:enumeration value="techreport"/>
          <xs:enumeration value="specification"/>
          <xs:enumeration value="faq"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="parentbook" type="xs:IDREF"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="article.role.attrib"/>
  </xs:attributeGroup>
</xs:schema>
<!-- end of article.attlist -->
<!-- end of article.module -->
<!-- End of DocBook document hierarchy module V4.3CR3 ........................ -->
<!-- ...................................................................... -->
 PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPCEtLSAuLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uIC0tPgo8IS0tIERvY0Jvb2sgbm90YXRpb25zIG1vZHVsZSBWNC4zQ1IzIC4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4gLS0+CjwhLS0gRmlsZSBkYm5vdG54Lm1vZCAuLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLiAtLT4KPCEtLQogIENvcHlyaWdodCAxOTkyLTIwMDIgSGFMIENvbXB1dGVyIFN5c3RlbXMsIEluYy4sCiAgTydSZWlsbHkgJiBBc3NvY2lhdGVzLCBJbmMuLCBBcmJvclRleHQsIEluYy4sIEZ1aml0c3UgU29mdHdhcmUKICBDb3Jwb3JhdGlvbiwgTm9ybWFuIFdhbHNoLCBTdW4gTWljcm9zeXN0ZW1zLCBJbmMuLCBhbmQgdGhlCiAgT3JnYW5pemF0aW9uIGZvciB0aGUgQWR2YW5jZW1lbnQgb2YgU3RydWN0dXJlZCBJbmZvcm1hdGlvbgogIFN0YW5kYXJkcyAoT0FTSVMpLgogIAogICRJZDogZGJub3RueC5tb2QsdiAxLjIxIDIwMDQvMDEvMjEgMTg6NTQ6MjEgbndhbHNoIEV4cCAkCiAgCiAgUGVybWlzc2lvbiB0byB1c2UsIGNvcHksIG1vZGlmeSBhbmQgZGlzdHJpYnV0ZSB0aGUgRG9jQm9vayBEVEQKICBhbmQgaXRzIGFjY29tcGFueWluZyBkb2N1bWVudGF0aW9uIGZvciBhbnkgcHVycG9zZSBhbmQgd2l0aG91dCBmZWUKICBpcyBoZXJlYnkgZ3JhbnRlZCBpbiBwZXJwZXR1aXR5LCBwcm92aWRlZCB0aGF0IHRoZSBhYm92ZSBjb3B5cmlnaHQKICBub3RpY2UgYW5kIHRoaXMgcGFyYWdyYXBoIGFwcGVhciBpbiBhbGwgY29waWVzLiAgVGhlIGNvcHlyaWdodAogIGhvbGRlcnMgbWFrZSBubyByZXByZXNlbnRhdGlvbiBhYm91dCB0aGUgc3VpdGFiaWxpdHkgb2YgdGhlIERURCBmb3IKICBhbnkgcHVycG9zZS4gIEl0IGlzIHByb3ZpZGVkICJhcyBpcyIgd2l0aG91dCBleHByZXNzZWQgb3IgaW1wbGllZAogIHdhcnJhbnR5LgogIAogIElmIHlvdSBtb2RpZnkgdGhlIERvY0Jvb2sgRFREIGluIGFueSB3YXksIGV4Y2VwdCBmb3IgZGVjbGFyaW5nIGFuZAogIHJlZmVyZW5jaW5nIGFkZGl0aW9uYWwgc2V0cyBvZiBnZW5lcmFsIGVudGl0aWVzIGFuZCBkZWNsYXJpbmcKICBhZGRpdGlvbmFsIG5vdGF0aW9ucywgbGFiZWwgeW91ciBEVEQgYXMgYSB2YXJpYW50IG9mIERvY0Jvb2suICBTZWUKICB0aGUgbWFpbnRlbmFuY2UgZG9jdW1lbnRhdGlvbiBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KICAKICBQbGVhc2UgZGlyZWN0IGFsbCBxdWVzdGlvbnMsIGJ1ZyByZXBvcnRzLCBvciBzdWdnZXN0aW9ucyBmb3IKICBjaGFuZ2VzIHRvIHRoZSBkb2Nib29rQGxpc3RzLm9hc2lzLW9wZW4ub3JnIG1haWxpbmcgbGlzdC4gRm9yIG1vcmUKICBpbmZvcm1hdGlvbiwgc2VlIGh0dHA6Ly93d3cub2FzaXMtb3Blbi5vcmcvZG9jYm9vay8uCi0tPgo8IS0tIC4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4gLS0+CjwhLS0KICBUaGlzIG1vZHVsZSBjb250YWlucyB0aGUgZW50aXR5IGRlY2xhcmF0aW9ucyBmb3IgdGhlIHN0YW5kYXJkIElTTwogIGVudGl0eSBzZXRzIHVzZWQgYnkgRG9jQm9vay4KICAKICBJbiBEVEQgZHJpdmVyIGZpbGVzIHJlZmVycmluZyB0byB0aGlzIG1vZHVsZSwgcGxlYXNlIHVzZSBhbiBlbnRpdHkKICBkZWNsYXJhdGlvbiB0aGF0IHVzZXMgdGhlIHB1YmxpYyBpZGVudGlmaWVyIHNob3duIGJlbG93OgogIAogIDwhRU5USVRZICUgZGJub3RuIFBVQkxJQwogICItLy9PQVNJUy8vRU5USVRJRVMgRG9jQm9vayBOb3RhdGlvbnMgVjQuM0NSMy8vRU4iCiAgImRibm90bngubW9kIj4KICAlZGJub3RuOwogIAogIFNlZSB0aGUgZG9jdW1lbnRhdGlvbiBmb3IgZGV0YWlsZWQgaW5mb3JtYXRpb24gb24gdGhlIHBhcmFtZXRlcgogIGVudGl0eSBhbmQgbW9kdWxlIHNjaGVtZSB1c2VkIGluIERvY0Jvb2ssIGN1c3RvbWl6aW5nIERvY0Jvb2sgYW5kCiAgcGxhbm5pbmcgZm9yIGludGVyY2hhbmdlLCBhbmQgY2hhbmdlcyBtYWRlIHNpbmNlIHRoZSBsYXN0IHJlbGVhc2UKICBvZiBEb2NCb29rLgotLT4KPHhzOnNjaGVtYSB4bWxuczp4cz0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEiIGVsZW1lbnRGb3JtRGVmYXVsdD0icXVhbGlmaWVkIj4KICA8eHM6aW1wb3J0IG5hbWVzcGFjZT0iaHR0cDovL3d3dy53My5vcmcvWE1MLzE5OTgvbmFtZXNwYWNlIiBzY2hlbWFMb2NhdGlvbj0ieG1sLnhzZCIvPgogIDx4czpzaW1wbGVUeXBlIG5hbWU9Im5vdGF0aW9uLmNsYXNzIj4KICAgIDx4czpyZXN0cmljdGlvbiBiYXNlPSJ4czp0b2tlbiI+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iQk1QIi8+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iQ0dNLUNIQVIiLz4KICAgICAgPHhzOmVudW1lcmF0aW9uIHZhbHVlPSJDR00tQklOQVJZIi8+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iQ0dNLUNMRUFSIi8+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iRElUUk9GRiIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IkRWSSIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IkVQUyIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IkVRTiIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IkZBWCIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IkdJRiIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IkdJRjg3YSIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IkdJRjg5YSIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IkpQRyIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IkpQRUciLz4KICAgICAgPHhzOmVudW1lcmF0aW9uIHZhbHVlPSJJR0VTIi8+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iUENYIi8+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iUElDIi8+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iUE5HIi8+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iUFMiLz4KICAgICAgPHhzOmVudW1lcmF0aW9uIHZhbHVlPSJTR01MIi8+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iVEJMIi8+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iVEVYIi8+CiAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0iVElGRiIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IldNRiIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IldQRyIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IlNWRyIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IlBERiIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9IlNXRiIvPgogICAgICA8eHM6ZW51bWVyYXRpb24gdmFsdWU9ImxpbmVzcGVjaWZpYyIvPgogICAgPC94czpyZXN0cmljdGlvbj4KICA8L3hzOnNpbXBsZVR5cGU+CjwveHM6c2NoZW1hPgo8IS0tIFdvcmRQZXJmZWN0IEdyYXBoaWMgZm9ybWF0IC0tPgo8IS0tIEVuZCBvZiBEb2NCb29rIG5vdGF0aW9ucyBtb2R1bGUgVjQuM0NSMyAuLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4gLS0+CjwhLS0gLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLiAtLT4K <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook XML information pool module V4.3CR3 ............................. -->
<!-- File dbpoolx.mod ..................................................... -->
<!--
  Copyright 1992-2002 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: dbpoolx.mod,v 1.85 2004/01/21 18:54:21 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook XML DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook XML DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the objects, inline
  elements, and so on that are available to be used as the main
  content of DocBook documents.  Some elements are useful for general
  publishing, and others are useful specifically for computer
  documentation.
  
  This module has the following dependencies on other modules:
  
  o It assumes that a %notation.class; entity is defined by the
    driver file or other high-level module.  This entity is
    referenced in the NOTATION attributes for the graphic-related and
    ModeSpec elements.
  
  o It assumes that an appropriately parameterized table module is
    available for use with the table-related elements.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % dbpool PUBLIC
  "-//OASIS//ELEMENTS DocBook XML Information Pool V4.3CR3//EN"
  "dbpoolx.mod">
  %dbpool;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ...................................................................... -->
<!-- General-purpose semantics entities ................................... -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:include schemaLocation="htmltblx.xsd"/>
  <xs:include schemaLocation="calstblx.xsd"/>
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <xs:simpleType name="yesorno.attvals">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <!-- ...................................................................... -->
  <!-- Entities for module inclusions ....................................... -->
  <!-- ...................................................................... -->
  <!-- Entities for element classes and mixtures ............................ -->
  <!-- "Ubiquitous" classes: ndxterm.class and beginpage -->
  <xs:element name="ndxterm.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="primary"/>
        <xs:choice minOccurs="0">
          <xs:sequence>
            <xs:element ref="secondary"/>
            <xs:choice minOccurs="0">
              <xs:sequence>
                <xs:element ref="tertiary"/>
                <xs:choice minOccurs="0">
                  <xs:element ref="see"/>
                  <xs:element maxOccurs="unbounded" ref="seealso"/>
                </xs:choice>
              </xs:sequence>
              <xs:element ref="see"/>
              <xs:element maxOccurs="unbounded" ref="seealso"/>
            </xs:choice>
          </xs:sequence>
          <xs:element ref="see"/>
          <xs:element maxOccurs="unbounded" ref="seealso"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="indexterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- Object-level classes ................................................. -->
  <xs:element name="list.class" abstract="true"/>
  <xs:element name="admon.class" abstract="true"/>
  <xs:element name="linespecific.class" abstract="true"/>
  <xs:element name="method.synop.class" abstract="true" substitutionGroup="synop.class"/>
  <xs:element name="synop.class" abstract="true"/>
  <xs:element name="para.class" abstract="true"/>
  <xs:element name="informal.class" abstract="true"/>
  <xs:element name="formal.class" abstract="true"/>
  <!-- The DocBook TC may produce an official EBNF module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:element name="compound.class" abstract="true"/>
  <xs:group name="genobj.class">
    <xs:choice>
      <xs:element ref="anchor"/>
      <xs:element ref="bridgehead"/>
      <xs:element ref="remark"/>
      <xs:element ref="highlights"/>
    </xs:choice>
  </xs:group>
  <xs:group name="descobj.class">
    <xs:choice>
      <xs:element ref="abstract"/>
      <xs:element ref="authorblurb"/>
      <xs:element ref="epigraph"/>
    </xs:choice>
  </xs:group>
  <!-- Character-level classes .............................................. -->
  <xs:element name="xref.char.class" abstract="true"/>
  <xs:element name="gen.char.class" abstract="true"/>
  <xs:element name="link.char.class" abstract="true"/>
  <!-- The DocBook TC may produce an official EBNF module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:element name="tech.char.class" abstract="true"/>
  <xs:group name="base.char.class">
    <xs:sequence>
      <xs:element ref="anchor"/>
    </xs:sequence>
  </xs:group>
  <xs:element name="docinfo.char.class" abstract="true"/>
  <xs:group name="other.char.class">
    <xs:choice>
      <xs:element ref="remark"/>
      <xs:element ref="subscript"/>
      <xs:element ref="superscript"/>
    </xs:choice>
  </xs:group>
  <xs:element name="inlineobj.char.class" abstract="true"/>
  <!-- ...................................................................... -->
  <!-- Entities for content models .......................................... -->
  <xs:group name="formalobject.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <!-- Redeclaration placeholder ............................................ -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- Object-level mixtures ................................................ -->
  <!--
                          list admn line synp para infm form cmpd gen  desc
    Component mixture       X    X    X    X    X    X    X    X    X    X
    Sidebar mixture         X    X    X    X    X    X    X    a    X
    Footnote mixture        X         X    X    X    X
    Example mixture         X         X    X    X    X
    Highlights mixture      X    X              X
    Paragraph mixture       X         X    X         X
    Admonition mixture      X         X    X    X    X    X    b    c
    Figure mixture                    X    X         X
    Table entry mixture     X    X    X         X    d
    Glossary def mixture    X         X    X    X    X         e
    Legal notice mixture    X    X    X         X    f
    
    a. Just Procedure; not Sidebar itself or MsgSet.
    b. No MsgSet.
    c. No Highlights.
    d. Just Graphic; no other informal objects.
    e. No Anchor, BridgeHead, or Highlights.
    f. Just BlockQuote; no other informal objects.
  -->
  <xs:group name="component.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="sidebar.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="qandaset.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="revdescription.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="footnote.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="example.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="highlights.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <!--
    %formal.class; is explicitly excluded from many contexts in which
    paragraphs are used
  -->
  <xs:group name="para.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="admon.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:element ref="sidebar"/>
      <xs:element ref="anchor"/>
      <xs:element ref="bridgehead"/>
      <xs:element ref="remark"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="figure.mix">
    <xs:choice>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="tabentry.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="graphic"/>
      <xs:element ref="mediaobject"/>
    </xs:choice>
  </xs:group>
  <xs:group name="glossdef.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="remark"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="legalnotice.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="blockquote"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="textobject.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="blockquote"/>
    </xs:choice>
  </xs:group>
  <xs:element name="mediaobject.mix" abstract="true"/>
  <xs:group name="listpreamble.mix">
    <xs:choice>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <!-- Character-level mixtures ............................................. -->
  <!-- sgml.features -->
  <!-- not [sgml.features[ -->
  <!-- ]] not sgml.features -->
  <!--
                        #PCD xref word link cptr base dnfo othr inob (synop)
    para.char.mix         X    X    X    X    X    X    X    X    X
    title.char.mix        X    X    X    X    X    X    X    X    X
    ndxterm.char.mix      X    X    X    X    X    X    X    X    a
    cptr.char.mix         X              X    X    X         X    a
    smallcptr.char.mix    X                   b                   a
    word.char.mix         X         c    X         X         X    a
    docinfo.char.mix      X         d    X    b              X    a
    
    a. Just InlineGraphic; no InlineEquation.
    b. Just Replaceable; no other computer terms.
    c. Just Emphasis and Trademark; no other word elements.
    d. Just Acronym, Emphasis, and Trademark; no other word elements.
  -->
  <!-- The DocBook TC may produce an official forms module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:group name="para.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlineobj.char.class"/>
        <xs:element ref="synop.class"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="title.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlineobj.char.class"/>
        <xs:element ref="ndxterm.class"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="ndxterm.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="cptr.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="smallcptr.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="replaceable"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="word.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="acronym"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="trademark"/>
        <xs:element ref="link.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="docinfo.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="trademark"/>
        <xs:element ref="replaceable"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <!-- ENTITY % bibliocomponent.mix (see Bibliographic section, below) -->
  <!-- ENTITY % person.ident.mix (see Bibliographic section, below) -->
  <!-- ...................................................................... -->
  <!-- Entities for attributes and attribute components ..................... -->
  <!-- Effectivity attributes ............................................... -->
  <!--
    Arch: Computer or chip architecture to which element applies; no
    default
  -->
  <xs:attributeGroup name="arch.attrib">
    <xs:attribute name="arch"/>
  </xs:attributeGroup>
  <!-- Condition: General-purpose effectivity attribute -->
  <xs:attributeGroup name="condition.attrib">
    <xs:attribute name="condition"/>
  </xs:attributeGroup>
  <!-- Conformance: Standards conformance characteristics -->
  <xs:attributeGroup name="conformance.attrib">
    <xs:attribute name="conformance" type="xs:NMTOKENS"/>
  </xs:attributeGroup>
  <!-- OS: Operating system to which element applies; no default -->
  <xs:attributeGroup name="os.attrib">
    <xs:attribute name="os"/>
  </xs:attributeGroup>
  <!-- Revision: Editorial revision to which element belongs; no default -->
  <xs:attributeGroup name="revision.attrib">
    <xs:attribute name="revision"/>
  </xs:attributeGroup>
  <!-- Security: Security classification; no default -->
  <xs:attributeGroup name="security.attrib">
    <xs:attribute name="security"/>
  </xs:attributeGroup>
  <!--
    UserLevel: Level of user experience to which element applies; no
    default
  -->
  <xs:attributeGroup name="userlevel.attrib">
    <xs:attribute name="userlevel"/>
  </xs:attributeGroup>
  <!-- Vendor: Computer vendor to which element applies; no default -->
  <xs:attributeGroup name="vendor.attrib">
    <xs:attribute name="vendor"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="effectivity.attrib">
    <xs:attributeGroup ref="arch.attrib"/>
    <xs:attributeGroup ref="condition.attrib"/>
    <xs:attributeGroup ref="conformance.attrib"/>
    <xs:attributeGroup ref="os.attrib"/>
    <xs:attributeGroup ref="revision.attrib"/>
    <xs:attributeGroup ref="security.attrib"/>
    <xs:attributeGroup ref="userlevel.attrib"/>
    <xs:attributeGroup ref="vendor.attrib"/>
  </xs:attributeGroup>
  <!-- Common attributes .................................................... -->
  <!-- Id: Unique identifier of element; no default -->
  <xs:attributeGroup name="id.attrib">
    <xs:attribute name="id" type="xs:ID"/>
  </xs:attributeGroup>
  <!--
    Id: Unique identifier of element; a value must be supplied; no
    default
  -->
  <xs:attributeGroup name="idreq.attrib">
    <xs:attribute name="id" use="required" type="xs:ID"/>
  </xs:attributeGroup>
  <!--
    Lang: Indicator of language in which element is written, for
    translation, character set management, etc.; no default
  -->
  <xs:attributeGroup name="lang.attrib">
    <xs:attribute name="lang"/>
  </xs:attributeGroup>
  <!-- Remap: Previous role of element before conversion; no default -->
  <xs:attributeGroup name="remap.attrib">
    <xs:attribute name="remap"/>
  </xs:attributeGroup>
  <!-- Role: New role of element in local environment; no default -->
  <xs:attributeGroup name="role.attrib">
    <xs:attribute name="role"/>
  </xs:attributeGroup>
  <!--
    XRefLabel: Alternate labeling string for XRef text generation;
    default is usually title or other appropriate label text already
    contained in element
  -->
  <xs:attributeGroup name="xreflabel.attrib">
    <xs:attribute name="xreflabel"/>
  </xs:attributeGroup>
  <!--
    RevisionFlag: Revision status of element; default is that element
    wasn't revised
  -->
  <xs:attributeGroup name="revisionflag.attrib">
    <xs:attribute name="revisionflag">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="changed"/>
          <xs:enumeration value="added"/>
          <xs:enumeration value="deleted"/>
          <xs:enumeration value="off"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- dir: Bidirectional override -->
  <xs:attributeGroup name="dir.attrib">
    <xs:attribute name="dir">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="ltr"/>
          <xs:enumeration value="rtl"/>
          <xs:enumeration value="lro"/>
          <xs:enumeration value="rlo"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- xml:base: base URI -->
  <xs:attributeGroup name="xml-base.attrib">
    <xs:attribute ref="xml:base"/>
  </xs:attributeGroup>
  <!-- Role is included explicitly on each element -->
  <xs:attributeGroup name="common.attrib">
    <xs:attributeGroup ref="id.attrib"/>
    <xs:attributeGroup ref="lang.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="dir.attrib"/>
    <xs:attributeGroup ref="xml-base.attrib"/>
  </xs:attributeGroup>
  <!-- Role is included explicitly on each element -->
  <xs:attributeGroup name="idreq.common.attrib">
    <xs:attributeGroup ref="idreq.attrib"/>
    <xs:attributeGroup ref="lang.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="dir.attrib"/>
    <xs:attributeGroup ref="xml-base.attrib"/>
  </xs:attributeGroup>
  <!-- Semi-common attributes and other attribute entities .................. -->
  <!--
    EntityRef: Name of an external entity containing the content
    of the graphic
  -->
  <!--
    FileRef: Filename, qualified by a pathname if desired,
    designating the file containing the content of the graphic
  -->
  <!-- Format: Notation of the element content, if any -->
  <!-- SrcCredit: Information about the source of the Graphic -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="graphics.attrib">
    <xs:attribute name="entityref" type="xs:ENTITY"/>
    <xs:attribute name="fileref"/>
    <xs:attribute name="format" type="notation.class"/>
    <xs:attribute name="srccredit"/>
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
  </xs:attributeGroup>
  <!--
    Action: Key combination type; default is unspecified if one
    child element, Simul if there is more than one; if value is
    Other, the OtherAction attribute must have a nonempty value
  -->
  <!-- OtherAction: User-defined key combination type -->
  <xs:attributeGroup name="keyaction.attrib">
    <xs:attribute name="action">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="click"/>
          <xs:enumeration value="double-click"/>
          <xs:enumeration value="press"/>
          <xs:enumeration value="seq"/>
          <xs:enumeration value="simul"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otheraction"/>
  </xs:attributeGroup>
  <!--
    Label: Identifying number or string; default is usually the
    appropriate number or string autogenerated by a formatter
  -->
  <xs:attributeGroup name="label.attrib">
    <xs:attribute name="label"/>
  </xs:attributeGroup>
  <!--
    Format: whether element is assumed to contain significant white
    space
  -->
  <xs:attributeGroup name="linespecific.attrib">
    <xs:attribute name="format" default="linespecific">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="linespecific"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="linenumbering">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="numbered"/>
          <xs:enumeration value="unnumbered"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="continuation">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="continues"/>
          <xs:enumeration value="restarts"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="startinglinenumber"/>
    <xs:attribute name="language"/>
  </xs:attributeGroup>
  <!-- Linkend: link to related information; no default -->
  <xs:attributeGroup name="linkend.attrib">
    <xs:attribute name="linkend" type="xs:IDREF"/>
  </xs:attributeGroup>
  <!-- Linkend: required link to related information -->
  <xs:attributeGroup name="linkendreq.attrib">
    <xs:attribute name="linkend" use="required" type="xs:IDREF"/>
  </xs:attributeGroup>
  <!--
    Linkends: link to one or more sets of related information; no
    default
  -->
  <xs:attributeGroup name="linkends.attrib">
    <xs:attribute name="linkends" type="xs:IDREFS"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="mark.attrib">
    <xs:attribute name="mark"/>
  </xs:attributeGroup>
  <!-- MoreInfo: whether element's content has an associated RefEntry -->
  <xs:attributeGroup name="moreinfo.attrib">
    <xs:attribute name="moreinfo" default="none">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="refentry"/>
          <xs:enumeration value="none"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- Pagenum: number of page on which element appears; no default -->
  <xs:attributeGroup name="pagenum.attrib">
    <xs:attribute name="pagenum"/>
  </xs:attributeGroup>
  <!--
    Status: Editorial or publication status of the element
    it applies to, such as "in review" or "approved for distribution"
  -->
  <xs:attributeGroup name="status.attrib">
    <xs:attribute name="status"/>
  </xs:attributeGroup>
  <!--
    Width: width of the longest line in the element to which it
    pertains, in number of characters
  -->
  <xs:attributeGroup name="width.attrib">
    <xs:attribute name="width"/>
  </xs:attributeGroup>
  <!-- ...................................................................... -->
  <!-- Title elements ....................................................... -->
  <xs:attributeGroup name="title.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="title">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="title.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of title.element -->
  <xs:attributeGroup name="title.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="title.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of title.attlist -->
  <!-- end of title.module -->
  <xs:attributeGroup name="titleabbrev.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="titleabbrev">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="titleabbrev.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of titleabbrev.element -->
  <xs:attributeGroup name="titleabbrev.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="titleabbrev.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of titleabbrev.attlist -->
  <!-- end of titleabbrev.module -->
  <xs:attributeGroup name="subtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="subtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subtitle.element -->
  <xs:attributeGroup name="subtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subtitle.attlist -->
  <!-- end of subtitle.module -->
  <!-- ...................................................................... -->
  <!-- Bibliographic entities and elements .................................. -->
  <!--
    The bibliographic elements are typically used in the document
    hierarchy. They do not appear in content models of information
    pool elements.  See also the document information elements,
    below.
  -->
  <xs:group name="person.ident.mix">
    <xs:choice>
      <xs:element ref="honorific"/>
      <xs:element ref="firstname"/>
      <xs:element ref="surname"/>
      <xs:element ref="lineage"/>
      <xs:element ref="othername"/>
      <xs:element ref="affiliation"/>
      <xs:element ref="authorblurb"/>
      <xs:element ref="contrib"/>
    </xs:choice>
  </xs:group>
  <xs:group name="bibliocomponent.mix">
    <xs:choice>
      <xs:element ref="abbrev"/>
      <xs:element ref="abstract"/>
      <xs:element ref="address"/>
      <xs:element ref="artpagenums"/>
      <xs:element ref="author"/>
      <xs:element ref="authorgroup"/>
      <xs:element ref="authorinitials"/>
      <xs:element ref="bibliomisc"/>
      <xs:element ref="biblioset"/>
      <xs:element ref="collab"/>
      <xs:element ref="confgroup"/>
      <xs:element ref="contractnum"/>
      <xs:element ref="contractsponsor"/>
      <xs:element ref="copyright"/>
      <xs:element ref="corpauthor"/>
      <xs:element ref="corpname"/>
      <xs:element ref="corpcredit"/>
      <xs:element ref="date"/>
      <xs:element ref="edition"/>
      <xs:element ref="editor"/>
      <xs:element ref="invpartnumber"/>
      <xs:element ref="isbn"/>
      <xs:element ref="issn"/>
      <xs:element ref="issuenum"/>
      <xs:element ref="orgname"/>
      <xs:element ref="biblioid"/>
      <xs:element ref="citebiblioid"/>
      <xs:element ref="bibliosource"/>
      <xs:element ref="bibliorelation"/>
      <xs:element ref="bibliocoverage"/>
      <xs:element ref="othercredit"/>
      <xs:element ref="pagenums"/>
      <xs:element ref="printhistory"/>
      <xs:element ref="productname"/>
      <xs:element ref="productnumber"/>
      <xs:element ref="pubdate"/>
      <xs:element ref="publisher"/>
      <xs:element ref="publishername"/>
      <xs:element ref="pubsnumber"/>
      <xs:element ref="releaseinfo"/>
      <xs:element ref="revhistory"/>
      <xs:element ref="seriesvolnums"/>
      <xs:element ref="subtitle"/>
      <xs:element ref="title"/>
      <xs:element ref="titleabbrev"/>
      <xs:element ref="volumenum"/>
      <xs:element ref="citetitle"/>
      <xs:element ref="personname"/>
      <xs:group ref="person.ident.mix"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <!-- I don't think this is well placed, but it needs to be here because of -->
  <!-- the reference to bibliocomponent.mix -->
  <xs:group name="info.class">
    <xs:choice>
      <xs:element ref="graphic"/>
      <xs:element ref="mediaobject"/>
      <xs:element ref="legalnotice"/>
      <xs:element ref="modespec"/>
      <xs:element ref="subjectset"/>
      <xs:element ref="keywordset"/>
      <xs:element ref="itermset"/>
      <xs:group ref="bibliocomponent.mix"/>
    </xs:choice>
  </xs:group>
  <xs:attributeGroup name="biblioentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="biblioentry">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="articleinfo"/>
        <xs:group ref="bibliocomponent.mix"/>
      </xs:choice>
      <xs:attributeGroup ref="biblioentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioentry.element -->
  <xs:attributeGroup name="biblioentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioentry.attlist -->
  <!-- end of biblioentry.module -->
  <xs:attributeGroup name="bibliomixed.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliomixed">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="bibliocomponent.mix"/>
        <xs:element ref="bibliomset"/>
      </xs:choice>
      <xs:attributeGroup ref="bibliomixed.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomixed.element -->
  <xs:attributeGroup name="bibliomixed.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomixed.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomixed.attlist -->
  <!-- end of bibliomixed.module -->
  <xs:attributeGroup name="articleinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="articleinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="articleinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of articleinfo.element -->
  <xs:attributeGroup name="articleinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="articleinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of articleinfo.attlist -->
  <!-- end of articleinfo.module -->
  <xs:attributeGroup name="biblioset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="biblioset">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="bibliocomponent.mix"/>
      <xs:attributeGroup ref="biblioset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioset.element -->
  <!-- Relation: Relationship of elements contained within BiblioSet -->
  <xs:attributeGroup name="biblioset.attlist">
    <xs:attribute name="relation"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioset.attlist -->
  <!-- end of biblioset.module -->
  <xs:attributeGroup name="bibliomset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliomset">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="bibliocomponent.mix"/>
        <xs:element ref="bibliomset"/>
      </xs:choice>
      <xs:attributeGroup ref="bibliomset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomset.element -->
  <!-- Relation: Relationship of elements contained within BiblioMSet -->
  <xs:attributeGroup name="bibliomset.attlist">
    <xs:attribute name="relation"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomset.attlist -->
  <!-- end of bibliomset.module -->
  <xs:attributeGroup name="bibliomisc.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliomisc">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="bibliomisc.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomisc.element -->
  <xs:attributeGroup name="bibliomisc.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomisc.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomisc.attlist -->
  <!-- end of bibliomisc.module -->
  <!-- ...................................................................... -->
  <!-- Subject, Keyword, and ITermSet elements .............................. -->
  <xs:attributeGroup name="subjectset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subjectset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="subject"/>
      </xs:sequence>
      <xs:attributeGroup ref="subjectset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subjectset.element -->
  <!-- Scheme: Controlled vocabulary employed in SubjectTerms -->
  <xs:attributeGroup name="subjectset.attlist">
    <xs:attribute name="scheme" type="xs:NMTOKEN"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subjectset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subjectset.attlist -->
  <!-- end of subjectset.module -->
  <xs:attributeGroup name="subject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subject">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="subjectterm"/>
      </xs:sequence>
      <xs:attributeGroup ref="subject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subject.element -->
  <!--
    Weight: Ranking of this group of SubjectTerms relative
    to others, 0 is low, no highest value specified
  -->
  <xs:attributeGroup name="subject.attlist">
    <xs:attribute name="weight"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subject.attlist -->
  <!-- end of subject.module -->
  <xs:attributeGroup name="subjectterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subjectterm">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="subjectterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subjectterm.element -->
  <xs:attributeGroup name="subjectterm.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subjectterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subjectterm.attlist -->
  <!-- end of subjectterm.module -->
  <!-- end of subjectset.content.module -->
  <xs:attributeGroup name="keywordset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keywordset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="keyword"/>
      </xs:sequence>
      <xs:attributeGroup ref="keywordset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keywordset.element -->
  <xs:attributeGroup name="keywordset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keywordset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keywordset.attlist -->
  <!-- end of keywordset.module -->
  <xs:attributeGroup name="keyword.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keyword">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="keyword.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keyword.element -->
  <xs:attributeGroup name="keyword.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keyword.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keyword.attlist -->
  <!-- end of keyword.module -->
  <!-- end of keywordset.content.module -->
  <xs:attributeGroup name="itermset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="itermset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="indexterm"/>
      </xs:sequence>
      <xs:attributeGroup ref="itermset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of itermset.element -->
  <xs:attributeGroup name="itermset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="itermset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of itermset.attlist -->
  <!-- end of itermset.module -->
  <!-- Bibliographic info for "blocks" -->
  <xs:attributeGroup name="blockinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="blockinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="blockinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of blockinfo.element -->
  <xs:attributeGroup name="blockinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="blockinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of blockinfo.attlist -->
  <!-- end of blockinfo.module -->
  <!-- ...................................................................... -->
  <!-- Compound (section-ish) elements ...................................... -->
  <!-- Message set ...................... -->
  <xs:attributeGroup name="msgset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgset" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="msgentry"/>
          <xs:element maxOccurs="unbounded" ref="simplemsgentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="msgset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgset.element -->
  <xs:attributeGroup name="msgset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgset.attlist -->
  <!-- end of msgset.module -->
  <xs:attributeGroup name="msgentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="msg"/>
        <xs:element minOccurs="0" ref="msginfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="msgexplan"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgentry.element -->
  <xs:attributeGroup name="msgentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgentry.attlist -->
  <!-- end of msgentry.module -->
  <xs:attributeGroup name="simplemsgentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simplemsgentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="msgtext"/>
        <xs:element maxOccurs="unbounded" ref="msgexplan"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplemsgentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplemsgentry.element -->
  <xs:attributeGroup name="simplemsgentry.attlist">
    <xs:attribute name="audience"/>
    <xs:attribute name="level"/>
    <xs:attribute name="origin"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplemsgentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplemsgentry.attlist -->
  <!-- end of simplemsgentry.module -->
  <xs:attributeGroup name="msg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msg">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgmain"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="msgsub"/>
          <xs:element ref="msgrel"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="msg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msg.element -->
  <xs:attributeGroup name="msg.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msg.attlist -->
  <!-- end of msg.module -->
  <xs:attributeGroup name="msgmain.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgmain">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgmain.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgmain.element -->
  <xs:attributeGroup name="msgmain.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgmain.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgmain.attlist -->
  <!-- end of msgmain.module -->
  <xs:attributeGroup name="msgsub.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgsub">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgsub.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgsub.element -->
  <xs:attributeGroup name="msgsub.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgsub.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgsub.attlist -->
  <!-- end of msgsub.module -->
  <xs:attributeGroup name="msgrel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgrel">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgrel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgrel.element -->
  <xs:attributeGroup name="msgrel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgrel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgrel.attlist -->
  <!-- end of msgrel.module -->
  <!-- MsgText (defined in the Inlines section, below) -->
  <xs:attributeGroup name="msginfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msginfo">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="msglevel"/>
        <xs:element ref="msgorig"/>
        <xs:element ref="msgaud"/>
      </xs:choice>
      <xs:attributeGroup ref="msginfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msginfo.element -->
  <xs:attributeGroup name="msginfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msginfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msginfo.attlist -->
  <!-- end of msginfo.module -->
  <xs:attributeGroup name="msglevel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msglevel">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="msglevel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msglevel.element -->
  <xs:attributeGroup name="msglevel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msglevel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msglevel.attlist -->
  <!-- end of msglevel.module -->
  <xs:attributeGroup name="msgorig.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgorig">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="msgorig.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgorig.element -->
  <xs:attributeGroup name="msgorig.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgorig.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgorig.attlist -->
  <!-- end of msgorig.module -->
  <xs:attributeGroup name="msgaud.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgaud">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="msgaud.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgaud.element -->
  <xs:attributeGroup name="msgaud.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgaud.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgaud.attlist -->
  <!-- end of msgaud.module -->
  <xs:attributeGroup name="msgexplan.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgexplan">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgexplan.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgexplan.element -->
  <xs:attributeGroup name="msgexplan.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgexplan.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgexplan.attlist -->
  <!-- end of msgexplan.module -->
  <!-- end of msgset.content.module -->
  <xs:attributeGroup name="task.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="task" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:element minOccurs="0" ref="tasksummary"/>
        <xs:element minOccurs="0" ref="taskprerequisites"/>
        <xs:element ref="procedure"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="example"/>
        <xs:element minOccurs="0" ref="taskrelated"/>
      </xs:sequence>
      <xs:attributeGroup ref="task.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of task.element -->
  <xs:attributeGroup name="task.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="task.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of task.attlist -->
  <!-- end of task.module -->
  <xs:attributeGroup name="tasksummary.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tasksummary">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="tasksummary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tasksummary.element -->
  <xs:attributeGroup name="tasksummary.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tasksummary.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tasksummary.attlist -->
  <!-- end of tasksummary.module -->
  <xs:attributeGroup name="taskprerequisites.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="taskprerequisites">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="taskprerequisites.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of taskprerequisites.element -->
  <xs:attributeGroup name="taskprerequisites.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="taskprerequisites.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of taskprerequisites.attlist -->
  <!-- end of taskprerequisites.module -->
  <xs:attributeGroup name="taskrelated.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="taskrelated">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="taskrelated.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of taskrelated.element -->
  <xs:attributeGroup name="taskrelated.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="taskrelated.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of taskrelated.attlist -->
  <!-- end of taskrelated.module -->
  <!-- end of task.content.module -->
  <!-- QandASet ........................ -->
  <xs:attributeGroup name="qandaset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="qandaset" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="qandadiv"/>
          <xs:element maxOccurs="unbounded" ref="qandaentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="qandaset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandaset.element -->
  <xs:attributeGroup name="qandaset.attlist">
    <xs:attribute name="defaultlabel">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="qanda"/>
          <xs:enumeration value="number"/>
          <xs:enumeration value="none"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandaset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandaset.attlist -->
  <!-- end of qandaset.module -->
  <xs:attributeGroup name="qandadiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="qandadiv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="qandadiv"/>
          <xs:element maxOccurs="unbounded" ref="qandaentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="qandadiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandadiv.element -->
  <xs:attributeGroup name="qandadiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandadiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandadiv.attlist -->
  <!-- end of qandadiv.module -->
  <xs:attributeGroup name="qandaentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="qandaentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="revhistory"/>
        <xs:element ref="question"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="answer"/>
      </xs:sequence>
      <xs:attributeGroup ref="qandaentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandaentry.element -->
  <xs:attributeGroup name="qandaentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandaentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandaentry.attlist -->
  <!-- end of qandaentry.module -->
  <xs:attributeGroup name="question.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="question">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="label"/>
        <xs:group maxOccurs="unbounded" ref="qandaset.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="question.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of question.element -->
  <xs:attributeGroup name="question.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="question.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of question.attlist -->
  <!-- end of question.module -->
  <xs:attributeGroup name="answer.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="answer">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="label"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="qandaentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="answer.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of answer.element -->
  <xs:attributeGroup name="answer.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="answer.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of answer.attlist -->
  <!-- end of answer.module -->
  <xs:attributeGroup name="label.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="label">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="label.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of label.element -->
  <xs:attributeGroup name="label.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="label.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of label.attlist -->
  <!-- end of label.module -->
  <!-- end of qandaset.content.module -->
  <!-- Procedure ........................ -->
  <xs:attributeGroup name="procedure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="procedure" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="procedure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of procedure.element -->
  <xs:attributeGroup name="procedure.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="procedure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of procedure.attlist -->
  <!-- end of procedure.module -->
  <xs:attributeGroup name="step.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="step">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="component.mix"/>
            <xs:sequence minOccurs="0">
              <xs:choice>
                <xs:element ref="substeps"/>
                <xs:element ref="stepalternatives"/>
              </xs:choice>
              <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
            </xs:sequence>
          </xs:sequence>
          <xs:sequence>
            <xs:choice>
              <xs:element ref="substeps"/>
              <xs:element ref="stepalternatives"/>
            </xs:choice>
            <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
          </xs:sequence>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="step.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of step.element -->
  <!-- Performance: Whether the Step must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="step.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="step.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of step.attlist -->
  <!-- end of step.module -->
  <xs:attributeGroup name="substeps.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="substeps">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="substeps.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of substeps.element -->
  <!-- Performance: whether entire set of substeps must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="substeps.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="substeps.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of substeps.attlist -->
  <!-- end of substeps.module -->
  <xs:attributeGroup name="stepalternatives.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="stepalternatives">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="stepalternatives.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of stepalternatives.element -->
  <!-- Performance: Whether (one of) the alternatives must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="stepalternatives.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="stepalternatives.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of stepalternatives.attlist -->
  <!-- end of stepalternatives.module -->
  <!-- end of procedure.content.module -->
  <!-- Sidebar .......................... -->
  <xs:attributeGroup name="sidebarinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sidebarinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sidebarinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sidebarinfo.element -->
  <xs:attributeGroup name="sidebarinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sidebarinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sidebarinfo.attlist -->
  <!-- end of sidebarinfo.module -->
  <xs:attributeGroup name="sidebar.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sidebar" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sidebarinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="sidebar.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="sidebar.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sidebar.element -->
  <xs:attributeGroup name="sidebar.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sidebar.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sidebar.attlist -->
  <!-- end of sidebar.module -->
  <!-- end of sidebar.content.model -->
  <!-- ...................................................................... -->
  <!-- Paragraph-related elements ........................................... -->
  <xs:attributeGroup name="abstract.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="abstract">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="abstract.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of abstract.element -->
  <xs:attributeGroup name="abstract.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="abstract.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of abstract.attlist -->
  <!-- end of abstract.module -->
  <xs:attributeGroup name="authorblurb.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="authorblurb">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="authorblurb.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorblurb.element -->
  <xs:attributeGroup name="authorblurb.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorblurb.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorblurb.attlist -->
  <!-- end of authorblurb.module -->
  <xs:attributeGroup name="personblurb.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="personblurb">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="personblurb.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of personblurb.element -->
  <xs:attributeGroup name="personblurb.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="personblurb.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of personblurb.attlist -->
  <!-- end of personblurb.module -->
  <xs:attributeGroup name="blockquote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="blockquote" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element minOccurs="0" ref="attribution"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="blockquote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of blockquote.element -->
  <xs:attributeGroup name="blockquote.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="blockquote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of blockquote.attlist -->
  <!-- end of blockquote.module -->
  <xs:attributeGroup name="attribution.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="attribution">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="attribution.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of attribution.element -->
  <xs:attributeGroup name="attribution.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="attribution.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of attribution.attlist -->
  <!-- end of attribution.module -->
  <xs:attributeGroup name="bridgehead.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bridgehead">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="bridgehead.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bridgehead.element -->
  <!--
    Renderas: Indicates the format in which the BridgeHead
    should appear
  -->
  <xs:attributeGroup name="bridgehead.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="other"/>
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bridgehead.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bridgehead.attlist -->
  <!-- end of bridgehead.module -->
  <xs:attributeGroup name="remark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="remark">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="remark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of remark.element -->
  <xs:attributeGroup name="remark.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="remark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of remark.attlist -->
  <!-- end of remark.module -->
  <xs:attributeGroup name="epigraph.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="epigraph">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="attribution"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="para.class"/>
          <xs:element ref="literallayout"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="epigraph.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of epigraph.element -->
  <xs:attributeGroup name="epigraph.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="epigraph.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of epigraph.attlist -->
  <!-- Attribution (defined above) -->
  <!-- end of epigraph.module -->
  <xs:attributeGroup name="footnote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="footnote" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="footnote.mix"/>
      <xs:attributeGroup ref="footnote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of footnote.element -->
  <xs:attributeGroup name="footnote.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="footnote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of footnote.attlist -->
  <!-- end of footnote.module -->
  <xs:attributeGroup name="highlights.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="highlights">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="highlights.mix"/>
      <xs:attributeGroup ref="highlights.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of highlights.element -->
  <xs:attributeGroup name="highlights.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="highlights.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of highlights.attlist -->
  <!-- end of highlights.module -->
  <xs:attributeGroup name="formalpara.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="formalpara" substitutionGroup="para.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="title"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element ref="para"/>
      </xs:sequence>
      <xs:attributeGroup ref="formalpara.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of formalpara.element -->
  <xs:attributeGroup name="formalpara.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="formalpara.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of formalpara.attlist -->
  <!-- end of formalpara.module -->
  <xs:attributeGroup name="para.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="para" substitutionGroup="para.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:group ref="para.mix"/>
      </xs:choice>
      <xs:attributeGroup ref="para.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of para.element -->
  <xs:attributeGroup name="para.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="para.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of para.attlist -->
  <!-- end of para.module -->
  <xs:attributeGroup name="simpara.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simpara" substitutionGroup="para.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="simpara.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simpara.element -->
  <xs:attributeGroup name="simpara.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simpara.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simpara.attlist -->
  <!-- end of simpara.module -->
  <xs:attributeGroup name="admon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="caution" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="caution.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of caution.element -->
  <xs:attributeGroup name="caution.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of caution.attlist -->
  <xs:element name="important" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="important.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of important.element -->
  <xs:attributeGroup name="important.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of important.attlist -->
  <xs:element name="note" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="note.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of note.element -->
  <xs:attributeGroup name="note.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of note.attlist -->
  <xs:element name="tip" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="tip.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tip.element -->
  <xs:attributeGroup name="tip.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tip.attlist -->
  <xs:element name="warning" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="warning.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of warning.element -->
  <xs:attributeGroup name="warning.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of warning.attlist -->
  <!-- end of admon.module -->
  <!-- ...................................................................... -->
  <!-- Lists ................................................................ -->
  <!-- GlossList ........................ -->
  <xs:attributeGroup name="glosslist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glosslist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="glossentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="glosslist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glosslist.element -->
  <xs:attributeGroup name="glosslist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glosslist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glosslist.attlist -->
  <!-- end of glosslist.module -->
  <xs:attributeGroup name="glossentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="glossterm"/>
        <xs:element minOccurs="0" ref="acronym"/>
        <xs:element minOccurs="0" ref="abbrev"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" ref="revhistory"/>
        <xs:choice>
          <xs:element ref="glosssee"/>
          <xs:element maxOccurs="unbounded" ref="glossdef"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="glossentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossentry.element -->
  <!--
    SortAs: String by which the GlossEntry is to be sorted
    (alphabetized) in lieu of its proper content
  -->
  <xs:attributeGroup name="glossentry.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossentry.attlist -->
  <!-- end of glossentry.module -->
  <!-- GlossTerm (defined in the Inlines section, below) -->
  <xs:attributeGroup name="glossdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossdef">
    <xs:complexType>
      <xs:sequence>
        <xs:group maxOccurs="unbounded" ref="glossdef.mix"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="glossseealso"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossdef.element -->
  <!-- Subject: List of subjects; keywords for the definition -->
  <xs:attributeGroup name="glossdef.attlist">
    <xs:attribute name="subject"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossdef.attlist -->
  <!-- end of glossdef.module -->
  <xs:attributeGroup name="glosssee.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glosssee">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glosssee.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glosssee.element -->
  <!--
    OtherTerm: Reference to the GlossEntry whose GlossTerm
    should be displayed at the point of the GlossSee
  -->
  <xs:attributeGroup name="glosssee.attlist">
    <xs:attribute name="otherterm" type="xs:IDREF"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glosssee.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glosssee.attlist -->
  <!-- end of glosssee.module -->
  <xs:attributeGroup name="glossseealso.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossseealso">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glossseealso.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossseealso.element -->
  <!--
    OtherTerm: Reference to the GlossEntry whose GlossTerm
    should be displayed at the point of the GlossSeeAlso
  -->
  <xs:attributeGroup name="glossseealso.attlist">
    <xs:attribute name="otherterm" type="xs:IDREF"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossseealso.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossseealso.attlist -->
  <!-- end of glossseealso.module -->
  <!-- end of glossentry.content.module -->
  <!-- ItemizedList and OrderedList ..... -->
  <xs:attributeGroup name="itemizedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="itemizedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="itemizedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of itemizedlist.element -->
  <!--
    Spacing: Whether the vertical space in the list should be
    compressed
  -->
  <!--
    Mark: Keyword, e.g., bullet, dash, checkbox, none;
    list of keywords and defaults are implementation specific
  -->
  <xs:attributeGroup name="itemizedlist.attlist">
    <xs:attribute name="spacing">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="normal"/>
          <xs:enumeration value="compact"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="mark.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="itemizedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of itemizedlist.attlist -->
  <!-- end of itemizedlist.module -->
  <xs:attributeGroup name="orderedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="orderedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="orderedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orderedlist.element -->
  <!--
    Numeration: Style of ListItem numbered; default is expected
    to be Arabic
  -->
  <!--
    InheritNum: Specifies for a nested list that the numbering
    of ListItems should include the number of the item
    within which they are nested (e.g., 1a and 1b within 1,
    rather than a and b)
  -->
  <!--
    Continuation: Where list numbering begins afresh (Restarts,
    the default) or continues that of the immediately preceding
    list (Continues)
  -->
  <!--
    Spacing: Whether the vertical space in the list should be
    compressed
  -->
  <xs:attributeGroup name="orderedlist.attlist">
    <xs:attribute name="numeration">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="arabic"/>
          <xs:enumeration value="upperalpha"/>
          <xs:enumeration value="loweralpha"/>
          <xs:enumeration value="upperroman"/>
          <xs:enumeration value="lowerroman"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="inheritnum" default="ignore">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="inherit"/>
          <xs:enumeration value="ignore"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="continuation" default="restarts">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="continues"/>
          <xs:enumeration value="restarts"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="spacing">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="normal"/>
          <xs:enumeration value="compact"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="orderedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orderedlist.attlist -->
  <!-- end of orderedlist.module -->
  <xs:attributeGroup name="listitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="listitem">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="listitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of listitem.element -->
  <!--
    Override: Indicates the mark to be used for this ListItem
    instead of the default mark or the mark specified by
    the Mark attribute on the enclosing ItemizedList
  -->
  <xs:attributeGroup name="listitem.attlist">
    <xs:attribute name="override"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="listitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of listitem.attlist -->
  <!-- end of listitem.module -->
  <!-- SegmentedList .................... -->
  <xs:attributeGroup name="segmentedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="segmentedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="segtitle"/>
        <xs:element maxOccurs="unbounded" ref="seglistitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="segmentedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of segmentedlist.element -->
  <xs:attributeGroup name="segmentedlist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="segmentedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of segmentedlist.attlist -->
  <!-- end of segmentedlist.module -->
  <xs:attributeGroup name="segtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="segtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="segtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of segtitle.element -->
  <xs:attributeGroup name="segtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="segtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of segtitle.attlist -->
  <!-- end of segtitle.module -->
  <xs:attributeGroup name="seglistitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seglistitem">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="seg"/>
      </xs:sequence>
      <xs:attributeGroup ref="seglistitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seglistitem.element -->
  <xs:attributeGroup name="seglistitem.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seglistitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seglistitem.attlist -->
  <!-- end of seglistitem.module -->
  <xs:attributeGroup name="seg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seg">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="seg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seg.element -->
  <xs:attributeGroup name="seg.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seg.attlist -->
  <!-- end of seg.module -->
  <!-- end of segmentedlist.content.module -->
  <!-- SimpleList ....................... -->
  <xs:attributeGroup name="simplelist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simplelist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="member"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplelist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplelist.element -->
  <!-- Columns: The number of columns the array should contain -->
  <!--
    Type: How the Members of the SimpleList should be
    formatted: Inline (members separated with commas etc.
    inline), Vert (top to bottom in n Columns), or Horiz (in
    the direction of text flow) in n Columns.  If Column
    is 1 or implied, Type=Vert and Type=Horiz give the same
    results.
  -->
  <xs:attributeGroup name="simplelist.attlist">
    <xs:attribute name="columns"/>
    <xs:attribute name="type" default="vert">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="inline"/>
          <xs:enumeration value="vert"/>
          <xs:enumeration value="horiz"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplelist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplelist.attlist -->
  <!-- end of simplelist.module -->
  <xs:attributeGroup name="member.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="member">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="member.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of member.element -->
  <xs:attributeGroup name="member.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="member.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of member.attlist -->
  <!-- end of member.module -->
  <!-- end of simplelist.content.module -->
  <!-- VariableList ..................... -->
  <xs:attributeGroup name="variablelist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="variablelist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="varlistentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="variablelist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of variablelist.element -->
  <!--
    TermLength: Length beyond which the presentation engine
    may consider the Term too long and select an alternate
    presentation of the Term and, or, its associated ListItem.
  -->
  <xs:attributeGroup name="variablelist.attlist">
    <xs:attribute name="termlength"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="variablelist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of variablelist.attlist -->
  <!-- end of variablelist.module -->
  <xs:attributeGroup name="varlistentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="varlistentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="term"/>
        <xs:element ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="varlistentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varlistentry.element -->
  <xs:attributeGroup name="varlistentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varlistentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varlistentry.attlist -->
  <!-- end of varlistentry.module -->
  <xs:attributeGroup name="term.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="term">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="term.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of term.element -->
  <xs:attributeGroup name="term.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="term.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of term.attlist -->
  <!-- end of term.module -->
  <!-- ListItem (defined above) -->
  <!-- end of variablelist.content.module -->
  <!-- CalloutList ...................... -->
  <xs:attributeGroup name="calloutlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="calloutlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="callout"/>
      </xs:sequence>
      <xs:attributeGroup ref="calloutlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of calloutlist.element -->
  <xs:attributeGroup name="calloutlist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="calloutlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of calloutlist.attlist -->
  <!-- end of calloutlist.module -->
  <xs:attributeGroup name="callout.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="callout">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="callout.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of callout.element -->
  <!--
    AreaRefs: IDs of one or more Areas or AreaSets described
    by this Callout
  -->
  <xs:attributeGroup name="callout.attlist">
    <xs:attribute name="arearefs" use="required" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="callout.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of callout.attlist -->
  <!-- end of callout.module -->
  <!-- end of calloutlist.content.module -->
  <!-- ...................................................................... -->
  <!-- Objects .............................................................. -->
  <!-- Examples etc. .................... -->
  <xs:attributeGroup name="example.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="example" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="example.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="example.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of example.element -->
  <xs:attributeGroup name="example.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="example.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of example.attlist -->
  <!-- end of example.module -->
  <xs:attributeGroup name="informalexample.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="informalexample" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group maxOccurs="unbounded" ref="example.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="informalexample.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalexample.element -->
  <xs:attributeGroup name="informalexample.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalexample.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalexample.attlist -->
  <!-- end of informalexample.module -->
  <xs:attributeGroup name="programlistingco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="programlistingco" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="programlisting"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="programlistingco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of programlistingco.element -->
  <xs:attributeGroup name="programlistingco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="programlistingco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of programlistingco.attlist -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of informalexample.module -->
  <xs:attributeGroup name="areaspec.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="areaspec">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="area"/>
        <xs:element ref="areaset"/>
      </xs:choice>
      <xs:attributeGroup ref="areaspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of areaspec.element -->
  <!--
    Units: global unit of measure in which coordinates in
    this spec are expressed:
    
    - CALSPair "x1,y1 x2,y2": lower-left and upper-right
    coordinates in a rectangle describing repro area in which
    graphic is placed, where X and Y dimensions are each some
    number 0..10000 (taken from CALS graphic attributes)
    
    - LineColumn "line column": line number and column number
    at which to start callout text in "linespecific" content
    
    - LineRange "startline endline": whole lines from startline
    to endline in "linespecific" content
    
    - LineColumnPair "line1 col1 line2 col2": starting and ending
    points of area in "linespecific" content that starts at
    first position and ends at second position (including the
    beginnings of any intervening lines)
    
    - Other: directive to look at value of OtherUnits attribute
    to get implementation-specific keyword
    
    The default is implementation-specific; usually dependent on
    the parent element (GraphicCO gets CALSPair, ProgramListingCO
    and ScreenCO get LineColumn)
  -->
  <!-- OtherUnits: User-defined units -->
  <xs:attributeGroup name="areaspec.attlist">
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="areaspec.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of areaspec.attlist -->
  <!-- end of areaspec.module -->
  <xs:attributeGroup name="area.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="area">
    <xs:complexType>
      <xs:attributeGroup ref="area.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of area.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <!--
    Units: unit of measure in which coordinates in this
    area are expressed; inherits from AreaSet and AreaSpec
  -->
  <!-- OtherUnits: User-defined units -->
  <xs:attributeGroup name="area.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attribute name="coords" use="required"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="area.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of area.attlist -->
  <!-- end of area.module -->
  <xs:attributeGroup name="areaset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="areaset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="area"/>
      </xs:sequence>
      <xs:attributeGroup ref="areaset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of areaset.element -->
  <!-- bug number/symbol override or initialization -->
  <!--
    Units: unit of measure in which coordinates in this
    area are expressed; inherits from AreaSpec
  -->
  <xs:attributeGroup name="areaset.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attribute name="coords" use="required"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="areaset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of areaset.attlist -->
  <!-- end of areaset.module -->
  <!-- end of areaspec.content.module -->
  <xs:attributeGroup name="programlisting.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="programlisting" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="lineannotation"/>
        <xs:element ref="textobject"/>
      </xs:choice>
      <xs:attributeGroup ref="programlisting.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of programlisting.element -->
  <xs:attributeGroup name="programlisting.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="programlisting.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of programlisting.attlist -->
  <!-- end of programlisting.module -->
  <xs:attributeGroup name="literallayout.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="literallayout" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="literallayout.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of literallayout.element -->
  <xs:attributeGroup name="literallayout.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attribute name="class" default="normal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="monospaced"/>
          <xs:enumeration value="normal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="literallayout.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of literallayout.attlist -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- end of literallayout.module -->
  <xs:attributeGroup name="screenco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screenco" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="screen"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="screenco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screenco.element -->
  <xs:attributeGroup name="screenco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screenco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screenco.attlist -->
  <!-- AreaSpec (defined above) -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of screenco.module -->
  <xs:attributeGroup name="screen.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screen" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="screen.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screen.element -->
  <xs:attributeGroup name="screen.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screen.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screen.attlist -->
  <!-- end of screen.module -->
  <xs:attributeGroup name="screenshot.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screenshot" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="screeninfo"/>
        <xs:choice>
          <xs:element ref="graphic"/>
          <xs:element ref="graphicco"/>
          <xs:element ref="mediaobject"/>
          <xs:element ref="mediaobjectco"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="screenshot.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screenshot.element -->
  <xs:attributeGroup name="screenshot.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screenshot.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screenshot.attlist -->
  <!-- end of screenshot.module -->
  <xs:attributeGroup name="screeninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screeninfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="screeninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screeninfo.element -->
  <xs:attributeGroup name="screeninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screeninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screeninfo.attlist -->
  <!-- end of screeninfo.module -->
  <!-- end of screenshot.content.module -->
  <!-- Figures etc. ..................... -->
  <xs:attributeGroup name="figure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="figure" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:choice maxOccurs="unbounded">
          <xs:group ref="figure.mix"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="figure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of figure.element -->
  <!--
    Float: Whether the Figure is supposed to be rendered
    where convenient (yes (1) value) or at the place it occurs
    in the text (no (0) value, the default)
  -->
  <xs:attributeGroup name="figure.attlist">
    <xs:attribute name="float" default="0" type="yesorno.attvals"/>
    <xs:attribute name="floatstyle"/>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="figure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of figure.attlist -->
  <!-- end of figure.module -->
  <xs:attributeGroup name="informalfigure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="informalfigure" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:choice maxOccurs="unbounded">
          <xs:group ref="figure.mix"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="informalfigure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalfigure.element -->
  <!--
    Float: Whether the Figure is supposed to be rendered
    where convenient (yes (1) value) or at the place it occurs
    in the text (no (0) value, the default)
  -->
  <xs:attributeGroup name="informalfigure.attlist">
    <xs:attribute name="float" default="0" type="yesorno.attvals"/>
    <xs:attribute name="floatstyle"/>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalfigure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalfigure.attlist -->
  <!-- end of informalfigure.module -->
  <xs:attributeGroup name="graphicco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="graphicco" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="graphic"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="graphicco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of graphicco.element -->
  <xs:attributeGroup name="graphicco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="graphicco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of graphicco.attlist -->
  <!-- AreaSpec (defined above in Examples) -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of graphicco.module -->
  <!--
    Graphical data can be the content of Graphic, or you can reference
    an external file either as an entity (Entitref) or a filename
    (Fileref).
  -->
  <xs:attributeGroup name="graphic.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="graphic" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:attributeGroup ref="graphic.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of graphic.element -->
  <xs:attributeGroup name="graphic.attlist">
    <xs:attributeGroup ref="graphics.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="graphic.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of graphic.attlist -->
  <!-- end of graphic.module -->
  <xs:attributeGroup name="inlinegraphic.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="inlinegraphic" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="inlinegraphic.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of inlinegraphic.element -->
  <xs:attributeGroup name="inlinegraphic.attlist">
    <xs:attributeGroup ref="graphics.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlinegraphic.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlinegraphic.attlist -->
  <!-- end of inlinegraphic.module -->
  <xs:attributeGroup name="mediaobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="mediaobject" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject.mix"/>
        <xs:element minOccurs="0" ref="caption"/>
      </xs:sequence>
      <xs:attributeGroup ref="mediaobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mediaobject.element -->
  <xs:attributeGroup name="mediaobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mediaobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mediaobject.attlist -->
  <!-- end of mediaobject.module -->
  <xs:attributeGroup name="inlinemediaobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="inlinemediaobject" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="inlinemediaobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of inlinemediaobject.element -->
  <xs:attributeGroup name="inlinemediaobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlinemediaobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlinemediaobject.attlist -->
  <!-- end of inlinemediaobject.module -->
  <xs:attributeGroup name="videoobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="videoobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="videodata"/>
      </xs:sequence>
      <xs:attributeGroup ref="videoobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of videoobject.element -->
  <xs:attributeGroup name="videoobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="videoobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of videoobject.attlist -->
  <!-- end of videoobject.module -->
  <xs:attributeGroup name="audioobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="audioobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="audiodata"/>
      </xs:sequence>
      <xs:attributeGroup ref="audioobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of audioobject.element -->
  <xs:attributeGroup name="audioobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="audioobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of audioobject.attlist -->
  <!-- end of audioobject.module -->
  <xs:attributeGroup name="imageobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="imageobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="imagedata"/>
      </xs:sequence>
      <xs:attributeGroup ref="imageobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imageobject.element -->
  <xs:attributeGroup name="imageobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imageobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imageobject.attlist -->
  <!-- end of imageobject.module -->
  <xs:attributeGroup name="textobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="textobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:choice>
          <xs:element ref="phrase"/>
          <xs:element ref="textdata"/>
          <xs:group maxOccurs="unbounded" ref="textobject.mix"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="textobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of textobject.element -->
  <xs:attributeGroup name="textobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="textobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of textobject.attlist -->
  <!-- end of textobject.module -->
  <xs:attributeGroup name="objectinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="objectinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="objectinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of objectinfo.element -->
  <xs:attributeGroup name="objectinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="objectinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of objectinfo.attlist -->
  <!-- end of objectinfo.module -->
  <!--
    EntityRef: Name of an external entity containing the content
    of the object data
  -->
  <!--
    FileRef: Filename, qualified by a pathname if desired,
    designating the file containing the content of the object data
  -->
  <!-- Format: Notation of the element content, if any -->
  <!-- SrcCredit: Information about the source of the image -->
  <xs:attributeGroup name="objectdata.attrib">
    <xs:attribute name="entityref" type="xs:ENTITY"/>
    <xs:attribute name="fileref"/>
    <xs:attribute name="format" type="notation.class"/>
    <xs:attribute name="srccredit"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="videodata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="videodata">
    <xs:complexType>
      <xs:attributeGroup ref="videodata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of videodata.element -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="videodata.attlist">
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="videodata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of videodata.attlist -->
  <!-- end of videodata.module -->
  <xs:attributeGroup name="audiodata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="audiodata">
    <xs:complexType>
      <xs:attributeGroup ref="audiodata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of audiodata.element -->
  <xs:attributeGroup name="audiodata.attlist">
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="audiodata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of audiodata.attlist -->
  <!-- end of audiodata.module -->
  <xs:attributeGroup name="imagedata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="imagedata">
    <xs:complexType>
      <xs:attributeGroup ref="imagedata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imagedata.element -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="imagedata.attlist">
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imagedata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imagedata.attlist -->
  <!-- end of imagedata.module -->
  <xs:attributeGroup name="textdata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="textdata">
    <xs:complexType>
      <xs:attributeGroup ref="textdata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of textdata.element -->
  <xs:attributeGroup name="textdata.attlist">
    <xs:attribute name="encoding"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="textdata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of textdata.attlist -->
  <!-- end of textdata.module -->
  <xs:attributeGroup name="mediaobjectco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="mediaobjectco" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="imageobjectco"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="imageobjectco"/>
          <xs:element ref="textobject"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="mediaobjectco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mediaobjectco.element -->
  <xs:attributeGroup name="mediaobjectco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mediaobjectco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mediaobjectco.attlist -->
  <!-- end of mediaobjectco.module -->
  <xs:attributeGroup name="imageobjectco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="imageobjectco">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="imageobject"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="imageobjectco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imageobjectco.element -->
  <xs:attributeGroup name="imageobjectco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imageobjectco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imageobjectco.attlist -->
  <!-- end of imageobjectco.module -->
  <!-- end of mediaobject.content.module -->
  <!-- Equations ........................ -->
  <!-- This PE provides a mechanism for replacing equation content, -->
  <!-- perhaps adding a new or different model (e.g., MathML) -->
  <xs:group name="equation.content">
    <xs:sequence>
      <xs:element minOccurs="0" ref="alt"/>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="graphic"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:complexType name="inlineequation.content">
    <xs:sequence>
      <xs:element minOccurs="0" ref="alt"/>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="graphic"/>
        <xs:element maxOccurs="unbounded" ref="inlinemediaobject"/>
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
  <xs:attributeGroup name="equation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="equation" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:choice>
          <xs:element ref="informalequation"/>
          <xs:group ref="equation.content"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="equation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of equation.element -->
  <xs:attributeGroup name="equation.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="equation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of equation.attlist -->
  <!-- end of equation.module -->
  <xs:attributeGroup name="informalequation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="informalequation" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="equation.content"/>
      </xs:sequence>
      <xs:attributeGroup ref="informalequation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalequation.element -->
  <xs:attributeGroup name="informalequation.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalequation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalequation.attlist -->
  <!-- end of informalequation.module -->
  <xs:attributeGroup name="inlineequation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="inlineequation" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="inlineequation.content">
          <xs:attributeGroup ref="inlineequation.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <!-- end of inlineequation.element -->
  <xs:attributeGroup name="inlineequation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlineequation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlineequation.attlist -->
  <!-- end of inlineequation.module -->
  <xs:attributeGroup name="alt.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="alt">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="alt.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of alt.element -->
  <xs:attributeGroup name="alt.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="alt.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of alt.attlist -->
  <!-- end of alt.module -->
  <!-- Tables ........................... -->
  <!-- Choose a table model. CALS or OASIS XML Exchange -->
  <!-- Do we allow the HTML table model as well? -->
  <!-- ====================================================== -->
  <!--
    xhtmltbl.mod defines HTML tables and sets parameter
    entities so that, when the CALS table module is read,
    we end up allowing any table to be CALS or HTML.
    i.e. This include must come first!
  -->
  <!-- ====================================================== -->
  <!-- end of allow.html.tables -->
  <!-- Add label and role attributes to table and informaltable -->
  <!--
    Add common attributes to Table, TGroup, TBody, THead, TFoot, Row,
    EntryTbl, and Entry (and InformalTable element).
  -->
  <!-- Content model for Table. -->
  <!-- Allow either objects or inlines; beware of REs between elements. -->
  <!-- Reference CALS Table Model -->
  <!-- end of table.module -->
  <!--
    Note that InformalTable is dependent on some of the entity
    declarations that customize Table.
  -->
  <!-- the following entity may have been declared by the XHTML table module -->
  <xs:element name="informaltable" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="informal.tbl.table.mdl"/>
      </xs:sequence>
      <xs:attributeGroup ref="informaltable.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informaltable.element -->
  <!--
    Frame, Colsep, and Rowsep must be repeated because
    they are not in entities in the table module.
  -->
  <!--
    includes TabStyle, ToCentry, ShortEntry,
    Orient, PgWide
  -->
  <!-- includes Label -->
  <!-- includes common attributes -->
  <xs:attributeGroup name="informaltable.attlist">
    <xs:attribute name="frame" type="tbl.frame.attval"/>
    <xs:attribute name="colsep" type="yesorno.attvals"/>
    <xs:attribute name="rowsep" type="yesorno.attvals"/>
    <xs:attributeGroup ref="common.table.attribs"/>
    <xs:attributeGroup ref="tbl.table.att"/>
  </xs:attributeGroup>
  <!-- end of informaltable.attlist -->
  <!-- end of informaltable.module -->
  <xs:attributeGroup name="caption.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="caption">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="textobject.mix"/>
      <xs:attributeGroup ref="caption.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of caption.element -->
  <!-- attrs comes from HTML tables ... -->
  <!-- common.attrib, but without ID because ID is in attrs -->
  <xs:attributeGroup name="caption.attlist.content">
    <xs:attributeGroup ref="lang.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="dir.attrib"/>
    <xs:attributeGroup ref="xml-base.attrib"/>
    <xs:attributeGroup ref="caption.role.attrib"/>
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="bottom"/>
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <xs:attributeGroup name="caption.attlist">
    <xs:attributeGroup ref="caption.attlist.content"/>
  </xs:attributeGroup>
  <!-- end of caption.attlist -->
  <!-- end of caption.module -->
  <!-- ...................................................................... -->
  <!-- Synopses ............................................................. -->
  <!-- Synopsis ......................... -->
  <xs:attributeGroup name="synopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="synopsis" substitutionGroup="synop.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="graphic"/>
        <xs:element ref="mediaobject"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="synopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopsis.element -->
  <xs:attributeGroup name="synopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="synopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopsis.attlist -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- end of synopsis.module -->
  <!-- CmdSynopsis ...................... -->
  <xs:attributeGroup name="cmdsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="cmdsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="command"/>
          <xs:element ref="arg"/>
          <xs:element ref="group"/>
          <xs:element ref="sbr"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="synopfragment"/>
      </xs:sequence>
      <xs:attributeGroup ref="cmdsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of cmdsynopsis.element -->
  <!--
    Sepchar: Character that should separate command and all
    top-level arguments; alternate value might be e.g., &Delta;
  -->
  <xs:attributeGroup name="cmdsynopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attribute name="sepchar" default=" "/>
    <xs:attribute name="cmdlength"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="cmdsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of cmdsynopsis.attlist -->
  <!-- end of cmdsynopsis.module -->
  <xs:attributeGroup name="arg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="arg">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
        <xs:element ref="option"/>
        <xs:element ref="synopfragmentref"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="sbr"/>
      </xs:choice>
      <xs:attributeGroup ref="arg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of arg.element -->
  <!--
    Choice: Whether Arg must be supplied: Opt (optional to
    supply, e.g. [arg]; the default), Req (required to supply,
    e.g. {arg}), or Plain (required to supply, e.g. arg)
  -->
  <!--
    Rep: whether Arg is repeatable: Norepeat (e.g. arg without
    ellipsis; the default), or Repeat (e.g. arg...)
  -->
  <xs:attributeGroup name="arg.attlist">
    <xs:attribute name="choice" default="opt">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="arg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of arg.attlist -->
  <!-- end of arg.module -->
  <xs:attributeGroup name="group.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="group">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
        <xs:element ref="option"/>
        <xs:element ref="synopfragmentref"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="sbr"/>
      </xs:choice>
      <xs:attributeGroup ref="group.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of group.element -->
  <!--
    Choice: Whether Group must be supplied: Opt (optional to
    supply, e.g.  [g1|g2|g3]; the default), Req (required to
    supply, e.g.  {g1|g2|g3}), Plain (required to supply,
    e.g.  g1|g2|g3), OptMult (can supply zero or more, e.g.
    [[g1|g2|g3]]), or ReqMult (must supply one or more, e.g.
    {{g1|g2|g3}})
  -->
  <!--
    Rep: whether Group is repeatable: Norepeat (e.g. group
    without ellipsis; the default), or Repeat (e.g. group...)
  -->
  <xs:attributeGroup name="group.attlist">
    <xs:attribute name="choice" default="opt">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="group.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of group.attlist -->
  <!-- end of group.module -->
  <!-- Synopsis break -->
  <xs:attributeGroup name="sbr.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sbr">
    <xs:complexType>
      <xs:attributeGroup ref="sbr.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sbr.element -->
  <xs:attributeGroup name="sbr.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sbr.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sbr.attlist -->
  <!-- end of sbr.module -->
  <xs:attributeGroup name="synopfragmentref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="synopfragmentref">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="synopfragmentref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopfragmentref.element -->
  <!--
    to SynopFragment of complex synopsis
    material for separate referencing
  -->
  <xs:attributeGroup name="synopfragmentref.attlist">
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="synopfragmentref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopfragmentref.attlist -->
  <!-- end of synopfragmentref.module -->
  <xs:attributeGroup name="synopfragment.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="synopfragment">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
      </xs:choice>
      <xs:attributeGroup ref="synopfragment.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopfragment.element -->
  <xs:attributeGroup name="synopfragment.attlist">
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="synopfragment.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopfragment.attlist -->
  <!-- end of synopfragment.module -->
  <!-- Command (defined in the Inlines section, below) -->
  <!-- Option (defined in the Inlines section, below) -->
  <!-- Replaceable (defined in the Inlines section, below) -->
  <!-- end of cmdsynopsis.content.module -->
  <!-- FuncSynopsis ..................... -->
  <xs:attributeGroup name="funcsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="funcsynopsisinfo"/>
        <xs:element ref="funcprototype"/>
      </xs:choice>
      <xs:attributeGroup ref="funcsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcsynopsis.element -->
  <xs:attributeGroup name="funcsynopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcsynopsis.attlist -->
  <!-- end of funcsynopsis.module -->
  <xs:attributeGroup name="funcsynopsisinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcsynopsisinfo">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="funcsynopsisinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcsynopsisinfo.element -->
  <xs:attributeGroup name="funcsynopsisinfo.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcsynopsisinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcsynopsisinfo.attlist -->
  <!-- end of funcsynopsisinfo.module -->
  <xs:attributeGroup name="funcprototype.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcprototype">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element ref="funcdef"/>
        <xs:choice>
          <xs:element ref="void"/>
          <xs:element ref="varargs"/>
          <xs:sequence>
            <xs:element maxOccurs="unbounded" ref="paramdef"/>
            <xs:element minOccurs="0" ref="varargs"/>
          </xs:sequence>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="funcprototype.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcprototype.element -->
  <xs:attributeGroup name="funcprototype.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcprototype.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcprototype.attlist -->
  <!-- end of funcprototype.module -->
  <xs:attributeGroup name="funcdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcdef">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="type"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="function"/>
      </xs:choice>
      <xs:attributeGroup ref="funcdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcdef.element -->
  <xs:attributeGroup name="funcdef.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcdef.attlist -->
  <!-- end of funcdef.module -->
  <xs:attributeGroup name="void.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="void">
    <xs:complexType>
      <xs:attributeGroup ref="void.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of void.element -->
  <xs:attributeGroup name="void.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="void.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of void.attlist -->
  <!-- end of void.module -->
  <xs:attributeGroup name="varargs.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="varargs">
    <xs:complexType>
      <xs:attributeGroup ref="varargs.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varargs.element -->
  <xs:attributeGroup name="varargs.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varargs.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varargs.attlist -->
  <!-- end of varargs.module -->
  <!--
    Processing assumes that only one Parameter will appear in a
    ParamDef, and that FuncParams will be used at most once, for
    providing information on the "inner parameters" for parameters that
    are pointers to functions.
  -->
  <xs:attributeGroup name="paramdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="paramdef">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="initializer"/>
        <xs:element ref="type"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="parameter"/>
        <xs:element ref="funcparams"/>
      </xs:choice>
      <xs:attributeGroup ref="paramdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of paramdef.element -->
  <xs:attributeGroup name="paramdef.attlist">
    <xs:attribute name="choice">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="paramdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of paramdef.attlist -->
  <!-- end of paramdef.module -->
  <xs:attributeGroup name="funcparams.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcparams">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="funcparams.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcparams.element -->
  <xs:attributeGroup name="funcparams.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcparams.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcparams.attlist -->
  <!-- end of funcparams.module -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- Replaceable (defined in the Inlines section, below) -->
  <!-- Function (defined in the Inlines section, below) -->
  <!-- Parameter (defined in the Inlines section, below) -->
  <!-- end of funcsynopsis.content.module -->
  <!-- ClassSynopsis ..................... -->
  <xs:attributeGroup name="classsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="classsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="ooclass"/>
          <xs:element ref="oointerface"/>
          <xs:element ref="ooexception"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="classsynopsisinfo"/>
          <xs:element ref="fieldsynopsis"/>
          <xs:element ref="method.synop.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="classsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classsynopsis.element -->
  <xs:attributeGroup name="classsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attribute name="class" default="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="class"/>
          <xs:enumeration value="interface"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classsynopsis.attlist -->
  <!-- end of classsynopsis.module -->
  <xs:attributeGroup name="classsynopsisinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="classsynopsisinfo">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="classsynopsisinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classsynopsisinfo.element -->
  <xs:attributeGroup name="classsynopsisinfo.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classsynopsisinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classsynopsisinfo.attlist -->
  <!-- end of classsynopsisinfo.module -->
  <xs:attributeGroup name="ooclass.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ooclass" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element ref="classname"/>
      </xs:sequence>
      <xs:attributeGroup ref="ooclass.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ooclass.element -->
  <xs:attributeGroup name="ooclass.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ooclass.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ooclass.attlist -->
  <!-- end of ooclass.module -->
  <xs:attributeGroup name="oointerface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="oointerface" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element ref="interfacename"/>
      </xs:sequence>
      <xs:attributeGroup ref="oointerface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of oointerface.element -->
  <xs:attributeGroup name="oointerface.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="oointerface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of oointerface.attlist -->
  <!-- end of oointerface.module -->
  <xs:attributeGroup name="ooexception.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ooexception" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="ooexception.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ooexception.element -->
  <xs:attributeGroup name="ooexception.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ooexception.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ooexception.attlist -->
  <!-- end of ooexception.module -->
  <xs:attributeGroup name="modifier.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="modifier">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="modifier.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of modifier.element -->
  <xs:attributeGroup name="modifier.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="modifier.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of modifier.attlist -->
  <!-- end of modifier.module -->
  <xs:attributeGroup name="interfacename.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="interfacename" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="interfacename.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of interfacename.element -->
  <xs:attributeGroup name="interfacename.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="interfacename.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of interfacename.attlist -->
  <!-- end of interfacename.module -->
  <xs:attributeGroup name="exceptionname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="exceptionname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="exceptionname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of exceptionname.element -->
  <xs:attributeGroup name="exceptionname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="exceptionname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of exceptionname.attlist -->
  <!-- end of exceptionname.module -->
  <xs:attributeGroup name="fieldsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="fieldsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="type"/>
        <xs:element ref="varname"/>
        <xs:element minOccurs="0" ref="initializer"/>
      </xs:sequence>
      <xs:attributeGroup ref="fieldsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of fieldsynopsis.element -->
  <xs:attributeGroup name="fieldsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="fieldsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of fieldsynopsis.attlist -->
  <!-- end of fieldsynopsis.module -->
  <xs:attributeGroup name="initializer.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="initializer">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="initializer.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of initializer.element -->
  <xs:attributeGroup name="initializer.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="initializer.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of initializer.attlist -->
  <!-- end of initializer.module -->
  <xs:attributeGroup name="constructorsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="constructorsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element minOccurs="0" ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="constructorsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of constructorsynopsis.element -->
  <xs:attributeGroup name="constructorsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="constructorsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of constructorsynopsis.attlist -->
  <!-- end of constructorsynopsis.module -->
  <xs:attributeGroup name="destructorsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="destructorsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element minOccurs="0" ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="destructorsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of destructorsynopsis.element -->
  <xs:attributeGroup name="destructorsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="destructorsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of destructorsynopsis.attlist -->
  <!-- end of destructorsynopsis.module -->
  <xs:attributeGroup name="methodsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="methodsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:choice minOccurs="0">
          <xs:element ref="type"/>
          <xs:element ref="void"/>
        </xs:choice>
        <xs:element ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element minOccurs="0" ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="methodsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodsynopsis.element -->
  <xs:attributeGroup name="methodsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodsynopsis.attlist -->
  <!-- end of methodsynopsis.module -->
  <xs:attributeGroup name="methodname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="methodname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="methodname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodname.element -->
  <xs:attributeGroup name="methodname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodname.attlist -->
  <!-- end of methodname.module -->
  <xs:attributeGroup name="methodparam.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="methodparam">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="type"/>
        <xs:choice>
          <xs:sequence>
            <xs:element ref="parameter"/>
            <xs:element minOccurs="0" ref="initializer"/>
          </xs:sequence>
          <xs:element ref="funcparams"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="methodparam.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodparam.element -->
  <xs:attributeGroup name="methodparam.attlist">
    <xs:attribute name="choice" default="req">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodparam.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodparam.attlist -->
  <!-- end of methodparam.module -->
  <!-- end of classsynopsis.content.module -->
  <!-- ...................................................................... -->
  <!-- Document information entities and elements ........................... -->
  <!--
    The document information elements include some elements that are
    currently used only in the document hierarchy module. They are
    defined here so that they will be available for use in customized
    document hierarchies.
  -->
  <!-- .................................. -->
  <!-- Ackno ............................ -->
  <xs:attributeGroup name="ackno.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ackno">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="ackno.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ackno.element -->
  <xs:attributeGroup name="ackno.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ackno.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ackno.attlist -->
  <!-- end of ackno.module -->
  <!-- Address .......................... -->
  <xs:attributeGroup name="address.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="address" substitutionGroup="informal.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="personname"/>
        <xs:group ref="person.ident.mix"/>
        <xs:element ref="street"/>
        <xs:element ref="pob"/>
        <xs:element ref="postcode"/>
        <xs:element ref="city"/>
        <xs:element ref="state"/>
        <xs:element ref="country"/>
        <xs:element ref="phone"/>
        <xs:element ref="fax"/>
        <xs:element ref="email"/>
        <xs:element ref="otheraddr"/>
      </xs:choice>
      <xs:attributeGroup ref="address.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of address.element -->
  <xs:attributeGroup name="address.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="address.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of address.attlist -->
  <!-- end of address.module -->
  <xs:attributeGroup name="street.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="street">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="street.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of street.element -->
  <xs:attributeGroup name="street.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="street.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of street.attlist -->
  <!-- end of street.module -->
  <xs:attributeGroup name="pob.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pob">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pob.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pob.element -->
  <xs:attributeGroup name="pob.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pob.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pob.attlist -->
  <!-- end of pob.module -->
  <xs:attributeGroup name="postcode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="postcode">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="postcode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of postcode.element -->
  <xs:attributeGroup name="postcode.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="postcode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of postcode.attlist -->
  <!-- end of postcode.module -->
  <xs:attributeGroup name="city.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="city">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="city.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of city.element -->
  <xs:attributeGroup name="city.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="city.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of city.attlist -->
  <!-- end of city.module -->
  <xs:attributeGroup name="state.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="state">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="state.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of state.element -->
  <xs:attributeGroup name="state.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="state.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of state.attlist -->
  <!-- end of state.module -->
  <xs:attributeGroup name="country.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="country">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="country.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of country.element -->
  <xs:attributeGroup name="country.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="country.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of country.attlist -->
  <!-- end of country.module -->
  <xs:attributeGroup name="phone.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="phone">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="phone.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of phone.element -->
  <xs:attributeGroup name="phone.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="phone.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of phone.attlist -->
  <!-- end of phone.module -->
  <xs:attributeGroup name="fax.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="fax">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="fax.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of fax.element -->
  <xs:attributeGroup name="fax.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="fax.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of fax.attlist -->
  <!-- end of fax.module -->
  <!-- Email (defined in the Inlines section, below) -->
  <xs:attributeGroup name="otheraddr.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="otheraddr">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="otheraddr.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of otheraddr.element -->
  <xs:attributeGroup name="otheraddr.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="otheraddr.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of otheraddr.attlist -->
  <!-- end of otheraddr.module -->
  <!-- end of address.content.module -->
  <!-- Affiliation ...................... -->
  <xs:attributeGroup name="affiliation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="affiliation">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="shortaffil"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="jobtitle"/>
        <xs:element minOccurs="0" ref="orgname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="orgdiv"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="address"/>
      </xs:sequence>
      <xs:attributeGroup ref="affiliation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of affiliation.element -->
  <xs:attributeGroup name="affiliation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="affiliation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of affiliation.attlist -->
  <!-- end of affiliation.module -->
  <xs:attributeGroup name="shortaffil.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="shortaffil">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="shortaffil.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of shortaffil.element -->
  <xs:attributeGroup name="shortaffil.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="shortaffil.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of shortaffil.attlist -->
  <!-- end of shortaffil.module -->
  <xs:attributeGroup name="jobtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="jobtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="jobtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of jobtitle.element -->
  <xs:attributeGroup name="jobtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="jobtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of jobtitle.attlist -->
  <!-- end of jobtitle.module -->
  <!-- OrgName (defined elsewhere in this section) -->
  <xs:attributeGroup name="orgdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="orgdiv">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="orgdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orgdiv.element -->
  <xs:attributeGroup name="orgdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="orgdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orgdiv.attlist -->
  <!-- end of orgdiv.module -->
  <!-- Address (defined elsewhere in this section) -->
  <!-- end of affiliation.content.module -->
  <!-- ArtPageNums ...................... -->
  <xs:attributeGroup name="artpagenums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="artpagenums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="artpagenums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of artpagenums.element -->
  <xs:attributeGroup name="artpagenums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="artpagenums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of artpagenums.attlist -->
  <!-- end of artpagenums.module -->
  <!-- PersonName -->
  <xs:attributeGroup name="personname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="personname" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="honorific"/>
        <xs:element ref="firstname"/>
        <xs:element ref="surname"/>
        <xs:element ref="lineage"/>
        <xs:element ref="othername"/>
      </xs:choice>
      <xs:attributeGroup ref="personname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of personname.element -->
  <xs:attributeGroup name="personname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="personname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of personname.attlist -->
  <!-- end of personname.module -->
  <!-- Author ........................... -->
  <xs:attributeGroup name="author.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="author" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="author.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of author.element -->
  <xs:attributeGroup name="author.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="author.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of author.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of author.module -->
  <!-- AuthorGroup ...................... -->
  <xs:attributeGroup name="authorgroup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="authorgroup">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="author"/>
        <xs:element ref="editor"/>
        <xs:element ref="collab"/>
        <xs:element ref="corpauthor"/>
        <xs:element ref="corpcredit"/>
        <xs:element ref="othercredit"/>
      </xs:choice>
      <xs:attributeGroup ref="authorgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorgroup.element -->
  <xs:attributeGroup name="authorgroup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorgroup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorgroup.attlist -->
  <!-- end of authorgroup.module -->
  <!-- Author (defined elsewhere in this section) -->
  <!-- Editor (defined elsewhere in this section) -->
  <xs:attributeGroup name="collab.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="collab">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="collabname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="affiliation"/>
      </xs:sequence>
      <xs:attributeGroup ref="collab.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of collab.element -->
  <xs:attributeGroup name="collab.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="collab.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of collab.attlist -->
  <!-- end of collab.module -->
  <xs:attributeGroup name="collabname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="collabname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="collabname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of collabname.element -->
  <xs:attributeGroup name="collabname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="collabname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of collabname.attlist -->
  <!-- end of collabname.module -->
  <!-- Affiliation (defined elsewhere in this section) -->
  <!-- end of collab.content.module -->
  <!-- CorpAuthor (defined elsewhere in this section) -->
  <!-- OtherCredit (defined elsewhere in this section) -->
  <!-- end of authorgroup.content.module -->
  <!-- AuthorInitials ................... -->
  <xs:attributeGroup name="authorinitials.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="authorinitials" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="authorinitials.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorinitials.element -->
  <xs:attributeGroup name="authorinitials.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorinitials.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorinitials.attlist -->
  <!-- end of authorinitials.module -->
  <!-- ConfGroup ........................ -->
  <xs:attributeGroup name="confgroup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confgroup">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="confdates"/>
        <xs:element ref="conftitle"/>
        <xs:element ref="confnum"/>
        <xs:element ref="address"/>
        <xs:element ref="confsponsor"/>
      </xs:choice>
      <xs:attributeGroup ref="confgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confgroup.element -->
  <xs:attributeGroup name="confgroup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confgroup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confgroup.attlist -->
  <!-- end of confgroup.module -->
  <xs:attributeGroup name="confdates.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confdates">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confdates.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confdates.element -->
  <xs:attributeGroup name="confdates.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confdates.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confdates.attlist -->
  <!-- end of confdates.module -->
  <xs:attributeGroup name="conftitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="conftitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="conftitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of conftitle.element -->
  <xs:attributeGroup name="conftitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="conftitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of conftitle.attlist -->
  <!-- end of conftitle.module -->
  <xs:attributeGroup name="confnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confnum.element -->
  <xs:attributeGroup name="confnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confnum.attlist -->
  <!-- end of confnum.module -->
  <!-- Address (defined elsewhere in this section) -->
  <xs:attributeGroup name="confsponsor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confsponsor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confsponsor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confsponsor.element -->
  <xs:attributeGroup name="confsponsor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confsponsor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confsponsor.attlist -->
  <!-- end of confsponsor.module -->
  <!-- end of confgroup.content.module -->
  <!-- ContractNum ...................... -->
  <xs:attributeGroup name="contractnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="contractnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contractnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contractnum.element -->
  <xs:attributeGroup name="contractnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contractnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contractnum.attlist -->
  <!-- end of contractnum.module -->
  <!-- ContractSponsor .................. -->
  <xs:attributeGroup name="contractsponsor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="contractsponsor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contractsponsor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contractsponsor.element -->
  <xs:attributeGroup name="contractsponsor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contractsponsor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contractsponsor.attlist -->
  <!-- end of contractsponsor.module -->
  <!-- Copyright ........................ -->
  <xs:attributeGroup name="copyright.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="copyright">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="year"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="holder"/>
      </xs:sequence>
      <xs:attributeGroup ref="copyright.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of copyright.element -->
  <xs:attributeGroup name="copyright.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="copyright.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of copyright.attlist -->
  <!-- end of copyright.module -->
  <xs:attributeGroup name="year.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="year">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="year.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of year.element -->
  <xs:attributeGroup name="year.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="year.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of year.attlist -->
  <!-- end of year.module -->
  <xs:attributeGroup name="holder.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="holder">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="holder.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of holder.element -->
  <xs:attributeGroup name="holder.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="holder.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of holder.attlist -->
  <!-- end of holder.module -->
  <!-- end of copyright.content.module -->
  <!-- CorpAuthor ....................... -->
  <xs:attributeGroup name="corpauthor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="corpauthor" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpauthor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpauthor.element -->
  <xs:attributeGroup name="corpauthor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpauthor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpauthor.attlist -->
  <!-- end of corpauthor.module -->
  <!-- CorpCredit ...................... -->
  <xs:attributeGroup name="corpcredit.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="corpcredit" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpcredit.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpcredit.element -->
  <xs:attributeGroup name="corpcredit.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="graphicdesigner"/>
          <xs:enumeration value="productioneditor"/>
          <xs:enumeration value="copyeditor"/>
          <xs:enumeration value="technicaleditor"/>
          <xs:enumeration value="translator"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpcredit.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpcredit.attlist -->
  <!-- end of corpcredit.module -->
  <!-- CorpName ......................... -->
  <xs:element name="corpname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpname.element -->
  <xs:attributeGroup name="corpname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="corpname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpname.attlist -->
  <!-- end of corpname.module -->
  <!-- Date ............................. -->
  <xs:attributeGroup name="date.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="date">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="date.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of date.element -->
  <xs:attributeGroup name="date.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="date.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of date.attlist -->
  <!-- end of date.module -->
  <!-- Edition .......................... -->
  <xs:attributeGroup name="edition.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="edition">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="edition.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of edition.element -->
  <xs:attributeGroup name="edition.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="edition.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of edition.attlist -->
  <!-- end of edition.module -->
  <!-- Editor ........................... -->
  <xs:attributeGroup name="editor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="editor">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="editor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of editor.element -->
  <xs:attributeGroup name="editor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="editor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of editor.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of editor.module -->
  <!-- ISBN ............................. -->
  <xs:attributeGroup name="isbn.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="isbn">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="isbn.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of isbn.element -->
  <xs:attributeGroup name="isbn.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="isbn.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of isbn.attlist -->
  <!-- end of isbn.module -->
  <!-- ISSN ............................. -->
  <xs:attributeGroup name="issn.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="issn">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="issn.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of issn.element -->
  <xs:attributeGroup name="issn.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="issn.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of issn.attlist -->
  <!-- end of issn.module -->
  <!-- BiblioId ................. -->
  <xs:attributeGroup name="biblio.class.attrib">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="uri"/>
          <xs:enumeration value="doi"/>
          <xs:enumeration value="isbn"/>
          <xs:enumeration value="issn"/>
          <xs:enumeration value="libraryofcongress"/>
          <xs:enumeration value="pubnumber"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherclass"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="biblioid.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="biblioid">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="biblioid.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioid.element -->
  <xs:attributeGroup name="biblioid.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioid.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioid.attlist -->
  <!-- end of biblioid.module -->
  <!-- CiteBiblioId ................. -->
  <xs:attributeGroup name="citebiblioid.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citebiblioid">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="citebiblioid.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citebiblioid.element -->
  <xs:attributeGroup name="citebiblioid.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citebiblioid.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citebiblioid.attlist -->
  <!-- end of citebiblioid.module -->
  <!-- BiblioSource ................. -->
  <xs:attributeGroup name="bibliosource.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliosource">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliosource.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliosource.element -->
  <xs:attributeGroup name="bibliosource.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliosource.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliosource.attlist -->
  <!-- end of bibliosource.module -->
  <!-- BiblioRelation ................. -->
  <xs:attributeGroup name="bibliorelation.type.attrib">
    <xs:attribute name="type">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="isversionof"/>
          <xs:enumeration value="hasversion"/>
          <xs:enumeration value="isreplacedby"/>
          <xs:enumeration value="replaces"/>
          <xs:enumeration value="isrequiredby"/>
          <xs:enumeration value="requires"/>
          <xs:enumeration value="ispartof"/>
          <xs:enumeration value="haspart"/>
          <xs:enumeration value="isreferencedby"/>
          <xs:enumeration value="references"/>
          <xs:enumeration value="isformatof"/>
          <xs:enumeration value="hasformat"/>
          <xs:enumeration value="othertype"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="othertype"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="bibliorelation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliorelation">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliorelation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliorelation.element -->
  <xs:attributeGroup name="bibliorelation.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="bibliorelation.type.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliorelation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliorelation.attlist -->
  <!-- end of bibliorelation.module -->
  <!-- BiblioCoverage ................. -->
  <xs:attributeGroup name="bibliocoverage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliocoverage">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliocoverage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliocoverage.element -->
  <xs:attributeGroup name="bibliocoverage.attlist">
    <xs:attribute name="spatial">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="dcmipoint"/>
          <xs:enumeration value="iso3166"/>
          <xs:enumeration value="dcmibox"/>
          <xs:enumeration value="tgn"/>
          <xs:enumeration value="otherspatial"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherspatial"/>
    <xs:attribute name="temporal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="dcmiperiod"/>
          <xs:enumeration value="w3c-dtf"/>
          <xs:enumeration value="othertemporal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="othertemporal"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliocoverage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliocoverage.attlist -->
  <!-- end of bibliocoverage.module -->
  <!-- InvPartNumber .................... -->
  <xs:attributeGroup name="invpartnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="invpartnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="invpartnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of invpartnumber.element -->
  <xs:attributeGroup name="invpartnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="invpartnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of invpartnumber.attlist -->
  <!-- end of invpartnumber.module -->
  <!-- IssueNum ......................... -->
  <xs:attributeGroup name="issuenum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="issuenum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="issuenum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of issuenum.element -->
  <xs:attributeGroup name="issuenum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="issuenum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of issuenum.attlist -->
  <!-- end of issuenum.module -->
  <!-- LegalNotice ...................... -->
  <xs:attributeGroup name="legalnotice.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="legalnotice">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="legalnotice.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="legalnotice.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of legalnotice.element -->
  <xs:attributeGroup name="legalnotice.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="legalnotice.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of legalnotice.attlist -->
  <!-- end of legalnotice.module -->
  <!-- ModeSpec ......................... -->
  <xs:attributeGroup name="modespec.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="modespec" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="modespec.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of modespec.element -->
  <!--
    Application: Type of action required for completion
    of the links to which the ModeSpec is relevant (e.g.,
    retrieval query)
  -->
  <xs:attributeGroup name="modespec.attlist">
    <xs:attribute name="application" type="notation.class"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="modespec.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of modespec.attlist -->
  <!-- end of modespec.module -->
  <!-- OrgName .......................... -->
  <xs:attributeGroup name="orgname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="orgname" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="orgname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orgname.element -->
  <xs:attributeGroup name="orgname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="corporation"/>
          <xs:enumeration value="nonprofit"/>
          <xs:enumeration value="consortium"/>
          <xs:enumeration value="informal"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherclass"/>
    <xs:attributeGroup ref="orgname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orgname.attlist -->
  <!-- end of orgname.module -->
  <!-- OtherCredit ...................... -->
  <xs:attributeGroup name="othercredit.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="othercredit" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="othercredit.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of othercredit.element -->
  <xs:attributeGroup name="othercredit.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="graphicdesigner"/>
          <xs:enumeration value="productioneditor"/>
          <xs:enumeration value="copyeditor"/>
          <xs:enumeration value="technicaleditor"/>
          <xs:enumeration value="translator"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="othercredit.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of othercredit.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of othercredit.module -->
  <!-- PageNums ......................... -->
  <xs:attributeGroup name="pagenums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pagenums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pagenums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pagenums.element -->
  <xs:attributeGroup name="pagenums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pagenums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pagenums.attlist -->
  <!-- end of pagenums.module -->
  <!-- Personal identity elements ....... -->
  <!--
    These elements are used only within Author, Editor, and
    OtherCredit.
  -->
  <xs:attributeGroup name="contrib.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="contrib">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contrib.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contrib.element -->
  <xs:attributeGroup name="contrib.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contrib.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contrib.attlist -->
  <!-- end of contrib.module -->
  <xs:attributeGroup name="firstname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="firstname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="firstname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of firstname.element -->
  <xs:attributeGroup name="firstname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="firstname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of firstname.attlist -->
  <!-- end of firstname.module -->
  <xs:attributeGroup name="honorific.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="honorific">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="honorific.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of honorific.element -->
  <xs:attributeGroup name="honorific.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="honorific.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of honorific.attlist -->
  <!-- end of honorific.module -->
  <xs:attributeGroup name="lineage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lineage">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="lineage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lineage.element -->
  <xs:attributeGroup name="lineage.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lineage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lineage.attlist -->
  <!-- end of lineage.module -->
  <xs:attributeGroup name="othername.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="othername">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="othername.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of othername.element -->
  <xs:attributeGroup name="othername.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="othername.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of othername.attlist -->
  <!-- end of othername.module -->
  <xs:attributeGroup name="surname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="surname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="surname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of surname.element -->
  <xs:attributeGroup name="surname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="surname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of surname.attlist -->
  <!-- end of surname.module -->
  <!-- end of person.ident.module -->
  <!-- PrintHistory ..................... -->
  <xs:attributeGroup name="printhistory.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="printhistory">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="printhistory.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of printhistory.element -->
  <xs:attributeGroup name="printhistory.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="printhistory.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of printhistory.attlist -->
  <!-- end of printhistory.module -->
  <!-- ProductName ...................... -->
  <xs:attributeGroup name="productname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="productname" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="productname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of productname.element -->
  <!-- Class: More precisely identifies the item the element names -->
  <xs:attributeGroup name="productname.attlist">
    <xs:attribute name="class" default="trade">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="service"/>
          <xs:enumeration value="trade"/>
          <xs:enumeration value="registered"/>
          <xs:enumeration value="copyright"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="productname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of productname.attlist -->
  <!-- end of productname.module -->
  <!-- ProductNumber .................... -->
  <xs:attributeGroup name="productnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="productnumber" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="productnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of productnumber.element -->
  <xs:attributeGroup name="productnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="productnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of productnumber.attlist -->
  <!-- end of productnumber.module -->
  <!-- PubDate .......................... -->
  <xs:attributeGroup name="pubdate.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pubdate">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pubdate.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pubdate.element -->
  <xs:attributeGroup name="pubdate.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pubdate.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pubdate.attlist -->
  <!-- end of pubdate.module -->
  <!-- Publisher ........................ -->
  <xs:attributeGroup name="publisher.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="publisher">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="publishername"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="address"/>
      </xs:sequence>
      <xs:attributeGroup ref="publisher.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of publisher.element -->
  <xs:attributeGroup name="publisher.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="publisher.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of publisher.attlist -->
  <!-- end of publisher.module -->
  <xs:attributeGroup name="publishername.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="publishername">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="publishername.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of publishername.element -->
  <xs:attributeGroup name="publishername.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="publishername.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of publishername.attlist -->
  <!-- end of publishername.module -->
  <!-- Address (defined elsewhere in this section) -->
  <!-- end of publisher.content.module -->
  <!-- PubsNumber ....................... -->
  <xs:attributeGroup name="pubsnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pubsnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pubsnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pubsnumber.element -->
  <xs:attributeGroup name="pubsnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pubsnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pubsnumber.attlist -->
  <!-- end of pubsnumber.module -->
  <!-- ReleaseInfo ...................... -->
  <xs:attributeGroup name="releaseinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="releaseinfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="releaseinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of releaseinfo.element -->
  <xs:attributeGroup name="releaseinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="releaseinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of releaseinfo.attlist -->
  <!-- end of releaseinfo.module -->
  <!-- RevHistory ....................... -->
  <xs:attributeGroup name="revhistory.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revhistory" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="revision"/>
      </xs:sequence>
      <xs:attributeGroup ref="revhistory.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revhistory.element -->
  <xs:attributeGroup name="revhistory.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revhistory.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revhistory.attlist -->
  <!-- end of revhistory.module -->
  <xs:attributeGroup name="revision.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revision">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="revnumber"/>
        <xs:element ref="date"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="author"/>
          <xs:element ref="authorinitials"/>
        </xs:choice>
        <xs:choice minOccurs="0">
          <xs:element ref="revremark"/>
          <xs:element ref="revdescription"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="revision.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revision.element -->
  <xs:attributeGroup name="revision.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revision.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revision.attlist -->
  <!-- end of revision.module -->
  <xs:attributeGroup name="revnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="revnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revnumber.element -->
  <xs:attributeGroup name="revnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revnumber.attlist -->
  <!-- end of revnumber.module -->
  <!-- Date (defined elsewhere in this section) -->
  <!-- AuthorInitials (defined elsewhere in this section) -->
  <xs:attributeGroup name="revremark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revremark">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="revremark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revremark.element -->
  <xs:attributeGroup name="revremark.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revremark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revremark.attlist -->
  <!-- end of revremark.module -->
  <xs:attributeGroup name="revdescription.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revdescription">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="revdescription.mix"/>
      <xs:attributeGroup ref="revdescription.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revdescription.element -->
  <xs:attributeGroup name="revdescription.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revdescription.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revdescription.attlist -->
  <!-- end of revdescription.module -->
  <!-- end of revhistory.content.module -->
  <!-- SeriesVolNums .................... -->
  <xs:attributeGroup name="seriesvolnums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seriesvolnums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="seriesvolnums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seriesvolnums.element -->
  <xs:attributeGroup name="seriesvolnums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seriesvolnums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seriesvolnums.attlist -->
  <!-- end of seriesvolnums.module -->
  <!-- VolumeNum ........................ -->
  <xs:attributeGroup name="volumenum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="volumenum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="volumenum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of volumenum.element -->
  <xs:attributeGroup name="volumenum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="volumenum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of volumenum.attlist -->
  <!-- end of volumenum.module -->
  <!-- .................................. -->
  <!-- end of docinfo.content.module -->
  <!-- ...................................................................... -->
  <!-- Inline, link, and ubiquitous elements ................................ -->
  <!-- Technical and computer terms ......................................... -->
  <xs:attributeGroup name="accel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="accel">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="accel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of accel.element -->
  <xs:attributeGroup name="accel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="accel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of accel.attlist -->
  <!-- end of accel.module -->
  <xs:attributeGroup name="action.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="action" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="action.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of action.element -->
  <xs:attributeGroup name="action.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="action.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of action.attlist -->
  <!-- end of action.module -->
  <xs:attributeGroup name="application.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="application" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="application.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of application.element -->
  <xs:attributeGroup name="application.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="hardware"/>
          <xs:enumeration value="software"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="application.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of application.attlist -->
  <!-- end of application.module -->
  <xs:attributeGroup name="classname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="classname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="classname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classname.element -->
  <xs:attributeGroup name="classname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classname.attlist -->
  <!-- end of classname.module -->
  <!--
    CO is a callout area of the LineColumn unit type (a single character
    position); the position is directly indicated by the location of CO.
  -->
  <xs:attributeGroup name="co.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="co">
    <xs:complexType>
      <xs:attributeGroup ref="co.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of co.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <xs:attributeGroup name="co.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="co.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of co.attlist -->
  <!-- end of co.module -->
  <!-- COREF is a reference to a CO -->
  <xs:attributeGroup name="coref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="coref">
    <xs:complexType>
      <xs:attributeGroup ref="coref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of coref.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <xs:attributeGroup name="coref.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="coref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of coref.attlist -->
  <!-- end of coref.module -->
  <xs:attributeGroup name="command.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="command" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="command.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of command.element -->
  <xs:attributeGroup name="command.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="command.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of command.attlist -->
  <!-- end of command.module -->
  <xs:attributeGroup name="computeroutput.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="computeroutput" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="computeroutput.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of computeroutput.element -->
  <xs:attributeGroup name="computeroutput.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="computeroutput.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of computeroutput.attlist -->
  <!-- end of computeroutput.module -->
  <xs:attributeGroup name="database.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="database" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="database.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of database.element -->
  <!-- Class: Type of database the element names; no default -->
  <xs:attributeGroup name="database.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="name"/>
          <xs:enumeration value="table"/>
          <xs:enumeration value="field"/>
          <xs:enumeration value="key1"/>
          <xs:enumeration value="key2"/>
          <xs:enumeration value="record"/>
          <xs:enumeration value="index"/>
          <xs:enumeration value="view"/>
          <xs:enumeration value="primarykey"/>
          <xs:enumeration value="secondarykey"/>
          <xs:enumeration value="foreignkey"/>
          <xs:enumeration value="altkey"/>
          <xs:enumeration value="procedure"/>
          <xs:enumeration value="datatype"/>
          <xs:enumeration value="constraint"/>
          <xs:enumeration value="rule"/>
          <xs:enumeration value="user"/>
          <xs:enumeration value="group"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="database.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of database.attlist -->
  <!-- end of database.module -->
  <xs:attributeGroup name="email.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="email" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="email.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of email.element -->
  <xs:attributeGroup name="email.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="email.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of email.attlist -->
  <!-- end of email.module -->
  <xs:attributeGroup name="envar.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="envar" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="envar.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of envar.element -->
  <xs:attributeGroup name="envar.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="envar.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of envar.attlist -->
  <!-- end of envar.module -->
  <xs:attributeGroup name="errorcode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errorcode" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errorcode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errorcode.element -->
  <xs:attributeGroup name="errorcode.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errorcode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errorcode.attlist -->
  <!-- end of errorcode.module -->
  <xs:attributeGroup name="errorname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errorname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errorname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errorname.element -->
  <xs:attributeGroup name="errorname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errorname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errorname.attlist -->
  <!-- end of errorname.module -->
  <xs:attributeGroup name="errortext.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errortext" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errortext.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errortext.element -->
  <xs:attributeGroup name="errortext.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errortext.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errortext.attlist -->
  <!-- end of errortext.module -->
  <xs:attributeGroup name="errortype.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errortype" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errortype.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errortype.element -->
  <xs:attributeGroup name="errortype.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errortype.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errortype.attlist -->
  <!-- end of errortype.module -->
  <xs:attributeGroup name="filename.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="filename" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="filename.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of filename.element -->
  <!-- Class: Type of filename the element names; no default -->
  <!--
    Path: Search path (possibly system-specific) in which
    file can be found
  -->
  <xs:attributeGroup name="filename.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="headerfile"/>
          <xs:enumeration value="partition"/>
          <xs:enumeration value="devicefile"/>
          <xs:enumeration value="libraryfile"/>
          <xs:enumeration value="directory"/>
          <xs:enumeration value="extension"/>
          <xs:enumeration value="symlink"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="path"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="filename.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of filename.attlist -->
  <!-- end of filename.module -->
  <xs:attributeGroup name="function.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="function" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="function.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of function.element -->
  <xs:attributeGroup name="function.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="function.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of function.attlist -->
  <!-- end of function.module -->
  <xs:attributeGroup name="guibutton.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guibutton" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guibutton.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guibutton.element -->
  <xs:attributeGroup name="guibutton.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guibutton.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guibutton.attlist -->
  <!-- end of guibutton.module -->
  <xs:attributeGroup name="guiicon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guiicon" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guiicon.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guiicon.element -->
  <xs:attributeGroup name="guiicon.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guiicon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guiicon.attlist -->
  <!-- end of guiicon.module -->
  <xs:attributeGroup name="guilabel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guilabel" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guilabel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guilabel.element -->
  <xs:attributeGroup name="guilabel.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guilabel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guilabel.attlist -->
  <!-- end of guilabel.module -->
  <xs:attributeGroup name="guimenu.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guimenu" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guimenu.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guimenu.element -->
  <xs:attributeGroup name="guimenu.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guimenu.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guimenu.attlist -->
  <!-- end of guimenu.module -->
  <xs:attributeGroup name="guimenuitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guimenuitem" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guimenuitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guimenuitem.element -->
  <xs:attributeGroup name="guimenuitem.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guimenuitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guimenuitem.attlist -->
  <!-- end of guimenuitem.module -->
  <xs:attributeGroup name="guisubmenu.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guisubmenu" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guisubmenu.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guisubmenu.element -->
  <xs:attributeGroup name="guisubmenu.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guisubmenu.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guisubmenu.attlist -->
  <!-- end of guisubmenu.module -->
  <xs:attributeGroup name="hardware.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="hardware" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="hardware.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of hardware.element -->
  <xs:attributeGroup name="hardware.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="hardware.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of hardware.attlist -->
  <!-- end of hardware.module -->
  <xs:attributeGroup name="interface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="interface" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="interface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of interface.element -->
  <!-- Class: Type of the Interface item; no default -->
  <xs:attributeGroup name="interface.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="interface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of interface.attlist -->
  <!-- end of interface.module -->
  <xs:attributeGroup name="keycap.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keycap" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="keycap.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycap.element -->
  <xs:attributeGroup name="keycap.attlist">
    <xs:attribute name="function">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="alt"/>
          <xs:enumeration value="control"/>
          <xs:enumeration value="shift"/>
          <xs:enumeration value="meta"/>
          <xs:enumeration value="escape"/>
          <xs:enumeration value="enter"/>
          <xs:enumeration value="tab"/>
          <xs:enumeration value="backspace"/>
          <xs:enumeration value="command"/>
          <xs:enumeration value="option"/>
          <xs:enumeration value="space"/>
          <xs:enumeration value="delete"/>
          <xs:enumeration value="insert"/>
          <xs:enumeration value="up"/>
          <xs:enumeration value="down"/>
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="home"/>
          <xs:enumeration value="end"/>
          <xs:enumeration value="pageup"/>
          <xs:enumeration value="pagedown"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherfunction"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycap.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycap.attlist -->
  <!-- end of keycap.module -->
  <xs:attributeGroup name="keycode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keycode" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="keycode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycode.element -->
  <xs:attributeGroup name="keycode.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycode.attlist -->
  <!-- end of keycode.module -->
  <xs:attributeGroup name="keycombo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keycombo" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="keycap"/>
        <xs:element ref="keycombo"/>
        <xs:element ref="keysym"/>
        <xs:element ref="mousebutton"/>
      </xs:choice>
      <xs:attributeGroup ref="keycombo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycombo.element -->
  <xs:attributeGroup name="keycombo.attlist">
    <xs:attributeGroup ref="keyaction.attrib"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycombo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycombo.attlist -->
  <!-- end of keycombo.module -->
  <xs:attributeGroup name="keysysm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keysym" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="keysym.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keysym.element -->
  <xs:attributeGroup name="keysym.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keysysm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keysym.attlist -->
  <!-- end of keysym.module -->
  <xs:attributeGroup name="lineannotation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lineannotation">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="lineannotation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lineannotation.element -->
  <xs:attributeGroup name="lineannotation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lineannotation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lineannotation.attlist -->
  <!-- end of lineannotation.module -->
  <xs:attributeGroup name="literal.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="literal" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="literal.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of literal.element -->
  <xs:attributeGroup name="literal.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="literal.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of literal.attlist -->
  <!-- end of literal.module -->
  <xs:attributeGroup name="code.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="code" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="code.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of code.element -->
  <xs:attributeGroup name="code.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="code.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of code.attlist -->
  <!-- end of code.module -->
  <xs:attributeGroup name="constant.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="constant" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="constant.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of constant.element -->
  <xs:attributeGroup name="constant.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="limit"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="constant.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of constant.attlist -->
  <!-- end of constant.module -->
  <xs:attributeGroup name="varname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="varname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="varname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varname.element -->
  <xs:attributeGroup name="varname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varname.attlist -->
  <!-- end of varname.module -->
  <xs:attributeGroup name="markup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="markup" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="markup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of markup.element -->
  <xs:attributeGroup name="markup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="markup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of markup.attlist -->
  <!-- end of markup.module -->
  <xs:attributeGroup name="medialabel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="medialabel" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="medialabel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of medialabel.element -->
  <!-- Class: Type of medium named by the element; no default -->
  <xs:attributeGroup name="medialabel.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="cartridge"/>
          <xs:enumeration value="cdrom"/>
          <xs:enumeration value="disk"/>
          <xs:enumeration value="tape"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="medialabel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of medialabel.attlist -->
  <!-- end of medialabel.module -->
  <xs:attributeGroup name="menuchoice.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="menuchoice" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="shortcut"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="guibutton"/>
          <xs:element ref="guiicon"/>
          <xs:element ref="guilabel"/>
          <xs:element ref="guimenu"/>
          <xs:element ref="guimenuitem"/>
          <xs:element ref="guisubmenu"/>
          <xs:element ref="interface"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="menuchoice.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of menuchoice.element -->
  <xs:attributeGroup name="menuchoice.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="menuchoice.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of menuchoice.attlist -->
  <!-- end of menuchoice.module -->
  <!-- See also KeyCombo -->
  <xs:attributeGroup name="shortcut.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="shortcut">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="keycap"/>
        <xs:element ref="keycombo"/>
        <xs:element ref="keysym"/>
        <xs:element ref="mousebutton"/>
      </xs:choice>
      <xs:attributeGroup ref="shortcut.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of shortcut.element -->
  <xs:attributeGroup name="shortcut.attlist">
    <xs:attributeGroup ref="keyaction.attrib"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="shortcut.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of shortcut.attlist -->
  <!-- end of shortcut.module -->
  <!-- end of menuchoice.content.module -->
  <xs:attributeGroup name="mousebutton.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="mousebutton" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="mousebutton.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mousebutton.element -->
  <xs:attributeGroup name="mousebutton.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mousebutton.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mousebutton.attlist -->
  <!-- end of mousebutton.module -->
  <xs:attributeGroup name="msgtext.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgtext">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="msgtext.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgtext.element -->
  <xs:attributeGroup name="msgtext.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgtext.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgtext.attlist -->
  <!-- end of msgtext.module -->
  <xs:attributeGroup name="option.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="option" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="option.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of option.element -->
  <xs:attributeGroup name="option.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="option.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of option.attlist -->
  <!-- end of option.module -->
  <xs:attributeGroup name="optional.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="optional" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="optional.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of optional.element -->
  <xs:attributeGroup name="optional.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="optional.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of optional.attlist -->
  <!-- end of optional.module -->
  <xs:attributeGroup name="parameter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="parameter" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="parameter.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of parameter.element -->
  <!-- Class: Type of the Parameter; no default -->
  <xs:attributeGroup name="parameter.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="command"/>
          <xs:enumeration value="function"/>
          <xs:enumeration value="option"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="parameter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of parameter.attlist -->
  <!-- end of parameter.module -->
  <xs:attributeGroup name="prompt.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="prompt" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="prompt.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of prompt.element -->
  <xs:attributeGroup name="prompt.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="prompt.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of prompt.attlist -->
  <!-- end of prompt.module -->
  <xs:attributeGroup name="property.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="property" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="property.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of property.element -->
  <xs:attributeGroup name="property.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="property.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of property.attlist -->
  <!-- end of property.module -->
  <xs:attributeGroup name="replaceable.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="replaceable" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="optional"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="replaceable.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of replaceable.element -->
  <!--
    Class: Type of information the element represents; no
    default
  -->
  <xs:attributeGroup name="replaceable.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="command"/>
          <xs:enumeration value="function"/>
          <xs:enumeration value="option"/>
          <xs:enumeration value="parameter"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="replaceable.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of replaceable.attlist -->
  <!-- end of replaceable.module -->
  <xs:attributeGroup name="returnvalue.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="returnvalue" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="returnvalue.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of returnvalue.element -->
  <xs:attributeGroup name="returnvalue.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="returnvalue.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of returnvalue.attlist -->
  <!-- end of returnvalue.module -->
  <xs:attributeGroup name="sgmltag.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sgmltag" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="sgmltag.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sgmltag.element -->
  <!-- Class: Type of SGML construct the element names; no default -->
  <xs:attributeGroup name="sgmltag.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="attribute"/>
          <xs:enumeration value="attvalue"/>
          <xs:enumeration value="element"/>
          <xs:enumeration value="endtag"/>
          <xs:enumeration value="emptytag"/>
          <xs:enumeration value="genentity"/>
          <xs:enumeration value="numcharref"/>
          <xs:enumeration value="paramentity"/>
          <xs:enumeration value="pi"/>
          <xs:enumeration value="xmlpi"/>
          <xs:enumeration value="starttag"/>
          <xs:enumeration value="sgmlcomment"/>
          <xs:enumeration value="prefix"/>
          <xs:enumeration value="namespace"/>
          <xs:enumeration value="localname"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="namespace"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sgmltag.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sgmltag.attlist -->
  <!-- end of sgmltag.module -->
  <xs:attributeGroup name="structfield.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="structfield" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="structfield.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of structfield.element -->
  <xs:attributeGroup name="structfield.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="structfield.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of structfield.attlist -->
  <!-- end of structfield.module -->
  <xs:attributeGroup name="structname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="structname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="structname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of structname.element -->
  <xs:attributeGroup name="structname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="structname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of structname.attlist -->
  <!-- end of structname.module -->
  <xs:attributeGroup name="symbol.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="symbol" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="symbol.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of symbol.element -->
  <!-- Class: Type of symbol; no default -->
  <xs:attributeGroup name="symbol.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="limit"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="symbol.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of symbol.attlist -->
  <!-- end of symbol.module -->
  <xs:attributeGroup name="systemitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="systemitem" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="acronym"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="systemitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of systemitem.element -->
  <!-- Class: Type of system item the element names; no default -->
  <xs:attributeGroup name="systemitem.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="constant"/>
          <xs:enumeration value="event"/>
          <xs:enumeration value="eventhandler"/>
          <xs:enumeration value="domainname"/>
          <xs:enumeration value="fqdomainname"/>
          <xs:enumeration value="ipaddress"/>
          <xs:enumeration value="netmask"/>
          <xs:enumeration value="etheraddress"/>
          <xs:enumeration value="groupname"/>
          <xs:enumeration value="library"/>
          <xs:enumeration value="macro"/>
          <xs:enumeration value="osname"/>
          <xs:enumeration value="filesystem"/>
          <xs:enumeration value="resource"/>
          <xs:enumeration value="systemname"/>
          <xs:enumeration value="username"/>
          <xs:enumeration value="newsgroup"/>
          <xs:enumeration value="process"/>
          <xs:enumeration value="service"/>
          <xs:enumeration value="server"/>
          <xs:enumeration value="daemon"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="systemitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of systemitem.attlist -->
  <!-- end of systemitem.module -->
  <xs:attributeGroup name="uri.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="uri" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="uri.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of uri.element -->
  <!-- Type: Type of URI; no default -->
  <xs:attributeGroup name="uri.attlist">
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="uri.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of uri.attlist -->
  <!-- end of uri.module -->
  <xs:attributeGroup name="token.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="token" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="token.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of token.element -->
  <xs:attributeGroup name="token.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="token.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of token.attlist -->
  <!-- end of token.module -->
  <xs:attributeGroup name="type.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="type" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="type.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of type.element -->
  <xs:attributeGroup name="type.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="type.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of type.attlist -->
  <!-- end of type.module -->
  <xs:attributeGroup name="userinput.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="userinput" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="userinput.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of userinput.element -->
  <xs:attributeGroup name="userinput.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="userinput.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of userinput.attlist -->
  <!-- end of userinput.module -->
  <!-- General words and phrases ............................................ -->
  <xs:attributeGroup name="abbrev.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="abbrev" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="abbrev.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of abbrev.element -->
  <xs:attributeGroup name="abbrev.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="abbrev.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of abbrev.attlist -->
  <!-- end of abbrev.module -->
  <xs:attributeGroup name="acronym.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="acronym" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="acronym.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of acronym.element -->
  <xs:attributeGroup name="acronym.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="acronym.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of acronym.attlist -->
  <!-- end of acronym.module -->
  <xs:attributeGroup name="citation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citation" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="citation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citation.element -->
  <xs:attributeGroup name="citation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citation.attlist -->
  <!-- end of citation.module -->
  <xs:attributeGroup name="citerefentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citerefentry" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="refentrytitle"/>
        <xs:element minOccurs="0" ref="manvolnum"/>
      </xs:sequence>
      <xs:attributeGroup ref="citerefentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citerefentry.element -->
  <xs:attributeGroup name="citerefentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citerefentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citerefentry.attlist -->
  <!-- end of citerefentry.module -->
  <xs:attributeGroup name="refentrytitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refentrytitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="refentrytitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refentrytitle.element -->
  <xs:attributeGroup name="refentrytitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentrytitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentrytitle.attlist -->
  <!-- end of refentrytitle.module -->
  <xs:attributeGroup name="namvolnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="manvolnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="manvolnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of manvolnum.element -->
  <xs:attributeGroup name="manvolnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="namvolnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of manvolnum.attlist -->
  <!-- end of manvolnum.module -->
  <xs:attributeGroup name="citetitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citetitle" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="citetitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citetitle.element -->
  <!-- Pubwork: Genre of published work cited; no default -->
  <xs:attributeGroup name="citetitle.attlist">
    <xs:attribute name="pubwork">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="article"/>
          <xs:enumeration value="book"/>
          <xs:enumeration value="chapter"/>
          <xs:enumeration value="part"/>
          <xs:enumeration value="refentry"/>
          <xs:enumeration value="section"/>
          <xs:enumeration value="journal"/>
          <xs:enumeration value="series"/>
          <xs:enumeration value="set"/>
          <xs:enumeration value="manuscript"/>
          <xs:enumeration value="cdrom"/>
          <xs:enumeration value="dvd"/>
          <xs:enumeration value="wiki"/>
          <xs:enumeration value="gopher"/>
          <xs:enumeration value="bbs"/>
          <xs:enumeration value="emailmessage"/>
          <xs:enumeration value="webpage"/>
          <xs:enumeration value="newsposting"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citetitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citetitle.attlist -->
  <!-- end of citetitle.module -->
  <xs:attributeGroup name="emphasis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="emphasis" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="emphasis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of emphasis.element -->
  <xs:attributeGroup name="emphasis.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="emphasis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of emphasis.attlist -->
  <!-- end of emphasis.module -->
  <xs:attributeGroup name="foreignphrase.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="foreignphrase" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="foreignphrase.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of foreignphrase.element -->
  <xs:attributeGroup name="foreignphrase.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="foreignphrase.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of foreignphrase.attlist -->
  <!-- end of foreignphrase.module -->
  <xs:attributeGroup name="glossterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossterm" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glossterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossterm.element -->
  <!-- to GlossEntry if Glossterm used in text -->
  <!--
    BaseForm: Provides the form of GlossTerm to be used
    for indexing
  -->
  <xs:attributeGroup name="glossterm.attlist">
    <xs:attribute name="baseform"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossterm.attlist -->
  <!-- end of glossterm.module -->
  <xs:attributeGroup name="firstterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="firstterm" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="firstterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of firstterm.element -->
  <!-- to GlossEntry or other explanation -->
  <xs:attributeGroup name="firstterm.attlist">
    <xs:attribute name="baseform"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="firstterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of firstterm.attlist -->
  <!-- end of firstterm.module -->
  <xs:attributeGroup name="phrase.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="phrase" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="phrase.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of phrase.element -->
  <xs:attributeGroup name="phrase.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="phrase.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of phrase.attlist -->
  <!-- end of phrase.module -->
  <xs:attributeGroup name="quote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="quote" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="quote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of quote.element -->
  <xs:attributeGroup name="quote.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="quote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of quote.attlist -->
  <!-- end of quote.module -->
  <xs:attributeGroup name="ssscript.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subscript">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="symbol"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
      </xs:choice>
      <xs:attributeGroup ref="subscript.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subscript.element -->
  <xs:attributeGroup name="subscript.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ssscript.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subscript.attlist -->
  <xs:element name="superscript">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="symbol"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
      </xs:choice>
      <xs:attributeGroup ref="superscript.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of superscript.element -->
  <xs:attributeGroup name="superscript.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ssscript.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of superscript.attlist -->
  <!-- end of ssscript.module -->
  <xs:attributeGroup name="trademark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="trademark" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="emphasis"/>
      </xs:choice>
      <xs:attributeGroup ref="trademark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of trademark.element -->
  <!-- Class: More precisely identifies the item the element names -->
  <xs:attributeGroup name="trademark.attlist">
    <xs:attribute name="class" default="trade">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="service"/>
          <xs:enumeration value="trade"/>
          <xs:enumeration value="registered"/>
          <xs:enumeration value="copyright"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="trademark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of trademark.attlist -->
  <!-- end of trademark.module -->
  <xs:attributeGroup name="wordasword.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="wordasword" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="wordasword.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of wordasword.element -->
  <xs:attributeGroup name="wordasword.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="wordasword.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of wordasword.attlist -->
  <!-- end of wordasword.module -->
  <!-- Links and cross-references ........................................... -->
  <xs:attributeGroup name="link.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="link" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="link.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of link.element -->
  <!--
    Endterm: ID of element containing text that is to be
    fetched from elsewhere in the document to appear as
    the content of this element
  -->
  <!-- to linked-to object -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="link.attlist">
    <xs:attribute name="endterm" type="xs:IDREF"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="link.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of link.attlist -->
  <!-- end of link.module -->
  <xs:attributeGroup name="olink.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="olink" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="olink.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of olink.element -->
  <!-- TargetDocEnt: Name of an entity to be the target of the link -->
  <!--
    LinkMode: ID of a ModeSpec containing instructions for
    operating on the entity named by TargetDocEnt
  -->
  <!-- LocalInfo: Information that may be passed to ModeSpec -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="olink.attlist">
    <xs:attribute name="targetdocent" type="xs:ENTITY"/>
    <xs:attribute name="linkmode" type="xs:IDREF"/>
    <xs:attribute name="localinfo"/>
    <xs:attribute name="type"/>
    <xs:attribute name="targetdoc"/>
    <xs:attribute name="targetptr"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="olink.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of olink.attlist -->
  <!-- end of olink.module -->
  <xs:attributeGroup name="ulink.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ulink" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="ulink.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ulink.element -->
  <!-- URL: uniform resource locator; the target of the ULink -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="ulink.attlist">
    <xs:attribute name="url" use="required"/>
    <xs:attribute name="type"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ulink.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ulink.attlist -->
  <!-- end of ulink.module -->
  <xs:attributeGroup name="footnoteref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="footnoteref" substitutionGroup="xref.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="footnoteref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of footnoteref.element -->
  <!-- to footnote content supplied elsewhere -->
  <xs:attributeGroup name="footnoteref.attlist">
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="footnoteref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of footnoteref.attlist -->
  <!-- end of footnoteref.module -->
  <xs:attributeGroup name="xref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="xref" substitutionGroup="xref.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="xref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of xref.element -->
  <!--
    Endterm: ID of element containing text that is to be
    fetched from elsewhere in the document to appear as
    the content of this element
  -->
  <!-- to linked-to object -->
  <xs:attributeGroup name="xref.attlist">
    <xs:attribute name="endterm" type="xs:IDREF"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="xref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of xref.attlist -->
  <!-- end of xref.module -->
  <!-- Ubiquitous elements .................................................. -->
  <xs:attributeGroup name="anchor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="anchor">
    <xs:complexType>
      <xs:attributeGroup ref="anchor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of anchor.element -->
  <!-- required -->
  <!-- replaces Lang -->
  <xs:attributeGroup name="anchor.attlist">
    <xs:attributeGroup ref="idreq.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="anchor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of anchor.attlist -->
  <!-- end of anchor.module -->
  <xs:attributeGroup name="beginpage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="beginpage">
    <xs:complexType>
      <xs:attributeGroup ref="beginpage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of beginpage.element -->
  <!-- PageNum: Number of page that begins at this point -->
  <xs:attributeGroup name="beginpage.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="beginpage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of beginpage.attlist -->
  <!-- end of beginpage.module -->
  <!--
    IndexTerms appear in the text flow for generating or linking an
    index.
  -->
  <xs:attributeGroup name="indexterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexterm" substitutionGroup="ndxterm.class"/>
  <!-- end of indexterm.element -->
  <!--
    Scope: Indicates which generated indices the IndexTerm
    should appear in: Global (whole document set), Local (this
    document only), or All (both)
  -->
  <!--
    Significance: Whether this IndexTerm is the most pertinent
    of its series (Preferred) or not (Normal, the default)
  -->
  <!--
    Class: Indicates type of IndexTerm; default is Singular,
    or EndOfRange if StartRef is supplied; StartOfRange value
    must be supplied explicitly on starts of ranges
  -->
  <!--
    StartRef: ID of the IndexTerm that starts the indexing
    range ended by this IndexTerm
  -->
  <!--
    Zone: IDs of the elements to which the IndexTerm applies,
    and indicates that the IndexTerm applies to those entire
    elements rather than the point at which the IndexTerm
    occurs
  -->
  <xs:attributeGroup name="indexterm.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attribute name="scope">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="all"/>
          <xs:enumeration value="global"/>
          <xs:enumeration value="local"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="significance" default="normal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="preferred"/>
          <xs:enumeration value="normal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="singular"/>
          <xs:enumeration value="startofrange"/>
          <xs:enumeration value="endofrange"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="startref" type="xs:IDREF"/>
    <xs:attribute name="zone" type="xs:IDREFS"/>
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexterm.attlist -->
  <!-- end of indexterm.module -->
  <xs:attributeGroup name="primsecter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="primary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="primary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of primary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="primary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of primary.attlist -->
  <xs:element name="secondary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="secondary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of secondary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="secondary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of secondary.attlist -->
  <xs:element name="tertiary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="tertiary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tertiary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="tertiary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tertiary.attlist -->
  <!-- end of primsecter.module -->
  <xs:attributeGroup name="seeseealso.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="see">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="see.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of see.element -->
  <xs:attributeGroup name="see.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeseealso.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of see.attlist -->
  <xs:element name="seealso">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seealso.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seealso.element -->
  <xs:attributeGroup name="seealso.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeseealso.role.attrib"/>
  </xs:attributeGroup>
</xs:schema>
<!-- end of seealso.attlist -->
<!-- end of seeseealso.module -->
<!-- end of indexterm.content.module -->
<!-- End of DocBook XML information pool module V4.3CR3 ...................... -->
<!-- ...................................................................... -->
 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 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook XML HTML Table Module V4.3CR3 ................................... -->
<!-- File htmltblx.mod .................................................... -->
<!--
  Copyright 2003 ArborText, Inc., Norman Walsh, Sun Microsystems, Inc.,
  and the Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: htmltblx.mod,v 1.11 2004/01/21 18:54:21 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook XML DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook XML DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for elements that are
  isomorphic to the HTML elements. One could argue we should
  instead have based ourselves on the XHTML Table Module, but the
  HTML one is more like what browsers are likely to accept today
  and users are likely to use.
  
  This module has been developed for use with the DocBook V4.3
  "union table model" in which elements and attlists common to both
  models are defined (as the union) in the CALS table module by
  setting various parameter entities appropriately in this file.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % htmltbl PUBLIC
  "-//OASIS//ELEMENTS DocBook XML HTML Tables V4.3CR3//EN"
  "htmltblx.mod">
  %htmltbl;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ======================= XHTML Tables ======================================= -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <xs:attributeGroup name="html.coreattrs">
    <xs:attribute name="id" type="xs:ID"/>
    <xs:attribute name="class"/>
    <xs:attribute name="style"/>
    <xs:attribute name="title"/>
  </xs:attributeGroup>
  <!-- Does not contain lang or dir because they are in %common.attribs -->
  <xs:attributeGroup name="i18n">
    <xs:attribute ref="xml:lang"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="events">
    <xs:attribute name="onclick"/>
    <xs:attribute name="ondblclick"/>
    <xs:attribute name="onmousedown"/>
    <xs:attribute name="onmouseup"/>
    <xs:attribute name="onmouseover"/>
    <xs:attribute name="onmousemove"/>
    <xs:attribute name="onmouseout"/>
    <xs:attribute name="onkeypress"/>
    <xs:attribute name="onkeydown"/>
    <xs:attribute name="onkeyup"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="attrs">
    <xs:attributeGroup ref="html.coreattrs"/>
    <xs:attributeGroup ref="i18n"/>
    <xs:attributeGroup ref="events"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="cellhalign">
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="cellvalign">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
          <xs:enumeration value="baseline"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <xs:element name="colgroup">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="col"/>
      </xs:sequence>
      <xs:attributeGroup ref="colgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="col">
    <xs:complexType>
      <xs:attributeGroup ref="col.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="tr">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="th"/>
        <xs:element ref="td"/>
      </xs:choice>
      <xs:attributeGroup ref="tr.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="th">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:group ref="tabentry.mix"/>
      </xs:choice>
      <xs:attributeGroup ref="th.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="td">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:group ref="tabentry.mix"/>
      </xs:choice>
      <xs:attributeGroup ref="td.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="colgroup.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="span" default="1"/>
    <xs:attribute name="width"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="col.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="span" default="1"/>
    <xs:attribute name="width"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="tr.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
    <xs:attribute name="bgcolor"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="th.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="abbr"/>
    <xs:attribute name="axis"/>
    <xs:attribute name="headers" type="xs:IDREFS"/>
    <xs:attribute name="scope">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="row"/>
          <xs:enumeration value="col"/>
          <xs:enumeration value="rowgroup"/>
          <xs:enumeration value="colgroup"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rowspan" default="1"/>
    <xs:attribute name="colspan" default="1"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
    <xs:attribute name="nowrap">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="nowrap"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="bgcolor"/>
    <xs:attribute name="width"/>
    <xs:attribute name="height"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="td.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="abbr"/>
    <xs:attribute name="axis"/>
    <xs:attribute name="headers" type="xs:IDREFS"/>
    <xs:attribute name="scope">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="row"/>
          <xs:enumeration value="col"/>
          <xs:enumeration value="rowgroup"/>
          <xs:enumeration value="colgroup"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rowspan" default="1"/>
    <xs:attribute name="colspan" default="1"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
    <xs:attribute name="nowrap">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="nowrap"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="bgcolor"/>
    <xs:attribute name="width"/>
    <xs:attribute name="height"/>
  </xs:attributeGroup>
  <!-- ====================================================== -->
  <!--
    Set up to read in the CALS model configured to
    merge with the XHTML table model
  -->
  <!-- ====================================================== -->
  <xs:attributeGroup name="tables.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- Add label and role attributes to table and informaltable -->
  <xs:attributeGroup name="bodyatt">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="label.attrib"/>
  </xs:attributeGroup>
  <!--
    Add common attributes to Table, TGroup, TBody, THead, TFoot, Row, 
    EntryTbl, and Entry (and InformalTable element).
  -->
  <xs:attributeGroup name="secur">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attribute name="class"/>
    <xs:attribute name="style"/>
    <xs:attribute name="title"/>
    <xs:attributeGroup ref="i18n"/>
    <xs:attributeGroup ref="events"/>
    <xs:attributeGroup ref="tables.role.attrib"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="common.table.attribs">
    <xs:attributeGroup ref="bodyatt"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- Content model for Table (that also allows HTML tables) -->
  <xs:complexType name="tbl.table.mdl">
    <xs:choice>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="textobject"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="graphic"/>
          <xs:element maxOccurs="unbounded" ref="mediaobject"/>
          <xs:element maxOccurs="unbounded" ref="tgroup"/>
        </xs:choice>
      </xs:sequence>
      <xs:sequence>
        <xs:element ref="caption"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="col"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="colgroup"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="thead"/>
        <xs:element minOccurs="0" ref="tfoot"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="tbody"/>
          <xs:element maxOccurs="unbounded" ref="tr"/>
        </xs:choice>
      </xs:sequence>
    </xs:choice>
  </xs:complexType>
  <xs:group name="informal.tbl.table.mdl">
    <xs:choice>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="textobject"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="graphic"/>
          <xs:element maxOccurs="unbounded" ref="mediaobject"/>
          <xs:element maxOccurs="unbounded" ref="tgroup"/>
        </xs:choice>
      </xs:sequence>
      <xs:sequence>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="col"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="colgroup"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="thead"/>
        <xs:element minOccurs="0" ref="tfoot"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="tbody"/>
          <xs:element maxOccurs="unbounded" ref="tr"/>
        </xs:choice>
      </xs:sequence>
    </xs:choice>
  </xs:group>
  <!-- Attributes for Table (including HTML ones) -->
  <xs:attributeGroup name="tbl.table.att">
    <xs:attribute name="tabstyle"/>
    <xs:attribute name="tocentry" type="yesorno.attvals"/>
    <xs:attribute name="shortentry" type="yesorno.attvals"/>
    <xs:attribute name="orient">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="port"/>
          <xs:enumeration value="land"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attribute name="summary"/>
    <xs:attribute name="width"/>
    <xs:attribute name="border"/>
    <xs:attribute name="rules">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="none"/>
          <xs:enumeration value="groups"/>
          <xs:enumeration value="rows"/>
          <xs:enumeration value="cols"/>
          <xs:enumeration value="all"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="cellspacing"/>
    <xs:attribute name="cellpadding"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="right"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="bgcolor"/>
  </xs:attributeGroup>
  <xs:simpleType name="tbl.frame.attval">
    <xs:restriction base="xs:token">
      <xs:enumeration value="void"/>
      <xs:enumeration value="above"/>
      <xs:enumeration value="below"/>
      <xs:enumeration value="hsides"/>
      <xs:enumeration value="lhs"/>
      <xs:enumeration value="rhs"/>
      <xs:enumeration value="vsides"/>
      <xs:enumeration value="box"/>
      <xs:enumeration value="border"/>
      <xs:enumeration value="top"/>
      <xs:enumeration value="bottom"/>
      <xs:enumeration value="topbot"/>
      <xs:enumeration value="all"/>
      <xs:enumeration value="sides"/>
      <xs:enumeration value="none"/>
    </xs:restriction>
  </xs:simpleType>
  <!-- Allow either objects or inlines; beware of REs between elements. -->
  <xs:group name="tbl.entry.mdl">
    <xs:choice>
      <xs:group ref="para.char.mix"/>
      <xs:group ref="tabentry.mix"/>
    </xs:choice>
  </xs:group>
  <!--
    thead, tfoot, and tbody are defined in both table models,
    so we set up parameter entities to define union models for them
  -->
  <xs:complexType name="tbl.hdft.mdl">
    <xs:choice>
      <xs:element maxOccurs="unbounded" ref="tr"/>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
        <xs:element maxOccurs="unbounded" ref="row"/>
      </xs:sequence>
    </xs:choice>
  </xs:complexType>
  <xs:complexType name="tbl.tbody.mdl">
    <xs:choice>
      <xs:element maxOccurs="unbounded" ref="tr"/>
      <xs:element maxOccurs="unbounded" ref="row"/>
    </xs:choice>
  </xs:complexType>
</xs:schema>
 PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHhzOnNjaGVtYSB4bWxuczp4cz0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEiIGVsZW1lbnRGb3JtRGVmYXVsdD0icXVhbGlmaWVkIiB0YXJnZXROYW1lc3BhY2U9Imh0dHA6Ly93d3cudzMub3JnL1hNTC8xOTk4L25hbWVzcGFjZSI+CiAgPHhzOmltcG9ydCBzY2hlbWFMb2NhdGlvbj0iZG9jYm9vay54c2QiLz4KICA8eHM6YXR0cmlidXRlIG5hbWU9ImJhc2UiLz4KICA8eHM6YXR0cmlidXRlIG5hbWU9ImxhbmciIHR5cGU9InhzOk5NVE9LRU4iLz4KPC94czpzY2hlbWE+Cg== <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook CALS Table Model V4.2 ........................................ -->
<!-- File calstblx.mod .................................................... -->
<!--
  Copyright 1992-2002 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  This DTD is based on the CALS Table Model
  PUBLIC "-//USA-DOD//DTD Table Model 951010//EN"
  
  $Id: calstblx.dtd,v 1.12 2002/07/17 15:26:16 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the CALS Table Model
  converted to XML.
-->
<!--
  These definitions are not directly related to the table model, but are
  used in the default CALS table model and are usually defined elsewhere
  (and prior to the inclusion of this table module) in a CALS DTD.
-->
<!--
  no if zero(s),
  yes if any other digits value
-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:simpleType name="yesorno">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:group name="titles">
    <xs:sequence>
      <xs:element minOccurs="0" ref="title"/>
    </xs:sequence>
  </xs:group>
  <!-- default for use in entry content -->
  <!--
    The parameter entities as defined below provide the CALS table model
    as published (as part of the Example DTD) in MIL-HDBK-28001.
    
    These following declarations provide the CALS-compliant default definitions
    for these entities.  However, these entities can and should be redefined
    (by giving the appropriate parameter entity declaration(s) prior to the
    reference to this Table Model declaration set entity) to fit the needs
    of the current application.
  -->
  <xs:group name="tbl.table-titles.mdl">
    <xs:sequence>
      <xs:group ref="titles"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="tbl.table-main.mdl">
    <xs:choice>
      <xs:element maxOccurs="unbounded" ref="tgroup"/>
      <xs:element maxOccurs="unbounded" ref="graphic"/>
    </xs:choice>
  </xs:group>
  <xs:attributeGroup name="tbl.table.att">
    <xs:attribute name="tabstyle"/>
    <xs:attribute name="tocentry" type="yesorno"/>
    <xs:attribute name="shortentry" type="yesorno"/>
    <xs:attribute name="orient">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="port"/>
          <xs:enumeration value="land"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="pgwide" type="yesorno"/>
  </xs:attributeGroup>
  <xs:complexType name="tbl.tgroup.mdl">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="spanspec"/>
      <xs:element minOccurs="0" ref="thead"/>
      <xs:element minOccurs="0" ref="tfoot"/>
      <xs:element ref="tbody"/>
    </xs:sequence>
  </xs:complexType>
  <xs:attributeGroup name="tbl.tgroup.att">
    <xs:attribute name="tgroupstyle"/>
  </xs:attributeGroup>
  <xs:complexType name="tbl.hdft.mdl">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
      <xs:element maxOccurs="unbounded" ref="row"/>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="tbl.row.mdl">
    <xs:choice maxOccurs="unbounded">
      <xs:element ref="entry"/>
      <xs:element ref="entrytbl"/>
    </xs:choice>
  </xs:complexType>
  <xs:complexType name="tbl.entrytbl.mdl">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="spanspec"/>
      <xs:element minOccurs="0" ref="thead"/>
      <xs:element ref="tbody"/>
    </xs:sequence>
  </xs:complexType>
  <!-- =====  Element and attribute declarations follow. ===== -->
  <xs:element name="table" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.table.mdl">
          <xs:attributeGroup ref="table.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="table.attlist">
    <xs:attribute name="frame">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="bottom"/>
          <xs:enumeration value="topbot"/>
          <xs:enumeration value="all"/>
          <xs:enumeration value="sides"/>
          <xs:enumeration value="none"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attributeGroup ref="tbl.table.att"/>
    <xs:attributeGroup ref="bodyatt"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="tgroup">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.tgroup.mdl">
          <xs:attributeGroup ref="tgroup.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tgroup.attlist">
    <xs:attribute name="cols" use="required"/>
    <xs:attributeGroup ref="tbl.tgroup.att"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="colspec">
    <xs:complexType>
      <xs:attributeGroup ref="colspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="colspec.attlist">
    <xs:attribute name="colnum"/>
    <xs:attribute name="colname"/>
    <xs:attribute name="colwidth"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <xs:element name="spanspec">
    <xs:complexType>
      <xs:attributeGroup ref="spanspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="spanspec.attlist">
    <xs:attribute name="namest" use="required"/>
    <xs:attribute name="nameend" use="required"/>
    <xs:attribute name="spanname" use="required"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <xs:element name="thead">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.hdft.mdl">
          <xs:attributeGroup ref="thead.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="thead.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="tfoot">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.hdft.mdl">
          <xs:attributeGroup ref="tfoot.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tfoot.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="tbody">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="row"/>
      </xs:sequence>
      <xs:attributeGroup ref="tbody.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tbody.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="row">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.row.mdl">
          <xs:attributeGroup ref="row.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="row.attlist">
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="entrytbl">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.entrytbl.mdl">
          <xs:attributeGroup ref="entrytbl.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="entrytbl.attlist">
    <xs:attribute name="cols" use="required"/>
    <xs:attributeGroup ref="tbl.tgroup.att"/>
    <xs:attribute name="colname"/>
    <xs:attribute name="spanname"/>
    <xs:attribute name="namest"/>
    <xs:attribute name="nameend"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="entry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="tbl.entry.mdl"/>
      <xs:attributeGroup ref="entry.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="entry.attlist">
    <xs:attribute name="colname"/>
    <xs:attribute name="namest"/>
    <xs:attribute name="nameend"/>
    <xs:attribute name="spanname"/>
    <xs:attribute name="morerows"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attribute name="rotate" type="yesorno"/>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
</xs:schema>
<!-- End of DocBook CALS Table Model V4.2 ................................. -->
<!-- ...................................................................... -->
 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook document hierarchy module V4.2 ............................... -->
<!-- File dbhierx.mod ..................................................... -->
<!--
  Copyright 1992-2002 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: dbhierx.mod,v 1.19 2002/07/17 15:26:16 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the overall document
  hierarchies of DocBook documents.  It covers computer documentation
  manuals and manual fragments, as well as reference entries (such as
  man pages) and technical journals or anthologies containing
  articles.
  
  This module depends on the DocBook information pool module.  All
  elements and entities referenced but not defined here are assumed
  to be defined in the information pool module.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % dbhier PUBLIC
  "-//OASIS//ELEMENTS DocBook Document Hierarchy V4.2//EN"
  "dbhierx.mod">
  %dbhier;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ...................................................................... -->
<!-- Entities for module inclusions ....................................... -->
<!-- ...................................................................... -->
<!-- Entities for element classes ......................................... -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:element name="appendix.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="appendixinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="appendix.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="article.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="articleinfo"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="lot"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:group ref="nav.class"/>
          <xs:element ref="appendix.class"/>
          <xs:element ref="ackno"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="article.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="book.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="bookinfo"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="dedication"/>
          <xs:element ref="toc"/>
          <xs:element ref="lot"/>
          <xs:element ref="glossary"/>
          <xs:element ref="bibliography"/>
          <xs:element ref="preface"/>
          <xs:element ref="chapter.class"/>
          <xs:element ref="reference"/>
          <xs:element ref="part"/>
          <xs:element ref="article.class"/>
          <xs:element ref="appendix.class"/>
          <xs:group ref="index.class"/>
          <xs:element ref="colophon"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="book.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="chapter.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="chapterinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="chapter.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:group name="index.class">
    <xs:choice>
      <xs:element ref="index"/>
      <xs:element ref="setindex"/>
    </xs:choice>
  </xs:group>
  <xs:element name="refentry.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" ref="refentryinfo"/>
        <xs:element minOccurs="0" ref="refmeta"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="remark"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
        <xs:element ref="refnamediv"/>
        <xs:element minOccurs="0" ref="refsynopsisdiv"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="refsect1"/>
          <xs:element maxOccurs="unbounded" ref="refsection"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="section.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sectioninfo"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="section.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="section.class"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="section.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:group name="nav.class">
    <xs:choice>
      <xs:element ref="toc"/>
      <xs:element ref="lot"/>
      <xs:element ref="index"/>
      <xs:element ref="glossary"/>
      <xs:element ref="bibliography"/>
    </xs:choice>
  </xs:group>
  <!-- Redeclaration placeholder ............................................ -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- ...................................................................... -->
  <!-- Entities for element mixtures ........................................ -->
  <!-- The DocBook TC may produce an official forms module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:group name="divcomponent.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refcomponent.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="indexdivcomponent.mix">
    <xs:choice>
      <xs:element ref="itemizedlist"/>
      <xs:element ref="orderedlist"/>
      <xs:element ref="variablelist"/>
      <xs:element ref="simplelist"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="anchor"/>
      <xs:element ref="remark"/>
      <xs:element ref="link.char.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refname.char.mix">
    <xs:sequence>
      <xs:element minOccurs="0" ref="tech.char.class"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="partcontent.mix">
    <xs:choice>
      <xs:element ref="appendix.class"/>
      <xs:element ref="chapter.class"/>
      <xs:group ref="nav.class"/>
      <xs:element ref="article.class"/>
      <xs:element ref="preface"/>
      <xs:element ref="refentry.class"/>
      <xs:element ref="reference"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refinline.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="refclass.char.mix">
    <xs:sequence>
      <xs:element minOccurs="0" ref="application"/>
    </xs:sequence>
  </xs:group>
  <!-- Redeclaration placeholder 2 .......................................... -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- ...................................................................... -->
  <!-- Entities for content models .......................................... -->
  <xs:group name="div.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="bookcomponent.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="sect.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="refsect.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="bookcomponent.content">
    <xs:choice>
      <xs:sequence>
        <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect1"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="section.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="sect1"/>
        <xs:element maxOccurs="unbounded" ref="refentry.class"/>
        <xs:element maxOccurs="unbounded" ref="simplesect"/>
        <xs:element maxOccurs="unbounded" ref="section.class"/>
      </xs:choice>
    </xs:choice>
  </xs:group>
  <!-- ...................................................................... -->
  <!-- Set and SetInfo ...................................................... -->
  <xs:attributeGroup name="set.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="set">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="setinfo"/>
        <xs:element minOccurs="0" ref="toc"/>
        <xs:element maxOccurs="unbounded" ref="book.class"/>
        <xs:element minOccurs="0" ref="setindex"/>
      </xs:sequence>
      <xs:attributeGroup ref="set.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of set.element -->
  <!-- FPI: SGML formal public identifier -->
  <xs:attributeGroup name="set.attlist">
    <xs:attribute name="fpi"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="set.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of set.attlist -->
  <!-- end of set.module -->
  <xs:attributeGroup name="setinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="setinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="setinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setinfo.element -->
  <!--
    Contents: IDs of the ToC, Books, and SetIndex that comprise
    the set, in the order of their appearance
  -->
  <xs:attributeGroup name="setinfo.attlist">
    <xs:attribute name="contents" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="setinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setinfo.attlist -->
  <!-- end of setinfo.module -->
  <!-- end of set.content.module -->
  <!-- ...................................................................... -->
  <!-- Book and BookInfo .................................................... -->
  <xs:attributeGroup name="book.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="book" substitutionGroup="book.class"/>
  <!-- end of book.element -->
  <!-- FPI: SGML formal public identifier -->
  <xs:attributeGroup name="book.attlist">
    <xs:attribute name="fpi"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="book.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of book.attlist -->
  <!-- end of book.module -->
  <xs:attributeGroup name="bookinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bookinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="bookinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bookinfo.element -->
  <!--
    Contents: IDs of the ToC, LoTs, Prefaces, Parts, Chapters,
    Appendixes, References, GLossary, Bibliography, and indexes
    comprising the Book, in the order of their appearance
  -->
  <xs:attributeGroup name="bookinfo.attlist">
    <xs:attribute name="contents" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bookinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bookinfo.attlist -->
  <!-- end of bookinfo.module -->
  <!-- end of book.content.module -->
  <!-- ...................................................................... -->
  <!-- Dedication, ToC, and LoT ............................................. -->
  <xs:attributeGroup name="dedication.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="dedication">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="legalnotice.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="dedication.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of dedication.element -->
  <xs:attributeGroup name="dedication.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="dedication.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of dedication.attlist -->
  <!-- end of dedication.module -->
  <xs:attributeGroup name="colophon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="colophon">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="textobject.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="colophon.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of colophon.element -->
  <xs:attributeGroup name="colophon.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="colophon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of colophon.attlist -->
  <!-- end of colophon.module -->
  <xs:attributeGroup name="toc.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toc">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocfront"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="tocpart"/>
          <xs:element ref="tocchap"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocback"/>
      </xs:sequence>
      <xs:attributeGroup ref="toc.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toc.element -->
  <xs:attributeGroup name="toc.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toc.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toc.attlist -->
  <!-- end of toc.module -->
  <xs:attributeGroup name="tocfront.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocfront">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocfront.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocfront.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocfront.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocfront.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocfront.attlist -->
  <!-- end of tocfront.module -->
  <xs:attributeGroup name="tocentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocentry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocentry.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocentry.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocentry.attlist -->
  <!-- end of tocentry.module -->
  <xs:attributeGroup name="tocpart.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocpart">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocchap"/>
      </xs:sequence>
      <xs:attributeGroup ref="tocpart.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocpart.element -->
  <xs:attributeGroup name="tocpart.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocpart.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocpart.attlist -->
  <!-- end of tocpart.module -->
  <xs:attributeGroup name="tocchap.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocchap">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel1"/>
      </xs:sequence>
      <xs:attributeGroup ref="tocchap.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocchap.element -->
  <xs:attributeGroup name="tocchap.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocchap.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocchap.attlist -->
  <!-- end of tocchap.module -->
  <xs:attributeGroup name="toclevel1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel1">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel2"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel1.element -->
  <xs:attributeGroup name="toclevel1.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel1.attlist -->
  <!-- end of toclevel1.module -->
  <xs:attributeGroup name="toclevel2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel2">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel3"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel2.element -->
  <xs:attributeGroup name="toclevel2.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel2.attlist -->
  <!-- end of toclevel2.module -->
  <xs:attributeGroup name="toclevel3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel3">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel4"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel3.element -->
  <xs:attributeGroup name="toclevel3.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel3.attlist -->
  <!-- end of toclevel3.module -->
  <xs:attributeGroup name="toclevel4.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel4">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel5"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel4.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel4.element -->
  <xs:attributeGroup name="toclevel4.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel4.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel4.attlist -->
  <!-- end of toclevel4.module -->
  <xs:attributeGroup name="toclevel5.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel5">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel5.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel5.element -->
  <xs:attributeGroup name="toclevel5.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel5.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel5.attlist -->
  <!-- end of toclevel5.module -->
  <xs:attributeGroup name="tocback.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocback">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocback.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocback.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocback.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocback.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocback.attlist -->
  <!-- end of tocback.module -->
  <!-- end of toc.content.module -->
  <xs:attributeGroup name="lot.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lot">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="lotentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="lot.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lot.element -->
  <xs:attributeGroup name="lot.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lot.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lot.attlist -->
  <!-- end of lot.module -->
  <xs:attributeGroup name="lotentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lotentry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="lotentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lotentry.element -->
  <!--
    SrcCredit: Information about the source of the entry,
    as for a list of illustrations
  -->
  <!-- linkend: to element that this entry represents -->
  <xs:attributeGroup name="lotentry.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attribute name="srccredit"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lotentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lotentry.attlist -->
  <!-- end of lotentry.module -->
  <!-- end of lot.content.module -->
  <!-- ...................................................................... -->
  <!-- Appendix, Chapter, Part, Preface, Reference, PartIntro ............... -->
  <xs:attributeGroup name="appendix.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="appendix" substitutionGroup="appendix.class"/>
  <!-- end of appendix.element -->
  <xs:attributeGroup name="appendix.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="appendix.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of appendix.attlist -->
  <!-- end of appendix.module -->
  <xs:attributeGroup name="chapter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="chapter" substitutionGroup="chapter.class"/>
  <!-- end of chapter.element -->
  <xs:attributeGroup name="chapter.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="chapter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of chapter.attlist -->
  <!-- end of chapter.module -->
  <!--
    Note that Part was to have its content model reduced in V4.2.  This
    change will not be made after all.
  -->
  <xs:attributeGroup name="part.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="part">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="partinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" ref="partintro"/>
        <xs:group maxOccurs="unbounded" ref="partcontent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="part.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of part.element -->
  <xs:attributeGroup name="part.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="part.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of part.attlist -->
  <!-- ELEMENT PartIntro (defined below) -->
  <!-- end of part.module -->
  <xs:attributeGroup name="preface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="preface">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="prefaceinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="preface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of preface.element -->
  <xs:attributeGroup name="preface.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="preface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of preface.attlist -->
  <!-- end of preface.module -->
  <xs:attributeGroup name="reference.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="reference">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="referenceinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" ref="partintro"/>
        <xs:element maxOccurs="unbounded" ref="refentry.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="reference.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of reference.element -->
  <xs:attributeGroup name="reference.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="reference.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of reference.attlist -->
  <!-- ELEMENT PartIntro (defined below) -->
  <!-- end of reference.module -->
  <xs:attributeGroup name="partintro.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="partintro">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:group ref="bookcomponent.content"/>
      </xs:sequence>
      <xs:attributeGroup ref="partintro.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of partintro.element -->
  <xs:attributeGroup name="partintro.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="partintro.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of partintro.attlist -->
  <!-- end of partintro.module -->
  <!-- ...................................................................... -->
  <!-- Other Info elements .................................................. -->
  <xs:attributeGroup name="appendixinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="appendixinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="appendixinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of appendixinfo.element -->
  <xs:attributeGroup name="appendixinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="appendixinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of appendixinfo.attlist -->
  <!-- end of appendixinfo.module -->
  <xs:attributeGroup name="bibliographyinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliographyinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="bibliographyinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliographyinfo.element -->
  <xs:attributeGroup name="bibliographyinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliographyinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliographyinfo.attlist -->
  <!-- end of bibliographyinfo.module -->
  <xs:attributeGroup name="chapterinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="chapterinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="chapterinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of chapterinfo.element -->
  <xs:attributeGroup name="chapterinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="chapterinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of chapterinfo.attlist -->
  <!-- end of chapterinfo.module -->
  <xs:attributeGroup name="glossaryinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossaryinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="glossaryinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossaryinfo.element -->
  <xs:attributeGroup name="glossaryinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossaryinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossaryinfo.attlist -->
  <!-- end of glossaryinfo.module -->
  <xs:attributeGroup name="indexinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="indexinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexinfo.element -->
  <xs:attributeGroup name="indexinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexinfo.attlist -->
  <!-- end of indexinfo.module -->
  <xs:attributeGroup name="setindexinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="setindexinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="setindexinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setindexinfo.element -->
  <xs:attributeGroup name="setindexinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="setindexinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setindexinfo.attlist -->
  <!-- end of setindexinfo.module -->
  <xs:attributeGroup name="partinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="partinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="partinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of partinfo.element -->
  <xs:attributeGroup name="partinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="partinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of partinfo.attlist -->
  <!-- end of partinfo.module -->
  <xs:attributeGroup name="prefaceinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="prefaceinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="prefaceinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of prefaceinfo.element -->
  <xs:attributeGroup name="prefaceinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="prefaceinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of prefaceinfo.attlist -->
  <!-- end of prefaceinfo.module -->
  <xs:attributeGroup name="refentryinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refentryinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refentryinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refentryinfo.element -->
  <xs:attributeGroup name="refentryinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentryinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentryinfo.attlist -->
  <!-- end of refentryinfo.module -->
  <xs:attributeGroup name="refsectioninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsectioninfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsectioninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsectioninfo.element -->
  <xs:attributeGroup name="refsectioninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsectioninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsectioninfo.attlist -->
  <!-- end of refsectioninfo.module -->
  <xs:attributeGroup name="refsect1info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect1info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect1info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect1info.element -->
  <xs:attributeGroup name="refsect1info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect1info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect1info.attlist -->
  <!-- end of refsect1info.module -->
  <xs:attributeGroup name="refsect2info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect2info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect2info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect2info.element -->
  <xs:attributeGroup name="refsect2info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect2info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect2info.attlist -->
  <!-- end of refsect2info.module -->
  <xs:attributeGroup name="refsect3info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect3info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect3info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect3info.element -->
  <xs:attributeGroup name="refsect3info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect3info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect3info.attlist -->
  <!-- end of refsect3info.module -->
  <xs:attributeGroup name="refsynopsisdivinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsynopsisdivinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsynopsisdivinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsynopsisdivinfo.element -->
  <xs:attributeGroup name="refsynopsisdivinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsynopsisdivinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsynopsisdivinfo.attlist -->
  <!-- end of refsynopsisdivinfo.module -->
  <xs:attributeGroup name="referenceinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="referenceinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="referenceinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of referenceinfo.element -->
  <xs:attributeGroup name="referenceinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="referenceinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of referenceinfo.attlist -->
  <!-- end of referenceinfo.module -->
  <xs:attributeGroup name="sect1info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect1info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect1info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect1info.element -->
  <xs:attributeGroup name="sect1info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect1info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect1info.attlist -->
  <xs:attributeGroup name="sect2info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect2info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect2info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect2info.element -->
  <xs:attributeGroup name="sect2info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect2info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect2info.attlist -->
  <xs:attributeGroup name="sect3info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect3info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect3info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect3info.element -->
  <xs:attributeGroup name="sect3info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect3info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect3info.attlist -->
  <xs:attributeGroup name="sect4info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect4info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect4info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect4info.element -->
  <xs:attributeGroup name="sect4info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect4info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect4info.attlist -->
  <xs:attributeGroup name="sect5info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect5info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect5info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect5info.element -->
  <xs:attributeGroup name="sect5info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect5info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect5info.attlist -->
  <!-- ...................................................................... -->
  <!-- Section (parallel to Sect*) ......................................... -->
  <xs:attributeGroup name="section.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="section" substitutionGroup="section.class"/>
  <!-- end of section.element -->
  <xs:attributeGroup name="section.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="section.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of section.attlist -->
  <!-- end of section.module -->
  <xs:attributeGroup name="sectioninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sectioninfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sectioninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sectioninfo.element -->
  <xs:attributeGroup name="sectioninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sectioninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sectioninfo.attlist -->
  <!-- end of sectioninfo.module -->
  <!-- end of section.content.module -->
  <!-- ...................................................................... -->
  <!-- Sect1, Sect2, Sect3, Sect4, Sect5 .................................... -->
  <xs:attributeGroup name="sect1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect1">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect1info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect2"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect2"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect1.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect1.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect1.attlist -->
  <!-- end of sect1.module -->
  <xs:attributeGroup name="sect2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect2">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect2info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect3"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect3"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect2.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect2.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect2.attlist -->
  <!-- end of sect2.module -->
  <xs:attributeGroup name="sect3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect3">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect3info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect4"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect4"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect3.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect3.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect3.attlist -->
  <!-- end of sect3.module -->
  <xs:attributeGroup name="sect4.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect4">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect4info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect5"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect5"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect4.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect4.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect4.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect4.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect4.attlist -->
  <!-- end of sect4.module -->
  <xs:attributeGroup name="sect5.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect5">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect5info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect5.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect5.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect5.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect5.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect5.attlist -->
  <!-- end of sect5.module -->
  <xs:attributeGroup name="simplesect.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simplesect">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplesect.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplesect.element -->
  <xs:attributeGroup name="simplesect.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplesect.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplesect.attlist -->
  <!-- end of simplesect.module -->
  <!-- ...................................................................... -->
  <!-- Bibliography ......................................................... -->
  <xs:attributeGroup name="bibliography.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliography">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="bibliographyinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="bibliodiv"/>
          <xs:choice maxOccurs="unbounded">
            <xs:element ref="biblioentry"/>
            <xs:element ref="bibliomixed"/>
          </xs:choice>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="bibliography.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliography.element -->
  <xs:attributeGroup name="bibliography.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliography.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliography.attlist -->
  <!-- end of bibliography.module -->
  <xs:attributeGroup name="bibliodiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliodiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="biblioentry"/>
          <xs:element ref="bibliomixed"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="bibliodiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliodiv.element -->
  <xs:attributeGroup name="bibliodiv.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliodiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliodiv.attlist -->
  <!-- end of bibliodiv.module -->
  <!-- end of bibliography.content.module -->
  <!-- ...................................................................... -->
  <!-- Glossary ............................................................. -->
  <xs:attributeGroup name="glossary.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossary">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="glossaryinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="glossdiv"/>
          <xs:element maxOccurs="unbounded" ref="glossentry"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="bibliography"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossary.element -->
  <xs:attributeGroup name="glossary.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossary.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossary.attlist -->
  <!-- end of glossary.module -->
  <xs:attributeGroup name="glossdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:element maxOccurs="unbounded" ref="glossentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossdiv.element -->
  <xs:attributeGroup name="glossdiv.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossdiv.attlist -->
  <!-- end of glossdiv.module -->
  <!-- end of glossary.content.module -->
  <!-- ...................................................................... -->
  <!-- Index and SetIndex ................................................... -->
  <xs:attributeGroup name="indexes.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="index">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="indexinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexdiv"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="index.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of index.element -->
  <xs:attributeGroup name="index.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexes.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of index.attlist -->
  <xs:element name="setindex">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="setindexinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexdiv"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="setindex.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setindex.element -->
  <xs:attributeGroup name="setindex.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexes.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setindex.attlist -->
  <!-- end of indexes.module -->
  <!--
    SegmentedList in this content is useful for marking up permuted
    indices.
  -->
  <xs:attributeGroup name="indexdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:sequence>
          <xs:group minOccurs="0" maxOccurs="unbounded" ref="indexdivcomponent.mix"/>
          <xs:choice>
            <xs:element maxOccurs="unbounded" ref="indexentry"/>
            <xs:element ref="segmentedlist"/>
          </xs:choice>
        </xs:sequence>
      </xs:sequence>
      <xs:attributeGroup ref="indexdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexdiv.element -->
  <xs:attributeGroup name="indexdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexdiv.attlist -->
  <!-- end of indexdiv.module -->
  <!-- Index entries appear in the index, not the text. -->
  <xs:attributeGroup name="indexentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="primaryie"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="seeie"/>
          <xs:element ref="seealsoie"/>
        </xs:choice>
        <xs:sequence minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="secondaryie"/>
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="seeie"/>
            <xs:element ref="seealsoie"/>
            <xs:element ref="tertiaryie"/>
          </xs:choice>
        </xs:sequence>
      </xs:sequence>
      <xs:attributeGroup ref="indexentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexentry.element -->
  <xs:attributeGroup name="indexentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexentry.attlist -->
  <!-- end of indexentry.module -->
  <xs:attributeGroup name="primsecterie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="primaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="primaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of primaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="primaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of primaryie.attlist -->
  <xs:element name="secondaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="secondaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of secondaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="secondaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of secondaryie.attlist -->
  <xs:element name="tertiaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="tertiaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tertiaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="tertiaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tertiaryie.attlist -->
  <!-- end of primsecterie.module -->
  <xs:attributeGroup name="seeie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seeie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seeie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seeie.element -->
  <!-- to IndexEntry to look up -->
  <xs:attributeGroup name="seeie.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seeie.attlist -->
  <!-- end of seeie.module -->
  <xs:attributeGroup name="seealsoie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seealsoie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seealsoie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seealsoie.element -->
  <!-- to related IndexEntries -->
  <xs:attributeGroup name="seealsoie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seealsoie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seealsoie.attlist -->
  <!-- end of seealsoie.module -->
  <!-- end of index.content.module -->
  <!-- ...................................................................... -->
  <!-- RefEntry ............................................................. -->
  <xs:attributeGroup name="refentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refentry" substitutionGroup="refentry.class"/>
  <!-- end of refentry.element -->
  <xs:attributeGroup name="refentry.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentry.attlist -->
  <!-- end of refentry.module -->
  <xs:attributeGroup name="refmeta.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refmeta">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element ref="refentrytitle"/>
        <xs:element minOccurs="0" ref="manvolnum"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="refmiscinfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="refmeta.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refmeta.element -->
  <xs:attributeGroup name="refmeta.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refmeta.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refmeta.attlist -->
  <!-- end of refmeta.module -->
  <xs:attributeGroup name="refmiscinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refmiscinfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="refmiscinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refmiscinfo.element -->
  <!-- Class: Freely assignable parameter; no default -->
  <xs:attributeGroup name="refmiscinfo.attlist">
    <xs:attribute name="class"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refmiscinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refmiscinfo.attlist -->
  <!-- end of refmiscinfo.module -->
  <xs:attributeGroup name="refnamediv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refnamediv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refdescriptor"/>
        <xs:element maxOccurs="unbounded" ref="refname"/>
        <xs:element ref="refpurpose"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="refclass"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="remark"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refnamediv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refnamediv.element -->
  <xs:attributeGroup name="refnamediv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refnamediv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refnamediv.attlist -->
  <!-- end of refnamediv.module -->
  <xs:attributeGroup name="refdescriptor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refdescriptor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refname.char.mix"/>
      <xs:attributeGroup ref="refdescriptor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refdescriptor.element -->
  <xs:attributeGroup name="refdescriptor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refdescriptor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refdescriptor.attlist -->
  <!-- end of refdescriptor.module -->
  <xs:attributeGroup name="refname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refname.char.mix"/>
      <xs:attributeGroup ref="refname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refname.element -->
  <xs:attributeGroup name="refname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refname.attlist -->
  <!-- end of refname.module -->
  <xs:attributeGroup name="refpurpose.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refpurpose">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refinline.char.mix"/>
      <xs:attributeGroup ref="refpurpose.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refpurpose.element -->
  <xs:attributeGroup name="refpurpose.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refpurpose.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refpurpose.attlist -->
  <!-- end of refpurpose.module -->
  <xs:attributeGroup name="refclass.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refclass">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refclass.char.mix"/>
      <xs:attributeGroup ref="refclass.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refclass.element -->
  <xs:attributeGroup name="refclass.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refclass.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refclass.attlist -->
  <!-- end of refclass.module -->
  <xs:attributeGroup name="refsynopsisdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsynopsisdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsynopsisdivinfo"/>
        <xs:group minOccurs="0" ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect2"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect2"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsynopsisdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsynopsisdiv.element -->
  <xs:attributeGroup name="refsynopsisdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsynopsisdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsynopsisdiv.attlist -->
  <!-- end of refsynopsisdiv.module -->
  <xs:attributeGroup name="refsection.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsection">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsectioninfo"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsection"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsection"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsection.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsection.element -->
  <xs:attributeGroup name="refsection.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsection.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsection.attlist -->
  <!-- end of refsection.module -->
  <xs:attributeGroup name="refsect1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect1">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect1info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect2"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect2"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsect1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect1.element -->
  <xs:attributeGroup name="refsect1.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect1.attlist -->
  <!-- end of refsect1.module -->
  <xs:attributeGroup name="refsect2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect2">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect2info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect3"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect3"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsect2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect2.element -->
  <xs:attributeGroup name="refsect2.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect2.attlist -->
  <!-- end of refsect2.module -->
  <xs:attributeGroup name="refsect3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect3">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect3info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="refsect3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect3.element -->
  <xs:attributeGroup name="refsect3.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect3.attlist -->
  <!-- end of refsect3.module -->
  <!-- end of refentry.content.module -->
  <!-- ...................................................................... -->
  <!-- Article .............................................................. -->
  <!--
    An Article is a chapter-level, stand-alone document that is often,
    but need not be, collected into a Book.
  -->
  <xs:attributeGroup name="article.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="article" substitutionGroup="article.class"/>
  <!-- end of article.element -->
  <!--
    Class: Indicates the type of a particular article;
    all articles have the same structure and general purpose.
    No default.
  -->
  <!-- ParentBook: ID of the enclosing Book -->
  <xs:attributeGroup name="article.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="journalarticle"/>
          <xs:enumeration value="productsheet"/>
          <xs:enumeration value="whitepaper"/>
          <xs:enumeration value="techreport"/>
          <xs:enumeration value="specification"/>
          <xs:enumeration value="faq"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="parentbook" type="xs:IDREF"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="article.role.attrib"/>
  </xs:attributeGroup>
</xs:schema>
<!-- end of article.attlist -->
<!-- end of article.module -->
<!-- End of DocBook document hierarchy module V4.2 ........................ -->
<!-- ...................................................................... -->
 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 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook XML information pool module V4.2 ............................. -->
<!-- File dbpoolx.mod ..................................................... -->
<!--
  Copyright 1992-2002 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: dbpoolx.mod,v 1.46 2002/07/17 15:26:16 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook XML DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook XML DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the objects, inline
  elements, and so on that are available to be used as the main
  content of DocBook documents.  Some elements are useful for general
  publishing, and others are useful specifically for computer
  documentation.
  
  This module has the following dependencies on other modules:
  
  o It assumes that a %notation.class; entity is defined by the
    driver file or other high-level module.  This entity is
    referenced in the NOTATION attributes for the graphic-related and
    ModeSpec elements.
  
  o It assumes that an appropriately parameterized table module is
    available for use with the table-related elements.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % dbpool PUBLIC
  "-//OASIS//ELEMENTS DocBook XML Information Pool V4.2//EN"
  "dbpoolx.mod">
  %dbpool;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ...................................................................... -->
<!-- General-purpose semantics entities ................................... -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:include schemaLocation="calstblx.xsd"/>
  <xs:simpleType name="yesorno.attvals">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <!-- ...................................................................... -->
  <!-- Entities for module inclusions ....................................... -->
  <!-- ...................................................................... -->
  <!-- Entities for element classes and mixtures ............................ -->
  <!-- "Ubiquitous" classes: ndxterm.class and beginpage -->
  <xs:element name="ndxterm.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="primary"/>
        <xs:choice minOccurs="0">
          <xs:sequence>
            <xs:element ref="secondary"/>
            <xs:choice minOccurs="0">
              <xs:sequence>
                <xs:element ref="tertiary"/>
                <xs:choice minOccurs="0">
                  <xs:element ref="see"/>
                  <xs:element maxOccurs="unbounded" ref="seealso"/>
                </xs:choice>
              </xs:sequence>
              <xs:element ref="see"/>
              <xs:element maxOccurs="unbounded" ref="seealso"/>
            </xs:choice>
          </xs:sequence>
          <xs:element ref="see"/>
          <xs:element maxOccurs="unbounded" ref="seealso"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="indexterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- Object-level classes ................................................. -->
  <xs:element name="list.class" abstract="true"/>
  <xs:element name="admon.class" abstract="true"/>
  <xs:element name="linespecific.class" abstract="true"/>
  <xs:element name="method.synop.class" abstract="true" substitutionGroup="synop.class"/>
  <xs:element name="synop.class" abstract="true"/>
  <xs:element name="para.class" abstract="true"/>
  <xs:element name="informal.class" abstract="true"/>
  <xs:element name="formal.class" abstract="true"/>
  <!-- The DocBook TC may produce an official EBNF module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:element name="compound.class" abstract="true"/>
  <xs:group name="genobj.class">
    <xs:choice>
      <xs:element ref="anchor"/>
      <xs:element ref="bridgehead"/>
      <xs:element ref="remark"/>
      <xs:element ref="highlights"/>
    </xs:choice>
  </xs:group>
  <xs:group name="descobj.class">
    <xs:choice>
      <xs:element ref="abstract"/>
      <xs:element ref="authorblurb"/>
      <xs:element ref="epigraph"/>
    </xs:choice>
  </xs:group>
  <!-- Character-level classes .............................................. -->
  <xs:element name="xref.char.class" abstract="true"/>
  <xs:element name="gen.char.class" abstract="true"/>
  <xs:element name="link.char.class" abstract="true"/>
  <!-- The DocBook TC may produce an official EBNF module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:element name="tech.char.class" abstract="true"/>
  <xs:group name="base.char.class">
    <xs:sequence>
      <xs:element ref="anchor"/>
    </xs:sequence>
  </xs:group>
  <xs:element name="docinfo.char.class" abstract="true"/>
  <xs:group name="other.char.class">
    <xs:choice>
      <xs:element ref="remark"/>
      <xs:element ref="subscript"/>
      <xs:element ref="superscript"/>
    </xs:choice>
  </xs:group>
  <xs:element name="inlineobj.char.class" abstract="true"/>
  <!-- ...................................................................... -->
  <!-- Entities for content models .......................................... -->
  <xs:group name="formalobject.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <!-- Redeclaration placeholder ............................................ -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- Object-level mixtures ................................................ -->
  <!--
                          list admn line synp para infm form cmpd gen  desc
    Component mixture       X    X    X    X    X    X    X    X    X    X
    Sidebar mixture         X    X    X    X    X    X    X    a    X
    Footnote mixture        X         X    X    X    X
    Example mixture         X         X    X    X    X
    Highlights mixture      X    X              X
    Paragraph mixture       X         X    X         X
    Admonition mixture      X         X    X    X    X    X    b    c
    Figure mixture                    X    X         X
    Table entry mixture     X    X    X         X    d
    Glossary def mixture    X         X    X    X    X         e
    Legal notice mixture    X    X    X         X    f
    
    a. Just Procedure; not Sidebar itself or MsgSet.
    b. No MsgSet.
    c. No Highlights.
    d. Just Graphic; no other informal objects.
    e. No Anchor, BridgeHead, or Highlights.
    f. Just BlockQuote; no other informal objects.
  -->
  <xs:group name="component.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="sidebar.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="qandaset.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="revdescription.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="footnote.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="example.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="highlights.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <!--
    %formal.class; is explicitly excluded from many contexts in which
    paragraphs are used
  -->
  <xs:group name="para.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="admon.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:element ref="sidebar"/>
      <xs:element ref="anchor"/>
      <xs:element ref="bridgehead"/>
      <xs:element ref="remark"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="figure.mix">
    <xs:choice>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="tabentry.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="graphic"/>
      <xs:element ref="mediaobject"/>
    </xs:choice>
  </xs:group>
  <xs:group name="glossdef.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="remark"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="legalnotice.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="blockquote"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="textobject.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="blockquote"/>
    </xs:choice>
  </xs:group>
  <xs:element name="mediaobject.mix" abstract="true"/>
  <xs:group name="listpreamble.mix">
    <xs:choice>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <!-- Character-level mixtures ............................................. -->
  <!-- sgml.features -->
  <!-- not [sgml.features[ -->
  <!-- ]] not sgml.features -->
  <!--
                        #PCD xref word link cptr base dnfo othr inob (synop)
    para.char.mix         X    X    X    X    X    X    X    X    X
    title.char.mix        X    X    X    X    X    X    X    X    X
    ndxterm.char.mix      X    X    X    X    X    X    X    X    a
    cptr.char.mix         X              X    X    X         X    a
    smallcptr.char.mix    X                   b                   a
    word.char.mix         X         c    X         X         X    a
    docinfo.char.mix      X         d    X    b              X    a
    
    a. Just InlineGraphic; no InlineEquation.
    b. Just Replaceable; no other computer terms.
    c. Just Emphasis and Trademark; no other word elements.
    d. Just Acronym, Emphasis, and Trademark; no other word elements.
  -->
  <!-- The DocBook TC may produce an official forms module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:group name="para.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlineobj.char.class"/>
        <xs:element ref="synop.class"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="title.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlineobj.char.class"/>
        <xs:element ref="ndxterm.class"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="ndxterm.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="cptr.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="smallcptr.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="replaceable"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="word.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="acronym"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="trademark"/>
        <xs:element ref="link.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="docinfo.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="trademark"/>
        <xs:element ref="replaceable"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <!-- ENTITY % bibliocomponent.mix (see Bibliographic section, below) -->
  <!-- ENTITY % person.ident.mix (see Bibliographic section, below) -->
  <!-- ...................................................................... -->
  <!-- Entities for attributes and attribute components ..................... -->
  <!-- Effectivity attributes ............................................... -->
  <!--
    Arch: Computer or chip architecture to which element applies; no
    default
  -->
  <xs:attributeGroup name="arch.attrib">
    <xs:attribute name="arch"/>
  </xs:attributeGroup>
  <!-- Condition: General-purpose effectivity attribute -->
  <xs:attributeGroup name="condition.attrib">
    <xs:attribute name="condition"/>
  </xs:attributeGroup>
  <!-- Conformance: Standards conformance characteristics -->
  <xs:attributeGroup name="conformance.attrib">
    <xs:attribute name="conformance" type="xs:NMTOKENS"/>
  </xs:attributeGroup>
  <!-- OS: Operating system to which element applies; no default -->
  <xs:attributeGroup name="os.attrib">
    <xs:attribute name="os"/>
  </xs:attributeGroup>
  <!-- Revision: Editorial revision to which element belongs; no default -->
  <xs:attributeGroup name="revision.attrib">
    <xs:attribute name="revision"/>
  </xs:attributeGroup>
  <!-- Security: Security classification; no default -->
  <xs:attributeGroup name="security.attrib">
    <xs:attribute name="security"/>
  </xs:attributeGroup>
  <!--
    UserLevel: Level of user experience to which element applies; no
    default
  -->
  <xs:attributeGroup name="userlevel.attrib">
    <xs:attribute name="userlevel"/>
  </xs:attributeGroup>
  <!-- Vendor: Computer vendor to which element applies; no default -->
  <xs:attributeGroup name="vendor.attrib">
    <xs:attribute name="vendor"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="effectivity.attrib">
    <xs:attributeGroup ref="arch.attrib"/>
    <xs:attributeGroup ref="condition.attrib"/>
    <xs:attributeGroup ref="conformance.attrib"/>
    <xs:attributeGroup ref="os.attrib"/>
    <xs:attributeGroup ref="revision.attrib"/>
    <xs:attributeGroup ref="security.attrib"/>
    <xs:attributeGroup ref="userlevel.attrib"/>
    <xs:attributeGroup ref="vendor.attrib"/>
  </xs:attributeGroup>
  <!-- Common attributes .................................................... -->
  <!-- Id: Unique identifier of element; no default -->
  <xs:attributeGroup name="id.attrib">
    <xs:attribute name="id" type="xs:ID"/>
  </xs:attributeGroup>
  <!--
    Id: Unique identifier of element; a value must be supplied; no
    default
  -->
  <xs:attributeGroup name="idreq.attrib">
    <xs:attribute name="id" use="required" type="xs:ID"/>
  </xs:attributeGroup>
  <!--
    Lang: Indicator of language in which element is written, for
    translation, character set management, etc.; no default
  -->
  <xs:attributeGroup name="lang.attrib">
    <xs:attribute name="lang"/>
  </xs:attributeGroup>
  <!-- Remap: Previous role of element before conversion; no default -->
  <xs:attributeGroup name="remap.attrib">
    <xs:attribute name="remap"/>
  </xs:attributeGroup>
  <!-- Role: New role of element in local environment; no default -->
  <xs:attributeGroup name="role.attrib">
    <xs:attribute name="role"/>
  </xs:attributeGroup>
  <!--
    XRefLabel: Alternate labeling string for XRef text generation;
    default is usually title or other appropriate label text already
    contained in element
  -->
  <xs:attributeGroup name="xreflabel.attrib">
    <xs:attribute name="xreflabel"/>
  </xs:attributeGroup>
  <!--
    RevisionFlag: Revision status of element; default is that element
    wasn't revised
  -->
  <xs:attributeGroup name="revisionflag.attrib">
    <xs:attribute name="revisionflag">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="changed"/>
          <xs:enumeration value="added"/>
          <xs:enumeration value="deleted"/>
          <xs:enumeration value="off"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- Role is included explicitly on each element -->
  <xs:attributeGroup name="common.attrib">
    <xs:attributeGroup ref="id.attrib"/>
    <xs:attributeGroup ref="lang.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
  </xs:attributeGroup>
  <!-- Role is included explicitly on each element -->
  <xs:attributeGroup name="idreq.common.attrib">
    <xs:attributeGroup ref="idreq.attrib"/>
    <xs:attributeGroup ref="lang.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
  </xs:attributeGroup>
  <!-- Semi-common attributes and other attribute entities .................. -->
  <!--
    EntityRef: Name of an external entity containing the content
    of the graphic
  -->
  <!--
    FileRef: Filename, qualified by a pathname if desired,
    designating the file containing the content of the graphic
  -->
  <!-- Format: Notation of the element content, if any -->
  <!-- SrcCredit: Information about the source of the Graphic -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="graphics.attrib">
    <xs:attribute name="entityref" type="xs:ENTITY"/>
    <xs:attribute name="fileref"/>
    <xs:attribute name="format" type="notation.class"/>
    <xs:attribute name="srccredit"/>
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
  </xs:attributeGroup>
  <!--
    Action: Key combination type; default is unspecified if one
    child element, Simul if there is more than one; if value is
    Other, the OtherAction attribute must have a nonempty value
  -->
  <!-- OtherAction: User-defined key combination type -->
  <xs:attributeGroup name="keyaction.attrib">
    <xs:attribute name="action">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="click"/>
          <xs:enumeration value="double-click"/>
          <xs:enumeration value="press"/>
          <xs:enumeration value="seq"/>
          <xs:enumeration value="simul"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otheraction"/>
  </xs:attributeGroup>
  <!--
    Label: Identifying number or string; default is usually the
    appropriate number or string autogenerated by a formatter
  -->
  <xs:attributeGroup name="label.attrib">
    <xs:attribute name="label"/>
  </xs:attributeGroup>
  <!--
    Format: whether element is assumed to contain significant white
    space
  -->
  <xs:attributeGroup name="linespecific.attrib">
    <xs:attribute name="format" default="linespecific">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="linespecific"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="linenumbering">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="numbered"/>
          <xs:enumeration value="unnumbered"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- Linkend: link to related information; no default -->
  <xs:attributeGroup name="linkend.attrib">
    <xs:attribute name="linkend" type="xs:IDREF"/>
  </xs:attributeGroup>
  <!-- Linkend: required link to related information -->
  <xs:attributeGroup name="linkendreq.attrib">
    <xs:attribute name="linkend" use="required" type="xs:IDREF"/>
  </xs:attributeGroup>
  <!--
    Linkends: link to one or more sets of related information; no
    default
  -->
  <xs:attributeGroup name="linkends.attrib">
    <xs:attribute name="linkends" type="xs:IDREFS"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="mark.attrib">
    <xs:attribute name="mark"/>
  </xs:attributeGroup>
  <!-- MoreInfo: whether element's content has an associated RefEntry -->
  <xs:attributeGroup name="moreinfo.attrib">
    <xs:attribute name="moreinfo" default="none">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="refentry"/>
          <xs:enumeration value="none"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- Pagenum: number of page on which element appears; no default -->
  <xs:attributeGroup name="pagenum.attrib">
    <xs:attribute name="pagenum"/>
  </xs:attributeGroup>
  <!--
    Status: Editorial or publication status of the element
    it applies to, such as "in review" or "approved for distribution"
  -->
  <xs:attributeGroup name="status.attrib">
    <xs:attribute name="status"/>
  </xs:attributeGroup>
  <!--
    Width: width of the longest line in the element to which it
    pertains, in number of characters
  -->
  <xs:attributeGroup name="width.attrib">
    <xs:attribute name="width"/>
  </xs:attributeGroup>
  <!-- ...................................................................... -->
  <!-- Title elements ....................................................... -->
  <xs:attributeGroup name="title.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="title">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="title.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of title.element -->
  <xs:attributeGroup name="title.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="title.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of title.attlist -->
  <!-- end of title.module -->
  <xs:attributeGroup name="titleabbrev.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="titleabbrev">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="titleabbrev.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of titleabbrev.element -->
  <xs:attributeGroup name="titleabbrev.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="titleabbrev.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of titleabbrev.attlist -->
  <!-- end of titleabbrev.module -->
  <xs:attributeGroup name="subtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="subtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subtitle.element -->
  <xs:attributeGroup name="subtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subtitle.attlist -->
  <!-- end of subtitle.module -->
  <!-- ...................................................................... -->
  <!-- Bibliographic entities and elements .................................. -->
  <!--
    The bibliographic elements are typically used in the document
    hierarchy. They do not appear in content models of information
    pool elements.  See also the document information elements,
    below.
  -->
  <xs:group name="person.ident.mix">
    <xs:choice>
      <xs:element ref="honorific"/>
      <xs:element ref="firstname"/>
      <xs:element ref="surname"/>
      <xs:element ref="lineage"/>
      <xs:element ref="othername"/>
      <xs:element ref="affiliation"/>
      <xs:element ref="authorblurb"/>
      <xs:element ref="contrib"/>
    </xs:choice>
  </xs:group>
  <xs:group name="bibliocomponent.mix">
    <xs:choice>
      <xs:element ref="abbrev"/>
      <xs:element ref="abstract"/>
      <xs:element ref="address"/>
      <xs:element ref="artpagenums"/>
      <xs:element ref="author"/>
      <xs:element ref="authorgroup"/>
      <xs:element ref="authorinitials"/>
      <xs:element ref="bibliomisc"/>
      <xs:element ref="biblioset"/>
      <xs:element ref="collab"/>
      <xs:element ref="confgroup"/>
      <xs:element ref="contractnum"/>
      <xs:element ref="contractsponsor"/>
      <xs:element ref="copyright"/>
      <xs:element ref="corpauthor"/>
      <xs:element ref="corpname"/>
      <xs:element ref="date"/>
      <xs:element ref="edition"/>
      <xs:element ref="editor"/>
      <xs:element ref="invpartnumber"/>
      <xs:element ref="isbn"/>
      <xs:element ref="issn"/>
      <xs:element ref="issuenum"/>
      <xs:element ref="orgname"/>
      <xs:element ref="biblioid"/>
      <xs:element ref="citebiblioid"/>
      <xs:element ref="bibliosource"/>
      <xs:element ref="bibliorelation"/>
      <xs:element ref="bibliocoverage"/>
      <xs:element ref="othercredit"/>
      <xs:element ref="pagenums"/>
      <xs:element ref="printhistory"/>
      <xs:element ref="productname"/>
      <xs:element ref="productnumber"/>
      <xs:element ref="pubdate"/>
      <xs:element ref="publisher"/>
      <xs:element ref="publishername"/>
      <xs:element ref="pubsnumber"/>
      <xs:element ref="releaseinfo"/>
      <xs:element ref="revhistory"/>
      <xs:element ref="seriesvolnums"/>
      <xs:element ref="subtitle"/>
      <xs:element ref="title"/>
      <xs:element ref="titleabbrev"/>
      <xs:element ref="volumenum"/>
      <xs:element ref="citetitle"/>
      <xs:element ref="personname"/>
      <xs:group ref="person.ident.mix"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <!-- I don't think this is well placed, but it needs to be here because of -->
  <!-- the reference to bibliocomponent.mix -->
  <xs:group name="info.class">
    <xs:choice>
      <xs:element ref="graphic"/>
      <xs:element ref="mediaobject"/>
      <xs:element ref="legalnotice"/>
      <xs:element ref="modespec"/>
      <xs:element ref="subjectset"/>
      <xs:element ref="keywordset"/>
      <xs:element ref="itermset"/>
      <xs:group ref="bibliocomponent.mix"/>
    </xs:choice>
  </xs:group>
  <xs:attributeGroup name="biblioentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="biblioentry">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="articleinfo"/>
        <xs:group ref="bibliocomponent.mix"/>
      </xs:choice>
      <xs:attributeGroup ref="biblioentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioentry.element -->
  <xs:attributeGroup name="biblioentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioentry.attlist -->
  <!-- end of biblioentry.module -->
  <xs:attributeGroup name="bibliomixed.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliomixed">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="bibliocomponent.mix"/>
        <xs:element ref="bibliomset"/>
      </xs:choice>
      <xs:attributeGroup ref="bibliomixed.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomixed.element -->
  <xs:attributeGroup name="bibliomixed.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomixed.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomixed.attlist -->
  <!-- end of bibliomixed.module -->
  <xs:attributeGroup name="articleinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="articleinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="articleinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of articleinfo.element -->
  <xs:attributeGroup name="articleinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="articleinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of articleinfo.attlist -->
  <!-- end of articleinfo.module -->
  <xs:attributeGroup name="biblioset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="biblioset">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="bibliocomponent.mix"/>
      <xs:attributeGroup ref="biblioset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioset.element -->
  <!-- Relation: Relationship of elements contained within BiblioSet -->
  <xs:attributeGroup name="biblioset.attlist">
    <xs:attribute name="relation"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioset.attlist -->
  <!-- end of biblioset.module -->
  <xs:attributeGroup name="bibliomset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliomset">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="bibliocomponent.mix"/>
        <xs:element ref="bibliomset"/>
      </xs:choice>
      <xs:attributeGroup ref="bibliomset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomset.element -->
  <!-- Relation: Relationship of elements contained within BiblioMSet -->
  <xs:attributeGroup name="bibliomset.attlist">
    <xs:attribute name="relation"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomset.attlist -->
  <!-- end of bibliomset.module -->
  <xs:attributeGroup name="bibliomisc.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliomisc">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="bibliomisc.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomisc.element -->
  <xs:attributeGroup name="bibliomisc.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomisc.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomisc.attlist -->
  <!-- end of bibliomisc.module -->
  <!-- ...................................................................... -->
  <!-- Subject, Keyword, and ITermSet elements .............................. -->
  <xs:attributeGroup name="subjectset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subjectset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="subject"/>
      </xs:sequence>
      <xs:attributeGroup ref="subjectset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subjectset.element -->
  <!-- Scheme: Controlled vocabulary employed in SubjectTerms -->
  <xs:attributeGroup name="subjectset.attlist">
    <xs:attribute name="scheme" type="xs:NMTOKEN"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subjectset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subjectset.attlist -->
  <!-- end of subjectset.module -->
  <xs:attributeGroup name="subject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subject">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="subjectterm"/>
      </xs:sequence>
      <xs:attributeGroup ref="subject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subject.element -->
  <!--
    Weight: Ranking of this group of SubjectTerms relative
    to others, 0 is low, no highest value specified
  -->
  <xs:attributeGroup name="subject.attlist">
    <xs:attribute name="weight"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subject.attlist -->
  <!-- end of subject.module -->
  <xs:attributeGroup name="subjectterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subjectterm">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="subjectterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subjectterm.element -->
  <xs:attributeGroup name="subjectterm.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subjectterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subjectterm.attlist -->
  <!-- end of subjectterm.module -->
  <!-- end of subjectset.content.module -->
  <xs:attributeGroup name="keywordset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keywordset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="keyword"/>
      </xs:sequence>
      <xs:attributeGroup ref="keywordset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keywordset.element -->
  <xs:attributeGroup name="keywordset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keywordset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keywordset.attlist -->
  <!-- end of keywordset.module -->
  <xs:attributeGroup name="keyword.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keyword">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="keyword.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keyword.element -->
  <xs:attributeGroup name="keyword.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keyword.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keyword.attlist -->
  <!-- end of keyword.module -->
  <!-- end of keywordset.content.module -->
  <xs:attributeGroup name="itermset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="itermset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="indexterm"/>
      </xs:sequence>
      <xs:attributeGroup ref="itermset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of itermset.element -->
  <xs:attributeGroup name="itermset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="itermset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of itermset.attlist -->
  <!-- end of itermset.module -->
  <!-- Bibliographic info for "blocks" -->
  <xs:attributeGroup name="blockinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="blockinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="blockinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of blockinfo.element -->
  <xs:attributeGroup name="blockinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="blockinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of blockinfo.attlist -->
  <!-- end of blockinfo.module -->
  <!-- ...................................................................... -->
  <!-- Compound (section-ish) elements ...................................... -->
  <!-- Message set ...................... -->
  <xs:attributeGroup name="msgset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgset" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="msgentry"/>
          <xs:element maxOccurs="unbounded" ref="simplemsgentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="msgset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgset.element -->
  <xs:attributeGroup name="msgset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgset.attlist -->
  <!-- end of msgset.module -->
  <xs:attributeGroup name="msgentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="msg"/>
        <xs:element minOccurs="0" ref="msginfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="msgexplan"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgentry.element -->
  <xs:attributeGroup name="msgentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgentry.attlist -->
  <!-- end of msgentry.module -->
  <xs:attributeGroup name="simplemsgentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simplemsgentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="msgtext"/>
        <xs:element maxOccurs="unbounded" ref="msgexplan"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplemsgentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplemsgentry.element -->
  <xs:attributeGroup name="simplemsgentry.attlist">
    <xs:attribute name="audience"/>
    <xs:attribute name="level"/>
    <xs:attribute name="origin"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplemsgentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplemsgentry.attlist -->
  <!-- end of simplemsgentry.module -->
  <xs:attributeGroup name="msg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msg">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgmain"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="msgsub"/>
          <xs:element ref="msgrel"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="msg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msg.element -->
  <xs:attributeGroup name="msg.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msg.attlist -->
  <!-- end of msg.module -->
  <xs:attributeGroup name="msgmain.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgmain">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgmain.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgmain.element -->
  <xs:attributeGroup name="msgmain.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgmain.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgmain.attlist -->
  <!-- end of msgmain.module -->
  <xs:attributeGroup name="msgsub.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgsub">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgsub.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgsub.element -->
  <xs:attributeGroup name="msgsub.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgsub.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgsub.attlist -->
  <!-- end of msgsub.module -->
  <xs:attributeGroup name="msgrel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgrel">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgrel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgrel.element -->
  <xs:attributeGroup name="msgrel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgrel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgrel.attlist -->
  <!-- end of msgrel.module -->
  <!-- MsgText (defined in the Inlines section, below) -->
  <xs:attributeGroup name="msginfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msginfo">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="msglevel"/>
        <xs:element ref="msgorig"/>
        <xs:element ref="msgaud"/>
      </xs:choice>
      <xs:attributeGroup ref="msginfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msginfo.element -->
  <xs:attributeGroup name="msginfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msginfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msginfo.attlist -->
  <!-- end of msginfo.module -->
  <xs:attributeGroup name="msglevel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msglevel">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="msglevel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msglevel.element -->
  <xs:attributeGroup name="msglevel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msglevel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msglevel.attlist -->
  <!-- end of msglevel.module -->
  <xs:attributeGroup name="msgorig.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgorig">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="msgorig.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgorig.element -->
  <xs:attributeGroup name="msgorig.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgorig.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgorig.attlist -->
  <!-- end of msgorig.module -->
  <xs:attributeGroup name="msgaud.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgaud">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="msgaud.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgaud.element -->
  <xs:attributeGroup name="msgaud.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgaud.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgaud.attlist -->
  <!-- end of msgaud.module -->
  <xs:attributeGroup name="msgexplan.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgexplan">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgexplan.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgexplan.element -->
  <xs:attributeGroup name="msgexplan.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgexplan.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgexplan.attlist -->
  <!-- end of msgexplan.module -->
  <!-- end of msgset.content.module -->
  <!-- QandASet ........................ -->
  <xs:attributeGroup name="qandaset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="qandaset" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="qandadiv"/>
          <xs:element maxOccurs="unbounded" ref="qandaentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="qandaset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandaset.element -->
  <xs:attributeGroup name="qandaset.attlist">
    <xs:attribute name="defaultlabel">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="qanda"/>
          <xs:enumeration value="number"/>
          <xs:enumeration value="none"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandaset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandaset.attlist -->
  <!-- end of qandaset.module -->
  <xs:attributeGroup name="qandadiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="qandadiv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="qandadiv"/>
          <xs:element maxOccurs="unbounded" ref="qandaentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="qandadiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandadiv.element -->
  <xs:attributeGroup name="qandadiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandadiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandadiv.attlist -->
  <!-- end of qandadiv.module -->
  <xs:attributeGroup name="qandaentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="qandaentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="revhistory"/>
        <xs:element ref="question"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="answer"/>
      </xs:sequence>
      <xs:attributeGroup ref="qandaentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandaentry.element -->
  <xs:attributeGroup name="qandaentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandaentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandaentry.attlist -->
  <!-- end of qandaentry.module -->
  <xs:attributeGroup name="question.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="question">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="label"/>
        <xs:group maxOccurs="unbounded" ref="qandaset.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="question.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of question.element -->
  <xs:attributeGroup name="question.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="question.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of question.attlist -->
  <!-- end of question.module -->
  <xs:attributeGroup name="answer.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="answer">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="label"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="qandaentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="answer.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of answer.element -->
  <xs:attributeGroup name="answer.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="answer.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of answer.attlist -->
  <!-- end of answer.module -->
  <xs:attributeGroup name="label.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="label">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="label.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of label.element -->
  <xs:attributeGroup name="label.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="label.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of label.attlist -->
  <!-- end of label.module -->
  <!-- end of qandaset.content.module -->
  <!-- Procedure ........................ -->
  <xs:attributeGroup name="procedure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="procedure" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="procedure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of procedure.element -->
  <xs:attributeGroup name="procedure.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="procedure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of procedure.attlist -->
  <!-- end of procedure.module -->
  <xs:attributeGroup name="step.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="step">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="component.mix"/>
            <xs:sequence minOccurs="0">
              <xs:element ref="substeps"/>
              <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
            </xs:sequence>
          </xs:sequence>
          <xs:sequence>
            <xs:element ref="substeps"/>
            <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
          </xs:sequence>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="step.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of step.element -->
  <!-- Performance: Whether the Step must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="step.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="step.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of step.attlist -->
  <!-- end of step.module -->
  <xs:attributeGroup name="substeps.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="substeps">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="substeps.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of substeps.element -->
  <!-- Performance: whether entire set of substeps must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="substeps.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="substeps.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of substeps.attlist -->
  <!-- end of substeps.module -->
  <!-- end of procedure.content.module -->
  <!-- Sidebar .......................... -->
  <xs:attributeGroup name="sidebarinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sidebarinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sidebarinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sidebarinfo.element -->
  <xs:attributeGroup name="sidebarinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sidebarinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sidebarinfo.attlist -->
  <!-- end of sidebarinfo.module -->
  <xs:attributeGroup name="sidebar.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sidebar" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sidebarinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="sidebar.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="sidebar.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sidebar.element -->
  <xs:attributeGroup name="sidebar.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sidebar.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sidebar.attlist -->
  <!-- end of sidebar.module -->
  <!-- end of sidebar.content.model -->
  <!-- ...................................................................... -->
  <!-- Paragraph-related elements ........................................... -->
  <xs:attributeGroup name="abstract.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="abstract">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="abstract.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of abstract.element -->
  <xs:attributeGroup name="abstract.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="abstract.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of abstract.attlist -->
  <!-- end of abstract.module -->
  <xs:attributeGroup name="authorblurb.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="authorblurb">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="authorblurb.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorblurb.element -->
  <xs:attributeGroup name="authorblurb.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorblurb.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorblurb.attlist -->
  <!-- end of authorblurb.module -->
  <xs:attributeGroup name="personblurb.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="personblurb">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="personblurb.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of personblurb.element -->
  <xs:attributeGroup name="personblurb.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="personblurb.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of personblurb.attlist -->
  <!-- end of personblurb.module -->
  <xs:attributeGroup name="blockquote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="blockquote" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element minOccurs="0" ref="attribution"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="blockquote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of blockquote.element -->
  <xs:attributeGroup name="blockquote.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="blockquote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of blockquote.attlist -->
  <!-- end of blockquote.module -->
  <xs:attributeGroup name="attribution.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="attribution">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="attribution.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of attribution.element -->
  <xs:attributeGroup name="attribution.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="attribution.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of attribution.attlist -->
  <!-- end of attribution.module -->
  <xs:attributeGroup name="bridgehead.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bridgehead">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="bridgehead.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bridgehead.element -->
  <!--
    Renderas: Indicates the format in which the BridgeHead
    should appear
  -->
  <xs:attributeGroup name="bridgehead.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="other"/>
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bridgehead.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bridgehead.attlist -->
  <!-- end of bridgehead.module -->
  <xs:attributeGroup name="remark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="remark">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="remark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of remark.element -->
  <xs:attributeGroup name="remark.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="remark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of remark.attlist -->
  <!-- end of remark.module -->
  <xs:attributeGroup name="epigraph.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="epigraph">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="attribution"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="para.class"/>
          <xs:element ref="literallayout"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="epigraph.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of epigraph.element -->
  <xs:attributeGroup name="epigraph.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="epigraph.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of epigraph.attlist -->
  <!-- Attribution (defined above) -->
  <!-- end of epigraph.module -->
  <xs:attributeGroup name="footnote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="footnote" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="footnote.mix"/>
      <xs:attributeGroup ref="footnote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of footnote.element -->
  <xs:attributeGroup name="footnote.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="footnote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of footnote.attlist -->
  <!-- end of footnote.module -->
  <xs:attributeGroup name="highlights.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="highlights">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="highlights.mix"/>
      <xs:attributeGroup ref="highlights.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of highlights.element -->
  <xs:attributeGroup name="highlights.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="highlights.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of highlights.attlist -->
  <!-- end of highlights.module -->
  <xs:attributeGroup name="formalpara.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="formalpara" substitutionGroup="para.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="title"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element ref="para"/>
      </xs:sequence>
      <xs:attributeGroup ref="formalpara.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of formalpara.element -->
  <xs:attributeGroup name="formalpara.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="formalpara.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of formalpara.attlist -->
  <!-- end of formalpara.module -->
  <xs:attributeGroup name="para.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="para" substitutionGroup="para.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:group ref="para.mix"/>
      </xs:choice>
      <xs:attributeGroup ref="para.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of para.element -->
  <xs:attributeGroup name="para.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="para.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of para.attlist -->
  <!-- end of para.module -->
  <xs:attributeGroup name="simpara.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simpara" substitutionGroup="para.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="simpara.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simpara.element -->
  <xs:attributeGroup name="simpara.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simpara.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simpara.attlist -->
  <!-- end of simpara.module -->
  <xs:attributeGroup name="admon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="caution" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="caution.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of caution.element -->
  <xs:attributeGroup name="caution.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of caution.attlist -->
  <xs:element name="important" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="important.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of important.element -->
  <xs:attributeGroup name="important.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of important.attlist -->
  <xs:element name="note" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="note.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of note.element -->
  <xs:attributeGroup name="note.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of note.attlist -->
  <xs:element name="tip" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="tip.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tip.element -->
  <xs:attributeGroup name="tip.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tip.attlist -->
  <xs:element name="warning" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="warning.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of warning.element -->
  <xs:attributeGroup name="warning.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of warning.attlist -->
  <!-- end of admon.module -->
  <!-- ...................................................................... -->
  <!-- Lists ................................................................ -->
  <!-- GlossList ........................ -->
  <xs:attributeGroup name="glosslist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glosslist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="glossentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="glosslist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glosslist.element -->
  <xs:attributeGroup name="glosslist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glosslist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glosslist.attlist -->
  <!-- end of glosslist.module -->
  <xs:attributeGroup name="glossentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="glossterm"/>
        <xs:element minOccurs="0" ref="acronym"/>
        <xs:element minOccurs="0" ref="abbrev"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" ref="revhistory"/>
        <xs:choice>
          <xs:element ref="glosssee"/>
          <xs:element maxOccurs="unbounded" ref="glossdef"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="glossentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossentry.element -->
  <!--
    SortAs: String by which the GlossEntry is to be sorted
    (alphabetized) in lieu of its proper content
  -->
  <xs:attributeGroup name="glossentry.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossentry.attlist -->
  <!-- end of glossentry.module -->
  <!-- GlossTerm (defined in the Inlines section, below) -->
  <xs:attributeGroup name="glossdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossdef">
    <xs:complexType>
      <xs:sequence>
        <xs:group maxOccurs="unbounded" ref="glossdef.mix"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="glossseealso"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossdef.element -->
  <!-- Subject: List of subjects; keywords for the definition -->
  <xs:attributeGroup name="glossdef.attlist">
    <xs:attribute name="subject"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossdef.attlist -->
  <!-- end of glossdef.module -->
  <xs:attributeGroup name="glosssee.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glosssee">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glosssee.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glosssee.element -->
  <!--
    OtherTerm: Reference to the GlossEntry whose GlossTerm
    should be displayed at the point of the GlossSee
  -->
  <xs:attributeGroup name="glosssee.attlist">
    <xs:attribute name="otherterm" type="xs:IDREF"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glosssee.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glosssee.attlist -->
  <!-- end of glosssee.module -->
  <xs:attributeGroup name="glossseealso.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossseealso">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glossseealso.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossseealso.element -->
  <!--
    OtherTerm: Reference to the GlossEntry whose GlossTerm
    should be displayed at the point of the GlossSeeAlso
  -->
  <xs:attributeGroup name="glossseealso.attlist">
    <xs:attribute name="otherterm" type="xs:IDREF"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossseealso.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossseealso.attlist -->
  <!-- end of glossseealso.module -->
  <!-- end of glossentry.content.module -->
  <!-- ItemizedList and OrderedList ..... -->
  <xs:attributeGroup name="itemizedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="itemizedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="itemizedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of itemizedlist.element -->
  <!--
    Spacing: Whether the vertical space in the list should be
    compressed
  -->
  <!--
    Mark: Keyword, e.g., bullet, dash, checkbox, none;
    list of keywords and defaults are implementation specific
  -->
  <xs:attributeGroup name="itemizedlist.attlist">
    <xs:attribute name="spacing">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="normal"/>
          <xs:enumeration value="compact"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="mark.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="itemizedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of itemizedlist.attlist -->
  <!-- end of itemizedlist.module -->
  <xs:attributeGroup name="orderedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="orderedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="orderedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orderedlist.element -->
  <!--
    Numeration: Style of ListItem numbered; default is expected
    to be Arabic
  -->
  <!--
    InheritNum: Specifies for a nested list that the numbering
    of ListItems should include the number of the item
    within which they are nested (e.g., 1a and 1b within 1,
    rather than a and b)
  -->
  <!--
    Continuation: Where list numbering begins afresh (Restarts,
    the default) or continues that of the immediately preceding
    list (Continues)
  -->
  <!--
    Spacing: Whether the vertical space in the list should be
    compressed
  -->
  <xs:attributeGroup name="orderedlist.attlist">
    <xs:attribute name="numeration">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="arabic"/>
          <xs:enumeration value="upperalpha"/>
          <xs:enumeration value="loweralpha"/>
          <xs:enumeration value="upperroman"/>
          <xs:enumeration value="lowerroman"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="inheritnum" default="ignore">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="inherit"/>
          <xs:enumeration value="ignore"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="continuation" default="restarts">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="continues"/>
          <xs:enumeration value="restarts"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="spacing">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="normal"/>
          <xs:enumeration value="compact"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="orderedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orderedlist.attlist -->
  <!-- end of orderedlist.module -->
  <xs:attributeGroup name="listitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="listitem">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="listitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of listitem.element -->
  <!--
    Override: Indicates the mark to be used for this ListItem
    instead of the default mark or the mark specified by
    the Mark attribute on the enclosing ItemizedList
  -->
  <xs:attributeGroup name="listitem.attlist">
    <xs:attribute name="override"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="listitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of listitem.attlist -->
  <!-- end of listitem.module -->
  <!-- SegmentedList .................... -->
  <xs:attributeGroup name="segmentedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="segmentedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="segtitle"/>
        <xs:element maxOccurs="unbounded" ref="seglistitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="segmentedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of segmentedlist.element -->
  <xs:attributeGroup name="segmentedlist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="segmentedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of segmentedlist.attlist -->
  <!-- end of segmentedlist.module -->
  <xs:attributeGroup name="segtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="segtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="segtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of segtitle.element -->
  <xs:attributeGroup name="segtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="segtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of segtitle.attlist -->
  <!-- end of segtitle.module -->
  <xs:attributeGroup name="seglistitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seglistitem">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="seg"/>
      </xs:sequence>
      <xs:attributeGroup ref="seglistitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seglistitem.element -->
  <xs:attributeGroup name="seglistitem.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seglistitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seglistitem.attlist -->
  <!-- end of seglistitem.module -->
  <xs:attributeGroup name="seg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seg">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="seg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seg.element -->
  <xs:attributeGroup name="seg.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seg.attlist -->
  <!-- end of seg.module -->
  <!-- end of segmentedlist.content.module -->
  <!-- SimpleList ....................... -->
  <xs:attributeGroup name="simplelist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simplelist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="member"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplelist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplelist.element -->
  <!-- Columns: The number of columns the array should contain -->
  <!--
    Type: How the Members of the SimpleList should be
    formatted: Inline (members separated with commas etc.
    inline), Vert (top to bottom in n Columns), or Horiz (in
    the direction of text flow) in n Columns.  If Column
    is 1 or implied, Type=Vert and Type=Horiz give the same
    results.
  -->
  <xs:attributeGroup name="simplelist.attlist">
    <xs:attribute name="columns"/>
    <xs:attribute name="type" default="vert">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="inline"/>
          <xs:enumeration value="vert"/>
          <xs:enumeration value="horiz"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplelist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplelist.attlist -->
  <!-- end of simplelist.module -->
  <xs:attributeGroup name="member.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="member">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="member.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of member.element -->
  <xs:attributeGroup name="member.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="member.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of member.attlist -->
  <!-- end of member.module -->
  <!-- end of simplelist.content.module -->
  <!-- VariableList ..................... -->
  <xs:attributeGroup name="variablelist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="variablelist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="varlistentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="variablelist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of variablelist.element -->
  <!--
    TermLength: Length beyond which the presentation engine
    may consider the Term too long and select an alternate
    presentation of the Term and, or, its associated ListItem.
  -->
  <xs:attributeGroup name="variablelist.attlist">
    <xs:attribute name="termlength"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="variablelist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of variablelist.attlist -->
  <!-- end of variablelist.module -->
  <xs:attributeGroup name="varlistentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="varlistentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="term"/>
        <xs:element ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="varlistentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varlistentry.element -->
  <xs:attributeGroup name="varlistentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varlistentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varlistentry.attlist -->
  <!-- end of varlistentry.module -->
  <xs:attributeGroup name="term.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="term">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="term.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of term.element -->
  <xs:attributeGroup name="term.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="term.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of term.attlist -->
  <!-- end of term.module -->
  <!-- ListItem (defined above) -->
  <!-- end of variablelist.content.module -->
  <!-- CalloutList ...................... -->
  <xs:attributeGroup name="calloutlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="calloutlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="callout"/>
      </xs:sequence>
      <xs:attributeGroup ref="calloutlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of calloutlist.element -->
  <xs:attributeGroup name="calloutlist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="calloutlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of calloutlist.attlist -->
  <!-- end of calloutlist.module -->
  <xs:attributeGroup name="callout.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="callout">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="callout.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of callout.element -->
  <!--
    AreaRefs: IDs of one or more Areas or AreaSets described
    by this Callout
  -->
  <xs:attributeGroup name="callout.attlist">
    <xs:attribute name="arearefs" use="required" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="callout.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of callout.attlist -->
  <!-- end of callout.module -->
  <!-- end of calloutlist.content.module -->
  <!-- ...................................................................... -->
  <!-- Objects .............................................................. -->
  <!-- Examples etc. .................... -->
  <xs:attributeGroup name="example.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="example" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="example.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="example.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of example.element -->
  <xs:attributeGroup name="example.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="example.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of example.attlist -->
  <!-- end of example.module -->
  <xs:attributeGroup name="informalexample.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="informalexample" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group maxOccurs="unbounded" ref="example.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="informalexample.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalexample.element -->
  <xs:attributeGroup name="informalexample.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalexample.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalexample.attlist -->
  <!-- end of informalexample.module -->
  <xs:attributeGroup name="programlistingco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="programlistingco" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="programlisting"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="programlistingco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of programlistingco.element -->
  <xs:attributeGroup name="programlistingco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="programlistingco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of programlistingco.attlist -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of informalexample.module -->
  <xs:attributeGroup name="areaspec.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="areaspec">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="area"/>
        <xs:element ref="areaset"/>
      </xs:choice>
      <xs:attributeGroup ref="areaspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of areaspec.element -->
  <!--
    Units: global unit of measure in which coordinates in
    this spec are expressed:
    
    - CALSPair "x1,y1 x2,y2": lower-left and upper-right
    coordinates in a rectangle describing repro area in which
    graphic is placed, where X and Y dimensions are each some
    number 0..10000 (taken from CALS graphic attributes)
    
    - LineColumn "line column": line number and column number
    at which to start callout text in "linespecific" content
    
    - LineRange "startline endline": whole lines from startline
    to endline in "linespecific" content
    
    - LineColumnPair "line1 col1 line2 col2": starting and ending
    points of area in "linespecific" content that starts at
    first position and ends at second position (including the
    beginnings of any intervening lines)
    
    - Other: directive to look at value of OtherUnits attribute
    to get implementation-specific keyword
    
    The default is implementation-specific; usually dependent on
    the parent element (GraphicCO gets CALSPair, ProgramListingCO
    and ScreenCO get LineColumn)
  -->
  <!-- OtherUnits: User-defined units -->
  <xs:attributeGroup name="areaspec.attlist">
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="areaspec.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of areaspec.attlist -->
  <!-- end of areaspec.module -->
  <xs:attributeGroup name="area.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="area">
    <xs:complexType>
      <xs:attributeGroup ref="area.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of area.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <!--
    Units: unit of measure in which coordinates in this
    area are expressed; inherits from AreaSet and AreaSpec
  -->
  <!-- OtherUnits: User-defined units -->
  <xs:attributeGroup name="area.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attribute name="coords" use="required"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="area.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of area.attlist -->
  <!-- end of area.module -->
  <xs:attributeGroup name="areaset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="areaset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="area"/>
      </xs:sequence>
      <xs:attributeGroup ref="areaset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of areaset.element -->
  <!-- bug number/symbol override or initialization -->
  <!--
    Units: unit of measure in which coordinates in this
    area are expressed; inherits from AreaSpec
  -->
  <xs:attributeGroup name="areaset.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attribute name="coords" use="required"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="areaset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of areaset.attlist -->
  <!-- end of areaset.module -->
  <!-- end of areaspec.content.module -->
  <xs:attributeGroup name="programlisting.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="programlisting" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="lineannotation"/>
        <xs:element ref="textobject"/>
      </xs:choice>
      <xs:attributeGroup ref="programlisting.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of programlisting.element -->
  <xs:attributeGroup name="programlisting.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="programlisting.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of programlisting.attlist -->
  <!-- end of programlisting.module -->
  <xs:attributeGroup name="literallayout.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="literallayout" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="literallayout.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of literallayout.element -->
  <xs:attributeGroup name="literallayout.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attribute name="class" default="normal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="monospaced"/>
          <xs:enumeration value="normal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="literallayout.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of literallayout.attlist -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- end of literallayout.module -->
  <xs:attributeGroup name="screenco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screenco" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="screen"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="screenco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screenco.element -->
  <xs:attributeGroup name="screenco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screenco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screenco.attlist -->
  <!-- AreaSpec (defined above) -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of screenco.module -->
  <xs:attributeGroup name="screen.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screen" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="screen.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screen.element -->
  <xs:attributeGroup name="screen.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screen.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screen.attlist -->
  <!-- end of screen.module -->
  <xs:attributeGroup name="screenshot.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screenshot" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="screeninfo"/>
        <xs:choice>
          <xs:element ref="graphic"/>
          <xs:element ref="graphicco"/>
          <xs:element ref="mediaobject"/>
          <xs:element ref="mediaobjectco"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="screenshot.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screenshot.element -->
  <xs:attributeGroup name="screenshot.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screenshot.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screenshot.attlist -->
  <!-- end of screenshot.module -->
  <xs:attributeGroup name="screeninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screeninfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="screeninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screeninfo.element -->
  <xs:attributeGroup name="screeninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screeninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screeninfo.attlist -->
  <!-- end of screeninfo.module -->
  <!-- end of screenshot.content.module -->
  <!-- Figures etc. ..................... -->
  <xs:attributeGroup name="figure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="figure" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:choice maxOccurs="unbounded">
          <xs:group ref="figure.mix"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="figure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of figure.element -->
  <!--
    Float: Whether the Figure is supposed to be rendered
    where convenient (yes (1) value) or at the place it occurs
    in the text (no (0) value, the default)
  -->
  <xs:attributeGroup name="figure.attlist">
    <xs:attribute name="float" default="0" type="yesorno.attvals"/>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="figure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of figure.attlist -->
  <!-- end of figure.module -->
  <xs:attributeGroup name="informalfigure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="informalfigure" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:choice maxOccurs="unbounded">
          <xs:group ref="figure.mix"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="informalfigure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalfigure.element -->
  <!--
    Float: Whether the Figure is supposed to be rendered
    where convenient (yes (1) value) or at the place it occurs
    in the text (no (0) value, the default)
  -->
  <xs:attributeGroup name="informalfigure.attlist">
    <xs:attribute name="float" default="0" type="yesorno.attvals"/>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalfigure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalfigure.attlist -->
  <!-- end of informalfigure.module -->
  <xs:attributeGroup name="graphicco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="graphicco" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="graphic"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="graphicco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of graphicco.element -->
  <xs:attributeGroup name="graphicco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="graphicco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of graphicco.attlist -->
  <!-- AreaSpec (defined above in Examples) -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of graphicco.module -->
  <!--
    Graphical data can be the content of Graphic, or you can reference
    an external file either as an entity (Entitref) or a filename
    (Fileref).
  -->
  <xs:attributeGroup name="graphic.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="graphic" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:attributeGroup ref="graphic.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of graphic.element -->
  <xs:attributeGroup name="graphic.attlist">
    <xs:attributeGroup ref="graphics.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="graphic.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of graphic.attlist -->
  <!-- end of graphic.module -->
  <xs:attributeGroup name="inlinegraphic.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="inlinegraphic" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="inlinegraphic.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of inlinegraphic.element -->
  <xs:attributeGroup name="inlinegraphic.attlist">
    <xs:attributeGroup ref="graphics.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlinegraphic.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlinegraphic.attlist -->
  <!-- end of inlinegraphic.module -->
  <xs:attributeGroup name="mediaobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="mediaobject" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject.mix"/>
        <xs:element minOccurs="0" ref="caption"/>
      </xs:sequence>
      <xs:attributeGroup ref="mediaobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mediaobject.element -->
  <xs:attributeGroup name="mediaobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mediaobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mediaobject.attlist -->
  <!-- end of mediaobject.module -->
  <xs:attributeGroup name="inlinemediaobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="inlinemediaobject" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="inlinemediaobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of inlinemediaobject.element -->
  <xs:attributeGroup name="inlinemediaobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlinemediaobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlinemediaobject.attlist -->
  <!-- end of inlinemediaobject.module -->
  <xs:attributeGroup name="videoobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="videoobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="videodata"/>
      </xs:sequence>
      <xs:attributeGroup ref="videoobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of videoobject.element -->
  <xs:attributeGroup name="videoobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="videoobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of videoobject.attlist -->
  <!-- end of videoobject.module -->
  <xs:attributeGroup name="audioobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="audioobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="audiodata"/>
      </xs:sequence>
      <xs:attributeGroup ref="audioobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of audioobject.element -->
  <xs:attributeGroup name="audioobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="audioobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of audioobject.attlist -->
  <!-- end of audioobject.module -->
  <xs:attributeGroup name="imageobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="imageobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="imagedata"/>
      </xs:sequence>
      <xs:attributeGroup ref="imageobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imageobject.element -->
  <xs:attributeGroup name="imageobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imageobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imageobject.attlist -->
  <!-- end of imageobject.module -->
  <xs:attributeGroup name="textobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="textobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:choice>
          <xs:element ref="phrase"/>
          <xs:element ref="textdata"/>
          <xs:group maxOccurs="unbounded" ref="textobject.mix"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="textobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of textobject.element -->
  <xs:attributeGroup name="textobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="textobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of textobject.attlist -->
  <!-- end of textobject.module -->
  <xs:attributeGroup name="objectinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="objectinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="objectinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of objectinfo.element -->
  <xs:attributeGroup name="objectinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="objectinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of objectinfo.attlist -->
  <!-- end of objectinfo.module -->
  <!--
    EntityRef: Name of an external entity containing the content
    of the object data
  -->
  <!--
    FileRef: Filename, qualified by a pathname if desired,
    designating the file containing the content of the object data
  -->
  <!-- Format: Notation of the element content, if any -->
  <!-- SrcCredit: Information about the source of the image -->
  <xs:attributeGroup name="objectdata.attrib">
    <xs:attribute name="entityref" type="xs:ENTITY"/>
    <xs:attribute name="fileref"/>
    <xs:attribute name="format" type="notation.class"/>
    <xs:attribute name="srccredit"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="videodata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="videodata">
    <xs:complexType>
      <xs:attributeGroup ref="videodata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of videodata.element -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="videodata.attlist">
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="videodata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of videodata.attlist -->
  <!-- end of videodata.module -->
  <xs:attributeGroup name="audiodata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="audiodata">
    <xs:complexType>
      <xs:attributeGroup ref="audiodata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of audiodata.element -->
  <xs:attributeGroup name="audiodata.attlist">
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="audiodata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of audiodata.attlist -->
  <!-- end of audiodata.module -->
  <xs:attributeGroup name="imagedata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="imagedata">
    <xs:complexType>
      <xs:attributeGroup ref="imagedata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imagedata.element -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="imagedata.attlist">
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imagedata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imagedata.attlist -->
  <!-- end of imagedata.module -->
  <xs:attributeGroup name="textdata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="textdata">
    <xs:complexType>
      <xs:attributeGroup ref="textdata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of textdata.element -->
  <xs:attributeGroup name="textdata.attlist">
    <xs:attribute name="encoding"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="textdata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of textdata.attlist -->
  <!-- end of textdata.module -->
  <xs:attributeGroup name="caption.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="caption">
    <xs:complexType>
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="textobject.mix"/>
      <xs:attributeGroup ref="caption.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of caption.element -->
  <xs:attributeGroup name="caption.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="caption.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of caption.attlist -->
  <!-- end of caption.module -->
  <xs:attributeGroup name="mediaobjectco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="mediaobjectco" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="imageobjectco"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="imageobjectco"/>
          <xs:element ref="textobject"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="mediaobjectco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mediaobjectco.element -->
  <xs:attributeGroup name="mediaobjectco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mediaobjectco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mediaobjectco.attlist -->
  <!-- end of mediaobjectco.module -->
  <xs:attributeGroup name="imageobjectco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="imageobjectco">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="imageobject"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="imageobjectco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imageobjectco.element -->
  <xs:attributeGroup name="imageobjectco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imageobjectco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imageobjectco.attlist -->
  <!-- end of imageobjectco.module -->
  <!-- end of mediaobject.content.module -->
  <!-- Equations ........................ -->
  <!-- This PE provides a mechanism for replacing equation content, -->
  <!-- perhaps adding a new or different model (e.g., MathML) -->
  <xs:group name="equation.content">
    <xs:sequence>
      <xs:element minOccurs="0" ref="alt"/>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="graphic"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:complexType name="inlineequation.content">
    <xs:sequence>
      <xs:element minOccurs="0" ref="alt"/>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="graphic"/>
        <xs:element maxOccurs="unbounded" ref="inlinemediaobject"/>
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
  <xs:attributeGroup name="equation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="equation" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:choice>
          <xs:element ref="informalequation"/>
          <xs:group ref="equation.content"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="equation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of equation.element -->
  <xs:attributeGroup name="equation.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="equation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of equation.attlist -->
  <!-- end of equation.module -->
  <xs:attributeGroup name="informalequation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="informalequation" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="equation.content"/>
      </xs:sequence>
      <xs:attributeGroup ref="informalequation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalequation.element -->
  <xs:attributeGroup name="informalequation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalequation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalequation.attlist -->
  <!-- end of informalequation.module -->
  <xs:attributeGroup name="inlineequation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="inlineequation" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="inlineequation.content">
          <xs:attributeGroup ref="inlineequation.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <!-- end of inlineequation.element -->
  <xs:attributeGroup name="inlineequation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlineequation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlineequation.attlist -->
  <!-- end of inlineequation.module -->
  <xs:attributeGroup name="alt.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="alt">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="alt.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of alt.element -->
  <xs:attributeGroup name="alt.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="alt.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of alt.attlist -->
  <!-- end of alt.module -->
  <!-- Tables ........................... -->
  <!-- Choose a table model. CALS or OASIS XML Exchange -->
  <xs:attributeGroup name="tables.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- Add label and role attributes to table and informaltable -->
  <xs:attributeGroup name="bodyatt">
    <xs:attributeGroup ref="label.attrib"/>
  </xs:attributeGroup>
  <!--
    Add common attributes to Table, TGroup, TBody, THead, TFoot, Row,
    EntryTbl, and Entry (and InformalTable element).
  -->
  <xs:attributeGroup name="secur">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tables.role.attrib"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="common.table.attribs">
    <xs:attributeGroup ref="bodyatt"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- Content model for Table. -->
  <xs:complexType name="tbl.table.mdl">
    <xs:sequence>
      <xs:element minOccurs="0" ref="blockinfo"/>
      <xs:group ref="formalobject.title.content"/>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="textobject"/>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="graphic"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject"/>
        <xs:element maxOccurs="unbounded" ref="tgroup"/>
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
  <!-- Allow either objects or inlines; beware of REs between elements. -->
  <xs:group name="tbl.entry.mdl">
    <xs:choice>
      <xs:group ref="para.char.mix"/>
      <xs:group ref="tabentry.mix"/>
    </xs:choice>
  </xs:group>
  <!-- Reference CALS Table Model -->
  <!-- end of table.module -->
  <!--
    Note that InformalTable is dependent on some of the entity
    declarations that customize Table.
  -->
  <xs:element name="informaltable" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="textobject"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="graphic"/>
          <xs:element maxOccurs="unbounded" ref="mediaobject"/>
          <xs:element maxOccurs="unbounded" ref="tgroup"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="informaltable.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informaltable.element -->
  <!--
    Frame, Colsep, and Rowsep must be repeated because
    they are not in entities in the table module.
  -->
  <!--
    includes TabStyle, ToCentry, ShortEntry,
    Orient, PgWide
  -->
  <!-- includes Label -->
  <!-- includes common attributes -->
  <xs:attributeGroup name="informaltable.attlist">
    <xs:attribute name="frame">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="bottom"/>
          <xs:enumeration value="topbot"/>
          <xs:enumeration value="all"/>
          <xs:enumeration value="sides"/>
          <xs:enumeration value="none"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="colsep" type="yesorno.attvals"/>
    <xs:attribute name="rowsep" type="yesorno.attvals"/>
    <xs:attributeGroup ref="common.table.attribs"/>
    <xs:attributeGroup ref="tbl.table.att"/>
  </xs:attributeGroup>
  <!-- end of informaltable.attlist -->
  <!-- end of informaltable.module -->
  <!-- ...................................................................... -->
  <!-- Synopses ............................................................. -->
  <!-- Synopsis ......................... -->
  <xs:attributeGroup name="synopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="synopsis" substitutionGroup="synop.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="graphic"/>
        <xs:element ref="mediaobject"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="synopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopsis.element -->
  <xs:attributeGroup name="synopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="synopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopsis.attlist -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- end of synopsis.module -->
  <!-- CmdSynopsis ...................... -->
  <xs:attributeGroup name="cmdsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="cmdsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="command"/>
          <xs:element ref="arg"/>
          <xs:element ref="group"/>
          <xs:element ref="sbr"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="synopfragment"/>
      </xs:sequence>
      <xs:attributeGroup ref="cmdsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of cmdsynopsis.element -->
  <!--
    Sepchar: Character that should separate command and all
    top-level arguments; alternate value might be e.g., &Delta;
  -->
  <xs:attributeGroup name="cmdsynopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attribute name="sepchar" default=" "/>
    <xs:attribute name="cmdlength"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="cmdsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of cmdsynopsis.attlist -->
  <!-- end of cmdsynopsis.module -->
  <xs:attributeGroup name="arg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="arg">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
        <xs:element ref="option"/>
        <xs:element ref="synopfragmentref"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="sbr"/>
      </xs:choice>
      <xs:attributeGroup ref="arg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of arg.element -->
  <!--
    Choice: Whether Arg must be supplied: Opt (optional to
    supply, e.g. [arg]; the default), Req (required to supply,
    e.g. {arg}), or Plain (required to supply, e.g. arg)
  -->
  <!--
    Rep: whether Arg is repeatable: Norepeat (e.g. arg without
    ellipsis; the default), or Repeat (e.g. arg...)
  -->
  <xs:attributeGroup name="arg.attlist">
    <xs:attribute name="choice" default="opt">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="arg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of arg.attlist -->
  <!-- end of arg.module -->
  <xs:attributeGroup name="group.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="group">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
        <xs:element ref="option"/>
        <xs:element ref="synopfragmentref"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="sbr"/>
      </xs:choice>
      <xs:attributeGroup ref="group.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of group.element -->
  <!--
    Choice: Whether Group must be supplied: Opt (optional to
    supply, e.g.  [g1|g2|g3]; the default), Req (required to
    supply, e.g.  {g1|g2|g3}), Plain (required to supply,
    e.g.  g1|g2|g3), OptMult (can supply zero or more, e.g.
    [[g1|g2|g3]]), or ReqMult (must supply one or more, e.g.
    {{g1|g2|g3}})
  -->
  <!--
    Rep: whether Group is repeatable: Norepeat (e.g. group
    without ellipsis; the default), or Repeat (e.g. group...)
  -->
  <xs:attributeGroup name="group.attlist">
    <xs:attribute name="choice" default="opt">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="group.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of group.attlist -->
  <!-- end of group.module -->
  <!-- Synopsis break -->
  <xs:attributeGroup name="sbr.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sbr">
    <xs:complexType>
      <xs:attributeGroup ref="sbr.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sbr.element -->
  <xs:attributeGroup name="sbr.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sbr.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sbr.attlist -->
  <!-- end of sbr.module -->
  <xs:attributeGroup name="synopfragmentref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="synopfragmentref">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="synopfragmentref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopfragmentref.element -->
  <!--
    to SynopFragment of complex synopsis
    material for separate referencing
  -->
  <xs:attributeGroup name="synopfragmentref.attlist">
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="synopfragmentref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopfragmentref.attlist -->
  <!-- end of synopfragmentref.module -->
  <xs:attributeGroup name="synopfragment.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="synopfragment">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
      </xs:choice>
      <xs:attributeGroup ref="synopfragment.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopfragment.element -->
  <xs:attributeGroup name="synopfragment.attlist">
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="synopfragment.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopfragment.attlist -->
  <!-- end of synopfragment.module -->
  <!-- Command (defined in the Inlines section, below) -->
  <!-- Option (defined in the Inlines section, below) -->
  <!-- Replaceable (defined in the Inlines section, below) -->
  <!-- end of cmdsynopsis.content.module -->
  <!-- FuncSynopsis ..................... -->
  <xs:attributeGroup name="funcsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="funcsynopsisinfo"/>
        <xs:element ref="funcprototype"/>
      </xs:choice>
      <xs:attributeGroup ref="funcsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcsynopsis.element -->
  <xs:attributeGroup name="funcsynopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcsynopsis.attlist -->
  <!-- end of funcsynopsis.module -->
  <xs:attributeGroup name="funcsynopsisinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcsynopsisinfo">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="funcsynopsisinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcsynopsisinfo.element -->
  <xs:attributeGroup name="funcsynopsisinfo.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcsynopsisinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcsynopsisinfo.attlist -->
  <!-- end of funcsynopsisinfo.module -->
  <xs:attributeGroup name="funcprototype.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcprototype">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="funcdef"/>
        <xs:choice>
          <xs:element ref="void"/>
          <xs:element ref="varargs"/>
          <xs:element maxOccurs="unbounded" ref="paramdef"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="funcprototype.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcprototype.element -->
  <xs:attributeGroup name="funcprototype.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcprototype.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcprototype.attlist -->
  <!-- end of funcprototype.module -->
  <xs:attributeGroup name="funcdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcdef">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="type"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="function"/>
      </xs:choice>
      <xs:attributeGroup ref="funcdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcdef.element -->
  <xs:attributeGroup name="funcdef.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcdef.attlist -->
  <!-- end of funcdef.module -->
  <xs:attributeGroup name="void.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="void">
    <xs:complexType>
      <xs:attributeGroup ref="void.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of void.element -->
  <xs:attributeGroup name="void.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="void.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of void.attlist -->
  <!-- end of void.module -->
  <xs:attributeGroup name="varargs.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="varargs">
    <xs:complexType>
      <xs:attributeGroup ref="varargs.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varargs.element -->
  <xs:attributeGroup name="varargs.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varargs.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varargs.attlist -->
  <!-- end of varargs.module -->
  <!--
    Processing assumes that only one Parameter will appear in a
    ParamDef, and that FuncParams will be used at most once, for
    providing information on the "inner parameters" for parameters that
    are pointers to functions.
  -->
  <xs:attributeGroup name="paramdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="paramdef">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="type"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="parameter"/>
        <xs:element ref="funcparams"/>
      </xs:choice>
      <xs:attributeGroup ref="paramdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of paramdef.element -->
  <xs:attributeGroup name="paramdef.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="paramdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of paramdef.attlist -->
  <!-- end of paramdef.module -->
  <xs:attributeGroup name="funcparams.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcparams">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="funcparams.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcparams.element -->
  <xs:attributeGroup name="funcparams.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcparams.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcparams.attlist -->
  <!-- end of funcparams.module -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- Replaceable (defined in the Inlines section, below) -->
  <!-- Function (defined in the Inlines section, below) -->
  <!-- Parameter (defined in the Inlines section, below) -->
  <!-- end of funcsynopsis.content.module -->
  <!-- ClassSynopsis ..................... -->
  <xs:attributeGroup name="classsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="classsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="ooclass"/>
          <xs:element ref="oointerface"/>
          <xs:element ref="ooexception"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="classsynopsisinfo"/>
          <xs:element ref="fieldsynopsis"/>
          <xs:element ref="method.synop.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="classsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classsynopsis.element -->
  <xs:attributeGroup name="classsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attribute name="class" default="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="class"/>
          <xs:enumeration value="interface"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classsynopsis.attlist -->
  <!-- end of classsynopsis.module -->
  <xs:attributeGroup name="classsynopsisinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="classsynopsisinfo">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="classsynopsisinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classsynopsisinfo.element -->
  <xs:attributeGroup name="classsynopsisinfo.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classsynopsisinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classsynopsisinfo.attlist -->
  <!-- end of classsynopsisinfo.module -->
  <xs:attributeGroup name="ooclass.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ooclass" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element ref="classname"/>
      </xs:sequence>
      <xs:attributeGroup ref="ooclass.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ooclass.element -->
  <xs:attributeGroup name="ooclass.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ooclass.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ooclass.attlist -->
  <!-- end of ooclass.module -->
  <xs:attributeGroup name="oointerface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="oointerface" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element ref="interfacename"/>
      </xs:sequence>
      <xs:attributeGroup ref="oointerface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of oointerface.element -->
  <xs:attributeGroup name="oointerface.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="oointerface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of oointerface.attlist -->
  <!-- end of oointerface.module -->
  <xs:attributeGroup name="ooexception.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ooexception" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="ooexception.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ooexception.element -->
  <xs:attributeGroup name="ooexception.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ooexception.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ooexception.attlist -->
  <!-- end of ooexception.module -->
  <xs:attributeGroup name="modifier.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="modifier">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="modifier.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of modifier.element -->
  <xs:attributeGroup name="modifier.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="modifier.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of modifier.attlist -->
  <!-- end of modifier.module -->
  <xs:attributeGroup name="interfacename.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="interfacename" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="interfacename.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of interfacename.element -->
  <xs:attributeGroup name="interfacename.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="interfacename.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of interfacename.attlist -->
  <!-- end of interfacename.module -->
  <xs:attributeGroup name="exceptionname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="exceptionname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="exceptionname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of exceptionname.element -->
  <xs:attributeGroup name="exceptionname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="exceptionname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of exceptionname.attlist -->
  <!-- end of exceptionname.module -->
  <xs:attributeGroup name="fieldsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="fieldsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="type"/>
        <xs:element ref="varname"/>
        <xs:element minOccurs="0" ref="initializer"/>
      </xs:sequence>
      <xs:attributeGroup ref="fieldsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of fieldsynopsis.element -->
  <xs:attributeGroup name="fieldsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="fieldsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of fieldsynopsis.attlist -->
  <!-- end of fieldsynopsis.module -->
  <xs:attributeGroup name="initializer.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="initializer">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="initializer.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of initializer.element -->
  <xs:attributeGroup name="initializer.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="initializer.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of initializer.attlist -->
  <!-- end of initializer.module -->
  <xs:attributeGroup name="constructorsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="constructorsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="constructorsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of constructorsynopsis.element -->
  <xs:attributeGroup name="constructorsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="constructorsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of constructorsynopsis.attlist -->
  <!-- end of constructorsynopsis.module -->
  <xs:attributeGroup name="destructorsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="destructorsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="destructorsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of destructorsynopsis.element -->
  <xs:attributeGroup name="destructorsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="destructorsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of destructorsynopsis.attlist -->
  <!-- end of destructorsynopsis.module -->
  <xs:attributeGroup name="methodsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="methodsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:choice minOccurs="0">
          <xs:element ref="type"/>
          <xs:element ref="void"/>
        </xs:choice>
        <xs:element ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="methodsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodsynopsis.element -->
  <xs:attributeGroup name="methodsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodsynopsis.attlist -->
  <!-- end of methodsynopsis.module -->
  <xs:attributeGroup name="methodname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="methodname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="methodname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodname.element -->
  <xs:attributeGroup name="methodname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodname.attlist -->
  <!-- end of methodname.module -->
  <xs:attributeGroup name="methodparam.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="methodparam">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="type"/>
        <xs:choice>
          <xs:sequence>
            <xs:element ref="parameter"/>
            <xs:element minOccurs="0" ref="initializer"/>
          </xs:sequence>
          <xs:element ref="funcparams"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="methodparam.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodparam.element -->
  <xs:attributeGroup name="methodparam.attlist">
    <xs:attribute name="choice" default="req">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodparam.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodparam.attlist -->
  <!-- end of methodparam.module -->
  <!-- end of classsynopsis.content.module -->
  <!-- ...................................................................... -->
  <!-- Document information entities and elements ........................... -->
  <!--
    The document information elements include some elements that are
    currently used only in the document hierarchy module. They are
    defined here so that they will be available for use in customized
    document hierarchies.
  -->
  <!-- .................................. -->
  <!-- Ackno ............................ -->
  <xs:attributeGroup name="ackno.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ackno">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="ackno.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ackno.element -->
  <xs:attributeGroup name="ackno.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ackno.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ackno.attlist -->
  <!-- end of ackno.module -->
  <!-- Address .......................... -->
  <xs:attributeGroup name="address.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="address" substitutionGroup="informal.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="personname"/>
        <xs:group ref="person.ident.mix"/>
        <xs:element ref="street"/>
        <xs:element ref="pob"/>
        <xs:element ref="postcode"/>
        <xs:element ref="city"/>
        <xs:element ref="state"/>
        <xs:element ref="country"/>
        <xs:element ref="phone"/>
        <xs:element ref="fax"/>
        <xs:element ref="email"/>
        <xs:element ref="otheraddr"/>
      </xs:choice>
      <xs:attributeGroup ref="address.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of address.element -->
  <xs:attributeGroup name="address.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="address.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of address.attlist -->
  <!-- end of address.module -->
  <xs:attributeGroup name="street.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="street">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="street.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of street.element -->
  <xs:attributeGroup name="street.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="street.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of street.attlist -->
  <!-- end of street.module -->
  <xs:attributeGroup name="pob.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pob">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pob.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pob.element -->
  <xs:attributeGroup name="pob.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pob.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pob.attlist -->
  <!-- end of pob.module -->
  <xs:attributeGroup name="postcode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="postcode">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="postcode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of postcode.element -->
  <xs:attributeGroup name="postcode.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="postcode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of postcode.attlist -->
  <!-- end of postcode.module -->
  <xs:attributeGroup name="city.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="city">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="city.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of city.element -->
  <xs:attributeGroup name="city.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="city.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of city.attlist -->
  <!-- end of city.module -->
  <xs:attributeGroup name="state.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="state">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="state.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of state.element -->
  <xs:attributeGroup name="state.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="state.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of state.attlist -->
  <!-- end of state.module -->
  <xs:attributeGroup name="country.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="country">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="country.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of country.element -->
  <xs:attributeGroup name="country.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="country.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of country.attlist -->
  <!-- end of country.module -->
  <xs:attributeGroup name="phone.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="phone">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="phone.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of phone.element -->
  <xs:attributeGroup name="phone.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="phone.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of phone.attlist -->
  <!-- end of phone.module -->
  <xs:attributeGroup name="fax.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="fax">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="fax.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of fax.element -->
  <xs:attributeGroup name="fax.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="fax.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of fax.attlist -->
  <!-- end of fax.module -->
  <!-- Email (defined in the Inlines section, below) -->
  <xs:attributeGroup name="otheraddr.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="otheraddr">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="otheraddr.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of otheraddr.element -->
  <xs:attributeGroup name="otheraddr.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="otheraddr.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of otheraddr.attlist -->
  <!-- end of otheraddr.module -->
  <!-- end of address.content.module -->
  <!-- Affiliation ...................... -->
  <xs:attributeGroup name="affiliation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="affiliation">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="shortaffil"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="jobtitle"/>
        <xs:element minOccurs="0" ref="orgname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="orgdiv"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="address"/>
      </xs:sequence>
      <xs:attributeGroup ref="affiliation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of affiliation.element -->
  <xs:attributeGroup name="affiliation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="affiliation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of affiliation.attlist -->
  <!-- end of affiliation.module -->
  <xs:attributeGroup name="shortaffil.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="shortaffil">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="shortaffil.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of shortaffil.element -->
  <xs:attributeGroup name="shortaffil.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="shortaffil.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of shortaffil.attlist -->
  <!-- end of shortaffil.module -->
  <xs:attributeGroup name="jobtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="jobtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="jobtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of jobtitle.element -->
  <xs:attributeGroup name="jobtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="jobtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of jobtitle.attlist -->
  <!-- end of jobtitle.module -->
  <!-- OrgName (defined elsewhere in this section) -->
  <xs:attributeGroup name="orgdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="orgdiv">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="orgdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orgdiv.element -->
  <xs:attributeGroup name="orgdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="orgdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orgdiv.attlist -->
  <!-- end of orgdiv.module -->
  <!-- Address (defined elsewhere in this section) -->
  <!-- end of affiliation.content.module -->
  <!-- ArtPageNums ...................... -->
  <xs:attributeGroup name="artpagenums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="artpagenums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="artpagenums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of artpagenums.element -->
  <xs:attributeGroup name="artpagenums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="artpagenums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of artpagenums.attlist -->
  <!-- end of artpagenums.module -->
  <!-- PersonName -->
  <xs:attributeGroup name="personname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="personname" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="honorific"/>
        <xs:element ref="firstname"/>
        <xs:element ref="surname"/>
        <xs:element ref="lineage"/>
        <xs:element ref="othername"/>
      </xs:choice>
      <xs:attributeGroup ref="personname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of personname.element -->
  <xs:attributeGroup name="personname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="personname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of personname.attlist -->
  <!-- end of personname.module -->
  <!-- Author ........................... -->
  <xs:attributeGroup name="author.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="author" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="author.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of author.element -->
  <xs:attributeGroup name="author.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="author.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of author.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of author.module -->
  <!-- AuthorGroup ...................... -->
  <xs:attributeGroup name="authorgroup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="authorgroup">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="author"/>
        <xs:element ref="editor"/>
        <xs:element ref="collab"/>
        <xs:element ref="corpauthor"/>
        <xs:element ref="othercredit"/>
      </xs:choice>
      <xs:attributeGroup ref="authorgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorgroup.element -->
  <xs:attributeGroup name="authorgroup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorgroup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorgroup.attlist -->
  <!-- end of authorgroup.module -->
  <!-- Author (defined elsewhere in this section) -->
  <!-- Editor (defined elsewhere in this section) -->
  <xs:attributeGroup name="collab.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="collab">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="collabname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="affiliation"/>
      </xs:sequence>
      <xs:attributeGroup ref="collab.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of collab.element -->
  <xs:attributeGroup name="collab.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="collab.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of collab.attlist -->
  <!-- end of collab.module -->
  <xs:attributeGroup name="collabname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="collabname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="collabname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of collabname.element -->
  <xs:attributeGroup name="collabname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="collabname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of collabname.attlist -->
  <!-- end of collabname.module -->
  <!-- Affiliation (defined elsewhere in this section) -->
  <!-- end of collab.content.module -->
  <!-- CorpAuthor (defined elsewhere in this section) -->
  <!-- OtherCredit (defined elsewhere in this section) -->
  <!-- end of authorgroup.content.module -->
  <!-- AuthorInitials ................... -->
  <xs:attributeGroup name="authorinitials.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="authorinitials" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="authorinitials.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorinitials.element -->
  <xs:attributeGroup name="authorinitials.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorinitials.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorinitials.attlist -->
  <!-- end of authorinitials.module -->
  <!-- ConfGroup ........................ -->
  <xs:attributeGroup name="confgroup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confgroup">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="confdates"/>
        <xs:element ref="conftitle"/>
        <xs:element ref="confnum"/>
        <xs:element ref="address"/>
        <xs:element ref="confsponsor"/>
      </xs:choice>
      <xs:attributeGroup ref="confgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confgroup.element -->
  <xs:attributeGroup name="confgroup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confgroup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confgroup.attlist -->
  <!-- end of confgroup.module -->
  <xs:attributeGroup name="confdates.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confdates">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confdates.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confdates.element -->
  <xs:attributeGroup name="confdates.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confdates.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confdates.attlist -->
  <!-- end of confdates.module -->
  <xs:attributeGroup name="conftitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="conftitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="conftitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of conftitle.element -->
  <xs:attributeGroup name="conftitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="conftitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of conftitle.attlist -->
  <!-- end of conftitle.module -->
  <xs:attributeGroup name="confnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confnum.element -->
  <xs:attributeGroup name="confnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confnum.attlist -->
  <!-- end of confnum.module -->
  <!-- Address (defined elsewhere in this section) -->
  <xs:attributeGroup name="confsponsor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confsponsor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confsponsor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confsponsor.element -->
  <xs:attributeGroup name="confsponsor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confsponsor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confsponsor.attlist -->
  <!-- end of confsponsor.module -->
  <!-- end of confgroup.content.module -->
  <!-- ContractNum ...................... -->
  <xs:attributeGroup name="contractnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="contractnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contractnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contractnum.element -->
  <xs:attributeGroup name="contractnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contractnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contractnum.attlist -->
  <!-- end of contractnum.module -->
  <!-- ContractSponsor .................. -->
  <xs:attributeGroup name="contractsponsor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="contractsponsor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contractsponsor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contractsponsor.element -->
  <xs:attributeGroup name="contractsponsor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contractsponsor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contractsponsor.attlist -->
  <!-- end of contractsponsor.module -->
  <!-- Copyright ........................ -->
  <xs:attributeGroup name="copyright.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="copyright">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="year"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="holder"/>
      </xs:sequence>
      <xs:attributeGroup ref="copyright.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of copyright.element -->
  <xs:attributeGroup name="copyright.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="copyright.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of copyright.attlist -->
  <!-- end of copyright.module -->
  <xs:attributeGroup name="year.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="year">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="year.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of year.element -->
  <xs:attributeGroup name="year.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="year.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of year.attlist -->
  <!-- end of year.module -->
  <xs:attributeGroup name="holder.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="holder">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="holder.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of holder.element -->
  <xs:attributeGroup name="holder.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="holder.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of holder.attlist -->
  <!-- end of holder.module -->
  <!-- end of copyright.content.module -->
  <!-- CorpAuthor ....................... -->
  <xs:attributeGroup name="corpauthor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="corpauthor" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpauthor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpauthor.element -->
  <xs:attributeGroup name="corpauthor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpauthor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpauthor.attlist -->
  <!-- end of corpauthor.module -->
  <!-- CorpName ......................... -->
  <xs:element name="corpname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpname.element -->
  <xs:attributeGroup name="corpname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="corpname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpname.attlist -->
  <!-- end of corpname.module -->
  <!-- Date ............................. -->
  <xs:attributeGroup name="date.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="date">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="date.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of date.element -->
  <xs:attributeGroup name="date.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="date.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of date.attlist -->
  <!-- end of date.module -->
  <!-- Edition .......................... -->
  <xs:attributeGroup name="edition.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="edition">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="edition.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of edition.element -->
  <xs:attributeGroup name="edition.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="edition.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of edition.attlist -->
  <!-- end of edition.module -->
  <!-- Editor ........................... -->
  <xs:attributeGroup name="editor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="editor">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="editor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of editor.element -->
  <xs:attributeGroup name="editor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="editor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of editor.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of editor.module -->
  <!-- ISBN ............................. -->
  <xs:attributeGroup name="isbn.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="isbn">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="isbn.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of isbn.element -->
  <xs:attributeGroup name="isbn.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="isbn.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of isbn.attlist -->
  <!-- end of isbn.module -->
  <!-- ISSN ............................. -->
  <xs:attributeGroup name="issn.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="issn">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="issn.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of issn.element -->
  <xs:attributeGroup name="issn.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="issn.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of issn.attlist -->
  <!-- end of issn.module -->
  <!-- BiblioId ................. -->
  <xs:attributeGroup name="biblio.class.attrib">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="uri"/>
          <xs:enumeration value="doi"/>
          <xs:enumeration value="isbn"/>
          <xs:enumeration value="issn"/>
          <xs:enumeration value="libraryofcongress"/>
          <xs:enumeration value="pubnumber"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherclass"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="biblioid.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="biblioid">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="biblioid.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioid.element -->
  <xs:attributeGroup name="biblioid.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioid.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioid.attlist -->
  <!-- end of biblioid.module -->
  <!-- CiteBiblioId ................. -->
  <xs:attributeGroup name="citebiblioid.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citebiblioid">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="citebiblioid.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citebiblioid.element -->
  <xs:attributeGroup name="citebiblioid.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citebiblioid.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citebiblioid.attlist -->
  <!-- end of citebiblioid.module -->
  <!-- BiblioSource ................. -->
  <xs:attributeGroup name="bibliosource.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliosource">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliosource.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliosource.element -->
  <xs:attributeGroup name="bibliosource.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliosource.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliosource.attlist -->
  <!-- end of bibliosource.module -->
  <!-- BiblioRelation ................. -->
  <xs:attributeGroup name="bibliorelation.type.attrib">
    <xs:attribute name="type">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="isversionof"/>
          <xs:enumeration value="hasversion"/>
          <xs:enumeration value="isreplacedby"/>
          <xs:enumeration value="replaces"/>
          <xs:enumeration value="isrequiredby"/>
          <xs:enumeration value="requires"/>
          <xs:enumeration value="ispartof"/>
          <xs:enumeration value="haspart"/>
          <xs:enumeration value="isreferencedby"/>
          <xs:enumeration value="references"/>
          <xs:enumeration value="isformatof"/>
          <xs:enumeration value="hasformat"/>
          <xs:enumeration value="othertype"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="othertype"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="bibliorelation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliorelation">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliorelation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliorelation.element -->
  <xs:attributeGroup name="bibliorelation.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="bibliorelation.type.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliorelation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliorelation.attlist -->
  <!-- end of bibliorelation.module -->
  <!-- BiblioCoverage ................. -->
  <xs:attributeGroup name="bibliocoverage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliocoverage">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliocoverage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliocoverage.element -->
  <xs:attributeGroup name="bibliocoverage.attlist">
    <xs:attribute name="spatial">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="dcmipoint"/>
          <xs:enumeration value="iso3166"/>
          <xs:enumeration value="dcmibox"/>
          <xs:enumeration value="tgn"/>
          <xs:enumeration value="otherspatial"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherspatial"/>
    <xs:attribute name="temporal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="dcmiperiod"/>
          <xs:enumeration value="w3c-dtf"/>
          <xs:enumeration value="othertemporal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="othertemporal"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliocoverage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliocoverage.attlist -->
  <!-- end of bibliocoverage.module -->
  <!-- InvPartNumber .................... -->
  <xs:attributeGroup name="invpartnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="invpartnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="invpartnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of invpartnumber.element -->
  <xs:attributeGroup name="invpartnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="invpartnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of invpartnumber.attlist -->
  <!-- end of invpartnumber.module -->
  <!-- IssueNum ......................... -->
  <xs:attributeGroup name="issuenum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="issuenum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="issuenum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of issuenum.element -->
  <xs:attributeGroup name="issuenum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="issuenum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of issuenum.attlist -->
  <!-- end of issuenum.module -->
  <!-- LegalNotice ...................... -->
  <xs:attributeGroup name="legalnotice.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="legalnotice">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="legalnotice.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="legalnotice.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of legalnotice.element -->
  <xs:attributeGroup name="legalnotice.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="legalnotice.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of legalnotice.attlist -->
  <!-- end of legalnotice.module -->
  <!-- ModeSpec ......................... -->
  <xs:attributeGroup name="modespec.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="modespec" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="modespec.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of modespec.element -->
  <!--
    Application: Type of action required for completion
    of the links to which the ModeSpec is relevant (e.g.,
    retrieval query)
  -->
  <xs:attributeGroup name="modespec.attlist">
    <xs:attribute name="application" type="notation.class"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="modespec.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of modespec.attlist -->
  <!-- end of modespec.module -->
  <!-- OrgName .......................... -->
  <xs:attributeGroup name="orgname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="orgname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="orgname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orgname.element -->
  <xs:attributeGroup name="orgname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="corporation"/>
          <xs:enumeration value="nonprofit"/>
          <xs:enumeration value="consortium"/>
          <xs:enumeration value="informal"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherclass"/>
    <xs:attributeGroup ref="orgname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orgname.attlist -->
  <!-- end of orgname.module -->
  <!-- OtherCredit ...................... -->
  <xs:attributeGroup name="othercredit.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="othercredit" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="othercredit.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of othercredit.element -->
  <xs:attributeGroup name="othercredit.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="othercredit.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of othercredit.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of othercredit.module -->
  <!-- PageNums ......................... -->
  <xs:attributeGroup name="pagenums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pagenums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pagenums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pagenums.element -->
  <xs:attributeGroup name="pagenums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pagenums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pagenums.attlist -->
  <!-- end of pagenums.module -->
  <!-- Personal identity elements ....... -->
  <!--
    These elements are used only within Author, Editor, and
    OtherCredit.
  -->
  <xs:attributeGroup name="contrib.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="contrib">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contrib.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contrib.element -->
  <xs:attributeGroup name="contrib.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contrib.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contrib.attlist -->
  <!-- end of contrib.module -->
  <xs:attributeGroup name="firstname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="firstname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="firstname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of firstname.element -->
  <xs:attributeGroup name="firstname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="firstname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of firstname.attlist -->
  <!-- end of firstname.module -->
  <xs:attributeGroup name="honorific.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="honorific">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="honorific.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of honorific.element -->
  <xs:attributeGroup name="honorific.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="honorific.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of honorific.attlist -->
  <!-- end of honorific.module -->
  <xs:attributeGroup name="lineage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lineage">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="lineage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lineage.element -->
  <xs:attributeGroup name="lineage.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lineage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lineage.attlist -->
  <!-- end of lineage.module -->
  <xs:attributeGroup name="othername.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="othername">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="othername.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of othername.element -->
  <xs:attributeGroup name="othername.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="othername.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of othername.attlist -->
  <!-- end of othername.module -->
  <xs:attributeGroup name="surname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="surname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="surname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of surname.element -->
  <xs:attributeGroup name="surname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="surname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of surname.attlist -->
  <!-- end of surname.module -->
  <!-- end of person.ident.module -->
  <!-- PrintHistory ..................... -->
  <xs:attributeGroup name="printhistory.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="printhistory">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="printhistory.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of printhistory.element -->
  <xs:attributeGroup name="printhistory.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="printhistory.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of printhistory.attlist -->
  <!-- end of printhistory.module -->
  <!-- ProductName ...................... -->
  <xs:attributeGroup name="productname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="productname" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="productname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of productname.element -->
  <!-- Class: More precisely identifies the item the element names -->
  <xs:attributeGroup name="productname.attlist">
    <xs:attribute name="class" default="trade">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="service"/>
          <xs:enumeration value="trade"/>
          <xs:enumeration value="registered"/>
          <xs:enumeration value="copyright"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="productname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of productname.attlist -->
  <!-- end of productname.module -->
  <!-- ProductNumber .................... -->
  <xs:attributeGroup name="productnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="productnumber" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="productnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of productnumber.element -->
  <xs:attributeGroup name="productnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="productnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of productnumber.attlist -->
  <!-- end of productnumber.module -->
  <!-- PubDate .......................... -->
  <xs:attributeGroup name="pubdate.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pubdate">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pubdate.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pubdate.element -->
  <xs:attributeGroup name="pubdate.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pubdate.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pubdate.attlist -->
  <!-- end of pubdate.module -->
  <!-- Publisher ........................ -->
  <xs:attributeGroup name="publisher.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="publisher">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="publishername"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="address"/>
      </xs:sequence>
      <xs:attributeGroup ref="publisher.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of publisher.element -->
  <xs:attributeGroup name="publisher.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="publisher.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of publisher.attlist -->
  <!-- end of publisher.module -->
  <xs:attributeGroup name="publishername.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="publishername">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="publishername.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of publishername.element -->
  <xs:attributeGroup name="publishername.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="publishername.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of publishername.attlist -->
  <!-- end of publishername.module -->
  <!-- Address (defined elsewhere in this section) -->
  <!-- end of publisher.content.module -->
  <!-- PubsNumber ....................... -->
  <xs:attributeGroup name="pubsnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pubsnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pubsnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pubsnumber.element -->
  <xs:attributeGroup name="pubsnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pubsnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pubsnumber.attlist -->
  <!-- end of pubsnumber.module -->
  <!-- ReleaseInfo ...................... -->
  <xs:attributeGroup name="releaseinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="releaseinfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="releaseinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of releaseinfo.element -->
  <xs:attributeGroup name="releaseinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="releaseinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of releaseinfo.attlist -->
  <!-- end of releaseinfo.module -->
  <!-- RevHistory ....................... -->
  <xs:attributeGroup name="revhistory.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revhistory" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="revision"/>
      </xs:sequence>
      <xs:attributeGroup ref="revhistory.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revhistory.element -->
  <xs:attributeGroup name="revhistory.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revhistory.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revhistory.attlist -->
  <!-- end of revhistory.module -->
  <xs:attributeGroup name="revision.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revision">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="revnumber"/>
        <xs:element ref="date"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="authorinitials"/>
        <xs:choice minOccurs="0">
          <xs:element ref="revremark"/>
          <xs:element ref="revdescription"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="revision.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revision.element -->
  <xs:attributeGroup name="revision.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revision.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revision.attlist -->
  <!-- end of revision.module -->
  <xs:attributeGroup name="revnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="revnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revnumber.element -->
  <xs:attributeGroup name="revnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revnumber.attlist -->
  <!-- end of revnumber.module -->
  <!-- Date (defined elsewhere in this section) -->
  <!-- AuthorInitials (defined elsewhere in this section) -->
  <xs:attributeGroup name="revremark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revremark">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="revremark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revremark.element -->
  <xs:attributeGroup name="revremark.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revremark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revremark.attlist -->
  <!-- end of revremark.module -->
  <xs:attributeGroup name="revdescription.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revdescription">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="revdescription.mix"/>
      <xs:attributeGroup ref="revdescription.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revdescription.element -->
  <xs:attributeGroup name="revdescription.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revdescription.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revdescription.attlist -->
  <!-- end of revdescription.module -->
  <!-- end of revhistory.content.module -->
  <!-- SeriesVolNums .................... -->
  <xs:attributeGroup name="seriesvolnums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seriesvolnums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="seriesvolnums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seriesvolnums.element -->
  <xs:attributeGroup name="seriesvolnums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seriesvolnums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seriesvolnums.attlist -->
  <!-- end of seriesvolnums.module -->
  <!-- VolumeNum ........................ -->
  <xs:attributeGroup name="volumenum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="volumenum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="volumenum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of volumenum.element -->
  <xs:attributeGroup name="volumenum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="volumenum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of volumenum.attlist -->
  <!-- end of volumenum.module -->
  <!-- .................................. -->
  <!-- end of docinfo.content.module -->
  <!-- ...................................................................... -->
  <!-- Inline, link, and ubiquitous elements ................................ -->
  <!-- Technical and computer terms ......................................... -->
  <xs:attributeGroup name="accel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="accel">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="accel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of accel.element -->
  <xs:attributeGroup name="accel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="accel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of accel.attlist -->
  <!-- end of accel.module -->
  <xs:attributeGroup name="action.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="action" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="action.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of action.element -->
  <xs:attributeGroup name="action.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="action.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of action.attlist -->
  <!-- end of action.module -->
  <xs:attributeGroup name="application.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="application" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="application.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of application.element -->
  <xs:attributeGroup name="application.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="hardware"/>
          <xs:enumeration value="software"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="application.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of application.attlist -->
  <!-- end of application.module -->
  <xs:attributeGroup name="classname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="classname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="classname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classname.element -->
  <xs:attributeGroup name="classname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classname.attlist -->
  <!-- end of classname.module -->
  <!--
    CO is a callout area of the LineColumn unit type (a single character
    position); the position is directly indicated by the location of CO.
  -->
  <xs:attributeGroup name="co.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="co">
    <xs:complexType>
      <xs:attributeGroup ref="co.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of co.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <xs:attributeGroup name="co.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="co.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of co.attlist -->
  <!-- end of co.module -->
  <!-- COREF is a reference to a CO -->
  <xs:attributeGroup name="coref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="coref">
    <xs:complexType>
      <xs:attributeGroup ref="coref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of coref.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <xs:attributeGroup name="coref.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="coref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of coref.attlist -->
  <!-- end of coref.module -->
  <xs:attributeGroup name="command.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="command" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="command.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of command.element -->
  <xs:attributeGroup name="command.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="command.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of command.attlist -->
  <!-- end of command.module -->
  <xs:attributeGroup name="computeroutput.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="computeroutput" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="computeroutput.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of computeroutput.element -->
  <xs:attributeGroup name="computeroutput.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="computeroutput.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of computeroutput.attlist -->
  <!-- end of computeroutput.module -->
  <xs:attributeGroup name="database.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="database" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="database.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of database.element -->
  <!-- Class: Type of database the element names; no default -->
  <xs:attributeGroup name="database.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="name"/>
          <xs:enumeration value="table"/>
          <xs:enumeration value="field"/>
          <xs:enumeration value="key1"/>
          <xs:enumeration value="key2"/>
          <xs:enumeration value="record"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="database.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of database.attlist -->
  <!-- end of database.module -->
  <xs:attributeGroup name="email.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="email" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="email.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of email.element -->
  <xs:attributeGroup name="email.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="email.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of email.attlist -->
  <!-- end of email.module -->
  <xs:attributeGroup name="envar.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="envar" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="envar.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of envar.element -->
  <xs:attributeGroup name="envar.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="envar.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of envar.attlist -->
  <!-- end of envar.module -->
  <xs:attributeGroup name="errorcode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errorcode" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errorcode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errorcode.element -->
  <xs:attributeGroup name="errorcode.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errorcode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errorcode.attlist -->
  <!-- end of errorcode.module -->
  <xs:attributeGroup name="errorname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errorname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errorname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errorname.element -->
  <xs:attributeGroup name="errorname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errorname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errorname.attlist -->
  <!-- end of errorname.module -->
  <xs:attributeGroup name="errortext.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errortext" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errortext.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errortext.element -->
  <xs:attributeGroup name="errortext.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errortext.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errortext.attlist -->
  <!-- end of errortext.module -->
  <xs:attributeGroup name="errortype.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errortype" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errortype.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errortype.element -->
  <xs:attributeGroup name="errortype.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errortype.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errortype.attlist -->
  <!-- end of errortype.module -->
  <xs:attributeGroup name="filename.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="filename" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="filename.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of filename.element -->
  <!-- Class: Type of filename the element names; no default -->
  <!--
    Path: Search path (possibly system-specific) in which
    file can be found
  -->
  <xs:attributeGroup name="filename.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="headerfile"/>
          <xs:enumeration value="partition"/>
          <xs:enumeration value="devicefile"/>
          <xs:enumeration value="libraryfile"/>
          <xs:enumeration value="directory"/>
          <xs:enumeration value="extension"/>
          <xs:enumeration value="symlink"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="path"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="filename.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of filename.attlist -->
  <!-- end of filename.module -->
  <xs:attributeGroup name="function.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="function" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="function.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of function.element -->
  <xs:attributeGroup name="function.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="function.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of function.attlist -->
  <!-- end of function.module -->
  <xs:attributeGroup name="guibutton.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guibutton" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guibutton.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guibutton.element -->
  <xs:attributeGroup name="guibutton.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guibutton.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guibutton.attlist -->
  <!-- end of guibutton.module -->
  <xs:attributeGroup name="guiicon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guiicon" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guiicon.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guiicon.element -->
  <xs:attributeGroup name="guiicon.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guiicon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guiicon.attlist -->
  <!-- end of guiicon.module -->
  <xs:attributeGroup name="guilabel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guilabel" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guilabel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guilabel.element -->
  <xs:attributeGroup name="guilabel.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guilabel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guilabel.attlist -->
  <!-- end of guilabel.module -->
  <xs:attributeGroup name="guimenu.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guimenu" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guimenu.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guimenu.element -->
  <xs:attributeGroup name="guimenu.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guimenu.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guimenu.attlist -->
  <!-- end of guimenu.module -->
  <xs:attributeGroup name="guimenuitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guimenuitem" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guimenuitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guimenuitem.element -->
  <xs:attributeGroup name="guimenuitem.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guimenuitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guimenuitem.attlist -->
  <!-- end of guimenuitem.module -->
  <xs:attributeGroup name="guisubmenu.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guisubmenu" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="guisubmenu.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guisubmenu.element -->
  <xs:attributeGroup name="guisubmenu.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guisubmenu.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guisubmenu.attlist -->
  <!-- end of guisubmenu.module -->
  <xs:attributeGroup name="hardware.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="hardware" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="hardware.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of hardware.element -->
  <xs:attributeGroup name="hardware.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="hardware.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of hardware.attlist -->
  <!-- end of hardware.module -->
  <xs:attributeGroup name="interface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="interface" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="interface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of interface.element -->
  <!-- Class: Type of the Interface item; no default -->
  <xs:attributeGroup name="interface.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="interface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of interface.attlist -->
  <!-- end of interface.module -->
  <xs:attributeGroup name="keycap.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keycap" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="keycap.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycap.element -->
  <xs:attributeGroup name="keycap.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycap.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycap.attlist -->
  <!-- end of keycap.module -->
  <xs:attributeGroup name="keycode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keycode" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="keycode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycode.element -->
  <xs:attributeGroup name="keycode.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycode.attlist -->
  <!-- end of keycode.module -->
  <xs:attributeGroup name="keycombo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keycombo" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="keycap"/>
        <xs:element ref="keycombo"/>
        <xs:element ref="keysym"/>
        <xs:element ref="mousebutton"/>
      </xs:choice>
      <xs:attributeGroup ref="keycombo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycombo.element -->
  <xs:attributeGroup name="keycombo.attlist">
    <xs:attributeGroup ref="keyaction.attrib"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycombo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycombo.attlist -->
  <!-- end of keycombo.module -->
  <xs:attributeGroup name="keysysm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keysym" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="keysym.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keysym.element -->
  <xs:attributeGroup name="keysym.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keysysm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keysym.attlist -->
  <!-- end of keysym.module -->
  <xs:attributeGroup name="lineannotation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lineannotation">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="lineannotation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lineannotation.element -->
  <xs:attributeGroup name="lineannotation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lineannotation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lineannotation.attlist -->
  <!-- end of lineannotation.module -->
  <xs:attributeGroup name="literal.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="literal" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="literal.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of literal.element -->
  <xs:attributeGroup name="literal.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="literal.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of literal.attlist -->
  <!-- end of literal.module -->
  <xs:attributeGroup name="constant.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="constant" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="constant.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of constant.element -->
  <xs:attributeGroup name="constant.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="limit"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="constant.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of constant.attlist -->
  <!-- end of constant.module -->
  <xs:attributeGroup name="varname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="varname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="varname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varname.element -->
  <xs:attributeGroup name="varname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varname.attlist -->
  <!-- end of varname.module -->
  <xs:attributeGroup name="markup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="markup" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="markup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of markup.element -->
  <xs:attributeGroup name="markup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="markup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of markup.attlist -->
  <!-- end of markup.module -->
  <xs:attributeGroup name="medialabel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="medialabel" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="medialabel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of medialabel.element -->
  <!-- Class: Type of medium named by the element; no default -->
  <xs:attributeGroup name="medialabel.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="cartridge"/>
          <xs:enumeration value="cdrom"/>
          <xs:enumeration value="disk"/>
          <xs:enumeration value="tape"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="medialabel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of medialabel.attlist -->
  <!-- end of medialabel.module -->
  <xs:attributeGroup name="menuchoice.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="menuchoice" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="shortcut"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="guibutton"/>
          <xs:element ref="guiicon"/>
          <xs:element ref="guilabel"/>
          <xs:element ref="guimenu"/>
          <xs:element ref="guimenuitem"/>
          <xs:element ref="guisubmenu"/>
          <xs:element ref="interface"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="menuchoice.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of menuchoice.element -->
  <xs:attributeGroup name="menuchoice.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="menuchoice.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of menuchoice.attlist -->
  <!-- end of menuchoice.module -->
  <!-- See also KeyCombo -->
  <xs:attributeGroup name="shortcut.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="shortcut">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="keycap"/>
        <xs:element ref="keycombo"/>
        <xs:element ref="keysym"/>
        <xs:element ref="mousebutton"/>
      </xs:choice>
      <xs:attributeGroup ref="shortcut.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of shortcut.element -->
  <xs:attributeGroup name="shortcut.attlist">
    <xs:attributeGroup ref="keyaction.attrib"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="shortcut.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of shortcut.attlist -->
  <!-- end of shortcut.module -->
  <!-- end of menuchoice.content.module -->
  <xs:attributeGroup name="mousebutton.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="mousebutton" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="mousebutton.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mousebutton.element -->
  <xs:attributeGroup name="mousebutton.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mousebutton.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mousebutton.attlist -->
  <!-- end of mousebutton.module -->
  <xs:attributeGroup name="msgtext.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgtext">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="msgtext.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgtext.element -->
  <xs:attributeGroup name="msgtext.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgtext.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgtext.attlist -->
  <!-- end of msgtext.module -->
  <xs:attributeGroup name="option.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="option" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="option.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of option.element -->
  <xs:attributeGroup name="option.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="option.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of option.attlist -->
  <!-- end of option.module -->
  <xs:attributeGroup name="optional.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="optional" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="optional.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of optional.element -->
  <xs:attributeGroup name="optional.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="optional.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of optional.attlist -->
  <!-- end of optional.module -->
  <xs:attributeGroup name="parameter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="parameter" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="parameter.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of parameter.element -->
  <!-- Class: Type of the Parameter; no default -->
  <xs:attributeGroup name="parameter.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="command"/>
          <xs:enumeration value="function"/>
          <xs:enumeration value="option"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="parameter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of parameter.attlist -->
  <!-- end of parameter.module -->
  <xs:attributeGroup name="prompt.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="prompt" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="prompt.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of prompt.element -->
  <xs:attributeGroup name="prompt.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="prompt.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of prompt.attlist -->
  <!-- end of prompt.module -->
  <xs:attributeGroup name="property.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="property" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="property.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of property.element -->
  <xs:attributeGroup name="property.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="property.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of property.attlist -->
  <!-- end of property.module -->
  <xs:attributeGroup name="replaceable.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="replaceable" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="optional"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="replaceable.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of replaceable.element -->
  <!--
    Class: Type of information the element represents; no
    default
  -->
  <xs:attributeGroup name="replaceable.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="command"/>
          <xs:enumeration value="function"/>
          <xs:enumeration value="option"/>
          <xs:enumeration value="parameter"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="replaceable.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of replaceable.attlist -->
  <!-- end of replaceable.module -->
  <xs:attributeGroup name="returnvalue.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="returnvalue" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="returnvalue.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of returnvalue.element -->
  <xs:attributeGroup name="returnvalue.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="returnvalue.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of returnvalue.attlist -->
  <!-- end of returnvalue.module -->
  <xs:attributeGroup name="sgmltag.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sgmltag" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="sgmltag.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sgmltag.element -->
  <!-- Class: Type of SGML construct the element names; no default -->
  <xs:attributeGroup name="sgmltag.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="attribute"/>
          <xs:enumeration value="attvalue"/>
          <xs:enumeration value="element"/>
          <xs:enumeration value="endtag"/>
          <xs:enumeration value="emptytag"/>
          <xs:enumeration value="genentity"/>
          <xs:enumeration value="numcharref"/>
          <xs:enumeration value="paramentity"/>
          <xs:enumeration value="pi"/>
          <xs:enumeration value="xmlpi"/>
          <xs:enumeration value="starttag"/>
          <xs:enumeration value="sgmlcomment"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sgmltag.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sgmltag.attlist -->
  <!-- end of sgmltag.module -->
  <xs:attributeGroup name="structfield.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="structfield" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="structfield.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of structfield.element -->
  <xs:attributeGroup name="structfield.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="structfield.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of structfield.attlist -->
  <!-- end of structfield.module -->
  <xs:attributeGroup name="structname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="structname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="structname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of structname.element -->
  <xs:attributeGroup name="structname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="structname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of structname.attlist -->
  <!-- end of structname.module -->
  <xs:attributeGroup name="symbol.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="symbol" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="symbol.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of symbol.element -->
  <!-- Class: Type of symbol; no default -->
  <xs:attributeGroup name="symbol.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="limit"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="symbol.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of symbol.attlist -->
  <!-- end of symbol.module -->
  <xs:attributeGroup name="systemitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="systemitem" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="acronym"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="systemitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of systemitem.element -->
  <!-- Class: Type of system item the element names; no default -->
  <xs:attributeGroup name="systemitem.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="constant"/>
          <xs:enumeration value="event"/>
          <xs:enumeration value="eventhandler"/>
          <xs:enumeration value="domainname"/>
          <xs:enumeration value="fqdomainname"/>
          <xs:enumeration value="ipaddress"/>
          <xs:enumeration value="netmask"/>
          <xs:enumeration value="etheraddress"/>
          <xs:enumeration value="groupname"/>
          <xs:enumeration value="library"/>
          <xs:enumeration value="macro"/>
          <xs:enumeration value="osname"/>
          <xs:enumeration value="filesystem"/>
          <xs:enumeration value="resource"/>
          <xs:enumeration value="systemname"/>
          <xs:enumeration value="username"/>
          <xs:enumeration value="newsgroup"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="systemitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of systemitem.attlist -->
  <!-- end of systemitem.module -->
  <xs:attributeGroup name="token.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="token" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="token.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of token.element -->
  <xs:attributeGroup name="token.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="token.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of token.attlist -->
  <!-- end of token.module -->
  <xs:attributeGroup name="type.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="type" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="type.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of type.element -->
  <xs:attributeGroup name="type.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="type.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of type.attlist -->
  <!-- end of type.module -->
  <xs:attributeGroup name="userinput.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="userinput" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="userinput.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of userinput.element -->
  <xs:attributeGroup name="userinput.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="userinput.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of userinput.attlist -->
  <!-- end of userinput.module -->
  <!-- General words and phrases ............................................ -->
  <xs:attributeGroup name="abbrev.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="abbrev" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="abbrev.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of abbrev.element -->
  <xs:attributeGroup name="abbrev.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="abbrev.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of abbrev.attlist -->
  <!-- end of abbrev.module -->
  <xs:attributeGroup name="acronym.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="acronym" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="acronym.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of acronym.element -->
  <xs:attributeGroup name="acronym.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="acronym.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of acronym.attlist -->
  <!-- end of acronym.module -->
  <xs:attributeGroup name="citation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citation" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="citation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citation.element -->
  <xs:attributeGroup name="citation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citation.attlist -->
  <!-- end of citation.module -->
  <xs:attributeGroup name="citerefentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citerefentry" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="refentrytitle"/>
        <xs:element minOccurs="0" ref="manvolnum"/>
      </xs:sequence>
      <xs:attributeGroup ref="citerefentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citerefentry.element -->
  <xs:attributeGroup name="citerefentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citerefentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citerefentry.attlist -->
  <!-- end of citerefentry.module -->
  <xs:attributeGroup name="refentrytitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refentrytitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="refentrytitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refentrytitle.element -->
  <xs:attributeGroup name="refentrytitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentrytitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentrytitle.attlist -->
  <!-- end of refentrytitle.module -->
  <xs:attributeGroup name="namvolnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="manvolnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="manvolnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of manvolnum.element -->
  <xs:attributeGroup name="manvolnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="namvolnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of manvolnum.attlist -->
  <!-- end of manvolnum.module -->
  <xs:attributeGroup name="citetitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citetitle" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="citetitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citetitle.element -->
  <!-- Pubwork: Genre of published work cited; no default -->
  <xs:attributeGroup name="citetitle.attlist">
    <xs:attribute name="pubwork">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="article"/>
          <xs:enumeration value="book"/>
          <xs:enumeration value="chapter"/>
          <xs:enumeration value="part"/>
          <xs:enumeration value="refentry"/>
          <xs:enumeration value="section"/>
          <xs:enumeration value="journal"/>
          <xs:enumeration value="series"/>
          <xs:enumeration value="set"/>
          <xs:enumeration value="manuscript"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citetitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citetitle.attlist -->
  <!-- end of citetitle.module -->
  <xs:attributeGroup name="emphasis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="emphasis" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="emphasis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of emphasis.element -->
  <xs:attributeGroup name="emphasis.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="emphasis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of emphasis.attlist -->
  <!-- end of emphasis.module -->
  <xs:attributeGroup name="firstterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="firstterm" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="firstterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of firstterm.element -->
  <!-- to GlossEntry or other explanation -->
  <xs:attributeGroup name="firstterm.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="firstterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of firstterm.attlist -->
  <!-- end of firstterm.module -->
  <xs:attributeGroup name="foreignphrase.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="foreignphrase" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="foreignphrase.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of foreignphrase.element -->
  <xs:attributeGroup name="foreignphrase.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="foreignphrase.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of foreignphrase.attlist -->
  <!-- end of foreignphrase.module -->
  <xs:attributeGroup name="glossterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossterm" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glossterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossterm.element -->
  <!-- to GlossEntry if Glossterm used in text -->
  <!--
    BaseForm: Provides the form of GlossTerm to be used
    for indexing
  -->
  <xs:attributeGroup name="glossterm.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attribute name="baseform"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossterm.attlist -->
  <!-- end of glossterm.module -->
  <xs:attributeGroup name="phrase.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="phrase" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="phrase.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of phrase.element -->
  <xs:attributeGroup name="phrase.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="phrase.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of phrase.attlist -->
  <!-- end of phrase.module -->
  <xs:attributeGroup name="quote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="quote" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="quote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of quote.element -->
  <xs:attributeGroup name="quote.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="quote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of quote.attlist -->
  <!-- end of quote.module -->
  <xs:attributeGroup name="ssscript.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subscript">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="symbol"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
      </xs:choice>
      <xs:attributeGroup ref="subscript.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subscript.element -->
  <xs:attributeGroup name="subscript.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ssscript.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subscript.attlist -->
  <xs:element name="superscript">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="symbol"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
      </xs:choice>
      <xs:attributeGroup ref="superscript.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of superscript.element -->
  <xs:attributeGroup name="superscript.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ssscript.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of superscript.attlist -->
  <!-- end of ssscript.module -->
  <xs:attributeGroup name="trademark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="trademark" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="emphasis"/>
      </xs:choice>
      <xs:attributeGroup ref="trademark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of trademark.element -->
  <!-- Class: More precisely identifies the item the element names -->
  <xs:attributeGroup name="trademark.attlist">
    <xs:attribute name="class" default="trade">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="service"/>
          <xs:enumeration value="trade"/>
          <xs:enumeration value="registered"/>
          <xs:enumeration value="copyright"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="trademark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of trademark.attlist -->
  <!-- end of trademark.module -->
  <xs:attributeGroup name="wordasword.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="wordasword" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="wordasword.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of wordasword.element -->
  <xs:attributeGroup name="wordasword.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="wordasword.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of wordasword.attlist -->
  <!-- end of wordasword.module -->
  <!-- Links and cross-references ........................................... -->
  <xs:attributeGroup name="link.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="link" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="link.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of link.element -->
  <!--
    Endterm: ID of element containing text that is to be
    fetched from elsewhere in the document to appear as
    the content of this element
  -->
  <!-- to linked-to object -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="link.attlist">
    <xs:attribute name="endterm" type="xs:IDREF"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="link.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of link.attlist -->
  <!-- end of link.module -->
  <xs:attributeGroup name="olink.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="olink" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="olink.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of olink.element -->
  <!-- TargetDocEnt: Name of an entity to be the target of the link -->
  <!--
    LinkMode: ID of a ModeSpec containing instructions for
    operating on the entity named by TargetDocEnt
  -->
  <!-- LocalInfo: Information that may be passed to ModeSpec -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="olink.attlist">
    <xs:attribute name="targetdocent" type="xs:ENTITY"/>
    <xs:attribute name="linkmode" type="xs:IDREF"/>
    <xs:attribute name="localinfo"/>
    <xs:attribute name="type"/>
    <xs:attribute name="targetdoc"/>
    <xs:attribute name="targetptr"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="olink.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of olink.attlist -->
  <!-- end of olink.module -->
  <xs:attributeGroup name="ulink.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ulink" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="ulink.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ulink.element -->
  <!-- URL: uniform resource locator; the target of the ULink -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="ulink.attlist">
    <xs:attribute name="url" use="required"/>
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ulink.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ulink.attlist -->
  <!-- end of ulink.module -->
  <xs:attributeGroup name="footnoteref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="footnoteref" substitutionGroup="xref.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="footnoteref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of footnoteref.element -->
  <!-- to footnote content supplied elsewhere -->
  <xs:attributeGroup name="footnoteref.attlist">
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="footnoteref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of footnoteref.attlist -->
  <!-- end of footnoteref.module -->
  <xs:attributeGroup name="xref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="xref" substitutionGroup="xref.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="xref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of xref.element -->
  <!--
    Endterm: ID of element containing text that is to be
    fetched from elsewhere in the document to appear as
    the content of this element
  -->
  <!-- to linked-to object -->
  <xs:attributeGroup name="xref.attlist">
    <xs:attribute name="endterm" type="xs:IDREF"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="xref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of xref.attlist -->
  <!-- end of xref.module -->
  <!-- Ubiquitous elements .................................................. -->
  <xs:attributeGroup name="anchor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="anchor">
    <xs:complexType>
      <xs:attributeGroup ref="anchor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of anchor.element -->
  <!-- required -->
  <!-- replaces Lang -->
  <xs:attributeGroup name="anchor.attlist">
    <xs:attributeGroup ref="idreq.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="anchor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of anchor.attlist -->
  <!-- end of anchor.module -->
  <xs:attributeGroup name="beginpage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="beginpage">
    <xs:complexType>
      <xs:attributeGroup ref="beginpage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of beginpage.element -->
  <!-- PageNum: Number of page that begins at this point -->
  <xs:attributeGroup name="beginpage.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="beginpage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of beginpage.attlist -->
  <!-- end of beginpage.module -->
  <!--
    IndexTerms appear in the text flow for generating or linking an
    index.
  -->
  <xs:attributeGroup name="indexterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexterm" substitutionGroup="ndxterm.class"/>
  <!-- end of indexterm.element -->
  <!--
    Scope: Indicates which generated indices the IndexTerm
    should appear in: Global (whole document set), Local (this
    document only), or All (both)
  -->
  <!--
    Significance: Whether this IndexTerm is the most pertinent
    of its series (Preferred) or not (Normal, the default)
  -->
  <!--
    Class: Indicates type of IndexTerm; default is Singular,
    or EndOfRange if StartRef is supplied; StartOfRange value
    must be supplied explicitly on starts of ranges
  -->
  <!--
    StartRef: ID of the IndexTerm that starts the indexing
    range ended by this IndexTerm
  -->
  <!--
    Zone: IDs of the elements to which the IndexTerm applies,
    and indicates that the IndexTerm applies to those entire
    elements rather than the point at which the IndexTerm
    occurs
  -->
  <xs:attributeGroup name="indexterm.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attribute name="scope">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="all"/>
          <xs:enumeration value="global"/>
          <xs:enumeration value="local"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="significance" default="normal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="preferred"/>
          <xs:enumeration value="normal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="singular"/>
          <xs:enumeration value="startofrange"/>
          <xs:enumeration value="endofrange"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="startref" type="xs:IDREF"/>
    <xs:attribute name="zone" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexterm.attlist -->
  <!-- end of indexterm.module -->
  <xs:attributeGroup name="primsecter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="primary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="primary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of primary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="primary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of primary.attlist -->
  <xs:element name="secondary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="secondary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of secondary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="secondary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of secondary.attlist -->
  <xs:element name="tertiary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="tertiary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tertiary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="tertiary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tertiary.attlist -->
  <!-- end of primsecter.module -->
  <xs:attributeGroup name="seeseealso.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="see">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="see.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of see.element -->
  <xs:attributeGroup name="see.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeseealso.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of see.attlist -->
  <xs:element name="seealso">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seealso.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seealso.element -->
  <xs:attributeGroup name="seealso.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeseealso.role.attrib"/>
  </xs:attributeGroup>
</xs:schema>
<!-- end of seealso.attlist -->
<!-- end of seeseealso.module -->
<!-- end of indexterm.content.module -->
<!-- End of DocBook XML information pool module V4.2 ...................... -->
<!-- ...................................................................... -->
 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 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook CALS Table Model V4.4 ........................................ -->
<!-- File calstblx.mod .................................................... -->
<!--
  Copyright 1992-2002 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  This DTD is based on the CALS Table Model
  PUBLIC "-//USA-DOD//DTD Table Model 951010//EN"
  
  $Id: calstblx.dtd,v 1.27 2005/01/27 13:52:00 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the CALS Table Model
  converted to XML. It has been modified slightly for use in the
  combined HTML/CALS models supported by DocBook V4.4.
-->
<!--
  These definitions are not directly related to the table model, but are
  used in the default CALS table model and are usually defined elsewhere
  (and prior to the inclusion of this table module) in a CALS DTD.
-->
<!--
  no if zero(s),
  yes if any other digits value
-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <xs:simpleType name="yesorno">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:group name="titles">
    <xs:sequence>
      <xs:element minOccurs="0" ref="title"/>
    </xs:sequence>
  </xs:group>
  <!-- default for use in entry content -->
  <!--
    The parameter entities as defined below provide the CALS table model
    as published (as part of the Example DTD) in MIL-HDBK-28001.
    
    These following declarations provide the CALS-compliant default definitions
    for these entities.  However, these entities can and should be redefined
    (by giving the appropriate parameter entity declaration(s) prior to the
    reference to this Table Model declaration set entity) to fit the needs
    of the current application.
  -->
  <xs:group name="tbl.table-titles.mdl">
    <xs:sequence>
      <xs:group ref="titles"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="tbl.table-main.mdl">
    <xs:choice>
      <xs:element maxOccurs="unbounded" ref="tgroup"/>
      <xs:element maxOccurs="unbounded" ref="graphic"/>
    </xs:choice>
  </xs:group>
  <xs:complexType name="tbl.tgroup.mdl">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="spanspec"/>
      <xs:element minOccurs="0" ref="thead"/>
      <xs:element minOccurs="0" ref="tfoot"/>
      <xs:element ref="tbody"/>
    </xs:sequence>
  </xs:complexType>
  <xs:attributeGroup name="tbl.tgroup.att">
    <xs:attribute name="tgroupstyle"/>
  </xs:attributeGroup>
  <xs:complexType name="tbl.row.mdl">
    <xs:choice maxOccurs="unbounded">
      <xs:element ref="entry"/>
      <xs:element ref="entrytbl"/>
    </xs:choice>
  </xs:complexType>
  <xs:complexType name="tbl.entrytbl.mdl">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="spanspec"/>
      <xs:element minOccurs="0" ref="thead"/>
      <xs:element ref="tbody"/>
    </xs:sequence>
  </xs:complexType>
  <!-- =====  Element and attribute declarations follow. ===== -->
  <xs:element name="table" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.table.mdl">
          <xs:attributeGroup ref="table.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="table.attlist">
    <xs:attribute name="frame" type="tbl.frame.attval"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attributeGroup ref="tbl.table.att"/>
    <xs:attributeGroup ref="bodyatt"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="tgroup">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.tgroup.mdl">
          <xs:attributeGroup ref="tgroup.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tgroup.attlist">
    <xs:attribute name="cols" use="required"/>
    <xs:attributeGroup ref="tbl.tgroup.att"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="colspec">
    <xs:complexType>
      <xs:attributeGroup ref="colspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="colspec.attlist">
    <xs:attribute name="colnum"/>
    <xs:attribute name="colname"/>
    <xs:attribute name="colwidth"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <xs:element name="spanspec">
    <xs:complexType>
      <xs:attributeGroup ref="spanspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="spanspec.attlist">
    <xs:attribute name="namest" use="required"/>
    <xs:attribute name="nameend" use="required"/>
    <xs:attribute name="spanname" use="required"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <xs:element name="thead">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.hdft.mdl">
          <xs:attributeGroup ref="thead.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="thead.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="tfoot">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.hdft.mdl">
          <xs:attributeGroup ref="tfoot.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tfoot.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="tbody">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.tbody.mdl">
          <xs:attributeGroup ref="tbody.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tbody.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="row">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.row.mdl">
          <xs:attributeGroup ref="row.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="row.attlist">
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="entrytbl">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.entrytbl.mdl">
          <xs:attributeGroup ref="entrytbl.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="entrytbl.attlist">
    <xs:attribute name="cols" use="required"/>
    <xs:attributeGroup ref="tbl.tgroup.att"/>
    <xs:attribute name="colname"/>
    <xs:attribute name="spanname"/>
    <xs:attribute name="namest"/>
    <xs:attribute name="nameend"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <xs:element name="entry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="tbl.entry.mdl"/>
      <xs:attributeGroup ref="entry.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="entry.attlist">
    <xs:attribute name="colname"/>
    <xs:attribute name="namest"/>
    <xs:attribute name="nameend"/>
    <xs:attribute name="spanname"/>
    <xs:attribute name="morerows"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attribute name="rotate" type="yesorno"/>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
</xs:schema>
<!-- End of DocBook CALS Table Model V4.4 ................................. -->
<!-- ...................................................................... -->
 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook document hierarchy module V4.4 ............................... -->
<!-- File dbhierx.mod ..................................................... -->
<!--
  Copyright 1992-2004 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: dbhierx.mod,v 1.38 2005/01/27 13:52:00 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the overall document
  hierarchies of DocBook documents.  It covers computer documentation
  manuals and manual fragments, as well as reference entries (such as
  man pages) and technical journals or anthologies containing
  articles.
  
  This module depends on the DocBook information pool module.  All
  elements and entities referenced but not defined here are assumed
  to be defined in the information pool module.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % dbhier PUBLIC
  "-//OASIS//ELEMENTS DocBook Document Hierarchy V4.4//EN"
  "dbhierx.mod">
  %dbhier;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ...................................................................... -->
<!-- Entities for module inclusions ....................................... -->
<!-- ...................................................................... -->
<!-- Entities for element classes ......................................... -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <xs:element name="appendix.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="appendixinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="appendix.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="article.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="articleinfo"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="lot"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:group ref="nav.class"/>
          <xs:element ref="appendix.class"/>
          <xs:element ref="ackno"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="article.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="book.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="bookinfo"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="dedication"/>
          <xs:element ref="toc"/>
          <xs:element ref="lot"/>
          <xs:element ref="glossary"/>
          <xs:element ref="bibliography"/>
          <xs:element ref="preface"/>
          <xs:element ref="chapter.class"/>
          <xs:element ref="reference"/>
          <xs:element ref="part"/>
          <xs:element ref="article.class"/>
          <xs:element ref="appendix.class"/>
          <xs:group ref="index.class"/>
          <xs:element ref="colophon"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="book.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="chapter.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="chapterinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="chapter.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:group name="index.class">
    <xs:choice>
      <xs:element ref="index"/>
      <xs:element ref="setindex"/>
    </xs:choice>
  </xs:group>
  <xs:element name="refentry.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" ref="refentryinfo"/>
        <xs:element minOccurs="0" ref="refmeta"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="remark"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
        <xs:element maxOccurs="unbounded" ref="refnamediv"/>
        <xs:element minOccurs="0" ref="refsynopsisdiv"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="refsect1"/>
          <xs:element maxOccurs="unbounded" ref="refsection"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="section.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sectioninfo"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="section.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="section.class"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="section.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:group name="nav.class">
    <xs:choice>
      <xs:element ref="toc"/>
      <xs:element ref="lot"/>
      <xs:element ref="index"/>
      <xs:element ref="glossary"/>
      <xs:element ref="bibliography"/>
    </xs:choice>
  </xs:group>
  <!-- Redeclaration placeholder ............................................ -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- ...................................................................... -->
  <!-- Entities for element mixtures ........................................ -->
  <xs:group name="divcomponent.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refcomponent.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="indexdivcomponent.mix">
    <xs:choice>
      <xs:element ref="itemizedlist"/>
      <xs:element ref="orderedlist"/>
      <xs:element ref="variablelist"/>
      <xs:element ref="simplelist"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="anchor"/>
      <xs:element ref="remark"/>
      <xs:element ref="link.char.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refname.char.mix">
    <xs:sequence>
      <xs:element minOccurs="0" ref="tech.char.class"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="partcontent.mix">
    <xs:choice>
      <xs:element ref="appendix.class"/>
      <xs:element ref="chapter.class"/>
      <xs:group ref="nav.class"/>
      <xs:element ref="article.class"/>
      <xs:element ref="preface"/>
      <xs:element ref="refentry.class"/>
      <xs:element ref="reference"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refinline.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="refclass.char.mix">
    <xs:sequence>
      <xs:element minOccurs="0" ref="application"/>
    </xs:sequence>
  </xs:group>
  <!-- Redeclaration placeholder 2 .......................................... -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- ...................................................................... -->
  <!-- Entities for content models .......................................... -->
  <xs:group name="div.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="bookcomponent.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="sect.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="refsect.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="bookcomponent.content">
    <xs:choice>
      <xs:sequence>
        <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect1"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="section.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="sect1"/>
        <xs:element maxOccurs="unbounded" ref="refentry.class"/>
        <xs:element maxOccurs="unbounded" ref="simplesect"/>
        <xs:element maxOccurs="unbounded" ref="section.class"/>
      </xs:choice>
    </xs:choice>
  </xs:group>
  <!-- ...................................................................... -->
  <!-- Set and SetInfo ...................................................... -->
  <xs:attributeGroup name="set.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="set">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="setinfo"/>
        <xs:element minOccurs="0" ref="toc"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="set"/>
          <xs:element ref="book.class"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="setindex"/>
      </xs:sequence>
      <xs:attributeGroup ref="set.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of set.element -->
  <!-- FPI: SGML formal public identifier -->
  <xs:attributeGroup name="set.attlist">
    <xs:attribute name="fpi"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="set.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of set.attlist -->
  <!-- end of set.module -->
  <xs:attributeGroup name="setinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="setinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="setinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setinfo.element -->
  <!--
    Contents: IDs of the ToC, Books, and SetIndex that comprise
    the set, in the order of their appearance
  -->
  <xs:attributeGroup name="setinfo.attlist">
    <xs:attribute name="contents" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="setinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setinfo.attlist -->
  <!-- end of setinfo.module -->
  <!-- end of set.content.module -->
  <!-- ...................................................................... -->
  <!-- Book and BookInfo .................................................... -->
  <xs:attributeGroup name="book.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="book" substitutionGroup="book.class"/>
  <!-- end of book.element -->
  <!-- FPI: SGML formal public identifier -->
  <xs:attributeGroup name="book.attlist">
    <xs:attribute name="fpi"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="book.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of book.attlist -->
  <!-- end of book.module -->
  <xs:attributeGroup name="bookinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bookinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="bookinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bookinfo.element -->
  <!--
    Contents: IDs of the ToC, LoTs, Prefaces, Parts, Chapters,
    Appendixes, References, GLossary, Bibliography, and indexes
    comprising the Book, in the order of their appearance
  -->
  <xs:attributeGroup name="bookinfo.attlist">
    <xs:attribute name="contents" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bookinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bookinfo.attlist -->
  <!-- end of bookinfo.module -->
  <!-- end of book.content.module -->
  <!-- ...................................................................... -->
  <!-- Dedication, ToC, and LoT ............................................. -->
  <xs:attributeGroup name="dedication.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="dedication">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="legalnotice.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="dedication.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of dedication.element -->
  <xs:attributeGroup name="dedication.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="dedication.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of dedication.attlist -->
  <!-- end of dedication.module -->
  <xs:attributeGroup name="colophon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="colophon">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="textobject.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="colophon.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of colophon.element -->
  <xs:attributeGroup name="colophon.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="colophon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of colophon.attlist -->
  <!-- end of colophon.module -->
  <xs:attributeGroup name="toc.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toc">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocfront"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="tocpart"/>
          <xs:element ref="tocchap"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocback"/>
      </xs:sequence>
      <xs:attributeGroup ref="toc.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toc.element -->
  <xs:attributeGroup name="toc.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toc.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toc.attlist -->
  <!-- end of toc.module -->
  <xs:attributeGroup name="tocfront.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocfront">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocfront.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocfront.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocfront.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocfront.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocfront.attlist -->
  <!-- end of tocfront.module -->
  <xs:attributeGroup name="tocentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocentry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocentry.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocentry.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocentry.attlist -->
  <!-- end of tocentry.module -->
  <xs:attributeGroup name="tocpart.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocpart">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocchap"/>
      </xs:sequence>
      <xs:attributeGroup ref="tocpart.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocpart.element -->
  <xs:attributeGroup name="tocpart.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocpart.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocpart.attlist -->
  <!-- end of tocpart.module -->
  <xs:attributeGroup name="tocchap.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocchap">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel1"/>
      </xs:sequence>
      <xs:attributeGroup ref="tocchap.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocchap.element -->
  <xs:attributeGroup name="tocchap.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocchap.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocchap.attlist -->
  <!-- end of tocchap.module -->
  <xs:attributeGroup name="toclevel1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel1">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel2"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel1.element -->
  <xs:attributeGroup name="toclevel1.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel1.attlist -->
  <!-- end of toclevel1.module -->
  <xs:attributeGroup name="toclevel2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel2">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel3"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel2.element -->
  <xs:attributeGroup name="toclevel2.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel2.attlist -->
  <!-- end of toclevel2.module -->
  <xs:attributeGroup name="toclevel3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel3">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel4"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel3.element -->
  <xs:attributeGroup name="toclevel3.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel3.attlist -->
  <!-- end of toclevel3.module -->
  <xs:attributeGroup name="toclevel4.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel4">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel5"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel4.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel4.element -->
  <xs:attributeGroup name="toclevel4.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel4.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel4.attlist -->
  <!-- end of toclevel4.module -->
  <xs:attributeGroup name="toclevel5.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="toclevel5">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel5.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel5.element -->
  <xs:attributeGroup name="toclevel5.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel5.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel5.attlist -->
  <!-- end of toclevel5.module -->
  <xs:attributeGroup name="tocback.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tocback">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocback.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocback.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocback.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocback.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocback.attlist -->
  <!-- end of tocback.module -->
  <!-- end of toc.content.module -->
  <xs:attributeGroup name="lot.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lot">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="lotentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="lot.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lot.element -->
  <xs:attributeGroup name="lot.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lot.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lot.attlist -->
  <!-- end of lot.module -->
  <xs:attributeGroup name="lotentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lotentry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="lotentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lotentry.element -->
  <!--
    SrcCredit: Information about the source of the entry,
    as for a list of illustrations
  -->
  <!-- linkend: to element that this entry represents -->
  <xs:attributeGroup name="lotentry.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attribute name="srccredit"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lotentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lotentry.attlist -->
  <!-- end of lotentry.module -->
  <!-- end of lot.content.module -->
  <!-- ...................................................................... -->
  <!-- Appendix, Chapter, Part, Preface, Reference, PartIntro ............... -->
  <xs:attributeGroup name="appendix.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="appendix" substitutionGroup="appendix.class"/>
  <!-- end of appendix.element -->
  <xs:attributeGroup name="appendix.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="appendix.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of appendix.attlist -->
  <!-- end of appendix.module -->
  <xs:attributeGroup name="chapter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="chapter" substitutionGroup="chapter.class"/>
  <!-- end of chapter.element -->
  <xs:attributeGroup name="chapter.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="chapter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of chapter.attlist -->
  <!-- end of chapter.module -->
  <!--
    Note that Part was to have its content model reduced in V4.4.  This
    change will not be made after all.
  -->
  <xs:attributeGroup name="part.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="part">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="partinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" ref="partintro"/>
        <xs:group maxOccurs="unbounded" ref="partcontent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="part.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of part.element -->
  <xs:attributeGroup name="part.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="part.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of part.attlist -->
  <!-- ELEMENT PartIntro (defined below) -->
  <!-- end of part.module -->
  <xs:attributeGroup name="preface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="preface">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="prefaceinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="preface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of preface.element -->
  <xs:attributeGroup name="preface.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="preface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of preface.attlist -->
  <!-- end of preface.module -->
  <xs:attributeGroup name="reference.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="reference">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="referenceinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" ref="partintro"/>
        <xs:element maxOccurs="unbounded" ref="refentry.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="reference.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of reference.element -->
  <xs:attributeGroup name="reference.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="reference.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of reference.attlist -->
  <!-- ELEMENT PartIntro (defined below) -->
  <!-- end of reference.module -->
  <xs:attributeGroup name="partintro.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="partintro">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:group ref="bookcomponent.content"/>
      </xs:sequence>
      <xs:attributeGroup ref="partintro.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of partintro.element -->
  <xs:attributeGroup name="partintro.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="partintro.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of partintro.attlist -->
  <!-- end of partintro.module -->
  <!-- ...................................................................... -->
  <!-- Other Info elements .................................................. -->
  <xs:attributeGroup name="appendixinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="appendixinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="appendixinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of appendixinfo.element -->
  <xs:attributeGroup name="appendixinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="appendixinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of appendixinfo.attlist -->
  <!-- end of appendixinfo.module -->
  <xs:attributeGroup name="bibliographyinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliographyinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="bibliographyinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliographyinfo.element -->
  <xs:attributeGroup name="bibliographyinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliographyinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliographyinfo.attlist -->
  <!-- end of bibliographyinfo.module -->
  <xs:attributeGroup name="chapterinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="chapterinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="chapterinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of chapterinfo.element -->
  <xs:attributeGroup name="chapterinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="chapterinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of chapterinfo.attlist -->
  <!-- end of chapterinfo.module -->
  <xs:attributeGroup name="glossaryinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossaryinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="glossaryinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossaryinfo.element -->
  <xs:attributeGroup name="glossaryinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossaryinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossaryinfo.attlist -->
  <!-- end of glossaryinfo.module -->
  <xs:attributeGroup name="indexinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="indexinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexinfo.element -->
  <xs:attributeGroup name="indexinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexinfo.attlist -->
  <!-- end of indexinfo.module -->
  <xs:attributeGroup name="setindexinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="setindexinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="setindexinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setindexinfo.element -->
  <xs:attributeGroup name="setindexinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="setindexinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setindexinfo.attlist -->
  <!-- end of setindexinfo.module -->
  <xs:attributeGroup name="partinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="partinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="partinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of partinfo.element -->
  <xs:attributeGroup name="partinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="partinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of partinfo.attlist -->
  <!-- end of partinfo.module -->
  <xs:attributeGroup name="prefaceinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="prefaceinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="prefaceinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of prefaceinfo.element -->
  <xs:attributeGroup name="prefaceinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="prefaceinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of prefaceinfo.attlist -->
  <!-- end of prefaceinfo.module -->
  <xs:attributeGroup name="refentryinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refentryinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refentryinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refentryinfo.element -->
  <xs:attributeGroup name="refentryinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentryinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentryinfo.attlist -->
  <!-- end of refentryinfo.module -->
  <xs:attributeGroup name="refsectioninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsectioninfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsectioninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsectioninfo.element -->
  <xs:attributeGroup name="refsectioninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsectioninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsectioninfo.attlist -->
  <!-- end of refsectioninfo.module -->
  <xs:attributeGroup name="refsect1info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect1info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect1info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect1info.element -->
  <xs:attributeGroup name="refsect1info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect1info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect1info.attlist -->
  <!-- end of refsect1info.module -->
  <xs:attributeGroup name="refsect2info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect2info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect2info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect2info.element -->
  <xs:attributeGroup name="refsect2info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect2info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect2info.attlist -->
  <!-- end of refsect2info.module -->
  <xs:attributeGroup name="refsect3info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect3info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect3info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect3info.element -->
  <xs:attributeGroup name="refsect3info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect3info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect3info.attlist -->
  <!-- end of refsect3info.module -->
  <xs:attributeGroup name="refsynopsisdivinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsynopsisdivinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsynopsisdivinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsynopsisdivinfo.element -->
  <xs:attributeGroup name="refsynopsisdivinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsynopsisdivinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsynopsisdivinfo.attlist -->
  <!-- end of refsynopsisdivinfo.module -->
  <xs:attributeGroup name="referenceinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="referenceinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="referenceinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of referenceinfo.element -->
  <xs:attributeGroup name="referenceinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="referenceinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of referenceinfo.attlist -->
  <!-- end of referenceinfo.module -->
  <xs:attributeGroup name="sect1info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect1info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect1info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect1info.element -->
  <xs:attributeGroup name="sect1info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect1info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect1info.attlist -->
  <xs:attributeGroup name="sect2info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect2info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect2info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect2info.element -->
  <xs:attributeGroup name="sect2info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect2info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect2info.attlist -->
  <xs:attributeGroup name="sect3info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect3info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect3info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect3info.element -->
  <xs:attributeGroup name="sect3info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect3info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect3info.attlist -->
  <xs:attributeGroup name="sect4info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect4info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect4info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect4info.element -->
  <xs:attributeGroup name="sect4info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect4info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect4info.attlist -->
  <xs:attributeGroup name="sect5info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect5info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect5info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect5info.element -->
  <xs:attributeGroup name="sect5info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect5info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect5info.attlist -->
  <!-- ...................................................................... -->
  <!-- Section (parallel to Sect*) ......................................... -->
  <xs:attributeGroup name="section.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="section" substitutionGroup="section.class"/>
  <!-- end of section.element -->
  <xs:attributeGroup name="section.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="section.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of section.attlist -->
  <!-- end of section.module -->
  <xs:attributeGroup name="sectioninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sectioninfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sectioninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sectioninfo.element -->
  <xs:attributeGroup name="sectioninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sectioninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sectioninfo.attlist -->
  <!-- end of sectioninfo.module -->
  <!-- end of section.content.module -->
  <!-- ...................................................................... -->
  <!-- Sect1, Sect2, Sect3, Sect4, Sect5 .................................... -->
  <xs:attributeGroup name="sect1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect1">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect1info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect2"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect2"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect1.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect1.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect1.attlist -->
  <!-- end of sect1.module -->
  <xs:attributeGroup name="sect2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect2">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect2info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect3"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect3"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect2.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect2.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect2.attlist -->
  <!-- end of sect2.module -->
  <xs:attributeGroup name="sect3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect3">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect3info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect4"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect4"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect3.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect3.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect3.attlist -->
  <!-- end of sect3.module -->
  <xs:attributeGroup name="sect4.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect4">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect4info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect5"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect5"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect4.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect4.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect4.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect4.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect4.attlist -->
  <!-- end of sect4.module -->
  <xs:attributeGroup name="sect5.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sect5">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect5info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect5.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect5.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect5.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect5.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect5.attlist -->
  <!-- end of sect5.module -->
  <xs:attributeGroup name="simplesect.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simplesect">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplesect.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplesect.element -->
  <xs:attributeGroup name="simplesect.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplesect.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplesect.attlist -->
  <!-- end of simplesect.module -->
  <!-- ...................................................................... -->
  <!-- Bibliography ......................................................... -->
  <xs:attributeGroup name="bibliography.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliography">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="bibliographyinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="bibliodiv"/>
          <xs:choice maxOccurs="unbounded">
            <xs:element ref="biblioentry"/>
            <xs:element ref="bibliomixed"/>
          </xs:choice>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="bibliography.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliography.element -->
  <xs:attributeGroup name="bibliography.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliography.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliography.attlist -->
  <!-- end of bibliography.module -->
  <xs:attributeGroup name="bibliodiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliodiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="biblioentry"/>
          <xs:element ref="bibliomixed"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="bibliodiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliodiv.element -->
  <xs:attributeGroup name="bibliodiv.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliodiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliodiv.attlist -->
  <!-- end of bibliodiv.module -->
  <!-- end of bibliography.content.module -->
  <!-- ...................................................................... -->
  <!-- Glossary ............................................................. -->
  <xs:attributeGroup name="glossary.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossary">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="glossaryinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="glossdiv"/>
          <xs:element maxOccurs="unbounded" ref="glossentry"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="bibliography"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossary.element -->
  <xs:attributeGroup name="glossary.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossary.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossary.attlist -->
  <!-- end of glossary.module -->
  <xs:attributeGroup name="glossdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:element maxOccurs="unbounded" ref="glossentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossdiv.element -->
  <xs:attributeGroup name="glossdiv.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossdiv.attlist -->
  <!-- end of glossdiv.module -->
  <!-- end of glossary.content.module -->
  <!-- ...................................................................... -->
  <!-- Index and SetIndex ................................................... -->
  <xs:attributeGroup name="indexes.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="index">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="indexinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexdiv"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="index.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of index.element -->
  <xs:attributeGroup name="index.attlist">
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexes.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of index.attlist -->
  <xs:element name="setindex">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="setindexinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexdiv"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="setindex.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setindex.element -->
  <xs:attributeGroup name="setindex.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexes.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setindex.attlist -->
  <!-- end of indexes.module -->
  <!--
    SegmentedList in this content is useful for marking up permuted
    indices.
  -->
  <xs:attributeGroup name="indexdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:sequence>
          <xs:group minOccurs="0" maxOccurs="unbounded" ref="indexdivcomponent.mix"/>
          <xs:choice>
            <xs:element maxOccurs="unbounded" ref="indexentry"/>
            <xs:element ref="segmentedlist"/>
          </xs:choice>
        </xs:sequence>
      </xs:sequence>
      <xs:attributeGroup ref="indexdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexdiv.element -->
  <xs:attributeGroup name="indexdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexdiv.attlist -->
  <!-- end of indexdiv.module -->
  <!-- Index entries appear in the index, not the text. -->
  <xs:attributeGroup name="indexentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="primaryie"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="seeie"/>
          <xs:element ref="seealsoie"/>
        </xs:choice>
        <xs:sequence minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="secondaryie"/>
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="seeie"/>
            <xs:element ref="seealsoie"/>
            <xs:element ref="tertiaryie"/>
          </xs:choice>
        </xs:sequence>
      </xs:sequence>
      <xs:attributeGroup ref="indexentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexentry.element -->
  <xs:attributeGroup name="indexentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexentry.attlist -->
  <!-- end of indexentry.module -->
  <xs:attributeGroup name="primsecterie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="primaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="primaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of primaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="primaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of primaryie.attlist -->
  <xs:element name="secondaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="secondaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of secondaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="secondaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of secondaryie.attlist -->
  <xs:element name="tertiaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="tertiaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tertiaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="tertiaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tertiaryie.attlist -->
  <!-- end of primsecterie.module -->
  <xs:attributeGroup name="seeie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seeie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seeie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seeie.element -->
  <!-- to IndexEntry to look up -->
  <xs:attributeGroup name="seeie.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seeie.attlist -->
  <!-- end of seeie.module -->
  <xs:attributeGroup name="seealsoie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seealsoie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seealsoie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seealsoie.element -->
  <!-- to related IndexEntries -->
  <xs:attributeGroup name="seealsoie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seealsoie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seealsoie.attlist -->
  <!-- end of seealsoie.module -->
  <!-- end of index.content.module -->
  <!-- ...................................................................... -->
  <!-- RefEntry ............................................................. -->
  <xs:attributeGroup name="refentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refentry" substitutionGroup="refentry.class"/>
  <!-- end of refentry.element -->
  <xs:attributeGroup name="refentry.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentry.attlist -->
  <!-- end of refentry.module -->
  <xs:attributeGroup name="refmeta.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refmeta">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element ref="refentrytitle"/>
        <xs:element minOccurs="0" ref="manvolnum"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="refmiscinfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="refmeta.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refmeta.element -->
  <xs:attributeGroup name="refmeta.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refmeta.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refmeta.attlist -->
  <!-- end of refmeta.module -->
  <xs:attributeGroup name="refmiscinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refmiscinfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="refmiscinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refmiscinfo.element -->
  <!-- Class: Freely assignable parameter; no default -->
  <xs:attributeGroup name="refmiscinfo.attlist">
    <xs:attribute name="class"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refmiscinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refmiscinfo.attlist -->
  <!-- end of refmiscinfo.module -->
  <xs:attributeGroup name="refnamediv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refnamediv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refdescriptor"/>
        <xs:element maxOccurs="unbounded" ref="refname"/>
        <xs:element ref="refpurpose"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="refclass"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="remark"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refnamediv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refnamediv.element -->
  <xs:attributeGroup name="refnamediv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refnamediv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refnamediv.attlist -->
  <!-- end of refnamediv.module -->
  <xs:attributeGroup name="refdescriptor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refdescriptor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refname.char.mix"/>
      <xs:attributeGroup ref="refdescriptor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refdescriptor.element -->
  <xs:attributeGroup name="refdescriptor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refdescriptor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refdescriptor.attlist -->
  <!-- end of refdescriptor.module -->
  <xs:attributeGroup name="refname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refname.char.mix"/>
      <xs:attributeGroup ref="refname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refname.element -->
  <xs:attributeGroup name="refname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refname.attlist -->
  <!-- end of refname.module -->
  <xs:attributeGroup name="refpurpose.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refpurpose">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refinline.char.mix"/>
      <xs:attributeGroup ref="refpurpose.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refpurpose.element -->
  <xs:attributeGroup name="refpurpose.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refpurpose.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refpurpose.attlist -->
  <!-- end of refpurpose.module -->
  <xs:attributeGroup name="refclass.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refclass">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refclass.char.mix"/>
      <xs:attributeGroup ref="refclass.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refclass.element -->
  <xs:attributeGroup name="refclass.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refclass.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refclass.attlist -->
  <!-- end of refclass.module -->
  <xs:attributeGroup name="refsynopsisdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsynopsisdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsynopsisdivinfo"/>
        <xs:group minOccurs="0" ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect2"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect2"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsynopsisdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsynopsisdiv.element -->
  <xs:attributeGroup name="refsynopsisdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsynopsisdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsynopsisdiv.attlist -->
  <!-- end of refsynopsisdiv.module -->
  <xs:attributeGroup name="refsection.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsection">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsectioninfo"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsection"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsection"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsection.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsection.element -->
  <xs:attributeGroup name="refsection.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsection.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsection.attlist -->
  <!-- end of refsection.module -->
  <xs:attributeGroup name="refsect1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect1">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect1info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect2"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect2"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsect1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect1.element -->
  <xs:attributeGroup name="refsect1.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect1.attlist -->
  <!-- end of refsect1.module -->
  <xs:attributeGroup name="refsect2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect2">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect2info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect3"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect3"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsect2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect2.element -->
  <xs:attributeGroup name="refsect2.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect2.attlist -->
  <!-- end of refsect2.module -->
  <xs:attributeGroup name="refsect3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refsect3">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect3info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="refsect3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect3.element -->
  <xs:attributeGroup name="refsect3.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect3.attlist -->
  <!-- end of refsect3.module -->
  <!-- end of refentry.content.module -->
  <!-- ...................................................................... -->
  <!-- Article .............................................................. -->
  <!--
    An Article is a chapter-level, stand-alone document that is often,
    but need not be, collected into a Book.
  -->
  <xs:attributeGroup name="article.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="article" substitutionGroup="article.class"/>
  <!-- end of article.element -->
  <!--
    Class: Indicates the type of a particular article;
    all articles have the same structure and general purpose.
    No default.
  -->
  <!-- ParentBook: ID of the enclosing Book -->
  <xs:attributeGroup name="article.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="journalarticle"/>
          <xs:enumeration value="productsheet"/>
          <xs:enumeration value="whitepaper"/>
          <xs:enumeration value="techreport"/>
          <xs:enumeration value="specification"/>
          <xs:enumeration value="faq"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="parentbook" type="xs:IDREF"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="article.role.attrib"/>
  </xs:attributeGroup>
</xs:schema>
<!-- end of article.attlist -->
<!-- end of article.module -->
<!-- End of DocBook document hierarchy module V4.4 ........................ -->
<!-- ...................................................................... -->
 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 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook XML information pool module V4.4 ............................. -->
<!-- File dbpoolx.mod ..................................................... -->
<!--
  Copyright 1992-2004 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: dbpoolx.mod,v 1.107 2005/01/27 13:52:00 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook XML DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook XML DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the objects, inline
  elements, and so on that are available to be used as the main
  content of DocBook documents.  Some elements are useful for general
  publishing, and others are useful specifically for computer
  documentation.
  
  This module has the following dependencies on other modules:
  
  o It assumes that a %notation.class; entity is defined by the
    driver file or other high-level module.  This entity is
    referenced in the NOTATION attributes for the graphic-related and
    ModeSpec elements.
  
  o It assumes that an appropriately parameterized table module is
    available for use with the table-related elements.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % dbpool PUBLIC
  "-//OASIS//ELEMENTS DocBook XML Information Pool V4.4//EN"
  "dbpoolx.mod">
  %dbpool;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ...................................................................... -->
<!-- Forms entities ....................................................... -->
<!-- These PEs provide the hook by which the forms module can be inserted -->
<!-- into the DTD. -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:include schemaLocation="htmltblx.xsd"/>
  <xs:include schemaLocation="calstblx.xsd"/>
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <!-- ...................................................................... -->
  <!-- General-purpose semantics entities ................................... -->
  <xs:simpleType name="yesorno.attvals">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <!-- ...................................................................... -->
  <!-- Entities for module inclusions ....................................... -->
  <!-- ...................................................................... -->
  <!-- Entities for element classes and mixtures ............................ -->
  <!-- "Ubiquitous" classes: ndxterm.class and beginpage -->
  <xs:element name="ndxterm.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="primary"/>
        <xs:choice minOccurs="0">
          <xs:sequence>
            <xs:element ref="secondary"/>
            <xs:choice minOccurs="0">
              <xs:sequence>
                <xs:element ref="tertiary"/>
                <xs:choice minOccurs="0">
                  <xs:element ref="see"/>
                  <xs:element maxOccurs="unbounded" ref="seealso"/>
                </xs:choice>
              </xs:sequence>
              <xs:element ref="see"/>
              <xs:element maxOccurs="unbounded" ref="seealso"/>
            </xs:choice>
          </xs:sequence>
          <xs:element ref="see"/>
          <xs:element maxOccurs="unbounded" ref="seealso"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="indexterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- Object-level classes ................................................. -->
  <xs:element name="list.class" abstract="true"/>
  <xs:element name="admon.class" abstract="true"/>
  <xs:element name="linespecific.class" abstract="true"/>
  <xs:element name="method.synop.class" abstract="true" substitutionGroup="synop.class"/>
  <xs:element name="synop.class" abstract="true"/>
  <xs:element name="para.class" abstract="true"/>
  <xs:element name="informal.class" abstract="true"/>
  <xs:element name="formal.class" abstract="true"/>
  <!-- The DocBook TC may produce an official EBNF module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:element name="compound.class" abstract="true"/>
  <xs:group name="genobj.class">
    <xs:choice>
      <xs:element ref="anchor"/>
      <xs:element ref="bridgehead"/>
      <xs:element ref="remark"/>
      <xs:element ref="highlights"/>
    </xs:choice>
  </xs:group>
  <xs:group name="descobj.class">
    <xs:choice>
      <xs:element ref="abstract"/>
      <xs:element ref="authorblurb"/>
      <xs:element ref="epigraph"/>
    </xs:choice>
  </xs:group>
  <!-- Character-level classes .............................................. -->
  <xs:element name="xref.char.class" abstract="true"/>
  <xs:element name="gen.char.class" abstract="true"/>
  <xs:element name="link.char.class" abstract="true"/>
  <!-- The DocBook TC may produce an official EBNF module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:element name="tech.char.class" abstract="true"/>
  <xs:group name="base.char.class">
    <xs:sequence>
      <xs:element ref="anchor"/>
    </xs:sequence>
  </xs:group>
  <xs:element name="docinfo.char.class" abstract="true"/>
  <xs:group name="other.char.class">
    <xs:choice>
      <xs:element ref="remark"/>
      <xs:element ref="subscript"/>
      <xs:element ref="superscript"/>
    </xs:choice>
  </xs:group>
  <xs:element name="inlineobj.char.class" abstract="true"/>
  <!-- ...................................................................... -->
  <!-- Entities for content models .......................................... -->
  <xs:group name="formalobject.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <!-- Redeclaration placeholder ............................................ -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- Object-level mixtures ................................................ -->
  <!--
                          list admn line synp para infm form cmpd gen  desc
    Component mixture       X    X    X    X    X    X    X    X    X    X
    Sidebar mixture         X    X    X    X    X    X    X    a    X
    Footnote mixture        X         X    X    X    X
    Example mixture         X         X    X    X    X
    Highlights mixture      X    X              X
    Paragraph mixture       X         X    X         X
    Admonition mixture      X         X    X    X    X    X    b    c
    Figure mixture                    X    X         X
    Table entry mixture     X    X    X         X    d
    Glossary def mixture    X         X    X    X    X         e
    Legal notice mixture    X    X    X         X    f
    
    a. Just Procedure; not Sidebar itself or MsgSet.
    b. No MsgSet.
    c. No Highlights.
    d. Just Graphic; no other informal objects.
    e. No Anchor, BridgeHead, or Highlights.
    f. Just BlockQuote; no other informal objects.
  -->
  <xs:group name="component.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="sidebar.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="qandaset.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="revdescription.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="footnote.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="example.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="highlights.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <!--
    %formal.class; is explicitly excluded from many contexts in which
    paragraphs are used
  -->
  <xs:group name="para.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="admon.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:element ref="sidebar"/>
      <xs:element ref="anchor"/>
      <xs:element ref="bridgehead"/>
      <xs:element ref="remark"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="figure.mix">
    <xs:choice>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="tabentry.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="graphic"/>
      <xs:element ref="mediaobject"/>
    </xs:choice>
  </xs:group>
  <xs:group name="glossdef.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="remark"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="legalnotice.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="blockquote"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="textobject.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="blockquote"/>
    </xs:choice>
  </xs:group>
  <xs:element name="mediaobject.mix" abstract="true"/>
  <xs:group name="listpreamble.mix">
    <xs:choice>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <!-- Character-level mixtures ............................................. -->
  <!-- sgml.features -->
  <!-- not [sgml.features[ -->
  <!-- ]] not sgml.features -->
  <!--
                        #PCD xref word link cptr base dnfo othr inob (synop)
    para.char.mix         X    X    X    X    X    X    X    X    X
    title.char.mix        X    X    X    X    X    X    X    X    X
    ndxterm.char.mix      X    X    X    X    X    X    X    X    a
    cptr.char.mix         X              X    X    X         X    a
    smallcptr.char.mix    X                   b                   a
    word.char.mix         X         c    X         X         X    a
    docinfo.char.mix      X         d    X    b              X    a
    
    a. Just InlineGraphic; no InlineEquation.
    b. Just Replaceable; no other computer terms.
    c. Just Emphasis and Trademark; no other word elements.
    d. Just Acronym, Emphasis, and Trademark; no other word elements.
  -->
  <xs:group name="para.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlineobj.char.class"/>
        <xs:element ref="synop.class"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="title.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlineobj.char.class"/>
        <xs:element ref="ndxterm.class"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="ndxterm.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="cptr.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="smallcptr.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="replaceable"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="word.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="acronym"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="trademark"/>
        <xs:element ref="link.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="docinfo.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="trademark"/>
        <xs:element ref="replaceable"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <!-- ENTITY % bibliocomponent.mix (see Bibliographic section, below) -->
  <!-- ENTITY % person.ident.mix (see Bibliographic section, below) -->
  <!-- ...................................................................... -->
  <!-- Entities for attributes and attribute components ..................... -->
  <!-- Effectivity attributes ............................................... -->
  <!--
    Arch: Computer or chip architecture to which element applies; no
    default
  -->
  <xs:attributeGroup name="arch.attrib">
    <xs:attribute name="arch"/>
  </xs:attributeGroup>
  <!-- Condition: General-purpose effectivity attribute -->
  <xs:attributeGroup name="condition.attrib">
    <xs:attribute name="condition"/>
  </xs:attributeGroup>
  <!-- Conformance: Standards conformance characteristics -->
  <xs:attributeGroup name="conformance.attrib">
    <xs:attribute name="conformance" type="xs:NMTOKENS"/>
  </xs:attributeGroup>
  <!-- OS: Operating system to which element applies; no default -->
  <xs:attributeGroup name="os.attrib">
    <xs:attribute name="os"/>
  </xs:attributeGroup>
  <!-- Revision: Editorial revision to which element belongs; no default -->
  <xs:attributeGroup name="revision.attrib">
    <xs:attribute name="revision"/>
  </xs:attributeGroup>
  <!-- Security: Security classification; no default -->
  <xs:attributeGroup name="security.attrib">
    <xs:attribute name="security"/>
  </xs:attributeGroup>
  <!--
    UserLevel: Level of user experience to which element applies; no
    default
  -->
  <xs:attributeGroup name="userlevel.attrib">
    <xs:attribute name="userlevel"/>
  </xs:attributeGroup>
  <!-- Vendor: Computer vendor to which element applies; no default -->
  <xs:attributeGroup name="vendor.attrib">
    <xs:attribute name="vendor"/>
  </xs:attributeGroup>
  <!-- Wordsize: Computer word size (32 bit, 64 bit, etc.); no default -->
  <xs:attributeGroup name="wordsize.attrib">
    <xs:attribute name="wordsize"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="effectivity.attrib">
    <xs:attributeGroup ref="arch.attrib"/>
    <xs:attributeGroup ref="condition.attrib"/>
    <xs:attributeGroup ref="conformance.attrib"/>
    <xs:attributeGroup ref="os.attrib"/>
    <xs:attributeGroup ref="revision.attrib"/>
    <xs:attributeGroup ref="security.attrib"/>
    <xs:attributeGroup ref="userlevel.attrib"/>
    <xs:attributeGroup ref="vendor.attrib"/>
    <xs:attributeGroup ref="wordsize.attrib"/>
  </xs:attributeGroup>
  <!-- Common attributes .................................................... -->
  <!-- Id: Unique identifier of element; no default -->
  <xs:attributeGroup name="id.attrib">
    <xs:attribute name="id" type="xs:ID"/>
  </xs:attributeGroup>
  <!--
    Id: Unique identifier of element; a value must be supplied; no
    default
  -->
  <xs:attributeGroup name="idreq.attrib">
    <xs:attribute name="id" use="required" type="xs:ID"/>
  </xs:attributeGroup>
  <!--
    Lang: Indicator of language in which element is written, for
    translation, character set management, etc.; no default
  -->
  <xs:attributeGroup name="lang.attrib">
    <xs:attribute name="lang"/>
  </xs:attributeGroup>
  <!-- Remap: Previous role of element before conversion; no default -->
  <xs:attributeGroup name="remap.attrib">
    <xs:attribute name="remap"/>
  </xs:attributeGroup>
  <!-- Role: New role of element in local environment; no default -->
  <xs:attributeGroup name="role.attrib">
    <xs:attribute name="role"/>
  </xs:attributeGroup>
  <!--
    XRefLabel: Alternate labeling string for XRef text generation;
    default is usually title or other appropriate label text already
    contained in element
  -->
  <xs:attributeGroup name="xreflabel.attrib">
    <xs:attribute name="xreflabel"/>
  </xs:attributeGroup>
  <!--
    RevisionFlag: Revision status of element; default is that element
    wasn't revised
  -->
  <xs:attributeGroup name="revisionflag.attrib">
    <xs:attribute name="revisionflag">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="changed"/>
          <xs:enumeration value="added"/>
          <xs:enumeration value="deleted"/>
          <xs:enumeration value="off"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- dir: Bidirectional override -->
  <xs:attributeGroup name="dir.attrib">
    <xs:attribute name="dir">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="ltr"/>
          <xs:enumeration value="rtl"/>
          <xs:enumeration value="lro"/>
          <xs:enumeration value="rlo"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- xml:base: base URI -->
  <xs:attributeGroup name="xml-base.attrib">
    <xs:attribute ref="xml:base"/>
  </xs:attributeGroup>
  <!-- Role is included explicitly on each element -->
  <xs:attributeGroup name="common.attrib">
    <xs:attributeGroup ref="id.attrib"/>
    <xs:attributeGroup ref="lang.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="dir.attrib"/>
    <xs:attributeGroup ref="xml-base.attrib"/>
  </xs:attributeGroup>
  <!-- Role is included explicitly on each element -->
  <xs:attributeGroup name="idreq.common.attrib">
    <xs:attributeGroup ref="idreq.attrib"/>
    <xs:attributeGroup ref="lang.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="dir.attrib"/>
    <xs:attributeGroup ref="xml-base.attrib"/>
  </xs:attributeGroup>
  <!-- Semi-common attributes and other attribute entities .................. -->
  <!--
    EntityRef: Name of an external entity containing the content
    of the graphic
  -->
  <!--
    FileRef: Filename, qualified by a pathname if desired,
    designating the file containing the content of the graphic
  -->
  <!-- Format: Notation of the element content, if any -->
  <!-- SrcCredit: Information about the source of the Graphic -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="graphics.attrib">
    <xs:attribute name="entityref" type="xs:ENTITY"/>
    <xs:attribute name="fileref"/>
    <xs:attribute name="format" type="notation.class"/>
    <xs:attribute name="srccredit"/>
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
  </xs:attributeGroup>
  <!--
    Action: Key combination type; default is unspecified if one
    child element, Simul if there is more than one; if value is
    Other, the OtherAction attribute must have a nonempty value
  -->
  <!-- OtherAction: User-defined key combination type -->
  <xs:attributeGroup name="keyaction.attrib">
    <xs:attribute name="action">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="click"/>
          <xs:enumeration value="double-click"/>
          <xs:enumeration value="press"/>
          <xs:enumeration value="seq"/>
          <xs:enumeration value="simul"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otheraction"/>
  </xs:attributeGroup>
  <!--
    Label: Identifying number or string; default is usually the
    appropriate number or string autogenerated by a formatter
  -->
  <xs:attributeGroup name="label.attrib">
    <xs:attribute name="label"/>
  </xs:attributeGroup>
  <!-- xml:space: whitespace treatment -->
  <xs:attributeGroup name="xml-space.attrib">
    <xs:attribute ref="xml:space"/>
  </xs:attributeGroup>
  <!--
    Format: whether element is assumed to contain significant white
    space
  -->
  <xs:attributeGroup name="linespecific.attrib">
    <xs:attribute name="format" default="linespecific">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="linespecific"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="xml-space.attrib"/>
    <xs:attribute name="linenumbering">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="numbered"/>
          <xs:enumeration value="unnumbered"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="continuation">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="continues"/>
          <xs:enumeration value="restarts"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="startinglinenumber"/>
    <xs:attribute name="language"/>
  </xs:attributeGroup>
  <!-- Linkend: link to related information; no default -->
  <xs:attributeGroup name="linkend.attrib">
    <xs:attribute name="linkend" type="xs:IDREF"/>
  </xs:attributeGroup>
  <!-- Linkend: required link to related information -->
  <xs:attributeGroup name="linkendreq.attrib">
    <xs:attribute name="linkend" use="required" type="xs:IDREF"/>
  </xs:attributeGroup>
  <!--
    Linkends: link to one or more sets of related information; no
    default
  -->
  <xs:attributeGroup name="linkends.attrib">
    <xs:attribute name="linkends" type="xs:IDREFS"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="mark.attrib">
    <xs:attribute name="mark"/>
  </xs:attributeGroup>
  <!-- MoreInfo: whether element's content has an associated RefEntry -->
  <xs:attributeGroup name="moreinfo.attrib">
    <xs:attribute name="moreinfo" default="none">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="refentry"/>
          <xs:enumeration value="none"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- Pagenum: number of page on which element appears; no default -->
  <xs:attributeGroup name="pagenum.attrib">
    <xs:attribute name="pagenum"/>
  </xs:attributeGroup>
  <!--
    Status: Editorial or publication status of the element
    it applies to, such as "in review" or "approved for distribution"
  -->
  <xs:attributeGroup name="status.attrib">
    <xs:attribute name="status"/>
  </xs:attributeGroup>
  <!--
    Width: width of the longest line in the element to which it
    pertains, in number of characters
  -->
  <xs:attributeGroup name="width.attrib">
    <xs:attribute name="width"/>
  </xs:attributeGroup>
  <!-- ...................................................................... -->
  <!-- Title elements ....................................................... -->
  <xs:attributeGroup name="title.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="title">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="title.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of title.element -->
  <xs:attributeGroup name="title.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="title.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of title.attlist -->
  <!-- end of title.module -->
  <xs:attributeGroup name="titleabbrev.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="titleabbrev">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="titleabbrev.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of titleabbrev.element -->
  <xs:attributeGroup name="titleabbrev.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="titleabbrev.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of titleabbrev.attlist -->
  <!-- end of titleabbrev.module -->
  <xs:attributeGroup name="subtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="subtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subtitle.element -->
  <xs:attributeGroup name="subtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subtitle.attlist -->
  <!-- end of subtitle.module -->
  <!-- ...................................................................... -->
  <!-- Bibliographic entities and elements .................................. -->
  <!--
    The bibliographic elements are typically used in the document
    hierarchy. They do not appear in content models of information
    pool elements.  See also the document information elements,
    below.
  -->
  <xs:group name="person.ident.mix">
    <xs:choice>
      <xs:element ref="honorific"/>
      <xs:element ref="firstname"/>
      <xs:element ref="surname"/>
      <xs:element ref="lineage"/>
      <xs:element ref="othername"/>
      <xs:element ref="affiliation"/>
      <xs:element ref="authorblurb"/>
      <xs:element ref="contrib"/>
    </xs:choice>
  </xs:group>
  <xs:group name="bibliocomponent.mix">
    <xs:choice>
      <xs:element ref="abbrev"/>
      <xs:element ref="abstract"/>
      <xs:element ref="address"/>
      <xs:element ref="artpagenums"/>
      <xs:element ref="author"/>
      <xs:element ref="authorgroup"/>
      <xs:element ref="authorinitials"/>
      <xs:element ref="bibliomisc"/>
      <xs:element ref="biblioset"/>
      <xs:element ref="collab"/>
      <xs:element ref="confgroup"/>
      <xs:element ref="contractnum"/>
      <xs:element ref="contractsponsor"/>
      <xs:element ref="copyright"/>
      <xs:element ref="corpauthor"/>
      <xs:element ref="corpname"/>
      <xs:element ref="corpcredit"/>
      <xs:element ref="date"/>
      <xs:element ref="edition"/>
      <xs:element ref="editor"/>
      <xs:element ref="invpartnumber"/>
      <xs:element ref="isbn"/>
      <xs:element ref="issn"/>
      <xs:element ref="issuenum"/>
      <xs:element ref="orgname"/>
      <xs:element ref="biblioid"/>
      <xs:element ref="citebiblioid"/>
      <xs:element ref="bibliosource"/>
      <xs:element ref="bibliorelation"/>
      <xs:element ref="bibliocoverage"/>
      <xs:element ref="othercredit"/>
      <xs:element ref="pagenums"/>
      <xs:element ref="printhistory"/>
      <xs:element ref="productname"/>
      <xs:element ref="productnumber"/>
      <xs:element ref="pubdate"/>
      <xs:element ref="publisher"/>
      <xs:element ref="publishername"/>
      <xs:element ref="pubsnumber"/>
      <xs:element ref="releaseinfo"/>
      <xs:element ref="revhistory"/>
      <xs:element ref="seriesvolnums"/>
      <xs:element ref="subtitle"/>
      <xs:element ref="title"/>
      <xs:element ref="titleabbrev"/>
      <xs:element ref="volumenum"/>
      <xs:element ref="citetitle"/>
      <xs:element ref="personname"/>
      <xs:group ref="person.ident.mix"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <!-- I don't think this is well placed, but it needs to be here because of -->
  <!-- the reference to bibliocomponent.mix -->
  <xs:group name="info.class">
    <xs:choice>
      <xs:element ref="graphic"/>
      <xs:element ref="mediaobject"/>
      <xs:element ref="legalnotice"/>
      <xs:element ref="modespec"/>
      <xs:element ref="subjectset"/>
      <xs:element ref="keywordset"/>
      <xs:element ref="itermset"/>
      <xs:group ref="bibliocomponent.mix"/>
    </xs:choice>
  </xs:group>
  <!-- BiblioList ........................ -->
  <xs:attributeGroup name="bibliolist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliolist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="biblioentry"/>
          <xs:element ref="bibliomixed"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="bibliolist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliolist.element -->
  <xs:attributeGroup name="bibliolist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliolist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliolist.attlist -->
  <!-- end of bibliolist.module -->
  <xs:attributeGroup name="biblioentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="biblioentry">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="articleinfo"/>
        <xs:group ref="bibliocomponent.mix"/>
      </xs:choice>
      <xs:attributeGroup ref="biblioentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioentry.element -->
  <xs:attributeGroup name="biblioentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioentry.attlist -->
  <!-- end of biblioentry.module -->
  <xs:attributeGroup name="bibliomixed.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliomixed">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="bibliocomponent.mix"/>
        <xs:element ref="bibliomset"/>
      </xs:choice>
      <xs:attributeGroup ref="bibliomixed.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomixed.element -->
  <xs:attributeGroup name="bibliomixed.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomixed.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomixed.attlist -->
  <!-- end of bibliomixed.module -->
  <xs:attributeGroup name="articleinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="articleinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="articleinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of articleinfo.element -->
  <xs:attributeGroup name="articleinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="articleinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of articleinfo.attlist -->
  <!-- end of articleinfo.module -->
  <xs:attributeGroup name="biblioset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="biblioset">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="bibliocomponent.mix"/>
      <xs:attributeGroup ref="biblioset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioset.element -->
  <!-- Relation: Relationship of elements contained within BiblioSet -->
  <xs:attributeGroup name="biblioset.attlist">
    <xs:attribute name="relation"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioset.attlist -->
  <!-- end of biblioset.module -->
  <xs:attributeGroup name="bibliomset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliomset">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="bibliocomponent.mix"/>
        <xs:element ref="bibliomset"/>
      </xs:choice>
      <xs:attributeGroup ref="bibliomset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomset.element -->
  <!-- Relation: Relationship of elements contained within BiblioMSet -->
  <xs:attributeGroup name="bibliomset.attlist">
    <xs:attribute name="relation"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomset.attlist -->
  <!-- end of bibliomset.module -->
  <xs:attributeGroup name="bibliomisc.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliomisc">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="bibliomisc.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomisc.element -->
  <xs:attributeGroup name="bibliomisc.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomisc.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomisc.attlist -->
  <!-- end of bibliomisc.module -->
  <!-- ...................................................................... -->
  <!-- Subject, Keyword, and ITermSet elements .............................. -->
  <xs:attributeGroup name="subjectset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subjectset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="subject"/>
      </xs:sequence>
      <xs:attributeGroup ref="subjectset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subjectset.element -->
  <!-- Scheme: Controlled vocabulary employed in SubjectTerms -->
  <xs:attributeGroup name="subjectset.attlist">
    <xs:attribute name="scheme" type="xs:NMTOKEN"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subjectset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subjectset.attlist -->
  <!-- end of subjectset.module -->
  <xs:attributeGroup name="subject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subject">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="subjectterm"/>
      </xs:sequence>
      <xs:attributeGroup ref="subject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subject.element -->
  <!--
    Weight: Ranking of this group of SubjectTerms relative
    to others, 0 is low, no highest value specified
  -->
  <xs:attributeGroup name="subject.attlist">
    <xs:attribute name="weight"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subject.attlist -->
  <!-- end of subject.module -->
  <xs:attributeGroup name="subjectterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subjectterm">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="subjectterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subjectterm.element -->
  <xs:attributeGroup name="subjectterm.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subjectterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subjectterm.attlist -->
  <!-- end of subjectterm.module -->
  <!-- end of subjectset.content.module -->
  <xs:attributeGroup name="keywordset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keywordset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="keyword"/>
      </xs:sequence>
      <xs:attributeGroup ref="keywordset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keywordset.element -->
  <xs:attributeGroup name="keywordset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keywordset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keywordset.attlist -->
  <!-- end of keywordset.module -->
  <xs:attributeGroup name="keyword.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keyword">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="keyword.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keyword.element -->
  <xs:attributeGroup name="keyword.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keyword.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keyword.attlist -->
  <!-- end of keyword.module -->
  <!-- end of keywordset.content.module -->
  <xs:attributeGroup name="itermset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="itermset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="indexterm"/>
      </xs:sequence>
      <xs:attributeGroup ref="itermset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of itermset.element -->
  <xs:attributeGroup name="itermset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="itermset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of itermset.attlist -->
  <!-- end of itermset.module -->
  <!-- Bibliographic info for "blocks" -->
  <xs:attributeGroup name="blockinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="blockinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="blockinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of blockinfo.element -->
  <xs:attributeGroup name="blockinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="blockinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of blockinfo.attlist -->
  <!-- end of blockinfo.module -->
  <!-- ...................................................................... -->
  <!-- Compound (section-ish) elements ...................................... -->
  <!-- Message set ...................... -->
  <xs:attributeGroup name="msgset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgset" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="msgentry"/>
          <xs:element maxOccurs="unbounded" ref="simplemsgentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="msgset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgset.element -->
  <xs:attributeGroup name="msgset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgset.attlist -->
  <!-- end of msgset.module -->
  <xs:attributeGroup name="msgentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="msg"/>
        <xs:element minOccurs="0" ref="msginfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="msgexplan"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgentry.element -->
  <xs:attributeGroup name="msgentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgentry.attlist -->
  <!-- end of msgentry.module -->
  <xs:attributeGroup name="simplemsgentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simplemsgentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="msgtext"/>
        <xs:element maxOccurs="unbounded" ref="msgexplan"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplemsgentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplemsgentry.element -->
  <xs:attributeGroup name="simplemsgentry.attlist">
    <xs:attribute name="audience"/>
    <xs:attribute name="level"/>
    <xs:attribute name="origin"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplemsgentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplemsgentry.attlist -->
  <!-- end of simplemsgentry.module -->
  <xs:attributeGroup name="msg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msg">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgmain"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="msgsub"/>
          <xs:element ref="msgrel"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="msg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msg.element -->
  <xs:attributeGroup name="msg.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msg.attlist -->
  <!-- end of msg.module -->
  <xs:attributeGroup name="msgmain.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgmain">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgmain.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgmain.element -->
  <xs:attributeGroup name="msgmain.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgmain.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgmain.attlist -->
  <!-- end of msgmain.module -->
  <xs:attributeGroup name="msgsub.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgsub">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgsub.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgsub.element -->
  <xs:attributeGroup name="msgsub.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgsub.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgsub.attlist -->
  <!-- end of msgsub.module -->
  <xs:attributeGroup name="msgrel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgrel">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgrel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgrel.element -->
  <xs:attributeGroup name="msgrel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgrel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgrel.attlist -->
  <!-- end of msgrel.module -->
  <!-- MsgText (defined in the Inlines section, below) -->
  <xs:attributeGroup name="msginfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msginfo">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="msglevel"/>
        <xs:element ref="msgorig"/>
        <xs:element ref="msgaud"/>
      </xs:choice>
      <xs:attributeGroup ref="msginfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msginfo.element -->
  <xs:attributeGroup name="msginfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msginfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msginfo.attlist -->
  <!-- end of msginfo.module -->
  <xs:attributeGroup name="msglevel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msglevel">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="msglevel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msglevel.element -->
  <xs:attributeGroup name="msglevel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msglevel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msglevel.attlist -->
  <!-- end of msglevel.module -->
  <xs:attributeGroup name="msgorig.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgorig">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="msgorig.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgorig.element -->
  <xs:attributeGroup name="msgorig.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgorig.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgorig.attlist -->
  <!-- end of msgorig.module -->
  <xs:attributeGroup name="msgaud.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgaud">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="msgaud.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgaud.element -->
  <xs:attributeGroup name="msgaud.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgaud.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgaud.attlist -->
  <!-- end of msgaud.module -->
  <xs:attributeGroup name="msgexplan.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgexplan">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgexplan.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgexplan.element -->
  <xs:attributeGroup name="msgexplan.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgexplan.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgexplan.attlist -->
  <!-- end of msgexplan.module -->
  <!-- end of msgset.content.module -->
  <xs:attributeGroup name="task.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="task" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:element minOccurs="0" ref="tasksummary"/>
        <xs:element minOccurs="0" ref="taskprerequisites"/>
        <xs:element ref="procedure"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="example"/>
        <xs:element minOccurs="0" ref="taskrelated"/>
      </xs:sequence>
      <xs:attributeGroup ref="task.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of task.element -->
  <xs:attributeGroup name="task.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="task.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of task.attlist -->
  <!-- end of task.module -->
  <xs:attributeGroup name="tasksummary.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="tasksummary">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="tasksummary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tasksummary.element -->
  <xs:attributeGroup name="tasksummary.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tasksummary.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tasksummary.attlist -->
  <!-- end of tasksummary.module -->
  <xs:attributeGroup name="taskprerequisites.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="taskprerequisites">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="taskprerequisites.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of taskprerequisites.element -->
  <xs:attributeGroup name="taskprerequisites.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="taskprerequisites.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of taskprerequisites.attlist -->
  <!-- end of taskprerequisites.module -->
  <xs:attributeGroup name="taskrelated.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="taskrelated">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="taskrelated.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of taskrelated.element -->
  <xs:attributeGroup name="taskrelated.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="taskrelated.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of taskrelated.attlist -->
  <!-- end of taskrelated.module -->
  <!-- end of task.content.module -->
  <!-- QandASet ........................ -->
  <xs:attributeGroup name="qandaset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="qandaset" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="qandadiv"/>
          <xs:element maxOccurs="unbounded" ref="qandaentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="qandaset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandaset.element -->
  <xs:attributeGroup name="qandaset.attlist">
    <xs:attribute name="defaultlabel">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="qanda"/>
          <xs:enumeration value="number"/>
          <xs:enumeration value="none"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandaset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandaset.attlist -->
  <!-- end of qandaset.module -->
  <xs:attributeGroup name="qandadiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="qandadiv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="qandadiv"/>
          <xs:element maxOccurs="unbounded" ref="qandaentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="qandadiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandadiv.element -->
  <xs:attributeGroup name="qandadiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandadiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandadiv.attlist -->
  <!-- end of qandadiv.module -->
  <xs:attributeGroup name="qandaentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="qandaentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="revhistory"/>
        <xs:element ref="question"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="answer"/>
      </xs:sequence>
      <xs:attributeGroup ref="qandaentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandaentry.element -->
  <xs:attributeGroup name="qandaentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandaentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandaentry.attlist -->
  <!-- end of qandaentry.module -->
  <xs:attributeGroup name="question.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="question">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="label"/>
        <xs:group maxOccurs="unbounded" ref="qandaset.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="question.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of question.element -->
  <xs:attributeGroup name="question.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="question.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of question.attlist -->
  <!-- end of question.module -->
  <xs:attributeGroup name="answer.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="answer">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="label"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="qandaentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="answer.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of answer.element -->
  <xs:attributeGroup name="answer.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="answer.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of answer.attlist -->
  <!-- end of answer.module -->
  <xs:attributeGroup name="label.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="label">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="label.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of label.element -->
  <xs:attributeGroup name="label.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="label.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of label.attlist -->
  <!-- end of label.module -->
  <!-- end of qandaset.content.module -->
  <!-- Procedure ........................ -->
  <xs:attributeGroup name="procedure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="procedure" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="procedure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of procedure.element -->
  <xs:attributeGroup name="procedure.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="procedure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of procedure.attlist -->
  <!-- end of procedure.module -->
  <xs:attributeGroup name="step.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="step">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="component.mix"/>
            <xs:sequence minOccurs="0">
              <xs:choice>
                <xs:element ref="substeps"/>
                <xs:element ref="stepalternatives"/>
              </xs:choice>
              <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
            </xs:sequence>
          </xs:sequence>
          <xs:sequence>
            <xs:choice>
              <xs:element ref="substeps"/>
              <xs:element ref="stepalternatives"/>
            </xs:choice>
            <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
          </xs:sequence>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="step.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of step.element -->
  <!-- Performance: Whether the Step must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="step.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="step.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of step.attlist -->
  <!-- end of step.module -->
  <xs:attributeGroup name="substeps.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="substeps">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="substeps.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of substeps.element -->
  <!-- Performance: whether entire set of substeps must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="substeps.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="substeps.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of substeps.attlist -->
  <!-- end of substeps.module -->
  <xs:attributeGroup name="stepalternatives.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="stepalternatives">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="stepalternatives.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of stepalternatives.element -->
  <!-- Performance: Whether (one of) the alternatives must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="stepalternatives.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="stepalternatives.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of stepalternatives.attlist -->
  <!-- end of stepalternatives.module -->
  <!-- end of procedure.content.module -->
  <!-- Sidebar .......................... -->
  <xs:attributeGroup name="sidebarinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sidebarinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sidebarinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sidebarinfo.element -->
  <xs:attributeGroup name="sidebarinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sidebarinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sidebarinfo.attlist -->
  <!-- end of sidebarinfo.module -->
  <xs:attributeGroup name="sidebar.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sidebar" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sidebarinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="sidebar.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="sidebar.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sidebar.element -->
  <xs:attributeGroup name="sidebar.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sidebar.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sidebar.attlist -->
  <!-- end of sidebar.module -->
  <!-- end of sidebar.content.model -->
  <!-- ...................................................................... -->
  <!-- Paragraph-related elements ........................................... -->
  <xs:attributeGroup name="abstract.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="abstract">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="abstract.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of abstract.element -->
  <xs:attributeGroup name="abstract.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="abstract.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of abstract.attlist -->
  <!-- end of abstract.module -->
  <xs:attributeGroup name="authorblurb.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="authorblurb">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="authorblurb.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorblurb.element -->
  <xs:attributeGroup name="authorblurb.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorblurb.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorblurb.attlist -->
  <!-- end of authorblurb.module -->
  <xs:attributeGroup name="personblurb.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="personblurb">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="personblurb.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of personblurb.element -->
  <xs:attributeGroup name="personblurb.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="personblurb.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of personblurb.attlist -->
  <!-- end of personblurb.module -->
  <xs:attributeGroup name="blockquote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="blockquote" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element minOccurs="0" ref="attribution"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="blockquote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of blockquote.element -->
  <xs:attributeGroup name="blockquote.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="blockquote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of blockquote.attlist -->
  <!-- end of blockquote.module -->
  <xs:attributeGroup name="attribution.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="attribution">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="attribution.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of attribution.element -->
  <xs:attributeGroup name="attribution.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="attribution.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of attribution.attlist -->
  <!-- end of attribution.module -->
  <xs:attributeGroup name="bridgehead.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bridgehead">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="bridgehead.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bridgehead.element -->
  <!--
    Renderas: Indicates the format in which the BridgeHead
    should appear
  -->
  <xs:attributeGroup name="bridgehead.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="other"/>
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bridgehead.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bridgehead.attlist -->
  <!-- end of bridgehead.module -->
  <xs:attributeGroup name="remark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="remark">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="remark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of remark.element -->
  <xs:attributeGroup name="remark.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="remark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of remark.attlist -->
  <!-- end of remark.module -->
  <xs:attributeGroup name="epigraph.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="epigraph">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="attribution"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="para.class"/>
          <xs:element ref="literallayout"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="epigraph.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of epigraph.element -->
  <xs:attributeGroup name="epigraph.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="epigraph.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of epigraph.attlist -->
  <!-- Attribution (defined above) -->
  <!-- end of epigraph.module -->
  <xs:attributeGroup name="footnote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="footnote" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="footnote.mix"/>
      <xs:attributeGroup ref="footnote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of footnote.element -->
  <xs:attributeGroup name="footnote.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="footnote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of footnote.attlist -->
  <!-- end of footnote.module -->
  <xs:attributeGroup name="highlights.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="highlights">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="highlights.mix"/>
      <xs:attributeGroup ref="highlights.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of highlights.element -->
  <xs:attributeGroup name="highlights.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="highlights.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of highlights.attlist -->
  <!-- end of highlights.module -->
  <xs:attributeGroup name="formalpara.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="formalpara" substitutionGroup="para.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="title"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element ref="para"/>
      </xs:sequence>
      <xs:attributeGroup ref="formalpara.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of formalpara.element -->
  <xs:attributeGroup name="formalpara.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="formalpara.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of formalpara.attlist -->
  <!-- end of formalpara.module -->
  <xs:attributeGroup name="para.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="para" substitutionGroup="para.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:group ref="para.mix"/>
      </xs:choice>
      <xs:attributeGroup ref="para.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of para.element -->
  <xs:attributeGroup name="para.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="para.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of para.attlist -->
  <!-- end of para.module -->
  <xs:attributeGroup name="simpara.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simpara" substitutionGroup="para.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="simpara.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simpara.element -->
  <xs:attributeGroup name="simpara.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simpara.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simpara.attlist -->
  <!-- end of simpara.module -->
  <xs:attributeGroup name="admon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="caution" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="caution.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of caution.element -->
  <xs:attributeGroup name="caution.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of caution.attlist -->
  <xs:element name="important" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="important.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of important.element -->
  <xs:attributeGroup name="important.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of important.attlist -->
  <xs:element name="note" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="note.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of note.element -->
  <xs:attributeGroup name="note.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of note.attlist -->
  <xs:element name="tip" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="tip.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tip.element -->
  <xs:attributeGroup name="tip.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tip.attlist -->
  <xs:element name="warning" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="warning.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of warning.element -->
  <xs:attributeGroup name="warning.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of warning.attlist -->
  <!-- end of admon.module -->
  <!-- ...................................................................... -->
  <!-- Lists ................................................................ -->
  <!-- GlossList ........................ -->
  <xs:attributeGroup name="glosslist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glosslist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="glossentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="glosslist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glosslist.element -->
  <xs:attributeGroup name="glosslist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glosslist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glosslist.attlist -->
  <!-- end of glosslist.module -->
  <xs:attributeGroup name="glossentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="glossterm"/>
        <xs:element minOccurs="0" ref="acronym"/>
        <xs:element minOccurs="0" ref="abbrev"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" ref="revhistory"/>
        <xs:choice>
          <xs:element ref="glosssee"/>
          <xs:element maxOccurs="unbounded" ref="glossdef"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="glossentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossentry.element -->
  <!--
    SortAs: String by which the GlossEntry is to be sorted
    (alphabetized) in lieu of its proper content
  -->
  <xs:attributeGroup name="glossentry.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossentry.attlist -->
  <!-- end of glossentry.module -->
  <!-- GlossTerm (defined in the Inlines section, below) -->
  <xs:attributeGroup name="glossdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossdef">
    <xs:complexType>
      <xs:sequence>
        <xs:group maxOccurs="unbounded" ref="glossdef.mix"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="glossseealso"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossdef.element -->
  <!-- Subject: List of subjects; keywords for the definition -->
  <xs:attributeGroup name="glossdef.attlist">
    <xs:attribute name="subject"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossdef.attlist -->
  <!-- end of glossdef.module -->
  <xs:attributeGroup name="glosssee.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glosssee">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glosssee.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glosssee.element -->
  <!--
    OtherTerm: Reference to the GlossEntry whose GlossTerm
    should be displayed at the point of the GlossSee
  -->
  <xs:attributeGroup name="glosssee.attlist">
    <xs:attribute name="otherterm" type="xs:IDREF"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glosssee.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glosssee.attlist -->
  <!-- end of glosssee.module -->
  <xs:attributeGroup name="glossseealso.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossseealso">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glossseealso.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossseealso.element -->
  <!--
    OtherTerm: Reference to the GlossEntry whose GlossTerm
    should be displayed at the point of the GlossSeeAlso
  -->
  <xs:attributeGroup name="glossseealso.attlist">
    <xs:attribute name="otherterm" type="xs:IDREF"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossseealso.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossseealso.attlist -->
  <!-- end of glossseealso.module -->
  <!-- end of glossentry.content.module -->
  <!-- ItemizedList and OrderedList ..... -->
  <xs:attributeGroup name="itemizedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="itemizedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="itemizedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of itemizedlist.element -->
  <!--
    Spacing: Whether the vertical space in the list should be
    compressed
  -->
  <!--
    Mark: Keyword, e.g., bullet, dash, checkbox, none;
    list of keywords and defaults are implementation specific
  -->
  <xs:attributeGroup name="itemizedlist.attlist">
    <xs:attribute name="spacing">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="normal"/>
          <xs:enumeration value="compact"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="mark.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="itemizedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of itemizedlist.attlist -->
  <!-- end of itemizedlist.module -->
  <xs:attributeGroup name="orderedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="orderedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="orderedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orderedlist.element -->
  <!--
    Numeration: Style of ListItem numbered; default is expected
    to be Arabic
  -->
  <!--
    InheritNum: Specifies for a nested list that the numbering
    of ListItems should include the number of the item
    within which they are nested (e.g., 1a and 1b within 1,
    rather than a and b)
  -->
  <!--
    Continuation: Where list numbering begins afresh (Restarts,
    the default) or continues that of the immediately preceding
    list (Continues)
  -->
  <!--
    Spacing: Whether the vertical space in the list should be
    compressed
  -->
  <xs:attributeGroup name="orderedlist.attlist">
    <xs:attribute name="numeration">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="arabic"/>
          <xs:enumeration value="upperalpha"/>
          <xs:enumeration value="loweralpha"/>
          <xs:enumeration value="upperroman"/>
          <xs:enumeration value="lowerroman"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="inheritnum" default="ignore">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="inherit"/>
          <xs:enumeration value="ignore"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="continuation" default="restarts">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="continues"/>
          <xs:enumeration value="restarts"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="spacing">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="normal"/>
          <xs:enumeration value="compact"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="orderedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orderedlist.attlist -->
  <!-- end of orderedlist.module -->
  <xs:attributeGroup name="listitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="listitem">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="listitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of listitem.element -->
  <!--
    Override: Indicates the mark to be used for this ListItem
    instead of the default mark or the mark specified by
    the Mark attribute on the enclosing ItemizedList
  -->
  <xs:attributeGroup name="listitem.attlist">
    <xs:attribute name="override"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="listitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of listitem.attlist -->
  <!-- end of listitem.module -->
  <!-- SegmentedList .................... -->
  <xs:attributeGroup name="segmentedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="segmentedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="segtitle"/>
        <xs:element maxOccurs="unbounded" ref="seglistitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="segmentedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of segmentedlist.element -->
  <xs:attributeGroup name="segmentedlist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="segmentedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of segmentedlist.attlist -->
  <!-- end of segmentedlist.module -->
  <xs:attributeGroup name="segtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="segtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="segtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of segtitle.element -->
  <xs:attributeGroup name="segtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="segtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of segtitle.attlist -->
  <!-- end of segtitle.module -->
  <xs:attributeGroup name="seglistitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seglistitem">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="seg"/>
      </xs:sequence>
      <xs:attributeGroup ref="seglistitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seglistitem.element -->
  <xs:attributeGroup name="seglistitem.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seglistitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seglistitem.attlist -->
  <!-- end of seglistitem.module -->
  <xs:attributeGroup name="seg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seg">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="seg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seg.element -->
  <xs:attributeGroup name="seg.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seg.attlist -->
  <!-- end of seg.module -->
  <!-- end of segmentedlist.content.module -->
  <!-- SimpleList ....................... -->
  <xs:attributeGroup name="simplelist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="simplelist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="member"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplelist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplelist.element -->
  <!-- Columns: The number of columns the array should contain -->
  <!--
    Type: How the Members of the SimpleList should be
    formatted: Inline (members separated with commas etc.
    inline), Vert (top to bottom in n Columns), or Horiz (in
    the direction of text flow) in n Columns.  If Column
    is 1 or implied, Type=Vert and Type=Horiz give the same
    results.
  -->
  <xs:attributeGroup name="simplelist.attlist">
    <xs:attribute name="columns"/>
    <xs:attribute name="type" default="vert">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="inline"/>
          <xs:enumeration value="vert"/>
          <xs:enumeration value="horiz"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplelist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplelist.attlist -->
  <!-- end of simplelist.module -->
  <xs:attributeGroup name="member.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="member">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="member.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of member.element -->
  <xs:attributeGroup name="member.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="member.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of member.attlist -->
  <!-- end of member.module -->
  <!-- end of simplelist.content.module -->
  <!-- VariableList ..................... -->
  <xs:attributeGroup name="variablelist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="variablelist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="varlistentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="variablelist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of variablelist.element -->
  <!--
    TermLength: Length beyond which the presentation engine
    may consider the Term too long and select an alternate
    presentation of the Term and, or, its associated ListItem.
  -->
  <xs:attributeGroup name="variablelist.attlist">
    <xs:attribute name="termlength"/>
    <xs:attribute name="spacing">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="normal"/>
          <xs:enumeration value="compact"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="variablelist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of variablelist.attlist -->
  <!-- end of variablelist.module -->
  <xs:attributeGroup name="varlistentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="varlistentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="term"/>
        <xs:element ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="varlistentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varlistentry.element -->
  <xs:attributeGroup name="varlistentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varlistentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varlistentry.attlist -->
  <!-- end of varlistentry.module -->
  <xs:attributeGroup name="term.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="term">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="term.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of term.element -->
  <xs:attributeGroup name="term.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="term.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of term.attlist -->
  <!-- end of term.module -->
  <!-- ListItem (defined above) -->
  <!-- end of variablelist.content.module -->
  <!-- CalloutList ...................... -->
  <xs:attributeGroup name="calloutlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="calloutlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="callout"/>
      </xs:sequence>
      <xs:attributeGroup ref="calloutlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of calloutlist.element -->
  <xs:attributeGroup name="calloutlist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="calloutlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of calloutlist.attlist -->
  <!-- end of calloutlist.module -->
  <xs:attributeGroup name="callout.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="callout">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="callout.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of callout.element -->
  <!--
    AreaRefs: IDs of one or more Areas or AreaSets described
    by this Callout
  -->
  <xs:attributeGroup name="callout.attlist">
    <xs:attribute name="arearefs" use="required" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="callout.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of callout.attlist -->
  <!-- end of callout.module -->
  <!-- end of calloutlist.content.module -->
  <!-- ...................................................................... -->
  <!-- Objects .............................................................. -->
  <!-- Examples etc. .................... -->
  <xs:attributeGroup name="example.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="example" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="example.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="example.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of example.element -->
  <xs:attributeGroup name="example.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="example.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of example.attlist -->
  <!-- end of example.module -->
  <xs:attributeGroup name="informalexample.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="informalexample" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group maxOccurs="unbounded" ref="example.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="informalexample.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalexample.element -->
  <xs:attributeGroup name="informalexample.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalexample.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalexample.attlist -->
  <!-- end of informalexample.module -->
  <xs:attributeGroup name="programlistingco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="programlistingco" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="programlisting"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="programlistingco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of programlistingco.element -->
  <xs:attributeGroup name="programlistingco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="programlistingco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of programlistingco.attlist -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of informalexample.module -->
  <xs:attributeGroup name="areaspec.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="areaspec">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="area"/>
        <xs:element ref="areaset"/>
      </xs:choice>
      <xs:attributeGroup ref="areaspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of areaspec.element -->
  <!--
    Units: global unit of measure in which coordinates in
    this spec are expressed:
    
    - CALSPair "x1,y1 x2,y2": lower-left and upper-right
    coordinates in a rectangle describing repro area in which
    graphic is placed, where X and Y dimensions are each some
    number 0..10000 (taken from CALS graphic attributes)
    
    - LineColumn "line column": line number and column number
    at which to start callout text in "linespecific" content
    
    - LineRange "startline endline": whole lines from startline
    to endline in "linespecific" content
    
    - LineColumnPair "line1 col1 line2 col2": starting and ending
    points of area in "linespecific" content that starts at
    first position and ends at second position (including the
    beginnings of any intervening lines)
    
    - Other: directive to look at value of OtherUnits attribute
    to get implementation-specific keyword
    
    The default is implementation-specific; usually dependent on
    the parent element (GraphicCO gets CALSPair, ProgramListingCO
    and ScreenCO get LineColumn)
  -->
  <!-- OtherUnits: User-defined units -->
  <xs:attributeGroup name="areaspec.attlist">
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="areaspec.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of areaspec.attlist -->
  <!-- end of areaspec.module -->
  <xs:attributeGroup name="area.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="area">
    <xs:complexType>
      <xs:attributeGroup ref="area.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of area.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <!--
    Units: unit of measure in which coordinates in this
    area are expressed; inherits from AreaSet and AreaSpec
  -->
  <!-- OtherUnits: User-defined units -->
  <xs:attributeGroup name="area.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attribute name="coords" use="required"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="area.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of area.attlist -->
  <!-- end of area.module -->
  <xs:attributeGroup name="areaset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="areaset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="area"/>
      </xs:sequence>
      <xs:attributeGroup ref="areaset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of areaset.element -->
  <!-- bug number/symbol override or initialization -->
  <!--
    Units: unit of measure in which coordinates in this
    area are expressed; inherits from AreaSpec
  -->
  <xs:attributeGroup name="areaset.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attribute name="coords" use="required"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="areaset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of areaset.attlist -->
  <!-- end of areaset.module -->
  <!-- end of areaspec.content.module -->
  <xs:attributeGroup name="programlisting.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="programlisting" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="lineannotation"/>
        <xs:element ref="textobject"/>
      </xs:choice>
      <xs:attributeGroup ref="programlisting.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of programlisting.element -->
  <xs:attributeGroup name="programlisting.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="programlisting.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of programlisting.attlist -->
  <!-- end of programlisting.module -->
  <xs:attributeGroup name="literallayout.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="literallayout" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="literallayout.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of literallayout.element -->
  <xs:attributeGroup name="literallayout.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attribute name="class" default="normal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="monospaced"/>
          <xs:enumeration value="normal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="literallayout.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of literallayout.attlist -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- end of literallayout.module -->
  <xs:attributeGroup name="screenco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screenco" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="screen"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="screenco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screenco.element -->
  <xs:attributeGroup name="screenco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screenco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screenco.attlist -->
  <!-- AreaSpec (defined above) -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of screenco.module -->
  <xs:attributeGroup name="screen.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screen" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="screen.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screen.element -->
  <xs:attributeGroup name="screen.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screen.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screen.attlist -->
  <!-- end of screen.module -->
  <xs:attributeGroup name="screenshot.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screenshot" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="screeninfo"/>
        <xs:choice>
          <xs:element ref="graphic"/>
          <xs:element ref="graphicco"/>
          <xs:element ref="mediaobject"/>
          <xs:element ref="mediaobjectco"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="screenshot.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screenshot.element -->
  <xs:attributeGroup name="screenshot.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screenshot.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screenshot.attlist -->
  <!-- end of screenshot.module -->
  <xs:attributeGroup name="screeninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="screeninfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="screeninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screeninfo.element -->
  <xs:attributeGroup name="screeninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screeninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screeninfo.attlist -->
  <!-- end of screeninfo.module -->
  <!-- end of screenshot.content.module -->
  <!-- Figures etc. ..................... -->
  <xs:attributeGroup name="figure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="figure" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:choice maxOccurs="unbounded">
          <xs:group ref="figure.mix"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="figure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of figure.element -->
  <!--
    Float: Whether the Figure is supposed to be rendered
    where convenient (yes (1) value) or at the place it occurs
    in the text (no (0) value, the default)
  -->
  <xs:attributeGroup name="figure.attlist">
    <xs:attribute name="float" default="0" type="yesorno.attvals"/>
    <xs:attribute name="floatstyle"/>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="figure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of figure.attlist -->
  <!-- end of figure.module -->
  <xs:attributeGroup name="informalfigure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="informalfigure" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:choice maxOccurs="unbounded">
          <xs:group ref="figure.mix"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="informalfigure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalfigure.element -->
  <!--
    Float: Whether the Figure is supposed to be rendered
    where convenient (yes (1) value) or at the place it occurs
    in the text (no (0) value, the default)
  -->
  <xs:attributeGroup name="informalfigure.attlist">
    <xs:attribute name="float" default="0" type="yesorno.attvals"/>
    <xs:attribute name="floatstyle"/>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalfigure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalfigure.attlist -->
  <!-- end of informalfigure.module -->
  <xs:attributeGroup name="graphicco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="graphicco" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="graphic"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="graphicco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of graphicco.element -->
  <xs:attributeGroup name="graphicco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="graphicco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of graphicco.attlist -->
  <!-- AreaSpec (defined above in Examples) -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of graphicco.module -->
  <!--
    Graphical data can be the content of Graphic, or you can reference
    an external file either as an entity (Entitref) or a filename
    (Fileref).
  -->
  <xs:attributeGroup name="graphic.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="graphic" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:attributeGroup ref="graphic.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of graphic.element -->
  <xs:attributeGroup name="graphic.attlist">
    <xs:attributeGroup ref="graphics.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="graphic.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of graphic.attlist -->
  <!-- end of graphic.module -->
  <xs:attributeGroup name="inlinegraphic.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="inlinegraphic" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="inlinegraphic.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of inlinegraphic.element -->
  <xs:attributeGroup name="inlinegraphic.attlist">
    <xs:attributeGroup ref="graphics.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlinegraphic.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlinegraphic.attlist -->
  <!-- end of inlinegraphic.module -->
  <xs:attributeGroup name="mediaobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="mediaobject" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject.mix"/>
        <xs:element minOccurs="0" ref="caption"/>
      </xs:sequence>
      <xs:attributeGroup ref="mediaobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mediaobject.element -->
  <xs:attributeGroup name="mediaobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mediaobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mediaobject.attlist -->
  <!-- end of mediaobject.module -->
  <xs:attributeGroup name="inlinemediaobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="inlinemediaobject" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="inlinemediaobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of inlinemediaobject.element -->
  <xs:attributeGroup name="inlinemediaobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlinemediaobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlinemediaobject.attlist -->
  <!-- end of inlinemediaobject.module -->
  <xs:attributeGroup name="videoobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="videoobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="videodata"/>
      </xs:sequence>
      <xs:attributeGroup ref="videoobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of videoobject.element -->
  <xs:attributeGroup name="videoobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="videoobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of videoobject.attlist -->
  <!-- end of videoobject.module -->
  <xs:attributeGroup name="audioobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="audioobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="audiodata"/>
      </xs:sequence>
      <xs:attributeGroup ref="audioobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of audioobject.element -->
  <xs:attributeGroup name="audioobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="audioobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of audioobject.attlist -->
  <!-- end of audioobject.module -->
  <xs:attributeGroup name="imageobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="imageobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="imagedata"/>
      </xs:sequence>
      <xs:attributeGroup ref="imageobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imageobject.element -->
  <xs:attributeGroup name="imageobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imageobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imageobject.attlist -->
  <!-- end of imageobject.module -->
  <xs:attributeGroup name="textobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="textobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:choice>
          <xs:element ref="phrase"/>
          <xs:element ref="textdata"/>
          <xs:group maxOccurs="unbounded" ref="textobject.mix"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="textobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of textobject.element -->
  <xs:attributeGroup name="textobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="textobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of textobject.attlist -->
  <!-- end of textobject.module -->
  <xs:attributeGroup name="objectinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="objectinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="objectinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of objectinfo.element -->
  <xs:attributeGroup name="objectinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="objectinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of objectinfo.attlist -->
  <!-- end of objectinfo.module -->
  <!--
    EntityRef: Name of an external entity containing the content
    of the object data
  -->
  <!--
    FileRef: Filename, qualified by a pathname if desired,
    designating the file containing the content of the object data
  -->
  <!-- Format: Notation of the element content, if any -->
  <!-- SrcCredit: Information about the source of the image -->
  <xs:attributeGroup name="objectdata.attrib">
    <xs:attribute name="entityref" type="xs:ENTITY"/>
    <xs:attribute name="fileref"/>
    <xs:attribute name="format" type="notation.class"/>
    <xs:attribute name="srccredit"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="videodata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="videodata">
    <xs:complexType>
      <xs:attributeGroup ref="videodata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of videodata.element -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="videodata.attlist">
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="videodata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of videodata.attlist -->
  <!-- end of videodata.module -->
  <xs:attributeGroup name="audiodata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="audiodata">
    <xs:complexType>
      <xs:attributeGroup ref="audiodata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of audiodata.element -->
  <xs:attributeGroup name="audiodata.attlist">
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="audiodata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of audiodata.attlist -->
  <!-- end of audiodata.module -->
  <xs:attributeGroup name="imagedata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="imagedata">
    <xs:complexType>
      <xs:attributeGroup ref="imagedata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imagedata.element -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="imagedata.attlist">
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imagedata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imagedata.attlist -->
  <!-- end of imagedata.module -->
  <xs:attributeGroup name="textdata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="textdata">
    <xs:complexType>
      <xs:attributeGroup ref="textdata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of textdata.element -->
  <xs:attributeGroup name="textdata.attlist">
    <xs:attribute name="encoding"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="textdata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of textdata.attlist -->
  <!-- end of textdata.module -->
  <xs:attributeGroup name="mediaobjectco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="mediaobjectco" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="imageobjectco"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="imageobjectco"/>
          <xs:element ref="textobject"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="mediaobjectco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mediaobjectco.element -->
  <xs:attributeGroup name="mediaobjectco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mediaobjectco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mediaobjectco.attlist -->
  <!-- end of mediaobjectco.module -->
  <xs:attributeGroup name="imageobjectco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="imageobjectco" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="imageobject"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="imageobjectco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imageobjectco.element -->
  <xs:attributeGroup name="imageobjectco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imageobjectco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imageobjectco.attlist -->
  <!-- end of imageobjectco.module -->
  <!-- end of mediaobject.content.module -->
  <!-- Equations ........................ -->
  <!-- This PE provides a mechanism for replacing equation content, -->
  <!-- perhaps adding a new or different model (e.g., MathML) -->
  <xs:group name="equation.content">
    <xs:sequence>
      <xs:element minOccurs="0" ref="alt"/>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="graphic"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:complexType name="inlineequation.content">
    <xs:sequence>
      <xs:element minOccurs="0" ref="alt"/>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="graphic"/>
        <xs:element maxOccurs="unbounded" ref="inlinemediaobject"/>
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
  <xs:attributeGroup name="equation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="equation" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:choice>
          <xs:element ref="informalequation"/>
          <xs:group ref="equation.content"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="equation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of equation.element -->
  <xs:attributeGroup name="equation.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="equation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of equation.attlist -->
  <!-- end of equation.module -->
  <xs:attributeGroup name="informalequation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="informalequation" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="equation.content"/>
      </xs:sequence>
      <xs:attributeGroup ref="informalequation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalequation.element -->
  <xs:attributeGroup name="informalequation.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalequation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalequation.attlist -->
  <!-- end of informalequation.module -->
  <xs:attributeGroup name="inlineequation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="inlineequation" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="inlineequation.content">
          <xs:attributeGroup ref="inlineequation.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <!-- end of inlineequation.element -->
  <xs:attributeGroup name="inlineequation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlineequation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlineequation.attlist -->
  <!-- end of inlineequation.module -->
  <xs:attributeGroup name="alt.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="alt">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="alt.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of alt.element -->
  <xs:attributeGroup name="alt.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="alt.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of alt.attlist -->
  <!-- end of alt.module -->
  <!-- Tables ........................... -->
  <!-- Choose a table model. CALS or OASIS XML Exchange -->
  <!-- Do we allow the HTML table model as well? -->
  <!-- ====================================================== -->
  <!--
    xhtmltbl.mod defines HTML tables and sets parameter
    entities so that, when the CALS table module is read,
    we end up allowing any table to be CALS or HTML.
    i.e. This include must come first!
  -->
  <!-- ====================================================== -->
  <!-- end of allow.html.tables -->
  <!-- Add label and role attributes to table and informaltable -->
  <!--
    Add common attributes to Table, TGroup, TBody, THead, TFoot, Row,
    EntryTbl, and Entry (and InformalTable element).
  -->
  <!-- Content model for Table. -->
  <!-- Allow either objects or inlines; beware of REs between elements. -->
  <!-- Reference CALS Table Model -->
  <!-- end of table.module -->
  <!--
    Note that InformalTable is dependent on some of the entity
    declarations that customize Table.
  -->
  <!-- the following entity may have been declared by the XHTML table module -->
  <xs:element name="informaltable" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="informal.tbl.table.mdl"/>
      </xs:sequence>
      <xs:attributeGroup ref="informaltable.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informaltable.element -->
  <!--
    Frame, Colsep, and Rowsep must be repeated because
    they are not in entities in the table module.
  -->
  <!--
    includes TabStyle, ToCentry, ShortEntry,
    Orient, PgWide
  -->
  <!-- includes Label -->
  <!-- includes common attributes -->
  <xs:attributeGroup name="informaltable.attlist">
    <xs:attribute name="frame" type="tbl.frame.attval"/>
    <xs:attribute name="colsep" type="yesorno.attvals"/>
    <xs:attribute name="rowsep" type="yesorno.attvals"/>
    <xs:attributeGroup ref="common.table.attribs"/>
    <xs:attributeGroup ref="tbl.table.att"/>
  </xs:attributeGroup>
  <!-- end of informaltable.attlist -->
  <!-- end of informaltable.module -->
  <xs:attributeGroup name="caption.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="caption">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="textobject.mix"/>
      <xs:attributeGroup ref="caption.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of caption.element -->
  <!-- attrs comes from HTML tables ... -->
  <!-- common.attrib, but without ID because ID is in attrs -->
  <xs:attributeGroup name="caption.attlist.content">
    <xs:attributeGroup ref="lang.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="dir.attrib"/>
    <xs:attributeGroup ref="xml-base.attrib"/>
    <xs:attributeGroup ref="caption.role.attrib"/>
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="bottom"/>
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <xs:attributeGroup name="caption.attlist">
    <xs:attributeGroup ref="caption.attlist.content"/>
  </xs:attributeGroup>
  <!-- end of caption.attlist -->
  <!-- end of caption.module -->
  <!-- ...................................................................... -->
  <!-- Synopses ............................................................. -->
  <!-- Synopsis ......................... -->
  <xs:attributeGroup name="synopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="synopsis" substitutionGroup="synop.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="graphic"/>
        <xs:element ref="mediaobject"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="synopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopsis.element -->
  <xs:attributeGroup name="synopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="synopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopsis.attlist -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- end of synopsis.module -->
  <!-- CmdSynopsis ...................... -->
  <xs:attributeGroup name="cmdsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="cmdsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="command"/>
          <xs:element ref="arg"/>
          <xs:element ref="group"/>
          <xs:element ref="sbr"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="synopfragment"/>
      </xs:sequence>
      <xs:attributeGroup ref="cmdsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of cmdsynopsis.element -->
  <!--
    Sepchar: Character that should separate command and all
    top-level arguments; alternate value might be e.g., &Delta;
  -->
  <xs:attributeGroup name="cmdsynopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attribute name="sepchar" default=" "/>
    <xs:attribute name="cmdlength"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="cmdsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of cmdsynopsis.attlist -->
  <!-- end of cmdsynopsis.module -->
  <xs:attributeGroup name="arg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="arg">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
        <xs:element ref="option"/>
        <xs:element ref="synopfragmentref"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="sbr"/>
      </xs:choice>
      <xs:attributeGroup ref="arg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of arg.element -->
  <!--
    Choice: Whether Arg must be supplied: Opt (optional to
    supply, e.g. [arg]; the default), Req (required to supply,
    e.g. {arg}), or Plain (required to supply, e.g. arg)
  -->
  <!--
    Rep: whether Arg is repeatable: Norepeat (e.g. arg without
    ellipsis; the default), or Repeat (e.g. arg...)
  -->
  <xs:attributeGroup name="arg.attlist">
    <xs:attribute name="choice" default="opt">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="arg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of arg.attlist -->
  <!-- end of arg.module -->
  <xs:attributeGroup name="group.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="group">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
        <xs:element ref="option"/>
        <xs:element ref="synopfragmentref"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="sbr"/>
      </xs:choice>
      <xs:attributeGroup ref="group.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of group.element -->
  <!--
    Choice: Whether Group must be supplied: Opt (optional to
    supply, e.g.  [g1|g2|g3]; the default), Req (required to
    supply, e.g.  {g1|g2|g3}), Plain (required to supply,
    e.g.  g1|g2|g3), OptMult (can supply zero or more, e.g.
    [[g1|g2|g3]]), or ReqMult (must supply one or more, e.g.
    {{g1|g2|g3}})
  -->
  <!--
    Rep: whether Group is repeatable: Norepeat (e.g. group
    without ellipsis; the default), or Repeat (e.g. group...)
  -->
  <xs:attributeGroup name="group.attlist">
    <xs:attribute name="choice" default="opt">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="group.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of group.attlist -->
  <!-- end of group.module -->
  <!-- Synopsis break -->
  <xs:attributeGroup name="sbr.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sbr">
    <xs:complexType>
      <xs:attributeGroup ref="sbr.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sbr.element -->
  <xs:attributeGroup name="sbr.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sbr.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sbr.attlist -->
  <!-- end of sbr.module -->
  <xs:attributeGroup name="synopfragmentref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="synopfragmentref">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="synopfragmentref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopfragmentref.element -->
  <!--
    to SynopFragment of complex synopsis
    material for separate referencing
  -->
  <xs:attributeGroup name="synopfragmentref.attlist">
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="synopfragmentref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopfragmentref.attlist -->
  <!-- end of synopfragmentref.module -->
  <xs:attributeGroup name="synopfragment.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="synopfragment">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
      </xs:choice>
      <xs:attributeGroup ref="synopfragment.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopfragment.element -->
  <xs:attributeGroup name="synopfragment.attlist">
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="synopfragment.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopfragment.attlist -->
  <!-- end of synopfragment.module -->
  <!-- Command (defined in the Inlines section, below) -->
  <!-- Option (defined in the Inlines section, below) -->
  <!-- Replaceable (defined in the Inlines section, below) -->
  <!-- end of cmdsynopsis.content.module -->
  <!-- FuncSynopsis ..................... -->
  <xs:attributeGroup name="funcsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="funcsynopsisinfo"/>
        <xs:element ref="funcprototype"/>
      </xs:choice>
      <xs:attributeGroup ref="funcsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcsynopsis.element -->
  <xs:attributeGroup name="funcsynopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcsynopsis.attlist -->
  <!-- end of funcsynopsis.module -->
  <xs:attributeGroup name="funcsynopsisinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcsynopsisinfo">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="funcsynopsisinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcsynopsisinfo.element -->
  <xs:attributeGroup name="funcsynopsisinfo.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcsynopsisinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcsynopsisinfo.attlist -->
  <!-- end of funcsynopsisinfo.module -->
  <xs:attributeGroup name="funcprototype.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcprototype">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element ref="funcdef"/>
        <xs:choice>
          <xs:element ref="void"/>
          <xs:element ref="varargs"/>
          <xs:sequence>
            <xs:element maxOccurs="unbounded" ref="paramdef"/>
            <xs:element minOccurs="0" ref="varargs"/>
          </xs:sequence>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="funcprototype.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcprototype.element -->
  <xs:attributeGroup name="funcprototype.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcprototype.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcprototype.attlist -->
  <!-- end of funcprototype.module -->
  <xs:attributeGroup name="funcdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcdef">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="type"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="function"/>
      </xs:choice>
      <xs:attributeGroup ref="funcdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcdef.element -->
  <xs:attributeGroup name="funcdef.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcdef.attlist -->
  <!-- end of funcdef.module -->
  <xs:attributeGroup name="void.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="void">
    <xs:complexType>
      <xs:attributeGroup ref="void.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of void.element -->
  <xs:attributeGroup name="void.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="void.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of void.attlist -->
  <!-- end of void.module -->
  <xs:attributeGroup name="varargs.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="varargs">
    <xs:complexType>
      <xs:attributeGroup ref="varargs.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varargs.element -->
  <xs:attributeGroup name="varargs.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varargs.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varargs.attlist -->
  <!-- end of varargs.module -->
  <!--
    Processing assumes that only one Parameter will appear in a
    ParamDef, and that FuncParams will be used at most once, for
    providing information on the "inner parameters" for parameters that
    are pointers to functions.
  -->
  <xs:attributeGroup name="paramdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="paramdef">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="initializer"/>
        <xs:element ref="type"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="parameter"/>
        <xs:element ref="funcparams"/>
      </xs:choice>
      <xs:attributeGroup ref="paramdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of paramdef.element -->
  <xs:attributeGroup name="paramdef.attlist">
    <xs:attribute name="choice">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="paramdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of paramdef.attlist -->
  <!-- end of paramdef.module -->
  <xs:attributeGroup name="funcparams.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="funcparams">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="funcparams.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcparams.element -->
  <xs:attributeGroup name="funcparams.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcparams.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcparams.attlist -->
  <!-- end of funcparams.module -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- Replaceable (defined in the Inlines section, below) -->
  <!-- Function (defined in the Inlines section, below) -->
  <!-- Parameter (defined in the Inlines section, below) -->
  <!-- end of funcsynopsis.content.module -->
  <!-- ClassSynopsis ..................... -->
  <xs:attributeGroup name="classsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="classsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="ooclass"/>
          <xs:element ref="oointerface"/>
          <xs:element ref="ooexception"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="classsynopsisinfo"/>
          <xs:element ref="fieldsynopsis"/>
          <xs:element ref="method.synop.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="classsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classsynopsis.element -->
  <xs:attributeGroup name="classsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attribute name="class" default="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="class"/>
          <xs:enumeration value="interface"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classsynopsis.attlist -->
  <!-- end of classsynopsis.module -->
  <xs:attributeGroup name="classsynopsisinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="classsynopsisinfo">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="classsynopsisinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classsynopsisinfo.element -->
  <xs:attributeGroup name="classsynopsisinfo.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classsynopsisinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classsynopsisinfo.attlist -->
  <!-- end of classsynopsisinfo.module -->
  <xs:attributeGroup name="ooclass.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ooclass" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="modifier"/>
          <xs:element ref="package"/>
        </xs:choice>
        <xs:element ref="classname"/>
      </xs:sequence>
      <xs:attributeGroup ref="ooclass.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ooclass.element -->
  <xs:attributeGroup name="ooclass.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ooclass.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ooclass.attlist -->
  <!-- end of ooclass.module -->
  <xs:attributeGroup name="oointerface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="oointerface" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="modifier"/>
          <xs:element ref="package"/>
        </xs:choice>
        <xs:element ref="interfacename"/>
      </xs:sequence>
      <xs:attributeGroup ref="oointerface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of oointerface.element -->
  <xs:attributeGroup name="oointerface.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="oointerface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of oointerface.attlist -->
  <!-- end of oointerface.module -->
  <xs:attributeGroup name="ooexception.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ooexception" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="modifier"/>
          <xs:element ref="package"/>
        </xs:choice>
        <xs:element ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="ooexception.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ooexception.element -->
  <xs:attributeGroup name="ooexception.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ooexception.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ooexception.attlist -->
  <!-- end of ooexception.module -->
  <xs:attributeGroup name="modifier.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="modifier">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="modifier.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of modifier.element -->
  <xs:attributeGroup name="modifier.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="modifier.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of modifier.attlist -->
  <!-- end of modifier.module -->
  <xs:attributeGroup name="interfacename.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="interfacename" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="interfacename.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of interfacename.element -->
  <xs:attributeGroup name="interfacename.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="interfacename.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of interfacename.attlist -->
  <!-- end of interfacename.module -->
  <xs:attributeGroup name="exceptionname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="exceptionname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="exceptionname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of exceptionname.element -->
  <xs:attributeGroup name="exceptionname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="exceptionname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of exceptionname.attlist -->
  <!-- end of exceptionname.module -->
  <xs:attributeGroup name="fieldsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="fieldsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="type"/>
        <xs:element ref="varname"/>
        <xs:element minOccurs="0" ref="initializer"/>
      </xs:sequence>
      <xs:attributeGroup ref="fieldsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of fieldsynopsis.element -->
  <xs:attributeGroup name="fieldsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="fieldsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of fieldsynopsis.attlist -->
  <!-- end of fieldsynopsis.module -->
  <xs:attributeGroup name="initializer.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="initializer">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="initializer.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of initializer.element -->
  <xs:attributeGroup name="initializer.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="initializer.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of initializer.attlist -->
  <!-- end of initializer.module -->
  <xs:attributeGroup name="constructorsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="constructorsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element minOccurs="0" ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="constructorsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of constructorsynopsis.element -->
  <xs:attributeGroup name="constructorsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="constructorsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of constructorsynopsis.attlist -->
  <!-- end of constructorsynopsis.module -->
  <xs:attributeGroup name="destructorsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="destructorsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element minOccurs="0" ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="destructorsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of destructorsynopsis.element -->
  <xs:attributeGroup name="destructorsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="destructorsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of destructorsynopsis.attlist -->
  <!-- end of destructorsynopsis.module -->
  <xs:attributeGroup name="methodsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="methodsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:choice minOccurs="0">
          <xs:element ref="type"/>
          <xs:element ref="void"/>
        </xs:choice>
        <xs:element ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element minOccurs="0" ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="methodsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodsynopsis.element -->
  <xs:attributeGroup name="methodsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodsynopsis.attlist -->
  <!-- end of methodsynopsis.module -->
  <xs:attributeGroup name="methodname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="methodname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="methodname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodname.element -->
  <xs:attributeGroup name="methodname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodname.attlist -->
  <!-- end of methodname.module -->
  <xs:attributeGroup name="methodparam.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="methodparam">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="type"/>
        <xs:choice>
          <xs:sequence>
            <xs:element ref="parameter"/>
            <xs:element minOccurs="0" ref="initializer"/>
          </xs:sequence>
          <xs:element ref="funcparams"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="methodparam.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodparam.element -->
  <xs:attributeGroup name="methodparam.attlist">
    <xs:attribute name="choice" default="req">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodparam.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodparam.attlist -->
  <!-- end of methodparam.module -->
  <!-- end of classsynopsis.content.module -->
  <!-- ...................................................................... -->
  <!-- Document information entities and elements ........................... -->
  <!--
    The document information elements include some elements that are
    currently used only in the document hierarchy module. They are
    defined here so that they will be available for use in customized
    document hierarchies.
  -->
  <!-- .................................. -->
  <!-- Ackno ............................ -->
  <xs:attributeGroup name="ackno.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ackno">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="ackno.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ackno.element -->
  <xs:attributeGroup name="ackno.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ackno.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ackno.attlist -->
  <!-- end of ackno.module -->
  <!-- Address .......................... -->
  <xs:attributeGroup name="address.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="address" substitutionGroup="informal.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="personname"/>
        <xs:group ref="person.ident.mix"/>
        <xs:element ref="street"/>
        <xs:element ref="pob"/>
        <xs:element ref="postcode"/>
        <xs:element ref="city"/>
        <xs:element ref="state"/>
        <xs:element ref="country"/>
        <xs:element ref="phone"/>
        <xs:element ref="fax"/>
        <xs:element ref="email"/>
        <xs:element ref="otheraddr"/>
      </xs:choice>
      <xs:attributeGroup ref="address.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of address.element -->
  <xs:attributeGroup name="address.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="address.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of address.attlist -->
  <!-- end of address.module -->
  <xs:attributeGroup name="street.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="street">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="street.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of street.element -->
  <xs:attributeGroup name="street.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="street.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of street.attlist -->
  <!-- end of street.module -->
  <xs:attributeGroup name="pob.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pob">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pob.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pob.element -->
  <xs:attributeGroup name="pob.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pob.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pob.attlist -->
  <!-- end of pob.module -->
  <xs:attributeGroup name="postcode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="postcode">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="postcode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of postcode.element -->
  <xs:attributeGroup name="postcode.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="postcode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of postcode.attlist -->
  <!-- end of postcode.module -->
  <xs:attributeGroup name="city.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="city">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="city.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of city.element -->
  <xs:attributeGroup name="city.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="city.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of city.attlist -->
  <!-- end of city.module -->
  <xs:attributeGroup name="state.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="state">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="state.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of state.element -->
  <xs:attributeGroup name="state.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="state.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of state.attlist -->
  <!-- end of state.module -->
  <xs:attributeGroup name="country.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="country">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="country.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of country.element -->
  <xs:attributeGroup name="country.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="country.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of country.attlist -->
  <!-- end of country.module -->
  <xs:attributeGroup name="phone.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="phone">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="phone.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of phone.element -->
  <xs:attributeGroup name="phone.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="phone.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of phone.attlist -->
  <!-- end of phone.module -->
  <xs:attributeGroup name="fax.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="fax">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="fax.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of fax.element -->
  <xs:attributeGroup name="fax.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="fax.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of fax.attlist -->
  <!-- end of fax.module -->
  <!-- Email (defined in the Inlines section, below) -->
  <xs:attributeGroup name="otheraddr.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="otheraddr">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="otheraddr.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of otheraddr.element -->
  <xs:attributeGroup name="otheraddr.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="otheraddr.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of otheraddr.attlist -->
  <!-- end of otheraddr.module -->
  <!-- end of address.content.module -->
  <!-- Affiliation ...................... -->
  <xs:attributeGroup name="affiliation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="affiliation">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="shortaffil"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="jobtitle"/>
        <xs:element minOccurs="0" ref="orgname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="orgdiv"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="address"/>
      </xs:sequence>
      <xs:attributeGroup ref="affiliation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of affiliation.element -->
  <xs:attributeGroup name="affiliation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="affiliation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of affiliation.attlist -->
  <!-- end of affiliation.module -->
  <xs:attributeGroup name="shortaffil.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="shortaffil">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="shortaffil.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of shortaffil.element -->
  <xs:attributeGroup name="shortaffil.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="shortaffil.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of shortaffil.attlist -->
  <!-- end of shortaffil.module -->
  <xs:attributeGroup name="jobtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="jobtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="jobtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of jobtitle.element -->
  <xs:attributeGroup name="jobtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="jobtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of jobtitle.attlist -->
  <!-- end of jobtitle.module -->
  <!-- OrgName (defined elsewhere in this section) -->
  <xs:attributeGroup name="orgdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="orgdiv">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="orgdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orgdiv.element -->
  <xs:attributeGroup name="orgdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="orgdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orgdiv.attlist -->
  <!-- end of orgdiv.module -->
  <!-- Address (defined elsewhere in this section) -->
  <!-- end of affiliation.content.module -->
  <!-- ArtPageNums ...................... -->
  <xs:attributeGroup name="artpagenums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="artpagenums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="artpagenums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of artpagenums.element -->
  <xs:attributeGroup name="artpagenums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="artpagenums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of artpagenums.attlist -->
  <!-- end of artpagenums.module -->
  <!-- PersonName -->
  <xs:attributeGroup name="personname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="personname" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="honorific"/>
        <xs:element ref="firstname"/>
        <xs:element ref="surname"/>
        <xs:element ref="lineage"/>
        <xs:element ref="othername"/>
      </xs:choice>
      <xs:attributeGroup ref="personname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of personname.element -->
  <xs:attributeGroup name="personname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="personname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of personname.attlist -->
  <!-- end of personname.module -->
  <!-- Author ........................... -->
  <xs:attributeGroup name="author.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="author" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="author.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of author.element -->
  <xs:attributeGroup name="author.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="author.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of author.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of author.module -->
  <!-- AuthorGroup ...................... -->
  <xs:attributeGroup name="authorgroup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="authorgroup">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="author"/>
        <xs:element ref="editor"/>
        <xs:element ref="collab"/>
        <xs:element ref="corpauthor"/>
        <xs:element ref="corpcredit"/>
        <xs:element ref="othercredit"/>
      </xs:choice>
      <xs:attributeGroup ref="authorgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorgroup.element -->
  <xs:attributeGroup name="authorgroup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorgroup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorgroup.attlist -->
  <!-- end of authorgroup.module -->
  <!-- Author (defined elsewhere in this section) -->
  <!-- Editor (defined elsewhere in this section) -->
  <xs:attributeGroup name="collab.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="collab">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="collabname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="affiliation"/>
      </xs:sequence>
      <xs:attributeGroup ref="collab.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of collab.element -->
  <xs:attributeGroup name="collab.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="collab.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of collab.attlist -->
  <!-- end of collab.module -->
  <xs:attributeGroup name="collabname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="collabname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="collabname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of collabname.element -->
  <xs:attributeGroup name="collabname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="collabname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of collabname.attlist -->
  <!-- end of collabname.module -->
  <!-- Affiliation (defined elsewhere in this section) -->
  <!-- end of collab.content.module -->
  <!-- CorpAuthor (defined elsewhere in this section) -->
  <!-- OtherCredit (defined elsewhere in this section) -->
  <!-- end of authorgroup.content.module -->
  <!-- AuthorInitials ................... -->
  <xs:attributeGroup name="authorinitials.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="authorinitials" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="authorinitials.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorinitials.element -->
  <xs:attributeGroup name="authorinitials.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorinitials.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorinitials.attlist -->
  <!-- end of authorinitials.module -->
  <!-- ConfGroup ........................ -->
  <xs:attributeGroup name="confgroup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confgroup">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="confdates"/>
        <xs:element ref="conftitle"/>
        <xs:element ref="confnum"/>
        <xs:element ref="address"/>
        <xs:element ref="confsponsor"/>
      </xs:choice>
      <xs:attributeGroup ref="confgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confgroup.element -->
  <xs:attributeGroup name="confgroup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confgroup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confgroup.attlist -->
  <!-- end of confgroup.module -->
  <xs:attributeGroup name="confdates.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confdates">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confdates.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confdates.element -->
  <xs:attributeGroup name="confdates.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confdates.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confdates.attlist -->
  <!-- end of confdates.module -->
  <xs:attributeGroup name="conftitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="conftitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="conftitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of conftitle.element -->
  <xs:attributeGroup name="conftitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="conftitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of conftitle.attlist -->
  <!-- end of conftitle.module -->
  <xs:attributeGroup name="confnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confnum.element -->
  <xs:attributeGroup name="confnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confnum.attlist -->
  <!-- end of confnum.module -->
  <!-- Address (defined elsewhere in this section) -->
  <xs:attributeGroup name="confsponsor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="confsponsor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confsponsor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confsponsor.element -->
  <xs:attributeGroup name="confsponsor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confsponsor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confsponsor.attlist -->
  <!-- end of confsponsor.module -->
  <!-- end of confgroup.content.module -->
  <!-- ContractNum ...................... -->
  <xs:attributeGroup name="contractnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="contractnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contractnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contractnum.element -->
  <xs:attributeGroup name="contractnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contractnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contractnum.attlist -->
  <!-- end of contractnum.module -->
  <!-- ContractSponsor .................. -->
  <xs:attributeGroup name="contractsponsor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="contractsponsor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contractsponsor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contractsponsor.element -->
  <xs:attributeGroup name="contractsponsor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contractsponsor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contractsponsor.attlist -->
  <!-- end of contractsponsor.module -->
  <!-- Copyright ........................ -->
  <xs:attributeGroup name="copyright.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="copyright">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="year"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="holder"/>
      </xs:sequence>
      <xs:attributeGroup ref="copyright.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of copyright.element -->
  <xs:attributeGroup name="copyright.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="copyright.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of copyright.attlist -->
  <!-- end of copyright.module -->
  <xs:attributeGroup name="year.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="year">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="year.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of year.element -->
  <xs:attributeGroup name="year.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="year.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of year.attlist -->
  <!-- end of year.module -->
  <xs:attributeGroup name="holder.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="holder">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="holder.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of holder.element -->
  <xs:attributeGroup name="holder.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="holder.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of holder.attlist -->
  <!-- end of holder.module -->
  <!-- end of copyright.content.module -->
  <!-- CorpAuthor ....................... -->
  <xs:attributeGroup name="corpauthor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="corpauthor" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpauthor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpauthor.element -->
  <xs:attributeGroup name="corpauthor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpauthor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpauthor.attlist -->
  <!-- end of corpauthor.module -->
  <!-- CorpCredit ...................... -->
  <xs:attributeGroup name="corpcredit.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="corpcredit" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpcredit.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpcredit.element -->
  <xs:attributeGroup name="corpcredit.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="graphicdesigner"/>
          <xs:enumeration value="productioneditor"/>
          <xs:enumeration value="copyeditor"/>
          <xs:enumeration value="technicaleditor"/>
          <xs:enumeration value="translator"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpcredit.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpcredit.attlist -->
  <!-- end of corpcredit.module -->
  <!-- CorpName ......................... -->
  <xs:element name="corpname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpname.element -->
  <xs:attributeGroup name="corpname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="corpname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpname.attlist -->
  <!-- end of corpname.module -->
  <!-- Date ............................. -->
  <xs:attributeGroup name="date.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="date">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="date.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of date.element -->
  <xs:attributeGroup name="date.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="date.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of date.attlist -->
  <!-- end of date.module -->
  <!-- Edition .......................... -->
  <xs:attributeGroup name="edition.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="edition">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="edition.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of edition.element -->
  <xs:attributeGroup name="edition.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="edition.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of edition.attlist -->
  <!-- end of edition.module -->
  <!-- Editor ........................... -->
  <xs:attributeGroup name="editor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="editor">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="editor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of editor.element -->
  <xs:attributeGroup name="editor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="editor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of editor.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of editor.module -->
  <!-- ISBN ............................. -->
  <xs:attributeGroup name="isbn.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="isbn">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="isbn.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of isbn.element -->
  <xs:attributeGroup name="isbn.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="isbn.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of isbn.attlist -->
  <!-- end of isbn.module -->
  <!-- ISSN ............................. -->
  <xs:attributeGroup name="issn.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="issn">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="issn.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of issn.element -->
  <xs:attributeGroup name="issn.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="issn.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of issn.attlist -->
  <!-- end of issn.module -->
  <!-- BiblioId ................. -->
  <xs:attributeGroup name="biblio.class.attrib">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="uri"/>
          <xs:enumeration value="doi"/>
          <xs:enumeration value="isbn"/>
          <xs:enumeration value="issn"/>
          <xs:enumeration value="libraryofcongress"/>
          <xs:enumeration value="pubnumber"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherclass"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="biblioid.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="biblioid">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="biblioid.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioid.element -->
  <xs:attributeGroup name="biblioid.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioid.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioid.attlist -->
  <!-- end of biblioid.module -->
  <!-- CiteBiblioId ................. -->
  <xs:attributeGroup name="citebiblioid.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citebiblioid">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="citebiblioid.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citebiblioid.element -->
  <xs:attributeGroup name="citebiblioid.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citebiblioid.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citebiblioid.attlist -->
  <!-- end of citebiblioid.module -->
  <!-- BiblioSource ................. -->
  <xs:attributeGroup name="bibliosource.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliosource">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliosource.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliosource.element -->
  <xs:attributeGroup name="bibliosource.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliosource.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliosource.attlist -->
  <!-- end of bibliosource.module -->
  <!-- BiblioRelation ................. -->
  <xs:attributeGroup name="bibliorelation.type.attrib">
    <xs:attribute name="type">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="isversionof"/>
          <xs:enumeration value="hasversion"/>
          <xs:enumeration value="isreplacedby"/>
          <xs:enumeration value="replaces"/>
          <xs:enumeration value="isrequiredby"/>
          <xs:enumeration value="requires"/>
          <xs:enumeration value="ispartof"/>
          <xs:enumeration value="haspart"/>
          <xs:enumeration value="isreferencedby"/>
          <xs:enumeration value="references"/>
          <xs:enumeration value="isformatof"/>
          <xs:enumeration value="hasformat"/>
          <xs:enumeration value="othertype"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="othertype"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="bibliorelation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliorelation">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliorelation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliorelation.element -->
  <xs:attributeGroup name="bibliorelation.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="bibliorelation.type.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliorelation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliorelation.attlist -->
  <!-- end of bibliorelation.module -->
  <!-- BiblioCoverage ................. -->
  <xs:attributeGroup name="bibliocoverage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="bibliocoverage">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliocoverage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliocoverage.element -->
  <xs:attributeGroup name="bibliocoverage.attlist">
    <xs:attribute name="spatial">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="dcmipoint"/>
          <xs:enumeration value="iso3166"/>
          <xs:enumeration value="dcmibox"/>
          <xs:enumeration value="tgn"/>
          <xs:enumeration value="otherspatial"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherspatial"/>
    <xs:attribute name="temporal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="dcmiperiod"/>
          <xs:enumeration value="w3c-dtf"/>
          <xs:enumeration value="othertemporal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="othertemporal"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliocoverage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliocoverage.attlist -->
  <!-- end of bibliocoverage.module -->
  <!-- InvPartNumber .................... -->
  <xs:attributeGroup name="invpartnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="invpartnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="invpartnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of invpartnumber.element -->
  <xs:attributeGroup name="invpartnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="invpartnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of invpartnumber.attlist -->
  <!-- end of invpartnumber.module -->
  <!-- IssueNum ......................... -->
  <xs:attributeGroup name="issuenum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="issuenum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="issuenum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of issuenum.element -->
  <xs:attributeGroup name="issuenum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="issuenum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of issuenum.attlist -->
  <!-- end of issuenum.module -->
  <!-- LegalNotice ...................... -->
  <xs:attributeGroup name="legalnotice.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="legalnotice">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="legalnotice.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="legalnotice.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of legalnotice.element -->
  <xs:attributeGroup name="legalnotice.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="legalnotice.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of legalnotice.attlist -->
  <!-- end of legalnotice.module -->
  <!-- ModeSpec ......................... -->
  <xs:attributeGroup name="modespec.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="modespec" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="modespec.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of modespec.element -->
  <!--
    Application: Type of action required for completion
    of the links to which the ModeSpec is relevant (e.g.,
    retrieval query)
  -->
  <xs:attributeGroup name="modespec.attlist">
    <xs:attribute name="application" type="notation.class"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="modespec.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of modespec.attlist -->
  <!-- end of modespec.module -->
  <!-- OrgName .......................... -->
  <xs:attributeGroup name="orgname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="orgname" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="orgname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orgname.element -->
  <xs:attributeGroup name="orgname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="corporation"/>
          <xs:enumeration value="nonprofit"/>
          <xs:enumeration value="consortium"/>
          <xs:enumeration value="informal"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherclass"/>
    <xs:attributeGroup ref="orgname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orgname.attlist -->
  <!-- end of orgname.module -->
  <!-- OtherCredit ...................... -->
  <xs:attributeGroup name="othercredit.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="othercredit" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="othercredit.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of othercredit.element -->
  <xs:attributeGroup name="othercredit.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="graphicdesigner"/>
          <xs:enumeration value="productioneditor"/>
          <xs:enumeration value="copyeditor"/>
          <xs:enumeration value="technicaleditor"/>
          <xs:enumeration value="translator"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="othercredit.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of othercredit.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of othercredit.module -->
  <!-- PageNums ......................... -->
  <xs:attributeGroup name="pagenums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pagenums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pagenums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pagenums.element -->
  <xs:attributeGroup name="pagenums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pagenums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pagenums.attlist -->
  <!-- end of pagenums.module -->
  <!-- Personal identity elements ....... -->
  <!--
    These elements are used only within Author, Editor, and
    OtherCredit.
  -->
  <xs:attributeGroup name="contrib.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="contrib">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contrib.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contrib.element -->
  <xs:attributeGroup name="contrib.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contrib.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contrib.attlist -->
  <!-- end of contrib.module -->
  <xs:attributeGroup name="firstname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="firstname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="firstname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of firstname.element -->
  <xs:attributeGroup name="firstname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="firstname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of firstname.attlist -->
  <!-- end of firstname.module -->
  <xs:attributeGroup name="honorific.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="honorific">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="honorific.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of honorific.element -->
  <xs:attributeGroup name="honorific.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="honorific.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of honorific.attlist -->
  <!-- end of honorific.module -->
  <xs:attributeGroup name="lineage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lineage">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="lineage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lineage.element -->
  <xs:attributeGroup name="lineage.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lineage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lineage.attlist -->
  <!-- end of lineage.module -->
  <xs:attributeGroup name="othername.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="othername">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="othername.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of othername.element -->
  <xs:attributeGroup name="othername.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="othername.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of othername.attlist -->
  <!-- end of othername.module -->
  <xs:attributeGroup name="surname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="surname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="surname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of surname.element -->
  <xs:attributeGroup name="surname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="surname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of surname.attlist -->
  <!-- end of surname.module -->
  <!-- end of person.ident.module -->
  <!-- PrintHistory ..................... -->
  <xs:attributeGroup name="printhistory.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="printhistory">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="printhistory.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of printhistory.element -->
  <xs:attributeGroup name="printhistory.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="printhistory.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of printhistory.attlist -->
  <!-- end of printhistory.module -->
  <!-- ProductName ...................... -->
  <xs:attributeGroup name="productname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="productname" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="productname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of productname.element -->
  <!-- Class: More precisely identifies the item the element names -->
  <xs:attributeGroup name="productname.attlist">
    <xs:attribute name="class" default="trade">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="service"/>
          <xs:enumeration value="trade"/>
          <xs:enumeration value="registered"/>
          <xs:enumeration value="copyright"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="productname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of productname.attlist -->
  <!-- end of productname.module -->
  <!-- ProductNumber .................... -->
  <xs:attributeGroup name="productnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="productnumber" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="productnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of productnumber.element -->
  <xs:attributeGroup name="productnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="productnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of productnumber.attlist -->
  <!-- end of productnumber.module -->
  <!-- PubDate .......................... -->
  <xs:attributeGroup name="pubdate.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pubdate">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pubdate.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pubdate.element -->
  <xs:attributeGroup name="pubdate.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pubdate.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pubdate.attlist -->
  <!-- end of pubdate.module -->
  <!-- Publisher ........................ -->
  <xs:attributeGroup name="publisher.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="publisher">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="publishername"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="address"/>
      </xs:sequence>
      <xs:attributeGroup ref="publisher.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of publisher.element -->
  <xs:attributeGroup name="publisher.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="publisher.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of publisher.attlist -->
  <!-- end of publisher.module -->
  <xs:attributeGroup name="publishername.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="publishername">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="publishername.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of publishername.element -->
  <xs:attributeGroup name="publishername.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="publishername.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of publishername.attlist -->
  <!-- end of publishername.module -->
  <!-- Address (defined elsewhere in this section) -->
  <!-- end of publisher.content.module -->
  <!-- PubsNumber ....................... -->
  <xs:attributeGroup name="pubsnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="pubsnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pubsnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pubsnumber.element -->
  <xs:attributeGroup name="pubsnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pubsnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pubsnumber.attlist -->
  <!-- end of pubsnumber.module -->
  <!-- ReleaseInfo ...................... -->
  <xs:attributeGroup name="releaseinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="releaseinfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="releaseinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of releaseinfo.element -->
  <xs:attributeGroup name="releaseinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="releaseinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of releaseinfo.attlist -->
  <!-- end of releaseinfo.module -->
  <!-- RevHistory ....................... -->
  <xs:attributeGroup name="revhistory.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revhistory" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="revision"/>
      </xs:sequence>
      <xs:attributeGroup ref="revhistory.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revhistory.element -->
  <xs:attributeGroup name="revhistory.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revhistory.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revhistory.attlist -->
  <!-- end of revhistory.module -->
  <xs:attributeGroup name="revision.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revision">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="revnumber"/>
        <xs:element ref="date"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="author"/>
          <xs:element ref="authorinitials"/>
        </xs:choice>
        <xs:choice minOccurs="0">
          <xs:element ref="revremark"/>
          <xs:element ref="revdescription"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="revision.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revision.element -->
  <xs:attributeGroup name="revision.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revision.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revision.attlist -->
  <!-- end of revision.module -->
  <xs:attributeGroup name="revnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="revnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revnumber.element -->
  <xs:attributeGroup name="revnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revnumber.attlist -->
  <!-- end of revnumber.module -->
  <!-- Date (defined elsewhere in this section) -->
  <!-- AuthorInitials (defined elsewhere in this section) -->
  <xs:attributeGroup name="revremark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revremark">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="revremark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revremark.element -->
  <xs:attributeGroup name="revremark.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revremark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revremark.attlist -->
  <!-- end of revremark.module -->
  <xs:attributeGroup name="revdescription.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="revdescription">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="revdescription.mix"/>
      <xs:attributeGroup ref="revdescription.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revdescription.element -->
  <xs:attributeGroup name="revdescription.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revdescription.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revdescription.attlist -->
  <!-- end of revdescription.module -->
  <!-- end of revhistory.content.module -->
  <!-- SeriesVolNums .................... -->
  <xs:attributeGroup name="seriesvolnums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="seriesvolnums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="seriesvolnums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seriesvolnums.element -->
  <xs:attributeGroup name="seriesvolnums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seriesvolnums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seriesvolnums.attlist -->
  <!-- end of seriesvolnums.module -->
  <!-- VolumeNum ........................ -->
  <xs:attributeGroup name="volumenum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="volumenum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="volumenum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of volumenum.element -->
  <xs:attributeGroup name="volumenum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="volumenum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of volumenum.attlist -->
  <!-- end of volumenum.module -->
  <!-- .................................. -->
  <!-- end of docinfo.content.module -->
  <!-- ...................................................................... -->
  <!-- Inline, link, and ubiquitous elements ................................ -->
  <!-- Technical and computer terms ......................................... -->
  <xs:attributeGroup name="accel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="accel">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="accel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of accel.element -->
  <xs:attributeGroup name="accel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="accel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of accel.attlist -->
  <!-- end of accel.module -->
  <xs:attributeGroup name="action.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="action" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="action.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of action.element -->
  <xs:attributeGroup name="action.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="action.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of action.attlist -->
  <!-- end of action.module -->
  <xs:attributeGroup name="application.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="application" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="application.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of application.element -->
  <xs:attributeGroup name="application.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="hardware"/>
          <xs:enumeration value="software"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="application.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of application.attlist -->
  <!-- end of application.module -->
  <xs:attributeGroup name="classname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="classname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="classname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classname.element -->
  <xs:attributeGroup name="classname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classname.attlist -->
  <!-- end of classname.module -->
  <xs:attributeGroup name="package.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="package" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="package.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of package.element -->
  <xs:attributeGroup name="package.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="package.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of package.attlist -->
  <!-- end of package.module -->
  <!--
    CO is a callout area of the LineColumn unit type (a single character
    position); the position is directly indicated by the location of CO.
  -->
  <xs:attributeGroup name="co.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="co">
    <xs:complexType>
      <xs:attributeGroup ref="co.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of co.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <xs:attributeGroup name="co.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="co.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of co.attlist -->
  <!-- end of co.module -->
  <!-- COREF is a reference to a CO -->
  <xs:attributeGroup name="coref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="coref">
    <xs:complexType>
      <xs:attributeGroup ref="coref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of coref.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <xs:attributeGroup name="coref.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="coref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of coref.attlist -->
  <!-- end of coref.module -->
  <xs:attributeGroup name="command.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="command" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="command.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of command.element -->
  <xs:attributeGroup name="command.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="command.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of command.attlist -->
  <!-- end of command.module -->
  <xs:attributeGroup name="computeroutput.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="computeroutput" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="computeroutput.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of computeroutput.element -->
  <xs:attributeGroup name="computeroutput.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="computeroutput.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of computeroutput.attlist -->
  <!-- end of computeroutput.module -->
  <xs:attributeGroup name="database.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="database" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="database.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of database.element -->
  <!-- Class: Type of database the element names; no default -->
  <xs:attributeGroup name="database.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="name"/>
          <xs:enumeration value="table"/>
          <xs:enumeration value="field"/>
          <xs:enumeration value="key1"/>
          <xs:enumeration value="key2"/>
          <xs:enumeration value="record"/>
          <xs:enumeration value="index"/>
          <xs:enumeration value="view"/>
          <xs:enumeration value="primarykey"/>
          <xs:enumeration value="secondarykey"/>
          <xs:enumeration value="foreignkey"/>
          <xs:enumeration value="altkey"/>
          <xs:enumeration value="procedure"/>
          <xs:enumeration value="datatype"/>
          <xs:enumeration value="constraint"/>
          <xs:enumeration value="rule"/>
          <xs:enumeration value="user"/>
          <xs:enumeration value="group"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="database.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of database.attlist -->
  <!-- end of database.module -->
  <xs:attributeGroup name="email.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="email" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="email.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of email.element -->
  <xs:attributeGroup name="email.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="email.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of email.attlist -->
  <!-- end of email.module -->
  <xs:attributeGroup name="envar.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="envar" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="envar.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of envar.element -->
  <xs:attributeGroup name="envar.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="envar.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of envar.attlist -->
  <!-- end of envar.module -->
  <xs:attributeGroup name="errorcode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errorcode" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errorcode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errorcode.element -->
  <xs:attributeGroup name="errorcode.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errorcode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errorcode.attlist -->
  <!-- end of errorcode.module -->
  <xs:attributeGroup name="errorname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errorname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errorname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errorname.element -->
  <xs:attributeGroup name="errorname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errorname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errorname.attlist -->
  <!-- end of errorname.module -->
  <xs:attributeGroup name="errortext.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errortext" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errortext.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errortext.element -->
  <xs:attributeGroup name="errortext.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errortext.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errortext.attlist -->
  <!-- end of errortext.module -->
  <xs:attributeGroup name="errortype.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="errortype" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errortype.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errortype.element -->
  <xs:attributeGroup name="errortype.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errortype.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errortype.attlist -->
  <!-- end of errortype.module -->
  <xs:attributeGroup name="filename.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="filename" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="filename.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of filename.element -->
  <!-- Class: Type of filename the element names; no default -->
  <!--
    Path: Search path (possibly system-specific) in which
    file can be found
  -->
  <xs:attributeGroup name="filename.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="headerfile"/>
          <xs:enumeration value="partition"/>
          <xs:enumeration value="devicefile"/>
          <xs:enumeration value="libraryfile"/>
          <xs:enumeration value="directory"/>
          <xs:enumeration value="extension"/>
          <xs:enumeration value="symlink"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="path"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="filename.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of filename.attlist -->
  <!-- end of filename.module -->
  <xs:attributeGroup name="function.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="function" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="function.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of function.element -->
  <xs:attributeGroup name="function.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="function.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of function.attlist -->
  <!-- end of function.module -->
  <xs:attributeGroup name="guibutton.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guibutton" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guibutton.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guibutton.element -->
  <xs:attributeGroup name="guibutton.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guibutton.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guibutton.attlist -->
  <!-- end of guibutton.module -->
  <xs:attributeGroup name="guiicon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guiicon" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guiicon.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guiicon.element -->
  <xs:attributeGroup name="guiicon.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guiicon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guiicon.attlist -->
  <!-- end of guiicon.module -->
  <xs:attributeGroup name="guilabel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guilabel" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guilabel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guilabel.element -->
  <xs:attributeGroup name="guilabel.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guilabel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guilabel.attlist -->
  <!-- end of guilabel.module -->
  <xs:attributeGroup name="guimenu.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guimenu" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guimenu.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guimenu.element -->
  <xs:attributeGroup name="guimenu.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guimenu.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guimenu.attlist -->
  <!-- end of guimenu.module -->
  <xs:attributeGroup name="guimenuitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guimenuitem" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guimenuitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guimenuitem.element -->
  <xs:attributeGroup name="guimenuitem.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guimenuitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guimenuitem.attlist -->
  <!-- end of guimenuitem.module -->
  <xs:attributeGroup name="guisubmenu.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="guisubmenu" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guisubmenu.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guisubmenu.element -->
  <xs:attributeGroup name="guisubmenu.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guisubmenu.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guisubmenu.attlist -->
  <!-- end of guisubmenu.module -->
  <xs:attributeGroup name="hardware.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="hardware" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="hardware.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of hardware.element -->
  <xs:attributeGroup name="hardware.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="hardware.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of hardware.attlist -->
  <!-- end of hardware.module -->
  <xs:attributeGroup name="interface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="interface" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="interface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of interface.element -->
  <!-- Class: Type of the Interface item; no default -->
  <xs:attributeGroup name="interface.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="interface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of interface.attlist -->
  <!-- end of interface.module -->
  <xs:attributeGroup name="keycap.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keycap" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="keycap.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycap.element -->
  <xs:attributeGroup name="keycap.attlist">
    <xs:attribute name="function">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="alt"/>
          <xs:enumeration value="control"/>
          <xs:enumeration value="shift"/>
          <xs:enumeration value="meta"/>
          <xs:enumeration value="escape"/>
          <xs:enumeration value="enter"/>
          <xs:enumeration value="tab"/>
          <xs:enumeration value="backspace"/>
          <xs:enumeration value="command"/>
          <xs:enumeration value="option"/>
          <xs:enumeration value="space"/>
          <xs:enumeration value="delete"/>
          <xs:enumeration value="insert"/>
          <xs:enumeration value="up"/>
          <xs:enumeration value="down"/>
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="home"/>
          <xs:enumeration value="end"/>
          <xs:enumeration value="pageup"/>
          <xs:enumeration value="pagedown"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherfunction"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycap.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycap.attlist -->
  <!-- end of keycap.module -->
  <xs:attributeGroup name="keycode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keycode" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="keycode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycode.element -->
  <xs:attributeGroup name="keycode.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycode.attlist -->
  <!-- end of keycode.module -->
  <xs:attributeGroup name="keycombo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keycombo" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="keycap"/>
        <xs:element ref="keycombo"/>
        <xs:element ref="keysym"/>
        <xs:element ref="mousebutton"/>
      </xs:choice>
      <xs:attributeGroup ref="keycombo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycombo.element -->
  <xs:attributeGroup name="keycombo.attlist">
    <xs:attributeGroup ref="keyaction.attrib"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycombo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycombo.attlist -->
  <!-- end of keycombo.module -->
  <xs:attributeGroup name="keysysm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="keysym" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="keysym.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keysym.element -->
  <xs:attributeGroup name="keysym.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keysysm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keysym.attlist -->
  <!-- end of keysym.module -->
  <xs:attributeGroup name="lineannotation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="lineannotation">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="lineannotation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lineannotation.element -->
  <xs:attributeGroup name="lineannotation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lineannotation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lineannotation.attlist -->
  <!-- end of lineannotation.module -->
  <xs:attributeGroup name="literal.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="literal" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="literal.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of literal.element -->
  <xs:attributeGroup name="literal.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="literal.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of literal.attlist -->
  <!-- end of literal.module -->
  <xs:attributeGroup name="code.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="code" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="code.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of code.element -->
  <xs:attributeGroup name="code.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="code.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of code.attlist -->
  <!-- end of code.module -->
  <xs:attributeGroup name="constant.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="constant" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="constant.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of constant.element -->
  <xs:attributeGroup name="constant.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="limit"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="constant.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of constant.attlist -->
  <!-- end of constant.module -->
  <xs:attributeGroup name="varname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="varname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="varname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varname.element -->
  <xs:attributeGroup name="varname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varname.attlist -->
  <!-- end of varname.module -->
  <xs:attributeGroup name="markup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="markup" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="markup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of markup.element -->
  <xs:attributeGroup name="markup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="markup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of markup.attlist -->
  <!-- end of markup.module -->
  <xs:attributeGroup name="medialabel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="medialabel" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="medialabel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of medialabel.element -->
  <!-- Class: Type of medium named by the element; no default -->
  <xs:attributeGroup name="medialabel.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="cartridge"/>
          <xs:enumeration value="cdrom"/>
          <xs:enumeration value="disk"/>
          <xs:enumeration value="tape"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="medialabel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of medialabel.attlist -->
  <!-- end of medialabel.module -->
  <xs:attributeGroup name="menuchoice.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="menuchoice" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="shortcut"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="guibutton"/>
          <xs:element ref="guiicon"/>
          <xs:element ref="guilabel"/>
          <xs:element ref="guimenu"/>
          <xs:element ref="guimenuitem"/>
          <xs:element ref="guisubmenu"/>
          <xs:element ref="interface"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="menuchoice.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of menuchoice.element -->
  <xs:attributeGroup name="menuchoice.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="menuchoice.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of menuchoice.attlist -->
  <!-- end of menuchoice.module -->
  <!-- See also KeyCombo -->
  <xs:attributeGroup name="shortcut.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="shortcut">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="keycap"/>
        <xs:element ref="keycombo"/>
        <xs:element ref="keysym"/>
        <xs:element ref="mousebutton"/>
      </xs:choice>
      <xs:attributeGroup ref="shortcut.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of shortcut.element -->
  <xs:attributeGroup name="shortcut.attlist">
    <xs:attributeGroup ref="keyaction.attrib"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="shortcut.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of shortcut.attlist -->
  <!-- end of shortcut.module -->
  <!-- end of menuchoice.content.module -->
  <xs:attributeGroup name="mousebutton.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="mousebutton" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="mousebutton.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mousebutton.element -->
  <xs:attributeGroup name="mousebutton.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mousebutton.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mousebutton.attlist -->
  <!-- end of mousebutton.module -->
  <xs:attributeGroup name="msgtext.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="msgtext">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="msgtext.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgtext.element -->
  <xs:attributeGroup name="msgtext.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgtext.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgtext.attlist -->
  <!-- end of msgtext.module -->
  <xs:attributeGroup name="option.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="option" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="option.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of option.element -->
  <xs:attributeGroup name="option.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="option.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of option.attlist -->
  <!-- end of option.module -->
  <xs:attributeGroup name="optional.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="optional" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="optional.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of optional.element -->
  <xs:attributeGroup name="optional.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="optional.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of optional.attlist -->
  <!-- end of optional.module -->
  <xs:attributeGroup name="parameter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="parameter" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="parameter.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of parameter.element -->
  <!-- Class: Type of the Parameter; no default -->
  <xs:attributeGroup name="parameter.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="command"/>
          <xs:enumeration value="function"/>
          <xs:enumeration value="option"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="parameter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of parameter.attlist -->
  <!-- end of parameter.module -->
  <xs:attributeGroup name="prompt.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="prompt" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="prompt.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of prompt.element -->
  <xs:attributeGroup name="prompt.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="prompt.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of prompt.attlist -->
  <!-- end of prompt.module -->
  <xs:attributeGroup name="property.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="property" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="property.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of property.element -->
  <xs:attributeGroup name="property.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="property.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of property.attlist -->
  <!-- end of property.module -->
  <xs:attributeGroup name="replaceable.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="replaceable" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="optional"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="replaceable.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of replaceable.element -->
  <!--
    Class: Type of information the element represents; no
    default
  -->
  <xs:attributeGroup name="replaceable.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="command"/>
          <xs:enumeration value="function"/>
          <xs:enumeration value="option"/>
          <xs:enumeration value="parameter"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="replaceable.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of replaceable.attlist -->
  <!-- end of replaceable.module -->
  <xs:attributeGroup name="returnvalue.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="returnvalue" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="returnvalue.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of returnvalue.element -->
  <xs:attributeGroup name="returnvalue.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="returnvalue.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of returnvalue.attlist -->
  <!-- end of returnvalue.module -->
  <xs:attributeGroup name="sgmltag.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="sgmltag" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="sgmltag.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sgmltag.element -->
  <!-- Class: Type of SGML construct the element names; no default -->
  <xs:attributeGroup name="sgmltag.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="attribute"/>
          <xs:enumeration value="attvalue"/>
          <xs:enumeration value="element"/>
          <xs:enumeration value="endtag"/>
          <xs:enumeration value="emptytag"/>
          <xs:enumeration value="genentity"/>
          <xs:enumeration value="numcharref"/>
          <xs:enumeration value="paramentity"/>
          <xs:enumeration value="pi"/>
          <xs:enumeration value="xmlpi"/>
          <xs:enumeration value="starttag"/>
          <xs:enumeration value="sgmlcomment"/>
          <xs:enumeration value="prefix"/>
          <xs:enumeration value="namespace"/>
          <xs:enumeration value="localname"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="namespace"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sgmltag.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sgmltag.attlist -->
  <!-- end of sgmltag.module -->
  <xs:attributeGroup name="structfield.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="structfield" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="structfield.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of structfield.element -->
  <xs:attributeGroup name="structfield.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="structfield.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of structfield.attlist -->
  <!-- end of structfield.module -->
  <xs:attributeGroup name="structname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="structname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="structname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of structname.element -->
  <xs:attributeGroup name="structname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="structname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of structname.attlist -->
  <!-- end of structname.module -->
  <xs:attributeGroup name="symbol.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="symbol" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="symbol.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of symbol.element -->
  <!-- Class: Type of symbol; no default -->
  <xs:attributeGroup name="symbol.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="limit"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="symbol.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of symbol.attlist -->
  <!-- end of symbol.module -->
  <xs:attributeGroup name="systemitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="systemitem" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="acronym"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="systemitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of systemitem.element -->
  <!-- Class: Type of system item the element names; no default -->
  <xs:attributeGroup name="systemitem.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="constant"/>
          <xs:enumeration value="daemon"/>
          <xs:enumeration value="domainname"/>
          <xs:enumeration value="etheraddress"/>
          <xs:enumeration value="event"/>
          <xs:enumeration value="eventhandler"/>
          <xs:enumeration value="filesystem"/>
          <xs:enumeration value="fqdomainname"/>
          <xs:enumeration value="groupname"/>
          <xs:enumeration value="ipaddress"/>
          <xs:enumeration value="library"/>
          <xs:enumeration value="macro"/>
          <xs:enumeration value="netmask"/>
          <xs:enumeration value="newsgroup"/>
          <xs:enumeration value="osname"/>
          <xs:enumeration value="protocol"/>
          <xs:enumeration value="resource"/>
          <xs:enumeration value="systemname"/>
          <xs:enumeration value="username"/>
          <xs:enumeration value="process"/>
          <xs:enumeration value="server"/>
          <xs:enumeration value="service"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="systemitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of systemitem.attlist -->
  <!-- end of systemitem.module -->
  <xs:attributeGroup name="uri.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="uri" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="uri.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of uri.element -->
  <!-- Type: Type of URI; no default -->
  <xs:attributeGroup name="uri.attlist">
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="uri.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of uri.attlist -->
  <!-- end of uri.module -->
  <xs:attributeGroup name="token.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="token" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="token.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of token.element -->
  <xs:attributeGroup name="token.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="token.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of token.attlist -->
  <!-- end of token.module -->
  <xs:attributeGroup name="type.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="type" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="type.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of type.element -->
  <xs:attributeGroup name="type.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="type.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of type.attlist -->
  <!-- end of type.module -->
  <xs:attributeGroup name="userinput.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="userinput" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="userinput.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of userinput.element -->
  <xs:attributeGroup name="userinput.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="userinput.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of userinput.attlist -->
  <!-- end of userinput.module -->
  <!-- General words and phrases ............................................ -->
  <xs:attributeGroup name="abbrev.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="abbrev" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="abbrev.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of abbrev.element -->
  <xs:attributeGroup name="abbrev.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="abbrev.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of abbrev.attlist -->
  <!-- end of abbrev.module -->
  <xs:attributeGroup name="acronym.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="acronym" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="acronym.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of acronym.element -->
  <xs:attributeGroup name="acronym.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="acronym.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of acronym.attlist -->
  <!-- end of acronym.module -->
  <xs:attributeGroup name="citation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citation" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="citation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citation.element -->
  <xs:attributeGroup name="citation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citation.attlist -->
  <!-- end of citation.module -->
  <xs:attributeGroup name="citerefentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citerefentry" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="refentrytitle"/>
        <xs:element minOccurs="0" ref="manvolnum"/>
      </xs:sequence>
      <xs:attributeGroup ref="citerefentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citerefentry.element -->
  <xs:attributeGroup name="citerefentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citerefentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citerefentry.attlist -->
  <!-- end of citerefentry.module -->
  <xs:attributeGroup name="refentrytitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="refentrytitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="refentrytitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refentrytitle.element -->
  <xs:attributeGroup name="refentrytitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentrytitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentrytitle.attlist -->
  <!-- end of refentrytitle.module -->
  <xs:attributeGroup name="namvolnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="manvolnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="manvolnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of manvolnum.element -->
  <xs:attributeGroup name="manvolnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="namvolnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of manvolnum.attlist -->
  <!-- end of manvolnum.module -->
  <xs:attributeGroup name="citetitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="citetitle" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="citetitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citetitle.element -->
  <!-- Pubwork: Genre of published work cited; no default -->
  <xs:attributeGroup name="citetitle.attlist">
    <xs:attribute name="pubwork">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="article"/>
          <xs:enumeration value="book"/>
          <xs:enumeration value="chapter"/>
          <xs:enumeration value="part"/>
          <xs:enumeration value="refentry"/>
          <xs:enumeration value="section"/>
          <xs:enumeration value="journal"/>
          <xs:enumeration value="series"/>
          <xs:enumeration value="set"/>
          <xs:enumeration value="manuscript"/>
          <xs:enumeration value="cdrom"/>
          <xs:enumeration value="dvd"/>
          <xs:enumeration value="wiki"/>
          <xs:enumeration value="gopher"/>
          <xs:enumeration value="bbs"/>
          <xs:enumeration value="emailmessage"/>
          <xs:enumeration value="webpage"/>
          <xs:enumeration value="newsposting"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citetitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citetitle.attlist -->
  <!-- end of citetitle.module -->
  <xs:attributeGroup name="emphasis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="emphasis" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="emphasis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of emphasis.element -->
  <xs:attributeGroup name="emphasis.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="emphasis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of emphasis.attlist -->
  <!-- end of emphasis.module -->
  <xs:attributeGroup name="foreignphrase.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="foreignphrase" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="foreignphrase.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of foreignphrase.element -->
  <xs:attributeGroup name="foreignphrase.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="foreignphrase.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of foreignphrase.attlist -->
  <!-- end of foreignphrase.module -->
  <xs:attributeGroup name="glossterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="glossterm" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glossterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossterm.element -->
  <!-- to GlossEntry if Glossterm used in text -->
  <!--
    BaseForm: Provides the form of GlossTerm to be used
    for indexing
  -->
  <xs:attributeGroup name="glossterm.attlist">
    <xs:attribute name="baseform"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossterm.attlist -->
  <!-- end of glossterm.module -->
  <xs:attributeGroup name="firstterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="firstterm" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="firstterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of firstterm.element -->
  <!-- to GlossEntry or other explanation -->
  <xs:attributeGroup name="firstterm.attlist">
    <xs:attribute name="baseform"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="firstterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of firstterm.attlist -->
  <!-- end of firstterm.module -->
  <xs:attributeGroup name="phrase.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="phrase" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="phrase.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of phrase.element -->
  <xs:attributeGroup name="phrase.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="phrase.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of phrase.attlist -->
  <!-- end of phrase.module -->
  <xs:attributeGroup name="quote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="quote" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="quote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of quote.element -->
  <xs:attributeGroup name="quote.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="quote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of quote.attlist -->
  <!-- end of quote.module -->
  <xs:attributeGroup name="ssscript.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="subscript">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="symbol"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
      </xs:choice>
      <xs:attributeGroup ref="subscript.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subscript.element -->
  <xs:attributeGroup name="subscript.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ssscript.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subscript.attlist -->
  <xs:element name="superscript">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="symbol"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
      </xs:choice>
      <xs:attributeGroup ref="superscript.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of superscript.element -->
  <xs:attributeGroup name="superscript.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ssscript.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of superscript.attlist -->
  <!-- end of ssscript.module -->
  <xs:attributeGroup name="trademark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="trademark" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="emphasis"/>
      </xs:choice>
      <xs:attributeGroup ref="trademark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of trademark.element -->
  <!-- Class: More precisely identifies the item the element names -->
  <xs:attributeGroup name="trademark.attlist">
    <xs:attribute name="class" default="trade">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="service"/>
          <xs:enumeration value="trade"/>
          <xs:enumeration value="registered"/>
          <xs:enumeration value="copyright"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="trademark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of trademark.attlist -->
  <!-- end of trademark.module -->
  <xs:attributeGroup name="wordasword.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="wordasword" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="wordasword.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of wordasword.element -->
  <xs:attributeGroup name="wordasword.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="wordasword.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of wordasword.attlist -->
  <!-- end of wordasword.module -->
  <!-- Links and cross-references ........................................... -->
  <xs:attributeGroup name="link.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="link" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="link.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of link.element -->
  <!--
    Endterm: ID of element containing text that is to be
    fetched from elsewhere in the document to appear as
    the content of this element
  -->
  <!-- to linked-to object -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="link.attlist">
    <xs:attribute name="endterm" type="xs:IDREF"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="link.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of link.attlist -->
  <!-- end of link.module -->
  <xs:attributeGroup name="olink.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="olink" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="olink.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of olink.element -->
  <!-- TargetDocEnt: Name of an entity to be the target of the link -->
  <!--
    LinkMode: ID of a ModeSpec containing instructions for
    operating on the entity named by TargetDocEnt
  -->
  <!-- LocalInfo: Information that may be passed to ModeSpec -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="olink.attlist">
    <xs:attribute name="targetdocent" type="xs:ENTITY"/>
    <xs:attribute name="linkmode" type="xs:IDREF"/>
    <xs:attribute name="localinfo"/>
    <xs:attribute name="type"/>
    <xs:attribute name="targetdoc"/>
    <xs:attribute name="targetptr"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="olink.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of olink.attlist -->
  <!-- end of olink.module -->
  <xs:attributeGroup name="ulink.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="ulink" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="ulink.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ulink.element -->
  <!-- URL: uniform resource locator; the target of the ULink -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="ulink.attlist">
    <xs:attribute name="url" use="required"/>
    <xs:attribute name="type"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ulink.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ulink.attlist -->
  <!-- end of ulink.module -->
  <xs:attributeGroup name="footnoteref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="footnoteref" substitutionGroup="xref.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="footnoteref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of footnoteref.element -->
  <!-- to footnote content supplied elsewhere -->
  <xs:attributeGroup name="footnoteref.attlist">
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="footnoteref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of footnoteref.attlist -->
  <!-- end of footnoteref.module -->
  <xs:attributeGroup name="xref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="xref" substitutionGroup="xref.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="xref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of xref.element -->
  <!--
    Endterm: ID of element containing text that is to be
    fetched from elsewhere in the document to appear as
    the content of this element
  -->
  <!-- to linked-to object -->
  <xs:attributeGroup name="xref.attlist">
    <xs:attribute name="endterm" type="xs:IDREF"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="xref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of xref.attlist -->
  <!-- end of xref.module -->
  <xs:attributeGroup name="biblioref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="biblioref" substitutionGroup="xref.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="biblioref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioref.element -->
  <xs:attributeGroup name="biblioref.attlist">
    <xs:attribute name="endterm" type="xs:IDREF"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attribute name="units"/>
    <xs:attribute name="begin"/>
    <xs:attribute name="end"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="biblioref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioref.attlist -->
  <!-- end of biblioref.module -->
  <!-- Ubiquitous elements .................................................. -->
  <xs:attributeGroup name="anchor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="anchor">
    <xs:complexType>
      <xs:attributeGroup ref="anchor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of anchor.element -->
  <!-- required -->
  <!-- replaces Lang -->
  <xs:attributeGroup name="anchor.attlist">
    <xs:attributeGroup ref="idreq.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="anchor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of anchor.attlist -->
  <!-- end of anchor.module -->
  <xs:attributeGroup name="beginpage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="beginpage">
    <xs:complexType>
      <xs:attributeGroup ref="beginpage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of beginpage.element -->
  <!-- PageNum: Number of page that begins at this point -->
  <xs:attributeGroup name="beginpage.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="beginpage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of beginpage.attlist -->
  <!-- end of beginpage.module -->
  <!--
    IndexTerms appear in the text flow for generating or linking an
    index.
  -->
  <xs:attributeGroup name="indexterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="indexterm" substitutionGroup="ndxterm.class"/>
  <!-- end of indexterm.element -->
  <!--
    Scope: Indicates which generated indices the IndexTerm
    should appear in: Global (whole document set), Local (this
    document only), or All (both)
  -->
  <!--
    Significance: Whether this IndexTerm is the most pertinent
    of its series (Preferred) or not (Normal, the default)
  -->
  <!--
    Class: Indicates type of IndexTerm; default is Singular,
    or EndOfRange if StartRef is supplied; StartOfRange value
    must be supplied explicitly on starts of ranges
  -->
  <!--
    StartRef: ID of the IndexTerm that starts the indexing
    range ended by this IndexTerm
  -->
  <!--
    Zone: IDs of the elements to which the IndexTerm applies,
    and indicates that the IndexTerm applies to those entire
    elements rather than the point at which the IndexTerm
    occurs
  -->
  <xs:attributeGroup name="indexterm.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attribute name="scope">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="all"/>
          <xs:enumeration value="global"/>
          <xs:enumeration value="local"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="significance" default="normal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="preferred"/>
          <xs:enumeration value="normal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="singular"/>
          <xs:enumeration value="startofrange"/>
          <xs:enumeration value="endofrange"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="startref" type="xs:IDREF"/>
    <xs:attribute name="zone" type="xs:IDREFS"/>
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexterm.attlist -->
  <!-- end of indexterm.module -->
  <xs:attributeGroup name="primsecter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="primary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="primary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of primary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="primary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of primary.attlist -->
  <xs:element name="secondary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="secondary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of secondary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="secondary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of secondary.attlist -->
  <xs:element name="tertiary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="tertiary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tertiary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="tertiary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tertiary.attlist -->
  <!-- end of primsecter.module -->
  <xs:attributeGroup name="seeseealso.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:element name="see">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="see.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of see.element -->
  <xs:attributeGroup name="see.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeseealso.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of see.attlist -->
  <xs:element name="seealso">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seealso.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seealso.element -->
  <xs:attributeGroup name="seealso.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeseealso.role.attrib"/>
  </xs:attributeGroup>
</xs:schema>
<!-- end of seealso.attlist -->
<!-- end of seeseealso.module -->
<!-- end of indexterm.content.module -->
<!-- End of DocBook XML information pool module V4.4 ...................... -->
<!-- ...................................................................... -->
 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 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook XML HTML Table Module V4.4 ................................... -->
<!-- File htmltblx.mod .................................................... -->
<!--
  Copyright 2003, 2004 ArborText, Inc., Norman Walsh, Sun Microsystems,
  Inc., and the Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: htmltblx.mod,v 1.23 2005/01/27 13:52:00 nwalsh Exp $
  
  Permission to use, copy, modify and distribute the DocBook XML DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook XML DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for elements that are
  isomorphic to the HTML elements. One could argue we should
  instead have based ourselves on the XHTML Table Module, but the
  HTML one is more like what browsers are likely to accept today
  and users are likely to use.
  
  This module has been developed for use with the DocBook V4.4
  "union table model" in which elements and attlists common to both
  models are defined (as the union) in the CALS table module by
  setting various parameter entities appropriately in this file.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % htmltbl PUBLIC
  "-//OASIS//ELEMENTS DocBook XML HTML Tables V4.4//EN"
  "htmltblx.mod">
  %htmltbl;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ======================= XHTML Tables ======================================= -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <xs:attributeGroup name="html.coreattrs">
    <xs:attribute name="id" type="xs:ID"/>
    <xs:attribute name="class"/>
    <xs:attribute name="style"/>
    <xs:attribute name="title"/>
  </xs:attributeGroup>
  <!-- Does not contain lang or dir because they are in %common.attribs -->
  <xs:attributeGroup name="i18n">
    <xs:attribute ref="xml:lang"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="events">
    <xs:attribute name="onclick"/>
    <xs:attribute name="ondblclick"/>
    <xs:attribute name="onmousedown"/>
    <xs:attribute name="onmouseup"/>
    <xs:attribute name="onmouseover"/>
    <xs:attribute name="onmousemove"/>
    <xs:attribute name="onmouseout"/>
    <xs:attribute name="onkeypress"/>
    <xs:attribute name="onkeydown"/>
    <xs:attribute name="onkeyup"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="attrs">
    <xs:attributeGroup ref="html.coreattrs"/>
    <xs:attributeGroup ref="i18n"/>
    <xs:attributeGroup ref="events"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="cellhalign">
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="cellvalign">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
          <xs:enumeration value="baseline"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <xs:element name="colgroup">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="col"/>
      </xs:sequence>
      <xs:attributeGroup ref="colgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="col">
    <xs:complexType>
      <xs:attributeGroup ref="col.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="tr">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="th"/>
        <xs:element ref="td"/>
      </xs:choice>
      <xs:attributeGroup ref="tr.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="th">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:group ref="tabentry.mix"/>
        <xs:element ref="table"/>
        <xs:element ref="informaltable"/>
      </xs:choice>
      <xs:attributeGroup ref="th.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="td">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:group ref="tabentry.mix"/>
        <xs:element ref="table"/>
        <xs:element ref="informaltable"/>
      </xs:choice>
      <xs:attributeGroup ref="td.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="colgroup.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="span" default="1"/>
    <xs:attribute name="width"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="col.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="span" default="1"/>
    <xs:attribute name="width"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="tr.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
    <xs:attribute name="bgcolor"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="th.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="abbr"/>
    <xs:attribute name="axis"/>
    <xs:attribute name="headers" type="xs:IDREFS"/>
    <xs:attribute name="scope">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="row"/>
          <xs:enumeration value="col"/>
          <xs:enumeration value="rowgroup"/>
          <xs:enumeration value="colgroup"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rowspan" default="1"/>
    <xs:attribute name="colspan" default="1"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
    <xs:attribute name="nowrap">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="nowrap"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="bgcolor"/>
    <xs:attribute name="width"/>
    <xs:attribute name="height"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="td.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="abbr"/>
    <xs:attribute name="axis"/>
    <xs:attribute name="headers" type="xs:IDREFS"/>
    <xs:attribute name="scope">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="row"/>
          <xs:enumeration value="col"/>
          <xs:enumeration value="rowgroup"/>
          <xs:enumeration value="colgroup"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rowspan" default="1"/>
    <xs:attribute name="colspan" default="1"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
    <xs:attribute name="nowrap">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="nowrap"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="bgcolor"/>
    <xs:attribute name="width"/>
    <xs:attribute name="height"/>
  </xs:attributeGroup>
  <!-- ====================================================== -->
  <!--
    Set up to read in the CALS model configured to
    merge with the XHTML table model
  -->
  <!-- ====================================================== -->
  <xs:attributeGroup name="tables.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- Add label and role attributes to table and informaltable -->
  <xs:attributeGroup name="bodyatt">
    <xs:attribute name="floatstyle"/>
    <xs:attribute name="rowheader">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="firstcol"/>
          <xs:enumeration value="norowheader"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
  </xs:attributeGroup>
  <!--
    Add common attributes to Table, TGroup, TBody, THead, TFoot, Row, 
    EntryTbl, and Entry (and InformalTable element).
  -->
  <xs:attributeGroup name="secur">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attribute name="class"/>
    <xs:attribute name="style"/>
    <xs:attribute name="title"/>
    <xs:attributeGroup ref="i18n"/>
    <xs:attributeGroup ref="events"/>
    <xs:attributeGroup ref="tables.role.attrib"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="common.table.attribs">
    <xs:attributeGroup ref="bodyatt"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- Content model for Table (that also allows HTML tables) -->
  <xs:complexType name="tbl.table.mdl">
    <xs:choice>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="textobject"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="graphic"/>
          <xs:element maxOccurs="unbounded" ref="mediaobject"/>
          <xs:element maxOccurs="unbounded" ref="tgroup"/>
        </xs:choice>
      </xs:sequence>
      <xs:sequence>
        <xs:element ref="caption"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="col"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="colgroup"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="thead"/>
        <xs:element minOccurs="0" ref="tfoot"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="tbody"/>
          <xs:element maxOccurs="unbounded" ref="tr"/>
        </xs:choice>
      </xs:sequence>
    </xs:choice>
  </xs:complexType>
  <xs:group name="informal.tbl.table.mdl">
    <xs:choice>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="textobject"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="graphic"/>
          <xs:element maxOccurs="unbounded" ref="mediaobject"/>
          <xs:element maxOccurs="unbounded" ref="tgroup"/>
        </xs:choice>
      </xs:sequence>
      <xs:sequence>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="col"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="colgroup"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="thead"/>
        <xs:element minOccurs="0" ref="tfoot"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="tbody"/>
          <xs:element maxOccurs="unbounded" ref="tr"/>
        </xs:choice>
      </xs:sequence>
    </xs:choice>
  </xs:group>
  <!-- Attributes for Table (including HTML ones) -->
  <!-- N.B. rules = (none | groups | rows | cols | all) but it can't be spec'd -->
  <!-- that way because 'all' already occurs in a different enumeration in -->
  <!-- CALS tables (frame). -->
  <xs:attributeGroup name="tbl.table.att">
    <xs:attribute name="tabstyle"/>
    <xs:attribute name="tocentry" type="yesorno.attvals"/>
    <xs:attribute name="shortentry" type="yesorno.attvals"/>
    <xs:attribute name="orient">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="port"/>
          <xs:enumeration value="land"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attribute name="summary"/>
    <xs:attribute name="width"/>
    <xs:attribute name="border"/>
    <xs:attribute name="rules"/>
    <xs:attribute name="cellspacing"/>
    <xs:attribute name="cellpadding"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="right"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="bgcolor"/>
  </xs:attributeGroup>
  <xs:simpleType name="tbl.frame.attval">
    <xs:restriction base="xs:token">
      <xs:enumeration value="void"/>
      <xs:enumeration value="above"/>
      <xs:enumeration value="below"/>
      <xs:enumeration value="hsides"/>
      <xs:enumeration value="lhs"/>
      <xs:enumeration value="rhs"/>
      <xs:enumeration value="vsides"/>
      <xs:enumeration value="box"/>
      <xs:enumeration value="border"/>
      <xs:enumeration value="top"/>
      <xs:enumeration value="bottom"/>
      <xs:enumeration value="topbot"/>
      <xs:enumeration value="all"/>
      <xs:enumeration value="sides"/>
      <xs:enumeration value="none"/>
    </xs:restriction>
  </xs:simpleType>
  <!-- Allow either objects or inlines; beware of REs between elements. -->
  <xs:group name="tbl.entry.mdl">
    <xs:choice>
      <xs:group ref="para.char.mix"/>
      <xs:group ref="tabentry.mix"/>
    </xs:choice>
  </xs:group>
  <!--
    thead, tfoot, and tbody are defined in both table models,
    so we set up parameter entities to define union models for them
  -->
  <xs:complexType name="tbl.hdft.mdl">
    <xs:choice>
      <xs:element maxOccurs="unbounded" ref="tr"/>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
        <xs:element maxOccurs="unbounded" ref="row"/>
      </xs:sequence>
    </xs:choice>
  </xs:complexType>
  <xs:complexType name="tbl.tbody.mdl">
    <xs:choice>
      <xs:element maxOccurs="unbounded" ref="tr"/>
      <xs:element maxOccurs="unbounded" ref="row"/>
    </xs:choice>
  </xs:complexType>
</xs:schema>
<!-- End of DocBook XML HTML Table Module V4.4 ............................ -->
<!-- ...................................................................... -->
 PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHhzOnNjaGVtYSB4bWxuczp4cz0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEiIGVsZW1lbnRGb3JtRGVmYXVsdD0icXVhbGlmaWVkIiB0YXJnZXROYW1lc3BhY2U9Imh0dHA6Ly93d3cudzMub3JnL1hNTC8xOTk4L25hbWVzcGFjZSI+CiAgPHhzOmltcG9ydCBzY2hlbWFMb2NhdGlvbj0iZG9jYm9vay54c2QiLz4KICA8eHM6YXR0cmlidXRlIG5hbWU9ImJhc2UiLz4KICA8eHM6YXR0cmlidXRlIG5hbWU9InNwYWNlIj4KICAgIDx4czpzaW1wbGVUeXBlPgogICAgICA8eHM6cmVzdHJpY3Rpb24gYmFzZT0ieHM6dG9rZW4iPgogICAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0icHJlc2VydmUiLz4KICAgICAgPC94czpyZXN0cmljdGlvbj4KICAgIDwveHM6c2ltcGxlVHlwZT4KICA8L3hzOmF0dHJpYnV0ZT4KICA8eHM6YXR0cmlidXRlIG5hbWU9ImxhbmciIHR5cGU9InhzOk5NVE9LRU4iLz4KPC94czpzY2hlbWE+Cg== <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook CALS Table Model V4.5 ........................................ -->
<!-- File calstblx.mod .................................................... -->
<!--
  Copyright 1992-2002 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  This DTD is based on the CALS Table Model
  PUBLIC "-//USA-DOD//DTD Table Model 951010//EN"
  
  $Id: calstblx.dtd 6340 2006-10-03 13:23:24Z nwalsh $
  
  Permission to use, copy, modify and distribute the DocBook DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the CALS Table Model
  converted to XML. It has been modified slightly for use in the
  combined HTML/CALS models supported by DocBook V4.5.
-->
<!--
  These definitions are not directly related to the table model, but are
  used in the default CALS table model and are usually defined elsewhere
  (and prior to the inclusion of this table module) in a CALS DTD.
-->
<!--
  no if zero(s),
  yes if any other digits value
-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <xs:simpleType name="yesorno">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:group name="titles">
    <xs:sequence>
      <xs:element minOccurs="0" ref="title"/>
    </xs:sequence>
  </xs:group>
  <!-- default for use in entry content -->
  <!--
    The parameter entities as defined below provide the CALS table model
    as published (as part of the Example DTD) in MIL-HDBK-28001.
    
    These following declarations provide the CALS-compliant default definitions
    for these entities.  However, these entities can and should be redefined
    (by giving the appropriate parameter entity declaration(s) prior to the
    reference to this Table Model declaration set entity) to fit the needs
    of the current application.
  -->
  <xs:group name="tbl.table-titles.mdl">
    <xs:sequence>
      <xs:group ref="titles"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="tbl.table-main.mdl">
    <xs:choice>
      <xs:element maxOccurs="unbounded" ref="tgroup"/>
      <xs:element maxOccurs="unbounded" ref="graphic"/>
    </xs:choice>
  </xs:group>
  <xs:complexType name="tbl.tgroup.mdl">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="spanspec"/>
      <xs:element minOccurs="0" ref="thead"/>
      <xs:element minOccurs="0" ref="tfoot"/>
      <xs:element ref="tbody"/>
    </xs:sequence>
  </xs:complexType>
  <xs:attributeGroup name="tbl.tgroup.att">
    <xs:attribute name="tgroupstyle"/>
  </xs:attributeGroup>
  <xs:complexType name="tbl.row.mdl">
    <xs:choice maxOccurs="unbounded">
      <xs:element ref="entry"/>
      <xs:element ref="entrytbl"/>
    </xs:choice>
  </xs:complexType>
  <xs:complexType name="tbl.entrytbl.mdl">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
      <xs:element minOccurs="0" maxOccurs="unbounded" ref="spanspec"/>
      <xs:element minOccurs="0" ref="thead"/>
      <xs:element ref="tbody"/>
    </xs:sequence>
  </xs:complexType>
  <!-- =====  Element and attribute declarations follow. ===== -->
  <!-- doc:A formal table in a document. -->
  <xs:element name="table" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.table.mdl">
          <xs:attributeGroup ref="table.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="table.attlist">
    <xs:attribute name="frame" type="tbl.frame.attval"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attributeGroup ref="tbl.table.att"/>
    <xs:attributeGroup ref="bodyatt"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for the main content of a table, or part of a table. -->
  <xs:element name="tgroup">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.tgroup.mdl">
          <xs:attributeGroup ref="tgroup.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tgroup.attlist">
    <xs:attribute name="cols" use="required"/>
    <xs:attributeGroup ref="tbl.tgroup.att"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- doc:Specifications for a column in a table. -->
  <xs:element name="colspec">
    <xs:complexType>
      <xs:attributeGroup ref="colspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="colspec.attlist">
    <xs:attribute name="colnum"/>
    <xs:attribute name="colname"/>
    <xs:attribute name="colwidth"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <!-- doc:Formatting information for a spanned column in a table. -->
  <xs:element name="spanspec">
    <xs:complexType>
      <xs:attributeGroup ref="spanspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="spanspec.attlist">
    <xs:attribute name="namest" use="required"/>
    <xs:attribute name="nameend" use="required"/>
    <xs:attribute name="spanname" use="required"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <!-- doc:A table header consisting of one or more rows. -->
  <xs:element name="thead">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.hdft.mdl">
          <xs:attributeGroup ref="thead.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="thead.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- doc:A table footer consisting of one or more rows. -->
  <xs:element name="tfoot">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.hdft.mdl">
          <xs:attributeGroup ref="tfoot.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tfoot.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for the rows of a table or informal table. -->
  <xs:element name="tbody">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.tbody.mdl">
          <xs:attributeGroup ref="tbody.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="tbody.attlist">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- doc:A row in a table. -->
  <xs:element name="row">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.row.mdl">
          <xs:attributeGroup ref="row.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="row.attlist">
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- doc:A subtable appearing in place of an Entry in a table. -->
  <xs:element name="entrytbl">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="tbl.entrytbl.mdl">
          <xs:attributeGroup ref="entrytbl.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="entrytbl.attlist">
    <xs:attribute name="cols" use="required"/>
    <xs:attributeGroup ref="tbl.tgroup.att"/>
    <xs:attribute name="colname"/>
    <xs:attribute name="spanname"/>
    <xs:attribute name="namest"/>
    <xs:attribute name="nameend"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- doc:A cell in a table. -->
  <xs:element name="entry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="tbl.entry.mdl"/>
      <xs:attributeGroup ref="entry.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="entry.attlist">
    <xs:attribute name="colname"/>
    <xs:attribute name="namest"/>
    <xs:attribute name="nameend"/>
    <xs:attribute name="spanname"/>
    <xs:attribute name="morerows"/>
    <xs:attribute name="colsep" type="yesorno"/>
    <xs:attribute name="rowsep" type="yesorno"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
    <xs:attribute name="rotate" type="yesorno"/>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
</xs:schema>
<!-- End of DocBook CALS Table Model V4.5 ................................. -->
<!-- ...................................................................... -->
 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook document hierarchy module V4.5 ............................... -->
<!-- File dbhierx.mod ..................................................... -->
<!--
  Copyright 1992-2004 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: dbhierx.mod 6340 2006-10-03 13:23:24Z nwalsh $
  
  Permission to use, copy, modify and distribute the DocBook DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the overall document
  hierarchies of DocBook documents.  It covers computer documentation
  manuals and manual fragments, as well as reference entries (such as
  man pages) and technical journals or anthologies containing
  articles.
  
  This module depends on the DocBook information pool module.  All
  elements and entities referenced but not defined here are assumed
  to be defined in the information pool module.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % dbhier PUBLIC
  "-//OASIS//ELEMENTS DocBook Document Hierarchy V4.5//EN"
  "dbhierx.mod">
  %dbhier;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ...................................................................... -->
<!-- Entities for module inclusions ....................................... -->
<!-- ...................................................................... -->
<!-- Entities for element classes ......................................... -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <xs:element name="appendix.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="appendixinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="appendix.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="article.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="articleinfo"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="lot"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:group ref="nav.class"/>
          <xs:element ref="appendix.class"/>
          <xs:element ref="colophon"/>
          <xs:element ref="ackno"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="article.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="book.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="bookinfo"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="dedication"/>
          <xs:element ref="toc"/>
          <xs:element ref="lot"/>
          <xs:element ref="glossary"/>
          <xs:element ref="bibliography"/>
          <xs:element ref="preface"/>
          <xs:element ref="chapter.class"/>
          <xs:element ref="reference"/>
          <xs:element ref="part"/>
          <xs:element ref="article.class"/>
          <xs:element ref="appendix.class"/>
          <xs:group ref="index.class"/>
          <xs:element ref="colophon"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="book.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="chapter.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="chapterinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="chapter.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:group name="index.class">
    <xs:choice>
      <xs:element ref="index"/>
      <xs:element ref="setindex"/>
    </xs:choice>
  </xs:group>
  <xs:element name="refentry.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" ref="refentryinfo"/>
        <xs:element minOccurs="0" ref="refmeta"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="remark"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
        <xs:element maxOccurs="unbounded" ref="refnamediv"/>
        <xs:element minOccurs="0" ref="refsynopsisdiv"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="refsect1"/>
          <xs:element maxOccurs="unbounded" ref="refsection"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="section.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sectioninfo"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="section.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="section.class"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="section.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:group name="nav.class">
    <xs:choice>
      <xs:element ref="toc"/>
      <xs:element ref="lot"/>
      <xs:element ref="index"/>
      <xs:element ref="glossary"/>
      <xs:element ref="bibliography"/>
    </xs:choice>
  </xs:group>
  <!-- Redeclaration placeholder ............................................ -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- ...................................................................... -->
  <!-- Entities for element mixtures ........................................ -->
  <xs:group name="divcomponent.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refcomponent.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="indexdivcomponent.mix">
    <xs:choice>
      <xs:element ref="itemizedlist"/>
      <xs:element ref="orderedlist"/>
      <xs:element ref="variablelist"/>
      <xs:element ref="simplelist"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="anchor"/>
      <xs:element ref="remark"/>
      <xs:element ref="link.char.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refname.char.mix">
    <xs:sequence>
      <xs:element minOccurs="0" ref="tech.char.class"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="partcontent.mix">
    <xs:choice>
      <xs:element ref="appendix.class"/>
      <xs:element ref="chapter.class"/>
      <xs:group ref="nav.class"/>
      <xs:element ref="article.class"/>
      <xs:element ref="preface"/>
      <xs:element ref="refentry.class"/>
      <xs:element ref="reference"/>
    </xs:choice>
  </xs:group>
  <xs:group name="refinline.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="refclass.char.mix">
    <xs:sequence>
      <xs:element minOccurs="0" ref="application"/>
    </xs:sequence>
  </xs:group>
  <!-- Redeclaration placeholder 2 .......................................... -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- ...................................................................... -->
  <!-- Entities for content models .......................................... -->
  <xs:group name="div.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="bookcomponent.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="sect.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="refsect.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="subtitle"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <xs:group name="bookcomponent.content">
    <xs:choice>
      <xs:sequence>
        <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect1"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="section.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="sect1"/>
        <xs:element maxOccurs="unbounded" ref="refentry.class"/>
        <xs:element maxOccurs="unbounded" ref="simplesect"/>
        <xs:element maxOccurs="unbounded" ref="section.class"/>
      </xs:choice>
    </xs:choice>
  </xs:group>
  <!-- ...................................................................... -->
  <!-- Set and SetInfo ...................................................... -->
  <xs:attributeGroup name="set.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A collection of books. -->
  <xs:element name="set">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:element minOccurs="0" ref="setinfo"/>
        <xs:element minOccurs="0" ref="toc"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="set"/>
          <xs:element ref="book.class"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="setindex"/>
      </xs:sequence>
      <xs:attributeGroup ref="set.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of set.element -->
  <!-- FPI: SGML formal public identifier -->
  <xs:attributeGroup name="set.attlist">
    <xs:attribute name="fpi"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="set.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of set.attlist -->
  <!-- end of set.module -->
  <xs:attributeGroup name="setinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Set. -->
  <xs:element name="setinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="setinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setinfo.element -->
  <!--
    Contents: IDs of the ToC, Books, and SetIndex that comprise
    the set, in the order of their appearance
  -->
  <xs:attributeGroup name="setinfo.attlist">
    <xs:attribute name="contents" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="setinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setinfo.attlist -->
  <!-- end of setinfo.module -->
  <!-- end of set.content.module -->
  <!-- ...................................................................... -->
  <!-- Book and BookInfo .................................................... -->
  <xs:attributeGroup name="book.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A book. -->
  <xs:element name="book" substitutionGroup="book.class"/>
  <!-- end of book.element -->
  <!-- FPI: SGML formal public identifier -->
  <xs:attributeGroup name="book.attlist">
    <xs:attribute name="fpi"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="book.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of book.attlist -->
  <!-- end of book.module -->
  <xs:attributeGroup name="bookinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Book. -->
  <xs:element name="bookinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="bookinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bookinfo.element -->
  <!--
    Contents: IDs of the ToC, LoTs, Prefaces, Parts, Chapters,
    Appendixes, References, GLossary, Bibliography, and indexes
    comprising the Book, in the order of their appearance
  -->
  <xs:attributeGroup name="bookinfo.attlist">
    <xs:attribute name="contents" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bookinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bookinfo.attlist -->
  <!-- end of bookinfo.module -->
  <!-- end of book.content.module -->
  <!-- ...................................................................... -->
  <!-- Dedication, ToC, and LoT ............................................. -->
  <xs:attributeGroup name="dedication.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for the dedication section of a book. -->
  <xs:element name="dedication">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="legalnotice.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="dedication.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of dedication.element -->
  <xs:attributeGroup name="dedication.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="dedication.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of dedication.attlist -->
  <!-- end of dedication.module -->
  <xs:attributeGroup name="colophon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Text at the back of a book describing facts about its production. -->
  <xs:element name="colophon">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="textobject.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="colophon.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of colophon.element -->
  <xs:attributeGroup name="colophon.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="colophon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of colophon.attlist -->
  <!-- end of colophon.module -->
  <xs:attributeGroup name="toc.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A table of contents. -->
  <xs:element name="toc">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocfront"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="tocpart"/>
          <xs:element ref="tocchap"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocback"/>
      </xs:sequence>
      <xs:attributeGroup ref="toc.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toc.element -->
  <xs:attributeGroup name="toc.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toc.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toc.attlist -->
  <!-- end of toc.module -->
  <xs:attributeGroup name="tocfront.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An entry in a table of contents for a front matter component. -->
  <xs:element name="tocfront">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocfront.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocfront.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocfront.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocfront.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocfront.attlist -->
  <!-- end of tocfront.module -->
  <xs:attributeGroup name="tocentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A component title in a table of contents. -->
  <xs:element name="tocentry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocentry.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocentry.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocentry.attlist -->
  <!-- end of tocentry.module -->
  <xs:attributeGroup name="tocpart.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An entry in a table of contents for a part of a book. -->
  <xs:element name="tocpart">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="tocchap"/>
      </xs:sequence>
      <xs:attributeGroup ref="tocpart.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocpart.element -->
  <xs:attributeGroup name="tocpart.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocpart.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocpart.attlist -->
  <!-- end of tocpart.module -->
  <xs:attributeGroup name="tocchap.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An entry in a table of contents for a component in the body of a document. -->
  <xs:element name="tocchap">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel1"/>
      </xs:sequence>
      <xs:attributeGroup ref="tocchap.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocchap.element -->
  <xs:attributeGroup name="tocchap.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocchap.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocchap.attlist -->
  <!-- end of tocchap.module -->
  <xs:attributeGroup name="toclevel1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A top-level entry within a table of contents entry for a chapter-like component. -->
  <xs:element name="toclevel1">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel2"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel1.element -->
  <xs:attributeGroup name="toclevel1.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel1.attlist -->
  <!-- end of toclevel1.module -->
  <xs:attributeGroup name="toclevel2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A second-level entry within a table of contents entry for a chapter-like component. -->
  <xs:element name="toclevel2">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel3"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel2.element -->
  <xs:attributeGroup name="toclevel2.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel2.attlist -->
  <!-- end of toclevel2.module -->
  <xs:attributeGroup name="toclevel3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A third-level entry within a table of contents entry for a chapter-like component. -->
  <xs:element name="toclevel3">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel4"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel3.element -->
  <xs:attributeGroup name="toclevel3.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel3.attlist -->
  <!-- end of toclevel3.module -->
  <xs:attributeGroup name="toclevel4.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A fourth-level entry within a table of contents entry for a chapter-like component. -->
  <xs:element name="toclevel4">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="toclevel5"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel4.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel4.element -->
  <xs:attributeGroup name="toclevel4.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel4.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel4.attlist -->
  <!-- end of toclevel4.module -->
  <xs:attributeGroup name="toclevel5.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A fifth-level entry within a table of contents entry for a chapter-like component. -->
  <xs:element name="toclevel5">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="tocentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="toclevel5.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of toclevel5.element -->
  <xs:attributeGroup name="toclevel5.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="toclevel5.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of toclevel5.attlist -->
  <!-- end of toclevel5.module -->
  <xs:attributeGroup name="tocback.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An entry in a table of contents for a back matter component. -->
  <xs:element name="tocback">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="tocback.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tocback.element -->
  <!-- to element that this entry represents -->
  <xs:attributeGroup name="tocback.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tocback.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tocback.attlist -->
  <!-- end of tocback.module -->
  <!-- end of toc.content.module -->
  <xs:attributeGroup name="lot.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A list of the titles of formal objects (as tables or figures) in a document. -->
  <xs:element name="lot">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="lotentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="lot.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lot.element -->
  <xs:attributeGroup name="lot.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lot.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lot.attlist -->
  <!-- end of lot.module -->
  <xs:attributeGroup name="lotentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An entry in a list of titles. -->
  <xs:element name="lotentry">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="lotentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lotentry.element -->
  <!--
    SrcCredit: Information about the source of the entry,
    as for a list of illustrations
  -->
  <!-- linkend: to element that this entry represents -->
  <xs:attributeGroup name="lotentry.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attribute name="srccredit"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lotentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lotentry.attlist -->
  <!-- end of lotentry.module -->
  <!-- end of lot.content.module -->
  <!-- ...................................................................... -->
  <!-- Appendix, Chapter, Part, Preface, Reference, PartIntro ............... -->
  <xs:attributeGroup name="appendix.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An appendix in a Book or Article. -->
  <xs:element name="appendix" substitutionGroup="appendix.class"/>
  <!-- end of appendix.element -->
  <xs:attributeGroup name="appendix.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="appendix.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of appendix.attlist -->
  <!-- end of appendix.module -->
  <xs:attributeGroup name="chapter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A chapter, as of a book. -->
  <xs:element name="chapter" substitutionGroup="chapter.class"/>
  <!-- end of chapter.element -->
  <xs:attributeGroup name="chapter.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="chapter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of chapter.attlist -->
  <!-- end of chapter.module -->
  <!--
    Note that Part was to have its content model reduced in V4.5.  This
    change will not be made after all.
  -->
  <xs:attributeGroup name="part.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A division in a book. -->
  <xs:element name="part">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="partinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" ref="partintro"/>
        <xs:group maxOccurs="unbounded" ref="partcontent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="part.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of part.element -->
  <xs:attributeGroup name="part.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="part.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of part.attlist -->
  <!-- ELEMENT PartIntro (defined below) -->
  <!-- end of part.module -->
  <xs:attributeGroup name="preface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Introductory matter preceding the first chapter of a book. -->
  <xs:element name="preface">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="prefaceinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:element minOccurs="0" ref="tocchap"/>
        <xs:group ref="bookcomponent.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="preface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of preface.element -->
  <xs:attributeGroup name="preface.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="preface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of preface.attlist -->
  <!-- end of preface.module -->
  <xs:attributeGroup name="reference.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A collection of reference entries. -->
  <xs:element name="reference">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="beginpage"/>
        <xs:element minOccurs="0" ref="referenceinfo"/>
        <xs:group ref="bookcomponent.title.content"/>
        <xs:element minOccurs="0" ref="partintro"/>
        <xs:element maxOccurs="unbounded" ref="refentry.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="reference.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of reference.element -->
  <xs:attributeGroup name="reference.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="reference.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of reference.attlist -->
  <!-- ELEMENT PartIntro (defined below) -->
  <!-- end of reference.module -->
  <xs:attributeGroup name="partintro.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An introduction to the contents of a part. -->
  <xs:element name="partintro">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="div.title.content"/>
        <xs:group ref="bookcomponent.content"/>
      </xs:sequence>
      <xs:attributeGroup ref="partintro.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of partintro.element -->
  <xs:attributeGroup name="partintro.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="partintro.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of partintro.attlist -->
  <!-- end of partintro.module -->
  <!-- ...................................................................... -->
  <!-- Other Info elements .................................................. -->
  <xs:attributeGroup name="appendixinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for an Appendix. -->
  <xs:element name="appendixinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="appendixinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of appendixinfo.element -->
  <xs:attributeGroup name="appendixinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="appendixinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of appendixinfo.attlist -->
  <!-- end of appendixinfo.module -->
  <xs:attributeGroup name="bibliographyinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Bibliography. -->
  <xs:element name="bibliographyinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="bibliographyinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliographyinfo.element -->
  <xs:attributeGroup name="bibliographyinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliographyinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliographyinfo.attlist -->
  <!-- end of bibliographyinfo.module -->
  <xs:attributeGroup name="chapterinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Chapter. -->
  <xs:element name="chapterinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="chapterinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of chapterinfo.element -->
  <xs:attributeGroup name="chapterinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="chapterinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of chapterinfo.attlist -->
  <!-- end of chapterinfo.module -->
  <xs:attributeGroup name="glossaryinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Glossary. -->
  <xs:element name="glossaryinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="glossaryinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossaryinfo.element -->
  <xs:attributeGroup name="glossaryinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossaryinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossaryinfo.attlist -->
  <!-- end of glossaryinfo.module -->
  <xs:attributeGroup name="indexinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for an Index. -->
  <xs:element name="indexinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="indexinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexinfo.element -->
  <xs:attributeGroup name="indexinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexinfo.attlist -->
  <!-- end of indexinfo.module -->
  <xs:attributeGroup name="setindexinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a SetIndex. -->
  <xs:element name="setindexinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="setindexinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setindexinfo.element -->
  <xs:attributeGroup name="setindexinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="setindexinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setindexinfo.attlist -->
  <!-- end of setindexinfo.module -->
  <xs:attributeGroup name="partinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Part. -->
  <xs:element name="partinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="partinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of partinfo.element -->
  <xs:attributeGroup name="partinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="partinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of partinfo.attlist -->
  <!-- end of partinfo.module -->
  <xs:attributeGroup name="prefaceinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Preface. -->
  <xs:element name="prefaceinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="prefaceinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of prefaceinfo.element -->
  <xs:attributeGroup name="prefaceinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="prefaceinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of prefaceinfo.attlist -->
  <!-- end of prefaceinfo.module -->
  <xs:attributeGroup name="refentryinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Refentry. -->
  <xs:element name="refentryinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refentryinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refentryinfo.element -->
  <xs:attributeGroup name="refentryinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentryinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentryinfo.attlist -->
  <!-- end of refentryinfo.module -->
  <xs:attributeGroup name="refsectioninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a refsection. -->
  <xs:element name="refsectioninfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsectioninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsectioninfo.element -->
  <xs:attributeGroup name="refsectioninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsectioninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsectioninfo.attlist -->
  <!-- end of refsectioninfo.module -->
  <xs:attributeGroup name="refsect1info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a RefSect1. -->
  <xs:element name="refsect1info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect1info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect1info.element -->
  <xs:attributeGroup name="refsect1info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect1info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect1info.attlist -->
  <!-- end of refsect1info.module -->
  <xs:attributeGroup name="refsect2info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a RefSect2. -->
  <xs:element name="refsect2info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect2info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect2info.element -->
  <xs:attributeGroup name="refsect2info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect2info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect2info.attlist -->
  <!-- end of refsect2info.module -->
  <xs:attributeGroup name="refsect3info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a RefSect3. -->
  <xs:element name="refsect3info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsect3info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect3info.element -->
  <xs:attributeGroup name="refsect3info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect3info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect3info.attlist -->
  <!-- end of refsect3info.module -->
  <xs:attributeGroup name="refsynopsisdivinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a RefSynopsisDiv. -->
  <xs:element name="refsynopsisdivinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="refsynopsisdivinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsynopsisdivinfo.element -->
  <xs:attributeGroup name="refsynopsisdivinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsynopsisdivinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsynopsisdivinfo.attlist -->
  <!-- end of refsynopsisdivinfo.module -->
  <xs:attributeGroup name="referenceinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Reference. -->
  <xs:element name="referenceinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="referenceinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of referenceinfo.element -->
  <xs:attributeGroup name="referenceinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="referenceinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of referenceinfo.attlist -->
  <!-- end of referenceinfo.module -->
  <xs:attributeGroup name="sect1info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Sect1. -->
  <xs:element name="sect1info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect1info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect1info.element -->
  <xs:attributeGroup name="sect1info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect1info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect1info.attlist -->
  <xs:attributeGroup name="sect2info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Sect2. -->
  <xs:element name="sect2info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect2info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect2info.element -->
  <xs:attributeGroup name="sect2info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect2info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect2info.attlist -->
  <xs:attributeGroup name="sect3info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Sect3. -->
  <xs:element name="sect3info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect3info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect3info.element -->
  <xs:attributeGroup name="sect3info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect3info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect3info.attlist -->
  <xs:attributeGroup name="sect4info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Sect4. -->
  <xs:element name="sect4info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect4info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect4info.element -->
  <xs:attributeGroup name="sect4info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect4info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect4info.attlist -->
  <xs:attributeGroup name="sect5info.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Sect5. -->
  <xs:element name="sect5info">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sect5info.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect5info.element -->
  <xs:attributeGroup name="sect5info.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect5info.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect5info.attlist -->
  <!-- ...................................................................... -->
  <!-- Section (parallel to Sect*) ......................................... -->
  <xs:attributeGroup name="section.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A recursive section. -->
  <xs:element name="section" substitutionGroup="section.class"/>
  <!-- end of section.element -->
  <xs:attributeGroup name="section.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="section.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of section.attlist -->
  <!-- end of section.module -->
  <xs:attributeGroup name="sectioninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a recursive section. -->
  <xs:element name="sectioninfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sectioninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sectioninfo.element -->
  <xs:attributeGroup name="sectioninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sectioninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sectioninfo.attlist -->
  <!-- end of sectioninfo.module -->
  <!-- end of section.content.module -->
  <!-- ...................................................................... -->
  <!-- Sect1, Sect2, Sect3, Sect4, Sect5 .................................... -->
  <xs:attributeGroup name="sect1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A top-level section of document. -->
  <xs:element name="sect1">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect1info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect2"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect2"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect1.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect1.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect1.attlist -->
  <!-- end of sect1.module -->
  <xs:attributeGroup name="sect2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A subsection within a Sect1. -->
  <xs:element name="sect2">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect2info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect3"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect3"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect2.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect2.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect2.attlist -->
  <!-- end of sect2.module -->
  <xs:attributeGroup name="sect3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A subsection within a Sect2. -->
  <xs:element name="sect3">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect3info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect4"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect4"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect3.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect3.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect3.attlist -->
  <!-- end of sect3.module -->
  <xs:attributeGroup name="sect4.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A subsection within a Sect3. -->
  <xs:element name="sect4">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect4info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="sect5"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="sect5"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect4.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect4.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect4.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect4.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect4.attlist -->
  <!-- end of sect4.module -->
  <xs:attributeGroup name="sect5.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A subsection within a Sect4. -->
  <xs:element name="sect5">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sect5info"/>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
            <xs:choice>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="refentry.class"/>
              <xs:element minOccurs="0" maxOccurs="unbounded" ref="simplesect"/>
            </xs:choice>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refentry.class"/>
          <xs:element maxOccurs="unbounded" ref="simplesect"/>
        </xs:choice>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="nav.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="sect5.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sect5.element -->
  <!--
    Renderas: Indicates the format in which the heading should
    appear
  -->
  <xs:attributeGroup name="sect5.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sect5.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sect5.attlist -->
  <!-- end of sect5.module -->
  <xs:attributeGroup name="simplesect.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A section of a document with no subdivisions. -->
  <xs:element name="simplesect">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="sect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="divcomponent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplesect.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplesect.element -->
  <xs:attributeGroup name="simplesect.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplesect.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplesect.attlist -->
  <!-- end of simplesect.module -->
  <!-- ...................................................................... -->
  <!-- Bibliography ......................................................... -->
  <xs:attributeGroup name="bibliography.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A bibliography. -->
  <xs:element name="bibliography">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="bibliographyinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="bibliodiv"/>
          <xs:choice maxOccurs="unbounded">
            <xs:element ref="biblioentry"/>
            <xs:element ref="bibliomixed"/>
          </xs:choice>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="bibliography.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliography.element -->
  <xs:attributeGroup name="bibliography.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliography.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliography.attlist -->
  <!-- end of bibliography.module -->
  <xs:attributeGroup name="bibliodiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A section of a Bibliography. -->
  <xs:element name="bibliodiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="biblioentry"/>
          <xs:element ref="bibliomixed"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="bibliodiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliodiv.element -->
  <xs:attributeGroup name="bibliodiv.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliodiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliodiv.attlist -->
  <!-- end of bibliodiv.module -->
  <!-- end of bibliography.content.module -->
  <!-- ...................................................................... -->
  <!-- Glossary ............................................................. -->
  <xs:attributeGroup name="glossary.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A glossary. -->
  <xs:element name="glossary">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="glossaryinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="glossdiv"/>
          <xs:element maxOccurs="unbounded" ref="glossentry"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="bibliography"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossary.element -->
  <xs:attributeGroup name="glossary.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossary.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossary.attlist -->
  <!-- end of glossary.module -->
  <xs:attributeGroup name="glossdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A division in a Glossary. -->
  <xs:element name="glossdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="sect.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:element maxOccurs="unbounded" ref="glossentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossdiv.element -->
  <xs:attributeGroup name="glossdiv.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossdiv.attlist -->
  <!-- end of glossdiv.module -->
  <!-- end of glossary.content.module -->
  <!-- ...................................................................... -->
  <!-- Index and SetIndex ................................................... -->
  <xs:attributeGroup name="indexes.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An index. -->
  <xs:element name="index">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="indexinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexdiv"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="index.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of index.element -->
  <xs:attributeGroup name="index.attlist">
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexes.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of index.attlist -->
  <!-- doc:An index to a set of books. -->
  <xs:element name="setindex">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="setindexinfo"/>
        <xs:group minOccurs="0" ref="bookcomponent.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexdiv"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="indexentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="setindex.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of setindex.element -->
  <xs:attributeGroup name="setindex.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexes.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of setindex.attlist -->
  <!-- end of indexes.module -->
  <!--
    SegmentedList in this content is useful for marking up permuted
    indices.
  -->
  <xs:attributeGroup name="indexdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A division in an index. -->
  <xs:element name="indexdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="sect.title.content"/>
        <xs:sequence>
          <xs:group minOccurs="0" maxOccurs="unbounded" ref="indexdivcomponent.mix"/>
          <xs:choice>
            <xs:element maxOccurs="unbounded" ref="indexentry"/>
            <xs:element ref="segmentedlist"/>
          </xs:choice>
        </xs:sequence>
      </xs:sequence>
      <xs:attributeGroup ref="indexdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexdiv.element -->
  <xs:attributeGroup name="indexdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexdiv.attlist -->
  <!-- end of indexdiv.module -->
  <!-- Index entries appear in the index, not the text. -->
  <xs:attributeGroup name="indexentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An entry in an index. -->
  <xs:element name="indexentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="primaryie"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="seeie"/>
          <xs:element ref="seealsoie"/>
        </xs:choice>
        <xs:sequence minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="secondaryie"/>
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="seeie"/>
            <xs:element ref="seealsoie"/>
            <xs:element ref="tertiaryie"/>
          </xs:choice>
        </xs:sequence>
      </xs:sequence>
      <xs:attributeGroup ref="indexentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of indexentry.element -->
  <xs:attributeGroup name="indexentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexentry.attlist -->
  <!-- end of indexentry.module -->
  <xs:attributeGroup name="primsecterie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A primary term in an index entry, not in the text. -->
  <xs:element name="primaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="primaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of primaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="primaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of primaryie.attlist -->
  <!-- doc:A secondary term in an index entry, rather than in the text. -->
  <xs:element name="secondaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="secondaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of secondaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="secondaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of secondaryie.attlist -->
  <!-- doc:A tertiary term in an index entry, rather than in the text. -->
  <xs:element name="tertiaryie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="tertiaryie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tertiaryie.element -->
  <!-- to IndexTerms that these entries represent -->
  <xs:attributeGroup name="tertiaryie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecterie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tertiaryie.attlist -->
  <!-- end of primsecterie.module -->
  <xs:attributeGroup name="seeie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A See entry in an index, rather than in the text. -->
  <xs:element name="seeie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seeie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seeie.element -->
  <!-- to IndexEntry to look up -->
  <xs:attributeGroup name="seeie.attlist">
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seeie.attlist -->
  <!-- end of seeie.module -->
  <xs:attributeGroup name="seealsoie.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A See also entry in an index, rather than in the text. -->
  <xs:element name="seealsoie">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seealsoie.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seealsoie.element -->
  <!-- to related IndexEntries -->
  <xs:attributeGroup name="seealsoie.attlist">
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seealsoie.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seealsoie.attlist -->
  <!-- end of seealsoie.module -->
  <!-- end of index.content.module -->
  <!-- ...................................................................... -->
  <!-- RefEntry ............................................................. -->
  <xs:attributeGroup name="refentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A reference page (originally a UNIX man-style reference page). -->
  <xs:element name="refentry" substitutionGroup="refentry.class"/>
  <!-- end of refentry.element -->
  <xs:attributeGroup name="refentry.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentry.attlist -->
  <!-- end of refentry.module -->
  <xs:attributeGroup name="refmeta.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a reference entry. -->
  <xs:element name="refmeta">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element ref="refentrytitle"/>
        <xs:element minOccurs="0" ref="manvolnum"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="refmiscinfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="refmeta.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refmeta.element -->
  <xs:attributeGroup name="refmeta.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refmeta.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refmeta.attlist -->
  <!-- end of refmeta.module -->
  <xs:attributeGroup name="refmiscinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a reference entry other than the title and volume number. -->
  <xs:element name="refmiscinfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="refmiscinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refmiscinfo.element -->
  <!-- Class: Freely assignable parameter; no default -->
  <xs:attributeGroup name="refmiscinfo.attlist">
    <xs:attribute name="class"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refmiscinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refmiscinfo.attlist -->
  <!-- end of refmiscinfo.module -->
  <xs:attributeGroup name="refnamediv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name, purpose, and classification of a reference page. -->
  <xs:element name="refnamediv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refdescriptor"/>
        <xs:element maxOccurs="unbounded" ref="refname"/>
        <xs:element ref="refpurpose"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="refclass"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="remark"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refnamediv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refnamediv.element -->
  <xs:attributeGroup name="refnamediv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refnamediv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refnamediv.attlist -->
  <!-- end of refnamediv.module -->
  <xs:attributeGroup name="refdescriptor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A description of the topic of a reference page. -->
  <xs:element name="refdescriptor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refname.char.mix"/>
      <xs:attributeGroup ref="refdescriptor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refdescriptor.element -->
  <xs:attributeGroup name="refdescriptor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refdescriptor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refdescriptor.attlist -->
  <!-- end of refdescriptor.module -->
  <xs:attributeGroup name="refname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of (one of) the subject(s) of a reference page. -->
  <xs:element name="refname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refname.char.mix"/>
      <xs:attributeGroup ref="refname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refname.element -->
  <xs:attributeGroup name="refname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refname.attlist -->
  <!-- end of refname.module -->
  <xs:attributeGroup name="refpurpose.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A short (one sentence) synopsis of the topic of a reference page. -->
  <xs:element name="refpurpose">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refinline.char.mix"/>
      <xs:attributeGroup ref="refpurpose.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refpurpose.element -->
  <xs:attributeGroup name="refpurpose.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refpurpose.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refpurpose.attlist -->
  <!-- end of refpurpose.module -->
  <xs:attributeGroup name="refclass.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The scope or other indication of applicability of a reference entry. -->
  <xs:element name="refclass">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="refclass.char.mix"/>
      <xs:attributeGroup ref="refclass.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refclass.element -->
  <xs:attributeGroup name="refclass.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refclass.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refclass.attlist -->
  <!-- end of refclass.module -->
  <xs:attributeGroup name="refsynopsisdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A syntactic synopsis of the subject of the reference page. -->
  <xs:element name="refsynopsisdiv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsynopsisdivinfo"/>
        <xs:group minOccurs="0" ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect2"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect2"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsynopsisdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsynopsisdiv.element -->
  <xs:attributeGroup name="refsynopsisdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsynopsisdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsynopsisdiv.attlist -->
  <!-- end of refsynopsisdiv.module -->
  <xs:attributeGroup name="refsection.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A recursive section in a refentry. -->
  <xs:element name="refsection">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsectioninfo"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsection"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsection"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsection.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsection.element -->
  <xs:attributeGroup name="refsection.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsection.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsection.attlist -->
  <!-- end of refsection.module -->
  <xs:attributeGroup name="refsect1.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A major subsection of a reference entry. -->
  <xs:element name="refsect1">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect1info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect2"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect2"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsect1.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect1.element -->
  <xs:attributeGroup name="refsect1.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect1.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect1.attlist -->
  <!-- end of refsect1.module -->
  <xs:attributeGroup name="refsect2.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A subsection of a RefSect1. -->
  <xs:element name="refsect2">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect2info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="refsect3"/>
          </xs:sequence>
          <xs:element maxOccurs="unbounded" ref="refsect3"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="refsect2.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect2.element -->
  <xs:attributeGroup name="refsect2.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect2.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect2.attlist -->
  <!-- end of refsect2.module -->
  <xs:attributeGroup name="refsect3.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A subsection of a RefSect2. -->
  <xs:element name="refsect3">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="refsect3info"/>
        <xs:group ref="refsect.title.content"/>
        <xs:group maxOccurs="unbounded" ref="refcomponent.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="refsect3.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refsect3.element -->
  <xs:attributeGroup name="refsect3.attlist">
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refsect3.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refsect3.attlist -->
  <!-- end of refsect3.module -->
  <!-- end of refentry.content.module -->
  <!-- ...................................................................... -->
  <!-- Article .............................................................. -->
  <!--
    An Article is a chapter-level, stand-alone document that is often,
    but need not be, collected into a Book.
  -->
  <xs:attributeGroup name="article.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An article. -->
  <xs:element name="article" substitutionGroup="article.class"/>
  <!-- end of article.element -->
  <!--
    Class: Indicates the type of a particular article;
    all articles have the same structure and general purpose.
    No default.
  -->
  <!-- ParentBook: ID of the enclosing Book -->
  <xs:attributeGroup name="article.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="journalarticle"/>
          <xs:enumeration value="productsheet"/>
          <xs:enumeration value="whitepaper"/>
          <xs:enumeration value="techreport"/>
          <xs:enumeration value="specification"/>
          <xs:enumeration value="faq"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="parentbook" type="xs:IDREF"/>
    <xs:attributeGroup ref="status.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="article.role.attrib"/>
  </xs:attributeGroup>
</xs:schema>
<!-- end of article.attlist -->
<!-- end of article.module -->
<!-- End of DocBook document hierarchy module V4.5 ........................ -->
<!-- ...................................................................... -->
 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 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook XML information pool module V4.5 ............................. -->
<!-- File dbpoolx.mod ..................................................... -->
<!--
  Copyright 1992-2004 HaL Computer Systems, Inc.,
  O'Reilly & Associates, Inc., ArborText, Inc., Fujitsu Software
  Corporation, Norman Walsh, Sun Microsystems, Inc., and the
  Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: dbpoolx.mod 6340 2006-10-03 13:23:24Z nwalsh $
  
  Permission to use, copy, modify and distribute the DocBook XML DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook XML DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for the objects, inline
  elements, and so on that are available to be used as the main
  content of DocBook documents.  Some elements are useful for general
  publishing, and others are useful specifically for computer
  documentation.
  
  This module has the following dependencies on other modules:
  
  o It assumes that a %notation.class; entity is defined by the
    driver file or other high-level module.  This entity is
    referenced in the NOTATION attributes for the graphic-related and
    ModeSpec elements.
  
  o It assumes that an appropriately parameterized table module is
    available for use with the table-related elements.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % dbpool PUBLIC
  "-//OASIS//ELEMENTS DocBook XML Information Pool V4.5//EN"
  "dbpoolx.mod">
  %dbpool;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ...................................................................... -->
<!-- Forms entities ....................................................... -->
<!-- These PEs provide the hook by which the forms module can be inserted -->
<!-- into the DTD. -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:include schemaLocation="htmltblx.xsd"/>
  <xs:include schemaLocation="calstblx.xsd"/>
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <!-- ...................................................................... -->
  <!-- General-purpose semantics entities ................................... -->
  <xs:simpleType name="yesorno.attvals">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <!-- ...................................................................... -->
  <!-- Entities for module inclusions ....................................... -->
  <!-- ...................................................................... -->
  <!-- Entities for element classes and mixtures ............................ -->
  <!-- "Ubiquitous" classes: ndxterm.class and beginpage -->
  <xs:element name="ndxterm.class" abstract="true">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="primary"/>
        <xs:choice minOccurs="0">
          <xs:sequence>
            <xs:element ref="secondary"/>
            <xs:choice minOccurs="0">
              <xs:sequence>
                <xs:element ref="tertiary"/>
                <xs:choice minOccurs="0">
                  <xs:element ref="see"/>
                  <xs:element maxOccurs="unbounded" ref="seealso"/>
                </xs:choice>
              </xs:sequence>
              <xs:element ref="see"/>
              <xs:element maxOccurs="unbounded" ref="seealso"/>
            </xs:choice>
          </xs:sequence>
          <xs:element ref="see"/>
          <xs:element maxOccurs="unbounded" ref="seealso"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="indexterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- Object-level classes ................................................. -->
  <xs:element name="list.class" abstract="true"/>
  <xs:element name="admon.class" abstract="true"/>
  <xs:element name="linespecific.class" abstract="true"/>
  <xs:element name="method.synop.class" abstract="true" substitutionGroup="synop.class"/>
  <xs:element name="synop.class" abstract="true"/>
  <xs:element name="para.class" abstract="true"/>
  <xs:element name="informal.class" abstract="true"/>
  <xs:element name="formal.class" abstract="true"/>
  <!-- The DocBook TC may produce an official EBNF module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:element name="compound.class" abstract="true"/>
  <xs:group name="genobj.class">
    <xs:choice>
      <xs:element ref="anchor"/>
      <xs:element ref="bridgehead"/>
      <xs:element ref="remark"/>
      <xs:element ref="highlights"/>
    </xs:choice>
  </xs:group>
  <xs:group name="descobj.class">
    <xs:choice>
      <xs:element ref="abstract"/>
      <xs:element ref="authorblurb"/>
      <xs:element ref="epigraph"/>
    </xs:choice>
  </xs:group>
  <!-- Character-level classes .............................................. -->
  <xs:element name="xref.char.class" abstract="true"/>
  <xs:element name="gen.char.class" abstract="true"/>
  <xs:element name="link.char.class" abstract="true"/>
  <!-- The DocBook TC may produce an official EBNF module for DocBook. -->
  <!-- This PE provides the hook by which it can be inserted into the DTD. -->
  <xs:element name="tech.char.class" abstract="true"/>
  <xs:group name="base.char.class">
    <xs:sequence>
      <xs:element ref="anchor"/>
    </xs:sequence>
  </xs:group>
  <xs:element name="docinfo.char.class" abstract="true"/>
  <xs:group name="other.char.class">
    <xs:choice>
      <xs:element ref="remark"/>
      <xs:element ref="subscript"/>
      <xs:element ref="superscript"/>
    </xs:choice>
  </xs:group>
  <xs:element name="inlineobj.char.class" abstract="true"/>
  <!-- ...................................................................... -->
  <!-- Entities for content models .......................................... -->
  <xs:group name="formalobject.title.content">
    <xs:sequence>
      <xs:element ref="title"/>
      <xs:element minOccurs="0" ref="titleabbrev"/>
    </xs:sequence>
  </xs:group>
  <!-- Redeclaration placeholder ............................................ -->
  <!--
    For redeclaring entities that are declared after this point while
    retaining their references to the entities that are declared before
    this point
  -->
  <!-- Object-level mixtures ................................................ -->
  <!--
                          list admn line synp para infm form cmpd gen  desc
    Component mixture       X    X    X    X    X    X    X    X    X    X
    Sidebar mixture         X    X    X    X    X    X    X    a    X
    Footnote mixture        X         X    X    X    X
    Example mixture         X         X    X    X    X
    Highlights mixture      X    X              X
    Paragraph mixture       X         X    X         X
    Admonition mixture      X         X    X    X    X    X    b    c
    Figure mixture                    X    X         X
    Table entry mixture     X    X    X         X    d
    Glossary def mixture    X         X    X    X    X         e
    Legal notice mixture    X    X    X         X    f
    
    a. Just Procedure; not Sidebar itself or MsgSet.
    b. No MsgSet.
    c. No Highlights.
    d. Just Graphic; no other informal objects.
    e. No Anchor, BridgeHead, or Highlights.
    f. Just BlockQuote; no other informal objects.
  -->
  <xs:group name="component.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="compound.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="sidebar.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="qandaset.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="revdescription.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:group ref="genobj.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="footnote.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="example.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
      <xs:element ref="procedure"/>
    </xs:choice>
  </xs:group>
  <xs:group name="highlights.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <!--
    %formal.class; is explicitly excluded from many contexts in which
    paragraphs are used
  -->
  <xs:group name="para.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
    </xs:choice>
  </xs:group>
  <xs:group name="admon.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="procedure"/>
      <xs:element ref="sidebar"/>
      <xs:element ref="anchor"/>
      <xs:element ref="bridgehead"/>
      <xs:element ref="remark"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="figure.mix">
    <xs:choice>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="tabentry.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="graphic"/>
      <xs:element ref="mediaobject"/>
    </xs:choice>
  </xs:group>
  <xs:group name="glossdef.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:element ref="formal.class"/>
      <xs:element ref="remark"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="legalnotice.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="blockquote"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <xs:group name="textobject.mix">
    <xs:choice>
      <xs:element ref="list.class"/>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="blockquote"/>
    </xs:choice>
  </xs:group>
  <xs:element name="mediaobject.mix" abstract="true"/>
  <xs:group name="listpreamble.mix">
    <xs:choice>
      <xs:element ref="admon.class"/>
      <xs:element ref="linespecific.class"/>
      <xs:element ref="synop.class"/>
      <xs:element ref="para.class"/>
      <xs:element ref="informal.class"/>
      <xs:group ref="genobj.class"/>
      <xs:group ref="descobj.class"/>
      <xs:element ref="ndxterm.class"/>
      <xs:element ref="beginpage"/>
    </xs:choice>
  </xs:group>
  <!-- Character-level mixtures ............................................. -->
  <!-- sgml.features -->
  <!-- not [sgml.features[ -->
  <!-- ]] not sgml.features -->
  <!--
                        #PCD xref word link cptr base dnfo othr inob (synop)
    para.char.mix         X    X    X    X    X    X    X    X    X
    title.char.mix        X    X    X    X    X    X    X    X    X
    ndxterm.char.mix      X    X    X    X    X    X    X    X    a
    cptr.char.mix         X              X    X    X         X    a
    smallcptr.char.mix    X                   b                   a
    word.char.mix         X         c    X         X         X    a
    docinfo.char.mix      X         d    X    b              X    a
    
    a. Just InlineGraphic; no InlineEquation.
    b. Just Replaceable; no other computer terms.
    c. Just Emphasis and Trademark; no other word elements.
    d. Just Acronym, Emphasis, and Trademark; no other word elements.
  -->
  <xs:group name="para.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlineobj.char.class"/>
        <xs:element ref="synop.class"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="title.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlineobj.char.class"/>
        <xs:element ref="ndxterm.class"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="ndxterm.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="xref.char.class"/>
        <xs:element ref="gen.char.class"/>
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:element ref="docinfo.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="cptr.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="smallcptr.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="replaceable"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="word.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="acronym"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="trademark"/>
        <xs:element ref="link.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
        <xs:element ref="beginpage"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="docinfo.char.mix">
    <xs:sequence>
      <xs:choice minOccurs="0">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="trademark"/>
        <xs:element ref="replaceable"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="ndxterm.class"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <!-- ENTITY % bibliocomponent.mix (see Bibliographic section, below) -->
  <!-- ENTITY % person.ident.mix (see Bibliographic section, below) -->
  <!-- ...................................................................... -->
  <!-- Entities for attributes and attribute components ..................... -->
  <!-- Effectivity attributes ............................................... -->
  <!--
    Arch: Computer or chip architecture to which element applies; no
    default
  -->
  <xs:attributeGroup name="arch.attrib">
    <xs:attribute name="arch"/>
  </xs:attributeGroup>
  <!-- Condition: General-purpose effectivity attribute -->
  <xs:attributeGroup name="condition.attrib">
    <xs:attribute name="condition"/>
  </xs:attributeGroup>
  <!-- Conformance: Standards conformance characteristics -->
  <xs:attributeGroup name="conformance.attrib">
    <xs:attribute name="conformance" type="xs:NMTOKENS"/>
  </xs:attributeGroup>
  <!-- OS: Operating system to which element applies; no default -->
  <xs:attributeGroup name="os.attrib">
    <xs:attribute name="os"/>
  </xs:attributeGroup>
  <!-- Revision: Editorial revision to which element belongs; no default -->
  <xs:attributeGroup name="revision.attrib">
    <xs:attribute name="revision"/>
  </xs:attributeGroup>
  <!-- Security: Security classification; no default -->
  <xs:attributeGroup name="security.attrib">
    <xs:attribute name="security"/>
  </xs:attributeGroup>
  <!--
    UserLevel: Level of user experience to which element applies; no
    default
  -->
  <xs:attributeGroup name="userlevel.attrib">
    <xs:attribute name="userlevel"/>
  </xs:attributeGroup>
  <!-- Vendor: Computer vendor to which element applies; no default -->
  <xs:attributeGroup name="vendor.attrib">
    <xs:attribute name="vendor"/>
  </xs:attributeGroup>
  <!-- Wordsize: Computer word size (32 bit, 64 bit, etc.); no default -->
  <xs:attributeGroup name="wordsize.attrib">
    <xs:attribute name="wordsize"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="effectivity.attrib">
    <xs:attributeGroup ref="arch.attrib"/>
    <xs:attributeGroup ref="condition.attrib"/>
    <xs:attributeGroup ref="conformance.attrib"/>
    <xs:attributeGroup ref="os.attrib"/>
    <xs:attributeGroup ref="revision.attrib"/>
    <xs:attributeGroup ref="security.attrib"/>
    <xs:attributeGroup ref="userlevel.attrib"/>
    <xs:attributeGroup ref="vendor.attrib"/>
    <xs:attributeGroup ref="wordsize.attrib"/>
  </xs:attributeGroup>
  <!-- Common attributes .................................................... -->
  <!-- Id: Unique identifier of element; no default -->
  <xs:attributeGroup name="id.attrib">
    <xs:attribute name="id" type="xs:ID"/>
  </xs:attributeGroup>
  <!--
    Id: Unique identifier of element; a value must be supplied; no
    default
  -->
  <xs:attributeGroup name="idreq.attrib">
    <xs:attribute name="id" use="required" type="xs:ID"/>
  </xs:attributeGroup>
  <!--
    Lang: Indicator of language in which element is written, for
    translation, character set management, etc.; no default
  -->
  <xs:attributeGroup name="lang.attrib">
    <xs:attribute name="lang"/>
  </xs:attributeGroup>
  <!-- Remap: Previous role of element before conversion; no default -->
  <xs:attributeGroup name="remap.attrib">
    <xs:attribute name="remap"/>
  </xs:attributeGroup>
  <!-- Role: New role of element in local environment; no default -->
  <xs:attributeGroup name="role.attrib">
    <xs:attribute name="role"/>
  </xs:attributeGroup>
  <!--
    XRefLabel: Alternate labeling string for XRef text generation;
    default is usually title or other appropriate label text already
    contained in element
  -->
  <xs:attributeGroup name="xreflabel.attrib">
    <xs:attribute name="xreflabel"/>
  </xs:attributeGroup>
  <!--
    RevisionFlag: Revision status of element; default is that element
    wasn't revised
  -->
  <xs:attributeGroup name="revisionflag.attrib">
    <xs:attribute name="revisionflag">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="changed"/>
          <xs:enumeration value="added"/>
          <xs:enumeration value="deleted"/>
          <xs:enumeration value="off"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- dir: Bidirectional override -->
  <xs:attributeGroup name="dir.attrib">
    <xs:attribute name="dir">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="ltr"/>
          <xs:enumeration value="rtl"/>
          <xs:enumeration value="lro"/>
          <xs:enumeration value="rlo"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- xml:base: base URI -->
  <xs:attributeGroup name="xml-base.attrib">
    <xs:attribute ref="xml:base"/>
  </xs:attributeGroup>
  <!-- Role is included explicitly on each element -->
  <xs:attributeGroup name="common.attrib">
    <xs:attributeGroup ref="id.attrib"/>
    <xs:attributeGroup ref="lang.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="dir.attrib"/>
    <xs:attributeGroup ref="xml-base.attrib"/>
  </xs:attributeGroup>
  <!-- Role is included explicitly on each element -->
  <xs:attributeGroup name="idreq.common.attrib">
    <xs:attributeGroup ref="idreq.attrib"/>
    <xs:attributeGroup ref="lang.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="dir.attrib"/>
    <xs:attributeGroup ref="xml-base.attrib"/>
  </xs:attributeGroup>
  <!-- Semi-common attributes and other attribute entities .................. -->
  <!--
    EntityRef: Name of an external entity containing the content
    of the graphic
  -->
  <!--
    FileRef: Filename, qualified by a pathname if desired,
    designating the file containing the content of the graphic
  -->
  <!-- Format: Notation of the element content, if any -->
  <!-- SrcCredit: Information about the source of the Graphic -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="graphics.attrib">
    <xs:attribute name="entityref" type="xs:ENTITY"/>
    <xs:attribute name="fileref"/>
    <xs:attribute name="format" type="notation.class"/>
    <xs:attribute name="srccredit"/>
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
  </xs:attributeGroup>
  <!--
    Action: Key combination type; default is unspecified if one
    child element, Simul if there is more than one; if value is
    Other, the OtherAction attribute must have a nonempty value
  -->
  <!-- OtherAction: User-defined key combination type -->
  <xs:attributeGroup name="keyaction.attrib">
    <xs:attribute name="action">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="click"/>
          <xs:enumeration value="double-click"/>
          <xs:enumeration value="press"/>
          <xs:enumeration value="seq"/>
          <xs:enumeration value="simul"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otheraction"/>
  </xs:attributeGroup>
  <!--
    Label: Identifying number or string; default is usually the
    appropriate number or string autogenerated by a formatter
  -->
  <xs:attributeGroup name="label.attrib">
    <xs:attribute name="label"/>
  </xs:attributeGroup>
  <!-- xml:space: whitespace treatment -->
  <xs:attributeGroup name="xml-space.attrib">
    <xs:attribute ref="xml:space"/>
  </xs:attributeGroup>
  <!--
    Format: whether element is assumed to contain significant white
    space
  -->
  <xs:attributeGroup name="linespecific.attrib">
    <xs:attribute name="format" default="linespecific">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="linespecific"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="xml-space.attrib"/>
    <xs:attribute name="linenumbering">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="numbered"/>
          <xs:enumeration value="unnumbered"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="continuation">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="continues"/>
          <xs:enumeration value="restarts"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="startinglinenumber"/>
    <xs:attribute name="language"/>
  </xs:attributeGroup>
  <!-- Linkend: link to related information; no default -->
  <xs:attributeGroup name="linkend.attrib">
    <xs:attribute name="linkend" type="xs:IDREF"/>
  </xs:attributeGroup>
  <!-- Linkend: required link to related information -->
  <xs:attributeGroup name="linkendreq.attrib">
    <xs:attribute name="linkend" use="required" type="xs:IDREF"/>
  </xs:attributeGroup>
  <!--
    Linkends: link to one or more sets of related information; no
    default
  -->
  <xs:attributeGroup name="linkends.attrib">
    <xs:attribute name="linkends" type="xs:IDREFS"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="mark.attrib">
    <xs:attribute name="mark"/>
  </xs:attributeGroup>
  <!-- MoreInfo: whether element's content has an associated RefEntry -->
  <xs:attributeGroup name="moreinfo.attrib">
    <xs:attribute name="moreinfo" default="none">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="refentry"/>
          <xs:enumeration value="none"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- Pagenum: number of page on which element appears; no default -->
  <xs:attributeGroup name="pagenum.attrib">
    <xs:attribute name="pagenum"/>
  </xs:attributeGroup>
  <!--
    Status: Editorial or publication status of the element
    it applies to, such as "in review" or "approved for distribution"
  -->
  <xs:attributeGroup name="status.attrib">
    <xs:attribute name="status"/>
  </xs:attributeGroup>
  <!--
    Width: width of the longest line in the element to which it
    pertains, in number of characters
  -->
  <xs:attributeGroup name="width.attrib">
    <xs:attribute name="width"/>
  </xs:attributeGroup>
  <!-- ...................................................................... -->
  <!-- Title elements ....................................................... -->
  <xs:attributeGroup name="title.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The text of the title of a section of a document or of a formal block-level element. -->
  <xs:element name="title">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="title.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of title.element -->
  <xs:attributeGroup name="title.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="title.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of title.attlist -->
  <!-- end of title.module -->
  <xs:attributeGroup name="titleabbrev.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The abbreviation of a Title. -->
  <xs:element name="titleabbrev">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="titleabbrev.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of titleabbrev.element -->
  <xs:attributeGroup name="titleabbrev.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="titleabbrev.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of titleabbrev.attlist -->
  <!-- end of titleabbrev.module -->
  <xs:attributeGroup name="subtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The subtitle of a document. -->
  <xs:element name="subtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="subtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subtitle.element -->
  <xs:attributeGroup name="subtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subtitle.attlist -->
  <!-- end of subtitle.module -->
  <!-- ...................................................................... -->
  <!-- Bibliographic entities and elements .................................. -->
  <!--
    The bibliographic elements are typically used in the document
    hierarchy. They do not appear in content models of information
    pool elements.  See also the document information elements,
    below.
  -->
  <xs:group name="person.ident.mix">
    <xs:choice>
      <xs:element ref="honorific"/>
      <xs:element ref="firstname"/>
      <xs:element ref="surname"/>
      <xs:element ref="lineage"/>
      <xs:element ref="othername"/>
      <xs:element ref="affiliation"/>
      <xs:element ref="authorblurb"/>
      <xs:element ref="contrib"/>
    </xs:choice>
  </xs:group>
  <xs:group name="bibliocomponent.mix">
    <xs:choice>
      <xs:element ref="abbrev"/>
      <xs:element ref="abstract"/>
      <xs:element ref="address"/>
      <xs:element ref="artpagenums"/>
      <xs:element ref="author"/>
      <xs:element ref="authorgroup"/>
      <xs:element ref="authorinitials"/>
      <xs:element ref="bibliomisc"/>
      <xs:element ref="biblioset"/>
      <xs:element ref="collab"/>
      <xs:element ref="confgroup"/>
      <xs:element ref="contractnum"/>
      <xs:element ref="contractsponsor"/>
      <xs:element ref="copyright"/>
      <xs:element ref="corpauthor"/>
      <xs:element ref="corpname"/>
      <xs:element ref="corpcredit"/>
      <xs:element ref="date"/>
      <xs:element ref="edition"/>
      <xs:element ref="editor"/>
      <xs:element ref="invpartnumber"/>
      <xs:element ref="isbn"/>
      <xs:element ref="issn"/>
      <xs:element ref="issuenum"/>
      <xs:element ref="orgname"/>
      <xs:element ref="biblioid"/>
      <xs:element ref="citebiblioid"/>
      <xs:element ref="bibliosource"/>
      <xs:element ref="bibliorelation"/>
      <xs:element ref="bibliocoverage"/>
      <xs:element ref="othercredit"/>
      <xs:element ref="pagenums"/>
      <xs:element ref="printhistory"/>
      <xs:element ref="productname"/>
      <xs:element ref="productnumber"/>
      <xs:element ref="pubdate"/>
      <xs:element ref="publisher"/>
      <xs:element ref="publishername"/>
      <xs:element ref="pubsnumber"/>
      <xs:element ref="releaseinfo"/>
      <xs:element ref="revhistory"/>
      <xs:element ref="seriesvolnums"/>
      <xs:element ref="subtitle"/>
      <xs:element ref="title"/>
      <xs:element ref="titleabbrev"/>
      <xs:element ref="volumenum"/>
      <xs:element ref="citetitle"/>
      <xs:element ref="personname"/>
      <xs:group ref="person.ident.mix"/>
      <xs:element ref="ndxterm.class"/>
    </xs:choice>
  </xs:group>
  <!-- I don't think this is well placed, but it needs to be here because of -->
  <!-- the reference to bibliocomponent.mix -->
  <xs:group name="info.class">
    <xs:choice>
      <xs:element ref="graphic"/>
      <xs:element ref="mediaobject"/>
      <xs:element ref="legalnotice"/>
      <xs:element ref="modespec"/>
      <xs:element ref="subjectset"/>
      <xs:element ref="keywordset"/>
      <xs:element ref="itermset"/>
      <xs:group ref="bibliocomponent.mix"/>
    </xs:choice>
  </xs:group>
  <!-- BiblioList ........................ -->
  <xs:attributeGroup name="bibliolist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for a set of bibliography entries. -->
  <xs:element name="bibliolist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="biblioentry"/>
          <xs:element ref="bibliomixed"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="bibliolist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliolist.element -->
  <xs:attributeGroup name="bibliolist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliolist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliolist.attlist -->
  <!-- end of bibliolist.module -->
  <xs:attributeGroup name="biblioentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An entry in a Bibliography. -->
  <xs:element name="biblioentry">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="articleinfo"/>
        <xs:group ref="bibliocomponent.mix"/>
      </xs:choice>
      <xs:attributeGroup ref="biblioentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioentry.element -->
  <xs:attributeGroup name="biblioentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioentry.attlist -->
  <!-- end of biblioentry.module -->
  <xs:attributeGroup name="bibliomixed.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An entry in a Bibliography. -->
  <xs:element name="bibliomixed">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="bibliocomponent.mix"/>
        <xs:element ref="bibliomset"/>
      </xs:choice>
      <xs:attributeGroup ref="bibliomixed.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomixed.element -->
  <xs:attributeGroup name="bibliomixed.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomixed.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomixed.attlist -->
  <!-- end of bibliomixed.module -->
  <xs:attributeGroup name="articleinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for an Article. -->
  <xs:element name="articleinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="articleinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of articleinfo.element -->
  <xs:attributeGroup name="articleinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="articleinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of articleinfo.attlist -->
  <!-- end of articleinfo.module -->
  <xs:attributeGroup name="biblioset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A "raw" container for related bibliographic information. -->
  <xs:element name="biblioset">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="bibliocomponent.mix"/>
      <xs:attributeGroup ref="biblioset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioset.element -->
  <!-- Relation: Relationship of elements contained within BiblioSet -->
  <xs:attributeGroup name="biblioset.attlist">
    <xs:attribute name="relation"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioset.attlist -->
  <!-- end of biblioset.module -->
  <xs:attributeGroup name="bibliomset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A "cooked" container for related bibliographic information. -->
  <xs:element name="bibliomset">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="bibliocomponent.mix"/>
        <xs:element ref="bibliomset"/>
      </xs:choice>
      <xs:attributeGroup ref="bibliomset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomset.element -->
  <!-- Relation: Relationship of elements contained within BiblioMSet -->
  <xs:attributeGroup name="bibliomset.attlist">
    <xs:attribute name="relation"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomset.attlist -->
  <!-- end of bibliomset.module -->
  <xs:attributeGroup name="bibliomisc.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Untyped bibliographic information. -->
  <xs:element name="bibliomisc">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="bibliomisc.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliomisc.element -->
  <xs:attributeGroup name="bibliomisc.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliomisc.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliomisc.attlist -->
  <!-- end of bibliomisc.module -->
  <!-- ...................................................................... -->
  <!-- Subject, Keyword, and ITermSet elements .............................. -->
  <xs:attributeGroup name="subjectset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A set of terms describing the subject matter of a document. -->
  <xs:element name="subjectset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="subject"/>
      </xs:sequence>
      <xs:attributeGroup ref="subjectset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subjectset.element -->
  <!-- Scheme: Controlled vocabulary employed in SubjectTerms -->
  <xs:attributeGroup name="subjectset.attlist">
    <xs:attribute name="scheme" type="xs:NMTOKEN"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subjectset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subjectset.attlist -->
  <!-- end of subjectset.module -->
  <xs:attributeGroup name="subject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:One of a group of terms describing the subject matter of a document. -->
  <xs:element name="subject">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="subjectterm"/>
      </xs:sequence>
      <xs:attributeGroup ref="subject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subject.element -->
  <!--
    Weight: Ranking of this group of SubjectTerms relative
    to others, 0 is low, no highest value specified
  -->
  <xs:attributeGroup name="subject.attlist">
    <xs:attribute name="weight"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subject.attlist -->
  <!-- end of subject.module -->
  <xs:attributeGroup name="subjectterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A term in a group of terms describing the subject matter of a document. -->
  <xs:element name="subjectterm">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="subjectterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subjectterm.element -->
  <xs:attributeGroup name="subjectterm.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="subjectterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subjectterm.attlist -->
  <!-- end of subjectterm.module -->
  <!-- end of subjectset.content.module -->
  <xs:attributeGroup name="keywordset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A set of keywords describing the content of a document. -->
  <xs:element name="keywordset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="keyword"/>
      </xs:sequence>
      <xs:attributeGroup ref="keywordset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keywordset.element -->
  <xs:attributeGroup name="keywordset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keywordset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keywordset.attlist -->
  <!-- end of keywordset.module -->
  <xs:attributeGroup name="keyword.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:One of a set of keywords describing the content of a document. -->
  <xs:element name="keyword">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="keyword.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keyword.element -->
  <xs:attributeGroup name="keyword.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keyword.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keyword.attlist -->
  <!-- end of keyword.module -->
  <!-- end of keywordset.content.module -->
  <xs:attributeGroup name="itermset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A set of index terms in the meta-information of a document. -->
  <xs:element name="itermset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="indexterm"/>
      </xs:sequence>
      <xs:attributeGroup ref="itermset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of itermset.element -->
  <xs:attributeGroup name="itermset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="itermset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of itermset.attlist -->
  <!-- end of itermset.module -->
  <!-- Bibliographic info for "blocks" -->
  <xs:attributeGroup name="blockinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a block element. -->
  <xs:element name="blockinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="blockinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of blockinfo.element -->
  <xs:attributeGroup name="blockinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="blockinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of blockinfo.attlist -->
  <!-- end of blockinfo.module -->
  <!-- ...................................................................... -->
  <!-- Compound (section-ish) elements ...................................... -->
  <!-- Message set ...................... -->
  <xs:attributeGroup name="msgset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A detailed set of messages, usually error messages. -->
  <xs:element name="msgset" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="msgentry"/>
          <xs:element maxOccurs="unbounded" ref="simplemsgentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="msgset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgset.element -->
  <xs:attributeGroup name="msgset.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgset.attlist -->
  <!-- end of msgset.module -->
  <xs:attributeGroup name="msgentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for an entry in a message set. -->
  <xs:element name="msgentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="msg"/>
        <xs:element minOccurs="0" ref="msginfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="msgexplan"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgentry.element -->
  <xs:attributeGroup name="msgentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgentry.attlist -->
  <!-- end of msgentry.module -->
  <xs:attributeGroup name="simplemsgentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for a simpler entry in a message set. -->
  <xs:element name="simplemsgentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="msgtext"/>
        <xs:element maxOccurs="unbounded" ref="msgexplan"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplemsgentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplemsgentry.element -->
  <xs:attributeGroup name="simplemsgentry.attlist">
    <xs:attribute name="audience"/>
    <xs:attribute name="level"/>
    <xs:attribute name="origin"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplemsgentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplemsgentry.attlist -->
  <!-- end of simplemsgentry.module -->
  <xs:attributeGroup name="msg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A message in a message set. -->
  <xs:element name="msg">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgmain"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="msgsub"/>
          <xs:element ref="msgrel"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="msg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msg.element -->
  <xs:attributeGroup name="msg.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msg.attlist -->
  <!-- end of msg.module -->
  <xs:attributeGroup name="msgmain.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The primary component of a message in a message set. -->
  <xs:element name="msgmain">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgmain.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgmain.element -->
  <xs:attributeGroup name="msgmain.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgmain.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgmain.attlist -->
  <!-- end of msgmain.module -->
  <xs:attributeGroup name="msgsub.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A subcomponent of a message in a message set. -->
  <xs:element name="msgsub">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgsub.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgsub.element -->
  <xs:attributeGroup name="msgsub.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgsub.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgsub.attlist -->
  <!-- end of msgsub.module -->
  <xs:attributeGroup name="msgrel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A related component of a message in a message set. -->
  <xs:element name="msgrel">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element ref="msgtext"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgrel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgrel.element -->
  <xs:attributeGroup name="msgrel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgrel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgrel.attlist -->
  <!-- end of msgrel.module -->
  <!-- MsgText (defined in the Inlines section, below) -->
  <xs:attributeGroup name="msginfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Information about a message in a message set. -->
  <xs:element name="msginfo">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="msglevel"/>
        <xs:element ref="msgorig"/>
        <xs:element ref="msgaud"/>
      </xs:choice>
      <xs:attributeGroup ref="msginfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msginfo.element -->
  <xs:attributeGroup name="msginfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msginfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msginfo.attlist -->
  <!-- end of msginfo.module -->
  <xs:attributeGroup name="msglevel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The level of importance or severity of a message in a message set. -->
  <xs:element name="msglevel">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="msglevel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msglevel.element -->
  <xs:attributeGroup name="msglevel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msglevel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msglevel.attlist -->
  <!-- end of msglevel.module -->
  <xs:attributeGroup name="msgorig.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The origin of a message in a message set. -->
  <xs:element name="msgorig">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="msgorig.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgorig.element -->
  <xs:attributeGroup name="msgorig.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgorig.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgorig.attlist -->
  <!-- end of msgorig.module -->
  <xs:attributeGroup name="msgaud.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The audience to which a message in a message set is relevant. -->
  <xs:element name="msgaud">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="msgaud.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgaud.element -->
  <xs:attributeGroup name="msgaud.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgaud.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgaud.attlist -->
  <!-- end of msgaud.module -->
  <xs:attributeGroup name="msgexplan.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Explanatory material relating to a message in a message set. -->
  <xs:element name="msgexplan">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="msgexplan.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgexplan.element -->
  <xs:attributeGroup name="msgexplan.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgexplan.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgexplan.attlist -->
  <!-- end of msgexplan.module -->
  <!-- end of msgset.content.module -->
  <xs:attributeGroup name="task.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A task to be completed. -->
  <xs:element name="task" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:element minOccurs="0" ref="tasksummary"/>
        <xs:element minOccurs="0" ref="taskprerequisites"/>
        <xs:element ref="procedure"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="example"/>
        <xs:element minOccurs="0" ref="taskrelated"/>
      </xs:sequence>
      <xs:attributeGroup ref="task.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of task.element -->
  <xs:attributeGroup name="task.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="task.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of task.attlist -->
  <!-- end of task.module -->
  <xs:attributeGroup name="tasksummary.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A summary of a task. -->
  <xs:element name="tasksummary">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="tasksummary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tasksummary.element -->
  <xs:attributeGroup name="tasksummary.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="tasksummary.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tasksummary.attlist -->
  <!-- end of tasksummary.module -->
  <xs:attributeGroup name="taskprerequisites.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The prerequisites for a task. -->
  <xs:element name="taskprerequisites">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="taskprerequisites.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of taskprerequisites.element -->
  <xs:attributeGroup name="taskprerequisites.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="taskprerequisites.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of taskprerequisites.attlist -->
  <!-- end of taskprerequisites.module -->
  <xs:attributeGroup name="taskrelated.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Information related to a task. -->
  <xs:element name="taskrelated">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="taskrelated.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of taskrelated.element -->
  <xs:attributeGroup name="taskrelated.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="taskrelated.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of taskrelated.attlist -->
  <!-- end of taskrelated.module -->
  <!-- end of task.content.module -->
  <!-- QandASet ........................ -->
  <xs:attributeGroup name="qandaset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A question-and-answer set. -->
  <xs:element name="qandaset" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="qandadiv"/>
          <xs:element maxOccurs="unbounded" ref="qandaentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="qandaset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandaset.element -->
  <xs:attributeGroup name="qandaset.attlist">
    <xs:attribute name="defaultlabel">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="qanda"/>
          <xs:enumeration value="number"/>
          <xs:enumeration value="none"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandaset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandaset.attlist -->
  <!-- end of qandaset.module -->
  <xs:attributeGroup name="qandadiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A titled division in a QandASet. -->
  <xs:element name="qandadiv">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="qandadiv"/>
          <xs:element maxOccurs="unbounded" ref="qandaentry"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="qandadiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandadiv.element -->
  <xs:attributeGroup name="qandadiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandadiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandadiv.attlist -->
  <!-- end of qandadiv.module -->
  <xs:attributeGroup name="qandaentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A question/answer set within a QandASet. -->
  <xs:element name="qandaentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="revhistory"/>
        <xs:element ref="question"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="answer"/>
      </xs:sequence>
      <xs:attributeGroup ref="qandaentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of qandaentry.element -->
  <xs:attributeGroup name="qandaentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="qandaentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of qandaentry.attlist -->
  <!-- end of qandaentry.module -->
  <xs:attributeGroup name="question.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A question in a QandASet. -->
  <xs:element name="question">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="label"/>
        <xs:group maxOccurs="unbounded" ref="qandaset.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="question.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of question.element -->
  <xs:attributeGroup name="question.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="question.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of question.attlist -->
  <!-- end of question.module -->
  <xs:attributeGroup name="answer.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An answer to a question posed in a QandASet. -->
  <xs:element name="answer">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="label"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="qandaset.mix"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="qandaentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="answer.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of answer.element -->
  <xs:attributeGroup name="answer.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="answer.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of answer.attlist -->
  <!-- end of answer.module -->
  <xs:attributeGroup name="label.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A label on a Question or Answer. -->
  <xs:element name="label">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="label.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of label.element -->
  <xs:attributeGroup name="label.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="label.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of label.attlist -->
  <!-- end of label.module -->
  <!-- end of qandaset.content.module -->
  <!-- Procedure ........................ -->
  <xs:attributeGroup name="procedure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A list of operations to be performed in a well-defined sequence. -->
  <xs:element name="procedure" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="procedure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of procedure.element -->
  <xs:attributeGroup name="procedure.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="procedure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of procedure.attlist -->
  <!-- end of procedure.module -->
  <xs:attributeGroup name="step.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A unit of action in a procedure. -->
  <xs:element name="step">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:choice>
          <xs:sequence>
            <xs:group maxOccurs="unbounded" ref="component.mix"/>
            <xs:sequence minOccurs="0">
              <xs:choice>
                <xs:element ref="substeps"/>
                <xs:element ref="stepalternatives"/>
              </xs:choice>
              <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
            </xs:sequence>
          </xs:sequence>
          <xs:sequence>
            <xs:choice>
              <xs:element ref="substeps"/>
              <xs:element ref="stepalternatives"/>
            </xs:choice>
            <xs:group minOccurs="0" maxOccurs="unbounded" ref="component.mix"/>
          </xs:sequence>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="step.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of step.element -->
  <!-- Performance: Whether the Step must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="step.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="step.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of step.attlist -->
  <!-- end of step.module -->
  <xs:attributeGroup name="substeps.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for steps that occur within steps in a procedure. -->
  <xs:element name="substeps">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="substeps.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of substeps.element -->
  <!-- Performance: whether entire set of substeps must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="substeps.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="substeps.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of substeps.attlist -->
  <!-- end of substeps.module -->
  <xs:attributeGroup name="stepalternatives.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Alternative steps in a procedure. -->
  <xs:element name="stepalternatives">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="step"/>
      </xs:sequence>
      <xs:attributeGroup ref="stepalternatives.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of stepalternatives.element -->
  <!-- Performance: Whether (one of) the alternatives must be performed -->
  <!-- not #REQUIRED! -->
  <xs:attributeGroup name="stepalternatives.attlist">
    <xs:attribute name="performance" default="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="optional"/>
          <xs:enumeration value="required"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="stepalternatives.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of stepalternatives.attlist -->
  <!-- end of stepalternatives.module -->
  <!-- end of procedure.content.module -->
  <!-- Sidebar .......................... -->
  <xs:attributeGroup name="sidebarinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for a Sidebar. -->
  <xs:element name="sidebarinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="sidebarinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sidebarinfo.element -->
  <xs:attributeGroup name="sidebarinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sidebarinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sidebarinfo.attlist -->
  <!-- end of sidebarinfo.module -->
  <xs:attributeGroup name="sidebar.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A portion of a document that is isolated from the main narrative flow. -->
  <xs:element name="sidebar" substitutionGroup="compound.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="sidebarinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="sidebar.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="sidebar.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sidebar.element -->
  <xs:attributeGroup name="sidebar.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sidebar.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sidebar.attlist -->
  <!-- end of sidebar.module -->
  <!-- end of sidebar.content.model -->
  <!-- ...................................................................... -->
  <!-- Paragraph-related elements ........................................... -->
  <xs:attributeGroup name="abstract.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A summary. -->
  <xs:element name="abstract">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="abstract.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of abstract.element -->
  <xs:attributeGroup name="abstract.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="abstract.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of abstract.attlist -->
  <!-- end of abstract.module -->
  <xs:attributeGroup name="authorblurb.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A short description or note about an author. -->
  <xs:element name="authorblurb">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="authorblurb.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorblurb.element -->
  <xs:attributeGroup name="authorblurb.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorblurb.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorblurb.attlist -->
  <!-- end of authorblurb.module -->
  <xs:attributeGroup name="personblurb.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A short description or note about a person. -->
  <xs:element name="personblurb">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="personblurb.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of personblurb.element -->
  <xs:attributeGroup name="personblurb.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="personblurb.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of personblurb.attlist -->
  <!-- end of personblurb.module -->
  <xs:attributeGroup name="blockquote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A quotation set off from the main text. -->
  <xs:element name="blockquote" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="title"/>
        <xs:element minOccurs="0" ref="attribution"/>
        <xs:group maxOccurs="unbounded" ref="component.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="blockquote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of blockquote.element -->
  <xs:attributeGroup name="blockquote.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="blockquote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of blockquote.attlist -->
  <!-- end of blockquote.module -->
  <xs:attributeGroup name="attribution.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The source of a block quote or epigraph. -->
  <xs:element name="attribution">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="attribution.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of attribution.element -->
  <xs:attributeGroup name="attribution.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="attribution.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of attribution.attlist -->
  <!-- end of attribution.module -->
  <xs:attributeGroup name="bridgehead.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A free-floating heading. -->
  <xs:element name="bridgehead">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="bridgehead.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bridgehead.element -->
  <!--
    Renderas: Indicates the format in which the BridgeHead
    should appear
  -->
  <xs:attributeGroup name="bridgehead.attlist">
    <xs:attribute name="renderas">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="other"/>
          <xs:enumeration value="sect1"/>
          <xs:enumeration value="sect2"/>
          <xs:enumeration value="sect3"/>
          <xs:enumeration value="sect4"/>
          <xs:enumeration value="sect5"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bridgehead.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bridgehead.attlist -->
  <!-- end of bridgehead.module -->
  <xs:attributeGroup name="remark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A remark (or comment) intended for presentation in a draft manuscript. -->
  <xs:element name="remark">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="remark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of remark.element -->
  <xs:attributeGroup name="remark.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="remark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of remark.attlist -->
  <!-- end of remark.module -->
  <xs:attributeGroup name="epigraph.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A short inscription at the beginning of a document or component. -->
  <xs:element name="epigraph">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="attribution"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="para.class"/>
          <xs:element ref="literallayout"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="epigraph.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of epigraph.element -->
  <xs:attributeGroup name="epigraph.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="epigraph.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of epigraph.attlist -->
  <!-- Attribution (defined above) -->
  <!-- end of epigraph.module -->
  <xs:attributeGroup name="footnote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A footnote. -->
  <xs:element name="footnote" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="footnote.mix"/>
      <xs:attributeGroup ref="footnote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of footnote.element -->
  <xs:attributeGroup name="footnote.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="footnote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of footnote.attlist -->
  <!-- end of footnote.module -->
  <xs:attributeGroup name="highlights.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A summary of the main points of the discussed component. -->
  <xs:element name="highlights">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="highlights.mix"/>
      <xs:attributeGroup ref="highlights.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of highlights.element -->
  <xs:attributeGroup name="highlights.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="highlights.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of highlights.attlist -->
  <!-- end of highlights.module -->
  <xs:attributeGroup name="formalpara.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A paragraph with a title. -->
  <xs:element name="formalpara" substitutionGroup="para.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="title"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element ref="para"/>
      </xs:sequence>
      <xs:attributeGroup ref="formalpara.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of formalpara.element -->
  <xs:attributeGroup name="formalpara.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="formalpara.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of formalpara.attlist -->
  <!-- end of formalpara.module -->
  <xs:attributeGroup name="para.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A paragraph. -->
  <xs:element name="para" substitutionGroup="para.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:group ref="para.mix"/>
      </xs:choice>
      <xs:attributeGroup ref="para.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of para.element -->
  <xs:attributeGroup name="para.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="para.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of para.attlist -->
  <!-- end of para.module -->
  <xs:attributeGroup name="simpara.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A paragraph that contains only text and inline markup, no block elements. -->
  <xs:element name="simpara" substitutionGroup="para.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="simpara.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simpara.element -->
  <xs:attributeGroup name="simpara.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simpara.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simpara.attlist -->
  <!-- end of simpara.module -->
  <xs:attributeGroup name="admon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A note of caution. -->
  <xs:element name="caution" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="caution.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of caution.element -->
  <xs:attributeGroup name="caution.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of caution.attlist -->
  <!-- doc:An admonition set off from the text. -->
  <xs:element name="important" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="important.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of important.element -->
  <xs:attributeGroup name="important.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of important.attlist -->
  <!-- doc:A message set off from the text. -->
  <xs:element name="note" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="note.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of note.element -->
  <xs:attributeGroup name="note.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of note.attlist -->
  <!-- doc:A suggestion to the user, set off from the text. -->
  <xs:element name="tip" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="tip.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tip.element -->
  <xs:attributeGroup name="tip.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tip.attlist -->
  <!-- doc:An admonition set off from the text. -->
  <xs:element name="warning" substitutionGroup="admon.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="admon.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="warning.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of warning.element -->
  <xs:attributeGroup name="warning.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="admon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of warning.attlist -->
  <!-- end of admon.module -->
  <!-- ...................................................................... -->
  <!-- Lists ................................................................ -->
  <!-- GlossList ........................ -->
  <xs:attributeGroup name="glosslist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for a set of GlossEntrys. -->
  <xs:element name="glosslist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="glossentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="glosslist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glosslist.element -->
  <xs:attributeGroup name="glosslist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glosslist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glosslist.attlist -->
  <!-- end of glosslist.module -->
  <xs:attributeGroup name="glossentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An entry in a Glossary or GlossList. -->
  <xs:element name="glossentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="glossterm"/>
        <xs:element minOccurs="0" ref="acronym"/>
        <xs:element minOccurs="0" ref="abbrev"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" ref="revhistory"/>
        <xs:choice>
          <xs:element ref="glosssee"/>
          <xs:element maxOccurs="unbounded" ref="glossdef"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="glossentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossentry.element -->
  <!--
    SortAs: String by which the GlossEntry is to be sorted
    (alphabetized) in lieu of its proper content
  -->
  <xs:attributeGroup name="glossentry.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossentry.attlist -->
  <!-- end of glossentry.module -->
  <!-- GlossTerm (defined in the Inlines section, below) -->
  <xs:attributeGroup name="glossdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A definition in a GlossEntry. -->
  <xs:element name="glossdef">
    <xs:complexType>
      <xs:sequence>
        <xs:group maxOccurs="unbounded" ref="glossdef.mix"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="glossseealso"/>
      </xs:sequence>
      <xs:attributeGroup ref="glossdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossdef.element -->
  <!-- Subject: List of subjects; keywords for the definition -->
  <xs:attributeGroup name="glossdef.attlist">
    <xs:attribute name="subject"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossdef.attlist -->
  <!-- end of glossdef.module -->
  <xs:attributeGroup name="glosssee.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A cross-reference from one GlossEntry to another. -->
  <xs:element name="glosssee">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glosssee.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glosssee.element -->
  <!--
    OtherTerm: Reference to the GlossEntry whose GlossTerm
    should be displayed at the point of the GlossSee
  -->
  <xs:attributeGroup name="glosssee.attlist">
    <xs:attribute name="otherterm" type="xs:IDREF"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glosssee.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glosssee.attlist -->
  <!-- end of glosssee.module -->
  <xs:attributeGroup name="glossseealso.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A cross-reference from one GlossEntry to another. -->
  <xs:element name="glossseealso">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glossseealso.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossseealso.element -->
  <!--
    OtherTerm: Reference to the GlossEntry whose GlossTerm
    should be displayed at the point of the GlossSeeAlso
  -->
  <xs:attributeGroup name="glossseealso.attlist">
    <xs:attribute name="otherterm" type="xs:IDREF"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossseealso.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossseealso.attlist -->
  <!-- end of glossseealso.module -->
  <!-- end of glossentry.content.module -->
  <!-- ItemizedList and OrderedList ..... -->
  <xs:attributeGroup name="itemizedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A list in which each entry is marked with a bullet or other dingbat. -->
  <xs:element name="itemizedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="itemizedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of itemizedlist.element -->
  <!--
    Spacing: Whether the vertical space in the list should be
    compressed
  -->
  <!--
    Mark: Keyword, e.g., bullet, dash, checkbox, none;
    list of keywords and defaults are implementation specific
  -->
  <xs:attributeGroup name="itemizedlist.attlist">
    <xs:attribute name="spacing">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="normal"/>
          <xs:enumeration value="compact"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="mark.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="itemizedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of itemizedlist.attlist -->
  <!-- end of itemizedlist.module -->
  <xs:attributeGroup name="orderedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A list in which each entry is marked with a sequentially incremented label. -->
  <xs:element name="orderedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="orderedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orderedlist.element -->
  <!--
    Numeration: Style of ListItem numbered; default is expected
    to be Arabic
  -->
  <!--
    InheritNum: Specifies for a nested list that the numbering
    of ListItems should include the number of the item
    within which they are nested (e.g., 1a and 1b within 1,
    rather than a and b)
  -->
  <!--
    Continuation: Where list numbering begins afresh (Restarts,
    the default) or continues that of the immediately preceding
    list (Continues)
  -->
  <!--
    Spacing: Whether the vertical space in the list should be
    compressed
  -->
  <xs:attributeGroup name="orderedlist.attlist">
    <xs:attribute name="numeration">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="arabic"/>
          <xs:enumeration value="upperalpha"/>
          <xs:enumeration value="loweralpha"/>
          <xs:enumeration value="upperroman"/>
          <xs:enumeration value="lowerroman"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="inheritnum" default="ignore">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="inherit"/>
          <xs:enumeration value="ignore"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="continuation" default="restarts">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="continues"/>
          <xs:enumeration value="restarts"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="spacing">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="normal"/>
          <xs:enumeration value="compact"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="orderedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orderedlist.attlist -->
  <!-- end of orderedlist.module -->
  <xs:attributeGroup name="listitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for the elements of a list item. -->
  <xs:element name="listitem">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="listitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of listitem.element -->
  <!--
    Override: Indicates the mark to be used for this ListItem
    instead of the default mark or the mark specified by
    the Mark attribute on the enclosing ItemizedList
  -->
  <xs:attributeGroup name="listitem.attlist">
    <xs:attribute name="override"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="listitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of listitem.attlist -->
  <!-- end of listitem.module -->
  <!-- SegmentedList .................... -->
  <xs:attributeGroup name="segmentedlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A segmented list, a list of sets of elements. -->
  <xs:element name="segmentedlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="segtitle"/>
        <xs:element maxOccurs="unbounded" ref="seglistitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="segmentedlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of segmentedlist.element -->
  <xs:attributeGroup name="segmentedlist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="segmentedlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of segmentedlist.attlist -->
  <!-- end of segmentedlist.module -->
  <xs:attributeGroup name="segtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The title of an element of a list item in a segmented list. -->
  <xs:element name="segtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="title.char.mix"/>
      <xs:attributeGroup ref="segtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of segtitle.element -->
  <xs:attributeGroup name="segtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="segtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of segtitle.attlist -->
  <!-- end of segtitle.module -->
  <xs:attributeGroup name="seglistitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A list item in a segmented list. -->
  <xs:element name="seglistitem">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="seg"/>
      </xs:sequence>
      <xs:attributeGroup ref="seglistitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seglistitem.element -->
  <xs:attributeGroup name="seglistitem.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seglistitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seglistitem.attlist -->
  <!-- end of seglistitem.module -->
  <xs:attributeGroup name="seg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An element of a list item in a segmented list. -->
  <xs:element name="seg">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="seg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seg.element -->
  <xs:attributeGroup name="seg.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seg.attlist -->
  <!-- end of seg.module -->
  <!-- end of segmentedlist.content.module -->
  <!-- SimpleList ....................... -->
  <xs:attributeGroup name="simplelist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An undecorated list of single words or short phrases. -->
  <xs:element name="simplelist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="member"/>
      </xs:sequence>
      <xs:attributeGroup ref="simplelist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of simplelist.element -->
  <!-- Columns: The number of columns the array should contain -->
  <!--
    Type: How the Members of the SimpleList should be
    formatted: Inline (members separated with commas etc.
    inline), Vert (top to bottom in n Columns), or Horiz (in
    the direction of text flow) in n Columns.  If Column
    is 1 or implied, Type=Vert and Type=Horiz give the same
    results.
  -->
  <xs:attributeGroup name="simplelist.attlist">
    <xs:attribute name="columns"/>
    <xs:attribute name="type" default="vert">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="inline"/>
          <xs:enumeration value="vert"/>
          <xs:enumeration value="horiz"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="simplelist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of simplelist.attlist -->
  <!-- end of simplelist.module -->
  <xs:attributeGroup name="member.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An element of a simple list. -->
  <xs:element name="member">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="member.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of member.element -->
  <xs:attributeGroup name="member.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="member.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of member.attlist -->
  <!-- end of member.module -->
  <!-- end of simplelist.content.module -->
  <!-- VariableList ..................... -->
  <xs:attributeGroup name="variablelist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A list in which each entry is composed of a set of one or more terms and an associated description. -->
  <xs:element name="variablelist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:group minOccurs="0" maxOccurs="unbounded" ref="listpreamble.mix"/>
        <xs:element maxOccurs="unbounded" ref="varlistentry"/>
      </xs:sequence>
      <xs:attributeGroup ref="variablelist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of variablelist.element -->
  <!--
    TermLength: Length beyond which the presentation engine
    may consider the Term too long and select an alternate
    presentation of the Term and, or, its associated ListItem.
  -->
  <xs:attributeGroup name="variablelist.attlist">
    <xs:attribute name="termlength"/>
    <xs:attribute name="spacing">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="normal"/>
          <xs:enumeration value="compact"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="variablelist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of variablelist.attlist -->
  <!-- end of variablelist.module -->
  <xs:attributeGroup name="varlistentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for a set of terms and the associated description in a variable list. -->
  <xs:element name="varlistentry">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="term"/>
        <xs:element ref="listitem"/>
      </xs:sequence>
      <xs:attributeGroup ref="varlistentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varlistentry.element -->
  <xs:attributeGroup name="varlistentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varlistentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varlistentry.attlist -->
  <!-- end of varlistentry.module -->
  <xs:attributeGroup name="term.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The word or phrase being defined or described in a variable list. -->
  <xs:element name="term">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="term.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of term.element -->
  <xs:attributeGroup name="term.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="term.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of term.attlist -->
  <!-- end of term.module -->
  <!-- ListItem (defined above) -->
  <!-- end of variablelist.content.module -->
  <!-- CalloutList ...................... -->
  <xs:attributeGroup name="calloutlist.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A list of Callouts. -->
  <xs:element name="calloutlist" substitutionGroup="list.class">
    <xs:complexType>
      <xs:sequence>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:element maxOccurs="unbounded" ref="callout"/>
      </xs:sequence>
      <xs:attributeGroup ref="calloutlist.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of calloutlist.element -->
  <xs:attributeGroup name="calloutlist.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="calloutlist.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of calloutlist.attlist -->
  <!-- end of calloutlist.module -->
  <xs:attributeGroup name="callout.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A &ldquo;called out&rdquo; description of a marked Area. -->
  <xs:element name="callout">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="callout.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of callout.element -->
  <!--
    AreaRefs: IDs of one or more Areas or AreaSets described
    by this Callout
  -->
  <xs:attributeGroup name="callout.attlist">
    <xs:attribute name="arearefs" use="required" type="xs:IDREFS"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="callout.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of callout.attlist -->
  <!-- end of callout.module -->
  <!-- end of calloutlist.content.module -->
  <!-- ...................................................................... -->
  <!-- Objects .............................................................. -->
  <!-- Examples etc. .................... -->
  <xs:attributeGroup name="example.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A formal example, with a title. -->
  <xs:element name="example" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:group maxOccurs="unbounded" ref="example.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="example.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of example.element -->
  <xs:attributeGroup name="example.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="example.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of example.attlist -->
  <!-- end of example.module -->
  <xs:attributeGroup name="informalexample.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A displayed example without a title. -->
  <xs:element name="informalexample" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group maxOccurs="unbounded" ref="example.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="informalexample.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalexample.element -->
  <xs:attributeGroup name="informalexample.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalexample.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalexample.attlist -->
  <!-- end of informalexample.module -->
  <xs:attributeGroup name="programlistingco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A program listing with associated areas used in callouts. -->
  <xs:element name="programlistingco" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="programlisting"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="programlistingco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of programlistingco.element -->
  <xs:attributeGroup name="programlistingco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="programlistingco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of programlistingco.attlist -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of informalexample.module -->
  <xs:attributeGroup name="areaspec.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A collection of regions in a graphic or code example. -->
  <xs:element name="areaspec">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="area"/>
        <xs:element ref="areaset"/>
      </xs:choice>
      <xs:attributeGroup ref="areaspec.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of areaspec.element -->
  <!--
    Units: global unit of measure in which coordinates in
    this spec are expressed:
    
    - CALSPair "x1,y1 x2,y2": lower-left and upper-right
    coordinates in a rectangle describing repro area in which
    graphic is placed, where X and Y dimensions are each some
    number 0..10000 (taken from CALS graphic attributes)
    
    - LineColumn "line column": line number and column number
    at which to start callout text in "linespecific" content
    
    - LineRange "startline endline": whole lines from startline
    to endline in "linespecific" content
    
    - LineColumnPair "line1 col1 line2 col2": starting and ending
    points of area in "linespecific" content that starts at
    first position and ends at second position (including the
    beginnings of any intervening lines)
    
    - Other: directive to look at value of OtherUnits attribute
    to get implementation-specific keyword
    
    The default is implementation-specific; usually dependent on
    the parent element (GraphicCO gets CALSPair, ProgramListingCO
    and ScreenCO get LineColumn)
  -->
  <!-- OtherUnits: User-defined units -->
  <xs:attributeGroup name="areaspec.attlist">
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="areaspec.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of areaspec.attlist -->
  <!-- end of areaspec.module -->
  <xs:attributeGroup name="area.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A region defined for a Callout in a graphic or code example. -->
  <xs:element name="area">
    <xs:complexType>
      <xs:attributeGroup ref="area.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of area.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <!--
    Units: unit of measure in which coordinates in this
    area are expressed; inherits from AreaSet and AreaSpec
  -->
  <!-- OtherUnits: User-defined units -->
  <xs:attributeGroup name="area.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attribute name="coords" use="required"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="area.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of area.attlist -->
  <!-- end of area.module -->
  <xs:attributeGroup name="areaset.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A set of related areas in a graphic or code example. -->
  <xs:element name="areaset">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="area"/>
      </xs:sequence>
      <xs:attributeGroup ref="areaset.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of areaset.element -->
  <!-- bug number/symbol override or initialization -->
  <!--
    Units: unit of measure in which coordinates in this
    area are expressed; inherits from AreaSpec
  -->
  <xs:attributeGroup name="areaset.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attribute name="units">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="calspair"/>
          <xs:enumeration value="linecolumn"/>
          <xs:enumeration value="linerange"/>
          <xs:enumeration value="linecolumnpair"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherunits" type="xs:NMTOKEN"/>
    <xs:attribute name="coords" use="required"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="areaset.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of areaset.attlist -->
  <!-- end of areaset.module -->
  <!-- end of areaspec.content.module -->
  <xs:attributeGroup name="programlisting.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A literal listing of all or part of a program. -->
  <xs:element name="programlisting" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="lineannotation"/>
        <xs:element ref="textobject"/>
      </xs:choice>
      <xs:attributeGroup ref="programlisting.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of programlisting.element -->
  <xs:attributeGroup name="programlisting.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="programlisting.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of programlisting.attlist -->
  <!-- end of programlisting.module -->
  <xs:attributeGroup name="literallayout.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A block of text in which line breaks and white space are to be reproduced faithfully. -->
  <xs:element name="literallayout" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="literallayout.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of literallayout.element -->
  <xs:attributeGroup name="literallayout.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attribute name="class" default="normal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="monospaced"/>
          <xs:enumeration value="normal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="literallayout.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of literallayout.attlist -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- end of literallayout.module -->
  <xs:attributeGroup name="screenco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A screen with associated areas used in callouts. -->
  <xs:element name="screenco" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="screen"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="screenco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screenco.element -->
  <xs:attributeGroup name="screenco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screenco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screenco.attlist -->
  <!-- AreaSpec (defined above) -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of screenco.module -->
  <xs:attributeGroup name="screen.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Text that a user sees or might see on a computer screen. -->
  <xs:element name="screen" substitutionGroup="linespecific.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="screen.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screen.element -->
  <xs:attributeGroup name="screen.attlist">
    <xs:attributeGroup ref="width.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screen.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screen.attlist -->
  <!-- end of screen.module -->
  <xs:attributeGroup name="screenshot.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A representation of what the user sees or might see on a computer screen. -->
  <xs:element name="screenshot" substitutionGroup="linespecific.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="screeninfo"/>
        <xs:choice>
          <xs:element ref="graphic"/>
          <xs:element ref="graphicco"/>
          <xs:element ref="mediaobject"/>
          <xs:element ref="mediaobjectco"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="screenshot.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screenshot.element -->
  <xs:attributeGroup name="screenshot.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screenshot.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screenshot.attlist -->
  <!-- end of screenshot.module -->
  <xs:attributeGroup name="screeninfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Information about how a screen shot was produced. -->
  <xs:element name="screeninfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="screeninfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of screeninfo.element -->
  <xs:attributeGroup name="screeninfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="screeninfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of screeninfo.attlist -->
  <!-- end of screeninfo.module -->
  <!-- end of screenshot.content.module -->
  <!-- Figures etc. ..................... -->
  <xs:attributeGroup name="figure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A formal figure, generally an illustration, with a title. -->
  <xs:element name="figure" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:choice maxOccurs="unbounded">
          <xs:group ref="figure.mix"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="figure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of figure.element -->
  <!--
    Float: Whether the Figure is supposed to be rendered
    where convenient (yes (1) value) or at the place it occurs
    in the text (no (0) value, the default)
  -->
  <xs:attributeGroup name="figure.attlist">
    <xs:attribute name="float" default="0" type="yesorno.attvals"/>
    <xs:attribute name="floatstyle"/>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="figure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of figure.attlist -->
  <!-- end of figure.module -->
  <xs:attributeGroup name="informalfigure.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A untitled figure. -->
  <xs:element name="informalfigure" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:choice maxOccurs="unbounded">
          <xs:group ref="figure.mix"/>
          <xs:element ref="link.char.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="informalfigure.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalfigure.element -->
  <!--
    Float: Whether the Figure is supposed to be rendered
    where convenient (yes (1) value) or at the place it occurs
    in the text (no (0) value, the default)
  -->
  <xs:attributeGroup name="informalfigure.attlist">
    <xs:attribute name="float" default="0" type="yesorno.attvals"/>
    <xs:attribute name="floatstyle"/>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalfigure.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalfigure.attlist -->
  <!-- end of informalfigure.module -->
  <xs:attributeGroup name="graphicco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A graphic that contains callout areas. -->
  <xs:element name="graphicco" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="graphic"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="graphicco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of graphicco.element -->
  <xs:attributeGroup name="graphicco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="graphicco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of graphicco.attlist -->
  <!-- AreaSpec (defined above in Examples) -->
  <!-- CalloutList (defined above in Lists) -->
  <!-- end of graphicco.module -->
  <!--
    Graphical data can be the content of Graphic, or you can reference
    an external file either as an entity (Entitref) or a filename
    (Fileref).
  -->
  <xs:attributeGroup name="graphic.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A displayed graphical object (not an inline). -->
  <xs:element name="graphic" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:attributeGroup ref="graphic.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of graphic.element -->
  <xs:attributeGroup name="graphic.attlist">
    <xs:attributeGroup ref="graphics.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="graphic.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of graphic.attlist -->
  <!-- end of graphic.module -->
  <xs:attributeGroup name="inlinegraphic.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An object containing or pointing to graphical data that will be rendered inline. -->
  <xs:element name="inlinegraphic" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="inlinegraphic.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of inlinegraphic.element -->
  <xs:attributeGroup name="inlinegraphic.attlist">
    <xs:attributeGroup ref="graphics.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlinegraphic.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlinegraphic.attlist -->
  <!-- end of inlinegraphic.module -->
  <xs:attributeGroup name="mediaobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A displayed media object (video, audio, image, etc.). -->
  <xs:element name="mediaobject" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject.mix"/>
        <xs:element minOccurs="0" ref="caption"/>
      </xs:sequence>
      <xs:attributeGroup ref="mediaobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mediaobject.element -->
  <xs:attributeGroup name="mediaobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mediaobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mediaobject.attlist -->
  <!-- end of mediaobject.module -->
  <xs:attributeGroup name="inlinemediaobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An inline media object (video, audio, image, and so on). -->
  <xs:element name="inlinemediaobject" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="inlinemediaobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of inlinemediaobject.element -->
  <xs:attributeGroup name="inlinemediaobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlinemediaobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlinemediaobject.attlist -->
  <!-- end of inlinemediaobject.module -->
  <xs:attributeGroup name="videoobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for video data and its associated meta-information. -->
  <xs:element name="videoobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="videodata"/>
      </xs:sequence>
      <xs:attributeGroup ref="videoobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of videoobject.element -->
  <xs:attributeGroup name="videoobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="videoobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of videoobject.attlist -->
  <!-- end of videoobject.module -->
  <xs:attributeGroup name="audioobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for audio data and its associated meta-information. -->
  <xs:element name="audioobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="audiodata"/>
      </xs:sequence>
      <xs:attributeGroup ref="audioobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of audioobject.element -->
  <xs:attributeGroup name="audioobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="audioobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of audioobject.attlist -->
  <!-- end of audioobject.module -->
  <xs:attributeGroup name="imageobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for image data and its associated meta-information. -->
  <xs:element name="imageobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="imagedata"/>
      </xs:sequence>
      <xs:attributeGroup ref="imageobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imageobject.element -->
  <xs:attributeGroup name="imageobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imageobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imageobject.attlist -->
  <!-- end of imageobject.module -->
  <xs:attributeGroup name="textobject.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for a text description of an object and its associated meta-information. -->
  <xs:element name="textobject" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:choice>
          <xs:element ref="phrase"/>
          <xs:element ref="textdata"/>
          <xs:group maxOccurs="unbounded" ref="textobject.mix"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="textobject.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of textobject.element -->
  <xs:attributeGroup name="textobject.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="textobject.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of textobject.attlist -->
  <!-- end of textobject.module -->
  <xs:attributeGroup name="objectinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Meta-information for an object. -->
  <xs:element name="objectinfo">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="info.class"/>
      <xs:attributeGroup ref="objectinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of objectinfo.element -->
  <xs:attributeGroup name="objectinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="objectinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of objectinfo.attlist -->
  <!-- end of objectinfo.module -->
  <!--
    EntityRef: Name of an external entity containing the content
    of the object data
  -->
  <!--
    FileRef: Filename, qualified by a pathname if desired,
    designating the file containing the content of the object data
  -->
  <!-- Format: Notation of the element content, if any -->
  <!-- SrcCredit: Information about the source of the image -->
  <xs:attributeGroup name="objectdata.attrib">
    <xs:attribute name="entityref" type="xs:ENTITY"/>
    <xs:attribute name="fileref"/>
    <xs:attribute name="format" type="notation.class"/>
    <xs:attribute name="srccredit"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="videodata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Pointer to external video data. -->
  <xs:element name="videodata">
    <xs:complexType>
      <xs:attributeGroup ref="videodata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of videodata.element -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="videodata.attlist">
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="videodata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of videodata.attlist -->
  <!-- end of videodata.module -->
  <xs:attributeGroup name="audiodata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Pointer to external audio data. -->
  <xs:element name="audiodata">
    <xs:complexType>
      <xs:attributeGroup ref="audiodata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of audiodata.element -->
  <xs:attributeGroup name="audiodata.attlist">
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="audiodata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of audiodata.attlist -->
  <!-- end of audiodata.module -->
  <xs:attributeGroup name="imagedata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Pointer to external image data. -->
  <xs:element name="imagedata">
    <xs:complexType>
      <xs:attributeGroup ref="imagedata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imagedata.element -->
  <!-- Width: Same as CALS reprowid (desired width) -->
  <!-- Depth: Same as CALS reprodep (desired depth) -->
  <!--
    Align: Same as CALS hplace with 'none' removed; #IMPLIED means
    application-specific
  -->
  <!-- Scale: Conflation of CALS hscale and vscale -->
  <!-- Scalefit: Same as CALS scalefit -->
  <xs:attributeGroup name="imagedata.attlist">
    <xs:attribute name="width"/>
    <xs:attribute name="contentwidth"/>
    <xs:attribute name="depth"/>
    <xs:attribute name="contentdepth"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="center"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="scale"/>
    <xs:attribute name="scalefit" type="yesorno.attvals"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imagedata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imagedata.attlist -->
  <!-- end of imagedata.module -->
  <xs:attributeGroup name="textdata.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Pointer to external text data. -->
  <xs:element name="textdata">
    <xs:complexType>
      <xs:attributeGroup ref="textdata.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of textdata.element -->
  <xs:attributeGroup name="textdata.attlist">
    <xs:attribute name="encoding"/>
    <xs:attributeGroup ref="objectdata.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="textdata.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of textdata.attlist -->
  <!-- end of textdata.module -->
  <xs:attributeGroup name="mediaobjectco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A media object that contains callouts. -->
  <xs:element name="mediaobjectco" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="objectinfo"/>
        <xs:element ref="imageobjectco"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="imageobjectco"/>
          <xs:element ref="textobject"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="mediaobjectco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mediaobjectco.element -->
  <xs:attributeGroup name="mediaobjectco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mediaobjectco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mediaobjectco.attlist -->
  <!-- end of mediaobjectco.module -->
  <xs:attributeGroup name="imageobjectco.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for an image object with callouts. -->
  <xs:element name="imageobjectco" substitutionGroup="mediaobject.mix">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="areaspec"/>
        <xs:element ref="imageobject"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="calloutlist"/>
      </xs:sequence>
      <xs:attributeGroup ref="imageobjectco.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of imageobjectco.element -->
  <xs:attributeGroup name="imageobjectco.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="imageobjectco.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of imageobjectco.attlist -->
  <!-- end of imageobjectco.module -->
  <!-- end of mediaobject.content.module -->
  <!-- Equations ........................ -->
  <!-- This PE provides a mechanism for replacing equation content, -->
  <!-- perhaps adding a new or different model (e.g., MathML) -->
  <xs:group name="equation.content">
    <xs:sequence>
      <xs:element minOccurs="0" ref="alt"/>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="graphic"/>
        <xs:element maxOccurs="unbounded" ref="mediaobject"/>
        <xs:element maxOccurs="unbounded" ref="mathphrase"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:complexType name="inlineequation.content">
    <xs:sequence>
      <xs:element minOccurs="0" ref="alt"/>
      <xs:choice>
        <xs:element maxOccurs="unbounded" ref="graphic"/>
        <xs:element maxOccurs="unbounded" ref="inlinemediaobject"/>
        <xs:element maxOccurs="unbounded" ref="mathphrase"/>
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
  <xs:attributeGroup name="equation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A displayed mathematical equation. -->
  <xs:element name="equation" substitutionGroup="formal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group minOccurs="0" ref="formalobject.title.content"/>
        <xs:choice>
          <xs:element ref="informalequation"/>
          <xs:group ref="equation.content"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="equation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of equation.element -->
  <xs:attributeGroup name="equation.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="equation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of equation.attlist -->
  <!-- end of equation.module -->
  <xs:attributeGroup name="informalequation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A displayed mathematical equation without a title. -->
  <xs:element name="informalequation" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="equation.content"/>
      </xs:sequence>
      <xs:attributeGroup ref="informalequation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informalequation.element -->
  <xs:attributeGroup name="informalequation.attlist">
    <xs:attribute name="floatstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="informalequation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of informalequation.attlist -->
  <!-- end of informalequation.module -->
  <xs:attributeGroup name="inlineequation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A mathematical equation or expression occurring inline. -->
  <xs:element name="inlineequation" substitutionGroup="inlineobj.char.class">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="inlineequation.content">
          <xs:attributeGroup ref="inlineequation.attlist"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <!-- end of inlineequation.element -->
  <xs:attributeGroup name="inlineequation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="inlineequation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of inlineequation.attlist -->
  <!-- end of inlineequation.module -->
  <xs:attributeGroup name="alt.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Text representation for a graphical element. -->
  <xs:element name="alt">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="alt.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of alt.element -->
  <xs:attributeGroup name="alt.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="alt.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of alt.attlist -->
  <!-- end of alt.module -->
  <xs:attributeGroup name="mathphrase.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A mathematical phrase, an expression that can be represented with ordinary text and a small amount of markup. -->
  <xs:element name="mathphrase">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="subscript"/>
        <xs:element ref="superscript"/>
        <xs:element ref="emphasis"/>
      </xs:choice>
      <xs:attributeGroup ref="mathphrase.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mathphrase.element -->
  <xs:attributeGroup name="mathphrase.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mathphrase.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mathphrase.attlist -->
  <!-- end of mathphrase.module -->
  <!-- Tables ........................... -->
  <!-- Choose a table model. CALS or OASIS XML Exchange -->
  <!-- Do we allow the HTML table model as well? -->
  <!-- ====================================================== -->
  <!--
    xhtmltbl.mod defines HTML tables and sets parameter
    entities so that, when the CALS table module is read,
    we end up allowing any table to be CALS or HTML.
    i.e. This include must come first!
  -->
  <!-- ====================================================== -->
  <!-- end of allow.html.tables -->
  <!-- Add label and role attributes to table and informaltable -->
  <!--
    Add common attributes to Table, TGroup, TBody, THead, TFoot, Row,
    EntryTbl, and Entry (and InformalTable element).
  -->
  <!-- Content model for Table. -->
  <!-- Allow either objects or inlines; beware of REs between elements. -->
  <!-- Reference CALS Table Model -->
  <!-- end of table.module -->
  <!--
    Note that InformalTable is dependent on some of the entity
    declarations that customize Table.
  -->
  <!-- the following entity may have been declared by the XHTML table module -->
  <!-- doc:A table without a title. -->
  <xs:element name="informaltable" substitutionGroup="informal.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="informal.tbl.table.mdl"/>
      </xs:sequence>
      <xs:attributeGroup ref="informaltable.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of informaltable.element -->
  <!--
    Frame, Colsep, and Rowsep must be repeated because
    they are not in entities in the table module.
  -->
  <!--
    includes TabStyle, ToCentry, ShortEntry,
    Orient, PgWide
  -->
  <!-- includes Label -->
  <!-- includes common attributes -->
  <xs:attributeGroup name="informaltable.attlist">
    <xs:attribute name="frame" type="tbl.frame.attval"/>
    <xs:attribute name="colsep" type="yesorno.attvals"/>
    <xs:attribute name="rowsep" type="yesorno.attvals"/>
    <xs:attributeGroup ref="common.table.attribs"/>
    <xs:attributeGroup ref="tbl.table.att"/>
  </xs:attributeGroup>
  <!-- end of informaltable.attlist -->
  <!-- end of informaltable.module -->
  <xs:attributeGroup name="caption.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A caption. -->
  <xs:element name="caption">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="textobject.mix"/>
      <xs:attributeGroup ref="caption.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of caption.element -->
  <!-- attrs comes from HTML tables ... -->
  <!-- common.attrib, but without ID because ID is in attrs -->
  <xs:attributeGroup name="caption.attlist.content">
    <xs:attributeGroup ref="caption.role.attrib"/>
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="bottom"/>
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <xs:attributeGroup name="caption.attlist">
    <xs:attributeGroup ref="caption.attlist.content"/>
  </xs:attributeGroup>
  <!-- end of caption.attlist -->
  <!-- end of caption.module -->
  <!-- ...................................................................... -->
  <!-- Synopses ............................................................. -->
  <!-- Synopsis ......................... -->
  <xs:attributeGroup name="synopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A general-purpose element for representing the syntax of commands or functions. -->
  <xs:element name="synopsis" substitutionGroup="synop.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:element ref="graphic"/>
        <xs:element ref="mediaobject"/>
        <xs:element ref="co"/>
        <xs:element ref="coref"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="synopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopsis.element -->
  <xs:attributeGroup name="synopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="synopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopsis.attlist -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- end of synopsis.module -->
  <!-- CmdSynopsis ...................... -->
  <xs:attributeGroup name="cmdsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A syntax summary for a software command. -->
  <xs:element name="cmdsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="command"/>
          <xs:element ref="arg"/>
          <xs:element ref="group"/>
          <xs:element ref="sbr"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="synopfragment"/>
      </xs:sequence>
      <xs:attributeGroup ref="cmdsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of cmdsynopsis.element -->
  <!--
    Sepchar: Character that should separate command and all
    top-level arguments; alternate value might be e.g., &Delta;
  -->
  <xs:attributeGroup name="cmdsynopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attribute name="sepchar" default=" "/>
    <xs:attribute name="cmdlength"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="cmdsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of cmdsynopsis.attlist -->
  <!-- end of cmdsynopsis.module -->
  <xs:attributeGroup name="arg.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An argument in a CmdSynopsis. -->
  <xs:element name="arg">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
        <xs:element ref="option"/>
        <xs:element ref="synopfragmentref"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="sbr"/>
      </xs:choice>
      <xs:attributeGroup ref="arg.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of arg.element -->
  <!--
    Choice: Whether Arg must be supplied: Opt (optional to
    supply, e.g. [arg]; the default), Req (required to supply,
    e.g. {arg}), or Plain (required to supply, e.g. arg)
  -->
  <!--
    Rep: whether Arg is repeatable: Norepeat (e.g. arg without
    ellipsis; the default), or Repeat (e.g. arg...)
  -->
  <xs:attributeGroup name="arg.attlist">
    <xs:attribute name="choice" default="opt">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="arg.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of arg.attlist -->
  <!-- end of arg.module -->
  <xs:attributeGroup name="group.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A group of elements in a CmdSynopsis. -->
  <xs:element name="group">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
        <xs:element ref="option"/>
        <xs:element ref="synopfragmentref"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="sbr"/>
      </xs:choice>
      <xs:attributeGroup ref="group.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of group.element -->
  <!--
    Choice: Whether Group must be supplied: Opt (optional to
    supply, e.g.  [g1|g2|g3]; the default), Req (required to
    supply, e.g.  {g1|g2|g3}), Plain (required to supply,
    e.g.  g1|g2|g3), OptMult (can supply zero or more, e.g.
    [[g1|g2|g3]]), or ReqMult (must supply one or more, e.g.
    {{g1|g2|g3}})
  -->
  <!--
    Rep: whether Group is repeatable: Norepeat (e.g. group
    without ellipsis; the default), or Repeat (e.g. group...)
  -->
  <xs:attributeGroup name="group.attlist">
    <xs:attribute name="choice" default="opt">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="group.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of group.attlist -->
  <!-- end of group.module -->
  <!-- Synopsis break -->
  <xs:attributeGroup name="sbr.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An explicit line break in a command synopsis. -->
  <xs:element name="sbr">
    <xs:complexType>
      <xs:attributeGroup ref="sbr.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sbr.element -->
  <xs:attributeGroup name="sbr.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sbr.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sbr.attlist -->
  <!-- end of sbr.module -->
  <xs:attributeGroup name="synopfragmentref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A reference to a fragment of a command synopsis. -->
  <xs:element name="synopfragmentref">
    <xs:complexType mixed="true">
      <xs:attributeGroup ref="synopfragmentref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopfragmentref.element -->
  <!--
    to SynopFragment of complex synopsis
    material for separate referencing
  -->
  <xs:attributeGroup name="synopfragmentref.attlist">
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="synopfragmentref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopfragmentref.attlist -->
  <!-- end of synopfragmentref.module -->
  <xs:attributeGroup name="synopfragment.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A portion of a CmdSynopsis broken out from the main body of the synopsis. -->
  <xs:element name="synopfragment">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="arg"/>
        <xs:element ref="group"/>
      </xs:choice>
      <xs:attributeGroup ref="synopfragment.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of synopfragment.element -->
  <xs:attributeGroup name="synopfragment.attlist">
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="synopfragment.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of synopfragment.attlist -->
  <!-- end of synopfragment.module -->
  <!-- Command (defined in the Inlines section, below) -->
  <!-- Option (defined in the Inlines section, below) -->
  <!-- Replaceable (defined in the Inlines section, below) -->
  <!-- end of cmdsynopsis.content.module -->
  <!-- FuncSynopsis ..................... -->
  <xs:attributeGroup name="funcsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The syntax summary for a function definition. -->
  <xs:element name="funcsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="funcsynopsisinfo"/>
        <xs:element ref="funcprototype"/>
      </xs:choice>
      <xs:attributeGroup ref="funcsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcsynopsis.element -->
  <xs:attributeGroup name="funcsynopsis.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcsynopsis.attlist -->
  <!-- end of funcsynopsis.module -->
  <xs:attributeGroup name="funcsynopsisinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Information supplementing the FuncDefs of a FuncSynopsis. -->
  <xs:element name="funcsynopsisinfo">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="funcsynopsisinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcsynopsisinfo.element -->
  <xs:attributeGroup name="funcsynopsisinfo.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcsynopsisinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcsynopsisinfo.attlist -->
  <!-- end of funcsynopsisinfo.module -->
  <xs:attributeGroup name="funcprototype.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The prototype of a function. -->
  <xs:element name="funcprototype">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element ref="funcdef"/>
        <xs:choice>
          <xs:element ref="void"/>
          <xs:element ref="varargs"/>
          <xs:sequence>
            <xs:element maxOccurs="unbounded" ref="paramdef"/>
            <xs:element minOccurs="0" ref="varargs"/>
          </xs:sequence>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="funcprototype.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcprototype.element -->
  <xs:attributeGroup name="funcprototype.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcprototype.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcprototype.attlist -->
  <!-- end of funcprototype.module -->
  <xs:attributeGroup name="funcdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A function (subroutine) name and its return type. -->
  <xs:element name="funcdef">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="type"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="function"/>
      </xs:choice>
      <xs:attributeGroup ref="funcdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcdef.element -->
  <xs:attributeGroup name="funcdef.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcdef.attlist -->
  <!-- end of funcdef.module -->
  <xs:attributeGroup name="void.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An empty element in a function synopsis indicating that the function in question takes no arguments. -->
  <xs:element name="void">
    <xs:complexType>
      <xs:attributeGroup ref="void.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of void.element -->
  <xs:attributeGroup name="void.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="void.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of void.attlist -->
  <!-- end of void.module -->
  <xs:attributeGroup name="varargs.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An empty element in a function synopsis indicating a variable number of arguments. -->
  <xs:element name="varargs">
    <xs:complexType>
      <xs:attributeGroup ref="varargs.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varargs.element -->
  <xs:attributeGroup name="varargs.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varargs.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varargs.attlist -->
  <!-- end of varargs.module -->
  <!--
    Processing assumes that only one Parameter will appear in a
    ParamDef, and that FuncParams will be used at most once, for
    providing information on the "inner parameters" for parameters that
    are pointers to functions.
  -->
  <xs:attributeGroup name="paramdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Information about a function parameter in a programming language. -->
  <xs:element name="paramdef">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="initializer"/>
        <xs:element ref="type"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="parameter"/>
        <xs:element ref="funcparams"/>
      </xs:choice>
      <xs:attributeGroup ref="paramdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of paramdef.element -->
  <xs:attributeGroup name="paramdef.attlist">
    <xs:attribute name="choice">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="paramdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of paramdef.attlist -->
  <!-- end of paramdef.module -->
  <xs:attributeGroup name="funcparams.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Parameters for a function referenced through a function pointer in a synopsis. -->
  <xs:element name="funcparams">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="funcparams.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of funcparams.element -->
  <xs:attributeGroup name="funcparams.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="funcparams.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of funcparams.attlist -->
  <!-- end of funcparams.module -->
  <!-- LineAnnotation (defined in the Inlines section, below) -->
  <!-- Replaceable (defined in the Inlines section, below) -->
  <!-- Function (defined in the Inlines section, below) -->
  <!-- Parameter (defined in the Inlines section, below) -->
  <!-- end of funcsynopsis.content.module -->
  <!-- ClassSynopsis ..................... -->
  <xs:attributeGroup name="classsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The syntax summary for a class definition. -->
  <xs:element name="classsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="ooclass"/>
          <xs:element ref="oointerface"/>
          <xs:element ref="ooexception"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="classsynopsisinfo"/>
          <xs:element ref="fieldsynopsis"/>
          <xs:element ref="method.synop.class"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="classsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classsynopsis.element -->
  <xs:attributeGroup name="classsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attribute name="class" default="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="class"/>
          <xs:enumeration value="interface"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classsynopsis.attlist -->
  <!-- end of classsynopsis.module -->
  <xs:attributeGroup name="classsynopsisinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Information supplementing the contents of a ClassSynopsis. -->
  <xs:element name="classsynopsisinfo">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="textobject"/>
        <xs:element ref="lineannotation"/>
      </xs:choice>
      <xs:attributeGroup ref="classsynopsisinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classsynopsisinfo.element -->
  <xs:attributeGroup name="classsynopsisinfo.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classsynopsisinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classsynopsisinfo.attlist -->
  <!-- end of classsynopsisinfo.module -->
  <xs:attributeGroup name="ooclass.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A class in an object-oriented programming language. -->
  <xs:element name="ooclass" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="modifier"/>
          <xs:element ref="package"/>
        </xs:choice>
        <xs:element ref="classname"/>
      </xs:sequence>
      <xs:attributeGroup ref="ooclass.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ooclass.element -->
  <xs:attributeGroup name="ooclass.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ooclass.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ooclass.attlist -->
  <!-- end of ooclass.module -->
  <xs:attributeGroup name="oointerface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An interface in an object-oriented programming language. -->
  <xs:element name="oointerface" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="modifier"/>
          <xs:element ref="package"/>
        </xs:choice>
        <xs:element ref="interfacename"/>
      </xs:sequence>
      <xs:attributeGroup ref="oointerface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of oointerface.element -->
  <xs:attributeGroup name="oointerface.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="oointerface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of oointerface.attlist -->
  <!-- end of oointerface.module -->
  <xs:attributeGroup name="ooexception.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An exception in an object-oriented programming language. -->
  <xs:element name="ooexception" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="modifier"/>
          <xs:element ref="package"/>
        </xs:choice>
        <xs:element ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="ooexception.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ooexception.element -->
  <xs:attributeGroup name="ooexception.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ooexception.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ooexception.attlist -->
  <!-- end of ooexception.module -->
  <xs:attributeGroup name="modifier.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Modifiers in a synopsis. -->
  <xs:element name="modifier">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="modifier.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of modifier.element -->
  <xs:attributeGroup name="modifier.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="modifier.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of modifier.attlist -->
  <!-- end of modifier.module -->
  <xs:attributeGroup name="interfacename.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of an interface. -->
  <xs:element name="interfacename" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="interfacename.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of interfacename.element -->
  <xs:attributeGroup name="interfacename.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="interfacename.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of interfacename.attlist -->
  <!-- end of interfacename.module -->
  <xs:attributeGroup name="exceptionname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of an exception. -->
  <xs:element name="exceptionname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="exceptionname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of exceptionname.element -->
  <xs:attributeGroup name="exceptionname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="exceptionname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of exceptionname.attlist -->
  <!-- end of exceptionname.module -->
  <xs:attributeGroup name="fieldsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a field in a class definition. -->
  <xs:element name="fieldsynopsis" substitutionGroup="synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="type"/>
        <xs:element ref="varname"/>
        <xs:element minOccurs="0" ref="initializer"/>
      </xs:sequence>
      <xs:attributeGroup ref="fieldsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of fieldsynopsis.element -->
  <xs:attributeGroup name="fieldsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="fieldsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of fieldsynopsis.attlist -->
  <!-- end of fieldsynopsis.module -->
  <xs:attributeGroup name="initializer.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The initializer for a FieldSynopsis. -->
  <xs:element name="initializer">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="initializer.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of initializer.element -->
  <xs:attributeGroup name="initializer.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="initializer.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of initializer.attlist -->
  <!-- end of initializer.module -->
  <xs:attributeGroup name="constructorsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A syntax summary for a constructor. -->
  <xs:element name="constructorsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element minOccurs="0" ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="constructorsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of constructorsynopsis.element -->
  <xs:attributeGroup name="constructorsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="constructorsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of constructorsynopsis.attlist -->
  <!-- end of constructorsynopsis.module -->
  <xs:attributeGroup name="destructorsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A syntax summary for a destructor. -->
  <xs:element name="destructorsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element minOccurs="0" ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
      </xs:sequence>
      <xs:attributeGroup ref="destructorsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of destructorsynopsis.element -->
  <xs:attributeGroup name="destructorsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="destructorsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of destructorsynopsis.attlist -->
  <!-- end of destructorsynopsis.module -->
  <xs:attributeGroup name="methodsynopsis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A syntax summary for a method. -->
  <xs:element name="methodsynopsis" substitutionGroup="method.synop.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:choice minOccurs="0">
          <xs:element ref="type"/>
          <xs:element ref="void"/>
        </xs:choice>
        <xs:element ref="methodname"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="methodparam"/>
          <xs:element minOccurs="0" ref="void"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="exceptionname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="methodsynopsis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodsynopsis.element -->
  <xs:attributeGroup name="methodsynopsis.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodsynopsis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodsynopsis.attlist -->
  <!-- end of methodsynopsis.module -->
  <xs:attributeGroup name="methodname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a method. -->
  <xs:element name="methodname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="methodname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodname.element -->
  <xs:attributeGroup name="methodname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodname.attlist -->
  <!-- end of methodname.module -->
  <xs:attributeGroup name="methodparam.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Parameters to a method. -->
  <xs:element name="methodparam">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
        <xs:element minOccurs="0" ref="type"/>
        <xs:choice>
          <xs:sequence>
            <xs:element ref="parameter"/>
            <xs:element minOccurs="0" ref="initializer"/>
          </xs:sequence>
          <xs:element ref="funcparams"/>
        </xs:choice>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="modifier"/>
      </xs:sequence>
      <xs:attributeGroup ref="methodparam.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of methodparam.element -->
  <xs:attributeGroup name="methodparam.attlist">
    <xs:attribute name="choice" default="req">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="opt"/>
          <xs:enumeration value="req"/>
          <xs:enumeration value="plain"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rep" default="norepeat">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="norepeat"/>
          <xs:enumeration value="repeat"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="methodparam.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of methodparam.attlist -->
  <!-- end of methodparam.module -->
  <!-- end of classsynopsis.content.module -->
  <!-- ...................................................................... -->
  <!-- Document information entities and elements ........................... -->
  <!--
    The document information elements include some elements that are
    currently used only in the document hierarchy module. They are
    defined here so that they will be available for use in customized
    document hierarchies.
  -->
  <!-- .................................. -->
  <!-- Ackno ............................ -->
  <xs:attributeGroup name="ackno.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Acknowledgements in an Article. -->
  <xs:element name="ackno">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="ackno.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ackno.element -->
  <xs:attributeGroup name="ackno.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ackno.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ackno.attlist -->
  <!-- end of ackno.module -->
  <!-- Address .......................... -->
  <xs:attributeGroup name="address.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A real-world address, generally a postal address. -->
  <xs:element name="address" substitutionGroup="informal.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="personname"/>
        <xs:group ref="person.ident.mix"/>
        <xs:element ref="street"/>
        <xs:element ref="pob"/>
        <xs:element ref="postcode"/>
        <xs:element ref="city"/>
        <xs:element ref="state"/>
        <xs:element ref="country"/>
        <xs:element ref="phone"/>
        <xs:element ref="fax"/>
        <xs:element ref="email"/>
        <xs:element ref="otheraddr"/>
      </xs:choice>
      <xs:attributeGroup ref="address.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of address.element -->
  <xs:attributeGroup name="address.attlist">
    <xs:attributeGroup ref="linespecific.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="address.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of address.attlist -->
  <!-- end of address.module -->
  <xs:attributeGroup name="street.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A street address in an address. -->
  <xs:element name="street">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="street.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of street.element -->
  <xs:attributeGroup name="street.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="street.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of street.attlist -->
  <!-- end of street.module -->
  <xs:attributeGroup name="pob.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A post office box in an address. -->
  <xs:element name="pob">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pob.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pob.element -->
  <xs:attributeGroup name="pob.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pob.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pob.attlist -->
  <!-- end of pob.module -->
  <xs:attributeGroup name="postcode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A postal code in an address. -->
  <xs:element name="postcode">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="postcode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of postcode.element -->
  <xs:attributeGroup name="postcode.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="postcode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of postcode.attlist -->
  <!-- end of postcode.module -->
  <xs:attributeGroup name="city.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a city in an address. -->
  <xs:element name="city">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="city.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of city.element -->
  <xs:attributeGroup name="city.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="city.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of city.attlist -->
  <!-- end of city.module -->
  <xs:attributeGroup name="state.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A state or province in an address. -->
  <xs:element name="state">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="state.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of state.element -->
  <xs:attributeGroup name="state.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="state.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of state.attlist -->
  <!-- end of state.module -->
  <xs:attributeGroup name="country.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a country. -->
  <xs:element name="country">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="country.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of country.element -->
  <xs:attributeGroup name="country.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="country.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of country.attlist -->
  <!-- end of country.module -->
  <xs:attributeGroup name="phone.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A telephone number. -->
  <xs:element name="phone">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="phone.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of phone.element -->
  <xs:attributeGroup name="phone.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="phone.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of phone.attlist -->
  <!-- end of phone.module -->
  <xs:attributeGroup name="fax.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A fax number. -->
  <xs:element name="fax">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="fax.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of fax.element -->
  <xs:attributeGroup name="fax.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="fax.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of fax.attlist -->
  <!-- end of fax.module -->
  <!-- Email (defined in the Inlines section, below) -->
  <xs:attributeGroup name="otheraddr.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Uncategorized information in address. -->
  <xs:element name="otheraddr">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="otheraddr.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of otheraddr.element -->
  <xs:attributeGroup name="otheraddr.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="otheraddr.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of otheraddr.attlist -->
  <!-- end of otheraddr.module -->
  <!-- end of address.content.module -->
  <!-- Affiliation ...................... -->
  <xs:attributeGroup name="affiliation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The institutional affiliation of an individual. -->
  <xs:element name="affiliation">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="shortaffil"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="jobtitle"/>
        <xs:element minOccurs="0" ref="orgname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="orgdiv"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="address"/>
      </xs:sequence>
      <xs:attributeGroup ref="affiliation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of affiliation.element -->
  <xs:attributeGroup name="affiliation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="affiliation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of affiliation.attlist -->
  <!-- end of affiliation.module -->
  <xs:attributeGroup name="shortaffil.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A brief description of an affiliation. -->
  <xs:element name="shortaffil">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="shortaffil.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of shortaffil.element -->
  <xs:attributeGroup name="shortaffil.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="shortaffil.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of shortaffil.attlist -->
  <!-- end of shortaffil.module -->
  <xs:attributeGroup name="jobtitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The title of an individual in an organization. -->
  <xs:element name="jobtitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="jobtitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of jobtitle.element -->
  <xs:attributeGroup name="jobtitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="jobtitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of jobtitle.attlist -->
  <!-- end of jobtitle.module -->
  <!-- OrgName (defined elsewhere in this section) -->
  <xs:attributeGroup name="orgdiv.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A division of an organization. -->
  <xs:element name="orgdiv">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="orgdiv.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orgdiv.element -->
  <xs:attributeGroup name="orgdiv.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="orgdiv.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orgdiv.attlist -->
  <!-- end of orgdiv.module -->
  <!-- Address (defined elsewhere in this section) -->
  <!-- end of affiliation.content.module -->
  <!-- ArtPageNums ...................... -->
  <xs:attributeGroup name="artpagenums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The page numbers of an article as published. -->
  <xs:element name="artpagenums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="artpagenums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of artpagenums.element -->
  <xs:attributeGroup name="artpagenums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="artpagenums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of artpagenums.attlist -->
  <!-- end of artpagenums.module -->
  <!-- PersonName -->
  <xs:attributeGroup name="personname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The personal name of an individual. -->
  <xs:element name="personname" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="honorific"/>
        <xs:element ref="firstname"/>
        <xs:element ref="surname"/>
        <xs:element ref="lineage"/>
        <xs:element ref="othername"/>
      </xs:choice>
      <xs:attributeGroup ref="personname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of personname.element -->
  <xs:attributeGroup name="personname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="personname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of personname.attlist -->
  <!-- end of personname.module -->
  <!-- Author ........................... -->
  <xs:attributeGroup name="author.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of an individual author. -->
  <xs:element name="author" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="author.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of author.element -->
  <xs:attributeGroup name="author.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="author.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of author.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of author.module -->
  <!-- AuthorGroup ...................... -->
  <xs:attributeGroup name="authorgroup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Wrapper for author information when a document has multiple authors or collabarators. -->
  <xs:element name="authorgroup">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="author"/>
        <xs:element ref="editor"/>
        <xs:element ref="collab"/>
        <xs:element ref="corpauthor"/>
        <xs:element ref="corpcredit"/>
        <xs:element ref="othercredit"/>
      </xs:choice>
      <xs:attributeGroup ref="authorgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorgroup.element -->
  <xs:attributeGroup name="authorgroup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorgroup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorgroup.attlist -->
  <!-- end of authorgroup.module -->
  <!-- Author (defined elsewhere in this section) -->
  <!-- Editor (defined elsewhere in this section) -->
  <xs:attributeGroup name="collab.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Identifies a collaborator. -->
  <xs:element name="collab">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="collabname"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="affiliation"/>
      </xs:sequence>
      <xs:attributeGroup ref="collab.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of collab.element -->
  <xs:attributeGroup name="collab.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="collab.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of collab.attlist -->
  <!-- end of collab.module -->
  <xs:attributeGroup name="collabname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a collaborator. -->
  <xs:element name="collabname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="collabname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of collabname.element -->
  <xs:attributeGroup name="collabname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="collabname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of collabname.attlist -->
  <!-- end of collabname.module -->
  <!-- Affiliation (defined elsewhere in this section) -->
  <!-- end of collab.content.module -->
  <!-- CorpAuthor (defined elsewhere in this section) -->
  <!-- OtherCredit (defined elsewhere in this section) -->
  <!-- end of authorgroup.content.module -->
  <!-- AuthorInitials ................... -->
  <xs:attributeGroup name="authorinitials.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The initials or other short identifier for an author. -->
  <xs:element name="authorinitials" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="authorinitials.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of authorinitials.element -->
  <xs:attributeGroup name="authorinitials.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="authorinitials.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of authorinitials.attlist -->
  <!-- end of authorinitials.module -->
  <!-- ConfGroup ........................ -->
  <xs:attributeGroup name="confgroup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for document meta-information about a conference. -->
  <xs:element name="confgroup">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="confdates"/>
        <xs:element ref="conftitle"/>
        <xs:element ref="confnum"/>
        <xs:element ref="address"/>
        <xs:element ref="confsponsor"/>
      </xs:choice>
      <xs:attributeGroup ref="confgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confgroup.element -->
  <xs:attributeGroup name="confgroup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confgroup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confgroup.attlist -->
  <!-- end of confgroup.module -->
  <xs:attributeGroup name="confdates.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The dates of a conference for which a document was written. -->
  <xs:element name="confdates">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confdates.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confdates.element -->
  <xs:attributeGroup name="confdates.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confdates.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confdates.attlist -->
  <!-- end of confdates.module -->
  <xs:attributeGroup name="conftitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The title of a conference for which a document was written. -->
  <xs:element name="conftitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="conftitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of conftitle.element -->
  <xs:attributeGroup name="conftitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="conftitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of conftitle.attlist -->
  <!-- end of conftitle.module -->
  <xs:attributeGroup name="confnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An identifier, frequently numerical, associated with a conference for which a document was written. -->
  <xs:element name="confnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confnum.element -->
  <xs:attributeGroup name="confnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confnum.attlist -->
  <!-- end of confnum.module -->
  <!-- Address (defined elsewhere in this section) -->
  <xs:attributeGroup name="confsponsor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The sponsor of a conference for which a document was written. -->
  <xs:element name="confsponsor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="confsponsor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of confsponsor.element -->
  <xs:attributeGroup name="confsponsor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="confsponsor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of confsponsor.attlist -->
  <!-- end of confsponsor.module -->
  <!-- end of confgroup.content.module -->
  <!-- ContractNum ...................... -->
  <xs:attributeGroup name="contractnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The contract number of a document. -->
  <xs:element name="contractnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contractnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contractnum.element -->
  <xs:attributeGroup name="contractnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contractnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contractnum.attlist -->
  <!-- end of contractnum.module -->
  <!-- ContractSponsor .................. -->
  <xs:attributeGroup name="contractsponsor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The sponsor of a contract. -->
  <xs:element name="contractsponsor">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contractsponsor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contractsponsor.element -->
  <xs:attributeGroup name="contractsponsor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contractsponsor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contractsponsor.attlist -->
  <!-- end of contractsponsor.module -->
  <!-- Copyright ........................ -->
  <xs:attributeGroup name="copyright.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Copyright information about a document. -->
  <xs:element name="copyright">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="year"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="holder"/>
      </xs:sequence>
      <xs:attributeGroup ref="copyright.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of copyright.element -->
  <xs:attributeGroup name="copyright.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="copyright.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of copyright.attlist -->
  <!-- end of copyright.module -->
  <xs:attributeGroup name="year.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The year of publication of a document. -->
  <xs:element name="year">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="year.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of year.element -->
  <xs:attributeGroup name="year.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="year.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of year.attlist -->
  <!-- end of year.module -->
  <xs:attributeGroup name="holder.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of the individual or organization that holds a copyright. -->
  <xs:element name="holder">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="holder.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of holder.element -->
  <xs:attributeGroup name="holder.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="holder.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of holder.attlist -->
  <!-- end of holder.module -->
  <!-- end of copyright.content.module -->
  <!-- CorpAuthor ....................... -->
  <xs:attributeGroup name="corpauthor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A corporate author, as opposed to an individual. -->
  <xs:element name="corpauthor" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpauthor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpauthor.element -->
  <xs:attributeGroup name="corpauthor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpauthor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpauthor.attlist -->
  <!-- end of corpauthor.module -->
  <!-- CorpCredit ...................... -->
  <xs:attributeGroup name="corpcredit.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A corporation or organization credited in a document. -->
  <xs:element name="corpcredit" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpcredit.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpcredit.element -->
  <xs:attributeGroup name="corpcredit.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="graphicdesigner"/>
          <xs:enumeration value="productioneditor"/>
          <xs:enumeration value="copyeditor"/>
          <xs:enumeration value="technicaleditor"/>
          <xs:enumeration value="translator"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpcredit.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpcredit.attlist -->
  <!-- end of corpcredit.module -->
  <!-- CorpName ......................... -->
  <!-- doc:The name of a corporation. -->
  <xs:element name="corpname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="corpname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of corpname.element -->
  <xs:attributeGroup name="corpname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="corpname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="corpname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of corpname.attlist -->
  <!-- end of corpname.module -->
  <!-- Date ............................. -->
  <xs:attributeGroup name="date.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The date of publication or revision of a document. -->
  <xs:element name="date">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="date.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of date.element -->
  <xs:attributeGroup name="date.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="date.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of date.attlist -->
  <!-- end of date.module -->
  <!-- Edition .......................... -->
  <xs:attributeGroup name="edition.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name or number of an edition of a document. -->
  <xs:element name="edition">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="edition.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of edition.element -->
  <xs:attributeGroup name="edition.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="edition.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of edition.attlist -->
  <!-- end of edition.module -->
  <!-- Editor ........................... -->
  <xs:attributeGroup name="editor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of the editor of a document. -->
  <xs:element name="editor">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="editor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of editor.element -->
  <xs:attributeGroup name="editor.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="editor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of editor.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of editor.module -->
  <!-- ISBN ............................. -->
  <xs:attributeGroup name="isbn.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The International Standard Book Number of a document. -->
  <xs:element name="isbn">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="isbn.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of isbn.element -->
  <xs:attributeGroup name="isbn.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="isbn.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of isbn.attlist -->
  <!-- end of isbn.module -->
  <!-- ISSN ............................. -->
  <xs:attributeGroup name="issn.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The International Standard Serial Number of a periodical. -->
  <xs:element name="issn">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="issn.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of issn.element -->
  <xs:attributeGroup name="issn.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="issn.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of issn.attlist -->
  <!-- end of issn.module -->
  <!-- BiblioId ................. -->
  <xs:attributeGroup name="biblio.class.attrib">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="uri"/>
          <xs:enumeration value="doi"/>
          <xs:enumeration value="isbn"/>
          <xs:enumeration value="isrn"/>
          <xs:enumeration value="issn"/>
          <xs:enumeration value="libraryofcongress"/>
          <xs:enumeration value="pubnumber"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherclass"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="biblioid.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An identifier for a document. -->
  <xs:element name="biblioid">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="biblioid.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioid.element -->
  <xs:attributeGroup name="biblioid.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="biblioid.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioid.attlist -->
  <!-- end of biblioid.module -->
  <!-- CiteBiblioId ................. -->
  <xs:attributeGroup name="citebiblioid.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A citation of a bibliographic identifier. -->
  <xs:element name="citebiblioid" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="citebiblioid.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citebiblioid.element -->
  <xs:attributeGroup name="citebiblioid.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citebiblioid.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citebiblioid.attlist -->
  <!-- end of citebiblioid.module -->
  <!-- BiblioSource ................. -->
  <xs:attributeGroup name="bibliosource.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The source of a document. -->
  <xs:element name="bibliosource">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliosource.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliosource.element -->
  <xs:attributeGroup name="bibliosource.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliosource.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliosource.attlist -->
  <!-- end of bibliosource.module -->
  <!-- BiblioRelation ................. -->
  <xs:attributeGroup name="bibliorelation.type.attrib">
    <xs:attribute name="type">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="isversionof"/>
          <xs:enumeration value="hasversion"/>
          <xs:enumeration value="isreplacedby"/>
          <xs:enumeration value="replaces"/>
          <xs:enumeration value="isrequiredby"/>
          <xs:enumeration value="requires"/>
          <xs:enumeration value="ispartof"/>
          <xs:enumeration value="haspart"/>
          <xs:enumeration value="isreferencedby"/>
          <xs:enumeration value="references"/>
          <xs:enumeration value="isformatof"/>
          <xs:enumeration value="hasformat"/>
          <xs:enumeration value="othertype"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="othertype"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="bibliorelation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The relationship of a document to another. -->
  <xs:element name="bibliorelation">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliorelation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliorelation.element -->
  <xs:attributeGroup name="bibliorelation.attlist">
    <xs:attributeGroup ref="biblio.class.attrib"/>
    <xs:attributeGroup ref="bibliorelation.type.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliorelation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliorelation.attlist -->
  <!-- end of bibliorelation.module -->
  <!-- BiblioCoverage ................. -->
  <xs:attributeGroup name="bibliocoverage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The spatial or temporal coverage of a document. -->
  <xs:element name="bibliocoverage">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="bibliocoverage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of bibliocoverage.element -->
  <xs:attributeGroup name="bibliocoverage.attlist">
    <xs:attribute name="spatial">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="dcmipoint"/>
          <xs:enumeration value="iso3166"/>
          <xs:enumeration value="dcmibox"/>
          <xs:enumeration value="tgn"/>
          <xs:enumeration value="otherspatial"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherspatial"/>
    <xs:attribute name="temporal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="dcmiperiod"/>
          <xs:enumeration value="w3c-dtf"/>
          <xs:enumeration value="othertemporal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="othertemporal"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="bibliocoverage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of bibliocoverage.attlist -->
  <!-- end of bibliocoverage.module -->
  <!-- InvPartNumber .................... -->
  <xs:attributeGroup name="invpartnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An inventory part number. -->
  <xs:element name="invpartnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="invpartnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of invpartnumber.element -->
  <xs:attributeGroup name="invpartnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="invpartnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of invpartnumber.attlist -->
  <!-- end of invpartnumber.module -->
  <!-- IssueNum ......................... -->
  <xs:attributeGroup name="issuenum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The number of an issue of a journal. -->
  <xs:element name="issuenum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="issuenum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of issuenum.element -->
  <xs:attributeGroup name="issuenum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="issuenum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of issuenum.attlist -->
  <!-- end of issuenum.module -->
  <!-- LegalNotice ...................... -->
  <xs:attributeGroup name="legalnotice.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A statement of legal obligations or requirements. -->
  <xs:element name="legalnotice">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:element minOccurs="0" ref="title"/>
        <xs:group maxOccurs="unbounded" ref="legalnotice.mix"/>
      </xs:sequence>
      <xs:attributeGroup ref="legalnotice.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of legalnotice.element -->
  <xs:attributeGroup name="legalnotice.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="legalnotice.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of legalnotice.attlist -->
  <!-- end of legalnotice.module -->
  <!-- ModeSpec ......................... -->
  <xs:attributeGroup name="modespec.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Application-specific information necessary for the completion of an OLink. -->
  <xs:element name="modespec" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="modespec.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of modespec.element -->
  <!--
    Application: Type of action required for completion
    of the links to which the ModeSpec is relevant (e.g.,
    retrieval query)
  -->
  <xs:attributeGroup name="modespec.attlist">
    <xs:attribute name="application" type="notation.class"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="modespec.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of modespec.attlist -->
  <!-- end of modespec.module -->
  <!-- OrgName .......................... -->
  <xs:attributeGroup name="orgname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of an organization other than a corporation. -->
  <xs:element name="orgname" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="orgname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of orgname.element -->
  <xs:attributeGroup name="orgname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="corporation"/>
          <xs:enumeration value="nonprofit"/>
          <xs:enumeration value="consortium"/>
          <xs:enumeration value="informal"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherclass"/>
    <xs:attributeGroup ref="orgname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of orgname.attlist -->
  <!-- end of orgname.module -->
  <!-- OtherCredit ...................... -->
  <xs:attributeGroup name="othercredit.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A person or entity, other than an author or editor, credited in a document. -->
  <xs:element name="othercredit" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:element ref="personname"/>
          <xs:group maxOccurs="unbounded" ref="person.ident.mix"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="personblurb"/>
          <xs:element ref="email"/>
          <xs:element ref="address"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="othercredit.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of othercredit.element -->
  <xs:attributeGroup name="othercredit.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="graphicdesigner"/>
          <xs:enumeration value="productioneditor"/>
          <xs:enumeration value="copyeditor"/>
          <xs:enumeration value="technicaleditor"/>
          <xs:enumeration value="translator"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="othercredit.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of othercredit.attlist -->
  <!-- (see "Personal identity elements" for %person.ident.mix;) -->
  <!-- end of othercredit.module -->
  <!-- PageNums ......................... -->
  <xs:attributeGroup name="pagenums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The numbers of the pages in a book, for use in a bibliographic entry. -->
  <xs:element name="pagenums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pagenums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pagenums.element -->
  <xs:attributeGroup name="pagenums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pagenums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pagenums.attlist -->
  <!-- end of pagenums.module -->
  <!-- Personal identity elements ....... -->
  <!--
    These elements are used only within Author, Editor, and
    OtherCredit.
  -->
  <xs:attributeGroup name="contrib.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A summary of the contributions made to a document by a credited source. -->
  <xs:element name="contrib">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="contrib.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of contrib.element -->
  <xs:attributeGroup name="contrib.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="contrib.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of contrib.attlist -->
  <!-- end of contrib.module -->
  <xs:attributeGroup name="firstname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The first name of a person. -->
  <xs:element name="firstname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="firstname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of firstname.element -->
  <xs:attributeGroup name="firstname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="firstname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of firstname.attlist -->
  <!-- end of firstname.module -->
  <xs:attributeGroup name="honorific.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The title of a person. -->
  <xs:element name="honorific">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="honorific.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of honorific.element -->
  <xs:attributeGroup name="honorific.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="honorific.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of honorific.attlist -->
  <!-- end of honorific.module -->
  <xs:attributeGroup name="lineage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The portion of a person's name indicating a relationship to ancestors. -->
  <xs:element name="lineage">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="lineage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lineage.element -->
  <xs:attributeGroup name="lineage.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lineage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lineage.attlist -->
  <!-- end of lineage.module -->
  <xs:attributeGroup name="othername.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A component of a persons name that is not a first name, surname, or lineage. -->
  <xs:element name="othername">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="othername.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of othername.element -->
  <xs:attributeGroup name="othername.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="othername.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of othername.attlist -->
  <!-- end of othername.module -->
  <xs:attributeGroup name="surname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A family name; in western cultures the last name. -->
  <xs:element name="surname">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="surname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of surname.element -->
  <xs:attributeGroup name="surname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="surname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of surname.attlist -->
  <!-- end of surname.module -->
  <!-- end of person.ident.module -->
  <!-- PrintHistory ..................... -->
  <xs:attributeGroup name="printhistory.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The printing history of a document. -->
  <xs:element name="printhistory">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="para.class"/>
      </xs:sequence>
      <xs:attributeGroup ref="printhistory.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of printhistory.element -->
  <xs:attributeGroup name="printhistory.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="printhistory.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of printhistory.attlist -->
  <!-- end of printhistory.module -->
  <!-- ProductName ...................... -->
  <xs:attributeGroup name="productname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The formal name of a product. -->
  <xs:element name="productname" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="productname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of productname.element -->
  <!-- Class: More precisely identifies the item the element names -->
  <xs:attributeGroup name="productname.attlist">
    <xs:attribute name="class" default="trade">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="service"/>
          <xs:enumeration value="trade"/>
          <xs:enumeration value="registered"/>
          <xs:enumeration value="copyright"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="productname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of productname.attlist -->
  <!-- end of productname.module -->
  <!-- ProductNumber .................... -->
  <xs:attributeGroup name="productnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A number assigned to a product. -->
  <xs:element name="productnumber" substitutionGroup="docinfo.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="productnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of productnumber.element -->
  <xs:attributeGroup name="productnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="productnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of productnumber.attlist -->
  <!-- end of productnumber.module -->
  <!-- PubDate .......................... -->
  <xs:attributeGroup name="pubdate.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The date of publication of a document. -->
  <xs:element name="pubdate">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pubdate.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pubdate.element -->
  <xs:attributeGroup name="pubdate.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pubdate.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pubdate.attlist -->
  <!-- end of pubdate.module -->
  <!-- Publisher ........................ -->
  <xs:attributeGroup name="publisher.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The publisher of a document. -->
  <xs:element name="publisher">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="publishername"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="address"/>
      </xs:sequence>
      <xs:attributeGroup ref="publisher.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of publisher.element -->
  <xs:attributeGroup name="publisher.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="publisher.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of publisher.attlist -->
  <!-- end of publisher.module -->
  <xs:attributeGroup name="publishername.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of the publisher of a document. -->
  <xs:element name="publishername">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="publishername.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of publishername.element -->
  <xs:attributeGroup name="publishername.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="publishername.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of publishername.attlist -->
  <!-- end of publishername.module -->
  <!-- Address (defined elsewhere in this section) -->
  <!-- end of publisher.content.module -->
  <!-- PubsNumber ....................... -->
  <xs:attributeGroup name="pubsnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A number assigned to a publication other than an ISBN or ISSN or inventory part number. -->
  <xs:element name="pubsnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="pubsnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of pubsnumber.element -->
  <xs:attributeGroup name="pubsnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="pubsnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of pubsnumber.attlist -->
  <!-- end of pubsnumber.module -->
  <!-- ReleaseInfo ...................... -->
  <xs:attributeGroup name="releaseinfo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Information about a particular release of a document. -->
  <xs:element name="releaseinfo">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="releaseinfo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of releaseinfo.element -->
  <xs:attributeGroup name="releaseinfo.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="releaseinfo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of releaseinfo.attlist -->
  <!-- end of releaseinfo.module -->
  <!-- RevHistory ....................... -->
  <xs:attributeGroup name="revhistory.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A history of the revisions to a document. -->
  <xs:element name="revhistory" substitutionGroup="docinfo.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="revision"/>
      </xs:sequence>
      <xs:attributeGroup ref="revhistory.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revhistory.element -->
  <xs:attributeGroup name="revhistory.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revhistory.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revhistory.attlist -->
  <!-- end of revhistory.module -->
  <xs:attributeGroup name="revision.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An entry describing a single revision in the history of the revisions to a document. -->
  <xs:element name="revision">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="revnumber"/>
        <xs:element ref="date"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="author"/>
          <xs:element ref="authorinitials"/>
        </xs:choice>
        <xs:choice minOccurs="0">
          <xs:element ref="revremark"/>
          <xs:element ref="revdescription"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="revision.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revision.element -->
  <xs:attributeGroup name="revision.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revision.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revision.attlist -->
  <!-- end of revision.module -->
  <xs:attributeGroup name="revnumber.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A document revision number. -->
  <xs:element name="revnumber">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="revnumber.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revnumber.element -->
  <xs:attributeGroup name="revnumber.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revnumber.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revnumber.attlist -->
  <!-- end of revnumber.module -->
  <!-- Date (defined elsewhere in this section) -->
  <!-- AuthorInitials (defined elsewhere in this section) -->
  <xs:attributeGroup name="revremark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A description of a revision to a document. -->
  <xs:element name="revremark">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="revremark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revremark.element -->
  <xs:attributeGroup name="revremark.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revremark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revremark.attlist -->
  <!-- end of revremark.module -->
  <xs:attributeGroup name="revdescription.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A extended description of a revision to a document. -->
  <xs:element name="revdescription">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="revdescription.mix"/>
      <xs:attributeGroup ref="revdescription.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of revdescription.element -->
  <xs:attributeGroup name="revdescription.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="revdescription.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of revdescription.attlist -->
  <!-- end of revdescription.module -->
  <!-- end of revhistory.content.module -->
  <!-- SeriesVolNums .................... -->
  <xs:attributeGroup name="seriesvolnums.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Numbers of the volumes in a series of books. -->
  <xs:element name="seriesvolnums">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="seriesvolnums.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seriesvolnums.element -->
  <xs:attributeGroup name="seriesvolnums.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seriesvolnums.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of seriesvolnums.attlist -->
  <!-- end of seriesvolnums.module -->
  <!-- VolumeNum ........................ -->
  <xs:attributeGroup name="volumenum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The volume number of a document in a set (as of books in a set or articles in a journal). -->
  <xs:element name="volumenum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="volumenum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of volumenum.element -->
  <xs:attributeGroup name="volumenum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="volumenum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of volumenum.attlist -->
  <!-- end of volumenum.module -->
  <!-- .................................. -->
  <!-- end of docinfo.content.module -->
  <!-- ...................................................................... -->
  <!-- Inline, link, and ubiquitous elements ................................ -->
  <!-- Technical and computer terms ......................................... -->
  <xs:attributeGroup name="accel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A graphical user interface (GUI) keyboard shortcut. -->
  <xs:element name="accel">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="accel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of accel.element -->
  <xs:attributeGroup name="accel.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="accel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of accel.attlist -->
  <!-- end of accel.module -->
  <xs:attributeGroup name="action.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A response to a user event. -->
  <xs:element name="action" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="action.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of action.element -->
  <xs:attributeGroup name="action.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="action.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of action.attlist -->
  <!-- end of action.module -->
  <xs:attributeGroup name="application.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a software program. -->
  <xs:element name="application" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="application.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of application.element -->
  <xs:attributeGroup name="application.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="hardware"/>
          <xs:enumeration value="software"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="application.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of application.attlist -->
  <!-- end of application.module -->
  <xs:attributeGroup name="classname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a class, in the object-oriented programming sense. -->
  <xs:element name="classname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="classname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of classname.element -->
  <xs:attributeGroup name="classname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="classname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of classname.attlist -->
  <!-- end of classname.module -->
  <xs:attributeGroup name="package.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A package. -->
  <xs:element name="package" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="package.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of package.element -->
  <xs:attributeGroup name="package.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="package.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of package.attlist -->
  <!-- end of package.module -->
  <!--
    CO is a callout area of the LineColumn unit type (a single character
    position); the position is directly indicated by the location of CO.
  -->
  <xs:attributeGroup name="co.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The location of a callout embedded in text. -->
  <xs:element name="co">
    <xs:complexType>
      <xs:attributeGroup ref="co.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of co.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <xs:attributeGroup name="co.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkends.attrib"/>
    <xs:attributeGroup ref="idreq.common.attrib"/>
    <xs:attributeGroup ref="co.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of co.attlist -->
  <!-- end of co.module -->
  <!-- COREF is a reference to a CO -->
  <xs:attributeGroup name="coref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A cross reference to a co. -->
  <xs:element name="coref">
    <xs:complexType>
      <xs:attributeGroup ref="coref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of coref.element -->
  <!-- bug number/symbol override or initialization -->
  <!-- to any related information -->
  <xs:attributeGroup name="coref.attlist">
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="coref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of coref.attlist -->
  <!-- end of coref.module -->
  <xs:attributeGroup name="command.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of an executable program or other software command. -->
  <xs:element name="command" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="command.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of command.element -->
  <xs:attributeGroup name="command.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="command.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of command.attlist -->
  <!-- end of command.module -->
  <xs:attributeGroup name="computeroutput.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Data, generally text, displayed or presented by a computer. -->
  <xs:element name="computeroutput" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="computeroutput.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of computeroutput.element -->
  <xs:attributeGroup name="computeroutput.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="computeroutput.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of computeroutput.attlist -->
  <!-- end of computeroutput.module -->
  <xs:attributeGroup name="database.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a database, or part of a database. -->
  <xs:element name="database" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="database.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of database.element -->
  <!-- Class: Type of database the element names; no default -->
  <xs:attributeGroup name="database.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="name"/>
          <xs:enumeration value="table"/>
          <xs:enumeration value="field"/>
          <xs:enumeration value="key1"/>
          <xs:enumeration value="key2"/>
          <xs:enumeration value="record"/>
          <xs:enumeration value="index"/>
          <xs:enumeration value="view"/>
          <xs:enumeration value="primarykey"/>
          <xs:enumeration value="secondarykey"/>
          <xs:enumeration value="foreignkey"/>
          <xs:enumeration value="altkey"/>
          <xs:enumeration value="procedure"/>
          <xs:enumeration value="datatype"/>
          <xs:enumeration value="constraint"/>
          <xs:enumeration value="rule"/>
          <xs:enumeration value="user"/>
          <xs:enumeration value="group"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="database.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of database.attlist -->
  <!-- end of database.module -->
  <xs:attributeGroup name="email.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An email address. -->
  <xs:element name="email" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="docinfo.char.mix"/>
      <xs:attributeGroup ref="email.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of email.element -->
  <xs:attributeGroup name="email.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="email.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of email.attlist -->
  <!-- end of email.module -->
  <xs:attributeGroup name="envar.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A software environment variable. -->
  <xs:element name="envar" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="envar.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of envar.element -->
  <xs:attributeGroup name="envar.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="envar.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of envar.attlist -->
  <!-- end of envar.module -->
  <xs:attributeGroup name="errorcode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An error code. -->
  <xs:element name="errorcode" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errorcode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errorcode.element -->
  <xs:attributeGroup name="errorcode.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errorcode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errorcode.attlist -->
  <!-- end of errorcode.module -->
  <xs:attributeGroup name="errorname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An error name. -->
  <xs:element name="errorname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errorname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errorname.element -->
  <xs:attributeGroup name="errorname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errorname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errorname.attlist -->
  <!-- end of errorname.module -->
  <xs:attributeGroup name="errortext.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An error message.. -->
  <xs:element name="errortext" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errortext.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errortext.element -->
  <xs:attributeGroup name="errortext.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errortext.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errortext.attlist -->
  <!-- end of errortext.module -->
  <xs:attributeGroup name="errortype.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The classification of an error message. -->
  <xs:element name="errortype" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="errortype.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of errortype.element -->
  <xs:attributeGroup name="errortype.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="errortype.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of errortype.attlist -->
  <!-- end of errortype.module -->
  <xs:attributeGroup name="filename.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a file. -->
  <xs:element name="filename" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="filename.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of filename.element -->
  <!-- Class: Type of filename the element names; no default -->
  <!--
    Path: Search path (possibly system-specific) in which
    file can be found
  -->
  <xs:attributeGroup name="filename.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="headerfile"/>
          <xs:enumeration value="partition"/>
          <xs:enumeration value="devicefile"/>
          <xs:enumeration value="libraryfile"/>
          <xs:enumeration value="directory"/>
          <xs:enumeration value="extension"/>
          <xs:enumeration value="symlink"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="path"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="filename.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of filename.attlist -->
  <!-- end of filename.module -->
  <xs:attributeGroup name="function.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a function or subroutine, as in a programming language. -->
  <xs:element name="function" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="function.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of function.element -->
  <xs:attributeGroup name="function.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="function.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of function.attlist -->
  <!-- end of function.module -->
  <xs:attributeGroup name="guibutton.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The text on a button in a GUI. -->
  <xs:element name="guibutton" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guibutton.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guibutton.element -->
  <xs:attributeGroup name="guibutton.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guibutton.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guibutton.attlist -->
  <!-- end of guibutton.module -->
  <xs:attributeGroup name="guiicon.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Graphic and/or text appearing as a icon in a GUI. -->
  <xs:element name="guiicon" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guiicon.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guiicon.element -->
  <xs:attributeGroup name="guiicon.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guiicon.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guiicon.attlist -->
  <!-- end of guiicon.module -->
  <xs:attributeGroup name="guilabel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The text of a label in a GUI. -->
  <xs:element name="guilabel" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guilabel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guilabel.element -->
  <xs:attributeGroup name="guilabel.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guilabel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guilabel.attlist -->
  <!-- end of guilabel.module -->
  <xs:attributeGroup name="guimenu.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a menu in a GUI. -->
  <xs:element name="guimenu" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guimenu.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guimenu.element -->
  <xs:attributeGroup name="guimenu.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guimenu.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guimenu.attlist -->
  <!-- end of guimenu.module -->
  <xs:attributeGroup name="guimenuitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a terminal menu item in a GUI. -->
  <xs:element name="guimenuitem" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guimenuitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guimenuitem.element -->
  <xs:attributeGroup name="guimenuitem.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guimenuitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guimenuitem.attlist -->
  <!-- end of guimenuitem.module -->
  <xs:attributeGroup name="guisubmenu.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a submenu in a GUI. -->
  <xs:element name="guisubmenu" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
        <xs:element ref="superscript"/>
        <xs:element ref="subscript"/>
      </xs:choice>
      <xs:attributeGroup ref="guisubmenu.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of guisubmenu.element -->
  <xs:attributeGroup name="guisubmenu.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="guisubmenu.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of guisubmenu.attlist -->
  <!-- end of guisubmenu.module -->
  <xs:attributeGroup name="hardware.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A physical part of a computer system. -->
  <xs:element name="hardware" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="hardware.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of hardware.element -->
  <xs:attributeGroup name="hardware.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="hardware.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of hardware.attlist -->
  <!-- end of hardware.module -->
  <xs:attributeGroup name="interface.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An element of a GUI. -->
  <xs:element name="interface" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="accel"/>
      </xs:choice>
      <xs:attributeGroup ref="interface.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of interface.element -->
  <!-- Class: Type of the Interface item; no default -->
  <xs:attributeGroup name="interface.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="interface.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of interface.attlist -->
  <!-- end of interface.module -->
  <xs:attributeGroup name="keycap.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The text printed on a key on a keyboard. -->
  <xs:element name="keycap" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="keycap.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycap.element -->
  <xs:attributeGroup name="keycap.attlist">
    <xs:attribute name="function">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="alt"/>
          <xs:enumeration value="control"/>
          <xs:enumeration value="shift"/>
          <xs:enumeration value="meta"/>
          <xs:enumeration value="escape"/>
          <xs:enumeration value="enter"/>
          <xs:enumeration value="tab"/>
          <xs:enumeration value="backspace"/>
          <xs:enumeration value="command"/>
          <xs:enumeration value="option"/>
          <xs:enumeration value="space"/>
          <xs:enumeration value="delete"/>
          <xs:enumeration value="insert"/>
          <xs:enumeration value="up"/>
          <xs:enumeration value="down"/>
          <xs:enumeration value="left"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="home"/>
          <xs:enumeration value="end"/>
          <xs:enumeration value="pageup"/>
          <xs:enumeration value="pagedown"/>
          <xs:enumeration value="other"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="otherfunction"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycap.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycap.attlist -->
  <!-- end of keycap.module -->
  <xs:attributeGroup name="keycode.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The internal, frequently numeric, identifier for a key on a keyboard. -->
  <xs:element name="keycode" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="keycode.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycode.element -->
  <xs:attributeGroup name="keycode.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycode.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycode.attlist -->
  <!-- end of keycode.module -->
  <xs:attributeGroup name="keycombo.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A combination of input actions. -->
  <xs:element name="keycombo" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="keycap"/>
        <xs:element ref="keycombo"/>
        <xs:element ref="keysym"/>
        <xs:element ref="mousebutton"/>
      </xs:choice>
      <xs:attributeGroup ref="keycombo.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keycombo.element -->
  <xs:attributeGroup name="keycombo.attlist">
    <xs:attributeGroup ref="keyaction.attrib"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keycombo.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keycombo.attlist -->
  <!-- end of keycombo.module -->
  <xs:attributeGroup name="keysysm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The symbolic name of a key on a keyboard. -->
  <xs:element name="keysym" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="keysym.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of keysym.element -->
  <xs:attributeGroup name="keysym.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="keysysm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of keysym.attlist -->
  <!-- end of keysym.module -->
  <xs:attributeGroup name="lineannotation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A comment on a line in a verbatim listing. -->
  <xs:element name="lineannotation">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="lineannotation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of lineannotation.element -->
  <xs:attributeGroup name="lineannotation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="lineannotation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of lineannotation.attlist -->
  <!-- end of lineannotation.module -->
  <xs:attributeGroup name="literal.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Inline text that is some literal value. -->
  <xs:element name="literal" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="literal.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of literal.element -->
  <xs:attributeGroup name="literal.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="literal.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of literal.attlist -->
  <!-- end of literal.module -->
  <xs:attributeGroup name="code.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An inline code fragment. -->
  <xs:element name="code" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="code.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of code.element -->
  <xs:attributeGroup name="code.attlist">
    <xs:attribute name="language"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="code.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of code.attlist -->
  <!-- end of code.module -->
  <xs:attributeGroup name="constant.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A programming or system constant. -->
  <xs:element name="constant" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="constant.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of constant.element -->
  <xs:attributeGroup name="constant.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="limit"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="constant.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of constant.attlist -->
  <!-- end of constant.module -->
  <xs:attributeGroup name="varname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a variable. -->
  <xs:element name="varname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="varname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of varname.element -->
  <xs:attributeGroup name="varname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="varname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of varname.attlist -->
  <!-- end of varname.module -->
  <xs:attributeGroup name="markup.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A string of formatting markup in text that is to be represented literally. -->
  <xs:element name="markup" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="markup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of markup.element -->
  <xs:attributeGroup name="markup.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="markup.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of markup.attlist -->
  <!-- end of markup.module -->
  <xs:attributeGroup name="medialabel.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A name that identifies the physical medium on which some information resides. -->
  <xs:element name="medialabel" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="medialabel.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of medialabel.element -->
  <!-- Class: Type of medium named by the element; no default -->
  <xs:attributeGroup name="medialabel.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="cartridge"/>
          <xs:enumeration value="cdrom"/>
          <xs:enumeration value="disk"/>
          <xs:enumeration value="tape"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="medialabel.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of medialabel.attlist -->
  <!-- end of medialabel.module -->
  <xs:attributeGroup name="menuchoice.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A selection or series of selections from a menu. -->
  <xs:element name="menuchoice" substitutionGroup="tech.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" ref="shortcut"/>
        <xs:choice maxOccurs="unbounded">
          <xs:element ref="guibutton"/>
          <xs:element ref="guiicon"/>
          <xs:element ref="guilabel"/>
          <xs:element ref="guimenu"/>
          <xs:element ref="guimenuitem"/>
          <xs:element ref="guisubmenu"/>
          <xs:element ref="interface"/>
        </xs:choice>
      </xs:sequence>
      <xs:attributeGroup ref="menuchoice.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of menuchoice.element -->
  <xs:attributeGroup name="menuchoice.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="menuchoice.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of menuchoice.attlist -->
  <!-- end of menuchoice.module -->
  <!-- See also KeyCombo -->
  <xs:attributeGroup name="shortcut.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A key combination for an action that is also accessible through a menu. -->
  <xs:element name="shortcut">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="keycap"/>
        <xs:element ref="keycombo"/>
        <xs:element ref="keysym"/>
        <xs:element ref="mousebutton"/>
      </xs:choice>
      <xs:attributeGroup ref="shortcut.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of shortcut.element -->
  <xs:attributeGroup name="shortcut.attlist">
    <xs:attributeGroup ref="keyaction.attrib"/>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="shortcut.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of shortcut.attlist -->
  <!-- end of shortcut.module -->
  <!-- end of menuchoice.content.module -->
  <xs:attributeGroup name="mousebutton.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The conventional name of a mouse button. -->
  <xs:element name="mousebutton" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="mousebutton.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of mousebutton.element -->
  <xs:attributeGroup name="mousebutton.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="mousebutton.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of mousebutton.attlist -->
  <!-- end of mousebutton.module -->
  <xs:attributeGroup name="msgtext.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The actual text of a message component in a message set. -->
  <xs:element name="msgtext">
    <xs:complexType>
      <xs:group maxOccurs="unbounded" ref="component.mix"/>
      <xs:attributeGroup ref="msgtext.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of msgtext.element -->
  <xs:attributeGroup name="msgtext.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="msgtext.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of msgtext.attlist -->
  <!-- end of msgtext.module -->
  <xs:attributeGroup name="option.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An option for a software command. -->
  <xs:element name="option" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="option.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of option.element -->
  <xs:attributeGroup name="option.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="option.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of option.attlist -->
  <!-- end of option.module -->
  <xs:attributeGroup name="optional.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Optional information. -->
  <xs:element name="optional" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="optional.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of optional.element -->
  <xs:attributeGroup name="optional.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="optional.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of optional.attlist -->
  <!-- end of optional.module -->
  <xs:attributeGroup name="parameter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A value or a symbolic reference to a value. -->
  <xs:element name="parameter" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="parameter.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of parameter.element -->
  <!-- Class: Type of the Parameter; no default -->
  <xs:attributeGroup name="parameter.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="command"/>
          <xs:enumeration value="function"/>
          <xs:enumeration value="option"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="parameter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of parameter.attlist -->
  <!-- end of parameter.module -->
  <xs:attributeGroup name="prompt.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A character or string indicating the start of an input field in a  computer display. -->
  <xs:element name="prompt" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="smallcptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="prompt.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of prompt.element -->
  <xs:attributeGroup name="prompt.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="prompt.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of prompt.attlist -->
  <!-- end of prompt.module -->
  <xs:attributeGroup name="property.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A unit of data associated with some part of a computer system. -->
  <xs:element name="property" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="cptr.char.mix"/>
      <xs:attributeGroup ref="property.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of property.element -->
  <xs:attributeGroup name="property.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="property.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of property.attlist -->
  <!-- end of property.module -->
  <xs:attributeGroup name="replaceable.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Content that may or must be replaced by the user. -->
  <xs:element name="replaceable" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="optional"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="replaceable.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of replaceable.element -->
  <!--
    Class: Type of information the element represents; no
    default
  -->
  <xs:attributeGroup name="replaceable.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="command"/>
          <xs:enumeration value="function"/>
          <xs:enumeration value="option"/>
          <xs:enumeration value="parameter"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="replaceable.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of replaceable.attlist -->
  <!-- end of replaceable.module -->
  <xs:attributeGroup name="returnvalue.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The value returned by a function. -->
  <xs:element name="returnvalue" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="returnvalue.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of returnvalue.element -->
  <xs:attributeGroup name="returnvalue.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="returnvalue.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of returnvalue.attlist -->
  <!-- end of returnvalue.module -->
  <xs:attributeGroup name="sgmltag.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A component of SGML markup. -->
  <xs:element name="sgmltag" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="sgmltag.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of sgmltag.element -->
  <!-- Class: Type of SGML construct the element names; no default -->
  <xs:attributeGroup name="sgmltag.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="attribute"/>
          <xs:enumeration value="attvalue"/>
          <xs:enumeration value="element"/>
          <xs:enumeration value="endtag"/>
          <xs:enumeration value="emptytag"/>
          <xs:enumeration value="genentity"/>
          <xs:enumeration value="numcharref"/>
          <xs:enumeration value="paramentity"/>
          <xs:enumeration value="pi"/>
          <xs:enumeration value="xmlpi"/>
          <xs:enumeration value="starttag"/>
          <xs:enumeration value="sgmlcomment"/>
          <xs:enumeration value="prefix"/>
          <xs:enumeration value="namespace"/>
          <xs:enumeration value="localname"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="namespace"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="sgmltag.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of sgmltag.attlist -->
  <!-- end of sgmltag.module -->
  <xs:attributeGroup name="structfield.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A field in a structure (in the programming language sense). -->
  <xs:element name="structfield" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="structfield.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of structfield.element -->
  <xs:attributeGroup name="structfield.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="structfield.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of structfield.attlist -->
  <!-- end of structfield.module -->
  <xs:attributeGroup name="structname.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The name of a structure (in the programming language sense). -->
  <xs:element name="structname" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="structname.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of structname.element -->
  <xs:attributeGroup name="structname.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="structname.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of structname.attlist -->
  <!-- end of structname.module -->
  <xs:attributeGroup name="symbol.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A name that is replaced by a value before processing. -->
  <xs:element name="symbol" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="symbol.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of symbol.element -->
  <!-- Class: Type of symbol; no default -->
  <xs:attributeGroup name="symbol.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="limit"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="symbol.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of symbol.attlist -->
  <!-- end of symbol.module -->
  <xs:attributeGroup name="systemitem.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A system-related item or term. -->
  <xs:element name="systemitem" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="acronym"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="systemitem.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of systemitem.element -->
  <!-- Class: Type of system item the element names; no default -->
  <xs:attributeGroup name="systemitem.attlist">
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="constant"/>
          <xs:enumeration value="daemon"/>
          <xs:enumeration value="domainname"/>
          <xs:enumeration value="etheraddress"/>
          <xs:enumeration value="event"/>
          <xs:enumeration value="eventhandler"/>
          <xs:enumeration value="filesystem"/>
          <xs:enumeration value="fqdomainname"/>
          <xs:enumeration value="groupname"/>
          <xs:enumeration value="ipaddress"/>
          <xs:enumeration value="library"/>
          <xs:enumeration value="macro"/>
          <xs:enumeration value="netmask"/>
          <xs:enumeration value="newsgroup"/>
          <xs:enumeration value="osname"/>
          <xs:enumeration value="protocol"/>
          <xs:enumeration value="resource"/>
          <xs:enumeration value="systemname"/>
          <xs:enumeration value="username"/>
          <xs:enumeration value="process"/>
          <xs:enumeration value="server"/>
          <xs:enumeration value="service"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="systemitem.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of systemitem.attlist -->
  <!-- end of systemitem.module -->
  <xs:attributeGroup name="uri.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A Uniform Resource Identifier. -->
  <xs:element name="uri" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="uri.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of uri.element -->
  <!-- Type: Type of URI; no default -->
  <xs:attributeGroup name="uri.attlist">
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="uri.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of uri.attlist -->
  <!-- end of uri.module -->
  <xs:attributeGroup name="token.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A unit of information. -->
  <xs:element name="token" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="token.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of token.element -->
  <xs:attributeGroup name="token.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="token.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of token.attlist -->
  <!-- end of token.module -->
  <xs:attributeGroup name="type.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The classification of a value. -->
  <xs:element name="type" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="smallcptr.char.mix"/>
      <xs:attributeGroup ref="type.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of type.element -->
  <xs:attributeGroup name="type.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="type.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of type.attlist -->
  <!-- end of type.module -->
  <xs:attributeGroup name="userinput.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Data entered by the user. -->
  <xs:element name="userinput" substitutionGroup="tech.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="cptr.char.mix"/>
        <xs:element ref="co"/>
      </xs:choice>
      <xs:attributeGroup ref="userinput.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of userinput.element -->
  <xs:attributeGroup name="userinput.attlist">
    <xs:attributeGroup ref="moreinfo.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="userinput.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of userinput.attlist -->
  <!-- end of userinput.module -->
  <xs:attributeGroup name="termdef.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An inline definition of a term. -->
  <xs:element name="termdef" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="termdef.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of termdef.element -->
  <xs:attributeGroup name="termdef.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="termdef.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of termdef.attlist -->
  <!-- end of termdef.module -->
  <!-- General words and phrases ............................................ -->
  <xs:attributeGroup name="abbrev.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An abbreviation, especially one followed by a period. -->
  <xs:element name="abbrev" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="abbrev.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of abbrev.element -->
  <xs:attributeGroup name="abbrev.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="abbrev.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of abbrev.attlist -->
  <!-- end of abbrev.module -->
  <xs:attributeGroup name="acronym.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An often pronounceable word made from the initial (or selected) letters of a name or phrase. -->
  <xs:element name="acronym" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="acronym.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of acronym.element -->
  <xs:attributeGroup name="acronym.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="acronym.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of acronym.attlist -->
  <!-- end of acronym.module -->
  <xs:attributeGroup name="citation.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An inline bibliographic reference to another published work. -->
  <xs:element name="citation" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="citation.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citation.element -->
  <xs:attributeGroup name="citation.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citation.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citation.attlist -->
  <!-- end of citation.module -->
  <xs:attributeGroup name="citerefentry.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A citation to a reference page. -->
  <xs:element name="citerefentry" substitutionGroup="gen.char.class">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="refentrytitle"/>
        <xs:element minOccurs="0" ref="manvolnum"/>
      </xs:sequence>
      <xs:attributeGroup ref="citerefentry.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citerefentry.element -->
  <xs:attributeGroup name="citerefentry.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citerefentry.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citerefentry.attlist -->
  <!-- end of citerefentry.module -->
  <xs:attributeGroup name="refentrytitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The title of a reference page. -->
  <xs:element name="refentrytitle">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="refentrytitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of refentrytitle.element -->
  <xs:attributeGroup name="refentrytitle.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="refentrytitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of refentrytitle.attlist -->
  <!-- end of refentrytitle.module -->
  <xs:attributeGroup name="namvolnum.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A reference volume number. -->
  <xs:element name="manvolnum">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="manvolnum.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of manvolnum.element -->
  <xs:attributeGroup name="manvolnum.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="namvolnum.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of manvolnum.attlist -->
  <!-- end of manvolnum.module -->
  <xs:attributeGroup name="citetitle.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The title of a cited work. -->
  <xs:element name="citetitle" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="citetitle.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of citetitle.element -->
  <!-- Pubwork: Genre of published work cited; no default -->
  <xs:attributeGroup name="citetitle.attlist">
    <xs:attribute name="pubwork">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="article"/>
          <xs:enumeration value="book"/>
          <xs:enumeration value="chapter"/>
          <xs:enumeration value="part"/>
          <xs:enumeration value="refentry"/>
          <xs:enumeration value="section"/>
          <xs:enumeration value="journal"/>
          <xs:enumeration value="series"/>
          <xs:enumeration value="set"/>
          <xs:enumeration value="manuscript"/>
          <xs:enumeration value="cdrom"/>
          <xs:enumeration value="dvd"/>
          <xs:enumeration value="wiki"/>
          <xs:enumeration value="gopher"/>
          <xs:enumeration value="bbs"/>
          <xs:enumeration value="emailmessage"/>
          <xs:enumeration value="webpage"/>
          <xs:enumeration value="newsposting"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="citetitle.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of citetitle.attlist -->
  <!-- end of citetitle.module -->
  <xs:attributeGroup name="emphasis.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Emphasized text. -->
  <xs:element name="emphasis" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="emphasis.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of emphasis.element -->
  <xs:attributeGroup name="emphasis.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="emphasis.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of emphasis.attlist -->
  <!-- end of emphasis.module -->
  <xs:attributeGroup name="foreignphrase.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A word or phrase in a language other than the primary language of the document. -->
  <xs:element name="foreignphrase" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="foreignphrase.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of foreignphrase.element -->
  <xs:attributeGroup name="foreignphrase.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="foreignphrase.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of foreignphrase.attlist -->
  <!-- end of foreignphrase.module -->
  <xs:attributeGroup name="glossterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A glossary term. -->
  <xs:element name="glossterm" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="glossterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of glossterm.element -->
  <!-- to GlossEntry if Glossterm used in text -->
  <!--
    BaseForm: Provides the form of GlossTerm to be used
    for indexing
  -->
  <xs:attributeGroup name="glossterm.attlist">
    <xs:attribute name="baseform"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="glossterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of glossterm.attlist -->
  <!-- end of glossterm.module -->
  <xs:attributeGroup name="firstterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The first occurrence of a term. -->
  <xs:element name="firstterm" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="firstterm.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of firstterm.element -->
  <!-- to GlossEntry or other explanation -->
  <xs:attributeGroup name="firstterm.attlist">
    <xs:attribute name="baseform"/>
    <xs:attributeGroup ref="linkend.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="firstterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of firstterm.attlist -->
  <!-- end of firstterm.module -->
  <xs:attributeGroup name="phrase.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A span of text. -->
  <xs:element name="phrase" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="phrase.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of phrase.element -->
  <xs:attributeGroup name="phrase.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="phrase.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of phrase.attlist -->
  <!-- end of phrase.module -->
  <xs:attributeGroup name="quote.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:An inline quotation. -->
  <xs:element name="quote" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="quote.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of quote.element -->
  <xs:attributeGroup name="quote.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="quote.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of quote.attlist -->
  <!-- end of quote.module -->
  <xs:attributeGroup name="ssscript.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A subscript (as in H{^2}O, the molecular formula for water). -->
  <xs:element name="subscript">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="symbol"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
      </xs:choice>
      <xs:attributeGroup ref="subscript.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of subscript.element -->
  <xs:attributeGroup name="subscript.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ssscript.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of subscript.attlist -->
  <!-- doc:A superscript (as in x^2, the mathematical notation for x multiplied by itself). -->
  <xs:element name="superscript">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="emphasis"/>
        <xs:element ref="replaceable"/>
        <xs:element ref="symbol"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
      </xs:choice>
      <xs:attributeGroup ref="superscript.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of superscript.element -->
  <xs:attributeGroup name="superscript.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ssscript.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of superscript.attlist -->
  <!-- end of ssscript.module -->
  <xs:attributeGroup name="trademark.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A trademark. -->
  <xs:element name="trademark" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="link.char.class"/>
        <xs:element ref="tech.char.class"/>
        <xs:group ref="base.char.class"/>
        <xs:group ref="other.char.class"/>
        <xs:element ref="inlinegraphic"/>
        <xs:element ref="inlinemediaobject"/>
        <xs:element ref="emphasis"/>
      </xs:choice>
      <xs:attributeGroup ref="trademark.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of trademark.element -->
  <!-- Class: More precisely identifies the item the element names -->
  <xs:attributeGroup name="trademark.attlist">
    <xs:attribute name="class" default="trade">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="service"/>
          <xs:enumeration value="trade"/>
          <xs:enumeration value="registered"/>
          <xs:enumeration value="copyright"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="trademark.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of trademark.attlist -->
  <!-- end of trademark.module -->
  <xs:attributeGroup name="wordasword.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A word meant specifically as a word and not representing anything else. -->
  <xs:element name="wordasword" substitutionGroup="gen.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="word.char.mix"/>
      <xs:attributeGroup ref="wordasword.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of wordasword.element -->
  <xs:attributeGroup name="wordasword.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="wordasword.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of wordasword.attlist -->
  <!-- end of wordasword.module -->
  <!-- Links and cross-references ........................................... -->
  <xs:attributeGroup name="link.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A hypertext link. -->
  <xs:element name="link" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="link.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of link.element -->
  <!--
    Endterm: ID of element containing text that is to be
    fetched from elsewhere in the document to appear as
    the content of this element
  -->
  <!-- to linked-to object -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="link.attlist">
    <xs:attribute name="endterm" type="xs:IDREF"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="link.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of link.attlist -->
  <!-- end of link.module -->
  <xs:attributeGroup name="olink.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A link that addresses its target indirectly, through an entity. -->
  <xs:element name="olink" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="olink.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of olink.element -->
  <!-- TargetDocEnt: Name of an entity to be the target of the link -->
  <!--
    LinkMode: ID of a ModeSpec containing instructions for
    operating on the entity named by TargetDocEnt
  -->
  <!-- LocalInfo: Information that may be passed to ModeSpec -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="olink.attlist">
    <xs:attribute name="targetdocent" type="xs:ENTITY"/>
    <xs:attribute name="linkmode" type="xs:IDREF"/>
    <xs:attribute name="localinfo"/>
    <xs:attribute name="type"/>
    <xs:attribute name="targetdoc"/>
    <xs:attribute name="targetptr"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="olink.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of olink.attlist -->
  <!-- end of olink.module -->
  <xs:attributeGroup name="ulink.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A link that addresses its target by means of a URL (Uniform Resource Locator). -->
  <xs:element name="ulink" substitutionGroup="link.char.class">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="para.char.mix"/>
      <xs:attributeGroup ref="ulink.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of ulink.element -->
  <!-- URL: uniform resource locator; the target of the ULink -->
  <!-- Type: Freely assignable parameter -->
  <xs:attributeGroup name="ulink.attlist">
    <xs:attribute name="url" use="required"/>
    <xs:attribute name="type"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="ulink.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of ulink.attlist -->
  <!-- end of ulink.module -->
  <xs:attributeGroup name="footnoteref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A cross reference to a footnote (a footnote mark). -->
  <xs:element name="footnoteref" substitutionGroup="xref.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="footnoteref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of footnoteref.element -->
  <!-- to footnote content supplied elsewhere -->
  <xs:attributeGroup name="footnoteref.attlist">
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="label.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="footnoteref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of footnoteref.attlist -->
  <!-- end of footnoteref.module -->
  <xs:attributeGroup name="xref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A cross reference to another part of the document. -->
  <xs:element name="xref" substitutionGroup="xref.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="xref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of xref.element -->
  <!--
    Endterm: ID of element containing text that is to be
    fetched from elsewhere in the document to appear as
    the content of this element
  -->
  <!-- to linked-to object -->
  <xs:attributeGroup name="xref.attlist">
    <xs:attribute name="endterm" type="xs:IDREF"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="xref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of xref.attlist -->
  <!-- end of xref.module -->
  <xs:attributeGroup name="biblioref.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A cross reference to a bibliographic entry. -->
  <xs:element name="biblioref" substitutionGroup="xref.char.class">
    <xs:complexType>
      <xs:attributeGroup ref="biblioref.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of biblioref.element -->
  <xs:attributeGroup name="biblioref.attlist">
    <xs:attribute name="endterm" type="xs:IDREF"/>
    <xs:attribute name="xrefstyle"/>
    <xs:attribute name="units"/>
    <xs:attribute name="begin"/>
    <xs:attribute name="end"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="linkendreq.attrib"/>
    <xs:attributeGroup ref="biblioref.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of biblioref.attlist -->
  <!-- end of biblioref.module -->
  <!-- Ubiquitous elements .................................................. -->
  <xs:attributeGroup name="anchor.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A spot in the document. -->
  <xs:element name="anchor">
    <xs:complexType>
      <xs:attributeGroup ref="anchor.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of anchor.element -->
  <!-- required -->
  <!-- replaces Lang -->
  <xs:attributeGroup name="anchor.attlist">
    <xs:attributeGroup ref="idreq.attrib"/>
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="remap.attrib"/>
    <xs:attributeGroup ref="xreflabel.attrib"/>
    <xs:attributeGroup ref="revisionflag.attrib"/>
    <xs:attributeGroup ref="effectivity.attrib"/>
    <xs:attributeGroup ref="anchor.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of anchor.attlist -->
  <!-- end of anchor.module -->
  <xs:attributeGroup name="beginpage.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The location of a page break in a print version of the document. -->
  <xs:element name="beginpage">
    <xs:complexType>
      <xs:attributeGroup ref="beginpage.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of beginpage.element -->
  <!-- PageNum: Number of page that begins at this point -->
  <xs:attributeGroup name="beginpage.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="beginpage.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of beginpage.attlist -->
  <!-- end of beginpage.module -->
  <!--
    IndexTerms appear in the text flow for generating or linking an
    index.
  -->
  <xs:attributeGroup name="indexterm.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:A wrapper for terms to be indexed. -->
  <xs:element name="indexterm" substitutionGroup="ndxterm.class"/>
  <!-- end of indexterm.element -->
  <!--
    Scope: Indicates which generated indices the IndexTerm
    should appear in: Global (whole document set), Local (this
    document only), or All (both)
  -->
  <!--
    Significance: Whether this IndexTerm is the most pertinent
    of its series (Preferred) or not (Normal, the default)
  -->
  <!--
    Class: Indicates type of IndexTerm; default is Singular,
    or EndOfRange if StartRef is supplied; StartOfRange value
    must be supplied explicitly on starts of ranges
  -->
  <!--
    StartRef: ID of the IndexTerm that starts the indexing
    range ended by this IndexTerm
  -->
  <!--
    Zone: IDs of the elements to which the IndexTerm applies,
    and indicates that the IndexTerm applies to those entire
    elements rather than the point at which the IndexTerm
    occurs
  -->
  <xs:attributeGroup name="indexterm.attlist">
    <xs:attributeGroup ref="pagenum.attrib"/>
    <xs:attribute name="scope">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="all"/>
          <xs:enumeration value="global"/>
          <xs:enumeration value="local"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="significance" default="normal">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="preferred"/>
          <xs:enumeration value="normal"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="class">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="singular"/>
          <xs:enumeration value="startofrange"/>
          <xs:enumeration value="endofrange"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="startref" type="xs:IDREF"/>
    <xs:attribute name="zone" type="xs:IDREFS"/>
    <xs:attribute name="type"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="indexterm.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of indexterm.attlist -->
  <!-- end of indexterm.module -->
  <xs:attributeGroup name="primsecter.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:The primary word or phrase under which an index term should be sorted. -->
  <xs:element name="primary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="primary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of primary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="primary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of primary.attlist -->
  <!-- doc:A secondary word or phrase in an index term. -->
  <xs:element name="secondary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="secondary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of secondary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="secondary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of secondary.attlist -->
  <!-- doc:A tertiary word or phrase in an index term. -->
  <xs:element name="tertiary">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="tertiary.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of tertiary.element -->
  <!--
    SortAs: Alternate sort string for index sorting, e.g.,
    "fourteen" for an element containing "14"
  -->
  <xs:attributeGroup name="tertiary.attlist">
    <xs:attribute name="sortas"/>
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="primsecter.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of tertiary.attlist -->
  <!-- end of primsecter.module -->
  <xs:attributeGroup name="seeseealso.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- doc:Part of an index term directing the reader instead to another entry in the index. -->
  <xs:element name="see">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="see.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of see.element -->
  <xs:attributeGroup name="see.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeseealso.role.attrib"/>
  </xs:attributeGroup>
  <!-- end of see.attlist -->
  <!-- doc:Part of an index term directing the reader also to another entry in the index. -->
  <xs:element name="seealso">
    <xs:complexType mixed="true">
      <xs:group minOccurs="0" maxOccurs="unbounded" ref="ndxterm.char.mix"/>
      <xs:attributeGroup ref="seealso.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- end of seealso.element -->
  <xs:attributeGroup name="seealso.attlist">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attributeGroup ref="seeseealso.role.attrib"/>
  </xs:attributeGroup>
</xs:schema>
<!-- end of seealso.attlist -->
<!-- end of seeseealso.module -->
<!-- end of indexterm.content.module -->
<!-- End of DocBook XML information pool module V4.5 ...................... -->
<!-- ...................................................................... -->
 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 <?xml version="1.0" encoding="UTF-8"?>
<!-- ...................................................................... -->
<!-- DocBook XML HTML Table Module V4.5 ................................... -->
<!-- File htmltblx.mod .................................................... -->
<!--
  Copyright 2003-2006 ArborText, Inc., Norman Walsh, Sun Microsystems,
  Inc., and the Organization for the Advancement of Structured Information
  Standards (OASIS).
  
  $Id: htmltblx.mod 6340 2006-10-03 13:23:24Z nwalsh $
  
  Permission to use, copy, modify and distribute the DocBook XML DTD
  and its accompanying documentation for any purpose and without fee
  is hereby granted in perpetuity, provided that the above copyright
  notice and this paragraph appear in all copies.  The copyright
  holders make no representation about the suitability of the DTD for
  any purpose.  It is provided "as is" without expressed or implied
  warranty.
  
  If you modify the DocBook XML DTD in any way, except for declaring and
  referencing additional sets of general entities and declaring
  additional notations, label your DTD as a variant of DocBook.  See
  the maintenance documentation for more information.
  
  Please direct all questions, bug reports, or suggestions for
  changes to the docbook@lists.oasis-open.org mailing list. For more
  information, see http://www.oasis-open.org/docbook/.
-->
<!-- ...................................................................... -->
<!--
  This module contains the definitions for elements that are
  isomorphic to the HTML elements. One could argue we should
  instead have based ourselves on the XHTML Table Module, but the
  HTML one is more like what browsers are likely to accept today
  and users are likely to use.
  
  This module has been developed for use with the DocBook V4.5
  "union table model" in which elements and attlists common to both
  models are defined (as the union) in the CALS table module by
  setting various parameter entities appropriately in this file.
  
  In DTD driver files referring to this module, please use an entity
  declaration that uses the public identifier shown below:
  
  <!ENTITY % htmltbl PUBLIC
  "-//OASIS//ELEMENTS DocBook XML HTML Tables V4.5//EN"
  "htmltblx.mod">
  %htmltbl;
  
  See the documentation for detailed information on the parameter
  entity and module scheme used in DocBook, customizing DocBook and
  planning for interchange, and changes made since the last release
  of DocBook.
-->
<!-- ======================= XHTML Tables ======================================= -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  <xs:attributeGroup name="html.coreattrs">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attribute name="class"/>
    <xs:attribute name="style"/>
    <xs:attribute name="title"/>
  </xs:attributeGroup>
  <!-- Does not contain lang or dir because they are in %common.attribs -->
  <xs:attributeGroup name="i18n">
    <xs:attribute ref="xml:lang"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="events">
    <xs:attribute name="onclick"/>
    <xs:attribute name="ondblclick"/>
    <xs:attribute name="onmousedown"/>
    <xs:attribute name="onmouseup"/>
    <xs:attribute name="onmouseover"/>
    <xs:attribute name="onmousemove"/>
    <xs:attribute name="onmouseout"/>
    <xs:attribute name="onkeypress"/>
    <xs:attribute name="onkeydown"/>
    <xs:attribute name="onkeyup"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="attrs">
    <xs:attributeGroup ref="html.coreattrs"/>
    <xs:attributeGroup ref="i18n"/>
    <xs:attributeGroup ref="events"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="cellhalign">
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="right"/>
          <xs:enumeration value="justify"/>
          <xs:enumeration value="char"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="char"/>
    <xs:attribute name="charoff"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="cellvalign">
    <xs:attribute name="valign">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="top"/>
          <xs:enumeration value="middle"/>
          <xs:enumeration value="bottom"/>
          <xs:enumeration value="baseline"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <!-- doc:A group of columns in an HTML table. -->
  <xs:element name="colgroup">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="col"/>
      </xs:sequence>
      <xs:attributeGroup ref="colgroup.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- doc:Specifications for a column in an HTML table. -->
  <xs:element name="col">
    <xs:complexType>
      <xs:attributeGroup ref="col.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- doc:A row in an HTML table. -->
  <xs:element name="tr">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element ref="th"/>
        <xs:element ref="td"/>
      </xs:choice>
      <xs:attributeGroup ref="tr.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- doc:A table header entry in an HTML table. -->
  <xs:element name="th">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:group ref="tabentry.mix"/>
        <xs:element ref="table"/>
        <xs:element ref="informaltable"/>
      </xs:choice>
      <xs:attributeGroup ref="th.attlist"/>
    </xs:complexType>
  </xs:element>
  <!-- doc:A table ntry in an HTML table. -->
  <xs:element name="td">
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="para.char.mix"/>
        <xs:group ref="tabentry.mix"/>
        <xs:element ref="table"/>
        <xs:element ref="informaltable"/>
      </xs:choice>
      <xs:attributeGroup ref="td.attlist"/>
    </xs:complexType>
  </xs:element>
  <xs:attributeGroup name="colgroup.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="span" default="1"/>
    <xs:attribute name="width"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="col.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="span" default="1"/>
    <xs:attribute name="width"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="tr.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
    <xs:attribute name="bgcolor"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="th.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="abbr"/>
    <xs:attribute name="axis"/>
    <xs:attribute name="headers" type="xs:IDREFS"/>
    <xs:attribute name="scope">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="row"/>
          <xs:enumeration value="col"/>
          <xs:enumeration value="rowgroup"/>
          <xs:enumeration value="colgroup"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rowspan" default="1"/>
    <xs:attribute name="colspan" default="1"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
    <xs:attribute name="nowrap">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="nowrap"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="bgcolor"/>
    <xs:attribute name="width"/>
    <xs:attribute name="height"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="td.attlist">
    <xs:attributeGroup ref="attrs"/>
    <xs:attribute name="abbr"/>
    <xs:attribute name="axis"/>
    <xs:attribute name="headers" type="xs:IDREFS"/>
    <xs:attribute name="scope">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="row"/>
          <xs:enumeration value="col"/>
          <xs:enumeration value="rowgroup"/>
          <xs:enumeration value="colgroup"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="rowspan" default="1"/>
    <xs:attribute name="colspan" default="1"/>
    <xs:attributeGroup ref="cellhalign"/>
    <xs:attributeGroup ref="cellvalign"/>
    <xs:attribute name="nowrap">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="nowrap"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="bgcolor"/>
    <xs:attribute name="width"/>
    <xs:attribute name="height"/>
  </xs:attributeGroup>
  <!-- ====================================================== -->
  <!--
    Set up to read in the CALS model configured to
    merge with the XHTML table model
  -->
  <!-- ====================================================== -->
  <xs:attributeGroup name="tables.role.attrib">
    <xs:attributeGroup ref="role.attrib"/>
  </xs:attributeGroup>
  <!-- Add label and role attributes to table and informaltable -->
  <xs:attributeGroup name="bodyatt">
    <xs:attribute name="floatstyle"/>
    <xs:attribute name="rowheader">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="firstcol"/>
          <xs:enumeration value="norowheader"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attributeGroup ref="label.attrib"/>
  </xs:attributeGroup>
  <!--
    Add common attributes to Table, TGroup, TBody, THead, TFoot, Row, 
    EntryTbl, and Entry (and InformalTable element).
  -->
  <xs:attributeGroup name="secur">
    <xs:attributeGroup ref="common.attrib"/>
    <xs:attribute name="class"/>
    <xs:attribute name="style"/>
    <xs:attribute name="title"/>
    <xs:attributeGroup ref="i18n"/>
    <xs:attributeGroup ref="events"/>
    <xs:attributeGroup ref="tables.role.attrib"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="common.table.attribs">
    <xs:attributeGroup ref="bodyatt"/>
    <xs:attributeGroup ref="secur"/>
  </xs:attributeGroup>
  <!-- Content model for Table (that also allows HTML tables) -->
  <xs:complexType name="tbl.table.mdl">
    <xs:choice>
      <xs:sequence>
        <xs:element minOccurs="0" ref="blockinfo"/>
        <xs:group ref="formalobject.title.content"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="ndxterm.class"/>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="textobject"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="graphic"/>
          <xs:element maxOccurs="unbounded" ref="mediaobject"/>
          <xs:element maxOccurs="unbounded" ref="tgroup"/>
        </xs:choice>
      </xs:sequence>
      <xs:sequence>
        <xs:element ref="caption"/>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="col"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="colgroup"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="thead"/>
        <xs:element minOccurs="0" ref="tfoot"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="tbody"/>
          <xs:element maxOccurs="unbounded" ref="tr"/>
        </xs:choice>
      </xs:sequence>
    </xs:choice>
  </xs:complexType>
  <xs:group name="informal.tbl.table.mdl">
    <xs:choice>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="textobject"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="graphic"/>
          <xs:element maxOccurs="unbounded" ref="mediaobject"/>
          <xs:element maxOccurs="unbounded" ref="tgroup"/>
        </xs:choice>
      </xs:sequence>
      <xs:sequence>
        <xs:choice>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="col"/>
          <xs:element minOccurs="0" maxOccurs="unbounded" ref="colgroup"/>
        </xs:choice>
        <xs:element minOccurs="0" ref="thead"/>
        <xs:element minOccurs="0" ref="tfoot"/>
        <xs:choice>
          <xs:element maxOccurs="unbounded" ref="tbody"/>
          <xs:element maxOccurs="unbounded" ref="tr"/>
        </xs:choice>
      </xs:sequence>
    </xs:choice>
  </xs:group>
  <!-- Attributes for Table (including HTML ones) -->
  <!-- N.B. rules = (none | groups | rows | cols | all) but it can't be spec'd -->
  <!-- that way because 'all' already occurs in a different enumeration in -->
  <!-- CALS tables (frame). -->
  <xs:attributeGroup name="tbl.table.att">
    <xs:attribute name="tabstyle"/>
    <xs:attribute name="tocentry" type="yesorno.attvals"/>
    <xs:attribute name="shortentry" type="yesorno.attvals"/>
    <xs:attribute name="orient">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="port"/>
          <xs:enumeration value="land"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="pgwide" type="yesorno.attvals"/>
    <xs:attribute name="summary"/>
    <xs:attribute name="width"/>
    <xs:attribute name="border"/>
    <xs:attribute name="rules"/>
    <xs:attribute name="cellspacing"/>
    <xs:attribute name="cellpadding"/>
    <xs:attribute name="align">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="left"/>
          <xs:enumeration value="center"/>
          <xs:enumeration value="right"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name="bgcolor"/>
  </xs:attributeGroup>
  <xs:simpleType name="tbl.frame.attval">
    <xs:restriction base="xs:token">
      <xs:enumeration value="void"/>
      <xs:enumeration value="above"/>
      <xs:enumeration value="below"/>
      <xs:enumeration value="hsides"/>
      <xs:enumeration value="lhs"/>
      <xs:enumeration value="rhs"/>
      <xs:enumeration value="vsides"/>
      <xs:enumeration value="box"/>
      <xs:enumeration value="border"/>
      <xs:enumeration value="top"/>
      <xs:enumeration value="bottom"/>
      <xs:enumeration value="topbot"/>
      <xs:enumeration value="all"/>
      <xs:enumeration value="sides"/>
      <xs:enumeration value="none"/>
    </xs:restriction>
  </xs:simpleType>
  <!-- Allow either objects or inlines; beware of REs between elements. -->
  <xs:group name="tbl.entry.mdl">
    <xs:choice>
      <xs:group ref="para.char.mix"/>
      <xs:group ref="tabentry.mix"/>
    </xs:choice>
  </xs:group>
  <!--
    thead, tfoot, and tbody are defined in both table models,
    so we set up parameter entities to define union models for them
  -->
  <xs:complexType name="tbl.hdft.mdl">
    <xs:choice>
      <xs:element maxOccurs="unbounded" ref="tr"/>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="colspec"/>
        <xs:element maxOccurs="unbounded" ref="row"/>
      </xs:sequence>
    </xs:choice>
  </xs:complexType>
  <xs:complexType name="tbl.tbody.mdl">
    <xs:choice>
      <xs:element maxOccurs="unbounded" ref="tr"/>
      <xs:element maxOccurs="unbounded" ref="row"/>
    </xs:choice>
  </xs:complexType>
</xs:schema>
<!-- End of DocBook XML HTML Table Module V4.5 ............................ -->
<!-- ...................................................................... -->
 PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHhzOnNjaGVtYSB4bWxuczp4cz0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEiIGVsZW1lbnRGb3JtRGVmYXVsdD0icXVhbGlmaWVkIiB0YXJnZXROYW1lc3BhY2U9Imh0dHA6Ly93d3cudzMub3JnL1hNTC8xOTk4L25hbWVzcGFjZSI+CiAgPHhzOmltcG9ydCBzY2hlbWFMb2NhdGlvbj0iZG9jYm9vay54c2QiLz4KICA8eHM6YXR0cmlidXRlIG5hbWU9ImJhc2UiLz4KICA8eHM6YXR0cmlidXRlIG5hbWU9InNwYWNlIj4KICAgIDx4czpzaW1wbGVUeXBlPgogICAgICA8eHM6cmVzdHJpY3Rpb24gYmFzZT0ieHM6dG9rZW4iPgogICAgICAgIDx4czplbnVtZXJhdGlvbiB2YWx1ZT0icHJlc2VydmUiLz4KICAgICAgPC94czpyZXN0cmljdGlvbj4KICAgIDwveHM6c2ltcGxlVHlwZT4KICA8L3hzOmF0dHJpYnV0ZT4KICA8eHM6YXR0cmlidXRlIG5hbWU9ImxhbmciIHR5cGU9InhzOk5NVE9LRU4iLz4KPC94czpzY2hlbWE+Cg== <?xml version="1.0" encoding="UTF-8" ?>
<!--

Copyright 2001 - 2005, International Business Machines Corporation and Microsoft Corporation
All Rights Reserved

License for WSDL Schema Files

The Authors grant permission to copy and distribute the WSDL Schema
Files in any medium without fee or royalty as long as this notice and
license are distributed with them.  The originals of these files can
be located at:

http://schemas.xmlsoap.org/wsdl/2003-02-11.xsd

THESE SCHEMA FILES ARE PROVIDED "AS IS," AND THE AUTHORS MAKE NO REPRESENTATIONS
OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THESE FILES, INCLUDING, BUT NOT
LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
NON-INFRINGEMENT OR TITLE.  THE AUTHORS WILL NOT BE LIABLE FOR ANY DIRECT,
INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR
RELATING TO ANY USE OR DISTRIBUTION OF THESE FILES.

The name and trademarks of the Authors may NOT be used in any manner,
including advertising or publicity pertaining to these files or any program
or service that uses these files, written prior permission.  Title to copyright
in these files will at all times remain with the Authors.

No other rights are granted by implication, estoppel or otherwise.


-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
           targetNamespace="http://schemas.xmlsoap.org/wsdl/"
           elementFormDefault="qualified" >

  <xs:complexType mixed="true" name="tDocumentation" >
    <xs:sequence>
      <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax" />
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="tDocumented" >
    <xs:annotation>
      <xs:documentation>
      This type is extended by  component types to allow them to be documented
      </xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="documentation" type="wsdl:tDocumentation" minOccurs="0" />
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="tExtensibleAttributesDocumented" abstract="true" >
    <xs:complexContent>
      <xs:extension base="wsdl:tDocumented" >
        <xs:annotation>
          <xs:documentation>
          This type is extended by component types to allow attributes from other namespaces to be added.
          </xs:documentation>
        </xs:annotation>
        <xs:anyAttribute namespace="##other" processContents="lax" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tExtensibleDocumented" abstract="true" >
    <xs:complexContent>
      <xs:extension base="wsdl:tDocumented" >
        <xs:annotation>
          <xs:documentation>
          This type is extended by component types to allow elements from other namespaces to be added.
          </xs:documentation>
        </xs:annotation>
        <xs:sequence>
          <xs:any namespace="##other" minOccurs="0" maxOccurs="unbounded" processContents="lax" />
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:element name="definitions" type="wsdl:tDefinitions" >
    <xs:key name="message" >
      <xs:selector xpath="wsdl:message" />
      <xs:field xpath="@name" />
    </xs:key>
    <xs:key name="portType" >
      <xs:selector xpath="wsdl:portType" />
      <xs:field xpath="@name" />
    </xs:key>
    <xs:key name="binding" >
      <xs:selector xpath="wsdl:binding" />
      <xs:field xpath="@name" />
    </xs:key>
    <xs:key name="service" >
      <xs:selector xpath="wsdl:service" />
      <xs:field xpath="@name" />
    </xs:key>
    <xs:key name="import" >
      <xs:selector xpath="wsdl:import" />
      <xs:field xpath="@namespace" />
    </xs:key>
  </xs:element>

  <xs:group name="anyTopLevelOptionalElement" >
    <xs:annotation>
      <xs:documentation>
      Any top level optional element allowed to appear more then once - any child of definitions element except wsdl:types. Any extensibility element is allowed in any place.
      </xs:documentation>
    </xs:annotation>
    <xs:choice>
      <xs:element name="import" type="wsdl:tImport" />
      <xs:element name="types" type="wsdl:tTypes" />
      <xs:element name="message"  type="wsdl:tMessage" >
        <xs:unique name="part" >
          <xs:selector xpath="wsdl:part" />
          <xs:field xpath="@name" />
        </xs:unique>
      </xs:element>
      <xs:element name="portType" type="wsdl:tPortType" />
      <xs:element name="binding"  type="wsdl:tBinding" />
      <xs:element name="service"  type="wsdl:tService" >
        <xs:unique name="port" >
          <xs:selector xpath="wsdl:port" />
          <xs:field xpath="@name" />
        </xs:unique>
	  </xs:element>
    </xs:choice>
  </xs:group>

  <xs:complexType name="tDefinitions" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:sequence>
          <xs:group ref="wsdl:anyTopLevelOptionalElement"  minOccurs="0"   maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="targetNamespace" type="xs:anyURI" use="optional" />
        <xs:attribute name="name" type="xs:NCName" use="optional" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tImport" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleAttributesDocumented" >
        <xs:attribute name="namespace" type="xs:anyURI" use="required" />
        <xs:attribute name="location" type="xs:anyURI" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tTypes" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" />
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tMessage" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:sequence>
          <xs:element name="part" type="wsdl:tPart" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tPart" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleAttributesDocumented" >
        <xs:attribute name="name" type="xs:NCName" use="required" />
        <xs:attribute name="element" type="xs:QName" use="optional" />
<!--
Removed by OTOBO:
To be aligned with Literal style
        <xs:attribute name="type" type="xs:QName" use="optional" />
-->
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tPortType" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleAttributesDocumented" >
        <xs:sequence>
          <xs:element name="operation" type="wsdl:tOperation" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tOperation" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
	    <xs:sequence>
          <xs:choice>
            <xs:group ref="wsdl:request-response-or-one-way-operation" />
            <xs:group ref="wsdl:solicit-response-or-notification-operation" />
          </xs:choice>
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
        <xs:attribute name="parameterOrder" type="xs:NMTOKENS" use="optional" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:group name="request-response-or-one-way-operation" >
    <xs:sequence>
      <xs:element name="input" type="wsdl:tParam" />
	  <xs:sequence minOccurs='0' >
	    <xs:element name="output" type="wsdl:tParam" />
		<xs:element name="fault" type="wsdl:tFault" minOccurs="0" maxOccurs="unbounded" />
      </xs:sequence>
    </xs:sequence>
  </xs:group>

  <xs:group name="solicit-response-or-notification-operation" >
    <xs:sequence>
      <xs:element name="output" type="wsdl:tParam" />
	  <xs:sequence minOccurs='0' >
	    <xs:element name="input" type="wsdl:tParam" />
		<xs:element name="fault" type="wsdl:tFault" minOccurs="0" maxOccurs="unbounded" />
	  </xs:sequence>
    </xs:sequence>
  </xs:group>

  <xs:complexType name="tParam" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleAttributesDocumented" >
        <xs:attribute name="name" type="xs:NCName" use="optional" />
        <xs:attribute name="message" type="xs:QName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tFault" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleAttributesDocumented" >
        <xs:attribute name="name" type="xs:NCName"  use="required" />
        <xs:attribute name="message" type="xs:QName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tBinding" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:sequence>
          <xs:element name="operation" type="wsdl:tBindingOperation" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
        <xs:attribute name="type" type="xs:QName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tBindingOperationMessage" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:attribute name="name" type="xs:NCName" use="optional" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tBindingOperationFault" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:attribute name="name" type="xs:NCName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tBindingOperation" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:sequence>
          <xs:element name="input" type="wsdl:tBindingOperationMessage" minOccurs="0" />
          <xs:element name="output" type="wsdl:tBindingOperationMessage" minOccurs="0" />
          <xs:element name="fault" type="wsdl:tBindingOperationFault" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tService" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:sequence>
          <xs:element name="port" type="wsdl:tPort" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tPort" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:attribute name="name" type="xs:NCName" use="required" />
        <xs:attribute name="binding" type="xs:QName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:attribute name="arrayType" type="xs:string" />
  <xs:attribute name="required" type="xs:boolean" />
  <xs:complexType name="tExtensibilityElement" abstract="true" >
    <xs:attribute ref="wsdl:required" use="optional" />
  </xs:complexType>

</xs:schema> <?xml version="1.0" encoding="UTF-8" ?>
<!--

Copyright 2001 - 2005, International Business Machines Corporation and Microsoft Corporation
All Rights Reserved

License for WSDL Schema Files

The Authors grant permission to copy and distribute the WSDL Schema
Files in any medium without fee or royalty as long as this notice and
license are distributed with them.  The originals of these files can
be located at:

http://schemas.xmlsoap.org/wsdl/2003-02-11.xsd

THESE SCHEMA FILES ARE PROVIDED "AS IS," AND THE AUTHORS MAKE NO REPRESENTATIONS
OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THESE FILES, INCLUDING, BUT NOT
LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
NON-INFRINGEMENT OR TITLE.  THE AUTHORS WILL NOT BE LIABLE FOR ANY DIRECT,
INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR
RELATING TO ANY USE OR DISTRIBUTION OF THESE FILES.

The name and trademarks of the Authors may NOT be used in any manner,
including advertising or publicity pertaining to these files or any program
or service that uses these files, written prior permission.  Title to copyright
in these files will at all times remain with the Authors.

No other rights are granted by implication, estoppel or otherwise.


-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
           targetNamespace="http://schemas.xmlsoap.org/wsdl/"
           elementFormDefault="qualified" >

  <xs:complexType mixed="true" name="tDocumentation" >
    <xs:sequence>
      <xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax" />
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="tDocumented" >
    <xs:annotation>
      <xs:documentation>
      This type is extended by  component types to allow them to be documented
      </xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="documentation" type="wsdl:tDocumentation" minOccurs="0" />
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="tExtensibleAttributesDocumented" abstract="true" >
    <xs:complexContent>
      <xs:extension base="wsdl:tDocumented" >
        <xs:annotation>
          <xs:documentation>
          This type is extended by component types to allow attributes from other namespaces to be added.
          </xs:documentation>
        </xs:annotation>
        <xs:anyAttribute namespace="##other" processContents="lax" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tExtensibleDocumented" abstract="true" >
    <xs:complexContent>
      <xs:extension base="wsdl:tDocumented" >
        <xs:annotation>
          <xs:documentation>
          This type is extended by component types to allow elements from other namespaces to be added.
          </xs:documentation>
        </xs:annotation>
        <xs:sequence>
          <xs:any namespace="##other" minOccurs="0" maxOccurs="unbounded" processContents="lax" />
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:element name="definitions" type="wsdl:tDefinitions" >
    <xs:key name="message" >
      <xs:selector xpath="wsdl:message" />
      <xs:field xpath="@name" />
    </xs:key>
    <xs:key name="portType" >
      <xs:selector xpath="wsdl:portType" />
      <xs:field xpath="@name" />
    </xs:key>
    <xs:key name="binding" >
      <xs:selector xpath="wsdl:binding" />
      <xs:field xpath="@name" />
    </xs:key>
    <xs:key name="service" >
      <xs:selector xpath="wsdl:service" />
      <xs:field xpath="@name" />
    </xs:key>
    <xs:key name="import" >
      <xs:selector xpath="wsdl:import" />
      <xs:field xpath="@namespace" />
    </xs:key>
  </xs:element>

  <xs:group name="anyTopLevelOptionalElement" >
    <xs:annotation>
      <xs:documentation>
      Any top level optional element allowed to appear more then once - any child of definitions element except wsdl:types. Any extensibility element is allowed in any place.
      </xs:documentation>
    </xs:annotation>
    <xs:choice>
      <xs:element name="import" type="wsdl:tImport" />
      <xs:element name="types" type="wsdl:tTypes" />
      <xs:element name="message"  type="wsdl:tMessage" >
        <xs:unique name="part" >
          <xs:selector xpath="wsdl:part" />
          <xs:field xpath="@name" />
        </xs:unique>
      </xs:element>
      <xs:element name="portType" type="wsdl:tPortType" />
      <xs:element name="binding"  type="wsdl:tBinding" />
      <xs:element name="service"  type="wsdl:tService" >
        <xs:unique name="port" >
          <xs:selector xpath="wsdl:port" />
          <xs:field xpath="@name" />
        </xs:unique>
	  </xs:element>
    </xs:choice>
  </xs:group>

  <xs:complexType name="tDefinitions" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:sequence>
          <xs:group ref="wsdl:anyTopLevelOptionalElement"  minOccurs="0"   maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="targetNamespace" type="xs:anyURI" use="optional" />
        <xs:attribute name="name" type="xs:NCName" use="optional" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tImport" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleAttributesDocumented" >
        <xs:attribute name="namespace" type="xs:anyURI" use="required" />
        <xs:attribute name="location" type="xs:anyURI" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tTypes" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" />
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tMessage" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:sequence>
          <xs:element name="part" type="wsdl:tPart" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tPart" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleAttributesDocumented" >
        <xs:attribute name="name" type="xs:NCName" use="required" />
        <xs:attribute name="element" type="xs:QName" use="optional" />
        <xs:attribute name="type" type="xs:QName" use="optional" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tPortType" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleAttributesDocumented" >
        <xs:sequence>
          <xs:element name="operation" type="wsdl:tOperation" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tOperation" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
	    <xs:sequence>
          <xs:choice>
            <xs:group ref="wsdl:request-response-or-one-way-operation" />
            <xs:group ref="wsdl:solicit-response-or-notification-operation" />
          </xs:choice>
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
        <xs:attribute name="parameterOrder" type="xs:NMTOKENS" use="optional" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:group name="request-response-or-one-way-operation" >
    <xs:sequence>
      <xs:element name="input" type="wsdl:tParam" />
	  <xs:sequence minOccurs='0' >
	    <xs:element name="output" type="wsdl:tParam" />
		<xs:element name="fault" type="wsdl:tFault" minOccurs="0" maxOccurs="unbounded" />
      </xs:sequence>
    </xs:sequence>
  </xs:group>

  <xs:group name="solicit-response-or-notification-operation" >
    <xs:sequence>
      <xs:element name="output" type="wsdl:tParam" />
	  <xs:sequence minOccurs='0' >
	    <xs:element name="input" type="wsdl:tParam" />
		<xs:element name="fault" type="wsdl:tFault" minOccurs="0" maxOccurs="unbounded" />
	  </xs:sequence>
    </xs:sequence>
  </xs:group>

  <xs:complexType name="tParam" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleAttributesDocumented" >
        <xs:attribute name="name" type="xs:NCName" use="optional" />
        <xs:attribute name="message" type="xs:QName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tFault" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleAttributesDocumented" >
        <xs:attribute name="name" type="xs:NCName"  use="required" />
        <xs:attribute name="message" type="xs:QName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tBinding" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:sequence>
          <xs:element name="operation" type="wsdl:tBindingOperation" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
        <xs:attribute name="type" type="xs:QName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tBindingOperationMessage" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:attribute name="name" type="xs:NCName" use="optional" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tBindingOperationFault" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:attribute name="name" type="xs:NCName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tBindingOperation" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:sequence>
          <xs:element name="input" type="wsdl:tBindingOperationMessage" minOccurs="0" />
          <xs:element name="output" type="wsdl:tBindingOperationMessage" minOccurs="0" />
          <xs:element name="fault" type="wsdl:tBindingOperationFault" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tService" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:sequence>
          <xs:element name="port" type="wsdl:tPort" minOccurs="0" maxOccurs="unbounded" />
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="tPort" >
    <xs:complexContent>
      <xs:extension base="wsdl:tExtensibleDocumented" >
        <xs:attribute name="name" type="xs:NCName" use="required" />
        <xs:attribute name="binding" type="xs:QName" use="required" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:attribute name="arrayType" type="xs:string" />
  <xs:attribute name="required" type="xs:boolean" />
  <xs:complexType name="tExtensibilityElement" abstract="true" >
    <xs:attribute ref="wsdl:required" use="optional" />
  </xs:complexType>

</xs:schema> <?xml version="1.0" encoding="UTF-8" standalone="no"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
    <xs:import namespace="http://www.w3.org/XML/1998/namespace"/>

    <xs:include schemaLocation="Database.xsd"/>

    <xs:element name="otobo_package">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="Name" />
                <xs:element ref="Version"/>
                <xs:element ref="Framework" maxOccurs="unbounded"/>
                <xs:choice minOccurs="0" maxOccurs="unbounded">
                    <xs:element ref="PackageRequired"/>
                    <xs:element ref="ModuleRequired"/>
                </xs:choice>
                <xs:element ref="Vendor"/>
                <xs:element ref="URL"/>
                <xs:element ref="License"/>
                <xs:element ref="Description" maxOccurs="unbounded" />

                <xs:element ref="PackageIsVisible" minOccurs="0" />
                <xs:element ref="PackageIsDownloadable" minOccurs="0" />
                <xs:element ref="PackageIsBuildable" minOccurs="0" />
                <xs:element ref="PackageIsRemovable" minOccurs="0" />
                <xs:element ref="PackageAllowDirectUpdate" minOccurs="0" />

                <xs:element ref="ChangeLog" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="OS" minOccurs="0" maxOccurs="unbounded" />
                <xs:element ref="Filelist"/>
                <xs:choice minOccurs="0" maxOccurs="unbounded">
                    <xs:element ref="IntroInstall"/>
                    <xs:element ref="IntroUninstall"/>
                    <xs:element ref="IntroReinstall"/>
                    <xs:element ref="IntroUpgrade"/>
                    <xs:element ref="CodeInstall"/>
                    <xs:element ref="CodeUpgrade"/>
                    <xs:element ref="CodeUninstall"/>
                    <xs:element ref="CodeReinstall"/>
                    <xs:element ref="DatabaseInstall"/>
                    <xs:element ref="DatabaseUpgrade"/>
                    <xs:element ref="DatabaseReinstall"/>
                    <xs:element ref="DatabaseUninstall"/>
                    <xs:element ref="PackageMerge"/>
                </xs:choice>
            </xs:sequence>
            <xs:attribute name="version" use="required" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="ChangeLog">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Date" use="required" type="xs:token"/>
                    <xs:attribute name="Version" use="required" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <xs:element name="Description">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Lang" use="optional" type="xs:token"/>
                    <xs:attribute name="Format" use="optional" type="xs:token"/>
                    <xs:attribute name="Translatable" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <xs:element name="PackageIsVisible">
        <xs:simpleType>
            <xs:restriction base="xs:string">
                <xs:enumeration value="0"/>
                <xs:enumeration value="1"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:element>

    <xs:element name="PackageIsDownloadable">
        <xs:simpleType>
            <xs:restriction base="xs:string">
                <xs:enumeration value="0"/>
                <xs:enumeration value="1"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:element>

    <xs:element name="PackageIsBuildable">
        <xs:simpleType>
            <xs:restriction base="xs:string">
                <xs:enumeration value="0"/>
                <xs:enumeration value="1"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:element>

    <xs:element name="PackageIsRemovable">
        <xs:simpleType>
            <xs:restriction base="xs:string">
                <xs:enumeration value="0"/>
                <xs:enumeration value="1"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:element>

    <xs:element name="PackageAllowDirectUpdate">
        <xs:simpleType>
            <xs:restriction base="xs:string">
                <xs:enumeration value="0"/>
                <xs:enumeration value="1"/>
            </xs:restriction>
        </xs:simpleType>
    </xs:element>

    <xs:element name="Filelist">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="File" maxOccurs="unbounded" />
            </xs:sequence>
        </xs:complexType>
        <xs:key name="unique-location">
            <xs:selector xpath="File" />
            <xs:field xpath="@Location" />
        </xs:key>
    </xs:element>

    <xs:element name="File">
        <xs:complexType>
            <xs:attribute name="Permission" use="required" type="xs:token"/>
            <xs:attribute name="Location" use="required" type="xs:token"/>
            <xs:attribute name="Encode" use="optional" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="PackageRequired">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Version" use="required" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <xs:element name="ModuleRequired">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Version" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <xs:element name="IntroInstall">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="required" type="xs:token"/>
                    <xs:attribute name="Lang" use="optional" type="xs:token"/>
                    <xs:attribute name="Title" use="optional" type="xs:token"/>
                    <xs:attribute name="Translatable" use="optional" type="xs:token"/>
                    <xs:attribute name="Format" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="IntroUninstall">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="required" type="xs:token"/>
                    <xs:attribute name="Lang" use="optional" type="xs:token"/>
                    <xs:attribute name="Title" use="optional" type="xs:token"/>
                    <xs:attribute name="Translatable" use="optional" type="xs:token"/>
                    <xs:attribute name="Format" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="IntroReinstall">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="required" type="xs:token"/>
                    <xs:attribute name="Lang" use="optional" type="xs:token"/>
                    <xs:attribute name="Title" use="optional" type="xs:token"/>
                    <xs:attribute name="Translatable" use="optional" type="xs:token"/>
                    <xs:attribute name="Format" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="IntroUpgrade">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="required" type="xs:token"/>
                    <xs:attribute name="Lang" use="optional" type="xs:token"/>
                    <xs:attribute name="Title" use="optional" type="xs:token"/>
                    <xs:attribute name="Translatable" use="optional" type="xs:token"/>
                    <xs:attribute name="Version" use="optional" type="xs:token"/>
                    <xs:attribute name="Format" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <xs:element name="CodeInstall">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="optional" type="xs:token"/>
                    <xs:attribute name="IfPackage" use="optional" type="xs:token"/>
                    <xs:attribute name="IfNotPackage" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="CodeUninstall">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="optional" type="xs:token"/>
                    <xs:attribute name="IfPackage" use="optional" type="xs:token"/>
                    <xs:attribute name="IfNotPackage" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="CodeReinstall">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="optional" type="xs:token"/>
                    <xs:attribute name="IfPackage" use="optional" type="xs:token"/>
                    <xs:attribute name="IfNotPackage" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="CodeUpgrade">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="Type" use="optional" type="xs:token"/>
                    <xs:attribute name="Version" use="optional" type="xs:token"/>
                    <xs:attribute name="IfPackage" use="optional" type="xs:token"/>
                    <xs:attribute name="IfNotPackage" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>

    <xs:element name="PackageMerge">
        <xs:complexType>
            <xs:sequence>
                <xs:choice minOccurs="0" maxOccurs="unbounded">
                    <xs:element ref="CodeUpgrade"/>
                    <xs:element ref="DatabaseUpgrade"/>
                </xs:choice>
            </xs:sequence>
            <xs:attribute name="Name" use="required" type="xs:token"/>
            <xs:attribute name="TargetVersion" use="required" type="xs:token"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="Name" type="xs:token"/>
    <xs:element name="Vendor" type="xs:token"/>
    <xs:element name="URL" type="xs:token"/>
    <xs:element name="Framework">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:token">
                    <xs:attribute name="Minimum" use="optional" type="xs:token"/>
                    <xs:attribute name="Maximum" use="optional" type="xs:token"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="Version" type="xs:token"/>
    <xs:element name="License" type="xs:token"/>
    <xs:element name="OS" type="xs:token"/>
</xs:schema>
 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OldoaXRlc3BhY2U6OlRhYnM7Cgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7Cgp1c2UgTW9vOwoKZXh0ZW5kcyBxdyhUaWR5QWxsOjpQbHVnaW46Ok9UT0JPOjpCYXNlKTsKCnN1YiB2YWxpZGF0ZV9zb3VyY2UgewogICAgbXkgKCAkU2VsZiwgJENvZGUgKSA9IEBfOwoKICAgIHJldHVybiBpZiAkU2VsZi0+SXNQbHVnaW5EaXNhYmxlZCggQ29kZSA9PiAkQ29kZSApOwoKICAgIG15ICRDb3VudGVyID0gMTsKICAgIG15ICRFcnJvck1lc3NhZ2U7CgogICAgIwogICAgIyBDaGVjayBmb3Igc3RyYXkgdGFicwogICAgIwogICAgTElORToKICAgIGZvciBteSAkTGluZSAoIHNwbGl0KCAvXG4vLCAkQ29kZSApICkgewoKICAgICAgICAkQ291bnRlcisrOwoKICAgICAgICBpZiAoICRMaW5lID1+IG0vXHQvICkgewogICAgICAgICAgICAkRXJyb3JNZXNzYWdlIC49ICJMaW5lICRDb3VudGVyOiAkTGluZVxuIjsKICAgICAgICB9CgogICAgfQoKICAgIGlmICgkRXJyb3JNZXNzYWdlKSB7CiAgICAgICAgcmV0dXJuICRTZWxmLT5EaWVXaXRoRXJyb3IoPDwiRU9GIik7ClBsZWFzZSBzdWJzdGl0dXRlIGFsbCB0YWJ1bGF0b3JzIHdpdGggZm91ciBzcGFjZXMuCiRFcnJvck1lc3NhZ2UKRU9GCiAgICB9Cn0KCjE7Cg== IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OldoaXRlc3BhY2U6OlRyYWlsaW5nV2hpdGVzcGFjZTsKCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCnVzZSBNb287CgpleHRlbmRzIHF3KFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OkJhc2UpOwoKc3ViIHRyYW5zZm9ybV9zb3VyY2UgewogICAgbXkgKCAkU2VsZiwgJENvZGUgKSA9IEBfOwoKICAgIHJldHVybiBpZiAkU2VsZi0+SXNQbHVnaW5EaXNhYmxlZCggQ29kZSA9PiAkQ29kZSApOwoKICAgICMgUmVtb3ZlIHRyYWlsaW5nIHNwYWNlcyBhdCBlbmQgb2YgbGluZXMKICAgICRDb2RlID1+IHMvXiguKj8pWyBdK1xuLyQxXG4veG1zZzsKCiAgICAjIFJlbW92ZSBlbXB0eSB0cmFpbGluZyBsaW5lcwogICAgJENvZGUgPX4gcy9cbihcc3xcbikrXHovXG4veG1zZzsKCiAgICByZXR1cm4gJENvZGU7Cn0KCjE7Cg== IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlhNTDo6Q29uZmlnRGVzY3JpcHRpb247Cgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7Cgp1c2UgTW9vOwoKZXh0ZW5kcyBxdyhUaWR5QWxsOjpQbHVnaW46Ok9UT0JPOjpCYXNlKTsKCnN1YiB2YWxpZGF0ZV9zb3VyY2UgewogICAgbXkgKCAkU2VsZiwgJENvZGUgKSA9IEBfOwoKICAgIHJldHVybiBpZiAkU2VsZi0+SXNQbHVnaW5EaXNhYmxlZCggQ29kZSA9PiAkQ29kZSApOwoKICAgIG15ICggJEVycm9yTWVzc2FnZSwgJENvdW50ZXIsICROYXZCYXIgKTsKCiAgICBmb3IgbXkgJExpbmUgKCBzcGxpdCAvXG4vLCAkQ29kZSApIHsKICAgICAgICAkQ291bnRlcisrOwogICAgICAgIGlmICggJExpbmUgPX4gLzxOYXZCYXIvICkgewogICAgICAgICAgICAkTmF2QmFyID0gMTsKICAgICAgICB9CiAgICAgICAgaWYgKCAkTGluZSA9fiAvPFwvTmF2QmFyLyApIHsKICAgICAgICAgICAgJE5hdkJhciA9IDA7CiAgICAgICAgfQoKICAgICAgICBpZiAoICEkTmF2QmFyICYmICRMaW5lID1+IC88RGVzY3JpcHRpb24uKz8+KC4pLio/KC4pXCk/PFwvRGVzY3JpcHRpb24+LyApIHsKICAgICAgICAgICAgaWYgKCAkMiBuZSAnLicgJiYgJDIgbmUgJz8nICYmICQyIG5lICchJyApIHsKICAgICAgICAgICAgICAgICRFcnJvck1lc3NhZ2UgLj0gIkxpbmUgJENvdW50ZXI6ICRMaW5lXG4iOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2lmICggJDEgIX4gL1tBLVrDi8Ocw5YiXS8gKSB7CiAgICAgICAgICAgICAgICAkRXJyb3JNZXNzYWdlIC49ICJMaW5lICRDb3VudGVyOiAkTGluZVxuIjsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgIH0KCiAgICBpZiAoJEVycm9yTWVzc2FnZSkgewogICAgICAgIHJldHVybiAkU2VsZi0+RGllV2l0aEVycm9yKDw8IkVPRiIpOwpQbGVhc2UgbWFrZSBjb21wbGV0ZSBzZW50ZW5jZXMgaW4gPERlc2NyaXB0aW9uPiB0YWdzOiBzdGFydCB3aXRoIGEgY2FwaXRhbCBsZXR0ZXIgYW5kIGZpbmlzaCB3aXRoIGEgZG90LgokRXJyb3JNZXNzYWdlCkVPRgogICAgfQp9CgoxOwo= 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

package TidyAll::Plugin::OTOBO::XML::Configuration::Navigation;

use strict;
use warnings;

use Moo;

extends qw(TidyAll::Plugin::OTOBO::Base);

sub validate_source {
    my ( $Self, $Code ) = @_;

    return $Code if $Self->IsPluginDisabled( Code => $Code );

    my ( $Counter, $ErrorMessage );

    my $CurrentSettingName;

    LINE:
    for my $Line ( split /\n/, $Code ) {
        $Counter++;

        if ( $Line =~ m{<Setting\s+Name="(.*?)"}smx ) {
            $CurrentSettingName = $1;
        }
        my ($NavigationContent) = $Line =~ m{<Navigation>(.*?)</Navigation>}smx;

        next LINE unless $NavigationContent;

        my @Rules = (
            {
                Name                   => 'Valid toplevel entries',
                MatchSettingName       => qr{.*},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^(CloudService|Core|Daemon|GenericInterface|Frontend)(::|$)},
                ErrorMessage           => 'Invalid top level group found (only CloudService|Core|Daemon|GenericInterface|Frontend are allowed).',
            },
            {
                Name                   => 'Event handlers',
                MatchSettingName       => qr{::EventModule},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Core::Event::},
                ErrorMessage           => "Event handler registrations should be grouped in 'Core::Event::*.",
            },
            {
                Name                   => 'Valid Frontend subgroups',
                MatchSettingName       => qr{.*},
                MatchNavigationValue   => qr{^Frontend},                                                      # no entries allowed in "Frontend" directly
                RequireNavigationMatch => qr{^Frontend::(Admin|Agent|Base|Customer|Public|External)(::|$)},
                ErrorMessage           =>
                    'Invalid top Frontend subgroup found (only Admin|Agent|Base|Customer|Public|External are allowed).',
            },
            {
                Name                   => 'Main Loader config',
                MatchSettingName       => qr{^Loader::(Agent|Customer|Enabled)},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Base::Loader$},
                ErrorMessage           => "Main Loader settings should be grouped in 'Frontend::Base::Loader'.",
            },
            {
                Name                   => 'Loader config for Admin interface',
                MatchSettingName       => qr{^Loader::Module::Admin},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Admin::ModuleRegistration::Loader},
                ErrorMessage           =>
                    "Loader config for Admin interface should be grouped in 'Frontend::Admin::ModuleRegistration::Loader'.",
            },
            {
                Name                   => 'Loader config for Agent interface',
                MatchSettingName       => qr{^Loader::Module::Agent},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Agent::ModuleRegistration::Loader},
                ErrorMessage           =>
                    "Loader settings for Agent interface should be grouped in 'Frontend::Agent::ModuleRegistration::Loader'.",
            },
            {
                Name                   => 'Loader config for Customer interface',
                MatchSettingName       => qr{^Loader::Module::Customer},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Customer::ModuleRegistration::Loader},
                ErrorMessage           =>
                    "Loader settings for Customer interface should be grouped in 'Frontend::Customer::ModuleRegistration::Loader'.",
            },
            {
                Name                   => 'Loader config for Public interface',
                MatchSettingName       => qr{^Loader::Module::Public},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Public::ModuleRegistration},
                ErrorMessage           =>
                    "Loader settings for Public interface should be grouped in 'Frontend::Public::ModuleRegistration'.",
            },
            {
                Name                   => 'Frontend navigation config for Admin interface',
                MatchSettingName       => qr{^Frontend::Navigation###Admin},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Admin::ModuleRegistration::MainMenu},
                ErrorMessage           =>
                    "Frontend navigation config for Admin interface should be grouped in 'Frontend::Admin::ModuleRegistration::MainMenu'.",
            },
            {
                Name                   => 'Frontend navigation config for Agent interface',
                MatchSettingName       => qr{^Frontend::Navigation###Agent},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Agent::ModuleRegistration::MainMenu},
                ErrorMessage           =>
                    "Frontend navigation config for Agent interface should be grouped in 'Frontend::Agent::ModuleRegistration::MainMenu'.",
            },
            {
                Name                   => 'Frontend navigation config for Customer interface',
                MatchSettingName       => qr{^CustomerFrontend::Navigation###Customer},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Customer::ModuleRegistration::MainMenu},
                ErrorMessage           =>
                    "Frontend navigation config for Customer interface should be grouped in 'Frontend::Customer::ModuleRegistration::MainMenu'.",
            },
            {
                Name                   => 'Frontend navigation config for Public interface',
                MatchSettingName       => qr{^PublicFrontend::(Module|Navigation)},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Public::ModuleRegistration},
                ErrorMessage           =>
                    "Module registration config for Public interface should be grouped in 'Frontend::Public::ModuleRegistration'.",
            },
            {
                Name                   => 'Navigation module config',
                MatchSettingName       => qr{^Frontend::NavigationModule},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Admin::ModuleRegistration::AdminOverview},
                ErrorMessage           =>
                    "Navigation module config should be grouped in 'Frontend::Admin::ModuleRegistration::AdminOverview'.",
            },
            {
                Name                   => 'Search router config for Admin interface',
                MatchSettingName       => qr{^Frontend::Search.*?###Admin},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Admin::ModuleRegistration::MainMenu::Search},
                ErrorMessage           =>
                    "Search router config for Admin interface should be grouped in 'Frontend::Admin::ModuleRegistration::Search'.",
            },
            {
                Name                   => 'Search router config for Agent interface',
                MatchSettingName       => qr{^Frontend::Search.*?###Agent},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Agent::ModuleRegistration::MainMenu::Search},
                ErrorMessage           =>
                    "Search router config for Agent interface should be grouped in 'Frontend::Agent::ModuleRegistration::Search'.",
            },
            {
                Name                   => 'Output filters',
                MatchSettingName       => qr{(Output::Filter|OutputFilter)},
                MatchNavigationValue   => qr{.*},
                RequireNavigationMatch => qr{^Frontend::Base::OutputFilter},
                ErrorMessage           =>
                    "Output filter settings should be grouped in 'Frontend::Base::OutputFilter' or subgroups.",
            },
            {
                Name                   => 'Valid frontend views',
                MatchSettingName       => qr{.*},
                MatchNavigationValue   => qr{^Frontend::(Admin|Agent|Customer|Public)::(.+::)*View.+$},
                RequireNavigationMatch => qr{^Frontend::(Admin|Agent|Customer|Public)::View::.+$},
                ErrorMessage           =>
                    "Screen specific settings should be added in Frontend::(Admin|Agent|Customer|Public)::View.",
            },
        );

        RULE:
        for my $Rule (@Rules) {
            next RULE unless $CurrentSettingName =~ $Rule->{MatchSettingName};
            next RULE unless $NavigationContent  =~ $Rule->{MatchNavigationValue};

            if (
                $Rule->{SkipForFrameworkVersionLessThan}
                && $Self->IsFrameworkVersionLessThan( @{ $Rule->{SkipForFrameworkVersionLessThan} } )
                )
            {
                next RULE;
            }

            if ( $NavigationContent !~ $Rule->{RequireNavigationMatch} ) {
                $ErrorMessage
                    .= "Invalid navigation value found for setting $CurrentSettingName: $Rule->{ErrorMessage}\n";
                $ErrorMessage .= "Line $Counter: $Line\n";
            }
        }
    }

    if ($ErrorMessage) {
        return $Self->DieWithError(<<"EOF");
Problems were found in the navigation structure of the XML configuration:
$ErrorMessage
EOF
    }

    return;
}

1;
 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlhNTDo6RGF0YWJhc2U6OlhTRFZhbGlkYXRvcjsKCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCnVzZSBGaWxlOjpCYXNlbmFtZTsKdXNlIE1vbzsKCmV4dGVuZHMgcXcoVGlkeUFsbDo6UGx1Z2luOjpPVE9CTzo6QmFzZSk7CgpzdWIgdmFsaWRhdGVfZmlsZSB7CiAgICBteSAoICRTZWxmLCAkRmlsZW5hbWUgKSA9IEBfOwogICAgcmV0dXJuIGlmICRTZWxmLT5Jc1BsdWdpbkRpc2FibGVkKCBGaWxlbmFtZSA9PiAkRmlsZW5hbWUgKTsKCiAgICBteSAkWFNERmlsZSA9IGRpcm5hbWUoX19GSUxFX18pIC4gJy8uLi8uLi9TdGF0aWNGaWxlcy9YU0QvRGF0YWJhc2UueHNkJzsKICAgIG15ICRDTUQgICAgID0gInhtbGxpbnQgLS1ub291dCAtLW5vbmV0IC0tc2NoZW1hICRYU0RGaWxlIjsKCiAgICBteSAkQ29tbWFuZCA9IHNwcmludGYoICIlcyAlcyAlcyAyPiYxIiwgJENNRCwgJFNlbGYtPmFyZ3YoKSwgJEZpbGVuYW1lICk7CiAgICBteSAkT3V0cHV0ICA9IGAkQ29tbWFuZGA7CgogICAgIyBJZiBleGVjdXRpb24gZmFpbGVkLCB3YXJuIGFib3V0IGluc3RhbGxpbmcgcGFja2FnZS4KICAgIGlmICggJHteQ0hJTERfRVJST1JfTkFUSVZFfSA9PSAtMSApIHsKICAgICAgICByZXR1cm4gJFNlbGYtPkRpZVdpdGhFcnJvcigiJ3htbGxpbnQnIHdhcyBub3QgZm91bmQsIHBsZWFzZSBpbnN0YWxsIGl0LlxuIik7CiAgICB9CgogICAgaWYgKCAke15DSElMRF9FUlJPUl9OQVRJVkV9ICkgewogICAgICAgIHJldHVybiAkU2VsZi0+RGllV2l0aEVycm9yKCIkT3V0cHV0XG4iKTsgICAgIyBub24temVybyBleGl0IGNvZGUKICAgIH0KfQoKMTsK # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

package TidyAll::Plugin::OTOBO::XML::Database::KeyLength;

use strict;
use warnings;

use Moo;

extends qw(TidyAll::Plugin::OTOBO::Base);

sub validate_source {
    my ( $Self, $Code ) = @_;

    return $Code if $Self->IsPluginDisabled( Code => $Code );

    my $Counter;

    # Account for 3-byte UTF8 characters. We currently use the "utf8" charset in MySQL,
    #   which uses three bytes per character. In future we might want to switch to utf8mb4,
    #   which would even further reduce possible key length by using 4 bytes per character.
    my $CharacterSize = 3;

    # Keys with size of more than 1000 bytes will fail on MyISAM storage engine in MySQL.
    my $KeySizeLimit = 1000;

    my $CurrentTableName;
    my %CurrentColumns;
    my $CurrentKey;
    my $CurrentKeySize = 0;
    my $ErrorMessage;

    my %ColumnType2Size = (
        'TINYINT'   => 1,
        'SMALLINT'  => 2,
        'MEDIUMINT' => 3,
        'INT'       => 8,
        'INTEGER'   => 8,
        'BIGINT'    => 8,
        'DATE'      => 8,
        'LONGBLOB'  => 4294967295,
    );

    LINE:
    for my $Line ( split /\n/, $Code ) {
        $Counter++;

        # Match table create opening tag and reset any found columns.
        if ( $Line =~ m{ <Table(?:Create)? .*? Name="(?<TableName>.*?)" }smx ) {
            $CurrentTableName = $+{TableName};
            %CurrentColumns   = ();
            next LINE;
        }

        # Identify all columns with defined size.
        if ( $Line =~ m{ <Column .*? Name="(?<ColumnName>\w+)" }smx ) {
            my $ColumnName = $+{ColumnName};

            if ( $Line =~ m{ Type="(?<ColumnType>\w+)" }smx ) {
                my $ColumnType = $+{ColumnType};

                # Use internal sizes for some predefined column types.
                if ( $ColumnType2Size{ uc $ColumnType } ) {
                    $CurrentColumns{$ColumnName} = $ColumnType2Size{ uc $ColumnType };
                }

                # Check if there is a defined size tag.
                if ( $Line =~ m{ Size="(?<ColumnSize>[\d,]+)" }smx ) {
                    my $ColumnSize = $+{ColumnSize};

                    # For text columns multiply found size with defined number of bytes per character.
                    if ( uc $ColumnType eq 'VARCHAR' ) {
                        $CurrentColumns{$ColumnName} = $ColumnSize * $CharacterSize;
                    }

                    # For decimal column type use approximate calculation, it should be enough for our purposes.
                    #   More info here: https://dev.mysql.com/doc/refman/5.7/en/precision-math-decimal-characteristics.html
                    elsif ( uc $ColumnType eq 'DECIMAL' ) {
                        my ( $TotalDigits, $FractionalDigits ) = split m/,/, $ColumnSize;
                        $FractionalDigits //= 0;
                        my $IntegerDigits = $TotalDigits - $FractionalDigits;
                        for my $Digits ( $IntegerDigits, $FractionalDigits ) {
                            $CurrentColumns{$ColumnName} += sprintf( '%0.f', $Digits / 9 * 4 );
                        }
                    }

                    # For any use case that has not been covered until this point, just use defined size.
                    elsif ( !$ColumnType2Size{ uc $ColumnType } ) {
                        $CurrentColumns{$ColumnName} += $ColumnSize;
                    }
                }
            }
        }

        # Match key opening tag and remember its name.
        if ( $Line =~ m{ <(?:Unique|Index) \s+ Name="(?<KeyName>\w+)" }smx ) {
            $CurrentKey = $+{KeyName};
            next LINE;
        }

        # Match key closing tag and reset any found keys.
        if ( $Line =~ m{ </(?:Unique|Index)> }smx ) {
            $CurrentKey     = undef;
            $CurrentKeySize = 0;
            next LINE;
        }

        # Proceed only if we are within key definition.
        if ($CurrentKey) {

            # Match key column tag.
            if ( $Line =~ m{ <(?:Unique|Index)Column .*? Name="(?<ColumnName>\w+)" }smx ) {
                my $ColumnName = $+{ColumnName};

                # Skip undefined columns. Should not happen, if the definition is valid.
                next LINE if !$CurrentColumns{$ColumnName};

                # If key size is defined, use it.
                if ( $Line =~ m{ Size="(?<KeySize>\d+)" }smx ) {
                    $CurrentKeySize += $+{KeySize};
                }

                # Otherwise, use size from column definition.
                else {
                    $CurrentKeySize += $CurrentColumns{$ColumnName};
                }
            }

            # Check if current size of the key exceeds configured limit.
            if ($CurrentKeySize) {
                next LINE if $CurrentKeySize <= $KeySizeLimit;

                $ErrorMessage .= "Table: $CurrentTableName, Key: $CurrentKey\n";

                # Skip processing current key.
                $CurrentKey     = undef;
                $CurrentKeySize = 0;
            }
        }
    }

    if ($ErrorMessage) {
        return $Self->DieWithError(<<"EOF");
Problem found in XML database schema: keys with more than 1000 bytes will fail on MyISAM storage engine in MySQL!
$ErrorMessage
EOF
    }

    return;
}

1;
 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlhNTDo6RG9jYm9vazo6UmVtb3ZlQ29udGFjdENoYXB0ZXI7Cgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7Cgp1c2UgTW9vOwoKZXh0ZW5kcyBxdyhUaWR5QWxsOjpQbHVnaW46Ok9UT0JPOjpCYXNlKTsKCnN1YiB0cmFuc2Zvcm1fc291cmNlIHsKICAgIG15ICggJFNlbGYsICRDb2RlICkgPSBAXzsKCiAgICByZXR1cm4gJENvZGUgaWYgJFNlbGYtPklzUGx1Z2luRGlzYWJsZWQoIENvZGUgPT4gJENvZGUgKTsKCiAgICAjIHJlbW92ZSBjaGFwdGVyCiAgICAkQ29kZSA9fiBzewogICAgICAgIDxjaGFwdGVyPiBccyoKICAgICAgICAoPzoKICAgICAgICAgICAgPCEtLSBccysgXCorIFxzKyAtLT4gXHMrCiAgICAgICAgICAgIDwhLS0gXHMrIFxkKyBcLiBccysgXHcrIFxzKyAtLT4gXHMrCiAgICAgICAgICAgIDwhLS0gXHMrIFwqKyBccysgLS0+IFxzKwogICAgICAgIHwKICAgICAgICApCiAgICAgICAgPHRpdGxlPiBbIF0qICg/OiBDb250YWN0IHwgQ29udGFjdHMgfCBLb250YWt0ICkgWyBdKiA8XC90aXRsZT4KICAgICAgICAoICg/ISA8XC9jaGFwdGVyPiApLiApKiA8XC9jaGFwdGVyPiBbIFxuXSoKICAgIH17fXhtczsKCiAgICByZXR1cm4gJENvZGU7Cn0KCjE7Cg== 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 ;
; Global ignores
;

; Ignore all CPAN content.
ignore = Kernel/cpan-lib/**/* Custom/Kernel/cpan-lib/**/* local/lib/perl5/**/* local/bin/**/*
; Ignore all dynamic/temporary data.
ignore = var/{article,log,run,sessions,spool,tmp,virtualfs}/**/*
; Ignore thirdparty content.
ignore = **/thirdparty/**/*
ignore = **/ckeditor*.css
; Ignore minified files
ignore = **/*.min.{css,js}
; Ignore Loader cache files.
ignore = **/{js-cache,css-cache}/**/*
; Ignore test data files.
ignore = tmp/Test/**/*
;ignore = scripts/test/sample/**/*
; ignore the CodePolicy that is used by the git commit hooks
ignore = TidyAll/**/*

;
; Common
;

[+TidyAll::Plugin::OTOBO::Common::CRLFLineEndings]
select = **/*.{pl,pm,psgi,t,tt,spec,js,css,scss,vue,dist,tmpl,sh,skel,xml,sopm,html,service,conf}

[+TidyAll::Plugin::OTOBO::Common::NoFilter]
select = **/*.{pl,pm,psgi,t,tt,spec,js,css,scss,vue,dist,tmpl,sh,skel,xml,sopm,html}
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
ignore = */Kernel/Language/*.pm */Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Common::Origin]
select = **/*.{pl,psgi,pm,t,js,css,tt,xml,sopm}
ignore = Kernel/Config/Files/ZZZ*.pm
; Ignore docbook documentations
ignore = */content/**/*.xml

[+TidyAll::Plugin::OTOBO::Common::CustomizationMarkersTT]
select = Custom/Kernel/Output/HTML/**/*.tt
select = Kernel/Output/HTML/**/*.tt

[+TidyAll::Plugin::OTOBO::Common::CustomizationMarkers]
select = **/*.{pl,psgi,pm,t,js,css,tt}
ignore = Kernel/Config.pm
ignore = Kernel/Config/GenericAgent.pm
ignore = Kernel/Config/Files/ZZZ*.pm
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::XML::Docbook::ReplaceSupportEmail]
select = doc/**/*.xml

[+TidyAll::Plugin::OTOBO::XML::Docbook::RemoveContactChapter]
select = doc/**/*.xml

[+TidyAll::Plugin::OTOBO::Common::ProhibitEmailAddresses]
select = **/*.{pl,pm,psgi,t,tt,js,xml,sopm}

;[+TidyAll::Plugin::OTOBO::Common::TranslatableStringsSpellCheck]
;select = **/*.{pl,pm,tt,js,xml}

[+TidyAll::Plugin::OTOBO::Common::RemoveCVSIDs]
select = **/*.{pl,pm,psgi,t,xml,tt,dist,spec,js}
select = var/cron/*

[+TidyAll::Plugin::OTOBO::Common::ValidateFilename]
select = *

;
; Cron
;

[+TidyAll::Plugin::OTOBO::Cron::CronScripts]
select = var/cron/*.dist

;
; JavaScript
;

[+TidyAll::Plugin::OTOBO::JavaScript::DebugCode]
select = **/*.js
ignore = scripts/webpack/**/*

[+TidyAll::Plugin::OTOBO::JavaScript::UnloadEvent]
select = **/*.js **/*.tt

[+TidyAll::Plugin::OTOBO::JavaScript::FileName]
select = **/*.js
ignore = **/test/*

[+TidyAll::Plugin::OTOBO::JavaScript::FileNameUnitTest]
select = var/httpd/htdocs/js/test/*.js

[+TidyAll::Plugin::OTOBO::JavaScript::ESLint]
select = **/*.{js}
ignore = scripts/test/sample/Loader/**/*
; Ignore this slow plugin for more agile OTOBOCodePolicy filter development with a custom mode "fast".
;except_modes = fast

;
; Legal
;

[+TidyAll::Plugin::OTOBO::Legal::LicenseValidator]
select = **/*.{pl,pm,psgi,t,tt,spec,js,css,scss,vue,dist,sh,skel,xml,sopm}
ignore = COPYING RELEASE CREDITS
ignore = Kernel/Config.pm Kernel/Config/**/ZZZ*.pm Kernel/Config/Files/User/*.pm
ignore = scripts/auto_build/spec/templates/**/*
ignore = scripts/test/sample/SysConfig/Migration/**/ZZZ*.pm
ignore = scripts/DBUpdate{To6,}/TaskConfig/*.yml.dist
ignore = var/httpd/htdocs/common/**/*.css
; OTOBOContinuousIntegrationProvisioner - deployment template includes
ignore = **/*.tt.sh

[+TidyAll::Plugin::OTOBO::Legal::ReplaceCopyright]
select = **/*.{pl,pm,psgi,t,tt,spec,js,css,scss,vue,dist,tmpl,sh,skel,conf,template}
select = .*.dist .bash_completion
select = .screenrc
select = var/cron/*
select = var/git/hooks/*-receive
select = documentation.yml
ignore = Kernel/Config.pm Kernel/Config/**/ZZZ*.pm
ignore = module-format.xml,codesyntax.xml,language-translations.xml,writing-otobo-application.xml,test-mechanism.xml
ignore = scripts/auto_build/spec/templates/includes/suse-systemd-base.tt scripts/auto_build/spec/templates/includes/redhat-systemd-base.tt
; Don't run this in the CI to avoid updates on year changes. It is enough to update the code when it is changed.
only_modes = cli editor commit

[+TidyAll::Plugin::OTOBO::Legal::SOPMLicense]
select = *.{opm,sopm}

;
; POT/PO
;

[+TidyAll::Plugin::OTOBO::PO::DocbookLint]
select = i18n/**/*.{pot,po}
select = locale/**/*.{pot,po}

[+TidyAll::Plugin::OTOBO::PO::HTMLTags]
select = i18n/**/*.{pot,po}

[+TidyAll::Plugin::OTOBO::PO::msgfmt]
select = i18n/**/*.{pot,po}
select = locale/**/*.{pot,po}

;
; Perl
;

[+TidyAll::Plugin::OTOBO::Perl::BinScripts]
select = bin/*.pl

[+TidyAll::Plugin::OTOBO::Perl::CacheNew]
select = **/*.{pl,psgi,pm}
select = Kernel/Config.pm.dist
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::DBObject]
select = Kernel/Modules/**/*.pm Custom/Kernel/Modules/**/*.pm
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::DieExit]
select = Kernel/Modules/**/*.pm Custom/Kernel/Modules/**/*.pm
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::ForeachToFor]
select = **/*.{pl,pm,psgi,t}
select = Kernel/Config.pm.dist
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::ForMy]
select = **/*.{pl,psgi,pm,t}
select = Kernel/Config.pm.dist
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::LayoutObject]
select = **/*.{pl,pm,psgi,t}
select = Kernel/Config.pm.dist
ignore = scripts/test/**/*
ignore = Kernel/{Modules,Output}/**/* Custom/Kernel/{Modules,Output}/**/*
ignore = Kernel/System/Web/* Custom/Kernel/System/Web/*
ignore = Kernel/System/DynamicField/**/* Custom/Kernel/System/DynamicField/**/*
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::ModuleFormat]
select = **/*.{pm,t}
select = Kernel/Config.pm.dist
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::NoExitInConsoleCommands]
select = Kernel/System/Console/Command/**/*.pm Custom/Kernel/System/Console/Command/**/*.pm

[+TidyAll::Plugin::OTOBO::Perl::ObjectDependencies]
select = **/*.{pm}
select = Kernel/Config.pm.dist
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::ObjectManagerCreation]
select = **/*.{pm}
select = Kernel/Config.pm.dist
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
ignore = Kernel/System/UnitTest/RegisterDriver.pm Custom/Kernel/System/UnitTest/RegisterDriver.pm
ignore = Kernel/System/UnitTest/RegisterOM.pm Custom/Kernel/System/UnitTest/RegisterOM.pm

[+TidyAll::Plugin::OTOBO::Perl::ObjectNameSpace]
select = **/*.{pl,pm,t}
select = Kernel/Config.pm.dist
ignore = Kernel/Modules/**/* Custom/Kernel/Modules/**/*
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::ParamObject]
select = **/*.{pl,psgi}
select = Kernel/System/**/*.pm Custom/Kernel/System/**/*.pm
ignore = Kernel/System/Web/**/*.pm Custom/Kernel/System/Web/**/*.pm

[+TidyAll::Plugin::OTOBO::Perl::PerlCritic]
select = **/*.{pl,pm,psgi,t}
ignore = Kernel/Config.pm
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
ignore = scripts/test/sample/**/*
; Ignore this slow plugin for more agile OTOBOCodePolicy filter development with a custom mode "fast".
except_modes = fast
profile = $ROOT/Plugin/OTOBO/Perl/perlcriticrc

[+TidyAll::Plugin::OTOBO::Perl::PerlTidy]
select = **/*.{pl,pm,psgi,t}
ignore = Kernel/Config.pm Kernel/Config/Defaults.pm Kernel/Config/**/ZZZ*.pm Kernel/Config/Files/User/*.pm
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
argv = -pro=$ROOT/Plugin/OTOBO/Perl/perltidyrc
; Ignore this slow plugin for more agile OTOBOCodePolicy filter development with a custom mode "fast".
except_modes = fast

[+TidyAll::Plugin::OTOBO::Perl::Pod::FunctionPod]
select = **/*.{pm}
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::Pod::SpellCheck]
select = **/*.{pm,pod}
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
; Ignore this slow plugin for more agile OTOBOCodePolicy filter development with a custom mode "fast".
except_modes = fast

[+TidyAll::Plugin::OTOBO::Perl::Pod::Validator]
select = **/*.{pm,pod,pod.dist}
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::Print]
select = Kernel/Modules/**/*.pm Custom/Kernel/Modules/**/*.pm

[+TidyAll::Plugin::OTOBO::Perl::Require]
select = **/*.{pl,psgi,pm,t}
select = Kernel/Config.pm.dist
ignore = scripts/test/Selenium/**/*.t
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::ScriptFormat]
select = **/*.{pl,psgi}

[+TidyAll::Plugin::OTOBO::Perl::SubDeclaration]
select = **/*.{pl,pm,psgi,t}
select = Kernel/Config.pm.dist
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::SyntaxCheck]
select = **/*.{pl,pm,psgi,t}
select = Kernel/Config.pm.dist
; Ignore this slow plugin for more agile OTOBOCodePolicy filter development with a custom mode "fast".
except_modes = fast

[+TidyAll::Plugin::OTOBO::Perl::Tests::Helper]
select = **/*.{t}

[+TidyAll::Plugin::OTOBO::Perl::Time]
select = **/*.{pl,pm,psgi,t}
select = Kernel/Config.pm.dist
ignore = scripts/test/**/*
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::Translatable]
select = **/*.{pl,pm,psgi,t}
ignore = Kernel/Config.pm Kernel/Config/**/ZZZ*.pm
ignore = Kernel/Language.pm
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
ignore = scripts/test/**/*

[+TidyAll::Plugin::OTOBO::Perl::TranslationEncoding]
select = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::UnitTestConfigChanges]
select = scripts/test/**/*.{t}

[+TidyAll::Plugin::OTOBO::Perl::UseParent]
select = **/*.pm **/*.pm.skel
select = Kernel/Config.pm.dist
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

[+TidyAll::Plugin::OTOBO::Perl::UseWarnings]
select = **/*.{pl,pm,psgi,t}
select = Kernel/Config.pm.dist
ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm

;
; SOPM
;

[+TidyAll::Plugin::OTOBO::SOPM::CodeTags]
select = *.{opm,sopm}

[+TidyAll::Plugin::OTOBO::SOPM::FileList]
select = *.{opm,sopm}

[+TidyAll::Plugin::OTOBO::SOPM::FileRights]
select = *.{opm,sopm}

[+TidyAll::Plugin::OTOBO::SOPM::Name]
select = *.{sopm}

[+TidyAll::Plugin::OTOBO::SOPM::PackageRequired]
select = *.{opm,sopm}

[+TidyAll::Plugin::OTOBO::SOPM::RequiredElements]
select = *.{sopm}

[+TidyAll::Plugin::OTOBO::SOPM::XSDValidator]
select = *.{sopm}

;
; TT
;

[+TidyAll::Plugin::OTOBO::TT::ScriptUsage]
select = **/*.tt

[+TidyAll::Plugin::OTOBO::TT::TranslationFilter]
select = **/*.tt

;
; SQL
;

[+TidyAll::Plugin::OTOBO::SQL::ReservedWords]
select = **/*.{xml,opm,sopm}

;
; Whitespace
;

[+TidyAll::Plugin::OTOBO::Whitespace::FourSpaces]
select = **/*.{opm,sopm}

[+TidyAll::Plugin::OTOBO::Whitespace::Tabs]
select = **/*.{pl,pm,psgi,t,tt,js,xml,opm,sopm}
ignore = Kernel/Config.pm Kernel/Config/**/ZZZ*.pm

[+TidyAll::Plugin::OTOBO::Whitespace::TrailingWhitespace]
select = **/*.{pl,pm,psgi,t,tt,js,xml,opm,sopm,md}
ignore = Kernel/Config.pm Kernel/Config/**/ZZZ*.pm

;
; XML
;

[+TidyAll::Plugin::OTOBO::XML::ConfigSyntax]
select = **/*.xml
ignore = development/samples/config/*.xml
; ignore .xml files in documentation
ignore = doc/**/*.xml
ignore = en/content/**/*.xml
ignore = de/content/**/*.xml
ignore = hu/content/**/*.xml
ignore = scripts/test/sample/**/*.xml

[+TidyAll::Plugin::OTOBO::XML::ConfigDescription]
select = Kernel/Config/**/*.xml

[+TidyAll::Plugin::OTOBO::XML::Configuration::Navigation]
select = Kernel/Config/**/*.xml

[+TidyAll::Plugin::OTOBO::XML::Configuration::UnitTestBlacklist]
select = Kernel/Config/**/*.xml

[+TidyAll::Plugin::OTOBO::XML::Configuration::XSDValidator]
select = Kernel/Config/**/*.xml

[+TidyAll::Plugin::OTOBO::XML::Database::KeyLength]
select = scripts/database/otobo-schema.xml
select = *.{sopm}

[+TidyAll::Plugin::OTOBO::XML::Database::XSDValidator]
select = scripts/database/*.xml
select = scripts/database/update/*.xml

[+TidyAll::Plugin::OTOBO::XML::Docbook::BinScripts]
select = doc/**/*.xml
;select = en/content/**/*.xml

[+TidyAll::Plugin::OTOBO::XML::Docbook::ImageOutput]
select = doc/**/*.xml
select = en/content/**/*.xml

[+TidyAll::Plugin::OTOBO::XML::Docbook::XSDValidator]
select = doc/**/*.xml
;select = en/content/**/*.xml

[+TidyAll::Plugin::OTOBO::XML::WSDL::XSDValidator]
select = **/*.wsdl

[+TidyAll::Plugin::OTOBO::XML::Lint]
select = **/*.{xml,xsd}

[+TidyAll::Plugin::OTOBO::XML::LintWithOurParsers]
select = ;**/*.xml

;
; Migrations OTOBO 10
;

;[+TidyAll::Plugin::OTOBO::Migrations::OTOBO10::DateTime]
;select = **/*.{pl,pm,psgi,t}
;ignore = Kernel/Config/Files/ZZZ*.pm
;ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
;
;[+TidyAll::Plugin::OTOBO::Migrations::OTOBO10::PerlConfigFileFormat]
;select = Kernel/Config/Files/*.pm
;
;[+TidyAll::Plugin::OTOBO::Migrations::OTOBO10::PermissionDataNotInSession]
;select = **/*.{pl,pm,psgi,t}
;ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
;
;[+TidyAll::Plugin::OTOBO::Migrations::OTOBO10::SysConfig]
;select = **/*.{pl,pm,psgi,t}
;ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
;
;[+TidyAll::Plugin::OTOBO::Migrations::OTOBO10::TimeObject]
;select = **/*.{pl,pm,psgi,t}
;ignore = Kernel/System/Time.pm
;ignore = scripts/test/Time.t
;ignore = scripts/test/Time/**/*.t
;ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
;
;[+TidyAll::Plugin::OTOBO::Migrations::OTOBO10::TimeZoneOffset]
;select = **/*.{pl,pm,psgi,t}
;ignore = Kernel/Config/Files/ZZZ*.pm
;ignore = Kernel/Language/*.pm Custom/Kernel/Language/*.pm
;
;[+TidyAll::Plugin::OTOBO::Migrations::OTOBO10::XMLFrontendNavigation]
;select = Kernel/Config/**/*.xml
 IyEvdXNyL2Jpbi9lbnYgcGVybAojIC0tCiMgT1RPQk8gaXMgYSB3ZWItYmFzZWQgdGlja2V0aW5nIHN5c3RlbSBmb3Igc2VydmljZSBvcmdhbmlzYXRpb25zLgojIC0tCiMgQ29weXJpZ2h0IChDKSAyMDAxLTIwMjAgT1RSUyBBRywgaHR0cHM6Ly9vdHJzLmNvbS8KIyBDb3B5cmlnaHQgKEMpIDIwMTktMjAyNSBSb3RoZXIgT1NTIEdtYkgsIGh0dHBzOi8vb3RvYm8uaW8vCiMgLS0KIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdCB1bmRlcgojIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCiMgRm91bmRhdGlvbiwgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KIyBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKIyBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUwojIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgojIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCiMgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uIElmIG5vdCwgc2VlIDxodHRwczovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uCiMgLS0KCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCnVzZSBGaWxlOjpCYXNlbmFtZTsKdXNlIEZpbmRCaW4gcXcoJFJlYWxCaW4pOwp1c2UgbGliIGRpcm5hbWUoJFJlYWxCaW4pIC4gJy8uLi8uLi8nOwp1c2UgbGliIGRpcm5hbWUoJFJlYWxCaW4pIC4gJy8uLi8uLi9LZXJuZWwvJzsgICAgIyBmaW5kIFRpZHlBbGwKdXNlIGxpYiBkaXJuYW1lKCRSZWFsQmluKSAuICcvLi4vLi4vS2VybmVsL2NwYW4tbGliJzsKCnVzZSBUaWR5QWxsOjpPVE9CTzo6R2l0OjpQcmVDb21taXQ7CgojIHNraXAgbWVyZ2UgY29tbWl0cwppZiAoIC1lICcuZ2l0L01FUkdFX01TRycgKSB7CiAgICBwcmludCAibWVyZ2UgY29tbWl0LiBza2lwcGluZyBjb21taXQgaG9vay4uLlxuIjsKICAgIGV4aXQ7Cn0KCm15ICRQcmVDb21taXQgPSBUaWR5QWxsOjpPVE9CTzo6R2l0OjpQcmVDb21taXQtPm5ldygpOwokUHJlQ29tbWl0LT5SdW4oKTsK IyEvdXNyL2Jpbi9lbnYgcGVybAojIC0tCiMgT1RPQk8gaXMgYSB3ZWItYmFzZWQgdGlja2V0aW5nIHN5c3RlbSBmb3Igc2VydmljZSBvcmdhbmlzYXRpb25zLgojIC0tCiMgQ29weXJpZ2h0IChDKSAyMDAxLTIwMjAgT1RSUyBBRywgaHR0cHM6Ly9vdHJzLmNvbS8KIyBDb3B5cmlnaHQgKEMpIDIwMTktMjAyNiBSb3RoZXIgT1NTIEdtYkgsIGh0dHBzOi8vb3RvYm8uaW8vCiMgLS0KIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdCB1bmRlcgojIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCiMgRm91bmRhdGlvbiwgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KIyBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKIyBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUwojIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgojIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCiMgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uIElmIG5vdCwgc2VlIDxodHRwczovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uCiMgLS0KCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCiMgY29yZSBtb2R1bGVzCnVzZSBGaWxlOjpCYXNlbmFtZTsKdXNlIEZpbmRCaW4gcXcoJFJlYWxCaW4pOwp1c2UgR2V0b3B0OjpMb25nIHF3KEdldE9wdGlvbnMpOwoKIyBDUEFOIG1vZHVsZXMKCiMgT1RPQk8gbW9kdWxlcwoKdXNlIGxpYiBkaXJuYW1lKCRSZWFsQmluKSAuICcvLi4vLi4vJzsKdXNlIGxpYiBkaXJuYW1lKCRSZWFsQmluKSAuICcvLi4vLi4vS2VybmVsLyc7ICAgICMgZmluZCBUaWR5QWxsCnVzZSBsaWIgZGlybmFtZSgkUmVhbEJpbikgLiAnLy4uLy4uL0tlcm5lbC9jcGFuLWxpYic7Cgp1c2UgVGlkeUFsbDo6T1RPQk86OkdpdDo6UHJlUmVjZWl2ZTsKCm15ICRJbnB1dCA9ICcnOwpHZXRPcHRpb25zKCAnaW5wdXQ9cycgPT4gXCRJbnB1dCApOwoKbXkgJFByZVJlY2VpdmUgPSBUaWR5QWxsOjpPVE9CTzo6R2l0OjpQcmVSZWNlaXZlLT5uZXcoKTsKJFByZVJlY2VpdmUtPlJ1biggSW5wdXQgPT4gJElucHV0ICk7Cg== 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 IyEvdXNyL2Jpbi9lbnYgcGVybAojIC0tCiMgT1RPQk8gaXMgYSB3ZWItYmFzZWQgdGlja2V0aW5nIHN5c3RlbSBmb3Igc2VydmljZSBvcmdhbmlzYXRpb25zLgojIC0tCiMgQ29weXJpZ2h0IChDKSAyMDAxLTIwMjAgT1RSUyBBRywgaHR0cHM6Ly9vdHJzLmNvbS8KIyBDb3B5cmlnaHQgKEMpIDIwMTktMjAyNSBSb3RoZXIgT1NTIEdtYkgsIGh0dHBzOi8vb3RvYm8uaW8vCiMgLS0KIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdCB1bmRlcgojIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCiMgRm91bmRhdGlvbiwgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KIyBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKIyBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUwojIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgojIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCiMgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uIElmIG5vdCwgc2VlIDxodHRwczovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uCiMgLS0KdXNlIHN0cmljdDsKdXNlIHdhcm5pbmdzOwoKdXNlIEN3ZDsKdXNlIEZpbGU6OlNwZWM7CgpteSAkRGlyZWN0b3J5ID0gZ2V0Y3dkOwoKdW5saW5rIEZpbGU6OlNwZWMtPmNhdGZpbGUoICREaXJlY3RvcnksICcuZ2l0JywgJ2hvb2tzJywgJ3ByZS1jb21taXQnICk7CnVubGluayBGaWxlOjpTcGVjLT5jYXRmaWxlKCAkRGlyZWN0b3J5LCAnLmdpdCcsICdob29rcycsICdwcmVwYXJlLWNvbW1pdC1tc2cnICk7CnByaW50ICJSZW1vdmVkIGdpdCBob29rcyBpbiAkRGlyZWN0b3J5LlxuXG4iOwo= IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCnBhY2thZ2Ugc2NyaXB0czo6dGVzdDo6T1RPQk9Db2RlUG9saWN5UGx1Z2luczsKCiMjIG5vZmlsdGVyKFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6OlJlcXVpcmUpCgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7CnVzZSB1dGY4OwoKIyBjb3JlIG1vZHVsZXMKCiMgQ1BBTiBtb2R1bGVzCnVzZSBUZXN0Mjo6VjA7CgojIE9UT0JPIG1vZHVsZXMKdXNlIFRpZHlBbGw6Ok9UT0JPOwoKc3ViIFJ1biB7CiAgICBteSAoJVBhcmFtKSA9IEBfOwoKICAgICMgU3VwcHJlc3MgY29sb3JlZCBvdXRwdXQgdG8gbm90IGNsdXR0ZXIgbG9nIGZpbGVzLgogICAgbG9jYWwgJEVOVntPVE9CT0NPREVQT0xJQ1lfTk9DT0xPUn0gPSAxOwoKICAgIG15ICRUaWR5QWxsID0gVGlkeUFsbDo6T1RPQk8tPm5ld19mcm9tX2NvbmZfZmlsZSgKICAgICAgICAiLi9LZXJuZWwvVGlkeUFsbC90aWR5YWxscmMiLAogICAgICAgIG5vX2NhY2hlICAgPT4gMSwKICAgICAgICBjaGVja19vbmx5ID0+IDEsCiAgICAgICAgbW9kZSAgICAgICA9PiAndGVzdHMnLAogICAgICAgIHJvb3RfZGlyICAgPT4gJy4nLAogICAgICAgIGRhdGFfZGlyICAgPT4gRmlsZTo6U3BlYy0+dG1wZGlyKCksCgogICAgICAgICN2ZXJib3NlICAgID0+IDEsCiAgICApOwoKICAgIFRFU1Q6CiAgICBmb3IgbXkgJFRlc3QgKCAkUGFyYW17VGVzdHN9LT5AKiApIHsKCiAgICAgICAgIyBTZXQgZnJhbWV3b3JrIHZlcnNpb24gaW4gVGlkeUFsbCBzbyB0aGF0IHBsdWdpbnMgY2FuIHVzZSBpdC4KICAgICAgICBteSAoICRGcmFtZXdvcmtWZXJzaW9uTWFqb3IsICRGcmFtZXdvcmtWZXJzaW9uTWlub3IgKSA9ICRUZXN0LT57RnJhbWV3b3JrfSA9fiBtLyhcZCspWy5dKFxkKykveG1zOwogICAgICAgICRUaWR5QWxsOjpPVE9CTzo6RnJhbWV3b3JrVmVyc2lvbk1ham9yID0gJEZyYW1ld29ya1ZlcnNpb25NYWpvcjsKICAgICAgICAkVGlkeUFsbDo6T1RPQk86OkZyYW1ld29ya1ZlcnNpb25NaW5vciA9ICRGcmFtZXdvcmtWZXJzaW9uTWlub3I7CgogICAgICAgICMgU2V0IHRoZSBsaXN0IG9mIGZpbGVzIHRvIHRoZSBzYW1lIG9uZSBkZWZpbmVkIGluIHRoZSB0ZXN0IGNhc2UuCiAgICAgICAgQFRpZHlBbGw6Ok9UT0JPOjpGaWxlTGlzdCA9IEB7ICRUZXN0LT57RmlsZUxpc3R9IC8vIFtdIH07CgogICAgICAgIG15ICRTb3VyY2UgPSAkVGVzdC0+e1NvdXJjZX07CgogICAgICAgIGV2YWwgewogICAgICAgICAgICBmb3IgbXkgJFBsdWdpbk1vZHVsZSAoIEB7ICRUZXN0LT57UGx1Z2luc30gfSApIHsKICAgICAgICAgICAgICAgIG15ICRGaWxlTmFtZSA9ICIkUGx1Z2luTW9kdWxlLnBtIiA9fiBzezo6fXsvfXNteGdyOwoKICAgICAgICAgICAgICAgIHJlcXVpcmUgJEZpbGVOYW1lOwoKICAgICAgICAgICAgICAgIG15ICRQbHVnaW4gPSAkUGx1Z2luTW9kdWxlLT5uZXcoCiAgICAgICAgICAgICAgICAgICAgbmFtZSAgICA9PiAkUGx1Z2luTW9kdWxlLAogICAgICAgICAgICAgICAgICAgIHRpZHlhbGwgPT4gJFRpZHlBbGwsCiAgICAgICAgICAgICAgICApOwoKICAgICAgICAgICAgICAgIGZvciBteSAkTWV0aG9kIChxdyhwcmVwcm9jZXNzX3NvdXJjZSBwcm9jZXNzX3NvdXJjZV9vcl9maWxlIHBvc3Rwcm9jZXNzX3NvdXJjZSkpIHsKICAgICAgICAgICAgICAgICAgICAoJFNvdXJjZSkgPSAkUGx1Z2luLT4kTWV0aG9kKCAkU291cmNlLCAkVGVzdC0+e0ZpbGVuYW1lfSApOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgfTsKCiAgICAgICAgbXkgJEV4Y2VwdGlvbiA9ICRAOwoKICAgICAgICBzdWJ0ZXN0ICRUZXN0LT57TmFtZX0gPT4gc3ViIHsKICAgICAgICAgICAgbXkgJFRvZG87CiAgICAgICAgICAgIGlmICggJFRlc3QtPntUb2RvfSApIHsKICAgICAgICAgICAgICAgICRUb2RvID0gdG9kbyAkVGVzdC0+e1RvZG99OwogICAgICAgICAgICB9CgogICAgICAgICAgICBpZiAoICRUZXN0LT57RXhjZXB0aW9ufSApIHsKICAgICAgICAgICAgICAgIG9rKCAkRXhjZXB0aW9uLCAnZm91bmQgZXhwZWN0ZWQgZXhjZXB0aW9uJyApOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UgewogICAgICAgICAgICAgICAgb2soICEkRXhjZXB0aW9uLCAnY29uZmlybWVkIHRoYXQgdGhlcmUgaXMgbm8gZXhjZXB0aW9uJyApOwogICAgICAgICAgICB9CgogICAgICAgICAgICBpZiAoJEV4Y2VwdGlvbikgewogICAgICAgICAgICAgICAgZGlhZyAiZ290IGV4Y2VwdGlvbjogJEV4Y2VwdGlvbiI7CgogICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICB9CgogICAgICAgICAgICAjIGFsc28gY2hlY2sgdGhlIG1vZGlmaWVkIHNvdXJjZSB3aGVuIHRoZXJlIHdhcyBubyBleGNlcHRpb24KICAgICAgICAgICAgaXMoCiAgICAgICAgICAgICAgICAkU291cmNlLAogICAgICAgICAgICAgICAgJFRlc3QtPntSZXN1bHR9IC8vICRUZXN0LT57U291cmNlfSwKICAgICAgICAgICAgICAgICdnb3QgdGhlIGV4cGVjdGVkIHJlc3VsdCcsCiAgICAgICAgICAgICk7CiAgICAgICAgfQogICAgfQoKICAgIHJldHVybjsKfQoKMTsK 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKdXNlIHV0Zjg7CgojIGNvcmUgbW9kdWxlcwoKIyBDUEFOIG1vZHVsZXMKdXNlIFRlc3QyOjpWMDsKCiMgT1RPQk8gbW9kdWxlcwp1c2Ugc2NyaXB0czo6dGVzdDo6T1RPQk9Db2RlUG9saWN5UGx1Z2luczsKCm15IEBUZXN0cyA9ICgKICAgIHsKICAgICAgICBOYW1lICAgICAgPT4gJ0RlYnVnQ29kZSAtIGNvbnNvbGUgbG9nZ2luZyAodmFsaWQpJywKICAgICAgICBGaWxlbmFtZSAgPT4gJ1Rlc3QuanMnLAogICAgICAgIFBsdWdpbnMgICA9PiBbcXcoVGlkeUFsbDo6UGx1Z2luOjpPVE9CTzo6SmF2YVNjcmlwdDo6RGVidWdDb2RlKV0sCiAgICAgICAgRnJhbWV3b3JrID0+ICc3LjAnLAogICAgICAgIFNvdXJjZSAgICA9PiA8PCdFT0YnLAp0aGlzLiRsb2cuZGVidWcoJ3Zhck5hbWUnLCB2YXJOYW1lKTsKRU9GCiAgICAgICAgRXhjZXB0aW9uID0+IDAsCiAgICB9LAogICAgewogICAgICAgIE5hbWUgICAgICA9PiAnRGVidWdDb2RlIC0gY29uc29sZSBsb2dnaW5nIChpbnZhbGlkKScsCiAgICAgICAgRmlsZW5hbWUgID0+ICdUZXN0LmpzJywKICAgICAgICBQbHVnaW5zICAgPT4gW3F3KFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OkphdmFTY3JpcHQ6OkRlYnVnQ29kZSldLAogICAgICAgIEZyYW1ld29yayA9PiAnOC4wJywKICAgICAgICBTb3VyY2UgICAgPT4gPDwnRU9GJywKLy8gVE9ETzogUmVtb3ZlIHRoZSBjb2RlIGJlbG93Lgp0aGlzLiRuZXh0VGljaygoKSA9PiB7CiAgICBjb25zb2xlLmxvZygndmFyTmFtZScsIHZhck5hbWUpOwp9KTsKRU9GCiAgICAgICAgRXhjZXB0aW9uID0+IDEsCiAgICB9LAogICAgewogICAgICAgIE5hbWUgICAgICA9PiAnRGVidWdDb2RlIC0gc2tpcHBlZCB0ZXN0IChpbnZhbGlkKScsCiAgICAgICAgRmlsZW5hbWUgID0+ICdUZXN0LmpzJywKICAgICAgICBQbHVnaW5zICAgPT4gW3F3KFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OkphdmFTY3JpcHQ6OkRlYnVnQ29kZSldLAogICAgICAgIEZyYW1ld29yayA9PiAnOC4wJywKICAgICAgICBTb3VyY2UgICAgPT4gPDwnRU9GJywKICAgIC8vIFRPRE86IFNraXAgdGhpcyB0ZXN0IGZvciBub3cuCiAgICB4aXQoJ3N1cHBvcnRzIGhpZGluZyBvZiB0aGUgZGVzY3JpcHRpb24gbmV4dCB0byB0aGUgbGFiZWwnLCAoKSA9PiB7CiAgICAgICAgZXhwZWN0LmFzc2VydGlvbnMoMik7CgogICAgICAgIHdyYXBwZXIuc2V0UHJvcHMoewogICAgICAgICAgICBoaWRlRGVzY3JpcHRpb246IHRydWUsCiAgICAgICAgfSk7CgogICAgICAgIHdyYXBwZXIudm0uJG5leHRUaWNrKCgpID0+IHsKICAgICAgICAgICAgZXhwZWN0KHdyYXBwZXIuY29udGFpbnMoJ2xhYmVsIGEuZmxvYXQtcmlnaHQgaS5Db21tb25JY29uX19Cb2xkLS1JbmZvcm1hdGlvbkNpcmNsZScpKS50b0JlKHRydWUpOwogICAgICAgICAgICBleHBlY3Qod3JhcHBlci5jb250YWlucygnc21hbGwuc3Itb25seScpKS50b0JlKHRydWUpOwogICAgICAgIH0pOwogICAgfSk7CkVPRgogICAgICAgIEV4Y2VwdGlvbiA9PiAxLAogICAgfSwKICAgIHsKICAgICAgICBOYW1lICAgICAgPT4gJ0RlYnVnQ29kZSAtIGZ1bmN0aW9uIHNpbWlsYXIgaW4gbmFtZSB0byBza2lwcGVkIHRlc3QgKHZhbGlkKScsCiAgICAgICAgRmlsZW5hbWUgID0+ICdUZXN0LmpzJywKICAgICAgICBQbHVnaW5zICAgPT4gW3F3KFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OkphdmFTY3JpcHQ6OkRlYnVnQ29kZSldLAogICAgICAgIEZyYW1ld29yayA9PiAnOC4wJywKICAgICAgICBTb3VyY2UgICAgPT4gPDwnRU9GJywKZnVuY3Rpb24gZXhpdCAoKSB7CiAgICAvLyBEbyBzb21ldGhpbmcuCn0KZXhpdCgpOwpFT0YKICAgICAgICBFeGNlcHRpb24gPT4gMCwKICAgIH0sCik7CgpzY3JpcHRzOjp0ZXN0OjpPVE9CT0NvZGVQb2xpY3lQbHVnaW5zOjpSdW4oIFRlc3RzID0+IFxAVGVzdHMgKTsKCmRvbmVfdGVzdGluZzsK IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7CnVzZSB1dGY4OwoKIyBjb3JlIG1vZHVsZXMKCiMgQ1BBTiBtb2R1bGVzCnVzZSBUZXN0Mjo6VjA7CgojIE9UT0JPIG1vZHVsZXMKdXNlIHNjcmlwdHM6OnRlc3Q6Ok9UT0JPQ29kZVBvbGljeVBsdWdpbnM7CgpteSBAVGVzdHMgPSAoCiAgICB7CiAgICAgICAgTmFtZSAgICAgID0+ICdFU0xpbnQgKHZhbGlkKScsCiAgICAgICAgRmlsZW5hbWUgID0+ICdUZXN0LmpzJywKICAgICAgICBQbHVnaW5zICAgPT4gW3F3KFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OkphdmFTY3JpcHQ6OkVTTGludCldLAogICAgICAgIEZyYW1ld29yayA9PiAnMTEuMCcsCiAgICAgICAgVG9kbyAgICAgID0+ICdFU0xpbnQgaXMgbm90IGEgcmVxdWlyZW1lbnQnLAogICAgICAgIFNvdXJjZSAgICA9PiA8PCdFT0YnLAoidXNlIHN0cmljdDsiCkVPRgogICAgICAgIEV4Y2VwdGlvbiA9PiAwLAogICAgfSwKICAgIHsKICAgICAgICBOYW1lICAgICAgPT4gJ0VTTGludCAoc3ludGF4IGVycm9yKScsCiAgICAgICAgRmlsZW5hbWUgID0+ICdUZXN0LmpzJywKICAgICAgICBQbHVnaW5zICAgPT4gW3F3KFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OkphdmFTY3JpcHQ6OkVTTGludCldLAogICAgICAgIEZyYW1ld29yayA9PiAnMTEuMCcsCiAgICAgICAgU291cmNlICAgID0+IDw8J0VPRicsCnNvbWUgc3ludGF4IGVycm9yCkVPRgogICAgICAgIEV4Y2VwdGlvbiA9PiAxLAogICAgfSwKCik7CgpzY3JpcHRzOjp0ZXN0OjpPVE9CT0NvZGVQb2xpY3lQbHVnaW5zOjpSdW4oIFRlc3RzID0+IFxAVGVzdHMgKTsKCmRvbmVfdGVzdGluZzsK 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjUgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKdXNlIHV0Zjg7CgojIGNvcmUgbW9kdWxlcwoKIyBDUEFOIG1vZHVsZXMKdXNlIFRlc3QyOjpWMDsKCiMgT1RPQk8gbW9kdWxlcwp1c2Ugc2NyaXB0czo6dGVzdDo6T1RPQk9Db2RlUG9saWN5UGx1Z2luczsKCm15IEBUZXN0cyA9ICgKICAgIHsKICAgICAgICBOYW1lICAgICAgPT4gJ0NhY2hlTmV3LCBmb3JiaWRkZW4nLAogICAgICAgIEZpbGVuYW1lICA9PiAndGVzdC5wbCcsCiAgICAgICAgUGx1Z2lucyAgID0+IFtxdyhUaWR5QWxsOjpQbHVnaW46Ok9UT0JPOjpQZXJsOjpDYWNoZU5ldyldLAogICAgICAgIEZyYW1ld29yayA9PiAnNC4wJywKICAgICAgICBTb3VyY2UgICAgPT4gPDwnRU9GJywKS2VybmVsOjpTeXN0ZW06OkNhY2hlLT5uZXcoJXskU2VsZn0pOwpFT0YKICAgICAgICBFeGNlcHRpb24gPT4gMSwKICAgIH0sCiAgICB7CiAgICAgICAgTmFtZSAgICAgID0+ICdDYWNoZU5ldywgb2snLAogICAgICAgIEZpbGVuYW1lICA9PiAndGVzdC5wbCcsCiAgICAgICAgUGx1Z2lucyAgID0+IFtxdyhUaWR5QWxsOjpQbHVnaW46Ok9UT0JPOjpQZXJsOjpDYWNoZU5ldyldLAogICAgICAgIEZyYW1ld29yayA9PiAnNC4wJywKICAgICAgICBTb3VyY2UgICAgPT4gPDwnRU9GJywKJEtlcm5lbDo6T00tPkdldCgnS2VybmVsOjpTeXN0ZW06OkNhY2hlJyk7CkVPRgogICAgICAgIEV4Y2VwdGlvbiA9PiAwLAogICAgfSwKKTsKCnNjcmlwdHM6OnRlc3Q6Ok9UT0JPQ29kZVBvbGljeVBsdWdpbnM6OlJ1biggVGVzdHMgPT4gXEBUZXN0cyApOwoKZG9uZV90ZXN0aW5nOwo= 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

use strict;
use warnings;
use v5.24;
use utf8;

# core modules

# CPAN modules
use Test2::V0;

# OTOBO modules
use scripts::test::OTOBOCodePolicyPlugins;

our $Self;

my @Tests = (
    {
        Name      => 'ObjectDependencies, no OM used.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
#!/usr/bin/bash
use strict;
use warnings;
my $FH;
EOF
        Exception => 0,
    },
    {
        Name      => 'ObjectDependencies, undeclared dependency used (former default dependency)',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
$Kernel::OM->Get('Kernel::System::Encode');
EOF
        Exception => 1,
    },
    {
        Name      => 'ObjectDependencies, default dependencies used with invalid short form in Get()',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
our @ObjectDependencies = ('Kernel::System::Encode');
$Kernel::OM->Get('EncodeObject');
EOF
        Exception => 1,
    },
    {
        Name      => 'ObjectDependencies, undeclared dependency used',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
$Kernel::OM->Get('Kernel::System::Ticket');
EOF
        Exception => 1,
    },
    {
        Name      => 'ObjectDependencies, dependency declared',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
our @ObjectDependencies = ('Kernel::System::Ticket');
$Kernel::OM->Get('Kernel::System::Ticket');
EOF
        Exception => 0,
    },
    {
        Name => 'ObjectDependencies, dependency declared in TestObjectDependencies
',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
our @SoftObjectDependencies = ('Kernel::System::Ticket');
$Kernel::OM->Get('Kernel::System::Ticket');
EOF
        Exception => 0,
    },
    {
        Name      => 'ObjectDependencies, dependency declared, invalid short form',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
our @ObjectDependencies = ('Kernel::System::Ticket');
for my $Needed (qw(TicketObject)) {
    $Self->{$Needed} = $Kernel::OM->Get($Needed);
}
EOF
        Exception => 1,
    },
    {
        Name      => 'ObjectDependencies, undeclared dependency in loop',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
for my $Needed (qw(Kernel::System::Ticket)) {
    $Self->{$Needed} = $Kernel::OM->Get($Needed);
}
EOF
        Exception => 1,
    },
    {
        Name      => 'ObjectDependencies, Get called in for loop',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
for my $Needed (qw(Kernel::System::CustomObject)) {
    $Self->{$Needed} = $Kernel::OM->Get($Needed);
}
EOF
        Exception => 1,
    },
    {
        Name      => 'ObjectDependencies, complex code, undeclared dependency',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
$Self->{ConfigObject} = $Kernel::OM->Get('Kernel::System::Config');
$Kernel::OM->ObjectParamAdd(
    LogObject => {
        LogPrefix => $Self->{ConfigObject}->Get('CGILogPrefix'),
    },
    ParamObject => {
        WebRequest => $Param{WebRequest} || 0,
    },
);

for my $Object (
    qw( LogObject EncodeObject SessionObject MainObject TimeObject ParamObject UserObject GroupObject )
    )
{
    $Self->{$Object} = $Kernel::OM->Get($Object);
}
EOF
        Exception => 1,
    },
    {
        Name      => 'ObjectDependencies, complex code, undeclared dependency',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::DB',
    'Kernel::System::Encode',
    'Kernel::System::Log',
    'Kernel::System::Main',
    'Kernel::System::User',
    'Kernel::System::Group',
    'Kernel::System::AuthSession',
    'Kernel::System::Web::Request',
);

$Self->{ConfigObject} = $Kernel::OM->Get('Kernel::Config');
$Kernel::OM->ObjectParamAdd(
    LogObject => {
        LogPrefix => $Self->{ConfigObject}->Get('CGILogPrefix'),
    },
    ParamObject => {
        WebRequest => $Param{WebRequest} || 0,
    },
);

for my $Object (
    qw( Kernel::System::User Kernel::System::Group )
    )
{
    $Self->{$Object} = $Kernel::OM->Get($Object);
}
EOF
        Exception => 0,
    },
    {
        Name      => 'ObjectDependencies, object manager disabled',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
our $ObjectManagerDisabled = 1;
$Kernel::OM->Get('Kernel::System::Ticket');
EOF
        Exception => 0,
    },
    {
        Name      => 'ObjectDependencies, deprecated ObjectManagerAware flag',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
our @ObjectDependencies = ('Kernel::System::Ticket');
our $ObjectManagerAware = 1;
$Kernel::OM->Get('Kernel::System::Ticket');
EOF
        Exception => 1,
    },
    {
        Name      => 'ObjectDependencies, Moose::Role',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::ObjectDependencies)],
        Framework => '4.0',
        Source    => <<'EOF',
use Moose::Role;
$Kernel::OM->Get('Kernel::System::Ticket');
EOF
        Exception => 0,
    },
);

scripts::test::OTOBOCodePolicyPlugins::Run( Tests => \@Tests );

done_testing;
 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --
use strict;
use warnings;
use utf8;

# Work around a Perl bug that is triggered in Devel::StackTrace
#   (probaly from Exception::Class and this from Perl::Critic).
#
#   See https://github.com/houseabsolute/Devel-StackTrace/issues/11 and
#   http://rt.perl.org/rt3/Public/Bug/Display.html?id=78186
no warnings 'redefine';                     ## no critic qw(TestingAndDebugging::ProhibitNoWarnings)
use Devel::StackTrace ();
local *Devel::StackTrace::new = sub { };    # no-op
use warnings 'redefine';

# core modules

# CPAN modules
use Test2::V0;

# OTOBO modules
use scripts::test::OTOBOCodePolicyPlugins;

my @Tests = (
    {
        Name      => 'All fine',
        Filename  => 'test.pl',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
use strict;
use warnings;

sub MyFunction {}
my $CamelCaseVar = 1;

1;
EOF
        Exception => 0,
    },
    {
        Name      => 'Wrong sub',
        Filename  => 'test.pl',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
use strict;
use warnings;

sub my_function {}

1;
EOF
        Exception => 1,
    },
    {
        Name      => 'Wrong var',
        Filename  => 'test.pl',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
use strict;
use warnings;

my $_wrong_variable = 1;

1;
EOF
        Exception => 1,
    },
    {
        Name      => 'All fine',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

sub MyFunction {}
my $CamelCaseVar = 1;

1;
EOF
        Exception => 0,
    },
    {
        Name      => 'Wrong sub',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

sub my_function {}

1;
EOF
        Exception => 1,
    },
    {
        Name      => 'Wrong var',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

my $_wrong_variable = 1;

1;
EOF
        Exception => 1,
    },
    {
        Name      => 'Package Variable',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

my $OTHER::PACKAGE::_private_variable = 1;

1;
EOF
        Exception => 0,
    },
    {
        Name      => 'Derived Package (use parent)',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

use parent qw(My::Package);

sub overridden_method {}

1;
EOF
        Exception => 0,
    },
    {
        Name      => 'Derived Package (use base)',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

use base qw(My::Package);

sub overridden_method {}

1;
EOF
        Exception => 0,
    },
    {
        Name      => 'Derived Package (Moose + extend)',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

use Moose;
extends qw(My::Package);

sub overridden_method {}

1;
EOF
        Exception => 0,
    },
    {
        Name      => 'Derived Package (Moose::Role + with)',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

use Moose::Role;
with qw(My::Package);

sub overridden_method {}

1;
EOF
        Exception => 0,
    },
    {
        Name      => 'Derived Package (Moose + extends)',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

use Moose;
extends qw(My::Package);

sub overridden_method {}

1;
EOF
        Exception => 0,
    },
    {
        Name      => 'Moose Package, but not derived',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

use Moose;
use Moose::Role;

sub my_function {}

1;
EOF
        Exception => 1,
    },
    {
        Name      => 'RequireBaseClass',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

$Kernel::OM->Get('Kernel::System::Main')->RequireBaseClass('Some::Class');

sub overridden_method {}

1;
EOF
        Exception => 0,
    },
    {
        Name      => 'Mojo::Base',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::Perl::PerlCritic)],
        Framework => '8.0',
        Source    => <<'EOF',
package Kernel::Test;
use strict;
use warnings;

use Mojo::Base 'Some::Class';

sub overridden_method {}

1;
EOF
        Exception => 0,
    },
);

scripts::test::OTOBOCodePolicyPlugins::Run( Tests => \@Tests );

done_testing;
 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --
use strict;
use warnings;
use utf8;

# core modules

# CPAN modules
use Test2::V0;

# OTOBO modules
use scripts::test::OTOBOCodePolicyPlugins;

my @Tests = (
    {
        Name      => 'Minimal valid SOPM.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <PackageIsDownloadable>0</PackageIsDownloadable>
    <PackageIsBuildable>0</PackageIsBuildable>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 0,
    },
    {
        Name      => 'Missing name.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'Missing description.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'Missing version.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'Missing framework.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'Missing vendor.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'Missing URL.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'Missing license.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'Invalid content for PackageIsDownloadable flag.',
        Todo      => 'SOPM check seems to be lacking',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <PackageIsDownloadable>test</PackageIsDownloadable>
    <PackageIsBuildable>0</PackageIsBuildable>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'OTOBOCodePolicy - missing PackageIsDownloadable + PackageIsBuildable.',
        Todo      => 'SOPM check seems to be lacking',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'OTOBOCodePolicy - valid SOPM.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <PackageIsDownloadable>0</PackageIsDownloadable>
    <PackageIsBuildable>0</PackageIsBuildable>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 0,
    },
    {
        Name      => 'ITSMIncidentProblemManagement - missing PackageIsDownloadable + PackageIsBuildable.',
        Todo      => 'SOPM check seems to be lacking',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>ITSMIncidentProblemManagement</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'ITSMIncidentProblemManagement - valid SOPM.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>ITSMIncidentProblemManagement</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <PackageIsDownloadable>0</PackageIsDownloadable>
    <PackageIsBuildable>0</PackageIsBuildable>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 0,
    },
    {
        Name      => 'TimeAccounting - missing PackageIsDownloadable + PackageIsBuildable.',
        Todo      => 'SOPM check seems to be lacking',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>TimeAccounting</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'TimeAccounting - valid SOPM.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>TimeAccounting</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <PackageIsDownloadable>0</PackageIsDownloadable>
    <PackageIsBuildable>0</PackageIsBuildable>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 0,
    },
    {
        Name      => 'OTOBOSTORM - missing PackageIsDownloadable + PackageIsBuildable.',
        Todo      => 'SOPM check seems to be lacking',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOSTORM</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'OTOBOSTORM - valid SOPM.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOSTORM</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <PackageIsDownloadable>0</PackageIsDownloadable>
    <PackageIsBuildable>0</PackageIsBuildable>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 0,
    },
    {
        Name      => 'Test123 - valid SOPM (no restricted package).',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::RequiredElements)],
        Framework => '7.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>Test123</Name>
    <Version>0.0.0</Version>
    <Framework>7.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl" />
    </Filelist>
</otobo_package>
EOF
        Exception => 0,
    },
);

scripts::test::OTOBOCodePolicyPlugins::Run( Tests => \@Tests );

done_testing;
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --
use strict;
use warnings;
use utf8;

# core modules

# CPAN modules
use Test2::V0;

# OTOBO modules
use scripts::test::OTOBOCodePolicyPlugins;

my @Tests = (
    {
        Name      => 'Minimal valid SOPM.',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::XSDValidator)],
        Framework => '4.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>4.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl"/>
    </Filelist>
</otobo_package>
EOF
        Exception => 0,
    },
    {
        Name      => 'Simple PackageMerge',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::XSDValidator)],
        Framework => '4.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>4.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl"/>
    </Filelist>
    <PackageMerge Name="MergeOne" TargetVersion="2.0.0"></PackageMerge>
</otobo_package>
EOF
        Exception => 0,
    },
    {
        Name      => 'PackageMerge without TargetVersion',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::XSDValidator)],
        Framework => '4.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>4.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl"/>
    </Filelist>
    <PackageMerge Name="MergeOne"></PackageMerge>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'PackageMerge without Name',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::XSDValidator)],
        Framework => '4.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>4.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl"/>
    </Filelist>
    <PackageMerge TargetVersion="2.0.0"></PackageMerge>
</otobo_package>
EOF
        Exception => 1,
    },
    {
        Name      => 'Simple PackageMerge',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::XSDValidator)],
        Framework => '4.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>4.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl"/>
    </Filelist>
    <DatabaseUpgrade Type="post">
        <TableCreate Name="merge_package">
            <Column Name="id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER"/>
            <Column Name="description" Required="true" Size="200" Type="VARCHAR"/>
        </TableCreate>
    </DatabaseUpgrade>
    <PackageMerge Name="MergeOne" TargetVersion="2.0.0">
      <DatabaseUpgrade Type="merge" IfPackage="OtherPackage" IfNotPackage="OtherPackage2">
          <TableCreate Name="merge_package">
              <Column Name="id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER"/>
              <Column Name="description" Required="true" Size="200" Type="VARCHAR"/>
          </TableCreate>
      </DatabaseUpgrade>
    </PackageMerge>
</otobo_package>
EOF
        Exception => 0,
    },
    {
        Name      => 'PackageMerge with invalid CodeInstall',
        Filename  => 'Test.pm',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::SOPM::XSDValidator)],
        Framework => '4.0',
        Source    => <<'EOF',
<?xml version="1.0" encoding="utf-8" ?>
<otobo_package version="1.0">
    <Name>OTOBOCodePolicy</Name>
    <Version>0.0.0</Version>
    <Framework>4.0.x</Framework>
    <Vendor>Rother OSS GmbH</Vendor>
    <URL>https://otobo.io/</URL>
    <License>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</License>
    <Description Lang="en">OTOBO code quality checks.</Description>
    <Filelist>
        <File Permission="755" Location="bin/otobo.CodePolicy.pl"/>
    </Filelist>
    <PackageMerge Name="MergeOne" TargetVersion="2.0.0">
      <DatabaseInstall Type="merge">
          <TableCreate Name="merge_package">
              <Column Name="id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER"/>
              <Column Name="description" Required="true" Size="200" Type="VARCHAR"/>
          </TableCreate>
      </DatabaseInstall>
    </PackageMerge>
</otobo_package>
EOF
        Exception => 1,
    },
);

scripts::test::OTOBOCodePolicyPlugins::Run( Tests => \@Tests );

done_testing;
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

use strict;
use warnings;
use utf8;

# core modules

# CPAN modules
use Test2::V0;

# OTOBO modules
use scripts::test::OTOBOCodePolicyPlugins;

my @Tests = (
    {
        Name      => 'Simple function translation, invalid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
[% Translate("Hello, world!") %]
EOF
        Exception => 1,
    },
    {
        Name      => 'Simple function translation with HTML filter, valid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
[% Translate("Hello, world!") | html %]
EOF
        Exception => 0,
    },
    {
        Name      => 'Simple function translation with JSON filter, valid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
[% Translate("Hello, world!") | JSON %]
EOF
        Exception => 0,
    },
    {
        Name      => 'Variable function translation, invalid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
[% Translate(Data.Language) %]
EOF
        Exception => 1,
    },
    {
        Name      => 'Variable function translation, valid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
[% Translate(Data.Language) | html %]
EOF
        Exception => 0,
    },
    {
        Name      => 'Complex function translation, invalid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
&ndash; <span title="[% Translate("Created") %]: [% Data.CreateTime | Localize("TimeShort") %]">[% Data.CreateTime | Localize("TimeShort") %]</span> [% Translate("via %s", Translate(Data.CommunicationChannel)) | html %]
EOF
        Exception => 1,
    },
    {
        Name      => 'Complex function translation, valid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
&ndash; <span title="[% Translate("Created") | html %]: [% Data.CreateTime | Localize("TimeShort") %]">[% Data.CreateTime | Localize("TimeShort") %]</span> [% Translate("via %s", Translate(Data.CommunicationChannel)) | html %]
EOF
        Exception => 0,
    },
    {
        Name      => 'Function translation with placeholder, invalid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
<a href="[% Env("Baselink") %]Action=AdminOTOBOCommunity" class="Button"><i class="fa fa-angle-double-up"></i> [% Translate("Upgrade to %s", OTOBOCommunityLabel) %]</a>
EOF
        Exception => 1,
    },
    {
        Name      => 'Function translation with placeholder, valid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
<a href="[% Env("Baselink") %]Action=AdminOTOBOCommunity" class="Button"><i class="fa fa-angle-double-up"></i> [% Translate("Upgrade to %s") | html | ReplacePlaceholders(OTOBOCommunityLabel) %]</a>
EOF
        Exception => 0,
    },
    {
        Name      => 'Function translation with placeholders, invalid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
[% Translate('This system uses the %s without a proper license! Please make contact with %s to renew or activate your contract!', OTOBOCommunityLabel, '<a href="mailto:hallo@otobo.de">hallo@otobo.de</a>') %]
EOF
        Exception => 1,
    },
    {
        Name      => 'Function translation with placeholders, valid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
[% Translate('This system uses the %s without a proper license! Please make contact with %s to renew or activate your contract!') | html | ReplacePlaceholders(OTOBOCommunityLabel, '<a href="mailto:hallo@otobo.de">hallo@otobo.de</a>') %]
EOF
        Exception => 0,
    },
    {
        Name      => 'Function translation with no spaces, invalid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
<button class="Primary CallForAction" type="submit" value="[%Translate("Add")%]"><span>[% Translate("Add") | html %]</span></button>
EOF
        Exception => 1,
    },
    {
        Name      => 'Function translation with no spaces, valid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
<button class="Primary CallForAction" type="submit" value="[%Translate("Add")|html%]"><span>[% Translate("Add") | html %]</span></button>
EOF
        Exception => 0,
    },
    {
        Name      => 'Filter translation, invalid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
<span title="[% Translate(Data.Content) | html %]">[% Data.Content | Translate | truncate(Data.MaxLength) %]</span>
EOF
        Exception => 1,
    },
    {
        Name      => 'Filter translation, valid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
<span title="[% Translate(Data.Content) | html %]">[% Data.Content | Translate | truncate(Data.MaxLength) | html %]</span>
EOF
        Exception => 0,
    },
    {
        Name      => 'Second filter translation, invalid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
var Message = [% Data.CustomerRegExErrorMessageServerErrorMessage | Translate %];
EOF
        Exception => 1,
    },
    {
        Name      => 'Second filter translation, valid',
        Filename  => 'Template.tt',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::TT::TranslationFilter)],
        Framework => '6.0',
        Source    => <<'EOF',
var Message = [% Data.CustomerRegExErrorMessageServerErrorMessage | Translate | JSON %];
EOF
        Exception => 0,
    },

);

scripts::test::OTOBOCodePolicyPlugins::Run( Tests => \@Tests );

done_testing;
 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

use strict;
use warnings;
use utf8;

# core modules

# CPAN modules
use Test2::V0;

# OTOBO modules
use scripts::test::OTOBOCodePolicyPlugins;

my $SettingTemplate = <<'EOF';
        <Description Translatable="1">Test config setting definition for purposes of the unit testing.</Description>
        <Value>
            <Hash>
                <Item Key="Key">Value</Item>
            </Hash>
        </Value>
EOF

my @Tests = (
    {
        Name      => 'Top level entry - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Stats::StatsHook" Required="1" Valid="1">
        <Navigation>Core::Stats</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Top level entry - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Stats::StatsHook" Required="1" Valid="1">
        <Navigation>Stats::Core</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Event handler entry - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Package::EventModulePost###9000-SupportDataSend" Required="1" Valid="1">
        <Navigation>Core::Event::Package</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Event handler entry - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Package::EventModulePost###9000-SupportDataSend" Required="1" Valid="1">
        <Navigation>Package::Core::Events</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Valid frontend subgroup',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="CustomerFrontend::NotifyModule###9-CustomerNotificationModule" Required="1" Valid="1">
        <Navigation>Frontend::Customer::FrontendNotification</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Frontend subgroup - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="CustomerFrontend::NotifyModule###9-CustomerNotificationModule" Required="1" Valid="1">
        <Navigation>Frontend::Customer::FrontendNotification</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Main loader entry - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Loader::Agent::CommonCSS###000-Framework" Required="1" Valid="1">
        <Navigation>Frontend::Base::Loader</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Main loader entry - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Loader::Agent::CommonCSS###000-Framework" Required="1" Valid="1">
        <Navigation>Frontend::Agent::Loader</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Loader config for Admin interface - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Loader::Module::AdminSystemConfiguration###001-Framework" Required="1" Valid="1">
        <Navigation>Frontend::Admin::ModuleRegistration::Loader</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Loader config for Admin interface - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Loader::Module::AdminSystemConfiguration###001-Framework" Required="1" Valid="1">
        <Navigation>Frontend::Base::Loader</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Loader config for Agent interface - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Loader::Module::AgentDashboard###001-Framework" Required="1" Valid="1">
        <Navigation>Frontend::Agent::ModuleRegistration::Loader</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Loader config for Agent interface - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Loader::Module::AgentDashboard###001-Framework" Required="1" Valid="1">
        <Navigation>Frontend::Base::Loader</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Loader config for Customer interface - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Loader::Module::CustomerTicketMessage###002-Ticket" Required="1" Valid="1">
        <Navigation>Frontend::Customer::ModuleRegistration::Loader</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Loader config for Customer interface - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Loader::Module::CustomerTicketMessage###002-Ticket" Required="1" Valid="1">
        <Navigation>Frontend::Base::Loader</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Loader config for Public interface - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Loader::Module::PublicFAQExplorer###002-FAQ" Required="1" Valid="1">
        <Navigation>Frontend::Public::ModuleRegistration</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Loader config for Customer interface - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Loader::Module::PublicFAQExplorer###002-FAQ" Required="1" Valid="1">
        <Navigation>Frontend::Base::Loader</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Frontend navigation config for Admin interface - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::Navigation###Admin###001-Framework" Required="1" Valid="1">
        <Navigation>Frontend::Admin::ModuleRegistration::MainMenu</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Frontend navigation config for Admin interface - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::Navigation###Admin###001-Framework" Required="1" Valid="1">
        <Navigation>Core::MainMenu</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Frontend navigation config for Agent interface - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::Navigation###Agent###001-Framework" Required="1" Valid="1">
        <Navigation>Frontend::Agent::ModuleRegistration::MainMenu</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Frontend navigation config for Agent interface - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::Navigation###Agent###001-Framework" Required="1" Valid="1">
        <Navigation>Core::MainMenu</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Frontend navigation config for Customer interface - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="CustomerFrontend::Navigation###Customer###001-Framework" Required="1" Valid="1">
        <Navigation>Frontend::Customer::ModuleRegistration::MainMenu</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Frontend navigation config for Customer interface - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="CustomerFrontend::Navigation###Customer###001-Framework" Required="1" Valid="1">
        <Navigation>Core::MainMenu</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Frontend navigation config for Public interface - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="PublicFrontend::Navigation###Public###001-Framework" Required="1" Valid="1">
        <Navigation>Frontend::Public::ModuleRegistration::MainMenu</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Frontend navigation config for Public interface - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="PublicFrontend::Navigation###Public###001-Framework" Required="1" Valid="1">
        <Navigation>Core::MainMenu</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Navigation module config - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::NavigationModule###Admin" Required="1" Valid="1">
        <Navigation>Frontend::Admin::ModuleRegistration::AdminOverview</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Navigation module config - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::NavigationModule###Admin" Required="1" Valid="1">
        <Navigation>Frontend::Admin</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Search router config for Admin interface - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::Search###AdminSystemConfiguration" Required="1" Valid="1">
        <Navigation>Frontend::Admin::ModuleRegistration::MainMenu::Search</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Search router config for Admin interface - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::Search###AdminSystemConfiguration" Required="1" Valid="1">
        <Navigation>Frontend::Admin</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Search router config for Agent interface - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::Search###AgentCustomerInformationCenter" Required="1" Valid="1">
        <Navigation>Frontend::Agent::ModuleRegistration::MainMenu::Search</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Search router config for Agent interface - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::Search###AgentCustomerInformationCenter" Required="1" Valid="1">
        <Navigation>Frontend::Agent</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Output filters - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::Output::FilterText###AAAURL" Required="1" Valid="1">
        <Navigation>Frontend::Base::OutputFilter</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Output filters - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Frontend::Output::FilterText###AAAURL" Required="1" Valid="1">
        <Navigation>Frontend::Base</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Frontend views - Valid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Ticket::Frontend::ZoomRichTextForce" Required="1" Valid="1">
        <Navigation>Frontend::Agent::View::TicketZoom</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 0,
    },
    {
        Name      => 'Frontend views - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Ticket::Frontend::ZoomRichTextForce" Required="1" Valid="1">
        <Navigation>Frontend::Agent::TicketZoom::View::RichText</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
    {
        Name      => 'Frontend views (OTOBO 7+) - Invalid',
        Filename  => 'Kernel/Config/Files/XML/Test.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Configuration::Navigation)],
        Framework => '6.0',
        Source    => <<"EOF",
<otobo_config version="2.0" init="Framework">
    <Setting Name="Ticket::Frontend::CustomerTicketMessage###DynamicField" Required="1" Valid="1">
        <Navigation>Frontend::Customer::Ticket::View::Message</Navigation>
$SettingTemplate
    </Setting>
</otobo_config>
EOF
        Exception => 1,
    },
);

scripts::test::OTOBOCodePolicyPlugins::Run( Tests => \@Tests );

done_testing;
 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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/>.
# --

use strict;
use warnings;
use utf8;

# core modules

# CPAN modules
use Test2::V0;

# OTOBO modules
use scripts::test::OTOBOCodePolicyPlugins;

my @Tests = (
    {
        Name      => 'Bug#13199, dynamic_field_obj_id_name issue',
        Filename  => 'otobo-schema.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Database::KeyLength)],
        Framework => '6.0',
        Source    => <<"EOF",
<!-- object names for dynamic field values -->
<Table Name="dynamic_field_obj_id_name">
    <Column Name="object_id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER"/>
    <Column Name="object_name" Required="true" Size="200" Type="VARCHAR"/>
    <Column Name="object_type" Required="true" Size="200" Type="VARCHAR"/>
    <Unique Name="dynamic_field_object_name">
        <UniqueColumn Name="object_name"/>
        <UniqueColumn Name="object_type"/>
    </Unique>
</Table>
EOF
        Exception => 1,
    },
    {
        Name      => 'Bug#13199, dynamic_field_obj_id_name fix',
        Filename  => 'otobo-schema.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Database::KeyLength)],
        Framework => '6.0',
        Source    => <<"EOF",
<!-- object names for dynamic field values -->
<Table Name="dynamic_field_obj_id_name">
    <Column Name="object_id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER"/>
    <Column Name="object_name" Required="true" Size="200" Type="VARCHAR"/>
    <Column Name="object_type" Required="true" Size="100" Type="VARCHAR"/>
    <Unique Name="dynamic_field_object_name">
        <UniqueColumn Name="object_name"/>
        <UniqueColumn Name="object_type"/>
    </Unique>
</Table>
EOF
        Exception => 0,
    },
    {
        Name      => 'Bug#13199, form_draft issue',
        Filename  => 'otobo-schema.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Database::KeyLength)],
        Framework => '6.0',
        Source    => <<"EOF",
<!-- form_draft -->
 <TableCreate Name="form_draft">
     <Column Name="id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER" />
     <Column Name="object_type" Required="true" Size="200" Type="VARCHAR" />
     <Column Name="object_id" Required="true" Type="INTEGER" />
     <Column Name="action" Required="true" Size="200" Type="VARCHAR" />
     <Column Name="title" Required="false" Size="255" Type="VARCHAR" />
     <Column Name="content" Required="true" Type="LONGBLOB" />
     <Column Name="create_time" Required="true" Type="DATE" />
     <Column Name="create_by" Required="true" Type="INTEGER" />
     <Column Name="change_time" Required="true" Type="DATE" />
     <Column Name="change_by" Required="true" Type="INTEGER" />
     <Index Name="form_draft_object_type_object_id_action">
         <IndexColumn Name="object_type" />
         <IndexColumn Name="object_id" />
         <IndexColumn Name="action" />
     </Index>
     <ForeignKey ForeignTable="users">
         <Reference Local="create_by" Foreign="id" />
         <Reference Local="change_by" Foreign="id" />
     </ForeignKey>
</TableCreate>
EOF
        Exception => 1,
    },
    {
        Name      => 'Bug#13199, form_draft fix',
        Filename  => 'otobo-schema.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Database::KeyLength)],
        Framework => '6.0',
        Source    => <<"EOF",
<!-- form_draft -->
 <TableCreate Name="form_draft">
     <Column Name="id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER" />
     <Column Name="object_type" Required="true" Size="100" Type="VARCHAR" />
     <Column Name="object_id" Required="true" Type="INTEGER" />
     <Column Name="action" Required="true" Size="200" Type="VARCHAR" />
     <Column Name="title" Required="false" Size="255" Type="VARCHAR" />
     <Column Name="content" Required="true" Type="LONGBLOB" />
     <Column Name="create_time" Required="true" Type="DATE" />
     <Column Name="create_by" Required="true" Type="INTEGER" />
     <Column Name="change_time" Required="true" Type="DATE" />
     <Column Name="change_by" Required="true" Type="INTEGER" />
     <Index Name="form_draft_object_type_object_id_action">
         <IndexColumn Name="object_type" />
         <IndexColumn Name="object_id" />
         <IndexColumn Name="action" />
     </Index>
     <ForeignKey ForeignTable="users">
         <Reference Local="create_by" Foreign="id" />
         <Reference Local="change_by" Foreign="id" />
     </ForeignKey>
</TableCreate>
EOF
        Exception => 0,
    },
    {
        Name      => 'Order of size tags, invalid',
        Filename  => 'otobo-schema.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Database::KeyLength)],
        Framework => '6.0',
        Source    => <<"EOF",
<!-- object names for dynamic field values -->
<Table Name="table_name">
    <Column Name="id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER"/>
    <Column Name="column_one" Required="true" Type="VARCHAR" Size="100"/>
    <Column Name="column_two" Required="true" Size="200" Type="VARCHAR"/>
    <Column Name="column_three" Required="true" Type="VARCHAR" Size="100"/>
    <Unique Name="column_one_two_three">
        <UniqueColumn Name="column_one"/>
        <UniqueColumn Name="column_two"/>
        <UniqueColumn Name="column_three"/>
    </Unique>
</Table>
EOF
        Exception => 1,
    },
    {
        Name      => 'Size tags in keys, valid',
        Filename  => 'otobo-schema.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Database::KeyLength)],
        Framework => '6.0',
        Source    => <<"EOF",
<!-- object names for dynamic field values -->
<Table Name="table_name">
    <Column Name="id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER"/>
    <Column Type="VARCHAR" Name="column_one" Required="true" Size="100"/>
    <Column Required="true" Size="200" Name="column_two" Type="VARCHAR"/>
    <Column Name="column_three" Type="VARCHAR" Required="true" Size="100"/>
    <Index Name="column_one_two_three">
        <IndexColumn Name="column_one"/>
        <IndexColumn Name="column_two" Size="100"/>
        <IndexColumn Name="column_three"/>
    </Unique>
</Table>
EOF
        Exception => 0,
    },
    {
        Name      => 'Integer column, valid',
        Filename  => 'otobo-schema.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Database::KeyLength)],
        Framework => '6.0',
        Source    => <<"EOF",
<!-- object names for dynamic field values -->
<Table Name="table_name">
    <Column Name="id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER"/>
    <Column Type="VARCHAR" Name="column_one" Required="true" Size="329"/>
    <Column Required="true" Name="column_two" Type="BIGINT"/>
    <Column Name="column_three" Required="true" Type="DECIMAL" Size="10"/>
    <Index Name="column_one_two_three">
        <IndexColumn Name="column_one"/>
        <IndexColumn Name="column_two"/>
        <IndexColumn Name="column_three"/>
    </Unique>
</Table>
EOF
        Exception => 0,
    },
    {
        Name      => 'Integer column, invalid',
        Filename  => 'otobo-schema.xml',
        Plugins   => [qw(TidyAll::Plugin::OTOBO::XML::Database::KeyLength)],
        Framework => '6.0',
        Source    => <<"EOF",
<!-- object names for dynamic field values -->
<Table Name="table_name">
    <Column Name="id" Required="true" PrimaryKey="true" AutoIncrement="true" Type="INTEGER"/>
    <Column Type="VARCHAR" Name="column_one" Required="true" Size="330"/>
    <Column Required="true" Name="column_two" Type="BIGINT"/>
    <Column Name="column_three" Required="true" Type="DECIMAL" Size="10"/>
    <Index Name="column_one_two_three">
        <IndexColumn Name="column_one"/>
        <IndexColumn Name="column_two"/>
        <IndexColumn Name="column_three"/>
    </Unique>
</Table>
EOF
        Exception => 1,
    },
);

scripts::test::OTOBOCodePolicyPlugins::Run( Tests => \@Tests );

done_testing;
 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