From owner-man-jp-reviewer@jp.freebsd.org  Sat Aug 25 15:05:16 2001
Received: (from daemon@localhost)
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) id PAA91475;
	Sat, 25 Aug 2001 15:05:16 +0900 (JST)
	(envelope-from owner-man-jp-reviewer@jp.FreeBSD.org)
Received: from iris.dti.ne.jp (PPP1.sendai-ap2.dti.ne.jp [210.170.212.1])
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) with ESMTP id PAA91468
	for <man-jp-reviewer@jp.freebsd.org>; Sat, 25 Aug 2001 15:05:09 +0900 (JST)
	(envelope-from dais@iris.dti.ne.jp)
Received: (from dais@localhost)
	by iris.dti.ne.jp (8.11.6/8.11.3) id f7P63S300697;
	Sat, 25 Aug 2001 15:03:28 +0900 (JST)
	(envelope-from dais)
Date: Sat, 25 Aug 2001 15:03:28 +0900 (JST)
Message-Id: <200108250603.f7P63S300697@iris.dti.ne.jp>
To: man-jp-reviewer@jp.freebsd.org
From: dais@iris.dti.ne.jp (Daisuke Higashi)
Mime-Version: 1.0
Content-Type: text/plain; charset=ISO-2022-JP
X-Mailer: mnews [version 1.22] 1999-12/19(Sun)
Reply-To: man-jp-reviewer@jp.freebsd.org
Precedence: list
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+010328
X-Sequence: man-jp-reviewer 3759
Subject: [man-jp-reviewer 3759] bzip2.1
Errors-To: owner-man-jp-reviewer@jp.freebsd.org
Sender: owner-man-jp-reviewer@jp.freebsd.org
X-Originator: dais@iris.dti.ne.jp

bzip2.1 $B$G$9!#(Breviewer $B$KN.$9$NK:$l$F$^$7$?!#(B

-------------------------------------------------------------------------
--- bzip2.1.en	Mon Aug  6 10:21:50 2001
+++ bzip2.1	Fri Aug 24 04:46:03 2001
@@ -1,13 +1,14 @@
 .PU
+.\" jpman %Id: bzip2.1,v 0.0 2001/08/06 01:03:38 horikawa Stab %
 .TH bzip2 1
-.SH NAME
-bzip2, bunzip2 \- a block-sorting file compressor, v1.0
+.SH $BL>>N(B
+bzip2, bunzip2 \- $B%V%m%C%/%=!<%F%#%s%0$K$h$k%U%!%$%k05=L4o(B, v1.0
 .br
-bzcat \- decompresses files to stdout
+bzcat \- $B%U%!%$%k$r?-D9$7$FI8=`=PNO$X=q$-=P$9(B
 .br
-bzip2recover \- recovers data from damaged bzip2 files
+bzip2recover \- $BGKB;$7$?(B bzip2 $B%U%!%$%k$+$i%G!<%?$rI|85(B
 
-.SH SYNOPSIS
+.SH $B=q<0(B
 .ll +8
 .B bzip2
 .RB [ " \-cdfkqstvzVL123456789 " ]
@@ -31,291 +32,268 @@
 .B bzip2recover
 .I "filename"
 
-.SH DESCRIPTION
+.SH $B@bL@(B
 .I bzip2
-compresses files using the Burrows-Wheeler block sorting
-text compression algorithm, and Huffman coding.  Compression is
-generally considerably better than that achieved by more conventional
-LZ77/LZ78-based compressors, and approaches the performance of the PPM
-family of statistical compressors.
-
-The command-line options are deliberately very similar to 
-those of 
-.I GNU gzip, 
-but they are not identical.
-
-.I bzip2
-expects a list of file names to accompany the
-command-line flags.  Each file is replaced by a compressed version of
-itself, with the name "original_name.bz2".  
-Each compressed file
-has the same modification date, permissions, and, when possible,
-ownership as the corresponding original, so that these properties can
-be correctly restored at decompression time.  File name handling is
-naive in the sense that there is no mechanism for preserving original
-file names, permissions, ownerships or dates in filesystems which lack
-these concepts, or have serious file name length restrictions, such as
-MS-DOS.
+$B$O(B Burrows-Wheeler $B%V%m%C%/%=!<%F%#%s%0%F%-%9%H05=L%"%k%4%j%:%`$H(B Huffman $BId9f$r(B
+$B;H$C$F%U%!%$%k$r05=L$7$^$9!#05=LN($OBgDq!"$h$j0lHLE*$J(B
+LZ77/LZ78 $B$r%Y!<%9$H$7$?05=L4o$h$jBgJQNI$/!"@-G=$O(B
+$BE}7WE*05=L4o$N(B PPM $B%U%!%_%j$KGw$C$F$$$^$9!#(B
+
+$B%3%^%s%I%i%$%s%*%W%7%g%s$O0U?^E*$K(B
+.I GNU gzip
+$B$N$b$N$K;w$;$F$"$j$^$9$,!"F10l$G$O$"$j$^$;$s!#(B
+
+.I bzip2
+$B$O%3%^%s%I%i%$%s%U%i%0$rH<$C$?%U%!%$%kL>$N%j%9%H$r<u$1<h$j$^$9!#(B
+$B3F%U%!%$%k$O(B "original_name.bz2" $B$H$$$&L>A0$N(B
+$B05=L:Q$_%U%!%$%k$GCV$-49$($i$l$^$9!#(B
+$B05=L$5$l$?3F%U%!%$%k$O!"85$N%U%!%$%k$HF1$899?7;~9o$*$h$S%Q!<%_%C%7%g%s$r(B
+$B;}$A!"$=$7$F2DG=$J$iF1$8=jM-<T$H$J$j$^$9!#(B
+$B$7$?$,$C$F$3$l$i$NB0@-$O?-D9;~$K@5$7$/I|85$5$l$^$9!#(B
+$B%U%!%$%kL>$N07$$$OC1=c$G!"(B
+$B85%U%!%$%k$NL>A0!"%Q!<%_%C%7%g%s!"=jM-<T$H$$$&35G0$,L5$+$C$?$j!"(B
+MS-DOS $B$N$h$&$K%U%!%$%kL>$ND9$5$KBg$-$J@)8B$,$"$k%U%!%$%k%7%9%F%`(B
+$B$G$O!"$=$l$i$rJ]B8$9$k5!9=$O$"$j$^$;$s!#(B
 
 .I bzip2
-and
+$B$H(B
 .I bunzip2
-will by default not overwrite existing
-files.  If you want this to happen, specify the \-f flag.
+$B$O!"%G%U%)%k%H$G$O4{B8$N%U%!%$%k$r>e=q$-$7$^$;$s!#(B
+$B>e=q$-$7$?$$>l9g$O(B \-f $B%U%i%0$r;XDj$7$F$/$@$5$$!#(B
 
-If no file names are specified,
+$B%U%!%$%kL>$,;XDj$5$l$J$$>l9g!"(B
 .I bzip2
-compresses from standard
-input to standard output.  In this case,
+$B$OI8=`F~NO$r05=L$7$FI8=`=PNO$X=q$-=P$7$^$9!#$3$N>l9g(B
 .I bzip2
-will decline to
-write compressed output to a terminal, as this would be entirely
-incomprehensible and therefore pointless.
+$B$O05=L$5$l$?7k2L$rC<Kv$X=q$-=P$7$^$;$s!#$=$l$OA4$/FI$`$3$H$,$G$-$:!"(B
+$B=PNO$9$k$3$H$OL50UL#$@$+$i$G$9!#(B
 
 .I bunzip2
-(or
-.I bzip2 \-d) 
-decompresses all
-specified files.  Files which were not created by 
-.I bzip2
-will be detected and ignored, and a warning issued.  
-.I bzip2
-attempts to guess the filename for the decompressed file 
-from that of the compressed file as follows:
-
-       filename.bz2    becomes   filename
-       filename.bz     becomes   filename
-       filename.tbz2   becomes   filename.tar
-       filename.tbz    becomes   filename.tar
-       anyothername    becomes   anyothername.out
+($B$^$?$O(B
+.I bzip2 \-d)
+$B$O;XDj$5$l$?$9$Y$F$N%U%!%$%k$r?-D9$7$^$9!#(B 
+bzip2 $B$G@8@.$5$l$?$N$G$O$J$$%U%!%$%k$r8!CN$7!"L5;k$7!"(B
+$B$5$i$K7Y9p$rH/$7$^$9!#(B
+.I bzip2
+$B$O0J2<$N$h$&$K$7$F05=L:Q$_%U%!%$%k$NL>A0$+$i(B
+$B?-D98e$N%U%!%$%kL>$r?dB,$7$^$9(B:
+
+       filename.bz2    $B$O(B   filename          $B$H$7$^$9!#(B
+       filename.bz     $B$O(B   filename          $B$H$7$^$9!#(B
+       filename.tbz2   $B$O(B   filename.tar      $B$H$7$^$9!#(B
+       filename.tbz    $B$O(B   filename.tar      $B$H$7$^$9!#(B
+       anyothername    $B$O(B   anyothername.out  $B$H$7$^$9!#(B
 
-If the file does not end in one of the recognised endings, 
+$B%U%!%$%kL>$,(B
 .I .bz2, 
 .I .bz, 
 .I .tbz2
-or
-.I .tbz, 
+$B$^$?$O(B
+.I .tbz
+$B$N$h$&$J!"G'<1$G$-$kL>A0$G=*$o$C$F$$$J$$>l9g!"(B
 .I bzip2 
-complains that it cannot
-guess the name of the original file, and uses the original name
-with
+$B$O85$N%U%!%$%kL>$,?dB,$G$-$J$$;]$rDLCN$7$F(B
 .I .out
-appended.
+$B$rIU2C$7$?L>A0$r85$N%U%!%$%kL>$H$7$F;H$$$^$9!#(B
 
-As with compression, supplying no
-filenames causes decompression from 
-standard input to standard output.
+$B05=L$N>l9g$HF1MM$K!"%U%!%$%kL>$,;XDj$5$l$J$$>l9g$O(B
+$BI8=`F~NO$r05=L$7$FI8=`=PNO$X=q$-=P$7$^$9!#(B
 
 .I bunzip2 
-will correctly decompress a file which is the
-concatenation of two or more compressed files.  The result is the
-concatenation of the corresponding uncompressed files.  Integrity
-testing (\-t) 
-of concatenated 
-compressed files is also supported.
-
-You can also compress or decompress files to the standard output by
-giving the \-c flag.  Multiple files may be compressed and
-decompressed like this.  The resulting outputs are fed sequentially to
-stdout.  Compression of multiple files 
-in this manner generates a stream
-containing multiple compressed file representations.  Such a stream
-can be decompressed correctly only by
+$B$O(B 2 $B$D0J>e$N05=L:Q$_%U%!%$%k$rO"7k$7$?%U%!%$%k$r@5$7$/?-D9$7$^$9!#(B
+$BF@$i$l$k%U%!%$%k$O!"05=LA0$N%U%!%$%k$rO"7k$7$?$b$N$G$9!#(B
+$BO"7k$7$?05=L%U%!%$%k$KBP$7$F$b7rA4@-$N%F%9%H(B (\-t) $B$,%5%]!<%H$5$l$F$$$^$9!#(B
+
+\-c $B%U%i%0$rM?$($k$3$H$G!"%U%!%$%k$r05=L$^$?$O?-D9$7$?7k2L$r(B
+$BI8=`=PNO$X=q$-=P$9$3$H$,$G$-$^$9!#$3$N%U%i%0$rM?$($F!"(B
+$BJ#?t$N%U%!%$%k$r05=L$^$?$O?-D9$9$k$3$H$,$G$-$^$9!#7k2L$O(B
+$BI8=`=PNO$X=gHV$K=q$-=P$5$l$^$9!#$3$NJ}<0$K$h$kJ#?t%U%!%$%k$N05=L$G$O!"(B
+$BJ#?t$N05=L%U%!%$%k$+$i$J$k%9%H%j!<%`$,@8@.$5$l$^$9!#(B
+$B$3$N%9%H%j!<%`$O!"%P!<%8%g%s(B 0.9.0 $B0J9_$N(B
 .I bzip2 
-version 0.9.0 or
-later.  Earlier versions of
+$B$G$7$+@5$7$/?-D9$G$-$^$;$s!#$3$l$h$jA0$N%P!<%8%g%s$N(B
 .I bzip2
-will stop after decompressing
-the first file in the stream.
+$B$G$O!"%9%H%j!<%`Cf$N:G=i$N%U%!%$%k$r?-D9$7$?8e$KDd;_$7$^$9!#(B
 
 .I bzcat
-(or
+($B$^$?$O(B
 .I bzip2 -dc) 
-decompresses all specified files to
-the standard output.
+$B$O;XDj$5$l$?A4$F$N%U%!%$%k$r?-D9$7!"I8=`=PNO$K=q$-=P$7$^$9!#(B
 
 .I bzip2
-will read arguments from the environment variables
+$B$O0z?t$H$7$F4D6-JQ?t(B
 .I BZIP2
-and
-.I BZIP,
-in that order, and will process them
-before any arguments read from the command line.  This gives a 
-convenient way to supply default arguments.
-
-Compression is always performed, even if the compressed 
-file is slightly
-larger than the original.  Files of less than about one hundred bytes
-tend to get larger, since the compression mechanism has a constant
-overhead in the region of 50 bytes.  Random data (including the output
-of most file compressors) is coded at about 8.05 bits per byte, giving
-an expansion of around 0.5%.
+$B$H(B
+.I BZIP
+$B$r=gHV$KFI$_!"(B
+$B%3%^%s%I%i%$%s$+$iFI$s$@0z?t$h$j@h$K=hM}$7$^$9!#(B
+$B$3$l$O%G%U%)%k%H$N0z?t$rM?$($k$N$KJXMx$G$9!#(B
+
+$B05=L8e$N%U%!%$%k$,85$N%U%!%$%k$h$j$b>/$7Bg$-$/$J$k>l9g$G$b!"(B
+$B>o$K05=L$O9T$o$l$^$9!#(B
+$B05=L5!9=$K$O>o$K(B 50 $B%P%$%H$N%*!<%P%X%C%I$,$"$k$N$G!"(B
+$BLs(B 100 $B%P%$%H$h$j$b>.$5$J%U%!%$%k$OBg$-$/$J$k798~$,$"$j$^$9!#(B
+$B%i%s%@%`$J%G!<%?(B ( $B$[$H$s$I$N%U%!%$%k05=L4o$N=PNO$b(B )
+$B$O(B 1 $B%P%$%HEv$?$jLs(B 8.05 $B%S%C%H$GId9f2=$5$l!"Ls(B 0.5% $BBg$-$/$J$j$^$9!#(B
 
-As a self-check for your protection, 
+$BJ]8n$N$?$a$N<+8J%A%'%C%/$H$7$F!"(B
 .I 
 bzip2
-uses 32-bit CRCs to
-make sure that the decompressed version of a file is identical to the
-original.  This guards against corruption of the compressed data, and
-against undetected bugs in
-.I bzip2
-(hopefully very unlikely).  The
-chances of data corruption going undetected is microscopic, about one
-chance in four billion for each file processed.  Be aware, though, that
-the check occurs upon decompression, so it can only tell you that
-something is wrong.  It can't help you 
-recover the original uncompressed
-data.  You can use 
+$B$O!"?-D98e$N%U%!%$%k$H85$N%U%!%$%k$H$NF10l@-$r3N$+$a$k(B
+$B$?$a$K(B 32 $B%S%C%H(B CRC $B$r;H$$$^$9!#(B
+$B$3$l$K$h$j!"05=L:Q$_%G!<%?$NGKB;$d(B
+.I bzip2
+$B$N$^$@8+$D$+$C$F$$$J$$%P%0(B ( $B$[$H$s$IL5$$$O$9$G$9(B ) $B$+$i<i$j$^$9!#(B
+$B%G!<%?$NGK2u$,8!=P$G$-$J$$3NN($O6K$a$F>.$5$/!"3F%U%!%$%k$N=hM}(B
+40 $B2/2s$"$?$j(B 1 $B2sDxEY$G$9!#(B
+$B$?$@$7!"$3$N%A%'%C%/$O?-D9$N;~$K$7$+9T$o$l$:!"$7$?$,$C$F(B
+$B2?$+4V0c$$$,H/@8$7$?$3$H$7$+J,$+$j$^$;$s!#(B
+$B05=LA0$N85%G!<%?$rI|85$9$k$N$K$OLr$KN)$A$^$;$s!#(B
+$BGKB;$7$?%U%!%$%k$+$i%G!<%?$rI|85$9$k$N$K(B
 .I bzip2recover
-to try to recover data from
-damaged files.
+$B$r;H$&$3$H$O$G$-$^$9!#(B
 
-Return values: 0 for a normal exit, 1 for environmental problems (file
-not found, invalid flags, I/O errors, &c), 2 to indicate a corrupt
-compressed file, 3 for an internal consistency error (eg, bug) which
-caused
+$BJV$jCM(B: $B@5>o=*N;$N>l9g$O(B 0 $B$,JV$5$l$^$9!#(B
+$B<B9T4D6-$NLdBj(B ($B%U%!%$%k$,8+$D$+$i$J$$!"L58z$J%U%i%0!"F~=PNO%(%i!<$J$I(B)
+$B$N>l9g$O(B 1 $B$,JV$5$l$^$9!#05=L%U%!%$%k$,GKB;$7$F$$$k>l9g$O(B 2 $B$,JV$5$l$^$9!#(B
 .I bzip2
-to panic.
+$B$K%Q%K%C%/$r0z$-5/$3$9FbIt@09g@-%(%i!<(B ($BNc$($P%P%0(B) $B$N>l9g$O(B 3 $B$,JV$5$l$^$9!#(B
 
-.SH OPTIONS
+.SH $B%*%W%7%g%s(B
 .TP
 .B \-c --stdout
-Compress or decompress to standard output.
+$B05=L$^$?$O?-D9$7$?7k2L$rI8=`=PNO$K=q$-=P$7$^$9!#(B
 .TP
 .B \-d --decompress
-Force decompression.  
+$B%U%!%$%k$N?-D9$r6/@)$7$^$9!#(B
 .I bzip2, 
-.I bunzip2 
-and
+.I bunzip2,
 .I bzcat 
-are
-really the same program, and the decision about what actions to take is
-done on the basis of which name is used.  This flag overrides that
-mechanism, and forces 
+$B$O<B:]$K$OF1$8%W%m%0%i%`$G$9!#$I$NF0:n$r$9$k$N$+$O!"(B
+$B$I$NL>A0$,;H$o$l$?$+$K4p$E$$$F7h$a$i$l$^$9!#(B
+$B$3$N%U%i%0$O$=$l$h$j$bM%@h$5$l!"(B
 .I bzip2
-to decompress.
+$B$K%U%!%$%k$N?-D9$r$5$;$^$9!#(B
 .TP
 .B \-z --compress
-The complement to \-d: forces compression, regardless of the
-invokation name.
+\-d $B$NH?BP(B: $B5/F0;~$NL>A0$K$+$+$o$i$:!"05=L$r6/@)$7$^$9!#(B
 .TP
 .B \-t --test
-Check integrity of the specified file(s), but don't decompress them.
-This really performs a trial decompression and throws away the result.
+$B;XDj$5$l$?%U%!%$%k$N7rA4@-%A%'%C%/$r$7$^$9!#?-D9$O$7$^$;$s!#(B
+$B<B:]$K$O?-D9$r;n$_!"$=$N7k2L$O<N$F$F$$$^$9!#(B
 .TP
 .B \-f --force
-Force overwrite of output files.  Normally,
+$B=PNO%U%!%$%k$N>e=q$-$r6/@)$7$^$9!#DL>o(B
 .I bzip2 
-will not overwrite
-existing output files.  Also forces 
+$B$O4{B8$N=PNO%U%!%$%k$r>e=q$-$7$^$;$s!#$5$i$K(B
 .I bzip2 
-to break hard links
-to files, which it otherwise wouldn't do.
+$B$K%U%!%$%k$X$N%O!<%I%j%s%/$r:o=|$5$;$^$9!#$3$N(B
+$B%*%W%7%g%s$,;XDj$5$l$F$$$J$$>l9g$O!"%O!<%I%j%s%/$N:o=|$O$5$l$^$;$s!#(B
 .TP
 .B \-k --keep
-Keep (don't delete) input files during compression
-or decompression.
+$B05=L$^$?$O?-D98e$G$bF~NO%U%!%$%k$rJ]B8$7$^$9(B ($B:o=|$7$^$;$s(B)$B!#(B
 .TP
 .B \-s --small
-Reduce memory usage, for compression, decompression and testing.  Files
-are decompressed and tested using a modified algorithm which only
-requires 2.5 bytes per block byte.  This means any file can be
-decompressed in 2300k of memory, albeit at about half the normal speed.
-
-During compression, \-s selects a block size of 200k, which limits
-memory use to around the same figure, at the expense of your compression
-ratio.  In short, if your machine is low on memory (8 megabytes or
-less), use \-s for everything.  See MEMORY MANAGEMENT below.
+$B05=L!"?-D9!"%F%9%H$N:]$N%a%b%j;HMQNL$r8:$i$7$^$9!#(B
+$B%V%m%C%/%P%$%HEv$?$j(B 2.5 $B%P%$%H$7$+I,MW$H$7$J$$$h$&$KJQ99$5$l$?(B
+$B%"%k%4%j%:%`$r;H$C$F!"%U%!%$%k$N?-D9$d%F%9%H$,9T$o$l$^$9!#(B
+$BA4$F$N%U%!%$%k$,(B 2300kB $B$N%a%b%j$G?-D9$G$-$^$9$,!"(B
+$BDL>o$NLsH>J,$NB.EY$K$J$C$F$7$^$$$^$9!#(B
+
+$B05=L;~$K(B \-s $B%U%i%0$r;H$&$H(B 200k $B$N%V%m%C%/%5%$%:$,A*Br$5$l$^$9!#(B
+$B%a%b%j;HMQNL$O$=$l$/$i$$$K@)8B$5$l$^$9$,!"05=LN($,5>@7$K$J$j$^$9!#(B
+$B$D$^$j!"%^%7%s$KEk:\$5$l$F$$$k%a%b%j$,>/$J$1$l$P(B ( 8 $B%a%,%P%$%H0J2<(B)
+$B$D$M$K(B \-s $B%U%i%0$r;H$C$F$/$@$5$$!#2<$N%a%b%j4IM}$N9`L\$r;2>H$7$F$/$@$5$$!#(B
 .TP
 .B \-q --quiet
-Suppress non-essential warning messages.  Messages pertaining to
-I/O errors and other critical events will not be suppressed.
+$BK\<AE*$G$J$$7Y9p%a%C%;!<%8$O=PNO$7$^$;$s!#F~=PNO%(%i!<$H(B
+$BCWL?E*$J%$%Y%s%H$K4XO"$9$k%a%C%;!<%8$O=PNO$5$l$^$9!#(B
 .TP
 .B \-v --verbose
-Verbose mode -- show the compression ratio for each file processed.
-Further \-v's increase the verbosity level, spewing out lots of
-information which is primarily of interest for diagnostic purposes.
+$B>\:YI=<(%b!<%I$G$9!#=hM}$5$l$?%U%!%$%kKh$K05=LN($rI=<($7$^$9!#(B
+$B$5$i$K(B \-v $B$rM?$($k$H>\:YI=<($N%l%Y%k$,>e$,$j!"<g$K?GCG$rL\E*$H$9$k(B
+$BB?$/$N>pJs$,=PNO$5$l$^$9!#(B
 .TP
 .B \-L --license -V --version
-Display the software version, license terms and conditions.
+$B%=%U%H%&%'%"$N%P!<%8%g%s!"%i%$%;%s%9>r9`$H$=$N>r7o$,I=<($5$l$^$9!#(B
 .TP
-.B \-1 to \-9
-Set the block size to 100 k, 200 k ..  900 k when compressing.  Has no
-effect when decompressing.  See MEMORY MANAGEMENT below.
+.B \-1 $B$+$i(B \-9
+$B05=L;~$N%V%m%C%/%5%$%:$r(B 100 k, 200 k ..  900 k $B$K@_Dj$7$^$9!#(B
+$B?-D9;~$K$O2?$b1F6A$,$"$j$^$;$s!#2<$N%a%b%j4IM}$N9`L\$r;2>H$7$F$/$@$5$$!#(B
 .TP
 .B \--
-Treats all subsequent arguments as file names, even if they start
-with a dash.  This is so you can handle files with names beginning
-with a dash, for example: bzip2 \-- \-myfilename.
+$B$3$l0J9_$N0z?t$K$D$$$F$O%@%C%7%e$G;O$^$k$b$N$G$b%U%!%$%kL>$H$7$F(B
+$B07$o$l$^$9!#$3$l$K$h$j%@%C%7%e$G;O$^$k%U%!%$%kL>$b07$&$3$H$,(B
+$B$G$-$^$9!#Nc$($P$D$.$N$h$&$K;H$$$^$9(B: bzip2 \-- \-myfilename
 .TP
 .B \--repetitive-fast --repetitive-best
-These flags are redundant in versions 0.9.5 and above.  They provided
-some coarse control over the behaviour of the sorting algorithm in
-earlier versions, which was sometimes useful.  0.9.5 and above have an
-improved algorithm which renders these flags irrelevant.
+$B$3$l$i$N%U%i%0$O!"%P!<%8%g%s(B 0.9.5 $B0J9_$G$O>iD9$G$9!#(B
+$B$3$l$i$O0JA0$N%P!<%8%g%s$G@0Ns%"%k%4%j%:%`$NF0:n$rBg;(GD$K(B
+$B@)8f$9$k$?$a$KDs6!$5$l$?$b$N$G!";~!9$OLrN)$C$F$$$?$b$N$G$7$?!#(B
+0.9.5 $B0J9_$G$3$l$i$N%U%i%0$,L54X78$K$J$k2~NI$5$l$?%"%k%4%:%`$,;H$o$l$F$$$^$9!#(B
 
-.SH MEMORY MANAGEMENT
+.SH $B%a%b%j4IM}(B
 .I bzip2 
-compresses large files in blocks.  The block size affects
-both the compression ratio achieved, and the amount of memory needed for
-compression and decompression.  The flags \-1 through \-9
-specify the block size to be 100,000 bytes through 900,000 bytes (the
-default) respectively.  At decompression time, the block size used for
-compression is read from the header of the compressed file, and
-.I bunzip2
-then allocates itself just enough memory to decompress
-the file.  Since block sizes are stored in compressed files, it follows
-that the flags \-1 to \-9 are irrelevant to and so ignored
-during decompression.
+$B$OBg$-$J%U%!%$%k$r%V%m%C%/Kh$K05=L$7$^$9!#%V%m%C%/%5%$%:$O(B
+$B05=LN($H!"05=L$^$?$O?-D9$KMW$9$k%a%b%j$NNL$K1F6A$7$^$9!#(B
+\-1 $B$+$i(B \-9 $B$^$G$N%U%i%0$O!"$=$l$>$l%V%m%C%/%5%$%:$r(B 100,000 $B%P%$%H$+$i(B
+900,000 $B%P%$%H(B ($B%G%U%)%k%H(B) $B$K;XDj$7$^$9!#?-D9;~$K$O!"(B
+$B05=L$K;H$o$l$?%V%m%C%/%5%$%:$,05=L%U%!%$%k$N%X%C%@$+$iFI$^$l!"(B
+.I bunzip2 
+$B$O%U%!%$%k$r?-D9$9$k$N$K==J,$J%U%!%$%k$r3NJ]$7$^$9!#(B
+$B%V%m%C%/%5%$%:$O05=L%U%!%$%k$K3JG<$5$l$F$$$k$N$G!"(B
+$B?-D9;~$K$O%U%i%0(B \-1 $B$+$i(B \-9 $B$^$G$OL5;k$5$l$^$9!#(B
 
-Compression and decompression requirements, 
-in bytes, can be estimated as:
+$B05=L$H?-D9$KI,MW$J%a%b%jNL$O<!$N$h$&$K8+@Q$b$k$3$H$,$G$-$^$9(B:
 
-       Compression:   400k + ( 8 x block size )
+       $B05=L(B:   400k + ( 8 x $B%V%m%C%/%5%$%:(B )
 
-       Decompression: 100k + ( 4 x block size ), or
-                      100k + ( 2.5 x block size )
+       $B?-D9(B:   100k + ( 4 x $B%V%m%C%/%5%$%:(B ), $B$^$?$O(B
+                      100k + ( 2.5 x $B%V%m%C%/%5%$%:(B )
 
-Larger block sizes give rapidly diminishing marginal returns.  Most of
-the compression comes from the first two or three hundred k of block
-size, a fact worth bearing in mind when using
+$B%V%m%C%/%5%$%:$rBg$-$/$9$k$K$7$?$,$$!"8z2L$O5^B.$K8:>/$7$F$$$-$^$9!#(B
+$BBgItJ,$N05=L$O:G=i$N(B 200k $B$"$k$$$O(B 300k $B$N%V%m%C%/%5%$%:$GF@$i$l$^$9!#(B
+$B$3$N;v<B$r3P$($F$*$1$P!">.5,LO$J%^%7%s$G(B
 .I bzip2
-on small machines.
-It is also important to appreciate that the decompression memory
-requirement is set at compression time by the choice of block size.
+$B$r;H$&$H$-$KLrN)$D$G$7$g$&!#(B
+$B$^$?!"05=L;~$KA*Br$5$l$?%V%m%C%/%5%$%:$K$h$j(B
+$B?-D9$KI,MW$J%a%b%jNL$,@_Dj$5$l$k$3$HCN$C$F$*$/$N$b=EMW$G$9!#(B
 
-For files compressed with the default 900k block size,
+$B%V%m%C%/%5%$%:$,%G%U%)%k%H$N(B 900k $B$G05=L$5$l$?%U%!%$%k$r(B
 .I bunzip2
-will require about 3700 kbytes to decompress.  To support decompression
-of any file on a 4 megabyte machine, 
+$B$,?-D9$9$k;~$O(B 3700 k$B%P%$%HI,MW$G$9!#(B
+4 $B%a%,%P%$%H$7$+%a%b%j$rEk:\$7$F$$$J$$%^%7%s$G$"$i$f$k%U%!%$%k$r(B
+$B?-D9$9$k$?$a$K!"(B
 .I bunzip2
-has an option to
-decompress using approximately half this amount of memory, about 2300
-kbytes.  Decompression speed is also halved, so you should use this
-option only where necessary.  The relevant flag is -s.
-
-In general, try and use the largest block size memory constraints allow,
-since that maximises the compression achieved.  Compression and
-decompression speed are virtually unaffected by block size.
-
-Another significant point applies to files which fit in a single block
--- that means most files you'd encounter using a large block size.  The
-amount of real memory touched is proportional to the size of the file,
-since the file is smaller than a block.  For example, compressing a file
-20,000 bytes long with the flag -9 will cause the compressor to
-allocate around 7600k of memory, but only touch 400k + 20000 * 8 = 560
-kbytes of it.  Similarly, the decompressor will allocate 3700k but only
-touch 100k + 20000 * 4 = 180 kbytes.
-
-Here is a table which summarises the maximum memory usage for different
-block sizes.  Also recorded is the total compressed size for 14 files of
-the Calgary Text Compression Corpus totalling 3,141,622 bytes.  This
-column gives some feel for how compression varies with block size.
-These figures tend to understate the advantage of larger block sizes for
-larger files, since the Corpus is dominated by smaller files.
+$B$K$O!"LsH>J,$N(B 2300 $B%-%m%P%$%H$NNL$N%a%b%j$r;H$&%*%W%7%g%s$,$"$j$^$9!#(B
+$B?-D9B.EY$bH>J,$K$J$k$N$G!"$3$N%*%W%7%g%s$OI,MW$J>l9g$K$N$_;H$&$Y$-$G$9!#(B
+$B$=$N%U%i%0$O(B -s $B$G$9!#(B
+
+$B0lHL$K$O%a%b%jNL$,5v$98B$jBg$-$J%V%m%C%/%5%$%:$r;n$7$F;H$C$F$/$@$5$$!#(B
+$B$3$&$9$k$3$H$G:G$b9b$$05=LN($rC#@.$G$-$^$9!#(B
+$B%V%m%C%/%5%$%:$O!"05=L$H?-D9$NB.EY$K$[$H$s$I1F6A$7$^$;$s!#(B
+
+$BC10l$N%V%m%C%/$K<}$^$C$F$$$k%U%!%$%k$K4X$7$F$O!"$b$&0l$D$N(B
+$B=EMW$J%]%$%s%H$,$"$j$^$9!#$3$l$OBg$-$J%V%m%C%/%5%$%:$K$7$?>l9g$K(B
+$B$[$H$s$I$N%U%!%$%k$,$"$F$O$^$j$^$9!#(B
+$B$3$N>l9g!"%U%!%$%k$O%V%m%C%/$h$j>.$5$$$N$G!"(B
+$BMxMQ$5$l$k<B%a%b%j$NNL$O%U%!%$%k$NBg$-$5$KHfNc$7$^$9!#(B
+$BNc$($P!"D9$5$,(B 20,000 $B%P%$%H$N%U%!%$%k$r(B -9 $B$H$$$&%U%i%0$r(B
+$BM?$($F05=L$9$k>l9g!"05=L4o$OLs(B 7600k $B$N%a%b%j$r3d$jEv$F$^$9$,!"(B
+$B$=$N$&$A(B 400k + 20000 * 8 = 560 k$B%P%$%H$7$+;H$$$^$;$s!#(B
+$BF1MM$K?-D94o$O(B 3700k $B$r3d$jEv$F$^$9$,!"(B
+100k + 20000 * 4 = 180 k$B%P%$%H$7$+;H$$$^$;$s!#(B
+
+$B0[$J$k%V%m%C%/%5%$%:$K$*$1$k:GBg%a%b%j;HMQNL$r<($7$^$9!#(B
+$BA4It$G(B 14 $B%U%!%$%k!"9g7W(B 3,141,622 $B%P%$%H$N(B
+$B%+%k%,%j!<Bg3X%F%-%9%H05=L%3!<%Q%9$r05=L$7$?8e$N%5%$%:$b<($7$^$9!#(B
+$B9TKh$KHf$Y$k$H!"%V%m%C%/%5%$%:$K$h$C$F05=L$,$I$N$h$&$KJQ$o$k$+$r(B
+$BCN$k$3$H$,$G$-$^$9!#%3!<%Q%9$O>.$5$J%U%!%$%k$G@j$a$i$l$F$$$k$N$G!"(B
+$B$3$l$i$NI=$OBg$-$J%U%!%$%k$KBP$7$FBg$-$J%V%m%C%/%5%$%:$r;H$C$?>l9g$NMxE@$r(B
+$B95$($a$K$7$+=R$Y$F$$$^$;$s!#(B
 
-           Compress   Decompress   Decompress   Corpus
-    Flag     usage      usage       -s usage     Size
+            $B05=L;~(B     $B?-D9;~(B    $B?-D9;~(B       $B%3!<%Q%9$N(B
+   $B%U%i%0(B   $B;HMQNL(B     $B;HMQNL(B    $B;HMQNL(B (-s)    $B%5%$%:(B
 
      -1      1200k       500k         350k      914704
      -2      2000k       900k         600k      877703
@@ -327,113 +305,109 @@
      -8      6800k      3300k        2100k      828642
      -9      7600k      3700k        2350k      828642
 
-.SH RECOVERING DATA FROM DAMAGED FILES
+.SH $BGKB;$7$?%U%!%$%k$+$i%G!<%?$rI|85$9$k(B
 .I bzip2
-compresses files in blocks, usually 900kbytes long.  Each
-block is handled independently.  If a media or transmission error causes
-a multi-block .bz2
-file to become damaged, it may be possible to
-recover data from the undamaged blocks in the file.
-
-The compressed representation of each block is delimited by a 48-bit
-pattern, which makes it possible to find the block boundaries with
-reasonable certainty.  Each block also carries its own 32-bit CRC, so
-damaged blocks can be distinguished from undamaged ones.
+$B$O%U%!%$%k$rBgDq(B 900 $B%-%m%P%$%H$N%V%m%C%/Kh$K05=L$7$^$9!#(B
+$B$=$l$>$l$N%V%m%C%/$OFHN)$K07$o$l$^$9!#(B
+$B%a%G%#%"$dE>Aw;~$N8m$j$K$h$j!"(B
+$BJ#?t%V%m%C%/$+$i$J$k(B .bz2 $B%U%!%$%k$,GK2u$5$l$?>l9g$G$b!"(B
+$B%U%!%$%kCf$NGKB;$7$F$$$J$$%V%m%C%/$+$i%G!<%?$rI|85$G$-$k(B
+$B2DG=@-$,$"$j$^$9!#(B
+
+$B3F%V%m%C%/$N05=L$5$l$?I=8=$O(B 48 $B%S%C%H$N%Q%?%s$G6h@Z$i$l$F$*$j!"(B
+$B$3$l$r;H$C$F%V%m%C%/$N6-3&$r==J,3N<B$K8+$D$1$k$3$H$,$G$-$^$9!#(B
+$B3F%V%m%C%/$O(B 32 $B%S%C%H$N(B CRC $B$r;}$A!"GKB;$7$?%V%m%C%/$r(B
+$BGKB;$7$F$$$J$$%V%m%C%/$H6hJL$9$k$3$H$,$G$-$^$9!#(B
 
 .I bzip2recover
-is a simple program whose purpose is to search for
-blocks in .bz2 files, and write each block out into its own .bz2 
-file.  You can then use
+$B$O(B .bz2 $B%U%!%$%kCf$N%V%m%C%/$rC5$7!"(B
+$B$=$l$>$l$N%V%m%C%/$r$=$l$>$l$N(B .bz2 $B%U%!%$%k$X=q$-=P$9(B
+$BC1=c$J%W%m%0%i%`$G$9!#$5$i$K(B
 .I bzip2 
 \-t
-to test the
-integrity of the resulting files, and decompress those which are
-undamaged.
+$B$r;H$C$FF@$i$l$?3F%U%!%$%k$N7rA4@-$r%F%9%H$7!"GKB;$7$F$$$J$$(B
+$B%U%!%$%k$r?-D9$9$k$3$H$,$G$-$^$9!#(B
 
 .I bzip2recover
-takes a single argument, the name of the damaged file, 
-and writes a number of files "rec0001file.bz2",
-"rec0002file.bz2", etc, containing the  extracted  blocks.
-The  output  filenames  are  designed  so  that the use of
-wildcards in subsequent processing -- for example,  
-"bzip2 -dc  rec*file.bz2 > recovered_data" -- lists the files in
-the correct order.
+$B$OC10l$N0z?t$H$7$FGKB;$7$?%U%!%$%k$NL>A0$r$H$j!"(B
+$BCj=P$5$l$?%V%m%C%/$r4^$`(B "rec0001file.bz2", "rec0002file.bz2"
+... $B$H$$$&BgNL$N%U%!%$%k$r=q$-=P$7$^$9!#=PNO$5$l$k%U%!%$%kL>$O(B
+$B$=$N8e$N=hM}$G%o%$%k%I%+!<%I$,;H$($k$h$&$K@_7W$5$l$F$$$^$9!#(B
+$BNc$($P(B "bzip2 -dc  rec*file.bz2 > recovered_data" $B$H$9$l$P!"(B
+$B%U%!%$%k$r@5$7$$=gHV$KJB$Y$k$3$H$,$G$-$^$9!#(B
 
 .I bzip2recover
-should be of most use dealing with large .bz2
-files,  as  these will contain many blocks.  It is clearly
-futile to use it on damaged single-block  files,  since  a
-damaged  block  cannot  be recovered.  If you wish to minimise 
-any potential data loss through media  or  transmission errors, 
-you might consider compressing with a smaller
-block size.
-
-.SH PERFORMANCE NOTES
-The sorting phase of compression gathers together similar strings in the
-file.  Because of this, files containing very long runs of repeated
-symbols, like "aabaabaabaab ..."  (repeated several hundred times) may
-compress more slowly than normal.  Versions 0.9.5 and above fare much
-better than previous versions in this respect.  The ratio between
-worst-case and average-case compression time is in the region of 10:1.
-For previous versions, this figure was more like 100:1.  You can use the
-\-vvvv option to monitor progress in great detail, if you want.
-
-Decompression speed is unaffected by these phenomena.
-
-.I bzip2
-usually allocates several megabytes of memory to operate
-in, and then charges all over it in a fairly random fashion.  This means
-that performance, both for compressing and decompressing, is largely
-determined by the speed at which your machine can service cache misses.
-Because of this, small changes to the code to reduce the miss rate have
-been observed to give disproportionately large performance improvements.
-I imagine 
-.I bzip2
-will perform best on machines with very large caches.
-
-.SH CAVEATS
-I/O error messages are not as helpful as they could be.
-.I bzip2
-tries hard to detect I/O errors and exit cleanly, but the details of
-what the problem is sometimes seem rather misleading.
-
-This manual page pertains to version 1.0 of
-.I bzip2.  
-Compressed
-data created by this version is entirely forwards and backwards
-compatible with the previous public releases, versions 0.1pl2, 0.9.0
-and 0.9.5,
-but with the following exception: 0.9.0 and above can correctly
-decompress multiple concatenated compressed files.  0.1pl2 cannot do
-this; it will stop after decompressing just the first file in the
-stream.
+$B$OBg$-$J(B .bz2 $B%U%!%$%k$r07$&$H$-$K:G$bLr$KN)$A$^$9!#(B
+$BBg$-$J(B .bz2 $B%U%!%$%k$K$OBgNL$N%V%m%C%/$,4^$^$l$F$$$k$+$i$G$9!#(B
+$BC10l$N%V%m%C%/$@$1$G9=@.$5$l$F$$$kGKB;%U%!%$%k$KBP$7$F$O(B
+$BLr$KN)$?$J$$$N$OL@$i$+$G$9!#(B
+$B%a%G%#%"$dE>Aw;~$N8m$j$GH/@8$9$k%G!<%?$NB;<:$N2DG=@-$r(B
+$B:G>.$K$7$?$$>l9g$O!">.$5$J%V%m%C%/%5%$%:$G05=L$9$k$3$H$r(B
+$B9M$($k$3$H$,$G$-$^$9!#(B
+
+.SH $B@-G=$K4X$9$k%N!<%H(B
+$B05=L$K$*$1$k%=!<%HCJ3,$G$O!"%U%!%$%kCf$NF1$8J8;zNs$r=8$a$^$9!#(B
+$B$3$N$?$a!"(B"aabaabaabaab ..." $B$N$h$&$K5-9f$,2?2s$bD9$/(B ($B?tI42s(B)
+$B7+$jJV$5$l$F$$$k%U%!%$%k$r05=L$9$k>l9g$ODL>o$h$jCY$/$J$j$^$9!#(B
+$B%P!<%8%g%s(B 0.9.5 $B0J9_$G$O!"0JA0$N%P!<%8%g%s$KHf$Y$F$3$NE@$,(B
+$B$+$J$j2~A1$5$l$F$$$^$9!#(B
+$B05=L;~4V$N:G$b0-$$>l9g$HJ?6QE*$J>l9g$NHf$O(B 10:1 $B$NHO0O$G$9!#(B
+$B0JA0$N%P!<%8%g%s$G$O(B 100:1 $B$H$$$&$h$&$JHf$G$7$?!#(B
+$B%*%W%7%g%s(B \-vvvv $B$rM?$($k$3$H$G!"?J9T>u67$rBgJQ>\$7$/8+$k$3$H$,$G$-$^$9!#(B
+
+$B?-D9$NB.EY$O$3$l$i$N8=>]$K1F6A$5$l$^$;$s!#(B
+
+.I bzip2
+$B$OF0:n$N$?$a$KBgDq?t%a%,%P%$%H$r3NJ]$7!"A4$/%i%s%@%`$K(B
+$B$=$NNN0h$rJQ99$7$^$9!#(B
+$B$3$l$O!"%^%7%s$,%-%c%C%7%e%_%9$KBP$7$F$I$l$@$1$NB.EY$GBP=h$G$-$k$+$,!"(B
+$B05=L$d?-D9$N@-G=$rBg$-$/7hDj$9$k$H$$$&$3$H$r0UL#$7$^$9!#(B
+$B$3$N$?$a!"%-%c%C%7%e%_%9$N3d9g$r8:$i$9$h$&$K%3!<%I$r>/$7JQ99(B
+$B$9$k$3$H$K$h$j!"@-G=$,Bg$-$/8~>e$9$k$3$H$,$o$+$C$F$$$^$9!#(B
+.I bzip2
+$B$O$H$F$bBg$-$J%-%c%C%7%e$r;}$D%^%7%s$G:G9b$N@-G=$r=P$9$H9M$($i$l$^$9!#(B
+
+.SH $B7Y9p(B
+$BF~=PNO%(%i!<$N%a%C%;!<%8$O$=$l$[$ILrN)$A$^$;$s!#(B
+.I bzip2
+$B$O$G$-$k$@$1F~=PNO%(%i!<$r8!CN$7!"@5$7$/=*N;$9$k$h$&$K;n$_$^$9$,!"(B
+$B2?$,LdBj$J$N$+$N>\:Y$O!";~!9$+$J$j4V0c$C$?$b$N$K$J$k$3$H$,$"$j$^$9!#(B
+
+$B$3$N%^%K%e%"%k%Z!<%8$O(B
+.I bzip2 
+$B$N%P!<%8%g%s(B 1.0 $B$K$D$$$F=R$Y$F$$$^$9!#(B
+$B$3$N%P!<%8%g%s$,@8@.$9$k05=L%G!<%?$O!"A0J}8_49@-$H!"0JA0$N8x3+%j%j!<%9$G$"$k(B
+$B%P!<%8%g%s(B 0.1pl2, 0.9.0, 0.9.5 $B$KBP$9$k8eJ}8_49@-$,$"$j$^$9!#(B
+$B$?$@$7!"<!$NNc30$,$"$j$^$9(B: 0.9.0 $B0J9_$OJ#?t$N05=L%U%!%$%k$rO"7k$7$?(B
+$B%U%!%$%k$r?-D9$G$-$^$9$,!"(B0.1pl2 $B$O$G$-$^$;$s!#(B
+$B%9%H%j!<%`$N@hF,$K$"$k%U%!%$%k$r?-D9$7$?8e$KDd;_$7$^$9!#(B
 
 .I bzip2recover
-uses 32-bit integers to represent bit positions in
-compressed files, so it cannot handle compressed files more than 512
-megabytes long.  This could easily be fixed.
+$B$O05=L%U%!%$%kCf$N%S%C%H$N0LCV$rI=8=$9$k$?$a$K(B 32 $B%S%C%H@0?t$r(B
+$B;H$C$F$$$k$N$G!"(B512 $B%a%,%P%$%H$h$jD9$$05=L%U%!%$%k$r07$&$3$H$,(B
+$B$G$-$^$;$s!#$3$l$O4JC1$K=$@5$G$-$k$G$7$g$&!#(B
 
-.SH AUTHOR
-Julian Seward, jseward@acm.org.
+.SH $BCx<T(B
+Julian Seward, jseward@acm.org
 
 http://sourceware.cygnus.com/bzip2
 http://www.muraroa.demon.co.uk
 
-The ideas embodied in
 .I bzip2
-are due to (at least) the following
-people: Michael Burrows and David Wheeler (for the block sorting
-transformation), David Wheeler (again, for the Huffman coder), Peter
-Fenwick (for the structured coding model in the original
-.I bzip,
-and many refinements), and Alistair Moffat, Radford Neal and Ian Witten
-(for the arithmetic coder in the original
-.I bzip).  
-I am much
-indebted for their help, support and advice.  See the manual in the
-source distribution for pointers to sources of documentation.  Christian
-von Roques encouraged me to look for faster sorting algorithms, so as to
-speed up compression.  Bela Lubkin encouraged me to improve the
-worst-case compression performance.  Many people sent patches, helped
-with portability problems, lent machines, gave advice and were generally
-helpful.
+$B$K4^$^$l$k%"%$%G%#%"$O(B ($B>/$J$/$H$b(B) $B0J2<$N?M!9$K$h$k$b$N$G$9(B:
+Michael Burrows $B$H(B David Wheeler ($B%V%m%C%/%=!<%HJQ49(B)$B!"(B
+David Wheeler (Huffman $BId9f2=4o(B)$B!"(B
+Peter Fenwick ($B%*%j%8%J%k$N(B
+.I bzip
+$B$K$*$1$k9=B$2=%3!<%G%#%s%0%b%G%k$HB?$/$N2~NI(B)$B!"(B
+Alistair Moffat, Radford Neal $B$=$7$F(B Ian Witten ($B%*%j%8%J%k$N(B
+.I bzip
+$B$K$*$1$k;;=QId9f2=4o(B)$B!#;d$O!"H`$i$N=u$1$d;Y1g$=$7$F%"%I%P%$%9$K(B
+$B46<U$7$F$$$^$9!#(B
+$B%I%-%e%a%s%H$N%=!<%9$N>l=j$K$D$$$F$O!"%=!<%9G[I[$NCf$N%^%K%e%"%k$r(B
+$B;2>H$7$F$/$@$5$$!#(B
+Christian von Roques $B$O!"05=LB.EY$N8~>e$N$?$a$K(B
+$B$h$jB.$$%=!<%H%"%k%4%j%:%`$rC5$9$3$H$r4+$a$F$/$l$^$7$?!#(B
+Bela Lubkin $B$O!"05=LB.EY$,:G$bCY$$>l9g$N2~NI$r4+$a$F$/$l$^$7$?!#(B
+$BB?$/$N?M$,%Q%C%A$rAw$j!"0\?"@-$NLdBj$K$D$$$F=u$1$N<j$r:9$7$N$Y!"(B
+$B%^%7%s$rB_$7!"%"%I%P%$%9$r$/$l$^$7$?!#$3$l$i$O$9$Y$F=u$1$K$J$j$^$7$?!#(B
