diff --git a/AnimModel.cpp b/AnimModel.cpp
index 0e744639..738c4dc5 100644
--- a/AnimModel.cpp
+++ b/AnimModel.cpp
@@ -531,7 +531,7 @@ bool TAnimModel::Load(cParser *parser, bool ter)
     return true;
 }
 
-TAnimContainer *__fastcall TAnimModel::AddContainer(char *pName)
+TAnimContainer * TAnimModel::AddContainer(char *pName)
 { // dodanie sterowania submodelem dla egzemplarza
     if (!pModel)
         return NULL;
@@ -547,7 +547,7 @@ TAnimContainer *__fastcall TAnimModel::AddContainer(char *pName)
     return NULL;
 }
 
-TAnimContainer *__fastcall TAnimModel::GetContainer(char *pName)
+TAnimContainer * TAnimModel::GetContainer(char *pName)
 { // szukanie/dodanie sterowania submodelem dla egzemplarza
     if (!pName)
         return pRoot; // pobranie pierwszego (dla obrotnicy)
@@ -691,7 +691,7 @@ int TAnimModel::TerrainCount()
 { // zliczanie kwadratów kilometrowych (główna linia po Next) do tworznia tablicy
     return pModel ? pModel->TerrainCount() : 0;
 };
-TSubModel *__fastcall TAnimModel::TerrainSquare(int n)
+TSubModel * TAnimModel::TerrainSquare(int n)
 { // pobieranie wskaźników do pierwszego submodelu
     return pModel ? pModel->TerrainSquare(n) : 0;
 };
diff --git a/AnimModel.h b/AnimModel.h
index adfe2c46..be855881 100644
--- a/AnimModel.h
+++ b/AnimModel.h
@@ -80,7 +80,7 @@ class TAnimContainer
     // std::string(pSubModel?pSubModel->asName.c_str():""); };
     // std::string inline GetName() { return std::string(pSubModel?pSubModel->pName:"");
     // };
-    char *__fastcall NameGet()
+    char * NameGet()
     {
         return (pSubModel ? pSubModel->pName : NULL);
     };
@@ -107,7 +107,7 @@ class TAnimContainer
             pSubModel->WillBeAnimated();
     };
     void EventAssign(TEvent *ev);
-    TEvent *__fastcall Event()
+    TEvent * Event()
     {
         return evDone;
     };
@@ -156,8 +156,8 @@ class TAnimModel
     bool Init(TModel3d *pNewModel);
     bool Init(AnsiString asName, AnsiString asReplacableTexture);
     bool Load(cParser *parser, bool ter = false);
-    TAnimContainer *__fastcall AddContainer(char *pName);
-    TAnimContainer *__fastcall GetContainer(char *pName);
+    TAnimContainer * AddContainer(char *pName);
+    TAnimContainer * GetContainer(char *pName);
     void RenderDL(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
     void RenderAlphaDL(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
     void RenderVBO(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
@@ -175,7 +175,7 @@ class TAnimModel
     };
     bool TerrainLoaded();
     int TerrainCount();
-    TSubModel *__fastcall TerrainSquare(int n);
+    TSubModel * TerrainSquare(int n);
     void TerrainRenderVBO(int n);
     void AnimationVND(void *pData, double a, double b, double c, double d);
     void LightSet(int n, float v);
diff --git a/Curve.cpp b/Curve.cpp
index 4d5f0576..d22ba1a2 100644
--- a/Curve.cpp
+++ b/Curve.cpp
@@ -13,14 +13,14 @@ http://mozilla.org/MPL/2.0/.
 
 #include "Curve.h"
 
-__fastcall TCurve::TCurve()
+ TCurve::TCurve()
 {
     Values = NULL;
     iNumValues = 0;
     iNumCols = 0;
 }
 
-__fastcall TCurve::~TCurve()
+ TCurve::~TCurve()
 {
     for (int i = 0; i < iNumValues; i++)
         SafeDelete(Values[i]);
diff --git a/Driver.cpp b/Driver.cpp
index cae6628b..cf5a91d1 100644
--- a/Driver.cpp
+++ b/Driver.cpp
@@ -386,7 +386,7 @@ void TController::TableClear()
     eSignSkip = NULL; // nic nie pomijamy
 };
 
-TEvent *__fastcall TController::CheckTrackEvent(double fDirection, TTrack *Track)
+TEvent * TController::CheckTrackEvent(double fDirection, TTrack *Track)
 { // sprawdzanie eventów na podanym torze do podstawowego skanowania
     TEvent *e = (fDirection > 0) ? Track->evEvent2 : Track->evEvent1;
     if (!e)
@@ -4994,7 +4994,7 @@ bool TController::BackwardTrackBusy(TTrack *Track)
     return false; // wolny
 };
 
-TEvent *__fastcall TController::CheckTrackEventBackward(double fDirection, TTrack *Track)
+TEvent * TController::CheckTrackEventBackward(double fDirection, TTrack *Track)
 { // sprawdzanie eventu w torze, czy jest sygnałowym - skanowanie do tyłu
     TEvent *e = (fDirection > 0) ? Track->evEvent2 : Track->evEvent1;
     if (e)
@@ -5004,7 +5004,7 @@ TEvent *__fastcall TController::CheckTrackEventBackward(double fDirection, TTrac
     return NULL;
 };
 
-TTrack *__fastcall TController::BackwardTraceRoute(double &fDistance, double &fDirection,
+TTrack * TController::BackwardTraceRoute(double &fDistance, double &fDirection,
                                                    TTrack *Track, TEvent *&Event)
 { // szukanie sygnalizatora w kierunku przeciwnym jazdy (eventu odczytu komórki pamięci)
     TTrack *pTrackChVel = Track; // tor ze zmianą prędkości
diff --git a/Driver.h b/Driver.h
index 0dee0f88..1c902da0 100644
--- a/Driver.h
+++ b/Driver.h
@@ -309,7 +309,7 @@ class TController
     void ControllingSet(); // znajduje człon do sterowania
     void AutoRewident(); // ustawia hamulce w składzie
   public:
-    Mtable::TTrainParameters *__fastcall Timetable()
+    Mtable::TTrainParameters * Timetable()
     {
         return TrainParams;
     };
@@ -355,12 +355,12 @@ class TController
     double Distance(vector3 &p1, vector3 &n, vector3 &p2);
 
   private: // Ra: metody obsługujące skanowanie toru
-    TEvent *__fastcall CheckTrackEvent(double fDirection, TTrack *Track);
+    TEvent * CheckTrackEvent(double fDirection, TTrack *Track);
     bool TableCheckEvent(TEvent *e);
     bool TableAddNew();
     bool TableNotFound(TEvent *e);
     void TableClear();
-    TEvent *__fastcall TableCheckTrackEvent(double fDirection, TTrack *Track);
+    TEvent * TableCheckTrackEvent(double fDirection, TTrack *Track);
     void TableTraceRoute(double fDistance, TDynamicObject *pVehicle = NULL);
     void TableCheck(double fDistance);
     TCommandType TableUpdate(double &fVelDes, double &fDist, double &fNext, double &fAcc);
@@ -368,8 +368,8 @@ class TController
 
   private: // Ra: stare funkcje skanujące, używane do szukania sygnalizatora z tyłu
     bool BackwardTrackBusy(TTrack *Track);
-    TEvent *__fastcall CheckTrackEventBackward(double fDirection, TTrack *Track);
-    TTrack *__fastcall BackwardTraceRoute(double &fDistance, double &fDirection, TTrack *Track,
+    TEvent * CheckTrackEventBackward(double fDirection, TTrack *Track);
+    TTrack * BackwardTraceRoute(double &fDistance, double &fDirection, TTrack *Track,
                                           TEvent *&Event);
     void SetProximityVelocity(double dist, double vel, const vector3 *pos);
     TCommandType BackwardScan();
diff --git a/Float3d.h b/Float3d.h
index 4e0fc10a..a6bbb376 100644
--- a/Float3d.h
+++ b/Float3d.h
@@ -192,11 +192,11 @@ class float4x4
         for (int i = 0; i < 16; ++i)
             e[i] = f[i];
     };
-    float *__fastcall operator()(int i)
+    float * operator()(int i)
     {
         return &e[i << 2];
     }
-    const float *__fastcall readArray(void)
+    const float * readArray(void)
     {
         return e;
     }
diff --git a/Geom.cpp b/Geom.cpp
index 6d42ab00..9b2d7b02 100644
--- a/Geom.cpp
+++ b/Geom.cpp
@@ -19,11 +19,11 @@ http://mozilla.org/MPL/2.0/.
 #include "Globals.h"
 #include "Geom.h"
 
-__fastcall TGeometry::TGeometry()
+ TGeometry::TGeometry()
 {
 }
 
-__fastcall TGeometry::~TGeometry()
+ TGeometry::~TGeometry()
 {
 }
 
diff --git a/Globals.cpp b/Globals.cpp
index 8bcd3f03..9322e7dd 100644
--- a/Globals.cpp
+++ b/Globals.cpp
@@ -725,12 +725,12 @@ void Global::TrainDelete(TDynamicObject *d)
         pWorld->TrainDelete(d);
 };
 
-TDynamicObject *__fastcall Global::DynamicNearest()
+TDynamicObject * Global::DynamicNearest()
 { // ustalenie pojazdu najbliższego kamerze
     return pGround->DynamicNearest(pCamera->Pos);
 };
 
-TDynamicObject *__fastcall Global::CouplerNearest()
+TDynamicObject * Global::CouplerNearest()
 { // ustalenie pojazdu najbliższego kamerze
     return pGround->CouplerNearest(pCamera->Pos);
 };
diff --git a/Globals.h b/Globals.h
index 6ffc749e..522475a1 100644
--- a/Globals.h
+++ b/Globals.h
@@ -313,8 +313,8 @@ class Global
     static void TrainDelete(TDynamicObject *d);
     static void ConfigParse(Queryparsercomp::TQueryParserComp *qp, cParser *cp = NULL);
     static AnsiString GetNextSymbol();
-    static TDynamicObject *__fastcall DynamicNearest();
-    static TDynamicObject *__fastcall CouplerNearest();
+    static TDynamicObject * DynamicNearest();
+    static TDynamicObject * CouplerNearest();
     static bool AddToQuery(TEvent *event, TDynamicObject *who);
     static bool DoEvents();
     static AnsiString Bezogonkow(AnsiString str, bool _ = false);
diff --git a/Ground.cpp b/Ground.cpp
index 8490f292..a99a79fc 100644
--- a/Ground.cpp
+++ b/Ground.cpp
@@ -975,7 +975,7 @@ void TSubRect::Sort()
     };
 }
 
-TTrack *__fastcall TSubRect::FindTrack(vector3 *Point, int &iConnection, TTrack *Exclude)
+TTrack * TSubRect::FindTrack(vector3 *Point, int &iConnection, TTrack *Exclude)
 { // szukanie toru, którego koniec jest najbliższy (*Point)
     TTrack *Track;
     for (int i = 0; i < iTracks; ++i)
@@ -1022,7 +1022,7 @@ void TSubRect::RaAnimate()
     tTrackAnim = tTrackAnim->RaAnimate(); // przeliczenie animacji kolejnego
 };
 
-TTraction *__fastcall TSubRect::FindTraction(vector3 *Point, int &iConnection, TTraction *Exclude)
+TTraction * TSubRect::FindTraction(vector3 *Point, int &iConnection, TTraction *Exclude)
 { // szukanie przęsła w sektorze, którego koniec jest najbliższy (*Point)
     TGroundNode *Current;
     for (Current = nRenderWires; Current; Current = Current->nNext3)
@@ -1360,7 +1360,7 @@ void TGround::Free()
     delete sTracks;
 }
 
-TGroundNode *__fastcall TGround::DynamicFindAny(AnsiString asNameToFind)
+TGroundNode * TGround::DynamicFindAny(AnsiString asNameToFind)
 { // wyszukanie pojazdu o podanej nazwie, szukanie po wszystkich (użyć drzewa!)
     for (TGroundNode *Current = nRootDynamic; Current; Current = Current->nNext)
         if ((Current->asName == asNameToFind))
@@ -1368,7 +1368,7 @@ TGroundNode *__fastcall TGround::DynamicFindAny(AnsiString asNameToFind)
     return NULL;
 };
 
-TGroundNode *__fastcall TGround::DynamicFind(AnsiString asNameToFind)
+TGroundNode * TGround::DynamicFind(AnsiString asNameToFind)
 { // wyszukanie pojazdu z obsadą o podanej nazwie (użyć drzewa!)
     for (TGroundNode *Current = nRootDynamic; Current; Current = Current->nNext)
         if (Current->DynamicObject->Mechanik)
@@ -1386,7 +1386,7 @@ void TGround::DynamicList(bool all)
     WyslijString("none", 6); // informacja o końcu listy
 };
 
-TGroundNode *__fastcall TGround::FindGroundNode(AnsiString asNameToFind, TGroundNodeType iNodeType)
+TGroundNode * TGround::FindGroundNode(AnsiString asNameToFind, TGroundNodeType iNodeType)
 { // wyszukiwanie obiektu o podanej nazwie i konkretnym typie
     if ((iNodeType == TP_TRACK) || (iNodeType == TP_MEMCELL) || (iNodeType == TP_MODEL))
     { // wyszukiwanie w drzewie binarnym
@@ -1540,7 +1540,7 @@ void TGround::RaTriangleDivider(TGroundNode *node)
     RaTriangleDivider(ntri);
 };
 
-TGroundNode *__fastcall TGround::AddGroundNode(cParser *parser)
+TGroundNode * TGround::AddGroundNode(cParser *parser)
 { // wczytanie wpisu typu "node"
     // parser->LoadTraction=Global::bLoadTraction; //Ra: tu nie potrzeba powtarzać
     AnsiString str, str1, str2, str3, str4, Skin, DriverType, asNodeName;
@@ -2199,7 +2199,7 @@ TGroundNode *__fastcall TGround::AddGroundNode(cParser *parser)
     return tmp;
 }
 
-TSubRect *__fastcall TGround::FastGetSubRect(int iCol, int iRow)
+TSubRect * TGround::FastGetSubRect(int iCol, int iRow)
 {
     int br, bc, sr, sc;
     br = iRow / iNumSubRects;
@@ -2211,7 +2211,7 @@ TSubRect *__fastcall TGround::FastGetSubRect(int iCol, int iRow)
     return (Rects[br][bc].FastGetRect(sc, sr));
 }
 
-TSubRect *__fastcall TGround::GetSubRect(int iCol, int iRow)
+TSubRect * TGround::GetSubRect(int iCol, int iRow)
 { // znalezienie małego kwadratu mapy
     int br, bc, sr, sc;
     br = iRow / iNumSubRects; // współrzędne kwadratu kilometrowego
@@ -2223,7 +2223,7 @@ TSubRect *__fastcall TGround::GetSubRect(int iCol, int iRow)
     return (Rects[br][bc].SafeGetRect(sc, sr)); // pobranie małego kwadratu
 }
 
-TEvent *__fastcall TGround::FindEvent(const AnsiString &asEventName)
+TEvent * TGround::FindEvent(const AnsiString &asEventName)
 {
     return (TEvent *)sTracks->Find(0, asEventName.c_str()); // wyszukiwanie w drzewie
     /* //powolna wyszukiwarka
@@ -2236,7 +2236,7 @@ TEvent *__fastcall TGround::FindEvent(const AnsiString &asEventName)
     */
 }
 
-TEvent *__fastcall TGround::FindEventScan(const AnsiString &asEventName)
+TEvent * TGround::FindEventScan(const AnsiString &asEventName)
 { // wyszukanie eventu z opcją utworzenia niejawnego dla komórek skanowanych
     TEvent *e = (TEvent *)sTracks->Find(0, asEventName.c_str()); // wyszukiwanie w drzewie eventów
     if (e)
@@ -3619,7 +3619,7 @@ bool TGround::InitLaunchers()
     return true;
 }
 
-TTrack *__fastcall TGround::FindTrack(vector3 Point, int &iConnection, TGroundNode *Exclude)
+TTrack * TGround::FindTrack(vector3 Point, int &iConnection, TGroundNode *Exclude)
 { // wyszukiwanie innego toru kończącego się w (Point)
     TTrack *Track;
     TGroundNode *Current;
@@ -3667,7 +3667,7 @@ TTrack *__fastcall TGround::FindTrack(vector3 Point, int &iConnection, TGroundNo
     return NULL;
 }
 
-TTraction *__fastcall TGround::FindTraction(vector3 *Point, int &iConnection, TGroundNode *Exclude)
+TTraction * TGround::FindTraction(vector3 *Point, int &iConnection, TGroundNode *Exclude)
 { // wyszukiwanie innego przęsła kończącego się w (Point)
     TTraction *Traction;
     TGroundNode *Current;
@@ -3705,7 +3705,7 @@ TTraction *__fastcall TGround::FindTraction(vector3 *Point, int &iConnection, TG
     return NULL;
 };
 
-TTraction *__fastcall TGround::TractionNearestFind(vector3 &p, int dir, TGroundNode *n)
+TTraction * TGround::TractionNearestFind(vector3 &p, int dir, TGroundNode *n)
 { // wyszukanie najbliższego do (p) przęsła o tej samej nazwie sekcji (ale innego niż podłączone)
     // oraz zasilanego z kierunku (dir)
     TGroundNode *nCurrent, *nBest = NULL;
@@ -4971,7 +4971,7 @@ void TGround::RadioStop(vector3 pPosition)
                         node->pTrack->RadioStop(); // przekazanie do każdego toru w każdym segmencie
 };
 
-TDynamicObject *__fastcall TGround::DynamicNearest(vector3 pPosition, double distance, bool mech)
+TDynamicObject * TGround::DynamicNearest(vector3 pPosition, double distance, bool mech)
 { // wyszukanie pojazdu najbliższego względem (pPosition)
     TGroundNode *node;
     TSubRect *tmp;
@@ -4997,7 +4997,7 @@ TDynamicObject *__fastcall TGround::DynamicNearest(vector3 pPosition, double dis
                                 }
     return dyn;
 };
-TDynamicObject *__fastcall TGround::CouplerNearest(vector3 pPosition, double distance, bool mech)
+TDynamicObject * TGround::CouplerNearest(vector3 pPosition, double distance, bool mech)
 { // wyszukanie pojazdu, którego sprzęg jest najbliżej względem (pPosition)
     TGroundNode *node;
     TSubRect *tmp;
diff --git a/Ground.h b/Ground.h
index a8bad719..0502cc4a 100644
--- a/Ground.h
+++ b/Ground.h
@@ -156,7 +156,7 @@ class TGroundNode : public Resource
     void MoveMe(vector3 pPosition); // przesuwanie (nie działa)
 
     // bool Disable();
-    inline TGroundNode *__fastcall Find(const AnsiString &asNameToFind, TGroundNodeType iNodeType)
+    inline TGroundNode * Find(const AnsiString &asNameToFind, TGroundNodeType iNodeType)
     { // wyszukiwanie czołgowe z typem
         if ((iNodeType == iType) && (asNameToFind == asName))
             return this;
@@ -208,8 +208,8 @@ class TSubRect : public Resource, public CMesh
     void NodeAdd(TGroundNode *Node); // dodanie obiektu do sektora na etapie rozdzielania na sektory
     void RaNodeAdd(TGroundNode *Node); // dodanie obiektu do listy renderowania
     void Sort(); // optymalizacja obiektów w sektorze (sortowanie wg tekstur)
-    TTrack *__fastcall FindTrack(vector3 *Point, int &iConnection, TTrack *Exclude);
-    TTraction *__fastcall FindTraction(vector3 *Point, int &iConnection, TTraction *Exclude);
+    TTrack * FindTrack(vector3 *Point, int &iConnection, TTrack *Exclude);
+    TTraction * FindTraction(vector3 *Point, int &iConnection, TTraction *Exclude);
     bool StartVBO(); // ustwienie VBO sektora dla (nRenderRect), (nRenderRectAlpha) i
     // (nRenderWires)
     bool RaTrackAnimAdd(TTrack *t); // zgłoszenie toru do animacji
@@ -249,13 +249,13 @@ class TGroundRect : public TSubRect
     TGroundRect();
     virtual ~TGroundRect();
 
-    TSubRect *__fastcall SafeGetRect(int iCol, int iRow)
+    TSubRect * SafeGetRect(int iCol, int iRow)
     { // pobranie wskaźnika do małego kwadratu, utworzenie jeśli trzeba
         if (!pSubRects)
             Init(); // utworzenie małych kwadratów
         return pSubRects + iRow * iNumSubRects + iCol; // zwrócenie właściwego
     };
-    TSubRect *__fastcall FastGetRect(int iCol, int iRow)
+    TSubRect * FastGetRect(int iCol, int iRow)
     { // pobranie wskaźnika do małego kwadratu, bez tworzenia jeśli nie ma
         return (pSubRects ? pSubRects + iRow * iNumSubRects + iCol : NULL);
     };
@@ -308,11 +308,11 @@ class TGround
     void InitTraction();
     bool InitEvents();
     bool InitLaunchers();
-    TTrack *__fastcall FindTrack(vector3 Point, int &iConnection, TGroundNode *Exclude);
-    TTraction *__fastcall FindTraction(vector3 *Point, int &iConnection, TGroundNode *Exclude);
-    TTraction *__fastcall TractionNearestFind(vector3 &p, int dir, TGroundNode *n);
+    TTrack * FindTrack(vector3 Point, int &iConnection, TGroundNode *Exclude);
+    TTraction * FindTraction(vector3 *Point, int &iConnection, TGroundNode *Exclude);
+    TTraction * TractionNearestFind(vector3 &p, int dir, TGroundNode *n);
     // TGroundNode* CreateGroundNode();
-    TGroundNode *__fastcall AddGroundNode(cParser *parser);
+    TGroundNode * AddGroundNode(cParser *parser);
     bool AddGroundNode(double x, double z, TGroundNode *Node)
     {
         TSubRect *tmp = GetSubRect(x, z);
@@ -326,7 +326,7 @@ class TGround
     };
     //    bool Include(TQueryParserComp *Parser);
     // TGroundNode* GetVisible(AnsiString asName);
-    TGroundNode *__fastcall GetNode(AnsiString asName);
+    TGroundNode * GetNode(AnsiString asName);
     bool AddDynamic(TGroundNode *Node);
     void MoveGroundNode(vector3 pPosition);
     void UpdatePhys(double dt, int iter); // aktualizacja fizyki stałym krokiem
@@ -355,24 +355,24 @@ class TGround
              return NULL;
      }
     */
-    TGroundNode *__fastcall DynamicFindAny(AnsiString asNameToFind);
-    TGroundNode *__fastcall DynamicFind(AnsiString asNameToFind);
+    TGroundNode * DynamicFindAny(AnsiString asNameToFind);
+    TGroundNode * DynamicFind(AnsiString asNameToFind);
     void DynamicList(bool all = false);
-    TGroundNode *__fastcall FindGroundNode(AnsiString asNameToFind, TGroundNodeType iNodeType);
-    TGroundRect *__fastcall GetRect(double x, double z)
+    TGroundNode * FindGroundNode(AnsiString asNameToFind, TGroundNodeType iNodeType);
+    TGroundRect * GetRect(double x, double z)
     {
         return &Rects[GetColFromX(x) / iNumSubRects][GetRowFromZ(z) / iNumSubRects];
     };
-    TSubRect *__fastcall GetSubRect(double x, double z)
+    TSubRect * GetSubRect(double x, double z)
     {
         return GetSubRect(GetColFromX(x), GetRowFromZ(z));
     };
-    TSubRect *__fastcall FastGetSubRect(double x, double z)
+    TSubRect * FastGetSubRect(double x, double z)
     {
         return FastGetSubRect(GetColFromX(x), GetRowFromZ(z));
     };
-    TSubRect *__fastcall GetSubRect(int iCol, int iRow);
-    TSubRect *__fastcall FastGetSubRect(int iCol, int iRow);
+    TSubRect * GetSubRect(int iCol, int iRow);
+    TSubRect * FastGetSubRect(int iCol, int iRow);
     int GetRowFromZ(double z)
     {
         return (z / fSubRectSize + fHalfTotalNumSubRects);
@@ -381,8 +381,8 @@ class TGround
     {
         return (x / fSubRectSize + fHalfTotalNumSubRects);
     };
-    TEvent *__fastcall FindEvent(const AnsiString &asEventName);
-    TEvent *__fastcall FindEventScan(const AnsiString &asEventName);
+    TEvent * FindEvent(const AnsiString &asEventName);
+    TEvent * FindEventScan(const AnsiString &asEventName);
     void TrackJoin(TGroundNode *Current);
 
   private:
@@ -402,9 +402,9 @@ class TGround
 	void WyslijPojazdy(int nr); // -> skladanie wielu pojazdow
 	void WyslijObsadzone(); // -> skladanie wielu pojazdow    
 	void RadioStop(vector3 pPosition);
-    TDynamicObject *__fastcall DynamicNearest(vector3 pPosition, double distance = 20.0,
+    TDynamicObject * DynamicNearest(vector3 pPosition, double distance = 20.0,
                                               bool mech = false);
-    TDynamicObject *__fastcall CouplerNearest(vector3 pPosition, double distance = 20.0,
+    TDynamicObject * CouplerNearest(vector3 pPosition, double distance = 20.0,
                                               bool mech = false);
     void DynamicRemove(TDynamicObject *dyn);
     void TerrainRead(const AnsiString &f);
diff --git a/Machajka.cpp b/Machajka.cpp
index 3d75b541..4aeefe26 100644
--- a/Machajka.cpp
+++ b/Machajka.cpp
@@ -15,12 +15,12 @@ http://mozilla.org/MPL/2.0/.
 #include "Timer.h"
 #include "Globals.h"
 
-__fastcall TMachajka::TMachajka() : TTrain()
+ TMachajka::TMachajka() : TTrain()
 {
     TTrain::TTrain();
 }
 
-__fastcall TMachajka::~TMachajka()
+ TMachajka::~TMachajka()
 {
 }
 
diff --git a/MdlMngr.cpp b/MdlMngr.cpp
index 9e191424..1a97380f 100644
--- a/MdlMngr.cpp
+++ b/MdlMngr.cpp
@@ -23,7 +23,7 @@ http://mozilla.org/MPL/2.0/.
 
 #define SeekFiles AnsiString("*.t3d")
 
-TModel3d *__fastcall TMdlContainer::LoadModel(char *newName, bool dynamic)
+TModel3d * TMdlContainer::LoadModel(char *newName, bool dynamic)
 { // wczytanie modelu do kontenerka
     SafeDeleteArray(Name);
     SafeDelete(Model);
@@ -45,14 +45,14 @@ void TModelsManager::Init()
     Count = 0;
 }
 /*
-__fastcall TModelsManager::TModelsManager()
+ TModelsManager::TModelsManager()
 {
 //    Models= NULL;
     Models= new TMdlContainer[MAX_MODELS];
     Count= 0;
 };
 
-__fastcall TModelsManager::~TModelsManager()
+ TModelsManager::~TModelsManager()
 {
     Free();
 };
@@ -62,7 +62,7 @@ void TModelsManager::Free()
     SafeDeleteArray(Models);
 }
 
-TModel3d *__fastcall TModelsManager::LoadModel(char *Name, bool dynamic)
+TModel3d * TModelsManager::LoadModel(char *Name, bool dynamic)
 { // wczytanie modelu do tablicy
     TModel3d *mdl = NULL;
     if (Count >= MAX_MODELS)
@@ -76,7 +76,7 @@ TModel3d *__fastcall TModelsManager::LoadModel(char *Name, bool dynamic)
     return mdl;
 }
 
-TModel3d *__fastcall TModelsManager::GetModel(const char *Name, bool dynamic)
+TModel3d * TModelsManager::GetModel(const char *Name, bool dynamic)
 { // model może być we wpisie "node...model" albo "node...dynamic", a także być dodatkowym w dynamic
     // (kabina, wnętrze, ładunek)
     // dla "node...dynamic" mamy podaną ścieżkę w "\dynamic\" i musi być co najmniej 1 poziom, zwkle
diff --git a/MdlMngr.h b/MdlMngr.h
index 25665aca..9ff23adf 100644
--- a/MdlMngr.h
+++ b/MdlMngr.h
@@ -25,7 +25,7 @@ class TMdlContainer
         SafeDeleteArray(Name);
         SafeDelete(Model);
     };
-    TModel3d *__fastcall LoadModel(char *newName, bool dynamic);
+    TModel3d * LoadModel(char *newName, bool dynamic);
     TModel3d *Model;
     char *Name;
 };
@@ -35,7 +35,7 @@ class TModelsManager
   private:
     static TMdlContainer *Models;
     static int Count;
-    static TModel3d *__fastcall LoadModel(char *Name, bool dynamic);
+    static TModel3d * LoadModel(char *Name, bool dynamic);
 
   public:
     //    TModelsManager();
@@ -43,7 +43,7 @@ class TModelsManager
     static void Init();
     static void Free();
     // McZapkie: dodalem sciezke, notabene Path!=Patch :)
-    static TModel3d *__fastcall GetModel(const char *Name, bool dynamic = false);
+    static TModel3d * GetModel(const char *Name, bool dynamic = false);
 };
 //---------------------------------------------------------------------------
 #endif
diff --git a/MemCell.h b/MemCell.h
index caef4d94..8a6bc4f2 100644
--- a/MemCell.h
+++ b/MemCell.h
@@ -35,7 +35,7 @@ class TMemCell
     void PutCommand(TController *Mech, vector3 *Loc);
     bool Compare(char *szTestText, double fTestValue1, double fTestValue2, int CheckMask);
     bool Render();
-    inline char *__fastcall Text()
+    inline char * Text()
     {
         return szText;
     };
diff --git a/Model3d.cpp b/Model3d.cpp
index 90a3c309..0b61040d 100644
--- a/Model3d.cpp
+++ b/Model3d.cpp
@@ -657,7 +657,7 @@ int TSubModel::TriangleAdd(TModel3d *m, int tex, int tri)
     return s->iNumVerts - tri; // zwraca pozycję tych trójkątów w submodelu
 };
 
-float8 *__fastcall TSubModel::TrianglePtr(int tex, int pos, int *la, int *ld, int *ls)
+float8 * TSubModel::TrianglePtr(int tex, int pos, int *la, int *ld, int *ls)
 { // zwraca wskaźnik do wypełnienia tabeli wierzchołków, używane
     // przy tworzeniu E3D terenu
     TSubModel *s = this;
@@ -959,12 +959,12 @@ struct ToLower
     }
 };
 
-TSubModel *__fastcall TSubModel::GetFromName(AnsiString search, bool i)
+TSubModel * TSubModel::GetFromName(AnsiString search, bool i)
 {
     return GetFromName(search.c_str(), i);
 };
 
-TSubModel *__fastcall TSubModel::GetFromName(char *search, bool i)
+TSubModel * TSubModel::GetFromName(char *search, bool i)
 {
     TSubModel *result;
     // std::transform(search.begin(),search.end(),search.begin(),ToLower());
@@ -1724,7 +1724,7 @@ TModel3d::TModel3d()
     iNumVerts = 0; // nie ma jeszcze wierzchołków
 };
 /*
-__fastcall TModel3d::TModel3d(char *FileName)
+ TModel3d::TModel3d(char *FileName)
 {
 //    Root=NULL;
 //    Materials=NULL;
@@ -1752,7 +1752,7 @@ TModel3d::~TModel3d()
     // później się jeszcze usuwa obiekt z którego dziedziczymy tabelę VBO
 };
 
-TSubModel *__fastcall TModel3d::AddToNamed(const char *Name, TSubModel *SubModel)
+TSubModel * TModel3d::AddToNamed(const char *Name, TSubModel *SubModel)
 {
     TSubModel *sm = Name ? GetFromName(Name) : NULL;
     AddTo(sm, SubModel); // szukanie nadrzędnego
@@ -1776,7 +1776,7 @@ void TModel3d::AddTo(TSubModel *tmp, TSubModel *SubModel)
     iFlags |= 0x0200; // submodele są oddzielne
 };
 
-TSubModel *__fastcall TModel3d::GetFromName(const char *sName)
+TSubModel * TModel3d::GetFromName(const char *sName)
 { // wyszukanie submodelu po nazwie
     if (!sName)
         return Root; // potrzebne do terenu z E3D
@@ -2347,7 +2347,7 @@ int TModel3d::TerrainCount()
     }
     return i;
 };
-TSubModel *__fastcall TModel3d::TerrainSquare(int n)
+TSubModel * TModel3d::TerrainSquare(int n)
 { // pobieranie wskaźnika do submodelu (n)
     int i = 0;
     TSubModel *r = Root;
diff --git a/Model3d.h b/Model3d.h
index 0eae774f..9ffa52d0 100644
--- a/Model3d.h
+++ b/Model3d.h
@@ -262,16 +262,16 @@ class TSubModel
     int Load(cParser &Parser, TModel3d *Model, int Pos, bool dynamic);
     void ChildAdd(TSubModel *SubModel);
     void NextAdd(TSubModel *SubModel);
-    TSubModel *__fastcall NextGet()
+    TSubModel * NextGet()
     {
         return Next;
     };
-    TSubModel *__fastcall ChildGet()
+    TSubModel * ChildGet()
     {
         return Child;
     };
     int TriangleAdd(TModel3d *m, int tex, int tri);
-    float8 *__fastcall TrianglePtr(int tex, int pos, int *la, int *ld, int *ls);
+    float8 * TrianglePtr(int tex, int pos, int *la, int *ld, int *ls);
     // float8* TrianglePtr(const char *tex,int tri);
     // void SetRotate(vector3 vNewRotateAxis,float fNewAngle);
     void SetRotate(float3 vNewRotateAxis, float fNewAngle);
@@ -280,14 +280,14 @@ class TSubModel
     void SetTranslate(vector3 vNewTransVector);
     void SetTranslate(float3 vNewTransVector);
     void SetRotateIK1(float3 vNewAngles);
-    TSubModel *__fastcall GetFromName(AnsiString search, bool i = true);
-    TSubModel *__fastcall GetFromName(char *search, bool i = true);
+    TSubModel * GetFromName(AnsiString search, bool i = true);
+    TSubModel * GetFromName(char *search, bool i = true);
     void RenderDL();
     void RenderAlphaDL();
     void RenderVBO();
     void RenderAlphaVBO();
     // inline matrix4x4* GetMatrix() {return dMatrix;};
-    inline float4x4 *__fastcall GetMatrix()
+    inline float4x4 * GetMatrix()
     {
         return fMatrix;
     };
@@ -390,7 +390,7 @@ class TModel3d : public CMesh
     int iSubModelsCount; // Ra: używane do tworzenia binarnych
     AnsiString asBinary; // nazwa pod którą zapisać model binarny
   public:
-    inline TSubModel *__fastcall GetSMRoot()
+    inline TSubModel * GetSMRoot()
     {
         return (Root);
     };
@@ -398,9 +398,9 @@ class TModel3d : public CMesh
     TModel3d();
     TModel3d(char *FileName);
     ~TModel3d();
-    TSubModel *__fastcall GetFromName(const char *sName);
+    TSubModel * GetFromName(const char *sName);
     // TMaterial* GetMaterialFromName(char *sName);
-    TSubModel *__fastcall AddToNamed(const char *Name, TSubModel *SubModel);
+    TSubModel * AddToNamed(const char *Name, TSubModel *SubModel);
     void AddTo(TSubModel *tmp, TSubModel *SubModel);
     void LoadFromTextFile(char *FileName, bool dynamic);
     void LoadFromBinFile(char *FileName, bool dynamic);
@@ -438,12 +438,12 @@ class TModel3d : public CMesh
         return iFlags;
     };
     void Init();
-    char *__fastcall NameGet()
+    char * NameGet()
     {
         return Root ? Root->pName : NULL;
     };
     int TerrainCount();
-    TSubModel *__fastcall TerrainSquare(int n);
+    TSubModel * TerrainSquare(int n);
     void TerrainRenderVBO(int n);
 };
 
diff --git a/Mover.h b/Mover.h
index f92b3eb1..51909893 100644
--- a/Mover.h
+++ b/Mover.h
@@ -169,7 +169,7 @@ class TMoverParameters : public T_MoverParameters
     // &Track, const
     //	TLocation &NewLoc, TRotation &NewRot);
     // bool ChangeOffsetH(double DeltaOffset);
-    //__fastcall T_MoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit,
+    // T_MoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit,
     // int LoadInitial
     //	, AnsiString LoadTypeInitial, int Cab);
     // bool LoadChkFile(AnsiString chkpath);
diff --git a/Names.cpp b/Names.cpp
index 331da6f9..6c673e08 100644
--- a/Names.cpp
+++ b/Names.cpp
@@ -69,13 +69,13 @@ void ItemRecord::ListGet(ItemRecord *r, int *&n)
         rNext->ListGet(r, n); // dodanie wszystkich późniejszych
 };
 
-void *__fastcall ItemRecord::TreeFind(const char *n)
+void * ItemRecord::TreeFind(const char *n)
 { // wyszukanie ciągu (n)
     ItemRecord *r = TreeFindRecord(n);
     return r ? r->pData : NULL;
 };
 
-ItemRecord *__fastcall ItemRecord::TreeFindRecord(const char *n)
+ItemRecord * ItemRecord::TreeFindRecord(const char *n)
 { // wyszukanie ciągu (n)
     ItemRecord *r = this; //żeby nie robić rekurencji
     int i = 0;
@@ -147,7 +147,7 @@ bool TNames::Update(int t, const char *n, void *d)
     return false; // został dodany nowy
 };
 
-ItemRecord *__fastcall TNames::TreeSet(int *n, int d, int u)
+ItemRecord * TNames::TreeSet(int *n, int d, int u)
 { // rekurencyjne wypełnianie drzewa pozycjami od (d) do (u)
     if (d == u)
     {
@@ -177,7 +177,7 @@ void TNames::Sort(int t)
     return;
 };
 
-ItemRecord *__fastcall TNames::FindRecord(const int t, const char *n)
+ItemRecord * TNames::FindRecord(const int t, const char *n)
 { // poszukiwanie rekordu w celu np. zmiany wskaźnika
     return rTypes[t] ? rTypes[t]->TreeFindRecord(n) : NULL;
 };
diff --git a/Names.h b/Names.h
index 3ddcaf85..de38a637 100644
--- a/Names.h
+++ b/Names.h
@@ -34,8 +34,8 @@ class ItemRecord
     {
         pData = (void *)x;
     };
-    void *__fastcall TreeFind(const char *n);
-    ItemRecord *__fastcall TreeFindRecord(const char *n);
+    void * TreeFind(const char *n);
+    ItemRecord * TreeFindRecord(const char *n);
 };
 
 class TNames
@@ -54,14 +54,14 @@ class TNames
     int Add(int t, const char *n, int d); // dodanie obiektu z numerem
     bool Update(int t, const char *n, void *d); // dodanie jeśli nie ma, wymiana (d), gdy jest
     void TreeSet();
-    ItemRecord *__fastcall TreeSet(int *n, int d, int u);
+    ItemRecord * TreeSet(int *n, int d, int u);
     void Sort(int t); // przebudowa drzewa typu (t)
-    ItemRecord *__fastcall Item(int n); // rekord o numerze (n)
+    ItemRecord * Item(int n); // rekord o numerze (n)
     inline void *Find(const int t, const char *n)
     {
         return rTypes[t] ? rTypes[t]->TreeFind(n) : NULL;
     };
-    ItemRecord *__fastcall FindRecord(const int t, const char *n);
+    ItemRecord * FindRecord(const int t, const char *n);
     // template <typename TOut> inline TOut* Find(const int t,const char *n)
     //{return (TOut*)(rTypes[t]->TreeFind(n));};
 };
diff --git a/Sound.cpp b/Sound.cpp
index 06b4cc0c..27e1c50c 100644
--- a/Sound.cpp
+++ b/Sound.cpp
@@ -182,7 +182,7 @@ void TSoundsManager::Free()
     SAFE_RELEASE(pDS);
 };
 
-TSoundContainer *__fastcall TSoundsManager::LoadFromFile(char *Dir, char *Name, int Concurrent)
+TSoundContainer * TSoundsManager::LoadFromFile(char *Dir, char *Name, int Concurrent)
 {
     TSoundContainer *Tmp = First;
     First = new TSoundContainer(pDS, Dir, Name, Concurrent);
@@ -303,7 +303,7 @@ void TSoundsManager::RestoreAll()
 };
 
 // void TSoundsManager::Init(char *Name, int Concurrent)
-//__fastcall TSoundsManager::TSoundsManager(HWND hWnd)
+// TSoundsManager::TSoundsManager(HWND hWnd)
 // void TSoundsManager::Init(HWND hWnd, char *NDirectory)
 
 void TSoundsManager::Init(HWND hWnd)
diff --git a/Sound.h b/Sound.h
index 37652b45..914b977f 100644
--- a/Sound.h
+++ b/Sound.h
@@ -51,7 +51,7 @@ class TSoundsManager
     // static char Directory[80];
     static int Count;
     static TSoundContainer *First;
-    static TSoundContainer *__fastcall LoadFromFile(char *Dir, char *Name, int Concurrent);
+    static TSoundContainer * LoadFromFile(char *Dir, char *Name, int Concurrent);
 
   public:
     // TSoundsManager(HWND hWnd);
diff --git a/Spline.cpp b/Spline.cpp
index 2c4c5525..15711487 100644
--- a/Spline.cpp
+++ b/Spline.cpp
@@ -47,7 +47,7 @@ float CurveLength(vector3 p1, vector3 cp1, vector3 cp2, vector3 p2)
     return (l);
 }
 
-__fastcall TKnot::TKnot()
+ TKnot::TKnot()
 {
     Next = Prev = NULL;
     Length = -1;
@@ -58,7 +58,7 @@ __fastcall TKnot::TKnot()
     bSwitchDirectionBackward = false;
 }
 
-__fastcall TKnot::TKnot(int n)
+ TKnot::TKnot(int n)
 {
     bSwitchDirectionForward = false;
     bSwitchDirectionBackward = false;
@@ -73,7 +73,7 @@ __fastcall TKnot::TKnot(int n)
     }
 }
 
-__fastcall TKnot::~TKnot()
+ TKnot::~TKnot()
 {
 }
 
@@ -241,7 +241,7 @@ float TKnot::RombergIntegral(float fA, float fB)
 
 //----------------------------------------------------------------------------//
 
-__fastcall TSpline::TSpline()
+ TSpline::TSpline()
 {
     //    Closed= true;
     //    asName= "foo";
@@ -252,7 +252,7 @@ __fastcall TSpline::TSpline()
     //    Next=Prev= this;
 }
 
-__fastcall TSpline::TSpline(AnsiString asNName)
+ TSpline::TSpline(AnsiString asNName)
 {
     //    Closed= true;
     //    asName= asNName;
@@ -263,7 +263,7 @@ __fastcall TSpline::TSpline(AnsiString asNName)
     //    Next=Prev= this;
 }
 
-__fastcall TSpline::~TSpline()
+ TSpline::~TSpline()
 {
     //  if (KnotsAllocated)
     //        SafeDeleteArray(Knots);
@@ -473,7 +473,7 @@ vector3 TSpline::GetCenter()
         pt /= iNumKnots;
 }
 
-TKnot *__fastcall TSpline::GetLastKnot()
+TKnot * TSpline::GetLastKnot()
 {
     TKnot *ck;
     ck = RootKnot;
diff --git a/Spline.h b/Spline.h
index d60d2cf0..39d9aa6c 100644
--- a/Spline.h
+++ b/Spline.h
@@ -74,7 +74,7 @@ class TSpline
     int Load(TQueryParserComp *Parser, AnsiString asEndString = "endspline");
     float GetLength();
     vector3 GetCenter();
-    TKnot *__fastcall GetLastKnot();
+    TKnot * GetLastKnot();
     bool Render();
 
     //    inline int NextIndex(int n) { return (n<KnotsCount-1 ? n+1 : 0); };
diff --git a/Track.cpp b/Track.cpp
index e6a6bb78..9fda115c 100644
--- a/Track.cpp
+++ b/Track.cpp
@@ -115,7 +115,7 @@ TIsolated::~TIsolated(){
     */
 };
 
-TIsolated *__fastcall TIsolated::Find(const AnsiString &n)
+TIsolated * TIsolated::Find(const AnsiString &n)
 { // znalezienie obiektu albo utworzenie nowego
     TIsolated *p = pRoot;
     while (p)
@@ -248,7 +248,7 @@ void TTrack::Init()
     }
 }
 
-TTrack *__fastcall TTrack::Create400m(int what, double dx)
+TTrack * TTrack::Create400m(int what, double dx)
 { // tworzenie toru do wstawiania taboru podczas konwersji na E3D
     TGroundNode *tmp = new TGroundNode(TP_TRACK); // node
     TTrack *trk = tmp->pTrack;
@@ -264,7 +264,7 @@ TTrack *__fastcall TTrack::Create400m(int what, double dx)
     return trk;
 };
 
-TTrack *__fastcall TTrack::NullCreate(int dir)
+TTrack * TTrack::NullCreate(int dir)
 { // tworzenie toru wykolejającego od strony (dir), albo pętli dla samochodów
     TGroundNode *tmp = new TGroundNode(TP_TRACK), *tmp2 = NULL; // node
     TTrack *trk = tmp->pTrack; // tor; UWAGA! obrotnica może generować duże ilości tego
@@ -2828,7 +2828,7 @@ void TTrack::RaAnimListAdd(TTrack *t)
     }
 };
 
-TTrack *__fastcall TTrack::RaAnimate()
+TTrack * TTrack::RaAnimate()
 { // wykonanie rekurencyjne animacji, wywoływane przed wyświetleniem sektora
     // zwraca wskaźnik toru wymagającego dalszej animacji
     if (SwitchExtension->pNextAnim)
@@ -3146,7 +3146,7 @@ void TTrack::ConnectionsLog()
         }
 };
 
-TTrack *__fastcall TTrack::Neightbour(int s, double &d)
+TTrack * TTrack::Neightbour(int s, double &d)
 { // zwraca wskaźnik na sąsiedni tor, w kierunku określonym znakiem (s), odwraca (d) w razie
     // niezgodności kierunku torów
     TTrack *t; // nie zmieniamy kierunku (d), jeśli nie ma toru dalej
diff --git a/Track.h b/Track.h
index cd81f9c1..bf736ff4 100644
--- a/Track.h
+++ b/Track.h
@@ -108,18 +108,18 @@ class TIsolated
     TIsolated();
     TIsolated(const AnsiString &n, TIsolated *i);
     ~TIsolated();
-    static TIsolated *__fastcall Find(
+    static TIsolated * Find(
         const AnsiString &n); // znalezienie obiektu albo utworzenie nowego
     void Modify(int i, TDynamicObject *o); // dodanie lub odjęcie osi
     bool Busy()
     {
         return (iAxles > 0);
     };
-    static TIsolated *__fastcall Root()
+    static TIsolated * Root()
     {
         return (pRoot);
     };
-    TIsolated *__fastcall Next()
+    TIsolated * Next()
     {
         return (pNext);
     };
@@ -192,8 +192,8 @@ class TTrack : public Resource
     TTrack(TGroundNode *g);
     ~TTrack();
     void Init();
-    static TTrack *__fastcall Create400m(int what, double dx);
-    TTrack *__fastcall NullCreate(int dir);
+    static TTrack * Create400m(int what, double dx);
+    TTrack * NullCreate(int dir);
     inline bool IsEmpty()
     {
         return (iNumDynamics <= 0);
@@ -206,19 +206,19 @@ class TTrack : public Resource
     {
         return Segment->GetLength();
     };
-    inline TSegment *__fastcall CurrentSegment()
+    inline TSegment * CurrentSegment()
     {
         return Segment;
     };
-    inline TTrack *__fastcall CurrentNext()
+    inline TTrack * CurrentNext()
     {
         return (trNext);
     };
-    inline TTrack *__fastcall CurrentPrev()
+    inline TTrack * CurrentPrev()
     {
         return (trPrev);
     };
-    TTrack *__fastcall Neightbour(int s, double &d);
+    TTrack * Neightbour(int s, double &d);
     bool SetConnections(int i);
     bool Switch(int i, double t = -1.0, double d = -1.0);
     bool SwitchForced(int i, TDynamicObject *o);
@@ -257,7 +257,7 @@ class TTrack : public Resource
     void RaAssign(TGroundNode *gn, TAnimContainer *ac);
     void RaAssign(TGroundNode *gn, TAnimModel *am, TEvent *done, TEvent *joined);
     void RaAnimListAdd(TTrack *t);
-    TTrack *__fastcall RaAnimate();
+    TTrack * RaAnimate();
 
     void RadioStop();
     void AxleCounter(int i, TDynamicObject *o)
diff --git a/Train.cpp b/Train.cpp
index d10a4a2f..d5c4b5c9 100644
--- a/Train.cpp
+++ b/Train.cpp
@@ -95,7 +95,7 @@ TCab::~TCab()
     delete[] btList;
 };
 
-TGauge *__fastcall TCab::Gauge(int n)
+TGauge * TCab::Gauge(int n)
 { // pobranie adresu obiektu aniomowanego ruchem
     if (n < 0)
     { // rezerwacja wolnego
@@ -106,7 +106,7 @@ TGauge *__fastcall TCab::Gauge(int n)
         return ggList + n;
     return NULL;
 };
-TButton *__fastcall TCab::Button(int n)
+TButton * TCab::Button(int n)
 { // pobranie adresu obiektu animowanego wyborem 1 z 2
     if (n < 0)
     { // rezerwacja wolnego
diff --git a/Train.h b/Train.h
index ada05131..c69cae69 100644
--- a/Train.h
+++ b/Train.h
@@ -62,8 +62,8 @@ class TCab
     TButton *btList; // Ra 2014-08: lista animacji dwustanowych (lampek) w kabinie
     int iButtonsMax, iButtons; // ile miejsca w tablicy i ile jest w użyciu
   public:
-    TGauge *__fastcall Gauge(int n = -1); // pobranie adresu obiektu
-    TButton *__fastcall Button(int n = -1); // pobranie adresu obiektu
+    TGauge * Gauge(int n = -1); // pobranie adresu obiektu
+    TButton * Button(int n = -1); // pobranie adresu obiektu
     void Update();
 };
 
@@ -410,11 +410,11 @@ class TTrain
     {
         return iRadioChannel;
     };
-    inline TDynamicObject *__fastcall Dynamic()
+    inline TDynamicObject * Dynamic()
     {
         return DynamicObject;
     };
-    inline TMoverParameters *__fastcall Controlled()
+    inline TMoverParameters * Controlled()
     {
         return mvControlled;
     };
diff --git a/TrkFoll.cpp b/TrkFoll.cpp
index 019c01d4..ee2f3bf5 100644
--- a/TrkFoll.cpp
+++ b/TrkFoll.cpp
@@ -53,7 +53,7 @@ bool TTrackFollower::Init(TTrack *pTrack, TDynamicObject *NewOwner, double fDir)
     return true;
 }
 
-TTrack *__fastcall TTrackFollower::SetCurrentTrack(TTrack *pTrack, int end)
+TTrack * TTrackFollower::SetCurrentTrack(TTrack *pTrack, int end)
 { // przejechanie na inny odcinkek toru, z ewentualnym rozpruciem
     if (pTrack)
         switch (pTrack->eType)
diff --git a/TrkFoll.h b/TrkFoll.h
index 5c8c126a..4366f73a 100644
--- a/TrkFoll.h
+++ b/TrkFoll.h
@@ -33,9 +33,9 @@ class TTrackFollower
     vector3 vAngles; // x:przechyłka, y:pochylenie, z:kierunek w planie (w radianach)
     TTrackFollower();
     ~TTrackFollower();
-    TTrack *__fastcall SetCurrentTrack(TTrack *pTrack, int end);
+    TTrack * SetCurrentTrack(TTrack *pTrack, int end);
     bool Move(double fDistance, bool bPrimary);
-    inline TTrack *__fastcall GetTrack()
+    inline TTrack * GetTrack()
     {
         return pCurrentTrack;
     };
diff --git a/geometry.cpp b/geometry.cpp
index a4ef3a13..ced642a8 100644
--- a/geometry.cpp
+++ b/geometry.cpp
@@ -16,15 +16,15 @@ inline double sqr(double a)
     return (a * a);
 };
 
-__fastcall TLine::TLine(){};
+ TLine::TLine(){};
 
-__fastcall TLine::TLine(vector3 NPoint, vector3 NVector)
+ TLine::TLine(vector3 NPoint, vector3 NVector)
 {
     Vector = NVector;
     Point = NPoint;
 };
 
-__fastcall TLine::~TLine(){};
+ TLine::~TLine(){};
 
 TPlane TLine::GetPlane()
 {
@@ -42,31 +42,31 @@ double TLine::GetDistance(vector3 Point1)
 
 //---------------------------------------------------------------------------
 
-__fastcall TPlane::TPlane()
+ TPlane::TPlane()
 {
     Vector = vector3(0, 0, 0);
     d = 0;
 };
 
-__fastcall TPlane::TPlane(vector3 NVector, double nd)
+ TPlane::TPlane(vector3 NVector, double nd)
 {
     Vector = NVector;
     d = nd;
 }
 
-__fastcall TPlane::TPlane(vector3 Point, vector3 NVector)
+ TPlane::TPlane(vector3 Point, vector3 NVector)
 {
     Vector = NVector;
     d = -NVector.x * Point.x - NVector.y * Point.y - NVector.z * Point.z;
 };
 
-__fastcall TPlane::TPlane(vector3 Point1, vector3 Vector1, vector3 Vector2)
+ TPlane::TPlane(vector3 Point1, vector3 Vector1, vector3 Vector2)
 {
     Vector = CrossProduct(Vector1, Vector2);
     d = -Vector.x * Point1.x - Vector.y * Point1.y - Vector.z * Point1.z;
 };
 
-__fastcall TPlane::~TPlane(){};
+ TPlane::~TPlane(){};
 
 void TPlane::Normalize()
 {
diff --git a/python/include/pyport.h b/python/include/pyport.h
index 1abc14c5..693d0935 100644
--- a/python/include/pyport.h
+++ b/python/include/pyport.h
@@ -272,8 +272,8 @@ typedef Py_intptr_t     Py_ssize_t;
 /* ignore warnings if the compiler decides not to inline a function */
 #pragma warning(disable: 4710)
 /* fastest possible local call under MSVC */
-#define Py_LOCAL(type) static type __fastcall
-#define Py_LOCAL_INLINE(type) static __inline type __fastcall
+#define Py_LOCAL(type) static type 
+#define Py_LOCAL_INLINE(type) static __inline type 
 #elif defined(USE_INLINE)
 #define Py_LOCAL(type) static type
 #define Py_LOCAL_INLINE(type) static inline type