-      return aCode % theUpper;
+      return static_cast<Standard_Integer>(aCode & INT_MAX) % theUpper;

@@ -52,7 +52,7 @@ Standard_Integer HashCodes (const Standard_CString Value,
     hash = ((hash << 5) + hash) ^ (*c);
   }
 
-  return hash;
+  return hash & IntegerLast();
...
inline Standard_Integer HashCode (const Standard_CString theStr,
                                  const Standard_Integer theLen,
                                  const Standard_Integer theUpper)
{
//  return (Abs( HashCodes( Value , Len ) ) % Upper ) + 1 ;
  return HashCode (HashCodes (theStr, theLen), theUpper);
}
...
Standard_Integer HashCode (const Standard_CString Value,
                           const Standard_Integer Upper )
{
  Standard_Integer aLen = (Standard_Integer)strlen(Value);
  return HashCode (HashCodes (Value, aLen), Upper);
}

-  return h % upper;
+  return static_cast<Standard_Integer>(h & IntegerLast()) % upper;

//! Returns bounded hash code for a null-terminated string,
//! in range [1, theUpper]
Standard_Integer HashCode (const Standard_CString theStr,
                           const Standard_Integer theUpper);

-  return HashCode (hash, Upper);
+  return HashCode (static_cast<Standard_Integer>(hash), Upper);

  // the HashCode computed for a Location is the bitwise exclusive or
  // of values computed for each element of the list
  // to compute this value, the depth of the element is computed 
  // the depth is the position of the element in the list
  // this depth is multiplied by 3
  // each element is an elementary Datum raised to a Power
  // the Power is bitwise left shifted by depth
  // this is added to the HashCode of the Datum
  // this value is biwise rotated by depth
  // the use of depth avoids getting the same result for two permutated lists.

  Standard_Integer depth = 0;
  unsigned int h = 0;
  TopLoc_SListOfItemLocation items = myItems;
  while (items.More()) {
    depth += 3;
    unsigned int i = ::HashCode (items.Value().myDatum, upper);
    unsigned int j = ( (i + items.Value().myPower) <<depth);
    j = j>>(32-depth) | j<<depth;
    h ^= j;
    items.Next();
  }
  return h % upper;

--- a/src/BOPTools/BOPTools_Parallel.hxx
+++ b/src/BOPTools/BOPTools_Parallel.hxx
@@ -57,8 +57,13 @@ class BOPTools_Parallel
     {
       static Standard_Integer HashCode(const Standard_ThreadId theKey,
                                        const Standard_Integer  Upper)
+      //! Computes a hash code for the given thread identifier, in the range [1, theUpperBound]
+      //! @param theThreadId the thread identifier which hash code is to be computed
+      //! @param theUpperBound the upper bound of the range a computing hash code must be within
+      //! @return a computed hash code, in the range [1, theUpperBound]
+      static Standard_Integer HashCode (const Standard_ThreadId theThreadId, const Standard_Integer theUpperBound)
       {
-        return ::HashCode((Standard_Size)theKey, Upper);
+        return ::HashCode (theThreadId, theUpperBound);
       }
 
       static Standard_Boolean IsEqual(const Standard_ThreadId theKey1,
@@ -94,7 +99,7 @@ class BOPTools_Parallel

 
-      Standard_Mutex::Sentry aLocker (myMutex);
+      Standard_Mutex::Sentry aLocker(myMutex);
..
@@ -114,7 +119,7 @@ class BOPTools_Parallel
     ContextFunctor& operator= (const ContextFunctor&);
 
   private:
-    TypeSolverVector& mySolverVector;
+    TypeSolverVector&      mySolverVector;
..
   };
@@ -173,7 +178,7 @@ public:
   //! Context dependent version
   template<class TypeSolverVector, class TypeContext>
   static void Perform (Standard_Boolean  theIsRunParallel,
-                       TypeSolverVector& theSolverVector,
+                       TypeSolverVector&      theSolverVector,
                        opencascade::handle<TypeContext>& theContext)
   {
..
-      aFunctor.SetContext (theContext);
+      aFunctor.SetContext(theContext);

 #include <pthread.h>
 typedef pthread_t Standard_ThreadId;
 
+//! Computes a hash code for the given thread identifier (that is actually an integer), in the range [1, theUpperBound]
+//! @param TheThreadId the type of the given thread identifier (it is Standard_ThreadId,
+//! and must not be the same as Standard_Size, because the overload of the HashCode function
+//! for Standard_Size type is already presented in Standard_Size.hxx)
+//! @param theThreadId the thread identifier which hash code is to be computed
+//! @param theUpperBound the upper bound of the range a computing hash code must be within
+//! @return a computed hash code, in the range [1, theUpperBound]
+template <typename TheThreadId>
+typename opencascade::std::enable_if<opencascade::std::is_same<TheThreadId, Standard_ThreadId>::value
+                                       && !opencascade::std::is_same<TheThreadId, Standard_Size>::value
+                                       && opencascade::std::is_convertible<TheThreadId, Standard_Size>::value,
+                                     Standard_Integer>::type
+HashCode (const TheThreadId theThreadId, const Standard_Integer theUpperBound)
+{
+  return ::HashCode (static_cast<Standard_Size> (theThreadId), theUpperBound);
+}
+

typedef struct {
    void * p;                   /* Pointer to actual object */
    unsigned int x;             /* Extra information - reuse count etc */
} ptw32_handle_t;

typedef ptw32_handle_t pthread_t;