Add files using upload-large-folder tool

evalkit_cambrian/lib/python3.10/site-packages/pyasn1_modules/rfc5639.py

@@ -0,0 +1,49 @@
+# This file is being contributed to pyasn1-modules software.
+#
+# Created by Russ Housley.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Elliptic Curve Cryptography Brainpool Standard Curves
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5639.txt
+
+
+from pyasn1.type import univ
+
+
+ecStdCurvesAndGeneration = univ.ObjectIdentifier((1, 3, 36, 3, 3, 2, 8,))
+
+ellipticCurve = ecStdCurvesAndGeneration + (1,)
+
+versionOne = ellipticCurve + (1,)
+
+brainpoolP160r1 = versionOne + (1,)
+
+brainpoolP160t1 = versionOne + (2,)
+
+brainpoolP192r1 = versionOne + (3,)
+
+brainpoolP192t1 = versionOne + (4,)
+
+brainpoolP224r1 = versionOne + (5,)
+
+brainpoolP224t1 = versionOne + (6,)
+
+brainpoolP256r1 = versionOne + (7,)
+
+brainpoolP256t1 = versionOne + (8,)
+
+brainpoolP320r1 = versionOne + (9,)
+
+brainpoolP320t1 = versionOne + (10,)
+
+brainpoolP384r1 = versionOne + (11,)
+
+brainpoolP384t1 = versionOne + (12,)
+
+brainpoolP512r1 = versionOne + (13,)
+
+brainpoolP512t1 = versionOne + (14,)

evalkit_cambrian/lib/python3.10/site-packages/pyasn1_modules/rfc6031.py

@@ -0,0 +1,469 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# CMS Symmetric Key Package Content Type
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc6031.txt
+#
+
+from pyasn1.type import char
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import namedval
+from pyasn1.type import opentype
+from pyasn1.type import tag
+from pyasn1.type import univ
+from pyasn1.type import useful
+
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc6019
+
+
+def _OID(*components):
+    output = []
+    for x in tuple(components):
+        if isinstance(x, univ.ObjectIdentifier):
+            output.extend(list(x))
+        else:
+            output.append(int(x))
+    return univ.ObjectIdentifier(output)
+
+
+MAX = float('inf')
+
+id_pskc = univ.ObjectIdentifier('1.2.840.113549.1.9.16.12')
+
+
+# Symmetric Key Package Attributes
+
+id_pskc_manufacturer = _OID(id_pskc, 1)
+
+class at_pskc_manufacturer(char.UTF8String):
+    pass
+
+
+id_pskc_serialNo = _OID(id_pskc, 2)
+
+class at_pskc_serialNo(char.UTF8String):
+    pass
+
+
+id_pskc_model = _OID(id_pskc, 3)
+
+class at_pskc_model(char.UTF8String):
+    pass
+
+
+id_pskc_issueNo = _OID(id_pskc, 4)
+
+class at_pskc_issueNo(char.UTF8String):
+    pass
+
+
+id_pskc_deviceBinding = _OID(id_pskc, 5)
+
+class at_pskc_deviceBinding(char.UTF8String):
+    pass
+
+
+id_pskc_deviceStartDate = _OID(id_pskc, 6)
+
+class at_pskc_deviceStartDate(useful.GeneralizedTime):
+    pass
+
+
+id_pskc_deviceExpiryDate = _OID(id_pskc, 7)
+
+class at_pskc_deviceExpiryDate(useful.GeneralizedTime):
+    pass
+
+
+id_pskc_moduleId = _OID(id_pskc, 8)
+
+class at_pskc_moduleId(char.UTF8String):
+    pass
+
+
+id_pskc_deviceUserId = _OID(id_pskc, 26)
+
+class at_pskc_deviceUserId(char.UTF8String):
+    pass
+
+
+# Symmetric Key Attributes
+
+id_pskc_keyId = _OID(id_pskc, 9)
+
+class at_pskc_keyUserId(char.UTF8String):
+    pass
+
+
+id_pskc_algorithm = _OID(id_pskc, 10)
+
+class at_pskc_algorithm(char.UTF8String):
+    pass
+
+
+id_pskc_issuer = _OID(id_pskc, 11)
+
+class at_pskc_issuer(char.UTF8String):
+    pass
+
+
+id_pskc_keyProfileId = _OID(id_pskc, 12)
+
+class at_pskc_keyProfileId(char.UTF8String):
+    pass
+
+
+id_pskc_keyReference = _OID(id_pskc, 13)
+
+class at_pskc_keyReference(char.UTF8String):
+    pass
+
+
+id_pskc_friendlyName = _OID(id_pskc, 14)
+
+class FriendlyName(univ.Sequence):
+    pass
+
+FriendlyName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('friendlyName', char.UTF8String()),
+    namedtype.OptionalNamedType('friendlyNameLangTag', char.UTF8String())
+)
+
+class at_pskc_friendlyName(FriendlyName):
+    pass
+
+
+id_pskc_algorithmParameters = _OID(id_pskc, 15)
+
+class Encoding(char.UTF8String):
+    pass
+
+Encoding.namedValues = namedval.NamedValues(
+    ('dec',   "DECIMAL"),
+    ('hex',   "HEXADECIMAL"),
+    ('alpha', "ALPHANUMERIC"),
+    ('b64',   "BASE64"),
+    ('bin',   "BINARY")
+)
+
+Encoding.subtypeSpec = constraint.SingleValueConstraint(
+    "DECIMAL", "HEXADECIMAL", "ALPHANUMERIC", "BASE64", "BINARY" )
+
+class ChallengeFormat(univ.Sequence):
+    pass
+
+ChallengeFormat.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('encoding', Encoding()),
+    namedtype.DefaultedNamedType('checkDigit',
+        univ.Boolean().subtype(value=0)),
+    namedtype.NamedType('min', univ.Integer().subtype(
+        subtypeSpec=constraint.ValueRangeConstraint(0, MAX))),
+    namedtype.NamedType('max', univ.Integer().subtype(
+        subtypeSpec=constraint.ValueRangeConstraint(0, MAX)))
+)
+
+class ResponseFormat(univ.Sequence):
+    pass
+
+ResponseFormat.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('encoding', Encoding()),
+    namedtype.NamedType('length', univ.Integer().subtype(
+        subtypeSpec=constraint.ValueRangeConstraint(0, MAX))),
+    namedtype.DefaultedNamedType('checkDigit',
+        univ.Boolean().subtype(value=0))
+)
+
+class PSKCAlgorithmParameters(univ.Choice):
+    pass
+
+PSKCAlgorithmParameters.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('suite', char.UTF8String()),
+    namedtype.NamedType('challengeFormat', ChallengeFormat().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 0))),
+    namedtype.NamedType('responseFormat', ResponseFormat().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 1)))
+)
+
+class at_pskc_algorithmParameters(PSKCAlgorithmParameters):
+    pass
+
+
+id_pskc_counter = _OID(id_pskc, 16)
+
+class at_pskc_counter(univ.Integer):
+    pass
+
+at_pskc_counter.subtypeSpec = constraint.ValueRangeConstraint(0, MAX)
+
+
+id_pskc_time = _OID(id_pskc, 17)
+
+class at_pskc_time(rfc6019.BinaryTime):
+    pass
+
+
+id_pskc_timeInterval = _OID(id_pskc, 18)
+
+class at_pskc_timeInterval(univ.Integer):
+    pass
+
+at_pskc_timeInterval.subtypeSpec = constraint.ValueRangeConstraint(0, MAX)
+
+
+id_pskc_timeDrift = _OID(id_pskc, 19)
+
+class at_pskc_timeDrift(univ.Integer):
+    pass
+
+at_pskc_timeDrift.subtypeSpec = constraint.ValueRangeConstraint(0, MAX)
+
+
+id_pskc_valueMAC = _OID(id_pskc, 20)
+
+class ValueMac(univ.Sequence):
+    pass
+
+ValueMac.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('macAlgorithm', char.UTF8String()),
+    namedtype.NamedType('mac', char.UTF8String())
+)
+
+class at_pskc_valueMAC(ValueMac):
+    pass
+
+
+id_pskc_keyUserId = _OID(id_pskc, 27)
+
+class at_pskc_keyId(char.UTF8String):
+    pass
+
+
+id_pskc_keyStartDate = _OID(id_pskc, 21)
+
+class at_pskc_keyStartDate(useful.GeneralizedTime):
+    pass
+
+
+id_pskc_keyExpiryDate = _OID(id_pskc, 22)
+
+class at_pskc_keyExpiryDate(useful.GeneralizedTime):
+    pass
+
+
+id_pskc_numberOfTransactions = _OID(id_pskc, 23)
+
+class at_pskc_numberOfTransactions(univ.Integer):
+    pass
+    
+at_pskc_numberOfTransactions.subtypeSpec = constraint.ValueRangeConstraint(0, MAX)
+
+
+id_pskc_keyUsages = _OID(id_pskc, 24)
+
+class PSKCKeyUsage(char.UTF8String):
+    pass
+
+PSKCKeyUsage.namedValues = namedval.NamedValues(
+    ('otp',       "OTP"),
+    ('cr',        "CR"),
+    ('encrypt',   "Encrypt"),
+    ('integrity', "Integrity"),
+    ('verify',    "Verify"),
+    ('unlock',    "Unlock"),
+    ('decrypt',   "Decrypt"),
+    ('keywrap',   "KeyWrap"),
+    ('unwrap',    "Unwrap"),
+    ('derive',    "Derive"),
+    ('generate',  "Generate")
+)
+
+PSKCKeyUsage.subtypeSpec = constraint.SingleValueConstraint(
+    "OTP", "CR", "Encrypt", "Integrity", "Verify", "Unlock",
+    "Decrypt", "KeyWrap", "Unwrap", "Derive", "Generate" )
+
+class PSKCKeyUsages(univ.SequenceOf):
+    pass
+
+PSKCKeyUsages.componentType = PSKCKeyUsage()
+
+class at_pskc_keyUsage(PSKCKeyUsages):
+    pass
+
+
+id_pskc_pinPolicy = _OID(id_pskc, 25)
+
+class PINUsageMode(char.UTF8String):
+    pass
+
+PINUsageMode.namedValues = namedval.NamedValues(
+    ("local",       "Local"),
+    ("prepend",     "Prepend"),
+    ("append",      "Append"),
+    ("algorithmic", "Algorithmic")
+)
+
+PINUsageMode.subtypeSpec = constraint.SingleValueConstraint(
+    "Local", "Prepend", "Append", "Algorithmic" )
+
+class PINPolicy(univ.Sequence):
+    pass
+
+PINPolicy.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('pinKeyId', char.UTF8String().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.NamedType('pinUsageMode', PINUsageMode().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+    namedtype.OptionalNamedType('maxFailedAttempts', univ.Integer().subtype(
+        subtypeSpec=constraint.ValueRangeConstraint(0, MAX)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2))),
+    namedtype.OptionalNamedType('minLength', univ.Integer().subtype(
+        subtypeSpec=constraint.ValueRangeConstraint(0, MAX)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3))),
+    namedtype.OptionalNamedType('maxLength', univ.Integer().subtype(
+        subtypeSpec=constraint.ValueRangeConstraint(0, MAX)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))),
+    namedtype.OptionalNamedType('pinEncoding', Encoding().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 5)))
+)
+
+class at_pskc_pinPolicy(PINPolicy):
+    pass
+
+
+# Map of Symmetric Key Package Attribute OIDs to Attributes
+
+sKeyPkgAttributesMap = {
+     id_pskc_manufacturer: at_pskc_manufacturer(),
+     id_pskc_serialNo: at_pskc_serialNo(),
+     id_pskc_model: at_pskc_model(),
+     id_pskc_issueNo: at_pskc_issueNo(),
+     id_pskc_deviceBinding: at_pskc_deviceBinding(),
+     id_pskc_deviceStartDate: at_pskc_deviceStartDate(),
+     id_pskc_deviceExpiryDate: at_pskc_deviceExpiryDate(),
+     id_pskc_moduleId: at_pskc_moduleId(),
+     id_pskc_deviceUserId: at_pskc_deviceUserId(),
+}
+
+
+# Map of Symmetric Key Attribute OIDs to Attributes
+
+sKeyAttributesMap = {
+     id_pskc_keyId: at_pskc_keyId(),
+     id_pskc_algorithm: at_pskc_algorithm(),
+     id_pskc_issuer: at_pskc_issuer(),
+     id_pskc_keyProfileId: at_pskc_keyProfileId(),
+     id_pskc_keyReference: at_pskc_keyReference(),
+     id_pskc_friendlyName: at_pskc_friendlyName(),
+     id_pskc_algorithmParameters: at_pskc_algorithmParameters(),
+     id_pskc_counter: at_pskc_counter(),
+     id_pskc_time: at_pskc_time(),
+     id_pskc_timeInterval: at_pskc_timeInterval(),
+     id_pskc_timeDrift: at_pskc_timeDrift(),
+     id_pskc_valueMAC: at_pskc_valueMAC(),
+     id_pskc_keyUserId: at_pskc_keyUserId(),
+     id_pskc_keyStartDate: at_pskc_keyStartDate(),
+     id_pskc_keyExpiryDate: at_pskc_keyExpiryDate(),
+     id_pskc_numberOfTransactions: at_pskc_numberOfTransactions(),
+     id_pskc_keyUsages: at_pskc_keyUsage(),
+     id_pskc_pinPolicy: at_pskc_pinPolicy(),
+}
+
+
+# This definition replaces Attribute() from rfc5652.py; it is the same except
+# that opentype is added with sKeyPkgAttributesMap and sKeyAttributesMap
+
+class AttributeType(univ.ObjectIdentifier):
+    pass
+
+
+class AttributeValue(univ.Any):
+    pass
+
+
+class SKeyAttribute(univ.Sequence):
+    pass
+
+SKeyAttribute.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('attrType', AttributeType()),
+    namedtype.NamedType('attrValues',
+        univ.SetOf(componentType=AttributeValue()),
+        openType=opentype.OpenType('attrType', sKeyAttributesMap)
+    )
+)
+
+
+class SKeyPkgAttribute(univ.Sequence):
+    pass
+
+SKeyPkgAttribute.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('attrType', AttributeType()),
+    namedtype.NamedType('attrValues',
+        univ.SetOf(componentType=AttributeValue()),
+        openType=opentype.OpenType('attrType', sKeyPkgAttributesMap)
+    )
+)
+
+
+# Symmetric Key Package Content Type
+
+id_ct_KP_sKeyPackage = univ.ObjectIdentifier('1.2.840.113549.1.9.16.1.25')
+
+
+class KeyPkgVersion(univ.Integer):
+    pass
+
+KeyPkgVersion.namedValues = namedval.NamedValues(
+    ('v1', 1)
+)
+
+
+class OneSymmetricKey(univ.Sequence):
+    pass
+
+OneSymmetricKey.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('sKeyAttrs',
+        univ.SequenceOf(componentType=SKeyAttribute()).subtype(
+            subtypeSpec=constraint.ValueSizeConstraint(1, MAX))),
+    namedtype.OptionalNamedType('sKey', univ.OctetString())
+)
+
+OneSymmetricKey.sizeSpec = univ.Sequence.sizeSpec + constraint.ValueSizeConstraint(1, 2)
+
+
+class SymmetricKeys(univ.SequenceOf):
+    pass
+
+SymmetricKeys.componentType = OneSymmetricKey()
+SymmetricKeys.subtypeSpec=constraint.ValueSizeConstraint(1, MAX)
+
+
+class SymmetricKeyPackage(univ.Sequence):
+    pass
+
+SymmetricKeyPackage.componentType = namedtype.NamedTypes(
+    namedtype.DefaultedNamedType('version', KeyPkgVersion().subtype(value='v1')),
+    namedtype.OptionalNamedType('sKeyPkgAttrs',
+        univ.SequenceOf(componentType=SKeyPkgAttribute()).subtype(
+            subtypeSpec=constraint.ValueSizeConstraint(1, MAX),
+            implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.NamedType('sKeys', SymmetricKeys())
+)
+
+
+# Map of Content Type OIDs to Content Types are
+# added to the ones that are in rfc5652.py
+
+_cmsContentTypesMapUpdate = {
+    id_ct_KP_sKeyPackage: SymmetricKeyPackage(),
+}
+
+rfc5652.cmsContentTypesMap.update(_cmsContentTypesMapUpdate)

janus/lib/pkgconfig/formw.pc

@@ -0,0 +1,19 @@
+# pkg-config file generated by gen-pkgconfig
+# vile:makemode
+
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include/ncursesw
+abi_version=6
+major_version=6
+version=6.4.20221231
+
+Name: formw
+Description: ncurses 6.4 add-on library
+Version: ${version}
+URL: https://invisible-island.net/ncurses
+Requires.private: ncursesw
+Libs:  -L/root/envs/janus/lib -Wl,-O2 -Wl,--sort-common -Wl,--disable-new-dtags -Wl,--gc-sections -Wl,-rpath,/root/envs/janus/lib -Wl,-rpath-link,/root/envs/janus/lib -lformw
+Libs.private:  
+Cflags:  -D_GNU_SOURCE -DNCURSES_WIDECHAR -I${includedir} -I/root/envs/janus/include

janus/lib/pkgconfig/history.pc

@@ -0,0 +1,11 @@
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: History
+Description: Gnu History library for managing previously-entered lines
+URL: http://tiswww.cwru.edu/php/chet/readline/rltop.html
+Version: 8.2
+Libs: -L${libdir} -lhistory
+Cflags: -I${includedir}

janus/lib/pkgconfig/libcrypto.pc

@@ -0,0 +1,13 @@
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+enginesdir=${libdir}/engines-3
+modulesdir=${libdir}/ossl-modules
+
+Name: OpenSSL-libcrypto
+Description: OpenSSL cryptography library
+Version: 3.0.16
+Libs: -L${libdir} -lcrypto
+Libs.private: -ldl -pthread 
+Cflags: -I${includedir}

janus/lib/pkgconfig/libffi.pc

@@ -0,0 +1,11 @@
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+toolexeclibdir=${libdir}
+includedir=/root/envs/janus/include
+
+Name: libffi
+Description: Library supporting Foreign Function Interfaces
+Version: 3.4.4
+Libs: -L${toolexeclibdir} -lffi
+Cflags: -I${includedir}

janus/lib/pkgconfig/liblzma.pc

@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: 0BSD
+# Author: Lasse Collin
+
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: liblzma
+Description: General purpose data compression library
+URL: https://tukaani.org/xz/
+Version: 5.6.4
+Cflags: -I${includedir}
+Cflags.private: -DLZMA_API_STATIC
+Libs: -L${libdir} -llzma
+Libs.private: -pthread 

janus/lib/pkgconfig/libssl.pc

@@ -0,0 +1,11 @@
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: OpenSSL-libssl
+Description: Secure Sockets Layer and cryptography libraries
+Version: 3.0.16
+Requires.private: libcrypto
+Libs: -L${libdir} -lssl
+Cflags: -I${includedir}

janus/lib/pkgconfig/menuw.pc

@@ -0,0 +1,19 @@
+# pkg-config file generated by gen-pkgconfig
+# vile:makemode
+
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include/ncursesw
+abi_version=6
+major_version=6
+version=6.4.20221231
+
+Name: menuw
+Description: ncurses 6.4 add-on library
+Version: ${version}
+URL: https://invisible-island.net/ncurses
+Requires.private: ncursesw
+Libs:  -L/root/envs/janus/lib -Wl,-O2 -Wl,--sort-common -Wl,--disable-new-dtags -Wl,--gc-sections -Wl,-rpath,/root/envs/janus/lib -Wl,-rpath-link,/root/envs/janus/lib -lmenuw
+Libs.private:  
+Cflags:  -D_GNU_SOURCE -DNCURSES_WIDECHAR -I${includedir} -I/root/envs/janus/include

janus/lib/pkgconfig/ncurses++w.pc

@@ -0,0 +1,19 @@
+# pkg-config file generated by gen-pkgconfig
+# vile:makemode
+
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include/ncursesw
+abi_version=6
+major_version=6
+version=6.4.20221231
+
+Name: ncurses++w
+Description: ncurses 6.4 add-on library
+Version: ${version}
+URL: https://invisible-island.net/ncurses
+Requires.private: panelw, menuw, formw, ncursesw
+Libs:  -L/root/envs/janus/lib -Wl,-O2 -Wl,--sort-common -Wl,--disable-new-dtags -Wl,--gc-sections -Wl,-rpath,/root/envs/janus/lib -Wl,-rpath-link,/root/envs/janus/lib -lncurses++w
+Libs.private:  
+Cflags:  -D_GNU_SOURCE -DNCURSES_WIDECHAR -I${includedir} -I/root/envs/janus/include

janus/lib/pkgconfig/ncursesw.pc

@@ -0,0 +1,19 @@
+# pkg-config file generated by gen-pkgconfig
+# vile:makemode
+
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include/ncursesw
+abi_version=6
+major_version=6
+version=6.4.20221231
+
+Name: ncursesw
+Description: ncurses 6.4 library
+Version: ${version}
+URL: https://invisible-island.net/ncurses
+Requires.private: 
+Libs:  -L/root/envs/janus/lib -Wl,-O2 -Wl,--sort-common -Wl,--disable-new-dtags -Wl,--gc-sections -Wl,-rpath,/root/envs/janus/lib -Wl,-rpath-link,/root/envs/janus/lib -lncursesw -ltinfow
+Libs.private:  
+Cflags:  -D_GNU_SOURCE -DNCURSES_WIDECHAR -I${includedir} -I/root/envs/janus/include

janus/lib/pkgconfig/openssl.pc

@@ -0,0 +1,9 @@
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: OpenSSL
+Description: Secure Sockets Layer and cryptography libraries and tools
+Version: 3.0.16
+Requires: libssl libcrypto

janus/lib/pkgconfig/panelw.pc

@@ -0,0 +1,19 @@
+# pkg-config file generated by gen-pkgconfig
+# vile:makemode
+
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include/ncursesw
+abi_version=6
+major_version=6
+version=6.4.20221231
+
+Name: panelw
+Description: ncurses 6.4 add-on library
+Version: ${version}
+URL: https://invisible-island.net/ncurses
+Requires.private: ncursesw
+Libs:  -L/root/envs/janus/lib -Wl,-O2 -Wl,--sort-common -Wl,--disable-new-dtags -Wl,--gc-sections -Wl,-rpath,/root/envs/janus/lib -Wl,-rpath-link,/root/envs/janus/lib -lpanelw
+Libs.private:  
+Cflags:  -D_GNU_SOURCE -DNCURSES_WIDECHAR -I${includedir} -I/root/envs/janus/include

janus/lib/pkgconfig/python-3.10-embed.pc

@@ -0,0 +1,13 @@
+# See: man pkg-config
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: Python
+Description: Embed Python into an application
+Requires:
+Version: 3.10
+Libs.private: -lcrypt -lpthread -ldl  -lutil -lm
+Libs: -L${libdir} -lpython3.10
+Cflags: -I${includedir}/python3.10

janus/lib/pkgconfig/python3-embed.pc

@@ -0,0 +1,13 @@
+# See: man pkg-config
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: Python
+Description: Embed Python into an application
+Requires:
+Version: 3.10
+Libs.private: -lcrypt -lpthread -ldl  -lutil -lm
+Libs: -L${libdir} -lpython3.10
+Cflags: -I${includedir}/python3.10

janus/lib/pkgconfig/python3.pc

@@ -0,0 +1,13 @@
+# See: man pkg-config
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: Python
+Description: Build a C extension for Python
+Requires:
+Version: 3.10
+Libs.private: -lcrypt -lpthread -ldl  -lutil -lm
+Libs:
+Cflags: -I${includedir}/python3.10

janus/lib/pkgconfig/readline.pc

@@ -0,0 +1,12 @@
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: Readline
+Description: Gnu Readline library for command line editing
+URL: http://tiswww.cwru.edu/php/chet/readline/rltop.html
+Version: 8.2
+Requires.private: tinfo
+Libs: -L${libdir} -lreadline
+Cflags: -I${includedir}

janus/lib/pkgconfig/sqlite3.pc

@@ -0,0 +1,13 @@
+# Package Information for pkg-config
+
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: SQLite
+Description: SQL database engine
+Version: 3.45.3
+Libs: -L${libdir} -lsqlite3
+Libs.private: -lz -lm -ldl -lpthread 
+Cflags: -I${includedir}

janus/lib/pkgconfig/tcl.pc

@@ -0,0 +1,16 @@
+# tcl pkg-config source file
+
+prefix=/root/envs/janus
+exec_prefix=/root/envs/janus
+libdir=/root/envs/janus/lib
+includedir=${prefix}/include
+libfile=libtcl8.6.so
+
+Name: Tool Command Language
+Description: Tcl is a powerful, easy-to-learn dynamic programming language, suitable for a wide range of uses.
+URL: https://www.tcl-lang.org/
+Version: 8.6.14
+Requires.private: zlib >= 1.2.3
+Libs: -L${libdir} -ltcl8.6 -ltclstub8.6
+Libs.private: -ldl -lz  -lpthread -lm
+Cflags: -I${includedir}

janus/lib/pkgconfig/tinfow.pc

@@ -0,0 +1,19 @@
+# pkg-config file generated by gen-pkgconfig
+# vile:makemode
+
+prefix=/root/envs/janus
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include/ncursesw
+abi_version=6
+major_version=6
+version=6.4.20221231
+
+Name: tinfow
+Description: ncurses 6.4 terminal interface library
+Version: ${version}
+URL: https://invisible-island.net/ncurses
+Requires.private: 
+Libs:  -L/root/envs/janus/lib -Wl,-O2 -Wl,--sort-common -Wl,--disable-new-dtags -Wl,--gc-sections -Wl,-rpath,/root/envs/janus/lib -Wl,-rpath-link,/root/envs/janus/lib -ltinfow
+Libs.private:  
+Cflags:  -D_GNU_SOURCE -DNCURSES_WIDECHAR -I${includedir} -I/root/envs/janus/include

janus/lib/pkgconfig/tk.pc

@@ -0,0 +1,15 @@
+# tk pkg-config source file
+
+prefix=/root/envs/janus
+exec_prefix=/root/envs/janus
+libdir=/root/envs/janus/lib
+includedir=${prefix}/include
+
+Name: The Tk Toolkit
+Description: Tk is a cross-platform graphical user interface toolkit, the standard GUI not only for Tcl, but for many other dynamic languages as well.
+URL: https://www.tcl-lang.org/
+Version: 8.6.14
+Requires: tcl >= 8.6
+Libs: -L${libdir} -ltk8.6 -ltkstub8.6
+Libs.private:  -lX11
+Cflags: -I${includedir}

janus/lib/pkgconfig/uuid.pc

@@ -0,0 +1,11 @@
+prefix=/root/envs/janus
+exec_prefix=/root/envs/janus
+libdir=/root/envs/janus/lib
+includedir=/root/envs/janus/include
+
+Name: uuid
+Description: Universally unique id library
+Version: 2.32.1
+Requires:
+Cflags: -I${includedir}/uuid
+Libs: -L${libdir} -luuid

janus/lib/pkgconfig/zlib.pc

@@ -0,0 +1,13 @@
+prefix=/root/envs/janus
+exec_prefix=/root/envs/janus
+libdir=/root/envs/janus/lib
+sharedlibdir=/root/envs/janus/lib
+includedir=/root/envs/janus/include
+
+Name: zlib
+Description: zlib compression library
+Version: 1.2.13
+
+Requires:
+Libs: -L${libdir} -L${sharedlibdir} -lz
+Cflags: -I${includedir}

janus/lib/thread2.8.9/pkgIndex.tcl

@@ -0,0 +1,68 @@
+# -*- tcl -*-
+# Tcl package index file, version 1.1
+#
+
+if {![package vsatisfies [package provide Tcl] 8.4]} {
+    # Pre-8.4 Tcl interps we dont support at all.  Bye!
+    # 9.0+ Tcl interps are only supported on 32-bit platforms.
+    if {![package vsatisfies [package provide Tcl] 9.0]
+	    || ($::tcl_platform(pointerSize) != 4)} {
+	return
+    }
+}
+
+# All Tcl 8.4+ interps can [load] Thread 2.8.9
+#
+# For interps that are not thread-enabled, we still call [package ifneeded].
+# This is contrary to the usual convention, but is a good idea because we
+# cannot imagine any other version of Thread that might succeed in a
+# thread-disabled interp.  There's nothing to gain by yielding to other
+# competing callers of [package ifneeded Thread].  On the other hand,
+# deferring the error has the advantage that a script calling
+# [package require Thread] in a thread-disabled interp gets an error message
+# about a thread-disabled interp, instead of the message
+# "can't find package Thread".
+
+package ifneeded Thread 2.8.9 [list load [file join $dir libthread2.8.9.so] [string totitle thread]]
+
+# package Ttrace uses some support machinery.
+
+# In Tcl 8.4 interps we use some older interfaces
+if {![package vsatisfies [package provide Tcl] 8.5]} {
+    package ifneeded Ttrace 2.8.9 "
+    [list proc thread_source {dir} {
+	if {[info exists ::env(TCL_THREAD_LIBRARY)] &&
+		[file readable $::env(TCL_THREAD_LIBRARY)/ttrace.tcl]} {
+	    source $::env(TCL_THREAD_LIBRARY)/ttrace.tcl
+	} elseif {[file readable [file join $dir .. lib ttrace.tcl]]} {
+	    source [file join $dir .. lib ttrace.tcl]
+	} elseif {[file readable [file join $dir ttrace.tcl]]} {
+	    source [file join $dir ttrace.tcl]
+	}
+	if {[namespace which ::ttrace::update] ne ""} {
+	    ::ttrace::update
+	}
+    }]
+    [list thread_source $dir]
+    [list rename thread_source {}]"
+    return
+}
+
+# In Tcl 8.5+ interps; use [::apply]
+
+package ifneeded Ttrace 2.8.9 [list ::apply {{dir} {
+    if {[info exists ::env(TCL_THREAD_LIBRARY)] &&
+	[file readable $::env(TCL_THREAD_LIBRARY)/ttrace.tcl]} {
+	source $::env(TCL_THREAD_LIBRARY)/ttrace.tcl
+    } elseif {[file readable [file join $dir .. lib ttrace.tcl]]} {
+	source [file join $dir .. lib ttrace.tcl]
+    } elseif {[file readable [file join $dir ttrace.tcl]]} {
+	source [file join $dir ttrace.tcl]
+    }
+    if {[namespace which ::ttrace::update] ne ""} {
+	::ttrace::update
+    }
+}} $dir]
+
+
+

janus/lib/thread2.8.9/ttrace.tcl

@@ -0,0 +1,942 @@
+#
+# ttrace.tcl --
+#
+# Copyright (C) 2003 Zoran Vasiljevic, Archiware GmbH. All Rights Reserved.
+#
+# See the file "license.terms" for information on usage and redistribution of
+# this file, and for a DISCLAIMER OF ALL WARRANTIES.
+# ----------------------------------------------------------------------------
+#
+# User level commands:
+#
+#   ttrace::eval           top-level wrapper (ttrace-savvy eval)
+#   ttrace::enable         activates registered Tcl command traces
+#   ttrace::disable        terminates tracing of Tcl commands
+#   ttrace::isenabled      returns true if ttrace is enabled
+#   ttrace::cleanup        bring the interp to a pristine state
+#   ttrace::update         update interp to the latest trace epoch
+#   ttrace::config         setup some configuration options
+#   ttrace::getscript      returns a script for initializing interps
+#
+# Commands used for/from trace callbacks:
+#
+#   ttrace::atenable       register callback to be done at trace enable
+#   ttrace::atdisable      register callback to be done at trace disable
+#   ttrace::addtrace       register user-defined tracer callback
+#   ttrace::addscript      register user-defined script generator
+#   ttrace::addresolver    register user-defined command resolver
+#   ttrace::addcleanup     register user-defined cleanup procedures
+#   ttrace::addentry       adds one entry into the named trace store
+#   ttrace::getentry       returns the entry value from the named store
+#   ttrace::delentry       removes the entry from the named store
+#   ttrace::getentries     returns all entries from the named store
+#   ttrace::preload        register procedures to be preloaded always
+#
+#
+# Limitations:
+#
+#   o. [namespace forget] is still not implemented
+#   o. [namespace origin cmd] breaks if cmd is not already defined
+#
+#      I left this deliberately. I didn't want to override the [namespace]
+#      command in order to avoid potential slowdown.
+#
+
+namespace eval ttrace {
+
+    # Setup some compatibility wrappers
+    if {[info commands nsv_set] != ""} {
+        variable tvers 0
+        variable mutex ns_mutex
+        variable elock [$mutex create traceepochmutex]
+        # Import the underlying API; faster than recomputing
+        interp alias {} [namespace current]::_array   {} nsv_array
+        interp alias {} [namespace current]::_incr    {} nsv_incr
+        interp alias {} [namespace current]::_lappend {} nsv_lappend
+        interp alias {} [namespace current]::_names   {} nsv_names
+        interp alias {} [namespace current]::_set     {} nsv_set
+        interp alias {} [namespace current]::_unset   {} nsv_unset
+    } elseif {![catch {
+        variable tvers [package require Thread]
+    }]} {
+        variable mutex thread::mutex
+        variable elock [$mutex create]
+        # Import the underlying API; faster than recomputing
+        interp alias {} [namespace current]::_array   {} tsv::array
+        interp alias {} [namespace current]::_incr    {} tsv::incr
+        interp alias {} [namespace current]::_lappend {} tsv::lappend
+        interp alias {} [namespace current]::_names   {} tsv::names
+        interp alias {} [namespace current]::_set     {} tsv::set
+        interp alias {} [namespace current]::_unset   {} tsv::unset
+    } else {
+        error "requires NaviServer/AOLserver or Tcl threading extension"
+    }
+
+    # Keep in sync with the Thread package
+    package provide Ttrace 2.8.9
+
+    # Package variables
+    variable resolvers ""     ; # List of registered resolvers
+    variable tracers   ""     ; # List of registered cmd tracers
+    variable scripts   ""     ; # List of registered script makers
+    variable enables   ""     ; # List of trace-enable callbacks
+    variable disables  ""     ; # List of trace-disable callbacks
+    variable preloads  ""     ; # List of procedure names to preload
+    variable enabled   0      ; # True if trace is enabled
+    variable config           ; # Array with config options
+
+    variable epoch     -1     ; # The initialization epoch
+    variable cleancnt   0     ; # Counter of registered cleaners
+
+    # Package private namespaces
+    namespace eval resolve "" ; # Commands for resolving commands
+    namespace eval trace   "" ; # Commands registered for tracing
+    namespace eval enable  "" ; # Commands invoked at trace enable
+    namespace eval disable "" ; # Commands invoked at trace disable
+    namespace eval script  "" ; # Commands for generating scripts
+
+    # Exported commands
+    namespace export unknown
+
+    # Initialize ttrace shared state
+    if {[_array exists ttrace] == 0} {
+        _set ttrace lastepoch $epoch
+        _set ttrace epochlist ""
+    }
+
+    # Initially, allow creation of epochs
+    set config(-doepochs) 1
+
+    proc eval {cmd args} {
+        enable
+        set code [catch {uplevel 1 [concat $cmd $args]} result]
+        disable
+        if {$code == 0} {
+            if {[llength [info commands ns_ictl]]} {
+                ns_ictl save [getscript]
+            } else {
+                thread::broadcast {
+                    package require Ttrace
+                    ttrace::update
+                }
+            }
+        }
+        return -code $code \
+            -errorinfo $::errorInfo -errorcode $::errorCode $result
+    }
+
+    proc config {args} {
+        variable config
+        if {[llength $args] == 0} {
+            array get config
+        } elseif {[llength $args] == 1} {
+            set opt [lindex $args 0]
+            set config($opt)
+        } else {
+            set opt [lindex $args 0]
+            set val [lindex $args 1]
+            set config($opt) $val
+        }
+    }
+
+    proc enable {} {
+        variable config
+        variable tracers
+        variable enables
+        variable enabled
+        incr enabled 1
+        if {$enabled > 1} {
+            return
+        }
+        if {$config(-doepochs) != 0} {
+            variable epoch [_newepoch]
+        }
+        set nsp [namespace current]
+        foreach enabler $enables {
+            enable::_$enabler
+        }
+        foreach trace $tracers {
+            if {[info commands $trace] != ""} {
+                trace add execution $trace leave ${nsp}::trace::_$trace
+            }
+        }
+    }
+
+    proc disable {} {
+        variable enabled
+        variable tracers
+        variable disables
+        incr enabled -1
+        if {$enabled > 0} {
+            return
+        }
+        set nsp [namespace current]
+        foreach disabler $disables {
+            disable::_$disabler
+        }
+        foreach trace $tracers {
+            if {[info commands $trace] != ""} {
+                trace remove execution $trace leave ${nsp}::trace::_$trace
+            }
+        }
+    }
+
+    proc isenabled {} {
+        variable enabled
+        expr {$enabled > 0}
+    }
+
+    proc update {{from -1}} {
+        if {$from < 0} {
+            variable epoch [_set ttrace lastepoch]
+        } else {
+            if {[lsearch [_set ttrace epochlist] $from] < 0} {
+                error "no such epoch: $from"
+            }
+            variable epoch $from
+        }
+        uplevel 1 [getscript]
+    }
+
+    proc getscript {} {
+        variable preloads
+        variable epoch
+        variable scripts
+        append script [_serializensp] \n
+        append script "::namespace eval [namespace current] {" \n
+        append script "::namespace export unknown" \n
+        append script "_useepoch $epoch" \n
+        append script "}" \n
+        foreach cmd $preloads {
+            append script [_serializeproc $cmd] \n
+        }
+        foreach maker $scripts {
+            append script [script::_$maker]
+        }
+        return $script
+    }
+
+    proc cleanup {args} {
+        foreach cmd [info commands resolve::cleaner_*] {
+            uplevel 1 $cmd $args
+        }
+    }
+
+    proc preload {cmd} {
+        variable preloads
+        if {[lsearch $preloads $cmd] < 0} {
+            lappend preloads $cmd
+        }
+    }
+
+    proc atenable {cmd arglist body} {
+        variable enables
+        if {[lsearch $enables $cmd] < 0} {
+            lappend enables $cmd
+            set cmd [namespace current]::enable::_$cmd
+            proc $cmd $arglist $body
+            return $cmd
+        }
+    }
+
+    proc atdisable {cmd arglist body} {
+        variable disables
+        if {[lsearch $disables $cmd] < 0} {
+            lappend disables $cmd
+            set cmd [namespace current]::disable::_$cmd
+            proc $cmd $arglist $body
+            return $cmd
+        }
+    }
+
+    proc addtrace {cmd arglist body} {
+        variable tracers
+        if {[lsearch $tracers $cmd] < 0} {
+            lappend tracers $cmd
+            set tracer [namespace current]::trace::_$cmd
+            proc $tracer $arglist $body
+            if {[isenabled]} {
+                trace add execution $cmd leave $tracer
+            }
+            return $tracer
+        }
+    }
+
+    proc addscript {cmd body} {
+        variable scripts
+        if {[lsearch $scripts $cmd] < 0} {
+            lappend scripts $cmd
+            set cmd [namespace current]::script::_$cmd
+            proc $cmd args $body
+            return $cmd
+        }
+    }
+
+    proc addresolver {cmd arglist body} {
+        variable resolvers
+        if {[lsearch $resolvers $cmd] < 0} {
+            lappend resolvers $cmd
+            set cmd [namespace current]::resolve::$cmd
+            proc $cmd $arglist $body
+            return $cmd
+        }
+    }
+
+    proc addcleanup {body} {
+        variable cleancnt
+        set cmd [namespace current]::resolve::cleaner_[incr cleancnt]
+        proc $cmd args $body
+        return $cmd
+    }
+
+    proc addentry {cmd var val} {
+        variable epoch
+        _set ${epoch}-$cmd $var $val
+    }
+
+    proc delentry {cmd var} {
+        variable epoch
+        set ei $::errorInfo
+        set ec $::errorCode
+        catch {_unset ${epoch}-$cmd $var}
+        set ::errorInfo $ei
+        set ::errorCode $ec
+    }
+
+    proc getentry {cmd var} {
+        variable epoch
+        set ei $::errorInfo
+        set ec $::errorCode
+        if {[catch {_set ${epoch}-$cmd $var} val]} {
+            set ::errorInfo $ei
+            set ::errorCode $ec
+            set val ""
+        }
+        return $val
+    }
+
+    proc getentries {cmd {pattern *}} {
+        variable epoch
+        _array names ${epoch}-$cmd $pattern
+    }
+
+    proc unknown {args} {
+        set cmd [lindex $args 0]
+        if {[uplevel 1 ttrace::_resolve [list $cmd]]} {
+            set c [catch {uplevel 1 $cmd [lrange $args 1 end]} r]
+        } else {
+            set c [catch {uplevel 1 ::tcl::unknown $args} r]
+        }
+        return -code $c -errorcode $::errorCode -errorinfo $::errorInfo $r
+    }
+
+    proc _resolve {cmd} {
+        variable resolvers
+        foreach resolver $resolvers {
+            if {[uplevel 1 [info comm resolve::$resolver] [list $cmd]]} {
+                return 1
+            }
+        }
+        return 0
+    }
+
+    proc _getthread {} {
+        if {[info commands ns_thread] == ""} {
+            thread::id
+        } else {
+            ns_thread getid
+        }
+    }
+
+    proc _getthreads {} {
+        if {[info commands ns_thread] == ""} {
+            return [thread::names]
+        } else {
+            foreach entry [ns_info threads] {
+                lappend threads [lindex $entry 2]
+            }
+            return $threads
+        }
+    }
+
+    proc _newepoch {} {
+        variable elock
+        variable mutex
+        $mutex lock $elock
+        set old [_set ttrace lastepoch]
+        set new [_incr ttrace lastepoch]
+        _lappend ttrace $new [_getthread]
+        if {$old >= 0} {
+            _copyepoch $old $new
+            _delepochs
+        }
+        _lappend ttrace epochlist $new
+        $mutex unlock $elock
+        return $new
+    }
+
+    proc _copyepoch {old new} {
+        foreach var [_names $old-*] {
+            set cmd [lindex [split $var -] 1]
+            _array reset $new-$cmd [_array get $var]
+        }
+    }
+
+    proc _delepochs {} {
+        set tlist [_getthreads]
+        set elist ""
+        foreach epoch [_set ttrace epochlist] {
+            if {[_dropepoch $epoch $tlist] == 0} {
+                lappend elist $epoch
+            } else {
+                _unset ttrace $epoch
+            }
+        }
+        _set ttrace epochlist $elist
+    }
+
+    proc _dropepoch {epoch threads} {
+        set self [_getthread]
+        foreach tid [_set ttrace $epoch] {
+            if {$tid != $self && [lsearch $threads $tid] >= 0} {
+                lappend alive $tid
+            }
+        }
+        if {[info exists alive]} {
+            _set ttrace $epoch $alive
+            return 0
+        } else {
+            foreach var [_names $epoch-*] {
+                _unset $var
+            }
+            return 1
+        }
+    }
+
+    proc _useepoch {epoch} {
+        if {$epoch >= 0} {
+            set tid [_getthread]
+            if {[lsearch [_set ttrace $epoch] $tid] == -1} {
+                _lappend ttrace $epoch $tid
+            }
+        }
+    }
+
+    proc _serializeproc {cmd} {
+        set dargs [info args $cmd]
+        set pbody [info body $cmd]
+        set pargs ""
+        foreach arg $dargs {
+            if {![info default $cmd $arg def]} {
+                lappend pargs $arg
+            } else {
+                lappend pargs [list $arg $def]
+            }
+        }
+        set nsp [namespace qual $cmd]
+        if {$nsp == ""} {
+            set nsp "::"
+        }
+        append res [list ::namespace eval $nsp] " {" \n
+        append res [list ::proc [namespace tail $cmd] $pargs $pbody] \n
+        append res "}" \n
+    }
+
+    proc _serializensp {{nsp ""} {result _}} {
+        upvar $result res
+        if {$nsp == ""} {
+            set nsp [namespace current]
+        }
+        append res [list ::namespace eval $nsp] " {" \n
+        foreach var [info vars ${nsp}::*] {
+            set vname [namespace tail $var]
+            if {[array exists $var] == 0} {
+                append res [list ::variable $vname [set $var]] \n
+            } else {
+                append res [list ::variable $vname] \n
+                append res [list ::array set $vname [array get $var]] \n
+            }
+        }
+        foreach cmd [info procs ${nsp}::*] {
+            append res [_serializeproc $cmd] \n
+        }
+        append res "}" \n
+        foreach nn [namespace children $nsp] {
+            _serializensp $nn res
+        }
+        return $res
+    }
+}
+
+#
+# The code below is ment to be run once during the application start.  It
+# provides implementation of tracing callbacks for some Tcl commands.  Users
+# can supply their own tracer implementations on-the-fly.
+#
+# The code below will create traces for the following Tcl commands:
+#    "namespace", "variable", "load", "proc" and "rename"
+#
+# Also, the Tcl object extension XOTcl 1.1.0 is handled and all XOTcl related
+# things, like classes and objects are traced (many thanks to Gustaf Neumann
+# from XOTcl for his kind help and support).
+#
+
+eval {
+
+    #
+    # Register the "load" trace. This will create the following key/value pair
+    # in the "load" store:
+    #
+    #  --- key ----              --- value ---
+    #  <path_of_loaded_image>    <name_of_the_init_proc>
+    #
+    # We normally need only the name_of_the_init_proc for being able to load
+    # the package in other interpreters, but we store the path to the image
+    # file as well.
+    #
+
+    ttrace::addtrace load {cmdline code args} {
+        if {$code != 0} {
+            return
+        }
+        set image [lindex $cmdline 1]
+        set initp [lindex $cmdline 2]
+        if {$initp == ""} {
+            foreach pkg [info loaded] {
+                if {[lindex $pkg 0] == $image} {
+                    set initp [lindex $pkg 1]
+                }
+            }
+        }
+        ttrace::addentry load $image $initp
+    }
+
+    ttrace::addscript load {
+        append res "\n"
+        foreach entry [ttrace::getentries load] {
+            set initp [ttrace::getentry load $entry]
+            append res "::load {} $initp" \n
+        }
+        return $res
+    }
+
+    #
+    # Register the "namespace" trace. This will create the following key/value
+    # entry in "namespace" store:
+    #
+    #  --- key ----                   --- value ---
+    #  ::fully::qualified::namespace  1
+    #
+    # It will also fill the "proc" store for procedures and commands imported
+    # in this namespace with following:
+    #
+    #  --- key ----                   --- value ---
+    #  ::fully::qualified::proc       [list <ns>  "" ""]
+    #
+    # The <ns> is the name of the namespace where the command or procedure is
+    # imported from.
+    #
+
+    ttrace::addtrace namespace {cmdline code args} {
+        if {$code != 0} {
+            return
+        }
+        set nop [lindex $cmdline 1]
+        set cns [uplevel 1 namespace current]
+        if {$cns == "::"} {
+            set cns ""
+        }
+        switch -glob $nop {
+            eva* {
+                set nsp [lindex $cmdline 2]
+                if {![string match "::*" $nsp]} {
+                    set nsp ${cns}::$nsp
+                }
+                ttrace::addentry namespace $nsp 1
+            }
+            imp* {
+                # - parse import arguments (skip opt "-force")
+                set opts [lrange $cmdline 2 end]
+                if {[string match "-fo*" [lindex $opts 0]]} {
+                    set opts [lrange $cmdline 3 end]
+                }
+                # - register all imported procs and commands
+                foreach opt $opts {
+                    if {![string match "::*" [::namespace qual $opt]]} {
+                        set opt ${cns}::$opt
+                    }
+                    # - first import procs
+                    foreach entry [ttrace::getentries proc $opt] {
+                        set cmd ${cns}::[::namespace tail $entry]
+                        set nsp [::namespace qual $entry]
+                        set done($cmd) 1
+                        set entry [list 0 $nsp "" ""]
+                        ttrace::addentry proc $cmd $entry
+                    }
+
+                    # - then import commands
+                    foreach entry [info commands $opt] {
+                        set cmd ${cns}::[::namespace tail $entry]
+                        set nsp [::namespace qual $entry]
+                        if {[info exists done($cmd)] == 0} {
+                            set entry [list 0 $nsp "" ""]
+                            ttrace::addentry proc $cmd $entry
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    ttrace::addscript namespace {
+        append res \n
+        foreach entry [ttrace::getentries namespace] {
+            append res "::namespace eval $entry {}" \n
+        }
+        return $res
+    }
+
+    #
+    # Register the "variable" trace. This will create the following key/value
+    # entry in the "variable" store:
+    #
+    #  --- key ----                   --- value ---
+    #  ::fully::qualified::variable   1
+    #
+    # The variable value itself is ignored at the time of
+    # trace/collection. Instead, we take the real value at the time of script
+    # generation.
+    #
+
+    ttrace::addtrace variable {cmdline code args} {
+        if {$code != 0} {
+            return
+        }
+        set opts [lrange $cmdline 1 end]
+        if {[llength $opts]} {
+            set cns [uplevel 1 namespace current]
+            if {$cns == "::"} {
+                set cns ""
+            }
+            foreach {var val} $opts {
+                if {![string match "::*" $var]} {
+                    set var ${cns}::$var
+                }
+                ttrace::addentry variable $var 1
+            }
+        }
+    }
+
+    ttrace::addscript variable {
+        append res \n
+        foreach entry [ttrace::getentries variable] {
+            set cns [namespace qual $entry]
+            set var [namespace tail $entry]
+            append res "::namespace eval $cns {" \n
+            append res "::variable $var"
+            if {[array exists $entry]} {
+                append res "\n::array set $var [list [array get $entry]]" \n
+            } elseif {[info exists $entry]} {
+                append res " [list [set $entry]]" \n
+            } else {
+                append res \n
+            }
+            append res "}" \n
+        }
+        return $res
+    }
+
+
+    #
+    # Register the "rename" trace. It will create the following key/value pair
+    # in "rename" store:
+    #
+    #  --- key ----              --- value ---
+    #  ::fully::qualified::old  ::fully::qualified::new
+    #
+    # The "new" value may be empty, for commands that have been deleted. In
+    # such cases we also remove any traced procedure definitions.
+    #
+
+    ttrace::addtrace rename {cmdline code args} {
+        if {$code != 0} {
+            return
+        }
+        set cns [uplevel 1 namespace current]
+        if {$cns == "::"} {
+            set cns ""
+        }
+        set old [lindex $cmdline 1]
+        if {![string match "::*" $old]} {
+            set old ${cns}::$old
+        }
+        set new [lindex $cmdline 2]
+        if {$new != ""} {
+            if {![string match "::*" $new]} {
+                set new ${cns}::$new
+            }
+            ttrace::addentry rename $old $new
+        } else {
+            ttrace::delentry proc $old
+        }
+    }
+
+    ttrace::addscript rename {
+        append res \n
+        foreach old [ttrace::getentries rename] {
+            set new [ttrace::getentry rename $old]
+            append res "::rename $old {$new}" \n
+        }
+        return $res
+    }
+
+    #
+    # Register the "proc" trace. This will create the following key/value pair
+    # in the "proc" store:
+    #
+    #  --- key ----              --- value ---
+    #  ::fully::qualified::proc  [list <epoch> <ns> <arglist> <body>]
+    #
+    # The <epoch> chages anytime one (re)defines a proc.  The <ns> is the
+    # namespace where the command was imported from. If empty, the <arglist>
+    # and <body> will hold the actual procedure definition. See the
+    # "namespace" tracer implementation also.
+    #
+
+    ttrace::addtrace proc {cmdline code args} {
+        if {$code != 0} {
+            return
+        }
+        set cns [uplevel 1 namespace current]
+        if {$cns == "::"} {
+            set cns ""
+        }
+        set cmd [lindex $cmdline 1]
+        if {![string match "::*" $cmd]} {
+            set cmd ${cns}::$cmd
+        }
+        set dargs [info args $cmd]
+        set pbody [info body $cmd]
+        set pargs ""
+        foreach arg $dargs {
+            if {![info default $cmd $arg def]} {
+                lappend pargs $arg
+            } else {
+                lappend pargs [list $arg $def]
+            }
+        }
+        set pdef [ttrace::getentry proc $cmd]
+        if {$pdef == ""} {
+            set epoch -1 ; # never traced before
+        } else {
+            set epoch [lindex $pdef 0]
+        }
+        ttrace::addentry proc $cmd [list [incr epoch] "" $pargs $pbody]
+    }
+
+    ttrace::addscript proc {
+        return {
+            if {[info command ::tcl::unknown] == ""} {
+                rename ::unknown ::tcl::unknown
+                namespace import -force ::ttrace::unknown
+            }
+            if {[info command ::tcl::info] == ""} {
+                rename ::info ::tcl::info
+            }
+            proc ::info args {
+                set cmd [lindex $args 0]
+                set hit [lsearch -glob {commands procs args default body} $cmd*]
+                if {$hit > 1} {
+                    if {[catch {uplevel 1 ::tcl::info $args}]} {
+                        uplevel 1 ttrace::_resolve [list [lindex $args 1]]
+                    }
+                    return [uplevel 1 ::tcl::info $args]
+                }
+                if {$hit == -1} {
+                    return [uplevel 1 ::tcl::info $args]
+                }
+                set cns [uplevel 1 namespace current]
+                if {$cns == "::"} {
+                    set cns ""
+                }
+                set pat [lindex $args 1]
+                if {![string match "::*" $pat]} {
+                    set pat ${cns}::$pat
+                }
+                set fns [ttrace::getentries proc $pat]
+                if {[string match $cmd* commands]} {
+                    set fns [concat $fns [ttrace::getentries xotcl $pat]]
+                }
+                foreach entry $fns {
+                    if {$cns != [namespace qual $entry]} {
+                        set lazy($entry) 1
+                    } else {
+                        set lazy([namespace tail $entry]) 1
+                    }
+                }
+                foreach entry [uplevel 1 ::tcl::info $args] {
+                    set lazy($entry) 1
+                }
+                array names lazy
+            }
+        }
+    }
+
+    #
+    # Register procedure resolver. This will try to resolve the command in the
+    # current namespace first, and if not found, in global namespace.  It also
+    # handles commands imported from other namespaces.
+    #
+
+    ttrace::addresolver resolveprocs {cmd {export 0}} {
+        set cns [uplevel 1 namespace current]
+        set name [namespace tail $cmd]
+        if {$cns == "::"} {
+            set cns ""
+        }
+        if {![string match "::*" $cmd]} {
+            set ncmd ${cns}::$cmd
+            set gcmd ::$cmd
+        } else {
+            set ncmd $cmd
+            set gcmd $cmd
+        }
+        set pdef [ttrace::getentry proc $ncmd]
+        if {$pdef == ""} {
+            set pdef [ttrace::getentry proc $gcmd]
+            if {$pdef == ""} {
+                return 0
+            }
+            set cmd $gcmd
+        } else {
+            set cmd $ncmd
+        }
+        set epoch [lindex $pdef 0]
+        set pnsp  [lindex $pdef 1]
+        if {$pnsp != ""} {
+            set nsp [namespace qual $cmd]
+            if {$nsp == ""} {
+                set nsp ::
+            }
+            set cmd ${pnsp}::$name
+            if {[resolveprocs $cmd 1] == 0 && [info commands $cmd] == ""} {
+                return 0
+            }
+            namespace eval $nsp "namespace import -force $cmd"
+        } else {
+            uplevel 0 [list ::proc $cmd [lindex $pdef 2] [lindex $pdef 3]]
+            if {$export} {
+                set nsp [namespace qual $cmd]
+                if {$nsp == ""} {
+                    set nsp ::
+                }
+                namespace eval $nsp "namespace export $name"
+            }
+        }
+        variable resolveproc
+        set resolveproc($cmd) $epoch
+        return 1
+    }
+
+    #
+    # For XOTcl, the entire item introspection/tracing is delegated to XOTcl
+    # itself. The xotcl store is filled with this:
+    #
+    #  --- key ----               --- value ---
+    #  ::fully::qualified::item   <body>
+    #
+    # The <body> is the script used to generate the entire item (class,
+    # object). Note that we do not fill in this during code tracing. It is
+    # done during the script generation. In this step, only the placeholder is
+    # set.
+    #
+    # NOTE: we assume all XOTcl commands are imported in global namespace
+    #
+
+    ttrace::atenable XOTclEnabler {args} {
+        if {[info commands ::xotcl::Class] == ""} {
+            return
+        }
+        if {[info commands ::xotcl::_creator] == ""} {
+            ::xotcl::Class create ::xotcl::_creator -instproc create {args} {
+                set result [next]
+                if {![string match ::xotcl::_* $result]} {
+                    ttrace::addentry xotcl $result ""
+                }
+                return $result
+            }
+        }
+        ::xotcl::Class instmixin ::xotcl::_creator
+    }
+
+    ttrace::atdisable XOTclDisabler {args} {
+        if {   [info commands ::xotcl::Class] == ""
+            || [info commands ::xotcl::_creator] == ""} {
+            return
+        }
+        ::xotcl::Class instmixin ""
+        ::xotcl::_creator destroy
+    }
+
+    set resolver [ttrace::addresolver resolveclasses {classname} {
+        set cns [uplevel 1 namespace current]
+        set script [ttrace::getentry xotcl $classname]
+        if {$script == ""} {
+            set name [namespace tail $classname]
+            if {$cns == "::"} {
+                set script [ttrace::getentry xotcl ::$name]
+            } else {
+                set script [ttrace::getentry xotcl ${cns}::$name]
+                if {$script == ""} {
+                    set script [ttrace::getentry xotcl ::$name]
+                }
+            }
+            if {$script == ""} {
+                return 0
+            }
+        }
+        uplevel 1 [list namespace eval $cns $script]
+        return 1
+    }]
+
+    ttrace::addscript xotcl [subst -nocommands {
+        if {![catch {Serializer new} ss]} {
+            foreach entry [ttrace::getentries xotcl] {
+                if {[ttrace::getentry xotcl \$entry] == ""} {
+                    ttrace::addentry xotcl \$entry [\$ss serialize \$entry]
+                }
+            }
+            \$ss destroy
+            return {::xotcl::Class proc __unknown name {$resolver \$name}}
+        }
+    }]
+
+    #
+    # Register callback to be called on cleanup. This will trash lazily loaded
+    # procs which have changed since.
+    #
+
+    ttrace::addcleanup {
+        variable resolveproc
+        foreach cmd [array names resolveproc] {
+            set def [ttrace::getentry proc $cmd]
+            if {$def != ""} {
+                set new [lindex $def 0]
+                set old $resolveproc($cmd)
+                if {[info command $cmd] != "" && $new != $old} {
+                    catch {rename $cmd ""}
+                }
+            }
+        }
+    }
+}
+
+# EOF
+return
+
+# Local Variables:
+# mode: tcl
+# fill-column: 78
+# tab-width: 8
+# indent-tabs-mode: nil
+# End:

janus/share/man/de/man1/lzdiff.1

@@ -0,0 +1,58 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" German translation for xz-man.
+.\" Mario Blättermann <[email protected]>, 2015, 2019-2020, 2022-2024.
+.\"
+.\" (Note that this file is not based on gzip's zdiff.1.)
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZDIFF 1 "13. Februar 2024" Tukaani XZ\-Dienstprogramme
+.SH BEZEICHNUNG
+xzcmp, xzdiff, lzcmp, lzdiff \- komprimierte Dateien vergleichen
+.
+.SH ÜBERSICHT
+\fBxzcmp\fP [\fIOption …\fP] \fIDatei1\fP [\fIDatei2\fP]
+.br
+\fBxzdiff\fP \&…
+.br
+\fBlzcmp\fP \&…
+.br
+\fBlzdiff\fP \&…
+.
+.SH BESCHREIBUNG
+\fBxzcmp\fP und \fBxzdiff\fP vergleichen den unkomprimierten Inhalt zweier
+Dateien. Die unkomprimierten Daten und Optionen werden an \fBcmp\fP(1) oder
+\fBdiff\fP(1) übergeben, sofern weder \fB\-\-help\fP noch \fB\-\-version\fP angegeben
+wird.
+.PP
+Wenn sowohl \fIDatei1\fP als auch \fIDatei2\fP angegeben sind, können diese
+unkomprimierte Dateien oder Dateien in Formaten sein, die \fBxz\fP(1),
+\fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1)
+dekomprimieren können. Die erforderlichen Dekomprimierungsbefehle werden aus
+den Dateiendungen von \fIDatei1\fP und \fIDatei2\fP abgeleitet. Für eine Datei mit
+einer unbekannten Endung wird angenommen, dass sie entweder unkomprimiert
+ist oder von \fBxz\fP(1) dekomprimiert werden kann.
+.PP
+Falls nur ein Dateiname angegeben wird, muss \fIDatei1\fP eine Endung eines
+unterstützten Kompressionsformat haben und der Name von \fIDatei2\fP wird aus
+\fIDatei1\fP abgeleitet, indem die Endung des Kompressionsformats entfernt
+wird.
+.PP
+Die Befehle \fBlzcmp\fP und \fBlzdiff\fP dienen der Abwärtskompatibilität zu den
+LZMA\-Dienstprogrammen.
+.
+.SH EXIT\-STATUS
+Falls ein Dekompressionsfehler auftritt, ist der Exit\-Status
+\fB2\fP. Anderenfalls wird der Exit\-Status von \fBcmp\fP(1) oder \fBdiff\fP(1)
+verwendet.
+.
+.SH "SIEHE AUCH"
+\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1),
+\fBzstd\fP(1), \fBlz4\fP(1)

janus/share/man/de/man1/lzgrep.1

@@ -0,0 +1,96 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" German translation for xz-man.
+.\" Mario Blättermann <[email protected]>, 2015, 2019-2020, 2022-2024.
+.\"
+.\" (Note that this file is not based on gzip's zgrep.1.)
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZGREP 1 "13. Februar 2024" Tukaani XZ\-Dienstprogramme
+.SH BEZEICHNUNG
+xzgrep \- möglicherweise komprimierte Dateien nach Mustern durchsuchen
+.
+.SH ÜBERSICHT
+\fBxzgrep\fP [\fIOption …\fP] [\fIMusterliste\fP] [\fIDatei …\fP]
+.br
+\fBxzegrep\fP …
+.br
+\fBxzfgrep\fP …
+.br
+\fBlzgrep\fP …
+.br
+\fBlzegrep\fP …
+.br
+\fBlzfgrep\fP …
+.
+.SH BESCHREIBUNG
+\fBxzgrep\fP ruft \fBgrep\fP(1) mit dem unkomprimierten Inhalt von Dateien
+auf. Die Formate der \fIDateien\fP werden aus den Dateiendungen
+abgeleitet. Jede \fIDatei\fP mit einer Endung, die von \fBxz\fP(1), \fBgzip\fP(1),
+\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) unterstützt wird, wird
+dekomprimiert; für andere Dateien wird angenommen, dass sie bereits in
+unkomprimierter Form vorliegen.
+.PP
+Wenn keine \fIDateien\fP angegeben werden oder \fIDatei\fP als \fB\-\fP angegeben
+wird, wird aus der Standardeingabe gelesen. Beim Lesen aus der
+Standardeingabe werden nur die von \fBxz\fP(1) unterstützten Dateien
+dekomprimiert. Für andere Dateien wird angenommen, dass sie bereits in
+unkomprimierter Form vorliegen.
+.PP
+Die meisten \fIOptionen\fP von \fBgrep\fP(1) werden unterstützt, die folgenden
+jedoch nicht:
+.IP "" 4
+\fB\-r\fP, \fB\-\-recursive\fP
+.IP "" 4
+\fB\-R\fP, \fB\-\-dereference\-recursive\fP
+.IP "" 4
+\fB\-d\fP, \fB\-\-directories=\fP\fIAktion\fP
+.IP "" 4
+\fB\-Z\fP, \fB\-\-null\fP
+.IP "" 4
+\fB\-z\fP, \fB\-\-null\-data\fP
+.IP "" 4
+\fB\-\-include=\fP\fIGlob\fP
+.IP "" 4
+\fB\-\-exclude=\fP\fIGlob\fP
+.IP "" 4
+\fB\-\-exclude\-from=\fP\fIDatei\fP
+.IP "" 4
+\fB\-\-exclude\-dir=\fP\fIGlob\fP
+.PP
+\fBxzegrep\fP ist ein Alias für \fBxzgrep \-E\fP.  \fBxzfgrep\fP ist ein Alias für
+\fBxzgrep \-F\fP.
+.PP
+Die Befehle \fBlzgrep\fP, \fBlzegrep\fP und \fBlzfgrep\fP dienen der
+Abwärtskompatibilität zu den LZMA\-Dienstprogrammen.
+.
+.SH EXIT\-STATUS
+.TP 
+0
+In mindestens einer der Eingabedateien wurde mindestens ein Treffer
+gefunden. Es sind keine Fehler aufgetreten.
+.TP 
+1
+In keiner der Eingabedateien wurde ein Treffer gefunden. Es sind keine
+Fehler aufgetreten.
+.TP 
+>1
+Ein oder mehrere Fehler sind aufgetreten. Es ist unbekannt, ob Treffer
+gefunden wurden.
+.
+.SH UMGEBUNGSVARIABLEN
+.TP 
+\fBGREP\fP
+Wenn die Umgebungsvariable \fBGREP\fP auf einen nicht\-leeren Wert gesetzt ist,
+wird diese anstelle von \fBgrep\fP(1), \fBgrep \-E\fP oder \fBgrep \-F\fP verwendet.
+.
+.SH "SIEHE AUCH"
+\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1),
+\fBlz4\fP(1), \fBzgrep\fP(1)

janus/share/man/de/man1/lzmore.1

@@ -0,0 +1,49 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Andrew Dudman
+.\"          Lasse Collin
+.\"
+.\" German translation for xz-man.
+.\" Mario Blättermann <[email protected]>, 2015, 2019-2020, 2022-2024.
+.\"
+.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.)
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZMORE 1 "12. Februar 2024" Tukaani XZ\-Dienstprogramme
+.SH BEZEICHNUNG
+xzmore, lzmore \- mit xz oder lzma komprimierte (Text\-)Dateien lesen
+.
+.SH ÜBERSICHT
+\fBxzmore\fP [\fIDatei\fP …]
+.br
+\fBlzmore\fP [\fIDatei\fP …]
+.
+.SH BESCHREIBUNG
+\fBxzmore\fP zeigt Text aus komprimierten Dateien mit Hilfe des Pagers
+(Textanzeigeprogramms) \fBmore\fP(1) in einem Terminal an. Von \fBxz\fP(1)
+unterstützte Dateien werden dekomprimiert; für andere Dateien wird
+angenommen, dass sie bereits in unkomprimierter Form vorliegen. Wenn keine
+\fIDateien\fP angegeben werden, liest \fBxzmore\fP aus der Standardeingabe. Im
+\fBmore\fP(1)\-Handbuch finden Sie Informationen zu den Tastaturbefehlen.
+.PP
+Beachten Sie, dass Zurückrollen nicht möglich sein könnte, abhängig von der
+Implementierung von \fBmore\fP(1). Das kommt daher, dass \fBxzmore\fP eine Pipe
+verwendet, um die dekomprimierten Daten an \fBmore\fP(1) zu
+übergeben. \fBxzless\fP(1) verwendet \fBless\fP(1), welches fortgeschrittenere
+Funktionen bietet.
+.PP
+Der Befehl \fBlzmore\fP dient der Abwärtskompatibilität zu den
+LZMA\-Dienstprogrammen.
+.
+.SH UMGEBUNGSVARIABLEN
+.TP 
+\fBPAGER\fP
+Falls die Umgebungsvariable \fBPAGER\fP gesetzt ist, wird diese als Pager
+(Textanzeigeprogramm) anstelle von \fBmore\fP(1) verwendet.
+.
+.SH "SIEHE AUCH"
+\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1)

janus/share/man/de/man1/xz.1

@@ -0,0 +1,2070 @@
+'\" t
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" German translation for xz-man.
+.\" Mario Blättermann <[email protected]>, 2015, 2019-2020, 2022-2024.
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZ 1 2024\-12\-30 Tukaani XZ\-Dienstprogramme
+.
+.SH BEZEICHNUNG
+xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz\- und .lzma\-Dateien komprimieren
+oder dekomprimieren
+.
+.SH ÜBERSICHT
+\fBxz\fP [\fIOption…\fP] [\fIDatei…\fP]
+.
+.SH BEFEHLSALIASE
+\fBunxz\fP ist gleichbedeutend mit \fBxz \-\-decompress\fP.
+.br
+\fBxzcat\fP ist gleichbedeutend mit \fBxz \-\-decompress \-\-stdout\fP.
+.br
+\fBlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma\fP.
+.br
+\fBunlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress\fP.
+.br
+\fBlzcat\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP.
+.PP
+Wenn Sie Skripte schreiben, die Dateien dekomprimieren, sollten Sie stets
+den Namen \fBxz\fP mit den entsprechenden Argumenten (\fBxz \-d\fP oder \fBxz \-dc\fP)
+anstelle der Namen \fBunxz\fP und \fBxzcat\fP verwenden.
+.
+.SH BESCHREIBUNG
+\fBxz\fP ist ein Allzweckwerkzeug zur Datenkompression, dessen
+Befehlszeilensyntax denen von \fBgzip\fP(1) und \fBbzip2\fP(1) ähnelt. Das native
+Dateiformat ist das \fB.xz\fP\-Format, aber das veraltete, von den
+LZMA\-Dienstprogrammen verwendete Format sowie komprimierte Rohdatenströme
+ohne Containerformat\-Header werden ebenfalls unterstützt. Außerdem wird die
+Dekompression des von \fBlzip\fP verwendeten \fB.lz\fP\-Formats unterstützt.
+.PP
+\fBxz\fP komprimiert oder dekomprimiert jede \fIDatei\fP entsprechend des
+gewählten Vorgangsmodus. Falls entweder \fB\-\fP oder keine Datei angegeben ist,
+liest \fBxz\fP aus der Standardeingabe und leitet die verarbeiteten Dateien in
+die Standardausgabe. Wenn die Standardausgabe kein Terminal ist, verweigert
+\fBxz\fP das Schreiben komprimierter Daten in die Standardausgabe. Dabei wird
+eine Fehlermeldung angezeigt und die \fIDatei\fP übersprungen. Ebenso
+verweigert \fBxz\fP das Lesen komprimierter Daten aus der Standardeingabe, wenn
+diese ein Terminal ist.
+.PP
+\fIDateien\fP, die nicht als \fB\-\fP angegeben sind, werden in eine neue Datei
+geschrieben, deren Name aus dem Namen der Quell\-\fIDatei\fP abgeleitet wird
+(außer wenn \fB\-\-stdout\fP angegeben ist):
+.IP \(bu 3
+Bei der Kompression wird das Suffix des Formats der Zieldatei (\fB.xz\fP oder
+\&\fB.lzma\fP) an den Namen der Quelldatei angehängt und so der Name der
+Zieldatei gebildet.
+.IP \(bu 3
+Bei der Dekompression wird das Suffix \fB.xz\fP, \fB.lzma\fP oder \fB.lz\fP vom
+Dateinamen entfernt und so der Name der Zieldatei gebildet. Außerdem erkennt
+\fBxz\fP die Suffixe \fB.txz\fP und \fB.tlz\fP und ersetzt diese durch \fB.tar\fP.
+.PP
+Wenn die Zieldatei bereits existiert, wird eine Fehlermeldung angezeigt und
+die \fIDatei\fP übersprungen.
+.PP
+Außer beim Schreiben in die Standardausgabe zeigt \fBxz\fP eine Warnung an und
+überspringt die \fIDatei\fP, wenn eine der folgenden Bedingungen zutreffend
+ist:
+.IP \(bu 3
+Die \fIDatei\fP ist keine reguläre Datei. Symbolischen Verknüpfungen wird nicht
+gefolgt und diese daher nicht zu den regulären Dateien gezählt.
+.IP \(bu 3
+Die \fIDatei\fP hat mehr als eine harte Verknüpfung.
+.IP \(bu 3
+Für die \fIDatei\fP ist das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt.
+.IP \(bu 3
+Der Aktionsmodus wird auf Kompression gesetzt und die \fIDatei\fP hat bereits
+das Suffix des Zieldateiformats (\fB.xz\fP oder \fB.txz\fP beim Komprimieren in
+das \fB.xz\fP\-Format und \fB.lzma\fP oder \fB.tlz\fP beim Komprimieren in das
+\&\fB.lzma\fP\-Format).
+.IP \(bu 3
+Der Aktionsmodus wird auf Dekompression gesetzt und die \fIDatei\fP hat nicht
+das Suffix eines der unterstützten Zieldateiformate (\fB.xz\fP, \fB.txz\fP,
+\&\fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP).
+.PP
+Nach erfolgreicher Kompression oder Dekompression der \fIDatei\fP kopiert \fBxz\fP
+Eigentümer, Gruppe, Zugriffsrechte, Zugriffszeit und Änderungszeit aus der
+Ursprungs\-\fIDatei\fP in die Zieldatei. Sollte das Kopieren der Gruppe
+fehlschlagen, werden die Zugriffsrechte so angepasst, dass jenen Benutzern
+der Zugriff auf die Zieldatei verwehrt bleibt, die auch keinen Zugriff auf
+die Ursprungs\-\fIDatei\fP hatten. Das Kopieren anderer Metadaten wie
+Zugriffssteuerlisten oder erweiterter Attribute wird von \fBxz\fP noch nicht
+unterstützt.
+.PP
+Sobald die Zieldatei erfolgreich geschlossen wurde, wird die
+Ursprungs\-\fIDatei\fP entfernt. Dies wird durch die Option \fB\-\-keep\fP
+verhindert. Die Ursprungs\-\fIDatei\fP wird niemals entfernt, wenn die Ausgabe
+in die Standardausgabe geschrieben wird oder falls ein Fehler auftritt.
+.PP
+Durch Senden der Signale \fBSIGINFO\fP oder \fBSIGUSR1\fP an den \fBxz\fP\-Prozess
+werden Fortschrittsinformationen in den Fehlerkanal der Standardausgabe
+geleitet. Dies ist nur eingeschränkt hilfreich, wenn die
+Standardfehlerausgabe ein Terminal ist. Mittels \fB\-\-verbose\fP wird ein
+automatisch aktualisierter Fortschrittsanzeiger angezeigt.
+.
+.SS Speicherbedarf
+In Abhängigkeit von den gewählten Kompressionseinstellungen bewegt sich der
+Speicherverbrauch zwischen wenigen hundert Kilobyte und mehreren
+Gigabyte. Die Einstellungen bei der Kompression einer Datei bestimmen dabei
+den Speicherbedarf bei der Dekompression. Die Dekompression benötigt
+üblicherweise zwischen 5\ % und 20\ % des Speichers, der bei der Kompression
+der Datei erforderlich war. Beispielsweise benötigt die Dekompression einer
+Datei, die mit \fBxz \-9\fP komprimiert wurde, gegenwärtig etwa 65\ MiB
+Speicher. Es ist jedoch auch möglich, dass \fB.xz\fP\-Dateien mehrere Gigabyte
+an Speicher zur Dekompression erfordern.
+.PP
+Insbesondere für Benutzer älterer Systeme wird eventuell ein sehr großer
+Speicherbedarf ärgerlich sein. Um unangenehme Überraschungen zu vermeiden,
+verfügt \fBxz\fP über eine eingebaute Begrenzung des Speicherbedarfs, die
+allerdings in der Voreinstellung deaktiviert ist. Zwar verfügen einige
+Betriebssysteme über eingebaute Möglichkeiten zur prozessabhängigen
+Speicherbegrenzung, doch diese sind zu unflexibel (zum Beispiel kann
+\fBulimit\fP(1) beim Begrenzen des virtuellen Speichers \fBmmap\fP(2)
+beeinträchtigen).
+.PP
+Die Begrenzung des Speicherbedarfs kann mit der Befehlszeilenoption
+\fB\-\-memlimit=\fP\fIBegrenzung\fP aktiviert werden. Oft ist es jedoch bequemer,
+die Begrenzung durch Setzen der Umgebungsvariable \fBXZ_DEFAULTS\fP
+standardmäßig zu aktivieren, zum Beispiel
+\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Die Begrenzungen können getrennt für
+Kompression und Dekompression mittels \fB\-\-memlimit\-compress=\fP\fIBegrenzung\fP
+und \fB\-\-memlimit\-decompress=\fP\fIBegrenzung\fP festgelegt werden. Die Verwendung
+einer solchen Option außerhalb der Variable \fBXZ_DEFAULTS\fP ist kaum
+sinnvoll, da \fBxz\fP in einer einzelnen Aktion nicht gleichzeitig Kompression
+und Dekompression ausführen kann und \fB\-\-memlimit=\fP\fIBegrenzung\fP (oder \fB\-M\fP
+\fIBegrenzung\fP) lässt sich einfacher in der Befehlszeile eingeben.
+.PP
+Wenn die angegebene Speicherbegrenzung bei der Dekompression überschritten
+wird, schlägt der Vorgang fehl und \fBxz\fP zeigt eine Fehlermeldung an. Wird
+die Begrenzung bei der Kompression überschritten, dann versucht \fBxz\fP die
+Einstellungen entsprechend anzupassen, außer wenn \fB\-\-format=raw\fP oder
+\fB\-\-no\-adjust\fP angegeben ist. Auf diese Weise schlägt die Aktion nicht fehl,
+es sei denn, die Begrenzung wurde sehr niedrig angesetzt. Die Anpassung der
+Einstellungen wird schrittweise vorgenommen, allerdings entsprechen die
+Schritte nicht den Voreinstellungen der Kompressionsstufen. Das bedeutet,
+wenn beispielsweise die Begrenzung nur geringfügig unter den Anforderungen
+für \fBxz \-9\fP liegt, werden auch die Einstellungen nur wenig angepasst und
+nicht vollständig herunter zu den Werten für \fBxz \-8\fP
+.
+.SS "Verkettung und Auffüllung von .xz\-Dateien"
+Es ist möglich, \fB.xz\fP\-Dateien direkt zu verketten. Solche Dateien werden
+von \fBxz\fP genauso dekomprimiert wie eine einzelne \fB.xz\fP\-Datei.
+.PP
+Es ist weiterhin möglich, eine Auffüllung zwischen den verketteten Teilen
+oder nach dem letzten Teil einzufügen. Die Auffüllung muss aus Null\-Bytes
+bestehen und deren Größe muss ein Vielfaches von vier Byte sein. Dies kann
+zum Beispiel dann vorteilhaft sein, wenn die \fB.xz\fP\-Datei auf einem
+Datenträger gespeichert wird, dessen Dateisystem die Dateigrößen in
+512\-Byte\-Blöcken speichert.
+.PP
+Verkettung und Auffüllung sind für \fB.lzma\fP\-Dateien oder Rohdatenströme
+nicht erlaubt.
+.
+.SH OPTIONEN
+.
+.SS "Ganzzahlige Suffixe und spezielle Werte"
+An den meisten Stellen, wo ein ganzzahliges Argument akzeptiert wird, kann
+ein optionales Suffix große Ganzzahlwerte einfacher darstellen. Zwischen
+Ganzzahl und dem Suffix dürfen sich keine Leerzeichen befinden.
+.TP 
+\fBKiB\fP
+multipliziert die Ganzzahl mit 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP und
+\fBKB\fP werden als Synonyme für \fBKiB\fP akzeptiert.
+.TP 
+\fBMiB\fP
+multipliziert die Ganzzahl mit 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP und \fBMB\fP
+werden als Synonyme für \fBMiB\fP akzeptiert.
+.TP 
+\fBGiB\fP
+multipliziert die Ganzzahl mit 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP und
+\fBGB\fP werden als Synonyme für \fBGiB\fP akzeptiert.
+.PP
+Der spezielle Wert \fBmax\fP kann dazu verwendet werden, um den von der
+jeweiligen Option akzeptierten maximalen Ganzzahlwert anzugeben.
+.
+.SS Aktionsmodus
+Falls mehrere Aktionsmodi angegeben sind, wird der zuletzt angegebene
+verwendet.
+.TP 
+\fB\-z\fP, \fB\-\-compress\fP
+Kompression. Dies ist der voreingestellte Aktionsmodus, sofern keiner
+angegeben ist und auch kein bestimmter Modus aus dem Befehlsnamen abgeleitet
+werden kann (der Befehl \fBunxz\fP impliziert zum Beispiel \fB\-\-decompress\fP).
+.IP ""
+.\" The DESCRIPTION section already says this but it's good to repeat it
+.\" here because the default behavior is a bit dangerous and new users
+.\" in a hurry may skip reading the DESCRIPTION section.
+After successful compression, the source file is removed unless writing to
+standard output or \fB\-\-keep\fP was specified.
+.TP 
+\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP
+.\" The DESCRIPTION section already says this but it's good to repeat it
+.\" here because the default behavior is a bit dangerous and new users
+.\" in a hurry may skip reading the DESCRIPTION section.
+Decompress.  After successful decompression, the source file is removed
+unless writing to standard output or \fB\-\-keep\fP was specified.
+.TP 
+\fB\-t\fP, \fB\-\-test\fP
+prüft die Integrität der komprimierten \fIDateien\fP. Diese Option ist
+gleichbedeutend mit \fB\-\-decompress \-\-stdout\fP, außer dass die dekomprimierten
+Daten verworfen werden, anstatt sie in die Standardausgabe zu leiten. Es
+werden keine Dateien erstellt oder entfernt.
+.TP 
+\fB\-l\fP, \fB\-\-list\fP
+gibt Informationen zu den komprimierten \fIDateien\fP aus. Es werden keine
+unkomprimierten Dateien ausgegeben und keine Dateien angelegt oder
+entfernt. Im Listenmodus kann das Programm keine komprimierten Daten aus der
+Standardeingabe oder anderen nicht durchsuchbaren Quellen lesen.
+.IP ""
+Die Liste zeigt in der Standardeinstellung grundlegende Informationen zu den
+\fIDateien\fP an, zeilenweise pro Datei. Detailliertere Informationen erhalten
+Sie mit der Option \fB\-\-verbose\fP. Wenn Sie diese Option zweimal angeben,
+werden noch ausführlichere Informationen ausgegeben. Das kann den Vorgang
+allerdings deutlich verlangsamen, da die Ermittlung der zusätzlichen
+Informationen zahlreiche Suchvorgänge erfordert. Die Breite der
+ausführlichen Ausgabe übersteigt 80 Zeichen, daher könnte die Weiterleitung
+in beispielsweise\& \fBless\ \-S\fP sinnvoll sein, falls das Terminal nicht
+breit genug ist.
+.IP ""
+Die exakte Ausgabe kann in verschiedenen \fBxz\fP\-Versionen und
+Spracheinstellungen unterschiedlich sein. Wenn eine maschinell auswertbare
+Ausgabe gewünscht ist, dann sollten Sie \fB\-\-robot \-\-list\fP verwenden.
+.
+.SS Aktionsattribute
+.TP 
+\fB\-k\fP, \fB\-\-keep\fP
+verhindert das Löschen der Eingabedateien.
+.IP ""
+Seit der \fBxz\fP\-Version 5.2.6 wird die Kompression oder Dekompression auch
+dann ausgeführt, wenn die Eingabe ein symbolischer Link zu einer regulären
+Datei ist, mehr als einen harten Link hat oder das »setuid«\-, »setgid«\- oder
+»sticky«\-Bit gesetzt ist. Die genannten Bits werden nicht in die Zieldatei
+kopiert. In früheren Versionen geschah dies nur mit \fB\-\-force\fP.
+.TP 
+\fB\-f\fP, \fB\-\-force\fP
+Diese Option hat verschiedene Auswirkungen:
+.RS
+.IP \(bu 3
+Wenn die Zieldatei bereits existiert, wird diese vor der Kompression oder
+Dekompression gelöscht.
+.IP \(bu 3
+Die Kompression oder Dekompression wird auch dann ausgeführt, wenn die
+Eingabe ein symbolischer Link zu einer regulären Datei ist, mehr als einen
+harten Link hat oder das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt
+ist. Die genannten Bits werden nicht in die Zieldatei kopiert.
+.IP \(bu 3
+Wenn es zusammen mit \fB\-\-decompress\fP und \fB\-\-stdout\fP verwendet wird und
+\fBxz\fP den Typ der Quelldatei nicht ermitteln kann, wird die Quelldatei
+unverändert in die Standardausgabe kopiert. Dadurch kann \fBxzcat\fP \fB\-\-force\fP
+für Dateien, die nicht mit \fBxz\fP komprimiert wurden, wie \fBcat\fP(1) verwendet
+werden. Zukünftig könnte \fBxz\fP neue Dateikompressionsformate unterstützen,
+wodurch \fBxz\fP mehr Dateitypen dekomprimieren kann, anstatt sie unverändert
+in die Standardausgabe zu kopieren. Mit der Option \fB\-\-format=\fP\fIFormat\fP
+können Sie \fBxz\fP anweisen, nur ein einzelnes Dateiformat zu dekomprimieren.
+.RE
+.TP 
+\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP
+schreibt die komprimierten oder dekomprimierten Daten in die Standardausgabe
+anstatt in eine Datei. Dies impliziert \fB\-\-keep\fP.
+.TP 
+\fB\-\-single\-stream\fP
+dekomprimiert nur den ersten \fB.xz\fP\-Datenstrom und ignoriert stillschweigend
+weitere Eingabedaten, die möglicherweise dem Datenstrom
+folgen. Normalerweise führt solcher anhängender Datenmüll dazu, dass \fBxz\fP
+eine Fehlermeldung ausgibt.
+.IP ""
+\fBxz\fP dekomprimiert niemals mehr als einen Datenstrom aus \fB.lzma\fP\-Dateien
+oder Rohdatenströmen, aber dennoch wird durch diese Option möglicherweise
+vorhandener Datenmüll nach der \fB.lzma\fP\-Datei oder dem Rohdatenstrom
+ignoriert.
+.IP ""
+Diese Option ist wirkungslos, wenn der Aktionsmodus nicht \fB\-\-decompress\fP
+oder \fB\-\-test\fP ist.
+.TP 
+\fB\-\-no\-sparse\fP
+verhindert die Erzeugung von Sparse\-Dateien. In der Voreinstellung versucht
+\fBxz\fP, bei der Dekompression in eine reguläre Datei eine Sparse\-Datei zu
+erzeugen, wenn die dekomprimierten Daten lange Abfolgen von binären Nullen
+enthalten. Dies funktioniert auch beim Schreiben in die Standardausgabe,
+sofern diese in eine reguläre Datei weitergeleitet wird und bestimmte
+Zusatzbedingungen erfüllt sind, die die Aktion absichern. Die Erzeugung von
+Sparse\-Dateien kann Plattenplatz sparen und beschleunigt die Dekompression
+durch Verringerung der Ein\-/Ausgaben der Platte.
+.TP 
+\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP
+verwendet \fI.suf\fP bei der Dekompression anstelle von \fB.xz\fP oder \fB.lzma\fP
+als Suffix für die Zieldatei. Falls nicht in die Standardausgabe geschrieben
+wird und die Quelldatei bereits das Suffix \fI.suf\fP hat, wird eine Warnung
+angezeigt und die Datei übersprungen.
+.IP ""
+berücksichtigt bei der Dekompression zusätzlich zu Dateien mit den Suffixen
+\&\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP auch jene mit dem Suffix
+\&\fI.suf\fP. Falls die Quelldatei das Suffix \fI.suf\fP hat, wird dieses entfernt
+und so der Name der Zieldatei abgeleitet.
+.IP ""
+Beim Komprimieren oder Dekomprimieren von Rohdatenströmen mit
+\fB\-\-format=raw\fP muss das Suffix stets angegeben werden, außer wenn die
+Ausgabe in die Standardausgabe erfolgt. Der Grund dafür ist, dass es kein
+vorgegebenes Suffix für Rohdatenströme gibt.
+.TP 
+\fB\-\-files\fP[\fB=\fP\fIDatei\fP]
+liest die zu verarbeitenden Dateinamen aus \fIDatei\fP. Falls keine \fIDatei\fP
+angegeben ist, werden die Dateinamen aus der Standardeingabe
+gelesen. Dateinamen müssen mit einem Zeilenumbruch beendet werden. Ein
+Bindestrich (\fB\-\fP) wird als regulärer Dateiname angesehen und nicht als
+Standardeingabe interpretiert. Falls Dateinamen außerdem als
+Befehlszeilenargumente angegeben sind, werden diese vor den Dateinamen aus
+der \fIDatei\fP verarbeitet.
+.TP 
+\fB\-\-files0\fP[\fB=\fP\fIDatei\fP]
+Dies ist gleichbedeutend mit \fB\-\-files\fP[\fB=\fP\fIDatei\fP], außer dass jeder
+Dateiname mit einem Null\-Zeichen abgeschlossen werden muss.
+.
+.SS "Grundlegende Dateiformat\- und Kompressionsoptionen"
+.TP 
+\fB\-F\fP \fIFormat\fP, \fB\-\-format=\fP\fIFormat\fP
+gibt das \fIFormat\fP der zu komprimierenden oder dekomprimierenden Datei an:
+.RS
+.TP 
+\fBauto\fP
+Dies ist die Voreinstellung. Bei der Kompression ist \fBauto\fP gleichbedeutend
+mit \fBxz\fP. Bei der Dekompression wird das Format der Eingabedatei
+automatisch erkannt. Beachten Sie, dass Rohdatenströme, wie sie mit
+\fB\-\-format=raw\fP erzeugt werden, nicht automatisch erkannt werden können.
+.TP 
+\fBxz\fP
+Die Kompression erfolgt in das \fB.xz\fP\-Dateiformat oder akzeptiert nur
+\&\fB.xz\fP\-Dateien bei der Dekompression.
+.TP 
+\fBlzma\fP, \fBalone\fP
+Die Kompression erfolgt in das veraltete \fB.lzma\fP\-Dateiformat oder
+akzeptiert nur \fB.lzma\fP\-Dateien bei der Dekompression. Der alternative Name
+\fBalone\fP dient der Abwärtskompatibilität zu den LZMA\-Dienstprogrammen.
+.TP 
+\fBlzip\fP
+Akzeptiert nur \fB.lz\fP\-Dateien bei der Dekompression. Kompression wird nicht
+unterstützt.
+.IP ""
+Das \fB.lz\fP\-Format wird in Version 0 und der unerweiterten Version 1
+unterstützt. Dateien der Version 0 wurden von \fBlzip\fP 1.3 und älter
+erstellt. Solche Dateien sind nicht sehr weit verbreitet, können aber in
+Dateiarchiven gefunden werden, da einige Quellpakete in diesem Format
+veröffentlicht wurden. Es ist auch möglich, dass Benutzer alte persönliche
+Dateien in diesem Format haben. Die Dekompressionsunterstützung für das
+Format der Version 0 wurde mit der Version 1.18 aus \fBlzip\fP entfernt.
+.IP ""
+\fBlzip\fP\-Versionen ab 1.4 erstellen Dateien im Format der Version 0. Die
+Erweiterung »Sync Flush Marker« zur Formatversion 1 wurde in \fBlzip\fP 1.6
+hinzugefügt. Diese Erweiterung wird sehr selten verwendet und wird von \fBxz\fP
+nicht unterstützt (die Eingabe wird als beschädigt erkannt).
+.TP 
+\fBraw\fP
+Komprimiert oder dekomprimiert einen Rohdatenstrom (ohne Header). Diese
+Option ist nur für fortgeschrittene Benutzer bestimmt. Zum Dekodieren von
+Rohdatenströmen müssen Sie die Option \fB\-\-format=raw\fP verwenden und die
+Filterkette ausdrücklich angeben, die normalerweise in den (hier fehlenden)
+Container\-Headern gespeichert worden wäre.
+.RE
+.TP 
+\fB\-C\fP \fIPrüfung\fP, \fB\-\-check=\fP\fIPrüfung\fP
+gibt den Typ der Integritätsprüfung an. Die Prüfsumme wird aus den
+unkomprimierten Daten berechnet und in der \fB.xz\fP\-Datei gespeichert. Diese
+Option wird nur bei der Kompression in das \fB.xz\fP\-Format angewendet, da das
+\&\fB.lzma\fP\-Format keine Integritätsprüfungen unterstützt. Die eigentliche
+Integritätsprüfung erfolgt (falls möglich), wenn die \fB.xz\fP\-Datei
+dekomprimiert wird.
+.IP ""
+Folgende Typen von \fIPrüfungen\fP werden unterstützt:
+.RS
+.TP 
+\fBnone\fP
+führt keine Integritätsprüfung aus. Dies ist eine eher schlechte
+Idee. Dennoch kann es nützlich sein, wenn die Integrität der Daten auf
+andere Weise sichergestellt werden kann.
+.TP 
+\fBcrc32\fP
+berechnet die CRC32\-Prüfsumme anhand des Polynoms aus IEEE\-802.3 (Ethernet).
+.TP 
+\fBcrc64\fP
+berechnet die CRC64\-Prüfsumme anhand des Polynoms aus ECMA\-182. Dies ist die
+Voreinstellung, da beschädigte Dateien etwas besser als mit CRC32 erkannt
+werden und die Geschwindigkeitsdifferenz unerheblich ist.
+.TP 
+\fBsha256\fP
+berechnet die SHA\-256\-Prüfsumme. Dies ist etwas langsamer als CRC32 und
+CRC64.
+.RE
+.IP ""
+Die Integrität der \fB.xz\fP\-Header wird immer mit CRC32 geprüft. Es ist nicht
+möglich, dies zu ändern oder zu deaktivieren.
+.TP 
+\fB\-\-ignore\-check\fP
+verifiziert die Integritätsprüfsumme der komprimierten Daten bei der
+Dekompression nicht. Die CRC32\-Werte in den \fB.xz\fP\-Headern werden weiterhin
+normal verifiziert.
+.IP ""
+\fBVerwenden Sie diese Option nicht, außer Sie wissen, was Sie tun.\fP Mögliche
+Gründe, diese Option zu verwenden:
+.RS
+.IP \(bu 3
+Versuchen, Daten aus einer beschädigten .xz\-Datei wiederherzustellen.
+.IP \(bu 3
+Erhöhung der Geschwindigkeit bei der Dekompression. Dies macht sich meist
+mit SHA\-256 bemerkbar, oder mit Dateien, die extrem stark komprimiert
+sind. Wir empfehlen, diese Option nicht für diesen Zweck zu verwenden, es
+sei denn, die Integrität der Datei wird extern auf andere Weise überprüft.
+.RE
+.TP 
+\fB\-0\fP … \fB\-9\fP
+wählt eine der voreingestellten Kompressionsstufen, standardmäßig
+\fB\-6\fP. Wenn mehrere Voreinstellungsstufen angegeben sind, ist nur die
+zuletzt angegebene wirksam. Falls bereits eine benutzerdefinierte
+Filterkette angegeben wurde, wird diese durch die Festlegung der
+Voreinstellung geleert.
+.IP ""
+Die Unterschiede zwischen den Voreinstellungsstufen sind deutlicher als bei
+\fBgzip\fP(1) und \fBbzip2\fP(1). Die gewählten Kompressionseinstellungen
+bestimmen den Speicherbedarf bei der Dekompression, daher ist es auf älteren
+Systemen mit wenig Speicher bei einer zu hoch gewählten Voreinstellung
+schwer, eine Datei zu dekomprimieren. Insbesondere \fBist es keine gute Idee, blindlings \-9 für alles\fP zu verwenden, wie dies häufig mit \fBgzip\fP(1) und
+\fBbzip2\fP(1) gehandhabt wird.
+.RS
+.TP 
+\fB\-0\fP … \fB\-3\fP
+Diese Voreinstellungen sind recht schnell. \fB\-0\fP ist manchmal schneller als
+\fBgzip \-9\fP, wobei aber die Kompression wesentlich besser ist. Die
+schnelleren Voreinstellungen sind im Hinblick auf die Geschwindigkeit mit
+\fBbzip2\fP(1) vergleichbar , mit einem ähnlichen oder besseren
+Kompressionsverhältnis, wobei das Ergebnis aber stark vom Typ der zu
+komprimierenden Daten abhängig ist.
+.TP 
+\fB\-4\fP … \fB\-6\fP
+Gute bis sehr gute Kompression, wobei der Speicherbedarf für die
+Dekompression selbst auf alten Systemen akzeptabel ist. \fB\-6\fP ist die
+Voreinstellung, welche üblicherweise eine gute Wahl für die Verteilung von
+Dateien ist, die selbst noch auf Systemen mit nur 16\ MiB Arbeitsspeicher
+dekomprimiert werden müssen (\fB\-5e\fP oder \fB\-6e\fP sind ebenfalls eine
+Überlegung wert. Siehe \fB\-\-extreme\fP).
+.TP 
+\fB\-7 … \-9\fP
+Ähnlich wie \fB\-6\fP, aber mit einem höheren Speicherbedarf für die Kompression
+und Dekompression. Sie sind nur nützlich, wenn Dateien komprimiert werden
+sollen, die größer als 8\ MiB, 16\ MiB beziehungsweise 32\ MiB sind.
+.RE
+.IP ""
+Auf der gleichen Hardware ist die Dekompressionsgeschwindigkeit ein nahezu
+konstanter Wert in Bytes komprimierter Daten pro Sekunde. Anders
+ausgedrückt: Je besser die Kompression, umso schneller wird üblicherweise
+die Dekompression sein. Das bedeutet auch, dass die Menge der pro Sekunde
+ausgegebenen unkomprimierten Daten stark variieren kann.
+.IP ""
+Die folgende Tabelle fasst die Eigenschaften der Voreinstellungen zusammen:
+.RS
+.RS
+.PP
+.TS
+tab(;);
+c c c c c
+n n n n n.
+Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich
+\-0;256 KiB;0;3 MiB;1 MiB
+\-1;1 MiB;1;9 MiB;2 MiB
+\-2;2 MiB;2;17 MiB;3 MiB
+\-3;4 MiB;3;32 MiB;5 MiB
+\-4;4 MiB;4;48 MiB;5 MiB
+\-5;8 MiB;5;94 MiB;9 MiB
+\-6;8 MiB;6;94 MiB;9 MiB
+\-7;16 MiB;6;186 MiB;17 MiB
+\-8;32 MiB;6;370 MiB;33 MiB
+\-9;64 MiB;6;674 MiB;65 MiB
+.TE
+.RE
+.RE
+.IP ""
+Spaltenbeschreibungen:
+.RS
+.IP \(bu 3
+Wörtb.Größe ist die Größe des LZMA2\-Wörterbuchs. Es ist
+Speicherverschwendung, ein Wörterbuch zu verwenden, das größer als die
+unkomprimierte Datei ist. Daher ist es besser, die Voreinstellungen \fB\-7\fP …
+\fB\-9\fP zu vermeiden, falls es keinen wirklichen Bedarf dafür gibt. Mit \fB\-6\fP
+und weniger wird üblicherweise so wenig Speicher verschwendet, dass dies
+nicht ins Gewicht fällt.
+.IP \(bu 3
+KomprCPU ist eine vereinfachte Repräsentation der LZMA2\-Einstellungen,
+welche die Kompressionsgeschwindigkeit beeinflussen. Die Wörterbuchgröße
+wirkt sich ebenfalls auf die Geschwindigkeit aus. Während KompCPU für die
+Stufen \fB\-6\fP bis \fB\-9\fP gleich ist, tendieren höhere Stufen dazu, etwas
+langsamer zu sein. Um eine noch langsamere, aber möglicherweise bessere
+Kompression zu erhalten, siehe \fB\-\-extreme\fP.
+.IP \(bu 3
+KompSpeich enthält den Speicherbedarf des Kompressors im
+Einzel\-Thread\-Modus. Dieser kann zwischen den \fBxz\fP\-Versionen leicht
+variieren.
+.IP \(bu 3
+DekompSpeich enthält den Speicherbedarf für die Dekompression. Das bedeutet,
+dass die Kompressionseinstellungen den Speicherbedarf bei der Dekompression
+bestimmen. Der exakte Speicherbedarf bei der Dekompression ist geringfügig
+größer als die Größe des LZMA2\-Wörterbuchs, aber die Werte in der Tabelle
+wurden auf ganze MiB aufgerundet.
+.RE
+.IP ""
+ Der Speicherbedarf einiger der zukünftigen Multithread\-Modi kann dramatisch
+höher sein als im Einzel\-Thread\-Modus. Mit dem Standardwert von
+\fB\-\-block\-size\fP benötigt jeder Thread 3*3*Wörtb.Gr plus KompSpeich oder
+DekompSpeich. Beispielsweise benötigen vier Threads mit der Voreinstellung
+\fB\-6\fP etwa 660 bis 670 MiB Speicher.
+.TP 
+\fB\-e\fP, \fB\-\-extreme\fP
+verwendet eine langsamere Variante der gewählten
+Kompressions\-Voreinstellungsstufe (\fB\-0\fP … \fB\-9\fP), um hoffentlich ein etwas
+besseres Kompressionsverhältnis zu erreichen, das aber in ungünstigen Fällen
+auch schlechter werden kann. Der Speicherverbrauch bei der Dekompression
+wird dabei nicht beeinflusst, aber der Speicherverbrauch der Kompression
+steigt in den Voreinstellungsstufen \fB\-0\fP bis \fB\-3\fP geringfügig an.
+.IP ""
+Da es zwei Voreinstellungen mit den Wörterbuchgrößen 4\ MiB und 8\ MiB gibt,
+verwenden die Voreinstellungsstufen \fB\-3e\fP und \fB\-5e\fP etwas schnellere
+Einstellungen (niedrigere KompCPU) als \fB\-4e\fP beziehungsweise \fB\-6e\fP. Auf
+diese Weise sind zwei Voreinstellungen nie identisch.
+.RS
+.RS
+.PP
+.TS
+tab(;);
+c c c c c
+n n n n n.
+Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich
+\-0e;256 KiB;8;4 MiB;1 MiB
+\-1e;1 MiB;8;13 MiB;2 MiB
+\-2e;2 MiB;8;25 MiB;3 MiB
+\-3e;4 MiB;7;48 MiB;5 MiB
+\-4e;4 MiB;8;48 MiB;5 MiB
+\-5e;8 MiB;7;94 MiB;9 MiB
+\-6e;8 MiB;8;94 MiB;9 MiB
+\-7e;16 MiB;8;186 MiB;17 MiB
+\-8e;32 MiB;8;370 MiB;33 MiB
+\-9e;64 MiB;8;674 MiB;65 MiB
+.TE
+.RE
+.RE
+.IP ""
+Zum Beispiel gibt es insgesamt vier Voreinstellungen, die ein 8\ MiB großes
+Wörterbuch verwenden, deren Reihenfolge von der schnellsten zur langsamsten
+\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP und \fB\-6e\fP ist.
+.TP 
+\fB\-\-fast\fP
+.PD 0
+.TP 
+\fB\-\-best\fP
+.PD
+sind etwas irreführende Aliase für \fB\-0\fP beziehungsweise \fB\-9\fP. Sie werden
+nur zwecks Abwärtskompatibilität zu den LZMA\-Dienstprogrammen
+bereitgestellt. Sie sollten diese Optionen besser nicht verwenden.
+.TP 
+\fB\-\-block\-size=\fP\fIGröße\fP
+teilt beim Komprimieren in das \fB.xz\fP\-Format die Eingabedaten in Blöcke der
+angegebenen \fIGröße\fP in Byte. Die Blöcke werden unabhängig voneinander
+komprimiert, was dem Multi\-Threading entgegen kommt und Zufallszugriffe bei
+der Dekompression begrenzt. Diese Option wird typischerweise eingesetzt, um
+die vorgegebene Blockgröße im Multi\-Thread\-Modus außer Kraft zu setzen, aber
+sie kann auch im Einzel\-Thread\-Modus angewendet werden.
+.IP ""
+Im Multi\-Thread\-Modus wird etwa die dreifache \fIGröße\fP in jedem Thread zur
+Pufferung der Ein\- und Ausgabe belegt. Die vorgegebene \fIGröße\fP ist das
+Dreifache der Größe des LZMA2\-Wörterbuchs oder 1 MiB, je nachdem, was mehr
+ist. Typischerweise ist das Zwei\- bis Vierfache der Größe des
+LZMA2\-Wörterbuchs oder wenigstens 1 MB ein guter Wert. Eine \fIGröße\fP, die
+geringer ist als die des LZMA2\-Wörterbuchs, ist Speicherverschwendung, weil
+dann der LZMA2\-Wörterbuchpuffer niemals vollständig genutzt werden würde. Im
+Multi\-Thread\-Modus wird die Größe der Blöcke wird in den Block\-Headern
+gespeichert. Die Größeninformation wird für eine Multi\-Thread\-Dekompression
+genutzt.
+.IP ""
+Im Einzel\-Thread\-Modus werden die Blöcke standardmäßig nicht geteilt. Das
+Setzen dieser Option wirkt sich nicht auf den Speicherbedarf aus. In den
+Block\-Headern werden keine Größeninformationen gespeichert, daher werden im
+Einzel\-Thread\-Modus erzeugte Dateien nicht zu den im Multi\-Thread\-Modus
+erzeugten Dateien identisch sein. Das Fehlen der Größeninformation bedingt
+auch, dass \fBxz\fP nicht in der Lage sein wird, die Dateien im
+Multi\-Thread\-Modus zu dekomprimieren.
+.TP 
+\fB\-\-block\-list=\fP\fIBlöcke\fP
+beginnt bei der Kompression in das \fB.xz\fP\-Format nach den angegebenen
+Intervallen unkomprimierter Daten einen neuen Block, optional mit einer
+benutzerdefinierten Filterkette.
+.IP ""
+Die \fIBlöcke\fP werden in einer durch Kommata getrennten Liste
+angegeben. Jeder Block besteht aus einer optionalen Filterkettennummer
+zwischen 0 und 9, gefolgt von einem Doppelpunkt (\fB:\fP) und der Größe der
+unkomprimierten Daten (diese Angabe ist erforderlich). Überspringen eines
+Blocks (zwei oder mehr aufeinander folgende Kommata) ist ein Kürzel dafür,
+die Größe und die Filter des vorherigen Blocks zu verwenden.
+.IP ""
+Falls die Eingabedatei größer ist als die Summe der \fIBlöcke\fP, dann wird der
+letzte in \fIVBlöcke\fP angegebene Wert bis zum Ende der Datei wiederholt. Mit
+dem speziellen Wert \fB0\fP können Sie angeben, dass der Rest der Datei als
+einzelner Block kodiert werden soll.
+.IP ""
+Eine alternative Filterkette für jeden Block kann in Kombination mit den
+Optionen \fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP angegeben
+werden. Diese Optionen definieren Filterketten mit einem Bezeichner zwischen
+1 und 9. Die Filterkette 0 bezeichnet hierbei die voreingestellte
+Filterkette, was dem Nichtangeben einer Filterkette gleichkommt. Der
+Filterkettenbezeichner kann vor der unkomprimierten Größe verwendet werden,
+gefolgt von einem Doppelpunkt (\fB:\fP). Falls Sie beispielsweise
+\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP angeben, werden die Blöcke
+folgendermaßen erstellt:
+.RS
+.IP \(bu 3
+Die durch \fB\-\-filters1\fP angegebene Filterkette und 2 MiB Eingabe
+.IP \(bu 3
+Die durch \fB\-\-filters3\fP angegebene Filterkette und 2 MiB Eingabe
+.IP \(bu 3
+Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe
+.IP \(bu 3
+Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe
+.IP \(bu 3
+Die vorgegebene Filterkette und 2 MiB Eingabe
+.IP \(bu 3
+Die vorgegebene Filterkette und 4 MiB Eingabe für jeden Block bis zum Ende
+der Eingabe.
+.RE
+.IP ""
+Falls Sie eine Größe angeben, welche die Blockgröße des Encoders übersteigen
+(entweder den Vorgabewert im Thread\-Modus oder den mit
+\fB\-\-block\-size=\fP\fIGröße\fP angegebenen Wert), wird der Encoder zusätzliche
+Blöcke erzeugen, wobei die in den \fIBlöcke\fP angegebenen Grenzen eingehalten
+werden. Wenn Sie zum Beispiel \fB\-\-block\-size=10MiB\fP
+\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP angeben und die Eingabedatei 80
+MiB groß ist, erhalten Sie 11 Blöcke: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 und
+1 MiB.
+.IP ""
+Im Multi\-Thread\-Modus werden die Blockgrößen in den Block\-Headern
+gespeichert. Dies geschieht im Einzel\-Thread\-Modus nicht, daher wird die
+kodierte Ausgabe zu der im Multi\-Thread\-Modus nicht identisch sein.
+.TP 
+\fB\-\-flush\-timeout=\fP\fIZeit\fP
+löscht bei der Kompression die ausstehenden Daten aus dem Encoder und macht
+sie im Ausgabedatenstrom verfügbar, wenn mehr als die angegebene \fIZeit\fP in
+Millisekunden (als positive Ganzzahl) seit dem vorherigen Löschen vergangen
+ist und das Lesen weiterer Eingaben blockieren würde. Dies kann nützlich
+sein, wenn \fBxz\fP zum Komprimieren von über das Netzwerk eingehenden Daten
+verwendet wird. Kleine \fIZeit\fP\-Werte machen die Daten unmittelbar nach dem
+Empfang nach einer kurzen Verzögerung verfügbar, während große \fIZeit\fP\-Werte
+ein besseres Kompressionsverhältnis bewirken.
+.IP ""
+Dieses Funktionsmerkmal ist standardmäßig deaktiviert. Wenn diese Option
+mehrfach angegeben wird, ist die zuletzt angegebene wirksam. Für die Angabe
+der \fIZeit\fP kann der spezielle Wert \fB0\fP verwendet werden, um dieses
+Funktionsmerkmal explizit zu deaktivieren.
+.IP ""
+Dieses Funktionsmerkmal ist außerhalb von POSIX\-Systemen nicht verfügbar.
+.IP ""
+.\" FIXME
+\fBDieses Funktionsmerkmal ist noch experimentell.\fP Gegenwärtig ist \fBxz\fP
+aufgrund der Art und Weise, wie \fBxz\fP puffert, für Dekompression in Echtzeit
+ungeeignet.
+.TP 
+\fB\-\-memlimit\-compress=\fP\fIGrenze\fP
+legt eine Grenze für die Speichernutzung bei der Kompression fest. Wenn
+diese Option mehrmals angegeben wird, ist die zuletzt angegebene wirksam.
+.IP ""
+Falls die Kompressionseinstellungen die \fIGrenze\fP überschreiten, versucht
+\fBxz\fP, die Einstellungen nach unten anzupassen, so dass die Grenze nicht
+mehr überschritten wird und zeigt einen Hinweis an, dass eine automatische
+Anpassung vorgenommen wurde. Die Anpassungen werden in folgender Reihenfolge
+angewendet: Reduzierung der Anzahl der Threads, Wechsel in den
+Einzelthread\-Modus, falls sogar ein einziger Thread im Multithread\-Modus die
+\fIGrenze\fP überschreitet, und schlussendlich die Reduzierung der Größe des
+LZMA2\-Wörterbuchs.
+.IP ""
+Beim Komprimieren mit \fB\-\-format=raw\fP oder falls \fB\-\-no\-adjust\fP angegeben
+wurde, wird nur die Anzahl der Threads reduziert, da nur so die komprimierte
+Ausgabe nicht beeinflusst wird.
+.IP ""
+Falls die \fIGrenze\fP nicht anhand der vorstehend beschriebenen Anpassungen
+gesetzt werden kann, wird ein Fehler angezeigt und \fBxz\fP wird mit dem
+Exit\-Status 1 beendet.
+.IP ""
+Die \fIGrenze\fP kann auf verschiedene Arten angegeben werden:
+.RS
+.IP \(bu 3
+Die \fIGrenze\fP kann ein absoluter Wert in Byte sein. Ein Suffix wie \fBMiB\fP
+kann dabei hilfreich sein. Beispiel: \fB\-\-memlimit\-compress=80MiB\fP.
+.IP \(bu 3
+Die \fIGrenze\fP kann als Prozentsatz des physischen Gesamtspeichers (RAM)
+angegeben werden. Dies ist insbesondere nützlich, wenn in einem
+Shell\-Initialisierungsskript, das mehrere unterschiedliche Rechner gemeinsam
+verwenden, die Umgebungsvariable \fBXZ_DEFAULTS\fP gesetzt ist. Auf diese Weise
+ist die Grenze auf Systemen mit mehr Speicher höher. Beispiel:
+\fB\-\-memlimit\-compress=70%\fP
+.IP \(bu 3
+Mit \fB0\fP kann die \fIGrenze\fP auf den Standardwert zurückgesetzt werden. Dies
+ist gegenwärtig gleichbedeutend mit dem Setzen der \fIGrenze\fP auf \fBmax\fP
+(keine Speicherbegrenzung).
+.RE
+.IP ""
+Für die 32\-Bit\-Version von \fBxz\fP gibt es einen Spezialfall: Falls die Grenze
+über \fB4020\ MiB\fP liegt, wird die \fIGrenze\fP auf \fB4020\ MiB\fP gesetzt. Auf
+MIPS32 wird stattdessen \fB2000\ MB\fP verwendet (die Werte \fB0\fP und \fBmax\fP
+werden hiervon nicht beeinflusst; für die Dekompression gibt es keine
+vergleichbare Funktion). Dies kann hilfreich sein, wenn ein
+32\-Bit\-Executable auf einen 4\ GiB großen Adressraum (2 GiB auf MIPS32)
+zugreifen kann, wobei wir hoffen wollen, dass es in anderen Situationen
+keine negativen Effekte hat.
+.IP ""
+Siehe auch den Abschnitt \fBSpeicherbedarf\fP.
+.TP 
+\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP
+legt eine Begrenzung des Speicherverbrauchs für die Dekompression fest. Dies
+beeinflusst auch den Modus \fB\-\-list\fP. Falls die Aktion nicht ausführbar ist,
+ohne die \fIGrenze\fP zu überschreiten, gibt \fBxz\fP eine Fehlermeldung aus und
+die Dekompression wird fehlschlagen. Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP
+zu möglichen Wegen, die \fIGrenze\fP anzugeben.
+.TP 
+\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP
+legt eine Begrenzung des Speicherverbrauchs für Multithread\-Dekompression
+fest. Dies beeinflusst lediglich die Anzahl der Threads; \fBxz\fP wird dadurch
+niemals die Dekompression einer Datei verweigern. Falls die \fIGrenze\fP für
+jegliches Multithreading zu niedrig ist, wird sie ignoriert und \fBxz\fP setzt
+im Einzelthread\-modus fort. Beachten Sie auch, dass bei der Verwendung von
+\fB\-\-memlimit\-decompress\fP dies stets sowohl auf den Einzelthread\-als auch auf
+den Multithread\-Modus angewendet wird und so die effektive \fIGrenze\fP für den
+Multithread\-Modus niemals höher sein wird als die mit
+\fB\-\-memlimit\-decompress\fP gesetzte Grenze.
+.IP ""
+Im Gegensatz zu anderen Optionen zur Begrenzung des Speicherverbrauchs hat
+\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP eine systemspezifisch vorgegebene
+\fIGrenze\fP. Mit \fBxz \-\-info\-memory\fP können Sie deren aktuellen Wert anzeigen
+lassen.
+.IP ""
+Diese Option und ihr Standardwert existieren, weil die unbegrenzte
+threadbezogene Dekompression bei einigen Eingabedateien zu unglaublich
+großem Speicherverbrauch führen würde. Falls die vorgegebene \fIGrenze\fP auf
+Ihrem System zu niedrig ist, können Sie die \fIGrenze\fP durchaus erhöhen, aber
+setzen Sie sie niemals auf einen Wert größer als die Menge des nutzbaren
+Speichers, da \fBxz\fP bei entsprechenden Eingabedateien versuchen wird, diese
+Menge an Speicher auch bei einer geringen Anzahl von Threads zu
+verwnden. Speichermangel oder Auslagerung verbessern die
+Dekomprimierungsleistung nicht.
+.IP ""
+Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP für mögliche Wege zur Angabe der
+\fIGrenze\fP.  Sezen der \fIGrenze\fP auf \fB0\fP setzt die \fIGrenze\fP auf den
+vorgegebenen systemspezifischen Wert zurück.
+.TP 
+\fB\-M\fP \fIGrenze\fP, \fB\-\-memlimit=\fP\fIGrenze\fP, \fB\-\-memory=\fP\fIGrenze\fP
+Dies ist gleichbedeutend mit \fB\-\-memlimit\-compress=\fP\fIGrenze\fP
+\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP.
+.TP 
+\fB\-\-no\-adjust\fP
+zeigt einen Fehler an und beendet, falls die Grenze der Speichernutzung
+nicht ohne Änderung der Einstellungen, welche die komprimierte Ausgabe
+beeinflussen, berücksichtigt werden kann. Das bedeutet, dass \fBxz\fP daran
+gehindert wird, den Encoder vom Multithread\-Modus in den Einzelthread\-Modus
+zu versetzen und die Größe des LZMA2\-Wörterbuchs zu reduzieren. Allerdings
+kann bei Verwendung dieser Option dennoch die Anzahl der Threads reduziert
+werden, um die Grenze der Speichernutzung zu halten, sofern dies die
+komprimierte Ausgabe nicht beeinflusst.
+.IP ""
+Die automatische Anpassung ist beim Erzeugen von Rohdatenströmen
+(\fB\-\-format=raw\fP) immer deaktiviert.
+.TP 
+\fB\-T\fP \fIThreads\fP, \fB\-\-threads=\fP\fIThreads\fP
+gibt die Anzahl der zu verwendenden Arbeits\-Threads an. Wenn Sie \fIThreads\fP
+auf einen speziellen Wert \fB0\fP setzen, verwendet \fBxz\fP maximal so viele
+Threads, wie der/die Prozessor(en) im System untestützen. Die tatsächliche
+Anzahl kann geringer sein als die angegebenen \fIThreads\fP, wenn die
+Eingabedatei nicht groß genug für Threading mit den gegebenen Einstellungen
+ist oder wenn mehr Threads die Speicherbegrenzung übersteigen würden.
+.IP ""
+Die Multithread\- bzw. Einzelthread\-Kompressoren erzeugen unterschiedliche
+Ausgaben. Der Einzelthread\-Kompressor erzeugt die geringste Dateigröße, aber
+nur die Ausgabe des Multithread\-Kompressors kann mit mehreren Threads wieder
+dekomprimiert werden. Das Setzen der Anzahl der \fIThreads\fP auf \fB1\fP wird den
+Einzelthread\-Modus verwenden.  Das Setzen der Anzahl der \fIThreads\fP auf
+einen anderen Wert einschließlich \fB0\fP verwendet den Multithread\-Kompressor,
+und zwar sogar dann, wenn das System nur einen einzigen Hardware\-Thread
+unterstützt (\fBxz\fP 5.2.x verwendete in diesem Fall noch den
+Einzelthread\-Modus).
+.IP ""
+Um den Multithread\-Modus mit nur einem einzigen Thread zu verwenden, setzen
+Sie die Anzahl der \fIThreads\fP auf \fB+1\fP. Das Präfix \fB+\fP hat mit Werten
+verschieden von \fB1\fP keinen Effekt. Eine Begrenzung des Speicherverbrauchs
+kann \fBxz\fP dennoch veranlassen, den Einzelthread\-Modus zu verwenden, außer
+wenn \fB\-\-no\-adjust\fP verwendet wird. Die Unterstützung für das Präfix \fB+\fP
+wurde in \fBxz\fP 5.4.0 hinzugefügt.
+.IP ""
+Falls das automatische Setzen der Anzahl der Threads angefordert und keine
+Speicherbegrenzung angegeben wurde, dann wird eine systemspezifisch
+vorgegebene weiche Grenze verwendet, um eventuell die Anzahl der Threads zu
+begrenzen. Es ist eine weiche Grenze im Sinne davon, dass sie ignoriert
+wird, falls die Anzahl der Threads 1 ist; daher wird eine weiche Grenze
+\fBxz\fP niemals an der Kompression oder Dekompression hindern. Diese
+vorgegebene weiche Grenze veranlasst \fBxz\fP nicht, vom Multithread\-Modus in
+den Einzelthread\-Modus zu wechseln. Die aktiven Grenzen können Sie mit dem
+Befehl \fBxz \-\-info\-memory\fP anzeigen lassen.
+.IP ""
+Die gegenwärtig einzige Threading\-Methode teilt die Eingabe in Blöcke und
+komprimiert diese unabhängig voneinander. Die vorgegebene Blockgröße ist von
+der Kompressionsstufe abhängig und kann mit der Option
+\fB\-\-block\-size=\fP\fIGröße\fP außer Kraft gesetzt werden.
+.IP ""
+Eine thread\-basierte Dekompression wird nur bei Dateien funktionieren, die
+mehrere Blöcke mit Größeninformationen in deren Headern enthalten. Alle im
+Multi\-Thread\-Modus komprimierten Dateien, die groß genug sind, erfüllen
+diese Bedingung, im Einzel\-Thread\-Modus komprimierte Dateien dagegen nicht,
+selbst wenn \fB\-\-block\-size=\fP\fIGröße\fP verwendet wurde.
+.IP ""
+Der Vorgabewert für \fIThreads\fP is \fB0\fP. In \fBxz\fP 5.4.x und älteren Versionen
+ist der Vorgabewert \fB1\fP.
+.
+.SS "Benutzerdefinierte Filterketten für die Kompression"
+Eine benutzerdefinierte Filterkette ermöglicht die Angabe detaillierter
+Kompressionseinstellungen, anstatt von den Voreinstellungen auszugehen. Wenn
+eine benutzerdefinierte Filterkette angegeben wird, werden die vorher in der
+Befehlszeile angegebenen Voreinstellungsoptionen (\fB\-0\fP … \fB\-9\fP und
+\fB\-\-extreme\fP) außer Kraft gesetzt. Wenn eine Voreinstellungsoption nach
+einer oder mehreren benutzerdefinierten Filterkettenoptionen angegeben wird,
+dann wird die neue Voreinstellung wirksam und die zuvor angegebenen
+Filterkettenoptionen werden außer Kraft gesetzt.
+.PP
+Eine Filterkette ist mit dem Piping (der Weiterleitung) in der Befehlszeile
+vergleichbar. Bei der Kompression gelangt die unkomprimierte Eingabe in den
+ersten Filter, dessen Ausgabe wiederum in den zweiten Filter geleitet wird
+(sofern ein solcher vorhanden ist). Die Ausgabe des letzten Filters wird in
+die komprimierte Datei geschrieben. In einer Filterkette sind maximal vier
+Filter zulässig, aber typischerweise besteht eine Filterkette nur aus einem
+oder zwei Filtern.
+.PP
+Bei vielen Filtern ist die Positionierung in der Filterkette eingeschränkt:
+Einige Filter sind nur als letzte in der Kette verwendbar, einige können
+nicht als letzte Filter gesetzt werden, und andere funktionieren an
+beliebiger Stelle. Abhängig von dem Filter ist diese Beschränkung entweder
+auf das Design des Filters selbst zurückzuführen oder ist aus
+Sicherheitsgründen vorhanden.
+.PP
+Eine benutzerdefinierte Filterkette kann auf zwei verschiedene Arten
+angegeben werden. Die Optionen \fB\-\-filters=\fP\fIFilter\fP und
+\fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP ermöglichen die Angabe
+einer ganzen Filterkette in einer einzelnen Option gemäß der
+Liblzma\-Filterzeichenkettensyntax. Alternativ können Sie eine Filterkette
+mit einer oder mehreren individuellen Filteroptionen in der Reihenfolge
+angeben, in der sie in der Filterkette verwendet werden sollen. Daher ist
+die Reihenfolge der individuellen Filteroptionen wichtig! Beim Dekodieren
+von Rohdatenströmen (\fB\-\-format=raw\fP) muss die Filterkette in der gleichen
+Reihenfolge wie bei der Komprimierung angegeben werden. Alle individuellen
+Filter\- oder Voreinstellungsoptionen, die \fIvor\fP der vollen
+Filterkettenoption (\fB\-\-filters=\fP\fIFilter\fP) angegeben werden, werden
+verworfen. Individuelle Filter, die \fInach\fP der vollen Filterkettenoption
+angegeben werden, setzen die Filterkette zurück
+.PP
+Sowohl vollständige als auch individuelle Filteroptionen akzeptieren
+filterspezifische \fIOptionen\fP in einer durch Kommata getrennten
+Liste. Zusätzliche Kommata in den \fIOptionen\fP werden ignoriert. Jede Option
+hat einen Standardwert, daher brauchen Sie nur jene anzugeben, die Sie
+ändern wollen.
+.PP
+Um die gesamte Filterkette und die \fIOptionen\fP anzuzeigen, rufen Sie \fBxz \-vv\fP auf (was gleichbedeutend mit der zweimaligen Angabe von \fB\-\-verbose\fP
+ist). Dies funktioniert auch zum Betrachten der von den Voreinstellungen
+verwendeten Filterkettenoptionen.
+.TP 
+\fB\-\-filters=\fP\fIFilter\fP
+gibt die vollständige Filterkette oder eine Voreinstellung in einer
+einzelnen Option an. Mehrere Filter können durch Leerzeichen oder zwei
+Minuszeichen (\fB\-\-\fP) voneinander getrennt werden. Es kann notwendig sein,
+die \fIFilter\fP in der Shell\-Befehlszeile zu maskieren, so dass diese als
+einzelne Option ausgewertet werden. Um Optionen Werte zuzuordnen, verwenden
+Sie \fB:\fP oder \fB=\fP. Einer Voreinstellung kann ein \fB\-\fP vorangestellt werden,
+dem keiner oder mehrere Schalter folgen. Der einzige unterstützte Schalter
+ist \fBe\fP zum Anwenden der gleichen Optionen wie \fB\-\-extreme\fP.
+.TP 
+\fB\-\-filters1\fP=\fIFilter\fP … \fB\-\-filters9\fP=\fIFilter\fP
+gibt bis zu neun optionale Filterketten an, die mit \fB\-\-block\-list\fP
+verwendet werden können.
+.IP ""
+Wenn Sie beispielsweise ein Archiv mit ausführbaren Dateien gefolgt von
+Textdateien komprimieren, könnte der Teil mit den ausführbaren Dateien eine
+Filterkette mit einem BCJ\-Filter und der Textdateiteil lediglich den
+LZMA2\-Filter verwenden.
+.TP 
+\fB\-\-filters\-help\fP
+zeigt eine Hilfemeldung an, welche beschreibt, wie Voreinstellungen und
+benutzerdefinierte Filterketten in den Optionen \fB\-\-filters\fP und
+\fB\-\-filters1=\fP\fIFilter\fP \&… \& \fB\-\-filters9=\fP\fIFilter\fP angegeben werden und
+beendet das Programm.
+.TP 
+\fB\-\-lzma1\fP[\fB=\fP\fIOptionen\fP]
+.PD 0
+.TP 
+\fB\-\-lzma2\fP[\fB=\fP\fIOptionen\fP]
+.PD
+fügt LZMA1\- oder LZMA2\-Filter zur Filterkette hinzu. Diese Filter können nur
+als letzte Filter in der Kette verwendet werden.
+.IP ""
+LZMA1 ist ein veralteter Filter, welcher nur wegen des veralteten
+\&\fB.lzma\fP\-Dateiformats unterstützt wird, welches nur LZMA1 unterstützt. LZMA2
+ist eine aktualisierte Version von LZMA1, welche einige praktische Probleme
+von LZMA1 behebt. Das \fB.xz\fP\-Format verwendet LZMA2 und unterstützt LZMA1
+gar nicht. Kompressionsgeschwindigkeit und \-verhältnis sind bei LZMA1 und
+LZMA2 praktisch gleich.
+.IP ""
+LZMA1 und LZMA2 haben die gleichen \fIOptionen\fP:
+.RS
+.TP 
+\fBpreset=\fP\fIVoreinstellung\fP
+setzt alle LZMA1\- oder LZMA2\-\fIOptionen\fP auf die \fIVoreinstellung\fP
+zurück. Diese \fIVoreinstellung\fP wird in Form einer Ganzzahl angegeben, der
+ein aus einem einzelnen Buchstaben bestehender Voreinstellungsmodifikator
+folgen kann. Die Ganzzahl kann \fB0\fP bis \fB9\fP sein, entsprechend den
+Befehlszeilenoptionen \fB\-0\fP … \fB\-9\fP. Gegenwärtig ist \fBe\fP der einzige
+unterstützte Modifikator, was \fB\-\-extreme\fP entspricht. Wenn keine
+\fBVoreinstellung\fP angegeben ist, werden die Standardwerte der LZMA1\- oder
+LZMA2\-\fIOptionen\fP der Voreinstellung \fB6\fP entnommen.
+.TP 
+\fBdict=\fP\fIGröße\fP
+Die \fIGröße\fP des Wörterbuchs (Chronikpuffers) gibt an, wie viel Byte der
+kürzlich verarbeiteten unkomprimierten Daten im Speicher behalten werden
+sollen. Der Algorithmus versucht, sich wiederholende Byte\-Abfolgen
+(Übereinstimmungen) in den unkomprimierten Daten zu finden und diese durch
+Referenzen zu den Daten zu ersetzen, die sich gegenwärtig im Wörterbuch
+befinden. Je größer das Wörterbuch, umso größer ist die Chance, eine
+Übereinstimmung zu finden. Daher bewirkt eine Erhöhung der \fIGröße\fP des
+Wörterbuchs üblicherweise ein besseres Kompressionsverhältnis, aber ein
+Wörterbuch, das größer ist als die unkomprimierte Datei, wäre
+Speicherverschwendung.
+.IP ""
+Typische Wörterbuch\-\fIGrößen\fP liegen im Bereich von 64\ KiB bis 64\ MiB. Das
+Minimum ist 4\ KiB. Das Maximum für die Kompression ist gegenwärtig 1.5\ GiB
+(1536\ MiB). Bei der Dekompression wird bereits eine Wörterbuchgröße bis zu
+4\ GiB minus 1 Byte unterstützt, welche das Maximum für die LZMA1\- und
+LZMA2\-Datenstromformate ist.
+.IP ""
+Die \fIGröße\fP des Wörterbuchs und der Übereinstimmungsfinder (\fIÜf\fP)
+bestimmen zusammen den Speicherverbrauch des LZMA1\- oder
+LZMA2\-Kodierers. Bei der Dekompression ist ein Wörterbuch der gleichen
+\fIGröße\fP (oder ein noch größeres) wie bei der Kompression erforderlich,
+daher wird der Speicherverbrauch des Dekoders durch die Größe des bei der
+Kompression verwendeten Wörterbuchs bestimmt. Die \fB.xz\fP\-Header speichern
+die \fIGröße\fP des Wörterbuchs entweder als 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1),
+so dass diese \fIGrößen\fP für die Kompression etwas bevorzugt werden. Andere
+\fIGrößen\fP werden beim Speichern in den \fB.xz\fP\-Headern aufgerundet.
+.TP 
+\fBlc=\fP\fIlc\fP
+gibt die Anzahl der literalen Kontextbits an. Das Minimum ist 0 und das
+Maximum 4; der Standardwert ist 3. Außerdem darf die Summe von \fIlc\fP und
+\fIlp\fP nicht größer als 4 sein.
+.IP ""
+Alle Bytes, die nicht als Übereinstimmungen kodiert werden können, werden
+als Literale kodiert. Solche Literale sind einfache 8\-bit\-Bytes, die jeweils
+für sich kodiert werden.
+.IP ""
+Bei der Literalkodierung wird angenommen, dass die höchsten \fIlc\fP\-Bits des
+zuvor unkomprimierten Bytes mit dem nächsten Byte in Beziehung stehen. Zum
+Beispiel folgt in typischen englischsprachigen Texten auf einen
+Großbuchstaben ein Kleinbuchstabe und auf einen Kleinbuchstaben
+üblicherweise wieder ein Kleinbuchstabe. Im US\-ASCII\-Zeichensatz sind die
+höchsten drei Bits 010 für Großbuchstaben und 011 für Kleinbuchstaben. Wenn
+\fIlc\fP mindestens 3 ist, kann die literale Kodierung diese Eigenschaft der
+unkomprimierten Daten ausnutzen.
+.IP ""
+Der Vorgabewert (3) ist üblicherweise gut. Wenn Sie die maximale Kompression
+erreichen wollen, versuchen Sie \fBlc=4\fP. Manchmal hilft es ein wenig, doch
+manchmal verschlechtert es die Kompression. Im letzteren Fall versuchen Sie
+zum Beispiel auch\& \fBlc=2\fP.
+.TP 
+\fBlp=\fP\fIlp\fP
+gibt die Anzahl der literalen Positionsbits an. Das Minimum ist 0 und das
+Maximum 4; die Vorgabe ist 0.
+.IP ""
+\fILp\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten beim
+Kodieren von Literalen angenommen wird. Siehe \fIpb\fP weiter unten für weitere
+Informationen zur Ausrichtung.
+.TP 
+\fBpb=\fP\fIAnzahl\fP
+legt die Anzahl der Positions\-Bits fest. Das Minimum ist 0 und das Maximum
+4; Standard ist 2.
+.IP ""
+\fIPb\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten
+generell angenommen wird. Standardmäßig wird eine Vier\-Byte\-Ausrichtung
+angenommen (2^\fIpb\fP=2^2=4), was oft eine gute Wahl ist, wenn es keine
+bessere Schätzung gibt.
+.IP ""
+Wenn die Ausrichtung bekannt ist, kann das entsprechende Setzen von \fIpb\fP
+die Dateigröße ein wenig verringern. Wenn Textdateien zum Beispiel eine
+Ein\-Byte\-Ausrichtung haben (US\-ASCII, ISO\-8859\-*, UTF\-8), kann das Setzen
+von \fBpb=0\fP die Kompression etwas verbessern. Für UTF\-16\-Text ist \fBpb=1\fP
+eine gute Wahl. Wenn die Ausrichtung eine ungerade Zahl wie beispielsweise 3
+Byte ist, könnte \fBpb=0\fP die beste Wahl sein.
+.IP ""
+Obwohl die angenommene Ausrichtung mit \fIpb\fP und \fIlp\fP angepasst werden
+kann, bevorzugen LZMA1 und LZMA2 noch etwas die 16\-Byte\-Ausrichtung. Das
+sollten Sie vielleicht beim Design von Dateiformaten berücksichtigen, die
+wahrscheinlich oft mit LZMA1 oder LZMA2 komprimiert werden.
+.TP 
+\fBmf=\fP\fIÜf\fP
+Der Übereinstimmungsfinder hat einen großen Einfluss auf die Geschwindigkeit
+des Kodierers, den Speicherbedarf und das
+Kompressionsverhältnis. Üblicherweise sind auf Hash\-Ketten basierende
+Übereinstimmungsfinder schneller als jene, die mit Binärbäumen arbeiten. Die
+Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab: 0 verwendet \fBhc3\fP, 1\-3
+verwenden \fBhc4\fP und der Rest verwendet \fBbt4\fP.
+.IP ""
+Die folgenden Übereinstimmungsfinder werden unterstützt. Die Formeln zur
+Ermittlung des Speicherverbrauchs sind grobe Schätzungen, die der Realität
+am nächsten kommen, wenn \fIWörterbuch\fP eine Zweierpotenz ist.
+.RS
+.TP 
+\fBhc3\fP
+Hash\-Kette mit 2\- und 3\-Byte\-Hashing
+.br
+Minimalwert für \fInice\fP: 3
+.br
+Speicherbedarf:
+.br
+\fIdict\fP * 7,5 (falls \fIdict\fP <= 16 MiB);
+.br
+\fIdict\fP * 5,5 + 64 MiB (falls \fIdict\fP > 16 MiB)
+.TP 
+\fBhc4\fP
+Hash\-Kette mit 2\-, 3\- und 4\-Byte\-Hashing
+.br
+Minimaler Wert für \fInice\fP: 4
+.br
+Speicherbedarf:
+.br
+\fIdict\fP * 7,5 (falls \fIdict\fP <= 32 MiB ist);
+.br
+\fIdict\fP * 6,5 (falls \fIdict\fP > 32 MiB ist)
+.TP 
+\fBbt2\fP
+Binärbaum mit 2\-Byte\-Hashing
+.br
+Minimaler Wert für \fInice\fP: 2
+.br
+Speicherverbrauch: \fIdict\fP * 9.5
+.TP 
+\fBbt3\fP
+Binärbaum mit 2\- und 3\-Byte\-Hashing
+.br
+Minimalwert für \fInice\fP: 3
+.br
+Speicherbedarf:
+.br
+\fIdict\fP * 11,5 (falls \fIdict\fP <= 16 MiB ist);
+.br
+\fIdict\fP * 9,5 + 64 MiB (falls \fIdict\fP > 16 MiB ist)
+.TP 
+\fBbt4\fP
+Binärbaum mit 2\-, 3\- und 4\-Byte\-Hashing
+.br
+Minimaler Wert für \fInice\fP: 4
+.br
+Speicherbedarf:
+.br
+\fIdict\fP * 11,5 (falls \fIdict\fP <= 32 MiB ist);
+.br
+\fIdict\fP * 10,5 (falls \fIdict\fP > 32 MiB ist)
+.RE
+.TP 
+\fBmode=\fP\fIModus\fP
+gibt die Methode zum Analysieren der vom Übereinstimmungsfinder gelieferten
+Daten an. Als \fIModi\fP werden \fBfast\fP und \fBnormal\fP unterstützt. Die Vorgabe
+ist \fBfast\fP für die \fIVoreinstellungsstufen\fP 0\-3 und \fBnormal\fP für die
+\fIVoreinstellungsstufen\fP 4\-9.
+.IP ""
+Üblicherweise wird \fBfast\fP mit Hashketten\-basierten Übereinstimmungsfindern
+und \fBnormal\fP mit Binärbaum\-basierten Übereinstimmungsfindern verwendet. So
+machen es auch die \fIVoreinstellungsstufen\fP.
+.TP 
+\fBnice=\fP\fInice\fP
+gibt an, was als annehmbarer Wert für eine Übereinstimmung angesehen werden
+kann. Wenn eine Übereinstimmung gefunden wird, die mindestens diesen
+\fInice\fP\-Wert hat, sucht der Algorithmus nicht weiter nach besseren
+Übereinstimmungen.
+.IP ""
+Der \fInice\fP\-Wert kann 2\-273 Byte sein. Höhere Werte tendieren zu einem
+besseren Kompressionsverhältnis, aber auf Kosten der Geschwindigkeit. Die
+Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab.
+.TP 
+\fBdepth=\fP\fITiefe\fP
+legt die maximale Suchtiefe im Übereinstimmungsfinder fest. Vorgegeben ist
+der spezielle Wert 0, der den Kompressor veranlasst, einen annehmbaren Wert
+für \fITiefe\fP aus \fIÜf\fP und \fInice\fP\-Wert zu bestimmen.
+.IP ""
+Die angemessene \fITiefe\fP für Hash\-Ketten ist 4\-100 und 16\-1000 für
+Binärbäume. Hohe Werte für die \fITiefe\fP können den Kodierer bei einigen
+Dateien extrem verlangsamen. Vermeiden Sie es, die \fITiefe\fP über einen Wert
+von 100 zu setzen, oder stellen Sie sich darauf ein, die Kompression
+abzubrechen, wenn sie zu lange dauert.
+.RE
+.IP ""
+Beim Dekodieren von Rohdatenströmen (\fB\-\-format=raw\fP) benötigt LZMA2 nur die
+Wörterbuch\-\fIGröße\fP.  LZMA1 benötigt außerdem \fIlc\fP, \fIlp\fP und \fIpb\fP.
+.TP 
+\fB\-\-x86\fP[\fB=\fP\fIOptionen\fP]
+.PD 0
+.TP 
+\fB\-\-arm\fP[\fB=\fP\fIOptionen\fP]
+.TP 
+\fB\-\-armthumb\fP[\fB=\fP\fIOptionen\fP]
+.TP 
+\fB\-\-arm64\fP[\fB=\fP\fIOptionen\fP]
+.TP 
+\fB\-\-powerpc\fP[\fB=\fP\fIOptionen\fP]
+.TP 
+\fB\-\-ia64\fP[\fB=\fP\fIOptionen\fP]
+.TP 
+\fB\-\-sparc\fP[\fB=\fP\fIOptionen\fP]
+.TP 
+\fB\-\-riscv\fP[\fB=\fP\fIOptionen\fP]
+.PD
+fügt ein »Branch/Call/Jump«\-(BCJ\-)Filter zur Filterkette hinzu. Diese Filter
+können nicht als letzter Filter in der Filterkette verwendet werden.
+.IP ""
+Ein BCJ\-Filter wandelt relative Adressen im Maschinencode in deren absolute
+Gegenstücke um. Die Datengröße wird dadurch nicht geändert, aber die
+Redundanz erhöht, was LZMA2 dabei helfen kann, eine um 10 bis 15% kleinere
+\&\fB.xz\fP\-Datei zu erstellen. Die BCJ\-Filter sind immer reversibel, daher
+verursacht die Anwendung eines BCJ\-Filters auf den falschen Datentyp keinen
+Datenverlust, wobei aber das Kompressionsverhältnis etwas schlechter werden
+könnte. Die BCJ\-Filter sind sehr schnell und verbrauchen nur wenig mehr
+Speicher.
+.IP ""
+Diese BCJ\-Filter haben bekannte Probleme mit dem Kompressionsverhältnis:
+.RS
+.IP \(bu 3
+In einigen Dateitypen, die ausführbaren Code enthalten (zum Beispiel
+Objektdateien, statische Bibliotheken und Linux\-Kernelmodule), sind die
+Adressen in den Anweisungen mit Füllwerten gefüllt. Diese BCJ\-Filter führen
+dennoch die Adressumwandlung aus, wodurch die Kompression bei diesen Dateien
+schlechter wird.
+.IP \(bu 3
+Falls ein BCJ\-Filter auf ein Archiv angewendet wird, ist es möglich, dass
+das Kompressionsverhältnis schlechter als ohne Filter wird. Falls es
+beispielsweise ähnliche oder sogar identische ausführbare Dateien gibt, dann
+werden diese durch die Filterung wahrscheinlich »unähnlicher« und
+verschlechtern dadurch das Kompressionsverhältnis. Der Inhalt
+nicht\-ausführbarer Dateien im gleichen Archiv kann sich ebenfalls darauf
+auswirken. In der Praxis werden Sie durch Versuche mit oder ohne BCJ\-Filter
+selbst herausfinden müssen, was situationsbezogen besser ist.
+.RE
+.IP ""
+Verschiedene Befehlssätze haben unterschiedliche Ausrichtungen: Die
+ausführbare Datei muss in den Eingabedateien einem Vielfachen dieses Wertes
+entsprechen, damit dieser Filter funktioniert.
+.RS
+.RS
+.PP
+.TS
+tab(;);
+l n l
+l n l.
+Filter;Ausrichtung;Hinweise
+x86;1;32\-Bit oder 64\-Bit x86
+ARM;4;
+ARM\-Thumb;2;
+ARM64;4;4096\-Byte\-Ausrichtung ist optimal
+PowerPC;4;Nur Big Endian
+IA\-64;16;Itanium
+SPARC;4;
+RISC\-V;2;
+.TE
+.RE
+.RE
+.IP ""
+Da die BCJ\-gefilterten Daten üblicherweise mit LZMA2 komprimiert sind, kann
+das Kompressionsverhältnis dadurch etwas verbessert werden, dass die
+LZMA2\-Optionen so gesetzt werden, dass sie der Ausrichtung des gewählten
+BCJ\-Filters entsprechen. Beispiele:
+.RS
+.IP \(bu 3
+Der IA\-64\-Filter hat eine 16\-Byte\-Ausrichtung, daher ist \fBpb=4,lp=4,lc=0\fP
+für LZMA2 passend (2^4=16).
+.IP \(bu 3
+RISC\-V\-Code hat eine 2\-Byte\- oder 4\-Byte\-Ausrichtung, abhängig davon, ob die
+Datei 16\-bit\-komprimierte Instruktionen enthält (die C\-Erweiterung). Wenn
+16\-bit\-Instruktionen verwendet werden, ist \fBpb=2,lp=1,lc=3\fP oder
+\fBpb=1,lp=1,lc=3\fP passend. Wenn keine 16\-bit\-Instruktionen vorhanden sind,
+ist \fBpb=2,lp=2,lc=2\fP am besten. Mit \fBreadelf \-h\fP können Sie überprüfen, ob
+»RVC« in der »Flags«\-Zeile auftritt.
+.IP \(bu 3
+ARM64 hat stets eine 4\-Byte\-Ausrichtung, daher ist \fBpb=2,lp=2,lc=2\fP am
+besten.
+.IP \(bu 3
+Der x86\-Filter stellt eine Ausnahme dar. Es ist üblicherweise eine gute
+Wahl, bei den Voreinstellungen von LZMA2 (\fBpb=2,lp=0,lc=3\fP) zu bleiben,
+wenn Sie ausführbare x86\-Dateien komprimieren
+.RE
+.IP ""
+Alle BCJ\-Filter unterstützen die gleichen \fIOptionen\fP:
+.RS
+.TP 
+\fBstart=\fP\fIVersatz\fP
+gibt den Start\-\fIVersatz\fP an, der bei der Umwandlung zwischen relativen und
+absoluten Adressen verwendet wird. Der \fIVersatz\fP muss ein Vielfaches der
+Filterausrichtung sein (siehe die Tabelle oben). Der Standardwert ist 0. In
+der Praxis ist dieser Standardwert gut; die Angabe eines benutzerdefinierten
+\fIVersatzes\fP ist fast immer unnütz.
+.RE
+.TP 
+\fB\-\-delta\fP[\fB=\fP\fIOptionen\fP]
+fügt den Delta\-Filter zur Filterkette hinzu. Der Delta\-Filter kann nicht als
+letzter Filter in der Filterkette verwendet werden.
+.IP ""
+Gegenwärtig wird nur eine einfache, Byte\-bezogene Delta\-Berechnung
+unterstützt. Beim Komprimieren von zum Beispiel unkomprimierten
+Bitmap\-Bildern oder unkomprimierten PCM\-Audiodaten kann es jedoch sinnvoll
+sein. Dennoch können für spezielle Zwecke entworfene Algorithmen deutlich
+bessere Ergebnisse als Delta und LZMA2 liefern. Dies trifft insbesondere auf
+Audiodaten zu, die sich zum Beispiel mit \fBflac\fP(1) schneller und besser
+komprimieren lassen.
+.IP ""
+Unterstützte \fIOptionen\fP:
+.RS
+.TP 
+\fBdist=\fP\fIAbstand\fP
+gibt den \fIAbstand\fP der Delta\-Berechnung in Byte an. Zulässige Werte für den
+\fIAbstand\fP sind 1 bis 256. Der Vorgabewert ist 1.
+.IP ""
+Zum Beispiel wird mit \fBdist=2\fP und der 8\-Byte\-Eingabe A1 B1 A2 B3 A3 B5 A4
+B7 die Ausgabe A1 B1 01 02 01 02 01 02 sein.
+.RE
+.
+.SS "Andere Optionen"
+.TP 
+\fB\-q\fP, \fB\-\-quiet\fP
+unterdrückt Warnungen und Hinweise. Geben Sie dies zweimal an, um auch
+Fehlermeldungen zu unterdrücken. Diese Option wirkt sich nicht auf den
+Exit\-Status aus. Das bedeutet, das selbst bei einer unterdrückten Warnung
+der Exit\-Status zur Anzeige einer Warnung dennoch verwendet wird.
+.TP 
+\fB\-v\fP, \fB\-\-verbose\fP
+bewirkt ausführliche Ausgaben. Wenn die Standardfehlerausgabe mit einem
+Terminal verbunden ist, zeigt \fBxz\fP den Fortschritt an. Durch zweimalige
+Angabe von \fB\-\-verbose\fP wird die Ausgabe noch ausführlicher.
+.IP ""
+Der Fortschrittsanzeiger stellt die folgenden Informationen dar:
+.RS
+.IP \(bu 3
+Der Prozentsatz des Fortschritts wird angezeigt, wenn die Größe der
+Eingabedatei bekannt ist. Das bedeutet, dass der Prozentsatz in
+Weiterleitungen (Pipes) nicht angezeigt werden kann.
+.IP \(bu 3
+Menge der erzeugten komprimierten Daten (bei der Kompression) oder der
+verarbeiteten Daten (bei der Dekompression).
+.IP \(bu 3
+Menge der verarbeiteten unkomprimierten Daten (bei der Kompression) oder der
+erzeugten Daten (bei der Dekompression).
+.IP \(bu 3
+Kompressionsverhältnis, das mittels Dividieren der Menge der bisher
+komprimierten Daten durch die Menge der bisher verarbeiteten unkomprimierten
+Daten ermittelt wird.
+.IP \(bu 3
+Kompressions\- oder Dekompressionsgeschwindigkeit. Diese wird anhand der
+Menge der unkomprimierten verarbeiteten Daten (bei der Kompression) oder der
+Menge der erzeugten Daten (bei der Dekompression) pro Sekunde gemessen. Die
+Anzeige startet einige Sekunden nachdem \fBxz\fP mit der Verarbeitung der Datei
+begonnen hat.
+.IP \(bu 3
+Die vergangene Zeit im Format M:SS oder H:MM:SS.
+.IP \(bu 3
+Die geschätzte verbleibende Zeit wird nur angezeigt, wenn die Größe der
+Eingabedatei bekannt ist und bereits einige Sekunden vergangen sind, nachdem
+\fBxz\fP mit der Verarbeitung der Datei begonnen hat. Die Zeit wird in einem
+weniger präzisen Format ohne Doppelpunkte angezeigt, zum Beispiel 2 min 30
+s.
+.RE
+.IP ""
+Wenn die Standardfehlerausgabe kein Terminal ist, schreibt \fBxz\fP mit
+\fB\-\-verbose\fP nach dem Komprimieren oder Dekomprimieren der Datei in einer
+einzelnen Zeile den Dateinamen, die komprimierte Größe, die unkomprimierte
+Größe, das Kompressionsverhältnis und eventuell auch die Geschwindigkeit und
+die vergangene Zeit in die Standardfehlerausgabe. Die Geschwindigkeit und
+die vergangene Zeit werden nur angezeigt, wenn der Vorgang mindestens ein
+paar Sekunden gedauert hat. Wurde der Vorgang nicht beendet, zum Beispiel
+weil ihn der Benutzer abgebrochen hat, wird außerdem der Prozentsatz des
+erreichten Verarbeitungsfortschritts aufgenommen, sofern die Größe der
+Eingabedatei bekannt ist.
+.TP 
+\fB\-Q\fP, \fB\-\-no\-warn\fP
+setzt den Exit\-Status nicht auf 2, selbst wenn eine Bedingung erfüllt ist,
+die eine Warnung gerechtfertigt hätte. Diese Option wirkt sich nicht auf die
+Ausführlichkeitsstufe aus, daher müssen sowohl \fB\-\-quiet\fP als auch
+\fB\-\-no\-warn\fP angegeben werden, um einerseits keine Warnungen anzuzeigen und
+andererseits auch den Exit\-Status nicht zu ändern.
+.TP 
+\fB\-\-robot\fP
+gibt Meldungen in einem maschinenlesbaren Format aus. Dadurch soll das
+Schreiben von Frontends erleichtert werden, die \fBxz\fP anstelle von Liblzma
+verwenden wollen, was in verschiedenen Skripten der Fall sein kann. Die
+Ausgabe mit dieser aktivierten Option sollte über mehrere
+\fBxz\fP\-Veröffentlichungen stabil sein. Details hierzu finden Sie im Abschnitt
+\fBROBOTER\-MODUS\fP.
+.TP 
+\fB\-\-info\-memory\fP
+zeigt in einem menschenlesbaren Format an, wieviel physischen Speicher (RAM)
+und wie viele Prozessor\-Threads das System nach Annahme von \fBxz\fP hat, sowie
+die Speicherbedarfsbegrenzung für Kompression und Dekompression, und beendet
+das Programm erfolgreich.
+.TP 
+\fB\-h\fP, \fB\-\-help\fP
+zeigt eine Hilfemeldung mit den am häufigsten genutzten Optionen an und
+beendet das Programm erfolgreich.
+.TP 
+\fB\-H\fP, \fB\-\-long\-help\fP
+zeigt eine Hilfemeldung an, die alle Funktionsmerkmale von \fBxz\fP beschreibt
+und beendet das Programm erfolgreich.
+.TP 
+\fB\-V\fP, \fB\-\-version\fP
+zeigt die Versionsnummer von \fBxz\fP und Liblzma in einem menschenlesbaren
+Format an. Um eine maschinell auswertbare Ausgabe zu erhalten, geben Sie
+\fB\-\-robot\fP vor \fB\-\-version\fP an.
+.
+.SH ROBOTER\-MODUS
+Der Roboter\-Modus wird mit der Option \fB\-\-robot\fP aktiviert. Er bewirkt, dass
+die Ausgabe von \fBxz\fP leichter von anderen Programmen ausgewertet werden
+kann. Gegenwärtig wird \fB\-\-robot\fP nur zusammen mit \fB\-\-list\fP,
+\fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP und \fB\-\-version\fP unterstützt. In der
+Zukunft wird dieser Modus auch für Kompression und Dekompression
+unterstützt.
+.
+.SS Listenmodus
+\fBxz \-\-robot \-\-list\fP verwendet eine durch Tabulatoren getrennte Ausgabe. In
+der ersten Spalte jeder Zeile bezeichnet eine Zeichenkette den Typ der
+Information, die in dieser Zeile enthalten ist:
+.TP 
+\fBname\fP
+Dies ist stets die erste Zeile, wenn eine Datei aufgelistet wird. Die zweite
+Spalte in der Zeile enthält den Dateinamen.
+.TP 
+\fBfile\fP
+Diese Zeile enthält allgemeine Informationen zur \fB.xz\fP\-Datei. Diese Zeile
+wird stets nach der \fBname\fP\-Zeile ausgegeben.
+.TP 
+\fBstream\fP
+Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es
+gibt genau so viele \fBstream\fP\-Zeilen, wie Datenströme in der \fB.xz\fP\-Datei
+enthalten sind.
+.TP 
+\fBblock\fP
+Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es
+gibt so viele \fBblock\fP\-Zeilen, wie Blöcke in der \fB.xz\fP\-Datei. Die
+\fBblock\fP\-Zeilen werden nach allen \fBstream\fP\-Zeilen angezeigt; verschiedene
+Zeilentypen werden nicht verschachtelt.
+.TP 
+\fBsummary\fP
+Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP zwei Mal angegeben
+wurde. Diese Zeile wird nach allen \fBblock\fP\-Zeilen ausgegeben. Wie die
+\fBfile\fP\-Zeile enthält die \fBsummary\fP\-Zeile allgemeine Informationen zur
+\&\fB.xz\fP\-Datei.
+.TP 
+\fBtotals\fP
+Diese Zeile ist immer die letzte der Listenausgabe. Sie zeigt die
+Gesamtanzahlen und \-größen an.
+.PP
+Die Spalten der \fBfile\fP\-Zeilen:
+.PD 0
+.RS
+.IP 2. 4
+Anzahl der Datenströme in der Datei
+.IP 3. 4
+Gesamtanzahl der Blöcke in den Datenströmen
+.IP 4. 4
+Komprimierte Größe der Datei
+.IP 5. 4
+Unkomprimierte Größe der Datei
+.IP 6. 4
+Das Kompressionsverhältnis, zum Beispiel \fB0.123\fP. Wenn das Verhältnis über
+9.999 liegt, werden drei Minuszeichen (\fB\-\-\-\fP) anstelle des
+Kompressionsverhältnisses angezeigt.
+.IP 7. 4
+Durch Kommata getrennte Liste der Namen der Integritätsprüfungen. Für die
+bekannten Überprüfungstypen werden folgende Zeichenketten verwendet:
+\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP und \fBSHA\-256\fP. \fBUnbek.\fP\fIN\fP wird verwendet,
+wobei \fIN\fP die Kennung der Überprüfung als Dezimalzahl angibt (ein\- oder
+zweistellig).
+.IP 8. 4
+Gesamtgröße der Datenstromauffüllung in der Datei
+.RE
+.PD
+.PP
+Die Spalten der \fBstream\fP\-Zeilen:
+.PD 0
+.RS
+.IP 2. 4
+Datenstromnummer (der erste Datenstrom ist 1)
+.IP 3. 4
+Anzahl der Blöcke im Datenstrom
+.IP 4. 4
+Komprimierte Startposition
+.IP 5. 4
+Unkomprimierte Startposition
+.IP 6. 4
+Komprimierte Größe (schließt die Datenstromauffüllung nicht mit ein)
+.IP 7. 4
+Unkomprimierte Größe
+.IP 8. 4
+Kompressionsverhältnis
+.IP 9. 4
+Name der Integritätsprüfung
+.IP 10. 4
+Größe der Datenstromauffüllung
+.RE
+.PD
+.PP
+Die Spalten der \fBblock\fP\-Zeilen:
+.PD 0
+.RS
+.IP 2. 4
+Anzahl der in diesem Block enthaltenen Datenströme
+.IP 3. 4
+Blocknummer relativ zum Anfang des Datenstroms (der erste Block ist 1)
+.IP 4. 4
+Blocknummer relativ zum Anfang der Datei
+.IP 5. 4
+Komprimierter Startversatz relativ zum Beginn der Datei
+.IP 6. 4
+Unkomprimierter Startversatz relativ zum Beginn der Datei
+.IP 7. 4
+Komprimierte Gesamtgröße des Blocks (einschließlich Header)
+.IP 8. 4
+Unkomprimierte Größe
+.IP 9. 4
+Kompressionsverhältnis
+.IP 10. 4
+Name der Integritätsprüfung
+.RE
+.PD
+.PP
+Wenn \fB\-\-verbose\fP zwei Mal angegeben wurde, werden zusätzliche Spalten in
+die \fBblock\fP\-Zeilen eingefügt. Diese werden mit einem einfachen \fB\-\-verbose\fP
+nicht angezeigt, da das Ermitteln dieser Informationen viele Suchvorgänge
+erfordert und daher recht langsam sein kann:
+.PD 0
+.RS
+.IP 11. 4
+Wert der Integritätsprüfung in hexadezimaler Notation
+.IP 12. 4
+Block\-Header\-Größe
+.IP 13. 4
+Block\-Schalter: \fBc\fP gibt an, dass die komprimierte Größe verfügbar ist, und
+\fBu\fP gibt an, dass die unkomprimierte Größe verfügbar ist. Falls der
+Schalter nicht gesetzt ist, wird stattdessen ein Bindestrich (\fB\-\fP)
+angezeigt, um die Länge der Zeichenkette beizubehalten. In Zukunft könnten
+neue Schalter am Ende der Zeichenkette hinzugefügt werden.
+.IP 14. 4
+Größe der tatsächlichen komprimierten Daten im Block. Ausgeschlossen sind
+hierbei die Block\-Header, die Blockauffüllung und die Prüffelder.
+.IP 15. 4
+Größe des Speichers (in Byte), der zum Dekomprimieren dieses Blocks mit
+dieser \fBxz\fP\-Version benötigt wird.
+.IP 16. 4
+Filterkette. Beachten Sie, dass die meisten der bei der Kompression
+verwendeten Optionen nicht bekannt sein können, da in den \fB.xz\fP\-Headern nur
+die für die Dekompression erforderlichen Optionen gespeichert sind.
+.RE
+.PD
+.PP
+Die Spalten der \fBsummary\fP\-Zeilen:
+.PD 0
+.RS
+.IP 2. 4
+Größe des Speichers (in Byte), der zum Dekomprimieren dieser Datei mit
+dieser \fBxz\fP\-Version benötigt wird.
+.IP 3. 4
+\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die
+komprimierte als auch die unkomprimierte Größe gespeichert ist.
+.PP
+\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP
+.IP 4. 4
+Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist
+.RE
+.PD
+.PP
+Die Spalten der \fBtotals\fP\-Zeile:
+.PD 0
+.RS
+.IP 2. 4
+Anzahl der Datenströme
+.IP 3. 4
+Anzahl der Blöcke
+.IP 4. 4
+Komprimierte Größe
+.IP 5. 4
+Unkomprimierte Größe
+.IP 6. 4
+Durchschnittliches Kompressionsverhältnis
+.IP 7. 4
+Durch Kommata getrennte Liste der Namen der Integritätsprüfungen, die in den
+Dateien präsent waren.
+.IP 8. 4
+Größe der Datenstromauffüllung
+.IP 9. 4
+Anzahl der Dateien. Dies dient dazu, die Reihenfolge der vorigen Spalten an
+die in den \fBfile\fP\-Zeilen anzugleichen.
+.PD
+.RE
+.PP
+Wenn \fB\-\-verbose\fP zwei Mal angegeben wird, werden zusätzliche Spalten in die
+\fBtotals\fP\-Zeile eingefügt:
+.PD 0
+.RS
+.IP 10. 4
+Maximale Größe des Speichers (in Byte), der zum Dekomprimieren der Dateien
+mit dieser \fBxz\fP\-Version benötigt wird.
+.IP 11. 4
+\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die
+komprimierte als auch die unkomprimierte Größe gespeichert ist.
+.PP
+\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP
+.IP 12. 4
+Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist
+.RE
+.PD
+.PP
+Zukünftige Versionen könnten neue Zeilentypen hinzufügen, weiterhin könnten
+auch in den vorhandenen Zeilentypen weitere Spalten hinzugefügt werden, aber
+die existierenden Spalten werden nicht geändert.
+.
+.SS Filterhilfe
+\fBxz \-\-robot \-\-filters\-help\fP gibt die unterstützten Filter im folgenden
+Format aus:
+.PP
+\fIFilter\fP\fB:\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>,\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>\fP
+…
+.TP 
+\fIFilter\fP
+Name des Filters
+.TP 
+\fIOption\fP
+Name der filterspezifischen Option
+.TP 
+\fIWert\fP
+Der numerische \fIWert\fP erscheint als Bereich
+\fB<\fP\fIMinimum\fP\fB\-\fP\fIMaximum\fP\fB>\fP. Die Auswahl des
+Zeichenketten\-\fIWert\fPs wird in \fB< >\fP eingeschlossen und durch \fB|\fP
+getrennt.
+.PP
+Jeder Filter wird in einer separaten Zeile ausgegeben.
+.
+.SS "Informationen zur Speicherbedarfsbegrenzung"
+\fBxz \-\-robot \-\-info\-memory\fP gibt eine einzelne Zeile mit mehreren durch
+Tabulatoren getrennten Spalten aus:
+.IP 1. 4
+Gesamter physischer Speicher (RAM) in Byte.
+.IP 2. 4
+Speicherbedarfsbegrenzung für die Kompression in Byte
+(\fB\-\-memlimit\-compress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die
+Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine
+Begrenzung vorhanden ist.
+.IP 3. 4
+Speicherbedarfsbegrenzung für die Dekompression in Byte
+(\fB\-\-memlimit\-decompress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die
+Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine
+Begrenzung vorhanden ist.
+.IP 4. 4
+Seit \fBxz\fP 5.3.4alpha: Die Speichernutzung für Multithread\-Dekompression in
+Byte (\fB\-\-memlimit\-mt\-decompress\fP). Dies ist niemals \fB0\fP, da ein
+systemspezifischer Vorgabewert (gezeigt in Spalte 5) verwendet wird, falls
+keine Grenze ausdrücklich angegeben wurde. Dies ist außerdem niemals größer
+als der Wert in in Spalte 3, selbst wenn mit \fB\-\-memlimit\-mt\-decompress\fP ein
+größerer Wert angegeben wurde.
+.IP 5. 4
+Seit \fBxz\fP 5.3.4alpha: Eine systemspezifisch vorgegebene Begrenzung des
+Speicherverbrauchs, die zur Begrenzung der Anzahl der Threads beim
+Komprimieren mit automatischer Anzahl der Threads (\fB\-\-threads=0\fP) und wenn
+keine Speicherbedarfsbegrenzung angegeben wurde (\fB\-\-memlimit\-compress\fP)
+verwendet wird. Dies wird auch als Standardwert für
+\fB\-\-memlimit\-mt\-decompress\fP verwendet.
+.IP 6. 4
+Seit \fBxz\fP 5.3.4alpha: Anzahl der verfügbaren Prozessorthreads.
+.PP
+In der Zukunft könnte die Ausgabe von \fBxz \-\-robot \-\-info\-memory\fP weitere
+Spalten enthalten, aber niemals mehr als eine einzelne Zeile.
+.
+.SS Version
+\fBxz \-\-robot \-\-version\fP gibt die Versionsnummern von \fBxz\fP und Liblzma im
+folgenden Format aus:
+.PP
+\fBXZ_VERSION=\fP\fIXYYYZZZS\fP
+.br
+\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP
+.TP 
+\fIX\fP
+Hauptversion.
+.TP 
+\fIYYY\fP
+Unterversion. Gerade Zahlen bezeichnen eine stabile Version. Ungerade Zahlen
+bezeichnen Alpha\- oder Betaversionen.
+.TP 
+\fIZZZ\fP
+Patch\-Stufe für stabile Veröffentlichungen oder einfach nur ein Zähler für
+Entwicklungsversionen.
+.TP 
+\fIS\fP
+Stabilität. 0 ist Alpha, 1 ist Beta und 2 ist stabil. \fIS\fP sollte immer 2
+sein, wenn \fIYYY\fP eine gerade Zahl ist.
+.PP
+\fIXYYYZZZS\fP sind in beiden Zeilen gleich, sofern \fBxz\fP und Liblzma aus der
+gleichen Veröffentlichung der XZ\-Utils stammen.
+.PP
+Beispiele: 4.999.9beta ist \fB49990091\fP und 5.0.0 is \fB50000002\fP.
+.
+.SH EXIT\-STATUS
+.TP 
+\fB0\fP
+Alles ist in Ordnung.
+.TP 
+\fB1\fP
+Ein Fehler ist aufgetreten.
+.TP 
+\fB2\fP
+Es ist etwas passiert, das eine Warnung rechtfertigt, aber es sind keine
+tatsächlichen Fehler aufgetreten.
+.PP
+In die Standardausgabe geschriebene Hinweise (keine Warnungen oder Fehler),
+welche den Exit\-Status nicht beeinflussen.
+.
+.SH UMGEBUNGSVARIABLEN
+\fBxz\fP wertet eine durch Leerzeichen getrennte Liste von Optionen in den
+Umgebungsvariablen \fBXZ_DEFAULTS\fP und \fBXZ_OPT\fP aus (in dieser Reihenfolge),
+bevor die Optionen aus der Befehlszeile ausgewertet werden. Beachten Sie,
+dass beim Auswerten der Umgebungsvariablen nur Optionen berücksichtigt
+werden; alle Einträge, die keine Optionen sind, werden stillschweigend
+ignoriert. Die Auswertung erfolgt mit \fBgetopt_long\fP(3), welches auch für
+die Befehlszeilenargumente verwendet wird.
+.TP 
+\fBXZ_DEFAULTS\fP
+Benutzerspezifische oder systemweite Standardoptionen. Typischerweise werden
+diese in einem Shell\-Initialisierungsskript gesetzt, um die
+Speicherbedarfsbegrenzung von \fBxz\fP standardmäßig zu aktivieren. Außer bei
+Shell\-Initialisierungsskripten und in ähnlichen Spezialfällen darf die
+Variable \fBXZ_DEFAULTS\fP in Skripten niemals gesetzt oder außer Kraft gesetzt
+werden.
+.TP 
+\fBXZ_OPT\fP
+Dies dient der Übergabe von Optionen an \fBxz\fP, wenn es nicht möglich ist,
+die Optionen direkt in der Befehlszeile von \fBxz\fP zu übergeben. Dies ist der
+Fall, wenn \fBxz\fP von einem Skript oder Dienstprogramm ausgeführt wird, zum
+Beispiel GNU \fBtar\fP(1):
+.RS
+.RS
+.PP
+.nf
+\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR
+.fi
+.RE
+.RE
+.IP ""
+Skripte können \fBXZ_OPT\fP zum Beispiel zum Setzen skriptspezifischer
+Standard\-Kompressionsoptionen verwenden. Es ist weiterhin empfehlenswert,
+Benutzern die Außerkraftsetzung von \fBXZ_OPT\fP zu erlauben, falls dies
+angemessen ist. Zum Beispiel könnte in \fBsh\fP(1)\-Skripten Folgendes stehen:
+.RS
+.RS
+.PP
+.nf
+\f(CRXZ_OPT=${XZ_OPT\-"\-7e"}
+export XZ_OPT\fR
+.fi
+.RE
+.RE
+.
+.SH "KOMPATIBILITÄT ZU DEN LZMA\-UTILS"
+Die Befehlszeilensyntax von \fBxz\fP ist praktisch eine Obermenge der von
+\fBlzma\fP, \fBunlzma\fP und \fBlzcat\fP in den LZMA\-Utils der Versionen 4.32.x. In
+den meisten Fällen sollte es möglich sein, die LZMA\-Utils durch die XZ\-Utils
+zu ersetzen, ohne vorhandene Skripte ändern zu müssen. Dennoch gibt es
+einige Inkompatibilitäten, die manchmal Probleme verursachen können.
+.
+.SS "Voreinstellungsstufen zur Kompression"
+Die Nummerierung der Voreinstellungsstufen der Kompression ist in \fBxz\fP und
+den LZMA\-Utils unterschiedlich. Der wichtigste Unterschied ist die Zuweisung
+der Wörterbuchgrößen zu den verschiedenen Voreinstellungsstufen. Die
+Wörterbuchgröße ist etwa gleich dem Speicherbedarf bei der Dekompression.
+.RS
+.PP
+.TS
+tab(;);
+c c c
+c n n.
+Stufe;xz;LZMA\-Utils
+\-0;256 KiB;nicht verfügbar
+\-1;1 MiB;64 KiB
+\-2;2 MiB;1 MiB
+\-3;4 MiB;512 KiB
+\-4;4 MiB;1 MiB
+\-5;8 MiB;2 MiB
+\-6;8 MiB;4 MiB
+\-7;16 MiB;8 MiB
+\-8;32 MiB;16 MiB
+\-9;64 MiB;32 MiB
+.TE
+.RE
+.PP
+Die Unterschiede in der Wörterbuchgröße beeinflussen auch den Speicherbedarf
+bei der Kompression, aber es gibt noch einige andere Unterschiede zwischen
+den LZMA\-Utils und den XZ\-Utils, die die Kluft noch vergrößern:
+.RS
+.PP
+.TS
+tab(;);
+c c c
+c n n.
+Stufe;xz;LZMA\-Utils 4.32.x
+\-0;3 MiB;nicht verfügbar
+\-1;9 MiB;2 MiB
+\-2;17 MiB;12 MiB
+\-3;32 MiB;12 MiB
+\-4;48 MiB;16 MiB
+\-5;94 MiB;26 MiB
+\-6;94 MiB;45 MiB
+\-7;186 MiB;83 MiB
+\-8;370 MiB;159 MiB
+\-9;674 MiB;311 MiB
+.TE
+.RE
+.PP
+Die standardmäßige Voreinstellungsstufe in den LZMA\-Utils ist \fB\-7\fP, während
+diese in den XZ\-Utils \fB\-6\fP ist, daher verwenden beide standardmäßig ein 8
+MiB großes Wörterbuch.
+.
+.SS "Vor\- und Nachteile von .lzma\-Dateien als Datenströme"
+Die unkomprimierte Größe der Datei kann in den \fB.lzma\fP\-Headern gespeichert
+werden. Die LZMA\-Utils tun das beim Komprimieren gewöhnlicher Dateien. Als
+Alternative kann die unkomprimierte Größe als unbekannt markiert und eine
+Nutzdatenende\-Markierung (end\-of\-payload) verwendet werden, um anzugeben, wo
+der Dekompressor stoppen soll. Die LZMA\-Utils verwenden diese Methode, wenn
+die unkomprimierte Größe unbekannt ist, was beispielsweise in Pipes
+(Befehlsverkettungen) der Fall ist.
+.PP
+\fBxz\fP unterstützt die Dekompression von \fB.lzma\fP\-Dateien mit oder ohne
+Nutzdatenende\-Markierung, aber alle von \fBxz\fP erstellten \fB.lzma\fP\-Dateien
+verwenden diesen Nutzdatenende\-Markierung, wobei die unkomprimierte Größe in
+den \fB.lzma\fP\-Headern als unbekannt markiert wird. Das könnte in einigen
+unüblichen Situationen ein Problem sein. Zum Beispiel könnte ein
+\&\fB.lzma\fP\-Dekompressor in einem Gerät mit eingebettetem System nur mit
+Dateien funktionieren, deren unkomprimierte Größe bekannt ist. Falls Sie auf
+dieses Problem stoßen, müssen Sie die LZMA\-Utils oder das LZMA\-SDK
+verwenden, um \fB.lzma\fP\-Dateien mit bekannter unkomprimierter Größe zu
+erzeugen.
+.
+.SS "Nicht unterstützte .lzma\-Dateien"
+Das \fB.lzma\fP\-Format erlaubt \fIlc\fP\-Werte bis zu 8 und \fIlp\fP\-Werte bis zu
+4. Die LZMA\-Utils können Dateien mit beliebigem \fIlc\fP und \fIlp\fP
+dekomprimieren, aber erzeugen immer Dateien mit \fBlc=3\fP und \fBlp=0\fP. Das
+Erzeugen von Dateien mit anderem \fIlc\fP und \fIlp\fP ist mit \fBxz\fP und mit dem
+LZMA\-SDK möglich.
+.PP
+Die Implementation des LZMA\-Filters in liblzma setzt voraus, dass die Summe
+von \fIlc\fP und \fIlp\fP nicht größer als 4 ist. Daher können \fB.lzma\fP\-Dateien,
+welche diese Begrenzung überschreiten, mit \fBxz\fP nicht dekomprimiert werden.
+.PP
+Die LZMA\-Utils erzeugen nur \fB.lzma\fP\-Dateien mit einer Wörterbuchgröße von
+2^\fIn\fP (einer Zweierpotenz), aber akzeptieren Dateien mit einer beliebigen
+Wörterbuchgröße. Liblzma akzeptiert nur \fB.lzma\fP\-Dateien mit einer
+Wörterbuchgröße von 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1). Dies dient zum
+Verringern von Fehlalarmen beim Erkennen von \fB.lzma\fP\-Dateien.
+.PP
+Diese Einschränkungen sollten in der Praxis kein Problem sein, da praktisch
+alle \fB.lzma\fP\-Dateien mit Einstellungen komprimiert wurden, die Liblzma
+akzeptieren wird.
+.
+.SS "Angehängter Datenmüll"
+Bei der Dekompression ignorieren die LZMA\-Utils stillschweigend alles nach
+dem ersten \fB.lzma\fP\-Datenstrom. In den meisten Situationen ist das ein
+Fehler. Das bedeutet auch, dass die LZMA\-Utils die Dekompression verketteter
+\&\fB.lzma\fP\-Dateien nicht unterstützen.
+.PP
+Wenn nach dem ersten \fB.lzma\fP\-Datenstrom Daten verbleiben, erachtet \fBxz\fP
+die Datei als beschädigt, es sei denn, die Option \fB\-\-single\-stream\fP wurde
+verwendet. Dies könnte die Ausführung von Skripten beeinflussen, die davon
+ausgehen, dass angehängter Datenmüll ignoriert wird.
+.
+.SH ANMERKUNGEN
+.
+.SS "Die komprimierte Ausgabe kann variieren"
+Die exakte komprimierte Ausgabe, die aus der gleichen unkomprimierten
+Eingabedatei erzeugt wird, kann zwischen den Versionen der XZ\-Utils
+unterschiedlich sein, selbst wenn die Kompressionsoptionen identisch
+sind. Das kommt daher, weil der Kodierer verbessert worden sein könnte
+(hinsichtlich schnellerer oder besserer Kompression), ohne das Dateiformat
+zu beeinflussen. Die Ausgabe kann sogar zwischen verschiedenen Programmen
+der gleichen Version der XZ\-Utils variieren, wenn bei der Erstellung des
+Binärprogramms unterschiedliche Optionen verwendet wurden.
+.PP
+Sobald \fB\-\-rsyncable\fP implementiert wurde, bedeutet das, dass die sich
+ergebenden Dateien nicht notwendigerweise mit Rsync abgeglichen werden
+können, außer wenn die alte und neue Datei mit der gleichen \fBxz\fP\-Version
+erzeugt wurden. Das Problem kann beseitigt werden, wenn ein Teil der
+Encoder\-Implementierung eingefroren wird, um die mit Rsync abgleichbare
+Ausgabe über \fBxz\fP\-Versionsgrenzen hinweg stabil zu halten.
+.
+.SS "Eingebettete .xz\-Dekompressoren"
+Eingebettete \fB.xz\fP\-Dekompressor\-Implementierungen wie XZ Embedded
+unterstützen nicht unbedingt Dateien, die mit anderen Integritätsprüfungen
+(\fIPrüfung\fP\-Typen) als \fBnone\fP und \fBcrc32\fP erzeugt wurden. Da
+\fB\-\-check=crc64\fP die Voreinstellung ist, müssen Sie \fB\-\-check=none\fP oder
+\fB\-\-check=crc32\fP verwenden, wenn Sie Dateien für eingebettete Systeme
+erstellen.
+.PP
+Außerhalb eingebetteter Systeme unterstützen die Dekompressoren des
+\&\fB.xz\fP\-Formats alle \fIPrüfung\fP\-Typen oder sind mindestens in der Lage, die
+Datei zu dekomprimieren, ohne deren Integrität zu prüfen, wenn die bestimmte
+\fIPrüfung\fP nicht verfügbar ist.
+.PP
+XZ Embedded unterstützt BCJ\-Filter, aber nur mit dem vorgegebenen
+Startversatz.
+.
+.SH BEISPIELE
+.
+.SS Grundlagen
+Komprimiert die Datei \fIfoo\fP mit der Standard\-Kompressionsstufe (\fB\-6\fP) zu
+\fIfoo.xz\fP und entfernt \fIfoo\fP nach erfolgreicher Kompression:
+.RS
+.PP
+.nf
+\f(CRxz foo\fR
+.fi
+.RE
+.PP
+\fIbar.xz\fP in \fIbar\fP dekomprimieren und \fIbar.xz\fP selbst dann nicht löschen,
+wenn die Dekompression erfolgreich war:
+.RS
+.PP
+.nf
+\f(CRxz \-dk bar.xz\fR
+.fi
+.RE
+.PP
+\fIbaz.tar.xz\fP mit der Voreinstellung \fB\-4e\fP (\fB\-4 \-\-extreme\fP) erzeugen, was
+langsamer ist als die Vorgabe \fB\-6\fP, aber weniger Speicher für Kompression
+und Dekompression benötigt (48\ MiB beziehungsweise 5\ MiB):
+.RS
+.PP
+.nf
+\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR
+.fi
+.RE
+.PP
+Eine Mischung aus komprimierten und unkomprimierten Dateien kann mit einem
+einzelnen Befehl dekomprimiert in die Standardausgabe geschrieben werden:
+.RS
+.PP
+.nf
+\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR
+.fi
+.RE
+.
+.SS "Parallele Kompression von vielen Dateien"
+Auf GNU\- und *BSD\-Systemen können \fBfind\fP(1) und \fBxargs\fP(1) zum
+Parallelisieren der Kompression vieler Dateien verwendet werden:
+.RS
+.PP
+.nf
+\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e
+    | xargs \-0r \-P4 \-n16 xz \-T1\fR
+.fi
+.RE
+.PP
+Die Option \fB\-P\fP von \fBxargs\fP(1) legt die Anzahl der parallelen
+\fBxz\fP\-Prozesse fest. Der beste Wert für die Option \fB\-n\fP hängt davon ab, wie
+viele Dateien komprimiert werden sollen. Wenn es sich nur um wenige Dateien
+handelt, sollte der Wert wahrscheinlich 1 sein; bei Zehntausenden von
+Dateien kann 100 oder noch mehr angemessener sein, um die Anzahl der
+\fBxz\fP\-Prozesse zu beschränken, die \fBxargs\fP(1) schließlich erzeugen wird.
+.PP
+Die Option \fB\-T1\fP für \fBxz\fP dient dazu, den Einzelthread\-Modus zu erzwingen,
+da \fBxargs\fP(1) zur Steuerung des Umfangs der Parallelisierung verwendet
+wird.
+.
+.SS Roboter\-Modus
+Berechnen, wie viel Byte nach der Kompression mehrerer Dateien insgesamt
+eingespart wurden:
+.RS
+.PP
+.nf
+\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR
+.fi
+.RE
+.PP
+Ein Skript könnte abfragen wollen, ob es ein \fBxz\fP verwendet, das aktuell
+genug ist. Das folgende \fBsh\fP(1)\-Skript prüft, ob die Versionsnummer des
+Dienstprogramms \fBxz\fP mindestens 5.0.0 ist. Diese Methode ist zu alten
+Beta\-Versionen kompatibel, welche die Option \fB\-\-robot\fP nicht unterstützen:
+.RS
+.PP
+.nf
+\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" ||
+        [ "$XZ_VERSION" \-lt 50000002 ]; then
+    echo "Your xz is too old."
+fi
+unset XZ_VERSION LIBLZMA_VERSION\fR
+.fi
+.RE
+.PP
+Eine Speicherbedarfsbegrenzung für die Dekompression mit \fBXZ_OPT\fP setzen,
+aber eine bereits gesetzte Begrenzung nicht erhöhen:
+.RS
+.PP
+.nf
+\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB
+OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3)
+if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then
+    XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM"
+    export XZ_OPT
+fi\fR
+.fi
+.RE
+.
+.SS "Benutzerdefinierte Filterketten für die Kompression"
+Der einfachste Anwendungsfall für benutzerdefinierte Filterketten ist die
+Anpassung von LZMA2\-Voreinstellungsstufen. Das kann nützlich sein, weil die
+Voreinstellungen nur einen Teil der potenziell sinnvollen Kombinationen aus
+Kompressionseinstellungen abdecken.
+.PP
+Die KompCPU\-Spalten der Tabellen aus den Beschreibungen der Optionen \fB\-0\fP …
+\fB\-9\fP und \fB\-\-extreme\fP sind beim Anpassen der LZMA2\-Voreinstellungen
+nützlich. Diese sind die relevanten Teile aus diesen zwei Tabellen:
+.RS
+.PP
+.TS
+tab(;);
+c c
+n n.
+Voreinst.;KomprCPU
+\-0;0
+\-1;1
+\-2;2
+\-3;3
+\-4;4
+\-5;5
+\-6;6
+\-5e;7
+\-6e;8
+.TE
+.RE
+.PP
+Wenn Sie wissen, dass eine Datei für eine gute Kompression ein etwas
+größeres Wörterbuch benötigt (zum Beispiel 32 MiB), aber Sie sie schneller
+komprimieren wollen, als dies mit \fBxz \-8\fP geschehen würde, kann eine
+Voreinstellung mit einem niedrigen KompCPU\-Wert (zum Beispiel 1) dahingehend
+angepasst werden, ein größeres Wörterbuch zu verwenden:
+.RS
+.PP
+.nf
+\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR
+.fi
+.RE
+.PP
+Mit bestimmten Dateien kann der obige Befehl schneller sein als \fBxz \-6\fP,
+wobei die Kompression deutlich besser wird. Dennoch muss betont werden, dass
+nur wenige Dateien von einem größeren Wörterbuch profitieren, wenn der
+KompCPU\-Wert niedrig bleibt. Der offensichtlichste Fall, in dem ein größeres
+Wörterbuch  sehr hilfreich sein kann, ist ein Archiv, das einander sehr
+ähnliche Dateien enthält, die jeweils wenigstens einige Megabyte groß
+sind. Das Wörterbuch muss dann deutlich größer sein als die einzelne Datei,
+damit LZMA2 den größtmöglichen Vorteil aus den Ähnlichkeiten der aufeinander
+folgenden Dateien zieht.
+.PP
+Wenn hoher Speicherbedarf für Kompression und Dekompression kein Problem ist
+und die zu komprimierende Datei mindestens einige Hundert Megabyte groß ist,
+kann es sinnvoll sein, ein noch größeres Wörterbuch zu verwenden, als die 64
+MiB, die mit \fBxz \-9\fP verwendet werden würden:
+.RS
+.PP
+.nf
+\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR
+.fi
+.RE
+.PP
+Die Verwendung von \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) wie im obigen Beispiel
+kann nützlich sein, um den Speicherbedarf für Kompressor und Dekompressor zu
+sehen. Denken Sie daran, dass ein Wörterbuch, das größer als die
+unkomprimierte Datei ist, Speicherverschwendung wäre. Daher ist der obige
+Befehl für kleine Dateien nicht sinnvoll.
+.PP
+Manchmal spielt die Kompressionszeit keine Rolle, aber der Speicherbedarf
+bei der Dekompression muss gering gehalten werden, zum Beispiel um die Datei
+auf eingebetteten Systemen dekomprimieren zu können. Der folgende Befehl
+verwendet \fB\-6e\fP (\fB\-6 \-\-extreme\fP) als Basis und setzt die Wörterbuchgröße
+auf nur 64\ KiB. Die sich ergebende Datei kann mit XZ Embedded (aus diesem
+Grund ist dort \fB\-\-check=crc32\fP) mit nur etwa 100\ KiB Speicher
+dekomprimiert werden.
+.RS
+.PP
+.nf
+\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR
+.fi
+.RE
+.PP
+Wenn Sie so viele Byte wie möglich herausquetschen wollen, kann die
+Anpassung der Anzahl der literalen Kontextbits (\fIlc\fP) und der Anzahl der
+Positionsbits (\fIpb\fP) manchmal hilfreich sein. Auch die Anpassung der Anzahl
+der literalen Positionsbits (\fIlp\fP) könnte helfen, aber üblicherweise sind
+\fIlc\fP und \fIpb\fP wichtiger. Wenn ein Quellcode\-Archiv zum Beispiel
+hauptsächlich ASCII\-Text enthält, könnte ein Aufruf wie der folgende eine
+etwas kleinere Datei (etwa 0,1\ %) ergeben als mit \fBxz \-6e\fP (versuchen Sie
+es auch \fBlc=4\fP):
+.RS
+.PP
+.nf
+\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR
+.fi
+.RE
+.PP
+Die Verwendung eines anderen Filters mit LZMA2 kann die Kompression bei
+verschiedenen Dateitypen verbessern. So könnten Sie eine gemeinsam genutzte
+Bibliothek der Architekturen x86\-32 oder x86\-64 mit dem BCJ\-Filter für x86
+komprimieren:
+.RS
+.PP
+.nf
+\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR
+.fi
+.RE
+.PP
+Beachten Sie, dass die Reihenfolge der Filteroptionen von Bedeutung
+ist. Falls \fB\-\-x86\fP nach \fB\-\-lzma2\fP angegeben wird, gibt \fBxz\fP einen Fehler
+aus, weil nach LZMA2 kein weiterer Filter sein darf und auch weil der
+BCJ\-Filter für x86 nicht als letzter Filter in der Filterkette gesetzt
+werden darf.
+.PP
+Der Delta\-Filter zusammen mit LZMA2 kann bei Bitmap\-Bildern gute Ergebnisse
+liefern. Er sollte üblicherweise besser sein als PNG, welches zwar einige
+fortgeschrittene Filter als ein simples delta bietet, aber für die
+eigentliche Kompression »Deflate« verwendet.
+.PP
+Das Bild muss in einem unkomprimierten Format gespeichert werden, zum
+Beispiel als unkomprimiertes TIFF. Der Abstandsparameter des Delta\-Filters
+muss so gesetzt werden, dass er der Anzahl der Bytes pro Pixel im Bild
+entspricht. Zum Beispiel erfordert ein 24\-Bit\-RGB\-Bitmap \fBdist=3\fP, außerdem
+ist es gut, \fBpb=0\fP an LZMA2 zu übergeben, um die 3\-Byte\-Ausrichtung zu
+berücksichtigen:
+.RS
+.PP
+.nf
+\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR
+.fi
+.RE
+.PP
+Wenn sich mehrere Bilder in einem einzelnen Archiv befinden (zum Beispiel\&
+\&\fB.tar\fP), funktioniert der Delta\-Filter damit auch, sofern alle Bilder im
+Archiv die gleiche Anzahl Bytes pro Pixel haben.
+.
+.SH "SIEHE AUCH"
+\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1),
+\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1)
+.PP
+XZ Utils: <https://tukaani.org/xz/>
+.br
+XZ Embedded: <https://tukaani.org/xz/embedded.html>
+.br
+LZMA\-SDK: <https://7\-zip.org/sdk.html>

janus/share/man/ko/man1/lzcmp.1

@@ -0,0 +1,51 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\" (Note that this file is not based on gzip's zdiff.1.)
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZDIFF 1 2024\-02\-13 Tukaani "XZ 유틸리티"
+.SH 이름
+xzcmp, xzdiff, lzcmp, lzdiff \- 압축 파일을 비교합니다
+.
+.SH 요약
+\fBxzcmp\fP [\fI<옵션>...\fP] \fI<파일1>\fP [\fI<파일2>\fP]
+.br
+\fBxzdiff\fP \&...
+.br
+\fBlzcmp\fP \&...
+.br
+\fBlzdiff\fP \&...
+.
+.SH 설명
+\fBxzcmp\fP 와 \fBxzdiff\fP 명령은 압축 해제한 두 파일의 내용을 비교합니다.  압축 해제한 파일의 데이터와 옵션은
+\fB\-\-help\fP 옵션 또는 \fB\-\-version\fP 옵션을 지정하지 않는다면, \fBcmp\fP(1)  또는   \fBdiff\fP(1) 명령으로
+전달합니다.
+.PP
+\fI<파일1>\fP 과 \fI<파일2>\fP를 모두 지정했다면, 지정한 파일은 이미 압축해제한 파일이거나,
+\fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1) 명령으로
+압축해제할 수 있는 형식의 파일일 수 있습니다.  필요한 압축 해제 명령은 \fI<파일1>\fP 과
+\fI<파일2>\fP의 파일 이름 확장자로 결정합니다.  알 수 없는 확장자를 지닌 파일은 이미 압축을 해제했거나
+\fBxz\fP(1) 명령으로 압축 해제할 수 있는 형식으로 간주합니다.
+.PP
+파일 이름을 하나만 지정한다면, \fI<파일1>\fP의 확장자는 지원 압축 형식의 확장자여야 하며,
+\fI<파일2>\fP는 \fI<파일1>\fP에서 압축 파일 확장자를 제거한 파일로 간주합니다.
+.PP
+\fBlzcmp\fP와 \fBlzdiff\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다.
+.
+.SH "종료 상태"
+압축 해제 오류가 나타나는 경우, 종료 코드는 \fB2\fP입니다.  그렇지 않을 경우 \fBcmp\fP(1)  또는 \fBdiff\fP(1) 명령의
+종료 코드를 활용합니다.
+.
+.SH "추가 참조"
+\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1),
+\fBzstd\fP(1), \fBlz4\fP(1)

janus/share/man/ko/man1/lzdiff.1

@@ -0,0 +1,51 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\" (Note that this file is not based on gzip's zdiff.1.)
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZDIFF 1 2024\-02\-13 Tukaani "XZ 유틸리티"
+.SH 이름
+xzcmp, xzdiff, lzcmp, lzdiff \- 압축 파일을 비교합니다
+.
+.SH 요약
+\fBxzcmp\fP [\fI<옵션>...\fP] \fI<파일1>\fP [\fI<파일2>\fP]
+.br
+\fBxzdiff\fP \&...
+.br
+\fBlzcmp\fP \&...
+.br
+\fBlzdiff\fP \&...
+.
+.SH 설명
+\fBxzcmp\fP 와 \fBxzdiff\fP 명령은 압축 해제한 두 파일의 내용을 비교합니다.  압축 해제한 파일의 데이터와 옵션은
+\fB\-\-help\fP 옵션 또는 \fB\-\-version\fP 옵션을 지정하지 않는다면, \fBcmp\fP(1)  또는   \fBdiff\fP(1) 명령으로
+전달합니다.
+.PP
+\fI<파일1>\fP 과 \fI<파일2>\fP를 모두 지정했다면, 지정한 파일은 이미 압축해제한 파일이거나,
+\fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1) 명령으로
+압축해제할 수 있는 형식의 파일일 수 있습니다.  필요한 압축 해제 명령은 \fI<파일1>\fP 과
+\fI<파일2>\fP의 파일 이름 확장자로 결정합니다.  알 수 없는 확장자를 지닌 파일은 이미 압축을 해제했거나
+\fBxz\fP(1) 명령으로 압축 해제할 수 있는 형식으로 간주합니다.
+.PP
+파일 이름을 하나만 지정한다면, \fI<파일1>\fP의 확장자는 지원 압축 형식의 확장자여야 하며,
+\fI<파일2>\fP는 \fI<파일1>\fP에서 압축 파일 확장자를 제거한 파일로 간주합니다.
+.PP
+\fBlzcmp\fP와 \fBlzdiff\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다.
+.
+.SH "종료 상태"
+압축 해제 오류가 나타나는 경우, 종료 코드는 \fB2\fP입니다.  그렇지 않을 경우 \fBcmp\fP(1)  또는 \fBdiff\fP(1) 명령의
+종료 코드를 활용합니다.
+.
+.SH "추가 참조"
+\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1),
+\fBzstd\fP(1), \fBlz4\fP(1)

janus/share/man/ko/man1/lzegrep.1

@@ -0,0 +1,84 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\" (Note that this file is not based on gzip's zgrep.1.)
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZGREP 1 2024\-02\-13 Tukaani "XZ 유틸리티"
+.SH 이름
+xzgrep \- 패턴을 활용하여 가능한 방식으로 압축한 파일의 내용을 검색합니다
+.
+.SH 요약
+\fBxzgrep\fP [\fI<옵션>...\fP] [\fI<패턴목록>\fP] [\fI<파일>...\fP]
+.br
+\fBxzegrep\fP \&...
+.br
+\fBxzfgrep\fP \&...
+.br
+\fBlzgrep\fP \&...
+.br
+\fBlzegrep\fP \&...
+.br
+\fBlzfgrep\fP \&...
+.
+.SH 설명
+\fBxzgrep\fP은 압축 해제한 파일의 내용에 \fBgrep\fP(1)을 실행합니다.  \fI<파일>\fP 형식은 파일 이름 확장으로
+결정합니다.  \fI<파일>\fP에서 지원하는 확장자는 \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1),
+\fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1)로 압축 해제할 수 있는 파일의 확장자입니다. 다른 파일은 이미 압축을 해제한
+파일로 간주합니다.
+.PP
+지정한 \fI<파일>\fP이 없거나 \fI<파일>\fP 값이 \fB\-\fP이라면 표준 입력을 읽어들입니다.  표준 입력을
+읽어들일 때, \fBxz\fP(1) 방식으로 압축을 해제하는 파일만 지원합니다.  다른 파일은 이미 압축을 해제한 파일로 간주합니다.
+.PP
+대부분의 \fBgrep\fP(1)의 \fI<옵션>\fP을 지원합니다.  그러나 다음 옵션은 지원하지 않습니다:
+.IP "" 4
+\fB\-r\fP, \fB\-\-recursive\fP
+.IP "" 4
+\fB\-R\fP, \fB\-\-dereference\-recursive\fP
+.IP "" 4
+\fB\-d\fP, \fB\-\-directories=\fP\fIaction\fP
+.IP "" 4
+\fB\-Z\fP, \fB\-\-null\fP
+.IP "" 4
+\fB\-z\fP, \fB\-\-null\-data\fP
+.IP "" 4
+\fB\-\-include=\fP\fIglob\fP
+.IP "" 4
+\fB\-\-exclude=\fP\fIglob\fP
+.IP "" 4
+\fB\-\-exclude\-from=\fP\fIfile\fP
+.IP "" 4
+\fB\-\-exclude\-dir=\fP\fIglob\fP
+.PP
+\fBxzegrep\fP은 \fBxzgrep \-E\fP 명령의 별칭입니다.  \fBxzfgrep\fP은 \fBxzgrep \-F\fP 명령의 별칭입니다.
+.PP
+\fBlzgrep\fP, \fBlzegrep\fP, \fBlzfgrep\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다.
+.
+.SH "종료 상태"
+.TP 
+0
+최소한 하나 이상의 파일에서 하나 이상의 일치하는 결과를 찾았습니다.  오류가 없습니다.
+.TP 
+1
+어떤 입력 파일에서든 일치하는 내용이 없습니다.  오류가 없습니다.
+.TP 
+>1
+하나 이상의 오류가 나타납니다.  일치하는 항목을 찾아낼 지 여부는 알 수 없습니다.
+.
+.SH 환경
+.TP 
+\fBGREP\fP
+\fBGREP\fP 환경변수 값이 비어있지 않으면, \fBgrep\fP, \fBgrep \-E\fP, \fBgrep \-F\fP 명령 대신 활용합니다.
+.
+.SH "추가 참조"
+\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1),
+\fBlz4\fP(1), \fBzgrep\fP(1)

janus/share/man/ko/man1/lzgrep.1

@@ -0,0 +1,84 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\" (Note that this file is not based on gzip's zgrep.1.)
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZGREP 1 2024\-02\-13 Tukaani "XZ 유틸리티"
+.SH 이름
+xzgrep \- 패턴을 활용하여 가능한 방식으로 압축한 파일의 내용을 검색합니다
+.
+.SH 요약
+\fBxzgrep\fP [\fI<옵션>...\fP] [\fI<패턴목록>\fP] [\fI<파일>...\fP]
+.br
+\fBxzegrep\fP \&...
+.br
+\fBxzfgrep\fP \&...
+.br
+\fBlzgrep\fP \&...
+.br
+\fBlzegrep\fP \&...
+.br
+\fBlzfgrep\fP \&...
+.
+.SH 설명
+\fBxzgrep\fP은 압축 해제한 파일의 내용에 \fBgrep\fP(1)을 실행합니다.  \fI<파일>\fP 형식은 파일 이름 확장으로
+결정합니다.  \fI<파일>\fP에서 지원하는 확장자는 \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1),
+\fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1)로 압축 해제할 수 있는 파일의 확장자입니다. 다른 파일은 이미 압축을 해제한
+파일로 간주합니다.
+.PP
+지정한 \fI<파일>\fP이 없거나 \fI<파일>\fP 값이 \fB\-\fP이라면 표준 입력을 읽어들입니다.  표준 입력을
+읽어들일 때, \fBxz\fP(1) 방식으로 압축을 해제하는 파일만 지원합니다.  다른 파일은 이미 압축을 해제한 파일로 간주합니다.
+.PP
+대부분의 \fBgrep\fP(1)의 \fI<옵션>\fP을 지원합니다.  그러나 다음 옵션은 지원하지 않습니다:
+.IP "" 4
+\fB\-r\fP, \fB\-\-recursive\fP
+.IP "" 4
+\fB\-R\fP, \fB\-\-dereference\-recursive\fP
+.IP "" 4
+\fB\-d\fP, \fB\-\-directories=\fP\fIaction\fP
+.IP "" 4
+\fB\-Z\fP, \fB\-\-null\fP
+.IP "" 4
+\fB\-z\fP, \fB\-\-null\-data\fP
+.IP "" 4
+\fB\-\-include=\fP\fIglob\fP
+.IP "" 4
+\fB\-\-exclude=\fP\fIglob\fP
+.IP "" 4
+\fB\-\-exclude\-from=\fP\fIfile\fP
+.IP "" 4
+\fB\-\-exclude\-dir=\fP\fIglob\fP
+.PP
+\fBxzegrep\fP은 \fBxzgrep \-E\fP 명령의 별칭입니다.  \fBxzfgrep\fP은 \fBxzgrep \-F\fP 명령의 별칭입니다.
+.PP
+\fBlzgrep\fP, \fBlzegrep\fP, \fBlzfgrep\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다.
+.
+.SH "종료 상태"
+.TP 
+0
+최소한 하나 이상의 파일에서 하나 이상의 일치하는 결과를 찾았습니다.  오류가 없습니다.
+.TP 
+1
+어떤 입력 파일에서든 일치하는 내용이 없습니다.  오류가 없습니다.
+.TP 
+>1
+하나 이상의 오류가 나타납니다.  일치하는 항목을 찾아낼 지 여부는 알 수 없습니다.
+.
+.SH 환경
+.TP 
+\fBGREP\fP
+\fBGREP\fP 환경변수 값이 비어있지 않으면, \fBgrep\fP, \fBgrep \-E\fP, \fBgrep \-F\fP 명령 대신 활용합니다.
+.
+.SH "추가 참조"
+\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1),
+\fBlz4\fP(1), \fBzgrep\fP(1)

janus/share/man/ko/man1/lzless.1

@@ -0,0 +1,41 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Andrew Dudman
+.\"          Lasse Collin
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\" (Note that this file is not based on gzip's zless.1.)
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZLESS 1 2024\-02\-12 Tukaani "XZ 유틸리티"
+.SH 이름
+xzless, lzless \- xz 또는 lzma 압축 (텍스트) 파일을 봅니다
+.SH 요약
+\fBxzless\fP [\fI<파일>\fP...]
+.br
+\fBlzless\fP [\fI<파일>\fP...]
+.SH 설명
+\fBxzless\fP는 압축 파일 내용을 터미널에 나타내는 필터 프로그램입니다.  \fBxz\fP(1) 방식으로 압축을 해제하는 파일만
+지원합니다.  다른 파일은 이미 압축을 해제한 파일로 간주합니다.  주어진 \fI<파일>\fP 값이 없다면, \fBxzless\fP는
+표준 입력을 읽어들입니다.
+.PP
+\fBxzless\fP 는 \fBless\fP(1)  를 사용하여 출력을 막습니다.  \fBxzmore\fP  와는 다르게, 환경 변수 설정으로 선택한
+페이저를 바꿀 수 없습니다.  명령은 \fBmore\fP(1)  와 \fBvi\fP(1)  가 기반이며, 앞뒤로 움직이고 검색할 수 있습니다.
+자세한 정보는 \fBless\fP(1)  설명서를 참고하십시오.
+.PP
+\fBlzless\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다.
+.SH 환경
+.TP 
+\fBLESSMETACHARS\fP
+셸에서 동작할 수도 있는 특수 문자 목록입니다.  환경에 미리 설정해두지 않았다면 \fBxzless\fP에서 설정합니다.
+.TP 
+\fBLESSOPEN\fP
+입력 파일을 \fBless\fP(1)  에 전달하기 전에 \fBxz\fP(1)  압축 해제 프로그램을 실행해서 미리 처리하는 명령행을 설정합니다.
+.SH "추가 참조"
+\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1)

janus/share/man/ko/man1/lzmadec.1

@@ -0,0 +1,72 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Author: Lasse Collin
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZDEC 1 2024\-04\-08 Tukaani "XZ 유틸리티"
+.SH 이름
+xzdec, lzmadec \- .xz와 .lzma용 작은 압축 해제 프로그램
+.SH 요약
+\fBxzdec\fP [\f\fI옵션\fP...\fP] [\fI<파일>...\fP]
+.br
+\fBlzmadec\fP [\f\fI옵션\fP...\fP] [\fI<파일>...\fP]
+.SH 설명
+\fBxzdec\fP은 liblzma 기반 \fB.xz\fP (그리고 \fB.xz\fP 확장자만) 파일 압축 해제 전용 도구 프로그램입니다.
+\fBxzdec\fP 은 \fBxz\fP(1)  명령을 활용하여 \fB.xz\fP 파일의 압축을 해제할 때 쓰던 \fBxz \-\-decompress \-\-stdout\fP (그리고 일반적으로 쓰던 몇가지 다른 옵션도 같이) 명령을 작성하던 일상적인 경우를 대신하려 만든 결과물입니다.
+\fBlzmadec\fP 는 \fB.xz\fP 파일 대신 \fB.lzma\fP 파일을 지원하는 점만 다르며, 나머지는 \fBxzdec\fP과 동일합니다.
+.PP
+실행 파일 크기를 줄이려는 목적으로, \fBxzdec\fP 에서는 다중\-스레드 실행 또는 현지 언어 표기를 지원하지 않으며
+\fBXZ_DEFAULTS\fP 환경 변수와 \fBXZ_OPT\fP 환경 변수의 옵션 값을 읽지 않습니다.  \fBxzdec\fP은 단계별 진행 정보를
+표시하지 않습니다. \fBxzdec\fP 명령어로 \fBSIGINFO\fP 시그널을 보내면 아무 동작도 취하지 않지만, \fBSIGUSR1\fP 시그널을
+보내면 프 정보를 표시하는 대신 프로세스를 끝냅니다.
+.SH 옵션
+.TP 
+\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP
+\fBxz\fP(1)  호환성을 문제로 무시합니다.  \fBxzdec\fP은 압축 해제 기능만 지원합니다.
+.TP 
+\fB\-k\fP, \fB\-\-keep\fP
+\fBxz\fP(1)  호환성을 문제로 무시합니다.  \fBxzdec\fP은 어떤 파일도 만들거나 제거하지 않습니다.
+.TP 
+\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP
+\fBxz\fP(1)  호환성을 문제로 무시합니다.  \fBxzdec\fP은 항상 압축 해제한 데이터를 표준 출력으로만 기록합니다.
+.TP 
+\fB\-q\fP, \fB\-\-quiet\fP
+이 옵션을 한번 지정하면 \fBxzdec\fP에서 어떤 경고나 알림을 표시하지 않기 때문에 아무런 동작도 취하지 않습니다.  오류 메시지를
+표시하지 않으려면 이 옵션을 두번 지정하십시오.
+.TP 
+\fB\-Q\fP, \fB\-\-no\-warn\fP
+\fBxz\fP(1)  호환성을 문제로 무시합니다.  \fBxzdec\fP은 종료 코드 2번을 사용하지 않습니다.
+.TP 
+\fB\-h\fP, \fB\-\-help\fP
+도움말 메시지를 나타내고 무사히 나갑니다.
+.TP 
+\fB\-V\fP, \fB\-\-version\fP
+\fBxzdec\fP과 liblzma의 버전 번호를 나타냅니다.
+.SH "종료 상태"
+.TP 
+\fB0\fP
+모든 상태 양호.
+.TP 
+\fB1\fP
+오류 발생.
+.PP
+\fBxzdec\fP 은 \fBxz\fP에 있는 경고 메시지를 출력하지 않기 때문에 \fBxzdec\fP 에서는 종료 코드 2번을 사용하지 않습니다.
+.SH 참고
+보통 매일 사용하실 목적이라면 \fBxzdec\fP 또는 \fBlzmadec\fP 대신 \fBxz\fP 명령을 사용하십시오.  \fBxzdec\fP 또는
+\fBlzmadec\fP은 완전한 기능을 갖춘 \fBxz\fP(1) 보다는 작은 압축 해제 프로그램을 사용해야 할 경우에만 사용하라고 있는
+명령입니다.
+.PP
+\fBxzdec\fP 과 \fBlzmadec\fP  은 실제로 그렇게 작은건 아닙니다.  컴파일 시간에 liblzma에서 얼마나 기능을 떨궈내느냐에
+따라 더 줄어들 수도 있습니다만, 보통 임베디드 운영체제 배포판이 아닌 경우는 이렇게 할 수가 없습니다.  실제로 작은 \fB.xz\fP 압축
+해제 프로그램이 필요하다면 XZ 임베디드 사용을 고려하십시오.
+.SH "추가 참조"
+\fBxz\fP(1)
+.PP
+XZ 임베디드: <https://tukaani.org/xz/embedded/>

janus/share/man/ko/man1/lzmainfo.1

@@ -0,0 +1,38 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Author: Lasse Collin
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH LZMAINFO 1 2013\-06\-30 Tukaani "XZ 유틸리티"
+.SH 이름
+lzmainfo \- .lzma 파일 헤더에 들어있는 정보를 보여줍니다
+.SH 요약
+\fBlzmainfo\fP [\fB\-\-help\fP] [\fB\-\-version\fP] [\fI<파일>...\fP]
+.SH 설명
+\fBlzmainfo\fP 는 \fB.lzma\fP 파일 헤더에 들어있는 정보를 보여줍니다.  지정 \fI<파일>\fP에서 13바이트를
+우선 읽어 헤더를 디코딩한 후, 가독 형식으로 표준 출력에 보여줍니다.  \fI<파일>\fP을 지정하지 않거나
+\fI<파일>\fP 값이 \fI\-\fP 이면 표준 입력을 읽습니다.
+.PP
+보통 대부분 관심있는 정보는 압축 해제 용량과 딕서너리 크기입니다.  압축 해제 용량의 경우 파일이 비스트림 \fB.lzma\fP 형식 계열인
+경우에만 나타납니다.  파일 압축 해제 필요 메모리 용량은 수십 킬로바이트에 딕셔너리 크기를 합친 값입니다.
+.PP
+\fBlzmainfo\fP 는 LZMA 유틸리티 하위 호환성을 목적으로 XZ 유틸리티에 기본으로 들어있습니다.
+.SH "종료 상태"
+.TP 
+\fB0\fP
+모든 상태 양호.
+.TP 
+\fB1\fP
+오류 발생.
+.SH 버그
+\fBlzmainfo\fP 프로그램은 \fBMiB\fP (2^20 바이트) 용량 단위인데 (실제로) \fBMB\fP를 사용합니다.  LZMA 유틸리티
+출력 호환 유지가 목적입니다.
+.SH "추가 참조"
+\fBxz\fP(1)

janus/share/man/ko/man1/lzmore.1

@@ -0,0 +1,42 @@
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Andrew Dudman
+.\"          Lasse Collin
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.)
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZMORE 1 2024\-02\-12 Tukaani "XZ 유틸리티"
+.SH 이름
+xzmore, lzmore \- xz 압축 (텍스트) 파일 또는 lzma 압축 (텍스트) 파일을 봅니다
+.
+.SH 요약
+\fBxzmore\fP [\fI<파일>\fP...]
+.br
+\fBlzmore\fP [\fI<파일>\fP...]
+.
+.SH 설명
+\fBxzmore\fP 명령은 압축 파일에 들어있는 텍스트를 \fBmore\fP(1) 명령으로 터미널에 나타냅니다.  \fBxz\fP(1) 방식으로
+압축을 해제하는 파일만 지원합니다.  다른 파일은 이미 압축을 해제한 파일로 간주합니다.  \fI<파일>\fP을 지정하지
+않으면, \fBxzmore\fP 프로그램에서는 표준 입력을 읽어들입니다.  키보드 명령 정보는 \fBmore\fP(1)  설명서를 참고하십시오.
+.PP
+참고로 \fBmore\fP(1) 명령 구현체에 따라 반대 방향(윗방향)으로의 스크롤은 못할 수도 있습니다.  \fBxzmore\fP 명령이
+\fBmore\fP(1) 명령에 압축 해제한 데이터를 파이프로 전달하기 때문입니다.  \fBxzless\fP(1)는   좀 더 나은 기능을 가진
+\fBless\fP(1) 명령을 활용합니다.
+.PP
+\fBlzmore\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다.
+.
+.SH 환경
+.TP 
+\fBPAGER\fP
+\fBPAGER\fP 환경변수 값을 설정했다면 \fBmore\fP(1) 대신 해당 환경변수 값을 사용합니다.
+.
+.SH "추가 참조"
+\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1)

janus/share/man/ko/man1/unlzma.1

@@ -0,0 +1,1548 @@
+'\" t
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZ 1 2024\-12\-30 Tukaani "XZ 유틸리티"
+.
+.SH 이름
+xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz 파일과 .lzma 파일을 압축 또는 압축 해제합니다
+.
+.SH 요약
+\fBxz\fP [\fI<옵션>...\fP] [\fI<파일>...\fP]
+.
+.SH "명령 별칭"
+\fBunxz\fP 명령은 \fBxz \-\-decompress\fP 명령과 동일합니다.
+.br
+\fBxzcat\fP 명령은 \fBxz \-\-decompress \-\-stdout\fP 명령과 동일합니다.
+.br
+\fBlzma\fP 명령은 \fBxz \-\-format=lzma\fP 명령과 동일합니다.
+.br
+\fBunlzma\fP 명령은 \fBxz \-\-format=lzma \-\-decompress\fP 명령과 동일합니다.
+.br
+\fBlzcat\fP 명령은 \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP 명령과 동일합니다.
+.PP
+파일 압축을 해제해야 하는 셸 스크립트를 작성할 때, \fBunxz\fP 와 \fBxzcat\fP 이름 대신 \fBxz\fP 명령과 적절한 인자
+값(\fBxz \-d\fP 또는 \fBxz \-dc\fP)의 사용을 추천드립니다.
+.
+.SH 설명
+\fBxz\fP는 \fBgzip\fP(1)  과 \fBbzip2\fP(1)  과 비슷한 명령행 문법을 지닌 범용 데이터 압축 도구입니다.  자체 파일
+형식은 \fB.xz\fP 형식이나, LZMA 유틸리티에서 사용하는 예전 \fB.lzma\fP 형식과 형식 헤더가 없는 RAW 압축 스트림도
+지원합니다.  게다가, \fBlzip\fP에서 활용하는 \fB.lz\fP 형식 압축 해제도 지원합니다.
+.PP
+각 \fI파일\fP 에 대한 \fBxz\fP 압축 또는 압축 해제는 선택 동작 모드에 따릅니다.  \fI<파일>\fP 값이 주어졌거나
+\fI<파일>\fP 값이 \fB\-\fP이면, \fBxz\fP 명령에서 표준 입력을 읽고 처리한 데이터를 표준 출력에 기록합니다.
+\fBxz\fP 에서는 터미널에서 활용할 경우 압축 데이터를 표준 압축으로 기록하는 동작을 거절(오류를 출력하고 \fI<파일>\fP을
+건너뜀)합니다.  이와 비슷하게, \fBxz\fP 유틸리티를 터미널에서 실행하면 표준 입력의 압축 데이터 읽기를 거절합니다.
+.PP
+\fB\-\-stdout\fP 을 지정하지 않는 한, \fB\-\fP가 아닌 \fI<파일>\fP을 원본 \fI<파일>\fP 이름에서
+가져온 새 파일 이름으로 기록합니다:
+.IP \(bu 3
+압축할 때, 대상 파일 형식의 접미사(\fB.xz\fP or \fB.lzma\fP)  는 원본 파일 이름 뒤에 붙어 대상 파일이름이 됩니다.
+.IP \(bu 3
+압축 해제할 때, \fB.xz\fP, \fB.lzma\fP, \fB.lz\fP 접미사를 파일 이름에서 제거하고 대상 파일 이름을 알아냅니다.
+\fBxz\fP에서는 \fB.txz\fP, \fB.tlz\fP 접미사도 인식하며, \fB.tar\fP 접미사로 치환합니다.
+.PP
+대상 파일이 이미 있으면, 오류를 나타내고 \fI<파일>\fP을 건너뜁니다.
+.PP
+표준 출력으로 기록하기 전에는, \fBxz\fP는 경고를 나타내며, 다음 조건에 만족할 경우 \fI<파일>\fP을 건너뜁니다:
+.IP \(bu 3
+\fI<파일>\fP이 일반 파일이 아닐 때.  심볼릭 링크는 따라가지 않기에, 일반 파일로 간주하지 않습니다.
+.IP \(bu 3
+\fI<파일>\fP이 하나 이상의 하드 링크일 떄.
+.IP \(bu 3
+\fI<파일>\fP에 setuid, setgid, 끈적이 비트 집합이 붙어있을 떄.
+.IP \(bu 3
+동작 모드를 압축으로 설정하고, \fI<파일>\fP은 대상 파일 형식의 접미사를 이미 붙였을 때(\fB.xz\fP 형식으로 압축하면
+\&\fB.xz\fP 또는 \fB.txz\fP, \fB.lzma\fP 형식으로 압축하면 \fB.lzma\fP 또는 \fB.tlz\fP).
+.IP \(bu 3
+동작 모드를 압축 해제로 설정하고, \fI<파일>\fP에 지원 파일 형식 접미사(\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP,
+\&\fB.tlz\fP, \fB.lz\fP)를 붙이지 않았을 때.
+.PP
+\fI<파일>\fP 의 압축 또는 압축 해제를 성공하고 나면, \fBxz\fP는 소유자, 소유그룹, 권한, 접근 시각, 수정 시각
+정보를 원본 \fI<파일>\fP에서 대상 파일로 그대로 복사합니다.  그룹 정보 복사에 실패하면, 권한을 수정하여 원본
+\fI<파일>\fP에 접근 권한이 없는 사용자가 대상 파일로 접근하지 못하게 합니다.  \fBxz\fP는 아직 접근 제어 목록이나
+확장 속성 등의 기타 메타데이터를 복사하는 기능은 지원하지 않습니다.
+.PP
+대상 파일을 온전히 닫고 나면, \fB\-\-keep\fP 옵션을 지원하지 않았을 경우 원본 \fI<파일>\fP을 제거합니다.  원본
+\fI<파일>\fP은 출력을 표준 출력으로 기록했거나 오류가 발생했을 경우 제거하지 않습니다.
+.PP
+\fBxz\fP 프로세스에 \fBSIGINFO\fP 시그널 또는 \fBSIGUSR1\fP 시그널을 보내면 표준 출력으로 진행 정보를 출력합니다.  표준
+오류가 터미널일 경우일 경우에만 제한하며 \fB\-\-verbose\fP 옵션을 지정하면 진행 표시줄을 자동으로 나타냅니다.
+.
+.SS "메모리 사용"
+\fBxz\fP 메모리 사용은 수백 킬로바이트로 시작하여 수 기가바이트까지 압축 설정에 따라 다릅니다.  압축 해제 프로그램이 필요로 하는
+메모리 공간을 결정하는 파일 압축시에 설정 값을 활용합니다.  보통 압축 해제 프로그램은 파일을 만들 때, 압축 프로그램 메모리 사용량의
+5% 에서 20% 정도 필요합니다.  예를 들면, \fBxz \-9\fP로 압축한 파일 압축 해제시 현재 65MiB 메모리 용량이 필요합니다.
+여전하게도, 압축 해제시 수 기가 바이트의 메모리가 필요한 \fB.xz\fP 파일에도 가능한 이야기입니다.
+.PP
+특히 이전 시스템 사용자의 경우 메모리 사용량이 엄청나게 늘어나는 점에 짜증이 날 수 있습니다.  이런 불편한 상황을 피하기 위해,
+\fBxz\fP에 기본적으로 비활성 상태인 내장 메모리 사용 제한 기능을 넣었습니다.  일부 운영체제에서 처리 중 메모리 사용을 제한하는
+수단을 제공하긴 하지만, 여기에 의지하기에는 충분히 유연하지 않습니다(예를 들면, \fBulimit\fP(1)을 사용하면 가상 메모리를
+제한하여  \fBmmap\fP(2)을 먹통으로 만듭니다).
+.PP
+메모리 사용 제한 기능은 \fB\-\-memlimit=\fP\fI<제한용량>\fP 명령행 옵션으로 사용할 수 있습니다.  종종
+\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP와 같이 \fBXZ_DEFAULTS\fP 환경 변수를 설정하여 제한 기능을 켜는게 더
+편합니다.  \fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션과
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP 옵션을 활용하여 압축 및 압축 해제시 별도로 한계 값을
+설정할 수 있습니다.  이 두 가지 옵션의 \fBXZ_DEFAULTS\fP 환경 변수 밖에서의 사용은, \fBxz\fP를 단일 실행할 때 압축 및
+압축 해제 동작을 동시에 수행하지 않으며, 앞서 언급한 두가지 옵션을 명령행에 입력하기에는
+\fB\-\-memlimit=\fP\fI<제한용량>\fP(또는 \fB\-M\fP \fI<제한용량>\fP)이 더 짧기 때문에 별로 쓸모가
+없습니다.
+.PP
+압축 해제시 메모리 사용 제한 지정 한계를 초과하면, \fBxz\fP 유틸리티에서 오류를 나타내며 파일 압축 해제는 실패합니다.  압축을
+실행할 때 사용 제한 지정 한계를 넘어서면 \fBxz\fP에서는 설정 값을 줄여서 어쨌든 한계를 넘지 못하게
+합니다(\fB\-\-format=raw\fP 옵션 또는 \fB\-\-no\-adjust\fP 옵션 사용시 제외).  설정 한계 값이 엄청 작지 않은 이상 이
+방식대로 처리하면 어쨌든 실패하지 않습니다.  설정 값조정은 압축 래벨 사전 설정과 일치하지 않을 때 단계적으로 진행하는데, 이를테면,
+\fBxz \-9\fP 명령 수행에 필요한 양보다 한계 값이 약간 작으면, 설정 값을 \fBxz \-8\fP에 못미치게 약간 줄여서 진행합니다.
+.
+.SS ".xz 파일 결합 및 패딩"
+\&\fB.xz\fP 파일을 있는 그대로 합칠 수 있습니다.  \fBxz\fP는 \fB.xz\fP 파일을 단독 파일일 때 처럼 압축해제합니다.
+.PP
+결합 부분과 마지막 부분 뒤에 패딩을 추가할 수 있습니다.  패딩은 널 바이트로 구성해야 하며 패딩 길이는 4바이트로 구성해야 합니다.
+512 바이트 블록으로 파일 크기를 이루는 매체에 \fB.xz\fP 파일을 저장했을 경우에 요긴할 수 있습니다.
+.PP
+\&\fB.lzma\fP 파일 또는 원시 스트림의 경우 결합과 패딩을 허용하지 않습니다.
+.
+.SH 옵션
+.
+.SS "정수 접두사와 별도 값"
+정수 인자값이 필요한 대부분 위치에서는, 큰 정수값을 나타내기 쉽게 하도록 추가 접미사를 지원합니다.  정수와 접미사 사이에 어떤 공백이
+있으면 안됩니다.
+.TP 
+\fBKiB\fP
+1,024 (2^10) 배수 정수값. \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, \fBKB\fP 단위를 \fBKiB\fP 동의어로 받아들입니다.
+.TP 
+\fBMiB\fP
+1,048,576 (2^20) 배수 정수값. \fBMi\fP, \fBm\fP, \fBM\fP, \fBMB\fP 단위를 \fBMiB\fP 동의어로 받아들입니다.
+.TP 
+\fBGiB\fP
+1,073,741,824 (2^30) 배수 정수값.  \fBGi\fP, \fBg\fP, \fBG\fP, \fBGB\fP 단위를 \fBGiB\fP 동의어로
+받아들입니다.
+.PP
+특수 값 \fBmax\fP는 옵션에서 지원하는 정수 최대 값을 나타낼 때 사용할 수 있습니다.
+.
+.SS "동작 모드"
+여러 동작 모드를 보여드리겠습니다만, 마지막에 주어진 동작 모드로 동작합니다.
+.TP 
+\fB\-z\fP, \fB\-\-compress\fP
+압축합니다.  어떤 동작 모드 옵션도 지정하지 않고 다른 동작 모드를 명령행에 따로 지정하지 않았다면 이 동작 모드는 기본입니다(예:
+\fBunxz\fP 는 \fB\-\-decompress\fP를 암시).
+.IP ""
+.\" The DESCRIPTION section already says this but it's good to repeat it
+.\" here because the default behavior is a bit dangerous and new users
+.\" in a hurry may skip reading the DESCRIPTION section.
+After successful compression, the source file is removed unless writing to
+standard output or \fB\-\-keep\fP was specified.
+.TP 
+\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP
+.\" The DESCRIPTION section already says this but it's good to repeat it
+.\" here because the default behavior is a bit dangerous and new users
+.\" in a hurry may skip reading the DESCRIPTION section.
+Decompress.  After successful decompression, the source file is removed
+unless writing to standard output or \fB\-\-keep\fP was specified.
+.TP 
+\fB\-t\fP, \fB\-\-test\fP
+압축 \fI<파일>\fP의 무결성을 시험해봅니다.  이 옵션은 압축 해제 데이터를 표준 출력으로 기록하는 대신 버린다는 점을
+제외하고 \fB\-\-decompress \-\-stdout\fP과 동일합니다.  어떤 파일도 만들거나 제거하지 않습니다.
+.TP 
+\fB\-l\fP, \fB\-\-list\fP
+압축 \fI<파일>\fP 정보를 출력합니다.  압축 해제 출력을 내보내지 않으며, 어떤 파일도 만들거나 제거하지 않습니다.  이
+조회 모드에서, 프로그램은 표준 입력 또는 기타 탐색 불가능한 원본에서 압축 데이터를 읽을 수 없습니다.
+.IP ""
+\fI<파일>\fP 기본 정보를 파일 당 한 줄 씩 기본으로 보여줍니다.  더 자세한 정보를 보려면 \fB\-\-verbose\fP
+옵션을 사용하십시오.  더 자세한 정보는 \fB\-\-verbose\fP 옵션을 두번 사용하면 되지만, 추가 정보를 더 많이 가져오면서 탐색
+횟수가 늘어나는 문제로 인해 느려질 수 있습니다.  세부 출력 너비는 80 문자를 초과하며, 예를 들어 출력을 파이핑한다면, 터미널이
+충분히 너비가 넓지 못할 경우 \fBless\ \-S\fP 명령이 편리할 수 있습니다.
+.IP ""
+정확한 출력은 \fBxz\fP 버전과 다른 로캘에 따라 바뀔 수 있습니다.  기계 판독용 출력시 \fB\-\-robot \-\-list\fP 옵션을
+사용합니다.
+.
+.SS "동작 수정자"
+.TP 
+\fB\-k\fP, \fB\-\-keep\fP
+입력 파일을 삭제하지 않습니다.
+.IP ""
+\fBxz\fP 5.2.6 부터는 이 옵션으로 입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid,
+setgid, 끈적이 비트 세트를 설정한 상태라도 압축하거나 압축을 풀 수 있습니다. setuid, setgid, 끈적이 비트는 대상
+파일에 복사하지 않습니다.  이전 버전에서는 \fB\-\-force\fP 옵션을 지정했을 때만 가능했습니다.
+.TP 
+\fB\-f\fP, \fB\-\-force\fP
+이 옵션은 몇가지 동작에 영향을 줍니다:
+.RS
+.IP \(bu 3
+대상 파일이 이미 있으면, 압축 또는 압축 해제 전 삭제합니다.
+.IP \(bu 3
+입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, setgid, 끈적이 비트 세트를 설정한
+상태라도 압축 또는 압축 해제를 진행합니다.  setuid, setgid, 끈적이 비트는 대상 파일에 복사하지 않습니다.
+.IP \(bu 3
+\fB\-\-decompress\fP \fB\-\-stdout\fP 옵션을 같이 사용하는 상황에서 \fBxz\fP 명령이 원본 파일의 형식을 알아내지 못할 때,
+원본 파일의 사본을 표준 출력으로 보냅니다.  이렇게 하면 \fBxzcat\fP \fB\-\-force\fP 명령을 \fBxz\fP 명령으로 압축하지 않은
+파일에 대해 \fBcat\fP(1) 을 사용하는 것처럼 사용할 수 있습니다.  참고로 나중에, \fBxz\fP에서 \fBxz\fP로 하여금 여러 형식의
+파일을 표준 출력으로 복사하는 대신 압축을 해제하도록 새 압축 파일 형식을 지원할 예정입니다.
+\fB\-\-format=\fP\fI<형식>\fP 옵션은 \fBxz\fP 명령에 단일 파일 형식만 압축 해제하도록 제한할 때 사용할 수
+있습니다.
+.RE
+.TP 
+\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP
+파일 대신 표준 출력으로 압축 또는 압축 해제한 데이터를 기록합니다.  \fB\-\-keep\fP를 생략했습니다.
+.TP 
+\fB\-\-single\-stream\fP
+처음 \fB.xz\fP 스트림만 압축 해제하며, 스트림에 뒤따라오는 나머지 입력 데이터는 조용히 무시합니다.  보통 뒤따라오는 쓰레기 값에
+대해서는 \fBxz\fP 에서 오류를 나타냅니다.
+.IP ""
+\fBxz\fP는 \fB.lzma\fP 파일 또는 원시 스트림에서 온 하나 이상의 스트림에 대해 압축 해제동작을 취하지 않지만, 이 옵션을 사용하면
+\fBxz\fP에서 \fB.lzma\fP 파일 또는 원시 스트림을 처리한 다음에 뒤따라오는 데이터를 무시하도록 합니다.
+.IP ""
+이 옵션은 동작 모드가 \fB\-\-decompress\fP 또는 \fB\-\-test\fP가 아니면 동작에 아무런 영향을 주지 않습니다.
+.TP 
+\fB\-\-no\-sparse\fP
+희소 파일을 만들지 않습니다.  기본적으로 일반 파일로 압축 해제할 경우 \fBxz\fP 에서는 압축 해제한 파일에 이진 0값이 길게 늘어질
+경우 희소 배열 파일을 만들려고 합니다.  표준 출력의 내용 길이만큼 연결한 일반 파일로 기록할 때도 동작하며 희소 파일을 만드는 동안
+아무런 ��제가 나타나지 않게 각각의 추가 조건을 만족합니다.  희소 파일을 만들면 디스크 공간을 절약할 수 있으며 디스크 입출력을 줄여
+압축 해제 속도를 올릴 수 있습니다.
+.TP 
+\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP
+압축할 때, 대상 파일의 접두사를 \fB.xz\fP 또는 \fB.lzma\fP 대신 \fI.suf\fP로 사용하십시오.  표준 출력으로 기록하지 않고
+원본 파일에 \fI.suf\fP 접두사가 붙어있으면, 경고를 나타내고 해당 파일을 건너뜁니다.
+.IP ""
+압축 해제할 때, \fI.suf\fP 접미사로 파일을 인식하기도 하고, \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP,
+\&\fB.lz\fP 접미사가 붙은 파일도 인식합니다.  원본 파일에 \fI.suf\fP 접미사가 붙어있으면, 해당 접미사를 제거하여 대상 파일 이름을
+알아냅니다.
+.IP ""
+원시 스트림 압축 및 압축 해제시(\fB\-\-format=raw\fP) 원시 스트림에 기본 접미사가 없기 때문에, 표준 출력으로 기록하지 않는
+한 접미사를 반드시 지정해야 합니다.
+.TP 
+\fB\-\-files\fP[\fB=\fP\fI<파일>\fP]
+\fI<파일>\fP에서 처리할 파일 이름을 읽습니다. \fI<파일>\fP을 생략하면 파일 이름은 표준 입력에서
+불러옵니다.  파일 이름은 개행 문자로 끝나야 합니다.  대시 문자(\fB\-\fP)는 일반 파일 이름으로 취급하며 표준 입력을 의미하지
+않습니다.  파일 이름을 명령행 인자로 지정하면, \fI<파일>\fP에서 파일 이름을 읽어들이기 전 해당 명령행 인자를 먼저
+처리합니다.
+.TP 
+\fB\-\-files0\fP[\fB=\fP\fI<파일>\fP]
+각 파일 이름이 널 문자로 끝나야 한다는 점만 제외하면 \fB\-\-files\fP[\fB=\fP\fI<파일>\fP] 옵션과 동일합니다.
+.
+.SS "기본 파일 형식 및 압축 옵션"
+.TP 
+\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fI<형식>\fP
+압축 또는 압축해제 파일 \fI<형식>\fP을 지정합니다:
+.RS
+.TP 
+\fBauto\fP
+기본 값입니다.  압축할 때, \fBauto\fP는 \fBxz\fP의 기본 동작과 동일합니다.  압축을 해제할 때, 입력 파일 형식을 자동으로
+찾습니다.  참고로 원시 스트림(\fB\-\-format=raw\fP)의 경우 자동으로 찾을 수 없습니다.
+.TP 
+\fBxz\fP
+\&\fB.xz\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.xz\fP 파일만 받아들입니다.
+.TP 
+\fBlzma\fP, \fBalone\fP
+이전 \fB.lzma\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.lzma\fP 파일만 받아들입니다.  \fBalone\fP 대체 명령은 LZMA
+유틸리티 하위 호환성을 목적으로 제공합니다.
+.TP 
+\fBlzip\fP
+압축 해제시 \fB.lz\fP 파일만 받아들입니다.  압축은 지원하지 않습니다.
+.IP ""
+\&\fB.lz\fP 형식 버전 0과 비확장 버전 1을 지원합니다.  버전 0파일은 \fBlzip\fP 1.3 이전에서만 만듭니다.  일반적이진 않지만
+일부 파일의 경우 이 형식과 관련된 원본 패키지로 보관한 파일을 찾을 수도 있습니다.  개인적으로 이 형식으로 압축한 오래된 개인 파일을
+가지고 있을 수도 있습니다.  형식 버전 0 압축 해제 지원은 \fBlzip\fP 1.18에서 제거했습니다.
+.IP ""
+\fBlzip\fP 1.4 이상에서는 버전 1형식의 파일을 만듭니다.  형식 버전 1로의 동기화 제거 마커 확장은 \fBlzip\fP 1.6에
+추가했습니다.  이 확장은 거의 쓰지 않으며 \fBxz\fP 에서 조차도 지원하지 않습니다(손상된 입력 파일로 진단함).
+.TP 
+\fBraw\fP
+원시 스트림으로 압축하거나 압축을 해제합니다(헤더 없음).  고급 사용자 전용입니다.  원시 스트림을 디코딩하려면,
+\fB\-\-format=raw\fP 옵션을 사용하고 분명하게 필터 체인을 지정하여 컨테이너 헤더에 필요한 정보를 저장하게 끔 해야합니다.
+.RE
+.TP 
+\fB\-C\fP \fI<검사방식>\fP, \fB\-\-check=\fP\fI<검사방식>\fP
+무결성 검사 방식을 지정합니다.  검사 방식은 \fB.xz\fP 파일에 저장하며 압축 해제 데이터를 계산합니다.  이 옵션은 \fB.xz\fP
+형식으로 압축할 때만 효력이 있습니다: \fB.lzma\fP 형식은 무결성 겁사를 지원하지 않습니다.  무결성 검사는 \fB.xz\fP 파일 압축을
+풀었을 때에 검사합니다.
+.IP ""
+지원 \fI검사\fP 형식:
+.RS
+.TP 
+\fBnone\fP
+어떤 경우에도 무결성 검사 계산을 수행하지 않습니다.  보통 바람직하지 못한 생각입니다.  데이터 무결성을 다른 방식으로라도 검증해야
+하는 상황이면 쓸만할 수 있습니다.
+.TP 
+\fBcrc32\fP
+IEEE\-802.3 (이더넷)의 다항 연산으로 CRC32를 계산합니다.
+.TP 
+\fBcrc64\fP
+ECMA\-182의 다항식 연산으로 CRC64를 계산합니다.  이 동작이 기본 동작이기 때문에 CRC32가 깨진 파일을 찾을 때보다는 좀
+낮은 편이며 속도 차이도 거의 없습니다.
+.TP 
+\fBsha256\fP
+SHA\-256 해시를 계산합니다.  CRC32와 CRC64 보다는 좀 느립니다.
+.RE
+.IP ""
+\&\fB.xz\fP 헤더 무결성은 항상 CRC32로 검증하빈다.  이를 바꾸거나 It is not possible to change or
+disable it.
+.TP 
+\fB\-\-ignore\-check\fP
+압축 데이터를 압축해제할 경우 압축 데이터의 무결성 검증을 진행하지 않습니다.  \fB.xz\fP 헤더의 CRC32 값은 그래도 여전히 보통
+방식으로 검증합니다.
+.IP ""
+\fB이 옵션이 정확히 무슨 동작을 하는지 알기 전에는 사용하지 마십시오.\fP 이 옵션을 사용하는 타당한 이유로:
+.RS
+.IP \(bu 3
+깨진 .xz 파일에서 데이터 복구를 시도합니다.
+.IP \(bu 3
+압축 해제 속도를 늘립니다.  SHA\-256 또는 압축 파일에 들어간 그 무언가를 엄청 빨리 처리합니다.  다른 방식으로 파일 무결성을
+검증해야 하는 목적이 아니라면 이 옵션을 사용하지 않는게 좋습니다.
+.RE
+.TP 
+\fB\-0\fP ... \fB\-9\fP
+압축 사전 설정 수준을 선택합니다.  기본값은 \fB\-6\fP입니다.  다중 수준을 지정하면 가장 마지막 수준 옵션을 적용합니다.  개별 필터
+체인을 이미 지정했다면, 압축 사전 설정 수준 값을 설정할 때 개별 필터 체인을 정리합니다.
+.IP ""
+사전 설정간 차이는 \fBgzip\fP(1)과 \fBbzip2\fP(1)을 사용할 때보다 더 비중을 차지합니다.  선택한 압축 설정은 압축 해제시
+필요한 메모리 사용량을 셜정하므로 사전 설정 수준 값을 너무 높게 지정하면 RAM 용량이 적은 오래된 시스템에서 파일 압축 해제시 실패할
+수 있습니다.  게다가, \fBgzip\fP(1)  과 \fBbzip2\fP(1)에서 처럼 종종 \fB모든 동작에 \-9를 몰래 활용하는건 바람직하지 않습니다\fP.
+.RS
+.TP 
+\fB\-0\fP ... \fB\-3\fP
+동작이 빠른 사전 설정 부류입니다. \fB\-0\fP은 때로는 \fBgzip \-9\fP 명령보다 압축율이 훨씬 우수하면서도 더 빠릅니다.  더 큰
+값은 보통 \fBbzip2\fP(1) 명령과 비교했을 떄 압축 결과가 압축 데이터에 따라 달라지더라도, 비교할 법한 속도 또는 더 나은
+압축율을 보입니다.
+.TP 
+\fB\-4\fP ... \fB\-6\fP
+오래된 시스템에서 조차도 압축 해제 프로그램의 적절한 메모리 사용량을 보이면서 양호하거나 최적의 압축율을 보여줍니다.  \fB\-6\fP 옵션은
+압축 해제시 메모리 사용량이 16MiB 밖에 안되기 때문에 파일을 배포할 때 최적의 선택인 기본 값입니다.  (\fB\-5e\fP 또는
+\fB\-6e\fP도 역시 고려할 만합니다.  \fB\-\-extreme\fP을 참고하십시오.)
+.TP 
+\fB\-7 ... \-9\fP
+\fB\-6\fP과 비슷하지만 압축 및 압축 해제시 요구 메모리 사용량이 더 높습니다.  압축 파일이 각각 8MiB, 16MiB, 32MiB
+보다 클 경우에만 쓸만한 옵션입니다.
+.RE
+.IP ""
+동일한 하드웨어에서, 압축 해제 속도는 압축한 데이터의 초당 정적 바이트 처리 수의 어림 평균입니다.  다시 말해, 압축율을 더 올리면,
+압축 해제 속도도 역시 올라갑니다.  이는 곧 초당 비압축 데이터 출력 양이 달라질 수 있단 뜻입니다.
+.IP ""
+다음 표에 사전 설정 기능을 정리했습니다:
+.RS
+.RS
+.PP
+.TS
+tab(;);
+c c c c c
+n n n n n.
+Preset;DictSize;CompCPU;CompMem;DecMem
+\-0;256 KiB;0;3 MiB;1 MiB
+\-1;1 MiB;1;9 MiB;2 MiB
+\-2;2 MiB;2;17 MiB;3 MiB
+\-3;4 MiB;3;32 MiB;5 MiB
+\-4;4 MiB;4;48 MiB;5 MiB
+\-5;8 MiB;5;94 MiB;9 MiB
+\-6;8 MiB;6;94 MiB;9 MiB
+\-7;16 MiB;6;186 MiB;17 MiB
+\-8;32 MiB;6;370 MiB;33 MiB
+\-9;64 MiB;6;674 MiB;65 MiB
+.TE
+.RE
+.RE
+.IP ""
+컬럼 설명:
+.RS
+.IP \(bu 3
+DictSize는 LZMA2 딕셔너리 크기입니다.  압축 해제 파일의 크기보다 딕셔너리에서 사용하는 낭비 메모리 용량입니다.  실제로
+필요하지 않은 \fB\-7\fP ... \fB\-9\fP 사전 설정값을 피해야 하는 적절한 이유이기도 합니다.  \fB\-6\fP 이하에서는 소모 메모리 양이
+충분히 적거나 따로 신경쓸 필요가 없습니다.
+.IP \(bu 3
+CompCPU는 압축 속도에 영향을 주는 LZMA2 설정의 단순화 표기 값입니다.  딕셔너리 크기는 속도에도 영향을 주기 때문에
+CompCPU는 \fB\-6\fP ... \fB\-9\fP 수준값과 동일한데, 고수준 값은 여전히 조금 더 느려질 수 있습니다.  느려지는 만큼
+압축율은 가능한 한 더 좋아집니다. \fB\-\-extreme\fP을 참고하십시오.
+.IP \(bu 3
+CompMem은 단일\-스레드 모드에서 필요한 압축 프로그램의 메모리 점유 용량입니다.  \fBxz\fP 버전에 따라 다를 수 있습니다.
+.IP \(bu 3
+DecMem은 압축 해제 프로그램의 메모리 점유용량입니다.  이는 곧, 압축 해제 프로그램에서 필요한 메모리 사용량을 압축 설정에서
+결정한다는 의미가 들어있습니다.  정확한 압축 해제 프로그램의 메모리 사용량은 LZMA2 딕셔너리 크기 보다는 조금 많지만 테이블의 값은
+MiB 용량으로 완전히 반올림한 값입니다.
+.RE
+.IP ""
+다중\-스레드 모드에서 필요한 메모리 용량은 단일\-스레드 모드보단 약간 더 많습니다.  \fB\-\-block\-size\fP 기본값에 따라, 각
+스레드에서는 3*3*딕셔녀리_크기 + 압축시_메모리용량 또는 압축_해제시_메모리용량 정도가 필요합니다.  예를 들면, 스레드 넷에 사전
+설정 옵션 \fB\-6\fP을 사용한다면, 660\(en670 MiB 메모리 용량이 필요합니다.
+.TP 
+\fB\-e\fP, \fB\-\-extreme\fP
+기대하는 만큼의 좀 더 나은 압축율을 확보하려 선택한 압축 사전 설정 수준의 느린 변형 옵션을 사용하지만, 재수 없는 와중에 골로 가는
+경우가 생기기도 합니다.  압축 해제 프로그램의 메모리 사용에는 영향을 주지 않지만, 압축 프로그램의 메모리 사용량은 \fB\-0\fP
+\&... \fB\-3\fP 사전 설정 수준에서 약간 더 올라갈 뿐입니다.
+.IP ""
+4MiB와 8MiB 두 가지 딕셔너리 용량 설정이 있기 때문에 \fB\-3e\fP 와 \fB\-5e\fP 사전 설정을 (CompCPU 수치를 낮춰서)
+각각 \fB\-4e\fP 와 \fB\-6e\fP 보다 약간 더 빠르게 설정할 수 있습니다.  이런 식으로 두 사전 설정이 동일하지 않습니다.
+.RS
+.RS
+.PP
+.TS
+tab(;);
+c c c c c
+n n n n n.
+Preset;DictSize;CompCPU;CompMem;DecMem
+\-0e;256 KiB;8;4 MiB;1 MiB
+\-1e;1 MiB;8;13 MiB;2 MiB
+\-2e;2 MiB;8;25 MiB;3 MiB
+\-3e;4 MiB;7;48 MiB;5 MiB
+\-4e;4 MiB;8;48 MiB;5 MiB
+\-5e;8 MiB;7;94 MiB;9 MiB
+\-6e;8 MiB;8;94 MiB;9 MiB
+\-7e;16 MiB;8;186 MiB;17 MiB
+\-8e;32 MiB;8;370 MiB;33 MiB
+\-9e;64 MiB;8;674 MiB;65 MiB
+.TE
+.RE
+.RE
+.IP ""
+예를 들면, 8MiB 딕셔너리를 활용하는 네가지 사전 설정이 있다고 할 때, 빠른 순으로 설정을 나열하자면, \fB\-5\fP, \fB\-6\fP,
+\fB\-5e\fP, \fB\-6e\fP 입니다.
+.TP 
+\fB\-\-fast\fP
+.PD 0
+.TP 
+\fB\-\-best\fP
+.PD
+이 옵션은 \fB\-0\fP 과 \fB\-9\fP의 별칭으로 각각 오해할 수 있습니다. LZMA 유틸리티의 하위 호환성을 목적으로 제공합니다.  이
+옵션 사용은 피하십시오.
+.TP 
+\fB\-\-block\-size=\fP\fI<크기>\fP
+\&\fB.xz\fP 형식으로 압축할 때, 입력 데이터를 \fI<크기>\fP 바이트 블록으로 입력 데이터를 쪼갭니다.  각각의 블록은
+다중\-스레드 방식으로 처리할 수 있고 임의 접근 압축 해제 가능성을 제한할 수 있게 개별적으로 압축 처리합니다.  이 옵션은 보통
+다중\-스레드 모드에서 기본 블록 크기를 지정할 때 사용하지만, 단일\-스레드 모드에서도 사용할 수 있습니다.
+.IP ""
+다중\-스레드 모드에서는 약 3배 용량의 \fI<크기>\fP 바이트만큼 각 스레드 별로 입출력 버퍼링용 공간을 할당합니다.  기본
+\fI<크기>\fP는 LZMA2 딕셔너리 크기 또는 1MiB 중 가장 큰 쪽의 세 배입니다.  보통 적절한 값으로 LZMA2
+딕셔너리 크기 또는 최소한 1MiB 용량의 2\(en4배입니다.  LZMA2 딕셔너리 크기보다 작은 \fI<크기>\fP는 램의
+소모적 사용 공간으로 할당하는데 LZMA2 딕셔너리 버퍼를 할당한 용량 크기 전체를 다 사용하지 않기 때문입니다.  다중\-스레드 모드에서
+블록 크기는 블록 헤더에 저장하며, 이 크기 정보는 다중\-스레드 압축 해제시 필요합니다.
+.IP ""
+단일\-스레드 모드에서는 기본적으로 블록 쪼개기를 하지 않습니다.  이 옵션을 설정한다고 해서 메모리 사용에 영향을 주지는 않습니다.
+블록 헤더에 크기 정보를 저장하지 않기 때문에 단일\-스레드 모드에서 만든 파일은 다중\-스레드 모드에서 만든 파일과 동일하지 않습니다.
+크기 정보의 누락은 또한 \fBxz\fP에서 다중\-스레드 모드로 압축 해제를 진행할 수 없음을 의미하기도 합니다.
+.TP 
+\fB\-\-block\-list=\fP\fI<항목>\fP
+\&\fB.xz\fP 형식으로 압축할 때, 압축하지 않은 데이터로 부터 일정 간격 이후에 새 블록 처리를 시작합니다.
+.IP ""
+\fI<항목>\fP은 쉼표로 구분한 목록으로 지정합니다.  각 항목은 콜론 (\fB:\fP)으로 구분한 0부터 9까지의 추가 필터
+체인 번호 값으로 이루어져 있으며, 압축하지 않은 데이터의 크기 값이 필요합니다.  항목을 생략하면(둘 이상의 쉼표 연속 표기) 이전
+항목의 크기와 필터를 활용하겠다는 함축 의미를 넣을 수 있습니다.
+.IP ""
+입력 파일이 \fI<항목>\fP 크기의 합보다 크면, 마지막 항목을 파일의 끝까지 반복합니다.  특별히 \fB0\fP 값을 마지막
+값으로 사용하여 파일 나머지 부분을 단일 블록으로 인코딩해야 한다는 의미를 나타낼 수도 있습니다.
+.IP ""
+\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션 조합으로
+각 블록별 별도 필터 체인을 지정할 수 있습니다.  이 옵션은 1\(en9번 필터 체인을 지정합니다. 필터 체인 0번은 필터 체인을
+지정하지 않았을 때와 동일한 기본 필터 체인으로 참조할 수 있습니다.  필터 체인 식별 번호는 비 ���축 크기 앞에 콜론(\fB:\fP)을 붙여
+사용할 수 있습니다. 예를 들면, \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP 옵션을
+지정했을 경우 다음 규칙대로 블록을 만듭니다:
+.RS
+.IP \(bu 3
+\fB\-\-filters1\fP 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+\fB\-\-filters3\fP 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을
+.IP \(bu 3
+\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을
+.IP \(bu 3
+기본 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+입력이 끝나기 전의 모든 블록에는 기본 필터 체인과 4MiB 입력을 적용합니다.
+.RE
+.IP ""
+인코더 블록 크기를 초과하는 크기 값을 지정하면(스레드 모드 기본값 또는 \fB\-\-block\-size=\fP\fI<크기>\fP
+옵션으로 지정한 값), 인코더는 \fI<크기>\fP 지정 용량 범위는 유지하면서 추가 블록을 만듭니다.  예를 들면
+\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP 옵션을 지정하고
+입력 파일을 80MiB 용량으로 전달하면, 각각 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, 1 MiB 용량을
+차지하는 블록 11개를 결과물로 내줍니다.
+.IP ""
+다중\-스레드 모드에서 블록 크기는 블록 헤더에 저장합니다.  단일\-스레드 모드에서는 저장하지 않기 때문에 인코딩 처리한 출력은
+다중\-스레드 모드의 출력 결과물과는 다릅니다.
+.TP 
+\fB\-\-flush\-timeout=\fP\fI<제한시간>\fP
+압축할 때, 이전 데이터를 소거하고 다음 입력을 블록 단위로 더 읽는데 \fI<제한시간>\fP 밀리초(양의 정수값)가 지났을
+경우, 대기중이던 모든 입력 데이터를 인코더에서 소거한 다음 출력 스트림에 전달합니다.  이런 동작은 네트워크로 스트리밍한 데이터를
+\fBxz\fP로 압축할 때 쓸만합니다.  \fI<제한시간>\fP 값을 적게 지정하면 적은 지연 시간에 데이터를 받아낼 수 있지만
+\fI<제한시간>\fP 값을 크게 하면 압축율을 높일 수 있습니다.
+.IP ""
+이 기능은 기본적으로 꺼져있습니다.  이 옵션을 한번 이상 지정하면, 마지막 옵션의 값대로 동작합니다.  특별히
+\fI<제한시간>\fP 값을 \fB0\fP으로 설정하면 이 설정을 완전히 끌 수 있습니다.
+.IP ""
+이 기능은 POSIX 시스템이 아닌 곳에서는 사용할 수 없습니다.
+.IP ""
+.\" FIXME
+\fB이 기능은 여전히 시험중입니다\fP.  현재로서는, \fBxz\fP 버퍼링 처리 방식 때문에 \fBxz\fP의 실시간 스트림 압축 해제 기능 활용은
+적절하지 않습니다.
+.TP 
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP
+압축 수행시 메모리 사용 한계를 지정합니다.  이 옵션을 여러번 지정하면 마지막 값을 취합니다.
+.IP ""
+압축 설정이 \fI<제한용량>\fP을 초과하면, \fBxz\fP는 설정 값의 하향 조정을 시도하여 한계 값을 더이상 넘치지 않게 하고
+자동 조절을 끝냈다는 알림을 표시합니다.  조정은 다음 순서대로 진행합니다. 스레드 수를 줄입니다. 다중\-스레드 모드에서 스레드 하나의
+할당 한계치가 \fI<제한용량>\fP을 넘으면 단일\-스레드 모드로 전환합니다. 그 다음 마지막으로 LZMA2 딕셔너리 크기를
+줄입니다.
+.IP ""
+\fB\-\-format=raw\fP 또는 \fB\-\-no\-adjust\fP 미지정 상황에서 압축할 때, 압축 데이터 출력에 영향을 주지 않고 스레드
+처리 수만 줄일 수 있습니다.
+.IP ""
+\fI<제한용량>\fP 값이 아래 설명한 조건에 맞지 않으면, 오류가 나타나고 \fBxz\fP 명령은 종료 상태 1번을 반환하며
+빠져나갑니다.
+.IP ""
+\fI<제한용량>\fP 값은 여러 방식으로 지정할 수 있습니다:
+.RS
+.IP \(bu 3
+\fI<제한용량>\fP 값은 바이트 용량 절대값입니다.  정수 값을 사용하되 \fBMiB\fP와 같은 접미사를 사용하는게 좋습니다.
+예: \fB\-\-memlimit\-compress=80MiB\fP
+.IP \(bu 3
+\fI<제한용량>\fP 값은 총 물리 메모리(RAM) 용량의 백분율로 지정할 수도 있습니다.  다른 컴퓨터끼리 공유하는 셸
+초기화 스크립트의 \fBXZ_DEFAULTS\fP 환경 변수에 값을 설정할 때 특히 쓸만합니다.  이런 방식으로 설정하면 시스템의 메모리 설치
+용량에 따라 자동으로 늘어납니다.  예: \fB\-\-memlimit\-compress=70%\fP
+.IP \(bu 3
+\fI<제한용량>\fP 값은 \fB0\fP 기본값으로 설정하여 초기화할 수 있습니다.  현재로서는 \fI<제한용량>\fP
+값이 \fImax\fP(최대) (메모리 사용 한계 없음) 인 상태와 동일합니다.
+.RE
+.IP ""
+\fBxz\fP 32비트 버전에서는 몇가지 특별한 경우가 있습니다. \fI<제한용량>\fP 값이 \fB4020MiB\fP를 넘으면
+\fI<제한용량>\fP을 \fB4020MiB\fP로 고정합니다. MIPS32에서는 \fB2000MiB\fP로 대신 고정합니다.
+(\fB0\fP과 \fBmax\fP는 이 경우에 해당하지 않습니다.  압축 해제시 비슷한 기능은 없습니다.)  이 경우 32비트 실행 파일이
+4GiB(MIPS32의 경우 2GiB) 주소 영역에 접근할 때 매우 용이하며, 다른 경우에는 원하는대로 문제를 일으키지 않습니다.
+.IP ""
+\fB메모리 활용\fP 섹션도 참고하십시오.
+.TP 
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP
+압축 해제시 메모리 사용 한계 용량을 설정합니다.  \fB\-\-list\fP 모드에도 영향을 줍니다.  \fI<제한용량>\fP을 넘기지
+않고서는 동작이 진행이 안될 경우, \fBxz\fP 에서는 오류를 나타내고 파일 압축 해제를 실패로
+간주합니다. \fI<제한용량>\fP을 지정하는 가능한 방법에 대해서는
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오.
+.TP 
+\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP
+다중\-스레드 모드 압축 해제시 메모리 사용 한계 용량을 설정합니다.  스레드 수에 영향을 줄 수도 있습니다.  \fBxz\fP에서 파일 압축
+해제를 거부하게 하진 않습니다.  \fI<제한용량>\fP 수치가 다중\-스레드로 처리하기에 너무 낮다면,
+\fI<제한용량>\fP 값을 무시하고 \fBxz\fP 동작을 단일\-스레드 모드로 계속 진행합니다.  참고로
+\fB\-\-memlimit\-decompress\fP 옵션도 사용하면, 단일\-스레드 모드와 다중\-스레드 모드 두 경우에 모두 적용하기에,
+다중\-스레드 모드에 적용할 \fI<제한용량>\fP 값은 \fB\-\-memlimit\-decompress\fP에 설정하는 제한 값보다 더
+크면 안됩니다.
+.IP ""
+다른 메모리 사용 용량 제한 옵션과는 달리, \fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 옵션은
+시스템별 기본 \fI<제한용량>\fP 값을 지닙니다.  현재 설정 값은 \fBxz \-\-info\-memory\fP 명령으로 확인해볼 수
+있습니다.
+.IP ""
+이 옵션과 기본 값은 한계 값을 주지 않으면 스레드 기반 압축 해제 프로그램이 일부 입력 파일에 대해 정신나간 수준의 메모리 용량을
+할당해서 동작이 끝나버릴 수 있습니다.  기본 \fI<제한용량>\fP이 시스템의 사양에 비해 낮다면,
+\fI<제한용량>\fP 값을 자유롭게 올리시되, \fBxz\fP 에서 적은 스레드 수에도 메모리 공간 할당을 시도하는 만큼, 입력
+파일에 적절한 수준으로 가용 RAM 용량을 넘는 큰 값을 설정하지 마십시오. 메모리나 스와핑 영역 공간이 줄어들면 압축해제 성능을
+개선하지 못합니다.
+.IP ""
+\fI<제한용량>\fP 값을 지정하는 가능한 방법을 보려면
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오.  \fI<제한용량>\fP 값을
+\fB0\fP으로 설정하면 \fI<제한용량>\fP 값이 시스템 지정 기본값으로 바뀝니다.
+.TP 
+\fB\-M\fP \fI<제한용량>\fP, \fB\-\-memlimit=\fP\fI<제한용량>\fP, \fB\-\-memory=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 지정과 동일합니다.
+.TP 
+\fB\-\-no\-adjust\fP
+압축 출력 결과에 영향을 주는 설정을 조정하지 않고는 메모리 사용 용량 제한 조건이 맞지 않으면 오류를 표시하고 빠져나갑니다.  이
+옵션은 \fBxz\fP가 다중\-스레드 모드에서 단일\-스레드 모드로 전환하고 LZMA2 딕셔너리 크기를 줄이는 동작을 막아줍니다.  심지어 이
+옵션을 사용하면 메모리 사용 한계를 만족하도록 스레드 수를 줄여 압축 결과물 출력에 영향이 가지 않게 합니다.
+.IP ""
+원시 스트림(\fB\-\-format=raw\fP)을 만들 떄 자동 조정은 항상 꺼집니다.
+.TP 
+\fB\-T\fP \fI<스레드수>\fP, \fB\-\-threads=\fP\fI<스레드수>\fP
+활용할 작업 스레드 수를 지정합니다.  \fI<스레드수>\fP 값을 \fB0\fP 값으로 설정하면, \fBxz\fP는 시스템에서 지원하는
+최대 프로세서 스레드 수를 모두 확보합니다. 실제 스레드 수는 입력 파일이 주어진 설정대로 스레드 처리를 할 만큼 그렇게 크지 않을
+경우, 내지는 더 많은 스레드를 사용했을 때 메모리 사용량 한계를 초과할 경우 \fI<스레드수>\fP 보다 적을 수 있습니다.
+.IP ""
+단일\-스레드와 다중\-스레드 압축 프로그램은 다른 출력 결과물을 냅니다.  단일\-스레드 압축 프로그램은 작은 파일 크기 결과물을 내놓지만,
+다중\-스레드 압축 프로그램의 경우 다중\-스레드 압축 프로그램에서 내놓은 결과물은 다중\-스레드로만 압축을 해제할 수 있습니다.
+\fI<스레드수>\fP를 \fB1\fP로 설정하면 단일\-스레드 모드를 사용합니다.  \fI<스레드수>\fP를 \fB0\fP과 다른
+값으로 설정하면, 시스템에서 실제로 하드웨어 스레드가 1개만 지원한다 하더라도, 다중\-스레드 압축 프로그램을 사용합니다.  (\fBxz\fP
+5.2.x에서는 이 경우 단일\-스레드 모드를 활용합니다.)
+.IP ""
+단일\-스레드로 다중\-스레드 모드를 사용하려면, \fI<스레드수>\fP를 \fB+1\fP로 설정하십시오. \fB+\fP 접두사는 \fB1\fP
+이외의 값에는 영향을 주지 않습니다.  메모리 사용량 한계 설정은 \fBxz\fP을 \fB\-\-no\-adjust\fP 옵션을 쓰기 전까지는
+단일\-스레드로 전환하게 합니다.  \fB+\fP 접두사 지원은 \fBxz\fP 5.4.0에 추가했습니다.
+.IP ""
+자동 스레드 수를 요청했고 메모리 사용 한계를 지정하지 않았다면, 시스템에 맞게끔 가능한 스레드 수를 제한하는 기본 소프트 제한 값을
+사용합니다. 스레드 수가 한개가 되면 무시하는 이런 개념이 소프트 제한이기에, \fBxz\fP로 하여금 압축 동작 및 압축 해제 동작 수행시
+멈추지 않습니다.  이 가본 소프트 제한 값은 \fBxz\fP 실행 도중 다중\-스레드 모드에서 단일\-스레드 모드로 바뀌게 하지는 않습니다.
+활성 제한 값은 \fBxz \-\-info\-memory\fP 명령으로 볼 수 있습니다.
+.IP ""
+현재 스레딩 처리 방식은 입력을 블록 단위로 쪼개고 각각의 블록을 독립적으로 압축하는 동작을 취합니다.  기본 블록 크기는 압축 수준에
+따라 다르며 \fB\-\-block\-size=\fP\fI<크기>\fP 옵션으로 재지정할 수 있습니다.
+.IP ""
+스레드 압축 해제 방식은 여러 블록이 블록 헤더에 넣은 크기 정보와 함께 들어간 파일에만 동작합니다.  다중\-스레드 모드에서 압축한
+충분히 큰 모든 파일은 이 조건에 만족하지만, 단일\-스레드 모드에서 압축한 파일은
+\fB\-\-block\-size=\fP\fI<크기>\fP 옵션을 지정하더라도 조건에 만족하지 않습니다.
+.IP ""
+\fI스레드\fP 기본 값은 \fB0\fP입니다.  \fBxz\fP 5.4.x 이전의 기본값은 \fB1\fP입니다.
+.
+.SS "개별 압축 필터 체인 설정"
+개별 필터 체인은 사전 설정에 엮인 설정에 의존하는 대신 압축 설정을 세부적으로 하나하나 설정할 수 있게 합니다.  개별 필터 체인을
+지정하면, 명령행에 앞서 지정한 사전 설정 옵션(\fB\-0\fP \&...\& \fB\-9\fP 과 \fB\-\-extreme\fP)은 무시합니다.  사전
+설정 옵션을 하나 이상의 필터 체인 옵션 다음에 지정하면, 새 사전 설정을 취하며, 앞서 지정한 개별 필터 체인 옵션은 무시합니다.
+.PP
+필터 체인은 명령행 파이핑에 비교할 수 있습니다.  압축할 때, 압축하지 않은 입력을 첫번째 필터로 놓고, 출력 대상(이 있으면)을 다음
+필터로 지정합니다.  최종 필터의 출력은 압축 파일로 기옥합니다.  체인의 최대 필터 수는 4이지만, 필터 체인상 필터 갯수는 보통
+1~2개입니다.
+.PP
+수많은 필터가 필터 체인 상에서 제약점을 가지고 있습니다. 일부 필터는 체인의 마지막 필터로만 동작하며, 일부 다른 필터는 마지막이 아닌
+필터로, 어떤 동작은 체인의 어떤 위치에든 둡니다.  필터에 따라, 이 제한은 필터 설계를 따르거나 보안 문제를 막기 위해 존재하기도
+합니다.
+.PP
+개별 필터 체인은 두가지 방식으로 지정할 수 있습니다.  \fB\-\-filters=\fP\fI<필터>\fP와
+\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션으로
+liblzma 필터 문자열 문법에 따라 한가지 옵션을 필터 체인 전체를 지정할 수 있습니다.  대신, 하나 이상의 개별 필터 옵션을
+원하는 필터 체인 순서대로 지정할 수도 있습니다.  이 말인 즉슨, 개별 필터 옵션의 순서가 중요하단 뜻입니다! 원시 스트림을 디코딩할
+때(\fB\-\-format=raw\fP), 압축했을 때 지정했던 필터와 같은 순서로 필터 체인을 지정해야 합니다.  전체 체인
+옵션(\fB\-\-filters=\fP\fI<필터>\fP) 보다 우선 지정한 개별 필터 또는 사전 설정 옵션은 까먹을 수도 있습니다.
+전체 체인 옵션 다음에 개별 필터를 지정할 경우 필터 체인의 동작을 무효로 합니다.
+.PP
+필터는 쉼표로 구분하는 필터별 \fI<옵션>\fP이 있습니다.  \fI<옵션>\fP에 추가로 입력한 쉼표는
+무시합니다.  모든 옵션 값에는 기본값이 있어, 값을 바꾸려면 지정해야합니다.
+.PP
+전체 필터 체인과 \fI<옵션>\fP을 보려면 \fBxz \-vv\fP (\fB\-\-verbose\fP 두 번)명령을 사용하십시오.  이
+명령은 사전 설정이 사용하는 필터 체인 옵션도 볼 수 있습니다.
+.TP 
+\fB\-\-filters=\fP\fI<필터>\fP
+전체 필터 체인 또는 사전 설정을 단일 옵션으로 지정합니다.  각 필터는 공백 문자 또는 대시 문자 두번 입력(\fB\-\-\fP)으로
+구분합니다.  셸 명령행에서 \fI필터\fP는 따옴표로 감싸서 단일 옵션으로 해석하도록 해야 합니다.  \fI옵션\fP을 표기하려면 \fB:\fP 또는
+\fB=\fP을 활용하십시오.  사전 설정 앞에 \fB\-\fP를 붙일 수 있고 0개 또는 하나 이상의 플래그를 붙일 수 있습니다.  유일하게
+지원하는 플래그는 \fB\-\-extreme\fP과 동일한 \fBe\fP입니다.
+.TP 
+\fB\-\-filters1\fP=\fI<필터>\fP ... \fB\-\-filters9\fP=\fI<필터>\fP
+\fB\-\-block\-list\fP와 사용할 수 있는 추가 필터 체인을 최대 9개까지 지정합니다.
+.IP ""
+예를 들어 텍스트 파일과 실행 파일의 아카이브를 압축할 때 실행 부분에 BCJ 필터 체인을 사용하고 텍스트 부분은 LZMA2 필터를
+사용할 수 있습니다.
+.TP 
+\fB\-\-filters\-help\fP
+\fB\-\-filters\fP와 \fB\-\-filters1=\fP\fI<필터>\fP \&...\&
+\fB\-\-filters9=\fP\fI<필터>\fP 옵션의 사전 설정 필터와 개별 설정 필터 체인을 지정하는 방법을 설명하는 도움말
+메시지를 출력하고 완전히 빠져나갑니다.
+.TP 
+\fB\-\-lzma1\fP[\fB=\fP\fI<옵션>\fP]
+.PD 0
+.TP 
+\fB\-\-lzma2\fP[\fB=\fP\fI<옵션>\fP]
+.PD
+LZMA1 또는 LZMA2 필터를 필터 체인에 추가합니다.  이 필터는 필터 체인의 마지막 요소로만 사용할 수 있습니다.
+.IP ""
+LZMA1은 고전 필터로, LZMA1만 지원하는 고전 \fB.lzma\fP 파일 형식에서만 지원합니다.  LZMA2는 LZMA1의 업데이트
+버전으로 LZMA1의 실질적 문제를 해결했습니다.  \fB.xz\fP 형식은 LZMA2 필터를 사용하며 LZMA1 필터는 전적으로 지원하지
+않습니다.  압축 속도와 압축율은 LZMA1과 LZMA2가 실질적으로 동일합니다.
+.IP ""
+LZMA1과 LZMA2는 동일한 \fI<옵션>\fP 집합을 공유합니다:
+.RS
+.TP 
+\fBpreset=\fP\fI<사전설정>\fP
+LZMA1 또는 LZMA2의 모든 \fI<옵션>\fP을 \fI<사전설정>\fP으로
+초기화합니다. \fI<사전설정>\fP 값은 정수 값으로 이루어져 있으며, 사전 설정에 변형을 줄 떄 단일 문자가 따라올 수도
+있습니다.  정수 값은 \fB0\fP에서 \fB9\fP 까지이며, 명령행 옵션에서 \fB\-0\fP \&...\& \fB\-9\fP로 대응합니다.  변형 옵션으로
+지원하는 문자는 현재 \fBe\fP 뿐이며, \fB\-\-extreme\fP에 대응합니다.  \fI<사전설정>\fP 값을 지정하지 않으면,
+LZMA1 또는 LZMA2 기본값을 사전 설정 \fB6\fP에서 가져온 \fI<옵션>\fP으로 취합니다.
+.TP 
+\fBdict=\fP\fI<크기>\fP
+딕셔너리(기록 버퍼)  \fI<크기>\fP는 최근 처리한 비압축 데이터를 바이트 단위로 메모리에 얼마나 유지하는지 나타냅니다.
+알고리즘은 비압축 데이터상 바이트 시퀀스(일치 항목) 반복 탐색을 시도하며, 해당 부분을 딕셔너리의 현재 참조로 치환합니다. 딕셔너리가
+크면 일치하는 항목을 찾을 기회가 더 많아집니다.  따라서, 딕셔너리 \fI<크기>\fP를 더욱 크게 설정하면 압축율을 증가할
+수는 있지만, 압축하지 않은 파일보다 딕셔너리가 크면 메모리 낭비율이 올라갑니다.
+.IP ""
+보통 딕셔너리 \fI<크기>\fP는 64KiB 에서 64MiB 정도 됩니다. 최소 4KiB 입니다. 압축시 최대 용량은 현재
+1.5GiB(1536MiB)로 나타납니다.  압축 해제 프로그램에도 4GiB 미만으로 딕셔너리 크기를 이미 지원하며 4GiB 라는 수치는
+LZMA1과 LZMA2 스트림 형식의 최대값입니다.
+.IP ""
+딕셔너리 \fI<크기>\fP와 검색기(\fImf\fP)는 LZMA1 또는 LZMA 인코더의 메모리 사용량을 함께 결정합니다.
+동일한(또는 더 큰) 딕셔너리 \fI<크기>\fP가 데이터를 압축했을 때만큼 압축 해제할 떄 필요하기 때문에, 디코더의 메모리
+사용량은 압축할 때의 딕셔너리 크기로 결정합니다.  \fB.xz\fP 헤더에는 딕셔너리 \fI<크기>\fP를 2^\fIn\fP 또는
+2^\fIn\fP + 2^(\fIn\fP\-1) 으로 저장하기에, 이 \fI<크기>\fP 값을 압축할 때 선호하는 편입니다.  다른
+\fI<크기>\fP 값은 \fB.xz\fP 헤더에 저장할 때 반올림합니다.
+.TP 
+\fBlc=\fP\fIlc\fP
+리터럴 컨텍스트 비트 수를 지정합니다.  최소 값은 0이고 최대 값은 4입니다. 기본 값은 3입니다.  추가로, \fIlc\fP 값과
+\fIlp\fP 값의 합은 4를 넘으면 안됩니다.
+.IP ""
+조건이 일치하지 않아 인코딩할 수 없는 모든 바이트는 리터럴로 인코딩합니다.  이 말인 즉슨, 간단히 8비트 바이트로서의 리터럴을 한번에
+하나씩 인코딩합니다.
+.IP ""
+리터럴 코딩을 할 때 이전 비압축 바이트와 다음 바이트와의 관련성을 가진 가장 많은 \fIlc\fP 비트 수를 가정합니다.  예를 들면, 보통
+영문 문장의 경우 대문자 다음에 종종 소문자가 오고, 소문자 다음에 다른 소문자가 따라옵니다. US\-ASCII 문자 세트에서는 가장 긴
+비트 3개는 대문자에 대해 010, 소문자에 대해 011입니다.  \fIlc\fP 값이 최소한 3이면, 리터럴 코딩시 비압축 데이터에 대해
+이런 속성의 장점을 취할 수 있습니다.
+.IP ""
+(어쨌거나) 기본값 (3)은 보통 적절합니다.  최대 압축을 원한다면 \fBlc=4\fP 값을 시험해보십시오.  때로는 약간 도움이 되기도
+하겠지만, 오히려 결��가 안좋을 수도 있습니다.  결과가 엄한 방향으로 간다면, \fBlc=2\fP 값도 시험해보십시오.
+.TP 
+\fBlp=\fP\fIlp\fP
+리터럴 위치 비트 수를 지정하빈다.  최소 값은 0이고 최대 값은 4입니다. 기본 값은 0입니다.
+.IP ""
+\fIlp\fP 값은 리터럴 인코딩 진행시 비압축 데이터 정렬 방식 고려에 영향을 줍니다.  정렬 방식에 대한 자세한 정보는 하단 \fIpb\fP를
+참고하십시오.
+.TP 
+\fBpb=\fP\fIpb\fP
+위치 비트 수를 지정합니다.  최소 값은 0이며 최대 값은 4입니다.  기본값은 2입니다.
+.IP ""
+\fIpb\fP 값은 보통 압축하지 않은 데이터에 어떤 정렬 방식을 고려하느냐에 영향을 줍니다.  기본적으로 4바이트
+정렬(2^\fIpb\fP=2^2=4)을 의미하는데, 이보다 더 나은 추측 값이 없어서 종종 최적의 선택으로 간주합니다.
+.IP ""
+정렬 상태를 알지 못할 경우, \fIpb\fP 설정 값이 파일 크기를 조금 줄일 수 있습니다.  예를 들면, 텍스트 파일이 단일 바이트 단위로
+정돈된 상태(US\-ASCII, ISO\-8859\-*, UTF\-8)라면, \fBpb=0\fP 설정 값으로 압축율을 조금 개선할 수 있습니다.
+UTF\-16 텍스트의 경우, \fBpb=1\fP 설정 값이 좋은 선택입니다.  정렬 바이트가 3 바이트 같은 홀수 바이트일 경우,
+\fBpb=0\fP 설정 값이 최적의 선택일지도 모릅니다.
+.IP ""
+가정 정렬을 \fIpb\fP 값과 \fIlp\fP 값으로 조정하긴 하지만, LZMA1과 LZMA2는 여전히 16바이트 정렬 방식으로 선호합니다.
+LZMA1 또는 LZMA2로 종종 압축하는 파일 형식이라고 하면 고려해볼만 합니다.
+.TP 
+\fBmf=\fP\fImf\fP
+일치 검색기는 인코더 속도, 메모리 사용량, 압축율에 주된 영향을 줍니다.  보통 해시 체인 검색기는 이진 트리 검색기보다 빠르긴
+합니다.  기본 값은 \fI<사전설정>\fP에 따라 다릅니다. 0은 \fBhc3\fP을, 1\(en3은 \fBhc4\fP를, 나머지는
+\fBbt4\fP를 활용합니다.
+.IP ""
+다음 검색 필터를 지원합니다.  메모리 사용 공식은 \fIdict\fP 값이 2의 승수일 경우 실제에 가까운 근사치입니다.
+.RS
+.TP 
+\fBhc3\fP
+2바이트, 3바이트 해싱 체인
+.br
+\fInice\fP 최소값: 3
+.br
+메모리 사용:
+.br
+\fIdict\fP * 7.5 (조건: \fIdict\fP <= 16 MiB);
+.br
+\fIdict\fP * 5.5 + 64 MiB (조건: \fIdict\fP > 16 MiB)
+.TP 
+\fBhc4\fP
+2바이트, 3바이트, 4바이트 해싱 체인
+.br
+\fInice\fP 최소값: 4
+.br
+메모리 사용:
+.br
+\fIdict\fP * 7.5 (조건: \fIdict\fP <= 32 MiB);
+.br
+\fIdict\fP * 6.5 (조건: \fIdict\fP > 32 MiB)
+.TP 
+\fBbt2\fP
+2바이트 해싱 이진 트리
+.br
+\fInice\fP 최소값: 2
+.br
+메모리 사용: \fIdict\fP * 9.5
+.TP 
+\fBbt3\fP
+2바이트, 3바이트 해싱 이진트리
+.br
+\fInice\fP 최소값: 3
+.br
+메모리 사용:
+.br
+\fIdict\fP * 11.5 (조건: \fIdict\fP <= 16 MiB);
+.br
+\fIdict\fP * 9.5 + 64 MiB (조건: \fIdict\fP > 16 MiB)
+.TP 
+\fBbt4\fP
+2바이트, 3바이트, 4바이트 해싱 이진 트리
+.br
+\fInice\fP 최소값: 4
+.br
+메모리 사용:
+.br
+\fIdict\fP * 11.5 (조건: \fIdict\fP <= 32 MiB);
+.br
+\fIdict\fP * 10.5 (조건: \fIdict\fP > 32 MiB)
+.RE
+.TP 
+\fBmode=\fP\fI<모드>\fP
+압축 \fI<모드>\fP 값은 일치 검색기에서 생산하는 데이터 분석 방식을 지정합니다.  지원하는 \fI<모드>\fP는
+\fBfast\fP와 \fBnormal\fP 입니다. 기본값은 \fI<사전설정>\fP값 0\(en3에 대해 \fBfast\fP,
+\fI<사전설정>\fP값 4\(en9에 대해 \fBnormal\fP입니다.
+.IP ""
+보통 \fBfast\fP는 해시 체인 검색기에서 사용하며 \fBnormal\fP은 이진 트리 검색기에서 사용합니다.  이 동작은 또한
+\fI<사전설정>\fP 값이 할 일이기도 합니다.
+.TP 
+\fBnice=\fP\fInice\fP
+일치하는 nice 길이를 지정합니다.  최소한 \fInice\fP 바이트 정도 일치하면, 알고리즘이 가능한 최선의 부분을 찾는 동작을
+멈춥니다.
+.IP ""
+\fInice\fP 값은 2\(en273 바이트입니다.  값이 클 수록 속도 면에서는 손해를 보겠지만 압축율은 더욱 올라갑니다.  기본 값은
+\fI<사전설정>\fP값에 따라 다릅니다.
+.TP 
+\fBdepth=\fP\fI<깊이>\fP
+일치 검색기에서의 최대 검색 깊이를 지정합니다.  기본값은 특별한 값 0으로 지정하며, 이 값으로 압축 프로그램이 \fImf\fP 와
+\fInice\fP간 적절한 \fI<깊이>\fP 값을 결정합니다.
+.IP ""
+적절한 해시 체인 \fI<깊이>\fP 값은 이진 트리에서 4\(en100 그리고 16\(en1000 입니다. 상당히 큰 값을
+\fI<깊이>\fP 값으로 사용하면 일부 파일에 대해 인코더가 매우 느리게 동작할 수가 있습니다.  압축 시간이 너무 오래걸려서
+동작을 중간에 끊을 준비가 되지 않은 이상 \fI<깊이>\fP 설정 값은 1000을 넘지 않게하십시오.
+.RE
+.IP ""
+원시 스트림(\fB\-\-format=raw\fP)을 디코딩할 때, LZMA2는 딕셔너리 \fI<크기>\fP만 필요합니다.  LZMA1는
+\fIlc\fP, \fIlp\fP, \fIpb\fP 값이 모두 필요합니다.
+.TP 
+\fB\-\-x86\fP[\fB=\fP\fI<옵션>\fP]
+.PD 0
+.TP 
+\fB\-\-arm\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-armthumb\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-arm64\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-powerpc\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-ia64\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-sparc\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-riscv\fP[\fB=\fP\fI<옵션>\fP]
+.PD
+브랜치/호출/점프(BCJ) 필터를 필터 체인에 추가합니다.  이 필터는 필터 체인의 비종결 필터로만 사용할 수 있습니다.
+.IP ""
+BCJ 필터는 머신 코드의 상대 주소를 절대 주소로 변환합니다.  데이터 크기를 바꾸지는 않지만 LZMA2에서 \fB.xz\fP 파일을
+0\(en15% 정도 줄여주게 하는 중복성이 늘어납니다.  BCJ 필터는 언제든 뒤집을 수 있어, 데이터에 적절하지 않은 BCJ 필터
+형식을 활용하면, 그냥 가만히 두면 압축율이 약간 떨어지게 한다 하더라도, 데이터를 잃을 수가 있습니다.  BCJ 필터는 굉장히 빠르며
+메모리 공간을 적게 활용합니다.
+.IP ""
+이 BCJ 필터에는 압축율 관련 몇가지 문제가 있습니다:
+.RS
+.IP \(bu 3
+실행 코드가 들어있는 몇가지 파일 형식(예: 목적 파일, 정적 라이브러리, 리눅스 커널 모듈)의 경우 필터 값으로 채운 명령 주소가
+있습니다.  여기 BCJ 필터의 경우 파일의 압축율을 떨어뜨리는 주소 변환을 수행합니다.
+.IP \(bu 3
+BCJ 필터를 아카이브에 적용하면, BCJ 필터를 사용하지 않았을 때보다 압축율이 떨어질 수가 있습니다.  예를 들면, 유사하거나 동일한
+실행 파일 여럿이 있으면 필터를 사용하여 파일을 덜 비슷하게 만들어 압축율이 떨어지게 합니다.  동일한 아카이브 파일에서 비 실행 파일의
+내용에 대해서도 비슷한 일이 벌어질 수 있습니다.  실제로 하나는 BCJ 필터를 걸고 하나는 제외하여 각 경우에 대해 어떤 경우가 결과가
+우수한 지 살펴보겠습니다.
+.RE
+.IP ""
+다른 명령 세트는 다른 정렬 상태에 놓여있습니다.  실행 파일은 필터가 제대로 동작하게 하려면 입력 데이터에 있는 이 값의 배수로
+정돈해야합니다.
+.RS
+.RS
+.PP
+.TS
+tab(;);
+l n l
+l n l.
+필터;정렬;참고
+x86;1;32\-bit 또는 64\-bit x86
+ARM;4;
+ARM\-Thumb;2;
+ARM64;4;4096 바이트 정렬이 가장 좋습니다
+PowerPC;4;빅엔디안 전용
+IA\-64;16;Itanium
+SPARC;4;
+RISC\-V;2;
+.TE
+.RE
+.RE
+.IP ""
+BCJ 필터를 사용한 데이터는 LZMA2로 보통 압축하기 때문에 LZMA2 옵션을 선택한 BCJ 필터의 정렬기준에 맞추도록 설정하면
+압축율을 좀 더 개선할 수 있습니다.  예를 들면:
+.RS
+.IP \(bu 3
+IA\-64 필터는 16\-바이트 정렬 방식으로 동작하기에 LZMA2 필터에 \fBpb=4,lp=4,lc=0\fP 옵션(2^4=16)을 주는게
+좋습니다.
+.IP \(bu 3
+RISC\-V 코드에는 16\-비트 압축 명령(C 확장) 적재 여부에 따라 2\-바이트 또는 4\-바이트 정렬 방식을 채택합니다. 16\-비트
+명령을 사용하면, \fBpb=2,lp=1,lc=3\fP 또는 \fBpb=1,lp=1,lc=3\fP 옵션 값 사용이 바람직합니다. 16\-비트 명령이
+없다면, \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다.  "RVC"가 "Flags"행에 나타나는지 확인할 때
+\fBreadelf \-h\fP 명령을 사용할 수 있습니다.
+.IP \(bu 3
+ARM64는 항상 4\-바이트 정렬 방식을 택하기에 \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다.
+.IP \(bu 3
+x86 필터는 예외입니다.  x86 실행 파일을 압축할 경우에는 보통 LZMA2 기본 옵션 값(\fBpb=2,lp=0,lc=3\fP)을 그대로
+사용하는게 좋습니다.
+.RE
+.IP ""
+모든 BCJ 필터는 동일한 \fI옵션\fP을 지원합니다:
+.RS
+.TP 
+\fBstart=\fP\fI<오프셋>\fP
+상대 주소와 절대 주소를 변환할 때 사용할 시작 \fI<오프셋>\fP을 지정합니다.  \fI<오프셋>\fP에는 필터
+정렬 배수여야 합니다(상단 테이블 참조).  기본값은 0입니다.  실제로 기본값이 낫습니다. 개별 \fI<오프셋>\fP 지정
+값은 거의 쓸모가 없습니다.
+.RE
+.TP 
+\fB\-\-delta\fP[\fB=\fP\fI<옵션>\fP]
+필터 체인에 델타 필터를 추가합니다.  델타 필터는 필터 체인에서 마지막에 지정하지 않은 필터로만 사용할 수 있습니다.
+.IP ""
+현재로서는 바이트 단위 단순 델타계산 결과만 보여줍니다.  예를 들면, 압축하지 않은 비트맵 그림 또는 압축하지 않은 PCM 오디오를
+압축할 때 쓸만합니다.  그러나 특별한 목적으로 활용하는 알고리즘은 델타 + LZMA2 보다 더 나은 결과를 가져다 주기도 합니다.
+이는 특히 오디오의 경우 맞는 이야기인데, \fBflac\fP(1)의 경우 더 빠르고 우수한 압축율을 보여줍니다.
+.IP ""
+지원 \fI옵션\fP:
+.RS
+.TP 
+\fBdist=\fP\fI<차이>\fP
+바이트 단위 델터 계산 \fI<차이>\fP를 지정합니다.  \fI<차이>\fP값은 1\(en256 이어야합니다.  기본
+값은 1입니다.
+.IP ""
+예를 들어, \fBdist=2\fP 옵션과 A1 B1 A2 B3 A3 B5 A4 B7 입력 값을 주면, 출력 값은 A1 B1 01 02 01
+02 01 02 입니다.
+.RE
+.
+.SS "기타 옵션"
+.TP 
+\fB\-q\fP, \fB\-\-quiet\fP
+경고 및 알림을 끕니다.  두 번 지정하면 오류 메시지 표시도 끕니다.  이 옵션은 종료 상태에 영향을 주지 않습니다.  경고 표시를
+끄더라도, 종료 상태에서는 여전히 경고가 나타났음을 알려줍니다.
+.TP 
+\fB\-v\fP, \fB\-\-verbose\fP
+출력 내용이 많아집니다.  표준 오류를 터미널에 연결했다면 \fBxz\fP는 진행 표시를 나타냅니다.  \fB\-\-verbose\fP를 두번 지정하면
+더 많은 내용을 표시합니다.
+.IP ""
+진행 표시에서는 다음 정보를 나타냅니다:
+.RS
+.IP \(bu 3
+입력 파일의 크기를 알고 있을 경우 완료 백분율.  파이프 처리시에는 백분율을 나타낼 수 없습니다.
+.IP \(bu 3
+산출 압축 데이터 용량 (압축) 또는 소모 공간 용량 (압축 해제).
+.IP \(bu 3
+비압축 데이터 소모 용량 (압축) 또는 산출 용량 (압축 해제).
+.IP \(bu 3
+압축 데이터 산출 용량을 비압축 데이터 처리 용량으로 나누어 계산한 압축율.
+.IP \(bu 3
+압축 또는 압축 해제 속도.  초당 비압축 데이터 소모량(압축) 또는 산출 용량(압축 해제)를 측정한 값입니다.  \fBxz\fP에서 파일
+처리를 시작한 몇 초 후 나타납니다.
+.IP \(bu 3
+경과 시간 형식은 M:SS 또는 H:MM:SS 입니다.
+.IP \(bu 3
+추산 여분 시간은 \fBxz\fP가 파일을 처리하기 시작한 이후 입력 파일의 크기를 알고 몇 초가 지난 후에야 보여줍니다.  시간은 콜론
+문자를 사용하지 않고 덜 자세한 형식으로, 예를 들면, 2분 30초 와 같은 형식으로 보여줍니다.
+.RE
+.IP ""
+표준 오류가 터미널이 아니라면 \fB\-\-verbose\fP는 \fBxz\fP에서 파일 이름, 압축 크기, 압축 해제 용량, 압축율, 그리고
+가능하다면 파일을 압축 또는 압축 해제한 후 표준 오류로 속도와 걸린 시간을 나타내도록 합니다.  속도와 걸린 시간 정보는 동작을
+처리하는데 최소한 몇초 정도 소요했을 경우에만 들어갑니다.  동작이 끝나지 않았다면, 이를테면 사용자의 중단 요청이 있었을 경우 입력
+파일의 크기를 알고 있을 때 압축 백분율 정보도 들어갑니다.
+.TP 
+\fB\-Q\fP, \fB\-\-no\-warn\fP
+경고로 알릴 만한 상황을 만났다 하더라도 종료 상태 2번을 설정하지 않습니다.  이 옵션은 출력 수준에 영향을 주지 않기 때문에,
+\fB\-\-quiet\fP 옵션과 \fB\-\-no\-warn\fP 옵션을 경고 표시를 막고 종료 상태를 바꾸지 않을 목적으로 사용합니다.
+.TP 
+\fB\-\-robot\fP
+머신에서 해석할 형식으로 메시지를 나타냅니다.  liblzma 대신 \fBxz\fP를 활용하려는 다양상 스크립트로서의 프론트엔드를 쉽게
+작성하도록 하기 위함입니다.  이 옵션을 지정한 출력은 \fBxz\fP 릴리스가 어떻게 되든 안정 버전이란 의미입니다.  자세한 내용은
+\fB로봇 모드\fP 섹션을 참고하십시오.
+.TP 
+\fB\-\-info\-memory\fP
+압축 및 압축 해제시 물리 메모리 용량 (RAM), \fBxz\fP에서 파악하는 프로세서 스레드 갯수, 메모리 사용량 한계를 파악하기 쉬운
+형식으로 나타내고 무사히 나갑니다.
+.TP 
+\fB\-h\fP, \fB\-\-help\fP
+보통 사용하는 옵션을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다.
+.TP 
+\fB\-H\fP, \fB\-\-long\-help\fP
+\fBxz\fP의 모든 기능을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다
+.TP 
+\fB\-V\fP, \fB\-\-version\fP
+\fBxz\fP와 liblzma 버전 번호를 가독 형식으로 출력합니다.  기계 해석 가능 형식을 가져오려면 \fB\-\-version\fP 앞에
+\fB\-\-robot\fP을 지정하십시오.
+.
+.SH "로봇 모드"
+로봇 모드는 \fB\-\-robot\fP 옵션으로 동작합니다.  \fBxz\fP 출력을 다른 프로그램에서 해석하기 쉽게 해줍니다.  현재로서는
+\fB\-\-robot\fP 옵션은  \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, \fB\-\-version\fP
+옵션하고만 사용할 수 있습니다.  앞으로는 압축 및 압축 해제 동작에 대해서도 지원합니다.
+.
+.SS "목록 모드"
+\fBxz \-\-robot \-\-list\fP 명령은 탭으로 구분한 출력 형태를 활용합니다.  모든 행의 첫번째 컬럼에는 해당 행에서 찾을 수
+있는 정보의 형식을 나타냅니다:
+.TP 
+\fB이름\fP
+이 행은 항상 파일 목록 시작 부분의 첫번째 줄에 있습니다.  이 행의 두번째 컬럼에 파일 이름이 들어있습니다.
+.TP 
+\fB파일\fP
+이 행에는 \fB.xz\fP 파일의 전반적인 정보가 들어있습니다.  이 행은 항상 \fB이름\fP 행 다음에 있습니다.
+.TP 
+\fB스트림\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 ��만 사용합니다.  \fB.xz\fP 파일의 \fB스트림\fP 행 수만큼 나타납니다.
+.TP 
+\fB블록\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다.  \fB.xz\fP 파일의 블록 수만큼 \fB블록\fP 행이 나타납니다.
+\fB블록\fP 행은 모든 \fB스트림\fP 행 다음에 나타납니다. 다른 형식의 행이 끼어들지는 않습니다.
+.TP 
+\fB요약\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 두번 지정했을 때만 사용합니다.  이 행은 모든 \fB블록\fP 행 다음에 출력합니다.
+\fB파일\fP 행과 비슷하게, \fB요약\fP 행에는 \fB.xz\fP 파일의 전반적인 정보가 담겨있습니다.
+.TP 
+\fB총계\fP
+이 행은 목록 출력의 가장 마지막에 항상 나타납니다.  총 갯수와 크기를 나타냅니다.
+.PP
+\fB파일\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+파일 스트림 갯수
+.IP 3. 4
+스트림의 블록 총 갯수
+.IP 4. 4
+파일 압축 크기
+.IP 5. 4
+파일 압축 해제 크기
+.IP 6. 4
+예를 들면, \fB0.123\fP과 같은 압축율 입니다.  비율이 9.999라면, 대시 문자 3개 (\fB\-\-\-\fP)를 비율 값 대신 나타냅니다.
+.IP 7. 4
+쉼표로 구분한 무결성 검사 이름 목록입니다.  \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP, \fBSHA\-256\fP 문자열을 알려진
+검사 형식으로 사용합니다.  알 수 없는 검사 형식에 대해서는 \fBUnknown\-\fP\fIN\fP을 사용하며, 여기서 \fIN\fP은 (한 두자리)
+정수형 숫자값으로 이루어진 검사 ID 입니다.
+.IP 8. 4
+파일의 스트림 패딩 총 길이
+.RE
+.PD
+.PP
+\fB스트림\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+스트림 번호 (첫 스트림은 1번)
+.IP 3. 4
+스트림의 블록 총 갯수
+.IP 4. 4
+압축 시작 오프셋
+.IP 5. 4
+비압축 시작 오프셋
+.IP 6. 4
+압축 크기 (스트림 패딩 미포함)
+.IP 7. 4
+압축 해제 용량
+.IP 8. 4
+압축율
+.IP 9. 4
+무결성 검사 이름
+.IP 10. 4
+스트림 패딩 길이
+.RE
+.PD
+.PP
+\fB블록\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+이 블록이 들어간 스트림 갯수
+.IP 3. 4
+스트림 시작 부분의 블록 번호 (첫번째 블록은 1번)
+.IP 4. 4
+파일 시작 부분의 블록 번호
+.IP 5. 4
+파일 시작 부분의 압축 시작 오프셋
+.IP 6. 4
+파일 시작 부분의 비압축 시작 오프셋
+.IP 7. 4
+총 블록 압축 크기 (헤더 포함)
+.IP 8. 4
+압축 해제 용량
+.IP 9. 4
+압축율
+.IP 10. 4
+무결성 검사 이름
+.RE
+.PD
+.PP
+\fB\-\-verbose\fP를 두 번 지정하면, 추가 컬럼을 \fB블록\fP 행에 넣습니다.  \fB\-\-verbose\fP 단일 지정시에는 이 정보를 볼
+때 탐색을 여러번 수행해야 하기 때문에 실행 과정이 느려질 수 있어서 나타내지 않습니다:
+.PD 0
+.RS
+.IP 11. 4
+16진수 무결성 검사값
+.IP 12. 4
+블록 헤더 크기
+.IP 13. 4
+블록 플래그: \fBc\fP는 압축 크기가 현재 값임을 나타내고, \fBu\fP는 압축 전 원본 크기가 현재 값임을 나타냅니다.  플래그를 설정하지
+않았다면, 문자열 길이를 유지할 목적으로 대시 \fB\-\fP 를 대신 나타냅니다.  새 플래그는 나중에 문자열 끝 부분에 추가할 예정입니다.
+.IP 14. 4
+블록에 압축 해서 넣은 데이터의 실제 츠기 (블록 헤더, 블록 패딩, 검사 필드 제외)
+.IP 15. 4
+이 \fBxz\fP 버전에서 이 블록의 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량
+.IP 16. 4
+필터 체인.  대부분 사용하는 옵션은 압축 해제시 필요한 옵션만을 \fB.xz\fP 헤더에 저장하기 때문에 압축 시간에 알 수 없습니다.
+.RE
+.PD
+.PP
+\fB요약\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+이 \fBxz\fP 버전에서 이 파일 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량
+.IP 3. 4
+모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값
+.PP
+\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP
+.IP 4. 4
+파일 압축 해제시 필요한 최소 \fBxz\fP 버전
+.RE
+.PD
+.PP
+\fB총계\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+스트림 갯수
+.IP 3. 4
+블록 갯수
+.IP 4. 4
+압축 크기
+.IP 5. 4
+압축 해제 용량
+.IP 6. 4
+평균 압축율
+.IP 7. 4
+파일에 들어 있어 쉼표로 구분한 무결성 검사 이름 목록
+.IP 8. 4
+스트림 패딩 길이
+.IP 9. 4
+파일 갯수.  \fB파일\fP 행의 컬럼 순서를 따라갑니다.
+.PD
+.RE
+.PP
+\fB\-\-verbose\fP 옵션을 두 번 지정하면, \fB총계\fP 행에 추가 컬럼이 들어갑니다:
+.PD 0
+.RS
+.IP 10. 4
+이 \fBxz\fP 버전에서 파일 압축을 해제할 떄 필요한 (바이트 단위) 최대 메모리 사용량
+.IP 11. 4
+모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값
+.PP
+\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP
+.IP 12. 4
+파일 압축 해제시 필요한 최소 \fBxz\fP 버전
+.RE
+.PD
+.PP
+차후 버전에서는 새 행 형식을 추가하고 기존 행 형식에 추가할 수 있는 새 컬럼을 넣기 까지는 알 수 있겠지만, 기존 컬럼은 바꾸지 않을
+예정입니다.
+.
+.SS "필터 도움말"
+\fBxz \-\-robot \-\-filters\-help\fP 는 다음 형식의 지원 필터 목록을 출력합니다:
+.PP
+\fI<필터>\fP\fB:\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>,\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>\fP...
+.TP 
+\fI<필터>\fP
+필터 이름
+.TP 
+\fI<옵션>\fP
+필터별 옵션 이름
+.TP 
+\fI<값>\fP
+숫자 \fI값\fP 범위는 \fB<\fP\fI최소\fP\fB\-\fP\fI최대\fP\fB>\fP입니다.  문자열 \fI값\fP은 \fB< >\fP 범위
+내에서 선택하며 \fB|\fP 문자로 구분합니다.
+.PP
+각 필터는 한 줄에 하나씩 출력합니다.
+.
+.SS "메모리 제한 정보"
+\fBxz \-\-robot \-\-info\-memory\fP 명령은 탭으로 나뉜 여러 컬럼을 단일 행으로 나타냅니다:
+.IP 1. 4
+물리 메모리(RAM)의 바이트 단위 총량.
+.IP 2. 4
+압축 진행시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-compress\fP).  특수 값 \fB0\fP은 단일\-스레드 모드에서
+제한을 두지 않는 기본 설정임을 나타냅니다.
+.IP 3. 4
+압축 해제시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-decompress\fP).  특수 값 \fB0\fP은 단일\-스레드 모드에서
+제한을 두지 않는 기본 설정임을 나타냅니다.
+.IP 4. 4
+\fBxz\fP 5.3.4alpha 이후: 다중\-스레드 기반 압축 해제시 바이트 단위 메모리
+사용량(\fB\-\-memlimit\-mt\-decompress\fP).  분명하게 제한을 걸어두지 않았을 경우 5번째 컬럼에 나타난 시스템별
+기본값을 사용하기 때문에 0 값을 지정하면 안됩니다.  또한 \fB\-\-memlimit\-mt\-decompress\fP로 세번째 컬럼 값보다 더
+크게 지정을 한다 할지라도 이 값이 세번째 컬럼 값보다 크면 안됩니다.
+.IP 5. 4
+\fBxz\fP 5.3.4alpha 이후: A system\-specific default memory usage limit that is
+used to limit the number of threads when compressing with an automatic
+number of threads (\fB\-\-threads=0\fP)  and no memory usage limit has been
+specified (\fB\-\-memlimit\-compress\fP).  This is also used as the default value
+for \fB\-\-memlimit\-mt\-decompress\fP.
+.IP 6. 4
+\fBxz\fP 5.3.4alpha 이후: Number of available processor threads.
+.PP
+차후, \fBxz \-\-robot \-\-info\-memory\fP 출력에는 더 많은 내용이 들어가지만, 한 줄 이상은 넘어가지 않습니다.
+.
+.SS 버전
+\fBxz \-\-robot \-\-version\fP 은 \fBxz\fP 와 liblzma의 버전 번호를 다음 형식으로 나타냅니다:
+.PP
+\fBXZ_VERSION=\fP\fIXYYYZZZS\fP
+.br
+\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP
+.TP 
+\fIX\fP
+주 버전.
+.TP 
+\fIYYY\fP
+부 버전.  짝수가 안정 버전입니다.  홀수는 알파 또는 베타 버전입니다.
+.TP 
+\fIZZZ\fP
+안정 릴리스의 패치 수준 또는 개발 릴리스의 횟수입니다.
+.TP 
+\fIS\fP
+안정도.  0은 알파 버전, 1은 베타 버전을 나타내며, 2는 안정 버전을 나타냅니다.  \fIS\fP는 \fIYYY\fP 값이 짝수라 해도 항상
+2여야 합니다.
+.PP
+\fBxz\fP 명령과 liblzma이 동일한 XZ 유틸리티 릴리스에서 나왔다면 두 행의 \fIXYYYZZZS\fP 값은 같습니다.
+.PP
+예제: 4.999.9beta는 \fB49990091\fP이며, 5.0.0은 \fB50000002\fP입니다.
+.
+.SH "종료 상태"
+.TP 
+\fB0\fP
+모든 상태 양호.
+.TP 
+\fB1\fP
+오류 발생.
+.TP 
+\fB2\fP
+눈여겨볼 경고가 나타났지만, 실제 오류는 일어나지 않음.
+.PP
+표준 오류에 출력하는 알림(경고 또는 오류 아님)는 종료 상태에 영향을 주지 않습니다.
+.
+.SH 환경
+\fBxz\fP는 빈칸으로 구분한 옵션 값 목록을 \fBXZ_DEFAULTS\fP, \fBXZ_OPT\fP 환경 변수에서 순서대로, 명령행에서 옵션을
+해석하기 전에 불러옵니다.  참고로 환경 변수에서 옵션만 해석하며, 옵션이 아닌 부분은 조용히 무시합니다.  해석은
+\fBgetopt_long\fP(3)으로 가능하며,  명령행 인자로 활용하기도 합니다.
+.TP 
+\fBXZ_DEFAULTS\fP
+사용자별, 시스템 범위 기본 옵션입니다.  보통 \fBxz\fP의 메모리 사용량 제한을 기본으로 걸어둘 경우 셸 초기화 스크립트에
+설정합니다.  셸 초기화 스크립트와 별도의 유사한 경우를 제외하고라면, 스크립트에서는 \fBXZ_DEFAULTS\fP 환경 변수를 설정하지
+말거나 설정을 해제해야합니다.
+.TP 
+\fBXZ_OPT\fP
+\fBxz\fP 명령행으로 옵션 설정 값을 직접 전달할 수 없을 경우 \fBxz\fP에 옵션을 전달하는 환경 변수입니다.  예를 들어, \fBxz\fP를
+스크립트 또는 도구에서 실행할 경우 GNU \fBtar\fP(1) 라면:
+.RS
+.RS
+.PP
+.nf
+\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR
+.fi
+.RE
+.RE
+.IP ""
+예를 들면, 스크립트에서 \fBXZ_OPT\fP 를 활용하여, 스크립트별로 기본 압축 옵션을 지정할 수 있습니다.  적절한 이유가 있다면
+\fBXZ_OPT\fP 옵션 값을 사용자가 바꾸는걸 추천합니다.  예를 들면, \fBsh\fP(1)  스크립트에서 다음처럼 활용할 수도 있습니다:
+.RS
+.RS
+.PP
+.nf
+\f(CRXZ_OPT=${XZ_OPT\-"\-7e"}
+export XZ_OPT\fR
+.fi
+.RE
+.RE
+.
+.SH "LZMA 유틸리티 호환성"
+\fBxz\fP의 명령행 문법은 실제로 LZMA 유틸리티 4.32.x에서 찾을 수 있는 \fBlzma\fP, \fBunlzma\fP \fBlzcat\fP의
+상위 집합입니다.  대부분의 경우 LZMA 유틸리티를 XZ 유틸리티로 기존에 작성한 스크립트를 깨지 않고도 바꿀 수 있습니다.  몇가지
+비호환성 문제 때문에 문제가 일어날 수는 있습니다.
+.
+.SS "압축 사전 설정 단계"
+압축 수준 사전 설정의 번호 부여 방식은 \fBxz\fP와 LZMA 유틸리티가 동일하지 않습니다.  가장 중요한 차이는 다른 사전 설정에 대해
+딕셔너리 크기를 어떻게 대응했느냐 여부입니다.  딕셔너리 크기는 압축 해제시 메모리 사용량과 거의 비슷합니다.
+.RS
+.PP
+.TS
+tab(;);
+c c c
+c n n.
+단계;xz;LZMA 유틸리티
+\-0;256 KiB;없음
+\-1;1 MiB;64 KiB
+\-2;2 MiB;1 MiB
+\-3;4 MiB;512 KiB
+\-4;4 MiB;1 MiB
+\-5;8 MiB;2 MiB
+\-6;8 MiB;4 MiB
+\-7;16 MiB;8 MiB
+\-8;32 MiB;16 MiB
+\-9;64 MiB;32 MiB
+.TE
+.RE
+.PP
+딕셔너리 크기 차이는 압축 프로그램 메모리 사용에 영향을 주지만, LZMA 유틸리티와 XZ 유틸리티에서 사용량이 늘어나는 다른 차이점이
+있습니다:
+.RS
+.PP
+.TS
+tab(;);
+c c c
+c n n.
+단계;xz;LZMA 유틸리티 4.32.x
+\-0;3 MiB;없음
+\-1;9 MiB;2 MiB
+\-2;17 MiB;12 MiB
+\-3;32 MiB;12 MiB
+\-4;48 MiB;16 MiB
+\-5;94 MiB;26 MiB
+\-6;94 MiB;45 MiB
+\-7;186 MiB;83 MiB
+\-8;370 MiB;159 MiB
+\-9;674 MiB;311 MiB
+.TE
+.RE
+.PP
+XZ 유틸리티의 기본 사전 설정 수준값은 \fB\-6\fP이지만 LZMA 유틸리티의 기본 사전 설정 수준값은 \fB\-7\fP입니다. 두 프로그램의
+딕셔너리 메모리 기본 사용량은 8MiB입니다.
+.
+.SS "스트림 vs 비스트림 .lzma 파일"
+파일을 압축하지 않은 크기는 \fB.lzma\fP 헤더에 저장합니다.  LZMA 유틸리티는 일반 파일을 압축할 때 압축하지 않은 파일의 크기를
+저장합니다.  이 대신 압축하지 않은 크기를 '알 수 없음' 으로 저장하고 압축 해제 프로그램이 멈춰야 할 지점에
+end\-of\-payload 마커를 사용하는 방법도 있습니다.  LZMA 유틸리티는 파이프로 들어온 입력과 같이 압축하지 않은 파일의
+크기를 알 수 없을 때 이런 방식을 활용합니다.
+.PP
+\fBxz\fP는 \fB.lzma\fP 파일을 end\-of\-payload 마커의 유무와 관계없이 압축 해제 방식을 모두 지원하지만, \fBxz\fP로
+만든 모든 \fB.lzma\fP 파일은 end\-of\-payload 마커를 사용하며, \fB.lzma\fP 헤더에 압축하지 않은 파일 크기를 '알 수
+없음'으로 표기합니다. 이 방식은 드문 상황에서 문제를 야기할 수 있습니다.  예를 들면, 임베디드 장치의 \fB.lzma\fP 압축 해제
+프로그램은 압축을 해제했을 때 크기를 알아야 동작합니다.  이 문제를 만나면, LZMA 유틸리티 또는 LZMA SDK를 활용하여
+\&\fB.lzma\fP 파일에 압축 전 파일 크기 정보를 저장해야합니다.
+.
+.SS "지원하지 않는 .lzma 파일"
+\&\fB.lzma\fP 형식은 \fIlc\fP 값을 8까지 받아들이며, \fIlp\fP 값은 4까지 받아들입니다. LZMA 유틸리티는 어떤 \fIlc\fP 값과
+\fIlp\fP 값을 받아들이고도 압축을 해제할 수 있지만, 파일을 만들 때는 늘 \fBlc=3\fP 값과 \fBlp=0\fP 값을 활용합니다.  다른
+\fIlc\fP 값과 \fIlp\fP 값으로의 파일 압축은 \fBxz\fP와 LZMA SDK에서만 가능합니다.
+.PP
+liblzma의 LZMA1 필터 구현체에서는 \fIlc\fP 값과 \fIlp\fP 값의 합이 4를 넘어가면 안됩니다.  그래서 \fB.lzma\fP
+파일의 경우 이 제한을 넘어가면 \fBxz\fP로 압축을 해제할 수 없습니다.
+.PP
+LZMA 유틸리티는 2^\fIn\fP (2의 승수)크기를 지닌 딕셔너리를 가진 \fB.lzma\fP 파일만 만들지만 받아들이는 파일의 딕셔너리
+크기는 어떤 크기든 상관 없습니다.  liblzma에서는 2^\fIn\fP, 2^\fIn\fP + 2^(\fIn\fP\-1) 딕셔너리 크기를 가진
+\&\fB.lzma\fP 파일 만 받아들입니다. 이로 인해 \fB.lzma\fP 파일을 확인할 때 거짓 양성율이 늘어납니다.
+.PP
+모든 \fB.lzma\fP 파일을 liblzma 에서 받아들일 수 있도록 압축하기 때문에 이 제한이 실제로는 문제가 되지 않습니다.
+.
+.SS "뒤따라오는 쓰레기 값"
+압축 해제할 때, LZMA 유틸리티는 \fB.lzma\fP 스트림 처음 부분 다음 나머지를 다 조용히 무시합니다.  대부분의 경우,
+버그입니다.  LZMA 유틸리티에서 \fB.lzma\fP 결합 파일 압축 해제를 지원하지 않음을 의미하기도 합니다.
+.PP
+\&\fB.lzma\fP 스트림 처음부분 바로 다음에 데이터가 남아있을 경우, \fBxz\fP 에서는 \fB\-\-single\-stream\fP 옵션을 사용하지
+않으면 깨진 파일로 간주합니다.  이 동작으로 하여금 뒤따라오는 쓰레기 값을 무시하도록 간주하는 애매한 스크립트 동작을 깰 수가
+있습니��.
+.
+.SH 참고
+.
+.SS "출력 결과물이 달라짐"
+압축하지 않은 입력 파일로부터 얻어낸 정확한 압축 출력 결과물은 압축 옵션이 완전히 동일하더라도 XZ 유틸리티의 버전에 따라 달라질 수
+있습니다.  파일 형식에 영향을 주지 않고 인코더 그 자체를 개선(더 빠르게 하거나 더 나은 압축율로)하기 때문입니다.  XZ 유틸리티
+버전이 동일하더라도 빌드 옵션을 달리하여 빌드 상태가 제각각인 경우 출력 결과물이 달라질 수 있습니다.
+.PP
+\fB\-\-rsyncable\fP 기능을 넣었을 경우 동일한 xz 버전에서 이전 파일과 새 파일로 별도로 압축하지 않는 한 결과 파일을 (두
+파일이 서로 다른 파일이 아니므로) rsync 처리할 필요가 없습니다.  이 문제는 인코더 구현체 기능 개발이 끝나서 xz 버전이
+다르더라도 안정적인 rsync 가능한 출력 결과물을 유지할 수 있을 때여야 해결할 수 있습니다.
+.
+.SS "내장 .xz 압축 해제 프로그램"
+XZ 임베디드와 같은 내장 \fB.xz\fP 압축 해제 구현체는 지원 파일의 무결성 \fI검사\fP 형식을 \fInone\fP과 \fIcrc32\fP 이외의
+설정으로 만들 필요가 없습니다.  기본값이 \fB\-\-check=crc64\fP일 경우에만, 임베디드 시스템에서 파일을 만들 때
+\fB\-\-check=none\fP 또는 \fB\-\-check=crc32\fP 옵션을 사용해야합니다.
+.PP
+임베디드 시스템이 아니라면, 모든 \fB.xz\fP 형식 압축 해제 프로그램에서는 모든 \fI검사\fP 형식을 지원하거나, 일부 \fI검사\fP 방식을
+지원하지 않는다면, 최소한, 무결성 검사로 검증하지 않고 압축을 해제할 수 있습니다.
+.PP
+XZ 임베디드는 BCJ 필터를 지원하지만, 기본 시작 오프셋만 지정할 수 있습니다.
+.
+.SH 예제
+.
+.SS 기본
+\fIfoo\fP 파일을 기본 압축 수준 (\fB\-6\fP) 으로 \fIfoo.xz\fP 파일에 압축해 넣고, 압축 과정이 무사히 끝나면 \fIfoo\fP를
+삭제합니다:
+.RS
+.PP
+.nf
+\f(CRxz foo\fR
+.fi
+.RE
+.PP
+\fIbar.xz\fP를 \fIbar\fP 에 압축을 해제한 후 압축 해제가 무사히 끝나도 \fIbar.xz\fP를 삭제하지 않습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-dk bar.xz\fR
+.fi
+.RE
+.PP
+기본 사전 설정 \fB\-6\fP 보다는 느리지만, 압축 및 압축 해제시 메모리를 적게 차지(각각 48\ Mib, 5\MiB)는 \fB\-4e\fP
+사전 설정(\fB\-4 \-\-extreme\fP)을 활용하여 \fIbaz.tar.xz\fP 파일을 만듭니다:
+.RS
+.PP
+.nf
+\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR
+.fi
+.RE
+.PP
+압축 및 비압축 파일을 단일 명령으로 표준 출력에 압축해제할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR
+.fi
+.RE
+.
+.SS "다중 파일 병렬 압축"
+GNU와 *BSD에서는 \fBfind\fP(1)  명령과 \fBxargs\fP(1)  명령으로 여러 파일의 압축을 병렬 처리할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e
+    | xargs \-0r \-P4 \-n16 xz \-T1\fR
+.fi
+.RE
+.PP
+\fBxargs\fP(1)  의 \fB\-P\fP 옵션으로 \fBxz\fP 프로세스의 병렬 처리 갯수를 지정합니다.  \fB\-n\fP 옵션의 최적 값은 압축할
+파일 수에 달려있습니다.  압축할 파일이 몇개밖에 없다면 1이어야합니다. 파일이 수천 수만개 정도 된다면 \fBxargs\fP(1)  이
+어쨌든지간에 만들어낼 \fBxz\fP 프로세스의 겟수를 100으로 하거나 아니면 적당한 값을 지정하여 줄이는게 좋습니다.
+.PP
+\fBxz\fP에 \fB\-T1\fP옵션을 지정하면 단일\-스레드 모드로 강제합니다. \fBxargs\fP(1)  에서 병렬 처리 갯수를 제어할 수 있기
+때문입니다.
+.
+.SS "로봇 모드"
+여러 파일을 압축한 후 저장할 바이트 용량을 계산합니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR
+.fi
+.RE
+.PP
+이 스크립트에서는 충분히 최신의 \fBxz\fP 명령을 사용하는지 알아보려 합니다.  다음 \fBsh\fP(1)  스크립트에서는 \fBxz\fP 도구의
+버전 번호가 최소한 5.0.0인지 여부를 검사합니다.  이 방식은 \fB\-\-robot\fP 옵션을 지원하지 않는 오래된 베타 버전과도 호환성이
+있습니다:
+.RS
+.PP
+.nf
+\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" ||
+        [ "$XZ_VERSION" \-lt 50000002 ]; then
+    echo "Your xz is too old."
+fi
+unset XZ_VERSION LIBLZMA_VERSION\fR
+.fi
+.RE
+.PP
+\fBXZ_OPT\fP 환경 변수로 압축 해제시 메뢰 사용량 한계를 설정하지만, 한계 값을 이미 설정했다면, 값을 늘리지 않습니다:
+.RS
+.PP
+.nf
+\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB
+OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3)
+if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then
+    XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM"
+    export XZ_OPT
+fi\fR
+.fi
+.RE
+.
+.SS "개별 압축 필터 체인 설정"
+개별 설정 필터 체인의 초단순 사용방식은 LZMA2 사전 설정 값을 별도로 설정하는 방식입니다.  ���전 설정은 잠재적으로 쓸만한 압축
+설정 조합만 다루기 때문에 꽤 쓸모가 있을 수도 있습니다.
+.PP
+\fB\-0\fP ... \fB\-9\fP 옵션의 설명에서 테이블의 CompCPU 컬럼과 \fB\-\-extreme\fP 옵션은 LZMA2 사전 설정을
+개별적으로 맞췄을 때 쓸만할 수도 있습니다.  여기 관련내용을 테이블 둘로 정리해서 모아보았습니다:
+.RS
+.PP
+.TS
+tab(;);
+c c
+n n.
+Preset;CompCPU
+\-0;0
+\-1;1
+\-2;2
+\-3;3
+\-4;4
+\-5;5
+\-6;6
+\-5e;7
+\-6e;8
+.TE
+.RE
+.PP
+어떤 파일을 압축할 때 상당히 큰 딕셔너리(예: 32MiB)가 필요 하다는걸 알아채셨지만, \fBxz \-8\fP 명령이 압축할 때보다 더 빠른
+속도로 압축하려 한다면, 더 큰 딕셔너리 사용을 위해 더 낮은 CompCPU 사전 설정 값(예: 1)으로 수정할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR
+.fi
+.RE
+.PP
+각 파일에 대해, 위 명령은 압축율이 더 좋아지면서도 \fBxz \-6\fP보다 더 빨라집니다.  그러나, CompCPU 값을 낮게 유지하는
+대신 큰 딕셔너리에서 일부 파일을 강조해야 합니다.  큰 딕셔너리가 대부분의 도움을 주는 매우 명백한 상황에서는 최소한 몇 메가바이트의
+매우 유사한 각 파일이 아카이브에 들어갑니다.  딕셔너리 크기는 LZMA2가 연속으로 존재하는 각 파일의 유사성으로부터 얻는 장점을 취할
+수 있을 때 일부 개별 파일보다 훨씬 더 커집니다.
+.PP
+압축 프로그램과 압축 해제 프로그램에서 메모리를 엄청 많이 사용해도 상관 없고, 파일을 수백 메가 바이트 메모리 용량을 활용하여
+압축한다면, \fBxz \-9\fP 명령에 64MiB 용량을 초과하는 딕셔너리를 사용할 수 있게 하는 방법도 쓸만할 지도 모릅니다:
+.RS
+.PP
+.nf
+\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR
+.fi
+.RE
+.PP
+위 예제에서와 같이 \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) 옵션을 사용하면 압축 및 압축 해제 과정에서 필요한 메모리
+용량을 살펴보는데 요긴할 수 있습니다.  압축 해제한 파일 크기보다 더 큰 딕셔너리를 사용하면 불필요한 메모리 소모량이 발생하여 위
+명령이 작은 파일에는 쓸모 없음을 기억하십시오.
+.PP
+때로는 압축 시간이 딱히 상관이 없을 수도 있습니다만, 압축 해제시 메모리 사용량을 적게 유지해야 할 수도 있습니다. 예를 들면,
+임베디드 시스템에서 파일 압축을 해제할 수도 있습니다.  다음 명령의 경우 \fB\-6e\fP (\fB\-6 \-\-extreme\fP) 옵션을 기반
+옵션을 사용하며 딕셔너리 크기를 64KiB만 사용하도록 제한합니다.  결과 파일은 XZ 임베디드(이게 \fB\-\-check=crc32\fP
+옵션이 있는 이유)로 100KiB 메모리 용량을 활용하여 풀어낼 수 있습니다.
+.RS
+.PP
+.nf
+\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR
+.fi
+.RE
+.PP
+가능한 한 수 바이트를 더 쥐어 짜내고 싶을 때, 리터럴 문맥 비트 수(\fIlc\fP)와 위치 비트 수(\fIpb\fP)를 조정하면 도움이 될
+수도 있습니다.  리터럴 위치 비트 수(\fIlp\fP)를 조금 건드리는 것 또한 도움이 될 지도 모르겠지만 보통 \fIlc\fP 값과 \fIpb\fP
+값이 더 중요합니다.  예를 들면, 소스 코드 저장 파일에는 US\-ASCII 텍스트가 대부분이기에, 다음과 같은 경우는 \fBxz \-6e\fP
+명령을 실행했을 때부다는 아주 약간(거의 0.1% 수준) 작은 파일을 얻어낼 수도 있습니다(\fBlc=4\fP를 빼고도 시도해보십시오):
+.RS
+.PP
+.nf
+\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR
+.fi
+.RE
+.PP
+LZMA2와 다른 필터를 함께 사용하면 일부 파일 형식에 대해 압축율을 개선할 수 있습니다.  예를 들면 x86\-32 또는 x86\-64
+공유 라이브러리를 x86 BCJ 필터를 활용하여 압축할 경우:
+.RS
+.PP
+.nf
+\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR
+.fi
+.RE
+.PP
+참고로 필터 옵션의 순서는 상당히 중요합니다.  \fB\-\-x86\fP을 \fB\-\-lzma\fP 이전에 지정하면 \fBxz\fP에서 오류가 나는데,
+LZMA2 다음에는 어떤 필터든 설정할 수 없고, 옵션 체인상 마지막 필터로 x86 BCJ 필터를 사용할 수 없기 때문입니다.
+.PP
+LZMA2와 델타 필터는 비트맵 그림에 최적의 결과를 가져다줄 수 있습니다.  PNG에 보통 안성맞춥인데, PNG에는 단순 델타 필터보단
+약간 더 고급진 필터를 사용하지만, 실제 압축을 진행할 때는 Deflate를 사용하기 때문입니다.
+.PP
+예를 들어 이미지를 압축하지 않은 비압축 TIFF로 저장해야 하는 경우가 있습니다.  델타 필터의 거리 매개변수는 그림에서 픽셀당 바이트
+수에 일치하도록 설정합니다.  예를 들면, 24비트 RGB 비트맵의 경우 \fBdist=3\fP 거리 매개변수 값을 설정해야 하며, LZMA2
+압축시 3바이트 정렬을 따르도록 \fBpb=0\fP 값을 전달하는 방법도 바람직합니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR
+.fi
+.RE
+.PP
+여러 이미지를 단일 아카이브로 넣고 싶다면(예: \fB.tar\fP), 모든 이미지에 대해 동일한 픽셀당 바이트 수가 들어가는 경우에도 델타
+필터가 동작합니다.
+.
+.SH "추가 참조"
+\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1),
+\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1)
+.PP
+XZ 유틸리티: <https://tukaani.org/xz\-utils/>
+.br
+XZ 임베디드: <https://tukaani.org/xz/embedded/>
+.br
+LZMA SDK: <https://7\-zip.org/sdk.html>

janus/share/man/ko/man1/unxz.1

@@ -0,0 +1,1548 @@
+'\" t
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZ 1 2024\-12\-30 Tukaani "XZ 유틸리티"
+.
+.SH 이름
+xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz 파일과 .lzma 파일을 압축 또는 압축 해제합니다
+.
+.SH 요약
+\fBxz\fP [\fI<옵션>...\fP] [\fI<파일>...\fP]
+.
+.SH "명령 별칭"
+\fBunxz\fP 명령은 \fBxz \-\-decompress\fP 명령과 동일합니다.
+.br
+\fBxzcat\fP 명령은 \fBxz \-\-decompress \-\-stdout\fP 명령과 동일합니다.
+.br
+\fBlzma\fP 명령은 \fBxz \-\-format=lzma\fP 명령과 동일합니다.
+.br
+\fBunlzma\fP 명령은 \fBxz \-\-format=lzma \-\-decompress\fP 명령과 동일합니다.
+.br
+\fBlzcat\fP 명령은 \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP 명령과 동일합니다.
+.PP
+파일 압축을 해제해야 하는 셸 스크립트를 작성할 때, \fBunxz\fP 와 \fBxzcat\fP 이름 대신 \fBxz\fP 명령과 적절한 인자
+값(\fBxz \-d\fP 또는 \fBxz \-dc\fP)의 사용을 추천드립니다.
+.
+.SH 설명
+\fBxz\fP는 \fBgzip\fP(1)  과 \fBbzip2\fP(1)  과 비슷한 명령행 문법을 지닌 범용 데이터 압축 도구입니다.  자체 파일
+형식은 \fB.xz\fP 형식이나, LZMA 유틸리티에서 사용하는 예전 \fB.lzma\fP 형식과 형식 헤더가 없는 RAW 압축 스트림도
+지원합니다.  게다가, \fBlzip\fP에서 활용하는 \fB.lz\fP 형식 압축 해제도 지원합니다.
+.PP
+각 \fI파일\fP 에 대한 \fBxz\fP 압축 또는 압축 해제는 선택 동작 모드에 따릅니다.  \fI<파일>\fP 값이 주어졌거나
+\fI<파일>\fP 값이 \fB\-\fP이면, \fBxz\fP 명령에서 표준 입력을 읽고 처리한 데이터를 표준 출력에 기록합니다.
+\fBxz\fP 에서는 터미널에서 활용할 경우 압축 데이터를 표준 압축으로 기록하는 동작을 거절(오류를 출력하고 \fI<파일>\fP을
+건너뜀)합니다.  이와 비슷하게, \fBxz\fP 유틸리티를 터미널에서 실행하면 표준 입력의 압축 데이터 읽기를 거절합니다.
+.PP
+\fB\-\-stdout\fP 을 지정하지 않는 한, \fB\-\fP가 아닌 \fI<파일>\fP을 원본 \fI<파일>\fP 이름에서
+가져온 새 파일 이름으로 기록합니다:
+.IP \(bu 3
+압축할 때, 대상 파일 형식의 접미사(\fB.xz\fP or \fB.lzma\fP)  는 원본 파일 이름 뒤에 붙어 대상 파일이름이 됩니다.
+.IP \(bu 3
+압축 해제할 때, \fB.xz\fP, \fB.lzma\fP, \fB.lz\fP 접미사를 파일 이름에서 제거하고 대상 파일 이름을 알아냅니다.
+\fBxz\fP에서는 \fB.txz\fP, \fB.tlz\fP 접미사도 인식하며, \fB.tar\fP 접미사로 치환합니다.
+.PP
+대상 파일이 이미 있으면, 오류를 나타내고 \fI<파일>\fP을 건너뜁니다.
+.PP
+표준 출력으로 기록하기 전에는, \fBxz\fP는 경고를 나타내며, 다음 조건에 만족할 경우 \fI<파일>\fP을 건너뜁니다:
+.IP \(bu 3
+\fI<파일>\fP이 일반 파일이 아닐 때.  심볼릭 링크는 따라가지 않기에, 일반 파일로 간주하지 않습니다.
+.IP \(bu 3
+\fI<파일>\fP이 하나 이상의 하드 링크일 떄.
+.IP \(bu 3
+\fI<파일>\fP에 setuid, setgid, 끈적이 비트 집합이 붙어있을 떄.
+.IP \(bu 3
+동작 모드를 압축으로 설정하고, \fI<파일>\fP은 대상 파일 형식의 접미사를 이미 붙였을 때(\fB.xz\fP 형식으로 압축하면
+\&\fB.xz\fP 또는 \fB.txz\fP, \fB.lzma\fP 형식으로 압축하면 \fB.lzma\fP 또는 \fB.tlz\fP).
+.IP \(bu 3
+동작 모드를 압축 해제로 설정하고, \fI<파일>\fP에 지원 파일 형식 접미사(\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP,
+\&\fB.tlz\fP, \fB.lz\fP)를 붙이지 않았을 때.
+.PP
+\fI<파일>\fP 의 압축 또는 압축 해제를 성공하고 나면, \fBxz\fP는 소유자, 소유그룹, 권한, 접근 시각, 수정 시각
+정보를 원본 \fI<파일>\fP에서 대상 파일로 그대로 복사합니다.  그룹 정보 복사에 실패하면, 권한을 수정하여 원본
+\fI<파일>\fP에 접근 권한이 없는 사용자가 대상 파일로 접근하지 못하게 합니다.  \fBxz\fP는 아직 접근 제어 목록이나
+확장 속성 등의 기타 메타데이터를 복사하는 기능은 지원하지 않습니다.
+.PP
+대상 파일을 온전히 닫고 나면, \fB\-\-keep\fP 옵션을 지원하지 않았을 경우 원본 \fI<파일>\fP을 제거합니다.  원본
+\fI<파일>\fP은 출력을 표준 출력으로 기록했거나 오류가 발생했을 경우 제거하지 않습니다.
+.PP
+\fBxz\fP 프로세스에 \fBSIGINFO\fP 시그널 또는 \fBSIGUSR1\fP 시그널을 보내면 표준 출력으로 진행 정보를 출력합니다.  표준
+오류가 터미널일 경우일 경우에만 제한하며 \fB\-\-verbose\fP 옵션을 지정하면 진행 표시줄을 자동으로 나타냅니다.
+.
+.SS "메모리 사용"
+\fBxz\fP 메모리 사용은 수백 킬로바이트로 시작하여 수 기가바이트까지 압축 설정에 따라 다릅니다.  압축 해제 프로그램이 필요로 하는
+메모리 공간을 결정하는 파일 압축시에 설정 값을 활용합니다.  보통 압축 해제 프로그램은 파일을 만들 때, 압축 프로그램 메모리 사용량의
+5% 에서 20% 정도 필요합니다.  예를 들면, \fBxz \-9\fP로 압축한 파일 압축 해제시 현재 65MiB 메모리 용량이 필요합니다.
+여전하게도, 압축 해제시 수 기가 바이트의 메모리가 필요한 \fB.xz\fP 파일에도 가능한 이야기입니다.
+.PP
+특히 이전 시스템 사용자의 경우 메모리 사용량이 엄청나게 늘어나는 점에 짜증이 날 수 있습니다.  이런 불편한 상황을 피하기 위해,
+\fBxz\fP에 기본적으로 비활성 상태인 내장 메모리 사용 제한 기능을 넣었습니다.  일부 운영체제에서 처리 중 메모리 사용을 제한하는
+수단을 제공하긴 하지만, 여기에 의지하기에는 충분히 유연하지 않습니다(예를 들면, \fBulimit\fP(1)을 사용하면 가상 메모리를
+제한하여  \fBmmap\fP(2)을 먹통으로 만듭니다).
+.PP
+메모리 사용 제한 기능은 \fB\-\-memlimit=\fP\fI<제한용량>\fP 명령행 옵션으로 사용할 수 있습니다.  종종
+\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP와 같이 \fBXZ_DEFAULTS\fP 환경 변수를 설정하여 제한 기능을 켜는게 더
+편합니다.  \fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션과
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP 옵션을 활용하여 압축 및 압축 해제시 별도로 한계 값을
+설정할 수 있습니다.  이 두 가지 옵션의 \fBXZ_DEFAULTS\fP 환경 변수 밖에서의 사용은, \fBxz\fP를 단일 실행할 때 압축 및
+압축 해제 동작을 동시에 수행하지 않으며, 앞서 언급한 두가지 옵션을 명령행에 입력하기에는
+\fB\-\-memlimit=\fP\fI<제한용량>\fP(또는 \fB\-M\fP \fI<제한용량>\fP)이 더 짧기 때문에 별로 쓸모가
+없습니다.
+.PP
+압축 해제시 메모리 사용 제한 지정 한계를 초과하면, \fBxz\fP 유틸리티에서 오류를 나타내며 파일 압축 해제는 실패합니다.  압축을
+실행할 때 사용 제한 지정 한계를 넘어서면 \fBxz\fP에서는 설정 값을 줄여서 어쨌든 한계를 넘지 못하게
+합니다(\fB\-\-format=raw\fP 옵션 또는 \fB\-\-no\-adjust\fP 옵션 사용시 제외).  설정 한계 값이 엄청 작지 않은 이상 이
+방식대로 처리하면 어쨌든 실패하지 않습니다.  설정 값조정은 압축 래벨 사전 설정과 일치하지 않을 때 단계적으로 진행하는데, 이를테면,
+\fBxz \-9\fP 명령 수행에 필요한 양보다 한계 값이 약간 작으면, 설정 값을 \fBxz \-8\fP에 못미치게 약간 줄여서 진행합니다.
+.
+.SS ".xz 파일 결합 및 패딩"
+\&\fB.xz\fP 파일을 있는 그대로 합칠 수 있습니다.  \fBxz\fP는 \fB.xz\fP 파일을 단독 파일일 때 처럼 압축해제합니다.
+.PP
+결합 부분과 마지막 부분 뒤에 패딩을 추가할 수 있습니다.  패딩은 널 바이트로 구성해야 하며 패딩 길이는 4바이트로 구성해야 합니다.
+512 바이트 블록으로 파일 크기를 이루는 매체에 \fB.xz\fP 파일을 저장했을 경우에 요긴할 수 있습니다.
+.PP
+\&\fB.lzma\fP 파일 또는 원시 스트림의 경우 결합과 패딩을 허용하지 않습니다.
+.
+.SH 옵션
+.
+.SS "정수 접두사와 별도 값"
+정수 인자값이 필요한 대부분 위치에서는, 큰 정수값을 나타내기 쉽게 하도록 추가 접미사를 지원합니다.  정수와 접미사 사이에 어떤 공백이
+있으면 안됩니다.
+.TP 
+\fBKiB\fP
+1,024 (2^10) 배수 정수값. \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, \fBKB\fP 단위를 \fBKiB\fP 동의어로 받아들입니다.
+.TP 
+\fBMiB\fP
+1,048,576 (2^20) 배수 정수값. \fBMi\fP, \fBm\fP, \fBM\fP, \fBMB\fP 단위를 \fBMiB\fP 동의어로 받아들입니다.
+.TP 
+\fBGiB\fP
+1,073,741,824 (2^30) 배수 정수값.  \fBGi\fP, \fBg\fP, \fBG\fP, \fBGB\fP 단위를 \fBGiB\fP 동의어로
+받아들입니다.
+.PP
+특수 값 \fBmax\fP는 옵션에서 지원하는 정수 최대 값을 나타낼 때 사용할 수 있습니다.
+.
+.SS "동작 모드"
+여러 동작 모드를 보여드리겠습니다만, 마지막에 주어진 동작 모드로 동작합니다.
+.TP 
+\fB\-z\fP, \fB\-\-compress\fP
+압축합니다.  어떤 동작 모드 옵션도 지정하지 않고 다른 동작 모드를 명령행에 따로 지정하지 않았다면 이 동작 모드는 기본입니다(예:
+\fBunxz\fP 는 \fB\-\-decompress\fP를 암시).
+.IP ""
+.\" The DESCRIPTION section already says this but it's good to repeat it
+.\" here because the default behavior is a bit dangerous and new users
+.\" in a hurry may skip reading the DESCRIPTION section.
+After successful compression, the source file is removed unless writing to
+standard output or \fB\-\-keep\fP was specified.
+.TP 
+\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP
+.\" The DESCRIPTION section already says this but it's good to repeat it
+.\" here because the default behavior is a bit dangerous and new users
+.\" in a hurry may skip reading the DESCRIPTION section.
+Decompress.  After successful decompression, the source file is removed
+unless writing to standard output or \fB\-\-keep\fP was specified.
+.TP 
+\fB\-t\fP, \fB\-\-test\fP
+압축 \fI<파일>\fP의 무결성을 시험해봅니다.  이 옵션은 압축 해제 데이터를 표준 출력으로 기록하는 대신 버린다는 점을
+제외하고 \fB\-\-decompress \-\-stdout\fP과 동일합니다.  어떤 파일도 만들거나 제거하지 않습니다.
+.TP 
+\fB\-l\fP, \fB\-\-list\fP
+압축 \fI<파일>\fP 정보를 출력합니다.  압축 해제 출력을 내보내지 않으며, 어떤 파일도 만들거나 제거하지 않습니다.  이
+조회 모드에서, 프로그램은 표준 입력 또는 기타 탐색 불가능한 원본에서 압축 데이터를 읽을 수 없습니다.
+.IP ""
+\fI<파일>\fP 기본 정보를 파일 당 한 줄 씩 기본으로 보여줍니다.  더 자세한 정보를 보려면 \fB\-\-verbose\fP
+옵션을 사용하십시오.  더 자세한 정보는 \fB\-\-verbose\fP 옵션을 두번 사용하면 되지만, 추가 정보를 더 많이 가져오면서 탐색
+횟수가 늘어나는 문제로 인해 느려질 수 있습니다.  세부 출력 너비는 80 문자를 초과하며, 예를 들어 출력을 파이핑한다면, 터미널이
+충분히 너비가 넓지 못할 경우 \fBless\ \-S\fP 명령이 편리할 수 있습니다.
+.IP ""
+정확한 출력은 \fBxz\fP 버전과 다른 로캘에 따라 바뀔 수 있습니다.  기계 판독용 출력시 \fB\-\-robot \-\-list\fP 옵션을
+사용합니다.
+.
+.SS "동작 수정자"
+.TP 
+\fB\-k\fP, \fB\-\-keep\fP
+입력 파일을 삭제하지 않습니다.
+.IP ""
+\fBxz\fP 5.2.6 부터는 이 옵션으로 입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid,
+setgid, 끈적이 비트 세트를 설정한 상태라도 압축하거나 압축을 풀 수 있습니다. setuid, setgid, 끈적이 비트는 대상
+파일에 복사하지 않습니다.  이전 버전에서는 \fB\-\-force\fP 옵션을 지정했을 때만 가능했습니다.
+.TP 
+\fB\-f\fP, \fB\-\-force\fP
+이 옵션은 몇가지 동작에 영향을 줍니다:
+.RS
+.IP \(bu 3
+대상 파일이 이미 있으면, 압축 또는 압축 해제 전 삭제합니다.
+.IP \(bu 3
+입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, setgid, 끈적이 비트 세트를 설정한
+상태라도 압축 또는 압축 해제를 진행합니다.  setuid, setgid, 끈적이 비트는 대상 파일에 복사하지 않습니다.
+.IP \(bu 3
+\fB\-\-decompress\fP \fB\-\-stdout\fP 옵션을 같이 사용하는 상황에서 \fBxz\fP 명령이 원본 파일의 형식을 알아내지 못할 때,
+원본 파일의 사본을 표준 출력으로 보냅니다.  이렇게 하면 \fBxzcat\fP \fB\-\-force\fP 명령을 \fBxz\fP 명령으로 압축하지 않은
+파일에 대해 \fBcat\fP(1) 을 사용하는 것처럼 사용할 수 있습니다.  참고로 나중에, \fBxz\fP에서 \fBxz\fP로 하여금 여러 형식의
+파일을 표준 출력으로 복사하는 대신 압축을 해제하도록 새 압축 파일 형식을 지원할 예정입니다.
+\fB\-\-format=\fP\fI<형식>\fP 옵션은 \fBxz\fP 명령에 단일 파일 형식만 압축 해제하도록 제한할 때 사용할 수
+있습니다.
+.RE
+.TP 
+\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP
+파일 대신 표준 출력으로 압축 또는 압축 해제한 데이터를 기록합니다.  \fB\-\-keep\fP를 생략했습니다.
+.TP 
+\fB\-\-single\-stream\fP
+처음 \fB.xz\fP 스트림만 압축 해제하며, 스트림에 뒤따라오는 나머지 입력 데이터는 조용히 무시합니다.  보통 뒤따라오는 쓰레기 값에
+대해서는 \fBxz\fP 에서 오류를 나타냅니다.
+.IP ""
+\fBxz\fP는 \fB.lzma\fP 파일 또는 원시 스트림에서 온 하나 이상의 스트림에 대해 압축 해제동작을 취하지 않지만, 이 옵션을 사용하면
+\fBxz\fP에서 \fB.lzma\fP 파일 또는 원시 스트림을 처리한 다음에 뒤따라오는 데이터를 무시하도록 합니다.
+.IP ""
+이 옵션은 동작 모드가 \fB\-\-decompress\fP 또는 \fB\-\-test\fP가 아니면 동작에 아무런 영향을 주지 않습니다.
+.TP 
+\fB\-\-no\-sparse\fP
+희소 파일을 만들지 않습니다.  기본적으로 일반 파일로 압축 해제할 경우 \fBxz\fP 에서는 압축 해제한 파일에 이진 0값이 길게 늘어질
+경우 희소 배열 파일을 만들려고 합니다.  표준 출력의 내용 길이만큼 연결한 일반 파일로 기록할 때도 동작하며 희소 파일을 만드는 동안
+아무런 ��제가 나타나지 않게 각각의 추가 조건을 만족합니다.  희소 파일을 만들면 디스크 공간을 절약할 수 있으며 디스크 입출력을 줄여
+압축 해제 속도를 올릴 수 있습니다.
+.TP 
+\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP
+압축할 때, 대상 파일의 접두사를 \fB.xz\fP 또는 \fB.lzma\fP 대신 \fI.suf\fP로 사용하십시오.  표준 출력으로 기록하지 않고
+원본 파일에 \fI.suf\fP 접두사가 붙어있으면, 경고를 나타내고 해당 파일을 건너뜁니다.
+.IP ""
+압축 해제할 때, \fI.suf\fP 접미사로 파일을 인식하기도 하고, \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP,
+\&\fB.lz\fP 접미사가 붙은 파일도 인식합니다.  원본 파일에 \fI.suf\fP 접미사가 붙어있으면, 해당 접미사를 제거하여 대상 파일 이름을
+알아냅니다.
+.IP ""
+원시 스트림 압축 및 압축 해제시(\fB\-\-format=raw\fP) 원시 스트림에 기본 접미사가 없기 때문에, 표준 출력으로 기록하지 않는
+한 접미사를 반드시 지정해야 합니다.
+.TP 
+\fB\-\-files\fP[\fB=\fP\fI<파일>\fP]
+\fI<파일>\fP에서 처리할 파일 이름을 읽습니다. \fI<파일>\fP을 생략하면 파일 이름은 표준 입력에서
+불러옵니다.  파일 이름은 개행 문자로 끝나야 합니다.  대시 문자(\fB\-\fP)는 일반 파일 이름으로 취급하며 표준 입력을 의미하지
+않습니다.  파일 이름을 명령행 인자로 지정하면, \fI<파일>\fP에서 파일 이름을 읽어들이기 전 해당 명령행 인자를 먼저
+처리합니다.
+.TP 
+\fB\-\-files0\fP[\fB=\fP\fI<파일>\fP]
+각 파일 이름이 널 문자로 끝나야 한다는 점만 제외하면 \fB\-\-files\fP[\fB=\fP\fI<파일>\fP] 옵션과 동일합니다.
+.
+.SS "기본 파일 형식 및 압축 옵션"
+.TP 
+\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fI<형식>\fP
+압축 또는 압축해제 파일 \fI<형식>\fP을 지정합니다:
+.RS
+.TP 
+\fBauto\fP
+기본 값입니다.  압축할 때, \fBauto\fP는 \fBxz\fP의 기본 동작과 동일합니다.  압축을 해제할 때, 입력 파일 형식을 자동으로
+찾습니다.  참고로 원시 스트림(\fB\-\-format=raw\fP)의 경우 자동으로 찾을 수 없습니다.
+.TP 
+\fBxz\fP
+\&\fB.xz\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.xz\fP 파일만 받아들입니다.
+.TP 
+\fBlzma\fP, \fBalone\fP
+이전 \fB.lzma\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.lzma\fP 파일만 받아들입니다.  \fBalone\fP 대체 명령은 LZMA
+유틸리티 하위 호환성을 목적으로 제공합니다.
+.TP 
+\fBlzip\fP
+압축 해제시 \fB.lz\fP 파일만 받아들입니다.  압축은 지원하지 않습니다.
+.IP ""
+\&\fB.lz\fP 형식 버전 0과 비확장 버전 1을 지원합니다.  버전 0파일은 \fBlzip\fP 1.3 이전에서만 만듭니다.  일반적이진 않지만
+일부 파일의 경우 이 형식과 관련된 원본 패키지로 보관한 파일을 찾을 수도 있습니다.  개인적으로 이 형식으로 압축한 오래된 개인 파일을
+가지고 있을 수도 있습니다.  형식 버전 0 압축 해제 지원은 \fBlzip\fP 1.18에서 제거했습니다.
+.IP ""
+\fBlzip\fP 1.4 이상에서는 버전 1형식의 파일을 만듭니다.  형식 버전 1로의 동기화 제거 마커 확장은 \fBlzip\fP 1.6에
+추가했습니다.  이 확장은 거의 쓰지 않으며 \fBxz\fP 에서 조차도 지원하지 않습니다(손상된 입력 파일로 진단함).
+.TP 
+\fBraw\fP
+원시 스트림으로 압축하거나 압축을 해제합니다(헤더 없음).  고급 사용자 전용입니다.  원시 스트림을 디코딩하려면,
+\fB\-\-format=raw\fP 옵션을 사용하고 분명하게 필터 체인을 지정하여 컨테이너 헤더에 필요한 정보를 저장하게 끔 해야합니다.
+.RE
+.TP 
+\fB\-C\fP \fI<검사방식>\fP, \fB\-\-check=\fP\fI<검사방식>\fP
+무결성 검사 방식을 지정합니다.  검사 방식은 \fB.xz\fP 파일에 저장하며 압축 해제 데이터를 계산합니다.  이 옵션은 \fB.xz\fP
+형식으로 압축할 때만 효력이 있습니다: \fB.lzma\fP 형식은 무결성 겁사를 지원하지 않습니다.  무결성 검사는 \fB.xz\fP 파일 압축을
+풀었을 때에 검사합니다.
+.IP ""
+지원 \fI검사\fP 형식:
+.RS
+.TP 
+\fBnone\fP
+어떤 경우에도 무결성 검사 계산을 수행하지 않습니다.  보통 바람직하지 못한 생각입니다.  데이터 무결성을 다른 방식으로라도 검증해야
+하는 상황이면 쓸만할 수 있습니다.
+.TP 
+\fBcrc32\fP
+IEEE\-802.3 (이더넷)의 다항 연산으로 CRC32를 계산합니다.
+.TP 
+\fBcrc64\fP
+ECMA\-182의 다항식 연산으로 CRC64를 계산합니다.  이 동작이 기본 동작이기 때문에 CRC32가 깨진 파일을 찾을 때보다는 좀
+낮은 편이며 속도 차이도 거의 없습니다.
+.TP 
+\fBsha256\fP
+SHA\-256 해시를 계산합니다.  CRC32와 CRC64 보다는 좀 느립니다.
+.RE
+.IP ""
+\&\fB.xz\fP 헤더 무결성은 항상 CRC32로 검증하빈다.  이를 바꾸거나 It is not possible to change or
+disable it.
+.TP 
+\fB\-\-ignore\-check\fP
+압축 데이터를 압축해제할 경우 압축 데이터의 무결성 검증을 진행하지 않습니다.  \fB.xz\fP 헤더의 CRC32 값은 그래도 여전히 보통
+방식으로 검증합니다.
+.IP ""
+\fB이 옵션이 정확히 무슨 동작을 하는지 알기 전에는 사용하지 마십시오.\fP 이 옵션을 사용하는 타당한 이유로:
+.RS
+.IP \(bu 3
+깨진 .xz 파일에서 데이터 복구를 시도합니다.
+.IP \(bu 3
+압축 해제 속도를 늘립니다.  SHA\-256 또는 압축 파일에 들어간 그 무언가를 엄청 빨리 처리합니다.  다른 방식으로 파일 무결성을
+검증해야 하는 목적이 아니라면 이 옵션을 사용하지 않는게 좋습니다.
+.RE
+.TP 
+\fB\-0\fP ... \fB\-9\fP
+압축 사전 설정 수준을 선택합니다.  기본값은 \fB\-6\fP입니다.  다중 수준을 지정하면 가장 마지막 수준 옵션을 적용합니다.  개별 필터
+체인을 이미 지정했다면, 압축 사전 설정 수준 값을 설정할 때 개별 필터 체인을 정리합니다.
+.IP ""
+사전 설정간 차이는 \fBgzip\fP(1)과 \fBbzip2\fP(1)을 사용할 때보다 더 비중을 차지합니다.  선택한 압축 설정은 압축 해제시
+필요한 메모리 사용량을 셜정하므로 사전 설정 수준 값을 너무 높게 지정하면 RAM 용량이 적은 오래된 시스템에서 파일 압축 해제시 실패할
+수 있습니다.  게다가, \fBgzip\fP(1)  과 \fBbzip2\fP(1)에서 처럼 종종 \fB모든 동작에 \-9를 몰래 활용하는건 바람직하지 않습니다\fP.
+.RS
+.TP 
+\fB\-0\fP ... \fB\-3\fP
+동작이 빠른 사전 설정 부류입니다. \fB\-0\fP은 때로는 \fBgzip \-9\fP 명령보다 압축율이 훨씬 우수하면서도 더 빠릅니다.  더 큰
+값은 보통 \fBbzip2\fP(1) 명령과 비교했을 떄 압축 결과가 압축 데이터에 따라 달라지더라도, 비교할 법한 속도 또는 더 나은
+압축율을 보입니다.
+.TP 
+\fB\-4\fP ... \fB\-6\fP
+오래된 시스템에서 조차도 압축 해제 프로그램의 적절한 메모리 사용량을 보이면서 양호하거나 최적의 압축율을 보여줍니다.  \fB\-6\fP 옵션은
+압축 해제시 메모리 사용량이 16MiB 밖에 안되기 때문에 파일을 배포할 때 최적의 선택인 기본 값입니다.  (\fB\-5e\fP 또는
+\fB\-6e\fP도 역시 고려할 만합니다.  \fB\-\-extreme\fP을 참고하십시오.)
+.TP 
+\fB\-7 ... \-9\fP
+\fB\-6\fP과 비슷하지만 압축 및 압축 해제시 요구 메모리 사용량이 더 높습니다.  압축 파일이 각각 8MiB, 16MiB, 32MiB
+보다 클 경우에만 쓸만한 옵션입니다.
+.RE
+.IP ""
+동일한 하드웨어에서, 압축 해제 속도는 압축한 데이터의 초당 정적 바이트 처리 수의 어림 평균입니다.  다시 말해, 압축율을 더 올리면,
+압축 해제 속도도 역시 올라갑니다.  이는 곧 초당 비압축 데이터 출력 양이 달라질 수 있단 뜻입니다.
+.IP ""
+다음 표에 사전 설정 기능을 정리했습니다:
+.RS
+.RS
+.PP
+.TS
+tab(;);
+c c c c c
+n n n n n.
+Preset;DictSize;CompCPU;CompMem;DecMem
+\-0;256 KiB;0;3 MiB;1 MiB
+\-1;1 MiB;1;9 MiB;2 MiB
+\-2;2 MiB;2;17 MiB;3 MiB
+\-3;4 MiB;3;32 MiB;5 MiB
+\-4;4 MiB;4;48 MiB;5 MiB
+\-5;8 MiB;5;94 MiB;9 MiB
+\-6;8 MiB;6;94 MiB;9 MiB
+\-7;16 MiB;6;186 MiB;17 MiB
+\-8;32 MiB;6;370 MiB;33 MiB
+\-9;64 MiB;6;674 MiB;65 MiB
+.TE
+.RE
+.RE
+.IP ""
+컬럼 설명:
+.RS
+.IP \(bu 3
+DictSize는 LZMA2 딕셔너리 크기입니다.  압축 해제 파일의 크기보다 딕셔너리에서 사용하는 낭비 메모리 용량입니다.  실제로
+필요하지 않은 \fB\-7\fP ... \fB\-9\fP 사전 설정값을 피해야 하는 적절한 이유이기도 합니다.  \fB\-6\fP 이하에서는 소모 메모리 양이
+충분히 적거나 따로 신경쓸 필요가 없습니다.
+.IP \(bu 3
+CompCPU는 압축 속도에 영향을 주는 LZMA2 설정의 단순화 표기 값입니다.  딕셔너리 크기는 속도에도 영향을 주기 때문에
+CompCPU는 \fB\-6\fP ... \fB\-9\fP 수준값과 동일한데, 고수준 값은 여전히 조금 더 느려질 수 있습니다.  느려지는 만큼
+압축율은 가능한 한 더 좋아집니다. \fB\-\-extreme\fP을 참고하십시오.
+.IP \(bu 3
+CompMem은 단일\-스레드 모드에서 필요한 압축 프로그램의 메모리 점유 용량입니다.  \fBxz\fP 버전에 따라 다를 수 있습니다.
+.IP \(bu 3
+DecMem은 압축 해제 프로그램의 메모리 점유용량입니다.  이는 곧, 압축 해제 프로그램에서 필요한 메모리 사용량을 압축 설정에서
+결정한다는 의미가 들어있습니다.  정확한 압축 해제 프로그램의 메모리 사용량은 LZMA2 딕셔너리 크기 보다는 조금 많지만 테이블의 값은
+MiB 용량으로 완전히 반올림한 값입니다.
+.RE
+.IP ""
+다중\-스레드 모드에서 필요한 메모리 용량은 단일\-스레드 모드보단 약간 더 많습니다.  \fB\-\-block\-size\fP 기본값에 따라, 각
+스레드에서는 3*3*딕셔녀리_크기 + 압축시_메모리용량 또는 압축_해제시_메모리용량 정도가 필요합니다.  예를 들면, 스레드 넷에 사전
+설정 옵션 \fB\-6\fP을 사용한다면, 660\(en670 MiB 메모리 용량이 필요합니다.
+.TP 
+\fB\-e\fP, \fB\-\-extreme\fP
+기대하는 만큼의 좀 더 나은 압축율을 확보하려 선택한 압축 사전 설정 수준의 느린 변형 옵션을 사용하지만, 재수 없는 와중에 골로 가는
+경우가 생기기도 합니다.  압축 해제 프로그램의 메모리 사용에는 영향을 주지 않지만, 압축 프로그램의 메모리 사용량은 \fB\-0\fP
+\&... \fB\-3\fP 사전 설정 수준에서 약간 더 올라갈 뿐입니다.
+.IP ""
+4MiB와 8MiB 두 가지 딕셔너리 용량 설정이 있기 때문에 \fB\-3e\fP 와 \fB\-5e\fP 사전 설정을 (CompCPU 수치를 낮춰서)
+각각 \fB\-4e\fP 와 \fB\-6e\fP 보다 약간 더 빠르게 설정할 수 있습니다.  이런 식으로 두 사전 설정이 동일하지 않습니다.
+.RS
+.RS
+.PP
+.TS
+tab(;);
+c c c c c
+n n n n n.
+Preset;DictSize;CompCPU;CompMem;DecMem
+\-0e;256 KiB;8;4 MiB;1 MiB
+\-1e;1 MiB;8;13 MiB;2 MiB
+\-2e;2 MiB;8;25 MiB;3 MiB
+\-3e;4 MiB;7;48 MiB;5 MiB
+\-4e;4 MiB;8;48 MiB;5 MiB
+\-5e;8 MiB;7;94 MiB;9 MiB
+\-6e;8 MiB;8;94 MiB;9 MiB
+\-7e;16 MiB;8;186 MiB;17 MiB
+\-8e;32 MiB;8;370 MiB;33 MiB
+\-9e;64 MiB;8;674 MiB;65 MiB
+.TE
+.RE
+.RE
+.IP ""
+예를 들면, 8MiB 딕셔너리를 활용하는 네가지 사전 설정이 있다고 할 때, 빠른 순으로 설정을 나열하자면, \fB\-5\fP, \fB\-6\fP,
+\fB\-5e\fP, \fB\-6e\fP 입니다.
+.TP 
+\fB\-\-fast\fP
+.PD 0
+.TP 
+\fB\-\-best\fP
+.PD
+이 옵션은 \fB\-0\fP 과 \fB\-9\fP의 별칭으로 각각 오해할 수 있습니다. LZMA 유틸리티의 하위 호환성을 목적으로 제공합니다.  이
+옵션 사용은 피하십시오.
+.TP 
+\fB\-\-block\-size=\fP\fI<크기>\fP
+\&\fB.xz\fP 형식으로 압축할 때, 입력 데이터를 \fI<크기>\fP 바이트 블록으로 입력 데이터를 쪼갭니다.  각각의 블록은
+다중\-스레드 방식으로 처리할 수 있고 임의 접근 압축 해제 가능성을 제한할 수 있게 개별적으로 압축 처리합니다.  이 옵션은 보통
+다중\-스레드 모드에서 기본 블록 크기를 지정할 때 사용하지만, 단일\-스레드 모드에서도 사용할 수 있습니다.
+.IP ""
+다중\-스레드 모드에서는 약 3배 용량의 \fI<크기>\fP 바이트만큼 각 스레드 별로 입출력 버퍼링용 공간을 할당합니다.  기본
+\fI<크기>\fP는 LZMA2 딕셔너리 크기 또는 1MiB 중 가장 큰 쪽의 세 배입니다.  보통 적절한 값으로 LZMA2
+딕셔너리 크기 또는 최소한 1MiB 용량의 2\(en4배입니다.  LZMA2 딕셔너리 크기보다 작은 \fI<크기>\fP는 램의
+소모적 사용 공간으로 할당하는데 LZMA2 딕셔너리 버퍼를 할당한 용량 크기 전체를 다 사용하지 않기 때문입니다.  다중\-스레드 모드에서
+블록 크기는 블록 헤더에 저장하며, 이 크기 정보는 다중\-스레드 압축 해제시 필요합니다.
+.IP ""
+단일\-스레드 모드에서는 기본적으로 블록 쪼개기를 하지 않습니다.  이 옵션을 설정한다고 해서 메모리 사용에 영향을 주지는 않습니다.
+블록 헤더에 크기 정보를 저장하지 않기 때문에 단일\-스레드 모드에서 만든 파일은 다중\-스레드 모드에서 만든 파일과 동일하지 않습니다.
+크기 정보의 누락은 또한 \fBxz\fP에서 다중\-스레드 모드로 압축 해제를 진행할 수 없음을 의미하기도 합니다.
+.TP 
+\fB\-\-block\-list=\fP\fI<항목>\fP
+\&\fB.xz\fP 형식으로 압축할 때, 압축하지 않은 데이터로 부터 일정 간격 이후에 새 블록 처리를 시작합니다.
+.IP ""
+\fI<항목>\fP은 쉼표로 구분한 목록으로 지정합니다.  각 항목은 콜론 (\fB:\fP)으로 구분한 0부터 9까지의 추가 필터
+체인 번호 값으로 이루어져 있으며, 압축하지 않은 데이터의 크기 값이 필요합니다.  항목을 생략하면(둘 이상의 쉼표 연속 표기) 이전
+항목의 크기와 필터를 활용하겠다는 함축 의미를 넣을 수 있습니다.
+.IP ""
+입력 파일이 \fI<항목>\fP 크기의 합보다 크면, 마지막 항목을 파일의 끝까지 반복합니다.  특별히 \fB0\fP 값을 마지막
+값으로 사용하여 파일 나머지 부분을 단일 블록으로 인코딩해야 한다는 의미를 나타낼 수도 있습니다.
+.IP ""
+\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션 조합으로
+각 블록별 별도 필터 체인을 지정할 수 있습니다.  이 옵션은 1\(en9번 필터 체인을 지정합니다. 필터 체인 0번은 필터 체인을
+지정하지 않았을 때와 동일한 기본 필터 체인으로 참조할 수 있습니다.  필터 체인 식별 번호는 비 ���축 크기 앞에 콜론(\fB:\fP)을 붙여
+사용할 수 있습니다. 예를 들면, \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP 옵션을
+지정했을 경우 다음 규칙대로 블록을 만듭니다:
+.RS
+.IP \(bu 3
+\fB\-\-filters1\fP 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+\fB\-\-filters3\fP 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을
+.IP \(bu 3
+\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을
+.IP \(bu 3
+기본 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+입력이 끝나기 전의 모든 블록에는 기본 필터 체인과 4MiB 입력을 적용합니다.
+.RE
+.IP ""
+인코더 블록 크기를 초과하는 크기 값을 지정하면(스레드 모드 기본값 또는 \fB\-\-block\-size=\fP\fI<크기>\fP
+옵션으로 지정한 값), 인코더는 \fI<크기>\fP 지정 용량 범위는 유지하면서 추가 블록을 만듭니다.  예를 들면
+\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP 옵션을 지정하고
+입력 파일을 80MiB 용량으로 전달하면, 각각 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, 1 MiB 용량을
+차지하는 블록 11개를 결과물로 내줍니다.
+.IP ""
+다중\-스레드 모드에서 블록 크기는 블록 헤더에 저장합니다.  단일\-스레드 모드에서는 저장하지 않기 때문에 인코딩 처리한 출력은
+다중\-스레드 모드의 출력 결과물과는 다릅니다.
+.TP 
+\fB\-\-flush\-timeout=\fP\fI<제한시간>\fP
+압축할 때, 이전 데이터를 소거하고 다음 입력을 블록 단위로 더 읽는데 \fI<제한시간>\fP 밀리초(양의 정수값)가 지났을
+경우, 대기중이던 모든 입력 데이터를 인코더에서 소거한 다음 출력 스트림에 전달합니다.  이런 동작은 네트워크로 스트리밍한 데이터를
+\fBxz\fP로 압축할 때 쓸만합니다.  \fI<제한시간>\fP 값을 적게 지정하면 적은 지연 시간에 데이터를 받아낼 수 있지만
+\fI<제한시간>\fP 값을 크게 하면 압축율을 높일 수 있습니다.
+.IP ""
+이 기능은 기본적으로 꺼져있습니다.  이 옵션을 한번 이상 지정하면, 마지막 옵션의 값대로 동작합니다.  특별히
+\fI<제한시간>\fP 값을 \fB0\fP으로 설정하면 이 설정을 완전히 끌 수 있습니다.
+.IP ""
+이 기능은 POSIX 시스템이 아닌 곳에서는 사용할 수 없습니다.
+.IP ""
+.\" FIXME
+\fB이 기능은 여전히 시험중입니다\fP.  현재로서는, \fBxz\fP 버퍼링 처리 방식 때문에 \fBxz\fP의 실시간 스트림 압축 해제 기능 활용은
+적절하지 않습니다.
+.TP 
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP
+압축 수행시 메모리 사용 한계를 지정합니다.  이 옵션을 여러번 지정하면 마지막 값을 취합니다.
+.IP ""
+압축 설정이 \fI<제한용량>\fP을 초과하면, \fBxz\fP는 설정 값의 하향 조정을 시도하여 한계 값을 더이상 넘치지 않게 하고
+자동 조절을 끝냈다는 알림을 표시합니다.  조정은 다음 순서대로 진행합니다. 스레드 수를 줄입니다. 다중\-스레드 모드에서 스레드 하나의
+할당 한계치가 \fI<제한용량>\fP을 넘으면 단일\-스레드 모드로 전환합니다. 그 다음 마지막으로 LZMA2 딕셔너리 크기를
+줄입니다.
+.IP ""
+\fB\-\-format=raw\fP 또는 \fB\-\-no\-adjust\fP 미지정 상황에서 압축할 때, 압축 데이터 출력에 영향을 주지 않고 스레드
+처리 수만 줄일 수 있습니다.
+.IP ""
+\fI<제한용량>\fP 값이 아래 설명한 조건에 맞지 않으면, 오류가 나타나고 \fBxz\fP 명령은 종료 상태 1번을 반환하며
+빠져나갑니다.
+.IP ""
+\fI<제한용량>\fP 값은 여러 방식으로 지정할 수 있습니다:
+.RS
+.IP \(bu 3
+\fI<제한용량>\fP 값은 바이트 용량 절대값입니다.  정수 값을 사용하되 \fBMiB\fP와 같은 접미사를 사용하는게 좋습니다.
+예: \fB\-\-memlimit\-compress=80MiB\fP
+.IP \(bu 3
+\fI<제한용량>\fP 값은 총 물리 메모리(RAM) 용량의 백분율로 지정할 수도 있습니다.  다른 컴퓨터끼리 공유하는 셸
+초기화 스크립트의 \fBXZ_DEFAULTS\fP 환경 변수에 값을 설정할 때 특히 쓸만합니다.  이런 방식으로 설정하면 시스템의 메모리 설치
+용량에 따라 자동으로 늘어납니다.  예: \fB\-\-memlimit\-compress=70%\fP
+.IP \(bu 3
+\fI<제한용량>\fP 값은 \fB0\fP 기본값으로 설정하여 초기화할 수 있습니다.  현재로서는 \fI<제한용량>\fP
+값이 \fImax\fP(최대) (메모리 사용 한계 없음) 인 상태와 동일합니다.
+.RE
+.IP ""
+\fBxz\fP 32비트 버전에서는 몇가지 특별한 경우가 있습니다. \fI<제한용량>\fP 값이 \fB4020MiB\fP를 넘으면
+\fI<제한용량>\fP을 \fB4020MiB\fP로 고정합니다. MIPS32에서는 \fB2000MiB\fP로 대신 고정합니다.
+(\fB0\fP과 \fBmax\fP는 이 경우에 해당하지 않습니다.  압축 해제시 비슷한 기능은 없습니다.)  이 경우 32비트 실행 파일이
+4GiB(MIPS32의 경우 2GiB) 주소 영역에 접근할 때 매우 용이하며, 다른 경우에는 원하는대로 문제를 일으키지 않습니다.
+.IP ""
+\fB메모리 활용\fP 섹션도 참고하십시오.
+.TP 
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP
+압축 해제시 메모리 사용 한계 용량을 설정합니다.  \fB\-\-list\fP 모드에도 영향을 줍니다.  \fI<제한용량>\fP을 넘기지
+않고서는 동작이 진행이 안될 경우, \fBxz\fP 에서는 오류를 나타내고 파일 압축 해제를 실패로
+간주합니다. \fI<제한용량>\fP을 지정하는 가능한 방법에 대해서는
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오.
+.TP 
+\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP
+다중\-스레드 모드 압축 해제시 메모리 사용 한계 용량을 설정합니다.  스레드 수에 영향을 줄 수도 있습니다.  \fBxz\fP에서 파일 압축
+해제를 거부하게 하진 않습니다.  \fI<제한용량>\fP 수치가 다중\-스레드로 처리하기에 너무 낮다면,
+\fI<제한용량>\fP 값을 무시하고 \fBxz\fP 동작을 단일\-스레드 모드로 계속 진행합니다.  참고로
+\fB\-\-memlimit\-decompress\fP 옵션도 사용하면, 단일\-스레드 모드와 다중\-스레드 모드 두 경우에 모두 적용하기에,
+다중\-스레드 모드에 적용할 \fI<제한용량>\fP 값은 \fB\-\-memlimit\-decompress\fP에 설정하는 제한 값보다 더
+크면 안됩니다.
+.IP ""
+다른 메모리 사용 용량 제한 옵션과는 달리, \fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 옵션은
+시스템별 기본 \fI<제한용량>\fP 값을 지닙니다.  현재 설정 값은 \fBxz \-\-info\-memory\fP 명령으로 확인해볼 수
+있습니다.
+.IP ""
+이 옵션과 기본 값은 한계 값을 주지 않으면 스레드 기반 압축 해제 프로그램이 일부 입력 파일에 대해 정신나간 수준의 메모리 용량을
+할당해서 동작이 끝나버릴 수 있습니다.  기본 \fI<제한용량>\fP이 시스템의 사양에 비해 낮다면,
+\fI<제한용량>\fP 값을 자유롭게 올리시되, \fBxz\fP 에서 적은 스레드 수에도 메모리 공간 할당을 시도하는 만큼, 입력
+파일에 적절한 수준으로 가용 RAM 용량을 넘는 큰 값을 설정하지 마십시오. 메모리나 스와핑 영역 공간이 줄어들면 압축해제 성능을
+개선하지 못합니다.
+.IP ""
+\fI<제한용량>\fP 값을 지정하는 가능한 방법을 보려면
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오.  \fI<제한용량>\fP 값을
+\fB0\fP으로 설정하면 \fI<제한용량>\fP 값이 시스템 지정 기본값으로 바뀝니다.
+.TP 
+\fB\-M\fP \fI<제한용량>\fP, \fB\-\-memlimit=\fP\fI<제한용량>\fP, \fB\-\-memory=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 지정과 동일합니다.
+.TP 
+\fB\-\-no\-adjust\fP
+압축 출력 결과에 영향을 주는 설정을 조정하지 않고는 메모리 사용 용량 제한 조건이 맞지 않으면 오류를 표시하고 빠져나갑니다.  이
+옵션은 \fBxz\fP가 다중\-스레드 모드에서 단일\-스레드 모드로 전환하고 LZMA2 딕셔너리 크기를 줄이는 동작을 막아줍니다.  심지어 이
+옵션을 사용하면 메모리 사용 한계를 만족하도록 스레드 수를 줄여 압축 결과물 출력에 영향이 가지 않게 합니다.
+.IP ""
+원시 스트림(\fB\-\-format=raw\fP)을 만들 떄 자동 조정은 항상 꺼집니다.
+.TP 
+\fB\-T\fP \fI<스레드수>\fP, \fB\-\-threads=\fP\fI<스레드수>\fP
+활용할 작업 스레드 수를 지정합니다.  \fI<스레드수>\fP 값을 \fB0\fP 값으로 설정하면, \fBxz\fP는 시스템에서 지원하는
+최대 프로세서 스레드 수를 모두 확보합니다. 실제 스레드 수는 입력 파일이 주어진 설정대로 스레드 처리를 할 만큼 그렇게 크지 않을
+경우, 내지는 더 많은 스레드를 사용했을 때 메모리 사용량 한계를 초과할 경우 \fI<스레드수>\fP 보다 적을 수 있습니다.
+.IP ""
+단일\-스레드와 다중\-스레드 압축 프로그램은 다른 출력 결과물을 냅니다.  단일\-스레드 압축 프로그램은 작은 파일 크기 결과물을 내놓지만,
+다중\-스레드 압축 프로그램의 경우 다중\-스레드 압축 프로그램에서 내놓은 결과물은 다중\-스레드로만 압축을 해제할 수 있습니다.
+\fI<스레드수>\fP를 \fB1\fP로 설정하면 단일\-스레드 모드를 사용합니다.  \fI<스레드수>\fP를 \fB0\fP과 다른
+값으로 설정하면, 시스템에서 실제로 하드웨어 스레드가 1개만 지원한다 하더라도, 다중\-스레드 압축 프로그램을 사용합니다.  (\fBxz\fP
+5.2.x에서는 이 경우 단일\-스레드 모드를 활용합니다.)
+.IP ""
+단일\-스레드로 다중\-스레드 모드를 사용하려면, \fI<스레드수>\fP를 \fB+1\fP로 설정하십시오. \fB+\fP 접두사는 \fB1\fP
+이외의 값에는 영향을 주지 않습니다.  메모리 사용량 한계 설정은 \fBxz\fP을 \fB\-\-no\-adjust\fP 옵션을 쓰기 전까지는
+단일\-스레드로 전환하게 합니다.  \fB+\fP 접두사 지원은 \fBxz\fP 5.4.0에 추가했습니다.
+.IP ""
+자동 스레드 수를 요청했고 메모리 사용 한계를 지정하지 않았다면, 시스템에 맞게끔 가능한 스레드 수를 제한하는 기본 소프트 제한 값을
+사용합니다. 스레드 수가 한개가 되면 무시하는 이런 개념이 소프트 제한이기에, \fBxz\fP로 하여금 압축 동작 및 압축 해제 동작 수행시
+멈추지 않습니다.  이 가본 소프트 제한 값은 \fBxz\fP 실행 도중 다중\-스레드 모드에서 단일\-스레드 모드로 바뀌게 하지는 않습니다.
+활성 제한 값은 \fBxz \-\-info\-memory\fP 명령으로 볼 수 있습니다.
+.IP ""
+현재 스레딩 처리 방식은 입력을 블록 단위로 쪼개고 각각의 블록을 독립적으로 압축하는 동작을 취합니다.  기본 블록 크기는 압축 수준에
+따라 다르며 \fB\-\-block\-size=\fP\fI<크기>\fP 옵션으로 재지정할 수 있습니다.
+.IP ""
+스레드 압축 해제 방식은 여러 블록이 블록 헤더에 넣은 크기 정보와 함께 들어간 파일에만 동작합니다.  다중\-스레드 모드에서 압축한
+충분히 큰 모든 파일은 이 조건에 만족하지만, 단일\-스레드 모드에서 압축한 파일은
+\fB\-\-block\-size=\fP\fI<크기>\fP 옵션을 지정하더라도 조건에 만족하지 않습니다.
+.IP ""
+\fI스레드\fP 기본 값은 \fB0\fP입니다.  \fBxz\fP 5.4.x 이전의 기본값은 \fB1\fP입니다.
+.
+.SS "개별 압축 필터 체인 설정"
+개별 필터 체인은 사전 설정에 엮인 설정에 의존하는 대신 압축 설정을 세부적으로 하나하나 설정할 수 있게 합니다.  개별 필터 체인을
+지정하면, 명령행에 앞서 지정한 사전 설정 옵션(\fB\-0\fP \&...\& \fB\-9\fP 과 \fB\-\-extreme\fP)은 무시합니다.  사전
+설정 옵션을 하나 이상의 필터 체인 옵션 다음에 지정하면, 새 사전 설정을 취하며, 앞서 지정한 개별 필터 체인 옵션은 무시합니다.
+.PP
+필터 체인은 명령행 파이핑에 비교할 수 있습니다.  압축할 때, 압축하지 않은 입력을 첫번째 필터로 놓고, 출력 대상(이 있으면)을 다음
+필터로 지정합니다.  최종 필터의 출력은 압축 파일로 기옥합니다.  체인의 최대 필터 수는 4이지만, 필터 체인상 필터 갯수는 보통
+1~2개입니다.
+.PP
+수많은 필터가 필터 체인 상에서 제약점을 가지고 있습니다. 일부 필터는 체인의 마지막 필터로만 동작하며, 일부 다른 필터는 마지막이 아닌
+필터로, 어떤 동작은 체인의 어떤 위치에든 둡니다.  필터에 따라, 이 제한은 필터 설계를 따르거나 보안 문제를 막기 위해 존재하기도
+합니다.
+.PP
+개별 필터 체인은 두가지 방식으로 지정할 수 있습니다.  \fB\-\-filters=\fP\fI<필터>\fP와
+\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션으로
+liblzma 필터 문자열 문법에 따라 한가지 옵션을 필터 체인 전체를 지정할 수 있습니다.  대신, 하나 이상의 개별 필터 옵션을
+원하는 필터 체인 순서대로 지정할 수도 있습니다.  이 말인 즉슨, 개별 필터 옵션의 순서가 중요하단 뜻입니다! 원시 스트림을 디코딩할
+때(\fB\-\-format=raw\fP), 압축했을 때 지정했던 필터와 같은 순서로 필터 체인을 지정해야 합니다.  전체 체인
+옵션(\fB\-\-filters=\fP\fI<필터>\fP) 보다 우선 지정한 개별 필터 또는 사전 설정 옵션은 까먹을 수도 있습니다.
+전체 체인 옵션 다음에 개별 필터를 지정할 경우 필터 체인의 동작을 무효로 합니다.
+.PP
+필터는 쉼표로 구분하는 필터별 \fI<옵션>\fP이 있습니다.  \fI<옵션>\fP에 추가로 입력한 쉼표는
+무시합니다.  모든 옵션 값에는 기본값이 있어, 값을 바꾸려면 지정해야합니다.
+.PP
+전체 필터 체인과 \fI<옵션>\fP을 보려면 \fBxz \-vv\fP (\fB\-\-verbose\fP 두 번)명령을 사용하십시오.  이
+명령은 사전 설정이 사용하는 필터 체인 옵션도 볼 수 있습니다.
+.TP 
+\fB\-\-filters=\fP\fI<필터>\fP
+전체 필터 체인 또는 사전 설정을 단일 옵션으로 지정합니다.  각 필터는 공백 문자 또는 대시 문자 두번 입력(\fB\-\-\fP)으로
+구분합니다.  셸 명령행에서 \fI필터\fP는 따옴표로 감싸서 단일 옵션으로 해석하도록 해야 합니다.  \fI옵션\fP을 표기하려면 \fB:\fP 또는
+\fB=\fP을 활용하십시오.  사전 설정 앞에 \fB\-\fP를 붙일 수 있고 0개 또는 하나 이상의 플래그를 붙일 수 있습니다.  유일하게
+지원하는 플래그는 \fB\-\-extreme\fP과 동일한 \fBe\fP입니다.
+.TP 
+\fB\-\-filters1\fP=\fI<필터>\fP ... \fB\-\-filters9\fP=\fI<필터>\fP
+\fB\-\-block\-list\fP와 사용할 수 있는 추가 필터 체인을 최대 9개까지 지정합니다.
+.IP ""
+예를 들어 텍스트 파일과 실행 파일의 아카이브를 압축할 때 실행 부분에 BCJ 필터 체인을 사용하고 텍스트 부분은 LZMA2 필터를
+사용할 수 있습니다.
+.TP 
+\fB\-\-filters\-help\fP
+\fB\-\-filters\fP와 \fB\-\-filters1=\fP\fI<필터>\fP \&...\&
+\fB\-\-filters9=\fP\fI<필터>\fP 옵션의 사전 설정 필터와 개별 설정 필터 체인을 지정하는 방법을 설명하는 도움말
+메시지를 출력하고 완전히 빠져나갑니다.
+.TP 
+\fB\-\-lzma1\fP[\fB=\fP\fI<옵션>\fP]
+.PD 0
+.TP 
+\fB\-\-lzma2\fP[\fB=\fP\fI<옵션>\fP]
+.PD
+LZMA1 또는 LZMA2 필터를 필터 체인에 추가합니다.  이 필터는 필터 체인의 마지막 요소로만 사용할 수 있습니다.
+.IP ""
+LZMA1은 고전 필터로, LZMA1만 지원하는 고전 \fB.lzma\fP 파일 형식에서만 지원합니다.  LZMA2는 LZMA1의 업데이트
+버전으로 LZMA1의 실질적 문제를 해결했습니다.  \fB.xz\fP 형식은 LZMA2 필터를 사용하며 LZMA1 필터는 전적으로 지원하지
+않습니다.  압축 속도와 압축율은 LZMA1과 LZMA2가 실질적으로 동일합니다.
+.IP ""
+LZMA1과 LZMA2는 동일한 \fI<옵션>\fP 집합을 공유합니다:
+.RS
+.TP 
+\fBpreset=\fP\fI<사전설정>\fP
+LZMA1 또는 LZMA2의 모든 \fI<옵션>\fP을 \fI<사전설정>\fP으로
+초기화합니다. \fI<사전설정>\fP 값은 정수 값으로 이루어져 있으며, 사전 설정에 변형을 줄 떄 단일 문자가 따라올 수도
+있습니다.  정수 값은 \fB0\fP에서 \fB9\fP 까지이며, 명령행 옵션에서 \fB\-0\fP \&...\& \fB\-9\fP로 대응합니다.  변형 옵션으로
+지원하는 문자는 현재 \fBe\fP 뿐이며, \fB\-\-extreme\fP에 대응합니다.  \fI<사전설정>\fP 값을 지정하지 않으면,
+LZMA1 또는 LZMA2 기본값을 사전 설정 \fB6\fP에서 가져온 \fI<옵션>\fP으로 취합니다.
+.TP 
+\fBdict=\fP\fI<크기>\fP
+딕셔너리(기록 버퍼)  \fI<크기>\fP는 최근 처리한 비압축 데이터를 바이트 단위로 메모리에 얼마나 유지하는지 나타냅니다.
+알고리즘은 비압축 데이터상 바이트 시퀀스(일치 항목) 반복 탐색을 시도하며, 해당 부분을 딕셔너리의 현재 참조로 치환합니다. 딕셔너리가
+크면 일치하는 항목을 찾을 기회가 더 많아집니다.  따라서, 딕셔너리 \fI<크기>\fP를 더욱 크게 설정하면 압축율을 증가할
+수는 있지만, 압축하지 않은 파일보다 딕셔너리가 크면 메모리 낭비율이 올라갑니다.
+.IP ""
+보통 딕셔너리 \fI<크기>\fP는 64KiB 에서 64MiB 정도 됩니다. 최소 4KiB 입니다. 압축시 최대 용량은 현재
+1.5GiB(1536MiB)로 나타납니다.  압축 해제 프로그램에도 4GiB 미만으로 딕셔너리 크기를 이미 지원하며 4GiB 라는 수치는
+LZMA1과 LZMA2 스트림 형식의 최대값입니다.
+.IP ""
+딕셔너리 \fI<크기>\fP와 검색기(\fImf\fP)는 LZMA1 또는 LZMA 인코더의 메모리 사용량을 함께 결정합니다.
+동일한(또는 더 큰) 딕셔너리 \fI<크기>\fP가 데이터를 압축했을 때만큼 압축 해제할 떄 필요하기 때문에, 디코더의 메모리
+사용량은 압축할 때의 딕셔너리 크기로 결정합니다.  \fB.xz\fP 헤더에는 딕셔너리 \fI<크기>\fP를 2^\fIn\fP 또는
+2^\fIn\fP + 2^(\fIn\fP\-1) 으로 저장하기에, 이 \fI<크기>\fP 값을 압축할 때 선호하는 편입니다.  다른
+\fI<크기>\fP 값은 \fB.xz\fP 헤더에 저장할 때 반올림합니다.
+.TP 
+\fBlc=\fP\fIlc\fP
+리터럴 컨텍스트 비트 수를 지정합니다.  최소 값은 0이고 최대 값은 4입니다. 기본 값은 3입니다.  추가로, \fIlc\fP 값과
+\fIlp\fP 값의 합은 4를 넘으면 안됩니다.
+.IP ""
+조건이 일치하지 않아 인코딩할 수 없는 모든 바이트는 리터럴로 인코딩합니다.  이 말인 즉슨, 간단히 8비트 바이트로서의 리터럴을 한번에
+하나씩 인코딩합니다.
+.IP ""
+리터럴 코딩을 할 때 이전 비압축 바이트와 다음 바이트와의 관련성을 가진 가장 많은 \fIlc\fP 비트 수를 가정합니다.  예를 들면, 보통
+영문 문장의 경우 대문자 다음에 종종 소문자가 오고, 소문자 다음에 다른 소문자가 따라옵니다. US\-ASCII 문자 세트에서는 가장 긴
+비트 3개는 대문자에 대해 010, 소문자에 대해 011입니다.  \fIlc\fP 값이 최소한 3이면, 리터럴 코딩시 비압축 데이터에 대해
+이런 속성의 장점을 취할 수 있습니다.
+.IP ""
+(어쨌거나) 기본값 (3)은 보통 적절합니다.  최대 압축을 원한다면 \fBlc=4\fP 값을 시험해보십시오.  때로는 약간 도움이 되기도
+하겠지만, 오히려 결��가 안좋을 수도 있습니다.  결과가 엄한 방향으로 간다면, \fBlc=2\fP 값도 시험해보십시오.
+.TP 
+\fBlp=\fP\fIlp\fP
+리터럴 위치 비트 수를 지정하빈다.  최소 값은 0이고 최대 값은 4입니다. 기본 값은 0입니다.
+.IP ""
+\fIlp\fP 값은 리터럴 인코딩 진행시 비압축 데이터 정렬 방식 고려에 영향을 줍니다.  정렬 방식에 대한 자세한 정보는 하단 \fIpb\fP를
+참고하십시오.
+.TP 
+\fBpb=\fP\fIpb\fP
+위치 비트 수를 지정합니다.  최소 값은 0이며 최대 값은 4입니다.  기본값은 2입니다.
+.IP ""
+\fIpb\fP 값은 보통 압축하지 않은 데이터에 어떤 정렬 방식을 고려하느냐에 영향을 줍니다.  기본적으로 4바이트
+정렬(2^\fIpb\fP=2^2=4)을 의미하는데, 이보다 더 나은 추측 값이 없어서 종종 최적의 선택으로 간주합니다.
+.IP ""
+정렬 상태를 알지 못할 경우, \fIpb\fP 설정 값이 파일 크기를 조금 줄일 수 있습니다.  예를 들면, 텍스트 파일이 단일 바이트 단위로
+정돈된 상태(US\-ASCII, ISO\-8859\-*, UTF\-8)라면, \fBpb=0\fP 설정 값으로 압축율을 조금 개선할 수 있습니다.
+UTF\-16 텍스트의 경우, \fBpb=1\fP 설정 값이 좋은 선택입니다.  정렬 바이트가 3 바이트 같은 홀수 바이트일 경우,
+\fBpb=0\fP 설정 값이 최적의 선택일지도 모릅니다.
+.IP ""
+가정 정렬을 \fIpb\fP 값과 \fIlp\fP 값으로 조정하긴 하지만, LZMA1과 LZMA2는 여전히 16바이트 정렬 방식으로 선호합니다.
+LZMA1 또는 LZMA2로 종종 압축하는 파일 형식이라고 하면 고려해볼만 합니다.
+.TP 
+\fBmf=\fP\fImf\fP
+일치 검색기는 인코더 속도, 메모리 사용량, 압축율에 주된 영향을 줍니다.  보통 해시 체인 검색기는 이진 트리 검색기보다 빠르긴
+합니다.  기본 값은 \fI<사전설정>\fP에 따라 다릅니다. 0은 \fBhc3\fP을, 1\(en3은 \fBhc4\fP를, 나머지는
+\fBbt4\fP를 활용합니다.
+.IP ""
+다음 검색 필터를 지원합니다.  메모리 사용 공식은 \fIdict\fP 값이 2의 승수일 경우 실제에 가까운 근사치입니다.
+.RS
+.TP 
+\fBhc3\fP
+2바이트, 3바이트 해싱 체인
+.br
+\fInice\fP 최소값: 3
+.br
+메모리 사용:
+.br
+\fIdict\fP * 7.5 (조건: \fIdict\fP <= 16 MiB);
+.br
+\fIdict\fP * 5.5 + 64 MiB (조건: \fIdict\fP > 16 MiB)
+.TP 
+\fBhc4\fP
+2바이트, 3바이트, 4바이트 해싱 체인
+.br
+\fInice\fP 최소값: 4
+.br
+메모리 사용:
+.br
+\fIdict\fP * 7.5 (조건: \fIdict\fP <= 32 MiB);
+.br
+\fIdict\fP * 6.5 (조건: \fIdict\fP > 32 MiB)
+.TP 
+\fBbt2\fP
+2바이트 해싱 이진 트리
+.br
+\fInice\fP 최소값: 2
+.br
+메모리 사용: \fIdict\fP * 9.5
+.TP 
+\fBbt3\fP
+2바이트, 3바이트 해싱 이진트리
+.br
+\fInice\fP 최소값: 3
+.br
+메모리 사용:
+.br
+\fIdict\fP * 11.5 (조건: \fIdict\fP <= 16 MiB);
+.br
+\fIdict\fP * 9.5 + 64 MiB (조건: \fIdict\fP > 16 MiB)
+.TP 
+\fBbt4\fP
+2바이트, 3바이트, 4바이트 해싱 이진 트리
+.br
+\fInice\fP 최소값: 4
+.br
+메모리 사용:
+.br
+\fIdict\fP * 11.5 (조건: \fIdict\fP <= 32 MiB);
+.br
+\fIdict\fP * 10.5 (조건: \fIdict\fP > 32 MiB)
+.RE
+.TP 
+\fBmode=\fP\fI<모드>\fP
+압축 \fI<모드>\fP 값은 일치 검색기에서 생산하는 데이터 분석 방식을 지정합니다.  지원하는 \fI<모드>\fP는
+\fBfast\fP와 \fBnormal\fP 입니다. 기본값은 \fI<사전설정>\fP값 0\(en3에 대해 \fBfast\fP,
+\fI<사전설정>\fP값 4\(en9에 대해 \fBnormal\fP입니다.
+.IP ""
+보통 \fBfast\fP는 해시 체인 검색기에서 사용하며 \fBnormal\fP은 이진 트리 검색기에서 사용합니다.  이 동작은 또한
+\fI<사전설정>\fP 값이 할 일이기도 합니다.
+.TP 
+\fBnice=\fP\fInice\fP
+일치하는 nice 길이를 지정합니다.  최소한 \fInice\fP 바이트 정도 일치하면, 알고리즘이 가능한 최선의 부분을 찾는 동작을
+멈춥니다.
+.IP ""
+\fInice\fP 값은 2\(en273 바이트입니다.  값이 클 수록 속도 면에서는 손해를 보겠지만 압축율은 더욱 올라갑니다.  기본 값은
+\fI<사전설정>\fP값에 따라 다릅니다.
+.TP 
+\fBdepth=\fP\fI<깊이>\fP
+일치 검색기에서의 최대 검색 깊이를 지정합니다.  기본값은 특별한 값 0으로 지정하며, 이 값으로 압축 프로그램이 \fImf\fP 와
+\fInice\fP간 적절한 \fI<깊이>\fP 값을 결정합니다.
+.IP ""
+적절한 해시 체인 \fI<깊이>\fP 값은 이진 트리에서 4\(en100 그리고 16\(en1000 입니다. 상당히 큰 값을
+\fI<깊이>\fP 값으로 사용하면 일부 파일에 대해 인코더가 매우 느리게 동작할 수가 있습니다.  압축 시간이 너무 오래걸려서
+동작을 중간에 끊을 준비가 되지 않은 이상 \fI<깊이>\fP 설정 값은 1000을 넘지 않게하십시오.
+.RE
+.IP ""
+원시 스트림(\fB\-\-format=raw\fP)을 디코딩할 때, LZMA2는 딕셔너리 \fI<크기>\fP만 필요합니다.  LZMA1는
+\fIlc\fP, \fIlp\fP, \fIpb\fP 값이 모두 필요합니다.
+.TP 
+\fB\-\-x86\fP[\fB=\fP\fI<옵션>\fP]
+.PD 0
+.TP 
+\fB\-\-arm\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-armthumb\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-arm64\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-powerpc\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-ia64\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-sparc\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-riscv\fP[\fB=\fP\fI<옵션>\fP]
+.PD
+브랜치/호출/점프(BCJ) 필터를 필터 체인에 추가합니다.  이 필터는 필터 체인의 비종결 필터로만 사용할 수 있습니다.
+.IP ""
+BCJ 필터는 머신 코드의 상대 주소를 절대 주소로 변환합니다.  데이터 크기를 바꾸지는 않지만 LZMA2에서 \fB.xz\fP 파일을
+0\(en15% 정도 줄여주게 하는 중복성이 늘어납니다.  BCJ 필터는 언제든 뒤집을 수 있어, 데이터에 적절하지 않은 BCJ 필터
+형식을 활용하면, 그냥 가만히 두면 압축율이 약간 떨어지게 한다 하더라도, 데이터를 잃을 수가 있습니다.  BCJ 필터는 굉장히 빠르며
+메모리 공간을 적게 활용합니다.
+.IP ""
+이 BCJ 필터에는 압축율 관련 몇가지 문제가 있습니다:
+.RS
+.IP \(bu 3
+실행 코드가 들어있는 몇가지 파일 형식(예: 목적 파일, 정적 라이브러리, 리눅스 커널 모듈)의 경우 필터 값으로 채운 명령 주소가
+있습니다.  여기 BCJ 필터의 경우 파일의 압축율을 떨어뜨리는 주소 변환을 수행합니다.
+.IP \(bu 3
+BCJ 필터를 아카이브에 적용하면, BCJ 필터를 사용하지 않았을 때보다 압축율이 떨어질 수가 있습니다.  예를 들면, 유사하거나 동일한
+실행 파일 여럿이 있으면 필터를 사용하여 파일을 덜 비슷하게 만들어 압축율이 떨어지게 합니다.  동일한 아카이브 파일에서 비 실행 파일의
+내용에 대해서도 비슷한 일이 벌어질 수 있습니다.  실제로 하나는 BCJ 필터를 걸고 하나는 제외하여 각 경우에 대해 어떤 경우가 결과가
+우수한 지 살펴보겠습니다.
+.RE
+.IP ""
+다른 명령 세트는 다른 정렬 상태에 놓여있습니다.  실행 파일은 필터가 제대로 동작하게 하려면 입력 데이터에 있는 이 값의 배수로
+정돈해야합니다.
+.RS
+.RS
+.PP
+.TS
+tab(;);
+l n l
+l n l.
+필터;정렬;참고
+x86;1;32\-bit 또는 64\-bit x86
+ARM;4;
+ARM\-Thumb;2;
+ARM64;4;4096 바이트 정렬이 가장 좋습니다
+PowerPC;4;빅엔디안 전용
+IA\-64;16;Itanium
+SPARC;4;
+RISC\-V;2;
+.TE
+.RE
+.RE
+.IP ""
+BCJ 필터를 사용한 데이터는 LZMA2로 보통 압축하기 때문에 LZMA2 옵션을 선택한 BCJ 필터의 정렬기준에 맞추도록 설정하면
+압축율을 좀 더 개선할 수 있습니다.  예를 들면:
+.RS
+.IP \(bu 3
+IA\-64 필터는 16\-바이트 정렬 방식으로 동작하기에 LZMA2 필터에 \fBpb=4,lp=4,lc=0\fP 옵션(2^4=16)을 주는게
+좋습니다.
+.IP \(bu 3
+RISC\-V 코드에는 16\-비트 압축 명령(C 확장) 적재 여부에 따라 2\-바이트 또는 4\-바이트 정렬 방식을 채택합니다. 16\-비트
+명령을 사용하면, \fBpb=2,lp=1,lc=3\fP 또는 \fBpb=1,lp=1,lc=3\fP 옵션 값 사용이 바람직합니다. 16\-비트 명령이
+없다면, \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다.  "RVC"가 "Flags"행에 나타나는지 확인할 때
+\fBreadelf \-h\fP 명령을 사용할 수 있습니다.
+.IP \(bu 3
+ARM64는 항상 4\-바이트 정렬 방식을 택하기에 \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다.
+.IP \(bu 3
+x86 필터는 예외입니다.  x86 실행 파일을 압축할 경우에는 보통 LZMA2 기본 옵션 값(\fBpb=2,lp=0,lc=3\fP)을 그대로
+사용하는게 좋습니다.
+.RE
+.IP ""
+모든 BCJ 필터는 동일한 \fI옵션\fP을 지원합니다:
+.RS
+.TP 
+\fBstart=\fP\fI<오프셋>\fP
+상대 주소와 절대 주소를 변환할 때 사용할 시작 \fI<오프셋>\fP을 지정합니다.  \fI<오프셋>\fP에는 필터
+정렬 배수여야 합니다(상단 테이블 참조).  기본값은 0입니다.  실제로 기본값이 낫습니다. 개별 \fI<오프셋>\fP 지정
+값은 거의 쓸모가 없습니다.
+.RE
+.TP 
+\fB\-\-delta\fP[\fB=\fP\fI<옵션>\fP]
+필터 체인에 델타 필터를 추가합니다.  델타 필터는 필터 체인에서 마지막에 지정하지 않은 필터로만 사용할 수 있습니다.
+.IP ""
+현재로서는 바이트 단위 단순 델타계산 결과만 보여줍니다.  예를 들면, 압축하지 않은 비트맵 그림 또는 압축하지 않은 PCM 오디오를
+압축할 때 쓸만합니다.  그러나 특별한 목적으로 활용하는 알고리즘은 델타 + LZMA2 보다 더 나은 결과를 가져다 주기도 합니다.
+이는 특히 오디오의 경우 맞는 이야기인데, \fBflac\fP(1)의 경우 더 빠르고 우수한 압축율을 보여줍니다.
+.IP ""
+지원 \fI옵션\fP:
+.RS
+.TP 
+\fBdist=\fP\fI<차이>\fP
+바이트 단위 델터 계산 \fI<차이>\fP를 지정합니다.  \fI<차이>\fP값은 1\(en256 이어야합니다.  기본
+값은 1입니다.
+.IP ""
+예를 들어, \fBdist=2\fP 옵션과 A1 B1 A2 B3 A3 B5 A4 B7 입력 값을 주면, 출력 값은 A1 B1 01 02 01
+02 01 02 입니다.
+.RE
+.
+.SS "기타 옵션"
+.TP 
+\fB\-q\fP, \fB\-\-quiet\fP
+경고 및 알림을 끕니다.  두 번 지정하면 오류 메시지 표시도 끕니다.  이 옵션은 종료 상태에 영향을 주지 않습니다.  경고 표시를
+끄더라도, 종료 상태에서는 여전히 경고가 나타났음을 알려줍니다.
+.TP 
+\fB\-v\fP, \fB\-\-verbose\fP
+출력 내용이 많아집니다.  표준 오류를 터미널에 연결했다면 \fBxz\fP는 진행 표시를 나타냅니다.  \fB\-\-verbose\fP를 두번 지정하면
+더 많은 내용을 표시합니다.
+.IP ""
+진행 표시에서는 다음 정보를 나타냅니다:
+.RS
+.IP \(bu 3
+입력 파일의 크기를 알고 있을 경우 완료 백분율.  파이프 처리시에는 백분율을 나타낼 수 없습니다.
+.IP \(bu 3
+산출 압축 데이터 용량 (압축) 또는 소모 공간 용량 (압축 해제).
+.IP \(bu 3
+비압축 데이터 소모 용량 (압축) 또는 산출 용량 (압축 해제).
+.IP \(bu 3
+압축 데이터 산출 용량을 비압축 데이터 처리 용량으로 나누어 계산한 압축율.
+.IP \(bu 3
+압축 또는 압축 해제 속도.  초당 비압축 데이터 소모량(압축) 또는 산출 용량(압축 해제)를 측정한 값입니다.  \fBxz\fP에서 파일
+처리를 시작한 몇 초 후 나타납니다.
+.IP \(bu 3
+경과 시간 형식은 M:SS 또는 H:MM:SS 입니다.
+.IP \(bu 3
+추산 여분 시간은 \fBxz\fP가 파일을 처리하기 시작한 이후 입력 파일의 크기를 알고 몇 초가 지난 후에야 보여줍니다.  시간은 콜론
+문자를 사용하지 않고 덜 자세한 형식으로, 예를 들면, 2분 30초 와 같은 형식으로 보여줍니다.
+.RE
+.IP ""
+표준 오류가 터미널이 아니라면 \fB\-\-verbose\fP는 \fBxz\fP에서 파일 이름, 압축 크기, 압축 해제 용량, 압축율, 그리고
+가능하다면 파일을 압축 또는 압축 해제한 후 표준 오류로 속도와 걸린 시간을 나타내도록 합니다.  속도와 걸린 시간 정보는 동작을
+처리하는데 최소한 몇초 정도 소요했을 경우에만 들어갑니다.  동작이 끝나지 않았다면, 이를테면 사용자의 중단 요청이 있었을 경우 입력
+파일의 크기를 알고 있을 때 압축 백분율 정보도 들어갑니다.
+.TP 
+\fB\-Q\fP, \fB\-\-no\-warn\fP
+경고로 알릴 만한 상황을 만났다 하더라도 종료 상태 2번을 설정하지 않습니다.  이 옵션은 출력 수준에 영향을 주지 않기 때문에,
+\fB\-\-quiet\fP 옵션과 \fB\-\-no\-warn\fP 옵션을 경고 표시를 막고 종료 상태를 바꾸지 않을 목적으로 사용합니다.
+.TP 
+\fB\-\-robot\fP
+머신에서 해석할 형식으로 메시지를 나타냅니다.  liblzma 대신 \fBxz\fP를 활용하려는 다양상 스크립트로서의 프론트엔드를 쉽게
+작성하도록 하기 위함입니다.  이 옵션을 지정한 출력은 \fBxz\fP 릴리스가 어떻게 되든 안정 버전이란 의미입니다.  자세한 내용은
+\fB로봇 모드\fP 섹션을 참고하십시오.
+.TP 
+\fB\-\-info\-memory\fP
+압축 및 압축 해제시 물리 메모리 용량 (RAM), \fBxz\fP에서 파악하는 프로세서 스레드 갯수, 메모리 사용량 한계를 파악하기 쉬운
+형식으로 나타내고 무사히 나갑니다.
+.TP 
+\fB\-h\fP, \fB\-\-help\fP
+보통 사용하는 옵션을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다.
+.TP 
+\fB\-H\fP, \fB\-\-long\-help\fP
+\fBxz\fP의 모든 기능을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다
+.TP 
+\fB\-V\fP, \fB\-\-version\fP
+\fBxz\fP와 liblzma 버전 번호를 가독 형식으로 출력합니다.  기계 해석 가능 형식을 가져오려면 \fB\-\-version\fP 앞에
+\fB\-\-robot\fP을 지정하십시오.
+.
+.SH "로봇 모드"
+로봇 모드는 \fB\-\-robot\fP 옵션으로 동작합니다.  \fBxz\fP 출력을 다른 프로그램에서 해석하기 쉽게 해줍니다.  현재로서는
+\fB\-\-robot\fP 옵션은  \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, \fB\-\-version\fP
+옵션하고만 사용할 수 있습니다.  앞으로는 압축 및 압축 해제 동작에 대해서도 지원합니다.
+.
+.SS "목록 모드"
+\fBxz \-\-robot \-\-list\fP 명령은 탭으로 구분한 출력 형태를 활용합니다.  모든 행의 첫번째 컬럼에는 해당 행에서 찾을 수
+있는 정보의 형식을 나타냅니다:
+.TP 
+\fB이름\fP
+이 행은 항상 파일 목록 시작 부분의 첫번째 줄에 있습니다.  이 행의 두번째 컬럼에 파일 이름이 들어있습니다.
+.TP 
+\fB파일\fP
+이 행에는 \fB.xz\fP 파일의 전반적인 정보가 들어있습니다.  이 행은 항상 \fB이름\fP 행 다음에 있습니다.
+.TP 
+\fB스트림\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 ��만 사용합니다.  \fB.xz\fP 파일의 \fB스트림\fP 행 수만큼 나타납니다.
+.TP 
+\fB블록\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다.  \fB.xz\fP 파일의 블록 수만큼 \fB블록\fP 행이 나타납니다.
+\fB블록\fP 행은 모든 \fB스트림\fP 행 다음에 나타납니다. 다른 형식의 행이 끼어들지는 않습니다.
+.TP 
+\fB요약\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 두번 지정했을 때만 사용합니다.  이 행은 모든 \fB블록\fP 행 다음에 출력합니다.
+\fB파일\fP 행과 비슷하게, \fB요약\fP 행에는 \fB.xz\fP 파일의 전반적인 정보가 담겨있습니다.
+.TP 
+\fB총계\fP
+이 행은 목록 출력의 가장 마지막에 항상 나타납니다.  총 갯수와 크기를 나타냅니다.
+.PP
+\fB파일\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+파일 스트림 갯수
+.IP 3. 4
+스트림의 블록 총 갯수
+.IP 4. 4
+파일 압축 크기
+.IP 5. 4
+파일 압축 해제 크기
+.IP 6. 4
+예를 들면, \fB0.123\fP과 같은 압축율 입니다.  비율이 9.999라면, 대시 문자 3개 (\fB\-\-\-\fP)를 비율 값 대신 나타냅니다.
+.IP 7. 4
+쉼표로 구분한 무결성 검사 이름 목록입니다.  \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP, \fBSHA\-256\fP 문자열을 알려진
+검사 형식으로 사용합니다.  알 수 없는 검사 형식에 대해서는 \fBUnknown\-\fP\fIN\fP을 사용하며, 여기서 \fIN\fP은 (한 두자리)
+정수형 숫자값으로 이루어진 검사 ID 입니다.
+.IP 8. 4
+파일의 스트림 패딩 총 길이
+.RE
+.PD
+.PP
+\fB스트림\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+스트림 번호 (첫 스트림은 1번)
+.IP 3. 4
+스트림의 블록 총 갯수
+.IP 4. 4
+압축 시작 오프셋
+.IP 5. 4
+비압축 시작 오프셋
+.IP 6. 4
+압축 크기 (스트림 패딩 미포함)
+.IP 7. 4
+압축 해제 용량
+.IP 8. 4
+압축율
+.IP 9. 4
+무결성 검사 이름
+.IP 10. 4
+스트림 패딩 길이
+.RE
+.PD
+.PP
+\fB블록\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+이 블록이 들어간 스트림 갯수
+.IP 3. 4
+스트림 시작 부분의 블록 번호 (첫번째 블록은 1번)
+.IP 4. 4
+파일 시작 부분의 블록 번호
+.IP 5. 4
+파일 시작 부분의 압축 시작 오프셋
+.IP 6. 4
+파일 시작 부분의 비압축 시작 오프셋
+.IP 7. 4
+총 블록 압축 크기 (헤더 포함)
+.IP 8. 4
+압축 해제 용량
+.IP 9. 4
+압축율
+.IP 10. 4
+무결성 검사 이름
+.RE
+.PD
+.PP
+\fB\-\-verbose\fP를 두 번 지정하면, 추가 컬럼을 \fB블록\fP 행에 넣습니다.  \fB\-\-verbose\fP 단일 지정시에는 이 정보를 볼
+때 탐색을 여러번 수행해야 하기 때문에 실행 과정이 느려질 수 있어서 나타내지 않습니다:
+.PD 0
+.RS
+.IP 11. 4
+16진수 무결성 검사값
+.IP 12. 4
+블록 헤더 크기
+.IP 13. 4
+블록 플래그: \fBc\fP는 압축 크기가 현재 값임을 나타내고, \fBu\fP는 압축 전 원본 크기가 현재 값임을 나타냅니다.  플래그를 설정하지
+않았다면, 문자열 길이를 유지할 목적으로 대시 \fB\-\fP 를 대신 나타냅니다.  새 플래그는 나중에 문자열 끝 부분에 추가할 예정입니다.
+.IP 14. 4
+블록에 압축 해서 넣은 데이터의 실제 츠기 (블록 헤더, 블록 패딩, 검사 필드 제외)
+.IP 15. 4
+이 \fBxz\fP 버전에서 이 블록의 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량
+.IP 16. 4
+필터 체인.  대부분 사용하는 옵션은 압축 해제시 필요한 옵션만을 \fB.xz\fP 헤더에 저장하기 때문에 압축 시간에 알 수 없습니다.
+.RE
+.PD
+.PP
+\fB요약\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+이 \fBxz\fP 버전에서 이 파일 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량
+.IP 3. 4
+모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값
+.PP
+\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP
+.IP 4. 4
+파일 압축 해제시 필요한 최소 \fBxz\fP 버전
+.RE
+.PD
+.PP
+\fB총계\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+스트림 갯수
+.IP 3. 4
+블록 갯수
+.IP 4. 4
+압축 크기
+.IP 5. 4
+압축 해제 용량
+.IP 6. 4
+평균 압축율
+.IP 7. 4
+파일에 들어 있어 쉼표로 구분한 무결성 검사 이름 목록
+.IP 8. 4
+스트림 패딩 길이
+.IP 9. 4
+파일 갯수.  \fB파일\fP 행의 컬럼 순서를 따라갑니다.
+.PD
+.RE
+.PP
+\fB\-\-verbose\fP 옵션을 두 번 지정하면, \fB총계\fP 행에 추가 컬럼이 들어갑니다:
+.PD 0
+.RS
+.IP 10. 4
+이 \fBxz\fP 버전에서 파일 압축을 해제할 떄 필요한 (바이트 단위) 최대 메모리 사용량
+.IP 11. 4
+모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값
+.PP
+\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP
+.IP 12. 4
+파일 압축 해제시 필요한 최소 \fBxz\fP 버전
+.RE
+.PD
+.PP
+차후 버전에서는 새 행 형식을 추가하고 기존 행 형식에 추가할 수 있는 새 컬럼을 넣기 까지는 알 수 있겠지만, 기존 컬럼은 바꾸지 않을
+예정입니다.
+.
+.SS "필터 도움말"
+\fBxz \-\-robot \-\-filters\-help\fP 는 다음 형식의 지원 필터 목록을 출력합니다:
+.PP
+\fI<필터>\fP\fB:\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>,\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>\fP...
+.TP 
+\fI<필터>\fP
+필터 이름
+.TP 
+\fI<옵션>\fP
+필터별 옵션 이름
+.TP 
+\fI<값>\fP
+숫자 \fI값\fP 범위는 \fB<\fP\fI최소\fP\fB\-\fP\fI최대\fP\fB>\fP입니다.  문자열 \fI값\fP은 \fB< >\fP 범위
+내에서 선택하며 \fB|\fP 문자로 구분합니다.
+.PP
+각 필터는 한 줄에 하나씩 출력합니다.
+.
+.SS "메모리 제한 정보"
+\fBxz \-\-robot \-\-info\-memory\fP 명령은 탭으로 나뉜 여러 컬럼을 단일 행으로 나타냅니다:
+.IP 1. 4
+물리 메모리(RAM)의 바이트 단위 총량.
+.IP 2. 4
+압축 진행시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-compress\fP).  특수 값 \fB0\fP은 단일\-스레드 모드에서
+제한을 두지 않는 기본 설정임을 나타냅니다.
+.IP 3. 4
+압축 해제시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-decompress\fP).  특수 값 \fB0\fP은 단일\-스레드 모드에서
+제한을 두지 않는 기본 설정임을 나타냅니다.
+.IP 4. 4
+\fBxz\fP 5.3.4alpha 이후: 다중\-스레드 기반 압축 해제시 바이트 단위 메모리
+사용량(\fB\-\-memlimit\-mt\-decompress\fP).  분명하게 제한을 걸어두지 않았을 경우 5번째 컬럼에 나타난 시스템별
+기본값을 사용하기 때문에 0 값을 지정하면 안됩니다.  또한 \fB\-\-memlimit\-mt\-decompress\fP로 세번째 컬럼 값보다 더
+크게 지정을 한다 할지라도 이 값이 세번째 컬럼 값보다 크면 안됩니다.
+.IP 5. 4
+\fBxz\fP 5.3.4alpha 이후: A system\-specific default memory usage limit that is
+used to limit the number of threads when compressing with an automatic
+number of threads (\fB\-\-threads=0\fP)  and no memory usage limit has been
+specified (\fB\-\-memlimit\-compress\fP).  This is also used as the default value
+for \fB\-\-memlimit\-mt\-decompress\fP.
+.IP 6. 4
+\fBxz\fP 5.3.4alpha 이후: Number of available processor threads.
+.PP
+차후, \fBxz \-\-robot \-\-info\-memory\fP 출력에는 더 많은 내용이 들어가지만, 한 줄 이상은 넘어가지 않습니다.
+.
+.SS 버전
+\fBxz \-\-robot \-\-version\fP 은 \fBxz\fP 와 liblzma의 버전 번호를 다음 형식으로 나타냅니다:
+.PP
+\fBXZ_VERSION=\fP\fIXYYYZZZS\fP
+.br
+\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP
+.TP 
+\fIX\fP
+주 버전.
+.TP 
+\fIYYY\fP
+부 버전.  짝수가 안정 버전입니다.  홀수는 알파 또는 베타 버전입니다.
+.TP 
+\fIZZZ\fP
+안정 릴리스의 패치 수준 또는 개발 릴리스의 횟수입니다.
+.TP 
+\fIS\fP
+안정도.  0은 알파 버전, 1은 베타 버전을 나타내며, 2는 안정 버전을 나타냅니다.  \fIS\fP는 \fIYYY\fP 값이 짝수라 해도 항상
+2여야 합니다.
+.PP
+\fBxz\fP 명령과 liblzma이 동일한 XZ 유틸리티 릴리스에서 나왔다면 두 행의 \fIXYYYZZZS\fP 값은 같습니다.
+.PP
+예제: 4.999.9beta는 \fB49990091\fP이며, 5.0.0은 \fB50000002\fP입니다.
+.
+.SH "종료 상태"
+.TP 
+\fB0\fP
+모든 상태 양호.
+.TP 
+\fB1\fP
+오류 발생.
+.TP 
+\fB2\fP
+눈여겨볼 경고가 나타났지만, 실제 오류는 일어나지 않음.
+.PP
+표준 오류에 출력하는 알림(경고 또는 오류 아님)는 종료 상태에 영향을 주지 않습니다.
+.
+.SH 환경
+\fBxz\fP는 빈칸으로 구분한 옵션 값 목록을 \fBXZ_DEFAULTS\fP, \fBXZ_OPT\fP 환경 변수에서 순서대로, 명령행에서 옵션을
+해석하기 전에 불러옵니다.  참고로 환경 변수에서 옵션만 해석하며, 옵션이 아닌 부분은 조용히 무시합니다.  해석은
+\fBgetopt_long\fP(3)으로 가능하며,  명령행 인자로 활용하기도 합니다.
+.TP 
+\fBXZ_DEFAULTS\fP
+사용자별, 시스템 범위 기본 옵션입니다.  보통 \fBxz\fP의 메모리 사용량 제한을 기본으로 걸어둘 경우 셸 초기화 스크립트에
+설정합니다.  셸 초기화 스크립트와 별도의 유사한 경우를 제외하고라면, 스크립트에서는 \fBXZ_DEFAULTS\fP 환경 변수를 설정하지
+말거나 설정을 해제해야합니다.
+.TP 
+\fBXZ_OPT\fP
+\fBxz\fP 명령행으로 옵션 설정 값을 직접 전달할 수 없을 경우 \fBxz\fP에 옵션을 전달하는 환경 변수입니다.  예를 들어, \fBxz\fP를
+스크립트 또는 도구에서 실행할 경우 GNU \fBtar\fP(1) 라면:
+.RS
+.RS
+.PP
+.nf
+\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR
+.fi
+.RE
+.RE
+.IP ""
+예를 들면, 스크립트에서 \fBXZ_OPT\fP 를 활용하여, 스크립트별로 기본 압축 옵션을 지정할 수 있습니다.  적절한 이유가 있다면
+\fBXZ_OPT\fP 옵션 값을 사용자가 바꾸는걸 추천합니다.  예를 들면, \fBsh\fP(1)  스크립트에서 다음처럼 활용할 수도 있습니다:
+.RS
+.RS
+.PP
+.nf
+\f(CRXZ_OPT=${XZ_OPT\-"\-7e"}
+export XZ_OPT\fR
+.fi
+.RE
+.RE
+.
+.SH "LZMA 유틸리티 호환성"
+\fBxz\fP의 명령행 문법은 실제로 LZMA 유틸리티 4.32.x에서 찾을 수 있는 \fBlzma\fP, \fBunlzma\fP \fBlzcat\fP의
+상위 집합입니다.  대부분의 경우 LZMA 유틸리티를 XZ 유틸리티로 기존에 작성한 스크립트를 깨지 않고도 바꿀 수 있습니다.  몇가지
+비호환성 문제 때문에 문제가 일어날 수는 있습니다.
+.
+.SS "압축 사전 설정 단계"
+압축 수준 사전 설정의 번호 부여 방식은 \fBxz\fP와 LZMA 유틸리티가 동일하지 않습니다.  가장 중요한 차이는 다른 사전 설정에 대해
+딕셔너리 크기를 어떻게 대응했느냐 여부입니다.  딕셔너리 크기는 압축 해제시 메모리 사용량과 거의 비슷합니다.
+.RS
+.PP
+.TS
+tab(;);
+c c c
+c n n.
+단계;xz;LZMA 유틸리티
+\-0;256 KiB;없음
+\-1;1 MiB;64 KiB
+\-2;2 MiB;1 MiB
+\-3;4 MiB;512 KiB
+\-4;4 MiB;1 MiB
+\-5;8 MiB;2 MiB
+\-6;8 MiB;4 MiB
+\-7;16 MiB;8 MiB
+\-8;32 MiB;16 MiB
+\-9;64 MiB;32 MiB
+.TE
+.RE
+.PP
+딕셔너리 크기 차이는 압축 프로그램 메모리 사용에 영향을 주지만, LZMA 유틸리티와 XZ 유틸리티에서 사용량이 늘어나는 다른 차이점이
+있습니다:
+.RS
+.PP
+.TS
+tab(;);
+c c c
+c n n.
+단계;xz;LZMA 유틸리티 4.32.x
+\-0;3 MiB;없음
+\-1;9 MiB;2 MiB
+\-2;17 MiB;12 MiB
+\-3;32 MiB;12 MiB
+\-4;48 MiB;16 MiB
+\-5;94 MiB;26 MiB
+\-6;94 MiB;45 MiB
+\-7;186 MiB;83 MiB
+\-8;370 MiB;159 MiB
+\-9;674 MiB;311 MiB
+.TE
+.RE
+.PP
+XZ 유틸리티의 기본 사전 설정 수준값은 \fB\-6\fP이지만 LZMA 유틸리티의 기본 사전 설정 수준값은 \fB\-7\fP입니다. 두 프로그램의
+딕셔너리 메모리 기본 사용량은 8MiB입니다.
+.
+.SS "스트림 vs 비스트림 .lzma 파일"
+파일을 압축하지 않은 크기는 \fB.lzma\fP 헤더에 저장합니다.  LZMA 유틸리티는 일반 파일을 압축할 때 압축하지 않은 파일의 크기를
+저장합니다.  이 대신 압축하지 않은 크기를 '알 수 없음' 으로 저장하고 압축 해제 프로그램이 멈춰야 할 지점에
+end\-of\-payload 마커를 사용하는 방법도 있습니다.  LZMA 유틸리티는 파이프로 들어온 입력과 같이 압축하지 않은 파일의
+크기를 알 수 없을 때 이런 방식을 활용합니다.
+.PP
+\fBxz\fP는 \fB.lzma\fP 파일을 end\-of\-payload 마커의 유무와 관계없이 압축 해제 방식을 모두 지원하지만, \fBxz\fP로
+만든 모든 \fB.lzma\fP 파일은 end\-of\-payload 마커를 사용하며, \fB.lzma\fP 헤더에 압축하지 않은 파일 크기를 '알 수
+없음'으로 표기합니다. 이 방식은 드문 상황에서 문제를 야기할 수 있습니다.  예를 들면, 임베디드 장치의 \fB.lzma\fP 압축 해제
+프로그램은 압축을 해제했을 때 크기를 알아야 동작합니다.  이 문제를 만나면, LZMA 유틸리티 또는 LZMA SDK를 활용하여
+\&\fB.lzma\fP 파일에 압축 전 파일 크기 정보를 저장해야합니다.
+.
+.SS "지원하지 않는 .lzma 파일"
+\&\fB.lzma\fP 형식은 \fIlc\fP 값을 8까지 받아들이며, \fIlp\fP 값은 4까지 받아들입니다. LZMA 유틸리티는 어떤 \fIlc\fP 값과
+\fIlp\fP 값을 받아들이고도 압축을 해제할 수 있지만, 파일을 만들 때는 늘 \fBlc=3\fP 값과 \fBlp=0\fP 값을 활용합니다.  다른
+\fIlc\fP 값과 \fIlp\fP 값으로의 파일 압축은 \fBxz\fP와 LZMA SDK에서만 가능합니다.
+.PP
+liblzma의 LZMA1 필터 구현체에서는 \fIlc\fP 값과 \fIlp\fP 값의 합이 4를 넘어가면 안됩니다.  그래서 \fB.lzma\fP
+파일의 경우 이 제한을 넘어가면 \fBxz\fP로 압축을 해제할 수 없습니다.
+.PP
+LZMA 유틸리티는 2^\fIn\fP (2의 승수)크기를 지닌 딕셔너리를 가진 \fB.lzma\fP 파일만 만들지만 받아들이는 파일의 딕셔너리
+크기는 어떤 크기든 상관 없습니다.  liblzma에서는 2^\fIn\fP, 2^\fIn\fP + 2^(\fIn\fP\-1) 딕셔너리 크기를 가진
+\&\fB.lzma\fP 파일 만 받아들입니다. 이로 인해 \fB.lzma\fP 파일을 확인할 때 거짓 양성율이 늘어납니다.
+.PP
+모든 \fB.lzma\fP 파일을 liblzma 에서 받아들일 수 있도록 압축하기 때문에 이 제한이 실제로는 문제가 되지 않습니다.
+.
+.SS "뒤따라오는 쓰레기 값"
+압축 해제할 때, LZMA 유틸리티는 \fB.lzma\fP 스트림 처음 부분 다음 나머지를 다 조용히 무시합니다.  대부분의 경우,
+버그입니다.  LZMA 유틸리티에서 \fB.lzma\fP 결합 파일 압축 해제를 지원하지 않음을 의미하기도 합니다.
+.PP
+\&\fB.lzma\fP 스트림 처음부분 바로 다음에 데이터가 남아있을 경우, \fBxz\fP 에서는 \fB\-\-single\-stream\fP 옵션을 사용하지
+않으면 깨진 파일로 간주합니다.  이 동작으로 하여금 뒤따라오는 쓰레기 값을 무시하도록 간주하는 애매한 스크립트 동작을 깰 수가
+있습니��.
+.
+.SH 참고
+.
+.SS "출력 결과물이 달라짐"
+압축하지 않은 입력 파일로부터 얻어낸 정확한 압축 출력 결과물은 압축 옵션이 완전히 동일하더라도 XZ 유틸리티의 버전에 따라 달라질 수
+있습니다.  파일 형식에 영향을 주지 않고 인코더 그 자체를 개선(더 빠르게 하거나 더 나은 압축율로)하기 때문입니다.  XZ 유틸리티
+버전이 동일하더라도 빌드 옵션을 달리하여 빌드 상태가 제각각인 경우 출력 결과물이 달라질 수 있습니다.
+.PP
+\fB\-\-rsyncable\fP 기능을 넣었을 경우 동일한 xz 버전에서 이전 파일과 새 파일로 별도로 압축하지 않는 한 결과 파일을 (두
+파일이 서로 다른 파일이 아니므로) rsync 처리할 필요가 없습니다.  이 문제는 인코더 구현체 기능 개발이 끝나서 xz 버전이
+다르더라도 안정적인 rsync 가능한 출력 결과물을 유지할 수 있을 때여야 해결할 수 있습니다.
+.
+.SS "내장 .xz 압축 해제 프로그램"
+XZ 임베디드와 같은 내장 \fB.xz\fP 압축 해제 구현체는 지원 파일의 무결성 \fI검사\fP 형식을 \fInone\fP과 \fIcrc32\fP 이외의
+설정으로 만들 필요가 없습니다.  기본값이 \fB\-\-check=crc64\fP일 경우에만, 임베디드 시스템에서 파일을 만들 때
+\fB\-\-check=none\fP 또는 \fB\-\-check=crc32\fP 옵션을 사용해야합니다.
+.PP
+임베디드 시스템이 아니라면, 모든 \fB.xz\fP 형식 압축 해제 프로그램에서는 모든 \fI검사\fP 형식을 지원하거나, 일부 \fI검사\fP 방식을
+지원하지 않는다면, 최소한, 무결성 검사로 검증하지 않고 압축을 해제할 수 있습니다.
+.PP
+XZ 임베디드는 BCJ 필터를 지원하지만, 기본 시작 오프셋만 지정할 수 있습니다.
+.
+.SH 예제
+.
+.SS 기본
+\fIfoo\fP 파일을 기본 압축 수준 (\fB\-6\fP) 으로 \fIfoo.xz\fP 파일에 압축해 넣고, 압축 과정이 무사히 끝나면 \fIfoo\fP를
+삭제합니다:
+.RS
+.PP
+.nf
+\f(CRxz foo\fR
+.fi
+.RE
+.PP
+\fIbar.xz\fP를 \fIbar\fP 에 압축을 해제한 후 압축 해제가 무사히 끝나도 \fIbar.xz\fP를 삭제하지 않습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-dk bar.xz\fR
+.fi
+.RE
+.PP
+기본 사전 설정 \fB\-6\fP 보다는 느리지만, 압축 및 압축 해제시 메모리를 적게 차지(각각 48\ Mib, 5\MiB)는 \fB\-4e\fP
+사전 설정(\fB\-4 \-\-extreme\fP)을 활용하여 \fIbaz.tar.xz\fP 파일을 만듭니다:
+.RS
+.PP
+.nf
+\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR
+.fi
+.RE
+.PP
+압축 및 비압축 파일을 단일 명령으로 표준 출력에 압축해제할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR
+.fi
+.RE
+.
+.SS "다중 파일 병렬 압축"
+GNU와 *BSD에서는 \fBfind\fP(1)  명령과 \fBxargs\fP(1)  명령으로 여러 파일의 압축을 병렬 처리할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e
+    | xargs \-0r \-P4 \-n16 xz \-T1\fR
+.fi
+.RE
+.PP
+\fBxargs\fP(1)  의 \fB\-P\fP 옵션으로 \fBxz\fP 프로세스의 병렬 처리 갯수를 지정합니다.  \fB\-n\fP 옵션의 최적 값은 압축할
+파일 수에 달려있습니다.  압축할 파일이 몇개밖에 없다면 1이어야합니다. 파일이 수천 수만개 정도 된다면 \fBxargs\fP(1)  이
+어쨌든지간에 만들어낼 \fBxz\fP 프로세스의 겟수를 100으로 하거나 아니면 적당한 값을 지정하여 줄이는게 좋습니다.
+.PP
+\fBxz\fP에 \fB\-T1\fP옵션을 지정하면 단일\-스레드 모드로 강제합니다. \fBxargs\fP(1)  에서 병렬 처리 갯수를 제어할 수 있기
+때문입니다.
+.
+.SS "로봇 모드"
+여러 파일을 압축한 후 저장할 바이트 용량을 계산합니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR
+.fi
+.RE
+.PP
+이 스크립트에서는 충분히 최신의 \fBxz\fP 명령을 사용하는지 알아보려 합니다.  다음 \fBsh\fP(1)  스크립트에서는 \fBxz\fP 도구의
+버전 번호가 최소한 5.0.0인지 여부를 검사합니다.  이 방식은 \fB\-\-robot\fP 옵션을 지원하지 않는 오래된 베타 버전과도 호환성이
+있습니다:
+.RS
+.PP
+.nf
+\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" ||
+        [ "$XZ_VERSION" \-lt 50000002 ]; then
+    echo "Your xz is too old."
+fi
+unset XZ_VERSION LIBLZMA_VERSION\fR
+.fi
+.RE
+.PP
+\fBXZ_OPT\fP 환경 변수로 압축 해제시 메뢰 사용량 한계를 설정하지만, 한계 값을 이미 설정했다면, 값을 늘리지 않습니다:
+.RS
+.PP
+.nf
+\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB
+OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3)
+if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then
+    XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM"
+    export XZ_OPT
+fi\fR
+.fi
+.RE
+.
+.SS "개별 압축 필터 체인 설정"
+개별 설정 필터 체인의 초단순 사용방식은 LZMA2 사전 설정 값을 별도로 설정하는 방식입니다.  ���전 설정은 잠재적으로 쓸만한 압축
+설정 조합만 다루기 때문에 꽤 쓸모가 있을 수도 있습니다.
+.PP
+\fB\-0\fP ... \fB\-9\fP 옵션의 설명에서 테이블의 CompCPU 컬럼과 \fB\-\-extreme\fP 옵션은 LZMA2 사전 설정을
+개별적으로 맞췄을 때 쓸만할 수도 있습니다.  여기 관련내용을 테이블 둘로 정리해서 모아보았습니다:
+.RS
+.PP
+.TS
+tab(;);
+c c
+n n.
+Preset;CompCPU
+\-0;0
+\-1;1
+\-2;2
+\-3;3
+\-4;4
+\-5;5
+\-6;6
+\-5e;7
+\-6e;8
+.TE
+.RE
+.PP
+어떤 파일을 압축할 때 상당히 큰 딕셔너리(예: 32MiB)가 필요 하다는걸 알아채셨지만, \fBxz \-8\fP 명령이 압축할 때보다 더 빠른
+속도로 압축하려 한다면, 더 큰 딕셔너리 사용을 위해 더 낮은 CompCPU 사전 설정 값(예: 1)으로 수정할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR
+.fi
+.RE
+.PP
+각 파일에 대해, 위 명령은 압축율이 더 좋아지면서도 \fBxz \-6\fP보다 더 빨라집니다.  그러나, CompCPU 값을 낮게 유지하는
+대신 큰 딕셔너리에서 일부 파일을 강조해야 합니다.  큰 딕셔너리가 대부분의 도움을 주는 매우 명백한 상황에서는 최소한 몇 메가바이트의
+매우 유사한 각 파일이 아카이브에 들어갑니다.  딕셔너리 크기는 LZMA2가 연속으로 존재하는 각 파일의 유사성으로부터 얻는 장점을 취할
+수 있을 때 일부 개별 파일보다 훨씬 더 커집니다.
+.PP
+압축 프로그램과 압축 해제 프로그램에서 메모리를 엄청 많이 사용해도 상관 없고, 파일을 수백 메가 바이트 메모리 용량을 활용하여
+압축한다면, \fBxz \-9\fP 명령에 64MiB 용량을 초과하는 딕셔너리를 사용할 수 있게 하는 방법도 쓸만할 지도 모릅니다:
+.RS
+.PP
+.nf
+\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR
+.fi
+.RE
+.PP
+위 예제에서와 같이 \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) 옵션을 사용하면 압축 및 압축 해제 과정에서 필요한 메모리
+용량을 살펴보는데 요긴할 수 있습니다.  압축 해제한 파일 크기보다 더 큰 딕셔너리를 사용하면 불필요한 메모리 소모량이 발생하여 위
+명령이 작은 파일에는 쓸모 없음을 기억하십시오.
+.PP
+때로는 압축 시간이 딱히 상관이 없을 수도 있습니다만, 압축 해제시 메모리 사용량을 적게 유지해야 할 수도 있습니다. 예를 들면,
+임베디드 시스템에서 파일 압축을 해제할 수도 있습니다.  다음 명령의 경우 \fB\-6e\fP (\fB\-6 \-\-extreme\fP) 옵션을 기반
+옵션을 사용하며 딕셔너리 크기를 64KiB만 사용하도록 제한합니다.  결과 파일은 XZ 임베디드(이게 \fB\-\-check=crc32\fP
+옵션이 있는 이유)로 100KiB 메모리 용량을 활용하여 풀어낼 수 있습니다.
+.RS
+.PP
+.nf
+\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR
+.fi
+.RE
+.PP
+가능한 한 수 바이트를 더 쥐어 짜내고 싶을 때, 리터럴 문맥 비트 수(\fIlc\fP)와 위치 비트 수(\fIpb\fP)를 조정하면 도움이 될
+수도 있습니다.  리터럴 위치 비트 수(\fIlp\fP)를 조금 건드리는 것 또한 도움이 될 지도 모르겠지만 보통 \fIlc\fP 값과 \fIpb\fP
+값이 더 중요합니다.  예를 들면, 소스 코드 저장 파일에는 US\-ASCII 텍스트가 대부분이기에, 다음과 같은 경우는 \fBxz \-6e\fP
+명령을 실행했을 때부다는 아주 약간(거의 0.1% 수준) 작은 파일을 얻어낼 수도 있습니다(\fBlc=4\fP를 빼고도 시도해보십시오):
+.RS
+.PP
+.nf
+\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR
+.fi
+.RE
+.PP
+LZMA2와 다른 필터를 함께 사용하면 일부 파일 형식에 대해 압축율을 개선할 수 있습니다.  예를 들면 x86\-32 또는 x86\-64
+공유 라이브러리를 x86 BCJ 필터를 활용하여 압축할 경우:
+.RS
+.PP
+.nf
+\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR
+.fi
+.RE
+.PP
+참고로 필터 옵션의 순서는 상당히 중요합니다.  \fB\-\-x86\fP을 \fB\-\-lzma\fP 이전에 지정하면 \fBxz\fP에서 오류가 나는데,
+LZMA2 다음에는 어떤 필터든 설정할 수 없고, 옵션 체인상 마지막 필터로 x86 BCJ 필터를 사용할 수 없기 때문입니다.
+.PP
+LZMA2와 델타 필터는 비트맵 그림에 최적의 결과를 가져다줄 수 있습니다.  PNG에 보통 안성맞춥인데, PNG에는 단순 델타 필터보단
+약간 더 고급진 필터를 사용하지만, 실제 압축을 진행할 때는 Deflate를 사용하기 때문입니다.
+.PP
+예를 들어 이미지를 압축하지 않은 비압축 TIFF로 저장해야 하는 경우가 있습니다.  델타 필터의 거리 매개변수는 그림에서 픽셀당 바이트
+수에 일치하도록 설정합니다.  예를 들면, 24비트 RGB 비트맵의 경우 \fBdist=3\fP 거리 매개변수 값을 설정해야 하며, LZMA2
+압축시 3바이트 정렬을 따르도록 \fBpb=0\fP 값을 전달하는 방법도 바람직합니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR
+.fi
+.RE
+.PP
+여러 이미지를 단일 아카이브로 넣고 싶다면(예: \fB.tar\fP), 모든 이미지에 대해 동일한 픽셀당 바이트 수가 들어가는 경우에도 델타
+필터가 동작합니다.
+.
+.SH "추가 참조"
+\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1),
+\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1)
+.PP
+XZ 유틸리티: <https://tukaani.org/xz\-utils/>
+.br
+XZ 임베디드: <https://tukaani.org/xz/embedded/>
+.br
+LZMA SDK: <https://7\-zip.org/sdk.html>

janus/share/man/ko/man1/xz.1

@@ -0,0 +1,1548 @@
+'\" t
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZ 1 2024\-12\-30 Tukaani "XZ 유틸리티"
+.
+.SH 이름
+xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz 파일과 .lzma 파일을 압축 또는 압축 해제합니다
+.
+.SH 요약
+\fBxz\fP [\fI<옵션>...\fP] [\fI<파일>...\fP]
+.
+.SH "명령 별칭"
+\fBunxz\fP 명령은 \fBxz \-\-decompress\fP 명령과 동일합니다.
+.br
+\fBxzcat\fP 명령은 \fBxz \-\-decompress \-\-stdout\fP 명령과 동일합니다.
+.br
+\fBlzma\fP 명령은 \fBxz \-\-format=lzma\fP 명령과 동일합니다.
+.br
+\fBunlzma\fP 명령은 \fBxz \-\-format=lzma \-\-decompress\fP 명령과 동일합니다.
+.br
+\fBlzcat\fP 명령은 \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP 명령과 동일합니다.
+.PP
+파일 압축을 해제해야 하는 셸 스크립트를 작성할 때, \fBunxz\fP 와 \fBxzcat\fP 이름 대신 \fBxz\fP 명령과 적절한 인자
+값(\fBxz \-d\fP 또는 \fBxz \-dc\fP)의 사용을 추천드립니다.
+.
+.SH 설명
+\fBxz\fP는 \fBgzip\fP(1)  과 \fBbzip2\fP(1)  과 비슷한 명령행 문법을 지닌 범용 데이터 압축 도구입니다.  자체 파일
+형식은 \fB.xz\fP 형식이나, LZMA 유틸리티에서 사용하는 예전 \fB.lzma\fP 형식과 형식 헤더가 없는 RAW 압축 스트림도
+지원합니다.  게다가, \fBlzip\fP에서 활용하는 \fB.lz\fP 형식 압축 해제도 지원합니다.
+.PP
+각 \fI파일\fP 에 대한 \fBxz\fP 압축 또는 압축 해제는 선택 동작 모드에 따릅니다.  \fI<파일>\fP 값이 주어졌거나
+\fI<파일>\fP 값이 \fB\-\fP이면, \fBxz\fP 명령에서 표준 입력을 읽고 처리한 데이터를 표준 출력에 기록합니다.
+\fBxz\fP 에서는 터미널에서 활용할 경우 압축 데이터를 표준 압축으로 기록하는 동작을 거절(오류를 출력하고 \fI<파일>\fP을
+건너뜀)합니다.  이와 비슷하게, \fBxz\fP 유틸리티를 터미널에서 실행하면 표준 입력의 압축 데이터 읽기를 거절합니다.
+.PP
+\fB\-\-stdout\fP 을 지정하지 않는 한, \fB\-\fP가 아닌 \fI<파일>\fP을 원본 \fI<파일>\fP 이름에서
+가져온 새 파일 이름으로 기록합니다:
+.IP \(bu 3
+압축할 때, 대상 파일 형식의 접미사(\fB.xz\fP or \fB.lzma\fP)  는 원본 파일 이름 뒤에 붙어 대상 파일이름이 됩니다.
+.IP \(bu 3
+압축 해제할 때, \fB.xz\fP, \fB.lzma\fP, \fB.lz\fP 접미사를 파일 이름에서 제거하고 대상 파일 이름을 알아냅니다.
+\fBxz\fP에서는 \fB.txz\fP, \fB.tlz\fP 접미사도 인식하며, \fB.tar\fP 접미사로 치환합니다.
+.PP
+대상 파일이 이미 있으면, 오류를 나타내고 \fI<파일>\fP을 건너뜁니다.
+.PP
+표준 출력으로 기록하기 전에는, \fBxz\fP는 경고를 나타내며, 다음 조건에 만족할 경우 \fI<파일>\fP을 건너뜁니다:
+.IP \(bu 3
+\fI<파일>\fP이 일반 파일이 아닐 때.  심볼릭 링크는 따라가지 않기에, 일반 파일로 간주하지 않습니다.
+.IP \(bu 3
+\fI<파일>\fP이 하나 이상의 하드 링크일 떄.
+.IP \(bu 3
+\fI<파일>\fP에 setuid, setgid, 끈적이 비트 집합이 붙어있을 떄.
+.IP \(bu 3
+동작 모드를 압축으로 설정하고, \fI<파일>\fP은 대상 파일 형식의 접미사를 이미 붙였을 때(\fB.xz\fP 형식으로 압축하면
+\&\fB.xz\fP 또는 \fB.txz\fP, \fB.lzma\fP 형식으로 압축하면 \fB.lzma\fP 또는 \fB.tlz\fP).
+.IP \(bu 3
+동작 모드를 압축 해제로 설정하고, \fI<파일>\fP에 지원 파일 형식 접미사(\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP,
+\&\fB.tlz\fP, \fB.lz\fP)를 붙이지 않았을 때.
+.PP
+\fI<파일>\fP 의 압축 또는 압축 해제를 성공하고 나면, \fBxz\fP는 소유자, 소유그룹, 권한, 접근 시각, 수정 시각
+정보를 원본 \fI<파일>\fP에서 대상 파일로 그대로 복사합니다.  그룹 정보 복사에 실패하면, 권한을 수정하여 원본
+\fI<파일>\fP에 접근 권한이 없는 사용자가 대상 파일로 접근하지 못하게 합니다.  \fBxz\fP는 아직 접근 제어 목록이나
+확장 속성 등의 기타 메타데이터를 복사하는 기능은 지원하지 않습니다.
+.PP
+대상 파일을 온전히 닫고 나면, \fB\-\-keep\fP 옵션을 지원하지 않았을 경우 원본 \fI<파일>\fP을 제거합니다.  원본
+\fI<파일>\fP은 출력을 표준 출력으로 기록했거나 오류가 발생했을 경우 제거하지 않습니다.
+.PP
+\fBxz\fP 프로세스에 \fBSIGINFO\fP 시그널 또는 \fBSIGUSR1\fP 시그널을 보내면 표준 출력으로 진행 정보를 출력합니다.  표준
+오류가 터미널일 경우일 경우에만 제한하며 \fB\-\-verbose\fP 옵션을 지정하면 진행 표시줄을 자동으로 나타냅니다.
+.
+.SS "메모리 사용"
+\fBxz\fP 메모리 사용은 수백 킬로바이트로 시작하여 수 기가바이트까지 압축 설정에 따라 다릅니다.  압축 해제 프로그램이 필요로 하는
+메모리 공간을 결정하는 파일 압축시에 설정 값을 활용합니다.  보통 압축 해제 프로그램은 파일을 만들 때, 압축 프로그램 메모리 사용량의
+5% 에서 20% 정도 필요합니다.  예를 들면, \fBxz \-9\fP로 압축한 파일 압축 해제시 현재 65MiB 메모리 용량이 필요합니다.
+여전하게도, 압축 해제시 수 기가 바이트의 메모리가 필요한 \fB.xz\fP 파일에도 가능한 이야기입니다.
+.PP
+특히 이전 시스템 사용자의 경우 메모리 사용량이 엄청나게 늘어나는 점에 짜증이 날 수 있습니다.  이런 불편한 상황을 피하기 위해,
+\fBxz\fP에 기본적으로 비활성 상태인 내장 메모리 사용 제한 기능을 넣었습니다.  일부 운영체제에서 처리 중 메모리 사용을 제한하는
+수단을 제공하긴 하지만, 여기에 의지하기에는 충분히 유연하지 않습니다(예를 들면, \fBulimit\fP(1)을 사용하면 가상 메모리를
+제한하여  \fBmmap\fP(2)을 먹통으로 만듭니다).
+.PP
+메모리 사용 제한 기능은 \fB\-\-memlimit=\fP\fI<제한용량>\fP 명령행 옵션으로 사용할 수 있습니다.  종종
+\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP와 같이 \fBXZ_DEFAULTS\fP 환경 변수를 설정하여 제한 기능을 켜는게 더
+편합니다.  \fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션과
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP 옵션을 활용하여 압축 및 압축 해제시 별도로 한계 값을
+설정할 수 있습니다.  이 두 가지 옵션의 \fBXZ_DEFAULTS\fP 환경 변수 밖에서의 사용은, \fBxz\fP를 단일 실행할 때 압축 및
+압축 해제 동작을 동시에 수행하지 않으며, 앞서 언급한 두가지 옵션을 명령행에 입력하기에는
+\fB\-\-memlimit=\fP\fI<제한용량>\fP(또는 \fB\-M\fP \fI<제한용량>\fP)이 더 짧기 때문에 별로 쓸모가
+없습니다.
+.PP
+압축 해제시 메모리 사용 제한 지정 한계를 초과하면, \fBxz\fP 유틸리티에서 오류를 나타내며 파일 압축 해제는 실패합니다.  압축을
+실행할 때 사용 제한 지정 한계를 넘어서면 \fBxz\fP에서는 설정 값을 줄여서 어쨌든 한계를 넘지 못하게
+합니다(\fB\-\-format=raw\fP 옵션 또는 \fB\-\-no\-adjust\fP 옵션 사용시 제외).  설정 한계 값이 엄청 작지 않은 이상 이
+방식대로 처리하면 어쨌든 실패하지 않습니다.  설정 값조정은 압축 래벨 사전 설정과 일치하지 않을 때 단계적으로 진행하는데, 이를테면,
+\fBxz \-9\fP 명령 수행에 필요한 양보다 한계 값이 약간 작으면, 설정 값을 \fBxz \-8\fP에 못미치게 약간 줄여서 진행합니다.
+.
+.SS ".xz 파일 결합 및 패딩"
+\&\fB.xz\fP 파일을 있는 그대로 합칠 수 있습니다.  \fBxz\fP는 \fB.xz\fP 파일을 단독 파일일 때 처럼 압축해제합니다.
+.PP
+결합 부분과 마지막 부분 뒤에 패딩을 추가할 수 있습니다.  패딩은 널 바이트로 구성해야 하며 패딩 길이는 4바이트로 구성해야 합니다.
+512 바이트 블록으로 파일 크기를 이루는 매체에 \fB.xz\fP 파일을 저장했을 경우에 요긴할 수 있습니다.
+.PP
+\&\fB.lzma\fP 파일 또는 원시 스트림의 경우 결합과 패딩을 허용하지 않습니다.
+.
+.SH 옵션
+.
+.SS "정수 접두사와 별도 값"
+정수 인자값이 필요한 대부분 위치에서는, 큰 정수값을 나타내기 쉽게 하도록 추가 접미사를 지원합니다.  정수와 접미사 사이에 어떤 공백이
+있으면 안됩니다.
+.TP 
+\fBKiB\fP
+1,024 (2^10) 배수 정수값. \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, \fBKB\fP 단위를 \fBKiB\fP 동의어로 받아들입니다.
+.TP 
+\fBMiB\fP
+1,048,576 (2^20) 배수 정수값. \fBMi\fP, \fBm\fP, \fBM\fP, \fBMB\fP 단위를 \fBMiB\fP 동의어로 받아들입니다.
+.TP 
+\fBGiB\fP
+1,073,741,824 (2^30) 배수 정수값.  \fBGi\fP, \fBg\fP, \fBG\fP, \fBGB\fP 단위를 \fBGiB\fP 동의어로
+받아들입니다.
+.PP
+특수 값 \fBmax\fP는 옵션에서 지원하는 정수 최대 값을 나타낼 때 사용할 수 있습니다.
+.
+.SS "동작 모드"
+여러 동작 모드를 보여드리겠습니다만, 마지막에 주어진 동작 모드로 동작합니다.
+.TP 
+\fB\-z\fP, \fB\-\-compress\fP
+압축합니다.  어떤 동작 모드 옵션도 지정하지 않고 다른 동작 모드를 명령행에 따로 지정하지 않았다면 이 동작 모드는 기본입니다(예:
+\fBunxz\fP 는 \fB\-\-decompress\fP를 암시).
+.IP ""
+.\" The DESCRIPTION section already says this but it's good to repeat it
+.\" here because the default behavior is a bit dangerous and new users
+.\" in a hurry may skip reading the DESCRIPTION section.
+After successful compression, the source file is removed unless writing to
+standard output or \fB\-\-keep\fP was specified.
+.TP 
+\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP
+.\" The DESCRIPTION section already says this but it's good to repeat it
+.\" here because the default behavior is a bit dangerous and new users
+.\" in a hurry may skip reading the DESCRIPTION section.
+Decompress.  After successful decompression, the source file is removed
+unless writing to standard output or \fB\-\-keep\fP was specified.
+.TP 
+\fB\-t\fP, \fB\-\-test\fP
+압축 \fI<파일>\fP의 무결성을 시험해봅니다.  이 옵션은 압축 해제 데이터를 표준 출력으로 기록하는 대신 버린다는 점을
+제외하고 \fB\-\-decompress \-\-stdout\fP과 동일합니다.  어떤 파일도 만들거나 제거하지 않습니다.
+.TP 
+\fB\-l\fP, \fB\-\-list\fP
+압축 \fI<파일>\fP 정보를 출력합니다.  압축 해제 출력을 내보내지 않으며, 어떤 파일도 만들거나 제거하지 않습니다.  이
+조회 모드에서, 프로그램은 표준 입력 또는 기타 탐색 불가능한 원본에서 압축 데이터를 읽을 수 없습니다.
+.IP ""
+\fI<파일>\fP 기본 정보를 파일 당 한 줄 씩 기본으로 보여줍니다.  더 자세한 정보를 보려면 \fB\-\-verbose\fP
+옵션을 사용하십시오.  더 자세한 정보는 \fB\-\-verbose\fP 옵션을 두번 사용하면 되지만, 추가 정보를 더 많이 가져오면서 탐색
+횟수가 늘어나는 문제로 인해 느려질 수 있습니다.  세부 출력 너비는 80 문자를 초과하며, 예를 들어 출력을 파이핑한다면, 터미널이
+충분히 너비가 넓지 못할 경우 \fBless\ \-S\fP 명령이 편리할 수 있습니다.
+.IP ""
+정확한 출력은 \fBxz\fP 버전과 다른 로캘에 따라 바뀔 수 있습니다.  기계 판독용 출력시 \fB\-\-robot \-\-list\fP 옵션을
+사용합니다.
+.
+.SS "동작 수정자"
+.TP 
+\fB\-k\fP, \fB\-\-keep\fP
+입력 파일을 삭제하지 않습니다.
+.IP ""
+\fBxz\fP 5.2.6 부터는 이 옵션으로 입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid,
+setgid, 끈적이 비트 세트를 설정한 상태라도 압축하거나 압축을 풀 수 있습니다. setuid, setgid, 끈적이 비트는 대상
+파일에 복사하지 않습니다.  이전 버전에서는 \fB\-\-force\fP 옵션을 지정했을 때만 가능했습니다.
+.TP 
+\fB\-f\fP, \fB\-\-force\fP
+이 옵션은 몇가지 동작에 영향을 줍니다:
+.RS
+.IP \(bu 3
+대상 파일이 이미 있으면, 압축 또는 압축 해제 전 삭제합니다.
+.IP \(bu 3
+입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, setgid, 끈적이 비트 세트를 설정한
+상태라도 압축 또는 압축 해제를 진행합니다.  setuid, setgid, 끈적이 비트는 대상 파일에 복사하지 않습니다.
+.IP \(bu 3
+\fB\-\-decompress\fP \fB\-\-stdout\fP 옵션을 같이 사용하는 상황에서 \fBxz\fP 명령이 원본 파일의 형식을 알아내지 못할 때,
+원본 파일의 사본을 표준 출력으로 보냅니다.  이렇게 하면 \fBxzcat\fP \fB\-\-force\fP 명령을 \fBxz\fP 명령으로 압축하지 않은
+파일에 대해 \fBcat\fP(1) 을 사용하는 것처럼 사용할 수 있습니다.  참고로 나중에, \fBxz\fP에서 \fBxz\fP로 하여금 여러 형식의
+파일을 표준 출력으로 복사하는 대신 압축을 해제하도록 새 압축 파일 형식을 지원할 예정입니다.
+\fB\-\-format=\fP\fI<형식>\fP 옵션은 \fBxz\fP 명령에 단일 파일 형식만 압축 해제하도록 제한할 때 사용할 수
+있습니다.
+.RE
+.TP 
+\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP
+파일 대신 표준 출력으로 압축 또는 압축 해제한 데이터를 기록합니다.  \fB\-\-keep\fP를 생략했습니다.
+.TP 
+\fB\-\-single\-stream\fP
+처음 \fB.xz\fP 스트림만 압축 해제하며, 스트림에 뒤따라오는 나머지 입력 데이터는 조용히 무시합니다.  보통 뒤따라오는 쓰레기 값에
+대해서는 \fBxz\fP 에서 오류를 나타냅니다.
+.IP ""
+\fBxz\fP는 \fB.lzma\fP 파일 또는 원시 스트림에서 온 하나 이상의 스트림에 대해 압축 해제동작을 취하지 않지만, 이 옵션을 사용하면
+\fBxz\fP에서 \fB.lzma\fP 파일 또는 원시 스트림을 처리한 다음에 뒤따라오는 데이터를 무시하도록 합니다.
+.IP ""
+이 옵션은 동작 모드가 \fB\-\-decompress\fP 또는 \fB\-\-test\fP가 아니면 동작에 아무런 영향을 주지 않습니다.
+.TP 
+\fB\-\-no\-sparse\fP
+희소 파일을 만들지 않습니다.  기본적으로 일반 파일로 압축 해제할 경우 \fBxz\fP 에서는 압축 해제한 파일에 이진 0값이 길게 늘어질
+경우 희소 배열 파일을 만들려고 합니다.  표준 출력의 내용 길이만큼 연결한 일반 파일로 기록할 때도 동작하며 희소 파일을 만드는 동안
+아무런 ��제가 나타나지 않게 각각의 추가 조건을 만족합니다.  희소 파일을 만들면 디스크 공간을 절약할 수 있으며 디스크 입출력을 줄여
+압축 해제 속도를 올릴 수 있습니다.
+.TP 
+\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP
+압축할 때, 대상 파일의 접두사를 \fB.xz\fP 또는 \fB.lzma\fP 대신 \fI.suf\fP로 사용하십시오.  표준 출력으로 기록하지 않고
+원본 파일에 \fI.suf\fP 접두사가 붙어있으면, 경고를 나타내고 해당 파일을 건너뜁니다.
+.IP ""
+압축 해제할 때, \fI.suf\fP 접미사로 파일을 인식하기도 하고, \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP,
+\&\fB.lz\fP 접미사가 붙은 파일도 인식합니다.  원본 파일에 \fI.suf\fP 접미사가 붙어있으면, 해당 접미사를 제거하여 대상 파일 이름을
+알아냅니다.
+.IP ""
+원시 스트림 압축 및 압축 해제시(\fB\-\-format=raw\fP) 원시 스트림에 기본 접미사가 없기 때문에, 표준 출력으로 기록하지 않는
+한 접미사를 반드시 지정해야 합니다.
+.TP 
+\fB\-\-files\fP[\fB=\fP\fI<파일>\fP]
+\fI<파일>\fP에서 처리할 파일 이름을 읽습니다. \fI<파일>\fP을 생략하면 파일 이름은 표준 입력에서
+불러옵니다.  파일 이름은 개행 문자로 끝나야 합니다.  대시 문자(\fB\-\fP)는 일반 파일 이름으로 취급하며 표준 입력을 의미하지
+않습니다.  파일 이름을 명령행 인자로 지정하면, \fI<파일>\fP에서 파일 이름을 읽어들이기 전 해당 명령행 인자를 먼저
+처리합니다.
+.TP 
+\fB\-\-files0\fP[\fB=\fP\fI<파일>\fP]
+각 파일 이름이 널 문자로 끝나야 한다는 점만 제외하면 \fB\-\-files\fP[\fB=\fP\fI<파일>\fP] 옵션과 동일합니다.
+.
+.SS "기본 파일 형식 및 압축 옵션"
+.TP 
+\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fI<형식>\fP
+압축 또는 압축해제 파일 \fI<형식>\fP을 지정합니다:
+.RS
+.TP 
+\fBauto\fP
+기본 값입니다.  압축할 때, \fBauto\fP는 \fBxz\fP의 기본 동작과 동일합니다.  압축을 해제할 때, 입력 파일 형식을 자동으로
+찾습니다.  참고로 원시 스트림(\fB\-\-format=raw\fP)의 경우 자동으로 찾을 수 없습니다.
+.TP 
+\fBxz\fP
+\&\fB.xz\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.xz\fP 파일만 받아들입니다.
+.TP 
+\fBlzma\fP, \fBalone\fP
+이전 \fB.lzma\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.lzma\fP 파일만 받아들입니다.  \fBalone\fP 대체 명령은 LZMA
+유틸리티 하위 호환성을 목적으로 제공합니다.
+.TP 
+\fBlzip\fP
+압축 해제시 \fB.lz\fP 파일만 받아들입니다.  압축은 지원하지 않습니다.
+.IP ""
+\&\fB.lz\fP 형식 버전 0과 비확장 버전 1을 지원합니다.  버전 0파일은 \fBlzip\fP 1.3 이전에서만 만듭니다.  일반적이진 않지만
+일부 파일의 경우 이 형식과 관련된 원본 패키지로 보관한 파일을 찾을 수도 있습니다.  개인적으로 이 형식으로 압축한 오래된 개인 파일을
+가지고 있을 수도 있습니다.  형식 버전 0 압축 해제 지원은 \fBlzip\fP 1.18에서 제거했습니다.
+.IP ""
+\fBlzip\fP 1.4 이상에서는 버전 1형식의 파일을 만듭니다.  형식 버전 1로의 동기화 제거 마커 확장은 \fBlzip\fP 1.6에
+추가했습니다.  이 확장은 거의 쓰지 않으며 \fBxz\fP 에서 조차도 지원하지 않습니다(손상된 입력 파일로 진단함).
+.TP 
+\fBraw\fP
+원시 스트림으로 압축하거나 압축을 해제합니다(헤더 없음).  고급 사용자 전용입니다.  원시 스트림을 디코딩하려면,
+\fB\-\-format=raw\fP 옵션을 사용하고 분명하게 필터 체인을 지정하여 컨테이너 헤더에 필요한 정보를 저장하게 끔 해야합니다.
+.RE
+.TP 
+\fB\-C\fP \fI<검사방식>\fP, \fB\-\-check=\fP\fI<검사방식>\fP
+무결성 검사 방식을 지정합니다.  검사 방식은 \fB.xz\fP 파일에 저장하며 압축 해제 데이터를 계산합니다.  이 옵션은 \fB.xz\fP
+형식으로 압축할 때만 효력이 있습니다: \fB.lzma\fP 형식은 무결성 겁사를 지원하지 않습니다.  무결성 검사는 \fB.xz\fP 파일 압축을
+풀었을 때에 검사합니다.
+.IP ""
+지원 \fI검사\fP 형식:
+.RS
+.TP 
+\fBnone\fP
+어떤 경우에도 무결성 검사 계산을 수행하지 않습니다.  보통 바람직하지 못한 생각입니다.  데이터 무결성을 다른 방식으로라도 검증해야
+하는 상황이면 쓸만할 수 있습니다.
+.TP 
+\fBcrc32\fP
+IEEE\-802.3 (이더넷)의 다항 연산으로 CRC32를 계산합니다.
+.TP 
+\fBcrc64\fP
+ECMA\-182의 다항식 연산으로 CRC64를 계산합니다.  이 동작이 기본 동작이기 때문에 CRC32가 깨진 파일을 찾을 때보다는 좀
+낮은 편이며 속도 차이도 거의 없습니다.
+.TP 
+\fBsha256\fP
+SHA\-256 해시를 계산합니다.  CRC32와 CRC64 보다는 좀 느립니다.
+.RE
+.IP ""
+\&\fB.xz\fP 헤더 무결성은 항상 CRC32로 검증하빈다.  이를 바꾸거나 It is not possible to change or
+disable it.
+.TP 
+\fB\-\-ignore\-check\fP
+압축 데이터를 압축해제할 경우 압축 데이터의 무결성 검증을 진행하지 않습니다.  \fB.xz\fP 헤더의 CRC32 값은 그래도 여전히 보통
+방식으로 검증합니다.
+.IP ""
+\fB이 옵션이 정확히 무슨 동작을 하는지 알기 전에는 사용하지 마십시오.\fP 이 옵션을 사용하는 타당한 이유로:
+.RS
+.IP \(bu 3
+깨진 .xz 파일에서 데이터 복구를 시도합니다.
+.IP \(bu 3
+압축 해제 속도를 늘립니다.  SHA\-256 또는 압축 파일에 들어간 그 무언가를 엄청 빨리 처리합니다.  다른 방식으로 파일 무결성을
+검증해야 하는 목적이 아니라면 이 옵션을 사용하지 않는게 좋습니다.
+.RE
+.TP 
+\fB\-0\fP ... \fB\-9\fP
+압축 사전 설정 수준을 선택합니다.  기본값은 \fB\-6\fP입니다.  다중 수준을 지정하면 가장 마지막 수준 옵션을 적용합니다.  개별 필터
+체인을 이미 지정했다면, 압축 사전 설정 수준 값을 설정할 때 개별 필터 체인을 정리합니다.
+.IP ""
+사전 설정간 차이는 \fBgzip\fP(1)과 \fBbzip2\fP(1)을 사용할 때보다 더 비중을 차지합니다.  선택한 압축 설정은 압축 해제시
+필요한 메모리 사용량을 셜정하므로 사전 설정 수준 값을 너무 높게 지정하면 RAM 용량이 적은 오래된 시스템에서 파일 압축 해제시 실패할
+수 있습니다.  게다가, \fBgzip\fP(1)  과 \fBbzip2\fP(1)에서 처럼 종종 \fB모든 동작에 \-9를 몰래 활용하는건 바람직하지 않습니다\fP.
+.RS
+.TP 
+\fB\-0\fP ... \fB\-3\fP
+동작이 빠른 사전 설정 부류입니다. \fB\-0\fP은 때로는 \fBgzip \-9\fP 명령보다 압축율이 훨씬 우수하면서도 더 빠릅니다.  더 큰
+값은 보통 \fBbzip2\fP(1) 명령과 비교했을 떄 압축 결과가 압축 데이터에 따라 달라지더라도, 비교할 법한 속도 또는 더 나은
+압축율을 보입니다.
+.TP 
+\fB\-4\fP ... \fB\-6\fP
+오래된 시스템에서 조차도 압축 해제 프로그램의 적절한 메모리 사용량을 보이면서 양호하거나 최적의 압축율을 보여줍니다.  \fB\-6\fP 옵션은
+압축 해제시 메모리 사용량이 16MiB 밖에 안되기 때문에 파일을 배포할 때 최적의 선택인 기본 값입니다.  (\fB\-5e\fP 또는
+\fB\-6e\fP도 역시 고려할 만합니다.  \fB\-\-extreme\fP을 참고하십시오.)
+.TP 
+\fB\-7 ... \-9\fP
+\fB\-6\fP과 비슷하지만 압축 및 압축 해제시 요구 메모리 사용량이 더 높습니다.  압축 파일이 각각 8MiB, 16MiB, 32MiB
+보다 클 경우에만 쓸만한 옵션입니다.
+.RE
+.IP ""
+동일한 하드웨어에서, 압축 해제 속도는 압축한 데이터의 초당 정적 바이트 처리 수의 어림 평균입니다.  다시 말해, 압축율을 더 올리면,
+압축 해제 속도도 역시 올라갑니다.  이는 곧 초당 비압축 데이터 출력 양이 달라질 수 있단 뜻입니다.
+.IP ""
+다음 표에 사전 설정 기능을 정리했습니다:
+.RS
+.RS
+.PP
+.TS
+tab(;);
+c c c c c
+n n n n n.
+Preset;DictSize;CompCPU;CompMem;DecMem
+\-0;256 KiB;0;3 MiB;1 MiB
+\-1;1 MiB;1;9 MiB;2 MiB
+\-2;2 MiB;2;17 MiB;3 MiB
+\-3;4 MiB;3;32 MiB;5 MiB
+\-4;4 MiB;4;48 MiB;5 MiB
+\-5;8 MiB;5;94 MiB;9 MiB
+\-6;8 MiB;6;94 MiB;9 MiB
+\-7;16 MiB;6;186 MiB;17 MiB
+\-8;32 MiB;6;370 MiB;33 MiB
+\-9;64 MiB;6;674 MiB;65 MiB
+.TE
+.RE
+.RE
+.IP ""
+컬럼 설명:
+.RS
+.IP \(bu 3
+DictSize는 LZMA2 딕셔너리 크기입니다.  압축 해제 파일의 크기보다 딕셔너리에서 사용하는 낭비 메모리 용량입니다.  실제로
+필요하지 않은 \fB\-7\fP ... \fB\-9\fP 사전 설정값을 피해야 하는 적절한 이유이기도 합니다.  \fB\-6\fP 이하에서는 소모 메모리 양이
+충분히 적거나 따로 신경쓸 필요가 없습니다.
+.IP \(bu 3
+CompCPU는 압축 속도에 영향을 주는 LZMA2 설정의 단순화 표기 값입니다.  딕셔너리 크기는 속도에도 영향을 주기 때문에
+CompCPU는 \fB\-6\fP ... \fB\-9\fP 수준값과 동일한데, 고수준 값은 여전히 조금 더 느려질 수 있습니다.  느려지는 만큼
+압축율은 가능한 한 더 좋아집니다. \fB\-\-extreme\fP을 참고하십시오.
+.IP \(bu 3
+CompMem은 단일\-스레드 모드에서 필요한 압축 프로그램의 메모리 점유 용량입니다.  \fBxz\fP 버전에 따라 다를 수 있습니다.
+.IP \(bu 3
+DecMem은 압축 해제 프로그램의 메모리 점유용량입니다.  이는 곧, 압축 해제 프로그램에서 필요한 메모리 사용량을 압축 설정에서
+결정한다는 의미가 들어있습니다.  정확한 압축 해제 프로그램의 메모리 사용량은 LZMA2 딕셔너리 크기 보다는 조금 많지만 테이블의 값은
+MiB 용량으로 완전히 반올림한 값입니다.
+.RE
+.IP ""
+다중\-스레드 모드에서 필요한 메모리 용량은 단일\-스레드 모드보단 약간 더 많습니다.  \fB\-\-block\-size\fP 기본값에 따라, 각
+스레드에서는 3*3*딕셔녀리_크기 + 압축시_메모리용량 또는 압축_해제시_메모리용량 정도가 필요합니다.  예를 들면, 스레드 넷에 사전
+설정 옵션 \fB\-6\fP을 사용한다면, 660\(en670 MiB 메모리 용량이 필요합니다.
+.TP 
+\fB\-e\fP, \fB\-\-extreme\fP
+기대하는 만큼의 좀 더 나은 압축율을 확보하려 선택한 압축 사전 설정 수준의 느린 변형 옵션을 사용하지만, 재수 없는 와중에 골로 가는
+경우가 생기기도 합니다.  압축 해제 프로그램의 메모리 사용에는 영향을 주지 않지만, 압축 프로그램의 메모리 사용량은 \fB\-0\fP
+\&... \fB\-3\fP 사전 설정 수준에서 약간 더 올라갈 뿐입니다.
+.IP ""
+4MiB와 8MiB 두 가지 딕셔너리 용량 설정이 있기 때문에 \fB\-3e\fP 와 \fB\-5e\fP 사전 설정을 (CompCPU 수치를 낮춰서)
+각각 \fB\-4e\fP 와 \fB\-6e\fP 보다 약간 더 빠르게 설정할 수 있습니다.  이런 식으로 두 사전 설정이 동일하지 않습니다.
+.RS
+.RS
+.PP
+.TS
+tab(;);
+c c c c c
+n n n n n.
+Preset;DictSize;CompCPU;CompMem;DecMem
+\-0e;256 KiB;8;4 MiB;1 MiB
+\-1e;1 MiB;8;13 MiB;2 MiB
+\-2e;2 MiB;8;25 MiB;3 MiB
+\-3e;4 MiB;7;48 MiB;5 MiB
+\-4e;4 MiB;8;48 MiB;5 MiB
+\-5e;8 MiB;7;94 MiB;9 MiB
+\-6e;8 MiB;8;94 MiB;9 MiB
+\-7e;16 MiB;8;186 MiB;17 MiB
+\-8e;32 MiB;8;370 MiB;33 MiB
+\-9e;64 MiB;8;674 MiB;65 MiB
+.TE
+.RE
+.RE
+.IP ""
+예를 들면, 8MiB 딕셔너리를 활용하는 네가지 사전 설정이 있다고 할 때, 빠른 순으로 설정을 나열하자면, \fB\-5\fP, \fB\-6\fP,
+\fB\-5e\fP, \fB\-6e\fP 입니다.
+.TP 
+\fB\-\-fast\fP
+.PD 0
+.TP 
+\fB\-\-best\fP
+.PD
+이 옵션은 \fB\-0\fP 과 \fB\-9\fP의 별칭으로 각각 오해할 수 있습니다. LZMA 유틸리티의 하위 호환성을 목적으로 제공합니다.  이
+옵션 사용은 피하십시오.
+.TP 
+\fB\-\-block\-size=\fP\fI<크기>\fP
+\&\fB.xz\fP 형식으로 압축할 때, 입력 데이터를 \fI<크기>\fP 바이트 블록으로 입력 데이터를 쪼갭니다.  각각의 블록은
+다중\-스레드 방식으로 처리할 수 있고 임의 접근 압축 해제 가능성을 제한할 수 있게 개별적으로 압축 처리합니다.  이 옵션은 보통
+다중\-스레드 모드에서 기본 블록 크기를 지정할 때 사용하지만, 단일\-스레드 모드에서도 사용할 수 있습니다.
+.IP ""
+다중\-스레드 모드에서는 약 3배 용량의 \fI<크기>\fP 바이트만큼 각 스레드 별로 입출력 버퍼링용 공간을 할당합니다.  기본
+\fI<크기>\fP는 LZMA2 딕셔너리 크기 또는 1MiB 중 가장 큰 쪽의 세 배입니다.  보통 적절한 값으로 LZMA2
+딕셔너리 크기 또는 최소한 1MiB 용량의 2\(en4배입니다.  LZMA2 딕셔너리 크기보다 작은 \fI<크기>\fP는 램의
+소모적 사용 공간으로 할당하는데 LZMA2 딕셔너리 버퍼를 할당한 용량 크기 전체를 다 사용하지 않기 때문입니다.  다중\-스레드 모드에서
+블록 크기는 블록 헤더에 저장하며, 이 크기 정보는 다중\-스레드 압축 해제시 필요합니다.
+.IP ""
+단일\-스레드 모드에서는 기본적으로 블록 쪼개기를 하지 않습니다.  이 옵션을 설정한다고 해서 메모리 사용에 영향을 주지는 않습니다.
+블록 헤더에 크기 정보를 저장하지 않기 때문에 단일\-스레드 모드에서 만든 파일은 다중\-스레드 모드에서 만든 파일과 동일하지 않습니다.
+크기 정보의 누락은 또한 \fBxz\fP에서 다중\-스레드 모드로 압축 해제를 진행할 수 없음을 의미하기도 합니다.
+.TP 
+\fB\-\-block\-list=\fP\fI<항목>\fP
+\&\fB.xz\fP 형식으로 압축할 때, 압축하지 않은 데이터로 부터 일정 간격 이후에 새 블록 처리를 시작합니다.
+.IP ""
+\fI<항목>\fP은 쉼표로 구분한 목록으로 지정합니다.  각 항목은 콜론 (\fB:\fP)으로 구분한 0부터 9까지의 추가 필터
+체인 번호 값으로 이루어져 있으며, 압축하지 않은 데이터의 크기 값이 필요합니다.  항목을 생략하면(둘 이상의 쉼표 연속 표기) 이전
+항목의 크기와 필터를 활용하겠다는 함축 의미를 넣을 수 있습니다.
+.IP ""
+입력 파일이 \fI<항목>\fP 크기의 합보다 크면, 마지막 항목을 파일의 끝까지 반복합니다.  특별히 \fB0\fP 값을 마지막
+값으로 사용하여 파일 나머지 부분을 단일 블록으로 인코딩해야 한다는 의미를 나타낼 수도 있습니다.
+.IP ""
+\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션 조합으로
+각 블록별 별도 필터 체인을 지정할 수 있습니다.  이 옵션은 1\(en9번 필터 체인을 지정합니다. 필터 체인 0번은 필터 체인을
+지정하지 않았을 때와 동일한 기본 필터 체인으로 참조할 수 있습니다.  필터 체인 식별 번호는 비 ���축 크기 앞에 콜론(\fB:\fP)을 붙여
+사용할 수 있습니다. 예를 들면, \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP 옵션을
+지정했을 경우 다음 규칙대로 블록을 만듭니다:
+.RS
+.IP \(bu 3
+\fB\-\-filters1\fP 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+\fB\-\-filters3\fP 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을
+.IP \(bu 3
+\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을
+.IP \(bu 3
+기본 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+입력이 끝나기 전의 모든 블록에는 기본 필터 체인과 4MiB 입력을 적용합니다.
+.RE
+.IP ""
+인코더 블록 크기를 초과하는 크기 값을 지정하면(스레드 모드 기본값 또는 \fB\-\-block\-size=\fP\fI<크기>\fP
+옵션으로 지정한 값), 인코더는 \fI<크기>\fP 지정 용량 범위는 유지하면서 추가 블록을 만듭니다.  예를 들면
+\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP 옵션을 지정하고
+입력 파일을 80MiB 용량으로 전달하면, 각각 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, 1 MiB 용량을
+차지하는 블록 11개를 결과물로 내줍니다.
+.IP ""
+다중\-스레드 모드에서 블록 크기는 블록 헤더에 저장합니다.  단일\-스레드 모드에서는 저장하지 않기 때문에 인코딩 처리한 출력은
+다중\-스레드 모드의 출력 결과물과는 다릅니다.
+.TP 
+\fB\-\-flush\-timeout=\fP\fI<제한시간>\fP
+압축할 때, 이전 데이터를 소거하고 다음 입력을 블록 단위로 더 읽는데 \fI<제한시간>\fP 밀리초(양의 정수값)가 지났을
+경우, 대기중이던 모든 입력 데이터를 인코더에서 소거한 다음 출력 스트림에 전달합니다.  이런 동작은 네트워크로 스트리밍한 데이터를
+\fBxz\fP로 압축할 때 쓸만합니다.  \fI<제한시간>\fP 값을 적게 지정하면 적은 지연 시간에 데이터를 받아낼 수 있지만
+\fI<제한시간>\fP 값을 크게 하면 압축율을 높일 수 있습니다.
+.IP ""
+이 기능은 기본적으로 꺼져있습니다.  이 옵션을 한번 이상 지정하면, 마지막 옵션의 값대로 동작합니다.  특별히
+\fI<제한시간>\fP 값을 \fB0\fP으로 설정하면 이 설정을 완전히 끌 수 있습니다.
+.IP ""
+이 기능은 POSIX 시스템이 아닌 곳에서는 사용할 수 없습니다.
+.IP ""
+.\" FIXME
+\fB이 기능은 여전히 시험중입니다\fP.  현재로서는, \fBxz\fP 버퍼링 처리 방식 때문에 \fBxz\fP의 실시간 스트림 압축 해제 기능 활용은
+적절하지 않습니다.
+.TP 
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP
+압축 수행시 메모리 사용 한계를 지정합니다.  이 옵션을 여러번 지정하면 마지막 값을 취합니다.
+.IP ""
+압축 설정이 \fI<제한용량>\fP을 초과하면, \fBxz\fP는 설정 값의 하향 조정을 시도하여 한계 값을 더이상 넘치지 않게 하고
+자동 조절을 끝냈다는 알림을 표시합니다.  조정은 다음 순서대로 진행합니다. 스레드 수를 줄입니다. 다중\-스레드 모드에서 스레드 하나의
+할당 한계치가 \fI<제한용량>\fP을 넘으면 단일\-스레드 모드로 전환합니다. 그 다음 마지막으로 LZMA2 딕셔너리 크기를
+줄입니다.
+.IP ""
+\fB\-\-format=raw\fP 또는 \fB\-\-no\-adjust\fP 미지정 상황에서 압축할 때, 압축 데이터 출력에 영향을 주지 않고 스레드
+처리 수만 줄일 수 있습니다.
+.IP ""
+\fI<제한용량>\fP 값이 아래 설명한 조건에 맞지 않으면, 오류가 나타나고 \fBxz\fP 명령은 종료 상태 1번을 반환하며
+빠져나갑니다.
+.IP ""
+\fI<제한용량>\fP 값은 여러 방식으로 지정할 수 있습니다:
+.RS
+.IP \(bu 3
+\fI<제한용량>\fP 값은 바이트 용량 절대값입니다.  정수 값을 사용하되 \fBMiB\fP와 같은 접미사를 사용하는게 좋습니다.
+예: \fB\-\-memlimit\-compress=80MiB\fP
+.IP \(bu 3
+\fI<제한용량>\fP 값은 총 물리 메모리(RAM) 용량의 백분율로 지정할 수도 있습니다.  다른 컴퓨터끼리 공유하는 셸
+초기화 스크립트의 \fBXZ_DEFAULTS\fP 환경 변수에 값을 설정할 때 특히 쓸만합니다.  이런 방식으로 설정하면 시스템의 메모리 설치
+용량에 따라 자동으로 늘어납니다.  예: \fB\-\-memlimit\-compress=70%\fP
+.IP \(bu 3
+\fI<제한용량>\fP 값은 \fB0\fP 기본값으로 설정하여 초기화할 수 있습니다.  현재로서는 \fI<제한용량>\fP
+값이 \fImax\fP(최대) (메모리 사용 한계 없음) 인 상태와 동일합니다.
+.RE
+.IP ""
+\fBxz\fP 32비트 버전에서는 몇가지 특별한 경우가 있습니다. \fI<제한용량>\fP 값이 \fB4020MiB\fP를 넘으면
+\fI<제한용량>\fP을 \fB4020MiB\fP로 고정합니다. MIPS32에서는 \fB2000MiB\fP로 대신 고정합니다.
+(\fB0\fP과 \fBmax\fP는 이 경우에 해당하지 않습니다.  압축 해제시 비슷한 기능은 없습니다.)  이 경우 32비트 실행 파일이
+4GiB(MIPS32의 경우 2GiB) 주소 영역에 접근할 때 매우 용이하며, 다른 경우에는 원하는대로 문제를 일으키지 않습니다.
+.IP ""
+\fB메모리 활용\fP 섹션도 참고하십시오.
+.TP 
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP
+압축 해제시 메모리 사용 한계 용량을 설정합니다.  \fB\-\-list\fP 모드에도 영향을 줍니다.  \fI<제한용량>\fP을 넘기지
+않고서는 동작이 진행이 안될 경우, \fBxz\fP 에서는 오류를 나타내고 파일 압축 해제를 실패로
+간주합니다. \fI<제한용량>\fP을 지정하는 가능한 방법에 대해서는
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오.
+.TP 
+\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP
+다중\-스레드 모드 압축 해제시 메모리 사용 한계 용량을 설정합니다.  스레드 수에 영향을 줄 수도 있습니다.  \fBxz\fP에서 파일 압축
+해제를 거부하게 하진 않습니다.  \fI<제한용량>\fP 수치가 다중\-스레드로 처리하기에 너무 낮다면,
+\fI<제한용량>\fP 값을 무시하고 \fBxz\fP 동작을 단일\-스레드 모드로 계속 진행합니다.  참고로
+\fB\-\-memlimit\-decompress\fP 옵션도 사용하면, 단일\-스레드 모드와 다중\-스레드 모드 두 경우에 모두 적용하기에,
+다중\-스레드 모드에 적용할 \fI<제한용량>\fP 값은 \fB\-\-memlimit\-decompress\fP에 설정하는 제한 값보다 더
+크면 안됩니다.
+.IP ""
+다른 메모리 사용 용량 제한 옵션과는 달리, \fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 옵션은
+시스템별 기본 \fI<제한용량>\fP 값을 지닙니다.  현재 설정 값은 \fBxz \-\-info\-memory\fP 명령으로 확인해볼 수
+있습니다.
+.IP ""
+이 옵션과 기본 값은 한계 값을 주지 않으면 스레드 기반 압축 해제 프로그램이 일부 입력 파일에 대해 정신나간 수준의 메모리 용량을
+할당해서 동작이 끝나버릴 수 있습니다.  기본 \fI<제한용량>\fP이 시스템의 사양에 비해 낮다면,
+\fI<제한용량>\fP 값을 자유롭게 올리시되, \fBxz\fP 에서 적은 스레드 수에도 메모리 공간 할당을 시도하는 만큼, 입력
+파일에 적절한 수준으로 가용 RAM 용량을 넘는 큰 값을 설정하지 마십시오. 메모리나 스와핑 영역 공간이 줄어들면 압축해제 성능을
+개선하지 못합니다.
+.IP ""
+\fI<제한용량>\fP 값을 지정하는 가능한 방법을 보려면
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오.  \fI<제한용량>\fP 값을
+\fB0\fP으로 설정하면 \fI<제한용량>\fP 값이 시스템 지정 기본값으로 바뀝니다.
+.TP 
+\fB\-M\fP \fI<제한용량>\fP, \fB\-\-memlimit=\fP\fI<제한용량>\fP, \fB\-\-memory=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 지정과 동일합니다.
+.TP 
+\fB\-\-no\-adjust\fP
+압축 출력 결과에 영향을 주는 설정을 조정하지 않고는 메모리 사용 용량 제한 조건이 맞지 않으면 오류를 표시하고 빠져나갑니다.  이
+옵션은 \fBxz\fP가 다중\-스레드 모드에서 단일\-스레드 모드로 전환하고 LZMA2 딕셔너리 크기를 줄이는 동작을 막아줍니다.  심지어 이
+옵션을 사용하면 메모리 사용 한계를 만족하도록 스레드 수를 줄여 압축 결과물 출력에 영향이 가지 않게 합니다.
+.IP ""
+원시 스트림(\fB\-\-format=raw\fP)을 만들 떄 자동 조정은 항상 꺼집니다.
+.TP 
+\fB\-T\fP \fI<스레드수>\fP, \fB\-\-threads=\fP\fI<스레드수>\fP
+활용할 작업 스레드 수를 지정합니다.  \fI<스레드수>\fP 값을 \fB0\fP 값으로 설정하면, \fBxz\fP는 시스템에서 지원하는
+최대 프로세서 스레드 수를 모두 확보합니다. 실제 스레드 수는 입력 파일이 주어진 설정대로 스레드 처리를 할 만큼 그렇게 크지 않을
+경우, 내지는 더 많은 스레드를 사용했을 때 메모리 사용량 한계를 초과할 경우 \fI<스레드수>\fP 보다 적을 수 있습니다.
+.IP ""
+단일\-스레드와 다중\-스레드 압축 프로그램은 다른 출력 결과물을 냅니다.  단일\-스레드 압축 프로그램은 작은 파일 크기 결과물을 내놓지만,
+다중\-스레드 압축 프로그램의 경우 다중\-스레드 압축 프로그램에서 내놓은 결과물은 다중\-스레드로만 압축을 해제할 수 있습니다.
+\fI<스레드수>\fP를 \fB1\fP로 설정하면 단일\-스레드 모드를 사용합니다.  \fI<스레드수>\fP를 \fB0\fP과 다른
+값으로 설정하면, 시스템에서 실제로 하드웨어 스레드가 1개만 지원한다 하더라도, 다중\-스레드 압축 프로그램을 사용합니다.  (\fBxz\fP
+5.2.x에서는 이 경우 단일\-스레드 모드를 활용합니다.)
+.IP ""
+단일\-스레드로 다중\-스레드 모드를 사용하려면, \fI<스레드수>\fP를 \fB+1\fP로 설정하십시오. \fB+\fP 접두사는 \fB1\fP
+이외의 값에는 영향을 주지 않습니다.  메모리 사용량 한계 설정은 \fBxz\fP을 \fB\-\-no\-adjust\fP 옵션을 쓰기 전까지는
+단일\-스레드로 전환하게 합니다.  \fB+\fP 접두사 지원은 \fBxz\fP 5.4.0에 추가했습니다.
+.IP ""
+자동 스레드 수를 요청했고 메모리 사용 한계를 지정하지 않았다면, 시스템에 맞게끔 가능한 스레드 수를 제한하는 기본 소프트 제한 값을
+사용합니다. 스레드 수가 한개가 되면 무시하는 이런 개념이 소프트 제한이기에, \fBxz\fP로 하여금 압축 동작 및 압축 해제 동작 수행시
+멈추지 않습니다.  이 가본 소프트 제한 값은 \fBxz\fP 실행 도중 다중\-스레드 모드에서 단일\-스레드 모드로 바뀌게 하지는 않습니다.
+활성 제한 값은 \fBxz \-\-info\-memory\fP 명령으로 볼 수 있습니다.
+.IP ""
+현재 스레딩 처리 방식은 입력을 블록 단위로 쪼개고 각각의 블록을 독립적으로 압축하는 동작을 취합니다.  기본 블록 크기는 압축 수준에
+따라 다르며 \fB\-\-block\-size=\fP\fI<크기>\fP 옵션으로 재지정할 수 있습니다.
+.IP ""
+스레드 압축 해제 방식은 여러 블록이 블록 헤더에 넣은 크기 정보와 함께 들어간 파일에만 동작합니다.  다중\-스레드 모드에서 압축한
+충분히 큰 모든 파일은 이 조건에 만족하지만, 단일\-스레드 모드에서 압축한 파일은
+\fB\-\-block\-size=\fP\fI<크기>\fP 옵션을 지정하더라도 조건에 만족하지 않습니다.
+.IP ""
+\fI스레드\fP 기본 값은 \fB0\fP입니다.  \fBxz\fP 5.4.x 이전의 기본값은 \fB1\fP입니다.
+.
+.SS "개별 압축 필터 체인 설정"
+개별 필터 체인은 사전 설정에 엮인 설정에 의존하는 대신 압축 설정을 세부적으로 하나하나 설정할 수 있게 합니다.  개별 필터 체인을
+지정하면, 명령행에 앞서 지정한 사전 설정 옵션(\fB\-0\fP \&...\& \fB\-9\fP 과 \fB\-\-extreme\fP)은 무시합니다.  사전
+설정 옵션을 하나 이상의 필터 체인 옵션 다음에 지정하면, 새 사전 설정을 취하며, 앞서 지정한 개별 필터 체인 옵션은 무시합니다.
+.PP
+필터 체인은 명령행 파이핑에 비교할 수 있습니다.  압축할 때, 압축하지 않은 입력을 첫번째 필터로 놓고, 출력 대상(이 있으면)을 다음
+필터로 지정합니다.  최종 필터의 출력은 압축 파일로 기옥합니다.  체인의 최대 필터 수는 4이지만, 필터 체인상 필터 갯수는 보통
+1~2개입니다.
+.PP
+수많은 필터가 필터 체인 상에서 제약점을 가지고 있습니다. 일부 필터는 체인의 마지막 필터로만 동작하며, 일부 다른 필터는 마지막이 아닌
+필터로, 어떤 동작은 체인의 어떤 위치에든 둡니다.  필터에 따라, 이 제한은 필터 설계를 따르거나 보안 문제를 막기 위해 존재하기도
+합니다.
+.PP
+개별 필터 체인은 두가지 방식으로 지정할 수 있습니다.  \fB\-\-filters=\fP\fI<필터>\fP와
+\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션으로
+liblzma 필터 문자열 문법에 따라 한가지 옵션을 필터 체인 전체를 지정할 수 있습니다.  대신, 하나 이상의 개별 필터 옵션을
+원하는 필터 체인 순서대로 지정할 수도 있습니다.  이 말인 즉슨, 개별 필터 옵션의 순서가 중요하단 뜻입니다! 원시 스트림을 디코딩할
+때(\fB\-\-format=raw\fP), 압축했을 때 지정했던 필터와 같은 순서로 필터 체인을 지정해야 합니다.  전체 체인
+옵션(\fB\-\-filters=\fP\fI<필터>\fP) 보다 우선 지정한 개별 필터 또는 사전 설정 옵션은 까먹을 수도 있습니다.
+전체 체인 옵션 다음에 개별 필터를 지정할 경우 필터 체인의 동작을 무효로 합니다.
+.PP
+필터는 쉼표로 구분하는 필터별 \fI<옵션>\fP이 있습니다.  \fI<옵션>\fP에 추가로 입력한 쉼표는
+무시합니다.  모든 옵션 값에는 기본값이 있어, 값을 바꾸려면 지정해야합니다.
+.PP
+전체 필터 체인과 \fI<옵션>\fP을 보려면 \fBxz \-vv\fP (\fB\-\-verbose\fP 두 번)명령을 사용하십시오.  이
+명령은 사전 설정이 사용하는 필터 체인 옵션도 볼 수 있습니다.
+.TP 
+\fB\-\-filters=\fP\fI<필터>\fP
+전체 필터 체인 또는 사전 설정을 단일 옵션으로 지정합니다.  각 필터는 공백 문자 또는 대시 문자 두번 입력(\fB\-\-\fP)으로
+구분합니다.  셸 명령행에서 \fI필터\fP는 따옴표로 감싸서 단일 옵션으로 해석하도록 해야 합니다.  \fI옵션\fP을 표기하려면 \fB:\fP 또는
+\fB=\fP을 활용하십시오.  사전 설정 앞에 \fB\-\fP를 붙일 수 있고 0개 또는 하나 이상의 플래그를 붙일 수 있습니다.  유일하게
+지원하는 플래그는 \fB\-\-extreme\fP과 동일한 \fBe\fP입니다.
+.TP 
+\fB\-\-filters1\fP=\fI<필터>\fP ... \fB\-\-filters9\fP=\fI<필터>\fP
+\fB\-\-block\-list\fP와 사용할 수 있는 추가 필터 체인을 최대 9개까지 지정합니다.
+.IP ""
+예를 들어 텍스트 파일과 실행 파일의 아카이브를 압축할 때 실행 부분에 BCJ 필터 체인을 사용하고 텍스트 부분은 LZMA2 필터를
+사용할 수 있습니다.
+.TP 
+\fB\-\-filters\-help\fP
+\fB\-\-filters\fP와 \fB\-\-filters1=\fP\fI<필터>\fP \&...\&
+\fB\-\-filters9=\fP\fI<필터>\fP 옵션의 사전 설정 필터와 개별 설정 필터 체인을 지정하는 방법을 설명하는 도움말
+메시지를 출력하고 완전히 빠져나갑니다.
+.TP 
+\fB\-\-lzma1\fP[\fB=\fP\fI<옵션>\fP]
+.PD 0
+.TP 
+\fB\-\-lzma2\fP[\fB=\fP\fI<옵션>\fP]
+.PD
+LZMA1 또는 LZMA2 필터를 필터 체인에 추가합니다.  이 필터는 필터 체인의 마지막 요소로만 사용할 수 있습니다.
+.IP ""
+LZMA1은 고전 필터로, LZMA1만 지원하는 고전 \fB.lzma\fP 파일 형식에서만 지원합니다.  LZMA2는 LZMA1의 업데이트
+버전으로 LZMA1의 실질적 문제를 해결했습니다.  \fB.xz\fP 형식은 LZMA2 필터를 사용하며 LZMA1 필터는 전적으로 지원하지
+않습니다.  압축 속도와 압축율은 LZMA1과 LZMA2가 실질적으로 동일합니다.
+.IP ""
+LZMA1과 LZMA2는 동일한 \fI<옵션>\fP 집합을 공유합니다:
+.RS
+.TP 
+\fBpreset=\fP\fI<사전설정>\fP
+LZMA1 또는 LZMA2의 모든 \fI<옵션>\fP을 \fI<사전설정>\fP으로
+초기화합니다. \fI<사전설정>\fP 값은 정수 값으로 이루어져 있으며, 사전 설정에 변형을 줄 떄 단일 문자가 따라올 수도
+있습니다.  정수 값은 \fB0\fP에서 \fB9\fP 까지이며, 명령행 옵션에서 \fB\-0\fP \&...\& \fB\-9\fP로 대응합니다.  변형 옵션으로
+지원하는 문자는 현재 \fBe\fP 뿐이며, \fB\-\-extreme\fP에 대응합니다.  \fI<사전설정>\fP 값을 지정하지 않으면,
+LZMA1 또는 LZMA2 기본값을 사전 설정 \fB6\fP에서 가져온 \fI<옵션>\fP으로 취합니다.
+.TP 
+\fBdict=\fP\fI<크기>\fP
+딕셔너리(기록 버퍼)  \fI<크기>\fP는 최근 처리한 비압축 데이터를 바이트 단위로 메모리에 얼마나 유지하는지 나타냅니다.
+알고리즘은 비압축 데이터상 바이트 시퀀스(일치 항목) 반복 탐색을 시도하며, 해당 부분을 딕셔너리의 현재 참조로 치환합니다. 딕셔너리가
+크면 일치하는 항목을 찾을 기회가 더 많아집니다.  따라서, 딕셔너리 \fI<크기>\fP를 더욱 크게 설정하면 압축율을 증가할
+수는 있지만, 압축하지 않은 파일보다 딕셔너리가 크면 메모리 낭비율이 올라갑니다.
+.IP ""
+보통 딕셔너리 \fI<크기>\fP는 64KiB 에서 64MiB 정도 됩니다. 최소 4KiB 입니다. 압축시 최대 용량은 현재
+1.5GiB(1536MiB)로 나타납니다.  압축 해제 프로그램에도 4GiB 미만으로 딕셔너리 크기를 이미 지원하며 4GiB 라는 수치는
+LZMA1과 LZMA2 스트림 형식의 최대값입니다.
+.IP ""
+딕셔너리 \fI<크기>\fP와 검색기(\fImf\fP)는 LZMA1 또는 LZMA 인코더의 메모리 사용량을 함께 결정합니다.
+동일한(또는 더 큰) 딕셔너리 \fI<크기>\fP가 데이터를 압축했을 때만큼 압축 해제할 떄 필요하기 때문에, 디코더의 메모리
+사용량은 압축할 때의 딕셔너리 크기로 결정합니다.  \fB.xz\fP 헤더에는 딕셔너리 \fI<크기>\fP를 2^\fIn\fP 또는
+2^\fIn\fP + 2^(\fIn\fP\-1) 으로 저장하기에, 이 \fI<크기>\fP 값을 압축할 때 선호하는 편입니다.  다른
+\fI<크기>\fP 값은 \fB.xz\fP 헤더에 저장할 때 반올림합니다.
+.TP 
+\fBlc=\fP\fIlc\fP
+리터럴 컨텍스트 비트 수를 지정합니다.  최소 값은 0이고 최대 값은 4입니다. 기본 값은 3입니다.  추가로, \fIlc\fP 값과
+\fIlp\fP 값의 합은 4를 넘으면 안됩니다.
+.IP ""
+조건이 일치하지 않아 인코딩할 수 없는 모든 바이트는 리터럴로 인코딩합니다.  이 말인 즉슨, 간단히 8비트 바이트로서의 리터럴을 한번에
+하나씩 인코딩합니다.
+.IP ""
+리터럴 코딩을 할 때 이전 비압축 바이트와 다음 바이트와의 관련성을 가진 가장 많은 \fIlc\fP 비트 수를 가정합니다.  예를 들면, 보통
+영문 문장의 경우 대문자 다음에 종종 소문자가 오고, 소문자 다음에 다른 소문자가 따라옵니다. US\-ASCII 문자 세트에서는 가장 긴
+비트 3개는 대문자에 대해 010, 소문자에 대해 011입니다.  \fIlc\fP 값이 최소한 3이면, 리터럴 코딩시 비압축 데이터에 대해
+이런 속성의 장점을 취할 수 있습니다.
+.IP ""
+(어쨌거나) 기본값 (3)은 보통 적절합니다.  최대 압축을 원한다면 \fBlc=4\fP 값을 시험해보십시오.  때로는 약간 도움이 되기도
+하겠지만, 오히려 결��가 안좋을 수도 있습니다.  결과가 엄한 방향으로 간다면, \fBlc=2\fP 값도 시험해보십시오.
+.TP 
+\fBlp=\fP\fIlp\fP
+리터럴 위치 비트 수를 지정하빈다.  최소 값은 0이고 최대 값은 4입니다. 기본 값은 0입니다.
+.IP ""
+\fIlp\fP 값은 리터럴 인코딩 진행시 비압축 데이터 정렬 방식 고려에 영향을 줍니다.  정렬 방식에 대한 자세한 정보는 하단 \fIpb\fP를
+참고하십시오.
+.TP 
+\fBpb=\fP\fIpb\fP
+위치 비트 수를 지정합니다.  최소 값은 0이며 최대 값은 4입니다.  기본값은 2입니다.
+.IP ""
+\fIpb\fP 값은 보통 압축하지 않은 데이터에 어떤 정렬 방식을 고려하느냐에 영향을 줍니다.  기본적으로 4바이트
+정렬(2^\fIpb\fP=2^2=4)을 의미하는데, 이보다 더 나은 추측 값이 없어서 종종 최적의 선택으로 간주합니다.
+.IP ""
+정렬 상태를 알지 못할 경우, \fIpb\fP 설정 값이 파일 크기를 조금 줄일 수 있습니다.  예를 들면, 텍스트 파일이 단일 바이트 단위로
+정돈된 상태(US\-ASCII, ISO\-8859\-*, UTF\-8)라면, \fBpb=0\fP 설정 값으로 압축율을 조금 개선할 수 있습니다.
+UTF\-16 텍스트의 경우, \fBpb=1\fP 설정 값이 좋은 선택입니다.  정렬 바이트가 3 바이트 같은 홀수 바이트일 경우,
+\fBpb=0\fP 설정 값이 최적의 선택일지도 모릅니다.
+.IP ""
+가정 정렬을 \fIpb\fP 값과 \fIlp\fP 값으로 조정하긴 하지만, LZMA1과 LZMA2는 여전히 16바이트 정렬 방식으로 선호합니다.
+LZMA1 또는 LZMA2로 종종 압축하는 파일 형식이라고 하면 고려해볼만 합니다.
+.TP 
+\fBmf=\fP\fImf\fP
+일치 검색기는 인코더 속도, 메모리 사용량, 압축율에 주된 영향을 줍니다.  보통 해시 체인 검색기는 이진 트리 검색기보다 빠르긴
+합니다.  기본 값은 \fI<사전설정>\fP에 따라 다릅니다. 0은 \fBhc3\fP을, 1\(en3은 \fBhc4\fP를, 나머지는
+\fBbt4\fP를 활용합니다.
+.IP ""
+다음 검색 필터를 지원합니다.  메모리 사용 공식은 \fIdict\fP 값이 2의 승수일 경우 실제에 가까운 근사치입니다.
+.RS
+.TP 
+\fBhc3\fP
+2바이트, 3바이트 해싱 체인
+.br
+\fInice\fP 최소값: 3
+.br
+메모리 사용:
+.br
+\fIdict\fP * 7.5 (조건: \fIdict\fP <= 16 MiB);
+.br
+\fIdict\fP * 5.5 + 64 MiB (조건: \fIdict\fP > 16 MiB)
+.TP 
+\fBhc4\fP
+2바이트, 3바이트, 4바이트 해싱 체인
+.br
+\fInice\fP 최소값: 4
+.br
+메모리 사용:
+.br
+\fIdict\fP * 7.5 (조건: \fIdict\fP <= 32 MiB);
+.br
+\fIdict\fP * 6.5 (조건: \fIdict\fP > 32 MiB)
+.TP 
+\fBbt2\fP
+2바이트 해싱 이진 트리
+.br
+\fInice\fP 최소값: 2
+.br
+메모리 사용: \fIdict\fP * 9.5
+.TP 
+\fBbt3\fP
+2바이트, 3바이트 해싱 이진트리
+.br
+\fInice\fP 최소값: 3
+.br
+메모리 사용:
+.br
+\fIdict\fP * 11.5 (조건: \fIdict\fP <= 16 MiB);
+.br
+\fIdict\fP * 9.5 + 64 MiB (조건: \fIdict\fP > 16 MiB)
+.TP 
+\fBbt4\fP
+2바이트, 3바이트, 4바이트 해싱 이진 트리
+.br
+\fInice\fP 최소값: 4
+.br
+메모리 사용:
+.br
+\fIdict\fP * 11.5 (조건: \fIdict\fP <= 32 MiB);
+.br
+\fIdict\fP * 10.5 (조건: \fIdict\fP > 32 MiB)
+.RE
+.TP 
+\fBmode=\fP\fI<모드>\fP
+압축 \fI<모드>\fP 값은 일치 검색기에서 생산하는 데이터 분석 방식을 지정합니다.  지원하는 \fI<모드>\fP는
+\fBfast\fP와 \fBnormal\fP 입니다. 기본값은 \fI<사전설정>\fP값 0\(en3에 대해 \fBfast\fP,
+\fI<사전설정>\fP값 4\(en9에 대해 \fBnormal\fP입니다.
+.IP ""
+보통 \fBfast\fP는 해시 체인 검색기에서 사용하며 \fBnormal\fP은 이진 트리 검색기에서 사용합니다.  이 동작은 또한
+\fI<사전설정>\fP 값이 할 일이기도 합니다.
+.TP 
+\fBnice=\fP\fInice\fP
+일치하는 nice 길이를 지정합니다.  최소한 \fInice\fP 바이트 정도 일치하면, 알고리즘이 가능한 최선의 부분을 찾는 동작을
+멈춥니다.
+.IP ""
+\fInice\fP 값은 2\(en273 바이트입니다.  값이 클 수록 속도 면에서는 손해를 보겠지만 압축율은 더욱 올라갑니다.  기본 값은
+\fI<사전설정>\fP값에 따라 다릅니다.
+.TP 
+\fBdepth=\fP\fI<깊이>\fP
+일치 검색기에서의 최대 검색 깊이를 지정합니다.  기본값은 특별한 값 0으로 지정하며, 이 값으로 압축 프로그램이 \fImf\fP 와
+\fInice\fP간 적절한 \fI<깊이>\fP 값을 결정합니다.
+.IP ""
+적절한 해시 체인 \fI<깊이>\fP 값은 이진 트리에서 4\(en100 그리고 16\(en1000 입니다. 상당히 큰 값을
+\fI<깊이>\fP 값으로 사용하면 일부 파일에 대해 인코더가 매우 느리게 동작할 수가 있습니다.  압축 시간이 너무 오래걸려서
+동작을 중간에 끊을 준비가 되지 않은 이상 \fI<깊이>\fP 설정 값은 1000을 넘지 않게하십시오.
+.RE
+.IP ""
+원시 스트림(\fB\-\-format=raw\fP)을 디코딩할 때, LZMA2는 딕셔너리 \fI<크기>\fP만 필요합니다.  LZMA1는
+\fIlc\fP, \fIlp\fP, \fIpb\fP 값이 모두 필요합니다.
+.TP 
+\fB\-\-x86\fP[\fB=\fP\fI<옵션>\fP]
+.PD 0
+.TP 
+\fB\-\-arm\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-armthumb\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-arm64\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-powerpc\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-ia64\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-sparc\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-riscv\fP[\fB=\fP\fI<옵션>\fP]
+.PD
+브랜치/호출/점프(BCJ) 필터를 필터 체인에 추가합니다.  이 필터는 필터 체인의 비종결 필터로만 사용할 수 있습니다.
+.IP ""
+BCJ 필터는 머신 코드의 상대 주소를 절대 주소로 변환합니다.  데이터 크기를 바꾸지는 않지만 LZMA2에서 \fB.xz\fP 파일을
+0\(en15% 정도 줄여주게 하는 중복성이 늘어납니다.  BCJ 필터는 언제든 뒤집을 수 있어, 데이터에 적절하지 않은 BCJ 필터
+형식을 활용하면, 그냥 가만히 두면 압축율이 약간 떨어지게 한다 하더라도, 데이터를 잃을 수가 있습니다.  BCJ 필터는 굉장히 빠르며
+메모리 공간을 적게 활용합니다.
+.IP ""
+이 BCJ 필터에는 압축율 관련 몇가지 문제가 있습니다:
+.RS
+.IP \(bu 3
+실행 코드가 들어있는 몇가지 파일 형식(예: 목적 파일, 정적 라이브러리, 리눅스 커널 모듈)의 경우 필터 값으로 채운 명령 주소가
+있습니다.  여기 BCJ 필터의 경우 파일의 압축율을 떨어뜨리는 주소 변환을 수행합니다.
+.IP \(bu 3
+BCJ 필터를 아카이브에 적용하면, BCJ 필터를 사용하지 않았을 때보다 압축율이 떨어질 수가 있습니다.  예를 들면, 유사하거나 동일한
+실행 파일 여럿이 있으면 필터를 사용하여 파일을 덜 비슷하게 만들어 압축율이 떨어지게 합니다.  동일한 아카이브 파일에서 비 실행 파일의
+내용에 대해서도 비슷한 일이 벌어질 수 있습니다.  실제로 하나는 BCJ 필터를 걸고 하나는 제외하여 각 경우에 대해 어떤 경우가 결과가
+우수한 지 살펴보겠습니다.
+.RE
+.IP ""
+다른 명령 세트는 다른 정렬 상태에 놓여있습니다.  실행 파일은 필터가 제대로 동작하게 하려면 입력 데이터에 있는 이 값의 배수로
+정돈해야합니다.
+.RS
+.RS
+.PP
+.TS
+tab(;);
+l n l
+l n l.
+필터;정렬;참고
+x86;1;32\-bit 또는 64\-bit x86
+ARM;4;
+ARM\-Thumb;2;
+ARM64;4;4096 바이트 정렬이 가장 좋습니다
+PowerPC;4;빅엔디안 전용
+IA\-64;16;Itanium
+SPARC;4;
+RISC\-V;2;
+.TE
+.RE
+.RE
+.IP ""
+BCJ 필터를 사용한 데이터는 LZMA2로 보통 압축하기 때문에 LZMA2 옵션을 선택한 BCJ 필터의 정렬기준에 맞추도록 설정하면
+압축율을 좀 더 개선할 수 있습니다.  예를 들면:
+.RS
+.IP \(bu 3
+IA\-64 필터는 16\-바이트 정렬 방식으로 동작하기에 LZMA2 필터에 \fBpb=4,lp=4,lc=0\fP 옵션(2^4=16)을 주는게
+좋습니다.
+.IP \(bu 3
+RISC\-V 코드에는 16\-비트 압축 명령(C 확장) 적재 여부에 따라 2\-바이트 또는 4\-바이트 정렬 방식을 채택합니다. 16\-비트
+명령을 사용하면, \fBpb=2,lp=1,lc=3\fP 또는 \fBpb=1,lp=1,lc=3\fP 옵션 값 사용이 바람직합니다. 16\-비트 명령이
+없다면, \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다.  "RVC"가 "Flags"행에 나타나는지 확인할 때
+\fBreadelf \-h\fP 명령을 사용할 수 있습니다.
+.IP \(bu 3
+ARM64는 항상 4\-바이트 정렬 방식을 택하기에 \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다.
+.IP \(bu 3
+x86 필터는 예외입니다.  x86 실행 파일을 압축할 경우에는 보통 LZMA2 기본 옵션 값(\fBpb=2,lp=0,lc=3\fP)을 그대로
+사용하는게 좋습니다.
+.RE
+.IP ""
+모든 BCJ 필터는 동일한 \fI옵션\fP을 지원합니다:
+.RS
+.TP 
+\fBstart=\fP\fI<오프셋>\fP
+상대 주소와 절대 주소를 변환할 때 사용할 시작 \fI<오프셋>\fP을 지정합니다.  \fI<오프셋>\fP에는 필터
+정렬 배수여야 합니다(상단 테이블 참조).  기본값은 0입니다.  실제로 기본값이 낫습니다. 개별 \fI<오프셋>\fP 지정
+값은 거의 쓸모가 없습니다.
+.RE
+.TP 
+\fB\-\-delta\fP[\fB=\fP\fI<옵션>\fP]
+필터 체인에 델타 필터를 추가합니다.  델타 필터는 필터 체인에서 마지막에 지정하지 않은 필터로만 사용할 수 있습니다.
+.IP ""
+현재로서는 바이트 단위 단순 델타계산 결과만 보여줍니다.  예를 들면, 압축하지 않은 비트맵 그림 또는 압축하지 않은 PCM 오디오를
+압축할 때 쓸만합니다.  그러나 특별한 목적으로 활용하는 알고리즘은 델타 + LZMA2 보다 더 나은 결과를 가져다 주기도 합니다.
+이는 특히 오디오의 경우 맞는 이야기인데, \fBflac\fP(1)의 경우 더 빠르고 우수한 압축율을 보여줍니다.
+.IP ""
+지원 \fI옵션\fP:
+.RS
+.TP 
+\fBdist=\fP\fI<차이>\fP
+바이트 단위 델터 계산 \fI<차이>\fP를 지정합니다.  \fI<차이>\fP값은 1\(en256 이어야합니다.  기본
+값은 1입니다.
+.IP ""
+예를 들어, \fBdist=2\fP 옵션과 A1 B1 A2 B3 A3 B5 A4 B7 입력 값을 주면, 출력 값은 A1 B1 01 02 01
+02 01 02 입니다.
+.RE
+.
+.SS "기타 옵션"
+.TP 
+\fB\-q\fP, \fB\-\-quiet\fP
+경고 및 알림을 끕니다.  두 번 지정하면 오류 메시지 표시도 끕니다.  이 옵션은 종료 상태에 영향을 주지 않습니다.  경고 표시를
+끄더라도, 종료 상태에서는 여전히 경고가 나타났음을 알려줍니다.
+.TP 
+\fB\-v\fP, \fB\-\-verbose\fP
+출력 내용이 많아집니다.  표준 오류를 터미널에 연결했다면 \fBxz\fP는 진행 표시를 나타냅니다.  \fB\-\-verbose\fP를 두번 지정하면
+더 많은 내용을 표시합니다.
+.IP ""
+진행 표시에서는 다음 정보를 나타냅니다:
+.RS
+.IP \(bu 3
+입력 파일의 크기를 알고 있을 경우 완료 백분율.  파이프 처리시에는 백분율을 나타낼 수 없습니다.
+.IP \(bu 3
+산출 압축 데이터 용량 (압축) 또는 소모 공간 용량 (압축 해제).
+.IP \(bu 3
+비압축 데이터 소모 용량 (압축) 또는 산출 용량 (압축 해제).
+.IP \(bu 3
+압축 데이터 산출 용량을 비압축 데이터 처리 용량으로 나누어 계산한 압축율.
+.IP \(bu 3
+압축 또는 압축 해제 속도.  초당 비압축 데이터 소모량(압축) 또는 산출 용량(압축 해제)를 측정한 값입니다.  \fBxz\fP에서 파일
+처리를 시작한 몇 초 후 나타납니다.
+.IP \(bu 3
+경과 시간 형식은 M:SS 또는 H:MM:SS 입니다.
+.IP \(bu 3
+추산 여분 시간은 \fBxz\fP가 파일을 처리하기 시작한 이후 입력 파일의 크기를 알고 몇 초가 지난 후에야 보여줍니다.  시간은 콜론
+문자를 사용하지 않고 덜 자세한 형식으로, 예를 들면, 2분 30초 와 같은 형식으로 보여줍니다.
+.RE
+.IP ""
+표준 오류가 터미널이 아니라면 \fB\-\-verbose\fP는 \fBxz\fP에서 파일 이름, 압축 크기, 압축 해제 용량, 압축율, 그리고
+가능하다면 파일을 압축 또는 압축 해제한 후 표준 오류로 속도와 걸린 시간을 나타내도록 합니다.  속도와 걸린 시간 정보는 동작을
+처리하는데 최소한 몇초 정도 소요했을 경우에만 들어갑니다.  동작이 끝나지 않았다면, 이를테면 사용자의 중단 요청이 있었을 경우 입력
+파일의 크기를 알고 있을 때 압축 백분율 정보도 들어갑니다.
+.TP 
+\fB\-Q\fP, \fB\-\-no\-warn\fP
+경고로 알릴 만한 상황을 만났다 하더라도 종료 상태 2번을 설정하지 않습니다.  이 옵션은 출력 수준에 영향을 주지 않기 때문에,
+\fB\-\-quiet\fP 옵션과 \fB\-\-no\-warn\fP 옵션을 경고 표시를 막고 종료 상태를 바꾸지 않을 목적으로 사용합니다.
+.TP 
+\fB\-\-robot\fP
+머신에서 해석할 형식으로 메시지를 나타냅니다.  liblzma 대신 \fBxz\fP를 활용하려는 다양상 스크립트로서의 프론트엔드를 쉽게
+작성하도록 하기 위함입니다.  이 옵션을 지정한 출력은 \fBxz\fP 릴리스가 어떻게 되든 안정 버전이란 의미입니다.  자세한 내용은
+\fB로봇 모드\fP 섹션을 참고하십시오.
+.TP 
+\fB\-\-info\-memory\fP
+압축 및 압축 해제시 물리 메모리 용량 (RAM), \fBxz\fP에서 파악하는 프로세서 스레드 갯수, 메모리 사용량 한계를 파악하기 쉬운
+형식으로 나타내고 무사히 나갑니다.
+.TP 
+\fB\-h\fP, \fB\-\-help\fP
+보통 사용하는 옵션을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다.
+.TP 
+\fB\-H\fP, \fB\-\-long\-help\fP
+\fBxz\fP의 모든 기능을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다
+.TP 
+\fB\-V\fP, \fB\-\-version\fP
+\fBxz\fP와 liblzma 버전 번호를 가독 형식으로 출력합니다.  기계 해석 가능 형식을 가져오려면 \fB\-\-version\fP 앞에
+\fB\-\-robot\fP을 지정하십시오.
+.
+.SH "로봇 모드"
+로봇 모드는 \fB\-\-robot\fP 옵션으로 동작합니다.  \fBxz\fP 출력을 다른 프로그램에서 해석하기 쉽게 해줍니다.  현재로서는
+\fB\-\-robot\fP 옵션은  \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, \fB\-\-version\fP
+옵션하고만 사용할 수 있습니다.  앞으로는 압축 및 압축 해제 동작에 대해서도 지원합니다.
+.
+.SS "목록 모드"
+\fBxz \-\-robot \-\-list\fP 명령은 탭으로 구분한 출력 형태를 활용합니다.  모든 행의 첫번째 컬럼에는 해당 행에서 찾을 수
+있는 정보의 형식을 나타냅니다:
+.TP 
+\fB이름\fP
+이 행은 항상 파일 목록 시작 부분의 첫번째 줄에 있습니다.  이 행의 두번째 컬럼에 파일 이름이 들어있습니다.
+.TP 
+\fB파일\fP
+이 행에는 \fB.xz\fP 파일의 전반적인 정보가 들어있습니다.  이 행은 항상 \fB이름\fP 행 다음에 있습니다.
+.TP 
+\fB스트림\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 ��만 사용합니다.  \fB.xz\fP 파일의 \fB스트림\fP 행 수만큼 나타납니다.
+.TP 
+\fB블록\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다.  \fB.xz\fP 파일의 블록 수만큼 \fB블록\fP 행이 나타납니다.
+\fB블록\fP 행은 모든 \fB스트림\fP 행 다음에 나타납니다. 다른 형식의 행이 끼어들지는 않습니다.
+.TP 
+\fB요약\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 두번 지정했을 때만 사용합니다.  이 행은 모든 \fB블록\fP 행 다음에 출력합니다.
+\fB파일\fP 행과 비슷하게, \fB요약\fP 행에는 \fB.xz\fP 파일의 전반적인 정보가 담겨있습니다.
+.TP 
+\fB총계\fP
+이 행은 목록 출력의 가장 마지막에 항상 나타납니다.  총 갯수와 크기를 나타냅니다.
+.PP
+\fB파일\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+파일 스트림 갯수
+.IP 3. 4
+스트림의 블록 총 갯수
+.IP 4. 4
+파일 압축 크기
+.IP 5. 4
+파일 압축 해제 크기
+.IP 6. 4
+예를 들면, \fB0.123\fP과 같은 압축율 입니다.  비율이 9.999라면, 대시 문자 3개 (\fB\-\-\-\fP)를 비율 값 대신 나타냅니다.
+.IP 7. 4
+쉼표로 구분한 무결성 검사 이름 목록입니다.  \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP, \fBSHA\-256\fP 문자열을 알려진
+검사 형식으로 사용합니다.  알 수 없는 검사 형식에 대해서는 \fBUnknown\-\fP\fIN\fP을 사용하며, 여기서 \fIN\fP은 (한 두자리)
+정수형 숫자값으로 이루어진 검사 ID 입니다.
+.IP 8. 4
+파일의 스트림 패딩 총 길이
+.RE
+.PD
+.PP
+\fB스트림\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+스트림 번호 (첫 스트림은 1번)
+.IP 3. 4
+스트림의 블록 총 갯수
+.IP 4. 4
+압축 시작 오프셋
+.IP 5. 4
+비압축 시작 오프셋
+.IP 6. 4
+압축 크기 (스트림 패딩 미포함)
+.IP 7. 4
+압축 해제 용량
+.IP 8. 4
+압축율
+.IP 9. 4
+무결성 검사 이름
+.IP 10. 4
+스트림 패딩 길이
+.RE
+.PD
+.PP
+\fB블록\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+이 블록이 들어간 스트림 갯수
+.IP 3. 4
+스트림 시작 부분의 블록 번호 (첫번째 블록은 1번)
+.IP 4. 4
+파일 시작 부분의 블록 번호
+.IP 5. 4
+파일 시작 부분의 압축 시작 오프셋
+.IP 6. 4
+파일 시작 부분의 비압축 시작 오프셋
+.IP 7. 4
+총 블록 압축 크기 (헤더 포함)
+.IP 8. 4
+압축 해제 용량
+.IP 9. 4
+압축율
+.IP 10. 4
+무결성 검사 이름
+.RE
+.PD
+.PP
+\fB\-\-verbose\fP를 두 번 지정하면, 추가 컬럼을 \fB블록\fP 행에 넣습니다.  \fB\-\-verbose\fP 단일 지정시에는 이 정보를 볼
+때 탐색을 여러번 수행해야 하기 때문에 실행 과정이 느려질 수 있어서 나타내지 않습니다:
+.PD 0
+.RS
+.IP 11. 4
+16진수 무결성 검사값
+.IP 12. 4
+블록 헤더 크기
+.IP 13. 4
+블록 플래그: \fBc\fP는 압축 크기가 현재 값임을 나타내고, \fBu\fP는 압축 전 원본 크기가 현재 값임을 나타냅니다.  플래그를 설정하지
+않았다면, 문자열 길이를 유지할 목적으로 대시 \fB\-\fP 를 대신 나타냅니다.  새 플래그는 나중에 문자열 끝 부분에 추가할 예정입니다.
+.IP 14. 4
+블록에 압축 해서 넣은 데이터의 실제 츠기 (블록 헤더, 블록 패딩, 검사 필드 제외)
+.IP 15. 4
+이 \fBxz\fP 버전에서 이 블록의 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량
+.IP 16. 4
+필터 체인.  대부분 사용하는 옵션은 압축 해제시 필요한 옵션만을 \fB.xz\fP 헤더에 저장하기 때문에 압축 시간에 알 수 없습니다.
+.RE
+.PD
+.PP
+\fB요약\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+이 \fBxz\fP 버전에서 이 파일 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량
+.IP 3. 4
+모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값
+.PP
+\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP
+.IP 4. 4
+파일 압축 해제시 필요한 최소 \fBxz\fP 버전
+.RE
+.PD
+.PP
+\fB총계\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+스트림 갯수
+.IP 3. 4
+블록 갯수
+.IP 4. 4
+압축 크기
+.IP 5. 4
+압축 해제 용량
+.IP 6. 4
+평균 압축율
+.IP 7. 4
+파일에 들어 있어 쉼표로 구분한 무결성 검사 이름 목록
+.IP 8. 4
+스트림 패딩 길이
+.IP 9. 4
+파일 갯수.  \fB파일\fP 행의 컬럼 순서를 따라갑니다.
+.PD
+.RE
+.PP
+\fB\-\-verbose\fP 옵션을 두 번 지정하면, \fB총계\fP 행에 추가 컬럼이 들어갑니다:
+.PD 0
+.RS
+.IP 10. 4
+이 \fBxz\fP 버전에서 파일 압축을 해제할 떄 필요한 (바이트 단위) 최대 메모리 사용량
+.IP 11. 4
+모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값
+.PP
+\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP
+.IP 12. 4
+파일 압축 해제시 필요한 최소 \fBxz\fP 버전
+.RE
+.PD
+.PP
+차후 버전에서는 새 행 형식을 추가하고 기존 행 형식에 추가할 수 있는 새 컬럼을 넣기 까지는 알 수 있겠지만, 기존 컬럼은 바꾸지 않을
+예정입니다.
+.
+.SS "필터 도움말"
+\fBxz \-\-robot \-\-filters\-help\fP 는 다음 형식의 지원 필터 목록을 출력합니다:
+.PP
+\fI<필터>\fP\fB:\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>,\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>\fP...
+.TP 
+\fI<필터>\fP
+필터 이름
+.TP 
+\fI<옵션>\fP
+필터별 옵션 이름
+.TP 
+\fI<값>\fP
+숫자 \fI값\fP 범위는 \fB<\fP\fI최소\fP\fB\-\fP\fI최대\fP\fB>\fP입니다.  문자열 \fI값\fP은 \fB< >\fP 범위
+내에서 선택하며 \fB|\fP 문자로 구분합니다.
+.PP
+각 필터는 한 줄에 하나씩 출력합니다.
+.
+.SS "메모리 제한 정보"
+\fBxz \-\-robot \-\-info\-memory\fP 명령은 탭으로 나뉜 여러 컬럼을 단일 행으로 나타냅니다:
+.IP 1. 4
+물리 메모리(RAM)의 바이트 단위 총량.
+.IP 2. 4
+압축 진행시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-compress\fP).  특수 값 \fB0\fP은 단일\-스레드 모드에서
+제한을 두지 않는 기본 설정임을 나타냅니다.
+.IP 3. 4
+압축 해제시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-decompress\fP).  특수 값 \fB0\fP은 단일\-스레드 모드에서
+제한을 두지 않는 기본 설정임을 나타냅니다.
+.IP 4. 4
+\fBxz\fP 5.3.4alpha 이후: 다중\-스레드 기반 압축 해제시 바이트 단위 메모리
+사용량(\fB\-\-memlimit\-mt\-decompress\fP).  분명하게 제한을 걸어두지 않았을 경우 5번째 컬럼에 나타난 시스템별
+기본값을 사용하기 때문에 0 값을 지정하면 안됩니다.  또한 \fB\-\-memlimit\-mt\-decompress\fP로 세번째 컬럼 값보다 더
+크게 지정을 한다 할지라도 이 값이 세번째 컬럼 값보다 크면 안됩니다.
+.IP 5. 4
+\fBxz\fP 5.3.4alpha 이후: A system\-specific default memory usage limit that is
+used to limit the number of threads when compressing with an automatic
+number of threads (\fB\-\-threads=0\fP)  and no memory usage limit has been
+specified (\fB\-\-memlimit\-compress\fP).  This is also used as the default value
+for \fB\-\-memlimit\-mt\-decompress\fP.
+.IP 6. 4
+\fBxz\fP 5.3.4alpha 이후: Number of available processor threads.
+.PP
+차후, \fBxz \-\-robot \-\-info\-memory\fP 출력에는 더 많은 내용이 들어가지만, 한 줄 이상은 넘어가지 않습니다.
+.
+.SS 버전
+\fBxz \-\-robot \-\-version\fP 은 \fBxz\fP 와 liblzma의 버전 번호를 다음 형식으로 나타냅니다:
+.PP
+\fBXZ_VERSION=\fP\fIXYYYZZZS\fP
+.br
+\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP
+.TP 
+\fIX\fP
+주 버전.
+.TP 
+\fIYYY\fP
+부 버전.  짝수가 안정 버전입니다.  홀수는 알파 또는 베타 버전입니다.
+.TP 
+\fIZZZ\fP
+안정 릴리스의 패치 수준 또는 개발 릴리스의 횟수입니다.
+.TP 
+\fIS\fP
+안정도.  0은 알파 버전, 1은 베타 버전을 나타내며, 2는 안정 버전을 나타냅니다.  \fIS\fP는 \fIYYY\fP 값이 짝수라 해도 항상
+2여야 합니다.
+.PP
+\fBxz\fP 명령과 liblzma이 동일한 XZ 유틸리티 릴리스에서 나왔다면 두 행의 \fIXYYYZZZS\fP 값은 같습니다.
+.PP
+예제: 4.999.9beta는 \fB49990091\fP이며, 5.0.0은 \fB50000002\fP입니다.
+.
+.SH "종료 상태"
+.TP 
+\fB0\fP
+모든 상태 양호.
+.TP 
+\fB1\fP
+오류 발생.
+.TP 
+\fB2\fP
+눈여겨볼 경고가 나타났지만, 실제 오류는 일어나지 않음.
+.PP
+표준 오류에 출력하는 알림(경고 또는 오류 아님)는 종료 상태에 영향을 주지 않습니다.
+.
+.SH 환경
+\fBxz\fP는 빈칸으로 구분한 옵션 값 목록을 \fBXZ_DEFAULTS\fP, \fBXZ_OPT\fP 환경 변수에서 순서대로, 명령행에서 옵션을
+해석하기 전에 불러옵니다.  참고로 환경 변수에서 옵션만 해석하며, 옵션이 아닌 부분은 조용히 무시합니다.  해석은
+\fBgetopt_long\fP(3)으로 가능하며,  명령행 인자로 활용하기도 합니다.
+.TP 
+\fBXZ_DEFAULTS\fP
+사용자별, 시스템 범위 기본 옵션입니다.  보통 \fBxz\fP의 메모리 사용량 제한을 기본으로 걸어둘 경우 셸 초기화 스크립트에
+설정합니다.  셸 초기화 스크립트와 별도의 유사한 경우를 제외하고라면, 스크립트에서는 \fBXZ_DEFAULTS\fP 환경 변수를 설정하지
+말거나 설정을 해제해야합니다.
+.TP 
+\fBXZ_OPT\fP
+\fBxz\fP 명령행으로 옵션 설정 값을 직접 전달할 수 없을 경우 \fBxz\fP에 옵션을 전달하는 환경 변수입니다.  예를 들어, \fBxz\fP를
+스크립트 또는 도구에서 실행할 경우 GNU \fBtar\fP(1) 라면:
+.RS
+.RS
+.PP
+.nf
+\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR
+.fi
+.RE
+.RE
+.IP ""
+예를 들면, 스크립트에서 \fBXZ_OPT\fP 를 활용하여, 스크립트별로 기본 압축 옵션을 지정할 수 있습니다.  적절한 이유가 있다면
+\fBXZ_OPT\fP 옵션 값을 사용자가 바꾸는걸 추천합니다.  예를 들면, \fBsh\fP(1)  스크립트에서 다음처럼 활용할 수도 있습니다:
+.RS
+.RS
+.PP
+.nf
+\f(CRXZ_OPT=${XZ_OPT\-"\-7e"}
+export XZ_OPT\fR
+.fi
+.RE
+.RE
+.
+.SH "LZMA 유틸리티 호환성"
+\fBxz\fP의 명령행 문법은 실제로 LZMA 유틸리티 4.32.x에서 찾을 수 있는 \fBlzma\fP, \fBunlzma\fP \fBlzcat\fP의
+상위 집합입니다.  대부분의 경우 LZMA 유틸리티를 XZ 유틸리티로 기존에 작성한 스크립트를 깨지 않고도 바꿀 수 있습니다.  몇가지
+비호환성 문제 때문에 문제가 일어날 수는 있습니다.
+.
+.SS "압축 사전 설정 단계"
+압축 수준 사전 설정의 번호 부여 방식은 \fBxz\fP와 LZMA 유틸리티가 동일하지 않습니다.  가장 중요한 차이는 다른 사전 설정에 대해
+딕셔너리 크기를 어떻게 대응했느냐 여부입니다.  딕셔너리 크기는 압축 해제시 메모리 사용량과 거의 비슷합니다.
+.RS
+.PP
+.TS
+tab(;);
+c c c
+c n n.
+단계;xz;LZMA 유틸리티
+\-0;256 KiB;없음
+\-1;1 MiB;64 KiB
+\-2;2 MiB;1 MiB
+\-3;4 MiB;512 KiB
+\-4;4 MiB;1 MiB
+\-5;8 MiB;2 MiB
+\-6;8 MiB;4 MiB
+\-7;16 MiB;8 MiB
+\-8;32 MiB;16 MiB
+\-9;64 MiB;32 MiB
+.TE
+.RE
+.PP
+딕셔너리 크기 차이는 압축 프로그램 메모리 사용에 영향을 주지만, LZMA 유틸리티와 XZ 유틸리티에서 사용량이 늘어나는 다른 차이점이
+있습니다:
+.RS
+.PP
+.TS
+tab(;);
+c c c
+c n n.
+단계;xz;LZMA 유틸리티 4.32.x
+\-0;3 MiB;없음
+\-1;9 MiB;2 MiB
+\-2;17 MiB;12 MiB
+\-3;32 MiB;12 MiB
+\-4;48 MiB;16 MiB
+\-5;94 MiB;26 MiB
+\-6;94 MiB;45 MiB
+\-7;186 MiB;83 MiB
+\-8;370 MiB;159 MiB
+\-9;674 MiB;311 MiB
+.TE
+.RE
+.PP
+XZ 유틸리티의 기본 사전 설정 수준값은 \fB\-6\fP이지만 LZMA 유틸리티의 기본 사전 설정 수준값은 \fB\-7\fP입니다. 두 프로그램의
+딕셔너리 메모리 기본 사용량은 8MiB입니다.
+.
+.SS "스트림 vs 비스트림 .lzma 파일"
+파일을 압축하지 않은 크기는 \fB.lzma\fP 헤더에 저장합니다.  LZMA 유틸리티는 일반 파일을 압축할 때 압축하지 않은 파일의 크기를
+저장합니다.  이 대신 압축하지 않은 크기를 '알 수 없음' 으로 저장하고 압축 해제 프로그램이 멈춰야 할 지점에
+end\-of\-payload 마커를 사용하는 방법도 있습니다.  LZMA 유틸리티는 파이프로 들어온 입력과 같이 압축하지 않은 파일의
+크기를 알 수 없을 때 이런 방식을 활용합니다.
+.PP
+\fBxz\fP는 \fB.lzma\fP 파일을 end\-of\-payload 마커의 유무와 관계없이 압축 해제 방식을 모두 지원하지만, \fBxz\fP로
+만든 모든 \fB.lzma\fP 파일은 end\-of\-payload 마커를 사용하며, \fB.lzma\fP 헤더에 압축하지 않은 파일 크기를 '알 수
+없음'으로 표기합니다. 이 방식은 드문 상황에서 문제를 야기할 수 있습니다.  예를 들면, 임베디드 장치의 \fB.lzma\fP 압축 해제
+프로그램은 압축을 해제했을 때 크기를 알아야 동작합니다.  이 문제를 만나면, LZMA 유틸리티 또는 LZMA SDK를 활용하여
+\&\fB.lzma\fP 파일에 압축 전 파일 크기 정보를 저장해야합니다.
+.
+.SS "지원하지 않는 .lzma 파일"
+\&\fB.lzma\fP 형식은 \fIlc\fP 값을 8까지 받아들이며, \fIlp\fP 값은 4까지 받아들입니다. LZMA 유틸리티는 어떤 \fIlc\fP 값과
+\fIlp\fP 값을 받아들이고도 압축을 해제할 수 있지만, 파일을 만들 때는 늘 \fBlc=3\fP 값과 \fBlp=0\fP 값을 활용합니다.  다른
+\fIlc\fP 값과 \fIlp\fP 값으로의 파일 압축은 \fBxz\fP와 LZMA SDK에서만 가능합니다.
+.PP
+liblzma의 LZMA1 필터 구현체에서는 \fIlc\fP 값과 \fIlp\fP 값의 합이 4를 넘어가면 안됩니다.  그래서 \fB.lzma\fP
+파일의 경우 이 제한을 넘어가면 \fBxz\fP로 압축을 해제할 수 없습니다.
+.PP
+LZMA 유틸리티는 2^\fIn\fP (2의 승수)크기를 지닌 딕셔너리를 가진 \fB.lzma\fP 파일만 만들지만 받아들이는 파일의 딕셔너리
+크기는 어떤 크기든 상관 없습니다.  liblzma에서는 2^\fIn\fP, 2^\fIn\fP + 2^(\fIn\fP\-1) 딕셔너리 크기를 가진
+\&\fB.lzma\fP 파일 만 받아들입니다. 이로 인해 \fB.lzma\fP 파일을 확인할 때 거짓 양성율이 늘어납니다.
+.PP
+모든 \fB.lzma\fP 파일을 liblzma 에서 받아들일 수 있도록 압축하기 때문에 이 제한이 실제로는 문제가 되지 않습니다.
+.
+.SS "뒤따라오는 쓰레기 값"
+압축 해제할 때, LZMA 유틸리티는 \fB.lzma\fP 스트림 처음 부분 다음 나머지를 다 조용히 무시합니다.  대부분의 경우,
+버그입니다.  LZMA 유틸리티에서 \fB.lzma\fP 결합 파일 압축 해제를 지원하지 않음을 의미하기도 합니다.
+.PP
+\&\fB.lzma\fP 스트림 처음부분 바로 다음에 데이터가 남아있을 경우, \fBxz\fP 에서는 \fB\-\-single\-stream\fP 옵션을 사용하지
+않으면 깨진 파일로 간주합니다.  이 동작으로 하여금 뒤따라오는 쓰레기 값을 무시하도록 간주하는 애매한 스크립트 동작을 깰 수가
+있습니��.
+.
+.SH 참고
+.
+.SS "출력 결과물이 달라짐"
+압축하지 않은 입력 파일로부터 얻어낸 정확한 압축 출력 결과물은 압축 옵션이 완전히 동일하더라도 XZ 유틸리티의 버전에 따라 달라질 수
+있습니다.  파일 형식에 영향을 주지 않고 인코더 그 자체를 개선(더 빠르게 하거나 더 나은 압축율로)하기 때문입니다.  XZ 유틸리티
+버전이 동일하더라도 빌드 옵션을 달리하여 빌드 상태가 제각각인 경우 출력 결과물이 달라질 수 있습니다.
+.PP
+\fB\-\-rsyncable\fP 기능을 넣었을 경우 동일한 xz 버전에서 이전 파일과 새 파일로 별도로 압축하지 않는 한 결과 파일을 (두
+파일이 서로 다른 파일이 아니므로) rsync 처리할 필요가 없습니다.  이 문제는 인코더 구현체 기능 개발이 끝나서 xz 버전이
+다르더라도 안정적인 rsync 가능한 출력 결과물을 유지할 수 있을 때여야 해결할 수 있습니다.
+.
+.SS "내장 .xz 압축 해제 프로그램"
+XZ 임베디드와 같은 내장 \fB.xz\fP 압축 해제 구현체는 지원 파일의 무결성 \fI검사\fP 형식을 \fInone\fP과 \fIcrc32\fP 이외의
+설정으로 만들 필요가 없습니다.  기본값이 \fB\-\-check=crc64\fP일 경우에만, 임베디드 시스템에서 파일을 만들 때
+\fB\-\-check=none\fP 또는 \fB\-\-check=crc32\fP 옵션을 사용해야합니다.
+.PP
+임베디드 시스템이 아니라면, 모든 \fB.xz\fP 형식 압축 해제 프로그램에서는 모든 \fI검사\fP 형식을 지원하거나, 일부 \fI검사\fP 방식을
+지원하지 않는다면, 최소한, 무결성 검사로 검증하지 않고 압축을 해제할 수 있습니다.
+.PP
+XZ 임베디드는 BCJ 필터를 지원하지만, 기본 시작 오프셋만 지정할 수 있습니다.
+.
+.SH 예제
+.
+.SS 기본
+\fIfoo\fP 파일을 기본 압축 수준 (\fB\-6\fP) 으로 \fIfoo.xz\fP 파일에 압축해 넣고, 압축 과정이 무사히 끝나면 \fIfoo\fP를
+삭제합니다:
+.RS
+.PP
+.nf
+\f(CRxz foo\fR
+.fi
+.RE
+.PP
+\fIbar.xz\fP를 \fIbar\fP 에 압축을 해제한 후 압축 해제가 무사히 끝나도 \fIbar.xz\fP를 삭제하지 않습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-dk bar.xz\fR
+.fi
+.RE
+.PP
+기본 사전 설정 \fB\-6\fP 보다는 느리지만, 압축 및 압축 해제시 메모리를 적게 차지(각각 48\ Mib, 5\MiB)는 \fB\-4e\fP
+사전 설정(\fB\-4 \-\-extreme\fP)을 활용하여 \fIbaz.tar.xz\fP 파일을 만듭니다:
+.RS
+.PP
+.nf
+\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR
+.fi
+.RE
+.PP
+압축 및 비압축 파일을 단일 명령으로 표준 출력에 압축해제할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR
+.fi
+.RE
+.
+.SS "다중 파일 병렬 압축"
+GNU와 *BSD에서는 \fBfind\fP(1)  명령과 \fBxargs\fP(1)  명령으로 여러 파일의 압축을 병렬 처리할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e
+    | xargs \-0r \-P4 \-n16 xz \-T1\fR
+.fi
+.RE
+.PP
+\fBxargs\fP(1)  의 \fB\-P\fP 옵션으로 \fBxz\fP 프로세스의 병렬 처리 갯수를 지정합니다.  \fB\-n\fP 옵션의 최적 값은 압축할
+파일 수에 달려있습니다.  압축할 파일이 몇개밖에 없다면 1이어야합니다. 파일이 수천 수만개 정도 된다면 \fBxargs\fP(1)  이
+어쨌든지간에 만들어낼 \fBxz\fP 프로세스의 겟수를 100으로 하거나 아니면 적당한 값을 지정하여 줄이는게 좋습니다.
+.PP
+\fBxz\fP에 \fB\-T1\fP옵션을 지정하면 단일\-스레드 모드로 강제합니다. \fBxargs\fP(1)  에서 병렬 처리 갯수를 제어할 수 있기
+때문입니다.
+.
+.SS "로봇 모드"
+여러 파일을 압축한 후 저장할 바이트 용량을 계산합니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR
+.fi
+.RE
+.PP
+이 스크립트에서는 충분히 최신의 \fBxz\fP 명령을 사용하는지 알아보려 합니다.  다음 \fBsh\fP(1)  스크립트에서는 \fBxz\fP 도구의
+버전 번호가 최소한 5.0.0인지 여부를 검사합니다.  이 방식은 \fB\-\-robot\fP 옵션을 지원하지 않는 오래된 베타 버전과도 호환성이
+있습니다:
+.RS
+.PP
+.nf
+\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" ||
+        [ "$XZ_VERSION" \-lt 50000002 ]; then
+    echo "Your xz is too old."
+fi
+unset XZ_VERSION LIBLZMA_VERSION\fR
+.fi
+.RE
+.PP
+\fBXZ_OPT\fP 환경 변수로 압축 해제시 메뢰 사용량 한계를 설정하지만, 한계 값을 이미 설정했다면, 값을 늘리지 않습니다:
+.RS
+.PP
+.nf
+\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB
+OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3)
+if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then
+    XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM"
+    export XZ_OPT
+fi\fR
+.fi
+.RE
+.
+.SS "개별 압축 필터 체인 설정"
+개별 설정 필터 체인의 초단순 사용방식은 LZMA2 사전 설정 값을 별도로 설정하는 방식입니다.  ���전 설정은 잠재적으로 쓸만한 압축
+설정 조합만 다루기 때문에 꽤 쓸모가 있을 수도 있습니다.
+.PP
+\fB\-0\fP ... \fB\-9\fP 옵션의 설명에서 테이블의 CompCPU 컬럼과 \fB\-\-extreme\fP 옵션은 LZMA2 사전 설정을
+개별적으로 맞췄을 때 쓸만할 수도 있습니다.  여기 관련내용을 테이블 둘로 정리해서 모아보았습니다:
+.RS
+.PP
+.TS
+tab(;);
+c c
+n n.
+Preset;CompCPU
+\-0;0
+\-1;1
+\-2;2
+\-3;3
+\-4;4
+\-5;5
+\-6;6
+\-5e;7
+\-6e;8
+.TE
+.RE
+.PP
+어떤 파일을 압축할 때 상당히 큰 딕셔너리(예: 32MiB)가 필요 하다는걸 알아채셨지만, \fBxz \-8\fP 명령이 압축할 때보다 더 빠른
+속도로 압축하려 한다면, 더 큰 딕셔너리 사용을 위해 더 낮은 CompCPU 사전 설정 값(예: 1)으로 수정할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR
+.fi
+.RE
+.PP
+각 파일에 대해, 위 명령은 압축율이 더 좋아지면서도 \fBxz \-6\fP보다 더 빨라집니다.  그러나, CompCPU 값을 낮게 유지하는
+대신 큰 딕셔너리에서 일부 파일을 강조해야 합니다.  큰 딕셔너리가 대부분의 도움을 주는 매우 명백한 상황에서는 최소한 몇 메가바이트의
+매우 유사한 각 파일이 아카이브에 들어갑니다.  딕셔너리 크기는 LZMA2가 연속으로 존재하는 각 파일의 유사성으로부터 얻는 장점을 취할
+수 있을 때 일부 개별 파일보다 훨씬 더 커집니다.
+.PP
+압축 프로그램과 압축 해제 프로그램에서 메모리를 엄청 많이 사용해도 상관 없고, 파일을 수백 메가 바이트 메모리 용량을 활용하여
+압축한다면, \fBxz \-9\fP 명령에 64MiB 용량을 초과하는 딕셔너리를 사용할 수 있게 하는 방법도 쓸만할 지도 모릅니다:
+.RS
+.PP
+.nf
+\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR
+.fi
+.RE
+.PP
+위 예제에서와 같이 \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) 옵션을 사용하면 압축 및 압축 해제 과정에서 필요한 메모리
+용량을 살펴보는데 요긴할 수 있습니다.  압축 해제한 파일 크기보다 더 큰 딕셔너리를 사용하면 불필요한 메모리 소모량이 발생하여 위
+명령이 작은 파일에는 쓸모 없음을 기억하십시오.
+.PP
+때로는 압축 시간이 딱히 상관이 없을 수도 있습니다만, 압축 해제시 메모리 사용량을 적게 유지해야 할 수도 있습니다. 예를 들면,
+임베디드 시스템에서 파일 압축을 해제할 수도 있습니다.  다음 명령의 경우 \fB\-6e\fP (\fB\-6 \-\-extreme\fP) 옵션을 기반
+옵션을 사용하며 딕셔너리 크기를 64KiB만 사용하도록 제한합니다.  결과 파일은 XZ 임베디드(이게 \fB\-\-check=crc32\fP
+옵션이 있는 이유)로 100KiB 메모리 용량을 활용하여 풀어낼 수 있습니다.
+.RS
+.PP
+.nf
+\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR
+.fi
+.RE
+.PP
+가능한 한 수 바이트를 더 쥐어 짜내고 싶을 때, 리터럴 문맥 비트 수(\fIlc\fP)와 위치 비트 수(\fIpb\fP)를 조정하면 도움이 될
+수도 있습니다.  리터럴 위치 비트 수(\fIlp\fP)를 조금 건드리는 것 또한 도움이 될 지도 모르겠지만 보통 \fIlc\fP 값과 \fIpb\fP
+값이 더 중요합니다.  예를 들면, 소스 코드 저장 파일에는 US\-ASCII 텍스트가 대부분이기에, 다음과 같은 경우는 \fBxz \-6e\fP
+명령을 실행했을 때부다는 아주 약간(거의 0.1% 수준) 작은 파일을 얻어낼 수도 있습니다(\fBlc=4\fP를 빼고도 시도해보십시오):
+.RS
+.PP
+.nf
+\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR
+.fi
+.RE
+.PP
+LZMA2와 다른 필터를 함께 사용하면 일부 파일 형식에 대해 압축율을 개선할 수 있습니다.  예를 들면 x86\-32 또는 x86\-64
+공유 라이브러리를 x86 BCJ 필터를 활용하여 압축할 경우:
+.RS
+.PP
+.nf
+\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR
+.fi
+.RE
+.PP
+참고로 필터 옵션의 순서는 상당히 중요합니다.  \fB\-\-x86\fP을 \fB\-\-lzma\fP 이전에 지정하면 \fBxz\fP에서 오류가 나는데,
+LZMA2 다음에는 어떤 필터든 설정할 수 없고, 옵션 체인상 마지막 필터로 x86 BCJ 필터를 사용할 수 없기 때문입니다.
+.PP
+LZMA2와 델타 필터는 비트맵 그림에 최적의 결과를 가져다줄 수 있습니다.  PNG에 보통 안성맞춥인데, PNG에는 단순 델타 필터보단
+약간 더 고급진 필터를 사용하지만, 실제 압축을 진행할 때는 Deflate를 사용하기 때문입니다.
+.PP
+예를 들어 이미지를 압축하지 않은 비압축 TIFF로 저장해야 하는 경우가 있습니다.  델타 필터의 거리 매개변수는 그림에서 픽셀당 바이트
+수에 일치하도록 설정합니다.  예를 들면, 24비트 RGB 비트맵의 경우 \fBdist=3\fP 거리 매개변수 값을 설정해야 하며, LZMA2
+압축시 3바이트 정렬을 따르도록 \fBpb=0\fP 값을 전달하는 방법도 바람직합니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR
+.fi
+.RE
+.PP
+여러 이미지를 단일 아카이브로 넣고 싶다면(예: \fB.tar\fP), 모든 이미지에 대해 동일한 픽셀당 바이트 수가 들어가는 경우에도 델타
+필터가 동작합니다.
+.
+.SH "추가 참조"
+\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1),
+\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1)
+.PP
+XZ 유틸리티: <https://tukaani.org/xz\-utils/>
+.br
+XZ 임베디드: <https://tukaani.org/xz/embedded/>
+.br
+LZMA SDK: <https://7\-zip.org/sdk.html>

janus/share/man/ko/man1/xzcat.1

@@ -0,0 +1,1548 @@
+'\" t
+.\" SPDX-License-Identifier: 0BSD
+.\"
+.\" Authors: Lasse Collin
+.\"          Jia Tan
+.\"
+.\" Korean translation for the xz-man
+.\" Seong-ho Cho <[email protected]>, 2023, 2024.
+.\"
+.\"*******************************************************************
+.\"
+.\" This file was generated with po4a. Translate the source file.
+.\"
+.\"*******************************************************************
+.TH XZ 1 2024\-12\-30 Tukaani "XZ 유틸리티"
+.
+.SH 이름
+xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz 파일과 .lzma 파일을 압축 또는 압축 해제합니다
+.
+.SH 요약
+\fBxz\fP [\fI<옵션>...\fP] [\fI<파일>...\fP]
+.
+.SH "명령 별칭"
+\fBunxz\fP 명령은 \fBxz \-\-decompress\fP 명령과 동일합니다.
+.br
+\fBxzcat\fP 명령은 \fBxz \-\-decompress \-\-stdout\fP 명령과 동일합니다.
+.br
+\fBlzma\fP 명령은 \fBxz \-\-format=lzma\fP 명령과 동일합니다.
+.br
+\fBunlzma\fP 명령은 \fBxz \-\-format=lzma \-\-decompress\fP 명령과 동일합니다.
+.br
+\fBlzcat\fP 명령은 \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP 명령과 동일합니다.
+.PP
+파일 압축을 해제해야 하는 셸 스크립트를 작성할 때, \fBunxz\fP 와 \fBxzcat\fP 이름 대신 \fBxz\fP 명령과 적절한 인자
+값(\fBxz \-d\fP 또는 \fBxz \-dc\fP)의 사용을 추천드립니다.
+.
+.SH 설명
+\fBxz\fP는 \fBgzip\fP(1)  과 \fBbzip2\fP(1)  과 비슷한 명령행 문법을 지닌 범용 데이터 압축 도구입니다.  자체 파일
+형식은 \fB.xz\fP 형식이나, LZMA 유틸리티에서 사용하는 예전 \fB.lzma\fP 형식과 형식 헤더가 없는 RAW 압축 스트림도
+지원합니다.  게다가, \fBlzip\fP에서 활용하는 \fB.lz\fP 형식 압축 해제도 지원합니다.
+.PP
+각 \fI파일\fP 에 대한 \fBxz\fP 압축 또는 압축 해제는 선택 동작 모드에 따릅니다.  \fI<파일>\fP 값이 주어졌거나
+\fI<파일>\fP 값이 \fB\-\fP이면, \fBxz\fP 명령에서 표준 입력을 읽고 처리한 데이터를 표준 출력에 기록합니다.
+\fBxz\fP 에서는 터미널에서 활용할 경우 압축 데이터를 표준 압축으로 기록하는 동작을 거절(오류를 출력하고 \fI<파일>\fP을
+건너뜀)합니다.  이와 비슷하게, \fBxz\fP 유틸리티를 터미널에서 실행하면 표준 입력의 압축 데이터 읽기를 거절합니다.
+.PP
+\fB\-\-stdout\fP 을 지정하지 않는 한, \fB\-\fP가 아닌 \fI<파일>\fP을 원본 \fI<파일>\fP 이름에서
+가져온 새 파일 이름으로 기록합니다:
+.IP \(bu 3
+압축할 때, 대상 파일 형식의 접미사(\fB.xz\fP or \fB.lzma\fP)  는 원본 파일 이름 뒤에 붙어 대상 파일이름이 됩니다.
+.IP \(bu 3
+압축 해제할 때, \fB.xz\fP, \fB.lzma\fP, \fB.lz\fP 접미사를 파일 이름에서 제거하고 대상 파일 이름을 알아냅니다.
+\fBxz\fP에서는 \fB.txz\fP, \fB.tlz\fP 접미사도 인식하며, \fB.tar\fP 접미사로 치환합니다.
+.PP
+대상 파일이 이미 있으면, 오류를 나타내고 \fI<파일>\fP을 건너뜁니다.
+.PP
+표준 출력으로 기록하기 전에는, \fBxz\fP는 경고를 나타내며, 다음 조건에 만족할 경우 \fI<파일>\fP을 건너뜁니다:
+.IP \(bu 3
+\fI<파일>\fP이 일반 파일이 아닐 때.  심볼릭 링크는 따라가지 않기에, 일반 파일로 간주하지 않습니다.
+.IP \(bu 3
+\fI<파일>\fP이 하나 이상의 하드 링크일 떄.
+.IP \(bu 3
+\fI<파일>\fP에 setuid, setgid, 끈적이 비트 집합이 붙어있을 떄.
+.IP \(bu 3
+동작 모드를 압축으로 설정하고, \fI<파일>\fP은 대상 파일 형식의 접미사를 이미 붙였을 때(\fB.xz\fP 형식으로 압축하면
+\&\fB.xz\fP 또는 \fB.txz\fP, \fB.lzma\fP 형식으로 압축하면 \fB.lzma\fP 또는 \fB.tlz\fP).
+.IP \(bu 3
+동작 모드를 압축 해제로 설정하고, \fI<파일>\fP에 지원 파일 형식 접미사(\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP,
+\&\fB.tlz\fP, \fB.lz\fP)를 붙이지 않았을 때.
+.PP
+\fI<파일>\fP 의 압축 또는 압축 해제를 성공하고 나면, \fBxz\fP는 소유자, 소유그룹, 권한, 접근 시각, 수정 시각
+정보를 원본 \fI<파일>\fP에서 대상 파일로 그대로 복사합니다.  그룹 정보 복사에 실패하면, 권한을 수정하여 원본
+\fI<파일>\fP에 접근 권한이 없는 사용자가 대상 파일로 접근하지 못하게 합니다.  \fBxz\fP는 아직 접근 제어 목록이나
+확장 속성 등의 기타 메타데이터를 복사하는 기능은 지원하지 않습니다.
+.PP
+대상 파일을 온전히 닫고 나면, \fB\-\-keep\fP 옵션을 지원하지 않았을 경우 원본 \fI<파일>\fP을 제거합니다.  원본
+\fI<파일>\fP은 출력을 표준 출력으로 기록했거나 오류가 발생했을 경우 제거하지 않습니다.
+.PP
+\fBxz\fP 프로세스에 \fBSIGINFO\fP 시그널 또는 \fBSIGUSR1\fP 시그널을 보내면 표준 출력으로 진행 정보를 출력합니다.  표준
+오류가 터미널일 경우일 경우에만 제한하며 \fB\-\-verbose\fP 옵션을 지정하면 진행 표시줄을 자동으로 나타냅니다.
+.
+.SS "메모리 사용"
+\fBxz\fP 메모리 사용은 수백 킬로바이트로 시작하여 수 기가바이트까지 압축 설정에 따라 다릅니다.  압축 해제 프로그램이 필요로 하는
+메모리 공간을 결정하는 파일 압축시에 설정 값을 활용합니다.  보통 압축 해제 프로그램은 파일을 만들 때, 압축 프로그램 메모리 사용량의
+5% 에서 20% 정도 필요합니다.  예를 들면, \fBxz \-9\fP로 압축한 파일 압축 해제시 현재 65MiB 메모리 용량이 필요합니다.
+여전하게도, 압축 해제시 수 기가 바이트의 메모리가 필요한 \fB.xz\fP 파일에도 가능한 이야기입니다.
+.PP
+특히 이전 시스템 사용자의 경우 메모리 사용량이 엄청나게 늘어나는 점에 짜증이 날 수 있습니다.  이런 불편한 상황을 피하기 위해,
+\fBxz\fP에 기본적으로 비활성 상태인 내장 메모리 사용 제한 기능을 넣었습니다.  일부 운영체제에서 처리 중 메모리 사용을 제한하는
+수단을 제공하긴 하지만, 여기에 의지하기에는 충분히 유연하지 않습니다(예를 들면, \fBulimit\fP(1)을 사용하면 가상 메모리를
+제한하여  \fBmmap\fP(2)을 먹통으로 만듭니다).
+.PP
+메모리 사용 제한 기능은 \fB\-\-memlimit=\fP\fI<제한용량>\fP 명령행 옵션으로 사용할 수 있습니다.  종종
+\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP와 같이 \fBXZ_DEFAULTS\fP 환경 변수를 설정하여 제한 기능을 켜는게 더
+편합니다.  \fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션과
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP 옵션을 활용하여 압축 및 압축 해제시 별도로 한계 값을
+설정할 수 있습니다.  이 두 가지 옵션의 \fBXZ_DEFAULTS\fP 환경 변수 밖에서의 사용은, \fBxz\fP를 단일 실행할 때 압축 및
+압축 해제 동작을 동시에 수행하지 않으며, 앞서 언급한 두가지 옵션을 명령행에 입력하기에는
+\fB\-\-memlimit=\fP\fI<제한용량>\fP(또는 \fB\-M\fP \fI<제한용량>\fP)이 더 짧기 때문에 별로 쓸모가
+없습니다.
+.PP
+압축 해제시 메모리 사용 제한 지정 한계를 초과하면, \fBxz\fP 유틸리티에서 오류를 나타내며 파일 압축 해제는 실패합니다.  압축을
+실행할 때 사용 제한 지정 한계를 넘어서면 \fBxz\fP에서는 설정 값을 줄여서 어쨌든 한계를 넘지 못하게
+합니다(\fB\-\-format=raw\fP 옵션 또는 \fB\-\-no\-adjust\fP 옵션 사용시 제외).  설정 한계 값이 엄청 작지 않은 이상 이
+방식대로 처리하면 어쨌든 실패하지 않습니다.  설정 값조정은 압축 래벨 사전 설정과 일치하지 않을 때 단계적으로 진행하는데, 이를테면,
+\fBxz \-9\fP 명령 수행에 필요한 양보다 한계 값이 약간 작으면, 설정 값을 \fBxz \-8\fP에 못미치게 약간 줄여서 진행합니다.
+.
+.SS ".xz 파일 결합 및 패딩"
+\&\fB.xz\fP 파일을 있는 그대로 합칠 수 있습니다.  \fBxz\fP는 \fB.xz\fP 파일을 단독 파일일 때 처럼 압축해제합니다.
+.PP
+결합 부분과 마지막 부분 뒤에 패딩을 추가할 수 있습니다.  패딩은 널 바이트로 구성해야 하며 패딩 길이는 4바이트로 구성해야 합니다.
+512 바이트 블록으로 파일 크기를 이루는 매체에 \fB.xz\fP 파일을 저장했을 경우에 요긴할 수 있습니다.
+.PP
+\&\fB.lzma\fP 파일 또는 원시 스트림의 경우 결합과 패딩을 허용하지 않습니다.
+.
+.SH 옵션
+.
+.SS "정수 접두사와 별도 값"
+정수 인자값이 필요한 대부분 위치에서는, 큰 정수값을 나타내기 쉽게 하도록 추가 접미사를 지원합니다.  정수와 접미사 사이에 어떤 공백이
+있으면 안됩니다.
+.TP 
+\fBKiB\fP
+1,024 (2^10) 배수 정수값. \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, \fBKB\fP 단위를 \fBKiB\fP 동의어로 받아들입니다.
+.TP 
+\fBMiB\fP
+1,048,576 (2^20) 배수 정수값. \fBMi\fP, \fBm\fP, \fBM\fP, \fBMB\fP 단위를 \fBMiB\fP 동의어로 받아들입니다.
+.TP 
+\fBGiB\fP
+1,073,741,824 (2^30) 배수 정수값.  \fBGi\fP, \fBg\fP, \fBG\fP, \fBGB\fP 단위를 \fBGiB\fP 동의어로
+받아들입니다.
+.PP
+특수 값 \fBmax\fP는 옵션에서 지원하는 정수 최대 값을 나타낼 때 사용할 수 있습니다.
+.
+.SS "동작 모드"
+여러 동작 모드를 보여드리겠습니다만, 마지막에 주어진 동작 모드로 동작합니다.
+.TP 
+\fB\-z\fP, \fB\-\-compress\fP
+압축합니다.  어떤 동작 모드 옵션도 지정하지 않고 다른 동작 모드를 명령행에 따로 지정하지 않았다면 이 동작 모드는 기본입니다(예:
+\fBunxz\fP 는 \fB\-\-decompress\fP를 암시).
+.IP ""
+.\" The DESCRIPTION section already says this but it's good to repeat it
+.\" here because the default behavior is a bit dangerous and new users
+.\" in a hurry may skip reading the DESCRIPTION section.
+After successful compression, the source file is removed unless writing to
+standard output or \fB\-\-keep\fP was specified.
+.TP 
+\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP
+.\" The DESCRIPTION section already says this but it's good to repeat it
+.\" here because the default behavior is a bit dangerous and new users
+.\" in a hurry may skip reading the DESCRIPTION section.
+Decompress.  After successful decompression, the source file is removed
+unless writing to standard output or \fB\-\-keep\fP was specified.
+.TP 
+\fB\-t\fP, \fB\-\-test\fP
+압축 \fI<파일>\fP의 무결성을 시험해봅니다.  이 옵션은 압축 해제 데이터를 표준 출력으로 기록하는 대신 버린다는 점을
+제외하고 \fB\-\-decompress \-\-stdout\fP과 동일합니다.  어떤 파일도 만들거나 제거하지 않습니다.
+.TP 
+\fB\-l\fP, \fB\-\-list\fP
+압축 \fI<파일>\fP 정보를 출력합니다.  압축 해제 출력을 내보내지 않으며, 어떤 파일도 만들거나 제거하지 않습니다.  이
+조회 모드에서, 프로그램은 표준 입력 또는 기타 탐색 불가능한 원본에서 압축 데이터를 읽을 수 없습니다.
+.IP ""
+\fI<파일>\fP 기본 정보를 파일 당 한 줄 씩 기본으로 보여줍니다.  더 자세한 정보를 보려면 \fB\-\-verbose\fP
+옵션을 사용하십시오.  더 자세한 정보는 \fB\-\-verbose\fP 옵션을 두번 사용하면 되지만, 추가 정보를 더 많이 가져오면서 탐색
+횟수가 늘어나는 문제로 인해 느려질 수 있습니다.  세부 출력 너비는 80 문자를 초과하며, 예를 들어 출력을 파이핑한다면, 터미널이
+충분히 너비가 넓지 못할 경우 \fBless\ \-S\fP 명령이 편리할 수 있습니다.
+.IP ""
+정확한 출력은 \fBxz\fP 버전과 다른 로캘에 따라 바뀔 수 있습니다.  기계 판독용 출력시 \fB\-\-robot \-\-list\fP 옵션을
+사용합니다.
+.
+.SS "동작 수정자"
+.TP 
+\fB\-k\fP, \fB\-\-keep\fP
+입력 파일을 삭제하지 않습니다.
+.IP ""
+\fBxz\fP 5.2.6 부터는 이 옵션으로 입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid,
+setgid, 끈적이 비트 세트를 설정한 상태라도 압축하거나 압축을 풀 수 있습니다. setuid, setgid, 끈적이 비트는 대상
+파일에 복사하지 않습니다.  이전 버전에서는 \fB\-\-force\fP 옵션을 지정했을 때만 가능했습니다.
+.TP 
+\fB\-f\fP, \fB\-\-force\fP
+이 옵션은 몇가지 동작에 영향을 줍니다:
+.RS
+.IP \(bu 3
+대상 파일이 이미 있으면, 압축 또는 압축 해제 전 삭제합니다.
+.IP \(bu 3
+입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, setgid, 끈적이 비트 세트를 설정한
+상태라도 압축 또는 압축 해제를 진행합니다.  setuid, setgid, 끈적이 비트는 대상 파일에 복사하지 않습니다.
+.IP \(bu 3
+\fB\-\-decompress\fP \fB\-\-stdout\fP 옵션을 같이 사용하는 상황에서 \fBxz\fP 명령이 원본 파일의 형식을 알아내지 못할 때,
+원본 파일의 사본을 표준 출력으로 보냅니다.  이렇게 하면 \fBxzcat\fP \fB\-\-force\fP 명령을 \fBxz\fP 명령으로 압축하지 않은
+파일에 대해 \fBcat\fP(1) 을 사용하는 것처럼 사용할 수 있습니다.  참고로 나중에, \fBxz\fP에서 \fBxz\fP로 하여금 여러 형식의
+파일을 표준 출력으로 복사하는 대신 압축을 해제하도록 새 압축 파일 형식을 지원할 예정입니다.
+\fB\-\-format=\fP\fI<형식>\fP 옵션은 \fBxz\fP 명령에 단일 파일 형식만 압축 해제하도록 제한할 때 사용할 수
+있습니다.
+.RE
+.TP 
+\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP
+파일 대신 표준 출력으로 압축 또는 압축 해제한 데이터를 기록합니다.  \fB\-\-keep\fP를 생략했습니다.
+.TP 
+\fB\-\-single\-stream\fP
+처음 \fB.xz\fP 스트림만 압축 해제하며, 스트림에 뒤따라오는 나머지 입력 데이터는 조용히 무시합니다.  보통 뒤따라오는 쓰레기 값에
+대해서는 \fBxz\fP 에서 오류를 나타냅니다.
+.IP ""
+\fBxz\fP는 \fB.lzma\fP 파일 또는 원시 스트림에서 온 하나 이상의 스트림에 대해 압축 해제동작을 취하지 않지만, 이 옵션을 사용하면
+\fBxz\fP에서 \fB.lzma\fP 파일 또는 원시 스트림을 처리한 다음에 뒤따라오는 데이터를 무시하도록 합니다.
+.IP ""
+이 옵션은 동작 모드가 \fB\-\-decompress\fP 또는 \fB\-\-test\fP가 아니면 동작에 아무런 영향을 주지 않습니다.
+.TP 
+\fB\-\-no\-sparse\fP
+희소 파일을 만들지 않습니다.  기본적으로 일반 파일로 압축 해제할 경우 \fBxz\fP 에서는 압축 해제한 파일에 이진 0값이 길게 늘어질
+경우 희소 배열 파일을 만들려고 합니다.  표준 출력의 내용 길이만큼 연결한 일반 파일로 기록할 때도 동작하며 희소 파일을 만드는 동안
+아무런 ��제가 나타나지 않게 각각의 추가 조건을 만족합니다.  희소 파일을 만들면 디스크 공간을 절약할 수 있으며 디스크 입출력을 줄여
+압축 해제 속도를 올릴 수 있습니다.
+.TP 
+\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP
+압축할 때, 대상 파일의 접두사를 \fB.xz\fP 또는 \fB.lzma\fP 대신 \fI.suf\fP로 사용하십시오.  표준 출력으로 기록하지 않고
+원본 파일에 \fI.suf\fP 접두사가 붙어있으면, 경고를 나타내고 해당 파일을 건너뜁니다.
+.IP ""
+압축 해제할 때, \fI.suf\fP 접미사로 파일을 인식하기도 하고, \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP,
+\&\fB.lz\fP 접미사가 붙은 파일도 인식합니다.  원본 파일에 \fI.suf\fP 접미사가 붙어있으면, 해당 접미사를 제거하여 대상 파일 이름을
+알아냅니다.
+.IP ""
+원시 스트림 압축 및 압축 해제시(\fB\-\-format=raw\fP) 원시 스트림에 기본 접미사가 없기 때문에, 표준 출력으로 기록하지 않는
+한 접미사를 반드시 지정해야 합니다.
+.TP 
+\fB\-\-files\fP[\fB=\fP\fI<파일>\fP]
+\fI<파일>\fP에서 처리할 파일 이름을 읽습니다. \fI<파일>\fP을 생략하면 파일 이름은 표준 입력에서
+불러옵니다.  파일 이름은 개행 문자로 끝나야 합니다.  대시 문자(\fB\-\fP)는 일반 파일 이름으로 취급하며 표준 입력을 의미하지
+않습니다.  파일 이름을 명령행 인자로 지정하면, \fI<파일>\fP에서 파일 이름을 읽어들이기 전 해당 명령행 인자를 먼저
+처리합니다.
+.TP 
+\fB\-\-files0\fP[\fB=\fP\fI<파일>\fP]
+각 파일 이름이 널 문자로 끝나야 한다는 점만 제외하면 \fB\-\-files\fP[\fB=\fP\fI<파일>\fP] 옵션과 동일합니다.
+.
+.SS "기본 파일 형식 및 압축 옵션"
+.TP 
+\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fI<형식>\fP
+압축 또는 압축해제 파일 \fI<형식>\fP을 지정합니다:
+.RS
+.TP 
+\fBauto\fP
+기본 값입니다.  압축할 때, \fBauto\fP는 \fBxz\fP의 기본 동작과 동일합니다.  압축을 해제할 때, 입력 파일 형식을 자동으로
+찾습니다.  참고로 원시 스트림(\fB\-\-format=raw\fP)의 경우 자동으로 찾을 수 없습니다.
+.TP 
+\fBxz\fP
+\&\fB.xz\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.xz\fP 파일만 받아들입니다.
+.TP 
+\fBlzma\fP, \fBalone\fP
+이전 \fB.lzma\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.lzma\fP 파일만 받아들입니다.  \fBalone\fP 대체 명령은 LZMA
+유틸리티 하위 호환성을 목적으로 제공합니다.
+.TP 
+\fBlzip\fP
+압축 해제시 \fB.lz\fP 파일만 받아들입니다.  압축은 지원하지 않습니다.
+.IP ""
+\&\fB.lz\fP 형식 버전 0과 비확장 버전 1을 지원합니다.  버전 0파일은 \fBlzip\fP 1.3 이전에서만 만듭니다.  일반적이진 않지만
+일부 파일의 경우 이 형식과 관련된 원본 패키지로 보관한 파일을 찾을 수도 있습니다.  개인적으로 이 형식으로 압축한 오래된 개인 파일을
+가지고 있을 수도 있습니다.  형식 버전 0 압축 해제 지원은 \fBlzip\fP 1.18에서 제거했습니다.
+.IP ""
+\fBlzip\fP 1.4 이상에서는 버전 1형식의 파일을 만듭니다.  형식 버전 1로의 동기화 제거 마커 확장은 \fBlzip\fP 1.6에
+추가했습니다.  이 확장은 거의 쓰지 않으며 \fBxz\fP 에서 조차도 지원하지 않습니다(손상된 입력 파일로 진단함).
+.TP 
+\fBraw\fP
+원시 스트림으로 압축하거나 압축을 해제합니다(헤더 없음).  고급 사용자 전용입니다.  원시 스트림을 디코딩하려면,
+\fB\-\-format=raw\fP 옵션을 사용하고 분명하게 필터 체인을 지정하여 컨테이너 헤더에 필요한 정보를 저장하게 끔 해야합니다.
+.RE
+.TP 
+\fB\-C\fP \fI<검사방식>\fP, \fB\-\-check=\fP\fI<검사방식>\fP
+무결성 검사 방식을 지정합니다.  검사 방식은 \fB.xz\fP 파일에 저장하며 압축 해제 데이터를 계산합니다.  이 옵션은 \fB.xz\fP
+형식으로 압축할 때만 효력이 있습니다: \fB.lzma\fP 형식은 무결성 겁사를 지원하지 않습니다.  무결성 검사는 \fB.xz\fP 파일 압축을
+풀었을 때에 검사합니다.
+.IP ""
+지원 \fI검사\fP 형식:
+.RS
+.TP 
+\fBnone\fP
+어떤 경우에도 무결성 검사 계산을 수행하지 않습니다.  보통 바람직하지 못한 생각입니다.  데이터 무결성을 다른 방식으로라도 검증해야
+하는 상황이면 쓸만할 수 있습니다.
+.TP 
+\fBcrc32\fP
+IEEE\-802.3 (이더넷)의 다항 연산으로 CRC32를 계산합니다.
+.TP 
+\fBcrc64\fP
+ECMA\-182의 다항식 연산으로 CRC64를 계산합니다.  이 동작이 기본 동작이기 때문에 CRC32가 깨진 파일을 찾을 때보다는 좀
+낮은 편이며 속도 차이도 거의 없습니다.
+.TP 
+\fBsha256\fP
+SHA\-256 해시를 계산합니다.  CRC32와 CRC64 보다는 좀 느립니다.
+.RE
+.IP ""
+\&\fB.xz\fP 헤더 무결성은 항상 CRC32로 검증하빈다.  이를 바꾸거나 It is not possible to change or
+disable it.
+.TP 
+\fB\-\-ignore\-check\fP
+압축 데이터를 압축해제할 경우 압축 데이터의 무결성 검증을 진행하지 않습니다.  \fB.xz\fP 헤더의 CRC32 값은 그래도 여전히 보통
+방식으로 검증합니다.
+.IP ""
+\fB이 옵션이 정확히 무슨 동작을 하는지 알기 전에는 사용하지 마십시오.\fP 이 옵션을 사용하는 타당한 이유로:
+.RS
+.IP \(bu 3
+깨진 .xz 파일에서 데이터 복구를 시도합니다.
+.IP \(bu 3
+압축 해제 속도를 늘립니다.  SHA\-256 또는 압축 파일에 들어간 그 무언가를 엄청 빨리 처리합니다.  다른 방식으로 파일 무결성을
+검증해야 하는 목적이 아니라면 이 옵션을 사용하지 않는게 좋습니다.
+.RE
+.TP 
+\fB\-0\fP ... \fB\-9\fP
+압축 사전 설정 수준을 선택합니다.  기본값은 \fB\-6\fP입니다.  다중 수준을 지정하면 가장 마지막 수준 옵션을 적용합니다.  개별 필터
+체인을 이미 지정했다면, 압축 사전 설정 수준 값을 설정할 때 개별 필터 체인을 정리합니다.
+.IP ""
+사전 설정간 차이는 \fBgzip\fP(1)과 \fBbzip2\fP(1)을 사용할 때보다 더 비중을 차지합니다.  선택한 압축 설정은 압축 해제시
+필요한 메모리 사용량을 셜정하므로 사전 설정 수준 값을 너무 높게 지정하면 RAM 용량이 적은 오래된 시스템에서 파일 압축 해제시 실패할
+수 있습니다.  게다가, \fBgzip\fP(1)  과 \fBbzip2\fP(1)에서 처럼 종종 \fB모든 동작에 \-9를 몰래 활용하는건 바람직하지 않습니다\fP.
+.RS
+.TP 
+\fB\-0\fP ... \fB\-3\fP
+동작이 빠른 사전 설정 부류입니다. \fB\-0\fP은 때로는 \fBgzip \-9\fP 명령보다 압축율이 훨씬 우수하면서도 더 빠릅니다.  더 큰
+값은 보통 \fBbzip2\fP(1) 명령과 비교했을 떄 압축 결과가 압축 데이터에 따라 달라지더라도, 비교할 법한 속도 또는 더 나은
+압축율을 보입니다.
+.TP 
+\fB\-4\fP ... \fB\-6\fP
+오래된 시스템에서 조차도 압축 해제 프로그램의 적절한 메모리 사용량을 보이면서 양호하거나 최적의 압축율을 보여줍니다.  \fB\-6\fP 옵션은
+압축 해제시 메모리 사용량이 16MiB 밖에 안되기 때문에 파일을 배포할 때 최적의 선택인 기본 값입니다.  (\fB\-5e\fP 또는
+\fB\-6e\fP도 역시 고려할 만합니다.  \fB\-\-extreme\fP을 참고하십시오.)
+.TP 
+\fB\-7 ... \-9\fP
+\fB\-6\fP과 비슷하지만 압축 및 압축 해제시 요구 메모리 사용량이 더 높습니다.  압축 파일이 각각 8MiB, 16MiB, 32MiB
+보다 클 경우에만 쓸만한 옵션입니다.
+.RE
+.IP ""
+동일한 하드웨어에서, 압축 해제 속도는 압축한 데이터의 초당 정적 바이트 처리 수의 어림 평균입니다.  다시 말해, 압축율을 더 올리면,
+압축 해제 속도도 역시 올라갑니다.  이는 곧 초당 비압축 데이터 출력 양이 달라질 수 있단 뜻입니다.
+.IP ""
+다음 표에 사전 설정 기능을 정리했습니다:
+.RS
+.RS
+.PP
+.TS
+tab(;);
+c c c c c
+n n n n n.
+Preset;DictSize;CompCPU;CompMem;DecMem
+\-0;256 KiB;0;3 MiB;1 MiB
+\-1;1 MiB;1;9 MiB;2 MiB
+\-2;2 MiB;2;17 MiB;3 MiB
+\-3;4 MiB;3;32 MiB;5 MiB
+\-4;4 MiB;4;48 MiB;5 MiB
+\-5;8 MiB;5;94 MiB;9 MiB
+\-6;8 MiB;6;94 MiB;9 MiB
+\-7;16 MiB;6;186 MiB;17 MiB
+\-8;32 MiB;6;370 MiB;33 MiB
+\-9;64 MiB;6;674 MiB;65 MiB
+.TE
+.RE
+.RE
+.IP ""
+컬럼 설명:
+.RS
+.IP \(bu 3
+DictSize는 LZMA2 딕셔너리 크기입니다.  압축 해제 파일의 크기보다 딕셔너리에서 사용하는 낭비 메모리 용량입니다.  실제로
+필요하지 않은 \fB\-7\fP ... \fB\-9\fP 사전 설정값을 피해야 하는 적절한 이유이기도 합니다.  \fB\-6\fP 이하에서는 소모 메모리 양이
+충분히 적거나 따로 신경쓸 필요가 없습니다.
+.IP \(bu 3
+CompCPU는 압축 속도에 영향을 주는 LZMA2 설정의 단순화 표기 값입니다.  딕셔너리 크기는 속도에도 영향을 주기 때문에
+CompCPU는 \fB\-6\fP ... \fB\-9\fP 수준값과 동일한데, 고수준 값은 여전히 조금 더 느려질 수 있습니다.  느려지는 만큼
+압축율은 가능한 한 더 좋아집니다. \fB\-\-extreme\fP을 참고하십시오.
+.IP \(bu 3
+CompMem은 단일\-스레드 모드에서 필요한 압축 프로그램의 메모리 점유 용량입니다.  \fBxz\fP 버전에 따라 다를 수 있습니다.
+.IP \(bu 3
+DecMem은 압축 해제 프로그램의 메모리 점유용량입니다.  이는 곧, 압축 해제 프로그램에서 필요한 메모리 사용량을 압축 설정에서
+결정한다는 의미가 들어있습니다.  정확한 압축 해제 프로그램의 메모리 사용량은 LZMA2 딕셔너리 크기 보다는 조금 많지만 테이블의 값은
+MiB 용량으로 완전히 반올림한 값입니다.
+.RE
+.IP ""
+다중\-스레드 모드에서 필요한 메모리 용량은 단일\-스레드 모드보단 약간 더 많습니다.  \fB\-\-block\-size\fP 기본값에 따라, 각
+스레드에서는 3*3*딕셔녀리_크기 + 압축시_메모리용량 또는 압축_해제시_메모리용량 정도가 필요합니다.  예를 들면, 스레드 넷에 사전
+설정 옵션 \fB\-6\fP을 사용한다면, 660\(en670 MiB 메모리 용량이 필요합니다.
+.TP 
+\fB\-e\fP, \fB\-\-extreme\fP
+기대하는 만큼의 좀 더 나은 압축율을 확보하려 선택한 압축 사전 설정 수준의 느린 변형 옵션을 사용하지만, 재수 없는 와중에 골로 가는
+경우가 생기기도 합니다.  압축 해제 프로그램의 메모리 사용에는 영향을 주지 않지만, 압축 프로그램의 메모리 사용량은 \fB\-0\fP
+\&... \fB\-3\fP 사전 설정 수준에서 약간 더 올라갈 뿐입니다.
+.IP ""
+4MiB와 8MiB 두 가지 딕셔너리 용량 설정이 있기 때문에 \fB\-3e\fP 와 \fB\-5e\fP 사전 설정을 (CompCPU 수치를 낮춰서)
+각각 \fB\-4e\fP 와 \fB\-6e\fP 보다 약간 더 빠르게 설정할 수 있습니다.  이런 식으로 두 사전 설정이 동일하지 않습니다.
+.RS
+.RS
+.PP
+.TS
+tab(;);
+c c c c c
+n n n n n.
+Preset;DictSize;CompCPU;CompMem;DecMem
+\-0e;256 KiB;8;4 MiB;1 MiB
+\-1e;1 MiB;8;13 MiB;2 MiB
+\-2e;2 MiB;8;25 MiB;3 MiB
+\-3e;4 MiB;7;48 MiB;5 MiB
+\-4e;4 MiB;8;48 MiB;5 MiB
+\-5e;8 MiB;7;94 MiB;9 MiB
+\-6e;8 MiB;8;94 MiB;9 MiB
+\-7e;16 MiB;8;186 MiB;17 MiB
+\-8e;32 MiB;8;370 MiB;33 MiB
+\-9e;64 MiB;8;674 MiB;65 MiB
+.TE
+.RE
+.RE
+.IP ""
+예를 들면, 8MiB 딕셔너리를 활용하는 네가지 사전 설정이 있다고 할 때, 빠른 순으로 설정을 나열하자면, \fB\-5\fP, \fB\-6\fP,
+\fB\-5e\fP, \fB\-6e\fP 입니다.
+.TP 
+\fB\-\-fast\fP
+.PD 0
+.TP 
+\fB\-\-best\fP
+.PD
+이 옵션은 \fB\-0\fP 과 \fB\-9\fP의 별칭으로 각각 오해할 수 있습니다. LZMA 유틸리티의 하위 호환성을 목적으로 제공합니다.  이
+옵션 사용은 피하십시오.
+.TP 
+\fB\-\-block\-size=\fP\fI<크기>\fP
+\&\fB.xz\fP 형식으로 압축할 때, 입력 데이터를 \fI<크기>\fP 바이트 블록으로 입력 데이터를 쪼갭니다.  각각의 블록은
+다중\-스레드 방식으로 처리할 수 있고 임의 접근 압축 해제 가능성을 제한할 수 있게 개별적으로 압축 처리합니다.  이 옵션은 보통
+다중\-스레드 모드에서 기본 블록 크기를 지정할 때 사용하지만, 단일\-스레드 모드에서도 사용할 수 있습니다.
+.IP ""
+다중\-스레드 모드에서는 약 3배 용량의 \fI<크기>\fP 바이트만큼 각 스레드 별로 입출력 버퍼링용 공간을 할당합니다.  기본
+\fI<크기>\fP는 LZMA2 딕셔너리 크기 또는 1MiB 중 가장 큰 쪽의 세 배입니다.  보통 적절한 값으로 LZMA2
+딕셔너리 크기 또는 최소한 1MiB 용량의 2\(en4배입니다.  LZMA2 딕셔너리 크기보다 작은 \fI<크기>\fP는 램의
+소모적 사용 공간으로 할당하는데 LZMA2 딕셔너리 버퍼를 할당한 용량 크기 전체를 다 사용하지 않기 때문입니다.  다중\-스레드 모드에서
+블록 크기는 블록 헤더에 저장하며, 이 크기 정보는 다중\-스레드 압축 해제시 필요합니다.
+.IP ""
+단일\-스레드 모드에서는 기본적으로 블록 쪼개기를 하지 않습니다.  이 옵션을 설정한다고 해서 메모리 사용에 영향을 주지는 않습니다.
+블록 헤더에 크기 정보를 저장하지 않기 때문에 단일\-스레드 모드에서 만든 파일은 다중\-스레드 모드에서 만든 파일과 동일하지 않습니다.
+크기 정보의 누락은 또한 \fBxz\fP에서 다중\-스레드 모드로 압축 해제를 진행할 수 없음을 의미하기도 합니다.
+.TP 
+\fB\-\-block\-list=\fP\fI<항목>\fP
+\&\fB.xz\fP 형식으로 압축할 때, 압축하지 않은 데이터로 부터 일정 간격 이후에 새 블록 처리를 시작합니다.
+.IP ""
+\fI<항목>\fP은 쉼표로 구분한 목록으로 지정합니다.  각 항목은 콜론 (\fB:\fP)으로 구분한 0부터 9까지의 추가 필터
+체인 번호 값으로 이루어져 있으며, 압축하지 않은 데이터의 크기 값이 필요합니다.  항목을 생략하면(둘 이상의 쉼표 연속 표기) 이전
+항목의 크기와 필터를 활용하겠다는 함축 의미를 넣을 수 있습니다.
+.IP ""
+입력 파일이 \fI<항목>\fP 크기의 합보다 크면, 마지막 항목을 파일의 끝까지 반복합니다.  특별히 \fB0\fP 값을 마지막
+값으로 사용하여 파일 나머지 부분을 단일 블록으로 인코딩해야 한다는 의미를 나타낼 수도 있습니다.
+.IP ""
+\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션 조합으로
+각 블록별 별도 필터 체인을 지정할 수 있습니다.  이 옵션은 1\(en9번 필터 체인을 지정합니다. 필터 체인 0번은 필터 체인을
+지정하지 않았을 때와 동일한 기본 필터 체인으로 참조할 수 있습니다.  필터 체인 식별 번호는 비 ���축 크기 앞에 콜론(\fB:\fP)을 붙여
+사용할 수 있습니다. 예를 들면, \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP 옵션을
+지정했을 경우 다음 규칙대로 블록을 만듭니다:
+.RS
+.IP \(bu 3
+\fB\-\-filters1\fP 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+\fB\-\-filters3\fP 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을
+.IP \(bu 3
+\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을
+.IP \(bu 3
+기본 필터 체인에서는 2MiB 입력을
+.IP \(bu 3
+입력이 끝나기 전의 모든 블록에는 기본 필터 체인과 4MiB 입력을 적용합니다.
+.RE
+.IP ""
+인코더 블록 크기를 초과하는 크기 값을 지정하면(스레드 모드 기본값 또는 \fB\-\-block\-size=\fP\fI<크기>\fP
+옵션으로 지정한 값), 인코더는 \fI<크기>\fP 지정 용량 범위는 유지하면서 추가 블록을 만듭니다.  예를 들면
+\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP 옵션을 지정하고
+입력 파일을 80MiB 용량으로 전달하면, 각각 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, 1 MiB 용량을
+차지하는 블록 11개를 결과물로 내줍니다.
+.IP ""
+다중\-스레드 모드에서 블록 크기는 블록 헤더에 저장합니다.  단일\-스레드 모드에서는 저장하지 않기 때문에 인코딩 처리한 출력은
+다중\-스레드 모드의 출력 결과물과는 다릅니다.
+.TP 
+\fB\-\-flush\-timeout=\fP\fI<제한시간>\fP
+압축할 때, 이전 데이터를 소거하고 다음 입력을 블록 단위로 더 읽는데 \fI<제한시간>\fP 밀리초(양의 정수값)가 지났을
+경우, 대기중이던 모든 입력 데이터를 인코더에서 소거한 다음 출력 스트림에 전달합니다.  이런 동작은 네트워크로 스트리밍한 데이터를
+\fBxz\fP로 압축할 때 쓸만합니다.  \fI<제한시간>\fP 값을 적게 지정하면 적은 지연 시간에 데이터를 받아낼 수 있지만
+\fI<제한시간>\fP 값을 크게 하면 압축율을 높일 수 있습니다.
+.IP ""
+이 기능은 기본적으로 꺼져있습니다.  이 옵션을 한번 이상 지정하면, 마지막 옵션의 값대로 동작합니다.  특별히
+\fI<제한시간>\fP 값을 \fB0\fP으로 설정하면 이 설정을 완전히 끌 수 있습니다.
+.IP ""
+이 기능은 POSIX 시스템이 아닌 곳에서는 사용할 수 없습니다.
+.IP ""
+.\" FIXME
+\fB이 기능은 여전히 시험중입니다\fP.  현재로서는, \fBxz\fP 버퍼링 처리 방식 때문에 \fBxz\fP의 실시간 스트림 압축 해제 기능 활용은
+적절하지 않습니다.
+.TP 
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP
+압축 수행시 메모리 사용 한계를 지정합니다.  이 옵션을 여러번 지정하면 마지막 값을 취합니다.
+.IP ""
+압축 설정이 \fI<제한용량>\fP을 초과하면, \fBxz\fP는 설정 값의 하향 조정을 시도하여 한계 값을 더이상 넘치지 않게 하고
+자동 조절을 끝냈다는 알림을 표시합니다.  조정은 다음 순서대로 진행합니다. 스레드 수를 줄입니다. 다중\-스레드 모드에서 스레드 하나의
+할당 한계치가 \fI<제한용량>\fP을 넘으면 단일\-스레드 모드로 전환합니다. 그 다음 마지막으로 LZMA2 딕셔너리 크기를
+줄입니다.
+.IP ""
+\fB\-\-format=raw\fP 또는 \fB\-\-no\-adjust\fP 미지정 상황에서 압축할 때, 압축 데이터 출력에 영향을 주지 않고 스레드
+처리 수만 줄일 수 있습니다.
+.IP ""
+\fI<제한용량>\fP 값이 아래 설명한 조건에 맞지 않으면, 오류가 나타나고 \fBxz\fP 명령은 종료 상태 1번을 반환하며
+빠져나갑니다.
+.IP ""
+\fI<제한용량>\fP 값은 여러 방식으로 지정할 수 있습니다:
+.RS
+.IP \(bu 3
+\fI<제한용량>\fP 값은 바이트 용량 절대값입니다.  정수 값을 사용하되 \fBMiB\fP와 같은 접미사를 사용하는게 좋습니다.
+예: \fB\-\-memlimit\-compress=80MiB\fP
+.IP \(bu 3
+\fI<제한용량>\fP 값은 총 물리 메모리(RAM) 용량의 백분율로 지정할 수도 있습니다.  다른 컴퓨터끼리 공유하는 셸
+초기화 스크립트의 \fBXZ_DEFAULTS\fP 환경 변수에 값을 설정할 때 특히 쓸만합니다.  이런 방식으로 설정하면 시스템의 메모리 설치
+용량에 따라 자동으로 늘어납니다.  예: \fB\-\-memlimit\-compress=70%\fP
+.IP \(bu 3
+\fI<제한용량>\fP 값은 \fB0\fP 기본값으로 설정하여 초기화할 수 있습니다.  현재로서는 \fI<제한용량>\fP
+값이 \fImax\fP(최대) (메모리 사용 한계 없음) 인 상태와 동일합니다.
+.RE
+.IP ""
+\fBxz\fP 32비트 버전에서는 몇가지 특별한 경우가 있습니다. \fI<제한용량>\fP 값이 \fB4020MiB\fP를 넘으면
+\fI<제한용량>\fP을 \fB4020MiB\fP로 고정합니다. MIPS32에서는 \fB2000MiB\fP로 대신 고정합니다.
+(\fB0\fP과 \fBmax\fP는 이 경우에 해당하지 않습니다.  압축 해제시 비슷한 기능은 없습니다.)  이 경우 32비트 실행 파일이
+4GiB(MIPS32의 경우 2GiB) 주소 영역에 접근할 때 매우 용이하며, 다른 경우에는 원하는대로 문제를 일으키지 않습니다.
+.IP ""
+\fB메모리 활용\fP 섹션도 참고하십시오.
+.TP 
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP
+압축 해제시 메모리 사용 한계 용량을 설정합니다.  \fB\-\-list\fP 모드에도 영향을 줍니다.  \fI<제한용량>\fP을 넘기지
+않고서는 동작이 진행이 안될 경우, \fBxz\fP 에서는 오류를 나타내고 파일 압축 해제를 실패로
+간주합니다. \fI<제한용량>\fP을 지정하는 가능한 방법에 대해서는
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오.
+.TP 
+\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP
+다중\-스레드 모드 압축 해제시 메모리 사용 한계 용량을 설정합니다.  스레드 수에 영향을 줄 수도 있습니다.  \fBxz\fP에서 파일 압축
+해제를 거부하게 하진 않습니다.  \fI<제한용량>\fP 수치가 다중\-스레드로 처리하기에 너무 낮다면,
+\fI<제한용량>\fP 값을 무시하고 \fBxz\fP 동작을 단일\-스레드 모드로 계속 진행합니다.  참고로
+\fB\-\-memlimit\-decompress\fP 옵션도 사용하면, 단일\-스레드 모드와 다중\-스레드 모드 두 경우에 모두 적용하기에,
+다중\-스레드 모드에 적용할 \fI<제한용량>\fP 값은 \fB\-\-memlimit\-decompress\fP에 설정하는 제한 값보다 더
+크면 안됩니다.
+.IP ""
+다른 메모리 사용 용량 제한 옵션과는 달리, \fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 옵션은
+시스템별 기본 \fI<제한용량>\fP 값을 지닙니다.  현재 설정 값은 \fBxz \-\-info\-memory\fP 명령으로 확인해볼 수
+있습니다.
+.IP ""
+이 옵션과 기본 값은 한계 값을 주지 않으면 스레드 기반 압축 해제 프로그램이 일부 입력 파일에 대해 정신나간 수준의 메모리 용량을
+할당해서 동작이 끝나버릴 수 있습니다.  기본 \fI<제한용량>\fP이 시스템의 사양에 비해 낮다면,
+\fI<제한용량>\fP 값을 자유롭게 올리시되, \fBxz\fP 에서 적은 스레드 수에도 메모리 공간 할당을 시도하는 만큼, 입력
+파일에 적절한 수준으로 가용 RAM 용량을 넘는 큰 값을 설정하지 마십시오. 메모리나 스와핑 영역 공간이 줄어들면 압축해제 성능을
+개선하지 못합니다.
+.IP ""
+\fI<제한용량>\fP 값을 지정하는 가능한 방법을 보려면
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오.  \fI<제한용량>\fP 값을
+\fB0\fP으로 설정하면 \fI<제한용량>\fP 값이 시스템 지정 기본값으로 바뀝니다.
+.TP 
+\fB\-M\fP \fI<제한용량>\fP, \fB\-\-memlimit=\fP\fI<제한용량>\fP, \fB\-\-memory=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP
+\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 지정과 동일합니다.
+.TP 
+\fB\-\-no\-adjust\fP
+압축 출력 결과에 영향을 주는 설정을 조정하지 않고는 메모리 사용 용량 제한 조건이 맞지 않으면 오류를 표시하고 빠져나갑니다.  이
+옵션은 \fBxz\fP가 다중\-스레드 모드에서 단일\-스레드 모드로 전환하고 LZMA2 딕셔너리 크기를 줄이는 동작을 막아줍니다.  심지어 이
+옵션을 사용하면 메모리 사용 한계를 만족하도록 스레드 수를 줄여 압축 결과물 출력에 영향이 가지 않게 합니다.
+.IP ""
+원시 스트림(\fB\-\-format=raw\fP)을 만들 떄 자동 조정은 항상 꺼집니다.
+.TP 
+\fB\-T\fP \fI<스레드수>\fP, \fB\-\-threads=\fP\fI<스레드수>\fP
+활용할 작업 스레드 수를 지정합니다.  \fI<스레드수>\fP 값을 \fB0\fP 값으로 설정하면, \fBxz\fP는 시스템에서 지원하는
+최대 프로세서 스레드 수를 모두 확보합니다. 실제 스레드 수는 입력 파일이 주어진 설정대로 스레드 처리를 할 만큼 그렇게 크지 않을
+경우, 내지는 더 많은 스레드를 사용했을 때 메모리 사용량 한계를 초과할 경우 \fI<스레드수>\fP 보다 적을 수 있습니다.
+.IP ""
+단일\-스레드와 다중\-스레드 압축 프로그램은 다른 출력 결과물을 냅니다.  단일\-스레드 압축 프로그램은 작은 파일 크기 결과물을 내놓지만,
+다중\-스레드 압축 프로그램의 경우 다중\-스레드 압축 프로그램에서 내놓은 결과물은 다중\-스레드로만 압축을 해제할 수 있습니다.
+\fI<스레드수>\fP를 \fB1\fP로 설정하면 단일\-스레드 모드를 사용합니다.  \fI<스레드수>\fP를 \fB0\fP과 다른
+값으로 설정하면, 시스템에서 실제로 하드웨어 스레드가 1개만 지원한다 하더라도, 다중\-스레드 압축 프로그램을 사용합니다.  (\fBxz\fP
+5.2.x에서는 이 경우 단일\-스레드 모드를 활용합니다.)
+.IP ""
+단일\-스레드로 다중\-스레드 모드를 사용하려면, \fI<스레드수>\fP를 \fB+1\fP로 설정하십시오. \fB+\fP 접두사는 \fB1\fP
+이외의 값에는 영향을 주지 않습니다.  메모리 사용량 한계 설정은 \fBxz\fP을 \fB\-\-no\-adjust\fP 옵션을 쓰기 전까지는
+단일\-스레드로 전환하게 합니다.  \fB+\fP 접두사 지원은 \fBxz\fP 5.4.0에 추가했습니다.
+.IP ""
+자동 스레드 수를 요청했고 메모리 사용 한계를 지정하지 않았다면, 시스템에 맞게끔 가능한 스레드 수를 제한하는 기본 소프트 제한 값을
+사용합니다. 스레드 수가 한개가 되면 무시하는 이런 개념이 소프트 제한이기에, \fBxz\fP로 하여금 압축 동작 및 압축 해제 동작 수행시
+멈추지 않습니다.  이 가본 소프트 제한 값은 \fBxz\fP 실행 도중 다중\-스레드 모드에서 단일\-스레드 모드로 바뀌게 하지는 않습니다.
+활성 제한 값은 \fBxz \-\-info\-memory\fP 명령으로 볼 수 있습니다.
+.IP ""
+현재 스레딩 처리 방식은 입력을 블록 단위로 쪼개고 각각의 블록을 독립적으로 압축하는 동작을 취합니다.  기본 블록 크기는 압축 수준에
+따라 다르며 \fB\-\-block\-size=\fP\fI<크기>\fP 옵션으로 재지정할 수 있습니다.
+.IP ""
+스레드 압축 해제 방식은 여러 블록이 블록 헤더에 넣은 크기 정보와 함께 들어간 파일에만 동작합니다.  다중\-스레드 모드에서 압축한
+충분히 큰 모든 파일은 이 조건에 만족하지만, 단일\-스레드 모드에서 압축한 파일은
+\fB\-\-block\-size=\fP\fI<크기>\fP 옵션을 지정하더라도 조건에 만족하지 않습니다.
+.IP ""
+\fI스레드\fP 기본 값은 \fB0\fP입니다.  \fBxz\fP 5.4.x 이전의 기본값은 \fB1\fP입니다.
+.
+.SS "개별 압축 필터 체인 설정"
+개별 필터 체인은 사전 설정에 엮인 설정에 의존하는 대신 압축 설정을 세부적으로 하나하나 설정할 수 있게 합니다.  개별 필터 체인을
+지정하면, 명령행에 앞서 지정한 사전 설정 옵션(\fB\-0\fP \&...\& \fB\-9\fP 과 \fB\-\-extreme\fP)은 무시합니다.  사전
+설정 옵션을 하나 이상의 필터 체인 옵션 다음에 지정하면, 새 사전 설정을 취하며, 앞서 지정한 개별 필터 체인 옵션은 무시합니다.
+.PP
+필터 체인은 명령행 파이핑에 비교할 수 있습니다.  압축할 때, 압축하지 않은 입력을 첫번째 필터로 놓고, 출력 대상(이 있으면)을 다음
+필터로 지정합니다.  최종 필터의 출력은 압축 파일로 기옥합니다.  체인의 최대 필터 수는 4이지만, 필터 체인상 필터 갯수는 보통
+1~2개입니다.
+.PP
+수많은 필터가 필터 체인 상에서 제약점을 가지고 있습니다. 일부 필터는 체인의 마지막 필터로만 동작하며, 일부 다른 필터는 마지막이 아닌
+필터로, 어떤 동작은 체인의 어떤 위치에든 둡니다.  필터에 따라, 이 제한은 필터 설계를 따르거나 보안 문제를 막기 위해 존재하기도
+합니다.
+.PP
+개별 필터 체인은 두가지 방식으로 지정할 수 있습니다.  \fB\-\-filters=\fP\fI<필터>\fP와
+\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션으로
+liblzma 필터 문자열 문법에 따라 한가지 옵션을 필터 체인 전체를 지정할 수 있습니다.  대신, 하나 이상의 개별 필터 옵션을
+원하는 필터 체인 순서대로 지정할 수도 있습니다.  이 말인 즉슨, 개별 필터 옵션의 순서가 중요하단 뜻입니다! 원시 스트림을 디코딩할
+때(\fB\-\-format=raw\fP), 압축했을 때 지정했던 필터와 같은 순서로 필터 체인을 지정해야 합니다.  전체 체인
+옵션(\fB\-\-filters=\fP\fI<필터>\fP) 보다 우선 지정한 개별 필터 또는 사전 설정 옵션은 까먹을 수도 있습니다.
+전체 체인 옵션 다음에 개별 필터를 지정할 경우 필터 체인의 동작을 무효로 합니다.
+.PP
+필터는 쉼표로 구분하는 필터별 \fI<옵션>\fP이 있습니다.  \fI<옵션>\fP에 추가로 입력한 쉼표는
+무시합니다.  모든 옵션 값에는 기본값이 있어, 값을 바꾸려면 지정해야합니다.
+.PP
+전체 필터 체인과 \fI<옵션>\fP을 보려면 \fBxz \-vv\fP (\fB\-\-verbose\fP 두 번)명령을 사용하십시오.  이
+명령은 사전 설정이 사용하는 필터 체인 옵션도 볼 수 있습니다.
+.TP 
+\fB\-\-filters=\fP\fI<필터>\fP
+전체 필터 체인 또는 사전 설정을 단일 옵션으로 지정합니다.  각 필터는 공백 문자 또는 대시 문자 두번 입력(\fB\-\-\fP)으로
+구분합니다.  셸 명령행에서 \fI필터\fP는 따옴표로 감싸서 단일 옵션으로 해석하도록 해야 합니다.  \fI옵션\fP을 표기하려면 \fB:\fP 또는
+\fB=\fP을 활용하십시오.  사전 설정 앞에 \fB\-\fP를 붙일 수 있고 0개 또는 하나 이상의 플래그를 붙일 수 있습니다.  유일하게
+지원하는 플래그는 \fB\-\-extreme\fP과 동일한 \fBe\fP입니다.
+.TP 
+\fB\-\-filters1\fP=\fI<필터>\fP ... \fB\-\-filters9\fP=\fI<필터>\fP
+\fB\-\-block\-list\fP와 사용할 수 있는 추가 필터 체인을 최대 9개까지 지정합니다.
+.IP ""
+예를 들어 텍스트 파일과 실행 파일의 아카이브를 압축할 때 실행 부분에 BCJ 필터 체인을 사용하고 텍스트 부분은 LZMA2 필터를
+사용할 수 있습니다.
+.TP 
+\fB\-\-filters\-help\fP
+\fB\-\-filters\fP와 \fB\-\-filters1=\fP\fI<필터>\fP \&...\&
+\fB\-\-filters9=\fP\fI<필터>\fP 옵션의 사전 설정 필터와 개별 설정 필터 체인을 지정하는 방법을 설명하는 도움말
+메시지를 출력하고 완전히 빠져나갑니다.
+.TP 
+\fB\-\-lzma1\fP[\fB=\fP\fI<옵션>\fP]
+.PD 0
+.TP 
+\fB\-\-lzma2\fP[\fB=\fP\fI<옵션>\fP]
+.PD
+LZMA1 또는 LZMA2 필터를 필터 체인에 추가합니다.  이 필터는 필터 체인의 마지막 요소로만 사용할 수 있습니다.
+.IP ""
+LZMA1은 고전 필터로, LZMA1만 지원하는 고전 \fB.lzma\fP 파일 형식에서만 지원합니다.  LZMA2는 LZMA1의 업데이트
+버전으로 LZMA1의 실질적 문제를 해결했습니다.  \fB.xz\fP 형식은 LZMA2 필터를 사용하며 LZMA1 필터는 전적으로 지원하지
+않습니다.  압축 속도와 압축율은 LZMA1과 LZMA2가 실질적으로 동일합니다.
+.IP ""
+LZMA1과 LZMA2는 동일한 \fI<옵션>\fP 집합을 공유합니다:
+.RS
+.TP 
+\fBpreset=\fP\fI<사전설정>\fP
+LZMA1 또는 LZMA2의 모든 \fI<옵션>\fP을 \fI<사전설정>\fP으로
+초기화합니다. \fI<사전설정>\fP 값은 정수 값으로 이루어져 있으며, 사전 설정에 변형을 줄 떄 단일 문자가 따라올 수도
+있습니다.  정수 값은 \fB0\fP에서 \fB9\fP 까지이며, 명령행 옵션에서 \fB\-0\fP \&...\& \fB\-9\fP로 대응합니다.  변형 옵션으로
+지원하는 문자는 현재 \fBe\fP 뿐이며, \fB\-\-extreme\fP에 대응합니다.  \fI<사전설정>\fP 값을 지정하지 않으면,
+LZMA1 또는 LZMA2 기본값을 사전 설정 \fB6\fP에서 가져온 \fI<옵션>\fP으로 취합니다.
+.TP 
+\fBdict=\fP\fI<크기>\fP
+딕셔너리(기록 버퍼)  \fI<크기>\fP는 최근 처리한 비압축 데이터를 바이트 단위로 메모리에 얼마나 유지하는지 나타냅니다.
+알고리즘은 비압축 데이터상 바이트 시퀀스(일치 항목) 반복 탐색을 시도하며, 해당 부분을 딕셔너리의 현재 참조로 치환합니다. 딕셔너리가
+크면 일치하는 항목을 찾을 기회가 더 많아집니다.  따라서, 딕셔너리 \fI<크기>\fP를 더욱 크게 설정하면 압축율을 증가할
+수는 있지만, 압축하지 않은 파일보다 딕셔너리가 크면 메모리 낭비율이 올라갑니다.
+.IP ""
+보통 딕셔너리 \fI<크기>\fP는 64KiB 에서 64MiB 정도 됩니다. 최소 4KiB 입니다. 압축시 최대 용량은 현재
+1.5GiB(1536MiB)로 나타납니다.  압축 해제 프로그램에도 4GiB 미만으로 딕셔너리 크기를 이미 지원하며 4GiB 라는 수치는
+LZMA1과 LZMA2 스트림 형식의 최대값입니다.
+.IP ""
+딕셔너리 \fI<크기>\fP와 검색기(\fImf\fP)는 LZMA1 또는 LZMA 인코더의 메모리 사용량을 함께 결정합니다.
+동일한(또는 더 큰) 딕셔너리 \fI<크기>\fP가 데이터를 압축했을 때만큼 압축 해제할 떄 필요하기 때문에, 디코더의 메모리
+사용량은 압축할 때의 딕셔너리 크기로 결정합니다.  \fB.xz\fP 헤더에는 딕셔너리 \fI<크기>\fP를 2^\fIn\fP 또는
+2^\fIn\fP + 2^(\fIn\fP\-1) 으로 저장하기에, 이 \fI<크기>\fP 값을 압축할 때 선호하는 편입니다.  다른
+\fI<크기>\fP 값은 \fB.xz\fP 헤더에 저장할 때 반올림합니다.
+.TP 
+\fBlc=\fP\fIlc\fP
+리터럴 컨텍스트 비트 수를 지정합니다.  최소 값은 0이고 최대 값은 4입니다. 기본 값은 3입니다.  추가로, \fIlc\fP 값과
+\fIlp\fP 값의 합은 4를 넘으면 안됩니다.
+.IP ""
+조건이 일치하지 않아 인코딩할 수 없는 모든 바이트는 리터럴로 인코딩합니다.  이 말인 즉슨, 간단히 8비트 바이트로서의 리터럴을 한번에
+하나씩 인코딩합니다.
+.IP ""
+리터럴 코딩을 할 때 이전 비압축 바이트와 다음 바이트와의 관련성을 가진 가장 많은 \fIlc\fP 비트 수를 가정합니다.  예를 들면, 보통
+영문 문장의 경우 대문자 다음에 종종 소문자가 오고, 소문자 다음에 다른 소문자가 따라옵니다. US\-ASCII 문자 세트에서는 가장 긴
+비트 3개는 대문자에 대해 010, 소문자에 대해 011입니다.  \fIlc\fP 값이 최소한 3이면, 리터럴 코딩시 비압축 데이터에 대해
+이런 속성의 장점을 취할 수 있습니다.
+.IP ""
+(어쨌거나) 기본값 (3)은 보통 적절합니다.  최대 압축을 원한다면 \fBlc=4\fP 값을 시험해보십시오.  때로는 약간 도움이 되기도
+하겠지만, 오히려 결��가 안좋을 수도 있습니다.  결과가 엄한 방향으로 간다면, \fBlc=2\fP 값도 시험해보십시오.
+.TP 
+\fBlp=\fP\fIlp\fP
+리터럴 위치 비트 수를 지정하빈다.  최소 값은 0이고 최대 값은 4입니다. 기본 값은 0입니다.
+.IP ""
+\fIlp\fP 값은 리터럴 인코딩 진행시 비압축 데이터 정렬 방식 고려에 영향을 줍니다.  정렬 방식에 대한 자세한 정보는 하단 \fIpb\fP를
+참고하십시오.
+.TP 
+\fBpb=\fP\fIpb\fP
+위치 비트 수를 지정합니다.  최소 값은 0이며 최대 값은 4입니다.  기본값은 2입니다.
+.IP ""
+\fIpb\fP 값은 보통 압축하지 않은 데이터에 어떤 정렬 방식을 고려하느냐에 영향을 줍니다.  기본적으로 4바이트
+정렬(2^\fIpb\fP=2^2=4)을 의미하는데, 이보다 더 나은 추측 값이 없어서 종종 최적의 선택으로 간주합니다.
+.IP ""
+정렬 상태를 알지 못할 경우, \fIpb\fP 설정 값이 파일 크기를 조금 줄일 수 있습니다.  예를 들면, 텍스트 파일이 단일 바이트 단위로
+정돈된 상태(US\-ASCII, ISO\-8859\-*, UTF\-8)라면, \fBpb=0\fP 설정 값으로 압축율을 조금 개선할 수 있습니다.
+UTF\-16 텍스트의 경우, \fBpb=1\fP 설정 값이 좋은 선택입니다.  정렬 바이트가 3 바이트 같은 홀수 바이트일 경우,
+\fBpb=0\fP 설정 값이 최적의 선택일지도 모릅니다.
+.IP ""
+가정 정렬을 \fIpb\fP 값과 \fIlp\fP 값으로 조정하긴 하지만, LZMA1과 LZMA2는 여전히 16바이트 정렬 방식으로 선호합니다.
+LZMA1 또는 LZMA2로 종종 압축하는 파일 형식이라고 하면 고려해볼만 합니다.
+.TP 
+\fBmf=\fP\fImf\fP
+일치 검색기는 인코더 속도, 메모리 사용량, 압축율에 주된 영향을 줍니다.  보통 해시 체인 검색기는 이진 트리 검색기보다 빠르긴
+합니다.  기본 값은 \fI<사전설정>\fP에 따라 다릅니다. 0은 \fBhc3\fP을, 1\(en3은 \fBhc4\fP를, 나머지는
+\fBbt4\fP를 활용합니다.
+.IP ""
+다음 검색 필터를 지원합니다.  메모리 사용 공식은 \fIdict\fP 값이 2의 승수일 경우 실제에 가까운 근사치입니다.
+.RS
+.TP 
+\fBhc3\fP
+2바이트, 3바이트 해싱 체인
+.br
+\fInice\fP 최소값: 3
+.br
+메모리 사용:
+.br
+\fIdict\fP * 7.5 (조건: \fIdict\fP <= 16 MiB);
+.br
+\fIdict\fP * 5.5 + 64 MiB (조건: \fIdict\fP > 16 MiB)
+.TP 
+\fBhc4\fP
+2바이트, 3바이트, 4바이트 해싱 체인
+.br
+\fInice\fP 최소값: 4
+.br
+메모리 사용:
+.br
+\fIdict\fP * 7.5 (조건: \fIdict\fP <= 32 MiB);
+.br
+\fIdict\fP * 6.5 (조건: \fIdict\fP > 32 MiB)
+.TP 
+\fBbt2\fP
+2바이트 해싱 이진 트리
+.br
+\fInice\fP 최소값: 2
+.br
+메모리 사용: \fIdict\fP * 9.5
+.TP 
+\fBbt3\fP
+2바이트, 3바이트 해싱 이진트리
+.br
+\fInice\fP 최소값: 3
+.br
+메모리 사용:
+.br
+\fIdict\fP * 11.5 (조건: \fIdict\fP <= 16 MiB);
+.br
+\fIdict\fP * 9.5 + 64 MiB (조건: \fIdict\fP > 16 MiB)
+.TP 
+\fBbt4\fP
+2바이트, 3바이트, 4바이트 해싱 이진 트리
+.br
+\fInice\fP 최소값: 4
+.br
+메모리 사용:
+.br
+\fIdict\fP * 11.5 (조건: \fIdict\fP <= 32 MiB);
+.br
+\fIdict\fP * 10.5 (조건: \fIdict\fP > 32 MiB)
+.RE
+.TP 
+\fBmode=\fP\fI<모드>\fP
+압축 \fI<모드>\fP 값은 일치 검색기에서 생산하는 데이터 분석 방식을 지정합니다.  지원하는 \fI<모드>\fP는
+\fBfast\fP와 \fBnormal\fP 입니다. 기본값은 \fI<사전설정>\fP값 0\(en3에 대해 \fBfast\fP,
+\fI<사전설정>\fP값 4\(en9에 대해 \fBnormal\fP입니다.
+.IP ""
+보통 \fBfast\fP는 해시 체인 검색기에서 사용하며 \fBnormal\fP은 이진 트리 검색기에서 사용합니다.  이 동작은 또한
+\fI<사전설정>\fP 값이 할 일이기도 합니다.
+.TP 
+\fBnice=\fP\fInice\fP
+일치하는 nice 길이를 지정합니다.  최소한 \fInice\fP 바이트 정도 일치하면, 알고리즘이 가능한 최선의 부분을 찾는 동작을
+멈춥니다.
+.IP ""
+\fInice\fP 값은 2\(en273 바이트입니다.  값이 클 수록 속도 면에서는 손해를 보겠지만 압축율은 더욱 올라갑니다.  기본 값은
+\fI<사전설정>\fP값에 따라 다릅니다.
+.TP 
+\fBdepth=\fP\fI<깊이>\fP
+일치 검색기에서의 최대 검색 깊이를 지정합니다.  기본값은 특별한 값 0으로 지정하며, 이 값으로 압축 프로그램이 \fImf\fP 와
+\fInice\fP간 적절한 \fI<깊이>\fP 값을 결정합니다.
+.IP ""
+적절한 해시 체인 \fI<깊이>\fP 값은 이진 트리에서 4\(en100 그리고 16\(en1000 입니다. 상당히 큰 값을
+\fI<깊이>\fP 값으로 사용하면 일부 파일에 대해 인코더가 매우 느리게 동작할 수가 있습니다.  압축 시간이 너무 오래걸려서
+동작을 중간에 끊을 준비가 되지 않은 이상 \fI<깊이>\fP 설정 값은 1000을 넘지 않게하십시오.
+.RE
+.IP ""
+원시 스트림(\fB\-\-format=raw\fP)을 디코딩할 때, LZMA2는 딕셔너리 \fI<크기>\fP만 필요합니다.  LZMA1는
+\fIlc\fP, \fIlp\fP, \fIpb\fP 값이 모두 필요합니다.
+.TP 
+\fB\-\-x86\fP[\fB=\fP\fI<옵션>\fP]
+.PD 0
+.TP 
+\fB\-\-arm\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-armthumb\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-arm64\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-powerpc\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-ia64\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-sparc\fP[\fB=\fP\fI<옵션>\fP]
+.TP 
+\fB\-\-riscv\fP[\fB=\fP\fI<옵션>\fP]
+.PD
+브랜치/호출/점프(BCJ) 필터를 필터 체인에 추가합니다.  이 필터는 필터 체인의 비종결 필터로만 사용할 수 있습니다.
+.IP ""
+BCJ 필터는 머신 코드의 상대 주소를 절대 주소로 변환합니다.  데이터 크기를 바꾸지는 않지만 LZMA2에서 \fB.xz\fP 파일을
+0\(en15% 정도 줄여주게 하는 중복성이 늘어납니다.  BCJ 필터는 언제든 뒤집을 수 있어, 데이터에 적절하지 않은 BCJ 필터
+형식을 활용하면, 그냥 가만히 두면 압축율이 약간 떨어지게 한다 하더라도, 데이터를 잃을 수가 있습니다.  BCJ 필터는 굉장히 빠르며
+메모리 공간을 적게 활용합니다.
+.IP ""
+이 BCJ 필터에는 압축율 관련 몇가지 문제가 있습니다:
+.RS
+.IP \(bu 3
+실행 코드가 들어있는 몇가지 파일 형식(예: 목적 파일, 정적 라이브러리, 리눅스 커널 모듈)의 경우 필터 값으로 채운 명령 주소가
+있습니다.  여기 BCJ 필터의 경우 파일의 압축율을 떨어뜨리는 주소 변환을 수행합니다.
+.IP \(bu 3
+BCJ 필터를 아카이브에 적용하면, BCJ 필터를 사용하지 않았을 때보다 압축율이 떨어질 수가 있습니다.  예를 들면, 유사하거나 동일한
+실행 파일 여럿이 있으면 필터를 사용하여 파일을 덜 비슷하게 만들어 압축율이 떨어지게 합니다.  동일한 아카이브 파일에서 비 실행 파일의
+내용에 대해서도 비슷한 일이 벌어질 수 있습니다.  실제로 하나는 BCJ 필터를 걸고 하나는 제외하여 각 경우에 대해 어떤 경우가 결과가
+우수한 지 살펴보겠습니다.
+.RE
+.IP ""
+다른 명령 세트는 다른 정렬 상태에 놓여있습니다.  실행 파일은 필터가 제대로 동작하게 하려면 입력 데이터에 있는 이 값의 배수로
+정돈해야합니다.
+.RS
+.RS
+.PP
+.TS
+tab(;);
+l n l
+l n l.
+필터;정렬;참고
+x86;1;32\-bit 또는 64\-bit x86
+ARM;4;
+ARM\-Thumb;2;
+ARM64;4;4096 바이트 정렬이 가장 좋습니다
+PowerPC;4;빅엔디안 전용
+IA\-64;16;Itanium
+SPARC;4;
+RISC\-V;2;
+.TE
+.RE
+.RE
+.IP ""
+BCJ 필터를 사용한 데이터는 LZMA2로 보통 압축하기 때문에 LZMA2 옵션을 선택한 BCJ 필터의 정렬기준에 맞추도록 설정하면
+압축율을 좀 더 개선할 수 있습니다.  예를 들면:
+.RS
+.IP \(bu 3
+IA\-64 필터는 16\-바이트 정렬 방식으로 동작하기에 LZMA2 필터에 \fBpb=4,lp=4,lc=0\fP 옵션(2^4=16)을 주는게
+좋습니다.
+.IP \(bu 3
+RISC\-V 코드에는 16\-비트 압축 명령(C 확장) 적재 여부에 따라 2\-바이트 또는 4\-바이트 정렬 방식을 채택합니다. 16\-비트
+명령을 사용하면, \fBpb=2,lp=1,lc=3\fP 또는 \fBpb=1,lp=1,lc=3\fP 옵션 값 사용이 바람직합니다. 16\-비트 명령이
+없다면, \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다.  "RVC"가 "Flags"행에 나타나는지 확인할 때
+\fBreadelf \-h\fP 명령을 사용할 수 있습니다.
+.IP \(bu 3
+ARM64는 항상 4\-바이트 정렬 방식을 택하기에 \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다.
+.IP \(bu 3
+x86 필터는 예외입니다.  x86 실행 파일을 압축할 경우에는 보통 LZMA2 기본 옵션 값(\fBpb=2,lp=0,lc=3\fP)을 그대로
+사용하는게 좋습니다.
+.RE
+.IP ""
+모든 BCJ 필터는 동일한 \fI옵션\fP을 지원합니다:
+.RS
+.TP 
+\fBstart=\fP\fI<오프셋>\fP
+상대 주소와 절대 주소를 변환할 때 사용할 시작 \fI<오프셋>\fP을 지정합니다.  \fI<오프셋>\fP에는 필터
+정렬 배수여야 합니다(상단 테이블 참조).  기본값은 0입니다.  실제로 기본값이 낫습니다. 개별 \fI<오프셋>\fP 지정
+값은 거의 쓸모가 없습니다.
+.RE
+.TP 
+\fB\-\-delta\fP[\fB=\fP\fI<옵션>\fP]
+필터 체인에 델타 필터를 추가합니다.  델타 필터는 필터 체인에서 마지막에 지정하지 않은 필터로만 사용할 수 있습니다.
+.IP ""
+현재로서는 바이트 단위 단순 델타계산 결과만 보여줍니다.  예를 들면, 압축하지 않은 비트맵 그림 또는 압축하지 않은 PCM 오디오를
+압축할 때 쓸만합니다.  그러나 특별한 목적으로 활용하는 알고리즘은 델타 + LZMA2 보다 더 나은 결과를 가져다 주기도 합니다.
+이는 특히 오디오의 경우 맞는 이야기인데, \fBflac\fP(1)의 경우 더 빠르고 우수한 압축율을 보여줍니다.
+.IP ""
+지원 \fI옵션\fP:
+.RS
+.TP 
+\fBdist=\fP\fI<차이>\fP
+바이트 단위 델터 계산 \fI<차이>\fP를 지정합니다.  \fI<차이>\fP값은 1\(en256 이어야합니다.  기본
+값은 1입니다.
+.IP ""
+예를 들어, \fBdist=2\fP 옵션과 A1 B1 A2 B3 A3 B5 A4 B7 입력 값을 주면, 출력 값은 A1 B1 01 02 01
+02 01 02 입니다.
+.RE
+.
+.SS "기타 옵션"
+.TP 
+\fB\-q\fP, \fB\-\-quiet\fP
+경고 및 알림을 끕니다.  두 번 지정하면 오류 메시지 표시도 끕니다.  이 옵션은 종료 상태에 영향을 주지 않습니다.  경고 표시를
+끄더라도, 종료 상태에서는 여전히 경고가 나타났음을 알려줍니다.
+.TP 
+\fB\-v\fP, \fB\-\-verbose\fP
+출력 내용이 많아집니다.  표준 오류를 터미널에 연결했다면 \fBxz\fP는 진행 표시를 나타냅니다.  \fB\-\-verbose\fP를 두번 지정하면
+더 많은 내용을 표시합니다.
+.IP ""
+진행 표시에서는 다음 정보를 나타냅니다:
+.RS
+.IP \(bu 3
+입력 파일의 크기를 알고 있을 경우 완료 백분율.  파이프 처리시에는 백분율을 나타낼 수 없습니다.
+.IP \(bu 3
+산출 압축 데이터 용량 (압축) 또는 소모 공간 용량 (압축 해제).
+.IP \(bu 3
+비압축 데이터 소모 용량 (압축) 또는 산출 용량 (압축 해제).
+.IP \(bu 3
+압축 데이터 산출 용량을 비압축 데이터 처리 용량으로 나누어 계산한 압축율.
+.IP \(bu 3
+압축 또는 압축 해제 속도.  초당 비압축 데이터 소모량(압축) 또는 산출 용량(압축 해제)를 측정한 값입니다.  \fBxz\fP에서 파일
+처리를 시작한 몇 초 후 나타납니다.
+.IP \(bu 3
+경과 시간 형식은 M:SS 또는 H:MM:SS 입니다.
+.IP \(bu 3
+추산 여분 시간은 \fBxz\fP가 파일을 처리하기 시작한 이후 입력 파일의 크기를 알고 몇 초가 지난 후에야 보여줍니다.  시간은 콜론
+문자를 사용하지 않고 덜 자세한 형식으로, 예를 들면, 2분 30초 와 같은 형식으로 보여줍니다.
+.RE
+.IP ""
+표준 오류가 터미널이 아니라면 \fB\-\-verbose\fP는 \fBxz\fP에서 파일 이름, 압축 크기, 압축 해제 용량, 압축율, 그리고
+가능하다면 파일을 압축 또는 압축 해제한 후 표준 오류로 속도와 걸린 시간을 나타내도록 합니다.  속도와 걸린 시간 정보는 동작을
+처리하는데 최소한 몇초 정도 소요했을 경우에만 들어갑니다.  동작이 끝나지 않았다면, 이를테면 사용자의 중단 요청이 있었을 경우 입력
+파일의 크기를 알고 있을 때 압축 백분율 정보도 들어갑니다.
+.TP 
+\fB\-Q\fP, \fB\-\-no\-warn\fP
+경고로 알릴 만한 상황을 만났다 하더라도 종료 상태 2번을 설정하지 않습니다.  이 옵션은 출력 수준에 영향을 주지 않기 때문에,
+\fB\-\-quiet\fP 옵션과 \fB\-\-no\-warn\fP 옵션을 경고 표시를 막고 종료 상태를 바꾸지 않을 목적으로 사용합니다.
+.TP 
+\fB\-\-robot\fP
+머신에서 해석할 형식으로 메시지를 나타냅니다.  liblzma 대신 \fBxz\fP를 활용하려는 다양상 스크립트로서의 프론트엔드를 쉽게
+작성하도록 하기 위함입니다.  이 옵션을 지정한 출력은 \fBxz\fP 릴리스가 어떻게 되든 안정 버전이란 의미입니다.  자세한 내용은
+\fB로봇 모드\fP 섹션을 참고하십시오.
+.TP 
+\fB\-\-info\-memory\fP
+압축 및 압축 해제시 물리 메모리 용량 (RAM), \fBxz\fP에서 파악하는 프로세서 스레드 갯수, 메모리 사용량 한계를 파악하기 쉬운
+형식으로 나타내고 무사히 나갑니다.
+.TP 
+\fB\-h\fP, \fB\-\-help\fP
+보통 사용하는 옵션을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다.
+.TP 
+\fB\-H\fP, \fB\-\-long\-help\fP
+\fBxz\fP의 모든 기능을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다
+.TP 
+\fB\-V\fP, \fB\-\-version\fP
+\fBxz\fP와 liblzma 버전 번호를 가독 형식으로 출력합니다.  기계 해석 가능 형식을 가져오려면 \fB\-\-version\fP 앞에
+\fB\-\-robot\fP을 지정하십시오.
+.
+.SH "로봇 모드"
+로봇 모드는 \fB\-\-robot\fP 옵션으로 동작합니다.  \fBxz\fP 출력을 다른 프로그램에서 해석하기 쉽게 해줍니다.  현재로서는
+\fB\-\-robot\fP 옵션은  \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, \fB\-\-version\fP
+옵션하고만 사용할 수 있습니다.  앞으로는 압축 및 압축 해제 동작에 대해서도 지원합니다.
+.
+.SS "목록 모드"
+\fBxz \-\-robot \-\-list\fP 명령은 탭으로 구분한 출력 형태를 활용합니다.  모든 행의 첫번째 컬럼에는 해당 행에서 찾을 수
+있는 정보의 형식을 나타냅니다:
+.TP 
+\fB이름\fP
+이 행은 항상 파일 목록 시작 부분의 첫번째 줄에 있습니다.  이 행의 두번째 컬럼에 파일 이름이 들어있습니다.
+.TP 
+\fB파일\fP
+이 행에는 \fB.xz\fP 파일의 전반적인 정보가 들어있습니다.  이 행은 항상 \fB이름\fP 행 다음에 있습니다.
+.TP 
+\fB스트림\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 ��만 사용합니다.  \fB.xz\fP 파일의 \fB스트림\fP 행 수만큼 나타납니다.
+.TP 
+\fB블록\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다.  \fB.xz\fP 파일의 블록 수만큼 \fB블록\fP 행이 나타납니다.
+\fB블록\fP 행은 모든 \fB스트림\fP 행 다음에 나타납니다. 다른 형식의 행이 끼어들지는 않습니다.
+.TP 
+\fB요약\fP
+이 행 형식은 \fB\-\-verbose\fP 옵션을 두번 지정했을 때만 사용합니다.  이 행은 모든 \fB블록\fP 행 다음에 출력합니다.
+\fB파일\fP 행과 비슷하게, \fB요약\fP 행에는 \fB.xz\fP 파일의 전반적인 정보가 담겨있습니다.
+.TP 
+\fB총계\fP
+이 행은 목록 출력의 가장 마지막에 항상 나타납니다.  총 갯수와 크기를 나타냅니다.
+.PP
+\fB파일\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+파일 스트림 갯수
+.IP 3. 4
+스트림의 블록 총 갯수
+.IP 4. 4
+파일 압축 크기
+.IP 5. 4
+파일 압축 해제 크기
+.IP 6. 4
+예를 들면, \fB0.123\fP과 같은 압축율 입니다.  비율이 9.999라면, 대시 문자 3개 (\fB\-\-\-\fP)를 비율 값 대신 나타냅니다.
+.IP 7. 4
+쉼표로 구분한 무결성 검사 이름 목록입니다.  \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP, \fBSHA\-256\fP 문자열을 알려진
+검사 형식으로 사용합니다.  알 수 없는 검사 형식에 대해서는 \fBUnknown\-\fP\fIN\fP을 사용하며, 여기서 \fIN\fP은 (한 두자리)
+정수형 숫자값으로 이루어진 검사 ID 입니다.
+.IP 8. 4
+파일의 스트림 패딩 총 길이
+.RE
+.PD
+.PP
+\fB스트림\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+스트림 번호 (첫 스트림은 1번)
+.IP 3. 4
+스트림의 블록 총 갯수
+.IP 4. 4
+압축 시작 오프셋
+.IP 5. 4
+비압축 시작 오프셋
+.IP 6. 4
+압축 크기 (스트림 패딩 미포함)
+.IP 7. 4
+압축 해제 용량
+.IP 8. 4
+압축율
+.IP 9. 4
+무결성 검사 이름
+.IP 10. 4
+스트림 패딩 길이
+.RE
+.PD
+.PP
+\fB블록\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+이 블록이 들어간 스트림 갯수
+.IP 3. 4
+스트림 시작 부분의 블록 번호 (첫번째 블록은 1번)
+.IP 4. 4
+파일 시작 부분의 블록 번호
+.IP 5. 4
+파일 시작 부분의 압축 시작 오프셋
+.IP 6. 4
+파일 시작 부분의 비압축 시작 오프셋
+.IP 7. 4
+총 블록 압축 크기 (헤더 포함)
+.IP 8. 4
+압축 해제 용량
+.IP 9. 4
+압축율
+.IP 10. 4
+무결성 검사 이름
+.RE
+.PD
+.PP
+\fB\-\-verbose\fP를 두 번 지정하면, 추가 컬럼을 \fB블록\fP 행에 넣습니다.  \fB\-\-verbose\fP 단일 지정시에는 이 정보를 볼
+때 탐색을 여러번 수행해야 하기 때문에 실행 과정이 느려질 수 있어서 나타내지 않습니다:
+.PD 0
+.RS
+.IP 11. 4
+16진수 무결성 검사값
+.IP 12. 4
+블록 헤더 크기
+.IP 13. 4
+블록 플래그: \fBc\fP는 압축 크기가 현재 값임을 나타내고, \fBu\fP는 압축 전 원본 크기가 현재 값임을 나타냅니다.  플래그를 설정하지
+않았다면, 문자열 길이를 유지할 목적으로 대시 \fB\-\fP 를 대신 나타냅니다.  새 플래그는 나중에 문자열 끝 부분에 추가할 예정입니다.
+.IP 14. 4
+블록에 압축 해서 넣은 데이터의 실제 츠기 (블록 헤더, 블록 패딩, 검사 필드 제외)
+.IP 15. 4
+이 \fBxz\fP 버전에서 이 블록의 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량
+.IP 16. 4
+필터 체인.  대부분 사용하는 옵션은 압축 해제시 필요한 옵션만을 \fB.xz\fP 헤더에 저장하기 때문에 압축 시간에 알 수 없습니다.
+.RE
+.PD
+.PP
+\fB요약\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+이 \fBxz\fP 버전에서 이 파일 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량
+.IP 3. 4
+모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값
+.PP
+\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP
+.IP 4. 4
+파일 압축 해제시 필요한 최소 \fBxz\fP 버전
+.RE
+.PD
+.PP
+\fB총계\fP 행 컬럼:
+.PD 0
+.RS
+.IP 2. 4
+스트림 갯수
+.IP 3. 4
+블록 갯수
+.IP 4. 4
+압축 크기
+.IP 5. 4
+압축 해제 용량
+.IP 6. 4
+평균 압축율
+.IP 7. 4
+파일에 들어 있어 쉼표로 구분한 무결성 검사 이름 목록
+.IP 8. 4
+스트림 패딩 길이
+.IP 9. 4
+파일 갯수.  \fB파일\fP 행의 컬럼 순서를 따라갑니다.
+.PD
+.RE
+.PP
+\fB\-\-verbose\fP 옵션을 두 번 지정하면, \fB총계\fP 행에 추가 컬럼이 들어갑니다:
+.PD 0
+.RS
+.IP 10. 4
+이 \fBxz\fP 버전에서 파일 압축을 해제할 떄 필요한 (바이트 단위) 최대 메모리 사용량
+.IP 11. 4
+모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값
+.PP
+\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP
+.IP 12. 4
+파일 압축 해제시 필요한 최소 \fBxz\fP 버전
+.RE
+.PD
+.PP
+차후 버전에서는 새 행 형식을 추가하고 기존 행 형식에 추가할 수 있는 새 컬럼을 넣기 까지는 알 수 있겠지만, 기존 컬럼은 바꾸지 않을
+예정입니다.
+.
+.SS "필터 도움말"
+\fBxz \-\-robot \-\-filters\-help\fP 는 다음 형식의 지원 필터 목록을 출력합니다:
+.PP
+\fI<필터>\fP\fB:\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>,\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>\fP...
+.TP 
+\fI<필터>\fP
+필터 이름
+.TP 
+\fI<옵션>\fP
+필터별 옵션 이름
+.TP 
+\fI<값>\fP
+숫자 \fI값\fP 범위는 \fB<\fP\fI최소\fP\fB\-\fP\fI최대\fP\fB>\fP입니다.  문자열 \fI값\fP은 \fB< >\fP 범위
+내에서 선택하며 \fB|\fP 문자로 구분합니다.
+.PP
+각 필터는 한 줄에 하나씩 출력합니다.
+.
+.SS "메모리 제한 정보"
+\fBxz \-\-robot \-\-info\-memory\fP 명령은 탭으로 나뉜 여러 컬럼을 단일 행으로 나타냅니다:
+.IP 1. 4
+물리 메모리(RAM)의 바이트 단위 총량.
+.IP 2. 4
+압축 진행시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-compress\fP).  특수 값 \fB0\fP은 단일\-스레드 모드에서
+제한을 두지 않는 기본 설정임을 나타냅니다.
+.IP 3. 4
+압축 해제시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-decompress\fP).  특수 값 \fB0\fP은 단일\-스레드 모드에서
+제한을 두지 않는 기본 설정임을 나타냅니다.
+.IP 4. 4
+\fBxz\fP 5.3.4alpha 이후: 다중\-스레드 기반 압축 해제시 바이트 단위 메모리
+사용량(\fB\-\-memlimit\-mt\-decompress\fP).  분명하게 제한을 걸어두지 않았을 경우 5번째 컬럼에 나타난 시스템별
+기본값을 사용하기 때문에 0 값을 지정하면 안됩니다.  또한 \fB\-\-memlimit\-mt\-decompress\fP로 세번째 컬럼 값보다 더
+크게 지정을 한다 할지라도 이 값이 세번째 컬럼 값보다 크면 안됩니다.
+.IP 5. 4
+\fBxz\fP 5.3.4alpha 이후: A system\-specific default memory usage limit that is
+used to limit the number of threads when compressing with an automatic
+number of threads (\fB\-\-threads=0\fP)  and no memory usage limit has been
+specified (\fB\-\-memlimit\-compress\fP).  This is also used as the default value
+for \fB\-\-memlimit\-mt\-decompress\fP.
+.IP 6. 4
+\fBxz\fP 5.3.4alpha 이후: Number of available processor threads.
+.PP
+차후, \fBxz \-\-robot \-\-info\-memory\fP 출력에는 더 많은 내용이 들어가지만, 한 줄 이상은 넘어가지 않습니다.
+.
+.SS 버전
+\fBxz \-\-robot \-\-version\fP 은 \fBxz\fP 와 liblzma의 버전 번호를 다음 형식으로 나타냅니다:
+.PP
+\fBXZ_VERSION=\fP\fIXYYYZZZS\fP
+.br
+\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP
+.TP 
+\fIX\fP
+주 버전.
+.TP 
+\fIYYY\fP
+부 버전.  짝수가 안정 버전입니다.  홀수는 알파 또는 베타 버전입니다.
+.TP 
+\fIZZZ\fP
+안정 릴리스의 패치 수준 또는 개발 릴리스의 횟수입니다.
+.TP 
+\fIS\fP
+안정도.  0은 알파 버전, 1은 베타 버전을 나타내며, 2는 안정 버전을 나타냅니다.  \fIS\fP는 \fIYYY\fP 값이 짝수라 해도 항상
+2여야 합니다.
+.PP
+\fBxz\fP 명령과 liblzma이 동일한 XZ 유틸리티 릴리스에서 나왔다면 두 행의 \fIXYYYZZZS\fP 값은 같습니다.
+.PP
+예제: 4.999.9beta는 \fB49990091\fP이며, 5.0.0은 \fB50000002\fP입니다.
+.
+.SH "종료 상태"
+.TP 
+\fB0\fP
+모든 상태 양호.
+.TP 
+\fB1\fP
+오류 발생.
+.TP 
+\fB2\fP
+눈여겨볼 경고가 나타났지만, 실제 오류는 일어나지 않음.
+.PP
+표준 오류에 출력하는 알림(경고 또는 오류 아님)는 종료 상태에 영향을 주지 않습니다.
+.
+.SH 환경
+\fBxz\fP는 빈칸으로 구분한 옵션 값 목록을 \fBXZ_DEFAULTS\fP, \fBXZ_OPT\fP 환경 변수에서 순서대로, 명령행에서 옵션을
+해석하기 전에 불러옵니다.  참고로 환경 변수에서 옵션만 해석하며, 옵션이 아닌 부분은 조용히 무시합니다.  해석은
+\fBgetopt_long\fP(3)으로 가능하며,  명령행 인자로 활용하기도 합니다.
+.TP 
+\fBXZ_DEFAULTS\fP
+사용자별, 시스템 범위 기본 옵션입니다.  보통 \fBxz\fP의 메모리 사용량 제한을 기본으로 걸어둘 경우 셸 초기화 스크립트에
+설정합니다.  셸 초기화 스크립트와 별도의 유사한 경우를 제외하고라면, 스크립트에서는 \fBXZ_DEFAULTS\fP 환경 변수를 설정하지
+말거나 설정을 해제해야합니다.
+.TP 
+\fBXZ_OPT\fP
+\fBxz\fP 명령행으로 옵션 설정 값을 직접 전달할 수 없을 경우 \fBxz\fP에 옵션을 전달하는 환경 변수입니다.  예를 들어, \fBxz\fP를
+스크립트 또는 도구에서 실행할 경우 GNU \fBtar\fP(1) 라면:
+.RS
+.RS
+.PP
+.nf
+\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR
+.fi
+.RE
+.RE
+.IP ""
+예를 들면, 스크립트에서 \fBXZ_OPT\fP 를 활용하여, 스크립트별로 기본 압축 옵션을 지정할 수 있습니다.  적절한 이유가 있다면
+\fBXZ_OPT\fP 옵션 값을 사용자가 바꾸는걸 추천합니다.  예를 들면, \fBsh\fP(1)  스크립트에서 다음처럼 활용할 수도 있습니다:
+.RS
+.RS
+.PP
+.nf
+\f(CRXZ_OPT=${XZ_OPT\-"\-7e"}
+export XZ_OPT\fR
+.fi
+.RE
+.RE
+.
+.SH "LZMA 유틸리티 호환성"
+\fBxz\fP의 명령행 문법은 실제로 LZMA 유틸리티 4.32.x에서 찾을 수 있는 \fBlzma\fP, \fBunlzma\fP \fBlzcat\fP의
+상위 집합입니다.  대부분의 경우 LZMA 유틸리티를 XZ 유틸리티로 기존에 작성한 스크립트를 깨지 않고도 바꿀 수 있습니다.  몇가지
+비호환성 문제 때문에 문제가 일어날 수는 있습니다.
+.
+.SS "압축 사전 설정 단계"
+압축 수준 사전 설정의 번호 부여 방식은 \fBxz\fP와 LZMA 유틸리티가 동일하지 않습니다.  가장 중요한 차이는 다른 사전 설정에 대해
+딕셔너리 크기를 어떻게 대응했느냐 여부입니다.  딕셔너리 크기는 압축 해제시 메모리 사용량과 거의 비슷합니다.
+.RS
+.PP
+.TS
+tab(;);
+c c c
+c n n.
+단계;xz;LZMA 유틸리티
+\-0;256 KiB;없음
+\-1;1 MiB;64 KiB
+\-2;2 MiB;1 MiB
+\-3;4 MiB;512 KiB
+\-4;4 MiB;1 MiB
+\-5;8 MiB;2 MiB
+\-6;8 MiB;4 MiB
+\-7;16 MiB;8 MiB
+\-8;32 MiB;16 MiB
+\-9;64 MiB;32 MiB
+.TE
+.RE
+.PP
+딕셔너리 크기 차이는 압축 프로그램 메모리 사용에 영향을 주지만, LZMA 유틸리티와 XZ 유틸리티에서 사용량이 늘어나는 다른 차이점이
+있습니다:
+.RS
+.PP
+.TS
+tab(;);
+c c c
+c n n.
+단계;xz;LZMA 유틸리티 4.32.x
+\-0;3 MiB;없음
+\-1;9 MiB;2 MiB
+\-2;17 MiB;12 MiB
+\-3;32 MiB;12 MiB
+\-4;48 MiB;16 MiB
+\-5;94 MiB;26 MiB
+\-6;94 MiB;45 MiB
+\-7;186 MiB;83 MiB
+\-8;370 MiB;159 MiB
+\-9;674 MiB;311 MiB
+.TE
+.RE
+.PP
+XZ 유틸리티의 기본 사전 설정 수준값은 \fB\-6\fP이지만 LZMA 유틸리티의 기본 사전 설정 수준값은 \fB\-7\fP입니다. 두 프로그램의
+딕셔너리 메모리 기본 사용량은 8MiB입니다.
+.
+.SS "스트림 vs 비스트림 .lzma 파일"
+파일을 압축하지 않은 크기는 \fB.lzma\fP 헤더에 저장합니다.  LZMA 유틸리티는 일반 파일을 압축할 때 압축하지 않은 파일의 크기를
+저장합니다.  이 대신 압축하지 않은 크기를 '알 수 없음' 으로 저장하고 압축 해제 프로그램이 멈춰야 할 지점에
+end\-of\-payload 마커를 사용하는 방법도 있습니다.  LZMA 유틸리티는 파이프로 들어온 입력과 같이 압축하지 않은 파일의
+크기를 알 수 없을 때 이런 방식을 활용합니다.
+.PP
+\fBxz\fP는 \fB.lzma\fP 파일을 end\-of\-payload 마커의 유무와 관계없이 압축 해제 방식을 모두 지원하지만, \fBxz\fP로
+만든 모든 \fB.lzma\fP 파일은 end\-of\-payload 마커를 사용하며, \fB.lzma\fP 헤더에 압축하지 않은 파일 크기를 '알 수
+없음'으로 표기합니다. 이 방식은 드문 상황에서 문제를 야기할 수 있습니다.  예를 들면, 임베디드 장치의 \fB.lzma\fP 압축 해제
+프로그램은 압축을 해제했을 때 크기를 알아야 동작합니다.  이 문제를 만나면, LZMA 유틸리티 또는 LZMA SDK를 활용하여
+\&\fB.lzma\fP 파일에 압축 전 파일 크기 정보를 저장해야합니다.
+.
+.SS "지원하지 않는 .lzma 파일"
+\&\fB.lzma\fP 형식은 \fIlc\fP 값을 8까지 받아들이며, \fIlp\fP 값은 4까지 받아들입니다. LZMA 유틸리티는 어떤 \fIlc\fP 값과
+\fIlp\fP 값을 받아들이고도 압축을 해제할 수 있지만, 파일을 만들 때는 늘 \fBlc=3\fP 값과 \fBlp=0\fP 값을 활용합니다.  다른
+\fIlc\fP 값과 \fIlp\fP 값으로의 파일 압축은 \fBxz\fP와 LZMA SDK에서만 가능합니다.
+.PP
+liblzma의 LZMA1 필터 구현체에서는 \fIlc\fP 값과 \fIlp\fP 값의 합이 4를 넘어가면 안됩니다.  그래서 \fB.lzma\fP
+파일의 경우 이 제한을 넘어가면 \fBxz\fP로 압축을 해제할 수 없습니다.
+.PP
+LZMA 유틸리티는 2^\fIn\fP (2의 승수)크기를 지닌 딕셔너리를 가진 \fB.lzma\fP 파일만 만들지만 받아들이는 파일의 딕셔너리
+크기는 어떤 크기든 상관 없습니다.  liblzma에서는 2^\fIn\fP, 2^\fIn\fP + 2^(\fIn\fP\-1) 딕셔너리 크기를 가진
+\&\fB.lzma\fP 파일 만 받아들입니다. 이로 인해 \fB.lzma\fP 파일을 확인할 때 거짓 양성율이 늘어납니다.
+.PP
+모든 \fB.lzma\fP 파일을 liblzma 에서 받아들일 수 있도록 압축하기 때문에 이 제한이 실제로는 문제가 되지 않습니다.
+.
+.SS "뒤따라오는 쓰레기 값"
+압축 해제할 때, LZMA 유틸리티는 \fB.lzma\fP 스트림 처음 부분 다음 나머지를 다 조용히 무시합니다.  대부분의 경우,
+버그입니다.  LZMA 유틸리티에서 \fB.lzma\fP 결합 파일 압축 해제를 지원하지 않음을 의미하기도 합니다.
+.PP
+\&\fB.lzma\fP 스트림 처음부분 바로 다음에 데이터가 남아있을 경우, \fBxz\fP 에서는 \fB\-\-single\-stream\fP 옵션을 사용하지
+않으면 깨진 파일로 간주합니다.  이 동작으로 하여금 뒤따라오는 쓰레기 값을 무시하도록 간주하는 애매한 스크립트 동작을 깰 수가
+있습니��.
+.
+.SH 참고
+.
+.SS "출력 결과물이 달라짐"
+압축하지 않은 입력 파일로부터 얻어낸 정확한 압축 출력 결과물은 압축 옵션이 완전히 동일하더라도 XZ 유틸리티의 버전에 따라 달라질 수
+있습니다.  파일 형식에 영향을 주지 않고 인코더 그 자체를 개선(더 빠르게 하거나 더 나은 압축율로)하기 때문입니다.  XZ 유틸리티
+버전이 동일하더라도 빌드 옵션을 달리하여 빌드 상태가 제각각인 경우 출력 결과물이 달라질 수 있습니다.
+.PP
+\fB\-\-rsyncable\fP 기능을 넣었을 경우 동일한 xz 버전에서 이전 파일과 새 파일로 별도로 압축하지 않는 한 결과 파일을 (두
+파일이 서로 다른 파일이 아니므로) rsync 처리할 필요가 없습니다.  이 문제는 인코더 구현체 기능 개발이 끝나서 xz 버전이
+다르더라도 안정적인 rsync 가능한 출력 결과물을 유지할 수 있을 때여야 해결할 수 있습니다.
+.
+.SS "내장 .xz 압축 해제 프로그램"
+XZ 임베디드와 같은 내장 \fB.xz\fP 압축 해제 구현체는 지원 파일의 무결성 \fI검사\fP 형식을 \fInone\fP과 \fIcrc32\fP 이외의
+설정으로 만들 필요가 없습니다.  기본값이 \fB\-\-check=crc64\fP일 경우에만, 임베디드 시스템에서 파일을 만들 때
+\fB\-\-check=none\fP 또는 \fB\-\-check=crc32\fP 옵션을 사용해야합니다.
+.PP
+임베디드 시스템이 아니라면, 모든 \fB.xz\fP 형식 압축 해제 프로그램에서는 모든 \fI검사\fP 형식을 지원하거나, 일부 \fI검사\fP 방식을
+지원하지 않는다면, 최소한, 무결성 검사로 검증하지 않고 압축을 해제할 수 있습니다.
+.PP
+XZ 임베디드는 BCJ 필터를 지원하지만, 기본 시작 오프셋만 지정할 수 있습니다.
+.
+.SH 예제
+.
+.SS 기본
+\fIfoo\fP 파일을 기본 압축 수준 (\fB\-6\fP) 으로 \fIfoo.xz\fP 파일에 압축해 넣고, 압축 과정이 무사히 끝나면 \fIfoo\fP를
+삭제합니다:
+.RS
+.PP
+.nf
+\f(CRxz foo\fR
+.fi
+.RE
+.PP
+\fIbar.xz\fP를 \fIbar\fP 에 압축을 해제한 후 압축 해제가 무사히 끝나도 \fIbar.xz\fP를 삭제하지 않습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-dk bar.xz\fR
+.fi
+.RE
+.PP
+기본 사전 설정 \fB\-6\fP 보다는 느리지만, 압축 및 압축 해제시 메모리를 적게 차지(각각 48\ Mib, 5\MiB)는 \fB\-4e\fP
+사전 설정(\fB\-4 \-\-extreme\fP)을 활용하여 \fIbaz.tar.xz\fP 파일을 만듭니다:
+.RS
+.PP
+.nf
+\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR
+.fi
+.RE
+.PP
+압축 및 비압축 파일을 단일 명령으로 표준 출력에 압축해제할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR
+.fi
+.RE
+.
+.SS "다중 파일 병렬 압축"
+GNU와 *BSD에서는 \fBfind\fP(1)  명령과 \fBxargs\fP(1)  명령으로 여러 파일의 압축을 병렬 처리할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e
+    | xargs \-0r \-P4 \-n16 xz \-T1\fR
+.fi
+.RE
+.PP
+\fBxargs\fP(1)  의 \fB\-P\fP 옵션으로 \fBxz\fP 프로세스의 병렬 처리 갯수를 지정합니다.  \fB\-n\fP 옵션의 최적 값은 압축할
+파일 수에 달려있습니다.  압축할 파일이 몇개밖에 없다면 1이어야합니다. 파일이 수천 수만개 정도 된다면 \fBxargs\fP(1)  이
+어쨌든지간에 만들어낼 \fBxz\fP 프로세스의 겟수를 100으로 하거나 아니면 적당한 값을 지정하여 줄이는게 좋습니다.
+.PP
+\fBxz\fP에 \fB\-T1\fP옵션을 지정하면 단일\-스레드 모드로 강제합니다. \fBxargs\fP(1)  에서 병렬 처리 갯수를 제어할 수 있기
+때문입니다.
+.
+.SS "로봇 모드"
+여러 파일을 압축한 후 저장할 바이트 용량을 계산합니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR
+.fi
+.RE
+.PP
+이 스크립트에서는 충분히 최신의 \fBxz\fP 명령을 사용하는지 알아보려 합니다.  다음 \fBsh\fP(1)  스크립트에서는 \fBxz\fP 도구의
+버전 번호가 최소한 5.0.0인지 여부를 검사합니다.  이 방식은 \fB\-\-robot\fP 옵션을 지원하지 않는 오래된 베타 버전과도 호환성이
+있습니다:
+.RS
+.PP
+.nf
+\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" ||
+        [ "$XZ_VERSION" \-lt 50000002 ]; then
+    echo "Your xz is too old."
+fi
+unset XZ_VERSION LIBLZMA_VERSION\fR
+.fi
+.RE
+.PP
+\fBXZ_OPT\fP 환경 변수로 압축 해제시 메뢰 사용량 한계를 설정하지만, 한계 값을 이미 설정했다면, 값을 늘리지 않습니다:
+.RS
+.PP
+.nf
+\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB
+OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3)
+if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then
+    XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM"
+    export XZ_OPT
+fi\fR
+.fi
+.RE
+.
+.SS "개별 압축 필터 체인 설정"
+개별 설정 필터 체인의 초단순 사용방식은 LZMA2 사전 설정 값을 별도로 설정하는 방식입니다.  ���전 설정은 잠재적으로 쓸만한 압축
+설정 조합만 다루기 때문에 꽤 쓸모가 있을 수도 있습니다.
+.PP
+\fB\-0\fP ... \fB\-9\fP 옵션의 설명에서 테이블의 CompCPU 컬럼과 \fB\-\-extreme\fP 옵션은 LZMA2 사전 설정을
+개별적으로 맞췄을 때 쓸만할 수도 있습니다.  여기 관련내용을 테이블 둘로 정리해서 모아보았습니다:
+.RS
+.PP
+.TS
+tab(;);
+c c
+n n.
+Preset;CompCPU
+\-0;0
+\-1;1
+\-2;2
+\-3;3
+\-4;4
+\-5;5
+\-6;6
+\-5e;7
+\-6e;8
+.TE
+.RE
+.PP
+어떤 파일을 압축할 때 상당히 큰 딕셔너리(예: 32MiB)가 필요 하다는걸 알아채셨지만, \fBxz \-8\fP 명령이 압축할 때보다 더 빠른
+속도로 압축하려 한다면, 더 큰 딕셔너리 사용을 위해 더 낮은 CompCPU 사전 설정 값(예: 1)으로 수정할 수 있습니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR
+.fi
+.RE
+.PP
+각 파일에 대해, 위 명령은 압축율이 더 좋아지면서도 \fBxz \-6\fP보다 더 빨라집니다.  그러나, CompCPU 값을 낮게 유지하는
+대신 큰 딕셔너리에서 일부 파일을 강조해야 합니다.  큰 딕셔너리가 대부분의 도움을 주는 매우 명백한 상황에서는 최소한 몇 메가바이트의
+매우 유사한 각 파일이 아카이브에 들어갑니다.  딕셔너리 크기는 LZMA2가 연속으로 존재하는 각 파일의 유사성으로부터 얻는 장점을 취할
+수 있을 때 일부 개별 파일보다 훨씬 더 커집니다.
+.PP
+압축 프로그램과 압축 해제 프로그램에서 메모리를 엄청 많이 사용해도 상관 없고, 파일을 수백 메가 바이트 메모리 용량을 활용하여
+압축한다면, \fBxz \-9\fP 명령에 64MiB 용량을 초과하는 딕셔너리를 사용할 수 있게 하는 방법도 쓸만할 지도 모릅니다:
+.RS
+.PP
+.nf
+\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR
+.fi
+.RE
+.PP
+위 예제에서와 같이 \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) 옵션을 사용하면 압축 및 압축 해제 과정에서 필요한 메모리
+용량을 살펴보는데 요긴할 수 있습니다.  압축 해제한 파일 크기보다 더 큰 딕셔너리를 사용하면 불필요한 메모리 소모량이 발생하여 위
+명령이 작은 파일에는 쓸모 없음을 기억하십시오.
+.PP
+때로는 압축 시간이 딱히 상관이 없을 수도 있습니다만, 압축 해제시 메모리 사용량을 적게 유지해야 할 수도 있습니다. 예를 들면,
+임베디드 시스템에서 파일 압축을 해제할 수도 있습니다.  다음 명령의 경우 \fB\-6e\fP (\fB\-6 \-\-extreme\fP) 옵션을 기반
+옵션을 사용하며 딕셔너리 크기를 64KiB만 사용하도록 제한합니다.  결과 파일은 XZ 임베디드(이게 \fB\-\-check=crc32\fP
+옵션이 있는 이유)로 100KiB 메모리 용량을 활용하여 풀어낼 수 있습니다.
+.RS
+.PP
+.nf
+\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR
+.fi
+.RE
+.PP
+가능한 한 수 바이트를 더 쥐어 짜내고 싶을 때, 리터럴 문맥 비트 수(\fIlc\fP)와 위치 비트 수(\fIpb\fP)를 조정하면 도움이 될
+수도 있습니다.  리터럴 위치 비트 수(\fIlp\fP)를 조금 건드리는 것 또한 도움이 될 지도 모르겠지만 보통 \fIlc\fP 값과 \fIpb\fP
+값이 더 중요합니다.  예를 들면, 소스 코드 저장 파일에는 US\-ASCII 텍스트가 대부분이기에, 다음과 같은 경우는 \fBxz \-6e\fP
+명령을 실행했을 때부다는 아주 약간(거의 0.1% 수준) 작은 파일을 얻어낼 수도 있습니다(\fBlc=4\fP를 빼고도 시도해보십시오):
+.RS
+.PP
+.nf
+\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR
+.fi
+.RE
+.PP
+LZMA2와 다른 필터를 함께 사용하면 일부 파일 형식에 대해 압축율을 개선할 수 있습니다.  예를 들면 x86\-32 또는 x86\-64
+공유 라이브러리를 x86 BCJ 필터를 활용하여 압축할 경우:
+.RS
+.PP
+.nf
+\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR
+.fi
+.RE
+.PP
+참고로 필터 옵션의 순서는 상당히 중요합니다.  \fB\-\-x86\fP을 \fB\-\-lzma\fP 이전에 지정하면 \fBxz\fP에서 오류가 나는데,
+LZMA2 다음에는 어떤 필터든 설정할 수 없고, 옵션 체인상 마지막 필터로 x86 BCJ 필터를 사용할 수 없기 때문입니다.
+.PP
+LZMA2와 델타 필터는 비트맵 그림에 최적의 결과를 가져다줄 수 있습니다.  PNG에 보통 안성맞춥인데, PNG에는 단순 델타 필터보단
+약간 더 고급진 필터를 사용하지만, 실제 압축을 진행할 때는 Deflate를 사용하기 때문입니다.
+.PP
+예를 들어 이미지를 압축하지 않은 비압축 TIFF로 저장해야 하는 경우가 있습니다.  델타 필터의 거리 매개변수는 그림에서 픽셀당 바이트
+수에 일치하도록 설정합니다.  예를 들면, 24비트 RGB 비트맵의 경우 \fBdist=3\fP 거리 매개변수 값을 설정해야 하며, LZMA2
+압축시 3바이트 정렬을 따르도록 \fBpb=0\fP 값을 전달하는 방법도 바람직합니다:
+.RS
+.PP
+.nf
+\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR
+.fi
+.RE
+.PP
+여러 이미지를 단일 아카이브로 넣고 싶다면(예: \fB.tar\fP), 모든 이미지에 대해 동일한 픽셀당 바이트 수가 들어가는 경우에도 델타
+필터가 동작합니다.
+.
+.SH "추가 참조"
+\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1),
+\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1)
+.PP
+XZ 유틸리티: <https://tukaani.org/xz\-utils/>
+.br
+XZ 임베디드: <https://tukaani.org/xz/embedded/>
+.br
+LZMA SDK: <https://7\-zip.org/sdk.html>