Provided by: zpaq_7.15-1_amd64 bug

NAME

       zpaq - Journaling archiver for incremental backups.

SYNOPSIS

       zpaq command archive[".zpaq"] [files]... [-options]...

DESCRIPTION

       zpaq manages journaling archives for incremental user-level local or remote backups that
       conform to The ZPAQ Open Standard Format for Highly Compressed Data (see AVAILABILITY).
       The format supports encrypted, deduplicated, and compressed single or multi-part archives
       with rollback capability.  It supports archives as large as 1000 times available memory or
       up to 250 TB and 4 billion files, interoperable between Windows and Unix/Linux/OS X.

COMMANDS

       command is one of "add", "extract", or "list" Commands may be abbreviated to "a", "x", or
       "l" respectively.  archive is assumed to have a ".zpaq" extension if no extension is
       specified.

       If archive contains wildcards "*" or "?", then the archive is in multiple parts where "*"
       matches the part number and "?" matches single digits. zpaq will consider the
       concatenation of the parts in numerical order starting with 1 to be equivalent to a single
       archive.  For example, "arc??" would match the concatenation of "arc01.zpaq",
       "arc02.zpaq", etc. up to the last existing part.

       a
       add Append changes in files to archive, or create archive if it does not exist. files is a
           list of file and directory names separated by spaces. If a name is a directory, then
           it recursively includes all files and subdirectories within. In Windows, files may
           contain wildcards "*" and "?" in the last component of the path (after the last
           slash).  "*" matches any string and "?" matches any character. In Unix/Linux,
           wildcards are expanded by the shell, which has the same effect.

           A change is an addition, update, or deletion of any file or directory in files or any
           of its subdirectories to any depth. A file or directory is considered changed if its
           size or last-modified date (with 1 second resolution), or Windows attributes or
           Unix/Linux permissions (if saved) differ between the internal and external versions.
           File contents are not compared. If the attributes but not the date has changed, then
           the attributes are updated in the archive with the assumption that the file contents
           have not changed.

           Files are added by splitting them into fragments along content-dependent boundaries,
           computing their SHA-1 hashes, and comparing with hashes already stored in the archive.
           If the hash matches, it is assumed that the fragments are identical and only a pointer
           to the previous compressed fragment is saved. Unmatched fragments are packed into
           blocks, compressed, and appended to the archive.

           For each added or updated file or directory, the following information is saved in the
           archive: the compressed contents, fragment hashes, the file or directory name as it
           appears in files plus any trailing path, the last-modified date with 1 second
           resolution, and the Unix/Linux permissions or Windows attributes. Other metadata such
           as owner, group, ACLs, last access time, etc. are not saved. Symbolic links are not
           saved or followed.  Hard links are followed as if they were ordinary files. Special
           file types such as devices, named pipes, and named sockets are not saved.  The 64 bit
           Windows version will save alternate data streams.

           If any file cannot be read (e.g. permission denied), then it is skipped and a warning
           is reported. However, other files are still added and the update is still valid.

           If archive is "" (a quoted empty string), then zpaq compresses files as if creating a
           new archive, but discards the output without writing to disk.

           If archive is multi-part, the zpaq will create a new part using the next available
           part number. For example:

               zpaq add "arc??" files   (creates arc01.zpaq)
               zpaq add "arc??" files   (creates arc02.zpaq)
               zpaq add "arc??" files   (creates arc03.zpaq)
               zpaq extract "arc??"     (extracts all parts)

           Updates are transacted. If zpaq is interrupted before completing the update, then the
           partially appended data is ignored and overwritten on the next update. This is
           accomplished by first appending a temporary update header, appending the compressed
           data and index, then updating the header as the last step.

           As the archive is updated, the program will report the percent complete, estimated
           time remaining, the name and size of the file preceded by "+" if the file is being
           added, "#" if updated, or "-" if deleted. If the file is deduplicated, then the new
           size after deduplication but before compression is shown.

       x
       extract
           Extract files (including the contents of directories), or extract the whole archive
           contents if files is omitted.  The file names, last-modified date, and permissions or
           attributes are restored as saved in the archive.  If there are multiple versions of a
           file stored, then only the latest version is extracted. If a stored file has been
           marked as deleted, then it is not extracted.

           Existing files are skipped without being overwritten. (Use "-force" to overwrite).

           As files are extracted, the fragment SHA-1 hashes are computed and compared with the
           stored hashes. The program reports an error in case of mismatches.  Blocks are only
           decompressed up to the last used fragment.  If the archive is damaged, then zpaq will
           extract as much as possible from the undamaged blocks.

           As files are extracted, the program reports the percent completed, estimated time
           remaining, and the name of the file preceded by ">" if the file is created or
           overwritten (with "-force"), "?" if the file is skipped because it already exists, or
           "=" if decompression is skipped with "-force" because the contents were compared and
           found to be identical. The date and attributes are still extracted in this case.

       l
       list
           List the archive contents. With files, list only the specified files and directories
           and compare them with the same files on disk.  For each file or directory, show the
           comparison result, last modified date, uncompressed size, Windows attributes or
           Unix/Linux permissions, and the saved name. If the internal and external versions of
           the file differ, then show both.

           The comparison result is reported in the first column as "=" if the last-modified
           date, attributes (if saved), and size are identical, "#" if different, "-" if the
           external file does not exist, or "+" if the internal file does not exist. With
           "-force", the contents are compared, but not the dates or attributes. Contents are
           compared by reading the files, computing SHA-1 hashes and comparing with the stored
           hashes. In either case, replacing "list" with "add" will show exactly what changes
           would be made to the archive.

           In Unix/Linux, permissions are listed as a file type "d" for directory or blank for a
           regular file, followed by a 4 digit octal number as per chmod(1). In Windows,
           attributes are listed from the set "RHS DAdFTprCoIEivs" where the character is present
           if the corresponding bit 0..17 is set as returned by GetFileAttributes().  The
           meanings are as follows: "R"ead-only, "H"idden, "S"ystem, unused (blank), "D"irectory,
           "A"rchive, "d"evice, normal "F"ile, "T"emporary, s"p"arse file, "r"eparse point,
           "C"ompressed, "o"ffline, not content "I"indexed, "E"ncrypted, "i"ntegrity stream,
           "v"irtual, no "s"crub data.

           archive may be "", which is equivalent to comparing with an empty archive.

OPTIONS

       -all [N]
           With "list", list all saved versions and not just the latest version, including
           versions where the file is marked as deleted. Each version is shown in a separate
           numbered directory beginning with "0001/".  Absolute paths are first converted to
           relative paths. In Windows, the ":" on the drive letter is removed. For example, "foo"
           and "/foo" are shown as "0001/foo". "C:/foo" and "C:foo" are shown as "0001/C/foo".

           The date shown on the root directory of each version is the date of the update. The
           root directory listing also shows the number of updates and deletions in that version
           and the compressed size.

           When a file is deleted, it is shown with the dates and attributes blank with size 0.

           With "extract", extract the files in each version as shown with "list -all".

           N selects the number of digits in the directory name. The default is 4.  More digits
           will be used when necessary. For example:

               zpaq list archive -all 2 -not "??/?*"

           will show the dates when the archive was updated as "01/", "02/", etc. but not their
           contents.

       -f
       -force
           With "add", attempt to add files even if the last-modified date has not changed. Files
           are added only if they really are different, based on comparing the computed and
           stored SHA-1 hashes

           With "extract", overwrite existing output files. If the contents differ (tested by
           comparing SHA-1 hashes), then the file is decompressed and extracted. If the dates or
           attributes/permissions differ, then they are set to match those stored in the archive.

           With "list" files, compare files by computing SHA-1 fragment hashes and comparing with
           stored hashes. Ignore differences in dates and attributes.

       -fragment N
           Set the dedupe fragment size range from 64 2^N to 8128 2^N bytes with an average size
           of 1024 2^N bytes. The default is 6 (range 4096..520192, average 65536). Smaller
           fragment sizes can improve compression through deduplication of similar files, but
           require more memory and more overhead. Each fragment adds about 28 bytes to the
           archive and requires about 40 bytes of memory. For the default, this is less than 0.1%
           of the archive size.

           Values other than 6 conform to the ZPAQ specification and will decompress correctly by
           all versions, but do not conform to the recommendation for best deduplication. Adding
           identical files with different values of N will not deduplicate because the fragment
           boundaries will differ.  "list -summary" will not identify these files as identical
           for the same reason.

       -index indexfile
           With "add", create archive".zpaq" as a suffix to append to a remote archive which is
           assumed to be identical to indexfile except that indexfile contains no compressed file
           contents (D blocks).  Then update indexfile by appending a copy of archive".zpaq"
           without the D blocks. With "extract", specify the index to create for archive".zpaq"
           and do not extract any files.

           The purpose is to maintain a backup offsite without using much local disk space. The
           normal usage is to append the suffix at the remote site and delete it locally, keeping
           only the much smaller index.  For example:

               zpaq add part files -index index.zpaq
               cat part.zpaq >> remote.zpaq
               rm part.zpaq

           indexfile has no default extension. However, with a ".zpaq" extension it can be listed
           to show the contents of the remote archive or compare with local files. It cannot be
           extracted or updated as a regular archive. Thus, the following should produce
           identical output:

               zpaq list remote.zpaq
               zpaq list index.zpaq

           If archive is multi-part (contains "*" or "?"), then zpaq will substitute a part
           number equal to 1 plus the number of previous updates.  The parts may then be accessed
           as a multi-part archive without appending or renaming.

           With "add", it is an error if the archive to be created already exists, or if
           indexfile is a regular archive. "-index" cannot be used with "-until" or a streaming
           archive "-method s...".  With "extract", it is an error if indexfile exists and
           "-force" is not used to overwrite.

       -key password
           This option is required for all commands operating on an encrypted archive.  When
           creating a new archive with "add", the new archive will be encrypted with password and
           all subsequent operations will require the same password.

           An archive is encrypted with AES-256 in CTR mode. The password is strengthened using
           Scrypt(SHA-256(password), salt, N=16384, r=8, p=1), which would require 208M
           operations and 16 MB memory per test in a brute force key search.  When creating a new
           archive, a 32 byte salt is generated using CryptGenRandom() in Windows or from
           /dev/urandom in Unix/Linux, such that the first byte is different from the normal
           header of an unencrypted archive ("z" or 7). A multi-part archive is encrypted with a
           single keystream as if the parts were concatenated.  An index is encrypted with the
           same password, where the first byte of the salt is modified by XOR with ('z' XOR '7').

           Encryption provides secrecy but not authentication. An attacker who knows or can guess
           any bits of the plaintext can set them without knowing the key.

       -mtype[Blocksize[.pre[.arg][comp[.arg]]...]]
       -method type[Blocksize[.pre[.arg][comp[.arg]]...]]
           With "add", select a compression method. type may be 0, 1, 2, 3, 4, 5, "x", or "s".
           The optional Blocksize may be 0..11, written with no space after the type, like "-m10"
           or "-method 511". The remaining arguments, separated by periods or commas without
           spaces, are only allowed for types "x" or "s", for example "-mx4.3ci1".

           If type is numeric, then higher numbers compress better but are slower.  The default
           is "-m1". It is recommended for backups. "-m2" compresses slower but decompresses just
           as fast as 1. It is recommended for archives to be compressed once and decompressed
           many times, such as downloads. "-m0" stores with deduplication but no further
           compression.

           Blocksize says to pack fragments into blocks up to 2^Blocksize MiB. Using larger
           blocks can improve compression but require more memory and may be slower because each
           block is compressed or decompressed by a separate thread.  The memory requirement is
           up to 8 times Blocksize per thread for levels up to 4 and 16 times block size per
           thread for level 5.  The default Blocksize is 4 (16 MiB) for types 0 and 1, and 6 (64
           MiB) otherwise.

           Types "x" and "s" are for experimental use. Normally, zpaq selects different methods
           depending on the compression level and an analysis of the data (text, executable, or
           other binary, and degree of compressibility).  type selects journaling or streaming
           format.  pre is 0..7 selecting a preprocessing step (LZ77, BWT, E8E9), comp is a
           series of context modeling components from the set {c,i,a,w,m,s,t} selecting a CM or
           ICM, ISSE chain, MATCH, word model, MIX, SSE, or MIX2 respectively. pre and comp may
           be followed by a list of numeric arguments (arg) separated by periods or commas.  For
           example:

               -method x6.3ci1

           selects a journaling archive (x), block size 2^6 = 64 MiB, BWT transform (3), an order
           0 ICM (c), and order 1 ISSE (i1). (zpaq normally selects this method for level 3 text
           compression). type is as follows.

           x   Selects normal (journaling) mode. Files are split into fragments, deduplicated,
               packed into blocks, and compressed by the method described. The compressed blocks
               are preceded by a transaction header giving the date of the update.  The blocks
               are followed by a list of fragment hashes and sizes and a list of files added,
               updated, or deleted. Each added or updated file lists the last-modifed date,
               attributes, and a list of fragment IDs.

           s   Selectes streaming mode for single-pass extraction and compatibility with zpaq
               versions prior to 6.00 (2012). Streaming archives do not support deduplication or
               rollback. Files are split into fragments of size 2^blocksize MiB - 4 KiB. Each
               file or fragment is compressed in a separate block with no attempt at
               deduplication. The file name, date, and attributes are stored in the header of the
               first fragment. The hashes are stored in the trailers of each block. There is no
               transaction block to allow rollback. Files are added to the previously dated
               update.  Streaming mode with "-index" is an error.

           pre[.min1.min2.depth.size[.lookahead]]
               pre selects a pre/post processing step before context modeling as follows.

                   0 = no preprocessing
                   1 = Packed LZ77
                   2 = Byte aligned LZ77
                   3 = BWT (Burrows-Wheeler Transform)
                   4 = E8E9
                   5 = E8E9 + packed LZ77
                   6 = E8E9 + byte aligned LZ77
                   7 = E8E9 + BWT

               The E8E9 transform (4..7) improves the compression of x86 executable files (.exe
               or .dll). The transform scans backward for 5 byte patterns of the form (E8|E9 xx
               xx xx 00|FF) hex and adds the block offset to the three middle bytes. The E8 and
               E9 opcodes are CALL and JMP, respectively. The transform replaces relative
               addresses with absolute addresses. The transform is applied prior to LZ77 or BWT.
               Decompression reverses the transforms in the opposite order.

               LZ77 (1, 2, 5, 6) compresses by searching for matching strings using a hash table
               or suffix array and replacing them with pointers to the previous match. Types 1
               and 2 select variable bit length coding or byte aligned coding respectively.
               Variable bit length encoding compresses better by itself, but byte aligned coding
               allows for further compression using a context model.  Types 6 and 7 are the same
               as 1 and 2 respectively, except that the block is E8E9 transformed first.

               BWT (Burrows Wheeler Transform, 3 or 7), sorts the input block by context, which
               brings bytes with similar contexts together. It does not compress by itself, but
               makes the input suited to compression with a fast adapting low order context
               model.

               The remaining arguments apply only to LZ77.  min1 selects the minimum match
               length, which must be at least 4 for packed LZ77 or 1 for byte aligned LZ77. min2
               selects a longer minimum match length to try first, or is 0 to skip this step. The
               block is encoded by testing 2^depth locations indexed by a hash table of 2^size
               elements indexed by hashes of the next min2 and then min1 characters. If lookahead
               is specified and greater than 0, then, the search is repeated lookahead + 1 times
               to consider coding the next 0 to lookahead bytes as literals to find a longer
               match.

               If size = blocksize + 21, then matches are found using a suffix array instead of a
               hash table, scanning forward and backward 2^depth elements to find the longest
               past match. min2 has no effect.  A suffix array requires 4.5 x 2^blocksize MiB
               memory. A hash table requires 4 x 2^size bytes memory. For example:

                   -method x6.1.4.0.5.27.1

               specifies 64 MiB blocks (6), variable length LZ77 without E8E9 (1), minimum match
               length 4, no secondary search (0), search depth 2^5 = 32 in each direction in the
               suffix array (27 = 6 + 21), and 1 byte lookahead.

           comp specifies a component of a context model. If this section is empty, then no
           further compression is performed. Otherwise the block is compressed by an array of
           components. Each component takes a context and possibly the outputs of earlier
           components, and outputs a prediction, a probability that the next bit of input is a 1.
           The final prediction is used to arithmetic code the bit.  Components normally allocate
           memory equal to the block size, or less for smaller contexts as needed. Components are
           as follows:

           c[.maxcount[.offset[.mask]...]]
               Specifies a context model (CM), or indirect context model (ICM). A CM maps a
               context hash to a prediction by looking up the context in a table, and then
               adjusts the prediction to reduce the coding error by 1/count, where count is
               bounded by maxcount x 4, and maxcount is in 1..255.

               If maxcount is 0, then specify an ICM. An ICM maps a context to a state
               representing two bit counts and the most recent bit. That state is mapped to a
               prediction and updated at a fixed rate. An ICM adapts faster to changing
               statistics. A CM with a high count compresses stationary data better. The default
               is 0 (ICM).

               If maxcount has the form 1000m + n, then the effect is the same as maxcount = n
               while reducing memory to 1/2^m of block size.

               The remaining arguments represent contexts, all of which are hashed together. If
               offset is 1..255, then the block offset mod offset is hashed in. If offset is
               1000..1255, then the distance to the last occurrence of offset - 1000 is hashed
               in. For example, "c0.1010" specifies an ICM taking the text column number
               (distance back to the last linefeed = 10) as context. The default is 0 (no
               context).

               Each mask is ANDed with previous bytes. For example, "c0.0.255.255.255" is an ICM
               with order 3 context. A value in 256..511 specifies a context of mask - 256 hashed
               together with the byte aligned LZ77 parse state (whether a literal or match code
               is expected). For example, "-method x6.2.12.0.8.27c0.0.511.255" specifes block
               size 2^6 MiB, byte aligned LZ77 (2), minimum match length 12, search depth 2^8,
               suffix array search (27 = 6 + 21), an ICM (c0), no offset context (0), and order 2
               context plus LZ77 state (511.255).

               A mask greater than 1000 is shorthand for mask - 1000 zeros. For example, the
               sparse context "c0.0.255.1003.255" is equivalent to "c0.0.255.0.0.0.255".

           m[size[.rate]]
               Specifies a MIX (mixer). A MIX computes a weighted average of the predictions of
               all previous components. (The averaging is in the logistic domain: log(p / (1 -
               p))). The weights are then adjusted in proportion to rate (0..255) to reduce the
               prediction error. A size bit context can be used to select a set of weights to be
               used. The first 8 bits of context are the previously coded bits of the current
               byte. The default is "m8.24".  A MIX with n inputs requires 4n x 2^size bytes of
               memory.

           t[size[.rate]]
               Specifies a MIX2. A MIX2 is like a MIX except that it takes only the last 2
               components as input, and its weights are constrained to add to 1.  A MIX2 requires
               4 x 2^size bytes of memory. The default is "t8.24".

           s[size[.mincount[.maxcount]]]
               Specifes a SSE (secondary symbol estimator). A SSE takes the last size bits of
               context and the quantized and interpolated prediction of the previous component as
               input to output an adjusted prediction. The output is adjusted to reduce the
               prediction error by 1/count, where the count is constrained between mincount and 4
               x maxcount. The default is "s8.32.255".

           iorder[.increment]...
               Specifies an ISSE (indirect secondary symbol estimator) chain. An ISSE adjusts the
               predition of the previous component by mixing it with a constant 1.  The pair of
               mixing weights is selected by a bit history state (like an ICM).  The bit history
               is selected by a hash of the last order bytes hashed together with the context of
               the previous component. Each increment specifies an additional ISSE whose context
               order is increased by increment. For example, "ci1.1.2" specifies an order 0 ICM
               and order 1, 2, and 4 ISSEs.

           w[order[.A[.Z[.cap[.mul[.mem]]]]]]
               Specifies an ICM-ISSE chain of length order taking as contexts the hashes of the
               last 1, 2, 3..., order whole words. A word is defined as a sequence of characters
               in the range A to A + Z - 1, ANDed with cap before hashing. The hash H is updated
               by byte c as H := (H x mul + c) (mod 2^(blocksize + 24 - mem)).  Each component
               requires 2^(blocksize - mem) MiB. The default is "w1.65.26.223.20.0", which
               defines a word as 65..90 (A..Z). ANDing with 223 converts to upper case before
               hashing. mul = 20 has the effect of shifting 2 bits left. For typical block sizes
               (28 or 30 bit H), the word hash depends on the last 14 or 15 letters.

           a[mul[.bmem][.hmem]]]
               Specifies a MATCH. A MATCH searches for a past matching context and predicts
               whatever bit came next. The search is done by updating a context hash H with byte
               c by H := H x mul + c (mod 2^(blocksize + 18 - hmem)).  A MATCH uses 2^(blocksize
               - bmem) MiB history buffer and a 2^(blocksize - hmem) MiB hash table. The default
               is a24.0.0.  If blocksize is 6, then H is 24 bits. mul = 24 shifts 4 bits left,
               making the context hash effectively order 6.

       -noattributes
           With "add", do not save Windows attributes or Unix/Linux permissions to the archive.
           With "extract", ignore the saved values and extract using default values. With "list",
           do not list or compare attributes.

       -not [file]...
       -not =[#+-?^]...
           In the first form, do not add, extract, or list files that match any file by name.
           file may contain wildcards "*" and "?" that match any string or character
           respectively, including "/". A match to a directory also matches all of its contents.
           In Windows, matches are not case sensitive, and "\" matches "/". In Unix/Linux,
           arguments with wildcards must be quoted to protect them from the shell.

           When comparing with "list" files, "-not =" means do not list identical files.
           Additionally it is possible to suppress listing of differences with "#", missing
           external files with "-", missing internal files with "+", and duplicates ("list
           -summary") with "^".

       -only file...
           Do not add, extract, or list any files unless they match at least one argument. The
           rules for matching wildcards are the same as "-not". The default is "*" which matches
           everything.

           If a file matches an argument to both "-only" and "-not", then "-not" takes
           precedence.

       -repack new_archive [new_password]
           With "extract", store the extracted files in new_archive instead of writing them
           individually to disk. If new_password is specified, then the output is encrypted with
           this password. Otherwise the output is not encrypted, even if the input is.

           It is an error if new_archive exists unless "-force" is used to allow it to be
           overwritten.  new_archive does not automatically get a ".zpaq" extension.

           Repacking is implemented by copying those D blocks (compressed file contents) which
           are referenced by at least one selected file. This can result in a larger archive than
           a new one because unreferenced fragments in the same block are also copied.

           The repacked archive block dates range from the first to last update of the input
           archive. Using "add -until" with a date between these two dates will result in the
           date being adjust to 1 second after the last update.

           With "-all", the input archive is simply copied without modification except to decrypt
           and encrypt. Thus, the input may be any file, not just an archive. files and the
           options "-to", "-not", "-only", "-until", "-noattributes", and "-method" are not valid
           with "-repack -all".

       -sN
       -summary N
           With "list", sort by decreasing size and show only the N largest files and
           directories. Label duplicates of the previous file with "^". A file is a duplicate if
           its contents are identical (based on stored hashes) although the name, dates, and
           attributes may differ. If files is specified, then these are included in the listing
           but not compared with internal files or each other.  Internal and external files are
           labeled with "-" and "+" respectively.

           If N is negative as in "-s-1" then list normally but show fragment IDs after each file
           name. Files with identical fragment IDs have identical contents.

           With "add" and "extract", when N > 0, do not list files as they are added or
           extracted. Show only percent completed and estimated time remaining on a 1 line
           display.

       -test
           With "extract", do not write to disk, but perform all other operations normally.
           "extract" will decompress, compute the SHA-1 hashes of the output, report if it
           differs from the stored value, but not compare, create or update any files. With
           "-index", test for errors but do not create an index file.

       -tN
       -threads N
           Add or extract at most N blocks in parallel. The default is 0, which uses the number
           of processor cores, except not more than 2 when when zpaq is compiled to 32-bit code.
           Selecting fewer threads will reduce memory usage but run slower. Selecting more
           threads than cores does not help.

       -to name...
           With "add" and "list" rename external files to respective internal names. With
           "extract", rename internal files to external names. When files is empty, prefix the
           extracted files with the first name in names, inserting "/" if needed and removing ":"
           from drive letters. For example:

               zpaq extract archive file dir -to newfile newdir

           extracts "file" as "newfile" and "dir" as "newdir".

               zpaq extract archive -to tmp

           will extract "foo" or "/foo" as "tmp/foo" and extract "C:/foo" or "C:foo" as
           "tmp/C/foo".

               zpaq add archive dir -to newdir

           will save "dir/file" as "newdir/file", and so on.

               zpaq list archive dir -to newdir

           will compare external "dir" with internal "newdir".

           The "-only" and "-not" options apply prior to renaming.

       -until date | [-]version
           Ignore any part of the archive updated after date or after version updates or
           -versions from the end if negative.  Additionally, "add" will truncate the archive at
           this point before appending the next update. When a date is specified, the update will
           be timestamped with date rather than the current date.

           A date is specified as a 4 digit year (1900 to 2999), 2 digit month (01 to 12), 2
           digit day (01 to 31), optional 2 digit hour (00 to 23, default 23), optional 2 digit
           minute (00 to 59, default 59), and optional 2 digit seconds (00 to 59, default 59).
           Dates and times are always universal time zone (UT), not local time. Numbers up to
           9999999 are interpreted as version numbers rather than dates. Dates may contain spaces
           and punctuation characters for readability but are ignored. For example:

               zpaq list backup -until 3

           shows the archive as it existed after the first 3 updates.

               zpaq add backup files -until 2014/04/30 11:30

           truncates any data added after April 30, 2014 at 11:30:59 universal time, then appends
           the update as if this were the current time. (It does not matter if any files are
           dated in the future).

               zpaq add backup files -until 0

           deletes backup.zpaq and creates a new archive.

           "add -until" is an error on multi-part archives or with an index.  A multi-part
           archive can be rolled back by deleting the highest numbered parts.

           Truncating and appending an encrypted archive with "add -until" (even "-until 0") does
           not change the salt or keystream. Thus, it is possible for an attacker with the old
           and new versions to obtain the XOR of the trailing plaintexts without a password.

EXIT STATUS

       Returns 0 if successful, 1 in case of warnings, or 2 in case of an error.

ENVIRONMENT

       In Windows, the default number of threads (set by "-threads") is %NUMBER_OF_PROCESSORS%.
       In Linux, the number of lines of the form "Processor : 0", "Processor : 1",... in
       /cpu/procinfo is used instead.

STANDARDS

       The archive format is described in The ZPAQ Open Standard Format for Highly Compressed
       Data (see AVAILABILITY).

AVAILABILITY

       http://mattmahoney.net/zpaq/

BUGS

       There is no GUI.

       The archive format does not save sufficient information for backing up and restoring the
       operating system.

SEE ALSO

       bzip2(1) gzip(1) lrzip(1) lzop(1) lzma(1) p7zip(1) rzip(1) unace(1) unrar(1) unzip(1)
       zip(1)

AUTHORS

       "zpaq" and "libzpaq" are written by Matt Mahoney and released to the public domain in
       2015-2016. "libzpaq" contains libdivsufsort-lite v2.01, copyright (C) 2003-2008, Yuta
       Mori. It is licensed under the MIT license. See the source code for license text. The AES
       code is modified from libtomcrypt by Tom St Denis (public domain).  The salsa20/8 code in
       Scrypt() is by D. J. Bernstein (public domain).