npm - react-native-update - Versions diffs - 10.34.7 → 10.34.8 - Mend

react-native-update 10.34.7 → 10.34.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (747) hide show

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Common/OpenArchive.cpp DELETED Viewed

@@ -1,3553 +0,0 @@
-// OpenArchive.cpp
-#include "StdAfx.h"
-// #define SHOW_DEBUG_INFO
-#ifdef SHOW_DEBUG_INFO
-#include <stdio.h>
-#endif
-#include "../../../../C/CpuArch.h"
-#include "../../../Common/ComTry.h"
-#include "../../../Common/IntToString.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/StringToInt.h"
-#include "../../../Common/Wildcard.h"
-#include "../../../Windows/FileDir.h"
-#include "../../Common/FileStreams.h"
-#include "../../Common/LimitedStreams.h"
-#include "../../Common/ProgressUtils.h"
-#include "../../Common/StreamUtils.h"
-#include "../../Compress/CopyCoder.h"
-#include "DefaultName.h"
-#include "OpenArchive.h"
-#ifndef _SFX
-#include "SetProperties.h"
-#endif
-#ifdef SHOW_DEBUG_INFO
-#define PRF(x) x
-#else
-#define PRF(x)
-#endif
-// increase it, if you need to support larger SFX stubs
-static const UInt64 kMaxCheckStartPosition = 1 << 23;
-/*
-Open:
-  - formatIndex >= 0 (exact Format)
-       1) Open with main type. Archive handler is allowed to use archive start finder.
-          Warning, if there is tail.
-  - formatIndex = -1 (Parser:0) (default)
-    - same as #1 but doesn't return Parser
-  - formatIndex = -2 (#1)
-    - file has supported extension (like a.7z)
-      Open with that main type (only starting from start of file).
-        - open OK:
-            - if there is no tail - return OK
-            - if there is tail:
-              - archive is not "Self Exe" - return OK with Warning, that there is tail
-              - archive is "Self Exe"
-                ignore "Self Exe" stub, and tries to open tail
-                  - tail can be open as archive - shows that archive and stub size property.
-                  - tail can't be open as archive - shows Parser ???
-        - open FAIL:
-           Try to open with all other types from offset 0 only.
-           If some open type is OK and physical archive size is uequal or larger
-           than file size, then return that archive with warning that can not be open as [extension type].
-           If extension was EXE, it will try to open as unknown_extension case
-    - file has unknown extension (like a.hhh)
-       It tries to open via parser code.
-         - if there is full archive or tail archive and unknown block or "Self Exe"
-           at front, it shows tail archive and stub size property.
-         - in another cases, if there is some archive inside file, it returns parser/
-         - in another cases, it retuens S_FALSE
-  - formatIndex = -3 (#2)
-    - same as #1, but
-    - stub (EXE) + archive is open in Parser
-  - formatIndex = -4 (#3)
-    - returns only Parser. skip full file archive. And show other sub-archives
-  - formatIndex = -5 (#4)
-    - returns only Parser. skip full file archive. And show other sub-archives for each byte pos
-*/
-using namespace NWindows;
-/*
-#ifdef _SFX
-#define OPEN_PROPS_PARAM
-#else
-#define OPEN_PROPS_PARAM  , props
-#endif
-*/
-/*
-CArc::~CArc()
-{
-  GetRawProps.Release();
-  Archive.Release();
-  printf("\nCArc::~CArc()\n");
-}
-*/
-#ifndef _SFX
-namespace NArchive {
-namespace NParser {
-struct CParseItem
-{
-  UInt64 Offset;
-  UInt64 Size;
-  // UInt64 OkSize;
-  UString Name;
-  UString Extension;
-  FILETIME FileTime;
-  UString Comment;
-  UString ArcType;
-  bool FileTime_Defined;
-  bool UnpackSize_Defined;
-  bool NumSubDirs_Defined;
-  bool NumSubFiles_Defined;
-  bool IsSelfExe;
-  bool IsNotArcType;
-  UInt64 UnpackSize;
-  UInt64 NumSubDirs;
-  UInt64 NumSubFiles;
-  int FormatIndex;
-  bool LenIsUnknown;
-  CParseItem():
-      LenIsUnknown(false),
-      FileTime_Defined(false),
-      UnpackSize_Defined(false),
-      NumSubFiles_Defined(false),
-      NumSubDirs_Defined(false),
-      IsSelfExe(false),
-      IsNotArcType(false)
-      // OkSize(0)
-    {}
-  /*
-  bool IsEqualTo(const CParseItem &item) const
-  {
-    return Offset == item.Offset && Size == item.Size;
-  }
-  */
-  void NormalizeOffset()
-  {
-    if ((Int64)Offset < 0)
-    {
-      Size += Offset;
-      // OkSize += Offset;
-      Offset = 0;
-    }
-  }
-};
-class CHandler:
-  public IInArchive,
-  public IInArchiveGetStream,
-  public CMyUnknownImp
-{
-public:
-  CObjectVector<CParseItem> _items;
-  UInt64 _maxEndOffset;
-  CMyComPtr<IInStream> _stream;
-  MY_UNKNOWN_IMP2(
-    IInArchive,
-    IInArchiveGetStream)
-  INTERFACE_IInArchive(;)
-  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
-  UInt64 GetLastEnd() const
-  {
-    if (_items.IsEmpty())
-      return 0;
-    const CParseItem &back = _items.Back();
-    return back.Offset + back.Size;
-  }
-  void AddUnknownItem(UInt64 next);
-  int FindInsertPos(const CParseItem &item) const;
-  void AddItem(const CParseItem &item);
-  CHandler(): _maxEndOffset(0) {}
-};
-int CHandler::FindInsertPos(const CParseItem &item) const
-{
-  unsigned left = 0, right = _items.Size();
-  while (left != right)
-  {
-    unsigned mid = (left + right) / 2;
-    const CParseItem & midItem = _items[mid];
-    if (item.Offset < midItem.Offset)
-      right = mid;
-    else if (item.Offset > midItem.Offset)
-      left = mid + 1;
-    else if (item.Size < midItem.Size)
-      right = mid;
-    else if (item.Size > midItem.Size)
-      left = mid + 1;
-    else
-    {
-      left = mid + 1;
-      // return -1;
-    }
-  }
-  return left;
-}
-void CHandler::AddUnknownItem(UInt64 next)
-{
-  /*
-  UInt64 prevEnd = 0;
-  if (!_items.IsEmpty())
-  {
-    const CParseItem &back = _items.Back();
-    prevEnd = back.Offset + back.Size;
-  }
-  */
-  if (_maxEndOffset < next)
-  {
-    CParseItem item2;
-    item2.Offset = _maxEndOffset;
-    item2.Size = next - _maxEndOffset;
-    _maxEndOffset = next;
-    _items.Add(item2);
-  }
-  else if (_maxEndOffset > next && !_items.IsEmpty())
-  {
-    CParseItem &back = _items.Back();
-    if (back.LenIsUnknown)
-    {
-      back.Size = next - back.Offset;
-      _maxEndOffset = next;
-    }
-  }
-}
-void CHandler::AddItem(const CParseItem &item)
-{
-  AddUnknownItem(item.Offset);
-  int pos = FindInsertPos(item);
-  if (pos >= 0)
-  {
-    _items.Insert(pos, item);
-    UInt64 next = item.Offset + item.Size;
-    if (_maxEndOffset < next)
-      _maxEndOffset = next;
-  }
-}
-/*
-static const CStatProp kProps[] =
-{
-  { NULL, kpidPath, VT_BSTR},
-  { NULL, kpidSize, VT_UI8},
-  { NULL, kpidMTime, VT_FILETIME},
-  { NULL, kpidType, VT_BSTR},
-  { NULL, kpidComment, VT_BSTR},
-  { NULL, kpidOffset, VT_UI8},
-  { NULL, kpidUnpackSize, VT_UI8},
-//   { NULL, kpidNumSubDirs, VT_UI8},
-};
-*/
-static const Byte kProps[] =
-{
-  kpidPath,
-  kpidSize,
-  kpidMTime,
-  kpidType,
-  kpidComment,
-  kpidOffset,
-  kpidUnpackSize
-};
-IMP_IInArchive_Props
-IMP_IInArchive_ArcProps_NO
-STDMETHODIMP CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback * /* openArchiveCallback */)
-{
-  COM_TRY_BEGIN
-  {
-    Close();
-    _stream = stream;
-  }
-  return S_OK;
-  COM_TRY_END
-}
-STDMETHODIMP CHandler::Close()
-{
-  _items.Clear();
-  _stream.Release();
-  return S_OK;
-}
-STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
-{
-  *numItems = _items.Size();
-  return S_OK;
-}
-STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
-{
-  COM_TRY_BEGIN
-  NCOM::CPropVariant prop;
-  const CParseItem &item = _items[index];
-  switch (propID)
-  {
-    case kpidPath:
-    {
-      char sz[32];
-      ConvertUInt32ToString(index + 1, sz);
-      UString s(sz);
-      if (!item.Name.IsEmpty())
-      {
-        s += '.';
-        s += item.Name;
-      }
-      if (!item.Extension.IsEmpty())
-      {
-        s += '.';
-        s += item.Extension;
-      }
-      prop = s; break;
-    }
-    case kpidSize:
-    case kpidPackSize: prop = item.Size; break;
-    case kpidOffset: prop = item.Offset; break;
-    case kpidUnpackSize: if (item.UnpackSize_Defined) prop = item.UnpackSize; break;
-    case kpidNumSubFiles: if (item.NumSubFiles_Defined) prop = item.NumSubFiles; break;
-    case kpidNumSubDirs: if (item.NumSubDirs_Defined) prop = item.NumSubDirs; break;
-    case kpidMTime: if (item.FileTime_Defined) prop = item.FileTime; break;
-    case kpidComment: if (!item.Comment.IsEmpty()) prop = item.Comment; break;
-    case kpidType: if (!item.ArcType.IsEmpty()) prop = item.ArcType; break;
-  }
-  prop.Detach(value);
-  return S_OK;
-  COM_TRY_END
-}
-HRESULT CHandler::Extract(const UInt32 *indices, UInt32 numItems,
-    Int32 testMode, IArchiveExtractCallback *extractCallback)
-{
-  COM_TRY_BEGIN
-  bool allFilesMode = (numItems == (UInt32)(Int32)-1);
-  if (allFilesMode)
-    numItems = _items.Size();
-  if (_stream && numItems == 0)
-    return S_OK;
-  UInt64 totalSize = 0;
-  UInt32 i;
-  for (i = 0; i < numItems; i++)
-    totalSize += _items[allFilesMode ? i : indices[i]].Size;
-  extractCallback->SetTotal(totalSize);
-  totalSize = 0;
-  CLocalProgress *lps = new CLocalProgress;
-  CMyComPtr<ICompressProgressInfo> progress = lps;
-  lps->Init(extractCallback, false);
-  CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
-  CMyComPtr<ISequentialInStream> inStream(streamSpec);
-  streamSpec->SetStream(_stream);
-  CLimitedSequentialOutStream *outStreamSpec = new CLimitedSequentialOutStream;
-  CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
-  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
-  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
-  for (i = 0; i < numItems; i++)
-  {
-    lps->InSize = totalSize;
-    lps->OutSize = totalSize;
-    RINOK(lps->SetCur());
-    CMyComPtr<ISequentialOutStream> realOutStream;
-    Int32 askMode = testMode ?
-        NExtract::NAskMode::kTest :
-        NExtract::NAskMode::kExtract;
-    Int32 index = allFilesMode ? i : indices[i];
-    const CParseItem &item = _items[index];
-    RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
-    UInt64 unpackSize = item.Size;
-    totalSize += unpackSize;
-    bool skipMode = false;
-    if (!testMode && !realOutStream)
-      continue;
-    RINOK(extractCallback->PrepareOperation(askMode));
-    outStreamSpec->SetStream(realOutStream);
-    realOutStream.Release();
-    outStreamSpec->Init(skipMode ? 0 : unpackSize, true);
-    Int32 opRes = NExtract::NOperationResult::kOK;
-    RINOK(_stream->Seek(item.Offset, STREAM_SEEK_SET, NULL));
-    streamSpec->Init(unpackSize);
-    RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress));
-    if (outStreamSpec->GetRem() != 0)
-      opRes = NExtract::NOperationResult::kDataError;
-    outStreamSpec->ReleaseStream();
-    RINOK(extractCallback->SetOperationResult(opRes));
-  }
-  return S_OK;
-  COM_TRY_END
-}
-STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
-{
-  COM_TRY_BEGIN
-  const CParseItem &item = _items[index];
-  return CreateLimitedInStream(_stream, item.Offset, item.Size, stream);
-  COM_TRY_END
-}
-}}
-#endif
-HRESULT Archive_GetItemBoolProp(IInArchive *arc, UInt32 index, PROPID propID, bool &result) throw()
-{
-  NCOM::CPropVariant prop;
-  result = false;
-  RINOK(arc->GetProperty(index, propID, &prop));
-  if (prop.vt == VT_BOOL)
-    result = VARIANT_BOOLToBool(prop.boolVal);
-  else if (prop.vt != VT_EMPTY)
-    return E_FAIL;
-  return S_OK;
-}
-HRESULT Archive_IsItem_Dir(IInArchive *arc, UInt32 index, bool &result) throw()
-{
-  return Archive_GetItemBoolProp(arc, index, kpidIsDir, result);
-}
-HRESULT Archive_IsItem_Aux(IInArchive *arc, UInt32 index, bool &result) throw()
-{
-  return Archive_GetItemBoolProp(arc, index, kpidIsAux, result);
-}
-HRESULT Archive_IsItem_AltStream(IInArchive *arc, UInt32 index, bool &result) throw()
-{
-  return Archive_GetItemBoolProp(arc, index, kpidIsAltStream, result);
-}
-HRESULT Archive_IsItem_Deleted(IInArchive *arc, UInt32 index, bool &result) throw()
-{
-  return Archive_GetItemBoolProp(arc, index, kpidIsDeleted, result);
-}
-static HRESULT Archive_GetArcBoolProp(IInArchive *arc, PROPID propid, bool &result) throw()
-{
-  NCOM::CPropVariant prop;
-  result = false;
-  RINOK(arc->GetArchiveProperty(propid, &prop));
-  if (prop.vt == VT_BOOL)
-    result = VARIANT_BOOLToBool(prop.boolVal);
-  else if (prop.vt != VT_EMPTY)
-    return E_FAIL;
-  return S_OK;
-}
-static HRESULT Archive_GetArcProp_UInt(IInArchive *arc, PROPID propid, UInt64 &result, bool &defined)
-{
-  defined = false;
-  NCOM::CPropVariant prop;
-  RINOK(arc->GetArchiveProperty(propid, &prop));
-  switch (prop.vt)
-  {
-    case VT_UI4: result = prop.ulVal; defined = true; break;
-    case VT_I4: result = (Int64)prop.lVal; defined = true; break;
-    case VT_UI8: result = (UInt64)prop.uhVal.QuadPart; defined = true; break;
-    case VT_I8: result = (UInt64)prop.hVal.QuadPart; defined = true; break;
-    case VT_EMPTY: break;
-    default: return E_FAIL;
-  }
-  return S_OK;
-}
-static HRESULT Archive_GetArcProp_Int(IInArchive *arc, PROPID propid, Int64 &result, bool &defined)
-{
-  defined = false;
-  NCOM::CPropVariant prop;
-  RINOK(arc->GetArchiveProperty(propid, &prop));
-  switch (prop.vt)
-  {
-    case VT_UI4: result = prop.ulVal; defined = true; break;
-    case VT_I4: result = prop.lVal; defined = true; break;
-    case VT_UI8: result = (Int64)prop.uhVal.QuadPart; defined = true; break;
-    case VT_I8: result = (Int64)prop.hVal.QuadPart; defined = true; break;
-    case VT_EMPTY: break;
-    default: return E_FAIL;
-  }
-  return S_OK;
-}
-#ifndef _SFX
-HRESULT CArc::GetItemPathToParent(UInt32 index, UInt32 parent, UStringVector &parts) const
-{
-  if (!GetRawProps)
-    return E_FAIL;
-  if (index == parent)
-    return S_OK;
-  UInt32 curIndex = index;
-  UString s;
-  bool prevWasAltStream = false;
-  for (;;)
-  {
-    #ifdef MY_CPU_LE
-    const void *p;
-    UInt32 size;
-    UInt32 propType;
-    RINOK(GetRawProps->GetRawProp(curIndex, kpidName, &p, &size, &propType));
-    if (p && propType == PROP_DATA_TYPE_wchar_t_PTR_Z_LE)
-      s = (const wchar_t *)p;
-    else
-    #endif
-    {
-      NCOM::CPropVariant prop;
-      RINOK(Archive->GetProperty(curIndex, kpidName, &prop));
-      if (prop.vt == VT_BSTR && prop.bstrVal)
-        s.SetFromBstr(prop.bstrVal);
-      else if (prop.vt == VT_EMPTY)
-        s.Empty();
-      else
-        return E_FAIL;
-    }
-    UInt32 curParent = (UInt32)(Int32)-1;
-    UInt32 parentType = 0;
-    RINOK(GetRawProps->GetParent(curIndex, &curParent, &parentType));
-    // 18.06: fixed : we don't want to split name to parts
-    /*
-    if (parentType != NParentType::kAltStream)
-    {
-      for (;;)
-      {
-        int pos = s.ReverseFind_PathSepar();
-        if (pos < 0)
-        {
-          break;
-        }
-        parts.Insert(0, s.Ptr(pos + 1));
-        s.DeleteFrom(pos);
-      }
-    }
-    */
-    parts.Insert(0, s);
-    if (prevWasAltStream)
-    {
-      {
-        UString &s2 = parts[parts.Size() - 2];
-        s2 += ':';
-        s2 += parts.Back();
-      }
-      parts.DeleteBack();
-    }
-    if (parent == curParent)
-      return S_OK;
-    prevWasAltStream = false;
-    if (parentType == NParentType::kAltStream)
-      prevWasAltStream = true;
-    if (curParent == (UInt32)(Int32)-1)
-      return E_FAIL;
-    curIndex = curParent;
-  }
-}
-#endif
-HRESULT CArc::GetItemPath(UInt32 index, UString &result) const
-{
-  #ifdef MY_CPU_LE
-  if (GetRawProps)
-  {
-    const void *p;
-    UInt32 size;
-    UInt32 propType;
-    if (!IsTree)
-    {
-      if (GetRawProps->GetRawProp(index, kpidPath, &p, &size, &propType) == S_OK &&
-          propType == NPropDataType::kUtf16z)
-      {
-        unsigned len = size / 2 - 1;
-        wchar_t *s = result.GetBuf(len);
-        for (unsigned i = 0; i < len; i++)
-        {
-          wchar_t c = GetUi16(p);
-          p = (const void *)((const Byte *)p + 2);
-          #if WCHAR_PATH_SEPARATOR != L'/'
-          if (c == L'/')
-            c = WCHAR_PATH_SEPARATOR;
-          #endif
-          *s++ = c;
-        }
-        *s = 0;
-        result.ReleaseBuf_SetLen(len);
-        if (len != 0)
-          return S_OK;
-      }
-    }
-    /*
-    else if (GetRawProps->GetRawProp(index, kpidName, &p, &size, &propType) == S_OK &&
-        p && propType == NPropDataType::kUtf16z)
-    {
-      size -= 2;
-      UInt32 totalSize = size;
-      bool isOK = false;
-      {
-        UInt32 index2 = index;
-        for (;;)
-        {
-          UInt32 parent = (UInt32)(Int32)-1;
-          UInt32 parentType = 0;
-          if (GetRawProps->GetParent(index2, &parent, &parentType) != S_OK)
-            break;
-          if (parent == (UInt32)(Int32)-1)
-          {
-            if (parentType != 0)
-              totalSize += 2;
-            isOK = true;
-            break;
-          }
-          index2 = parent;
-          UInt32 size2;
-          const void *p2;
-          if (GetRawProps->GetRawProp(index2, kpidName, &p2, &size2, &propType) != S_OK &&
-              p2 && propType == NPropDataType::kUtf16z)
-            break;
-          totalSize += size2;
-        }
-      }
-      if (isOK)
-      {
-        wchar_t *sz = result.GetBuf_SetEnd(totalSize / 2);
-        UInt32 pos = totalSize - size;
-        memcpy((Byte *)sz + pos, p, size);
-        UInt32 index2 = index;
-        for (;;)
-        {
-          UInt32 parent = (UInt32)(Int32)-1;
-          UInt32 parentType = 0;
-          if (GetRawProps->GetParent(index2, &parent, &parentType) != S_OK)
-            break;
-          if (parent == (UInt32)(Int32)-1)
-          {
-            if (parentType != 0)
-              sz[pos / 2 - 1] = L':';
-            break;
-          }
-          index2 = parent;
-          UInt32 size2;
-          const void *p2;
-          if (GetRawProps->GetRawProp(index2, kpidName, &p2, &size2, &propType) != S_OK)
-            break;
-          pos -= size2;
-          memcpy((Byte *)sz + pos, p2, size2);
-          sz[(pos + size2 - 2) / 2] = (parentType == 0) ? WCHAR_PATH_SEPARATOR : L':';
-        }
-        #ifdef _WIN32
-        // result.Replace(L'/', WCHAR_PATH_SEPARATOR);
-        #endif
-        return S_OK;
-      }
-    }
-    */
-  }
-  #endif
-  {
-    NCOM::CPropVariant prop;
-    RINOK(Archive->GetProperty(index, kpidPath, &prop));
-    if (prop.vt == VT_BSTR && prop.bstrVal)
-      result.SetFromBstr(prop.bstrVal);
-    else if (prop.vt == VT_EMPTY)
-      result.Empty();
-    else
-      return E_FAIL;
-  }
-  if (result.IsEmpty())
-    return GetDefaultItemPath(index, result);
-  return S_OK;
-}
-HRESULT CArc::GetDefaultItemPath(UInt32 index, UString &result) const
-{
-  result.Empty();
-  bool isDir;
-  RINOK(Archive_IsItem_Dir(Archive, index, isDir));
-  if (!isDir)
-  {
-    result = DefaultName;
-    NCOM::CPropVariant prop;
-    RINOK(Archive->GetProperty(index, kpidExtension, &prop));
-    if (prop.vt == VT_BSTR)
-    {
-      result += '.';
-      result += prop.bstrVal;
-    }
-    else if (prop.vt != VT_EMPTY)
-      return E_FAIL;
-  }
-  return S_OK;
-}
-HRESULT CArc::GetItemPath2(UInt32 index, UString &result) const
-{
-  RINOK(GetItemPath(index, result));
-  if (Ask_Deleted)
-  {
-    bool isDeleted = false;
-    RINOK(Archive_IsItem_Deleted(Archive, index, isDeleted));
-    if (isDeleted)
-      result.Insert(0, L"[DELETED]" WSTRING_PATH_SEPARATOR);
-  }
-  return S_OK;
-}
-#ifdef SUPPORT_ALT_STREAMS
-int FindAltStreamColon_in_Path(const wchar_t *path)
-{
-  unsigned i = 0;
-  int colonPos = -1;
-  for (;; i++)
-  {
-    wchar_t c = path[i];
-    if (c == 0)
-      return colonPos;
-    if (c == ':')
-    {
-      if (colonPos < 0)
-        colonPos = i;
-      continue;
-    }
-    if (c == WCHAR_PATH_SEPARATOR)
-      colonPos = -1;
-  }
-}
-#endif
-HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
-{
-  #ifdef SUPPORT_ALT_STREAMS
-  item.IsAltStream = false;
-  item.AltStreamName.Empty();
-  item.MainPath.Empty();
-  #endif
-  item.IsDir = false;
-  item.Path.Empty();
-  item.ParentIndex = (UInt32)(Int32)-1;
-  item.PathParts.Clear();
-  RINOK(Archive_IsItem_Dir(Archive, index, item.IsDir));
-  item.MainIsDir = item.IsDir;
-  RINOK(GetItemPath2(index, item.Path));
-  #ifndef _SFX
-  UInt32 mainIndex = index;
-  #endif
-  #ifdef SUPPORT_ALT_STREAMS
-  item.MainPath = item.Path;
-  if (Ask_AltStream)
-  {
-    RINOK(Archive_IsItem_AltStream(Archive, index, item.IsAltStream));
-  }
-  bool needFindAltStream = false;
-  if (item.IsAltStream)
-  {
-    needFindAltStream = true;
-    if (GetRawProps)
-    {
-      UInt32 parentType = 0;
-      UInt32 parentIndex;
-      RINOK(GetRawProps->GetParent(index, &parentIndex, &parentType));
-      if (parentType == NParentType::kAltStream)
-      {
-        NCOM::CPropVariant prop;
-        RINOK(Archive->GetProperty(index, kpidName, &prop));
-        if (prop.vt == VT_BSTR && prop.bstrVal)
-          item.AltStreamName.SetFromBstr(prop.bstrVal);
-        else if (prop.vt != VT_EMPTY)
-          return E_FAIL;
-        else
-        {
-          // item.IsAltStream = false;
-        }
-        /*
-        if (item.AltStreamName.IsEmpty())
-          item.IsAltStream = false;
-        */
-        needFindAltStream = false;
-        item.ParentIndex = parentIndex;
-        mainIndex = parentIndex;
-        if (parentIndex == (UInt32)(Int32)-1)
-        {
-          item.MainPath.Empty();
-          item.MainIsDir = true;
-        }
-        else
-        {
-          RINOK(GetItemPath2(parentIndex, item.MainPath));
-          RINOK(Archive_IsItem_Dir(Archive, parentIndex, item.MainIsDir));
-        }
-      }
-    }
-  }
-  if (item.WriteToAltStreamIfColon || needFindAltStream)
-  {
-    /* Good handler must support GetRawProps::GetParent for alt streams.
-       So the following code currently is not used */
-    int colon = FindAltStreamColon_in_Path(item.Path);
-    if (colon >= 0)
-    {
-      item.MainPath.DeleteFrom(colon);
-      item.AltStreamName = item.Path.Ptr(colon + 1);
-      item.MainIsDir = (colon == 0 || IsPathSepar(item.Path[(unsigned)colon - 1]));
-      item.IsAltStream = true;
-    }
-  }
-  #endif
-  #ifndef _SFX
-  if (item._use_baseParentFolder_mode)
-  {
-    RINOK(GetItemPathToParent(mainIndex, item._baseParentFolder, item.PathParts));
-    #ifdef SUPPORT_ALT_STREAMS
-    if ((item.WriteToAltStreamIfColon || needFindAltStream) && !item.PathParts.IsEmpty())
-    {
-      int colon;
-      {
-        UString &s = item.PathParts.Back();
-        colon = FindAltStreamColon_in_Path(s);
-        if (colon >= 0)
-        {
-          item.AltStreamName = s.Ptr(colon + 1);
-          item.MainIsDir = (colon == 0 || IsPathSepar(s[(unsigned)colon - 1]));
-          item.IsAltStream = true;
-          s.DeleteFrom(colon);
-        }
-      }
-      if (colon == 0)
-        item.PathParts.DeleteBack();
-    }
-    #endif
-  }
-  else
-  #endif
-    SplitPathToParts(
-          #ifdef SUPPORT_ALT_STREAMS
-            item.MainPath
-          #else
-            item.Path
-          #endif
-      , item.PathParts);
-  return S_OK;
-}
-#ifndef _SFX
-static HRESULT Archive_GetItem_Size(IInArchive *archive, UInt32 index, UInt64 &size, bool &defined)
-{
-  NCOM::CPropVariant prop;
-  defined = false;
-  size = 0;
-  RINOK(archive->GetProperty(index, kpidSize, &prop));
-  switch (prop.vt)
-  {
-    case VT_UI1: size = prop.bVal; break;
-    case VT_UI2: size = prop.uiVal; break;
-    case VT_UI4: size = prop.ulVal; break;
-    case VT_UI8: size = (UInt64)prop.uhVal.QuadPart; break;
-    case VT_EMPTY: return S_OK;
-    default: return E_FAIL;
-  }
-  defined = true;
-  return S_OK;
-}
-#endif
-HRESULT CArc::GetItemSize(UInt32 index, UInt64 &size, bool &defined) const
-{
-  NCOM::CPropVariant prop;
-  defined = false;
-  size = 0;
-  RINOK(Archive->GetProperty(index, kpidSize, &prop));
-  switch (prop.vt)
-  {
-    case VT_UI1: size = prop.bVal; break;
-    case VT_UI2: size = prop.uiVal; break;
-    case VT_UI4: size = prop.ulVal; break;
-    case VT_UI8: size = (UInt64)prop.uhVal.QuadPart; break;
-    case VT_EMPTY: return S_OK;
-    default: return E_FAIL;
-  }
-  defined = true;
-  return S_OK;
-}
-HRESULT CArc::GetItemMTime(UInt32 index, FILETIME &ft, bool &defined) const
-{
-  NCOM::CPropVariant prop;
-  defined = false;
-  ft.dwHighDateTime = ft.dwLowDateTime = 0;
-  RINOK(Archive->GetProperty(index, kpidMTime, &prop));
-  if (prop.vt == VT_FILETIME)
-  {
-    ft = prop.filetime;
-    defined = true;
-  }
-  else if (prop.vt != VT_EMPTY)
-    return E_FAIL;
-  else if (MTimeDefined)
-  {
-    ft = MTime;
-    defined = true;
-  }
-  return S_OK;
-}
-#ifndef _SFX
-static inline bool TestSignature(const Byte *p1, const Byte *p2, size_t size)
-{
-  for (size_t i = 0; i < size; i++)
-    if (p1[i] != p2[i])
-      return false;
-  return true;
-}
-static void MakeCheckOrder(CCodecs *codecs,
-    CIntVector &orderIndices, unsigned numTypes, CIntVector &orderIndices2,
-    const Byte *data, size_t dataSize)
-{
-  for (unsigned i = 0; i < numTypes; i++)
-  {
-    int index = orderIndices[i];
-    if (index < 0)
-      continue;
-    const CArcInfoEx &ai = codecs->Formats[(unsigned)index];
-    if (ai.SignatureOffset != 0)
-    {
-      orderIndices2.Add(index);
-      orderIndices[i] = -1;
-      continue;
-    }
-    const CObjectVector<CByteBuffer> &sigs = ai.Signatures;
-    FOR_VECTOR (k, sigs)
-    {
-      const CByteBuffer &sig = sigs[k];
-      if (sig.Size() == 0 && dataSize == 0 ||
-          sig.Size() != 0 && sig.Size() <= dataSize &&
-          TestSignature(data, sig, sig.Size()))
-      {
-        orderIndices2.Add(index);
-        orderIndices[i] = -1;
-        break;
-      }
-    }
-  }
-}
-#endif
-#ifdef UNDER_CE
-  static const unsigned kNumHashBytes = 1;
-  #define HASH_VAL(buf) ((buf)[0])
-#else
-  static const unsigned kNumHashBytes = 2;
-  // #define HASH_VAL(buf) ((buf)[0] | ((UInt32)(buf)[1] << 8))
-  #define HASH_VAL(buf) GetUi16(buf)
-#endif
-#ifndef _SFX
-static bool IsExeExt(const UString &ext)
-{
-  return ext.IsEqualTo_Ascii_NoCase("exe");
-}
-static const char * const k_PreArcFormats[] =
-{
-    "pe"
-  , "elf"
-  , "macho"
-  , "mub"
-  , "te"
-};
-static bool IsNameFromList(const UString &s, const char * const names[], size_t num)
-{
-  for (unsigned i = 0; i < num; i++)
-    if (StringsAreEqualNoCase_Ascii(s, names[i]))
-      return true;
-  return false;
-}
-static bool IsPreArcFormat(const CArcInfoEx &ai)
-{
-  if (ai.Flags_PreArc())
-    return true;
-  return IsNameFromList(ai.Name, k_PreArcFormats, ARRAY_SIZE(k_PreArcFormats));
-}
-static const char * const k_Formats_with_simple_signuature[] =
-{
-    "7z"
-  , "xz"
-  , "rar"
-  , "bzip2"
-  , "gzip"
-  , "cab"
-  , "wim"
-  , "rpm"
-  , "vhd"
-  , "xar"
-};
-static bool IsNewStyleSignature(const CArcInfoEx &ai)
-{
-  // if (ai.Version >= 0x91F)
-  if (ai.NewInterface)
-    return true;
-  return IsNameFromList(ai.Name, k_Formats_with_simple_signuature, ARRAY_SIZE(k_Formats_with_simple_signuature));
-}
-class CArchiveOpenCallback_Offset:
-  public IArchiveOpenCallback,
-  public IArchiveOpenVolumeCallback,
-  #ifndef _NO_CRYPTO
-  public ICryptoGetTextPassword,
-  #endif
-  public CMyUnknownImp
-{
-public:
-  CMyComPtr<IArchiveOpenCallback> Callback;
-  CMyComPtr<IArchiveOpenVolumeCallback> OpenVolumeCallback;
-  UInt64 Files;
-  UInt64 Offset;
-  #ifndef _NO_CRYPTO
-  CMyComPtr<ICryptoGetTextPassword> GetTextPassword;
-  #endif
-  MY_QUERYINTERFACE_BEGIN2(IArchiveOpenCallback)
-  MY_QUERYINTERFACE_ENTRY(IArchiveOpenVolumeCallback)
-  #ifndef _NO_CRYPTO
-  MY_QUERYINTERFACE_ENTRY(ICryptoGetTextPassword)
-  #endif
-  MY_QUERYINTERFACE_END
-  MY_ADDREF_RELEASE
-  INTERFACE_IArchiveOpenCallback(;)
-  INTERFACE_IArchiveOpenVolumeCallback(;)
-  #ifndef _NO_CRYPTO
-  STDMETHOD(CryptoGetTextPassword)(BSTR *password);
-  #endif
-};
-#ifndef _NO_CRYPTO
-STDMETHODIMP CArchiveOpenCallback_Offset::CryptoGetTextPassword(BSTR *password)
-{
-  COM_TRY_BEGIN
-  if (GetTextPassword)
-    return GetTextPassword->CryptoGetTextPassword(password);
-  return E_NOTIMPL;
-  COM_TRY_END
-}
-#endif
-STDMETHODIMP CArchiveOpenCallback_Offset::SetTotal(const UInt64 *, const UInt64 *)
-{
-  return S_OK;
-}
-STDMETHODIMP CArchiveOpenCallback_Offset::SetCompleted(const UInt64 *, const UInt64 *bytes)
-{
-  if (!Callback)
-    return S_OK;
-  UInt64 value = Offset;
-  if (bytes)
-    value += *bytes;
-  return Callback->SetCompleted(&Files, &value);
-}
-STDMETHODIMP CArchiveOpenCallback_Offset::GetProperty(PROPID propID, PROPVARIANT *value)
-{
-  if (OpenVolumeCallback)
-    return OpenVolumeCallback->GetProperty(propID, value);
-  NCOM::PropVariant_Clear(value);
-  return S_OK;
-  // return E_NOTIMPL;
-}
-STDMETHODIMP CArchiveOpenCallback_Offset::GetStream(const wchar_t *name, IInStream **inStream)
-{
-  if (OpenVolumeCallback)
-    return OpenVolumeCallback->GetStream(name, inStream);
-  return S_FALSE;
-}
-#endif
-UInt32 GetOpenArcErrorFlags(const NCOM::CPropVariant &prop, bool *isDefinedProp)
-{
-  if (isDefinedProp != NULL)
-    *isDefinedProp = false;
-  switch (prop.vt)
-  {
-    case VT_UI8: if (isDefinedProp) *isDefinedProp = true; return (UInt32)prop.uhVal.QuadPart;
-    case VT_UI4: if (isDefinedProp) *isDefinedProp = true; return prop.ulVal;
-    case VT_EMPTY: return 0;
-    default: throw 151199;
-  }
-}
-void CArcErrorInfo::ClearErrors()
-{
-  // ErrorFormatIndex = -1; // we don't need to clear ErrorFormatIndex here !!!
-  ThereIsTail = false;
-  UnexpecedEnd = false;
-  IgnoreTail = false;
-  // NonZerosTail = false;
-  ErrorFlags_Defined = false;
-  ErrorFlags = 0;
-  WarningFlags = 0;
-  TailSize = 0;
-  ErrorMessage.Empty();
-  WarningMessage.Empty();
-}
-HRESULT CArc::ReadBasicProps(IInArchive *archive, UInt64 startPos, HRESULT openRes)
-{
-  // OkPhySize_Defined = false;
-  PhySizeDefined = false;
-  PhySize = 0;
-  Offset = 0;
-  AvailPhySize = FileSize - startPos;
-  ErrorInfo.ClearErrors();
-  {
-    NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidErrorFlags, &prop));
-    ErrorInfo.ErrorFlags = GetOpenArcErrorFlags(prop, &ErrorInfo.ErrorFlags_Defined);
-  }
-  {
-    NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidWarningFlags, &prop));
-    ErrorInfo.WarningFlags = GetOpenArcErrorFlags(prop);
-  }
-  {
-    NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidError, &prop));
-    if (prop.vt != VT_EMPTY)
-      ErrorInfo.ErrorMessage = (prop.vt == VT_BSTR ? prop.bstrVal : L"Unknown error");
-  }
-  {
-    NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidWarning, &prop));
-    if (prop.vt != VT_EMPTY)
-      ErrorInfo.WarningMessage = (prop.vt == VT_BSTR ? prop.bstrVal : L"Unknown warning");
-  }
-  if (openRes == S_OK || ErrorInfo.IsArc_After_NonOpen())
-  {
-    RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, PhySize, PhySizeDefined));
-    /*
-    RINOK(Archive_GetArcProp_UInt(archive, kpidOkPhySize, OkPhySize, OkPhySize_Defined));
-    if (!OkPhySize_Defined)
-    {
-      OkPhySize_Defined = PhySizeDefined;
-      OkPhySize = PhySize;
-    }
-    */
-    bool offsetDefined;
-    RINOK(Archive_GetArcProp_Int(archive, kpidOffset, Offset, offsetDefined));
-    Int64 globalOffset = startPos + Offset;
-    AvailPhySize = FileSize - globalOffset;
-    if (PhySizeDefined)
-    {
-      UInt64 endPos = globalOffset + PhySize;
-      if (endPos < FileSize)
-      {
-        AvailPhySize = PhySize;
-        ErrorInfo.ThereIsTail = true;
-        ErrorInfo.TailSize = FileSize - endPos;
-      }
-      else if (endPos > FileSize)
-        ErrorInfo.UnexpecedEnd = true;
-    }
-  }
-  return S_OK;
-}
-/*
-static PrintNumber(const char *s, int n)
-{
-  char temp[100];
-  sprintf(temp, "%s %d", s, n);
-  OutputDebugStringA(temp);
-}
-*/
-HRESULT CArc::PrepareToOpen(const COpenOptions &op, unsigned formatIndex, CMyComPtr<IInArchive> &archive)
-{
-  // OutputDebugStringA("a1");
-  // PrintNumber("formatIndex", formatIndex);
-  RINOK(op.codecs->CreateInArchive(formatIndex, archive));
-  // OutputDebugStringA("a2");
-  if (!archive)
-    return S_OK;
-  #ifdef EXTERNAL_CODECS
-  if (op.codecs->NeedSetLibCodecs)
-  {
-    const CArcInfoEx &ai = op.codecs->Formats[formatIndex];
-    if (ai.LibIndex >= 0 ?
-        !op.codecs->Libs[ai.LibIndex].SetCodecs :
-        !op.codecs->Libs.IsEmpty())
-    {
-      CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
-      archive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
-      if (setCompressCodecsInfo)
-      {
-        RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(op.codecs));
-      }
-    }
-  }
-  #endif
-  #ifndef _SFX
-  const CArcInfoEx &ai = op.codecs->Formats[formatIndex];
-  // OutputDebugStringW(ai.Name);
-  // OutputDebugStringA("a3");
-  if (ai.Flags_PreArc())
-  {
-    /* we notify parsers that extract executables, that they don't need
-       to open archive, if there is tail after executable (for SFX cases) */
-    CMyComPtr<IArchiveAllowTail> allowTail;
-    archive.QueryInterface(IID_IArchiveAllowTail, (void **)&allowTail);
-    if (allowTail)
-      allowTail->AllowTail(BoolToInt(true));
-  }
-  if (op.props)
-  {
-    /*
-    FOR_VECTOR (y, op.props)
-    {
-      const COptionalOpenProperties &optProps = (*op.props)[y];
-      if (optProps.FormatName.IsEmpty() || optProps.FormatName.CompareNoCase(ai.Name) == 0)
-      {
-        RINOK(SetProperties(archive, optProps.Props));
-        break;
-      }
-    }
-    */
-    RINOK(SetProperties(archive, *op.props));
-  }
-  #endif
-  return S_OK;
-}
-#ifndef _SFX
-static HRESULT ReadParseItemProps(IInArchive *archive, const CArcInfoEx &ai, NArchive::NParser::CParseItem &pi)
-{
-  pi.Extension = ai.GetMainExt();
-  pi.FileTime_Defined = false;
-  pi.ArcType = ai.Name;
-  RINOK(Archive_GetArcBoolProp(archive, kpidIsNotArcType, pi.IsNotArcType));
-  // RINOK(Archive_GetArcBoolProp(archive, kpidIsSelfExe, pi.IsSelfExe));
-  pi.IsSelfExe = ai.Flags_PreArc();
-  {
-    NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidMTime, &prop));
-    if (prop.vt == VT_FILETIME)
-    {
-      pi.FileTime_Defined = true;
-      pi.FileTime = prop.filetime;
-    }
-  }
-  if (!pi.FileTime_Defined)
-  {
-    NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidCTime, &prop));
-    if (prop.vt == VT_FILETIME)
-    {
-      pi.FileTime_Defined = true;
-      pi.FileTime = prop.filetime;
-    }
-  }
-  {
-    NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidName, &prop));
-    if (prop.vt == VT_BSTR)
-    {
-      pi.Name.SetFromBstr(prop.bstrVal);
-      pi.Extension.Empty();
-    }
-    else
-    {
-      RINOK(archive->GetArchiveProperty(kpidExtension, &prop));
-      if (prop.vt == VT_BSTR)
-        pi.Extension.SetFromBstr(prop.bstrVal);
-    }
-  }
-  {
-    NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidShortComment, &prop));
-    if (prop.vt == VT_BSTR)
-      pi.Comment.SetFromBstr(prop.bstrVal);
-  }
-  UInt32 numItems;
-  RINOK(archive->GetNumberOfItems(&numItems));
-  // pi.NumSubFiles = numItems;
-  // RINOK(Archive_GetArcProp_UInt(archive, kpidUnpackSize, pi.UnpackSize, pi.UnpackSize_Defined));
-  // if (!pi.UnpackSize_Defined)
-  {
-    pi.NumSubFiles = 0;
-    pi.NumSubDirs = 0;
-    pi.UnpackSize = 0;
-    for (UInt32 i = 0; i < numItems; i++)
-    {
-      UInt64 size = 0;
-      bool defined = false;
-      Archive_GetItem_Size(archive, i, size, defined);
-      if (defined)
-      {
-        pi.UnpackSize_Defined = true;
-        pi.UnpackSize += size;
-      }
-      bool isDir = false;
-      Archive_IsItem_Dir(archive, i, isDir);
-      if (isDir)
-        pi.NumSubDirs++;
-      else
-        pi.NumSubFiles++;
-    }
-    if (pi.NumSubDirs != 0)
-      pi.NumSubDirs_Defined = true;
-    pi.NumSubFiles_Defined = true;
-  }
-  return S_OK;
-}
-#endif
-HRESULT CArc::CheckZerosTail(const COpenOptions &op, UInt64 offset)
-{
-  if (!op.stream)
-    return S_OK;
-  RINOK(op.stream->Seek(offset, STREAM_SEEK_SET, NULL));
-  const UInt32 kBufSize = 1 << 11;
-  Byte buf[kBufSize];
-  for (;;)
-  {
-    UInt32 processed = 0;
-    RINOK(op.stream->Read(buf, kBufSize, &processed));
-    if (processed == 0)
-    {
-      // ErrorInfo.NonZerosTail = false;
-      ErrorInfo.IgnoreTail = true;
-      return S_OK;
-    }
-    for (size_t i = 0; i < processed; i++)
-    {
-      if (buf[i] != 0)
-      {
-        // ErrorInfo.IgnoreTail = false;
-        // ErrorInfo.NonZerosTail = true;
-        return S_OK;
-      }
-    }
-  }
-}
-#ifndef _SFX
-class CExtractCallback_To_OpenCallback:
-  public IArchiveExtractCallback,
-  public ICompressProgressInfo,
-  public CMyUnknownImp
-{
-public:
-  CMyComPtr<IArchiveOpenCallback> Callback;
-  UInt64 Files;
-  UInt64 Offset;
-  MY_UNKNOWN_IMP2(IArchiveExtractCallback, ICompressProgressInfo)
-  INTERFACE_IArchiveExtractCallback(;)
-  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
-  void Init(IArchiveOpenCallback *callback)
-  {
-    Callback = callback;
-    Files = 0;
-    Offset = 0;
-  }
-};
-STDMETHODIMP CExtractCallback_To_OpenCallback::SetTotal(UInt64 /* size */)
-{
-  return S_OK;
-}
-STDMETHODIMP CExtractCallback_To_OpenCallback::SetCompleted(const UInt64 * /* completeValue */)
-{
-  return S_OK;
-}
-STDMETHODIMP CExtractCallback_To_OpenCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */)
-{
-  if (Callback)
-  {
-    UInt64 value = Offset;
-    if (inSize)
-      value += *inSize;
-    return Callback->SetCompleted(&Files, &value);
-  }
-  return S_OK;
-}
-STDMETHODIMP CExtractCallback_To_OpenCallback::GetStream(UInt32 /* index */, ISequentialOutStream **outStream, Int32 /* askExtractMode */)
-{
-  *outStream = 0;
-  return S_OK;
-}
-STDMETHODIMP CExtractCallback_To_OpenCallback::PrepareOperation(Int32 /* askExtractMode */)
-{
-  return S_OK;
-}
-STDMETHODIMP CExtractCallback_To_OpenCallback::SetOperationResult(Int32 /* operationResult */)
-{
-  return S_OK;
-}
-static HRESULT OpenArchiveSpec(IInArchive *archive, bool needPhySize,
-    IInStream *stream, const UInt64 *maxCheckStartPosition,
-    IArchiveOpenCallback *openCallback,
-    IArchiveExtractCallback *extractCallback)
-{
-  /*
-  if (needPhySize)
-  {
-    CMyComPtr<IArchiveOpen2> open2;
-    archive->QueryInterface(IID_IArchiveOpen2, (void **)&open2);
-    if (open2)
-      return open2->ArcOpen2(stream, kOpenFlags_RealPhySize, openCallback);
-  }
-  */
-  RINOK(archive->Open(stream, maxCheckStartPosition, openCallback));
-  if (needPhySize)
-  {
-    bool phySize_Defined = false;
-    UInt64 phySize = 0;
-    RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, phySize, phySize_Defined));
-    if (phySize_Defined)
-      return S_OK;
-    bool phySizeCantBeDetected = false;;
-    RINOK(Archive_GetArcBoolProp(archive, kpidPhySizeCantBeDetected, phySizeCantBeDetected));
-    if (!phySizeCantBeDetected)
-    {
-      RINOK(archive->Extract(0, (UInt32)(Int32)-1, BoolToInt(true), extractCallback));
-    }
-  }
-  return S_OK;
-}
-static int FindFormatForArchiveType(CCodecs *codecs, CIntVector orderIndices, const char *name)
-{
-  FOR_VECTOR (i, orderIndices)
-    if (StringsAreEqualNoCase_Ascii(codecs->Formats[orderIndices[i]].Name, name))
-      return i;
-  return -1;
-}
-#endif
-HRESULT CArc::OpenStream2(const COpenOptions &op)
-{
-  // fprintf(stdout, "\nOpen: %S", Path); fflush(stdout);
-  Archive.Release();
-  GetRawProps.Release();
-  GetRootProps.Release();
-  ErrorInfo.ClearErrors();
-  ErrorInfo.ErrorFormatIndex = -1;
-  IsParseArc = false;
-  ArcStreamOffset = 0;
-  // OutputDebugStringA("1");
-  // OutputDebugStringW(Path);
-  const UString fileName = ExtractFileNameFromPath(Path);
-  UString extension;
-  {
-    int dotPos = fileName.ReverseFind_Dot();
-    if (dotPos >= 0)
-      extension = fileName.Ptr(dotPos + 1);
-  }
-  CIntVector orderIndices;
-  bool searchMarkerInHandler = false;
-  #ifdef _SFX
-    searchMarkerInHandler = true;
-  #endif
-  CBoolArr isMainFormatArr(op.codecs->Formats.Size());
-  {
-    FOR_VECTOR(i, op.codecs->Formats)
-      isMainFormatArr[i] = false;
-  }
-  UInt64 maxStartOffset =
-      op.openType.MaxStartOffset_Defined ?
-      op.openType.MaxStartOffset :
-      kMaxCheckStartPosition;
-  #ifndef _SFX
-  bool isUnknownExt = false;
-  #endif
-  bool isForced = false;
-  unsigned numMainTypes = 0;
-  int formatIndex = op.openType.FormatIndex;
-  if (formatIndex >= 0)
-  {
-    isForced = true;
-    orderIndices.Add(formatIndex);
-    numMainTypes = 1;
-    isMainFormatArr[(unsigned)formatIndex] = true;
-    searchMarkerInHandler = true;
-  }
-  else
-  {
-    unsigned numFinded = 0;
-    #ifndef _SFX
-    bool isPrearcExt = false;
-    #endif
-    {
-      #ifndef _SFX
-      bool isZip = false;
-      bool isRar = false;
-      const wchar_t c = extension[0];
-      if (c == 'z' || c == 'Z' || c == 'r' || c == 'R')
-      {
-        bool isNumber = false;
-        for (unsigned k = 1;; k++)
-        {
-          const wchar_t d = extension[k];
-          if (d == 0)
-            break;
-          if (d < '0' || d > '9')
-          {
-            isNumber = false;
-            break;
-          }
-          isNumber = true;
-        }
-        if (isNumber)
-          if (c == 'z' || c == 'Z')
-            isZip = true;
-          else
-            isRar = true;
-      }
-      #endif
-      FOR_VECTOR (i, op.codecs->Formats)
-      {
-        const CArcInfoEx &ai = op.codecs->Formats[i];
-        if (IgnoreSplit || !op.openType.CanReturnArc)
-          if (ai.IsSplit())
-            continue;
-        if (op.excludedFormats->FindInSorted(i) >= 0)
-          continue;
-        #ifndef _SFX
-        if (IsPreArcFormat(ai))
-          isPrearcExt = true;
-        #endif
-        if (ai.FindExtension(extension) >= 0
-            #ifndef _SFX
-            || isZip && StringsAreEqualNoCase_Ascii(ai.Name, "zip")
-            || isRar && StringsAreEqualNoCase_Ascii(ai.Name, "rar")
-            #endif
-            )
-        {
-          // PrintNumber("orderIndices.Insert", i);
-          orderIndices.Insert(numFinded++, i);
-          isMainFormatArr[i] = true;
-        }
-        else
-          orderIndices.Add(i);
-      }
-    }
-    if (!op.stream)
-    {
-      if (numFinded != 1)
-        return E_NOTIMPL;
-      orderIndices.DeleteFrom(1);
-    }
-    // PrintNumber("numFinded", numFinded );
-    /*
-    if (op.openOnlySpecifiedByExtension)
-    {
-      if (numFinded != 0 && !IsExeExt(extension))
-        orderIndices.DeleteFrom(numFinded);
-    }
-    */
-    #ifndef _SFX
-      if (op.stream && orderIndices.Size() >= 2)
-      {
-        RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
-        CByteBuffer byteBuffer;
-        CIntVector orderIndices2;
-        if (numFinded == 0 || IsExeExt(extension))
-        {
-          // signature search was here
-        }
-        else if (extension.IsEqualTo("000") || extension.IsEqualTo("001"))
-        {
-          int i = FindFormatForArchiveType(op.codecs, orderIndices, "rar");
-          if (i >= 0)
-          {
-            const size_t kBufSize = (1 << 10);
-            byteBuffer.Alloc(kBufSize);
-            size_t processedSize = kBufSize;
-            RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
-            if (processedSize >= 16)
-            {
-              const Byte *buf = byteBuffer;
-              const Byte kRarHeader[] = { 0x52 , 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00 };
-              if (TestSignature(buf, kRarHeader, 7) && buf[9] == 0x73 && (buf[10] & 1) != 0)
-              {
-                orderIndices2.Add(orderIndices[i]);
-                orderIndices[i] = -1;
-                if (i >= (int)numFinded)
-                  numFinded++;
-              }
-            }
-          }
-        }
-        else
-        {
-          const size_t kBufSize = (1 << 10);
-          byteBuffer.Alloc(kBufSize);
-          size_t processedSize = kBufSize;
-          RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
-          if (processedSize == 0)
-            return S_FALSE;
-          /*
-          check type order:
-            1) matched extension, no signuature
-            2) matched extension, matched signuature
-            // 3) no signuature
-            // 4) matched signuature
-          */
-          MakeCheckOrder(op.codecs, orderIndices, numFinded, orderIndices2, NULL, 0);
-          MakeCheckOrder(op.codecs, orderIndices, numFinded, orderIndices2, byteBuffer, processedSize);
-          // MakeCheckOrder(op.codecs, orderIndices, orderIndices.Size(), orderIndices2, NULL, 0);
-          // MakeCheckOrder(op.codecs, orderIndices, orderIndices.Size(), orderIndices2, byteBuffer, processedSize);
-        }
-        FOR_VECTOR (i, orderIndices)
-        {
-          int val = orderIndices[i];
-          if (val != -1)
-            orderIndices2.Add(val);
-        }
-        orderIndices = orderIndices2;
-      }
-      if (orderIndices.Size() >= 2)
-      {
-        int iIso = FindFormatForArchiveType(op.codecs, orderIndices, "iso");
-        int iUdf = FindFormatForArchiveType(op.codecs, orderIndices, "udf");
-        if (iUdf > iIso && iIso >= 0)
-        {
-          int isoIndex = orderIndices[iIso];
-          int udfIndex = orderIndices[iUdf];
-          orderIndices[iUdf] = isoIndex;
-          orderIndices[iIso] = udfIndex;
-        }
-      }
-      numMainTypes = numFinded;
-      isUnknownExt = (numMainTypes == 0) || isPrearcExt;
-    #else // _SFX
-      numMainTypes = orderIndices.Size();
-      // we need correct numMainTypes for mutlivolume SFX (if some volume is missing)
-      if (numFinded != 0)
-        numMainTypes = numFinded;
-    #endif
-  }
-  UInt64 fileSize = 0;
-  if (op.stream)
-  {
-    RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
-    RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
-  }
-  FileSize = fileSize;
-  #ifndef _SFX
-  CBoolArr skipFrontalFormat(op.codecs->Formats.Size());
-  {
-    FOR_VECTOR(i, op.codecs->Formats)
-      skipFrontalFormat[i] = false;
-  }
-  #endif
-  const COpenType &mode = op.openType;
-  if (mode.CanReturnArc)
-  {
-    // ---------- OPEN main type by extenssion ----------
-    unsigned numCheckTypes = orderIndices.Size();
-    if (formatIndex >= 0)
-      numCheckTypes = numMainTypes;
-    for (unsigned i = 0; i < numCheckTypes; i++)
-    {
-      FormatIndex = orderIndices[i];
-      bool exactOnly = false;
-      #ifndef _SFX
-      const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
-      // OutputDebugStringW(ai.Name);
-      if (i >= numMainTypes)
-      {
-        if (!ai.Flags_BackwardOpen()
-            // && !ai.Flags_PureStartOpen()
-            )
-          continue;
-        exactOnly = true;
-      }
-      #endif
-      // Some handlers do not set total bytes. So we set it here
-      if (op.callback)
-        RINOK(op.callback->SetTotal(NULL, &fileSize));
-      if (op.stream)
-      {
-        RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
-      }
-      CMyComPtr<IInArchive> archive;
-      RINOK(PrepareToOpen(op, FormatIndex, archive));
-      if (!archive)
-        continue;
-      HRESULT result;
-      if (op.stream)
-      {
-        UInt64 searchLimit = (!exactOnly && searchMarkerInHandler) ? maxStartOffset: 0;
-        result = archive->Open(op.stream, &searchLimit, op.callback);
-      }
-      else
-      {
-        CMyComPtr<IArchiveOpenSeq> openSeq;
-        archive.QueryInterface(IID_IArchiveOpenSeq, (void **)&openSeq);
-        if (!openSeq)
-          return E_NOTIMPL;
-        result = openSeq->OpenSeq(op.seqStream);
-      }
-      RINOK(ReadBasicProps(archive, 0, result));
-      if (result == S_FALSE)
-      {
-        bool isArc = ErrorInfo.IsArc_After_NonOpen();
-        #ifndef _SFX
-        // if it's archive, we allow another open attempt for parser
-        if (!mode.CanReturnParser || !isArc)
-          skipFrontalFormat[(unsigned)FormatIndex] = true;
-        #endif
-        if (exactOnly)
-          continue;
-        if (i == 0 && numMainTypes == 1)
-        {
-          // we set NonOpenErrorInfo, only if there is only one main format (defined by extension).
-          ErrorInfo.ErrorFormatIndex = FormatIndex;
-          NonOpen_ErrorInfo = ErrorInfo;
-          if (!mode.CanReturnParser && isArc)
-          {
-            // if (formatIndex < 0 && !searchMarkerInHandler)
-            {
-              // if bad archive was detected, we don't need additional open attempts
-              #ifndef _SFX
-              if (!IsPreArcFormat(ai) /* || !mode.SkipSfxStub */)
-              #endif
-                return S_FALSE;
-            }
-          }
-        }
-        /*
-        #ifndef _SFX
-        if (IsExeExt(extension) || ai.Flags_PreArc())
-        {
-        // openOnlyFullArc = false;
-        // canReturnTailArc = true;
-        // limitSignatureSearch = true;
-        }
-        #endif
-        */
-        continue;
-      }
-      RINOK(result);
-      #ifndef _SFX
-      bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
-      const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
-      bool thereIsTail = ErrorInfo.ThereIsTail;
-      if (thereIsTail && mode.ZerosTailIsAllowed)
-      {
-        RINOK(CheckZerosTail(op, Offset + PhySize));
-        if (ErrorInfo.IgnoreTail)
-          thereIsTail = false;
-      }
-      if (Offset > 0)
-      {
-        if (exactOnly
-            || !searchMarkerInHandler
-            || !specFlags.CanReturn_NonStart()
-            || (mode.MaxStartOffset_Defined && (UInt64)Offset > mode.MaxStartOffset))
-          continue;
-      }
-      if (thereIsTail)
-      {
-        if (Offset > 0)
-        {
-          if (!specFlags.CanReturnMid)
-            continue;
-        }
-        else if (!specFlags.CanReturnFrontal)
-          continue;
-      }
-      if (Offset > 0 || thereIsTail)
-      {
-        if (formatIndex < 0)
-        {
-          if (IsPreArcFormat(ai))
-          {
-            // openOnlyFullArc = false;
-            // canReturnTailArc = true;
-            /*
-            if (mode.SkipSfxStub)
-            limitSignatureSearch = true;
-            */
-            // if (mode.SkipSfxStub)
-            {
-              // skipFrontalFormat[FormatIndex] = true;
-              continue;
-            }
-          }
-        }
-      }
-      #endif
-      Archive = archive;
-      return S_OK;
-    }
-  }
-  #ifndef _SFX
-  if (!op.stream)
-    return S_FALSE;
-  if (formatIndex >= 0 && !mode.CanReturnParser)
-  {
-    if (mode.MaxStartOffset_Defined)
-    {
-      if (mode.MaxStartOffset == 0)
-        return S_FALSE;
-    }
-    else
-    {
-      const CArcInfoEx &ai = op.codecs->Formats[(unsigned)formatIndex];
-      if (ai.FindExtension(extension) >= 0)
-      {
-        if (ai.Flags_FindSignature() && searchMarkerInHandler)
-          return S_FALSE;
-      }
-    }
-  }
-  NArchive::NParser::CHandler *handlerSpec = new NArchive::NParser::CHandler;
-  CMyComPtr<IInArchive> handler = handlerSpec;
-  CExtractCallback_To_OpenCallback *extractCallback_To_OpenCallback_Spec = new CExtractCallback_To_OpenCallback;
-  CMyComPtr<IArchiveExtractCallback> extractCallback_To_OpenCallback = extractCallback_To_OpenCallback_Spec;
-  extractCallback_To_OpenCallback_Spec->Init(op.callback);
-  {
-    // ---------- Check all possible START archives ----------
-    // this code is better for full file archives than Parser's code.
-    CByteBuffer byteBuffer;
-    bool endOfFile = false;
-    size_t processedSize;
-    {
-      size_t bufSize = 1 << 20; // it must be larger than max signature offset or IsArcFunc offset ((1 << 19) + x for UDF)
-      if (bufSize > fileSize)
-      {
-        bufSize = (size_t)fileSize;
-        endOfFile = true;
-      }
-      byteBuffer.Alloc(bufSize);
-      RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
-      processedSize = bufSize;
-      RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
-      if (processedSize == 0)
-        return S_FALSE;
-      if (processedSize < bufSize)
-        endOfFile = true;
-    }
-    CUIntVector sortedFormats;
-    unsigned i;
-    int splitIndex = -1;
-    for (i = 0; i < orderIndices.Size(); i++)
-    {
-      unsigned form = orderIndices[i];
-      if (skipFrontalFormat[form])
-        continue;
-      const CArcInfoEx &ai = op.codecs->Formats[form];
-      if (ai.IsSplit())
-      {
-        splitIndex = form;
-        continue;
-      }
-      if (ai.IsArcFunc)
-      {
-        UInt32 isArcRes = ai.IsArcFunc(byteBuffer, processedSize);
-        if (isArcRes == k_IsArc_Res_NO)
-          continue;
-        if (isArcRes == k_IsArc_Res_NEED_MORE && endOfFile)
-          continue;
-        // if (isArcRes == k_IsArc_Res_YES_LOW_PROB) continue;
-        sortedFormats.Insert(0, form);
-        continue;
-      }
-      bool isNewStyleSignature = IsNewStyleSignature(ai);
-      bool needCheck = !isNewStyleSignature
-          || ai.Signatures.IsEmpty()
-          || ai.Flags_PureStartOpen()
-          || ai.Flags_StartOpen()
-          || ai.Flags_BackwardOpen();
-      if (isNewStyleSignature && !ai.Signatures.IsEmpty())
-      {
-        unsigned k;
-        for (k = 0; k < ai.Signatures.Size(); k++)
-        {
-          const CByteBuffer &sig = ai.Signatures[k];
-          UInt32 signatureEnd = ai.SignatureOffset + (UInt32)sig.Size();
-          if (processedSize < signatureEnd)
-          {
-            if (!endOfFile)
-              needCheck = true;
-          }
-          else if (memcmp(sig, byteBuffer + ai.SignatureOffset, sig.Size()) == 0)
-            break;
-        }
-        if (k != ai.Signatures.Size())
-        {
-          sortedFormats.Insert(0, form);
-          continue;
-        }
-      }
-      if (needCheck)
-        sortedFormats.Add(form);
-    }
-    if (splitIndex >= 0)
-      sortedFormats.Insert(0, splitIndex);
-    for (i = 0; i < sortedFormats.Size(); i++)
-    {
-      FormatIndex = sortedFormats[i];
-      const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
-      if (op.callback)
-        RINOK(op.callback->SetTotal(NULL, &fileSize));
-      RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
-      CMyComPtr<IInArchive> archive;
-      RINOK(PrepareToOpen(op, FormatIndex, archive));
-      if (!archive)
-        continue;
-      PRF(printf("\nSorted Open %S", (const wchar_t *)ai.Name));
-      HRESULT result;
-      {
-        UInt64 searchLimit = 0;
-        /*
-        if (mode.CanReturnArc)
-          result = archive->Open(op.stream, &searchLimit, op.callback);
-        else
-        */
-        result = OpenArchiveSpec(archive, !mode.CanReturnArc, op.stream, &searchLimit, op.callback, extractCallback_To_OpenCallback);
-      }
-      if (result == S_FALSE)
-      {
-        skipFrontalFormat[(unsigned)FormatIndex] = true;
-        // FIXME: maybe we must use LenIsUnknown.
-        // printf("  OpenForSize Error");
-        continue;
-      }
-      RINOK(result);
-      RINOK(ReadBasicProps(archive, 0, result));
-      if (Offset > 0)
-      {
-        continue; // good handler doesn't return such Offset > 0
-        // but there are some cases like false prefixed PK00 archive, when
-        // we can support it?
-      }
-      NArchive::NParser::CParseItem pi;
-      pi.Offset = Offset;
-      pi.Size = AvailPhySize;
-      // bool needScan = false;
-      if (!PhySizeDefined)
-      {
-        // it's for Z format
-        pi.LenIsUnknown = true;
-        // needScan = true;
-        // phySize = arcRem;
-        // nextNeedCheckStartOpen = false;
-      }
-      /*
-      if (OkPhySize_Defined)
-        pi.OkSize = pi.OkPhySize;
-      else
-        pi.OkSize = pi.Size;
-      */
-      pi.NormalizeOffset();
-      // printf("  phySize = %8d", (unsigned)phySize);
-      if (mode.CanReturnArc)
-      {
-        bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
-        const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
-        bool openCur = false;
-        if (!ErrorInfo.ThereIsTail)
-          openCur = true;
-        else
-        {
-          if (mode.ZerosTailIsAllowed)
-          {
-            RINOK(CheckZerosTail(op, Offset + PhySize));
-            if (ErrorInfo.IgnoreTail)
-              openCur = true;
-          }
-          if (!openCur)
-          {
-            openCur = specFlags.CanReturnFrontal;
-            if (formatIndex < 0) // format is not forced
-            {
-              if (IsPreArcFormat(ai))
-              {
-                // if (mode.SkipSfxStub)
-                {
-                  openCur = false;
-                }
-              }
-            }
-          }
-        }
-        if (openCur)
-        {
-          InStream = op.stream;
-          Archive = archive;
-          return S_OK;
-        }
-      }
-      skipFrontalFormat[(unsigned)FormatIndex] = true;
-      // if (!mode.CanReturnArc)
-      /*
-      if (!ErrorInfo.ThereIsTail)
-          continue;
-      */
-      if (pi.Offset == 0 && !pi.LenIsUnknown && pi.Size >= FileSize)
-        continue;
-      // printf("\nAdd offset = %d", (int)pi.Offset);
-      RINOK(ReadParseItemProps(archive, ai, pi));
-      handlerSpec->AddItem(pi);
-    }
-  }
-  // ---------- PARSER ----------
-  CUIntVector arc2sig; // formatIndex to signatureIndex
-  CUIntVector sig2arc; // signatureIndex to formatIndex;
-  {
-    unsigned sum = 0;
-    FOR_VECTOR (i, op.codecs->Formats)
-    {
-      arc2sig.Add(sum);
-      const CObjectVector<CByteBuffer> &sigs = op.codecs->Formats[i].Signatures;
-      sum += sigs.Size();
-      FOR_VECTOR (k, sigs)
-        sig2arc.Add(i);
-    }
-  }
-  {
-    const size_t kBeforeSize = 1 << 16;
-    const size_t kAfterSize  = 1 << 20;
-    const size_t kBufSize = 1 << 22; // it must be more than kBeforeSize + kAfterSize
-    const UInt32 kNumVals = (UInt32)1 << (kNumHashBytes * 8);
-    CByteArr hashBuffer(kNumVals);
-    Byte *hash = hashBuffer;
-    memset(hash, 0xFF, kNumVals);
-    Byte prevs[256];
-    memset(prevs, 0xFF, sizeof(prevs));
-    if (sig2arc.Size() >= 0xFF)
-      return S_FALSE;
-    CUIntVector difficultFormats;
-    CBoolArr difficultBools(256);
-    {
-      for (unsigned i = 0; i < 256; i++)
-        difficultBools[i] = false;
-    }
-    bool thereAreHandlersForSearch = false;
-    // UInt32 maxSignatureEnd = 0;
-    FOR_VECTOR (i, orderIndices)
-    {
-      int index = orderIndices[i];
-      if (index < 0)
-        continue;
-      const CArcInfoEx &ai = op.codecs->Formats[(unsigned)index];
-      bool isDifficult = false;
-      // if (ai.Version < 0x91F) // we don't use parser with old DLL (before 9.31)
-      if (!ai.NewInterface)
-        isDifficult = true;
-      else
-      {
-        if (ai.Flags_StartOpen())
-          isDifficult = true;
-        FOR_VECTOR (k, ai.Signatures)
-        {
-          const CByteBuffer &sig = ai.Signatures[k];
-          /*
-          UInt32 signatureEnd = ai.SignatureOffset + (UInt32)sig.Size();
-          if (maxSignatureEnd < signatureEnd)
-            maxSignatureEnd = signatureEnd;
-          */
-          if (sig.Size() < kNumHashBytes)
-          {
-            isDifficult = true;
-            continue;
-          }
-          thereAreHandlersForSearch = true;
-          UInt32 v = HASH_VAL(sig);
-          unsigned sigIndex = arc2sig[(unsigned)index] + k;
-          prevs[sigIndex] = hash[v];
-          hash[v] = (Byte)sigIndex;
-        }
-      }
-      if (isDifficult)
-      {
-        difficultFormats.Add(index);
-        difficultBools[(unsigned)index] = true;
-      }
-    }
-    if (!thereAreHandlersForSearch)
-    {
-      // openOnlyFullArc = true;
-      // canReturnTailArc = true;
-    }
-    RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
-    CLimitedCachedInStream *limitedStreamSpec = new CLimitedCachedInStream;
-    CMyComPtr<IInStream> limitedStream = limitedStreamSpec;
-    limitedStreamSpec->SetStream(op.stream);
-    CArchiveOpenCallback_Offset *openCallback_Offset_Spec = NULL;
-    CMyComPtr<IArchiveOpenCallback> openCallback_Offset;
-    if (op.callback)
-    {
-      openCallback_Offset_Spec = new CArchiveOpenCallback_Offset;
-      openCallback_Offset = openCallback_Offset_Spec;
-      openCallback_Offset_Spec->Callback = op.callback;
-      openCallback_Offset_Spec->Callback.QueryInterface(IID_IArchiveOpenVolumeCallback, &openCallback_Offset_Spec->OpenVolumeCallback);
-      #ifndef _NO_CRYPTO
-      openCallback_Offset_Spec->Callback.QueryInterface(IID_ICryptoGetTextPassword, &openCallback_Offset_Spec->GetTextPassword);
-      #endif
-    }
-    if (op.callback)
-      RINOK(op.callback->SetTotal(NULL, &fileSize));
-    CByteBuffer &byteBuffer = limitedStreamSpec->Buffer;
-    byteBuffer.Alloc(kBufSize);
-    UInt64 callbackPrev = 0;
-    bool needCheckStartOpen = true; // = true, if we need to test all archives types for current pos.
-    bool endOfFile = false;
-    UInt64 bufPhyPos = 0;
-    size_t bytesInBuf = 0;
-    // UInt64 prevPos = 0;
-    // ---------- Main Scan Loop ----------
-    UInt64 pos = 0;
-    if (!mode.EachPos && handlerSpec->_items.Size() == 1)
-    {
-      NArchive::NParser::CParseItem &pi = handlerSpec->_items[0];
-      if (!pi.LenIsUnknown && pi.Offset == 0)
-        pos = pi.Size;
-    }
-    for (;;)
-    {
-      // printf("\nPos = %d", (int)pos);
-      UInt64 posInBuf = pos - bufPhyPos;
-      // if (pos > ((UInt64)1 << 35)) break;
-      if (!endOfFile)
-      {
-        if (bytesInBuf < kBufSize)
-        {
-          size_t processedSize = kBufSize - bytesInBuf;
-          // printf("\nRead ask = %d", (unsigned)processedSize);
-          UInt64 seekPos = bufPhyPos + bytesInBuf;
-          RINOK(op.stream->Seek(bufPhyPos + bytesInBuf, STREAM_SEEK_SET, NULL));
-          RINOK(ReadStream(op.stream, byteBuffer + bytesInBuf, &processedSize));
-          // printf("   processed = %d", (unsigned)processedSize);
-          if (processedSize == 0)
-          {
-            fileSize = seekPos;
-            endOfFile = true;
-          }
-          else
-          {
-            bytesInBuf += processedSize;
-            limitedStreamSpec->SetCache(processedSize, (size_t)bufPhyPos);
-          }
-          continue;
-        }
-        if (bytesInBuf < posInBuf)
-        {
-          UInt64 skipSize = posInBuf - bytesInBuf;
-          if (skipSize <= kBeforeSize)
-          {
-            size_t keepSize = (size_t)(kBeforeSize - skipSize);
-            // printf("\nmemmove skip = %d", (int)keepSize);
-            memmove(byteBuffer, byteBuffer + bytesInBuf - keepSize, keepSize);
-            bytesInBuf = keepSize;
-            bufPhyPos = pos - keepSize;
-            continue;
-          }
-          // printf("\nSkip %d", (int)(skipSize - kBeforeSize));
-          // RINOK(op.stream->Seek(skipSize - kBeforeSize, STREAM_SEEK_CUR, NULL));
-          bytesInBuf = 0;
-          bufPhyPos = pos - kBeforeSize;
-          continue;
-        }
-        if (bytesInBuf - posInBuf < kAfterSize)
-        {
-          size_t beg = (size_t)posInBuf - kBeforeSize;
-          // printf("\nmemmove for after beg = %d", (int)beg);
-          memmove(byteBuffer, byteBuffer + beg, bytesInBuf - beg);
-          bufPhyPos += beg;
-          bytesInBuf -= beg;
-          continue;
-        }
-      }
-      if (bytesInBuf <= (size_t)posInBuf)
-        break;
-      bool useOffsetCallback = false;
-      if (openCallback_Offset)
-      {
-        openCallback_Offset_Spec->Files = handlerSpec->_items.Size();
-        openCallback_Offset_Spec->Offset = pos;
-        useOffsetCallback = (!op.openType.CanReturnArc || handlerSpec->_items.Size() > 1);
-        if (pos >= callbackPrev + (1 << 23))
-        {
-          RINOK(openCallback_Offset_Spec->SetCompleted(NULL, NULL));
-          callbackPrev = pos;
-        }
-      }
-      {
-        UInt64 endPos = bufPhyPos + bytesInBuf;
-        if (fileSize < endPos)
-        {
-          FileSize = fileSize; // why ????
-          fileSize = endPos;
-        }
-      }
-      size_t availSize = bytesInBuf - (size_t)posInBuf;
-      if (availSize < kNumHashBytes)
-        break;
-      size_t scanSize = availSize -
-          ((availSize >= kAfterSize) ? kAfterSize : kNumHashBytes);
-      {
-        /*
-        UInt64 scanLimit = openOnlyFullArc ?
-            maxSignatureEnd :
-            op.openType.ScanSize + maxSignatureEnd;
-        */
-        if (!mode.CanReturnParser)
-        {
-          if (pos > maxStartOffset)
-            break;
-          UInt64 remScan = maxStartOffset - pos;
-          if (scanSize > remScan)
-            scanSize = (size_t)remScan;
-        }
-      }
-      scanSize++;
-      const Byte *buf = byteBuffer + (size_t)posInBuf;
-      const Byte *bufLimit = buf + scanSize;
-      size_t ppp = 0;
-      if (!needCheckStartOpen)
-      {
-        for (; buf < bufLimit && hash[HASH_VAL(buf)] == 0xFF; buf++);
-        ppp = buf - (byteBuffer + (size_t)posInBuf);
-        pos += ppp;
-        if (buf == bufLimit)
-          continue;
-      }
-      UInt32 v = HASH_VAL(buf);
-      bool nextNeedCheckStartOpen = true;
-      unsigned i = hash[v];
-      unsigned indexOfDifficult = 0;
-      // ---------- Open Loop for Current Pos ----------
-      bool wasOpen = false;
-      for (;;)
-      {
-        unsigned index;
-        bool isDifficult;
-        if (needCheckStartOpen && indexOfDifficult < difficultFormats.Size())
-        {
-          index = difficultFormats[indexOfDifficult++];
-          isDifficult = true;
-        }
-        else
-        {
-          if (i == 0xFF)
-            break;
-          index = sig2arc[i];
-          unsigned sigIndex = i - arc2sig[index];
-          i = prevs[i];
-          if (needCheckStartOpen && difficultBools[index])
-            continue;
-          const CArcInfoEx &ai = op.codecs->Formats[index];
-          if (pos < ai.SignatureOffset)
-            continue;
-          /*
-          if (openOnlyFullArc)
-            if (pos != ai.SignatureOffset)
-              continue;
-          */
-          const CByteBuffer &sig = ai.Signatures[sigIndex];
-          if (ppp + sig.Size() > availSize
-              || !TestSignature(buf, sig, sig.Size()))
-            continue;
-          // printf("\nSignature OK: %10S %8x %5d", (const wchar_t *)ai.Name, (int)pos, (int)(pos - prevPos));
-          // prevPos = pos;
-          isDifficult = false;
-        }
-        const CArcInfoEx &ai = op.codecs->Formats[index];
-        if ((isDifficult && pos == 0) || ai.SignatureOffset == pos)
-        {
-          // we don't check same archive second time */
-          if (skipFrontalFormat[index])
-            continue;
-        }
-        UInt64 startArcPos = pos;
-        if (!isDifficult)
-        {
-          if (pos < ai.SignatureOffset)
-            continue;
-          startArcPos = pos - ai.SignatureOffset;
-          /*
-          // we don't need the check for Z files
-          if (startArcPos < handlerSpec->GetLastEnd())
-            continue;
-          */
-        }
-        if (ai.IsArcFunc && startArcPos >= bufPhyPos)
-        {
-          size_t offsetInBuf = (size_t)(startArcPos - bufPhyPos);
-          if (offsetInBuf < bytesInBuf)
-          {
-            UInt32 isArcRes = ai.IsArcFunc(byteBuffer + offsetInBuf, bytesInBuf - offsetInBuf);
-            if (isArcRes == k_IsArc_Res_NO)
-              continue;
-            if (isArcRes == k_IsArc_Res_NEED_MORE && endOfFile)
-              continue;
-            /*
-            if (isArcRes == k_IsArc_Res_YES_LOW_PROB)
-            {
-              // if (pos != ai.SignatureOffset)
-              continue;
-            }
-            */
-          }
-          // printf("\nIsArc OK: %S", (const wchar_t *)ai.Name);
-        }
-        /*
-        if (pos == 67109888)
-          pos = pos;
-        */
-        PRF(printf("\npos = %9I64d : %S", pos, (const wchar_t *)ai.Name));
-        bool isMainFormat = isMainFormatArr[index];
-        const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
-        CMyComPtr<IInArchive> archive;
-        RINOK(PrepareToOpen(op, index, archive));
-        if (!archive)
-          return E_FAIL;
-        // OutputDebugStringW(ai.Name);
-        UInt64 rem = fileSize - startArcPos;
-        UInt64 arcStreamOffset = 0;
-        if (ai.Flags_UseGlobalOffset())
-        {
-          limitedStreamSpec->InitAndSeek(0, fileSize);
-          limitedStream->Seek(startArcPos, STREAM_SEEK_SET, NULL);
-        }
-        else
-        {
-          limitedStreamSpec->InitAndSeek(startArcPos, rem);
-          arcStreamOffset = startArcPos;
-        }
-        UInt64 maxCheckStartPosition = 0;
-        if (openCallback_Offset)
-        {
-          openCallback_Offset_Spec->Files = handlerSpec->_items.Size();
-          openCallback_Offset_Spec->Offset = startArcPos;
-        }
-        // HRESULT result = archive->Open(limitedStream, &maxCheckStartPosition, openCallback_Offset);
-        extractCallback_To_OpenCallback_Spec->Files = 0;
-        extractCallback_To_OpenCallback_Spec->Offset = startArcPos;
-        HRESULT result = OpenArchiveSpec(archive, true, limitedStream, &maxCheckStartPosition,
-            useOffsetCallback ? (IArchiveOpenCallback *)openCallback_Offset : (IArchiveOpenCallback *)op.callback,
-            extractCallback_To_OpenCallback);
-        RINOK(ReadBasicProps(archive, ai.Flags_UseGlobalOffset() ? 0 : startArcPos, result));
-        bool isOpen = false;
-        if (result == S_FALSE)
-        {
-          if (!mode.CanReturnParser)
-          {
-            if (formatIndex < 0 && ErrorInfo.IsArc_After_NonOpen())
-            {
-              ErrorInfo.ErrorFormatIndex = index;
-              NonOpen_ErrorInfo = ErrorInfo;
-              // if archive was detected, we don't need additional open attempts
-              return S_FALSE;
-            }
-            continue;
-          }
-          if (!ErrorInfo.IsArc_After_NonOpen() || !PhySizeDefined || PhySize == 0)
-            continue;
-        }
-        else
-        {
-          isOpen = true;
-          RINOK(result);
-          PRF(printf("  OK "));
-        }
-        // fprintf(stderr, "\n %8X  %S", startArcPos, Path);
-        // printf("\nOpen OK: %S", ai.Name);
-        NArchive::NParser::CParseItem pi;
-        pi.Offset = startArcPos;
-        if (ai.Flags_UseGlobalOffset())
-          pi.Offset = Offset;
-        else if (Offset != 0)
-          return E_FAIL;
-        UInt64 arcRem = FileSize - pi.Offset;
-        UInt64 phySize = arcRem;
-        bool phySizeDefined = PhySizeDefined;
-        if (phySizeDefined)
-        {
-          if (pi.Offset + PhySize > FileSize)
-          {
-            // ErrorInfo.ThereIsTail = true;
-            PhySize = FileSize - pi.Offset;
-          }
-          phySize = PhySize;
-        }
-        if (phySize == 0 || (UInt64)phySize > ((UInt64)1 << 63))
-          return E_FAIL;
-        /*
-        if (!ai.UseGlobalOffset)
-        {
-          if (phySize > arcRem)
-          {
-            ThereIsTail = true;
-            phySize = arcRem;
-          }
-        }
-        */
-        bool needScan = false;
-        if (isOpen && !phySizeDefined)
-        {
-          // it's for Z format
-          pi.LenIsUnknown = true;
-          needScan = true;
-          phySize = arcRem;
-          nextNeedCheckStartOpen = false;
-        }
-        pi.Size = phySize;
-        /*
-        if (OkPhySize_Defined)
-          pi.OkSize = OkPhySize;
-        */
-        pi.NormalizeOffset();
-        // printf("  phySize = %8d", (unsigned)phySize);
-        /*
-        if (needSkipFullArc)
-          if (pi.Offset == 0 && phySizeDefined && pi.Size >= fileSize)
-            continue;
-        */
-        if (pi.Offset == 0 && !pi.LenIsUnknown && pi.Size >= FileSize)
-        {
-          // it's possible for dmg archives
-          if (!mode.CanReturnArc)
-            continue;
-        }
-        if (mode.EachPos)
-          pos++;
-        else if (needScan)
-        {
-          pos++;
-          /*
-          if (!OkPhySize_Defined)
-            pos++;
-          else
-            pos = pi.Offset + pi.OkSize;
-          */
-        }
-        else
-          pos = pi.Offset + pi.Size;
-        RINOK(ReadParseItemProps(archive, ai, pi));
-        if (pi.Offset < startArcPos && !mode.EachPos /* && phySizeDefined */)
-        {
-          /* It's for DMG format.
-          This code deletes all previous items that are included to current item */
-          while (!handlerSpec->_items.IsEmpty())
-          {
-            {
-              const NArchive::NParser::CParseItem &back = handlerSpec->_items.Back();
-              if (back.Offset < pi.Offset)
-                break;
-              if (back.Offset + back.Size > pi.Offset + pi.Size)
-                break;
-            }
-            handlerSpec->_items.DeleteBack();
-          }
-        }
-        if (isOpen && mode.CanReturnArc && phySizeDefined)
-        {
-          // if (pi.Offset + pi.Size >= fileSize)
-          bool openCur = false;
-          bool thereIsTail = ErrorInfo.ThereIsTail;
-          if (thereIsTail && mode.ZerosTailIsAllowed)
-          {
-            RINOK(CheckZerosTail(op, arcStreamOffset + Offset + PhySize));
-            if (ErrorInfo.IgnoreTail)
-              thereIsTail = false;
-          }
-          if (pi.Offset != 0)
-          {
-            if (!pi.IsNotArcType)
-              if (thereIsTail)
-                openCur = specFlags.CanReturnMid;
-              else
-                openCur = specFlags.CanReturnTail;
-          }
-          else
-          {
-            if (!thereIsTail)
-              openCur = true;
-            else
-              openCur = specFlags.CanReturnFrontal;
-            if (formatIndex >= -2)
-              openCur = true;
-          }
-          if (formatIndex < 0 && pi.IsSelfExe /* && mode.SkipSfxStub */)
-            openCur = false;
-          // We open file as SFX, if there is front archive or first archive is "Self Executable"
-          if (!openCur && !pi.IsSelfExe && !thereIsTail &&
-              (!pi.IsNotArcType || pi.Offset == 0))
-          {
-            if (handlerSpec->_items.IsEmpty())
-            {
-              if (specFlags.CanReturnTail)
-                openCur = true;
-            }
-            else if (handlerSpec->_items.Size() == 1)
-            {
-              if (handlerSpec->_items[0].IsSelfExe)
-              {
-                if (mode.SpecUnknownExt.CanReturnTail)
-                  openCur = true;
-              }
-            }
-          }
-          if (openCur)
-          {
-            InStream = op.stream;
-            Archive = archive;
-            FormatIndex = index;
-            ArcStreamOffset = arcStreamOffset;
-            return S_OK;
-          }
-        }
-        /*
-        if (openOnlyFullArc)
-        {
-          ErrorInfo.ClearErrors();
-          return S_FALSE;
-        }
-        */
-        pi.FormatIndex = index;
-        // printf("\nAdd offset = %d", (int)pi.Offset);
-        handlerSpec->AddItem(pi);
-        wasOpen = true;
-        break;
-      }
-      // ---------- End of Open Loop for Current Pos ----------
-      if (!wasOpen)
-        pos++;
-      needCheckStartOpen = (nextNeedCheckStartOpen && wasOpen);
-    }
-    // ---------- End of Main Scan Loop ----------
-    /*
-    if (handlerSpec->_items.Size() == 1)
-    {
-      const NArchive::NParser::CParseItem &pi = handlerSpec->_items[0];
-      if (pi.Size == fileSize && pi.Offset == 0)
-      {
-        Archive = archive;
-        FormatIndex2 = pi.FormatIndex;
-        return S_OK;
-      }
-    }
-    */
-    if (mode.CanReturnParser)
-    {
-      bool returnParser = (handlerSpec->_items.Size() == 1); // it's possible if fileSize was not correct at start of parsing
-      handlerSpec->AddUnknownItem(fileSize);
-      if (handlerSpec->_items.Size() == 0)
-        return S_FALSE;
-      if (returnParser || handlerSpec->_items.Size() != 1)
-      {
-        // return S_FALSE;
-        handlerSpec->_stream = op.stream;
-        Archive = handler;
-        ErrorInfo.ClearErrors();
-        IsParseArc = true;
-        FormatIndex = -1; // It's parser
-        Offset = 0;
-        return S_OK;
-      }
-    }
-  }
-  #endif
-  if (!Archive)
-    return S_FALSE;
-  return S_OK;
-}
-HRESULT CArc::OpenStream(const COpenOptions &op)
-{
-  RINOK(OpenStream2(op));
-  // PrintNumber("op.formatIndex 3", op.formatIndex);
-  if (Archive)
-  {
-    GetRawProps.Release();
-    GetRootProps.Release();
-    Archive->QueryInterface(IID_IArchiveGetRawProps, (void **)&GetRawProps);
-    Archive->QueryInterface(IID_IArchiveGetRootProps, (void **)&GetRootProps);
-    RINOK(Archive_GetArcBoolProp(Archive, kpidIsTree, IsTree));
-    RINOK(Archive_GetArcBoolProp(Archive, kpidIsDeleted, Ask_Deleted));
-    RINOK(Archive_GetArcBoolProp(Archive, kpidIsAltStream, Ask_AltStream));
-    RINOK(Archive_GetArcBoolProp(Archive, kpidIsAux, Ask_Aux));
-    RINOK(Archive_GetArcBoolProp(Archive, kpidINode, Ask_INode));
-    RINOK(Archive_GetArcBoolProp(Archive, kpidReadOnly, IsReadOnly));
-    const UString fileName = ExtractFileNameFromPath(Path);
-    UString extension;
-    {
-      int dotPos = fileName.ReverseFind_Dot();
-      if (dotPos >= 0)
-        extension = fileName.Ptr(dotPos + 1);
-    }
-    DefaultName.Empty();
-    if (FormatIndex >= 0)
-    {
-      const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
-      if (ai.Exts.Size() == 0)
-        DefaultName = GetDefaultName2(fileName, UString(), UString());
-      else
-      {
-        int subExtIndex = ai.FindExtension(extension);
-        if (subExtIndex < 0)
-          subExtIndex = 0;
-        const CArcExtInfo &extInfo = ai.Exts[subExtIndex];
-        DefaultName = GetDefaultName2(fileName, extInfo.Ext, extInfo.AddExt);
-      }
-    }
-  }
-  return S_OK;
-}
-#ifdef _SFX
-#ifdef _WIN32
-  #define k_ExeExt ".exe"
-  static const unsigned k_ExeExt_Len = 4;
-#else
-  #define k_ExeExt ""
-  static const unsigned k_ExeExt_Len = 0;
-#endif
-#endif
-HRESULT CArc::OpenStreamOrFile(COpenOptions &op)
-{
-  CMyComPtr<IInStream> fileStream;
-  CMyComPtr<ISequentialInStream> seqStream;
-  CInFileStream *fileStreamSpec = NULL;
-  if (op.stdInMode)
-  {
-    seqStream = new CStdInFileStream;
-    op.seqStream = seqStream;
-  }
-  else if (!op.stream)
-  {
-    fileStreamSpec = new CInFileStream;
-    fileStream = fileStreamSpec;
-    Path = filePath;
-    if (!fileStreamSpec->Open(us2fs(Path)))
-    {
-      return GetLastError();
-    }
-    op.stream = fileStream;
-    #ifdef _SFX
-    IgnoreSplit = true;
-    #endif
-  }
-  /*
-  if (callback)
-  {
-    UInt64 fileSize;
-    RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
-    RINOK(op.callback->SetTotal(NULL, &fileSize))
-  }
-  */
-  HRESULT res = OpenStream(op);
-  IgnoreSplit = false;
-  #ifdef _SFX
-  if (res != S_FALSE
-      || !fileStreamSpec
-      || !op.callbackSpec
-      || NonOpen_ErrorInfo.IsArc_After_NonOpen())
-    return res;
-  {
-    if (filePath.Len() > k_ExeExt_Len
-        && StringsAreEqualNoCase_Ascii(filePath.RightPtr(k_ExeExt_Len), k_ExeExt))
-    {
-      const UString path2 = filePath.Left(filePath.Len() - k_ExeExt_Len);
-      FOR_VECTOR (i, op.codecs->Formats)
-      {
-        const CArcInfoEx &ai = op.codecs->Formats[i];
-        if (ai.IsSplit())
-          continue;
-        UString path3 = path2;
-        path3 += '.';
-        path3 += ai.GetMainExt(); // "7z"  for SFX.
-        Path = path3;
-        Path += ".001";
-        bool isOk = op.callbackSpec->SetSecondFileInfo(us2fs(Path));
-        if (!isOk)
-        {
-          Path = path3;
-          isOk = op.callbackSpec->SetSecondFileInfo(us2fs(Path));
-        }
-        if (isOk)
-        {
-          if (fileStreamSpec->Open(us2fs(Path)))
-          {
-            op.stream = fileStream;
-            NonOpen_ErrorInfo.ClearErrors_Full();
-            if (OpenStream(op) == S_OK)
-              return S_OK;
-          }
-        }
-      }
-    }
-  }
-  #endif
-  return res;
-}
-void CArchiveLink::KeepModeForNextOpen()
-{
-  for (unsigned i = Arcs.Size(); i != 0;)
-  {
-    i--;
-    CMyComPtr<IArchiveKeepModeForNextOpen> keep;
-    Arcs[i].Archive->QueryInterface(IID_IArchiveKeepModeForNextOpen, (void **)&keep);
-    if (keep)
-      keep->KeepModeForNextOpen();
-  }
-}
-HRESULT CArchiveLink::Close()
-{
-  for (unsigned i = Arcs.Size(); i != 0;)
-  {
-    i--;
-    RINOK(Arcs[i].Close());
-  }
-  IsOpen = false;
-  // ErrorsText.Empty();
-  return S_OK;
-}
-void CArchiveLink::Release()
-{
-  // NonOpenErrorFormatIndex = -1;
-  NonOpen_ErrorInfo.ClearErrors();
-  NonOpen_ArcPath.Empty();
-  while (!Arcs.IsEmpty())
-    Arcs.DeleteBack();
-}
-/*
-void CArchiveLink::Set_ErrorsText()
-{
-  FOR_VECTOR(i, Arcs)
-  {
-    const CArc &arc = Arcs[i];
-    if (!arc.ErrorFlagsText.IsEmpty())
-    {
-      if (!ErrorsText.IsEmpty())
-        ErrorsText.Add_LF();
-      ErrorsText += GetUnicodeString(arc.ErrorFlagsText);
-    }
-    if (!arc.ErrorMessage.IsEmpty())
-    {
-      if (!ErrorsText.IsEmpty())
-        ErrorsText.Add_LF();
-      ErrorsText += arc.ErrorMessage;
-    }
-    if (!arc.WarningMessage.IsEmpty())
-    {
-      if (!ErrorsText.IsEmpty())
-        ErrorsText.Add_LF();
-      ErrorsText += arc.WarningMessage;
-    }
-  }
-}
-*/
-HRESULT CArchiveLink::Open(COpenOptions &op)
-{
-  Release();
-  if (op.types->Size() >= 32)
-    return E_NOTIMPL;
-  HRESULT resSpec;
-  for (;;)
-  {
-    resSpec = S_OK;
-    op.openType = COpenType();
-    if (op.types->Size() >= 1)
-    {
-      COpenType latest;
-      if (Arcs.Size() < op.types->Size())
-        latest = (*op.types)[op.types->Size() - Arcs.Size() - 1];
-      else
-      {
-        latest = (*op.types)[0];
-        if (!latest.Recursive)
-          break;
-      }
-      op.openType = latest;
-    }
-    else if (Arcs.Size() >= 32)
-      break;
-    /*
-    op.formatIndex = -1;
-    if (op.types->Size() >= 1)
-    {
-      int latest;
-      if (Arcs.Size() < op.types->Size())
-        latest = (*op.types)[op.types->Size() - Arcs.Size() - 1];
-      else
-      {
-        latest = (*op.types)[0];
-        if (latest != -2 && latest != -3)
-          break;
-      }
-      if (latest >= 0)
-        op.formatIndex = latest;
-      else if (latest == -1 || latest == -2)
-      {
-        // default
-      }
-      else if (latest == -3)
-        op.formatIndex = -2;
-      else
-        op.formatIndex = latest + 2;
-    }
-    else if (Arcs.Size() >= 32)
-      break;
-    */
-    if (Arcs.IsEmpty())
-    {
-      CArc arc;
-      arc.filePath = op.filePath;
-      arc.Path = op.filePath;
-      arc.SubfileIndex = (UInt32)(Int32)-1;
-      HRESULT result = arc.OpenStreamOrFile(op);
-      if (result != S_OK)
-      {
-        if (result == S_FALSE)
-        {
-          NonOpen_ErrorInfo = arc.NonOpen_ErrorInfo;
-          // NonOpenErrorFormatIndex = arc.ErrorFormatIndex;
-          NonOpen_ArcPath = arc.Path;
-        }
-        return result;
-      }
-      Arcs.Add(arc);
-      continue;
-    }
-    // PrintNumber("op.formatIndex 11", op.formatIndex);
-    const CArc &arc = Arcs.Back();
-    if (op.types->Size() > Arcs.Size())
-      resSpec = E_NOTIMPL;
-    UInt32 mainSubfile;
-    {
-      NCOM::CPropVariant prop;
-      RINOK(arc.Archive->GetArchiveProperty(kpidMainSubfile, &prop));
-      if (prop.vt == VT_UI4)
-        mainSubfile = prop.ulVal;
-      else
-        break;
-      UInt32 numItems;
-      RINOK(arc.Archive->GetNumberOfItems(&numItems));
-      if (mainSubfile >= numItems)
-        break;
-    }
-    CMyComPtr<IInArchiveGetStream> getStream;
-    if (arc.Archive->QueryInterface(IID_IInArchiveGetStream, (void **)&getStream) != S_OK || !getStream)
-      break;
-    CMyComPtr<ISequentialInStream> subSeqStream;
-    if (getStream->GetStream(mainSubfile, &subSeqStream) != S_OK || !subSeqStream)
-      break;
-    CMyComPtr<IInStream> subStream;
-    if (subSeqStream.QueryInterface(IID_IInStream, &subStream) != S_OK || !subStream)
-      break;
-    CArc arc2;
-    RINOK(arc.GetItemPath(mainSubfile, arc2.Path));
-    bool zerosTailIsAllowed;
-    RINOK(Archive_GetItemBoolProp(arc.Archive, mainSubfile, kpidZerosTailIsAllowed, zerosTailIsAllowed));
-    if (op.callback)
-    {
-      CMyComPtr<IArchiveOpenSetSubArchiveName> setSubArchiveName;
-      op.callback->QueryInterface(IID_IArchiveOpenSetSubArchiveName, (void **)&setSubArchiveName);
-      if (setSubArchiveName)
-        setSubArchiveName->SetSubArchiveName(arc2.Path);
-    }
-    arc2.SubfileIndex = mainSubfile;
-    // CIntVector incl;
-    CIntVector excl;
-    COpenOptions op2;
-    #ifndef _SFX
-    op2.props = op.props;
-    #endif
-    op2.codecs = op.codecs;
-    // op2.types = &incl;
-    op2.openType = op.openType;
-    op2.openType.ZerosTailIsAllowed = zerosTailIsAllowed;
-    op2.excludedFormats = &excl;
-    op2.stdInMode = false;
-    op2.stream = subStream;
-    op2.filePath = arc2.Path;
-    op2.callback = op.callback;
-    op2.callbackSpec = op.callbackSpec;
-    HRESULT result = arc2.OpenStream(op2);
-    resSpec = (op.types->Size() == 0 ? S_OK : S_FALSE);
-    if (result == S_FALSE)
-    {
-      NonOpen_ErrorInfo = arc2.ErrorInfo;
-      NonOpen_ArcPath = arc2.Path;
-      break;
-    }
-    RINOK(result);
-    RINOK(arc.GetItemMTime(mainSubfile, arc2.MTime, arc2.MTimeDefined));
-    Arcs.Add(arc2);
-  }
-  IsOpen = !Arcs.IsEmpty();
-  return resSpec;
-}
-HRESULT CArchiveLink::Open2(COpenOptions &op, IOpenCallbackUI *callbackUI)
-{
-  VolumesSize = 0;
-  COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
-  CMyComPtr<IArchiveOpenCallback> callback = openCallbackSpec;
-  openCallbackSpec->Callback = callbackUI;
-  FString prefix, name;
-  if (!op.stream && !op.stdInMode)
-  {
-    NFile::NDir::GetFullPathAndSplit(us2fs(op.filePath), prefix, name);
-    openCallbackSpec->Init(prefix, name);
-  }
-  else
-  {
-    openCallbackSpec->SetSubArchiveName(op.filePath);
-  }
-  op.callback = callback;
-  op.callbackSpec = openCallbackSpec;
-  HRESULT res = Open(op);
-  PasswordWasAsked = openCallbackSpec->PasswordWasAsked;
-  // Password = openCallbackSpec->Password;
-  RINOK(res);
-  // VolumePaths.Add(fs2us(prefix + name));
-  FOR_VECTOR (i, openCallbackSpec->FileNames_WasUsed)
-  {
-    if (openCallbackSpec->FileNames_WasUsed[i])
-    {
-      VolumePaths.Add(fs2us(prefix) + openCallbackSpec->FileNames[i]);
-      VolumesSize += openCallbackSpec->FileSizes[i];
-    }
-  }
-  // VolumesSize = openCallbackSpec->TotalSize;
-  return S_OK;
-}
-HRESULT CArc::ReOpen(const COpenOptions &op)
-{
-  ErrorInfo.ClearErrors();
-  ErrorInfo.ErrorFormatIndex = -1;
-  UInt64 fileSize = 0;
-  if (op.stream)
-  {
-    RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
-    RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
-  }
-  FileSize = fileSize;
-  CMyComPtr<IInStream> stream2;
-  Int64 globalOffset = GetGlobalOffset();
-  if (globalOffset <= 0)
-    stream2 = op.stream;
-  else
-  {
-    CTailInStream *tailStreamSpec = new CTailInStream;
-    stream2 = tailStreamSpec;
-    tailStreamSpec->Stream = op.stream;
-    tailStreamSpec->Offset = globalOffset;
-    tailStreamSpec->Init();
-    RINOK(tailStreamSpec->SeekToStart());
-  }
-  // There are archives with embedded STUBs (like ZIP), so we must support signature scanning
-  // But for another archives we can use 0 here. So the code can be fixed !!!
-  UInt64 maxStartPosition = kMaxCheckStartPosition;
-  HRESULT res = Archive->Open(stream2, &maxStartPosition, op.callback);
-  if (res == S_OK)
-  {
-    RINOK(ReadBasicProps(Archive, globalOffset, res));
-    ArcStreamOffset = globalOffset;
-    if (ArcStreamOffset != 0)
-      InStream = op.stream;
-  }
-  return res;
-}
-HRESULT CArchiveLink::Open3(COpenOptions &op, IOpenCallbackUI *callbackUI)
-{
-  HRESULT res = Open2(op, callbackUI);
-  if (callbackUI)
-  {
-    RINOK(callbackUI->Open_Finished());
-  }
-  return res;
-}
-HRESULT CArchiveLink::ReOpen(COpenOptions &op)
-{
-  if (Arcs.Size() > 1)
-    return E_NOTIMPL;
-  CObjectVector<COpenType> inc;
-  CIntVector excl;
-  op.types = &inc;
-  op.excludedFormats = &excl;
-  op.stdInMode = false;
-  op.stream = NULL;
-  if (Arcs.Size() == 0) // ???
-    return Open2(op, NULL);
-  COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
-  CMyComPtr<IArchiveOpenCallback> openCallbackNew = openCallbackSpec;
-  openCallbackSpec->Callback = NULL;
-  openCallbackSpec->ReOpenCallback = op.callback;
-  {
-    FString dirPrefix, fileName;
-    NFile::NDir::GetFullPathAndSplit(us2fs(op.filePath), dirPrefix, fileName);
-    openCallbackSpec->Init(dirPrefix, fileName);
-  }
-  CInFileStream *fileStreamSpec = new CInFileStream;
-  CMyComPtr<IInStream> stream(fileStreamSpec);
-  if (!fileStreamSpec->Open(us2fs(op.filePath)))
-    return GetLastError();
-  op.stream = stream;
-  CArc &arc = Arcs[0];
-  HRESULT res = arc.ReOpen(op);
-  PasswordWasAsked = openCallbackSpec->PasswordWasAsked;
-  // Password = openCallbackSpec->Password;
-  IsOpen = (res == S_OK);
-  return res;
-}
-#ifndef _SFX
-bool ParseComplexSize(const wchar_t *s, UInt64 &result)
-{
-  result = 0;
-  const wchar_t *end;
-  UInt64 number = ConvertStringToUInt64(s, &end);
-  if (end == s)
-    return false;
-  if (*end == 0)
-  {
-    result = number;
-    return true;
-  }
-  if (end[1] != 0)
-    return false;
-  unsigned numBits;
-  switch (MyCharLower_Ascii(*end))
-  {
-    case 'b': result = number; return true;
-    case 'k': numBits = 10; break;
-    case 'm': numBits = 20; break;
-    case 'g': numBits = 30; break;
-    case 't': numBits = 40; break;
-    default: return false;
-  }
-  if (number >= ((UInt64)1 << (64 - numBits)))
-    return false;
-  result = number << numBits;
-  return true;
-}
-static bool ParseTypeParams(const UString &s, COpenType &type)
-{
-  if (s[0] == 0)
-    return true;
-  if (s[1] == 0)
-  {
-    switch ((unsigned)(Byte)s[0])
-    {
-      case 'e': type.EachPos = true; return true;
-      case 'a': type.CanReturnArc = true; return true;
-      case 'r': type.Recursive = true; return true;
-    }
-    return false;
-  }
-  if (s[0] == 's')
-  {
-    UInt64 result;
-    if (!ParseComplexSize(s.Ptr(1), result))
-      return false;
-    type.MaxStartOffset = result;
-    type.MaxStartOffset_Defined = true;
-    return true;
-  }
-  return false;
-}
-bool ParseType(CCodecs &codecs, const UString &s, COpenType &type)
-{
-  int pos2 = s.Find(L':');
-  {
-  UString name;
-  if (pos2 < 0)
-  {
-    name = s;
-    pos2 = s.Len();
-  }
-  else
-  {
-    name = s.Left(pos2);
-    pos2++;
-  }
-  int index = codecs.FindFormatForArchiveType(name);
-  type.Recursive = false;
-  if (index < 0)
-  {
-    if (name[0] == '*')
-    {
-      if (name[1] != 0)
-        return false;
-    }
-    else if (name[0] == '#')
-    {
-      if (name[1] != 0)
-        return false;
-      type.CanReturnArc = false;
-      type.CanReturnParser = true;
-    }
-    else
-      return false;
-  }
-  type.FormatIndex = index;
-  }
-  for (unsigned i = pos2; i < s.Len();)
-  {
-    int next = s.Find(L':', i);
-    if (next < 0)
-      next = s.Len();
-    const UString name = s.Mid(i, next - i);
-    if (name.IsEmpty())
-      return false;
-    if (!ParseTypeParams(name, type))
-      return false;
-    i = next + 1;
-  }
-  return true;
-}
-bool ParseOpenTypes(CCodecs &codecs, const UString &s, CObjectVector<COpenType> &types)
-{
-  types.Clear();
-  for (unsigned pos = 0; pos < s.Len();)
-  {
-    int pos2 = s.Find(L'.', pos);
-    if (pos2 < 0)
-      pos2 = s.Len();
-    UString name = s.Mid(pos, pos2 - pos);
-    if (name.IsEmpty())
-      return false;
-    COpenType type;
-    if (!ParseType(codecs, name, type))
-      return false;
-    types.Add(type);
-    pos = pos2 + 1;
-  }
-  return true;
-}
-#endif