-                                             const Message_ProgressRange& theRange = Message_ProgressRange());
+                                             const Message_ProgressRange& theRange = Message_ProgressRange(),
+                                             const Standard_Boolean theIsMultiThread = Standard_False);

-  Standard_EXPORT Standard_Boolean Perform(const Message_ProgressRange& theRange = Message_ProgressRange());
+  Standard_EXPORT Standard_Boolean Perform(const Message_ProgressRange& theRange = Message_ProgressRange(),
+                                           const Standard_Boolean theIsMultiThread = Standard_False);

+    myMutex.reset(new Standard_HMutex());
...
+    myMutex = NULL;

+  VertexTask(Standard_Integer theFirtsIndex,
+             Standard_Integer theLastIndex,
+             std::vector<BRepExtrema_SolutionElem>* theSolutionsShape1,
+             std::vector<BRepExtrema_SolutionElem>* theSolutionsShape2,
+             const TopTools_IndexedMapOfShape* theMap1,
+             const TopTools_IndexedMapOfShape* theMap2,
+             const std::vector<Bnd_Box>* theLBox1,
+             const std::vector<Bnd_Box>* theLBox2,
+             const Message_ProgressRange theRange,
+             Standard_Boolean* theIsBreak,
+             Standard_Real* theDistRef,
+             Standard_Real theEps,
+             Handle(Standard_HMutex) theMutex)

+
+  Standard_Integer myFirtsIndex;
+  Standard_Integer myLastIndex;
+  std::vector<BRepExtrema_SolutionElem>* mySolutionsShape1;

+        Standard_Atomic_CompareAndSwap((int*) *theTask.myIsBreak, Standard_False, Standard_True);

+          else if (fabs(aDistTool.DistValue() - myDistRef) < myEps)
...
+        if (aDist < myDistRef - myEps || fabs (aDist - myDistRef) < myEps)

+  if (myMutex.IsNull())
+  {
+  Message_ProgressRange aBoxRange(aTwinScope.Next());
+    Message_ProgressScope aBoxScope(aBoxRange, NULL, aCount1);

+    OSD_Parallel::ForEach(aTaskArray.begin(), aTaskArray.end(), DistancePairFunctor(), Standard_False);

+      const gp_Pnt& aPnt = BRep_Tool::Pnt(aVertex);

+    SolidTreatmentMulty(theShape, theVertexMap, theRange);

+        if ((*it).Dist() > myDistRef + myEps)

+  if (n >= 5 && strncmp(a[4], "-", 1))

+  Standard_Boolean anIsMultiThread = Standard_False;

-  BRepExtrema_SeqOfSolution SeqSolShape1;
-  BRepExtrema_SeqOfSolution SeqSolShape2;
+  std::vector<BRepExtrema_SolutionElem> SeqSolShape1;
+  std::vector<BRepExtrema_SolutionElem> SeqSolShape2;

  if (n >= 5 && strncmp(a[4], "-", 1))

  for (Standard_Integer anAI = 4; anAI < n; anAI++)

    for (Standard_Integer i1 = 0; i1 < dst.NbSolution(); i1++)

  if (theIsMultiThread && myMutex.IsNull())
  {
    myMutex.reset(new Standard_HMutex());
  }
  else
  {
    myMutex = NULL;
  }

   }
+  //! If isMultiThread == Standard_True then computation will be performed in parallel.
+  void SetMultiThread(Standard_Boolean theIsMultiThread)
+  {
+    myIsMultiThread = theIsMultiThread;
+  }

+  const Message_ProgressRange& myRange;

+  //! isMultiThread - computation will be performed in parallel if Standard_True
   Standard_EXPORT Standard_Boolean Perform(const Message_ProgressRange& theRange = Message_ProgressRange());

+  //! Parameters F and A are not used in computation and are obsolete. 
   Standard_EXPORT BRepExtrema_DistShapeShape(const TopoDS_Shape& Shape1,

-      BoxCalculation (myMapV1, myBV1);
-      BoxCalculation (myMapE1, myBE1);
-      BoxCalculation (myMapF1, myBF1);
+      BoxCalculation(myMapV1, myBV1);
+      BoxCalculation(myMapE1, myBE1);
+      BoxCalculation(myMapF1, myBF1);

 }
 
+
+
 //=======================================================================

+    for (Standard_Integer i = 0; i < ArrayOfArrays->Value(theIndex).Size(); i++)
+    {
+      if (!aScope.More())
+      {
+        break;
+      }
...
+      if (*IsDone)
+      {
+        break;
+      }

//struct   : IndexRange

        TopoDS_Vertex aVertex1 = TopoDS::Vertex(Map1->FindKey(anIdx1));
        TopoDS_Vertex aVertex2 = TopoDS::Vertex(Map2->FindKey(anIdx2));

  Standard_Integer aNbTasks = aNbThreads;
  ...
  Standard_Integer aNbPairTasks = aNbThreads;
  ...
    Standard_Integer aNbTasks = aMapSize < aNbThreads ? aMapSize : aNbThreads;
    ...
  Standard_Integer aNbTasks = aNbThreads * 10;

    if (aCount1 < aFirstIndex + 2*aTaskSize - 1)

      if (IsDone[theIndex])
      {
        return;
      }

        if (aDist < anEpsDist || Abs(aDist - DistRef) < Eps)

  Message_ProgressScope aTwinScope(theRange, NULL, 1.0);

  Message_ProgressRange aBoxRange(aTwinScope.Next());
  Message_ProgressScope aBoxScope(aBoxRange, NULL, aNbPairTasks);
  DistancePairFunctor aPairFunctor(&aBandArray, aBoxScope.Next());

    Message_ProgressRange aDistRange(aTwinScope.Next(0.7));
    Message_ProgressScope aDistScope(aDistRange, NULL, 1);
    DistanceFunctor aFunctor(&anArrayOfArray, aDistScope.Next());

  NCollection_Vector<BRepExtrema_CheckPair> aPairList;

    Standard_Integer aLastRowLimit = ((aMapSize % aNbTasks) == 0) ? aNbTasks : (aMapSize % aNbTasks);
    for (Standard_Integer anI = 0; anI < aTaskSize; ++anI)

      else if (Abs(aDist - myDistRef) < myEps)
      {
        mySolutionsShape1.Append(aFunctor.Solution.Shape1[anI]);
        mySolutionsShape2.Append(aFunctor.Solution.Shape2[anI]);
        myDistRef = aDist;
      }

  const TopoDS_Shape*                        Shape;

      Message_ProgressRange aRange = aScope.Next();

    Scope(theRange, "Vertices distances calculating", theBandArray->Size()),

        Standard_Mutex::Sentry aLock(Mutex.get());

        if (aDist < DistRef + Eps)

  Message_ProgressRange aBoxRange(aTwinScope.Next(0.15));

  if(aPairFunctor.IsListEmpty())
  {
    return Standard_True;
  }
  NCollection_Vector<BRepExtrema_CheckPair> aPairList;