diff --git a/Driver.cpp b/Driver.cpp
index d4069481..57ec94a6 100644
--- a/Driver.cpp
+++ b/Driver.cpp
@@ -28,7 +28,7 @@ http://mozilla.org/MPL/2.0/.
 #include "McZapkie/MOVER.h"
 
 #define LOGVELOCITY 0
-#define LOGORDERS 0
+#define LOGORDERS 1
 #define LOGSTOPS 1
 #define LOGBACKSCAN 0
 #define LOGPRESS 0
@@ -2354,7 +2354,7 @@ bool TController::IncBrake()
                 */
                 // dodane dla towarowego
                 if (mvOccupied->BrakeDelayFlag == bdelay_G ?
-                        -AccDesired * 6.6 > Min0R(2, mvOccupied->BrakeCtrlPos) :
+                        -AccDesired * 6.6 > std::min(2, mvOccupied->BrakeCtrlPos) :
                         true)
                 {
                     OK = mvOccupied->IncBrakeLevel();
@@ -3254,6 +3254,7 @@ bool TController::UpdateSituation(double dt)
 { // uruchamiać przynajmniej raz na sekundę
     if ((iDrivigFlags & movePrimary) == 0)
         return true; // pasywny nic nie robi
+
     double AbsAccS;
     // double VelReduced; //o ile km/h może przekroczyć dozwoloną prędkość bez hamowania
     bool UpdateOK = false;
@@ -3593,8 +3594,7 @@ bool TController::UpdateSituation(double dt)
                         if ((mvControlling->MainCtrlPos > 0) ||
                             (mvOccupied->BrakeSystem == ElectroPneumatic)) // jeśli jazda
                         {
-                            // WriteLog("Odczepianie w kierunku
-                            // "+AnsiString(mvOccupied->DirAbsolute));
+                            WriteLog(mvOccupied->Name + " odczepianie w kierunku " + std::to_string(mvOccupied->DirAbsolute));
                             TDynamicObject *p =
                                 pVehicle; // pojazd do odczepienia, w (pVehicle) siedzi AI
                             int d; // numer sprzęgu, który sprawdzamy albo odczepiamy
@@ -3629,14 +3629,14 @@ bool TController::UpdateSituation(double dt)
                             else if (!p->Dettach(d)) // zwraca maskę bitową połączenia; usuwa
                             // własność pojazdów
                             { // tylko jeśli odepnie
-                                // WriteLog("Odczepiony od strony ");
+                                WriteLog( mvOccupied->Name + " odczepiony." );
                                 iVehicleCount = -2;
                             } // a jak nie, to dociskać dalej
                         }
                         if (iVehicleCount >= 0) // zmieni się po odczepieniu
                             if (!mvOccupied->DecLocalBrakeLevel(1))
                             { // dociśnij sklad
-                                // WriteLog("Dociskanie");
+                                WriteLog( mvOccupied->Name + " dociskanie..." );
                                 // mvOccupied->BrakeReleaser(); //wyluzuj lokomotywę
                                 // Ready=true; //zamiast sprawdzenia odhamowania całego składu
                                 IncSpeed(); // dla (Ready)==false nie ruszy
@@ -3665,7 +3665,7 @@ bool TController::UpdateSituation(double dt)
                                 mvOccupied->BrakeLevelSet(0); // wyłączenie EP, gdy wystarczy (może
                             // nie być potrzebne, bo na początku
                             // jest)
-                            // WriteLog("Luzowanie lokomotywy i zmiana kierunku");
+                            WriteLog("Luzowanie lokomotywy i zmiana kierunku");
                             mvOccupied->BrakeReleaser(1); // wyluzuj lokomotywę; a ST45?
                             mvOccupied->DecLocalBrakeLevel(10); // zwolnienie hamulca
                             iDrivigFlags |= movePress; // następnie będzie dociskanie
@@ -3683,7 +3683,7 @@ bool TController::UpdateSituation(double dt)
                     SetVelocity(0, 0, stopJoin); // wyłączyć przyspieszanie
                     if (!DecSpeed()) // jeśli już bardziej wyłączyć się nie da
                     { // ponowna zmiana kierunku
-                        // WriteLog("Ponowna zmiana kierunku");
+                        WriteLog( mvOccupied->Name + " ponowna zmiana kierunku" );
                         DirectionForward(mvOccupied->ActiveDir <
                                          0); // zmiana kierunku jazdy na właściwy
                         iDrivigFlags &= ~movePress; // koniec dociskania
@@ -3752,6 +3752,7 @@ bool TController::UpdateSituation(double dt)
             fVelPlus = 2.0; // dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
             fVelMinus = 5.0; // margines prędkości powodujący załączenie napędu
         } // switch
+
         switch (OrderList[OrderPos])
         { // co robi maszynista
         case Prepare_engine: // odpala silnik
@@ -3771,7 +3772,7 @@ bool TController::UpdateSituation(double dt)
             }
             break;
         case Release_engine:
-            if (ReleaseEngine()) // zdana maszyna?
+            if( ReleaseEngine() ) // zdana maszyna?
                 JumpToNextOrder();
             break;
         case Jump_to_first_order:
@@ -5273,12 +5274,9 @@ void TController::TakeControl(bool yes)
         // gdy zgaszone światła, flaga podjeżdżania pod semafory pozostaje bez zmiany
         // conditional below disabled to get around the situation where the AI train does nothing ever
         // because it is waiting for orders which don't come until the engine is engaged, i.e. effectively never
-/*
         if (OrderCurrentGet()) // jeśli coś robi
-*/            PrepareEngine(); // niech sprawdzi stan silnika
-/*
+            PrepareEngine(); // niech sprawdzi stan silnika
         else // jeśli nic nie robi
-*/
         if (pVehicle->iLights[mvOccupied->CabNo < 0 ? 1 : 0] &
                 21) // któreś ze świateł zapalone?
         { // od wersji 357 oczekujemy podania komend dla AI przez scenerię
diff --git a/EvLaunch.cpp b/EvLaunch.cpp
index ee27fe78..72b815e9 100644
--- a/EvLaunch.cpp
+++ b/EvLaunch.cpp
@@ -66,8 +66,8 @@ bool TEventLauncher::Load(cParser *parser)
     *parser >> token;
     if (token != "none")
     {
-        if (token.length() == 1)
-            iKey = VkKeyScan(token[1]); // jeden znak jest konwertowany na kod klawisza
+        if (token.size() == 1)
+            iKey = VkKeyScan(token[0]); // jeden znak jest konwertowany na kod klawisza
         else
             iKey = stol_def(token,0); // a jak więcej, to jakby numer klawisza jest
     }
diff --git a/Ground.cpp b/Ground.cpp
index f3c0af7f..39f74e65 100644
--- a/Ground.cpp
+++ b/Ground.cpp
@@ -2653,26 +2653,29 @@ bool TGround::Init(std::string asFile, HDC hDC)
                 TEvent *found = FindEvent(tmp->asName);
                 if (found)
                 { // jeśli znaleziony duplikat
-                    int i = tmp->asName.length();
-                    if (tmp->asName[1] == '#') // zawsze jeden znak co najmniej jest
+                    auto const size = tmp->asName.size();
+                    if( tmp->asName[0] == '#' ) // zawsze jeden znak co najmniej jest
                     {
                         delete tmp;
-                        tmp = NULL;
+                        tmp = nullptr;
                     } // utylizacja duplikatu z krzyżykiem
-                    else if (i > 8 ? tmp->asName.substr(0, 9) == "lineinfo:" :
-                                     false) // tymczasowo wyjątki
+                    else if( ( size > 8 )
+                          && ( tmp->asName.substr( 0, 9 ) == "lineinfo:" ))
+                        // tymczasowo wyjątki
                     {
                         delete tmp;
-                        tmp = NULL;
+                        tmp = nullptr;
                     } // tymczasowa utylizacja duplikatów W5
-                    else if (i > 8 ? tmp->asName.substr(i - 7, 8) == "_warning" :
-                                     false) // tymczasowo wyjątki
+                    else if( ( size > 8 )
+                          && ( tmp->asName.substr( size - 8 ) == "_warning"))
+                        // tymczasowo wyjątki
                     {
                         delete tmp;
-                        tmp = NULL;
+                        tmp = nullptr;
                     } // tymczasowa utylizacja duplikatu z trąbieniem
-                    else if (i > 4 ? tmp->asName.substr(i - 3, 4) == "_shp" :
-                                     false) // nie podlegają logowaniu
+                    else if( ( size > 4 )
+                          && ( tmp->asName.substr( size - 4 ) == "_shp" ))
+                          // nie podlegają logowaniu
                     {
                         delete tmp;
                         tmp = NULL;
@@ -2690,7 +2693,7 @@ bool TGround::Init(std::string asFile, HDC hDC)
                             // zaśmiecać drzewka
                         }
                 }
-                if (tmp)
+                if ( nullptr != tmp )
                 { // jeśli nie duplikat
                     tmp->evNext2 = RootEvent; // lista wszystkich eventów (m.in. do InitEvents)
                     RootEvent = tmp;
diff --git a/McZapkie/MOVER.h b/McZapkie/MOVER.h
index 01c3104e..ee072da9 100644
--- a/McZapkie/MOVER.h
+++ b/McZapkie/MOVER.h
@@ -1150,7 +1150,8 @@ private:
 extern double Distance(TLocation Loc1, TLocation Loc2, TDimension Dim1, TDimension Dim2);
 
 template <typename _Type>
-bool getkeyval( _Type &Variable, std::string const &Key, std::string const &Input, std::string const &Default ) {
+bool
+extract_value( _Type &Variable, std::string const &Key, std::string const &Input, std::string const &Default ) {
 
     auto value = extract_value( Key, Input );
     if( false == value.empty() ) {
diff --git a/McZapkie/Mover.cpp b/McZapkie/Mover.cpp
index d83a1321..8055a556 100644
--- a/McZapkie/Mover.cpp
+++ b/McZapkie/Mover.cpp
@@ -2737,7 +2737,7 @@ bool TMoverParameters::BrakeDelaySwitch(int BDS)
     {
         BrakeDelayFlag = BDS;
         rBDS = true;
-        BrakeStatus = (BrakeStatus & 191);
+        BrakeStatus &= 191;
         // kopowanie nastawy hamulca do kolejnego czlonu - do przemyślenia
         if (CabNo != 0)
             SendCtrlToNext("BrakeDelay", BrakeDelayFlag, CabNo);
@@ -3350,8 +3350,10 @@ void TMoverParameters::ComputeTotalForce(double dt, double dt1, bool FullVer)
         Vel = abs(V) * 3.6; // prędkość w km/h
         nrot = v2n(); // przeliczenie prędkości liniowej na obrotową
 
-        if (TestFlag(BrakeMethod, bp_MHS) && (PipePress < 3.0) && (Vel > 45) &&
-            TestFlag(BrakeDelayFlag, bdelay_M)) // ustawione na sztywno na 3 bar
+        if( (true == TestFlag(BrakeMethod, bp_MHS))
+         && (PipePress < 3.0)
+         && (Vel > 45)
+         && (true == TestFlag(BrakeDelayFlag, bdelay_M))) // ustawione na sztywno na 3 bar
             FStand += TrackBrakeForce; // doliczenie hamowania hamulcem szynowym
         // w charakterystykach jest wartość siły hamowania zamiast nacisku
         //    if(FullVer=true) then
@@ -3496,7 +3498,7 @@ double TMoverParameters::BrakeForce(const TTrackParam &Track)
     {
         if (Ntotal > 0) // nie luz
             K += Ntotal; // w kN
-        K *= BrakeCylNo / (NBrakeAxles * NBpA); // w kN na os
+        K *= static_cast<double>(BrakeCylNo) / (NBrakeAxles * static_cast<double>(NBpA)); // w kN na os
     }
     if ((BrakeSystem == Pneumatic) || (BrakeSystem == ElectroPneumatic))
     {
@@ -6197,13 +6199,13 @@ bool TMoverParameters::LoadFIZ(std::string chkpath)
 
 void TMoverParameters::LoadFIZ_Param( std::string const &line ) {
 
-    getkeyval( Mass, "M", line, "0" );
-    getkeyval( Mred, "Mred", line, "0" );
-    getkeyval( Vmax, "Vmax", line, "0" );
-    getkeyval( Power, "PWR", line, "0" );
-    getkeyval( SandCapacity, "SandCap", line, "0" );
-    getkeyval( HeatingPower, "HeatingP", line, "0" );
-    getkeyval( LightPower, "LightP", line, "0" );
+    extract_value( Mass, "M", line, "0" );
+    extract_value( Mred, "Mred", line, "0" );
+    extract_value( Vmax, "Vmax", line, "0" );
+    extract_value( Power, "PWR", line, "0" );
+    extract_value( SandCapacity, "SandCap", line, "0" );
+    extract_value( HeatingPower, "HeatingP", line, "0" );
+    extract_value( LightPower, "LightP", line, "0" );
 
     {
         std::map<std::string, int> categories{
@@ -6213,7 +6215,7 @@ void TMoverParameters::LoadFIZ_Param( std::string const &line ) {
             { "ship", 4 },
             { "airplane,", 8 }
         };
-        std::string category; getkeyval( category, "Category", line, "none" );
+        std::string category; extract_value( category, "Category", line, "none" );
         auto lookup = categories.find( category );
         CategoryFlag = (
             lookup != categories.end() ?
@@ -6237,7 +6239,7 @@ void TMoverParameters::LoadFIZ_Param( std::string const &line ) {
             { "181", dt_181 },
             { "182", dt_181 } // na razie tak
         };
-        std::string type; getkeyval( type, "Type", line, "none" );
+        std::string type; extract_value( type, "Type", line, "none" );
         auto lookup = types.find( ToLower( type ) );
         TrainType = (
             lookup != types.end() ?
@@ -6255,24 +6257,25 @@ void TMoverParameters::LoadFIZ_Param( std::string const &line ) {
 
 void TMoverParameters::LoadFIZ_Load( std::string const &line ) {
 
-    getkeyval( LoadAccepted, "LoadAccepted", line, "" );
+    extract_value( LoadAccepted, "LoadAccepted", line, "" );
     if( true == LoadAccepted.empty() ) {
         return;
     }
+    LoadAccepted = ToLower( LoadAccepted );
 
-    getkeyval( MaxLoad, "MaxLoad", line, "" );
-    getkeyval( LoadQuantity, "LoadQ", line, "" );
-    getkeyval( OverLoadFactor, "OverLoadFactor", line, "" );
-    getkeyval( LoadSpeed, "LoadSpeed", line, "" );
-    getkeyval( UnLoadSpeed, "UnLoadSpeed", line, "" );
+    extract_value( MaxLoad, "MaxLoad", line, "" );
+    extract_value( LoadQuantity, "LoadQ", line, "" );
+    extract_value( OverLoadFactor, "OverLoadFactor", line, "" );
+    extract_value( LoadSpeed, "LoadSpeed", line, "" );
+    extract_value( UnLoadSpeed, "UnLoadSpeed", line, "" );
 }
 
 void TMoverParameters::LoadFIZ_Dimensions( std::string const &line ) {
 
-    getkeyval( Dim.L, "L", line, "" );
-    getkeyval( Dim.H, "H", line, "" );
-    getkeyval( Dim.W, "W", line, "" );
-    getkeyval( Cx, "Cx", line, "0.3" );
+    extract_value( Dim.L, "L", line, "" );
+    extract_value( Dim.H, "H", line, "" );
+    extract_value( Dim.W, "W", line, "" );
+    extract_value( Cx, "Cx", line, "0.3" );
     if( Dim.H <= 2.0 ) {
         //gdyby nie było parametru, lepsze to niż zero
         Floor = Dim.H;
@@ -6281,22 +6284,22 @@ void TMoverParameters::LoadFIZ_Dimensions( std::string const &line ) {
         //zgodność wsteczna
         Floor = 0.0;
     }
-    getkeyval( Floor, "Floor", line, "" );
+    extract_value( Floor, "Floor", line, "" );
 }
 
 void TMoverParameters::LoadFIZ_Wheels( std::string const &line ) {
 
-    getkeyval( WheelDiameter, "D", line, "" );
+    extract_value( WheelDiameter, "D", line, "" );
     WheelDiameterL = WheelDiameter; //gdyby nie było parametru, lepsze to niż zero
-    getkeyval( WheelDiameterL, "Dl", line, "" );
+    extract_value( WheelDiameterL, "Dl", line, "" );
     WheelDiameterT = WheelDiameter; //gdyby nie było parametru, lepsze to niż zero
-    getkeyval( WheelDiameterT, "Dt", line, "" );
+    extract_value( WheelDiameterT, "Dt", line, "" );
 
-    getkeyval( TrackW, "Tw", line, "" );
-    getkeyval( AxleInertialMoment, "AIM", line, "" );
+    extract_value( TrackW, "Tw", line, "" );
+    extract_value( AxleInertialMoment, "AIM", line, "" );
     if( AxleInertialMoment <= 0.0 ) { AxleInertialMoment = 1.0; }
 
-    getkeyval( AxleArangement, "Axle", line, "" );
+    extract_value( AxleArangement, "Axle", line, "" );
     NPoweredAxles = s2NPW( AxleArangement );
     NAxles = NPoweredAxles + s2NNW( AxleArangement );
 
@@ -6305,8 +6308,8 @@ void TMoverParameters::LoadFIZ_Wheels( std::string const &line ) {
         1 :
         0;
 
-    getkeyval( ADist, "Ad", line, "" );
-    getkeyval( BDist, "Bd", line, "" );
+    extract_value( ADist, "Ad", line, "" );
+    extract_value( BDist, "Bd", line, "" );
 }
 
 void TMoverParameters::LoadFIZ_Brake( std::string const &line ) {
@@ -6314,33 +6317,33 @@ void TMoverParameters::LoadFIZ_Brake( std::string const &line ) {
     BrakeValveDecode( extract_value( "BrakeValve", line ) );
     BrakeSubsystemDecode();
 
-    getkeyval( NBpA, "NBpA", line, "" );
-    getkeyval( MaxBrakeForce, "MBF", line, "" );
-    getkeyval( BrakeValveSize, "Size", line, "" );
-    getkeyval( TrackBrakeForce, "TBF", line, "" ); TrackBrakeForce *= 1000.0;
+    extract_value( NBpA, "NBpA", line, "" );
+    extract_value( MaxBrakeForce, "MBF", line, "" );
+    extract_value( BrakeValveSize, "Size", line, "" );
+    extract_value( TrackBrakeForce, "TBF", line, "" ); TrackBrakeForce *= 1000.0;
 
-    getkeyval( MaxBrakePress[ 3 ], "MaxBP", line, "" );
+    extract_value( MaxBrakePress[ 3 ], "MaxBP", line, "" );
     if( MaxBrakePress[ 3 ] > 0.0 ) {
 
-        getkeyval( BrakeCylNo, "BCN", line, "" );
+        extract_value( BrakeCylNo, "BCN", line, "" );
         if( BrakeCylNo > 0 ) {
 
-            getkeyval( MaxBrakePress[ 0 ], "MaxLBP", line, "" );
+            extract_value( MaxBrakePress[ 0 ], "MaxLBP", line, "" );
             if( MaxBrakePress[ 0 ] < 0.01 ) { MaxBrakePress[ 0 ] = MaxBrakePress[ 3 ]; }
-            getkeyval( MaxBrakePress[ 1 ], "TareMaxBP", line, "" );
-            getkeyval( MaxBrakePress[ 2 ], "MedMaxBP", line, "" );
-            getkeyval( MaxBrakePress[ 4 ], "MaxASBP", line, "" );
+            extract_value( MaxBrakePress[ 1 ], "TareMaxBP", line, "" );
+            extract_value( MaxBrakePress[ 2 ], "MedMaxBP", line, "" );
+            extract_value( MaxBrakePress[ 4 ], "MaxASBP", line, "" );
             if( MaxBrakePress[ 4 ] < 0.01 ) { MaxBrakePress[ 4 ] = 0.0; }
 
-            getkeyval( BrakeCylRadius, "BCR", line, "" );
-            getkeyval( BrakeCylDist, "BCD", line, "" );
-            getkeyval( BrakeCylSpring, "BCS", line, "" );
-            getkeyval( BrakeSlckAdj, "BSA", line, "" );
-            getkeyval( BrakeRigEff, "BRE", line, "1" );
+            extract_value( BrakeCylRadius, "BCR", line, "" );
+            extract_value( BrakeCylDist, "BCD", line, "" );
+            extract_value( BrakeCylSpring, "BCS", line, "" );
+            extract_value( BrakeSlckAdj, "BSA", line, "" );
+            extract_value( BrakeRigEff, "BRE", line, "1" );
 
-            getkeyval( BrakeCylMult[ 0 ], "BCM", line, "" );
-            getkeyval( BrakeCylMult[ 1 ], "BCMlo", line, "" );
-            getkeyval( BrakeCylMult[ 2 ], "BCMHi", line, "" );
+            extract_value( BrakeCylMult[ 0 ], "BCM", line, "" );
+            extract_value( BrakeCylMult[ 1 ], "BCMlo", line, "" );
+            extract_value( BrakeCylMult[ 2 ], "BCMHi", line, "" );
 
             P2FTrans = 100 * M_PI * std::pow( BrakeCylRadius, 2 ); // w kN/bar
 
@@ -6348,7 +6351,7 @@ void TMoverParameters::LoadFIZ_Brake( std::string const &line ) {
             else { LoadFlag = 0; }
 
             BrakeVolume = M_PI * std::pow( BrakeCylRadius, 2 ) * BrakeCylDist * BrakeCylNo;
-            getkeyval( BrakeVVolume, "BVV", line, "" );
+            extract_value( BrakeVVolume, "BVV", line, "" );
 
             {
                 std::map<std::string, int> brakemethods{
@@ -6370,7 +6373,7 @@ void TMoverParameters::LoadFIZ_Brake( std::string const &line ) {
                     0;
             }
 
-            getkeyval( RapidMult, "RM", line, "1" );
+            extract_value( RapidMult, "RM", line, "1" );
         }
     }
     else {
@@ -6379,18 +6382,18 @@ void TMoverParameters::LoadFIZ_Brake( std::string const &line ) {
     }
 
     CntrlPipePress = 5 + 0.001 * ( Random( 10 ) - Random( 10 ) ); //Ra 2014-07: trochę niedokładności
-    getkeyval( CntrlPipePress, "HiPP", line, "" );
+    extract_value( CntrlPipePress, "HiPP", line, "" );
     HighPipePress = CntrlPipePress;
     LowPipePress = std::min( HighPipePress, 3.5 );
-    getkeyval( LowPipePress, "LoPP", line, "" );
+    extract_value( LowPipePress, "LoPP", line, "" );
     DeltaPipePress = HighPipePress - LowPipePress;
 
-    getkeyval( VeselVolume, "Vv", line, "" );
+    extract_value( VeselVolume, "Vv", line, "" );
     if( VeselVolume == 0.0 ) { VeselVolume = 0.01; }
 
-    getkeyval( MinCompressor, "MinCP", line, "" );
-    getkeyval( MaxCompressor, "MaxCP", line, "" );
-    getkeyval( CompressorSpeed, "CompressorSpeed", line, "" );
+    extract_value( MinCompressor, "MinCP", line, "" );
+    extract_value( MaxCompressor, "MaxCP", line, "" );
+    extract_value( CompressorSpeed, "CompressorSpeed", line, "" );
     {
         std::map<std::string, int> compressorpowers{
             { "Converter", 2 },
@@ -6410,39 +6413,39 @@ void TMoverParameters::LoadFIZ_Brake( std::string const &line ) {
 void TMoverParameters::LoadFIZ_Doors( std::string const &line ) {
 
     DoorOpenCtrl = 0;
-    std::string openctrl; getkeyval( openctrl, "OpenCtrl", line, "" );
+    std::string openctrl; extract_value( openctrl, "OpenCtrl", line, "" );
     if( openctrl == "DriverCtrl" ) { DoorOpenCtrl = 1; }
 
     DoorCloseCtrl = 0;
-    std::string closectrl; getkeyval( closectrl, "CloseCtrl", line, "" );
+    std::string closectrl; extract_value( closectrl, "CloseCtrl", line, "" );
     if( closectrl == "DriverCtrl" ) { DoorCloseCtrl = 1; }
     else if( closectrl == "AutomaticCtrl" ) { DoorCloseCtrl = 2; }
 
-    if( DoorCloseCtrl == 2 ) { getkeyval( DoorStayOpen, "DoorStayOpen", line, "" ); }
+    if( DoorCloseCtrl == 2 ) { extract_value( DoorStayOpen, "DoorStayOpen", line, "" ); }
 
-    getkeyval( DoorOpenSpeed, "OpenSpeed", line, "" );
-    getkeyval( DoorCloseSpeed, "CloseSpeed", line, "" );
-    getkeyval( DoorMaxShiftL, "DoorMaxShiftL", line, "" );
-    getkeyval( DoorMaxShiftR, "DoorMaxShiftR", line, "" );
+    extract_value( DoorOpenSpeed, "OpenSpeed", line, "" );
+    extract_value( DoorCloseSpeed, "CloseSpeed", line, "" );
+    extract_value( DoorMaxShiftL, "DoorMaxShiftL", line, "" );
+    extract_value( DoorMaxShiftR, "DoorMaxShiftR", line, "" );
 
     DoorOpenMethod = 2; //obrót, default
-    std::string openmethod; getkeyval( openmethod, "DoorOpenMethod", line, "" );
+    std::string openmethod; extract_value( openmethod, "DoorOpenMethod", line, "" );
     if( openmethod == "Shift" ) { DoorOpenMethod = 1; } //przesuw
     else if( openmethod == "Fold" ) { DoorOpenMethod = 3; } //3 submodele się obracają
     else if( openmethod == "Plug" ) { DoorOpenMethod = 4; } //odskokowo-przesuwne
 
-    std::string closurewarning; getkeyval( closurewarning, "DoorClosureWarning", line, "" );
+    std::string closurewarning; extract_value( closurewarning, "DoorClosureWarning", line, "" );
     DoorClosureWarning = ( closurewarning == "Yes" );
 
-    std::string doorblocked; getkeyval( doorblocked, "DoorBlocked", line, "" );
+    std::string doorblocked; extract_value( doorblocked, "DoorBlocked", line, "" );
     DoorBlocked = ( doorblocked == "Yes" );
 
-    getkeyval( DoorMaxPlugShift, "DoorMaxShiftPlug", line, "" );
-    getkeyval( PlatformSpeed, "PlatformSpeed", line, "" );
-    getkeyval( PlatformMaxShift, "PlatformMaxSpeed", line, "" );
+    extract_value( DoorMaxPlugShift, "DoorMaxShiftPlug", line, "" );
+    extract_value( PlatformSpeed, "PlatformSpeed", line, "" );
+    extract_value( PlatformMaxShift, "PlatformMaxSpeed", line, "" );
 
     PlatformOpenMethod = 2; // obrót, default
-    std::string platformopenmethod; getkeyval( platformopenmethod, "PlatformOpenMethod", line, "" );
+    std::string platformopenmethod; extract_value( platformopenmethod, "PlatformOpenMethod", line, "" );
     if( platformopenmethod == "Shift" ) { PlatformOpenMethod = 1; } // przesuw
 }
 
@@ -6465,14 +6468,14 @@ void TMoverParameters::LoadFIZ_BuffCoupl( std::string const &line, int const Ind
         lookup->second :
         NoCoupler );
 
-    getkeyval( coupler->SpringKC, "kC", line, "" );
-    getkeyval( coupler->DmaxC, "DmaxC", line, "" );
-    getkeyval( coupler->FmaxC, "FmaxC", line, "" );
-    getkeyval( coupler->SpringKB, "kB", line, "" );
-    getkeyval( coupler->DmaxB, "DmaxB", line, "" );
-    getkeyval( coupler->FmaxB, "FmaxB", line, "" );
-    getkeyval( coupler->beta, "beta", line, "" );
-    getkeyval( coupler->AllowedFlag, "AllowedFlag", line, "" );
+    extract_value( coupler->SpringKC, "kC", line, "" );
+    extract_value( coupler->DmaxC, "DmaxC", line, "" );
+    extract_value( coupler->FmaxC, "FmaxC", line, "" );
+    extract_value( coupler->SpringKB, "kB", line, "" );
+    extract_value( coupler->DmaxB, "DmaxB", line, "" );
+    extract_value( coupler->FmaxB, "FmaxB", line, "" );
+    extract_value( coupler->beta, "beta", line, "" );
+    extract_value( coupler->AllowedFlag, "AllowedFlag", line, "" );
 
     if( coupler->AllowedFlag < 0 ) {
 
@@ -6517,7 +6520,7 @@ void TMoverParameters::LoadFIZ_BuffCoupl( std::string const &line, int const Ind
 
 void TMoverParameters::LoadFIZ_TurboPos( std::string const &Input ) {
 
-    getkeyval( TurboTest, "TurboPos", Input, "" );
+    extract_value( TurboTest, "TurboPos", Input, "" );
 }
 
 void TMoverParameters::LoadFIZ_Cntrl( std::string const &line ) {
@@ -6535,10 +6538,10 @@ void TMoverParameters::LoadFIZ_Cntrl( std::string const &line ) {
     }
     if( BrakeSystem != Individual ) {
 
-        getkeyval( BrakeCtrlPosNo, "BCPN", line, "" );
+        extract_value( BrakeCtrlPosNo, "BCPN", line, "" );
         for( int idx = 0; idx < 4; ++idx ) {
 
-            getkeyval( BrakeDelay[ idx ], "BDelay" + std::to_string( idx + 1 ), line, "" );
+            extract_value( BrakeDelay[ idx ], "BDelay" + std::to_string( idx + 1 ), line, "" );
         }
         // brakedelays, brakedelayflag
         {
@@ -6558,7 +6561,7 @@ void TMoverParameters::LoadFIZ_Cntrl( std::string const &line ) {
                 { "G", bdelay_G }
             };
             std::string brakedelay;
-            getkeyval( brakedelay, "BrakeDelays", line, "" );
+            extract_value( brakedelay, "BrakeDelays", line, "" );
             auto lookup = brakedelays.find( brakedelay );
             BrakeDelays =
                 lookup != brakedelays.end() ?
@@ -6573,7 +6576,7 @@ void TMoverParameters::LoadFIZ_Cntrl( std::string const &line ) {
         // brakeopmode
         {
             std::map<std::string, int> brakeopmodes{
-                { "PM", bom_PS + bom_PN },
+                { "PN", bom_PS + bom_PN },
                 { "PNEPMED", bom_PS + bom_PN + bom_EP + bom_MED }
             };
             auto lookup = brakeopmodes.find( extract_value( "BrakeOpModes", line ) );
@@ -6616,12 +6619,12 @@ void TMoverParameters::LoadFIZ_Cntrl( std::string const &line ) {
         }
 
         // mbpm
-        getkeyval( MBPM, "MaxBPMass", line, "" );
-        MBPM *= 1000;
+        extract_value( MBPM, "MaxBPMass", line, "" );
+//        MBPM *= 1000;
 
         // asbtype
         std::string asb;
-        getkeyval( asb, "ASB", line, "" );
+        extract_value( asb, "ASB", line, "" );
         if( BrakeCtrlPosNo > 0 ) {
 
             if( asb == "Manual" ) { ASBType = 1; }
@@ -6663,12 +6666,12 @@ void TMoverParameters::LoadFIZ_Cntrl( std::string const &line ) {
             dbrake_none;
     }
 
-    getkeyval( MainCtrlPosNo, "MCPN", line, "" );
-    getkeyval( ScndCtrlPosNo, "SCPN", line, "" );
-    getkeyval( ScndInMain, "SCIM", line, "" );
+    extract_value( MainCtrlPosNo, "MCPN", line, "" );
+    extract_value( ScndCtrlPosNo, "SCPN", line, "" );
+    extract_value( ScndInMain, "SCIM", line, "" );
 
     std::string autorelay;
-    getkeyval( autorelay, "AutoRelay", line, "" );
+    extract_value( autorelay, "AutoRelay", line, "" );
     if( autorelay == "Optional" ) { AutoRelayType = 2; }
     else if( autorelay == "Yes" ) { AutoRelayType = 1; }
     else { AutoRelayType = 0; }
@@ -6677,10 +6680,10 @@ void TMoverParameters::LoadFIZ_Cntrl( std::string const &line ) {
 
     ScndS = ( extract_value( "ScndS", line ) == "Yes" ); // brak pozycji rownoleglej przy niskiej nastawie PSR
 
-    getkeyval( InitialCtrlDelay, "IniCDelay", line, "" );
-    getkeyval( CtrlDelay, "SCDelay", line, "" );
+    extract_value( InitialCtrlDelay, "IniCDelay", line, "" );
+    extract_value( CtrlDelay, "SCDelay", line, "" );
     CtrlDownDelay = CtrlDelay; //hunter-101012: jesli nie ma SCDDelay;
-    getkeyval( CtrlDownDelay, "SCDDelay", line, "" );
+    extract_value( CtrlDownDelay, "SCDDelay", line, "" );
 
     //hunter-111012: dla siodemek 303E
     FastSerialCircuit =
@@ -6688,7 +6691,7 @@ void TMoverParameters::LoadFIZ_Cntrl( std::string const &line ) {
         1 :
         0;
 
-    getkeyval( StopBrakeDecc, "SBD", line, "" );
+    extract_value( StopBrakeDecc, "SBD", line, "" );
 }
 
 void TMoverParameters::LoadFIZ_Light( std::string const &line ) {
@@ -6699,8 +6702,8 @@ void TMoverParameters::LoadFIZ_Light( std::string const &line ) {
     AlterLightPowerSource.SourceType = LoadFIZ_SourceDecode( extract_value( "AlterLight", line ) );
     LoadFIZ_PowerParamsDecode( AlterLightPowerSource, "AlterL", line );
 
-    getkeyval( NominalVoltage, "Volt", line, "" );
-    getkeyval( BatteryVoltage, "LMaxVoltage", line, "" );
+    extract_value( NominalVoltage, "Volt", line, "" );
+    extract_value( BatteryVoltage, "LMaxVoltage", line, "" );
     NominalBatteryVoltage = BatteryVoltage;
 }
 
@@ -6714,11 +6717,11 @@ void TMoverParameters::LoadFIZ_Security( std::string const &line ) {
         SetFlag( SecuritySystem.SystemType, 2 );
     }
 
-    getkeyval( SecuritySystem.AwareDelay, "AwareDelay", line, "" );
+    extract_value( SecuritySystem.AwareDelay, "AwareDelay", line, "" );
     SecuritySystem.AwareMinSpeed = 0.1 * Vmax; //domyślnie 10% Vmax
-    getkeyval( SecuritySystem.AwareMinSpeed, "AwareMinSpeed", line, "" );
-    getkeyval( SecuritySystem.SoundSignalDelay, "SoundSignalDelay", line, "" );
-    getkeyval( SecuritySystem.EmergencyBrakeDelay, "EmergencyBrakeDelay", line, "" );
+    extract_value( SecuritySystem.AwareMinSpeed, "AwareMinSpeed", line, "" );
+    extract_value( SecuritySystem.SoundSignalDelay, "SoundSignalDelay", line, "" );
+    extract_value( SecuritySystem.EmergencyBrakeDelay, "EmergencyBrakeDelay", line, "" );
     SecuritySystem.RadioStop = ( extract_value( "RadioStop", line ).find( "Yes" ) != std::string::npos );
 }
 
@@ -6775,34 +6778,34 @@ void TMoverParameters::LoadFIZ_Engine( std::string const &Input ) {
 
         case ElectricSeriesMotor: {
 
-            getkeyval( NominalVoltage, "Volt", Input, "" );
-            getkeyval( WindingRes, "WindingRes", Input, "" );
+            extract_value( NominalVoltage, "Volt", Input, "" );
+            extract_value( WindingRes, "WindingRes", Input, "" );
             if( WindingRes == 0.0 ) {
 
                 WindingRes = 0.01;
             }
-            getkeyval( nmax, "nmax", Input, "" );
+            extract_value( nmax, "nmax", Input, "" );
             nmax /= 60.0;
             break;
         }
         case WheelsDriven:
         case Dumb: {
 
-            getkeyval( Ftmax, "Ftmax", Input, "" );
+            extract_value( Ftmax, "Ftmax", Input, "" );
             break;
         }
         case DieselEngine: {
 
-            getkeyval( dizel_nmin, "nmin", Input, "" );
+            extract_value( dizel_nmin, "nmin", Input, "" );
             dizel_nmin /= 60.0;
-            getkeyval( dizel_nmax, "nmax", Input, "" );
+            extract_value( dizel_nmax, "nmax", Input, "" );
             dizel_nmax /= 60.0; 
             nmax = dizel_nmax; // not sure if this is needed, but just in case
-            getkeyval( dizel_nmax_cutoff, "nmax_cutoff", Input, "0.0" );
+            extract_value( dizel_nmax_cutoff, "nmax_cutoff", Input, "0.0" );
             dizel_nmax_cutoff /= 60.0;
-            getkeyval( dizel_AIM, "AIM", Input, "1.0" );
+            extract_value( dizel_AIM, "AIM", Input, "1.0" );
 
-            if( true == getkeyval( AnPos, "ShuntMode", Input, "" ) ) {
+            if( true == extract_value( AnPos, "ShuntMode", Input, "" ) ) {
                 //dodatkowa przekładnia dla SM03 (2Ls150)
                 ShuntModeAllow = true;
                 ShuntMode = false;
@@ -6815,14 +6818,14 @@ void TMoverParameters::LoadFIZ_Engine( std::string const &Input ) {
         }
         case DieselElectric: { //youBy
 
-            getkeyval( Ftmax, "Ftmax", Input, "" );
+            extract_value( Ftmax, "Ftmax", Input, "" );
             Flat = ( extract_value( "Flat", Input ) == "1" );
-            getkeyval( Vhyp, "Vhyp", Input, "" );
+            extract_value( Vhyp, "Vhyp", Input, "" );
             Vhyp /= 3.6;
-            getkeyval( Vadd, "Vadd", Input, "" );
+            extract_value( Vadd, "Vadd", Input, "" );
             Vadd /= 3.6;
-            getkeyval( PowerCorRatio, "Cr", Input, "" );
-            getkeyval( RelayType, "RelayType", Input, "" );
+            extract_value( PowerCorRatio, "Cr", Input, "" );
+            extract_value( RelayType, "RelayType", Input, "" );
             if( extract_value( "ShuntMode", Input ) == "1" ) {
 
                 ShuntModeAllow = true;
@@ -6836,29 +6839,29 @@ void TMoverParameters::LoadFIZ_Engine( std::string const &Input ) {
         case ElectricInductionMotor: {
 
             RVentnmax = 1.0;
-            getkeyval( NominalVoltage, "Volt", Input, "" );
+            extract_value( NominalVoltage, "Volt", Input, "" );
 
-            getkeyval( eimc[ eimc_s_dfic ], "dfic", Input, "" );
-            getkeyval( eimc[ eimc_s_dfmax ], "dfmax", Input, "" );
-            getkeyval( eimc[ eimc_s_p ], "p", Input, "" );
-            getkeyval( eimc[ eimc_s_cfu ], "cfu", Input, "" );
-            getkeyval( eimc[ eimc_s_cim ], "cim", Input, "" );
-            getkeyval( eimc[ eimc_s_icif ], "icif", Input, "" );
-            getkeyval( eimc[ eimc_f_Uzmax ], "Uzmax", Input, "" );
-            getkeyval( eimc[ eimc_f_Uzh ], "Uzh", Input, "" );
-            getkeyval( eimc[ eimc_f_DU ], "DU", Input, "" );
-            getkeyval( eimc[ eimc_f_I0 ], "I0", Input, "" );
-            getkeyval( eimc[ eimc_f_cfu ], "fcfu", Input, "" );
-            getkeyval( eimc[ eimc_p_F0 ], "F0", Input, "" );
-            getkeyval( eimc[ eimc_p_a1 ], "a1", Input, "" );
-            getkeyval( eimc[ eimc_p_Pmax ], "Pmax", Input, "" );
-            getkeyval( eimc[ eimc_p_Fh ], "Fh", Input, "" );
-            getkeyval( eimc[ eimc_p_Ph ], "Ph", Input, "" );
-            getkeyval( eimc[ eimc_p_Vh0 ], "Vh0", Input, "" );
-            getkeyval( eimc[ eimc_p_Vh1 ], "Vh1", Input, "" );
-            getkeyval( eimc[ eimc_p_Imax ], "Imax", Input, "" );
-            getkeyval( eimc[ eimc_p_abed ], "abed", Input, "" );
-            getkeyval( eimc[ eimc_p_eped ], "edep", Input, "" );
+            extract_value( eimc[ eimc_s_dfic ], "dfic", Input, "" );
+            extract_value( eimc[ eimc_s_dfmax ], "dfmax", Input, "" );
+            extract_value( eimc[ eimc_s_p ], "p", Input, "" );
+            extract_value( eimc[ eimc_s_cfu ], "cfu", Input, "" );
+            extract_value( eimc[ eimc_s_cim ], "cim", Input, "" );
+            extract_value( eimc[ eimc_s_icif ], "icif", Input, "" );
+            extract_value( eimc[ eimc_f_Uzmax ], "Uzmax", Input, "" );
+            extract_value( eimc[ eimc_f_Uzh ], "Uzh", Input, "" );
+            extract_value( eimc[ eimc_f_DU ], "DU", Input, "" );
+            extract_value( eimc[ eimc_f_I0 ], "I0", Input, "" );
+            extract_value( eimc[ eimc_f_cfu ], "fcfu", Input, "" );
+            extract_value( eimc[ eimc_p_F0 ], "F0", Input, "" );
+            extract_value( eimc[ eimc_p_a1 ], "a1", Input, "" );
+            extract_value( eimc[ eimc_p_Pmax ], "Pmax", Input, "" );
+            extract_value( eimc[ eimc_p_Fh ], "Fh", Input, "" );
+            extract_value( eimc[ eimc_p_Ph ], "Ph", Input, "" );
+            extract_value( eimc[ eimc_p_Vh0 ], "Vh0", Input, "" );
+            extract_value( eimc[ eimc_p_Vh1 ], "Vh1", Input, "" );
+            extract_value( eimc[ eimc_p_Imax ], "Imax", Input, "" );
+            extract_value( eimc[ eimc_p_abed ], "abed", Input, "" );
+            extract_value( eimc[ eimc_p_eped ], "edep", Input, "" );
 
             Flat = ( extract_value( "Flat", Input ) == "1" );
 
@@ -6872,8 +6875,8 @@ void TMoverParameters::LoadFIZ_Engine( std::string const &Input ) {
 
 void TMoverParameters::LoadFIZ_Switches( std::string const &Input ) {
 
-    getkeyval( PantSwitchType, "Pantograph", Input, "" );
-    getkeyval( ConvSwitchType, "Converter", Input, "" );
+    extract_value( PantSwitchType, "Pantograph", Input, "" );
+    extract_value( ConvSwitchType, "Converter", Input, "" );
 }
 
 void TMoverParameters::LoadFIZ_MotorParamTable( std::string const &Input ) {
@@ -6882,10 +6885,10 @@ void TMoverParameters::LoadFIZ_MotorParamTable( std::string const &Input ) {
 
         case DieselEngine: {
             
-            getkeyval( dizel_minVelfullengage, "minVelfullengage", Input, "" );
-            getkeyval( dizel_engageDia, "engageDia", Input, "" );
-            getkeyval( dizel_engageMaxForce, "engageMaxForce", Input, "" );
-            getkeyval( dizel_engagefriction, "engagefriction", Input, "" );
+            extract_value( dizel_minVelfullengage, "minVelfullengage", Input, "" );
+            extract_value( dizel_engageDia, "engageDia", Input, "" );
+            extract_value( dizel_engageMaxForce, "engageMaxForce", Input, "" );
+            extract_value( dizel_engagefriction, "engagefriction", Input, "" );
             break;
         }
         default: {
@@ -6896,11 +6899,11 @@ void TMoverParameters::LoadFIZ_MotorParamTable( std::string const &Input ) {
 
 void TMoverParameters::LoadFIZ_Circuit( std::string const &Input ) {
 
-    getkeyval( CircuitRes, "CircuitRes", Input, "" );
-    getkeyval( IminLo, "IminLo", Input, "" );
-    getkeyval( IminHi, "IminHi", Input, "" );
-    getkeyval( ImaxLo, "ImaxLo", Input, "" );
-    getkeyval( ImaxHi, "ImaxHi", Input, "" );
+    extract_value( CircuitRes, "CircuitRes", Input, "" );
+    extract_value( IminLo, "IminLo", Input, "" );
+    extract_value( IminHi, "IminHi", Input, "" );
+    extract_value( ImaxLo, "ImaxLo", Input, "" );
+    extract_value( ImaxHi, "ImaxHi", Input, "" );
     Imin = IminLo;
     Imax = ImaxLo;
 }
@@ -6922,27 +6925,27 @@ void TMoverParameters::LoadFIZ_RList( std::string const &Input ) {
 
     if( RVentType > 0 ) {
 
-        getkeyval( RVentnmax, "RVentmax", Input, "" );
+        extract_value( RVentnmax, "RVentmax", Input, "" );
         RVentnmax /= 60.0;
-        getkeyval( RVentCutOff, "RVentCutOff", Input, "" );
+        extract_value( RVentCutOff, "RVentCutOff", Input, "" );
     }
 }
 
 void TMoverParameters::LoadFIZ_DList( std::string const &Input ) {
 
-    getkeyval( dizel_Mmax, "Mmax", Input, "" );
-    getkeyval( dizel_nMmax, "nMmax", Input, "" );
-    getkeyval( dizel_Mnmax, "Mnmax", Input, "" );
-    getkeyval( dizel_nmax, "nmax", Input, "" );
-    getkeyval( dizel_nominalfill, "nominalfill", Input, "" );
-    getkeyval( dizel_Mstand, "Mstand", Input, "" );
+    extract_value( dizel_Mmax, "Mmax", Input, "" );
+    extract_value( dizel_nMmax, "nMmax", Input, "" );
+    extract_value( dizel_Mnmax, "Mnmax", Input, "" );
+    extract_value( dizel_nmax, "nmax", Input, "" );
+    extract_value( dizel_nominalfill, "nominalfill", Input, "" );
+    extract_value( dizel_Mstand, "Mstand", Input, "" );
 }
 
 void TMoverParameters::LoadFIZ_LightsList( std::string const &Input ) {
 
-    getkeyval( LightsPosNo, "Size", Input, "" );
-    getkeyval( LightsWrap, "Wrap", Input, "" );
-    getkeyval( LightsDefPos, "Default", Input, "" );
+    extract_value( LightsPosNo, "Size", Input, "" );
+    extract_value( LightsWrap, "Wrap", Input, "" );
+    extract_value( LightsDefPos, "Default", Input, "" );
 }
 
 void TMoverParameters::LoadFIZ_PowerParamsDecode( TPowerParameters &Powerparameters, std::string const Prefix, std::string const &Line ) {
@@ -6957,7 +6960,7 @@ void TMoverParameters::LoadFIZ_PowerParamsDecode( TPowerParameters &Powerparamet
         }
         case Transducer: {
             
-            getkeyval( Powerparameters.InputVoltage, Prefix + "TransducerInputV", Line, "" );
+            extract_value( Powerparameters.InputVoltage, Prefix + "TransducerInputV", Line, "" );
             break;
         }
         case Generator: {
@@ -6967,7 +6970,7 @@ void TMoverParameters::LoadFIZ_PowerParamsDecode( TPowerParameters &Powerparamet
         }
         case Accumulator: {
 
-            getkeyval( Powerparameters.RAccumulator.MaxCapacity, Prefix + "Cap", Line, "" );
+            extract_value( Powerparameters.RAccumulator.MaxCapacity, Prefix + "Cap", Line, "" );
             Powerparameters.RAccumulator.RechargeSource = LoadFIZ_SourceDecode( extract_value( Prefix + "RS", Line ) );
             break;
         }
@@ -6975,26 +6978,26 @@ void TMoverParameters::LoadFIZ_PowerParamsDecode( TPowerParameters &Powerparamet
 
             auto &collectorparameters = Powerparameters.CollectorParameters;
 
-            getkeyval( collectorparameters.CollectorsNo, "CollectorsNo", Line, "" );
-            getkeyval( collectorparameters.MinH, "MinH", Line, "" );
-            getkeyval( collectorparameters.MaxH, "MaxH", Line, "" );
-            getkeyval( collectorparameters.CSW, "CSW", Line, "" ); //szerokość części roboczej
-            getkeyval( collectorparameters.MaxV, "MaxVoltage", Line, "" );
+            extract_value( collectorparameters.CollectorsNo, "CollectorsNo", Line, "" );
+            extract_value( collectorparameters.MinH, "MinH", Line, "" );
+            extract_value( collectorparameters.MaxH, "MaxH", Line, "" );
+            extract_value( collectorparameters.CSW, "CSW", Line, "" ); //szerokość części roboczej
+            extract_value( collectorparameters.MaxV, "MaxVoltage", Line, "" );
             collectorparameters.OVP = //przekaźnik nadnapięciowy
                 extract_value( "OverVoltProt", Line ) == "Yes" ?
                 1 :
                 0;
             //napięcie rozłączające WS
             collectorparameters.MinV = 0.5 * collectorparameters.MaxV; //gdyby parametr nie podany
-            getkeyval( collectorparameters.MinV, "MinV", Line, "" );
+            extract_value( collectorparameters.MinV, "MinV", Line, "" );
             //napięcie wymagane do załączenia WS
             collectorparameters.InsetV = 0.6 * collectorparameters.MaxV; //gdyby parametr nie podany
-            getkeyval( collectorparameters.InsetV, "InsetV", Line, "" );
+            extract_value( collectorparameters.InsetV, "InsetV", Line, "" );
             //ciśnienie rozłączające WS
-            getkeyval( collectorparameters.MinPress, "MinPress", Line, "2.0" ); //domyślnie 2 bary do załączenia WS
+            extract_value( collectorparameters.MinPress, "MinPress", Line, "2.0" ); //domyślnie 2 bary do załączenia WS
             //maksymalne ciśnienie za reduktorem
             collectorparameters.MaxPress = 5.0 + 0.001 * ( Random( 50 ) - Random( 50 ) );
-            getkeyval( collectorparameters.MaxPress, "MaxPress", Line, "" );
+            extract_value( collectorparameters.MaxPress, "MaxPress", Line, "" );
             break;
         }
         case PowerCable: {
@@ -7002,7 +7005,7 @@ void TMoverParameters::LoadFIZ_PowerParamsDecode( TPowerParameters &Powerparamet
             Powerparameters.RPowerCable.PowerTrans = LoadFIZ_PowerDecode( extract_value( Prefix + "PowerTrans", Line ) );
             if( Powerparameters.RPowerCable.PowerTrans == SteamPower ) {
 
-                getkeyval( Powerparameters.RPowerCable.SteamPressure, Prefix + "SteamPress", Line, "" );
+                extract_value( Powerparameters.RPowerCable.SteamPressure, Prefix + "SteamPress", Line, "" );
             }
             break;
         }
@@ -7018,9 +7021,9 @@ void TMoverParameters::LoadFIZ_PowerParamsDecode( TPowerParameters &Powerparamet
      && ( Powerparameters.SourceType != InternalSource ) ) {
 
 
-        getkeyval( Powerparameters.MaxVoltage, Prefix + "MaxVoltage", Line, "" );
-        getkeyval( Powerparameters.MaxCurrent, Prefix + "MaxCurrent", Line, "" );
-        getkeyval( Powerparameters.IntR, Prefix + "IntR", Line, "" );
+        extract_value( Powerparameters.MaxVoltage, Prefix + "MaxVoltage", Line, "" );
+        extract_value( Powerparameters.MaxCurrent, Prefix + "MaxCurrent", Line, "" );
+        extract_value( Powerparameters.IntR, Prefix + "IntR", Line, "" );
     }
 }
 
@@ -7273,7 +7276,7 @@ bool TMoverParameters::CheckLocomotiveParameters(bool ReadyFlag, int Dir)
         ScndPipePress = CompressedVolume / VeselVolume;
         PipePress = CntrlPipePress;
         BrakePress = 0.0;
-        LocalBrakePos = 0.0;
+        LocalBrakePos = 0;
         if( CabNo == 0 )
             BrakeCtrlPos = static_cast<int>( Handle->GetPos( bh_NP ) );
         else
diff --git a/McZapkie/Oerlikon_ESt.cpp b/McZapkie/Oerlikon_ESt.cpp
index 705bb467..eded5cf6 100644
--- a/McZapkie/Oerlikon_ESt.cpp
+++ b/McZapkie/Oerlikon_ESt.cpp
@@ -15,9 +15,9 @@ Copyright (C) 2007-2014 Maciej Cierniak
 #include "stdafx.h"
 #include "Oerlikon_ESt.h"
 
-double d2A(double d)
+double d2A( double const d )
 {
-    return (d * d) * 0.7854 * 1.0 / 1000;
+    return (d * d) * 0.7854 / 1000.0;
 }
 
 // ------ RURA ------
@@ -42,7 +42,7 @@ void TPrzeciwposlizg::SetPoslizg(bool flag)
 
 void TPrzeciwposlizg::Update(double dt)
 {
-    if ((Poslizg))
+    if (true == Poslizg)
     {
         BrakeRes->Flow(dVol);
         Next->Flow(PF(Next->P(), 0, d2A(10)) * dt);
@@ -56,16 +56,14 @@ void TPrzeciwposlizg::Update(double dt)
 
 void TPrzekladnik::Update(double dt)
 {
-    double BCP;
-    double BVP;
     double dV;
 
-    BCP = Next->P();
-    BVP = BrakeRes->P();
+    double BCP{ Next->P() };
+    double BVP{ BrakeRes->P() };
 
-    if ((BCP > P()))
+    if ( BCP > P() )
         dV = -PFVd(BCP, 0, d2A(10), P()) * dt;
-    else if ((BCP < P()))
+    else if ( BCP < P() )
         dV = PFVa(BVP, BCP, d2A(10), P()) * dt;
     else
         dV = 0;
@@ -81,7 +79,7 @@ void TRapid::SetRapidParams(double mult, double size)
 {
     RapidMult = mult;
     RapidStatus = false;
-    if ((size > 0.1)) // dopasowywanie srednicy przekladnika
+    if (size > 0.1) // dopasowywanie srednicy przekladnika
     {
         DN = d2A(size * 0.4);
         DL = d2A(size * 0.4);
@@ -100,26 +98,23 @@ void TRapid::SetRapidStatus(bool rs)
 
 void TRapid::Update(double dt)
 {
-    double BCP;
-    double BVP;
-    double dV;
+    double BVP{ BrakeRes->P() };
+    double BCP{ Next->P() };
     double ActMult;
+    double dV;
 
-    BVP = BrakeRes->P();
-    BCP = Next->P();
-
-    if ((RapidStatus))
+    if ( true == RapidStatus )
     {
         ActMult = RapidMult;
     }
     else
     {
-        ActMult = 1;
+        ActMult = 1.0;
     }
 
-    if ((BCP * RapidMult > P() * ActMult))
+    if ((BCP * RapidMult) > (P() * ActMult))
         dV = -PFVd(BCP, 0, DL, P() * ActMult / RapidMult) * dt;
-    else if ((BCP * RapidMult < P() * ActMult))
+    else if ((BCP * RapidMult) < (P() * ActMult))
         dV = PFVa(BVP, BCP, DN, P() * ActMult / RapidMult) * dt;
     else
         dV = 0;
@@ -138,16 +133,13 @@ void TPrzekCiagly::SetMult(double m)
 
 void TPrzekCiagly::Update(double dt)
 {
-    double BCP;
-    double BVP;
+    double const BVP{ BrakeRes->P() };
+    double const BCP{ Next->P() };
     double dV;
 
-    BVP = BrakeRes->P();
-    BCP = Next->P();
-
-    if ((BCP > P() * mult))
+    if ( BCP > (P() * mult))
         dV = -PFVd(BCP, 0, d2A(8), P() * mult) * dt;
-    else if ((BCP < P() * mult))
+    else if (BCP < (P() * mult))
         dV = PFVa(BVP, BCP, d2A(8), P() * mult) * dt;
     else
         dV = 0;
@@ -166,19 +158,15 @@ void TPrzek_PZZ::SetLBP(double P)
 
 void TPrzek_PZZ::Update(double dt)
 {
-    double BCP;
-    double BVP;
+
+    double const BVP{ BrakeRes->P() };
+    double const BCP{ Next->P() };
+    double const Pgr{ std::max( LBP, P() ) };
     double dV;
-    double Pgr;
 
-    BVP = BrakeRes->P();
-    BCP = Next->P();
-
-    Pgr = Max0R(LBP, P());
-
-    if ((BCP > Pgr))
+    if (BCP > Pgr)
         dV = -PFVd(BCP, 0, d2A(8), Pgr) * dt;
-    else if ((BCP < Pgr))
+    else if (BCP < Pgr)
         dV = PFVa(BVP, BCP, d2A(8), Pgr) * dt;
     else
         dV = 0;
@@ -209,28 +197,18 @@ void TPrzekED::Update(double dt)
 
 // ------ OERLIKON EST NA BOGATO ------
 
-double TNESt3::GetPF(double PP, double dt, double Vel) // przeplyw miedzy komora wstepna i PG
+double TNESt3::GetPF( double const PP, double const dt, double const Vel ) // przeplyw miedzy komora wstepna i PG
 {
-    double dV;
-    double dV1;
-    double temp;
-    double VVP;
-    double BVP;
-    double BCP;
-    double CVP;
-    double MPP;
-    double nastG;
-    unsigned char i;
-
-    BVP = BrakeRes->P();
-    VVP = ValveRes->P();
+    double const BVP{ BrakeRes->P() };
+    double const VVP{ ValveRes->P() };
     //  BCP:=BrakeCyl.P;
-    BCP = Przekladniki[1]->P();
-    CVP = CntrlRes->P();
-    MPP = Miedzypoj->P();
-    dV1 = 0;
+    double const BCP{ Przekladniki[ 1 ]->P() };
+    double const CVP{ CntrlRes->P() };
+    double const MPP{ Miedzypoj->P() };
+    double dV{ 0.0 };
+    double dV1{ 0.0 };
 
-    nastG = static_cast<double>(BrakeDelayFlag & bdelay_G);
+    double const nastG = static_cast<double>(BrakeDelayFlag & bdelay_G);
 
     // sprawdzanie stanu
     CheckState(BCP, dV1);
@@ -238,65 +216,62 @@ double TNESt3::GetPF(double PP, double dt, double Vel) // przeplyw miedzy komora
 
     // luzowanie
     if ((BrakeStatus & b_hld) == b_off)
-        dV = PF(0, BCP, Nozzles[dTO] * nastG + (1 - nastG) * Nozzles[dOO]) * dt *
-             (0.1 + 4.9 * Min0R(0.2, BCP - ((CVP - 0.05 - VVP) * BVM + 0.1)));
+        dV = PF(0, BCP, Nozzles[dTO] * nastG + (1.0 - nastG) * Nozzles[dOO]) * dt *
+             (0.1 + 4.9 * std::min(0.2, BCP - ((CVP - 0.05 - VVP) * BVM + 0.1)));
     else
         dV = 0;
     //  BrakeCyl.Flow(-dV);
     Przekladniki[1]->Flow(-dV);
-    if (((BrakeStatus & b_on) == b_on) && (Przekladniki[1]->P() * HBG300 < MaxBP))
-        dV = PF(BVP, BCP,
-                Nozzles[dTN] * (nastG + 2 * short(BCP < Podskok)) + Nozzles[dON] * (1 - nastG)) *
-             dt * (0.1 + 4.9 * Min0R(0.2, (CVP - 0.05 - VVP) * BVM - BCP));
+    if ( ((BrakeStatus & b_on) == b_on) && (Przekladniki[1]->P() * HBG300 < MaxBP) )
+        dV = PF( BVP, BCP, Nozzles[dTN] * (nastG + 2.0 * (BCP < Podskok ? 1.0 : 0.0)) + Nozzles[dON] * (1 - nastG) )
+                * dt * (0.1 + 4.9 * std::min( 0.2, (CVP - 0.05 - VVP) * BVM - BCP ) );
     else
         dV = 0;
     //  BrakeCyl.Flow(-dV);
     Przekladniki[1]->Flow(-dV);
     BrakeRes->Flow(dV);
 
+    for (int i = 1; i < 4; ++i)
     {
-        for (i = 1; i < 4; ++i)
+        Przekladniki[i]->Update(dt);
+        if (typeid(*Przekladniki[i]) == typeid(TRapid))
         {
-            Przekladniki[i]->Update(dt);
-            if (typeid(*Przekladniki[i]) == typeid(TRapid))
-            {
-                RapidStatus =
-                    (((BrakeDelayFlag & bdelay_R) == bdelay_R) &&
-                     ((abs(Vel) > 70) || ((RapidStatus) && (abs(Vel) > 50)) || (RapidStaly)));
-                Przekladniki[i]->SetRapidStatus(RapidStatus);
-            }
-            else if (typeid(*Przekladniki[i]) == typeid(TPrzeciwposlizg))
-                Przekladniki[i]->SetPoslizg((BrakeStatus & b_asb) == b_asb);
-            else if (typeid(*Przekladniki[i]) == typeid(TPrzekED))
-                if ((Vel < -15))
-                    Przekladniki[i]->SetP(0);
-                else
-                    Przekladniki[i]->SetP(MaxBP * 3);
-            else if (typeid(*Przekladniki[i]) == typeid(TPrzekCiagly))
-                Przekladniki[i]->SetMult(LoadC);
-            else if (typeid(*Przekladniki[i]) == typeid(TPrzek_PZZ))
-                Przekladniki[i]->SetLBP(LBP);
+            RapidStatus =
+                (((BrakeDelayFlag & bdelay_R) == bdelay_R) &&
+                    ((abs(Vel) > 70) || ((RapidStatus) && (abs(Vel) > 50)) || (RapidStaly)));
+            Przekladniki[i]->SetRapidStatus(RapidStatus);
         }
+        else if (typeid(*Przekladniki[i]) == typeid(TPrzeciwposlizg))
+            Przekladniki[i]->SetPoslizg((BrakeStatus & b_asb) == b_asb);
+        else if (typeid(*Przekladniki[i]) == typeid(TPrzekED))
+            if (Vel < -15)
+                Przekladniki[i]->SetP(0);
+            else
+                Przekladniki[i]->SetP(MaxBP * 3);
+        else if (typeid(*Przekladniki[i]) == typeid(TPrzekCiagly))
+            Przekladniki[i]->SetMult(LoadC);
+        else if (typeid(*Przekladniki[i]) == typeid(TPrzek_PZZ))
+            Przekladniki[i]->SetLBP(LBP);
     }
 
     // przeplyw testowy miedzypojemnosci
     dV = PF(MPP, VVP, BVs(BCP)) + PF(MPP, CVP, CVs(BCP));
     if ((MPP - 0.05 > BVP))
-        dV += PF(MPP - 0.05, BVP, Nozzles[dPT] * nastG + (1 - nastG) * Nozzles[dPO]);
+        dV += PF(MPP - 0.05, BVP, Nozzles[dPT] * nastG + (1.0 - nastG) * Nozzles[dPO]);
     if (MPP > VVP)
         dV += PF(MPP, VVP, d2A(5));
     Miedzypoj->Flow(dV * dt * 0.15);
 
     // przeplyw ZS <-> PG
-    temp = CVs(BCP);
+    double const temp = CVs(BCP);
     dV = PF(CVP, MPP, temp) * dt;
     CntrlRes->Flow(dV);
     ValveRes->Flow(-0.02 * dV);
     dV1 += 0.98 * dV;
 
     // przeplyw ZP <-> MPJ
-    if ((MPP - 0.05 > BVP))
-        dV = PF(BVP, MPP - 0.05, Nozzles[dPT] * nastG + (1 - nastG) * Nozzles[dPO]) * dt;
+    if (MPP - 0.05 > BVP)
+        dV = PF(BVP, MPP - 0.05, Nozzles[dPT] * nastG + (1.0 - nastG) * Nozzles[dPO]) * dt;
     else
         dV = 0;
     BrakeRes->Flow(dV);
@@ -317,11 +292,11 @@ double TNESt3::GetPF(double PP, double dt, double Vel) // przeplyw miedzy komora
     return dV - dV1;
 }
 
-void TNESt3::EStParams(double i_crc) // parametry charakterystyczne dla ESt
+void TNESt3::EStParams( double const i_crc ) // parametry charakterystyczne dla ESt
 {
 }
 
-void TNESt3::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TNESt3::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     TBrake::Init(PP, HPP, LPP, BP, BDF);
     ValveRes->CreatePress(PP);
@@ -352,17 +327,12 @@ double TNESt3::GetCRP()
     //  return Miedzypoj.P;
 }
 
-void TNESt3::CheckState(double BCP, double &dV1) // glowny przyrzad rozrzadczy
+void TNESt3::CheckState(double const BCP, double &dV1) // glowny przyrzad rozrzadczy
 {
-    double VVP;
-    double BVP;
-    double CVP;
-    double MPP;
-
-    BVP = BrakeRes->P(); //-> tu ma byc komora rozprezna
-    VVP = ValveRes->P();
-    CVP = CntrlRes->P();
-    MPP = Miedzypoj->P();
+    double const BVP{ BrakeRes->P() }; //-> tu ma byc komora rozprezna
+    double const VVP{ ValveRes->P() };
+    double const CVP{ CntrlRes->P() };
+    double const MPP{ Miedzypoj->P() };
 
     if ((BCP < 0.25) && (VVP + 0.08 > CVP))
         Przys_blok = false;
@@ -370,19 +340,19 @@ void TNESt3::CheckState(double BCP, double &dV1) // glowny przyrzad rozrzadczy
     // sprawdzanie stanu
     // if ((BrakeStatus and 1)=1)and(BCP>0.25)then
     if ((VVP + 0.01 + BCP / BVM < CVP - 0.05) && (Przys_blok))
-        BrakeStatus |= 3; // hamowanie stopniowe;
-    else if ((VVP - 0.01 + (BCP - 0.1) / BVM > CVP - 0.05))
-        BrakeStatus &= 252; // luzowanie;
-    else if ((VVP + BCP / BVM > CVP - 0.05))
-        BrakeStatus &= 253; // zatrzymanie napelaniania;
+        BrakeStatus |= ( b_on | b_hld ); // hamowanie stopniowe;
+    else if (VVP - 0.01 + (BCP - 0.1) / BVM > CVP - 0.05)
+        BrakeStatus &= ~( b_on | b_hld ); // luzowanie;
+    else if (VVP + BCP / BVM > CVP - 0.05)
+        BrakeStatus &= ~b_on; // zatrzymanie napelaniania;
     else if ((VVP + (BCP - 0.1) / BVM < CVP - 0.05) && (BCP > 0.25)) // zatrzymanie luzowania
-        BrakeStatus |= 1;
+        BrakeStatus |= b_hld;
 
-    if ((BrakeStatus & 1) == 0)
+    if( ( BrakeStatus & b_hld ) == 0 )
         SoundFlag |= sf_CylU;
 
     if ((VVP + 0.10 < CVP) && (BCP < 0.25)) // poczatek hamowania
-        if ((!Przys_blok))
+        if (false == Przys_blok)
         {
             ValveRes->CreatePress(0.1 * VVP);
             SoundFlag |= sf_Acc;
@@ -390,59 +360,50 @@ void TNESt3::CheckState(double BCP, double &dV1) // glowny przyrzad rozrzadczy
             Przys_blok = true;
         }
 
-    if ((BCP > 0.5))
+    if (BCP > 0.5)
         Zamykajacy = true;
-    else if ((VVP - 0.6 < MPP))
+    else if (VVP - 0.6 < MPP)
         Zamykajacy = false;
 }
 
-void TNESt3::CheckReleaser(double dt) // odluzniacz
+void TNESt3::CheckReleaser(double const dt) // odluzniacz
 {
-    double VVP;
-    double CVP;
-
-    VVP = ValveRes->P();
-    CVP = CntrlRes->P();
+    double const VVP{ ValveRes->P() };
+    double const CVP{ CntrlRes->P() };
 
     // odluzniacz automatyczny
     if ((BrakeStatus & b_rls) == b_rls)
     {
         CntrlRes->Flow(PF(CVP, 0, 0.02) * dt);
-        if ((CVP < VVP + 0.3) || (!autom))
-            BrakeStatus &= 247;
+        if ((CVP < VVP + 0.3) || (false == autom))
+            BrakeStatus &= ~b_rls;
     }
 }
 
-double TNESt3::CVs(double BP) // napelniacz sterujacego
+double TNESt3::CVs(double const BP) // napelniacz sterujacego
 {
-    double CVP;
-    double MPP;
-
-    CVP = CntrlRes->P();
-    MPP = Miedzypoj->P();
+    double const CVP{ CntrlRes->P() };
+    double const MPP{ Miedzypoj->P() };
 
     // przeplyw ZS <-> PG
-    if ((MPP < CVP - 0.17))
+    if (MPP < CVP - 0.17)
         return 0;
-    else if ((MPP > CVP - 0.08))
+    else if (MPP > CVP - 0.08)
         return Nozzles[dSd];
     else
         return Nozzles[dSm];
 }
 
-double TNESt3::BVs(double BCP) // napelniacz pomocniczego
+double TNESt3::BVs(double const BCP) // napelniacz pomocniczego
 {
-    double CVP;
-    double MPP;
-
-    CVP = CntrlRes->P();
-    MPP = Miedzypoj->P();
+    double const CVP{ CntrlRes->P() };
+    double const MPP{ Miedzypoj->P() };
 
     // przeplyw ZP <-> rozdzielacz
-    if ((MPP < CVP - 0.3))
+    if (MPP < CVP - 0.3)
         return Nozzles[dP];
-    else if ((BCP < 0.5))
-        if ((Zamykajacy))
+    else if (BCP < 0.5)
+        if ( true == Zamykajacy)
             return Nozzles[dPm]; // 1.25
         else
             return Nozzles[dPd];
@@ -450,11 +411,12 @@ double TNESt3::BVs(double BCP) // napelniacz pomocniczego
         return 0;
 }
 
-void TNESt3::PLC(double mass)
+void TNESt3::PLC(double const mass)
 {
-    LoadC = 1 +
-            double(mass < LoadM) *
-                ((TareBP + (MaxBP - TareBP) * (mass - TareM) / (LoadM - TareM)) / MaxBP - 1);
+    LoadC = 1.0 +
+        ( mass < LoadM ?
+            ( (TareBP + (MaxBP - TareBP) * (mass - TareM) / (LoadM - TareM) ) / MaxBP - 1.0 ) :
+            0.0 );
 }
 
 void TNESt3::ForceEmptiness()
@@ -472,27 +434,25 @@ void TNESt3::ForceEmptiness()
     CntrlRes->Act();
 }
 
-void TNESt3::SetLP(double TM, double LM, double TBP)
+void TNESt3::SetLP(double const TM, double const LM, double const TBP)
 {
     TareM = TM;
     LoadM = LM;
     TareBP = TBP;
 }
 
-void TNESt3::SetLBP(double P)
+void TNESt3::SetLBP(double const P)
 {
     LBP = P;
 }
 
-void TNESt3::SetSize(int size, std::string params) // ustawianie dysz (rozmiaru ZR)
+void TNESt3::SetSize( int const size, std::string const &params ) // ustawianie dysz (rozmiaru ZR)
 {
     static double const dNO1l = 1.250;
     static double const dNT1l = 0.510;
     static double const dOO1l = 0.907;
     static double const dOT1l = 0.524;
 
-    int i;
-
     if (params.find("ESt3") != std::string::npos)
     {
         Podskok = 0.7;
@@ -590,7 +550,7 @@ void TNESt3::SetSize(int size, std::string params) // ustawianie dysz (rozmiaru
     case 200:
     { // dON,dOO,dTN,dTO,dP,dS
         Nozzles[dON] = dNO1l;
-        Nozzles[dOO] = dOO1l * 1.0 / 1.15;
+        Nozzles[dOO] = dOO1l / 1.15;
         Nozzles[dTN] = dNT1l;
         Nozzles[dTO] = dOT1l;
         Nozzles[dP] = 7.4;
@@ -603,7 +563,7 @@ void TNESt3::SetSize(int size, std::string params) // ustawianie dysz (rozmiaru
     case 375:
     { // dON,dOO,dTN,dTO,dP,dS
         Nozzles[dON] = dNO1l;
-        Nozzles[dOO] = dOO1l * 1.0 / 1.15;
+        Nozzles[dOO] = dOO1l / 1.15;
         Nozzles[dTN] = dNT1l;
         Nozzles[dTO] = dOT1l;
         Nozzles[dP] = 13.0;
@@ -655,11 +615,11 @@ void TNESt3::SetSize(int size, std::string params) // ustawianie dysz (rozmiaru
     Nozzles[dSm] = 0.9;
 
     // przeliczanie z mm^2 na l/m
-    for (i = 0; i < dMAX; ++i)
+    for (int i = 0; i < dMAX; ++i)
     {
         Nozzles[i] = d2A(Nozzles[i]); //(/1000^2*pi/4*1000)
     }
-    for (i = 1; i < 4; ++i)
+    for (int i = 1; i < 4; ++i)
     {
         Przekladniki[i]->BrakeRes = BrakeRes;
         Przekladniki[i]->CreateCap(i);
diff --git a/McZapkie/Oerlikon_ESt.h b/McZapkie/Oerlikon_ESt.h
index ac4b3248..88b07d27 100644
--- a/McZapkie/Oerlikon_ESt.h
+++ b/McZapkie/Oerlikon_ESt.h
@@ -190,11 +190,11 @@ class TNESt3 : public TBrake {
 	double Nozzles[ dMAX ]; // dysze
     double BVM = 0.0; // przelozenie PG-CH
     //        ValveFlag: byte;           //polozenie roznych zaworkow
-    bool Zamykajacy = false; // pamiec zaworka zamykajacego
+    bool Zamykajacy = true; // pamiec zaworka zamykajacego
     //        Przys_wlot: boolean;       //wlot do komory przyspieszacza
-    bool Przys_blok = false; // blokada przyspieszacza
-    bool RapidStatus = false;
-    bool RapidStaly = false;
+    bool Przys_blok = true; // blokada przyspieszacza
+    bool RapidStatus = true;
+    bool RapidStaly = true;
     double LoadC = 0.0;
 	double TareM = 0.0; // masa proznego
     double LoadM = 0.0; // masa pelnego
@@ -202,29 +202,29 @@ class TNESt3 : public TBrake {
     double HBG300 = 0.0; // zawor ograniczajacy cisnienie
     double Podskok = 0.0; // podskok preznosci poczatkowej
     //        HPBR: real;               //zasilanie ZP z wysokiego cisnienia
-    bool autom = false; // odluzniacz samoczynny
+    bool autom = true; // odluzniacz samoczynny
     double LBP = 0.0; // cisnienie hamulca pomocniczego
 
   public:
 	inline TNESt3(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
            TBrake(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
 	{}
-    void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/;
-    virtual double GetPF(double PP, double dt, double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG
+    void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF ) /*override*/;
+    virtual double GetPF( double const PP, double const dt, double const Vel ) /*override*/; // przeplyw miedzy komora wstepna i PG
     void EStParams(double i_crc); // parametry charakterystyczne dla ESt
     virtual double GetCRP() /*override*/;
-    void CheckState(double BCP, double &dV1); // glowny przyrzad rozrzadczy
-    void CheckReleaser(double dt); // odluzniacz
-    double CVs(double BP); // napelniacz sterujacego
-    double BVs(double BCP); // napelniacz pomocniczego
-    void SetSize(int size, std::string params); // ustawianie dysz (rozmiaru ZR), przekladniki
-    void PLC(double mass); // wspolczynnik cisnienia przystawki wazacej
-    void SetLP(double TM, double LM, double TBP); // parametry przystawki wazacej
+    void CheckState(double const BCP, double &dV1); // glowny przyrzad rozrzadczy
+    void CheckReleaser(double const dt); // odluzniacz
+    double CVs(double const BP); // napelniacz sterujacego
+    double BVs(double const BCP); // napelniacz pomocniczego
+    void SetSize( int const size, std::string const &params ); // ustawianie dysz (rozmiaru ZR), przekladniki
+    void PLC(double const mass); // wspolczynnik cisnienia przystawki wazacej
+    void SetLP(double const TM, double const LM, double const TBP); // parametry przystawki wazacej
     virtual void ForceEmptiness() /*override*/; // wymuszenie bycia pustym
-    void SetLBP(double P); // cisnienie z hamulca pomocniczego
+    void SetLBP(double const P); // cisnienie z hamulca pomocniczego
 };
 
-extern double d2A(double d);
+extern double d2A( double const d );
 
 #endif // INCLUDED_OERLIKON_EST_H
 // END
diff --git a/McZapkie/hamulce.cpp b/McZapkie/hamulce.cpp
index 47634153..4602622c 100644
--- a/McZapkie/hamulce.cpp
+++ b/McZapkie/hamulce.cpp
@@ -49,23 +49,23 @@ double PF_old(double P1, double P2, double S)
         return (PH + 1) * 222 * S * (P2 - P1) / (1.13 * PH - PL);
 }
 
-double PF(double P1, double P2, double S, double DP)
+double PF( double const P1, double const P2, double const S, double const DP )
 {
     double PH = std::max(P1, P2) + 1; // wyzsze cisnienie absolutne
     double PL = P1 + P2 - PH + 2; // nizsze cisnienie absolutne
     double sg = PL / PH; // bezwymiarowy stosunek cisnien
     double FM = PH * 197 * S * Sign(P2 - P1); // najwyzszy mozliwy przeplyw, wraz z kierunkiem
-    if ((sg > 0.5)) // jesli ponizej stosunku krytycznego
+    if (sg > 0.5) // jesli ponizej stosunku krytycznego
         if ((PH - PL) < DP) // niewielka roznica cisnien
-            return (1 - sg) / DPL * FM * 2 * std::sqrt((DP) * (PH - DP));
+            return (1.0 - sg) / DPL * FM * 2.0 * std::sqrt((DP) * (PH - DP));
         //      return 1/DPL*(PH-PL)*fm*2*SQRT((sg)*(1-sg));
         else
-            return FM * 2 * std::sqrt((sg) * (1 - sg));
+            return FM * 2.0 * std::sqrt((sg) * (1.0 - sg));
     else // powyzej stosunku krytycznego
         return FM;
 }
 
-double PF1(double P1, double P2, double S)
+double PF1( double const P1, double const P2, double const S )
 {
     static double const DPS = 0.001;
 
@@ -82,8 +82,8 @@ double PF1(double P1, double P2, double S)
         return FM;
 }
 
-double PFVa(double PH, double PL, double S, double LIM,
-            double DP) // zawor napelniajacy z PH do PL, PL do LIM
+double PFVa( double PH, double PL, double const S, double LIM, double const DP )
+// zawor napelniajacy z PH do PL, PL do LIM
 {
     if (LIM > PL)
     {
@@ -106,8 +106,8 @@ double PFVa(double PH, double PL, double S, double LIM,
         return 0;
 }
 
-double PFVd(double PH, double PL, double S, double LIM,
-            double DP) // zawor wypuszczajacy z PH do PL, PH do LIM
+double PFVd( double PH, double PL, double const S, double LIM, double const DP )
+// zawor wypuszczajacy z PH do PL, PH do LIM
 {
     if (LIM < PH)
     {
@@ -304,13 +304,13 @@ TBrake::TBrake(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn
 }
 
 // inicjalizacja hamulca (stan poczatkowy)
-void TBrake::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TBrake::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     BrakeDelayFlag = BDF;
 }
 
 // pobranie wspolczynnika tarcia materialu
-double TBrake::GetFC(double Vel, double N)
+double TBrake::GetFC( double const Vel, double const N )
 {
     return FM->GetFC(N, Vel);
 }
@@ -346,7 +346,7 @@ double TBrake::GetCRP()
 }
 
 // przeplyw z przewodu glowneg
-double TBrake::GetPF(double PP, double dt, double Vel)
+double TBrake::GetPF( double const PP, double const dt, double const Vel )
 {
     ValveRes->Act();
     BrakeCyl->Act();
@@ -355,7 +355,7 @@ double TBrake::GetPF(double PP, double dt, double Vel)
 }
 
 // przeplyw z przewodu zasilajacego
-double TBrake::GetHPFlow(double HP, double dt)
+double TBrake::GetHPFlow( double const HP, double const dt )
 {
     return 0;
 }
@@ -365,7 +365,7 @@ double TBrake::GetBCF()
     return BCA * 100 * BrakeCyl->P();
 }
 
-bool TBrake::SetBDF(int nBDF)
+bool TBrake::SetBDF( int const nBDF )
 {
     if (((nBDF & BrakeDelays) == nBDF) && (nBDF != BrakeDelayFlag))
     {
@@ -376,16 +376,16 @@ bool TBrake::SetBDF(int nBDF)
         return false;
 }
 
-void TBrake::Releaser(int state)
+void TBrake::Releaser( int const state )
 {
     BrakeStatus = (BrakeStatus & ~b_rls) | ( state * b_rls );
 }
 
-void TBrake::SetEPS(double nEPS)
+void TBrake::SetEPS( double const nEPS )
 {
 }
 
-void TBrake::ASB(int state)
+void TBrake::ASB( int const state )
 { // 255-b_asb(32)
     BrakeStatus = (BrakeStatus & ~b_asb) | ( state * b_asb );
 }
@@ -402,7 +402,7 @@ int TBrake::GetSoundFlag()
     return result;
 }
 
-void TBrake::SetASBP(double Press)
+void TBrake::SetASBP( double const Press )
 {
     ASBP = Press;
 }
@@ -417,7 +417,7 @@ void TBrake::ForceEmptiness()
 
 //---WESTINGHOUSE---
 
-void TWest::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TWest::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     TBrake::Init(PP, HPP, LPP, BP, BDF);
     ValveRes->CreatePress(PP);
@@ -426,7 +426,7 @@ void TWest::Init(double PP, double HPP, double LPP, double BP, int BDF)
     // BrakeStatus:=3*int(BP>0.1);
 }
 
-double TWest::GetPF(double PP, double dt, double Vel)
+double TWest::GetPF( double const PP, double const dt, double const Vel )
 {
     double dv;
     double dV1;
@@ -509,12 +509,12 @@ double TWest::GetPF(double PP, double dt, double Vel)
     return dv - dV1;
 }
 
-double TWest::GetHPFlow(double HP, double dt)
+double TWest::GetHPFlow( double const HP, double const dt )
 {
     return dVP;
 }
 
-void TWest::SetLBP(double P)
+void TWest::SetLBP( double const P )
 {
     LBP = P;
     if (P > BrakeCyl->P())
@@ -525,7 +525,7 @@ void TWest::SetLBP(double P)
     //    LBP:=P;
 }
 
-void TWest::SetEPS(double nEPS)
+void TWest::SetEPS( double const nEPS )
 {
     double BCP;
 
@@ -545,14 +545,14 @@ void TWest::SetEPS(double nEPS)
     EPS = nEPS;
 }
 
-void TWest::PLC(double mass)
+void TWest::PLC( double const mass )
 {
     LoadC = 1 +
             int(mass < LoadM) *
                 ((TareBP + (MaxBP - TareBP) * (mass - TareM) / (LoadM - TareM)) / MaxBP - 1);
 }
 
-void TWest::SetLP(double TM, double LM, double TBP)
+void TWest::SetLP( double const TM, double const LM, double const TBP )
 {
     TareM = TM;
     LoadM = LM;
@@ -560,7 +560,7 @@ void TWest::SetLP(double TM, double LM, double TBP)
 }
 
 //---OERLIKON EST4---
-void TESt::CheckReleaser(double dt)
+void TESt::CheckReleaser( double const dt )
 {
     double VVP = std::min(ValveRes->P(), BrakeRes->P() + 0.05);
     double CVP = CntrlRes->P() - 0.0;
@@ -575,7 +575,7 @@ void TESt::CheckReleaser(double dt)
         }
 }
 
-void TESt::CheckState(double BCP, double &dV1)
+void TESt::CheckState( double const BCP, double &dV1 )
 {
     double VVP;
     double BVP;
@@ -618,7 +618,7 @@ void TESt::CheckState(double BCP, double &dV1)
         SoundFlag |= sf_CylU;
 }
 
-double TESt::CVs(double BP)
+double TESt::CVs( double const BP )
 {
     double VVP;
     double BVP;
@@ -642,7 +642,7 @@ double TESt::CVs(double BP)
         return 0.3;
 }
 
-double TESt::BVs(double BCP)
+double TESt::BVs( double const BCP )
 {
     double VVP;
     double BVP;
@@ -664,7 +664,7 @@ double TESt::BVs(double BCP)
         return 0;
 }
 
-double TESt::GetPF(double PP, double dt, double Vel)
+double TESt::GetPF( double const PP, double const dt, double const Vel )
 {
     double dv;
     double dV1;
@@ -731,7 +731,7 @@ double TESt::GetPF(double PP, double dt, double Vel)
     return dv - dV1;
 }
 
-void TESt::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TESt::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     TBrake::Init(PP, HPP, LPP, BP, BDF);
     ValveRes->CreatePress(PP);
@@ -746,7 +746,7 @@ void TESt::Init(double PP, double HPP, double LPP, double BP, int BDF)
     BrakeDelayFlag = BDF;
 }
 
-void TESt::EStParams(double i_crc)
+void TESt::EStParams( double const i_crc )
 {
 }
 
@@ -757,7 +757,7 @@ double TESt::GetCRP()
 
 //---EP2---
 
-void TEStEP2::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TEStEP2::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     TLSt::Init(PP, HPP, LPP, BP, BDF);
     ImplsRes->CreateCap(1);
@@ -769,7 +769,7 @@ void TEStEP2::Init(double PP, double HPP, double LPP, double BP, int BDF)
     BrakeDelays = bdelay_P;
 }
 
-double TEStEP2::GetPF(double PP, double dt, double Vel)
+double TEStEP2::GetPF( double const PP, double const dt, double const Vel )
 {
     double result;
     double dv;
@@ -880,21 +880,21 @@ double TEStEP2::GetPF(double PP, double dt, double Vel)
     return result;
 }
 
-void TEStEP2::PLC(double mass)
+void TEStEP2::PLC( double const mass )
 {
     LoadC = 1 +
             int(mass < LoadM) *
                 ((TareBP + (MaxBP - TareBP) * (mass - TareM) / (LoadM - TareM)) / MaxBP - 1);
 }
 
-void TEStEP2::SetEPS(double nEPS)
+void TEStEP2::SetEPS( double const nEPS )
 {
     EPS = nEPS;
     if ((EPS > 0) && (LBP + 0.01 < BrakeCyl->P()))
         LBP = BrakeCyl->P();
 }
 
-void TEStEP2::SetLP(double TM, double LM, double TBP)
+void TEStEP2::SetLP( double const TM, double const LM, double const TBP )
 {
     TareM = TM;
     LoadM = LM;
@@ -903,23 +903,15 @@ void TEStEP2::SetLP(double TM, double LM, double TBP)
 
 //---EST3--
 
-double TESt3::GetPF(double PP, double dt, double Vel)
+double TESt3::GetPF( double const PP, double const dt, double const Vel )
 {
-    double dv;
-    double dV1;
-    double temp;
-    double VVP;
-    double BVP;
-    double BCP;
-    double CVP;
+    double BVP{ BrakeRes->P() };
+    double VVP{ ValveRes->P() };
+    double BCP{ BrakeCyl->P() };
+    double CVP{ CntrlRes->P() - 0.0 };
 
-    BVP = BrakeRes->P();
-    VVP = ValveRes->P();
-    BCP = BrakeCyl->P();
-    CVP = CntrlRes->P() - 0.0;
-
-    dv = 0;
-    dV1 = 0;
+    double dv{ 0.0 };
+    double dV1{ 0.0 };
 
     // sprawdzanie stanu
     CheckState(BCP, dV1);
@@ -928,7 +920,7 @@ double TESt3::GetPF(double PP, double dt, double Vel)
     CVP = CntrlRes->P();
     VVP = ValveRes->P();
     // przeplyw ZS <-> PG
-    temp = CVs(BCP);
+    double temp = CVs(BCP);
     dv = PF(CVP, VVP, 0.0015 * temp) * dt;
     CntrlRes->Flow(+dv);
     ValveRes->Flow(-0.04 * dv);
@@ -936,16 +928,19 @@ double TESt3::GetPF(double PP, double dt, double Vel)
 
     // luzowanie
     if ((BrakeStatus & b_hld) == b_off)
-        dv = PF(0, BCP, 0.0042 * (1.37 - int(BrakeDelayFlag == bdelay_G)) * SizeBC) * dt;
+        dv = PF(0, BCP, 0.0042 * (1.37 - (BrakeDelayFlag == bdelay_G ? 1.0 : 0.0)) * SizeBC) * dt;
     else
         dv = 0;
     BrakeCyl->Flow(-dv);
     // przeplyw ZP <-> silowniki
     if ((BrakeStatus & b_on) == b_on)
-        dv = PF(BVP, BCP,
-                0.017 * (1 + int((BCP < 0.58) && (BrakeDelayFlag == bdelay_G))) *
-                    (1.13 - int((BCP > 0.6) && (BrakeDelayFlag == bdelay_G))) * SizeBC) *
-             dt;
+        dv = PF(
+            BVP,
+            BCP,
+            0.017 *
+            ( 1.00 + ( ((BCP < 0.58) && (BrakeDelayFlag == bdelay_G)) ? 1.0 : 0.0 ) ) *
+            ( 1.13 - ( ((BCP > 0.60) && (BrakeDelayFlag == bdelay_G)) ? 1.0 : 0.0 ) ) * SizeBC
+            ) * dt;
     else
         dv = 0;
     BrakeRes->Flow(dv);
@@ -957,7 +952,7 @@ double TESt3::GetPF(double PP, double dt, double Vel)
     else
         dv = 0;
     BrakeRes->Flow(dv);
-    dV1 = dV1 + dv * 0.96;
+    dV1 += dv * 0.96;
     ValveRes->Flow(-0.04 * dv);
     // przeplyw PG <-> rozdzielacz
     dv = PF(PP, VVP, 0.01) * dt;
@@ -972,7 +967,7 @@ double TESt3::GetPF(double PP, double dt, double Vel)
 
 //---EST4-RAPID---
 
-double TESt4R::GetPF(double PP, double dt, double Vel)
+double TESt4R::GetPF( double const PP, double const dt, double const Vel )
 {
     double result;
     double dv;
@@ -1032,7 +1027,9 @@ double TESt4R::GetPF(double PP, double dt, double Vel)
 
     result = dv - dV1;
 
-    RapidStatus = (BrakeDelayFlag == bdelay_R) && (((Vel > 55) && (RapidStatus)) || (Vel > 70));
+    RapidStatus = ( BrakeDelayFlag == bdelay_R )
+               && ( ( ( Vel > 55 ) && ( RapidStatus == true ) )
+                 || ( Vel > 70 ) );
 
     RapidTemp = RapidTemp + (0.9 * int(RapidStatus) - RapidTemp) * dt / 2;
     temp = 1.9 - RapidTemp;
@@ -1066,7 +1063,7 @@ double TESt4R::GetPF(double PP, double dt, double Vel)
     return result;
 }
 
-void TESt4R::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TESt4R::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     TESt::Init(PP, HPP, LPP, BP, BDF);
     ImplsRes->CreateCap(1);
@@ -1077,7 +1074,7 @@ void TESt4R::Init(double PP, double HPP, double LPP, double BP, int BDF)
 
 //---EST3/AL2---
 
-double TESt3AL2::GetPF(double PP, double dt, double Vel)
+double TESt3AL2::GetPF( double const PP, double const dt, double const Vel )
 {
     double result;
     double dv;
@@ -1161,21 +1158,21 @@ double TESt3AL2::GetPF(double PP, double dt, double Vel)
     return result;
 }
 
-void TESt3AL2::PLC(double mass)
+void TESt3AL2::PLC( double const mass )
 {
     LoadC = 1 +
             int(mass < LoadM) *
                 ((TareBP + (MaxBP - TareBP) * (mass - TareM) / (LoadM - TareM)) / MaxBP - 1);
 }
 
-void TESt3AL2::SetLP(double TM, double LM, double TBP)
+void TESt3AL2::SetLP( double const TM, double const LM, double const TBP )
 {
     TareM = TM;
     LoadM = LM;
     TareBP = TBP;
 }
 
-void TESt3AL2::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TESt3AL2::Init( double const PP, double const HPP, double const LPP, double const  BP, int const BDF )
 {
     TESt::Init(PP, HPP, LPP, BP, BDF);
     ImplsRes->CreateCap(1);
@@ -1184,7 +1181,7 @@ void TESt3AL2::Init(double PP, double HPP, double LPP, double BP, int BDF)
 
 //---LSt---
 
-double TLSt::GetPF(double PP, double dt, double Vel)
+double TLSt::GetPF( double const PP, double const dt, double const Vel )
 {
     double result;
     double dv;
@@ -1298,7 +1295,7 @@ double TLSt::GetPF(double PP, double dt, double Vel)
     return result;
 }
 
-void TLSt::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TLSt::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     TESt4R::Init(PP, HPP, LPP, BP, BDF);
     ValveRes->CreateCap(1);
@@ -1312,7 +1309,7 @@ void TLSt::Init(double PP, double HPP, double LPP, double BP, int BDF)
     BrakeDelayFlag = BDF;
 }
 
-void TLSt::SetLBP(double P)
+void TLSt::SetLBP( double const P )
 {
     LBP = P;
 }
@@ -1327,17 +1324,17 @@ double TLSt::GetEDBCP()
     return (CVP - BCP) * BVM;
 }
 
-void TLSt::SetED(double EDstate)
+void TLSt::SetED( double const EDstate )
 {
     EDFlag = EDstate;
 }
 
-void TLSt::SetRM(double RMR)
+void TLSt::SetRM( double const RMR )
 {
     RM = 1 - RMR;
 }
 
-double TLSt::GetHPFlow(double HP, double dt)
+double TLSt::GetHPFlow( double const HP, double const dt )
 {
     double dv;
 
@@ -1348,7 +1345,7 @@ double TLSt::GetHPFlow(double HP, double dt)
 
 //---EStED---
 
-double TEStED::GetPF(double PP, double dt, double Vel)
+double TEStED::GetPF( double const PP, double const dt, double const Vel )
 {
     double dv;
     double dV1;
@@ -1496,7 +1493,7 @@ double TEStED::GetPF(double PP, double dt, double Vel)
     return dv - dV1;
 }
 
-void TEStED::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TEStED::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     TLSt::Init(PP, HPP, LPP, BP, BDF);
     int i;
@@ -1546,14 +1543,14 @@ double TEStED::GetEDBCP()
     return ImplsRes->P() * LoadC;
 }
 
-void TEStED::PLC(double mass)
+void TEStED::PLC( double const mass )
 {
     LoadC = 1 +
             int(mass < LoadM) *
                 ((TareBP + (MaxBP - TareBP) * (mass - TareM) / (LoadM - TareM)) / MaxBP - 1);
 }
 
-void TEStED::SetLP(double TM, double LM, double TBP)
+void TEStED::SetLP( double const TM, double const LM, double const TBP )
 {
     TareM = TM;
     LoadM = LM;
@@ -1562,7 +1559,7 @@ void TEStED::SetLP(double TM, double LM, double TBP)
 
 //---DAKO CV1---
 
-void TCV1::CheckState(double BCP, double &dV1)
+void TCV1::CheckState( double const BCP, double &dV1 )
 {
     double VVP;
     double BVP;
@@ -1595,7 +1592,7 @@ void TCV1::CheckState(double BCP, double &dV1)
         BrakeStatus |= b_hld;
 }
 
-double TCV1::CVs(double BP)
+double TCV1::CVs(double const BP)
 {
     // przeplyw ZS <-> PG
     if ((BP > 0.05))
@@ -1604,7 +1601,7 @@ double TCV1::CVs(double BP)
         return 0.23;
 }
 
-double TCV1::BVs(double BCP)
+double TCV1::BVs( double const BCP )
 {
     double VVP;
     double BVP;
@@ -1623,7 +1620,7 @@ double TCV1::BVs(double BCP)
         return 0.2 * (1.5 - int(BVP > VVP));
 }
 
-double TCV1::GetPF(double PP, double dt, double Vel)
+double TCV1::GetPF( double const PP, double const dt, double const Vel )
 {
     double dv;
     double dV1;
@@ -1690,7 +1687,7 @@ double TCV1::GetPF(double PP, double dt, double Vel)
     return dv - dV1;
 }
 
-void TCV1::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TCV1::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     TBrake::Init(PP, HPP, LPP, BP, BDF);
     ValveRes->CreatePress(PP);
@@ -1712,12 +1709,12 @@ double TCV1::GetCRP()
 
 //---CV1-L-TR---
 
-void TCV1L_TR::SetLBP(double P)
+void TCV1L_TR::SetLBP( double const P )
 {
     LBP = P;
 }
 
-double TCV1L_TR::GetHPFlow(double HP, double dt)
+double TCV1L_TR::GetHPFlow( double const HP, double const dt )
 {
     double dv;
 
@@ -1727,14 +1724,14 @@ double TCV1L_TR::GetHPFlow(double HP, double dt)
     return dv;
 }
 
-void TCV1L_TR::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TCV1L_TR::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     TCV1::Init(PP, HPP, LPP, BP, BDF);
     ImplsRes->CreateCap(2.5);
     ImplsRes->CreatePress(BP);
 }
 
-double TCV1L_TR::GetPF(double PP, double dt, double Vel)
+double TCV1L_TR::GetPF( double const PP, double const dt, double const Vel )
 {
     double result;
     double dv;
@@ -1821,7 +1818,7 @@ double TCV1L_TR::GetPF(double PP, double dt, double Vel)
 }
 
 //--- KNORR KE ---
-void TKE::CheckReleaser(double dt)
+void TKE::CheckReleaser( double const dt )
 {
     double VVP;
     double CVP;
@@ -1837,7 +1834,7 @@ void TKE::CheckReleaser(double dt)
             CntrlRes->Flow(+PF(CVP, 0, 0.1) * dt);
 }
 
-void TKE::CheckState(double BCP, double &dV1)
+void TKE::CheckState( double const BCP, double &dV1 )
 {
     double VVP;
     double BVP;
@@ -1866,7 +1863,7 @@ void TKE::CheckState(double BCP, double &dV1)
         BrakeStatus |= b_hld;
 }
 
-double TKE::CVs(double BP)
+double TKE::CVs( double const BP )
 {
     double VVP;
     double BVP;
@@ -1885,7 +1882,7 @@ double TKE::CVs(double BP)
         return 0.23;
 }
 
-double TKE::BVs(double BCP)
+double TKE::BVs( double const BCP )
 {
     double VVP;
     double BVP;
@@ -1904,7 +1901,7 @@ double TKE::BVs(double BCP)
         return 0.13;
 }
 
-double TKE::GetPF(double PP, double dt, double Vel)
+double TKE::GetPF( double const PP, double const dt, double const Vel )
 {
     double dv;
     double dV1;
@@ -2020,7 +2017,7 @@ double TKE::GetPF(double PP, double dt, double Vel)
     return dv - dV1;
 }
 
-void TKE::Init(double PP, double HPP, double LPP, double BP, int BDF)
+void TKE::Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )
 {
     TBrake::Init(PP, HPP, LPP, BP, BDF);
     ValveRes->CreatePress(PP);
@@ -2045,7 +2042,7 @@ double TKE::GetCRP()
     return CntrlRes->P();
 }
 
-double TKE::GetHPFlow(double HP, double dt)
+double TKE::GetHPFlow( double const HP, double const dt )
 {
     double dv;
 
@@ -2055,33 +2052,33 @@ double TKE::GetHPFlow(double HP, double dt)
     return dv;
 }
 
-void TKE::PLC(double mass)
+void TKE::PLC( double const mass )
 {
     LoadC = 1 +
             int(mass < LoadM) *
                 ((TareBP + (MaxBP - TareBP) * (mass - TareM) / (LoadM - TareM)) / MaxBP - 1);
 }
 
-void TKE::SetLP(double TM, double LM, double TBP)
+void TKE::SetLP( double const TM, double const LM, double const TBP )
 {
     TareM = TM;
     LoadM = LM;
     TareBP = TBP;
 }
 
-void TKE::SetRM(double RMR)
+void TKE::SetRM( double const RMR )
 {
     RM = 1.0 - RMR;
 }
 
-void TKE::SetLBP(double P)
+void TKE::SetLBP( double const P )
 {
     LBP = P;
 }
 
 //---KRANY---
 
-double TDriverHandle::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TDriverHandle::GetPF(double const i_bcp, double PP, double HP, double dt, double ep)
 {
     return 0;
 }
diff --git a/McZapkie/hamulce.h b/McZapkie/hamulce.h
index d2c2db8b..962b6a87 100644
--- a/McZapkie/hamulce.h
+++ b/McZapkie/hamulce.h
@@ -191,30 +191,30 @@ class TBrake {
   public:
 		TBrake(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa);
 		//maksymalne cisnienie, promien, skok roboczy, pojemnosc ZP, ilosc cylindrow, opoznienia hamulca, material klockow, osie hamowane, klocki na os;
-		virtual void Init(double PP, double HPP, double LPP, double BP, int BDF);  //inicjalizacja hamulca
+        virtual void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF );  //inicjalizacja hamulca
 
-		double GetFC(double Vel, double N);         //wspolczynnik tarcia - hamulec wie lepiej
-		virtual double GetPF(double PP, double dt, double Vel);      //przeplyw miedzy komora wstepna i PG
+        double GetFC( double const Vel, double const N );         //wspolczynnik tarcia - hamulec wie lepiej
+        virtual double GetPF( double const PP, double const dt, double const Vel );      //przeplyw miedzy komora wstepna i PG
 		double GetBCF();                           //sila tlokowa z tloka
-		virtual double GetHPFlow(double HP, double dt);  //przeplyw - 8 bar
+        virtual double GetHPFlow( double const HP, double const dt );  //przeplyw - 8 bar
 		double GetBCP();  //cisnienie cylindrow hamulcowych
 		virtual double GetEDBCP();    //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09
 		double GetBRP(); //cisnienie zbiornika pomocniczego
 		double GetVRP(); //cisnienie komory wstepnej rozdzielacza
 		virtual double GetCRP();  //cisnienie zbiornika sterujacego
-		bool SetBDF(int nBDF); //nastawiacz GPRM
-		void Releaser(int state); //odluzniacz
-		virtual void SetEPS(double nEPS); //hamulec EP
-		virtual void SetRM(double RMR) {};   //ustalenie przelozenia rapida
-		virtual void SetLP(double TM, double LM, double TBP) {};  //parametry przystawki wazacej
-		virtual void SetLBP(double P) {};   //cisnienie z hamulca pomocniczego
-		virtual void PLC(double mass) {};  //wspolczynnik cisnienia przystawki wazacej
+        bool SetBDF( int const nBDF ); //nastawiacz GPRM
+        void Releaser( int const state ); //odluzniacz
+        virtual void SetEPS( double const nEPS ); //hamulec EP
+        virtual void SetRM( double const RMR ) {};   //ustalenie przelozenia rapida
+		virtual void SetLP(double const TM, double const LM, double const TBP) {};  //parametry przystawki wazacej
+		virtual void SetLBP(double const P) {};   //cisnienie z hamulca pomocniczego
+		virtual void PLC(double const mass) {};  //wspolczynnik cisnienia przystawki wazacej
 		void ASB(int state); //hamulec przeciwposlizgowy
 		int GetStatus(); //flaga statusu, moze sie przydac do odglosow
-		void SetASBP(double Press); //ustalenie cisnienia pp
+        void SetASBP( double const Press ); //ustalenie cisnienia pp
     virtual void ForceEmptiness();
     int GetSoundFlag();
-		virtual void SetED(double EDstate) {}; //stan hamulca ED do luzowania
+    virtual void SetED( double const EDstate ) {}; //stan hamulca ED do luzowania
 };
 
 class TWest : public TBrake {
@@ -229,13 +229,13 @@ class TWest : public TBrake {
 		double LoadC = 0.0;   //wspolczynnik przystawki wazacej
 
   public:
-		void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/;
-		void SetLBP(double P);   //cisnienie z hamulca pomocniczego
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
-		double GetHPFlow(double HP, double dt)/*override*/;
-		void PLC(double mass);  //wspolczynnik cisnienia przystawki wazacej
-		void SetEPS(double nEPS)/*override*/;  //stan hamulca EP
-		void SetLP(double TM, double LM, double TBP);  //parametry przystawki wazacej
+      void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )/*override*/;
+		void SetLBP(double const P);   //cisnienie z hamulca pomocniczego
+        double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
+        double GetHPFlow( double const HP, double const dt )/*override*/;
+		void PLC(double const mass);  //wspolczynnik cisnienia przystawki wazacej
+        void SetEPS( double const nEPS )/*override*/;  //stan hamulca EP
+		void SetLP(double const TM, double const LM, double const TBP);  //parametry przystawki wazacej
 
 		inline TWest(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
               TBrake(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
@@ -251,8 +251,8 @@ class TESt : public TBrake {
 		double BVM = 0.0;                 // przelozenie PG-CH
 
   public:
-		void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/;
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
+      void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )/*override*/;
+        double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
 		void EStParams(double i_crc);                 //parametry charakterystyczne dla ESt
 		double GetCRP()/*override*/;
 		void CheckState(double BCP, double & dV1); //glowny przyrzad rozrzadczy
@@ -273,7 +273,7 @@ class TESt3 : public TESt {
 		//double CylFlowSpeed[2][2]; //zmienna nie uzywana
 
   public:
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
+      double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
 
 		inline TESt3(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
                 TESt(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
@@ -290,10 +290,10 @@ class TESt3AL2 : public TESt3 {
 		double LoadC = 0.0;
 
   public:
-		void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/;
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
-		void PLC(double mass);  //wspolczynnik cisnienia przystawki wazacej
-		void SetLP(double TM, double LM, double TBP);  //parametry przystawki wazacej
+      void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )/*override*/;
+      double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
+		void PLC(double const mass);  //wspolczynnik cisnienia przystawki wazacej
+		void SetLP(double const TM, double const LM, double const TBP);  //parametry przystawki wazacej
 
 		inline TESt3AL2(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
                   TESt3(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
@@ -312,8 +312,8 @@ class TESt4R : public TESt {
 		double RapidTemp = 0.0;           //aktualne, zmienne przelozenie
 
   public:
-		void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/;
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
+      void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )/*override*/;
+      double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
 
 		inline TESt4R(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
                  TESt(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
@@ -333,13 +333,13 @@ class TLSt : public TESt4R {
 		double EDFlag = 0.0; //luzowanie hamulca z powodu zalaczonego ED
 
   public:
-		void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/;
-		void SetLBP(double P);   //cisnienie z hamulca pomocniczego
-		void SetRM(double RMR);   //ustalenie przelozenia rapida
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
-		double GetHPFlow(double HP, double dt)/*override*/;  //przeplyw - 8 bar
+      void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )/*override*/;
+		void SetLBP(double const P);   //cisnienie z hamulca pomocniczego
+        void SetRM( double const RMR );   //ustalenie przelozenia rapida
+        double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
+        double GetHPFlow( double const HP, double const dt )/*override*/;  //przeplyw - 8 bar
 		virtual double GetEDBCP();    //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09
-		virtual void SetED(double EDstate); //stan hamulca ED do luzowania
+        virtual void SetED( double const EDstate ); //stan hamulca ED do luzowania
 
 		inline TLSt(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
              TESt4R(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
@@ -360,11 +360,11 @@ class TEStED : public TLSt {  //zawor z EP09 - Est4 z oddzielnym przekladnikiem,
 
 
   public:
-		void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/;
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
+      void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )/*override*/;
+      double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
 		double GetEDBCP()/*override*/;    //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED
-		void PLC(double mass);  //wspolczynnik cisnienia przystawki wazacej
-		void SetLP(double TM, double LM, double TBP);  //parametry przystawki wazacej        
+		void PLC(double const mass);  //wspolczynnik cisnienia przystawki wazacej
+        void SetLP( double const TM, double const LM, double const TBP );  //parametry przystawki wazacej        
 
 		inline TEStED(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
                  TLSt(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
@@ -375,20 +375,19 @@ class TEStED : public TLSt {  //zawor z EP09 - Est4 z oddzielnym przekladnikiem,
 
 class TEStEP2 : public TLSt {
 
-  private:
-		double TareM = 0.0;  //masa proznego
-		double LoadM = 0.0;  //masa pelnego
-		double TareBP = 0.0;  //cisnienie dla proznego
-		double LoadC = 0.0;
-		double EPS = 0.0;
+private:
+    double TareM = 0.0;  //masa proznego
+    double LoadM = 0.0;  //masa pelnego
+    double TareBP = 0.0;  //cisnienie dla proznego
+    double LoadC = 0.0;
+    double EPS = 0.0;
 
-
-  public:
-		void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/;   //inicjalizacja
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
-		void PLC(double mass);  //wspolczynnik cisnienia przystawki wazacej
-		void SetEPS(double nEPS)/*override*/;  //stan hamulca EP
-		void SetLP(double TM, double LM, double TBP);  //parametry przystawki wazacej
+public:
+    void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )/*override*/;   //inicjalizacja
+    double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
+    void PLC( double const mass );  //wspolczynnik cisnienia przystawki wazacej
+    void SetEPS( double const nEPS )/*override*/;  //stan hamulca EP
+    void SetLP( double const TM, double const LM, double const TBP );  //parametry przystawki wazacej
 
 		inline TEStEP2(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
                TLSt(          i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
@@ -397,19 +396,19 @@ class TEStEP2 : public TLSt {
 
 class TCV1 : public TBrake {
 
-  private:
-		double BVM = 0.0; //przelozenie PG-CH
+private:
+    double BVM = 0.0; //przelozenie PG-CH
 
-  protected:
-		std::shared_ptr<TReservoir> CntrlRes; // zbiornik sterujący
+protected:
+    std::shared_ptr<TReservoir> CntrlRes; // zbiornik sterujący
 
-  public:
-		void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/;
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
-		double GetCRP()/*override*/;
-		void CheckState(double BCP, double & dV1);
-    double CVs(double BP);
-    double BVs(double BCP);
+public:
+    void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )/*override*/;
+    double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
+    double GetCRP()/*override*/;
+    void CheckState( double const BCP, double &dV1 );
+    double CVs( double const BP );
+    double BVs( double const BCP );
 
 		inline TCV1(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
              TBrake(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
@@ -437,20 +436,20 @@ class TCV1 : public TBrake {
 
 class TCV1L_TR : public TCV1 {
 
-  private:
-		std::shared_ptr<TReservoir> ImplsRes;      //komora impulsowa
-		double LBP = 0.0;     //cisnienie hamulca pomocniczego
+private:
+    std::shared_ptr<TReservoir> ImplsRes;      //komora impulsowa
+    double LBP = 0.0;     //cisnienie hamulca pomocniczego
 
-  public:
-		void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/;
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
-		void SetLBP(double P);   //cisnienie z hamulca pomocniczego
-		double GetHPFlow(double HP, double dt)/*override*/;  //przeplyw - 8 bar
+public:
+    void Init( double const PP, double const  HPP, double const LPP, double const BP, int const BDF )/*override*/;
+    double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
+    void SetLBP( double const P );   //cisnienie z hamulca pomocniczego
+    double GetHPFlow( double const HP, double const dt )/*override*/;  //przeplyw - 8 bar
 
-		inline TCV1L_TR(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
-                   TCV1(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
+    inline TCV1L_TR(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
+               TCV1(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
     {
-			ImplsRes = std::make_shared<TReservoir>();
+        ImplsRes = std::make_shared<TReservoir>();
     }
 };
 
@@ -470,18 +469,18 @@ class TKE : public TBrake { //Knorr Einheitsbauart — jeden do wszystkiego
 		double LBP = 0.0; //cisnienie hamulca pomocniczego
 
   public:
-		void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/;
-		void SetRM(double RMR);   //ustalenie przelozenia rapida
-		double GetPF(double PP, double dt, double Vel)/*override*/;      //przeplyw miedzy komora wstepna i PG
-		double GetHPFlow(double HP, double dt)/*override*/;  //przeplyw - 8 bar
+      void Init( double const PP, double const HPP, double const LPP, double const BP, int const BDF )/*override*/;
+      void SetRM( double const RMR );   //ustalenie przelozenia rapida
+      double GetPF( double const PP, double const dt, double const Vel )/*override*/;      //przeplyw miedzy komora wstepna i PG
+        double GetHPFlow( double const HP, double const dt )/*override*/;  //przeplyw - 8 bar
 		double GetCRP()/*override*/;
-		void CheckState(double BCP, double & dV1);
-		void CheckReleaser(double dt); //odluzniacz
-		double CVs(double BP);      //napelniacz sterujacego
-		double BVs(double BCP);     //napelniacz pomocniczego
-		void PLC(double mass);  //wspolczynnik cisnienia przystawki wazacej
-		void SetLP(double TM, double LM, double TBP);  //parametry przystawki wazacej
-		void SetLBP(double P);   //cisnienie z hamulca pomocniczego
+        void CheckState( double const BCP, double &dV1 );
+        void CheckReleaser( double const dt ); //odluzniacz
+        double CVs( double const BP );      //napelniacz sterujacego
+        double BVs( double const BCP );     //napelniacz pomocniczego
+        void PLC( double const mass );  //wspolczynnik cisnienia przystawki wazacej
+        void SetLP( double const TM, double const LM, double const TBP );  //parametry przystawki wazacej
+        void SetLBP( double const P );   //cisnienie z hamulca pomocniczego
 
 		inline TKE(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
             TBrake(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
@@ -742,8 +741,8 @@ class TFVel6 : public TDriverHandle {
 };
 
 
-extern double PF(double P1, double P2, double S, double DP = 0.25);
-extern double PF1(double P1, double P2, double S);
+extern double PF( double const P1, double const P2, double const S, double const DP = 0.25 );
+extern double PF1( double const P1, double const P2, double const S );
 
-extern double PFVa(double PH, double PL, double S, double LIM, double DP = 0.1); //zawor napelniajacy z PH do PL, PL do LIM
-extern double PFVd(double PH, double PL, double S, double LIM, double DP = 0.1); //zawor wypuszczajacy z PH do PL, PH do LIM
+extern double PFVa( double PH, double PL, double const S, double LIM, double const DP = 0.1 ); //zawor napelniajacy z PH do PL, PL do LIM
+extern double PFVd( double PH, double PL, double const S, double LIM, double const DP = 0.1 ); //zawor wypuszczajacy z PH do PL, PH do LIM
diff --git a/Names.cpp b/Names.cpp
index 749cc70c..1f6bcd54 100644
--- a/Names.cpp
+++ b/Names.cpp
@@ -35,6 +35,8 @@ Obiekty sortowane wg nazw, można dodawać i usuwać komórki scenerii:
 
 */
 
+#ifdef EU07_USE_OLD_TNAMES_CLASS
+
 void ItemRecord::TreeAdd(ItemRecord *r, int c)
 { // dodanie rekordu do drzewa - ustalenie w której gałęzi
     // zapisać w (iFlags) ile znaków jest zgodnych z nadrzędnym, żeby nie sprawdzać wszystkich od
@@ -183,3 +185,5 @@ 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;
 };
+
+#endif
diff --git a/Names.h b/Names.h
index e0bb33d1..d9220fb1 100644
--- a/Names.h
+++ b/Names.h
@@ -11,6 +11,8 @@ http://mozilla.org/MPL/2.0/.
 #include <unordered_map>
 #include <string>
 
+#ifndef EU07_USE_OLD_TNAMES_CLASS
+
 template <typename _Pointer>
 class TNames {
 
@@ -65,7 +67,8 @@ private:
     pointermap_map                          m_maps;             // list of pointer maps of types specified so far
 };
 
-#ifdef EU07_USE_OLD_TNAMES_CLASS
+#else
+
 //---------------------------------------------------------------------------
 class ItemRecord
 { // rekord opisujący obiekt; raz utworzony nie przemieszcza się
diff --git a/Texture.cpp b/Texture.cpp
index c07b5a79..e16d85c8 100644
--- a/Texture.cpp
+++ b/Texture.cpp
@@ -303,7 +303,7 @@ TTexturesManager::AlphaValue TTexturesManager::LoadBMP(std::string const &fileNa
     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
-    if( true == GLEW_VERSION_1_4 ) {
+    if( GLEW_VERSION_1_4 ) {
         glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE );
     }
     // This is specific to the binary format of the data read in.
@@ -784,6 +784,15 @@ TTexturesManager::AlphaValue TTexturesManager::LoadDDS(std::string fileName, int
         data.width /= 2;
         data.height /= 2;
     };
+
+    if( ( data.numMipMaps == 1 )
+     && ( GLEW_VERSION_1_4 ) ) {
+        // generate missing mipmaps for the updated render path
+        // TODO, TBD: skip this for UI images
+        glGenerateMipmap( GL_TEXTURE_2D );
+        WriteLog( "Warning - generating missing mipmaps for " + fileName );
+    }
+
     delete[] data.pixels;
     return std::make_pair(id, data.components == 4);
 };
@@ -823,39 +832,46 @@ void TTexturesManager::SetFiltering(int filter)
 void TTexturesManager::SetFiltering(bool alpha, bool hash)
 {
 
-    if (alpha || hash)
-    {
-        if (alpha) // przezroczystosc: nie wlaczac mipmapingu
-        {
-            if (hash) // #: calkowity brak filtracji - pikseloza
-            {
-                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-            }
-            else
-            {
-                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-            }
-        }
-        else // filtruj ale bez dalekich mipmap - robi artefakty
-        {
-/*
-            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-*/
-            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
-            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
-        }
-    }
-    else // $: filtruj wszystko - brzydko się zlewa
-    {
-/*
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-*/
+    if( GLEW_VERSION_1_4 ) {
+
         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
+
+        if( true == hash ) {
+            // #: sharpen more
+            glTexEnvf( GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, -2.0 );
+        }
+        else {
+            // regular texture sharpening
+            glTexEnvf( GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, -1.0 );
+        }
+    }
+    else {
+        // legacy version, for ancient systems
+        if( alpha || hash ) {
+            if( alpha ) // przezroczystosc: nie wlaczac mipmapingu
+            {
+                if( hash ) // #: calkowity brak filtracji - pikseloza
+                {
+                    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+                    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+                }
+                else {
+                    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+                    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+                }
+            }
+            else // filtruj ale bez dalekich mipmap - robi artefakty
+            {
+                glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+                glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+            }
+        }
+        else // $: filtruj wszystko - brzydko się zlewa
+        {
+            glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+            glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
+        }
     }
 };
 
@@ -873,18 +889,25 @@ GLuint TTexturesManager::CreateTexture(GLubyte *buff, GLint bpp, int width, int
         SetFiltering(filter); // cyfra po % w nazwie
     else
         SetFiltering(bHasAlpha && bDollar, bHash); // znaki #, $ i kanał alfa w nazwie
-    if( true == GLEW_VERSION_1_4 ) {
-        glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE );
-    }
+
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
     glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
     glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
-/*    if (bHasAlpha || bHash || (filter == 0))
-*/        glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, bpp,
-                     GL_UNSIGNED_BYTE, buff);
-//    else
-//        gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, width, height, bpp, GL_UNSIGNED_BYTE, buff);
+
+    if( GLEW_VERSION_1_4 ) {
+
+        glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE );
+        glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, bpp, GL_UNSIGNED_BYTE, buff );
+    }
+    else {
+        // legacy version, for ancient systems
+        if( bHasAlpha || bHash || ( filter == 0 ) )
+            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, bpp, GL_UNSIGNED_BYTE, buff );
+        else
+            gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGB, width, height, bpp, GL_UNSIGNED_BYTE, buff );
+    }
+
     return ID;
 }
 
diff --git a/maszyna.vcxproj b/maszyna.vcxproj
index c0f7ee8a..2797b436 100644
--- a/maszyna.vcxproj
+++ b/maszyna.vcxproj
@@ -114,6 +114,7 @@
     <ClCompile Include="MemCell.cpp" />
     <ClCompile Include="Model3d.cpp" />
     <ClCompile Include="mtable.cpp" />
+    <ClCompile Include="Names.cpp" />
     <ClCompile Include="opengl\ARB_Multisample.cpp" />
     <ClCompile Include="parser.cpp" />
     <ClCompile Include="PyInt.cpp" />
@@ -205,6 +206,10 @@
   <ItemGroup>
     <Image Include="eu07.ico" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="ClassDiagram.cd" />
+    <None Include="ClassDiagram1.cd" />
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
diff --git a/maszyna.vcxproj.filters b/maszyna.vcxproj.filters
index d18b00e4..fed256d5 100644
--- a/maszyna.vcxproj.filters
+++ b/maszyna.vcxproj.filters
@@ -186,6 +186,9 @@
     <ClCompile Include="Console\MWD.cpp">
       <Filter>Source Files\console</Filter>
     </ClCompile>
+    <ClCompile Include="Names.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="opengl\glew.h">
@@ -373,4 +376,8 @@
       <Filter>Resource Files</Filter>
     </Image>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="ClassDiagram.cd" />
+    <None Include="ClassDiagram1.cd" />
+  </ItemGroup>
 </Project>
\ No newline at end of file