+    FILE * aF = fopen(aCPath, "wb");

+  // Calculate number of lines in input file.
+  Standard_Integer aNbLines = 0;
+  fseek(theF, 0L, SEEK_END);
+  long filesize = ftell(theF);
+  rewind(theF);
+  for (long aPos = 0; aPos < filesize; ++aPos)
+  {
+    if (getc(theF) == '\n')
+        aNbLines++;
+  }
+  rewind(theF);

+  const Standard_Integer CHUNKSIZE = 4096;
+  Standard_Character* aDataChunk = new Standard_Character[CHUNKSIZE * THE_STL_SIZEOF_FACET];
...
+  delete[] aDataChunk;

+    if (aVNorm.SquareMagnitude() > gp::Resolution())
+      aVNorm.Normalize();
+    else
+      aVNorm.SetCoord(0.0, 0.0, 0.0);
+
+     Sprintf (aBuffer,

   theCommands.Add ("readstl",   "shape file",__FILE__,readstl,g);
+  theCommands.Add ("readstlastri", "shape file",__FILE__,readstlastri,g);

+  if (theArgc < 3)
+    theDi << "wrong number of parameters" << "\n";
...
+  return 0;

+  // Create temporary triangulation.
+   Handle(Poly_Triangulation) aMesh = new Poly_Triangulation(aNbNodes, 
...
+  MergeNodes(aNodes, aTriangles);
+  // Simple copy to the OCCT data structures.
+ Handle(Poly_Triangulation) aMesh = new Poly_Triangulation(aNodes.Size(), 

+  Standard_Integer aNbNodes = 0;
+  Standard_Integer aNbTriangles = 0;
+
+  // Calculate total number of the nodes and triangles.
+  TopExp_Explorer anExpSF(theShape, TopAbs_FACE);
+  for ( ; anExpSF.More() ; anExpSF.Next() )
   {
+    TopLoc_Location aLoc;
+    Handle(Poly_Triangulation) aTriangulation 
+      = BRep_Tool::Triangulation(TopoDS::Face(anExpSF.Current()), aLoc);
+
+    aNbNodes += aTriangulation->NbNodes();
+    aNbTriangles += aTriangulation->NbTriangles();
   }
+
+  // Create temporary triangulation.
+   Handle(Poly_Triangulation) aMesh = new Poly_Triangulation(aNbNodes, 

+//=============================================================================
+// IN
+//=============================================================================
+
+  //! Resulting nodes.
+  NCollection_Vector<gp_Pnt> myResPoints;
+
+  //! Merging tolerance.
+  Standard_Real myMergingTol;
+
+//=============================================================================
+// INTERNAL
+//=============================================================================

+  //! Returns resulting nodes array.
+  const NCollection_Vector<gp_Pnt>& GetResultingArray() const { return myResPoints; }
+
+  //! Returns resulting index in range [1, NbNodes].
+  //! \param[in] theOrigNode original index in range [1, NbNodes].
+  Standard_Integer GetResultingNode(const Standard_Integer theOrigNode) const { return myInpOutMap(theOrigNode - 1); }
+
+  //! Returns merging map.
+  const NCollection_Vector<Standard_Integer>& GetMergingMap() const { return myInpOutMap; }
...
+    //! Get mesh in the internal representation.
+  const Handle(Poly_Triangulation)& GetMesh() const { return myTriangulation; }

+inline int HashCode(const gp_Pnt& thePnt,
+                    const int theUpper)
+{
+  double aVal = thePnt.X() * thePnt.X() +
+                thePnt.Y() * thePnt.Y() +
+                thePnt.Z() * thePnt.Z() +
+                thePnt.SquareDistance(gp_Pnt(1.0, 0.1, 2.0));
+
+  return HashCode(aVal, theUpper);
+}
+
+//=============================================================================
+//function : IsEqual
+//purpose  :
+//=============================================================================
+inline bool IsEqual(const gp_Pnt& thePnt1,
+                    const gp_Pnt& thePnt2)

+  if (thePnt1.SquareDistance(thePnt2) < gp::Resolution())
+    return true;
+
+  return false;

+RWStl_NodesMerger::RWStl_NodesMerger(const Standard_Real thePrecision)
+{
+  myMergingTol = thePrecision;
+  myMap.Clear();
+  myIsNew = Standard_False;
+}
...
+RWStl::RWStl()
+{
+  myWriteBinary = Standard_True;

+// Include self.
+#include <RWStl_NodesMerger.hxx>

 private:
 
+  //! Checks whether ASCII or binary.
+  Standard_Boolean IsASCII(const Standard_CString thePath);
 
+  //! Read ASCII version.
+  Standard_Boolean ReadASCII(FILE *theF,
+                             const Handle(Message_ProgressIndicator)& theProgInd);
...
+inline static void ConvertInteger(const Standard_Integer theValue,
+                                  Standard_Character* theResult)
...
+inline static void ConvertDouble(const Standard_Real theValue,
+                                 Standard_Character* theResult

+     fprintf(theF, "%s", aBuffer);
...
+  fprintf(theF, "%s", "endsolid\n");
...
+  fprintf(theF, "%s", "endsolid\n");

+  fprintf(theF, "%s", "endsolid\n");
+  return Standard_True;
...
+  // Write last part if necessary.
+  if (j != CHUNKSIZE * THE_STL_SIZEOF_FACET)
+    fwrite(aDataChunk, 1, j, theF);
+
+  delete[] aDataChunk;
+
+  return Standard_True;
...
+    Standard_Boolean isOK = WriteBinary(aF, theProgInd);
+    fclose(aF);
+    if (!isOK)
+      return Standard_False;
...
+    Standard_Boolean isOK = WriteASCII(aF, theProgInd);
+    fclose(aF);
+    if (!isOK)
+      return Standard_False;

+  Standard_Character* aDataChunk = new char[CHUNKSIZE * THE_STL_SIZEOF_FACET];

+  const Standard_Integer NBTriangles = myTriangulation->NbTriangles();
+  for (Standard_Integer i = 1; i <= NBTriangles; ++i)

+  for (Standard_Integer i  = 0; i < aNodes.Size();  ++i)

+Standard_Boolean RWStl::IsASCII(const Standard_CString thePath)

+    FILE * aF = OSD_OpenFile(aCPath, "r");
...
+    FILE * aF = OSD_OpenFile(aCPath, "w");

+  TCollection_AsciiString aPath; thePath.SystemName(aPath);
+  Standard_CString aCPath = aPath.ToCString();

//! Auxiliary tool for buffered reading from input stream
//! within chunks of constant size.
class CadImportBuffer
{
public:

  //! Constructor with initialization.
  CadImportBuffer (int64_t theDataLen,
                   size_t  theChunkLen)
  : myBufferPtr(NULL),
    myBufferEnd(NULL),
    myDataLen  (0),
    myDataRead (0),
    myChunkLen (0),
    myNbChunks (0),
    myBufferLen(0)
  {
    Init (theDataLen, theChunkLen);
  }

  //! Initialize the buffer.
  //! @param theDataLen  the full length of input data to read from stream.
  //! @param theChunkLen the length of single chunk to read
  void Init (int64_t theDataLen,
             size_t  theChunkLen)
  {
    myDataRead  = 0;
    myDataLen   = theDataLen - theDataLen % int64_t(theChunkLen);
    myChunkLen  = theChunkLen;
    myNbChunks  = sizeof(myBuffer) / theChunkLen;
    myBufferLen = theChunkLen * myNbChunks;

    myBufferEnd = myBuffer + sizeof(myBuffer);
    myBufferPtr = myBuffer + sizeof(myBuffer);
    memset (myBuffer, 0, sizeof(myBuffer));

    if (theChunkLen > sizeof(myBuffer))
    {
      Standard_ProgramError::Raise ("Internal error - chunk size is greater then preallocated buffer");
    }
  }

  //! Return TRUE if amount of read bytes is equal to requested length of entire data.
  bool IsDone() const
  {
    return myDataRead == myDataLen;
  }

  //! Read next chunk.
  //! @return pointer to the chunk or NULL on error / end of reading buffer
  template<typename Chunk_T, typename Stream_T>
  Chunk_T* ReadChunk (Stream_T& theStream)
  {
    return reinterpret_cast<Chunk_T*> (readRawDataChunk (theStream));
  }

  //! Read next chunk.
  //! @return pointer to the chunk or NULL on error / end of reading buffer
  template<typename Stream_T>
  char* ReadDataChunk (Stream_T& theStream)
  {
    return readRawDataChunk (theStream);
  }

private:

  //! Read next chunk.
  //! @return pointer to the chunk or NULL on error / end of reading buffer
  template<typename Stream_T>
  char* readRawDataChunk (Stream_T& theStream)
  {
    myBufferPtr += myChunkLen;
    if (myBufferPtr < myBufferEnd)
    {
      return myBufferPtr;
    }

    const int64_t aDataLeft = myDataLen - myDataRead;
    if (aDataLeft == 0) // myDataLen should be multiple of myChunkLen
    {
      myBufferPtr = NULL;
      return NULL;
    }

    const size_t aDataToRead = int64_t(myBufferLen) > aDataLeft ? size_t(aDataLeft) : myBufferLen;
    if (!readStream (theStream, aDataToRead))
    {
      myBufferPtr = NULL;
      return NULL;
    }

    myBufferPtr = myBuffer;
    myBufferEnd = myBuffer + aDataToRead;
    myDataRead += aDataToRead;
    return myBufferPtr;
  }

  //! Read from stl stream.
  bool readStream (std::istream& theStream,
                   size_t theLen)
  {
    theStream.read (myBuffer, theLen);
    return theStream.good();
  }

  //! Read from FILE stream.
  bool readStream (FILE* theStream,
                   size_t theLen)
  {
    return ::fread (myBuffer, 1, theLen, theStream) == theLen;
  }

private:

  char        myBuffer[4096]; //!< data cache
  char*       myBufferPtr;    //!< current position within the buffer
  const char* myBufferEnd;    //!< end of the buffer
  int64_t     myDataLen;      //!< length of entire data to read
  int64_t     myDataRead;     //!< amount of data already processed
  size_t      myChunkLen;     //!< length of single chunk that caller would like to read (e.g. iterator increment)
  size_t      myNbChunks;     //!< number of cached chunks
  size_t      myBufferLen;    //!< effective length of the buffer to be read at once (multiple of chunk length)

};

  // normal + 3 nodes + 2 extra bytes
  const size_t aVec3Size  = sizeof(float) * 3;
  const size_t aFaceDataLen = aVec3Size * 4 + 2;
  CadImportBuffer aBuffer (aDataLen, aFaceDataLen);
  for (int aFacetIter = 0; aFacetIter < aNbFacets && aPSentry.More(); ++aFacetIter, ++aNbRead, aPSentry.Next())
  {
    const char* aBufferPtr = aBuffer.ReadDataChunk (theFile);
    if (aBufferPtr == NULL)
    {
      Message::DefaultMessenger()->Send (TCollection_AsciiString ("File is corrupted or not in STL format!"), Message_Fail);
      return false;
    }

    readStlFloatVec3 (aBufferPtr, aNorm);
    readStlFloatVec3 (aBufferPtr + aVec3Size,     aCtx.Places[0]);
    readStlFloatVec3 (aBufferPtr + aVec3Size * 2, aCtx.Places[1]);
    readStlFloatVec3 (aBufferPtr + aVec3Size * 3, aCtx.Places[2]);
    if (!aCtx.pushTriangle())
    {
      return false;
    }
  }

     TCollection_AsciiString aPath((Standard_CString)file.toLatin1().constData());
-    OSD_Path aFile( aPath );
-    Handle(StlMesh_Mesh) aMesh = RWStl::ReadFile (aFile);
+
+    Handle(Poly_Triangulation) aMesh;
+    StlAPI_Reader::Read(aMesh, aPath.ToCString());

-  Standard_Character* aDataChunk = new char[CHUNKSIZE * THE_STL_SIZEOF_FACET];
+  const Standard_Integer SIZE = CHUNKSIZE * THE_STL_SIZEOF_FACET;
+  NCollection_Array1<Standard_Character> aData(1, SIZE);
+  Standard_Character* aDataChunk = &aData.ChangeFirst();

+  for (Standard_Integer aTriIdx = 0; aTriIdx < aNbTri && aPS.More() ;)
...
+  return Standard_True;