#!/usr/bin/perl -w
=head1 NAME

mhthread - sort an MH folder into 'threaded' order

=head1 SYNOPSIS

	mhthread [options] +folder
	mhthread [options] /path/to/folder

options accepted: [-debug] [-no-write] [-fast] [-lock]

=head1 DESCRIPTION

This will thread an MH folder.  It re-orders the messages (as sortm(1) would
do), and annotates each one with a new header, "X-MH-Thread-Markup", which can
be displayed by scan(1).

Together, this results in the messages being displayed in "threaded" order, as
in trn(1) or mutt(1).

Sequences will be rewritten appropriately.   The folder will also be "packed",
as if 'folder -pack' had been run; see folder(1).

=head1 RESULTS

Here's some sample output from scan(1), after threading the folder:

  430  03/23 mathew              3  [Asrg] Re: [OffTopic - NNTP]
  431  03/23 Kee Hinckley        5  |- [Asrg] Re: [OffTopic - NNTP]
  432 -03/23 Chuq Von Rospach   11  | |- Parameters for success? (was Re: [A
  433  03/23 To:Chuq Von Rospa   4  | | \- Re: Parameters for success? (was 
  434  03/23 Matt Sergeant       3  | \- Re: [Asrg] Re: [OffTopic - NNTP]
  435  03/23 Chuq Von Rospach    7  \- Re: [Asrg] Re: [OffTopic - NNTP]

=head1 OPTIONS

=over 4

=item -fast

Use an on-disk cache to speed up operation.

=item -lock

Use a folder-wide lock-file to synchronize access to folders, so that multiple
processes will not stomp on each other's changes or cause folder corruption.
If you use this, you should ensure that you also use a locking version of other
tools, such as the C<lockedrcvstore> script that comes with ExMH (typical
location: C</usr/lib/exmh*/misc/lockedrcvstore>).

=item -no-write

Do not rewrite the messages; instead, output a line for each message
noting the actions that would be taken.

=item -debug

Output debugging info to stderr.

=back

Note that options will also be read from the C<mhthread> entry in
your C<.mh_profile> file, in traditional MH style.

=head1 INSTALLATION FOR SCAN

To display the results in scan(1) output, use something like the following
for the subject-display part of the scan.form file:

  %(decode{x-mh-thread-markup})%(decode{subject})

If you do not have a "scan.form" file of your own, you will need to set it up.
This functionality is accessed using the -form or -format switches to the
scan(1) command.  To use this, copy the /etc/nmh/scan.default file to your
~/Mail dir and modify it with the above line, then add 

  scan: -form scan.form

to your ~/.mh_profile.

=head1 INSTALLATION FOR EXMH

Add the following function to your C<~/.tk/exmh/user.tcl> file:

  proc Folder_Thread {} {
    global exmh
    Background_Wait
    Exmh_Status "Threading folder..." blue
    if {[Ftoc_Changes "Thread"] == 0} then {
      if {[catch {MhExec mhthread +$exmh(folder)} err]} {
	  Exmh_Status $err error
      } else {
	# finish off by using the ExMH packing logic to redisplay folder
	Folder_Pack
	# then show the first unseen message
	Msg_ShowUnseen
      }
    }
  }

Next, you need to rebuild the C<tclIndex> file.  Run C<tclsh> and type:

  auto_mkindex ~/.tk/exmh *.tcl

Now add a button to run this function.  To do this, you must exit ExMH
first, then edit the C<~/.exmh/exmh-defaults> file and add these
files at the top of the file:

  *Fops.ubuttonlist: thread
  *Fops.thread.text: Thread
  *Fops.thread.command: Folder_Thread

Restart ExMH, and there should be a new button marked B<Thread> on the
folder button-bar.  Press this to re-thread the current folder.

=head1 NOTES

The threading algorithm uses the In-Reply-To, Message-Id and References
headers.  Thanks to JWZ for guidance, in the form of his page on threading at
C<http://www.jwz.org/doc/threading.html>.

The 'X-MH-Thread-Markup' headers are encoded using RFC-2047 encoding, using
'no-break space' characters for whitespace, as otherwise MH's scan(1) format
code will strip them.  Here's an example of the results:

  X-MH-Thread-Markup: =?US-ASCII?Q?=a0=a0=a0=a0=5c=2d=a0?=

=head1 TODO

dealing with private sequences (stored in .mh_profile); limiting displayed
thread-depth to keep UI readable (so far has not been a problem).

=head1 BUGS

duplicate messages will always be shuffled in order each time C<mhthread> is
run, due to handling of identical Message-Ids.

=head1 DOWNLOAD

Latest version can be found at http://jmason.org/software/mhthread/ .

=head1 AUTHOR

Justin Mason, C<jm dash mhthread dash nospam at jmason dot org>

=head1 VERSION

version = 1.5, Apr 25 2003 jm

=cut

sub usage {
  die "
usage: mhthread [options] +folder
       mhthread [options] /path/to/folder

options accepted: [-debug] [-no-write] [-fast] [-lock]
";
}

use vars qw(
  $mh_sequences_file_name $mhthread_options
);

read_mh_profile_data ();
if (defined $mhthread_options) {
  unshift (@ARGV, split(' ', $mhthread_options));
}

my $folder = '';
my $no_write = 0;
my $fast = 0;
my $lock = 0;
my $dbg = 0;

use Getopt::Long qw(:config no_ignore_case prefix_pattern=(--|-));
GetOptions(
	"debug" => \$dbg,
	"fast" => \$fast,
	"lock" => \$lock,
	"no-write" => \$no_write,
	'<>' => sub { $folder = $_[0]; }
);
usage unless ($folder =~ /\S/);

###########################################################################

use vars qw(
  %TZ %MONTH $locked_folder_lockfile
);

use strict;
use Time::Local;

if (!-d $folder) {
  chomp ($folder = `mhpath $folder`);
  if (!-d $folder) {
    usage();
  }
}

init_tz();

if ($lock) {
  $SIG{INT} = $SIG{TERM} = \&unlock_and_die;
  mh_lock_folder ($folder);
}

# trap die()s
eval {
  my $ctx = thread_folder ($folder);
  mh_rewrite_folder ($folder, $ctx);
};
my $err = $@;

# always unlock, even if we died
if ($lock) {
  mh_unlock_folder ($folder);
}

# and finally, propagate the death exception
if ($err) {
  die $err;
}

# otherwise we're fine, exit 0
exit;

###########################################################################

sub mh_lock_folder {
  $locked_folder_lockfile = $folder."/.lock";
  system ("lockfile", $locked_folder_lockfile);
  if ($? >> 8 != 0) {
    die "failed to lock folder $folder (lockfile $locked_folder_lockfile)\n";
    # $locked_folder_lockfile = undef;		# not needed, we're dead ;)
  }
}

sub mh_unlock_folder {
  if (defined $locked_folder_lockfile) {
    unlink $locked_folder_lockfile;
    $locked_folder_lockfile = undef;
  }
}

sub unlock_and_die {
  mh_unlock_folder();
  die "killed by signal\n";
}

###########################################################################

use vars qw(@to_unlink @to_rename %num2seq %newseqs);

sub mh_rewrite_folder {
  my ($folder, $ctx) = @_;

  my $newnum = 0;
  my %msg_rewritten = ();

  foreach my $num (@{$ctx->{all_message_locs}}) {
    $msg_rewritten{$num} = 0;
  }

  # read the mh_sequences file, and create the map of sequences in this
  # folder...  cf. man mh-sequence, man mark.
  %num2seq = ();
  %newseqs = ();
  if (open (IN, "<".$folder."/".$mh_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+): (.*h_sequences_file_name)) {
    while (<IN>) {
      /^([^:]+):