diff --git a/code/HTMLWriter.cpp b/code/HTMLWriter.cpp
index 91b1cbf..7e2a363 100644
--- a/code/HTMLWriter.cpp
+++ b/code/HTMLWriter.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -41,28 +41,30 @@ extern Image image;
 #include <sstream>
 #include <iomanip>
 
+using namespace std;
+
 double getLocalScale(const wstring &fontName, wstring &faceName);
 wstring getMeosCompectVersion();
 
 map <string, shared_ptr<HTMLWriter>> HTMLWriter::tCache;
 extern wchar_t exePath[MAX_PATH];
 
-static void generateStyles(const gdioutput &gdi, ostream &fout, double scale, bool withTbl, const list<TextInfo> &TL,
+static void generateStyles(const gdioutput &gdi, std::ostream &fout, double scale, bool withTbl, const list<TextInfo> &TL,
                            map< pair<gdiFonts, string>, pair<string, string> > &styles) {
   fout << "<style type=\"text/css\">\n";
   fout << "body {background-color: rgb(250,250,255)}\n";
-  fout << "h1 {font-family:arial,sans-serif;font-size:" << fixed << std::setprecision(2) << 24 * scale << "px;font-weight:normal;white-space:nowrap}\n";
-  fout << "h2 {font-family:arial,sans-serif;font-size:" << fixed << std::setprecision(2) << 20 * scale << "px;font-weight:normal;white-space:nowrap}\n";
-  fout << "h3 {font-family:arial,sans-serif;font-size:" << fixed << std::setprecision(2) << 16 * scale << "px;font-weight:normal;white-space:nowrap}\n";
-  fout << "p {font-family:arial,sans-serif;font-size:" << fixed << std::setprecision(2) << 12 * scale << "px;font-weight:normal}\n";
-  fout << "div {font-family:arial,sans-serif;font-size:" << fixed << std::setprecision(2) << 12 * scale << "px;font-weight:normal;white-space:nowrap}\n";
+  fout << "h1 {font-family:arial,sans-serif;font-size:" << std::fixed << std::setprecision(2) << 24 * scale << "px;font-weight:normal;white-space:nowrap}\n";
+  fout << "h2 {font-family:arial,sans-serif;font-size:" << std::fixed << std::setprecision(2) << 20 * scale << "px;font-weight:normal;white-space:nowrap}\n";
+  fout << "h3 {font-family:arial,sans-serif;font-size:" << std::fixed << std::setprecision(2) << 16 * scale << "px;font-weight:normal;white-space:nowrap}\n";
+  fout << "p {font-family:arial,sans-serif;font-size:" << std::fixed << std::setprecision(2) << 12 * scale << "px;font-weight:normal}\n";
+  fout << "div {font-family:arial,sans-serif;font-size:" << std::fixed << std::setprecision(2) << 12 * scale << "px;font-weight:normal;white-space:nowrap}\n";
 
   if (withTbl) {
-    fout << "td {font-family:arial,sans-serif;font-size:" << fixed << std::setprecision(2) << 12 * scale << "px;font-weight:normal;white-space:nowrap}\n";
+    fout << "td {font-family:arial,sans-serif;font-size:" << std::fixed << std::setprecision(2) << 12 * scale << "px;font-weight:normal;white-space:nowrap}\n";
     fout << "td.e0 {background-color: rgb(238,238,255)}\n";
     fout << "td.e1 {background-color: rgb(245,245,255)}\n";
-    fout << "td.header {line-height:" << fixed << std::setprecision(2) << 1.8 * scale << ";height:" << fixed << std::setprecision(2) << 40 * scale << "px}\n";
-    fout << "td.freeheader {line-height:" << fixed << std::setprecision(2) << 1.2 * scale << "}\n";
+    fout << "td.header {line-height:" << std::fixed << std::setprecision(2) << 1.8 * scale << ";height:" << std::fixed << std::setprecision(2) << 40 * scale << "px}\n";
+    fout << "td.freeheader {line-height:" << std::fixed << std::setprecision(2) << 1.2 * scale << "}\n";
   }
   list<TextInfo>::const_iterator it=TL.begin();
   int styleList = 1;
diff --git a/code/HTMLWriter.h b/code/HTMLWriter.h
index dd8e401..4134e4b 100644
--- a/code/HTMLWriter.h
+++ b/code/HTMLWriter.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -49,11 +49,11 @@ class HTMLWriter {
     ImageWriter(const wstring& dst, bool writeImages) : destination(dst), writeImages(writeImages) {}
 
 
-    void write(ostream &fout, const string &xp, const string &yp, const wstring &img, int width, int height);
+    void write(std::ostream &fout, const string &xp, const string &yp, const wstring &img, int width, int height);
   };
 
   template<typename T, typename TI>
-  static void formatTL(ostream& fout,
+  static void formatTL(std::ostream& fout,
     ImageWriter& imageWriter,
     const map< pair<gdiFonts, string>, pair<string, string> >& styles,
     const T& tl,
@@ -87,7 +87,7 @@ public:
   void read(const wstring &fileName);
 
   void generate(gdioutput &gdi,
-                ostream &fout,
+                std::ostream &fout,
                 const wstring &title,
                 const wstring &contentDescription,
                 bool respectPageBreak,
@@ -99,12 +99,12 @@ public:
 
   void getPage(const oEvent &oe, string &out) const;
 
-  static void writeHTML(gdioutput &gdi, ostream &dout, const wstring &title, 
+  static void writeHTML(gdioutput &gdi, std::ostream &dout, const wstring &title, 
                         bool includeImages,
                         const wstring& imageDirectoryDestination,
                         int refreshTimeOut, double scale);
 
-  static void writeTableHTML(gdioutput &gdi, ostream &fout,
+  static void writeTableHTML(gdioutput &gdi, std::ostream &fout,
                              const wstring &title,
                              bool includeImages,
                              const wstring &imageDirectoryDestination,
@@ -121,13 +121,13 @@ public:
                         const wstring &title, int refreshTimeOut, double scale);
 
   static void write(gdioutput& gdi, const wstring& file, const wstring& title, int refresh, oListParam& param, const oEvent& oe);
-  static void write(gdioutput& gdi, ostream& fout, const wstring& title, int refresh, oListParam& param, const oEvent& oe);
+  static void write(gdioutput& gdi, std::ostream& fout, const wstring& title, int refresh, oListParam& param, const oEvent& oe);
 
   static void write(gdioutput& gdi, const wstring& file, const wstring& title, const wstring& contentsDescription,
     bool respectPageBreak, const string& typeTag, int refresh,
     int rows, int cols, int time_ms, int margin, double scale);
 
-  static void write(gdioutput& gdi, ostream& fout, const wstring& title, 
+  static void write(gdioutput& gdi, std::ostream& fout, const wstring& title, 
     bool includeImages,
     const wstring& imageDirectoryDestination,
     const wstring& contentsDescription,
diff --git a/code/MeOS.sln b/code/MeOS.sln
new file mode 100644
index 0000000..9853837
--- /dev/null
+++ b/code/MeOS.sln
@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.8.34330.188
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MeOS", "MeOS.vcxproj", "{60BC59CB-8987-4A39-B866-403066F59B0F}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{60BC59CB-8987-4A39-B866-403066F59B0F}.Debug|x64.ActiveCfg = Debug|x64
+		{60BC59CB-8987-4A39-B866-403066F59B0F}.Debug|x64.Build.0 = Debug|x64
+		{60BC59CB-8987-4A39-B866-403066F59B0F}.Debug|x86.ActiveCfg = Debug|Win32
+		{60BC59CB-8987-4A39-B866-403066F59B0F}.Debug|x86.Build.0 = Debug|Win32
+		{60BC59CB-8987-4A39-B866-403066F59B0F}.Release|x64.ActiveCfg = Release|x64
+		{60BC59CB-8987-4A39-B866-403066F59B0F}.Release|x64.Build.0 = Release|x64
+		{60BC59CB-8987-4A39-B866-403066F59B0F}.Release|x86.ActiveCfg = Release|Win32
+		{60BC59CB-8987-4A39-B866-403066F59B0F}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {0AA159AF-578B-49E9-8D52-50F9272169DB}
+	EndGlobalSection
+EndGlobal
diff --git a/code/MeOS.vcxproj b/code/MeOS.vcxproj
new file mode 100644
index 0000000..a9a33b3
--- /dev/null
+++ b/code/MeOS.vcxproj
@@ -0,0 +1,379 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>17.0</VCProjectVersion>
+    <ProjectGuid>{60BC59CB-8987-4A39-B866-403066F59B0F}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <CopyCppRuntimeToOutputDir>false</CopyCppRuntimeToOutputDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level3</WarningLevel>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <AdditionalIncludeDirectories>./libharu;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4267;4244;4018</DisableSpecificWarnings>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalLibraryDirectories>./lib_db</AdditionalLibraryDirectories>
+      <AdditionalDependencies>Msimg32.lib;comctl32.lib;odbc32.lib;odbccp32.lib;winmm.lib;ws2_32.lib;wininet.lib;zlibstat_vc15.lib;libmysql.lib;libhpdf.lib;RestBed.lib;libpng.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <Manifest>
+      <AdditionalManifestFiles>meos_dpi_manifest.xml %(AdditionalManifestFiles)</AdditionalManifestFiles>
+    </Manifest>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level3</WarningLevel>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <DisableSpecificWarnings>4267;4244;4018</DisableSpecificWarnings>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <AdditionalIncludeDirectories>./libharu;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>Msimg32.lib;comctl32.lib;odbc32.lib;odbccp32.lib;winmm.lib;ws2_32.lib;wininet.lib;zlibstat.lib;libharu.lib;RestBed.lib;libpng.lib;libmysql.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>./lib64_db</AdditionalLibraryDirectories>
+    </Link>
+    <Manifest>
+      <AdditionalManifestFiles>meos_dpi_manifest.xml %(AdditionalManifestFiles)</AdditionalManifestFiles>
+    </Manifest>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level3</WarningLevel>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <DisableSpecificWarnings>4267;4244;4018</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>./libharu;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalLibraryDirectories>./lib</AdditionalLibraryDirectories>
+      <AdditionalDependencies>Msimg32.lib;comctl32.lib;odbc32.lib;odbccp32.lib;winmm.lib;ws2_32.lib;wininet.lib;zlibstat_vc15.lib;libmysql.lib;libhpdf.lib;RestBed.lib;libpng.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <Manifest>
+      <AdditionalManifestFiles>meos_dpi_manifest.xml %(AdditionalManifestFiles)</AdditionalManifestFiles>
+    </Manifest>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level3</WarningLevel>
+      <DisableSpecificWarnings>4267;4244;4018</DisableSpecificWarnings>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <AdditionalIncludeDirectories>./libharu;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>Msimg32.lib;comctl32.lib;odbc32.lib;odbccp32.lib;winmm.lib;ws2_32.lib;wininet.lib;zlibstat.lib;libharu.lib;RestBed.lib;libpng.lib;libmysql.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>./lib64</AdditionalLibraryDirectories>
+    </Link>
+    <Manifest>
+      <AdditionalManifestFiles>meos_dpi_manifest.xml %(AdditionalManifestFiles)</AdditionalManifestFiles>
+    </Manifest>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="animationdata.cpp" />
+    <ClCompile Include="autocomplete.cpp" />
+    <ClCompile Include="autotask.cpp" />
+    <ClCompile Include="binencoder.cpp" />
+    <ClCompile Include="classconfiginfo.cpp" />
+    <ClCompile Include="csvparser.cpp" />
+    <ClCompile Include="download.cpp" />
+    <ClCompile Include="gdioutput.cpp" />
+    <ClCompile Include="generalresult.cpp" />
+    <ClCompile Include="HTMLWriter.cpp" />
+    <ClCompile Include="image.cpp" />
+    <ClCompile Include="importformats.cpp" />
+    <ClCompile Include="infoserver.cpp" />
+    <ClCompile Include="iof30interface.cpp" />
+    <ClCompile Include="listeditor.cpp" />
+    <ClCompile Include="liveresult.cpp" />
+    <ClCompile Include="localizer.cpp" />
+    <ClCompile Include="machinecontainer.cpp" />
+    <ClCompile Include="meos.cpp" />
+    <ClCompile Include="MeOSFeatures.cpp" />
+    <ClCompile Include="MeosSQL.cpp" />
+    <ClCompile Include="meosversion.cpp" />
+    <ClCompile Include="meos_util.cpp" />
+    <ClCompile Include="metalist.cpp" />
+    <ClCompile Include="methodeditor.cpp" />
+    <ClCompile Include="mysqldaemon.cpp" />
+    <ClCompile Include="mysqlwrapper.cpp" />
+    <ClCompile Include="newcompetition.cpp" />
+    <ClCompile Include="oBase.cpp" />
+    <ClCompile Include="oCard.cpp" />
+    <ClCompile Include="oClass.cpp" />
+    <ClCompile Include="oClub.cpp" />
+    <ClCompile Include="oControl.cpp" />
+    <ClCompile Include="oCourse.cpp" />
+    <ClCompile Include="oDataContainer.cpp" />
+    <ClCompile Include="oEvent.cpp" />
+    <ClCompile Include="oEventDraw.cpp" />
+    <ClCompile Include="oEventResult.cpp" />
+    <ClCompile Include="oEventSpeaker.cpp" />
+    <ClCompile Include="oEventSQL.cpp" />
+    <ClCompile Include="oevent_transfer.cpp" />
+    <ClCompile Include="oFreeImport.cpp" />
+    <ClCompile Include="oFreePunch.cpp" />
+    <ClCompile Include="oImportExport.cpp" />
+    <ClCompile Include="oListInfo.cpp" />
+    <ClCompile Include="onlineinput.cpp" />
+    <ClCompile Include="onlineresults.cpp" />
+    <ClCompile Include="oPunch.cpp" />
+    <ClCompile Include="oReport.cpp" />
+    <ClCompile Include="oRunner.cpp" />
+    <ClCompile Include="oTeam.cpp" />
+    <ClCompile Include="oTeamEvent.cpp" />
+    <ClCompile Include="parser.cpp" />
+    <ClCompile Include="pdfwriter.cpp" />
+    <ClCompile Include="prefseditor.cpp" />
+    <ClCompile Include="printer.cpp" />
+    <ClCompile Include="progress.cpp" />
+    <ClCompile Include="qf_editor.cpp" />
+    <ClCompile Include="qualification_final.cpp" />
+    <ClCompile Include="random.cpp" />
+    <ClCompile Include="recorder.cpp" />
+    <ClCompile Include="restserver.cpp" />
+    <ClCompile Include="RestService.cpp" />
+    <ClCompile Include="RunnerDB.cpp" />
+    <ClCompile Include="socket.cpp" />
+    <ClCompile Include="speakermonitor.cpp" />
+    <ClCompile Include="SportIdent.cpp" />
+    <ClCompile Include="StdAfx.cpp" />
+    <ClCompile Include="TabAuto.cpp" />
+    <ClCompile Include="TabBase.cpp" />
+    <ClCompile Include="TabClass.cpp" />
+    <ClCompile Include="TabClub.cpp" />
+    <ClCompile Include="TabCompetition.cpp" />
+    <ClCompile Include="TabControl.cpp" />
+    <ClCompile Include="TabCourse.cpp" />
+    <ClCompile Include="Table.cpp" />
+    <ClCompile Include="TabList.cpp" />
+    <ClCompile Include="TabMulti.cpp" />
+    <ClCompile Include="TabRunner.cpp" />
+    <ClCompile Include="TabSI.cpp" />
+    <ClCompile Include="TabSpeaker.cpp" />
+    <ClCompile Include="TabTeam.cpp" />
+    <ClCompile Include="testmeos.cpp" />
+    <ClCompile Include="tests.cpp" />
+    <ClCompile Include="TimeStamp.cpp" />
+    <ClCompile Include="toolbar.cpp" />
+    <ClCompile Include="xmlparser.cpp" />
+    <ClCompile Include="zip.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="animationdata.h" />
+    <ClInclude Include="autocomplete.h" />
+    <ClInclude Include="autocompletehandler.h" />
+    <ClInclude Include="autotask.h" />
+    <ClInclude Include="binencoder.h" />
+    <ClInclude Include="classconfiginfo.h" />
+    <ClInclude Include="csvparser.h" />
+    <ClInclude Include="download.h" />
+    <ClInclude Include="gdiconstants.h" />
+    <ClInclude Include="gdifonts.h" />
+    <ClInclude Include="gdiimpl.h" />
+    <ClInclude Include="gdioutput.h" />
+    <ClInclude Include="gdistructures.h" />
+    <ClInclude Include="generalresult.h" />
+    <ClInclude Include="guihandler.h" />
+    <ClInclude Include="HTMLWriter.h" />
+    <ClInclude Include="image.h" />
+    <ClInclude Include="importformats.h" />
+    <ClInclude Include="infoserver.h" />
+    <ClInclude Include="inthashmap.h" />
+    <ClInclude Include="intkeymap.hpp" />
+    <ClInclude Include="intkeymapimpl.hpp" />
+    <ClInclude Include="iof30interface.h" />
+    <ClInclude Include="listeditor.h" />
+    <ClInclude Include="liveresult.h" />
+    <ClInclude Include="localizer.h" />
+    <ClInclude Include="machinecontainer.h" />
+    <ClInclude Include="meos.h" />
+    <ClInclude Include="meosexception.h" />
+    <ClInclude Include="MeOSFeatures.h" />
+    <ClInclude Include="MeosSQL.h" />
+    <ClInclude Include="meos_util.h" />
+    <ClInclude Include="metalist.h" />
+    <ClInclude Include="methodeditor.h" />
+    <ClInclude Include="mysqlwrapper.h" />
+    <ClInclude Include="oBase.h" />
+    <ClInclude Include="oCard.h" />
+    <ClInclude Include="oClass.h" />
+    <ClInclude Include="oClub.h" />
+    <ClInclude Include="oControl.h" />
+    <ClInclude Include="oCourse.h" />
+    <ClInclude Include="oDataContainer.h" />
+    <ClInclude Include="oEvent.h" />
+    <ClInclude Include="oEventDraw.h" />
+    <ClInclude Include="oFreeImport.h" />
+    <ClInclude Include="oFreePunch.h" />
+    <ClInclude Include="oListInfo.h" />
+    <ClInclude Include="onlineinput.h" />
+    <ClInclude Include="onlineresults.h" />
+    <ClInclude Include="oPunch.h" />
+    <ClInclude Include="oRunner.h" />
+    <ClInclude Include="ospeaker.h" />
+    <ClInclude Include="oTeam.h" />
+    <ClInclude Include="parser.h" />
+    <ClInclude Include="pdfwriter.h" />
+    <ClInclude Include="prefseditor.h" />
+    <ClInclude Include="Printer.h" />
+    <ClInclude Include="progress.h" />
+    <ClInclude Include="qf_editor.h" />
+    <ClInclude Include="qualification_final.h" />
+    <ClInclude Include="random.h" />
+    <ClInclude Include="recorder.h" />
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="restserver.h" />
+    <ClInclude Include="RestService.h" />
+    <ClInclude Include="RunnerDB.h" />
+    <ClInclude Include="socket.h" />
+    <ClInclude Include="speakermonitor.h" />
+    <ClInclude Include="SportIdent.h" />
+    <ClInclude Include="StdAfx.h" />
+    <ClInclude Include="subcommand.h" />
+    <ClInclude Include="TabAuto.h" />
+    <ClInclude Include="TabBase.h" />
+    <ClInclude Include="TabClass.h" />
+    <ClInclude Include="TabClub.h" />
+    <ClInclude Include="TabCompetition.h" />
+    <ClInclude Include="TabControl.h" />
+    <ClInclude Include="TabCourse.h" />
+    <ClInclude Include="Table.h" />
+    <ClInclude Include="TabList.h" />
+    <ClInclude Include="TabMulti.h" />
+    <ClInclude Include="TabRunner.h" />
+    <ClInclude Include="TabSI.h" />
+    <ClInclude Include="TabSpeaker.h" />
+    <ClInclude Include="TabTeam.h" />
+    <ClInclude Include="testmeos.h" />
+    <ClInclude Include="timeconstants.hpp" />
+    <ClInclude Include="TimeStamp.h" />
+    <ClInclude Include="toolbar.h" />
+    <ClInclude Include="xmlparser.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="meos.rc" />
+    <ResourceCompile Include="meoslang.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="html1.htm" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="announcer24.png" />
+    <Image Include="bitmap1.bmp" />
+    <Image Include="bmp00001.bmp" />
+    <Image Include="class24.png" />
+    <Image Include="clubs24.png" />
+    <Image Include="competition24.png" />
+    <Image Include="course24.png" />
+    <Image Include="ctrl24.png" />
+    <Image Include="edit.png" />
+    <Image Include="info24.png" />
+    <Image Include="lists24.png" />
+    <Image Include="meos.ICO" />
+    <Image Include="meos.png" />
+    <Image Include="readout24.png" />
+    <Image Include="runner24.png" />
+    <Image Include="services24.png" />
+    <Image Include="team24.png" />
+    <Image Include="title.png" />
+    <Image Include="warn24.png" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/code/MeOSFeatures.cpp b/code/MeOSFeatures.cpp
index 119142d..a99498c 100644
--- a/code/MeOSFeatures.cpp
+++ b/code/MeOSFeatures.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/MeOSFeatures.h b/code/MeOSFeatures.h
index 29d8303..fbd189d 100644
--- a/code/MeOSFeatures.h
+++ b/code/MeOSFeatures.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/MeosSQL.cpp b/code/MeosSQL.cpp
index 4dbd024..1359d7f 100644
--- a/code/MeosSQL.cpp
+++ b/code/MeosSQL.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -470,6 +470,12 @@ void MeosSQL::upgradeDB(const string &db, oDataContainer const * dc) {
       sql = sql.substr(0, sql.length() - 2);
       query.execute(sql);
     }
+    if (!eCol.count("Origin")) {
+      string sql = "ALTER TABLE " + db + " ";
+      sql += "ADD COLUMN " + C_INT("Origin");
+      sql = sql.substr(0, sql.length() - 2);
+      query.execute(sql);
+    }
   }
   if (dc) {
     // Ugrade table
@@ -700,7 +706,8 @@ bool MeosSQL::openDB(oEvent *oe)
       << C_INT("CardNo")
       << C_INT("Time")
       << C_INT("Type")
-      << C_INT("Unit") << C_END();
+      << C_INT("Unit") 
+      << C_INT("Origin") << C_END();
     query.execute();
 
     upgradeDB("oPunch", nullptr);
@@ -1622,6 +1629,8 @@ void MeosSQL::storePunch(const RowWrapper &row, oFreePunch &p, bool rehash)
     p.type = row["Type"];
   }
   p.punchUnit = row["Unit"];
+  p.origin = row["Origin"];
+
   p.sqlUpdated = row["Modified"];
   p.counter = row["Counter"];
   p.Removed = row["Removed"];
@@ -2953,6 +2962,7 @@ OpFailStatus MeosSQL::syncUpdate(oFreePunch *c, bool forceWriteAll)
   queryset << " CardNo=" <<  c->CardNo << ", "
     << " Type=" << c->type << ","
     << " Time=" << c->punchTime << ","
+    << " Origin=" << c->origin << ","
     << " Unit=" << c->punchUnit;
 
   return syncUpdate(queryset, "oPunch", c);
diff --git a/code/MeosSQL.h b/code/MeosSQL.h
index fccd011..ec5fa1e 100644
--- a/code/MeosSQL.h
+++ b/code/MeosSQL.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/Printer.h b/code/Printer.h
index 53bb1d5..1a04809 100644
--- a/code/Printer.h
+++ b/code/Printer.h
@@ -4,7 +4,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/RestService.cpp b/code/RestService.cpp
index 6c20fd1..2c19671 100644
--- a/code/RestService.cpp
+++ b/code/RestService.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -28,7 +28,7 @@
 
 #include <ShellAPI.h>
 
-int AutomaticCB(gdioutput *gdi, int type, void *data);
+int AutomaticCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 
 RestService::RestService() : AutoMachine("Informationsserver", Machines::mInfoService), port(-1) {
 }
@@ -88,12 +88,12 @@ void RestService::settings(gdioutput &gdi, oEvent &oe, State state) {
   gdi.pushX();
   gdi.addCheckbox("AllowEntry", "Tillåt anmälan", 0, false).setHandler(this);
   gdi.addSelection("PermissionPerson", 180, 200, 0, L"Vem får anmäla sig:");
-  gdi.addItem("PermissionPerson", RestServer::getPermissionsPersons());
+  gdi.setItems("PermissionPerson", RestServer::getPermissionsPersons());
   gdi.autoGrow("PermissionPerson");
   gdi.selectFirstItem("PermissionPerson");
   gdi.fillDown();
   gdi.addSelection("PermissionClass", 180, 200, 0, L"Till vilka klasser:");
-  gdi.addItem("PermissionClass", RestServer::getPermissionsClass());
+  gdi.setItems("PermissionClass", RestServer::getPermissionsClass());
   gdi.autoGrow("PermissionClass");
   gdi.selectFirstItem("PermissionClass");
   bool disablePermisson = true;
diff --git a/code/RestService.h b/code/RestService.h
index 2310cf4..38a76ed 100644
--- a/code/RestService.h
+++ b/code/RestService.h
@@ -1,6 +1,6 @@
 /************************************************************************
 MeOS - Orienteering Software
-Copyright (C) 2009-2023 Melin Software HB
+Copyright (C) 2009-2024 Melin Software HB
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
diff --git a/code/RunnerDB.cpp b/code/RunnerDB.cpp
index 85186b7..658858e 100644
--- a/code/RunnerDB.cpp
+++ b/code/RunnerDB.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -464,7 +464,7 @@ void RunnerDB::compactifyClubs()
           ba=nba;
         }
       }
-      swap(ref, *best);
+      std::swap(ref, *best);
 
       //Update map
       for (size_t j=0;j<compacted.size();j++) {
@@ -789,7 +789,7 @@ string RunnerDB::getDataDate() const
 
 void RunnerDB::setDataDate(const string &date)
 {
-   int d = convertDateYMS(date.substr(0, 10), false);
+   int d = convertDateYMD(date.substr(0, 10), false);
    int t = date.length()>11 ? convertAbsoluteTimeHMS(date.substr(11), -1) : 0;
 
    if (d<=0)
@@ -1960,7 +1960,7 @@ const wstring& RunnerDBEntry::getBirthDate() const {
 
 void RunnerDBEntry::setBirthDate(const wstring& in) {
   SYSTEMTIME st;
-  if (convertDateYMS(in, st, true) > 0) {
+  if (convertDateYMD(in, st, true) > 0) {
     setBirthYear(st.wYear);
     setBirthMonth(st.wMonth);
     setBirthDay(st.wDay);
diff --git a/code/RunnerDB.h b/code/RunnerDB.h
index e7750e8..ef2749c 100644
--- a/code/RunnerDB.h
+++ b/code/RunnerDB.h
@@ -11,7 +11,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -385,7 +385,7 @@ private:
 protected:
   /** Get internal data buffers for DI */
   oDataContainer &getDataBuffers(pvoid &data, pvoid &olddata, pvectorstr &strData) const;
-  int getDISize() const {return 0;}
+  int getDISize() const final {return 0;}
   void changedObject() {}
 public:
   void merge(const oBase &input, const oBase * base) final {}
diff --git a/code/SportIdent.cpp b/code/SportIdent.cpp
index 5d92b42..f8e8f93 100644
--- a/code/SportIdent.cpp
+++ b/code/SportIdent.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -1858,7 +1858,7 @@ bool SportIdent::getCard6Data(BYTE *data, SICard &card)
   }
 
   string2Wide(lastNameByte, lastName);
-  wcsncpy(card.lastName, lastName.c_str(), 20);
+  wcsncpy_s(card.lastName, lastName.c_str(), 20);
   card.lastName[20] = 0;
 
   memcpy(firstNameByte, data+32+20, 20);
@@ -1869,7 +1869,7 @@ bool SportIdent::getCard6Data(BYTE *data, SICard &card)
   }
 
   string2Wide(firstNameByte, firstName);
-  wcsncpy(card.firstName, firstName.c_str(), 20);
+  wcsncpy_s(card.firstName, firstName.c_str(), 20);
   card.firstName[20] = 0;
 
   data+=128-16;
diff --git a/code/SportIdent.h b/code/SportIdent.h
index 580d93c..f493c78 100644
--- a/code/SportIdent.h
+++ b/code/SportIdent.h
@@ -9,7 +9,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -96,6 +96,9 @@ struct SICard
   int relativeFinishTime;
   bool statusOK;
   bool statusDNF;
+
+  // 
+  bool isDebugCard = false;
   vector<string> codeLogData(gdioutput &converter, int row) const;
   static vector<string> logHeader();
 
diff --git a/code/StdAfx.h b/code/StdAfx.h
index c32655d..09be943 100644
--- a/code/StdAfx.h
+++ b/code/StdAfx.h
@@ -1,9 +1,13 @@
 #pragma once
 
 #define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers
-
 #define NOMINMAX
 
+#include <winsdkver.h>  
+#define WINVER 0x0A00
+#define _WIN32_WINNT 0x0601 // Target Windows 7.
+#include <sdkddkver.h>
+
 #include <windows.h>
 #include <commctrl.h>
 #include "timeconstants.hpp"
@@ -20,8 +24,34 @@
 #include <string>
 #include <fstream>
 #include <list>
+#include <vector>
+#include <map>
+#include <set>
+#include <unordered_set>
+#include <unordered_map>
+#include <deque>
+#include <algorithm>
+
+using std::shared_ptr;
+using std::string;
+using std::wstring;
+using std::vector;
+using std::list;
+using std::map;
+using std::set;
+using std::pair;
+using std::make_pair;
+using std::make_shared;
+using std::unordered_set;
+using std::unordered_map;
+using std::min;
+using std::max;
+using std::numeric_limits;
+using std::multimap;
+using std::unique_ptr;
+using std::deque;
+using std::tuple;
 
-using namespace std;
 bool getUserFile(wchar_t *fileNamePath, const wchar_t *fileName);
 bool getDesktopFile(wchar_t *fileNamePath, const wchar_t *fileName, const wchar_t *subFolder = 0);
 bool getMeOSFile(wchar_t *FileNamePath, const wchar_t *FileName);
diff --git a/code/TabAuto.cpp b/code/TabAuto.cpp
index 4f902b6..fe7c80b 100644
--- a/code/TabAuto.cpp
+++ b/code/TabAuto.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -163,8 +163,7 @@ void tabForceSync(gdioutput &gdi, pEvent oe) {
     tabAuto->syncCallback(gdi);
 }
 
-int AutomaticCB(gdioutput *gdi, int type, void *data)
-{
+int AutomaticCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   if (!tabAuto)
     throw std::exception("tabAuto undefined.");
 
@@ -178,6 +177,10 @@ int AutomaticCB(gdioutput *gdi, int type, void *data)
       ListBoxInfo lbi=*static_cast<ListBoxInfo *>(data);
       return tabAuto->processListBox(*gdi, lbi);
              }
+
+    case GuiEventType::GUI_POSTCLEAR:
+    case GuiEventType::GUI_CLEAR:
+      return tabAuto->clearPage(*gdi, type == GUI_POSTCLEAR);
   }
   return 0;
 }
@@ -289,11 +292,47 @@ void TabAuto::setTimer(AutoMachine *am)
   }
 }
 
+
+bool TabAuto::clearPage(gdioutput &gdi, bool postClear) {
+  if (!postClear) {
+    if (wasSaved) {
+      AutoMachine* sm = getMachine(currentMachineEditId);
+      if (sm && wasCreated)
+        stopMachine(sm);
+    }
+    else {
+      auto ans = gdi.askCancel(wasCreated ? L"Vill du starta automaten?" : L"Vill du spara ändringar?");
+      if (ans == gdioutput::AskAnswer::AnswerCancel)
+        return false;
+      else {
+        AutoMachine* sm = getMachine(currentMachineEditId);
+        if (sm) {
+          if (ans == gdioutput::AskAnswer::AnswerYes) {
+            sm->save(*oe, gdi, true);
+            setTimer(sm);
+            updateSyncInfo();
+          }
+          else {
+            if (wasCreated)
+              stopMachine(sm);
+          }
+        }
+        return true;
+      }
+    }
+  }
+  else {
+    currentMachineEditId = -1;
+    wasSaved = false;
+    wasCreated = false;
+  }
+  return true;
+}
+
 int TabAuto::processButton(gdioutput &gdi, const ButtonInfo &bu)
 {
 
   if (bu.id=="GenerateCMP") {
-#ifndef MEOSDB
     int nClass=gdi.getTextNo("nClass");
     int nRunner=gdi.getTextNo("nRunner");
 
@@ -303,7 +342,6 @@ int TabAuto::processButton(gdioutput &gdi, const ButtonInfo &bu)
       gdi.getTabs().get(TCmpTab)->loadPage(gdi);
       return 0;
     }
-#endif
   }
   else if (bu.id == "BrowseFolder") {
     const wchar_t *edit = bu.getExtra();
@@ -399,6 +437,7 @@ int TabAuto::processButton(gdioutput &gdi, const ButtonInfo &bu)
     if (gdi.hasWidget("Interval"))
       iv = gdi.getText("Interval");
     sm->saveMachine(*oe, iv);
+    wasSaved = true;
     oe->updateChanged();
     oe->synchronize(false);
   }
@@ -500,42 +539,46 @@ bool TabAuto::stopMachine(AutoMachine *am)
   return false;
 }
 
-void TabAuto::settings(gdioutput &gdi, AutoMachine *sm, AutoMachine::State state, Machines ms) {
-    editMode=true;
-    if (sm) {
-      if (state == AutoMachine::State::Create)
-        state = AutoMachine::State::Edit;
+void TabAuto::settings(gdioutput& gdi, AutoMachine* sm, AutoMachine::State state, Machines ms) {
+  editMode = true;
+  if (sm) {
+    if (state == AutoMachine::State::Create)
+      state = AutoMachine::State::Edit;
 
-      ms = sm->getType();
-    }
-    else {
-      state = AutoMachine::State::Create;
-      sm = AutoMachine::construct(ms);
-      machines.push_back(sm);
-    }
+    ms = sm->getType();
+  }
+  else {
+    state = AutoMachine::State::Create;
+    sm = AutoMachine::construct(ms);
+    machines.push_back(sm);
+  }
 
-    gdi.restore("", false);
-    gdi.dropLine();
-    int cx = gdi.getCX();
-    int cy = gdi.getCY();
-    int d = gdi.scaleLength(6);
-    gdi.setCX(cx + d);
-    sm->setEditMode(true);
-    sm->settings(gdi, *oe, state);
-    int w = gdi.getWidth();
-    int h = gdi.getHeight();
+  gdi.restore("", false);
+  gdi.dropLine();
+  int cx = gdi.getCX();
+  int cy = gdi.getCY();
+  int d = gdi.scaleLength(6);
+  gdi.setCX(cx + d);
+  sm->setEditMode(true);
+  sm->settings(gdi, *oe, state);
+  int w = gdi.getWidth();
+  int h = gdi.getHeight();
 
-    RECT rc;
-    rc.top = cy - d;
-    rc.bottom = h + d;
-    rc.left = cx - d;
-    rc.right = w + d;
-    gdi.addRectangle(rc, colorLightBlue, true, true);
-    gdi.refresh();
+  RECT rc;
+  rc.top = cy - d;
+  rc.bottom = h + d;
+  rc.left = cx - d;
+  rc.right = w + d;
+  gdi.addRectangle(rc, colorLightBlue, true, true);
+  gdi.setOnClearCb(AutomaticCB);
+  gdi.setPostClearCb(AutomaticCB);
+  currentMachineEditId = sm->getId();
+  wasCreated = (state == AutoMachine::State::Create) || (state == AutoMachine::State::Load);
+  wasSaved = false;
+  gdi.refresh();
 }
 
-void TabAuto::killMachines()
-{
+void TabAuto::killMachines() {
   while(!machines.empty()) {
     machines.back()->stop();
     delete machines.back();
@@ -544,8 +587,7 @@ void TabAuto::killMachines()
   AutoMachine::resetGlobalId();
 }
 
-bool TabAuto::loadPage(gdioutput &gdi, bool showSettingsLast)
-{
+bool TabAuto::loadPage(gdioutput &gdi, bool showSettingsLast) {
   oe->checkDB();
   oe->synchronize();
   tabAuto=this;
@@ -773,7 +815,7 @@ void PrintResultMachine::settings(gdioutput &gdi, oEvent &oe, State state) {
     gdi.pushX();
     gdi.fillDown();
     vector< pair<wstring, size_t> > d;
-    gdi.addItem("Classes", oe.fillClasses(d, oEvent::extraNone, oEvent::filterNone));
+    gdi.setItems("Classes", oe.fillClasses(d, oEvent::extraNone, oEvent::filterNone));
     gdi.setSelection("Classes", classesToPrint);
 
     gdi.addSelection("ListType", 200, 100, 0, L"Lista");
@@ -797,7 +839,7 @@ void PrintResultMachine::settings(gdioutput &gdi, oEvent &oe, State state) {
     set<int> clsUnused;
     vector< pair<wstring, size_t> > out;
     oe.fillLegNumbers(clsUnused, listInfo.isTeamList(), true, out);
-    gdi.addItem("LegNumber", out);
+    gdi.setItems("LegNumber", out);
     gdi.selectItemByData("LegNumber", listInfo.getLegNumberCoded());
 
     gdi.addCheckbox("PageBreak", "Sidbrytning mellan klasser", 0, pageBreak);
@@ -981,7 +1023,7 @@ void PrewarningMachine::settings(gdioutput &gdi, oEvent &oe, State state) {
   gdi.fillDown();
   vector< pair<wstring, size_t> > d;
   oe.fillControls(d, oEvent::ControlType::CourseControl);
-  gdi.addItem("Controls", d);
+  gdi.setItems("Controls", d);
   gdi.setSelection("Controls", controls);
   gdi.popX();
   gdi.addButton("SelectAll", "Välj alla", AutomaticCB, "").setExtra(L"Controls");
@@ -1205,7 +1247,7 @@ void SplitsMachine::save(oEvent &oe, gdioutput &gdi, bool doProcess) {
   if (doProcess) {
     //Try exporting.
     oe.exportIOFSplits(oEvent::IOF20, file.c_str(), true, false,
-                       set<int>(), -1, false, true, true, false, false);
+                       set<int>(), make_pair("",""), -1, false, true, true, false, false);
     interval = iv;
     synchronize = true;
   }
@@ -1244,7 +1286,8 @@ void SplitsMachine::process(gdioutput &gdi, oEvent *oe, AutoSyncType ast)
 {
   if ((interval>0 && ast==SyncTimer) || (interval==0 && ast==SyncDataUp)) {
     if (!file.empty())
-      oe->exportIOFSplits(oEvent::IOF20, file.c_str(), true, false, classes,
+      oe->exportIOFSplits(oEvent::IOF20, file.c_str(),
+                          true, false, classes, make_pair("", ""),
                           leg, false, true, true, false, false);
   }
 }
diff --git a/code/TabAuto.h b/code/TabAuto.h
index ce8223f..415ded4 100644
--- a/code/TabAuto.h
+++ b/code/TabAuto.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -311,12 +311,12 @@ class TabAuto :
   public TabBase
 {
 private:
-  //DWORD printResultIntervalSec;
-  //DWORD printResultTimeOut;
-  bool editMode;
-
-  bool synchronize;
-  bool synchronizePunches;
+  bool editMode = false;
+  int currentMachineEditId = -1;
+  bool wasCreated = false;
+  bool wasSaved = false;
+  bool synchronize = false;
+  bool synchronizePunches = false;
   void updateSyncInfo();
 
   list<AutoMachine *> machines;
@@ -336,6 +336,7 @@ public:
   AutoMachine *getMachine(int id);
   bool stopMachine(AutoMachine *am);
   void killMachines();
+  bool clearPage(gdioutput &gdi, bool postClear);
 
   AutoMachine &addMachine(const AutoMachine &am) {
     machines.push_back(am.clone());
diff --git a/code/TabBase.cpp b/code/TabBase.cpp
index 369acba..c067378 100644
--- a/code/TabBase.cpp
+++ b/code/TabBase.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -190,19 +190,6 @@ void FixedTabs::clearCompetitionData() {
     tabs[k]->clearCompetitionData();
 }
 
-
-TabObject::TabObject(TabBase *t)
-{
-  tab = t;
-  tab->tabId = id;
-}
-
-TabObject::~TabObject()
-{
-  //delete tab;
-}
-
-
 bool TabObject::loadPage(gdioutput &gdi)
 {
   if (tab)
diff --git a/code/TabBase.h b/code/TabBase.h
index 2916f27..9164d1f 100644
--- a/code/TabBase.h
+++ b/code/TabBase.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -74,42 +74,23 @@ public:
 class TabObject
 {
 protected:
-  mutable TabBase *tab;
+  TabBase * const tab = nullptr;
 
 public:
-  string name;
-  int id;
+  const string name;
+  const int imageId = -1;
+  int id = -1;
 
-  TabObject(TabBase *t, string n):name(n),tab(t) {}
+  TabObject(TabBase *t, string n, int imageId) : name(n), tab(t), imageId(imageId) {}
 
   void setId(int i){id=i; if (tab) tab->tabId=id;}
-  void setPage(TabBase *tb){delete tab; tab=tb;}
-
+  
   const type_info &getType() const {return typeid(*tab);}
   const TabBase &getTab() const {return *tab;}
-  TabObject(const TabObject &t)
-  {
-    if (&t!=this) {
-      name=t.name;
-      id=t.id;
-      tab=t.tab;
-      //t.tab=0;
-    }
-  }
 
-  TabObject &operator=(TabObject &t)
-  {
-    if (&t!=this) {
-      delete tab;
-      name=t.name;
-      id=t.id;
-      tab=t.tab;
-      //t.tab=0;
-    }
-  }
-
-  TabObject(TabBase *t);
-  ~TabObject();
+  TabObject(const TabObject& t) = delete;
+  TabObject& operator=(TabObject& t) = delete;
+  ~TabObject() = default;
 
   bool loadPage(gdioutput &gdi);
 };
diff --git a/code/TabClass.cpp b/code/TabClass.cpp
index 12951e2..821ff3b 100644
--- a/code/TabClass.cpp
+++ b/code/TabClass.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -39,6 +39,7 @@
 #include "oListInfo.h"
 #include "TabClass.h"
 #include "TabList.h"
+#include "TabRunner.h"
 #include "methodeditor.h"
 #include "ClassConfigInfo.h"
 #include "meosException.h"
@@ -47,11 +48,11 @@
 #include "MeOSFeatures.h"
 #include "qualification_final.h"
 #include "generalresult.h"
+#include "qf_editor.h"
 
 extern pEvent gEvent;
 const char *visualDrawWindow = "visualdraw";
 
-
 struct DrawSettingsCSV {
   int classId;
   wstring cls;
@@ -67,8 +68,7 @@ struct DrawSettingsCSV {
   static vector<DrawSettingsCSV> read(gdioutput &gdi, const oEvent &oe, const wstring &fn);
 };
 
-TabClass::TabClass(oEvent *poe):TabBase(poe)
-{
+TabClass::TabClass(oEvent* poe) : TabBase(poe) {
   handleCloseWindow.tabClass = this;
   clearCompetitionData();
 }
@@ -109,11 +109,11 @@ void TabClass::clearCompetitionData() {
   if (gdi) {
     gdi->closeWindow();
   }
+
+  qfEditor.reset();
 }
 
-TabClass::~TabClass(void)
-{
-}
+TabClass::~TabClass() = default;
 
 oEvent::DrawMethod TabClass::getDefaultMethod(const set<oEvent::DrawMethod> &allowedValues) const {
   oEvent::DrawMethod dm = (oEvent::DrawMethod)oe->getPropertyInt("DefaultDrawMethod", (int)oEvent::DrawMethod::MeOS);
@@ -149,20 +149,17 @@ void TabClass::HandleCloseWindow::handle(gdioutput &gdi, BaseInfo &info, GuiEven
 void TabClass::closeWindow(gdioutput &gdi) {
 }
 
-int ClassesCB(gdioutput *gdi, int type, void *data)
-{
+int ClassesCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabClass &tc = dynamic_cast<TabClass &>(*gdi->getTabs().get(TClassTab));
   return tc.classCB(*gdi, type, data);
 }
 
-int MultiCB(gdioutput *gdi, int type, void *data)
-{
+int MultiCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabClass &tc = dynamic_cast<TabClass &>(*gdi->getTabs().get(TClassTab));
   return tc.multiCB(*gdi, type, data);
 }
 
-int DrawClassesCB(gdioutput *gdi, int type, void *data)
-{
+int DrawClassesCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabClass &tc = dynamic_cast<TabClass &>(*gdi->getTabs().get(TClassTab));
   
   if (type == GUI_LISTBOX) {
@@ -204,8 +201,7 @@ int DrawClassesCB(gdioutput *gdi, int type, void *data)
 }
 
 
-int TabClass::multiCB(gdioutput &gdi, int type, void *data)
-{
+int TabClass::multiCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   if (type==GUI_BUTTON) {
     ButtonInfo bi=*(ButtonInfo *)data;
 
@@ -717,7 +713,7 @@ int TabClass::multiCB(gdioutput &gdi, int type, void *data)
         oe->getCourses(out, courseFilter, true, false);
         set<int> sel;
         gdi.getSelection("AllCourses", sel);
-        gdi.addItem("AllCourses", out);
+        gdi.setItems("AllCourses", out);
         gdi.setSelection("AllCourses", sel);
       }
     }
@@ -726,8 +722,7 @@ int TabClass::multiCB(gdioutput &gdi, int type, void *data)
   return 0;
 }
 
-int TabClass::classCB(gdioutput &gdi, int type, void *data)
-{
+int TabClass::classCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   if (type==GUI_BUTTON) {
     ButtonInfo bi=*(ButtonInfo *)data;
 
@@ -760,13 +755,16 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
         gdi.refresh();
       }
     }
-    else if (bi.id=="Restart") {
+    else if (bi.id == "DynamicStart") {
+      dynamicStart(gdi);
+    }
+    else if (bi.id == "Restart") {
       save(gdi, true);
       clearPage(gdi, true);
       gdi.addString("", 2, "Omstart i stafettklasser");
       gdi.addString("", 10, "help:31661");
       gdi.addListBox("RestartClasses", 200, 250, 0, L"Stafettklasser", L"", true);
-      oe->fillClasses(gdi, "RestartClasses", oEvent::extraNone, oEvent::filterOnlyMulti);
+      oe->fillClasses(gdi, "RestartClasses", {}, oEvent::extraNone, oEvent::filterOnlyMulti);
       gdi.pushX();
       gdi.fillRight();
       oe->updateComputerTime();
@@ -840,7 +838,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
         vector<pClass> cls;
         oe->getClasses(cls, true);
         for (pClass pc : cls) {
-          if (pc->hasFreeStart())
+          if (pc->hasFreeStart() || pc->hasRequestStart())
             continue;
           DrawSettingsCSV ds;
           ds.classId = pc->getId();
@@ -1025,7 +1023,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
         vector<pClass> cls;
         oe->getClasses(cls, true);
         for (size_t k = 0; k < cls.size(); k++) {
-          if (cls[k]->getStart() == start && !cls[k]->hasFreeStart())
+          if (cls[k]->getStart() == start && !cls[k]->hasFreeStart() && !cls[k]->hasRequestStart())
             lst.insert(cls[k]->getId());
         }
         gdi.setSelection("Classes", lst);
@@ -1278,9 +1276,8 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
 
       int nVacant = gdi.getTextNo("Vacanses");
 
-      for (set<int>::iterator it = classes.begin(); it!=classes.end();++it) {
-        simultaneous(*it, time, nVacant);
-      }
+      for (int id : classes) 
+        simultaneous(*oe, id, time, nVacant);
 
       bi.id = "Simultaneous";
       classCB(gdi, type, &bi);
@@ -1326,7 +1323,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
         oe->getClasses(cls, false);
         set<int> clsId;
         for (size_t k = 0; k < cls.size(); k++) {
-          if (cls[k]->hasFreeStart())
+          if (cls[k]->hasFreeStart() ||cls[k]->hasRequestStart())
             continue;
           if (cls[k]->getStartType(0) != STDrawn)
             continue;
@@ -1554,7 +1551,13 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
       return classCB(gdi, type, &bi);
     }
     else if (bi.id == "DrawAllBefore" || bi.id == "DrawAllAfter") {
-      oe->drawRemaining(oEvent::DrawMethod::MeOS, bi.id == "DrawAllAfter");
+      set<int> classes;
+      gdi.getSelection("Classes", classes);
+      if (classes.empty()) {
+        gdi.alert("Ingen klass vald.");
+        return 0;
+      }
+      oe->drawRemaining(classes, oEvent::DrawMethod::MeOS, bi.id == "DrawAllAfter");
       oe->addAutoBib();
       loadPage(gdi);
     }
@@ -1585,10 +1588,14 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
 
       wstring bib;
       bool doBibs = false;
-
+      bool bibToVacant = true;
       if (gdi.hasWidget("Bib")) {
         bib = gdi.getText("Bib");
         doBibs = gdi.isChecked("HandleBibs");
+        if (gdi.hasWidget("VacantBib")) {
+          bibToVacant = gdi.isChecked("VacantBib");
+          oe->getDI().setInt("NoVacantBib", bibToVacant ? 0 : 1);
+        }
       }
 
       wstring time = gdi.getText("FirstStart");
@@ -1596,7 +1603,6 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
 
       if (t<=0)
         throw std::exception("Ogiltig första starttid. Måste vara efter nolltid.");
-  
       
       oEvent::DrawType dtype(oEvent::DrawType::DrawAll);
       if (bi.id=="DoDrawAfter")
@@ -1644,7 +1650,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
                             scaleFactor);
       }
       else if (method == oEvent::DrawMethod::Simultaneous) {
-        simultaneous(cid, time, vacanses);
+        simultaneous(*oe, cid, time, vacanses);
       }
       else if (method == oEvent::DrawMethod::Seeded) {
         ListBoxInfo seedMethod;
@@ -1680,7 +1686,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
         throw std::exception("Not implemented");
 
       if (doBibs)
-        oe->addBib(cid, leg, bib);
+        oe->addBib(cid, leg, bib, bibToVacant);
 
       // Clear input
       gdi.restore("", false);
@@ -1703,6 +1709,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
     }
     else if (bi.id=="HandleBibs") {
       gdi.setInputStatus("Bib", gdi.isChecked("HandleBibs"));
+      gdi.setInputStatus("VacantBib", gdi.isChecked("HandleBibs"), true);
     }
     else if (bi.id == "DoDeleteStart") {
       pClass pc=oe->getClass(ClassId);
@@ -1783,15 +1790,26 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
     else if (bi.id == "QualificationFinal" || bi.id == "UpdateQF") {
       save(gdi, true);
       pClass pc = oe->getClass(ClassId);
-      if (!pc)
-        throw std::exception("Class not found");
+      
+      if (!qfEditor)
+        qfEditor = make_shared<QFEditor>();
 
-      vector< pair<wstring, wstring> > ext;
-      ext.push_back(make_pair(L"Qualfication/Final", L"*.xml"));
-      wstring fileName = gdi.browseForOpen(ext, L"xml");
-      pc->loadQualificationFinalScheme(fileName);
-      pc->updateFinalClasses(0, true);
-      loadPage(gdi);
+      if (pc) {
+        if (pc->getQualificationFinal()) {
+          qfEditor->load(pc->getQualificationFinal());
+          qfEditor->makeDirty(QFEditor::DirtyFlag::ClearDirty, QFEditor::DirtyFlag::MakeDirty);
+        }
+        else {
+          qfEditor->makeDirty(QFEditor::DirtyFlag::MakeDirty, QFEditor::DirtyFlag::NoTouch);
+        }
+
+        qfEditor->setClass(pc);
+      }
+      else {
+        qfEditor->setClass(nullptr);
+      }
+
+      qfEditor->show(gdi);
     }
     else if (bi.id == "RemoveQF") {
       pClass pc = oe->getClass(ClassId);
@@ -1855,7 +1873,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
       gdi.pushX();
 
       gdi.addSelection("BibSettings", 150, 100, ClassesCB, L"Metod:");
-      gdi.addItem("BibSettings", bibOptions);
+      gdi.setItems("BibSettings", bibOptions);
 
       AutoBibType bt = pc->getAutoBibType();
       gdi.selectItemByData("BibSettings", bt);
@@ -1867,7 +1885,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
         bibTeamOptions.push_back(make_pair(lang.tl("Ökande"), BibAdd));
         bibTeamOptions.push_back(make_pair(lang.tl("Sträcka"), BibLeg));
         gdi.addSelection("BibTeam", 80, 100, 0, L"Lagmedlem:", L"Ange relation mellan lagets och deltagarnas nummerlappar.");
-        gdi.addItem("BibTeam", bibTeamOptions);
+        gdi.setItems("BibTeam", bibTeamOptions);
         gdi.selectItemByData("BibTeam", pc->getBibMode());
       }
 
@@ -1878,10 +1896,19 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
       gdi.fillRight();
       gdi.popX();
       gdi.addString("", 0, "Antal reserverade nummerlappsnummer mellan klasser:");
-      gdi.dropLine(-0.1);
+      gdi.dropLine(-0.2);
       gdi.addInput("BibGap", itow(oe->getBibClassGap()), 5);
-      gdi.dropLine(3);
+      
+      gdi.dropLine(2.4);
       gdi.popX();
+
+      if (oe->getMeOSFeatures().hasFeature(MeOSFeatures::Vacancy)) {
+        bool bibToVacant = oe->getDCI().getInt("NoVacantBib") == 0;
+        gdi.addCheckbox("VacantBib", "Tilldela nummerlapp till vakanter", nullptr, bibToVacant);
+        gdi.dropLine(2.5);
+        gdi.popX();
+      }
+
       gdi.fillRight();
       gdi.addButton("DoBibs", "Tilldela", ClassesCB).setDefault();
     
@@ -1914,11 +1941,17 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
         pc->setBibMode(BibMode(teamBib.first));
       }
 
+      bool bibToVacant = true;
+      if (gdi.hasWidget("VacantBib")) {
+        bibToVacant = gdi.isChecked("VacantBib");
+        oe->getDI().setInt("NoVacantBib", bibToVacant ? 0 : 1);
+      }
+
       pc->getDI().setString("Bib", getBibCode(bt, gdi.getText("Bib")));
       pc->synchronize();
       int leg = pc->getParentClass() ? -1 : 0;
       if (bt == AutoBibManual) {
-        oe->addBib(cid, leg, gdi.getText("Bib"));
+        oe->addBib(cid, leg, gdi.getText("Bib"), bibToVacant);
       }
       else {
         oe->setBibClassGap(gdi.getTextNo("BibGap"));
@@ -1981,7 +2014,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
       
       copyClass.setName(name, true);
       pc = oe->addClass(copyClass);
-      oe->fillClasses(gdi, "Classes", oEvent::extraDrawn, oEvent::filterNone);
+      oe->fillClasses(gdi, "Classes", {}, oEvent::extraDrawn, oEvent::filterNone);
       selectClass(gdi, pc->getId());
       gdi.setInputFocus("Name", true);
     }
@@ -2041,7 +2074,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
       gdi.selectItemByData("Type", 1);
       vector< pair<wstring, size_t> > mt;
       oClass::getSplitMethods(mt);
-      gdi.addItem("Type", mt);
+      gdi.setItems("Type", mt);
       gdi.selectFirstItem("Type");
       int numSplitDef = 2;
       if (pc->getQualificationFinal()) {
@@ -2050,7 +2083,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
         gdi.dropLine(3);
         set<int> base;
         pc->getQualificationFinal()->getBaseClassInstances(base);
-        gdi.addString("", 1, "Kval/final-schema");
+        gdi.addString("", boldText| Capitalize, "Kval/final-schema");
         for (int i : base) {
           if (pc->getVirtualClass(i)) {
             gdi.addStringUT(0, pc->getVirtualClass(i)->getName());
@@ -2065,7 +2098,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
         vector< pair<wstring, size_t> > sp;
         for (int k = 2; k < 10; k++)
           sp.push_back(make_pair(itow(k), k));
-        gdi.addItem("SplitInput", sp);
+        gdi.setItems("SplitInput", sp);
         gdi.selectFirstItem("SplitInput");
         gdi.dropLine(3);
         gdi.popX();
@@ -2165,7 +2198,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
       gdi.pushX();
       gdi.fillRight();
       gdi.addSelection("Class", 150, 300, 0, L"Klass att slå ihop:");
-      gdi.addItem("Class", cls);
+      gdi.setItems("Class", cls);
       if (def != -1)
         gdi.selectItemByData("Class", def);
       else
@@ -2252,7 +2285,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
       save(gdi, true);
       pClass pc = oe->addClass(oe->getAutoClassName(), 0);
       if (pc) {
-        oe->fillClasses(gdi, "Classes", oEvent::extraDrawn, oEvent::filterNone);
+        oe->fillClasses(gdi, "Classes", {}, oEvent::extraDrawn, oEvent::filterNone);
         selectClass(gdi, pc->getId());
         gdi.setInputFocus("Name", true);
       }
@@ -2269,7 +2302,7 @@ int TabClass::classCB(gdioutput &gdi, int type, void *data)
       else
         oe->removeClass(cid);
 
-      oe->fillClasses(gdi, "Classes", oEvent::extraDrawn, oEvent::filterNone);
+      oe->fillClasses(gdi, "Classes", {}, oEvent::extraDrawn, oEvent::filterNone);
       ClassId = 0;
       selectClass(gdi, 0);
     }
@@ -2619,7 +2652,7 @@ void TabClass::showClassSettings(gdioutput &gdi)
     addVacantPosition(gdi);
 
     gdi.addSelection("PairSize", 150, 200, 0, L"Tillämpa parstart:");
-    gdi.addItem("PairSize", getPairOptions());
+    gdi.setItems("PairSize", getPairOptions());
     gdi.selectItemByData("PairSize", 1);
 
     gdi.dropLine(0.9);
@@ -2647,10 +2680,22 @@ void TabClass::showClassSettings(gdioutput &gdi)
 
 void TabClass::selectClass(gdioutput &gdi, int cid)
 {
-  oe->fillCourses(gdi, "Courses", true);
-  gdi.addItem("Courses", lang.tl("Ingen bana"), -2);
 
-  if (cid==0) {
+  pClass pc = oe->getClass(cid);
+  
+  if (gdi.hasWidget("Courses")) {    
+    vector<pair<wstring, size_t>> extraCourseTypes;
+    extraCourseTypes.emplace_back(lang.tl("Ingen bana"), -2);
+    if (pc && pc->hasTrueMultiCourse()) {
+      extraCourseTypes.emplace_back(lang.tl("Flera banor"), -3);
+    }
+    if (pc && !pc->hasTrueMultiCourse())
+      oe->fillCourses(gdi, "Courses", extraCourseTypes, true);
+    else
+      gdi.setItems("Courses", extraCourseTypes);
+  }
+
+  if (!pc) {
     gdi.restore("", true);
     gdi.disableInput("MultiCourse", true);
     if (gdi.hasWidget("Courses"))
@@ -2663,6 +2708,9 @@ void TabClass::selectClass(gdioutput &gdi, int cid)
 
     if (gdi.hasWidget("FreeStart"))
       gdi.check("FreeStart", false);
+    if (gdi.hasWidget("RequestStart"))
+      gdi.check("RequestStart", false);
+
     if (gdi.hasWidget("IgnoreStart"))
       gdi.check("IgnoreStart", false);
 
@@ -2684,12 +2732,7 @@ void TabClass::selectClass(gdioutput &gdi, int cid)
     return;
   }
 
-  pClass pc = oe->getClass(cid);
-
-  if (!pc) {
-    selectClass(gdi, 0);
-    return;
-  }
+  TabRunner::loadExtraFields(gdi, pc);
 
   gdi.enableEditControls(true);
   gdi.enableInput("Remove");
@@ -2710,7 +2753,7 @@ void TabClass::selectClass(gdioutput &gdi, int cid)
     vector< pair<wstring, size_t> > out;
     size_t selected = 0;
     pc->getDCI().fillInput("Status", out, selected);
-    gdi.addItem("Status", out);
+    gdi.setItems("Status", out);
     gdi.selectItemByData("Status", selected);
   }
 
@@ -2724,6 +2767,9 @@ void TabClass::selectClass(gdioutput &gdi, int cid)
   if (gdi.hasWidget("FreeStart"))
     gdi.check("FreeStart", pc->hasFreeStart());
 
+  if (gdi.hasWidget("RequestStart"))
+    gdi.check("RequestStart", pc->hasRequestStart());
+
   if (gdi.hasWidget("IgnoreStart"))
     gdi.check("IgnoreStart", pc->ignoreStartPunch());
 
@@ -2755,7 +2801,7 @@ void TabClass::selectClass(gdioutput &gdi, int cid)
     gdi.setCX(cx + 10);
     gdi.setCY(cy + 10);
 
-    gdi.addString("", fontMediumPlus, "Kval/final-schema");
+    gdi.addString("", fontMediumPlus | Capitalize, "Kval/final-schema");
     gdi.pushX();
     gdi.dropLine(0.3);
     gdi.fillRight();
@@ -2763,7 +2809,7 @@ void TabClass::selectClass(gdioutput &gdi, int cid)
     gdi.fillDown();
     gdi.addButton("RemoveQF", "Ta bort", ClassesCB);
     gdi.popX();
-    pc->getQualificationFinal()->printScheme(pc, gdi);
+    pc->getQualificationFinal()->printScheme(*pc, gdi);
   }
   else if (pc->hasTrueMultiCourse()) {
     gdi.restore("", false);
@@ -2772,7 +2818,6 @@ void TabClass::selectClass(gdioutput &gdi, int cid)
     gdi.refresh();
 
     if (gdi.hasWidget("Courses")) {
-      gdi.addItem("Courses", lang.tl("Flera banor"), -3);
       gdi.selectItemByData("Courses", -3);
       gdi.disableInput("Courses");
       gdi.check("CoursePool", pc->hasCoursePool());
@@ -2787,7 +2832,7 @@ void TabClass::selectClass(gdioutput &gdi, int cid)
     }
 
     if (gdi.hasWidget("MCourses")) {
-      oe->fillCourses(gdi, "MCourses", true);
+      oe->fillCourses(gdi, "MCourses", {}, true);
       string strId = "StageCourses_label";
       gdi.setTextTranslate(strId, getCourseLabel(pc->hasCoursePool()), true);
     }
@@ -2845,8 +2890,7 @@ void TabClass::selectClass(gdioutput &gdi, int cid)
   EditChanged=false;
 }
 
-void TabClass::legSetup(gdioutput &gdi)
-{
+void TabClass::legSetup(gdioutput &gdi) {
   gdi.restore("RelaySetup");
   gdi.pushX();
   gdi.fillDown();
@@ -3019,7 +3063,7 @@ void TabClass::multiCourse(gdioutput &gdi, int nLeg) {
         string multir(string("MultiR")+legno);
         headXPos[4]=gdi.getCX();
         gdi.addSelection(multir, 60, 200, MultiCB);
-        gdi.addItem(multir, legs);
+        gdi.setItems(multir, legs);
       }
       if (hasRelay) {
         headXPos[5]=gdi.getCX();
@@ -3160,6 +3204,9 @@ void TabClass::save(gdioutput &gdi, bool skipReload)
   if (gdi.hasWidget("FreeStart"))
     pc->setFreeStart(gdi.isChecked("FreeStart"));
 
+  if (gdi.hasWidget("RequestStart"))
+    pc->setRequestStart(gdi.isChecked("RequestStart"));
+
   if (gdi.hasWidget("IgnoreStart"))
     pc->setIgnoreStartPunch(gdi.isChecked("IgnoreStart"));
 
@@ -3177,6 +3224,8 @@ void TabClass::save(gdioutput &gdi, bool skipReload)
     pc->setDirectResult(withDirect);
   }
 
+  TabRunner::saveExtraFields(gdi, *pc);
+
   if (gdi.hasWidget("LockStartList")) {
     bool locked = gdi.isChecked("LockStartList");
     if (pc->getParentClass())
@@ -3278,7 +3327,7 @@ void TabClass::save(gdioutput &gdi, bool skipReload)
   cls.insert(pc->getId());
   oe->reEvaluateAll(cls, true);
 
-  oe->fillClasses(gdi, "Classes", oEvent::extraDrawn, oEvent::filterNone);
+  oe->fillClasses(gdi, "Classes", {}, oEvent::extraDrawn, oEvent::filterNone);
   EditChanged=false;
   if (!skipReload) {
     ClassId = 0;
@@ -3351,11 +3400,12 @@ bool TabClass::loadPage(gdioutput &gdi)
   gdi.fillDown();
   gdi.addListBox("Classes", 200, showAdvanced ? 512 : 420, ClassesCB, L"").isEdit(false).ignore(true);
   gdi.setTabStops("Classes", 170);
-  oe->fillClasses(gdi, "Classes", oEvent::extraDrawn, oEvent::filterNone);
+  oe->fillClasses(gdi, "Classes", {}, oEvent::extraDrawn, oEvent::filterNone);
 
 
   bool hasIgnoreStart = false;
   bool hasFreeStart = false;
+  bool hasRequestStart = false;
 
   if (!showAdvanced) {
     vector<pClass> clsList;
@@ -3365,6 +3415,8 @@ bool TabClass::loadPage(gdioutput &gdi)
         hasIgnoreStart = true;
       if (c->hasFreeStart())
         hasFreeStart = true;
+      if (c->hasRequestStart())
+        hasRequestStart = true;
     }
   }
 
@@ -3392,8 +3444,6 @@ bool TabClass::loadPage(gdioutput &gdi)
   }
   if (useCourse) {
     gdi.addSelection("Courses", 120, 400, ClassesCB, L"Bana:");
-    oe->fillCourses(gdi, "Courses", true);
-    gdi.addItem("Courses", lang.tl("Ingen bana"), -2);
   }
   if (showMulti(false)) {
     gdi.dropLine(0.9);
@@ -3430,7 +3480,7 @@ bool TabClass::loadPage(gdioutput &gdi)
     vector< pair<wstring, size_t> > st;
     for (auto &sc : statusClass)
       st.emplace_back(lang.tl(sc.second), st.size());
-    gdi.addItem("Status", st);
+    gdi.setItems("Status", st);
     gdi.autoGrow("Status");
     gdi.popX();
   }
@@ -3461,13 +3511,16 @@ bool TabClass::loadPage(gdioutput &gdi)
     gdi.addCheckbox("NoTiming", "Utan tidtagning", 0);
   }
 
-  if (showAdvanced || hasIgnoreStart || hasFreeStart) {
+  if (showAdvanced || hasIgnoreStart || hasFreeStart || hasRequestStart) {
     gdi.dropLine(2);
     gdi.popX();
 
     if (showAdvanced || hasFreeStart) 
       gdi.addCheckbox("FreeStart", "Fri starttid", 0, false, "Klassen lottas inte, startstämpling");
     
+    if (showAdvanced || hasRequestStart)
+      gdi.addCheckbox("RequestStart", "Boka starttid", 0, false, "Klassen lottas inte, boka starttid");
+
     if (showAdvanced || hasIgnoreStart)
       gdi.addCheckbox("IgnoreStart", "Ignorera startstämpling", 0, false, "Uppdatera inte starttiden vid startstämpling");
     gdi.dropLine(2);
@@ -3479,9 +3532,12 @@ bool TabClass::loadPage(gdioutput &gdi)
                     "help:DirectResult");
   }
   
-  gdi.dropLine(2);
   gdi.popX();
 
+  TabRunner::addExtraFields(*oe, gdi, oEvent::ExtraFieldContext::Class);
+
+  gdi.dropLine(1.5);
+
   {
     vector<pClass> pcls;
     oe->getClasses(pcls, false);
@@ -3502,16 +3558,19 @@ bool TabClass::loadPage(gdioutput &gdi)
   }
   vector<ButtonData> func;
   if (oe->getMeOSFeatures().hasFeature(MeOSFeatures::DrawStartList))
-    func.push_back(ButtonData("Draw", "Lotta / starttider...", false));
+    func.emplace_back("Draw", "Lotta / starttider...", false);
 
   if (oe->getMeOSFeatures().hasFeature(MeOSFeatures::Bib))
-    func.push_back(ButtonData("Bibs", "Nummerlappar...", false));
+    func.emplace_back("Bibs", "Nummerlappar...", false);
 
   if (oe->getMeOSFeatures().hasFeature(MeOSFeatures::DrawStartList))
-    func.push_back(ButtonData("DrawMode", "Lotta flera klasser", true));
+    func.emplace_back("DrawMode", "Lotta flera klasser", true);
   
+  if (showAdvanced)
+    func.emplace_back("DynamicStart", "Start på signal...", true);
+
   if (cnf.hasTeamClass()) {
-    func.push_back(ButtonData("Restart", "Omstart...", true));
+    func.emplace_back("Restart", "Omstart...", true);
 
     vector<pClass> allCls;
     oe->getClasses(allCls, false);
@@ -3532,17 +3591,17 @@ bool TabClass::loadPage(gdioutput &gdi)
       }
 
       if (unlockedClass) {
-        func.push_back(ButtonData("LockAllForks", "Lås gafflingar", true));
+        func.emplace_back("LockAllForks", "Lås gafflingar", true);
       }
       if (lockedClass) {
-        func.push_back(ButtonData("UnLockAllForks", "Tillåt gafflingsändringar", true));
+        func.emplace_back("UnLockAllForks", "Tillåt gafflingsändringar", true);
       }
     }
   }
 
   if (showAdvanced) {
-    func.push_back(ButtonData("Merge", "Slå ihop klasser...", false));
-    func.push_back(ButtonData("Split", "Dela klassen...", false));
+    func.emplace_back("Merge", "Slå ihop klasser...", false);
+    func.emplace_back("Split", "Dela klassen...", false);
   }
   func.emplace_back("Duplicate", "Duplicera", false);
 
@@ -3557,16 +3616,16 @@ bool TabClass::loadPage(gdioutput &gdi)
       }
     }
     if (hasVac)
-      func.push_back(ButtonData("RemoveVacant", "Radera vakanser", true));
+      func.emplace_back("RemoveVacant", "Radera vakanser", true);
   }
 
-  func.push_back(ButtonData("QuickSettings", "Snabbinställningar", true));
+  func.emplace_back("QuickSettings", "Snabbinställningar", true);
 
   if (oe->getMeOSFeatures().hasFeature(MeOSFeatures::MultipleRaces))
-    func.push_back(ButtonData("QualificationFinal", "Kval/final-schema", false));
+    func.emplace_back("QualificationFinal", "Kval/final-schema", false);
 
   if (showAdvanced || oe->getStartGroups(true).size() > 0) 
-    func.push_back(ButtonData("StartGroups", "Startgrupper", true));
+    func.emplace_back("StartGroups", "Startgrupper", true);
 
   RECT funRect;
   funRect.right = gdi.getCX() - 7;
@@ -3642,8 +3701,7 @@ bool TabClass::showMulti(bool singleOnly) const {
     return mf.hasFeature(MeOSFeatures::Relay) || mf.hasFeature(MeOSFeatures::Patrol) ||  mf.hasFeature(MeOSFeatures::MultipleRaces);
 }
 
-static int classSettingsCB(gdioutput *gdi, int type, void *data)
-{
+static int classSettingsCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabClass &tc = dynamic_cast<TabClass &>(*gdi->getTabs().get(TClassTab));
 
   static wstring lastStart = L"Start 1";
@@ -3691,6 +3749,16 @@ void TabClass::saveClassSettingsTable(gdioutput &gdi) {
     }
   }
   
+  if (gdi.hasWidget("VacantBib")) {
+    bool vacantBib = gdi.isChecked("VacantBib");
+    bool vacantBibStored = oe->getDCI().getInt("NoVacantBib") == 0;
+
+    if (vacantBib != vacantBibStored) {
+      oe->getDI().setInt("NoVacantBib", vacantBib ? 0 : 1);
+      modifiedBib = true;
+    }
+  }
+
   if (!modifiedFee.empty() && oe->getNumRunners() > 0) {
     bool updateFee = gdi.ask(L"ask:changedclassfee");
 
@@ -3724,10 +3792,18 @@ void TabClass::prepareForDrawing(gdioutput &gdi) {
   if (oe->getMeOSFeatures().hasFeature(MeOSFeatures::Bib)) {
     gdi.fillRight();
     gdi.addString("", 0, "Antal reserverade nummerlappsnummer mellan klasser:");
-    gdi.dropLine(-0.1);
+    gdi.dropLine(-0.2);
     gdi.addInput("BibGap", itow(oe->getBibClassGap()), 5);
+    
+    if (oe->getMeOSFeatures().hasFeature(MeOSFeatures::Vacancy)) {
+      bool bibToVacant = oe->getDCI().getInt("NoVacantBib") == 0;
+      gdi.dropLine(0.2);
+      gdi.setCX(gdi.getCX() + gdi.scaleLength(15));
+      gdi.addCheckbox("VacantBib", "Tilldela nummerlapp till vakanter", nullptr, bibToVacant);
+    }
+    
     gdi.popX();
-    gdi.dropLine(1.5);
+    gdi.dropLine(2.4);
     gdi.fillDown();
   }
 
@@ -3798,7 +3874,7 @@ void TabClass::drawDialog(gdioutput &gdi, oEvent::DrawMethod method, const oClas
     ListBoxInfo &seedmethod = gdi.addSelection("SeedMethod", 120, 100, 0, L"Seedningskälla:");
     vector< pair<wstring, size_t> > methods;
     oClass::getSeedingMethods(methods);
-    gdi.addItem("SeedMethod", methods);
+    gdi.setItems("SeedMethod", methods);
     if (lastSeedMethod == -1)
       gdi.selectFirstItem("SeedMethod");
     else
@@ -3824,7 +3900,7 @@ void TabClass::drawDialog(gdioutput &gdi, oEvent::DrawMethod method, const oClas
   if (method == oEvent::DrawMethod::Random || method == oEvent::DrawMethod::SOFT || method == oEvent::DrawMethod::Pursuit
       || method == oEvent::DrawMethod::ReversePursuit || method == oEvent::DrawMethod::Seeded || method == oEvent::DrawMethod::MeOS) {
     gdi.addSelection("PairSize", 150, 200, 0, L"Tillämpa parstart:").setSynchData(&lastPairSize);
-    gdi.addItem("PairSize", getPairOptions());
+    gdi.setItems("PairSize", getPairOptions());
     gdi.selectItemByData("PairSize", pairSize);
   }
   gdi.fillRight();
@@ -3868,7 +3944,15 @@ void TabClass::drawDialog(gdioutput &gdi, oEvent::DrawMethod method, const oClas
     gdi.addCheckbox("HandleBibs", "Tilldela nummerlappar:", ClassesCB, lastHandleBibs).setSynchData(&lastHandleBibs);
     gdi.dropLine(-0.2);
     gdi.addInput("Bib", L"", 10, 0, L"", L"Mata in första nummerlappsnummer, eller blankt för att ta bort nummerlappar");
-    gdi.setInputStatus("Bib", lastHandleBibs);
+    
+    if (oe->getMeOSFeatures().hasFeature(MeOSFeatures::Vacancy)) {
+      bool bibToVacant = oe->getDCI().getInt("NoVacantBib") == 0;
+      gdi.dropLine(0.2);
+      gdi.addCheckbox("VacantBib", "Tilldela nummerlapp till vakanter", nullptr, bibToVacant);
+      gdi.setInputStatus("VacantBib", lastHandleBibs);
+    }
+
+    gdi.setInputStatus("Bib", lastHandleBibs);    
     gdi.fillDown();
     gdi.dropLine(2.5);
     gdi.popX();
@@ -3915,7 +3999,7 @@ void TabClass::addVacantPosition(gdioutput &gdi) {
   vp.emplace_back(lang.tl("Lottat"), size_t(oEvent::VacantPosition::Mixed));
   vp.emplace_back(lang.tl("Först"), size_t(oEvent::VacantPosition::First));
   vp.emplace_back(lang.tl("Sist"), size_t(oEvent::VacantPosition::Last));
-  gdi.addItem("VacantPosition", vp);
+  gdi.setItems("VacantPosition", vp);
   int def = oe->getPropertyInt("VacantPosition", size_t(oEvent::VacantPosition::Mixed));
   gdi.selectItemByData("VacantPosition", def);
 }
@@ -3968,6 +4052,7 @@ void TabClass::setMultiDayClass(gdioutput &gdi, bool hasMulti, oEvent::DrawMetho
     if (hasMulti) {
       gdi.check("HandleBibs", false);
       gdi.setInputStatus("Bib", false);
+      gdi.setInputStatus("VacantBib", false, true);
     }
   }
 
@@ -4003,7 +4088,7 @@ void TabClass::pursuitDialog(gdioutput &gdi) {
   //xxx 
   //gdi.addCheckbox("Pairwise", "Tillämpa parstart", 0, false);
   gdi.addSelection("PairSize", 150, 200, 0, L"Tillämpa parstart:");
-  gdi.addItem("PairSize", getPairOptions());
+  gdi.setItems("PairSize", getPairOptions());
   gdi.selectItemByData("PairSize", 1);
 
   int cx = gdi.getCX();
@@ -4120,7 +4205,7 @@ void TabClass::showClassSelection(gdioutput &gdi, int &bx, int &by, GUICALLBACK
     gdi.fillDown();
   }
 
-  oe->fillClasses(gdi, "Classes", oEvent::extraDrawn, oEvent::filterNone);
+  oe->fillClasses(gdi, "Classes", {}, oEvent::extraDrawn, oEvent::filterNone);
 
   by = gdi.getCY()+gdi.getLineHeight();
   bx = gdi.getCX();
@@ -4154,8 +4239,8 @@ void TabClass::enableLoadSettings(gdioutput &gdi) {
 }
 
 
-void TabClass::simultaneous(int classId, const wstring &time, int nVacant) {
-  pClass pc = oe->getClass(classId);
+void TabClass::simultaneous(oEvent& oe, int classId, const wstring &time, int nVacant) {
+  pClass pc = oe.getClass(classId);
 
   if (!pc)
     throw exception();
@@ -4163,7 +4248,7 @@ void TabClass::simultaneous(int classId, const wstring &time, int nVacant) {
   if (nVacant >= 0 && pc->getNumStages() <= 1) {
     vector<int> toRemove;
     vector<pRunner> runners;
-    oe->getRunners(classId, 0, runners, true);
+    oe.getRunners(classId, 0, runners, true);
     //Remove old vacances
     for (pRunner r : runners) {
       if (r->getTeam())
@@ -4175,10 +4260,10 @@ void TabClass::simultaneous(int classId, const wstring &time, int nVacant) {
       }
     }
 
-    oe->removeRunner(toRemove);
+    oe.removeRunner(toRemove);
     toRemove.clear();
     for (int i = 0; i < nVacant; i++) {
-      oe->addRunnerVacant(classId);
+      oe.addRunnerVacant(classId);
     }
   }
 
@@ -4193,10 +4278,10 @@ void TabClass::simultaneous(int classId, const wstring &time, int nVacant) {
   pc->setStartData(0, time);
   pc->synchronize(true);
   pc->forceShowMultiDialog(false);
-  oe->reCalculateLeaderTimes(pc->getId());
+  oe.reCalculateLeaderTimes(pc->getId());
   set<int> cls;
   cls.insert(pc->getId());
-  oe->reEvaluateAll(cls, true);
+  oe.reEvaluateAll(cls, true);
 }
 
 const wchar_t *TabClass::getCourseLabel(bool pool) {
@@ -4242,7 +4327,7 @@ void TabClass::selectCourses(gdioutput &gdi, int legNo) {
   int x2=gdi.getCX();
   gdi.fillDown();
   gdi.addListBox("MCourses", 240, 200, MultiCB, L"Banor:").ignore(true);
-  oe->fillCourses(gdi, "MCourses", true);
+  oe->fillCourses(gdi, "MCourses", {}, true);
 
   gdi.setCX(x1);
   gdi.fillRight();
@@ -4308,7 +4393,7 @@ void TabClass::defineForking(gdioutput &gdi, bool clearSettings) {
   courseFilter = L"";
   gdi.addInput("CourseFilter", courseFilter, 16, MultiCB, L"Filtrera:");
   gdi.addListBox("AllCourses", 180, 300, 0, L"Banor:", L"", true);
-  oe->fillCourses(gdi, "AllCourses", true);
+  oe->fillCourses(gdi, "AllCourses", {}, true);
   int bxp = gdi.getCX();
   int byp = gdi.getCY();
   gdi.fillDown();
@@ -4370,8 +4455,12 @@ void TabClass::getClassSettingsTable(gdioutput &gdi, GUICALLBACK cb) {
   
   vector<pClass> cls;
   oe->getClasses(cls, true);
-
+  RECT rcMain;
   int yp = gdi.getCY();
+  const int margin = gdi.scaleLength(2);
+  rcMain.top = yp - margin;
+  rcMain.left = gdi.getCX() - margin;
+
   int a = gdi.scaleLength(160);
   int b = gdi.scaleLength(250);
   int c = gdi.scaleLength(300);
@@ -4383,22 +4472,56 @@ void TabClass::getClassSettingsTable(gdioutput &gdi, GUICALLBACK cb) {
 
   int ek1 = 0, ekextra = 0;
   bool useEco = oe->getMeOSFeatures().hasFeature(MeOSFeatures::Economy);
-
+  bool useEcaExtraLate = false;
   gdi.setOnClearCb(cb);
-
+  RECT rcLate;
+  RECT rcLate2;
+  RECT rcHead1;
+  RECT rcHead2;
   if (useEco) {
     ek1 = gdi.scaleLength(70);
-    ekextra = gdi.scaleLength(35);
-    d += 4 * ek1 + ekextra;
-    e += 4 * ek1 + ekextra;
-    et += 4 * ek1 + ekextra;
-    f += 4 * ek1 + ekextra;
-    g += 4 * ek1 + ekextra;
+    ekextra = gdi.scaleLength(40);
+    useEcaExtraLate = oe->getDCI().getInt("SecondEntryDate") > 0;
 
-    gdi.addString("", yp, c+ek1, 1, "Avgift");
-    gdi.addString("", yp, c+2*ek1, 1, "Sen avgift");
-    gdi.addString("", yp, c+3*ek1, 1, "Red. avgift");
-    gdi.addString("", yp, c+4*ek1, 1, "Sen red. avgift");
+    gdi.addString("", yp, c + 1* ek1, 1, "Avgifter");
+    gdi.addString("", yp, c + 3* ek1, 0, "Efteranmälan");
+    if (useEcaExtraLate) 
+      gdi.addString("", yp, c + 5 * ek1, 0, "Efteranmälan 2");
+    
+    yp += int(gdi.getLineHeight() * 1.3);
+
+    int numEco = useEcaExtraLate ? 6 : 4;
+
+    d += numEco * ek1 + ekextra;
+    e += numEco * ek1 + ekextra;
+    et += numEco * ek1 + ekextra;
+    f += numEco * ek1 + ekextra;
+    g += numEco * ek1 + ekextra;
+
+    gdi.addString("", yp, c + 1 * ek1, 1, "Standard");
+    gdi.addString("", yp, c + 2 * ek1, 1, "Reducerad");
+
+    gdi.addString("", yp, c + 3 * ek1, 1, "Standard");
+    gdi.addString("", yp, c + 4 * ek1, 1, "Reducerad");
+    int mgx = gdi.scaleLength(2);
+    rcLate.left = c + 3 * ek1 - mgx;
+    rcLate.right = c + 5 * ek1 - mgx;
+    rcLate.top = rcMain.top;
+    int lh = gdi.getLineHeight();
+    int thick = gdi.scaleLength(2);
+
+    if (useEcaExtraLate) {
+      rcLate2.left = c + 5 * ek1 - mgx - 1;
+      rcLate2.right = d - lh;
+      rcLate2.top = rcMain.top;
+      gdi.addString("", yp, c + 5 * ek1, 1, "Standard");
+      gdi.addString("", yp, c + 6 * ek1, 1, "Reducerad");
+    }
+    else 
+      rcLate.right = d - lh;
+    rcHead1 = { c + ek1 - lh, rcMain.top, d - lh, yp + gdi.getLineHeight() + margin };
+    rcHead2 = { c + ek1 - lh, yp - 2, d - lh, yp };
+    gdi.addRectangle(rcHead1, colorLightCyan, true);    
   }
 
   gdi.addString("", yp, gdi.getCX(), 1, "Klass");
@@ -4437,9 +4560,14 @@ void TabClass::getClassSettingsTable(gdioutput &gdi, GUICALLBACK cb) {
   
   gdi.addString("", yp, f, 1, "Direktanmälan");
   
+  rcMain.bottom = yp + gdi.getLineHeight() + margin;
+  rcMain.right = f + gdi.scaleLength(90);
+  gdi.addRectangle(rcMain, colorLightBlue, true, true);
+
   vector< pair<wstring,size_t> > arg;
   oe->getCourses(arg, L"", true);
-  
+  gdi.dropLine(0.4);
+
   for (size_t k = 0; k < cls.size(); k++) {
     pClass it = cls[k];
     int cyp = gdi.getCY();
@@ -4451,10 +4579,16 @@ void TabClass::getClassSettingsTable(gdioutput &gdi, GUICALLBACK cb) {
     gdi.addInput(c, cyp, "Sort"+id, itow(it->getDCI().getInt("SortIndex")), 4);
 
     if (useEco) {
-      gdi.addInput(c + ek1, cyp, "Fee"+id, oe->formatCurrency(it->getDCI().getInt("ClassFee")), 5);
-      gdi.addInput(c + 2*ek1, cyp, "LateFee"+id, oe->formatCurrency(it->getDCI().getInt("HighClassFee")), 5);
-      gdi.addInput(c + 3*ek1, cyp, "RedFee"+id, oe->formatCurrency(it->getDCI().getInt("ClassFeeRed")), 5);
-      gdi.addInput(c + 4*ek1, cyp, "RedLateFee"+id, oe->formatCurrency(it->getDCI().getInt("HighClassFeeRed")), 5);
+      gdi.addInput(c + 1 * ek1, cyp, "Fee" + id, oe->formatCurrency(it->getDCI().getInt("ClassFee")), 5);
+      gdi.addInput(c + 2 * ek1, cyp, "RedFee" + id, oe->formatCurrency(it->getDCI().getInt("ClassFeeRed")), 5);
+
+      gdi.addInput(c + 3 * ek1, cyp, "LateFee" + id, oe->formatCurrency(it->getDCI().getInt("HighClassFee")), 5);
+      gdi.addInput(c + 4 * ek1, cyp, "RedLateFee" + id, oe->formatCurrency(it->getDCI().getInt("HighClassFeeRed")), 5);
+
+      if (useEcaExtraLate) {
+        gdi.addInput(c + 5 * ek1, cyp, "ExLateFee" + id, oe->formatCurrency(it->getDCI().getInt("SecondHighClassFee")), 5);
+        gdi.addInput(c + 6 * ek1, cyp, "ExRedLateFee" + id, oe->formatCurrency(it->getDCI().getInt("SecondHighClassFeeRed")), 5);
+      }
     }
 
     string crs = "Cors"+id;
@@ -4466,13 +4600,13 @@ void TabClass::getClassSettingsTable(gdioutput &gdi, GUICALLBACK cb) {
       gdi.disableInput(crs.c_str());
     }
     else {
-      gdi.addItem(crs, arg);
+      gdi.setItems(crs, arg);
       gdi.selectItemByData(crs.c_str(), it->getCourseId());
     }
     
     if (useBibs)  {
       gdi.addCombo(e, cyp, "Bib" + id, 90, 100, 0, L"", L"Ange löpande numrering eller första nummer i klassen.");
-      gdi.addItem("Bib" + id, bibOptions);
+      gdi.setItems("Bib" + id, bibOptions);
 
       wstring bib = it->getDCI().getString("Bib");
       AutoBibType bt = it->getAutoBibType();
@@ -4483,16 +4617,29 @@ void TabClass::getClassSettingsTable(gdioutput &gdi, GUICALLBACK cb) {
 
       if (useTeam && (it->getNumDistinctRunners() > 1  || it->getQualificationFinal())) {
         gdi.addSelection(et, cyp, "BibTeam" + id, 80, 100, 0, L"", L"Ange relation mellan lagets och deltagarnas nummerlappar.");
-        gdi.addItem("BibTeam" + id, bibTeamOptions);
+        gdi.setItems("BibTeam" + id, bibTeamOptions);
         gdi.selectItemByData("BibTeam" + id, it->getBibMode());
       }
     }
     
-    gdi.addCheckbox(g, cyp, "Dirc"+id, "   ", 0, it->getAllowQuickEntry());
-    
+    gdi.addCheckbox(g, cyp, "Dirc"+id, "   ", 0, it->getAllowQuickEntry());    
     gdi.dropLine(-0.3);
-
   }
+
+  int bottom = gdi.getCY();
+
+  rcLate.bottom = bottom;
+  rcLate2.bottom = bottom;
+  if (useEco) {
+    gdi.addRectangle(rcLate, GDICOLOR(int(colorLightCyan) - RGB(220 / 20, 249 / 20, 245 / 20)), true);
+
+    if (useEcaExtraLate)
+      gdi.addRectangle(rcLate2, GDICOLOR(int(colorLightCyan) - RGB(220 / 10, 249 / 10, 245 / 10)), true);
+
+    gdi.addRectangle(rcHead1, colorTransparent, true);
+    gdi.addRectangle(rcHead2, colorGreyBlue, false);
+  }
+
 }
 
 void TabClass::saveClassSettingsTable(gdioutput &gdi, set<int> &classModifiedFee, bool &modifiedBib) {
@@ -4514,20 +4661,36 @@ void TabClass::saveClassSettingsTable(gdioutput &gdi, set<int> &classModifiedFee
       int latefee = oe->interpretCurrency(gdi.getText("LateFee"+id));
       int feered = oe->interpretCurrency(gdi.getText("RedFee"+id));
       int latefeered = oe->interpretCurrency(gdi.getText("RedLateFee"+id));
+      int late2fee = 0, late2feered = 0;
+      bool hasExtra2 = false;
+      if (gdi.hasWidget("ExLateFee" + id)) {
+        late2fee = oe->interpretCurrency(gdi.getText("ExLateFee" + id));
+        late2feered = oe->interpretCurrency(gdi.getText("ExRedLateFee" + id));
+        hasExtra2 = true;
+      }
 
       int oFee = it->getDCI().getInt("ClassFee");
       int oLateFee = it->getDCI().getInt("HighClassFee");
+      
       int oFeeRed = it->getDCI().getInt("ClassFeeRed");
       int oLateFeeRed = it->getDCI().getInt("HighClassFeeRed");
 
+      int oLateExFee = it->getDCI().getInt("SecondHighClassFee");
+      int oLateExFeeRed = it->getDCI().getInt("SecondHighClassFeeRed");
+
       if (oFee != fee || oLateFee != latefee ||
-          oFeeRed != feered || oLateFeeRed != latefeered)
+          oFeeRed != feered || oLateFeeRed != latefeered ||
+          (hasExtra2 && (late2fee != oLateExFee || late2feered != oLateExFeeRed)))
         classModifiedFee.insert(it->getId());
 
       it->getDI().setInt("ClassFee", fee);
-      it->getDI().setInt("HighClassFee", latefee);
       it->getDI().setInt("ClassFeeRed", feered);
+
+      it->getDI().setInt("HighClassFee", latefee);
       it->getDI().setInt("HighClassFeeRed", latefeered);
+
+      it->getDI().setInt("SecondHighClassFee", late2fee);
+      it->getDI().setInt("SecondHighClassFeeRed", late2feered);
     }
 
     if (gdi.hasWidget("Bib" + id)) {
@@ -4645,7 +4808,7 @@ void TabClass::setParallelOptions(const string &sdKey, gdioutput &gdi, pClass pc
     pc->setStartData(legno, 0); 
   }
 
-  gdi.addItem(sdKey, opt);
+  gdi.setItems(sdKey, opt);
   gdi.selectItemByData(sdKey, defKey);
 }
 
@@ -4982,7 +5145,7 @@ void TabClass::loadBasicDrawSetup(gdioutput &gdi, int &bx, int &by, const wstrin
   for (int k = 2; k<10; k++)
     items.push_back(make_pair(lang.tl("X kontroller#" + itos(k)), k + 1));
   items.push_back(make_pair(lang.tl("Hela banan"), 1000));
-  gdi.addItem("MaxCommonControl", items);
+  gdi.setItems("MaxCommonControl", items);
   gdi.selectItemByData("MaxCommonControl", maxNumControl);
 
   gdi.popX();
@@ -5133,7 +5296,7 @@ void TabClass::fillResultModules(gdioutput &gdi, pClass pc) {
 
     currentResultModuleTags.push_back(mol[k].second.first);
   }
-  gdi.addItem("Module", st);
+  gdi.setItems("Module", st);
   gdi.autoGrow("Module");
   gdi.selectItemByData("Module", current);
   hideEditResultModule(gdi, current);
@@ -5281,3 +5444,121 @@ void TabClass::drawStartGroups(gdioutput &gdi) {
   gdi.addButton("Cancel", "Stäng", ClassesCB);
   gdi.refresh();
 }
+
+void TabClass::dynamicStart(gdioutput& gdi) {
+  save(gdi, true);
+  clearPage(gdi, true);
+
+  class DynamicStart final : public GuiHandler {
+    oEvent& oe;
+
+    void handle(gdioutput& gdi, BaseInfo& info, GuiEventType type) override {
+      if (info.id == "All")
+        gdi.setSelection("StartClasses", {-1});
+      else if (info.id == "None")
+        gdi.setSelection("StartClasses", {});
+      else if (info.id == "DoSetStart") {
+        set<int> cls;
+        gdi.getSelection("StartClasses", cls);
+        wstring t = getLocalTimeOnly();
+        if (oe.getRelativeTime(t) <= 0)
+          throw meosException("Ogiltig första starttid. Måste vara efter nolltid.");
+
+        int type = 0;
+        if (gdi.hasWidget("StartType")) {
+          type = gdi.getSelectedItem("StartType").first;
+        }
+
+        if (type == 0)
+          gdi.addString("", 0, L"Starttid: X#" + t);
+        else if (type == 1)
+          gdi.addString("", 0, L"Omstart: X#" + t);
+        else if (type == 2)
+          gdi.addString("", 0, L"Reptid: X#" + t);
+
+        wstring out;
+        for (int id : cls) {
+          pClass pc = oe.getClass(id);
+          if (pc) {
+            if (type == 0)
+              TabClass::simultaneous(oe, id, t, -1);
+            else if (pc->getNumStages() > 1) {
+              for (int k = 1; k < pc->getNumStages(); k++) {
+                if (type == 2)
+                  pc->setRopeTime(k, t);
+                else if (type == 1)
+                  pc->setRestartTime(k, t);
+              }
+            }
+            if (out.size() > 0) {
+              out.append(L", ");
+              if (out.length() > 100) {
+                gdi.addStringUT(0, out);
+                out.clear();
+              }
+            }
+            out += pc->getName();           
+          }
+        }
+        if (type == 0 || type == 1)
+        gdi.setSelection("StartClasses", {});
+
+        gdi.addStringUT(0, out); 
+        gdi.refresh();
+      }
+    }
+
+  public:
+    DynamicStart(oEvent& oe) : oe(oe) {}
+  };
+
+  auto h = make_shared<DynamicStart>(*oe);
+  gdi.addString("", fontLarge, "Start på signal");
+  gdi.pushY();
+  gdi.addListBox("StartClasses", 200, 350, 0, L"Klasser", L"", true);
+  oe->fillClasses(gdi, "StartClasses", {}, oEvent::ClassExtra::extraNone, oEvent::ClassFilter::filterNone);
+  
+  if (ClassId > 0)
+    gdi.setSelection("StartClasses", { ClassId });
+
+  gdi.dropLine();
+  gdi.fillRight();
+
+  gdi.addButton("All", "Välj alla").setHandler(h);
+  gdi.addButton("None", "Välj ingen").setHandler(h);
+
+  gdi.newColumn();
+  gdi.popY();
+  gdi.pushX();
+  gdi.fillDown();
+  gdi.addString("", 0, "Datortid:");
+  oe->updateComputerTime();
+  int t = (oe->getComputerTime() + oe->getZeroTimeNum()) / timeConstSecond;
+  gdi.addTimer(gdi.getCY(), gdi.getCX(), fontLarge|time24HourClock|fullTimeHMS, t);
+  
+  gdi.dropLine();
+  vector<pClass> cls;
+  oe->getClasses(cls, false);
+  bool hasRelay = false;
+  for (pClass pc : cls) {
+    if (pc->getClassType() == ClassType::oClassRelay) {
+      hasRelay = true;
+      break;
+    }
+  }
+  if (hasRelay) {
+    gdi.addString("", 0, "Välj vilken tid du vill sätta:");
+    gdi.addSelection("StartType", 200, 100);
+    gdi.addItem("StartType", lang.tl("Starttid"), 0);
+    gdi.addItem("StartType", lang.tl("Omstart"), 1);
+    gdi.addItem("StartType", lang.tl("Rep"), 2);
+    gdi.selectFirstItem("StartType");
+  }
+
+  gdi.fillRight();
+  gdi.addButton("DoSetStart", hasRelay ?  "Sätt tiden" : "Starta nu").setDefault().setHandler(h);
+  gdi.addButton("Cancel", "Stäng", ClassesCB).setCancel();
+  gdi.fillDown();  
+  gdi.dropLine(3);
+  gdi.popX();
+}
diff --git a/code/TabClass.h b/code/TabClass.h
index 5ab1c9e..b4dbd62 100644
--- a/code/TabClass.h
+++ b/code/TabClass.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -24,6 +24,8 @@
 #include "tabbase.h"
 #include "oEventDraw.h"
 
+class QFEditor;
+
 class TabClass :
   public TabBase
 {
@@ -45,7 +47,6 @@ class TabClass :
   double pTimeScaling;
   int pInterval;
 
-
   class HandleCloseWindow : public GuiHandler {
     TabClass *tabClass;
     HandleCloseWindow(const HandleCloseWindow&);
@@ -57,7 +58,6 @@ class TabClass :
   };
   HandleCloseWindow handleCloseWindow;
 
-
   bool EditChanged;
   int ClassId;
   int currentStage;
@@ -71,7 +71,9 @@ class TabClass :
   void legSetup(gdioutput &gdi);
   vector<ClassInfo> cInfo;
   void saveDrawSettings() const;
-  
+
+  void dynamicStart(gdioutput& gdi);
+
   map<int, ClassInfo> cInfoCache;
 
   DrawInfo drawInfo;
@@ -120,9 +122,6 @@ class TabClass :
 
   void showClassSelection(gdioutput &gdi, int &bx, int &by, GUICALLBACK classesCB) const;
 
-  // Set simultaneous start in a class
-  void simultaneous(int classId, const wstring &time, int nVacant);
-
   void updateFairForking(gdioutput &gdi, pClass pc) const;
   void selectCourses(gdioutput &gdi, int legNo);
   bool showMulti(bool singleOnly) const;
@@ -168,11 +167,15 @@ class TabClass :
   void fillResultModules(gdioutput &gdi, pClass pc);
 
   shared_ptr<GuiHandler> startGroupHandler;
+  shared_ptr<QFEditor> qfEditor;
 
 public:
   void loadStartGroupSettings(gdioutput &gdi, bool reload);
   void drawStartGroups(gdioutput &gdi);
 
+  // Set simultaneous start in a class
+  static void simultaneous(oEvent &oe, int classId, const wstring& time, int nVacant);
+
   void clearCompetitionData();
 
   void closeWindow(gdioutput &gdi);
@@ -182,14 +185,14 @@ public:
   bool loadPage(gdioutput &gdi);
   void selectClass(gdioutput &gdi, int cid);
 
-  int classCB(gdioutput &gdi, int type, void *data);
-  int multiCB(gdioutput &gdi, int type, void *data);
+  int classCB(gdioutput &gdi, GuiEventType type, BaseInfo* data);
+  int multiCB(gdioutput &gdi, GuiEventType type, BaseInfo* data);
 
   const char * getTypeStr() const {return "TClassTab";}
   TabType getType() const {return TClassTab;}
 
-  friend int DrawClassesCB(gdioutput *gdi, int type, void *data);
+  friend int DrawClassesCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 
   TabClass(oEvent *oe);
-  ~TabClass(void);
+  ~TabClass();
 };
diff --git a/code/TabClub.cpp b/code/TabClub.cpp
index a166d2a..d9b7be2 100644
--- a/code/TabClub.cpp
+++ b/code/TabClub.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -108,14 +108,12 @@ void ageFilter(gdioutput &gdi, bool on, bool use) {
   gdi.setInputStatus("FilterAge", use);
 }
 
-int ClubsCB(gdioutput *gdi, int type, void *data)
-{
+int ClubsCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabClub &tc = dynamic_cast<TabClub &>(*gdi->getTabs().get(TClubTab));
   return tc.clubCB(*gdi, type, data);
 }
 
-int TabClub::clubCB(gdioutput &gdi, int type, void *data)
-{
+int TabClub::clubCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   if (type==GUI_BUTTON) {
     ButtonInfo bi=*(ButtonInfo *)data;
 
@@ -414,7 +412,7 @@ int TabClub::clubCB(gdioutput &gdi, int type, void *data)
       oe->fillClassTypes(types);
       oe->fillClasses(classes, oEvent::extraNone, oEvent::filterNone);
       types.insert(types.end(), classes.begin(), classes.end());
-      gdi.addItem("ClassType", types);
+      gdi.setItems("ClassType", types);
       gdi.addItem("ClassType", lang.tl("Alla typer"), -5);
 
       gdi.selectItemByData("ClassType", -5);
diff --git a/code/TabClub.h b/code/TabClub.h
index a8fb9c8..48b1693 100644
--- a/code/TabClub.h
+++ b/code/TabClub.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -26,7 +26,7 @@
 class TabClub :
   public TabBase
 {
-  int clubCB(gdioutput &gdi, int type, void *data);
+  int clubCB(gdioutput &gdi, GuiEventType type, BaseInfo* data);
 
   wstring firstDate;
   wstring lastDate;
@@ -59,5 +59,5 @@ public:
   TabClub(oEvent *oe);
   ~TabClub(void);
 
-  friend int ClubsCB(gdioutput *gdi, int type, void *data);
+  friend int ClubsCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 };
diff --git a/code/TabCompetition.cpp b/code/TabCompetition.cpp
index a8a24c9..b157a7e 100644
--- a/code/TabCompetition.cpp
+++ b/code/TabCompetition.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -67,7 +67,7 @@ void exportSetup();
 void resetSaveTimer();
 extern bool enableTests;
 
-int ListsCB(gdioutput *gdi, int type, void *data);
+int ListsCB(gdioutput *gdi, GuiEventType type, BaseInfo *data);
 
 TabCompetition::TabCompetition(oEvent *poe):TabBase(poe)
 {
@@ -198,7 +198,7 @@ bool TabCompetition::exportFileAs(HWND hWnd, gdioutput &gdi)
   return true;
 }
 
-int CompetitionCB(gdioutput *gdi, int type, void *data)
+int CompetitionCB(gdioutput *gdi, GuiEventType type, BaseInfo *data)
 {
   TabCompetition &tc = dynamic_cast<TabCompetition &>(*gdi->getTabs().get(TCmpTab));
 
@@ -206,8 +206,7 @@ int CompetitionCB(gdioutput *gdi, int type, void *data)
 }
 
 
-int restoreCB(gdioutput *gdi, int type, void *data)
-{
+int restoreCB(gdioutput *gdi, GuiEventType type, BaseInfo *data) {
   TabCompetition &tc = dynamic_cast<TabCompetition &>(*gdi->getTabs().get(TCmpTab));
 
   return tc.restoreCB(*gdi, type, data);
@@ -359,7 +358,7 @@ bool TabCompetition::checkEventor(gdioutput &gdi, ButtonInfo &bi) {
   return false;
 }
 
-int eventorServer(gdioutput *gdi, int type, void *data) {
+int eventorServer(gdioutput *gdi, GuiEventType type, BaseInfo *data) {
   TabCompetition &tc = dynamic_cast<TabCompetition &>(*gdi->getTabs().get(TCmpTab));
   if (type == GUI_COMBO) {
     const ListBoxInfo &lbi = *((ListBoxInfo *)data);
@@ -390,8 +389,7 @@ bool TabCompetition::useEventorUTC() const {
 
 enum StartMethod {SMCommon = 1, SMDrawn, SMFree, SMCustom};
 
-int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
-{
+int TabCompetition::competitionCB(gdioutput &gdi, GuiEventType type, BaseInfo *data) {
   if (type == GUI_LINK) {
     TextInfo ti = *(TextInfo *)data;
     if (ti.id == "link") {
@@ -569,10 +567,10 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
       gdi.addButton("Cancel", "Återgå", CompetitionCB);
       gdi.dropLine();
 
-      if (prefsEditor.empty())
-        prefsEditor.push_back(PrefsEditor(oe));
+      if (!prefsEditor)
+        prefsEditor = make_shared<PrefsEditor>(oe);
+      prefsEditor->showPrefs(gdi);
 
-      prefsEditor.back().showPrefs(gdi);
       gdi.refresh();
     }
     else if (bi.id=="Test") {
@@ -1143,7 +1141,7 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
       wstring startlist = getTempFile();
       bool eventorUTC = oe->getPropertyInt("UseEventorUTC", 0) != 0;
       oe->exportIOFStartlist(oEvent::IOF30, startlist.c_str(), eventorUTC, 
-                             set<int>(), false, false, true, true);
+                             set<int>(), make_pair("",""), false, false, true, true);
       vector<wstring> fileList;
       fileList.push_back(startlist);
 
@@ -1236,7 +1234,7 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
       set<int> classes;
       bool eventorUTC = oe->getPropertyInt("UseEventorUTC", 0) != 0;
       oe->exportIOFSplits(oEvent::IOF30, resultlist.c_str(), false,
-                          eventorUTC, classes, -1, false, true, 
+                          eventorUTC, classes, make_pair("", ""), -1, false, true,
                           false, true, true);
       vector<wstring> fileList;
       fileList.push_back(resultlist);
@@ -1531,7 +1529,7 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
         gdi.dropLine();
         gdi.addString("", 1, "Behandlar tävlingsdata").setColor(colorGreen);
         set<int> noFilter;
-        string noType;
+        pair<string, string> noType;
 
         if (createNew && id>0) {
           gdi.addString("", 1, "Skapar ny tävling");
@@ -1559,9 +1557,12 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
         removeTempFile(tClass);
 
         set<int> stageFilter;
-        string preferredIdType;
+        pair<string, string> preferredIdType;
         checkStageFilter(gdi, tEntry, stageFilter, preferredIdType);
         oe->importXML_EntryData(gdi, tEntry.c_str(), false, removeRemoved, stageFilter, 0, 0, preferredIdType);
+        if (!preferredIdType.second.empty())
+          oe->setRunnerIdTypes(preferredIdType);
+        
         removeTempFile(tEntry);
 
         if (!course.empty()) {
@@ -1791,6 +1792,8 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
         oe->setProperty("ExpWithRaceNo", includeStage);
       }
 
+      auto preferredIdTypes = getPreferredIdTypes(gdi);
+
       gdi.getSelection("ClassNewEntries", allTransfer);
       ImportFormats::ExportFormats filterIndex = ImportFormats::setExportFormat(*oe, gdi.getSelectedItem("Type").first);
       int cSVLanguageHeaderIndex = gdi.getSelectedItem("LanguageType").first;
@@ -1800,7 +1803,7 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
       if (filterIndex == ImportFormats::IOF30 || filterIndex == ImportFormats::IOF203) {
         bool useUTC = oe->getDCI().getInt("UTC") != 0;
         oe->exportIOFStartlist(filterIndex == ImportFormats::IOF30 ? oEvent::IOF30 : oEvent::IOF20,
-                                save.c_str(), useUTC, allTransfer, individual, includeStage, false, false);
+                                save.c_str(), useUTC, allTransfer, preferredIdTypes, individual, includeStage, false, false);
       }
       else if (filterIndex == ImportFormats::OE) {
         oe->exportOECSV(save.c_str(), allTransfer, cSVLanguageHeaderIndex, false);
@@ -1849,6 +1852,8 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
         oe->setProperty("ExpWithRaceNo", includeStage);
       }
 
+      auto preferredIdTypes = getPreferredIdTypes(gdi);
+
       gdi.setWaitCursor(true);
       if (filterIndex == ImportFormats::IOF30 || filterIndex == ImportFormats::IOF203) {
         oEvent::IOFVersion ver = filterIndex == ImportFormats::IOF30 ? oEvent::IOF30 : oEvent::IOF20;
@@ -1858,7 +1863,7 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
 
         if (!gdi.hasWidget("LegType")) {
           oe->exportIOFSplits(ver, save.c_str(), true, useUTC, 
-                              allTransfer, -1, false, unroll, includeStage, false, false);
+                              allTransfer, preferredIdTypes, -1, false, unroll, includeStage, false, false);
         }
         else {
           ListBoxInfo leglbi;
@@ -1880,16 +1885,16 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
             for (int leg = 0; leg<legMax; leg++) {
               file = fileBase + L"_" + itow(leg+1) + fileEnd;
               oe->exportIOFSplits(ver, file.c_str(), true, useUTC, 
-                                  allTransfer, leg, false, unroll, includeStage, false, false);
+                                  allTransfer, preferredIdTypes, leg, false, unroll, includeStage, false, false);
             }
           }
           else if (leglbi.data == 3) {
-            oe->exportIOFSplits(ver, file.c_str(), true, useUTC, allTransfer, 
+            oe->exportIOFSplits(ver, file.c_str(), true, useUTC, allTransfer, preferredIdTypes,
                                 -1, true, unroll, includeStage, false, false);
           }
           else {
             int leg = leglbi.data == 1 ? -1 : leglbi.data - 10;
-            oe->exportIOFSplits(ver, file.c_str(), true, useUTC, allTransfer, 
+            oe->exportIOFSplits(ver, file.c_str(), true, useUTC, allTransfer, preferredIdTypes,
                                 leg, false, unroll, includeStage, false, false);
           }
         }
@@ -2202,6 +2207,14 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
   else if (type==GUI_LISTBOX) {
     ListBoxInfo lbi=*(ListBoxInfo *)data;
 
+    if (lbi.id == "DataFields") {
+      oEvent::ExtraFieldContext context = oEvent::ExtraFieldContext(gdi.getDataInt("DataFieldsContext"));
+      saveExtraFields(gdi, context);
+      oe->synchronize(true);
+
+      oEvent::ExtraFieldContext contextNew = oEvent::ExtraFieldContext(lbi.data);
+      showExtraFields(gdi, contextNew);
+    }
     if (lbi.id=="LocalCmp") {
       gdi.selectItemByData("ServerCmp", -1);
       gdi.disableInput("Repair", true);
@@ -2302,7 +2315,7 @@ int TabCompetition::competitionCB(gdioutput &gdi, int type, void *data)
         gdi.setData("RunnerIx", ix);
         gdi.dropLine();
         gdi.addSelection("Classes", 200, 300, 0, L"Klasser:");
-        oe->fillClasses(gdi, "Classes", oEvent::extraNone, oEvent::filterOnlySingle);
+        oe->fillClasses(gdi, "Classes", {}, oEvent::extraNone, oEvent::filterOnlySingle);
 
         if (lastSelectedClass == -1 || !gdi.selectItemByData("Classes", lastSelectedClass))
           gdi.selectFirstItem("Classes");
@@ -2357,8 +2370,8 @@ void TabCompetition::openCompetition(gdioutput &gdi, int id) {
   }
 }
 
-int TabCompetition::restoreCB(gdioutput &gdi, int type, void *data) {
-  TextInfo &ti = *(TextInfo *)data;
+int TabCompetition::restoreCB(gdioutput &gdi, GuiEventType type, BaseInfo *data) {
+  TextInfo &ti = dynamic_cast<TextInfo&>(*data);
   int id = ti.getExtraInt();
   const BackupInfo &bi = oe->getBackup(id);
 
@@ -2417,7 +2430,7 @@ void TabCompetition::copyrightLine(gdioutput &gdi) const
 
   gdi.dropLine(0.4);
   gdi.fillDown();
-  gdi.addString("", 0, makeDash(L"#Copyright © 2007-2023 Melin Software HB"));
+  gdi.addString("", 0, makeDash(L"#Copyright © 2007-2024 Melin Software HB"));
   gdi.dropLine(1);
   gdi.popX();
 
@@ -2447,12 +2460,9 @@ void TabCompetition::loadAboutPage(gdioutput &gdi) const
   gdi.dropLine(1.5);
   gdi.setCX(gdi.getCX() + gdi.scaleLength(20));
 
-  gdi.addStringUT(1, makeDash(L"Copyright © 2007-2023 Melin Software HB"));
+  gdi.addStringUT(1, makeDash(L"Copyright © 2007-2024 Melin Software HB"));
   gdi.dropLine();
-  gdi.addStringUT(10, "The database connection used is MySQL++\nCopyright "
-				  "(c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by MySQL AB,"
-				  "\nand (c) 2004-2007 by Educational Technology Resources, Inc.\n"
-				  "The database used is MySQL, Copyright (c) 2008-2017 Oracle, Inc."
+  gdi.addStringUT(10, "The database used is MySQL, Copyright (c) 2008-2024 Oracle, Inc."
 				  "\n\nGerman Translation by Erik Nilsson-Simkovics"
 				  "\n\nDanish Translation by Michael Leth Jess and Chris Bagge"
 				  "\n\nRussian Translation by Paul A. Kazakov and Albert Salihov"
@@ -2462,7 +2472,9 @@ void TabCompetition::loadAboutPage(gdioutput &gdi) const
 				  "\n\nCzech Translation by Marek Kustka"
           "\n\nSpanish Translation by Manuel Pedre"
           "\n\nUkranian Translation by Oleg Rozhko"
+          "\n\nPortuguese Translation by Bruno Santos"
 				  "\n\nHelp with English documentation: Torbjörn Wikström");
+  
 
   gdi.dropLine();
   gdi.addString("", 0, "Det här programmet levereras utan någon som helst garanti. Programmet är ");
@@ -2519,6 +2531,7 @@ bool TabCompetition::loadPage(gdioutput &gdi)
   gdi.fillDown();
 
   if (oe->empty()) {
+    gdi.selectTab(tabId);
     gdi.addString("", 2, "Välkommen till MeOS");
     gdi.addString("", 1, makeDash(L"#- ")+ lang.tl("ett Mycket Enkelt OrienteringsSystem")).setColor(colorDarkBlue);
     gdi.dropLine();
@@ -2578,7 +2591,7 @@ bool TabCompetition::loadPage(gdioutput &gdi)
       vector< pair<wstring, size_t> > tests;
       TestMeOS tm(oe, "ALL");
       tm.getTests(tests);
-      gdi.addItem("Tests", tests);
+      gdi.setItems("Tests", tests);
       gdi.selectFirstItem("Tests");
       gdi.addButton("RunSpecificTest", "#Run", CompetitionCB);
       
@@ -3011,7 +3024,7 @@ void TabCompetition::getEventorCompetitions(gdioutput &gdi,
         eBreak.getObjectString("Date", breakDate);
 
         SYSTEMTIME st;
-        convertDateYMS(breakDate, st, false);
+        convertDateYMD(breakDate, st, false);
         __int64 time = SystemTimeToInt64TenthSecond(st) - 10;
         breakDate = convertSystemDate(Int64TenthSecondToSystemTime(time));
 
@@ -3319,6 +3332,7 @@ void TabCompetition::loadRunnerDB(gdioutput &gdi, int tableToShow, bool updateTa
 
 void TabCompetition::welcomeToMeOS(gdioutput &gdi) {
   gdi.clearPage(false, false);
+  gdi.selectTab(tabId);
   gdi.scaleSize(1.4*gdi.getScale());
   gdi.dropLine(5);
   gdi.setCX(gdi.getCX() + 5*gdi.getLineHeight());
@@ -3372,7 +3386,7 @@ void TabCompetition::selectTransferClasses(gdioutput &gdi, bool expand) {
   if (expand) {
     gdi.fillDown();
     gdi.addListBox("ClassNewEntries", 200, 400, 0, L"Klasser där nyanmälningar ska överföras:", L"", true);
-    oe->fillClasses(gdi, "ClassNewEntries", oEvent::extraNone, oEvent::filterNone);
+    oe->fillClasses(gdi, "ClassNewEntries", {}, oEvent::extraNone, oEvent::filterNone);
 
     gdi.setSelection("ClassNewEntries", allTransfer);
     gdi.pushX();
@@ -3396,14 +3410,14 @@ void TabCompetition::selectTransferClasses(gdioutput &gdi, bool expand) {
   gdi.refresh();
 }
 
-static int ClearFeaturesCB(gdioutput *gdi, int type, void *data)
+static int ClearFeaturesCB(gdioutput *gdi, GuiEventType type, BaseInfo *data)
 {
   TabCompetition &tc = dynamic_cast<TabCompetition &>(*gdi->getTabs().get(TCmpTab));
   tc.saveMeosFeatures(*gdi, true);
   return 1;
 }
 
-static int CheckFeaturesCB(gdioutput *gdi, int type, void *data)
+static int CheckFeaturesCB(gdioutput *gdi, GuiEventType type, BaseInfo *data)
 {
   TabCompetition &tc = dynamic_cast<TabCompetition &>(*gdi->getTabs().get(TCmpTab));
   tc.saveMeosFeatures(*gdi, false);
@@ -3653,13 +3667,16 @@ FlowOperation TabCompetition::saveEntries(gdioutput &gdi, bool removeRemoved, in
     }
     else {
       set<int> stageFilter;
-      string preferredIdType;
+      pair<string, string> preferredIdType;
 
       FlowOperation res = checkStageFilter(gdi, filename[i], stageFilter, preferredIdType);
 
       if (res != FlowContinue)
         return res;
 
+      if (!preferredIdType.second.empty())
+        oe->setRunnerIdTypes(preferredIdType);
+
       const int courseIdOffset = 0;
       oe->importXML_EntryData(gdi, filename[i], false, removeRemoved, stageFilter,
                               classOffset, courseIdOffset, preferredIdType);
@@ -3687,10 +3704,10 @@ FlowOperation TabCompetition::saveEntries(gdioutput &gdi, bool removeRemoved, in
   return FlowContinue;
 }
 
-int stageInfoCB(gdioutput *gdi, int type, void *data)
+int stageInfoCB(gdioutput *gdi, GuiEventType type, BaseInfo *data)
 {
   if (type == GUI_BUTTON) {
-    ButtonInfo &bi = *(ButtonInfo *)data;
+    ButtonInfo &bi = dynamic_cast<ButtonInfo &>(*data);
     bi.setExtra(1);
   }
   return 0;
@@ -3702,12 +3719,12 @@ FlowOperation importFilterGUI(oEvent *oe,
                               const set<int>& stages,
                               const vector<string> &idProviders,
                               set<int> & filter,
-                              string &preferredIdProvider);
+                              pair<string, string>&preferredIdProvider);
 
 FlowOperation TabCompetition::checkStageFilter(gdioutput & gdi,
                                                const wstring & fname,
                                                set<int>& filter,
-                                               string &preferredIdProvider) {
+                                               pair<string, string> &preferredIdProvider) {
   xmlparser xml;
   xml.read(fname);
   xmlobject xo = xml.getObject("EntryList");
@@ -3728,7 +3745,7 @@ FlowOperation importFilterGUI(oEvent *oe,
                               const set<int>& stages,
                               const vector<string> &idProviders,
                               set<int> & filter,
-                              string &preferredIdProvider) {
+                              pair<string, string> &preferredIdProvider) {
   auto &scanFilter = stages;
   bool stageFilter = scanFilter.size() > 1;
   bool idtype = idProviders.size() > 1;
@@ -3748,6 +3765,7 @@ FlowOperation importFilterGUI(oEvent *oe,
     gdi.fillRight();
     gdi.addSelection("Stage", 150, 200, stageInfoCB, L"Välj etapp att importera:");
     gdi.addItem("Stage", lang.tl("Alla"), 0);
+    gdi.fillDown();
     for (int sn : scanFilter) {
       if (sn > 0)
         gdi.addItem("Stage", lang.tl("Etapp X#" + itos(sn)), sn);
@@ -3757,14 +3775,12 @@ FlowOperation importFilterGUI(oEvent *oe,
       gdi.selectItemByData("Stage", cn);
     else
       gdi.selectItemByData("Stage", 0);
+
+    gdi.popX();
+    gdi.dropLine(3.5);
   }
 
   if (idtype) {
-    if (stageFilter) {
-      gdi.popX();
-      gdi.dropLine(2);
-    }
-    gdi.dropLine(0.5);
     gdi.addString("", 0, "Det finns multiplia Id-nummer för personer");
     gdi.dropLine(0.5);
     gdi.fillRight();
@@ -3773,9 +3789,12 @@ FlowOperation importFilterGUI(oEvent *oe,
     for (const string &sn : idProviders) {
       gdi.addItem("IdType", gdi.widen(sn), i++);
     }
+    gdi.popX();
+    gdi.dropLine(3.6);
   }
 
   if (needUseInput) {
+    gdi.fillRight(); 
     gdi.dropLine();
     gdi.addButton("OK_Stage", "OK", stageInfoCB);
     gdi.fillDown();
@@ -3817,7 +3836,14 @@ FlowOperation importFilterGUI(oEvent *oe,
       if (idProviders.size() > 1) {
         ListBoxInfo lbi;
         if (gdi.getSelectedItem("IdType", lbi)) {
-          preferredIdProvider = gdi.narrow(lbi.text);
+          preferredIdProvider.first = gdi.narrow(lbi.text);
+        }
+
+        // Auto select secondary type. TODO: Manually select if not unique... 
+        for (const string& sn : idProviders) {
+          if (preferredIdProvider.first != sn) {
+            preferredIdProvider.second = sn;
+          }
         }
       }
 
@@ -3837,7 +3863,7 @@ void TabCompetition::selectStartlistOptions(gdioutput &gdi) {
   gdi.addString("", boldLarge, "Exportera startlista");
   gdi.pushY();
   gdi.addListBox("ClassNewEntries", 250, 400, 0, L"Klassval:", L"", true);
-  oe->fillClasses(gdi, "ClassNewEntries", oEvent::extraNone, oEvent::filterNone);
+  oe->fillClasses(gdi, "ClassNewEntries", {}, oEvent::extraNone, oEvent::filterNone);
 
   gdi.setSelection("ClassNewEntries", allTransfer);
   gdi.pushX();
@@ -3854,7 +3880,7 @@ void TabCompetition::selectStartlistOptions(gdioutput &gdi) {
 
   vector< pair<wstring, size_t> > types;
   ImportFormats::getExportFormats(types, false);
-  gdi.addItem("Type", types);
+  gdi.setItems("Type", types);
   ImportFormats::ExportFormats format = ImportFormats::getDefaultExportFormat(*oe);
   gdi.selectItemByData("Type", format);
 
@@ -3862,7 +3888,7 @@ void TabCompetition::selectStartlistOptions(gdioutput &gdi) {
   ImportFormats::getOECSVLanguage(typeLanguages);
   
   gdi.addSelection("LanguageType", 250, 200, CompetitionCB, L"Export language:");
-  gdi.addItem("LanguageType", typeLanguages);
+  gdi.setItems("LanguageType", typeLanguages);
 
   gdi.selectItemByData("LanguageType", ImportFormats::getDefaultCSVLanguage(*oe));
  
@@ -3878,6 +3904,9 @@ void TabCompetition::selectStartlistOptions(gdioutput &gdi) {
     gdi.addCheckbox("IncludeRaceNumber", "Inkludera information om flera lopp per löpare", nullptr, 
                     oe->getPropertyInt("ExpWithRaceNo", true) != 0);
     
+  pair<bool, bool> priSecondId = hasPersonExtId();
+  showSelectId(priSecondId, gdi);
+  
   wstring fn = oe->getPropertyString("ExpStaFilename", L"");
   gdi.addInput("Filename", fn, 
                48, CompetitionCB,  L"Filnamn:").setExtra(L"DoSaveStartlist");
@@ -3892,13 +3921,34 @@ void TabCompetition::selectStartlistOptions(gdioutput &gdi) {
   gdi.refresh();
 }
 
+pair<bool, bool> TabCompetition::hasPersonExtId() const {
+  vector<pRunner> runners;
+  oe->getRunners(-1, -1, runners, false);
+  pair<bool, bool> res(false, false);
+  for (pRunner r : runners) {
+    if (!res.first && r->getExtIdentifier() != 0) {
+      res.first = true;
+      if (res.second)
+        break;
+    }
+
+    if (!res.second && r->getExtIdentifier2() != 0) {
+      res.second = true;
+      if (res.first)
+        break;
+    }
+  }
+
+  return res;
+}
+
 void TabCompetition::selectExportSplitOptions(gdioutput &gdi) {
   gdi.clearPage(false);
   gdi.addString("", boldLarge, "Export av resultat/sträcktider");
   gdi.dropLine();
   gdi.pushY();
   gdi.addListBox("ClassNewEntries", 250, 400, 0, L"Klassval:", L"", true);
-  oe->fillClasses(gdi, "ClassNewEntries", oEvent::extraNone, oEvent::filterNone);
+  oe->fillClasses(gdi, "ClassNewEntries", {}, oEvent::extraNone, oEvent::filterNone);
 
   gdi.setSelection("ClassNewEntries", allTransfer);
   gdi.pushX();
@@ -3915,7 +3965,7 @@ void TabCompetition::selectExportSplitOptions(gdioutput &gdi) {
   vector<pair<wstring, size_t>> types;
   ImportFormats::getExportFormats(types, true);
 
-  gdi.addItem("Type", types);
+  gdi.setItems("Type", types);
   ImportFormats::ExportFormats format = ImportFormats::getDefaultExportFormat(*oe);
   gdi.selectItemByData("Type", format);
 
@@ -3923,7 +3973,7 @@ void TabCompetition::selectExportSplitOptions(gdioutput &gdi) {
   ImportFormats::getOECSVLanguage(typeLanguages);
   
   gdi.addSelection("LanguageType", 250, 200, CompetitionCB, L"Export language:");
-  gdi.addItem("LanguageType", typeLanguages);
+  gdi.setItems("LanguageType", typeLanguages);
   
   gdi.selectItemByData("LanguageType", ImportFormats::getDefaultCSVLanguage(*oe));
  
@@ -3933,7 +3983,8 @@ void TabCompetition::selectExportSplitOptions(gdioutput &gdi) {
   oe->getClassConfigurationInfo(cnf);
 
   if (cnf.hasTeamClass() || cnf.hasQualificationFinal()) {
-    gdi.addSelection("LegType", 300, 100, 0, L"Exportval, IOF-XML");
+    gdi.dropLine(0.2);
+    gdi.addSelection("LegType", 300, 100, 0, L"Exportval, IOF-XML:");
     gdi.addItem("LegType", lang.tl("Totalresultat"), 1);
     gdi.addItem("LegType", lang.tl("Alla lopp som individuella"), 3);
     if (cnf.hasTeamClass()) {
@@ -3961,6 +4012,9 @@ void TabCompetition::selectExportSplitOptions(gdioutput &gdi) {
     gdi.addCheckbox("IncludeRaceNumber", "Inkludera information om flera lopp per löpare", 0, 
                     oe->getPropertyInt("ExpWithRaceNo", true) != 0);
 
+  pair<bool, bool> priSecondId = hasPersonExtId();
+  showSelectId(priSecondId, gdi);
+
   wstring fn = oe->getPropertyString("ExpResFilename", L"");
   gdi.addInput("Filename", fn, 48, CompetitionCB,  L"Filnamn:").setExtra(L"DoSaveSplits");
   setExportOptionsStatus(gdi, format);
@@ -3975,6 +4029,60 @@ void TabCompetition::selectExportSplitOptions(gdioutput &gdi) {
   gdi.refresh();
 }
 
+void TabCompetition::showSelectId(std::pair<bool, bool>& priSecondId, gdioutput& gdi) {
+  class IdType : public GuiHandler {
+    void handle(gdioutput& gdi, BaseInfo& info, GuiEventType type) final {
+      string baseType = info.id.substr(0, info.id.length() - 2);
+      gdi.setInputStatus(baseType + "Type", gdi.isChecked(info.id));
+    }
+  };
+  
+  if (priSecondId.first && priSecondId.second) {
+    auto idTypes = oe->getRunnerIdTypes();
+    gdi.dropLine(0.5);
+    gdi.addString("", 0, "Välj typ av ID att exportera:");
+    gdi.dropLine(0.3);
+    gdi.fillRight();
+    const int baseX = gdi.getCX();
+    gdi.addCheckbox("PrimaryId", "Primärt").setHandler(make_shared<IdType>());
+    const int idx = baseX + (3 * (gdi.getCX() - baseX)) / 2;
+    gdi.setCX(idx);
+    gdi.addInput("PrimaryType", idTypes.first);
+    gdi.popX();
+    gdi.dropLine(2);
+
+    gdi.fillRight();
+    gdi.addCheckbox("SecondaryId", "Sekundärt").setHandler(make_shared<IdType>());
+    gdi.setCX(max(idx, gdi.getCX()));
+    gdi.addInput("SecondaryType", idTypes.second);
+    gdi.popX();
+    gdi.dropLine(2);
+
+    gdi.fillDown();
+  }
+}
+
+pair<string, string> TabCompetition::getPreferredIdTypes(gdioutput& gdi) {
+  pair<string, string> preferredIdTypes;
+
+  if (gdi.hasWidget("PrimaryId")) {
+    if (gdi.isChecked("PrimaryId")) {
+      wstring pt = gdi.getText("PrimaryType");
+      preferredIdTypes.first = gdioutput::narrow(pt);
+      if (preferredIdTypes.first.empty())
+        preferredIdTypes.first = "PRIMARY";
+    }
+
+    if (gdi.isChecked("SecondaryId")) {
+      wstring st = gdi.getText("SecondaryType");
+      preferredIdTypes.second = gdioutput::narrow(st);
+      if (preferredIdTypes.second.empty())
+        preferredIdTypes.second = "SECONDARY";
+    }
+  }
+  return preferredIdTypes;
+}
+
 void TabCompetition::setExportOptionsStatus(gdioutput &gdi, int format) const {
   if (gdi.hasWidget("LegType")) {
     gdi.setInputStatus("LegType", format == ImportFormats::IOF30 || format == ImportFormats::IOF203); // Enable on IOF-XML
@@ -3993,6 +4101,17 @@ void TabCompetition::setExportOptionsStatus(gdioutput &gdi, int format) const {
     gdi.setInputStatus("IncludeRaceNumber", format == ImportFormats::IOF30); // Enable on IOF-XML
   }
 
+  if (gdi.hasWidget("PrimaryId")) {
+    for (auto s : {"Primary", "Secondary" }) {
+      bool enable = format == ImportFormats::IOF30;
+      string ss = s;
+      string ids = ss + "Id";
+      // Enable on IOF-XML
+      gdi.setInputStatus(ids, enable); 
+      gdi.setInputStatus(ss + "Type", enable && gdi.isChecked(ids));
+    }
+  }
+
   gdi.setInputStatus("LanguageType", format == ImportFormats::OE);
 
   if (gdi.hasWidget("Filename")) {
@@ -4064,10 +4183,25 @@ void TabCompetition::loadSettings(gdioutput &gdi) {
 
   oe->getDI().buildDataFields(gdi, fields, 10);
 
+  gdi.popX();
+  gdi.dropLine(3);
+  gdi.fillDown();
+  gdi.addString("", gdi.getCY(), gdi.getCX(), 10| breakLines,
+    L"help_second_fee",
+    gdi.scaleLength(250));
+  gdi.fillRight();;
+
+  fields.clear();
+  fields.push_back("SecondEntryDate");
+  fields.push_back("SecondEntryFactor");
+
+  oe->getDI().buildDataFields(gdi, fields, 10);
+
   gdi.fillDown();
   gdi.popX();
   gdi.dropLine(3);
 
+
   gdi.addString("", 1, "Åldersgränser, reducerad anmälningsavgift");
   gdi.addString("", 0, "Ungdomar och äldre kan få reducerad avgift");
   gdi.dropLine(0.5);
@@ -4188,19 +4322,32 @@ void TabCompetition::loadSettings(gdioutput &gdi) {
     string ms = itos(modes[k].second);
     gdi.addInput("M" + itos(k), modes[k].first, 24).setExtra(modes[k].second);
     if (k > 0)
-      gdi.addButton(gdi.getCX(), gdi.getCY(), gdi.scaleLength(20), 
-                    "RemovePayMode", makeDash(L"-"), CompetitionCB, 
-                    L"Ta bort", false, false).setExtra(modes[k].second);
-    if (k == 0) 
-      gdi.addButton(gdi.getCX(), gdi.getCY(), gdi.scaleLength(20), 
-                    "AddPayMode", "+", CompetitionCB, 
-                    "Lägg till", false, false);
+      gdi.addButton(gdi.getCX(), gdi.getCY(), gdi.scaleLength(20),
+        "RemovePayMode", makeDash(L"-"), CompetitionCB,
+        L"Ta bort", false, false).setExtra(modes[k].second);
+    if (k == 0)
+      gdi.addButton(gdi.getCX(), gdi.getCY(), gdi.scaleLength(20),
+        "AddPayMode", "+", CompetitionCB,
+        "Lägg till", false, false);
 
     gdi.dropLine(2.5);
     gdi.popX();
   }
-  bottom = max(bottom, gdi.getCY());
 
+  gdi.fillDown();
+  gdi.addString("", 1, "Extra datafält");
+  gdi.dropLine(0.2);
+
+  gdi.addSelection("DataFields", 200, 200, CompetitionCB, L"Sida:");
+  gdi.addItem("DataFields", lang.tl("Deltagare"), 0);
+  gdi.addItem("DataFields", lang.tl("Lag"), 1);
+  gdi.addItem("DataFields", lang.tl("Klass"), 2);
+  gdi.addItem("DataFields", lang.tl("Direktanmälan"), 3);
+  gdi.selectFirstItem("DataFields");
+  gdi.setData("FieldX", gdi.getCX());
+  gdi.setData("FieldY", gdi.getCY());
+
+  bottom = max(bottom, gdi.getCY());
   gdi.popX();
   gdi.setCY(bottom);
   gdi.fillRight();
@@ -4208,18 +4355,145 @@ void TabCompetition::loadSettings(gdioutput &gdi) {
   gdi.addButton("Cancel", "Avbryt", CompetitionCB).setCancel();
   gdi.dropLine(2);
   gdi.setOnClearCb(CompetitionCB);
-  gdi.refresh();
 
+  showExtraFields(gdi, oEvent::ExtraFieldContext::Runner);
+}
+
+void TabCompetition::showExtraFields(gdioutput& gdi, oEvent::ExtraFieldContext type) {
+  gdi.restore("ExtraFields", false);
+  gdi.setRestorePoint("ExtraFields");
+
+  gdi.setData("DataFieldsContext", int(type));
+  auto ef = oe->getExtraFields(type);
+  auto efNames = oe->getExtraFieldNames();
+
+  auto getName = [&ef, &efNames](oEvent::ExtraFields field) -> wstring {
+    auto res = ef.find(field);
+    if (res != ef.end() && !res->second.empty())
+      return res->second;
+
+    res = efNames.find(field);
+    if (res != efNames.end() && !res->second.empty())
+      return res->second;
+
+    return L"";
+    };
+
+  gdi.setCX(gdi.getDataInt("FieldX"));
+  gdi.setCY(gdi.getDataInt("FieldY"));
+  gdi.dropLine(0.5);
+  gdi.pushX();
+  gdi.fillRight();
+  auto dataA = ef.find(oEvent::ExtraFields::DataA);
+  gdi.dropLine(-0.2);
+  gdi.addCheckbox("DataA", L"Extra data X:#(A)", nullptr, dataA != ef.end());
+  gdi.addInput("DataAName", getName(oEvent::ExtraFields::DataA), 16);
+
+  gdi.dropLine(2.5);
+  gdi.popX();
+
+  auto dataB = ef.find(oEvent::ExtraFields::DataB);
+  gdi.addCheckbox("DataB", L"Extra data X:#(B)", nullptr, dataB != ef.end());
+  gdi.dropLine(-0.2);
+
+  gdi.addInput("DataBName", getName(oEvent::ExtraFields::DataB), 16);
+
+  gdi.dropLine(2.5);
+  gdi.popX();
+  auto textA = ef.find(oEvent::ExtraFields::TextA);
+  gdi.addCheckbox("TextA", L"Text:", nullptr, textA != ef.end());
+  gdi.dropLine(-0.2);
+  gdi.addInput("TextAName", getName(oEvent::ExtraFields::TextA), 16);
+
+  gdi.dropLine(2.5);
+  gdi.popX();
+
+  if (type == oEvent::ExtraFieldContext::DirectEntry) {
+    gdi.addCheckbox("StartTime", L"Starttid", nullptr, ef.count(oEvent::ExtraFields::StartTime));
+    gdi.addCheckbox("Bib", L"Nummerlapp", nullptr, ef.count(oEvent::ExtraFields::Bib));
+  }
+
+  if (type != oEvent::ExtraFieldContext::Class)
+    gdi.addCheckbox("Nationality", L"Nationalitet", nullptr, ef.count(oEvent::ExtraFields::Nationality));
+
+  if (type == oEvent::ExtraFieldContext::DirectEntry) {
+    gdi.dropLine(2.5);
+    gdi.popX();
+  }
+  if (type == oEvent::ExtraFieldContext::Runner || type == oEvent::ExtraFieldContext::DirectEntry) {
+    gdi.addCheckbox("Sex", L"Kön", nullptr, ef.count(oEvent::ExtraFields::Sex));
+    gdi.addCheckbox("BirthDate", L"Födelsedatum", nullptr, ef.count(oEvent::ExtraFields::BirthDate));
+    gdi.addCheckbox("Rank", L"Ranking", nullptr, ef.count(oEvent::ExtraFields::Rank));
+    gdi.addCheckbox("Phone", L"Telefon", nullptr, ef.count(oEvent::ExtraFields::Phone));
+  }
+
+  gdi.refresh();
+}
+
+void TabCompetition::saveExtraFields(gdioutput& gdi, oEvent::ExtraFieldContext type) {
+  map<oEvent::ExtraFields, wstring> fields;
+
+  if (gdi.isChecked("DataA")) {
+    wstring name = gdi.getText("DataAName");
+    if (trim(name).empty())
+      name = L"Data A";
+    fields[oEvent::ExtraFields::DataA] = name;
+  }
+
+  if (gdi.isChecked("DataB")) {
+    wstring name = gdi.getText("DataBName");
+    if (trim(name).empty())
+      name = L"Data B";
+    fields[oEvent::ExtraFields::DataB] = name;
+  }
+
+  if (gdi.isChecked("TextA")) {
+    wstring name = gdi.getText("TextAName");
+    if (trim(name).empty())
+      name = L"Text";
+    fields[oEvent::ExtraFields::TextA] = name;
+  }
+
+  if (gdi.isChecked("Nationality"))
+    fields[oEvent::ExtraFields::Nationality] = L"";
+
+  if (gdi.isChecked("Sex"))
+    fields[oEvent::ExtraFields::Sex] = L"";
+
+  if (gdi.isChecked("BirthDate"))
+    fields[oEvent::ExtraFields::BirthDate] = L"";
+
+  if (gdi.isChecked("Rank"))
+    fields[oEvent::ExtraFields::Rank] = L"";
+
+  if (gdi.isChecked("Phone"))
+    fields[oEvent::ExtraFields::Phone] = L"";
+
+  if (gdi.isChecked("Sex"))
+    fields[oEvent::ExtraFields::Sex] = L"";
+
+  if (gdi.isChecked("StartTime"))
+    fields[oEvent::ExtraFields::StartTime] = L"";
+
+  if (gdi.isChecked("Bib"))
+    fields[oEvent::ExtraFields::Bib] = L"";
+
+  if (gdi.isChecked("Sex"))
+    fields[oEvent::ExtraFields::Sex] = L"";
+
+  oe->updateExtraFields(type, fields);
 }
 
 void TabCompetition::saveSettings(gdioutput &gdi) {
-  vector<string> fields = { "CardFee" ,"EliteFee" ,"EntryFee","YouthFee" };
+  vector<string> fields = { "CardFee", "EliteFee", "EntryFee", "YouthFee" };
   vector<int> fees(4);
   
   for (int k = 0; k<4; k++)
     fees[k] = oe->getDCI().getInt(fields[k]);
   
   wstring factor = oe->getDCI().getString("LateEntryFactor");
+  wstring factor2 = oe->getDCI().getString("SecondEntryFactor");
+  bool useFactor2 = oe->getDCI().getInt("SecondEntryDate") > 0;
   set<string> modified;
 
   oe->getDI().saveDataFields(gdi, modified);
@@ -4241,6 +4515,13 @@ void TabCompetition::saveSettings(gdioutput &gdi) {
   if (factor != oe->getDCI().getString("LateEntryFactor"))
     changedFee = true;
 
+  if (factor2 != oe->getDCI().getString("SecondEntryFactor"))
+    changedFee = true;
+
+  bool useFactor2Now = oe->getDCI().getInt("SecondEntryDate") > 0;
+  if (useFactor2 != useFactor2Now)
+    changedFee = true;
+
   if (oe->getDI().setInt("UTC", gdi.isChecked("UTC") ? 1 : 0))
     setEventorUTC(gdi.isChecked("UTC"));
 
@@ -4284,33 +4565,11 @@ void TabCompetition::saveSettings(gdioutput &gdi) {
           throw std::exception();
       }
     }
-
-    //oe->setProperty("PayModes", oe->getDCI().getString("PayModes"));
-
-    /*oe->setProperty("Organizer", oe->getDCI().getString("Organizer"));
-    oe->setProperty("Street", oe->getDCI().getString("Street"));
-    oe->setProperty("Address", oe->getDCI().getString("Address"));
-    oe->setProperty("EMail", oe->getDCI().getString("EMail"));
-    oe->setProperty("Homepage", oe->getDCI().getString("Homepage"));
-
-    oe->setProperty("CardFee", oe->getDCI().getInt("CardFee"));
-    oe->setProperty("EliteFee", oe->getDCI().getInt("EliteFee"));
-    oe->setProperty("EntryFee", oe->getDCI().getInt("EntryFee"));
-    oe->setProperty("YouthFee", oe->getDCI().getInt("YouthFee"));
-
-    oe->setProperty("YouthAge", oe->getDCI().getInt("YouthAge"));
-    oe->setProperty("SeniorAge", oe->getDCI().getInt("SeniorAge"));
-
-    oe->setProperty("Account", oe->getDCI().getString("Account"));
-    oe->setProperty("LateEntryFactor", oe->getDCI().getString("LateEntryFactor"));
-
-    oe->setProperty("CurrencySymbol", oe->getDCI().getString("CurrencySymbol"));
-    oe->setProperty("CurrencyFactor", oe->getDCI().getInt("CurrencyFactor"));
-    oe->setProperty("CurrencyPreSymbol", oe->getDCI().getInt("CurrencyPreSymbol"));
-    oe->setProperty("CurrencySeparator", oe->getDCI().getString("CurrencySeparator"));
-    */
-    //oe->setProperty("PayModes", oe->getDCI().getString("PayModes"));
   }
+
+  oEvent::ExtraFieldContext context = oEvent::ExtraFieldContext(gdi.getSelectedItem("DataFields").first);
+  saveExtraFields(gdi, context);
+
   oe->synchronize(true);
   set<int> dummy;
   if (changedFee && oe->getNumClasses() > 0) {
diff --git a/code/TabCompetition.h b/code/TabCompetition.h
index 9b14c4e..ff03ebe 100644
--- a/code/TabCompetition.h
+++ b/code/TabCompetition.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -45,7 +45,7 @@ class TabCompetition :
 
   // Events from Eventor
   vector<CompetitionInfo> events;
-  list<PrefsEditor> prefsEditor;
+  shared_ptr<PrefsEditor> prefsEditor;
 
   oFreeImport fi;
   wstring entryText;
@@ -83,8 +83,7 @@ class TabCompetition :
                               vector<CompetitionInfo> &events) const;
 
   void saveSettings(gdioutput &gdi);
-  void loadSettings(gdioutput &gdi);
-
+  
   void getEventorCmpData(gdioutput &gdi, int id,
                          const wstring &eventFile,
                          const wstring &clubFile,
@@ -98,6 +97,8 @@ class TabCompetition :
   string eventorOrigin; // The command used when checking eventor
   bool checkEventor(gdioutput &gdi, ButtonInfo &bi);
 
+  pair<bool, bool> hasPersonExtId() const;
+
   bool useEventor() const;
   bool useEventorUTC() const;
 
@@ -125,13 +126,18 @@ class TabCompetition :
   void entryForm(gdioutput &gdi, bool isGuide);
   FlowOperation saveEntries(gdioutput &gdi, bool removeRemoved, int classOffset, bool isGuide);
   
-  FlowOperation checkStageFilter(gdioutput &gdi, const wstring &fname, set<int> &filter, string &preferredIdProvider);
+  FlowOperation checkStageFilter(gdioutput &gdi, const wstring &fname, set<int> &filter, pair<string, string> &preferredIdProvider);
   
   void setExportOptionsStatus(gdioutput &gdi, int format) const;
 
   void selectStartlistOptions(gdioutput &gdi);
   void selectExportSplitOptions(gdioutput &gdi);
 
+  void showSelectId(std::pair<bool, bool>& priSecondId, gdioutput& gdi);
+  pair<string, string> TabCompetition::getPreferredIdTypes(gdioutput& gdi);
+
+  void saveExtraFields(gdioutput& gdi, oEvent::ExtraFieldContext type);
+
   void entryChoice(gdioutput &gdi);
   void createCompetition(gdioutput &gdi);
 
@@ -149,6 +155,9 @@ protected:
   void clearCompetitionData();
 
 public:
+  void loadSettings(gdioutput& gdi);
+  void showExtraFields(gdioutput& gdi, oEvent::ExtraFieldContext type);
+
   const char * getTypeStr() const {return "TCmpTab";}
   TabType getType() const {return TCmpTab;}
 
@@ -158,9 +167,9 @@ public:
   void setEventorServer(const wstring &server);
   void setEventorUTC(bool useUTC);
 
-  int competitionCB(gdioutput &gdi, int type, void *data);
-  int restoreCB(gdioutput &gdi, int type, void *data);
-  int newGuideCB(gdioutput &gdi, int type, void *data);
+  int competitionCB(gdioutput &gdi, GuiEventType type, BaseInfo *data);
+  int restoreCB(gdioutput &gdi, GuiEventType type, BaseInfo *data);
+  int newGuideCB(gdioutput &gdi, GuiEventType type, BaseInfo *data);
 
   bool loadPage(gdioutput &gdi);
   TabCompetition(oEvent *oe);
diff --git a/code/TabControl.cpp b/code/TabControl.cpp
index d2f94d2..79868a6 100644
--- a/code/TabControl.cpp
+++ b/code/TabControl.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -151,8 +151,7 @@ void TabControl::selectControl(gdioutput &gdi,  pControl pc)
   }
 }
 
-int ControlsCB(gdioutput *gdi, int type, void *data)
-{
+int ControlsCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabControl &tc = dynamic_cast<TabControl &>(*gdi->getTabs().get(TControlTab));
   return tc.controlCB(*gdi, type, data);
 }
@@ -278,7 +277,7 @@ void TabControl::save(gdioutput &gdi) {
 
   vector<pair<wstring, size_t>> d;
   oe->fillControls(d, oEvent::ControlType::All);
-  gdi.addItem("Controls", d);
+  gdi.setItems("Controls", d);
 
   oe->reEvaluateAll(set<int>(), true);
 
@@ -402,8 +401,7 @@ void TabControl::visitorTable(Table &table) const {
   }
 }
 
-int TabControl::controlCB(gdioutput &gdi, int type, void *data)
-{
+int TabControl::controlCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   if (type==GUI_BUTTON) {
     ButtonInfo bi=*(ButtonInfo *)data;
 
@@ -431,7 +429,7 @@ int TabControl::controlCB(gdioutput &gdi, int type, void *data)
       pc->synchronize();
       vector< pair<wstring, size_t> > d;
       oe->fillControls(d, oEvent::ControlType::All);
-      gdi.addItem("Controls", d);
+      gdi.setItems("Controls", d);
       selectControl(gdi, pc);
     }
     else if (bi.id=="Remove") {
@@ -449,7 +447,7 @@ int TabControl::controlCB(gdioutput &gdi, int type, void *data)
 
       vector< pair<wstring, size_t> > d;
       oe->fillControls(d, oEvent::ControlType::All);
-      gdi.addItem("Controls", d);
+      gdi.setItems("Controls", d);
       selectControl(gdi, 0);
     }
     else if (bi.id=="SwitchMode") {
@@ -565,7 +563,7 @@ bool TabControl::loadPage(gdioutput &gdi)
 
   vector< pair<wstring, size_t> > d;
   oe->fillControls(d, oEvent::ControlType::All);
-  gdi.addItem("Controls", d);
+  gdi.setItems("Controls", d);
 
   gdi.newColumn();
   gdi.fillDown();
diff --git a/code/TabControl.h b/code/TabControl.h
index bad7b07..98311a0 100644
--- a/code/TabControl.h
+++ b/code/TabControl.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -26,7 +26,7 @@
 class TabControl :
   public TabBase
 {
-  int controlCB(gdioutput &gdi, int type, void *data);
+  int controlCB(gdioutput &gdi, GuiEventType type, BaseInfo* data);
 
   bool tableMode;
   int controlId;
@@ -48,5 +48,5 @@ public:
   TabControl(oEvent *oe);
   ~TabControl(void);
 
-  friend int ControlsCB(gdioutput *gdi, int type, void *data);
+  friend int ControlsCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 };
diff --git a/code/TabCourse.cpp b/code/TabCourse.cpp
index aa27174..06f2b85 100644
--- a/code/TabCourse.cpp
+++ b/code/TabCourse.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -179,9 +179,13 @@ void TabCourse::selectCourse(gdioutput &gdi, pCourse pc)
     if (cc) {
       gdi.selectItemByData("CommonControl", cc);
     }
-
-    fillOtherCourses(gdi, *pc, cc != 0);
     auto sh = pc->getShorterVersion();
+
+    if (sh.first)
+      fillOtherCourses(gdi, *pc, cc != 0);
+    else
+      gdi.selectItemByData("ShortCourse", -1);
+
     gdi.check("Shorten", sh.first);
     gdi.setInputStatus("ShortCourse", sh.first);
     gdi.selectItemByData("ShortCourse", sh.second ? sh.second->getId() : 0);
@@ -216,7 +220,7 @@ void TabCourse::selectCourse(gdioutput &gdi, pCourse pc)
   gdi.setInputStatus("DrawCourse", pc != 0, true);  
 }
 
-int CourseCB(gdioutput *gdi, int type, void *data) {
+int CourseCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabCourse &tc = dynamic_cast<TabCourse &>(*gdi->getTabs().get(TCourseTab));
   return tc.courseCB(*gdi, type, data);
 }
@@ -307,7 +311,7 @@ void TabCourse::save(gdioutput &gdi, int canSwitchViewMode) {
 
   pc->synchronize();//Update SQL
 
-  oe->fillCourses(gdi, "Courses");
+  oe->fillCourses(gdi, "Courses", {}, false);
   oe->reEvaluateCourse(pc->getId(), true);
 
   if (canSwitchViewMode != 2 && changedCourse && pc->getLegLengths().size() > 2) {
@@ -331,8 +335,7 @@ void TabCourse::save(gdioutput &gdi, int canSwitchViewMode) {
     selectCourse(gdi, pc);
 }
 
-int TabCourse::courseCB(gdioutput &gdi, int type, void *data)
-{
+int TabCourse::courseCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   if (type==GUI_BUTTON) {
     ButtonInfo bi=*(ButtonInfo *)data;
 
@@ -448,9 +451,13 @@ int TabCourse::courseCB(gdioutput &gdi, int type, void *data)
       bool w = gdi.isChecked(bi.id);
       gdi.setInputStatus("ShortCourse", w);
       if (w) {
+        pCourse pc = oe->getCourse(courseId);
+        if (pc) {
+          fillOtherCourses(gdi, *pc, gdi.isChecked("WithLoops"));
+        }
         ListBoxInfo clb;
-        if (!gdi.getSelectedItem("ShortCoursse", clb) || clb.data <= 0)
-          gdi.selectFirstItem("CommonControl");
+        if (!gdi.getSelectedItem("ShortCourse", clb) || clb.data <= 0)
+          gdi.selectFirstItem("ShortCourse");
       }
     }
     else if (bi.id == "ExportCourses") {
@@ -621,7 +628,7 @@ int TabCourse::courseCB(gdioutput &gdi, int type, void *data)
       }
       pCourse pc = oe->addCourse(oe->getAutoCourseName());
       pc->synchronize();
-      oe->fillCourses(gdi, "Courses");
+      oe->fillCourses(gdi, "Courses", {}, false);
       selectCourse(gdi, pc);
       gdi.setInputFocus("Name", true);
       addedCourse = true;
@@ -636,7 +643,7 @@ int TabCourse::courseCB(gdioutput &gdi, int type, void *data)
       else
         oe->removeCourse(cid);
 
-      oe->fillCourses(gdi, "Courses");
+      oe->fillCourses(gdi, "Courses", {}, false);
 
       selectCourse(gdi, 0);
     }
@@ -757,7 +764,7 @@ bool TabCourse::loadPage(gdioutput &gdi) {
   gdi.addListBox("Courses", 250, 360, CourseCB, L"Banor (antal kontroller)").isEdit(false).ignore(true);
   gdi.setTabStops("Courses", 240);
 
-  oe->fillCourses(gdi, "Courses");
+  oe->fillCourses(gdi, "Courses", {}, false);
 
   gdi.dropLine(0.7);
   gdi.pushX();
@@ -911,7 +918,7 @@ void TabCourse::runCourseImport(gdioutput& gdi, const wstring &filename,
     gdi.fillDown();
   }
   else if (filename.find(L".txt") != wstring::npos || filename.find(L".TXT") != wstring::npos) {
-    ifstream fin(filename);
+    std::ifstream fin(filename);
 
     if (!fin.good())
       throw meosException(L"Cannot read " + filename);
@@ -970,7 +977,7 @@ void TabCourse::runCourseImport(gdioutput& gdi, const wstring &filename,
   }
   else {
     set<int> noFilter;
-    string noType;
+    pair<string, string> noType;
     int classIdOffset = 0;
     int courseIdOffset = 0;
     oe->importXML_EntryData(gdi, filename.c_str(), addToClasses, false, 
@@ -1174,7 +1181,7 @@ void TabCourse::fillCourseControls(gdioutput &gdi, const wstring &ctrl) {
   }
 
   gdi.clearList("CommonControl");
-  gdi.addItem("CommonControl", item);
+  gdi.setItems("CommonControl", item);
 }
 
 void TabCourse::fillOtherCourses(gdioutput &gdi, oCourse &crs, bool withLoops) {
@@ -1198,8 +1205,7 @@ void TabCourse::fillOtherCourses(gdioutput &gdi, oCourse &crs, bool withLoops) {
       out.push_back(ac[k]);
   }
 
-  gdi.clearList("ShortCourse");
-  gdi.addItem("ShortCourse", out);
+  gdi.setItems("ShortCourse", out);
 }
 
 void TabCourse::saveLegLengths(gdioutput &gdi) {
diff --git a/code/TabCourse.h b/code/TabCourse.h
index 64e2fb9..ada8d0c 100644
--- a/code/TabCourse.h
+++ b/code/TabCourse.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -31,7 +31,7 @@ class TabCourse :
   int courseId;
   /** canSwitchViewMode: 0 = no, 1 = yes, 2 = switching to legs */
   void save(gdioutput &gdi, int canSwitchViewMode);
-  int courseCB(gdioutput &gdi, int type, void *data);
+  int courseCB(gdioutput &gdi, GuiEventType type, BaseInfo* data);
   bool addedCourse;
 
   wstring time_limit;
@@ -74,5 +74,5 @@ public:
 
   static void setupCourseImport(gdioutput& gdi, GUICALLBACK cb);
 
-  friend int CourseCB(gdioutput *gdi, int type, void *data);
+  friend int CourseCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 };
diff --git a/code/TabList.cpp b/code/TabList.cpp
index 6d179e5..181e8e9 100644
--- a/code/TabList.cpp
+++ b/code/TabList.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -80,10 +80,9 @@ TabList::~TabList(void)
   liveResults.clear();
 }
 
-int ListsCB(gdioutput *gdi, int type, void *data);
+int ListsCB(gdioutput *gdi, GuiEventType type, BaseInfo *data);
 
-int ListsEventCB(gdioutput *gdi, int type, void *data)
-{
+int ListsEventCB(gdioutput *gdi, GuiEventType type, BaseInfo *data) {
   if (type!=GUI_EVENT)
     return -1;
 
@@ -105,10 +104,10 @@ void TabList::rebuildList(gdioutput &gdi)
   }
 }
 
-int openRunnerTeamCB(gdioutput *gdi, int type, void *data)
+int openRunnerTeamCB(gdioutput *gdi, GuiEventType type, BaseInfo *data)
 {
   if (type==GUI_LINK && data) {
-    TextInfo *ti = static_cast<TextInfo *>(data);
+    TextInfo *ti = dynamic_cast<TextInfo *>(data);
     int id = ti->getExtraInt();
 
     if (id != 0 && ti->id == "T" && gdi->canClear()) {
@@ -123,31 +122,28 @@ int openRunnerTeamCB(gdioutput *gdi, int type, void *data)
   return 0;
 }
 
-int NoStartRunnerCB(gdioutput *gdi, int type, void *data)
-{
-  if (type==GUI_LINK)
-  {
-    TextInfo *ti=(TextInfo *)data;
-    int id=atoi(ti->id.c_str());
+int NoStartRunnerCB(gdioutput* gdi, GuiEventType type, BaseInfo* data) {
+  if (type == GUI_LINK) {
+    TextInfo* ti = dynamic_cast<TextInfo*>(data);
+    int id = atoi(ti->id.c_str());
 
-    TabList &tc = dynamic_cast<TabList &>(*gdi->getTabs().get(TListTab));
+    TabList& tc = dynamic_cast<TabList&>(*gdi->getTabs().get(TListTab));
     pRunner p = tc.getEvent()->getRunner(id, 0);
 
     if (p) {
       p->setStatus(StatusDNS, true, oBase::ChangeType::Update);
       p->synchronize();
-      ti->callBack=0;
-      ti->highlight=false;
-      ti->active=false;
-      ti->color=RGB(255,0,0);
+      ti->callBack = 0;
+      ti->highlight = false;
+      ti->active = false;
+      ti->color = RGB(255, 0, 0);
       gdi->setText(ti->id, L"Ej start", true);
     }
   }
   return 0;
 }
 
-int ListsCB(gdioutput *gdi, int type, void *data)
-{
+int ListsCB(gdioutput *gdi, GuiEventType type, BaseInfo *data) {
   TabList &tc = dynamic_cast<TabList &>(*gdi->getTabs().get(TListTab));
 
   return tc.listCB(*gdi, type, data);
@@ -218,7 +214,7 @@ void TabList::generateList(gdioutput &gdi, bool forceUpdate)
   }
   gdi.setRestorePoint("GeneralList");
 
-  currentList.setCallback(ownWindow ? 0 : openRunnerTeamCB);
+  currentList.setCallback(ownWindow ? nullptr : openRunnerTeamCB);
   const auto &par = currentList.getParam();
   int bgColor = par.bgColor;
 
@@ -276,7 +272,7 @@ void TabList::generateList(gdioutput &gdi, bool forceUpdate)
     gdi.addButton(gdi.getWidth() + 20, baseY, gdi.scaleLength(baseButtonWidth),
       "ListDesign", "Utseende...", ListsCB, "Justera visningsinställningar", true, false);
 
-    if (!currentList.getParam().saved && !oe->isReadOnly()) {
+    if (!currentList.getParam().saved && !oe->isKiosk()) {
       baseY += 3 + gdi.getButtonHeight();
       gdi.addButton(gdi.getWidth()+20, baseY,  gdi.scaleLength(baseButtonWidth),
                     "Remember", "Kom ihåg listan...", ListsCB, "Spara den här listan som en favoritlista", true, false);
@@ -300,19 +296,18 @@ void TabList::generateList(gdioutput &gdi, bool forceUpdate)
   }
 }
 
-int TabList::listCB(gdioutput &gdi, int type, void *data)
-{
+int TabList::listCB(gdioutput &gdi, GuiEventType type, BaseInfo *data) {
   int index;
   if (type==GUI_BUTTON || type==GUI_EVENT) {
     BaseInfo *tbi = 0;
     ButtonInfo button;
     EventInfo evnt;
     if (type == GUI_BUTTON) {
-      button = *(ButtonInfo *)data;
+      button = dynamic_cast<ButtonInfo &>(*data);
       tbi = &button;
     }
     else if (type == GUI_EVENT) {
-      evnt = *(EventInfo *)data;
+      evnt = dynamic_cast<EventInfo&>(*data);
       tbi = &evnt;
     }
     else
@@ -490,7 +485,7 @@ int TabList::listCB(gdioutput &gdi, int type, void *data)
         gdi.addListBox("Merge", 350, 250, 0, L"Slå ihop med:");
         vector < pair<wstring, size_t> > cand;
         oe->getListContainer().getMergeCandidates(lbi.data, cand);
-        gdi.addItem("Merge", cand);
+        gdi.setItems("Merge", cand);
         gdi.addCheckbox("ShowTitle", "Visa rubrik mellan listorna", 0, false);
         gdi.fillRight();
         gdi.addButton("DoMerge", "Slå ihop", ListsCB).setDefault();
@@ -636,7 +631,7 @@ int TabList::listCB(gdioutput &gdi, int type, void *data)
       ListBoxInfo lbi;
       bool advancedResults = false;
       if (gdi.getSelectedItem("ListType", lbi)) {
-        currentListType=EStdListType(lbi.data);
+        currentListType = EStdListType(lbi.data);
       }
       else if (gdi.getSelectedItem("ResultType", lbi)) {
         currentListType = getTypeFromResultIndex(lbi.data);
@@ -1230,6 +1225,7 @@ int TabList::listCB(gdioutput &gdi, int type, void *data)
     else if (lbi.id == "ListSelection") {
       gdi.getSelection(lbi.id, lastClassSelection);
       if (gdi.hasWidget("ResultType")) {
+        lastResultClassSelection = lastClassSelection;
         ListBoxInfo entry;
         gdi.getSelectedItem("ResultType", entry);
         gdi.setInputStatus("Generate", !lastClassSelection.empty() && int(entry.data) >= 0);
@@ -1348,7 +1344,7 @@ void TabList::enableFromTo(oEvent &oe, gdioutput &gdi, bool from, bool to) {
     vector< pair<wstring, size_t> > ds;
     ds.push_back(make_pair(lang.tl("Start"), 0));
     ds.insert(ds.end(), d.begin(), d.end());
-    gdi.addItem("ResultSpecialFrom", ds);
+    gdi.setItems("ResultSpecialFrom", ds);
     if (!gdi.selectItemByData("ResultSpecialFrom", oe.getPropertyInt("ControlFrom", 0))) {
       gdi.selectItemByData("ResultSpecialFrom", 0); // Fallback
     }
@@ -1360,7 +1356,7 @@ void TabList::enableFromTo(oEvent &oe, gdioutput &gdi, bool from, bool to) {
 
   if (to) {
     gdi.enableInput("ResultSpecialTo");
-    gdi.addItem("ResultSpecialTo", d);
+    gdi.setItems("ResultSpecialTo", d);
     gdi.addItem("ResultSpecialTo", lang.tl("Mål"), 0);
     if (!gdi.selectItemByData("ResultSpecialTo", oe.getPropertyInt("ControlTo", 0))) {
       gdi.selectItemByData("ResultSpecialTo", 0); // Fallback
@@ -1379,7 +1375,7 @@ void TabList::selectGeneralList(gdioutput &gdi, EStdListType type)
   oe->setProperty("ListType", type);
   if (li.supportClasses) {
     gdi.enableInput("ListSelection");
-    oe->fillClasses(gdi, "ListSelection", oEvent::extraNone, oEvent::filterNone);
+    oe->fillClasses(gdi, "ListSelection", {}, oEvent::extraNone, oEvent::filterNone);
     if (lastClassSelection.empty())
       lastClassSelection.insert(-1);
     gdi.setSelection("ListSelection", lastClassSelection);
@@ -1404,7 +1400,7 @@ void TabList::selectGeneralList(gdioutput &gdi, EStdListType type)
     set<int> clsUnused;
     vector< pair<wstring, size_t> > out;
     oe->fillLegNumbers(clsUnused, li.isTeamList(), true, out);
-    gdi.addItem("LegNumber", out);
+    gdi.setItems("LegNumber", out);
     gdi.setInputStatus("LegNumber", !out.empty());    
   }
   else {
@@ -1654,7 +1650,7 @@ void TabList::loadRememberList(gdioutput &gdi, string targetTag) {
   gdi.addListBox("Merge", 350, 250);
   vector < pair<wstring, size_t> > cand;
   oe->getListContainer().getMergeCandidates(-1, cand);
-  gdi.addItem("Merge", cand);
+  gdi.setItems("Merge", cand);
   gdi.dropLine(-0.2);
   gdi.addCheckbox("ShowTitle", "Visa rubrik mellan listorna", 0, false);
   gdi.dropLine(0.5);
@@ -2025,7 +2021,7 @@ void TabList::htmlSettings(gdioutput &gdi, string targetTag) {
   if (!htmlTemplateTag2Id.count(tmpSettingsParam.htmlTypeTag))
     tmpSettingsParam.htmlTypeTag = "free";
 
-  gdi.addItem("Format", items);
+  gdi.setItems("Format", items);
   int tid = htmlTemplateTag2Id[tmpSettingsParam.htmlTypeTag];
   gdi.selectItemByData("Format", tid);
   
@@ -2174,7 +2170,7 @@ void TabList::loadClassSettings(gdioutput &gdi, string targetTag) {
 
   oEvent::ClassFilter ct = currentList.isTeamList() ? oEvent::filterOnlyMulti : oEvent::filterNone;
 
-  oe->fillClasses(gdi, "ListSelection", oEvent::extraNone, ct);
+  oe->fillClasses(gdi, "ListSelection", {}, oEvent::extraNone, ct);
   gdi.setSelection("ListSelection", currentList.getParam().selection);
   gdi.dropLine(2.5);
 
@@ -2184,14 +2180,15 @@ void TabList::loadClassSettings(gdioutput &gdi, string targetTag) {
   ages.emplace_back(lang.tl("Alla"), size_t(oListParam::AgeFilter::All));
   ages.emplace_back(lang.tl("Ungdom"), size_t(oListParam::AgeFilter::OnlyYouth));
   ages.emplace_back(lang.tl("Vuxna"), size_t(oListParam::AgeFilter::ExludeYouth));
-  gdi.addItem("AgeFilter", ages);
+  gdi.setItems("AgeFilter", ages);
   gdi.selectItemByData("AgeFilter", int(currentList.getParam().ageFilter));
 
   gdi.addCheckbox("PageBreak", "Sidbrytning mellan klasser", 0, currentList.getParam().pageBreak).setHandler(&settingsClassSelection);
   gdi.addCheckbox("ShowHeader", "Visa rubrik", 0, currentList.getParam().showHeader).setHandler(&settingsClassSelection);
 
   gdi.dropLine(-0.3);
-  gdi.addInput("Heading", currentList.getParam().getCustomTitle(wstring(L"")), 28, 0, L"Egen listrubrik:");
+  wstring hdr;
+  gdi.addInput("Heading", currentList.getParam().getCustomTitle(hdr), 28, 0, L"Egen listrubrik:");
   gdi.setInputStatus("Heading", currentList.getParam().showHeader);
   gdi.dropLine(0.5);
   gdi.fillRight();
@@ -2305,7 +2302,7 @@ void TabList::settingsResultList(gdioutput &gdi)
   }
   sort(lists.begin() + startIx, lists.end());
 
-  gdi.addItem("ResultType", lists);
+  gdi.setItems("ResultType", lists);
   gdi.autoGrow("ResultType");
 
   int lastSelectedResultListOK = -1;
@@ -2615,7 +2612,7 @@ bool TabList::loadPage(gdioutput &gdi)
     gdi.pushX();
 
     gdi.addSelection("SavedInstance", 250, 200, ListsCB);
-    gdi.addItem("SavedInstance", savedParams);
+    gdi.setItems("SavedInstance", savedParams);
     gdi.autoGrow("SavedInstance");
     gdi.selectFirstItem("SavedInstance");
     gdi.addButton("ShowSaved", "Visa", ListsCB);
@@ -2796,7 +2793,7 @@ void TabList::splitPrintSettings(oEvent &oe, gdioutput &gdi, bool setupPrinter,
     lists.insert(lists.begin(), make_pair(lang.tl("Standard"), -10));
     lists.insert(lists.begin(), make_pair(lang.tl("Automatisk"), -11));
 
-    gdi.addItem("SplitPrintList", lists);
+    gdi.setItems("SplitPrintList", lists);
     gdi.autoGrow("SplitPrintList");
 
     gdi.dropLine(0.8);
@@ -2870,7 +2867,7 @@ void TabList::splitPrintSettings(oEvent &oe, gdioutput &gdi, bool setupPrinter,
       for (size_t j = 1; j < 8; j++)
         nsp.push_back(make_pair(itow(j), j));
       gdi.addSelection("NumPerPage", 90, 200, ListsCB, L"Max antal brickor per sida");
-      gdi.addItem("NumPerPage", nsp);
+      gdi.setItems("NumPerPage", nsp);
       gdi.selectItemByData("NumPerPage", printLen);
 
       int maxWait = oe.getPropertyInt("SplitPrintMaxWait", 60);
@@ -2924,7 +2921,7 @@ void TabList::customTextLines(oEvent &oe, const char *dataField, bool withSymbol
     gdi.addInput(row, L"", 24);
     string key = "font"+itos(k);
     gdi.addSelection(key, 100, 100);
-    gdi.addItem(key, fonts);
+    gdi.setItems(key, fonts);
     if (lines.size() > size_t(k)) {
       gdi.selectItemByData(key.c_str(), lines[k].second);
       gdi.setText(row, lines[k].first);
@@ -2947,7 +2944,7 @@ void TabList::customTextLines(oEvent &oe, const char *dataField, bool withSymbol
     gdi.setTabStops("Symbols", 300);
     vector < pair<wstring, size_t>> symb;
     MetaList::fillSymbols(symb);
-    gdi.addItem("Symbols", symb);
+    gdi.setItems("Symbols", symb);
     gdi.popX();
     gdi.popY();
   }
@@ -3010,38 +3007,29 @@ void TabList::setResultOptionsFromType(gdioutput &gdi, int data) {
 
     gdi.setInputStatus("ShowInterResults", builtIn);
     gdi.setInputStatus("ShowSplits", builtIn);
-      
-
+ 
     set<int> clsUnused;
     vector< pair<wstring, size_t> > out;
       
     oe->fillLegNumbers(clsUnused, li.isTeamList(), true, out);
-    gdi.addItem("LegNumber", out);
+    gdi.setItems("LegNumber", out);
     gdi.setInputStatus("LegNumber", !out.empty());
     
     if (!out.empty() && lastLeg >= 0)
       gdi.selectItemByData("LegNumber", lastLeg);
   
-    //oe->fillLegNumbers(gdi, "LegNumber", li.isTeamList(), true);
     gdi.setInputStatus("InputNumber", false);
   }
-  else {
-      
+  else {     
     gdi.setInputStatus("UseLargeSize", li.supportLarge);
     gdi.setInputStatus("InputNumber", li.supportParameter);
   
-    //gdi.setInputStatus("SplitAnalysis", li.supportSplitAnalysis);
-    //gdi.setInputStatus("ShowInterResults", li.supportInterResults);
-    //gdi.setInputStatus("PageBreak", li.supportPageBreak);
-    //gdi.setInputStatus("ClassLimit", li.supportClassLimit);
-      
     if (li.supportLegs) {
       gdi.enableInput("LegNumber");
-      //oe->fillLegNumbers(gdi, "LegNumber", li.isTeamList(), true);
       set<int> clsUnused;
       vector< pair<wstring, size_t> > out;
       oe->fillLegNumbers(clsUnused, li.isTeamList(), true, out);
-      gdi.addItem("LegNumber", out);
+      gdi.setItems("LegNumber", out);
       if (!out.empty() && lastLeg >= 0)
         gdi.selectItemByData("LegNumber", lastLeg);
       gdi.setInputStatus("LegNumber", !out.empty());
@@ -3091,16 +3079,23 @@ void TabList::setResultOptionsFromType(gdioutput &gdi, int data) {
   if (lastFilledResultClassType != ct) {
     lastFilledResultClassType = ct;
     lastResultClassSelection.insert(curSel.begin(), curSel.end());
-    oe->fillClasses(gdi, "ListSelection", oEvent::extraNone, ct);
+    oe->fillClasses(gdi, "ListSelection", {}, oEvent::extraNone, ct);
     gdi.setSelection("ListSelection", lastResultClassSelection);
   }
 
-  gdi.setInputStatus("Generate", data >= 0 && !lastResultClassSelection.empty());
+  gdi.setInputStatus("Generate", data >= 0 && hasSelectedClass(gdi));
+}
+
+bool TabList::hasSelectedClass(gdioutput& gdi) {
+  set<int> sel;
+  gdi.getSelection("ListSelection", sel);
+  return !sel.empty();
 }
 
 void TabList::clearCompetitionData() {
   SelectedList = "";
   lastResultClassSelection.clear();
+  lastClassSelection.clear();
 
   ownWindow = false;
   hideButtons = false;
diff --git a/code/TabList.h b/code/TabList.h
index 425653a..2223ce2 100644
--- a/code/TabList.h
+++ b/code/TabList.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -49,6 +49,8 @@ protected:
 
   static void createListButtons(gdioutput &gdi);
 
+  static bool hasSelectedClass(gdioutput& gdi);
+
   void generateList(gdioutput &gdi, bool forceUpdate = false);
   void selectGeneralList(gdioutput &gdi, EStdListType type);
 
@@ -124,7 +126,7 @@ public:
   static void enableFromTo(oEvent &oe, gdioutput &gdi, bool from, bool to);
   void liveResult(gdioutput &gdi, oListInfo &currentList);
 
-  int listCB(gdioutput &gdi, int type, void *data);
+  int listCB(gdioutput &gdi, GuiEventType type, BaseInfo *data);
   void loadGeneralList(gdioutput &gdi);
   void rebuildList(gdioutput &gdi);
   void settingsResultList(gdioutput &gdi);
diff --git a/code/TabMulti.cpp b/code/TabMulti.cpp
index 94b7280..5e0302b 100644
--- a/code/TabMulti.cpp
+++ b/code/TabMulti.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/TabMulti.h b/code/TabMulti.h
index 8e631bd..6c75fda 100644
--- a/code/TabMulti.h
+++ b/code/TabMulti.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/TabRunner.cpp b/code/TabRunner.cpp
index f93f927..a37213f 100644
--- a/code/TabRunner.cpp
+++ b/code/TabRunner.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -51,16 +51,13 @@
 #include "autocomplete.h"
 #include "RunnerDB.h"
 
-int SportIdentCB(gdioutput *gdi, int type, void *data);
+int SportIdentCB(gdioutput *gdi, GuiEventType type, BaseInfo *data);
 
-TabRunner::TabRunner(oEvent *poe):TabBase(poe)
-{
+TabRunner::TabRunner(oEvent *poe):TabBase(poe) {
   clearCompetitionData();
 }
 
-TabRunner::~TabRunner(void)
-{
-}
+TabRunner::~TabRunner(void) = default;
 
 void disablePunchCourse(gdioutput &gdi);
 
@@ -91,6 +88,7 @@ void TabRunner::enableControlButtons(gdioutput &gdi, bool enable, bool vacant)
     gdi.enableInput("Remove");
     gdi.enableInput("Save");
     gdi.enableInput("Undo");
+    gdi.enableInput("EditAnnotation");
     if (vacant) {
       gdi.disableInput("Move", true);
       gdi.disableInput("NoStart", true);
@@ -104,12 +102,16 @@ void TabRunner::enableControlButtons(gdioutput &gdi, bool enable, bool vacant)
     gdi.disableInput("Remove");
     gdi.disableInput("Save");
     gdi.disableInput("Undo");
+    gdi.disableInput("EditAnnotation");
     gdi.disableInput("Move", true);
     gdi.disableInput("NoStart", true);
   }
 }
 
 void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
+  if (gdioutput* gdi_comments = getExtraWindow("comments", false); gdi_comments)
+    gdi_comments->closeWindow();
+
   if (!r) {
     runnerId = 0;
     gdi.setText("Name", L"");
@@ -118,7 +120,6 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
     updateNumShort(gdi, 0, 0);
     //Don't clear club and class
 
-
     gdi.setText("CardNo", L"");
     gdi.enableInput("Start");
     gdi.setText("Start", makeDash(L"-"));
@@ -157,6 +158,8 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
         gdi.setText("PointIn", L"");
     }
 
+    loadExtraFields(gdi, nullptr);
+    gdi.restore("Annotation");
     return;
   }
 
@@ -186,8 +189,7 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
   if (ci) {
     ci->setExtra(r->getClubId());
   }
-  oe->fillClasses(gdi, "RClass", oEvent::extraNone, oEvent::filterNone);
-  gdi.addItem("RClass", lang.tl("Ingen klass"), 0);
+  oe->fillClasses(gdi, "RClass", {make_pair(lang.tl("Ingen klass"), 0)}, oEvent::extraNone, oEvent::filterNone);
   gdi.selectItemByData("RClass", r->getClassId(true));
 
   if (gdi.hasWidget("EditTeam")) {
@@ -207,8 +209,8 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
   vector<int> delta;
   vector<int> place;
   vector<int> after;
-  vector<int> placeAcc;
-  vector<int> afterAcc;
+  vector<oRunner::ResultData> placeAcc;
+  vector<oRunner::ResultData> afterAcc;
 
   r->getSplitAnalysis(delta);
   r->getLegTimeAfter(after);
@@ -221,13 +223,13 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
   for (size_t k = 0; k < delta.size(); k++) {
     out += itow(place[k]);
     if (k < placeAcc.size())
-      out += L" (" + itow(placeAcc[k]) + L")";
+      out += L" (" + itow(placeAcc[k].get(false)) + L")";
 
     if (after[k] > 0)
       out += L" +" + formatTimeMS(after[k], false);
 
-    if (k < afterAcc.size() && afterAcc[k]>0)
-      out += L" (+" + formatTimeMS(afterAcc[k], false) + L")";
+    if (k < afterAcc.size() && afterAcc[k].get(false)>0)
+      out += L" (+" + formatTimeMS(afterAcc[k].get(false), false) + L")";
 
     if (delta[k] > 0)
       out += L" B: " + formatTimeMS(delta[k], false);
@@ -258,7 +260,6 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
       gdi.selectItemByData("MultiR", r->getRaceNo());
     }
   }
-  oe->fillCourses(gdi, "RCourse", true);
   wstring crsName;
   if (r->getCourse(false))
     crsName = r->getCourse(false)->getName();
@@ -273,7 +274,10 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
   else if (crsName.empty())
     crsName += L" ";
 
-  gdi.addItem("RCourse", crsName + courseType, 0);
+  oe->fillCourses(gdi, "RCourse", { make_pair(L"X", 0)}, true);
+  gdi.modifyItemDescription("RCourse", 0, crsName + courseType);
+
+  //gdi.addItem("RCourse", crsName + courseType, 0);
   gdi.selectItemByData("RCourse", r->getCourseId());
   updateNumShort(gdi, r->getCourse(false), r);
 
@@ -282,7 +286,7 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
 
   warnDuplicateCard(gdi, cno, r);
 
-  gdi.check("RentCard", r->isHiredCard());
+  gdi.check("RentCard", r->isRentalCard());
   bool hasFee = gdi.hasWidget("Fee");
 
   if (hasFee)
@@ -335,9 +339,12 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
   if (pc) {
     gdi.setTabStops("Punches", 70);
     pc->fillPunches(gdi, "Punches", pcourse);
+    updateCardStatus(pc, gdi);
+  }
+  else {
+    gdi.clearList("Punches");
+    gdi.setText("CardStatus", L"", true);
   }
-  else gdi.clearList("Punches");
-
   if (pcourse) {
     pcourse->synchronize();
     gdi.setTabStops("Course", 50);
@@ -350,6 +357,10 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
     gdi.disableInput("AddAllC");
   }
 
+  loadExtraFields(gdi, r);
+
+  renderComments(gdi, *r);
+
   gdioutput *gdi_settings = getExtraWindow("ecosettings", false);
   if (gdi_settings) {
     TabRunner &dst = dynamic_cast<TabRunner&>(*gdi_settings->getTabs().get(TabType::TRunnerTab));
@@ -357,34 +368,65 @@ void TabRunner::selectRunner(gdioutput &gdi, pRunner r) {
   }
 }
 
-int RunnerCB(gdioutput *gdi, int type, void *data)
-{
-  TabRunner &tc = dynamic_cast<TabRunner &>(*gdi->getTabs().get(TRunnerTab));
+void TabRunner::updateCardStatus(const pCard& pc, gdioutput& gdi) {
+  wstring s;
+  GDICOLOR color;
+  switch (pc->isOriginalCard()) {
+  case oCard::PunchOrigin::Original:
+    s = L"Oförändrad brickdata";
+    color = GDICOLOR::colorGreen;
+    break;
+  case oCard::PunchOrigin::Manual:
+    s = L"Manuellt ändrad brickdata";
+    color = GDICOLOR::colorRed;
+    break;
+  case oCard::PunchOrigin::Unknown:
+    s = L"Okänd ursprungsstatus";
+    color = GDICOLOR::colorYellow;
+    break;
+  }
+  TextInfo* ti = (TextInfo*)gdi.setTextTranslate("CardStatus", s, true);
+  ti->setColor(color);
+}
 
+void TabRunner::updatePunchStatus(const pPunch& punch, InputInfo* ii, gdioutput& gdi) {
+  if (!punch->isOriginal()) {
+    int ot = punch->getOriginalTime();
+    ii->setBgColor(colorLightYellow).refresh();
+    if (ot > 0) {
+      gdi.updateToolTip("PTime", L"Ursprunglig tid: X#" + formatTimeHMS(ot));
+    }
+    else {
+      gdi.updateToolTip("PTime", L"Manuellt ändrad stämpling");
+    }   
+  }
+  else {
+    ii->setBgColor(colorDefault).refresh();
+    gdi.updateToolTip("PTime", L"Stämplingstid");
+  }
+}
+
+int RunnerCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
+  TabRunner &tc = dynamic_cast<TabRunner &>(*gdi->getTabs().get(TRunnerTab));
   return tc.runnerCB(*gdi, type, data);
 }
 
-int PunchesCB(gdioutput *gdi, int type, void *data)
-{
+int PunchesCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabRunner &tc = dynamic_cast<TabRunner &>(*gdi->getTabs().get(TRunnerTab));
   return tc.punchesCB(*gdi, type, data);
 }
 
-int VacancyCB(gdioutput *gdi, int type, void *data)
-{
+int VacancyCB(gdioutput *gdi, GuiEventType type, BaseInfo* data)  {
   TabRunner &tc = dynamic_cast<TabRunner &>(*gdi->getTabs().get(TRunnerTab));
-
   return tc.vacancyCB(*gdi, type, data);
 }
 
-int runnerSearchCB(gdioutput *gdi, int type, void *data)
-{
+int runnerSearchCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabRunner &tc = dynamic_cast<TabRunner &>(*gdi->getTabs().get(TRunnerTab));
-
   return tc.searchCB(*gdi, type, data);
 }
 
-int TabRunner::searchCB(gdioutput &gdi, int type, void *data) {
+int TabRunner::searchCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   static DWORD editTick = 0;
   wstring expr;
   bool showNow = false;
@@ -449,7 +491,7 @@ int TabRunner::searchCB(gdioutput &gdi, int type, void *data) {
       if (filter.empty()) {
         vector< pair<wstring, size_t> > runners;
         runners.push_back(make_pair(lang.tl(L"Ingen matchar 'X'#" + expr), -1));
-        gdi.addItem("Runners", runners);
+        gdi.setItems("Runners", runners);
       }
       else
         gdi.filterOnData("Runners", filter);
@@ -463,7 +505,7 @@ int TabRunner::searchCB(gdioutput &gdi, int type, void *data) {
 
       bool formMode = currentMode == 0;
 
-      vector< pair<wstring, size_t> > runners;
+      vector<pair<wstring, size_t>> runners;
       oe->fillRunners(runners, !formMode, formMode ? 0 : oEvent::RunnerFilterShowAll, filter);
 
       if (filter.size() == runners.size()){
@@ -474,7 +516,7 @@ int TabRunner::searchCB(gdioutput &gdi, int type, void *data) {
       }
 
       filter.swap(lastFilter);
-      gdi.addItem("Runners", runners);
+      gdi.setItems("Runners", runners);
     }
 
     if (lastFilter.size() == 1) {
@@ -588,22 +630,15 @@ pRunner TabRunner::save(gdioutput &gdi, int runnerId, bool willExit) {
     if (r->getCardNo() != cardNo) {
       r->setCardNo(cardNo, true);
     }
-    const bool hireChecked = gdi.isChecked("RentCard");
-    const bool hireState = r->isHiredCard();
-    if (hireChecked && !hireState) {
-      r->getDI().setInt("CardFee", oe->getBaseCardFee());
-    }
-    else if (!hireChecked && hireState) {
-      r->getDI().setInt("CardFee", 0);
-    }
-
+    r->setRentalCard(gdi.isChecked("RentCard"));
+    
     if (gdi.hasWidget("Fee"))
       r->getDI().setInt("Fee", oe->interpretCurrency(gdi.getText("Fee")));
 
     gdioutput *gdi_settings = getExtraWindow("ecosettings", false);
     if (gdi_settings) {
-      TabRunner &dst = dynamic_cast<TabRunner&>(*gdi_settings->getTabs().get(TabType::TRunnerTab));
-      dst.getEconomyHandler(*r)->save(*gdi_settings);
+      EconomyHandler h(*r);
+      h.save(*gdi_settings);
     }
 
     r->setStartTimeS(gdi.getText("Start"));
@@ -727,6 +762,8 @@ pRunner TabRunner::save(gdioutput &gdi, int runnerId, bool willExit) {
 
     if (r->getClassRef(false))
       r->getClassRef(false)->updateFinalClasses(r, false);
+
+    saveExtraFields(gdi, *r);
   }
   else
     runnerId=0;
@@ -742,10 +779,9 @@ pRunner TabRunner::save(gdioutput &gdi, int runnerId, bool willExit) {
   return r;
 }
 
-int TabRunner::runnerCB(gdioutput &gdi, int type, void *data)
-{
+int TabRunner::runnerCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   if (type==GUI_BUTTON){
-    ButtonInfo bi=*(ButtonInfo *)data;
+    ButtonInfo bi=dynamic_cast<ButtonInfo &>(*data);
 
     if (bi.id=="Search") {
       ListBoxInfo lbi;
@@ -813,6 +849,15 @@ int TabRunner::runnerCB(gdioutput &gdi, int type, void *data)
     else if (bi.id == "ListenReadout") {
       listenToPunches = gdi.isChecked(bi.id);
     }
+    else if (bi.id == "HideControls") {
+      hideReportControls = true;
+      listenToPunches = true;
+      PostMessage(gdi.getHWNDTarget(), WM_USER + 2, TRunnerTab, 0);
+    }
+    /*else if (bi.id == "ShowReportHeader") {
+      showReportHeader = gdi.isChecked(bi.id);
+      PostMessage(gdi.getHWNDTarget(), WM_USER + 2, TRunnerTab, 0);
+    }*/
     else if (bi.id=="Unpair") {
       ListBoxInfo lbi;
       int cid = bi.getExtraInt();
@@ -932,7 +977,7 @@ int TabRunner::runnerCB(gdioutput &gdi, int type, void *data)
       if (bi.getExtraInt() == 0) 
         r->printSplits(gdiprint);
       else
-        r->printStartInfo(gdiprint);
+        r->printStartInfo(gdiprint, true);
 
       gdiprint.print(oe, nullptr, false, true);
       gdiprint.fetchPrinterSettings(splitPrinter);
@@ -1016,12 +1061,21 @@ int TabRunner::runnerCB(gdioutput &gdi, int type, void *data)
       if (!runnerId)
         return 0;
       pRunner r = oe->getRunner(runnerId, 0);
-      if (getExtraWindow("ecosettings", true) == 0) {
+      if (r && getExtraWindow("ecosettings", true) == nullptr) {
         gdioutput *settings = createExtraWindow("ecosettings", L"Economy", gdi.scaleLength(550), gdi.scaleLength(350), true);
         TabRunner &dst = dynamic_cast<TabRunner&>(*settings->getTabs().get(TabType::TRunnerTab));
         dst.loadEconomy(*settings, *r);
       }
     }
+    else if (bi.id == "EditAnnotation") {
+      if (!runnerId)
+        return 0;
+      pRunner r = oe->getRunner(runnerId, 0);
+      if (r && getExtraWindow("comments", true) == nullptr) {
+        gdioutput* settings = createExtraWindow("comments", L"Kommentarer", gdi.scaleLength(550), gdi.scaleLength(350), true);
+        TabRunner::loadComments(*settings, *r);
+      }
+    }
     else if (bi.id=="NoStart") {
       if (!runnerId)
         return 0;
@@ -1198,8 +1252,8 @@ int TabRunner::runnerCB(gdioutput &gdi, int type, void *data)
         pRunner r = oe->getRunner(runnerId, 0);
         gdioutput *gdi_settings = getExtraWindow("ecosettings", false);
         if (gdi_settings) {
-          TabRunner &dst = dynamic_cast<TabRunner&>(*gdi_settings->getTabs().get(TabType::TRunnerTab));
-          dst.getEconomyHandler(*r)->save(*gdi_settings);
+          EconomyHandler h(*r);
+          h.save(*gdi_settings);
         }
       }
 
@@ -1225,7 +1279,14 @@ int TabRunner::runnerCB(gdioutput &gdi, int type, void *data)
         return 0;
       }
       runnerId = bi.data;
-      //loadPage(gdi);
+      PostMessage(gdi.getHWNDTarget(), WM_USER + 2, TRunnerTab, 0);
+    }
+    else if (bi.id == "NumCols") {
+      numReportColumn = bi.data;
+      PostMessage(gdi.getHWNDTarget(), WM_USER + 2, TRunnerTab, 0);
+    }
+    else if (bi.id == "NumRows") {
+      numReportRow = bi.data;
       PostMessage(gdi.getHWNDTarget(), WM_USER + 2, TRunnerTab, 0);
     }
     else if (bi.id=="RClass") {
@@ -1259,8 +1320,10 @@ int TabRunner::runnerCB(gdioutput &gdi, int type, void *data)
 
         ListBoxInfo rcrs;
         gdi.getSelectedItem("RCourse", rcrs);
-        oe->fillCourses(gdi, "RCourse", true);
-        gdi.addItem("RCourse", crsName + lang.tl("[Klassens bana]"), 0);
+        oe->fillCourses(gdi, "RCourse", { make_pair(L"X", 0)}, true);
+        //gdi.addItem("RCourse", crsName + lang.tl("[Klassens bana]"), 0);
+        gdi.modifyItemDescription("RCourse", 0, crsName + lang.tl("[Klassens bana]"));
+
         gdi.selectItemByData("RCourse", rcrs.data);
       }
 
@@ -1322,24 +1385,20 @@ int TabRunner::runnerCB(gdioutput &gdi, int type, void *data)
       
       cellAction(gdi, ei.getData(), b);
     }
-    else if ((ei.id == "DataUpdate") && listenToPunches && currentMode == 5) {
-      if (ei.getData() > 0) {
-        runnerId = ei.getData();
+    else if (currentMode == 5 && ei.id == "PunchCard") {
+      if (listenToPunches && ei.getData() > 0) {
+        addToReport(ei.getData(), true);
+
+        loadPage(gdi);
       }
-      loadPage(gdi);
     }
-    else if ((ei.id == "ReadCard") &&
-            (listenToPunches || oe->isReadOnly()) && currentMode == 5) {
-      if (ei.getData() > 0) {
-        vector<pRunner> rs;
-        oe->getRunnersByCardNo(ei.getData(), true, oEvent::CardLookupProperty::Any, rs);
-        if (!rs.empty()) {
-          runnersToReport.resize(rs.size());
-          for (size_t k = 0; k<rs.size(); k++)
-            runnersToReport[k] = make_pair(rs[k]->getId(), false);
-        }
-        runnerId = 0;
-      }
+    else if (currentMode == 5 && ei.id == "DataUpdate" && currentMode == 5) {
+      showRunnerReport(gdi);
+    }
+    else if (currentMode == 5 && ei.id == "ReadCard" &&
+            (listenToPunches || oe->isKiosk())) {
+      if (ei.getData() > 0)
+        addToReport(ei.getData(), oe->isKiosk());
       loadPage(gdi);
     }
   }
@@ -1452,10 +1511,9 @@ void TabRunner::showCardsList(gdioutput &gdi)
   gdi.refresh();
 }
 
-int TabRunner::vacancyCB(gdioutput &gdi, int type, void *data)
-{
+int TabRunner::vacancyCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   if (type == GUI_BUTTON) {
-    ButtonInfo bi=*(ButtonInfo *)data;
+    ButtonInfo bi = dynamic_cast<ButtonInfo &>(*data);
     TabSI &tsi = dynamic_cast<TabSI &>(*gdi.getTabs().get(TSITab));
 
     if (bi.id == "VacancyAdd") {
@@ -1524,17 +1582,9 @@ int TabRunner::vacancyCB(gdioutput &gdi, int type, void *data)
     r->getDI().setDate("EntryDate", getLocalDate());
     r->getDI().setInt("EntryTime", getLocalAbsTime());
     r->addClassDefaultFee(false);
-    int cardFee = 0;
-
-    if (gdi.isChecked("RentCard")) {
-      cardFee = oe->getBaseCardFee();
-      r->getDI().setInt("CardFee", cardFee);
-    }
-    else
-      r->getDI().setInt("CardFee", 0);
     
-    if (cardFee < 0)
-      cardFee = 0;
+    r->setRentalCard(gdi.isChecked("RentCard"));
+    int cardFee = r->getRentalCardFee(true);
     fee = r->getDCI().getInt("Fee");
     
     TabSI::writePayMode(gdi, fee + cardFee, *r);  
@@ -1554,7 +1604,7 @@ int TabRunner::vacancyCB(gdioutput &gdi, int type, void *data)
     TabSI &tsi = dynamic_cast<TabSI &>(*gdi.getTabs().get(TSITab));
     
     // Print start certificate
-    tsi.generateStartInfo(gdi, *r);
+    tsi.generateStartInfo(gdi, *r, true);
 
     showVacancyList(gdi, "", r->getClassId(true));
   }
@@ -1610,127 +1660,392 @@ void TabRunner::setCardNo(gdioutput &gdi, int cardNo) {
   }
 }
 
+string TabRunner::computeKeyForReport() {
+  string key = itos(runnersToReport.size());
+  for (auto &id : runnersToReport) {
+    key += "|" + itos(id.first);
+    pRunner r = oe->getRunner(id.first, 0);
+    if (r) {
+      key += gdioutput::toUTF8(r->getCompleteIdentification() + r->getClass(true));
+      key += itos(r->getStatus()) + itos(r->getFinishTime()) + itos(r->getStartTime());
+      vector<pFreePunch> pl;
+      oe->getPunchesForRunner(id.first, true, pl);
+      for (auto p : pl)
+        key += itos(p->getTimeInt());
+
+      if (r->getCard()) {
+        auto ch = r->getCard()->getCardHash();
+        key += itos(ch.first) + itos(ch.second);
+      }
+    }
+  }
+  return key;
+}
+
 void TabRunner::showRunnerReport(gdioutput &gdi) {
+  string oldHash, newHash = computeKeyForReport();
+ 
+  if (gdi.getData("ReportHash", oldHash) && oldHash == newHash)
+    return;
+  
   gdi.clearPage(true);
+  gdi.setData("ReportHash", newHash);
   currentMode = 5;
 
-  if (!ownWindow && !oe->isReadOnly())
+  if (!ownWindow && !oe->isKiosk())
     addToolbar(gdi);
-  else if (oe->isReadOnly())
+  else if (oe->isKiosk() && !listenToPunches)
     gdi.addString("", fontLarge, makeDash(L"MeOS - Resultatkiosk")).setColor(colorDarkBlue);
 
-  gdi.dropLine();
+  if (!hideReportControls) {
+    bool any = false;
+    gdi.pushX();
+    gdi.fillRight();
 
-  gdi.pushX();
-  gdi.fillRight();
-
-  gdi.addSelection("ReportRunner", 300, 300, RunnerCB);
-  oe->fillRunners(gdi, "ReportRunner", true, oEvent::RunnerFilterShowAll | oEvent::RunnerCompactMode);
-  gdi.selectItemByData("ReportRunner", runnerId);
-
-  if (!oe->isReadOnly()) {
-    if (!ownWindow) {
-      gdi.addButton("Kiosk", "Resultatkiosk", RunnerCB);
-      gdi.addButton("Window", "Eget fönster", RunnerCB, "Öppna i ett nytt fönster.");
+    if (!oe->isKiosk() || !listenToPunches) {
+      gdi.dropLine();
+      gdi.addSelection("ReportRunner", 300, 300, RunnerCB);
+      oe->fillRunners(gdi, "ReportRunner", true, oEvent::RunnerFilterShowAll | oEvent::RunnerCompactMode);
+      gdi.selectItemByData("ReportRunner", runnerId);
+      gdi.autoGrow("ReportRunner");
+      any = true;
     }
-    gdi.dropLine(0.2);
-    gdi.addCheckbox("ListenReadout", "Visa senast inlästa deltagare", RunnerCB, listenToPunches);
-  }
 
-  gdi.dropLine(3);
+    if (!oe->isKiosk() && !hideReportControls) {
+      if (!ownWindow) {
+        gdi.addButton("Kiosk", "Resultatkiosk", RunnerCB);
+        gdi.addButton("Window", "Eget fönster", RunnerCB, "Öppna i ett nytt fönster.");
+      }
+      else {
+        gdi.addButton("HideControls", "Dölj inställningar", RunnerCB);
+      }
+
+      any = true;
+      gdi.dropLine(0.2);
+      gdi.addCheckbox("ListenReadout", "Visa senast inlästa deltagare", RunnerCB, listenToPunches);
+      gdi.dropLine(2);
+      gdi.popX();
+      vector<pair<wstring, size_t>> options;
+      for (int i = 1; i <= 10; i++)
+        options.emplace_back(itow(i), i);
+
+      gdi.addString("", 0, "Layout");
+
+      gdi.addSelection("NumRows", 100, 200, RunnerCB);
+      gdi.addString("", 0, "rader");
+      gdi.setItems("NumRows", options);
+      gdi.selectItemByData("NumRows", numReportRow);
+
+      gdi.addSelection("NumCols", 100, 200, RunnerCB);
+      gdi.addString("", 0, "kolumner");
+      gdi.setItems("NumCols", options);
+      gdi.selectItemByData("NumCols", numReportColumn);
+
+      //gdi.addCheckbox("ShowReportHeader", "Visa sidhuvud", RunnerCB);
+    }
+
+    if (any)
+      gdi.dropLine(3);
+  }
   gdi.popX();
   gdi.registerEvent("DataUpdate", RunnerCB);
   gdi.registerEvent("ReadCard", RunnerCB);
-  
-  if (runnerId > 0) {
-    runnersToReport.resize(1);
-    runnersToReport[0] = make_pair(runnerId, false);
-  }
-  generateRunnerReport(*oe, gdi, runnersToReport);
+  gdi.registerEvent("PunchCard", RunnerCB);
+  gdi.setData("DataSync", 1);
+  gdi.setData("PunchSync", 1);
 
-  if (runnersToReport.size() == 1)
+  if (runnerId > 0) {
+    bool found = false;
+    addToReport(runnerId); 
+  }
+  while (runnersToReport.size() > numReportRow * numReportColumn)
+    runnersToReport.pop_back();
+
+  generateRunnerReport(*oe, gdi, numReportColumn, numReportRow, true, runnersToReport);
+
+  if (runnersToReport.size() > 0)
     runnerId = runnersToReport[0].first;
 }
 
- void TabRunner::generateRunnerReport(oEvent &oe, gdioutput &gdi, vector<pair<int, bool>> &runnersToReport) {
-   oe.synchronizeList({ oListId::oLRunnerId, oListId::oLTeamId, oListId::oLPunchId });
-  gdi.fillDown();
+void TabRunner::addToReport(int id) {
+  bool found = false;
+  for (auto& rr : runnersToReport) {
+    if (rr.first == id)
+      found = true;
+  }
+  if (!found) {
+    runnersToReport.emplace_front(id, false);
+  }
+}
 
-  cTeam t = 0;
+void TabRunner::addToReport(int cardNo, bool punchForShowReport) {
+  vector<pRunner> rs;
+  oe->getRunnersByCardNo(cardNo, true, oEvent::CardLookupProperty::Any, rs);
+
+  if (!punchForShowReport) {
+    // Take away runners with no card
+    vector<pRunner> rsFilter;
+    for (pRunner r : rs) {
+      if (r->getCard())
+        rsFilter.push_back(r);
+    }
+    rs.swap(rsFilter);
+  }
+
+  if (!rs.empty()) {
+    if (rs.size() == 1) {
+      addToReport(rs[0]->getId());
+    }
+    else {
+      map<int, vector<pRunner>> runnersPerTeam;
+      for (pRunner r : rs) {
+        if (r->getTeam())
+          runnersPerTeam[r->getTeam()->getId()].push_back(r);
+        else
+          runnersPerTeam[0].push_back(r);
+      }
+
+      for (auto& rpt : runnersPerTeam) {
+        if (rpt.second.size() == 1) {
+          addToReport(rpt.second[0]->getId());
+        }
+        else if (rpt.first == 0) {
+          sort(rpt.second.begin(), rpt.second.end(),
+            [](const pRunner& a, const pRunner& b) {return unsigned(a->getStartTime() - 1) < unsigned(b->getStartTime() - 1); });
+          // Take the last competitor using the card
+          addToReport(rpt.second.back()->getId());
+        }
+        else {
+          sort(rpt.second.begin(), rpt.second.end(),
+            [](const pRunner& a, const pRunner& b) {return a->getLegNumber() < b->getLegNumber(); });
+          bool hasResultAny = false;
+          bool done = false;
+          for (pRunner r : rpt.second) {
+            if (r->hasFinished())
+              hasResultAny = true;
+            else if (hasResultAny) {
+              // Prefer to report the next runner to run
+              addToReport(r->getId());
+              done = true;
+              break;
+            }
+          }
+          if (!done) {
+            if (hasResultAny) {
+              // Take the last one (final result)
+              addToReport(rpt.second.back()->getId());
+            }
+            else {
+              // None finished. Take first
+              addToReport(rpt.second.front()->getId());
+            }
+          }
+        }
+      }
+    }
+    /*runnersToReport.resize(rs.size());
+    for (size_t k = 0; k<rs.size(); k++)
+      runnersToReport[k] = make_pair(rs[k]->getId(), false);*/
+  }
+  runnerId = 0;
+}
+
+
+void TabRunner::generateRunnerReport(oEvent &oe, gdioutput &gdi, 
+                                      int numX, int numY,
+                                      bool onlySelectedRunner,
+                                      const deque<pair<int, bool>> &runnersToReport) {
+  oe.synchronizeList({ oListId::oLRunnerId, oListId::oLTeamId, oListId::oLPunchId });
+  gdi.fillDown();
+  int xx, yy;
+  int margin = gdi.scaleLength(16);
+  gdi.getTargetDimension(xx, yy);
+
+  int maxWidth = max(gdi.scaleLength(130 * 3) + 2*margin, xx / numX - margin * (numX + 1));
+  if (numX == 1 && numY == 1)
+    maxWidth = min(maxWidth, gdi.scaleLength(130)*6+margin);
+  
+  bool frame = true;
+
+  vector<const oTeam *> tList;
   set<int> clsSet;
+  
   for (size_t k = 0; k < runnersToReport.size(); k++) {
     pRunner r = oe.getRunner(runnersToReport[k].first, 0);
     if (!r)
       continue;
     clsSet.insert(r->getClassId(true));
-    if (r && r->getTeam()) {
+    pTeam t = r->getTeam();
+    if (t) {
       pClass cls = r->getClassRef(true);
       if (cls && cls->getClassType() != oClassRelay)
         continue;
 
-      if (t == 0)
-        t = r->getTeam();
+      bool added = count(tList.begin(), tList.end(), t) > 0;
+      if (added)
+        continue;
+      tList.push_back(t);
     }
   }
   oe.calculateResults(clsSet, oEvent::ResultType::PreliminarySplitResults, true);
   oe.calculateResults(clsSet, oEvent::ResultType::ClassResult);
 
-  if (t == 0) {
-    for (size_t k = 0; k < runnersToReport.size(); k++)
-      runnerReport(oe, gdi, runnersToReport[k].first, runnersToReport[k].second);
-  }
-  else {
-    oe.calculateTeamResults(clsSet, oEvent::ResultType::ClassResult);
+  RECT rcFrame;
+  
+  auto drawBox = [&gdi](RECT &rcFrame) {
+    RECT rc = rcFrame;
+    int mg = gdi.scaleLength(5);
+    rc.left -= mg;
+    rc.top -= mg;
+    rc.right += mg;
+    rc.bottom += mg;
+    gdi.addRectangle(rc, GDICOLOR::colorLightCyan, true, true);
+  };
 
-    set<int> selectedRunners;
-    bool selHasRes = false;
-    for (size_t k = 0; k < runnersToReport.size(); k++) {
-      selectedRunners.insert(runnersToReport[k].first);
-      pRunner r = oe.getRunner(runnersToReport[k].first, 0);
-      if (r && r->hasOnCourseResult())
-        selHasRes = true;
-    }
+  int baseX = gdi.getCX();
+  int baseY = gdi.getCY();
+  vector<RECT> rcList;
 
-    wstring tInfo = t->getName();
-    if (t->statusOK(true, true)) {
-      tInfo += L", "  + t->getRunningTimeS(true, SubSecond::Auto) +  lang.tl(", Placering: ") + t->getPlaceS();
-      if (t->getTimeAfter(-1, true) > 0)
-        tInfo += L", +" + formatTime(t->getTimeAfter(-1, true));
-    }
-    else if (t->getStatusComputed(true) != StatusUnknown) {
-      tInfo += L" " + t->getStatusS(true, true);
-    }
+  auto updatePositionDrawBox = [&](bool force) {
+    if (!force)
+      rcList.push_back(rcFrame);
 
-    gdi.addStringUT(fontMediumPlus, t->getClass(true));
-    gdi.addStringUT(boldLarge, tInfo);
-    gdi.dropLine();
-
-    bool visitedSelected = false;
-    for (int leg = 0; leg < t->getNumRunners(); leg++) {
-      if (selHasRes && visitedSelected)
-          break;
-
-      pRunner r = t->getRunner(leg);
-      pRunner nextR = t->getRunner(leg + 1);
-      bool nextSelected = nextR && selectedRunners.count(nextR->getId());
-
-      if (r) {
-        bool selected = selectedRunners.count(r->getId()) > 0;
-      
-        if (selHasRes) {
-          runnerReport(oe, gdi, r->getId(), !selected);
-        }
-        else {
-          runnerReport(oe, gdi, r->getId(), !nextSelected);
-        }
-
-        visitedSelected |= selected;
+    if ((force && !rcList.empty()) || rcList.size() == numX) {
+      int maxYP = 0;
+      for (RECT& rc : rcList)
+        maxYP = max<int>(maxYP, rc.bottom);
+      for (RECT& rc : rcList) {
+        rc.bottom = maxYP;
+        drawBox(rc);
       }
+      rcList.clear();
+      baseY = maxYP + margin;
+    }
+
+    gdi.setCY(baseY);
+    gdi.setCX(baseX + (maxWidth + margin) * rcList.size());
+  };
+
+  for (size_t k = 0; k < runnersToReport.size(); k++) {
+    pRunner r = oe.getRunner(runnersToReport[k].first, 0);
+    if (!r)
+      continue;
+
+    if (count(tList.begin(), tList.end(), r->getTeam()) == 0) {
+      runnerReport(oe, gdi, runnersToReport[k].first, runnersToReport[k].second, maxWidth, rcFrame);
+      updatePositionDrawBox(false);
     }
   }
+  if (tList.size() > 0) {
+    oe.calculateTeamResults(clsSet, oEvent::ResultType::ClassResult);
+    for (const oTeam *t : tList) {
+      teamReport(oe, gdi, t, onlySelectedRunner, runnersToReport, maxWidth, rcFrame);
+      updatePositionDrawBox(false);
+    }
+  }  
+
+  updatePositionDrawBox(true);
 }
 
-void TabRunner::runnerReport(oEvent &oe, gdioutput &gdi, int id, bool compact) {
+void TabRunner::teamReport(oEvent& oe, gdioutput& gdi,
+                           const oTeam* t,
+                           bool onlySelectedRunner,
+                           const deque<pair<int, bool>>& runnersToReport,
+                           int maxWidth,
+                           RECT& rc) {
+  rc.top = gdi.getCY();
+  rc.left = gdi.getCX();
+  rc.right = rc.left + maxWidth;
+
+  set<int> selectedRunners;
+  bool selHasPartialRes = false;
+  for (size_t k = 0; k < runnersToReport.size(); k++) {
+    pRunner r = oe.getRunner(runnersToReport[k].first, 0);
+    if (r && r->getTeam() == t) {
+      selectedRunners.insert(runnersToReport[k].first);
+      if (r && r->hasOnCourseResult())
+        selHasPartialRes = true; //Partial (radio) or complete result
+    }
+  }
+
+  wstring tInfo = t->getName();
+  if (t->statusOK(true, true)) {
+    tInfo += L", " + t->getRunningTimeS(true, SubSecond::Auto) + lang.tl(", Placering: ") + t->getPlaceS();
+    if (t->getTimeAfter(-1, true) > 0)
+      tInfo += L", +" + formatTime(t->getTimeAfter(-1, true));
+  }
+  else if (t->getStatusComputed(true) != StatusUnknown) {
+    tInfo += L" " + t->getStatusS(true, true);
+  }
+
+  gdi.addStringUT(fontMediumPlus, t->getClass(true));
+  gdi.addStringUT(boldLarge, tInfo);
+  gdi.dropLine();
+
+  pClass cls = t->getClassRef(false);
+
+  bool visitedSelected = false;
+  for (int leg = 0; leg < t->getNumRunners(); leg++) {
+    if ((selHasPartialRes || onlySelectedRunner) && visitedSelected)
+      break;
+
+    pRunner r = t->getRunner(leg);
+
+    pRunner nextR = t->getRunner(leg + 1);
+    bool nextSelected = false;
+    if (cls) {
+      // Check if leg has the selected runner (parallel legs)
+      int legNr, legOrd;
+      cls->splitLegNumberParallel(leg, legNr, legOrd);
+      int nextLeg = leg;
+      while (++nextLeg < t->getNumRunners()) {
+        int legNrN, legOrdN;
+        cls->splitLegNumberParallel(leg, legNrN, legOrdN);
+        if (legNrN == legNr + 1) {
+          nextR = t->getRunner(nextLeg);
+          nextSelected = nextR && selectedRunners.count(nextR->getId());
+          if (nextSelected)
+            break;
+        }
+      }
+    }
+    else {
+      nextSelected = nextR && selectedRunners.count(nextR->getId());
+    }
+
+    if (r) {
+      bool selected = selectedRunners.count(r->getId()) > 0;
+
+      if (onlySelectedRunner && !selected) {
+        if (!nextSelected)
+          continue; // Always skip if next is not selected
+        if (nextR->hasResult())
+          continue; // Only include previous if next does not have results
+      }
+      RECT dmy;
+      if (selHasPartialRes) {
+        // The selected runner has some result. Focus on that
+        runnerReport(oe, gdi, r->getId(), !selected, maxWidth, dmy);
+      }
+      else {
+        // The selected runner has not started. Focus on previous result
+        runnerReport(oe, gdi, r->getId(), !nextSelected, maxWidth, dmy);
+      }
+
+      visitedSelected |= selected;
+    }
+  }
+  rc.bottom = gdi.getCY();
+}
+
+void TabRunner::runnerReport(oEvent &oe, gdioutput &gdi,
+                             int id, bool compact, 
+                             int maxWidth, RECT &rc) {
+
+  rc.top = gdi.getCY();
+  rc.left = gdi.getCX();
+  rc.right = rc.left + maxWidth;
+
   pRunner r = oe.getRunner(id, 0);
   if (!r || ! r->getClassRef(false))
     return;
@@ -1739,7 +2054,8 @@ void TabRunner::runnerReport(oEvent &oe, gdioutput &gdi, int id, bool compact) {
   gdi.fillDown();
   if (r->getTeam() == 0) {
     gdi.addStringUT(fontMediumPlus, r->getClass(true));
-    gdi.addStringUT(boldLarge, r->getCompleteIdentification());
+    gdi.addStringUT(gdi.getCY(), gdi.getCX(), boldLarge, 
+                    r->getCompleteIdentification(), maxWidth - 4);
   }
   else {
     wstring s;
@@ -1784,20 +2100,31 @@ void TabRunner::runnerReport(oEvent &oe, gdioutput &gdi, int id, bool compact) {
 
   gdi.popX();
   gdi.fillRight();
+  int ww = gdi.scaleLength(120);
+  auto optionalBreakLine = [&] {
+    if (gdi.getCX() + ww > rc.left + maxWidth) {
+      gdi.popX();
+      gdi.dropLine();
+    }
+  };
 
-  if (r->getStartTime() > 0)
+  if (r->getStartTime() > 0) {
+    optionalBreakLine();
     gdi.addString("", fontMedium, L"Starttid: X  #" + r->getStartTimeCompact());
-
-  if (r->getFinishTime() > 0)
+  }
+  if (r->getFinishTime() > 0) {
+    optionalBreakLine();
     gdi.addString("", fontMedium, L"Måltid: X  #" + r->getFinishTimeS(false, SubSecond::Auto));
-
+  }
   const wstring &after = oe.formatListString(lRunnerTimeAfter, r);
   if (!after.empty()) {
+    optionalBreakLine();
     gdi.addString("", fontMedium, L"Tid efter: X  #" + after);
   }
 
   const wstring &lost = oe.formatListString(lRunnerLostTime, r);
   if (!lost.empty()) {
+    optionalBreakLine();
     gdi.addString("", fontMedium, L"Bomtid: X  #" + lost).setColor(colorDarkRed);
   }
 
@@ -1813,17 +2140,28 @@ void TabRunner::runnerReport(oEvent &oe, gdioutput &gdi, int id, bool compact) {
   int xp = gdi.getCX();
   int yp = gdi.getCY();
   int xw = gdi.scaleLength(130);
-  int cx = xp;
+  int mg4 = gdi.scaleLength(4);
+  int cx = xp + mg4;
   int limit = (9*xw)/10;
   int lh = gdi.getLineHeight();
+  int maxTimesPerLine = min(10, max(3, maxWidth / xw));
+
+  auto drawBox = [&gdi, xw, mg4, lh](int yp, int cx, GDICOLOR color) {
+    RECT rc;
+    rc.top = yp - mg4 / 2;
+    rc.bottom = yp + lh * 5 - mg4;
+    rc.left = cx - mg4;
+    rc.right = cx + xw - mg4 * 2;
+    gdi.addRectangle(rc, color);
+  };
 
   if (crs && r->getStatus() != StatusUnknown) {
     int nc = crs->getNumControls();
     vector<int> delta;
     vector<int> place;
     vector<int> after;
-    vector<int> placeAcc;
-    vector<int> afterAcc;
+    vector<oRunner::ResultData> placeAcc;
+    vector<oRunner::ResultData> afterAcc;
 
     r->getSplitAnalysis(delta);
     r->getLegTimeAfter(after);
@@ -1844,7 +2182,7 @@ void TabRunner::runnerReport(oEvent &oe, gdioutput &gdi, int id, bool compact) {
       else
         gdi.addStringUT(yp, cx, boldText, name, limit);
 
-      wstring split = r->getSplitTimeS(k, false);
+      wstring split = r->getSplitTimeS(k, false, SubSecond::Off);
 
       int bestTime = 0;
       if ( k < int(after.size()) && after[k] >= 0)
@@ -1865,14 +2203,14 @@ void TabRunner::runnerReport(oEvent &oe, gdioutput &gdi, int id, bool compact) {
       gdi.addStringUT(yp + lh, cx, fontMedium, split, limit);
 
       if (k>0 && k < int(placeAcc.size())) {
-        split = r->getPunchTimeS(k, false, false, SubSecond::Auto);
-        wstring pl = placeAcc[k] > 0 ? itow(placeAcc[k]) : L"-";
+        split = r->getPunchTimeS(k, false, false, false, SubSecond::Auto);
+        wstring pl = placeAcc[k].get(false) > 0 ? itow(placeAcc[k].get(false)) : L"-";
         if (k < int(afterAcc.size()) ) {
-          if (afterAcc[k] > 0)
-            split += L" (" + pl + L", +"  + formatTimeMS(afterAcc[k], false) + L")";
-        else if (placeAcc[k] == 1)
+          if (afterAcc[k].get(false) > 0)
+            split += L" (" + pl + L", +"  + formatTimeMS(afterAcc[k].get(false), false) + L")";
+        else if (placeAcc[k].get(false) == 1)
           split += lang.tl(" (ledare)");
-          else if (placeAcc[k] > 0)
+          else if (placeAcc[k].get(false) > 0)
             split += L" " + pl;
         }
         gdi.addStringUT(yp + 2*lh, cx, fontMedium, split, limit).setColor(colorDarkBlue);
@@ -1885,18 +2223,10 @@ void TabRunner::runnerReport(oEvent &oe, gdioutput &gdi, int id, bool compact) {
                   colorMediumDarkRed : colorMediumRed;
       }
 
-      RECT rc;
-      rc.top = yp - 2;
-      rc.bottom = yp + lh*5 - 4;
-      rc.left = cx - 4;
-      rc.right = cx + xw - 8;
-
-      gdi.addRectangle(rc, color);
-
+      drawBox(yp, cx, color);
       cx += xw;
-
-      if (k % 6 == 5) {
-        cx = xp;
+      if ( (k+1) % maxTimesPerLine == 0) {
+        cx = xp + mg4;
         yp += lh * 5;
       }
     }
@@ -1950,26 +2280,19 @@ void TabRunner::runnerReport(oEvent &oe, gdioutput &gdi, int id, bool compact) {
 
       GDICOLOR color = colorDefault;
 
-      RECT rc;
-      rc.top = yp - 2;
-      rc.bottom = yp + lh*5 - 4;
-      rc.left = cx - 4;
-      rc.right = cx + xw - 8;
-
-      gdi.addRectangle(rc, color);
+      drawBox(yp, cx, color);
       cx += xw;
-      if (k % 6 == 5) {
-        cx = xp;
+      if ((k + 1) % maxTimesPerLine == 0) {
+        cx = xp + mg4;
         yp += lh * 5;
       }
     }
   }
 
-  gdi.dropLine(3);
   gdi.popX();
+  rc.bottom = gdi.getCY();
 }
 
-
 void TabRunner::showVacancyList(gdioutput &gdi, const string &method, int classId)
 {
   gdi.clearPage(true);
@@ -2328,7 +2651,7 @@ void TabRunner::updateStatus(gdioutput &gdi, pRunner r) {
   }
 }
 
-int TabRunner::punchesCB(gdioutput &gdi, int type, void *data) {
+int TabRunner::punchesCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   DWORD rid = runnerId;
   if (!rid)
     return 0;
@@ -2340,7 +2663,7 @@ int TabRunner::punchesCB(gdioutput &gdi, int type, void *data) {
     return 0;
   }
   if (type == GUI_LISTBOXSELECT) {
-    ListBoxInfo bi = *(ListBoxInfo *)data;
+    ListBoxInfo bi = dynamic_cast<ListBoxInfo &>(*data);
     if (bi.id == "Course") {
       if (signed(bi.data) >= 0) {
         pCourse pc = r->getCourse(true);
@@ -2351,7 +2674,7 @@ int TabRunner::punchesCB(gdioutput &gdi, int type, void *data) {
     }
   }
   else if (type == GUI_LISTBOX) {
-    ListBoxInfo bi = *(ListBoxInfo *)data;
+    ListBoxInfo bi = dynamic_cast<ListBoxInfo&>(*data);
 
     if (bi.id == "Punches") {
       if (bi.data != -1) {
@@ -2363,10 +2686,11 @@ int TabRunner::punchesCB(gdioutput &gdi, int type, void *data) {
 
         wstring ptime;
         if (punch->getTimeInt() > 0)
-         ptime = punch->getTime(false, SubSecond::Auto);
+          ptime = punch->getTime(false, SubSecond::Auto);
+
+        BaseInfo *bb = gdi.setText("PTime", ptime);
+        updatePunchStatus(punch, (InputInfo *)bb, gdi);
 
-        gdi.setText("PTime", ptime);
-        
         gdi.enableInput("SaveC");
         
         gdi.enableInput("RemoveC");
@@ -2395,7 +2719,7 @@ int TabRunner::punchesCB(gdioutput &gdi, int type, void *data) {
     }
   }
   else if (type == GUI_BUTTON) {
-    ButtonInfo bi = *(ButtonInfo *)data;
+    ButtonInfo bi = dynamic_cast<ButtonInfo &>(*data);
     pCard card = r->getCard();
 
     if (!card) {
@@ -2444,6 +2768,7 @@ int TabRunner::punchesCB(gdioutput &gdi, int type, void *data) {
       r->hasManuallyUpdatedTimeStatus();
       card->fillPunches(gdi, "Punches", pc);
       updateStatus(gdi, r);
+      updateCardStatus(card, gdi);
     }
     else if (bi.id == "AddAllC") {
       vector<int> mp;
@@ -2465,6 +2790,7 @@ int TabRunner::punchesCB(gdioutput &gdi, int type, void *data) {
       card->fillPunches(gdi, "Punches", r->getCourse(true));
       r->hasManuallyUpdatedTimeStatus();
       updateStatus(gdi, r);
+      updateCardStatus(card, gdi);
     }
     else if (bi.id == "SaveC") {
       if (!savePunchTime(r, gdi))
@@ -2473,22 +2799,7 @@ int TabRunner::punchesCB(gdioutput &gdi, int type, void *data) {
 
       if (!gdi.getSelectedItem("Punches", lbi))
         return 0;
-      /*
-            pCard pc=r->getCard();
-
-            if (!pc) return 0;
-
-            pPunch pp = pc->getPunchByIndex(lbi.data);
-
-            if (!pp)
-              throw meosException("Punch not found.");
-
-            pc->setPunchTime(pp, gdi.getText("PTime"));
-
-            r->evaluateCard(true, mp);
-
-            //synchronize SQL
-            card->synchronize();*/
+      
       vector<int> mp;
       r->synchronize();
       r->evaluateCard(true, mp, 0, oBase::ChangeType::Quiet);
@@ -2517,6 +2828,9 @@ bool TabRunner::savePunchTime(pRunner r, gdioutput &gdi) {
     
   card->setPunchTime(pp, gdi.getText("PTime"));
 
+  updatePunchStatus(pp, (InputInfo*)&gdi.getBaseInfo("PTime"), gdi);
+  updateCardStatus(card, gdi);
+
   vector<int> mp;
   r->evaluateCard(true, mp, 0, oBase::ChangeType::Update);
 
@@ -2530,7 +2844,7 @@ bool TabRunner::loadPage(gdioutput &gdi)
 {
   oe->reEvaluateAll(set<int>(), true);
 
-  if (oe->isReadOnly())
+  if (oe->isKiosk())
     currentMode = 5; // Evaluate result
   else {
     clearInForestData();
@@ -2584,7 +2898,7 @@ bool TabRunner::loadPage(gdioutput &gdi)
   gdi.popX();
 
   gdi.fillDown();
-  gdi.addListBox("Runners", 206, 420, RunnerCB).isEdit(false).ignore(true);
+  gdi.addListBox("Runners", 206, 440, RunnerCB).isEdit(false).ignore(true);
   gdi.setInputFocus("Runners");
   fillRunnerList(gdi);
 
@@ -2621,18 +2935,16 @@ bool TabRunner::loadPage(gdioutput &gdi)
     gdi.disableInput("Team");
     gdi.fillDown();
     gdi.dropLine(0.9);
-    gdi.addButton("EditTeam", "...", RunnerCB, "Hantera laget");
+    gdi.addButton("EditTeam", L"\u21BA", RunnerCB, L"Hantera laget");
     gdi.popX();
   }
 
   gdi.fillRight();
   bool hasEco = oe->getMeOSFeatures().hasFeature(MeOSFeatures::Economy);
   gdi.addSelection("RClass", hasEco ? 130 : 170, 300, RunnerCB, L"Klass:");
-  oe->fillClasses(gdi, "RClass", oEvent::extraNone, oEvent::filterNone);
-  gdi.addItem("RClass", lang.tl("Ingen klass"), 0);
-
+  oe->fillClasses(gdi, "RClass", {make_pair(lang.tl("Ingen klass"), 0)}, oEvent::extraNone, oEvent::filterNone);
+  
   if (hasEco) {
-    //gdi.addInput("Fee", L"", 4, 0, L"Avgift:");
     gdi.fillDown();
     gdi.dropLine();
     gdi.addButton("Economy", "Ekonomi...", RunnerCB, "");
@@ -2662,8 +2974,11 @@ bool TabRunner::loadPage(gdioutput &gdi)
 
   if (!oe->getMeOSFeatures().withoutCourses(*oe)) {
     gdi.addSelection("RCourse", numSL == 0 ? 220 : 180, 300, RunnerCB, L"Bana:");
-    oe->fillCourses(gdi, "RCourse", true);
-    gdi.addItem("RCourse", lang.tl("[Klassens bana]"), 0);
+    oe->fillCourses(gdi, "RCourse", { make_pair(L"X", 0) }, true);
+    gdi.modifyItemDescription("RCourse", 0, lang.tl("[Klassens bana]"));
+
+    //oe->fillCourses(gdi, "RCourse", true);
+    //gdi.addItem("RCourse", lang.tl("[Klassens bana]"), 0);
 
     if (numSL > 0) {
       gdi.fillDown();
@@ -2679,7 +2994,7 @@ bool TabRunner::loadPage(gdioutput &gdi)
           data.push_back(make_pair(itow(i), i));
         }
       }
-      gdi.addItem("NumShort", data);
+      gdi.setItems("NumShort", data);
       gdi.popX();
     }
   }
@@ -2764,12 +3079,13 @@ bool TabRunner::loadPage(gdioutput &gdi)
     rc.bottom = gdi.getCY();
 
     gdi.addRectangle(rc, colorLightGreen, true, false);
-    gdi.dropLine();
-    gdi.popX();
   }
-  else
-     gdi.dropLine(1.0);
- 
+
+  addExtraFields(*oe, gdi, oEvent::ExtraFieldContext::Runner);
+
+  gdi.dropLine(0.5);
+  gdi.popX();
+
   gdi.fillRight();
   gdi.addButton("Save", "Spara", RunnerCB, "help:save").setDefault();
   gdi.addButton("Undo", "Ångra", RunnerCB);
@@ -2777,6 +3093,10 @@ bool TabRunner::loadPage(gdioutput &gdi)
   gdi.popX();
   gdi.addButton("Remove", "Radera", RunnerCB);
   gdi.addButton("Add", "Ny deltagare", RunnerCB);
+  gdi.popX();
+  gdi.dropLine(2.2);
+  gdi.addButton("EditAnnotation", L"Kommentar >>", RunnerCB, L"Lägg till eller redigera kommentarer om deltagaren.");
+
   enableControlButtons(gdi, false, false);
   gdi.fillDown();
 
@@ -2786,12 +3106,16 @@ bool TabRunner::loadPage(gdioutput &gdi)
   gdi.setCX(hx + gdi.scaleLength(5));
 
   gdi.dropLine(2.0);
-  gdi.addListBox("Punches", 150, 300, PunchesCB, L"Stämplingar:").ignore(true);
+  gdi.addListBox("Punches", 170, 360, PunchesCB, L"Stämplingar:").ignore(true);
+
+  gdi.addString("CardStatus", 0, " ");
+  gdi.dropLine(0.5);
+  int bxy = gdi.getCY();
   gdi.addButton("RemoveC", "Ta bort stämpling >>", RunnerCB);
 
   gdi.pushX();
   gdi.fillRight();
-  gdi.addInput("PTime", L"", 8, 0, L"", L"Stämplingstid");
+  gdi.addInput("PTime", L"", 8, PunchesCB, L"", L"Stämplingstid");
   gdi.fillDown();
   gdi.addButton("SaveC", "Spara tid", PunchesCB);
   gdi.popX();
@@ -2803,7 +3127,9 @@ bool TabRunner::loadPage(gdioutput &gdi)
   gdi.setCY(hy);
   gdi.dropLine(2.0);
   gdi.fillDown();
-  gdi.addListBox("Course", 140, 300, PunchesCB, L"Banmall:").ignore(true);
+  gdi.addListBox("Course", 140, 360, PunchesCB, L"Banmall:").ignore(true);
+  
+  gdi.setCY(bxy);
   gdi.addButton("AddC", "<< Lägg till stämpling", PunchesCB);
   gdi.addButton("AddAllC", "<< Lägg till alla", PunchesCB);
 
@@ -2816,14 +3142,10 @@ bool TabRunner::loadPage(gdioutput &gdi)
   
   gdi.dropLine(0.2);
   gdi.fillRight();
-  gdi.addButton(gdi.getCX(), gdi.getCY(), gdi.scaleLength(120), "SplitPrint", 
-                "Sträcktider", RunnerCB, "", false, false).isEdit(true).setExtra(0);
+  gdi.addButton("SplitPrint", "Sträcktider", RunnerCB).isEdit(true).setExtra(0);
   gdi.addButton("PrintSettings", "...", RunnerCB, "Inställningar").isEdit(true).setExtra(0);
 
-  gdi.dropLine(2.5);
-  gdi.setCX(contX);
-  gdi.addButton(gdi.getCX(), gdi.getCY(), gdi.scaleLength(120), "SplitPrint", 
-                "Startbevis", RunnerCB, "", false, false).isEdit(true).setExtra(1);
+  gdi.addButton("SplitPrint", "Startbevis", RunnerCB).isEdit(true).setExtra(1);
   gdi.addButton("PrintSettings", "...", RunnerCB, "Inställningar").isEdit(true).setExtra(1);
   gdi.pushY();
 
@@ -2850,6 +3172,191 @@ bool TabRunner::loadPage(gdioutput &gdi)
   return true;
 }
 
+int TabRunner::addExtraFields(const oEvent &oe, gdioutput& gdi, oEvent::ExtraFieldContext context) {
+  map<oEvent::ExtraFields, wstring> extraFields = oe.getExtraFields(context);
+
+  if (!extraFields.empty())
+    gdi.dropLine(1.5);
+
+  gdi.fillRight();
+  gdi.pushX();
+  int colCount = 0;
+  int baseY = gdi.getCY();
+  bool firstLabel = true;
+  int lastLabelX = 0;
+
+  auto newLine = [&colCount, context, &gdi, &baseY, &lastLabelX]() {
+    if (context != oEvent::ExtraFieldContext::DirectEntry) {
+      const int limit = context == oEvent::ExtraFieldContext::Class ? 3 : 2;
+      if (colCount >= limit) {
+        gdi.dropLine(2);
+        baseY = gdi.getCY();
+        gdi.popX();
+        lastLabelX = 0;
+        colCount = 0;
+      }
+    }
+  };
+  
+  auto addLabel = [context, &gdi, &baseY, &firstLabel, &lastLabelX](const wstring& label) {
+    if (context == oEvent::ExtraFieldContext::DirectEntry) {
+      if (firstLabel)
+        firstLabel = false;
+      else {
+        gdi.setCX(gdi.getCX() + gdi.scaleLength(12));
+      }
+      gdi.dropLine(0.2);
+      gdi.addString("", 0, label);
+      gdi.dropLine(-0.2);
+    }
+    else {
+      gdi.setCX(std::max(gdi.getCX(), lastLabelX));
+      int cx = gdi.getCX();
+      gdi.addString("", baseY, cx, 0, label);
+      lastLabelX = gdi.getCX();
+      gdi.setCX(cx);
+      gdi.setCY(baseY + gdi.getLineHeight() + gdi.scaleLength(2));
+    }
+  };
+
+  if (extraFields.count(oEvent::ExtraFields::Sex)) {
+    addLabel(L"Kön:");
+    gdi.addSelection("Sex", 100, 100);
+    gdi.addItem("Sex", lang.tl("Man"), 0);
+    gdi.addItem("Sex", lang.tl("Kvinna"), 1);
+    gdi.addItem("Sex", makeDash(L"-"), 2);
+    colCount++;
+    newLine();
+  }
+
+  if (extraFields.count(oEvent::ExtraFields::BirthDate)) {
+    addLabel(L"Födelsedatum:");
+    gdi.addInput("BirthDate", L"", 8);
+    colCount++;
+    newLine();
+  }
+
+
+  if (extraFields.count(oEvent::ExtraFields::StartTime)) {
+    addLabel(L"Starttid:");
+    gdi.addInput("StartTime", L"", 5);
+    colCount++;
+  }
+
+  if (extraFields.count(oEvent::ExtraFields::Bib)) {
+    addLabel(L"Nummerlapp:");
+    gdi.addInput("Bib", L"", 5);
+    colCount++;
+    newLine();
+  }
+
+  if (extraFields.count(oEvent::ExtraFields::Phone)) {
+    addLabel(L"Telefon:");
+    gdi.addInput("Phone", L"", 12);
+    colCount++;
+    newLine();
+  }
+
+  if (auto res = extraFields.find(oEvent::ExtraFields::DataA); res != extraFields.end()) {
+    addLabel(L"#" + ensureEndingColon(res->second));
+    gdi.addInput("DataA", L"", 8);
+    colCount++;
+    newLine();
+  }
+
+  if (auto res = extraFields.find(oEvent::ExtraFields::DataB); res != extraFields.end()) {
+    addLabel(L"#" + ensureEndingColon(res->second));
+    gdi.addInput("DataB", L"", 8, nullptr);
+    colCount++;
+    newLine();
+  }
+  
+  if (extraFields.count(oEvent::ExtraFields::Nationality)) {
+    addLabel(L"Nationalitet:");
+    gdi.addInput("Nationality", L"", 8);
+    colCount++;
+    newLine();
+  }
+
+  if (extraFields.count(oEvent::ExtraFields::Rank)) {
+    addLabel(L"Ranking:");
+    gdi.addInput("Rank", L"", 8);
+    colCount++;
+    newLine();
+  }
+
+  if (auto res = extraFields.find(oEvent::ExtraFields::TextA); res != extraFields.end()) {
+    if (colCount > 0)
+      colCount++;
+
+    newLine();
+
+    addLabel(L"#" + ensureEndingColon(res->second));
+    gdi.addInput("TextA", L"", 20);
+    colCount = 2;
+  }
+
+  if (colCount > 0)
+    colCount = 100;
+  newLine();
+  return extraFields.size();
+}
+
+void TabRunner::loadExtraFields(gdioutput& gdi, const oBase* r) {
+  if (gdi.hasWidget("DataA"))
+    gdi.setTextZeroBlank("DataA", r ? r->getDCI().getInt("DataA") : 0);
+  if (gdi.hasWidget("DataB"))
+    gdi.setTextZeroBlank("DataB", r ? r->getDCI().getInt("DataB") : 0);
+  if (gdi.hasWidget("TextA"))
+    gdi.setText("TextA", r ? r->getDCI().getString("TextA") : L"");
+
+  if (gdi.hasWidget("Sex")) {
+    wstring s = r ? r->getDCI().getString("Sex") : L":";
+    int sc = s == L"M" ? 0 : (s == L"F" ? 1 : 2);
+    gdi.selectItemByIndex("Sex", sc);
+  }
+
+  if (gdi.hasWidget("BirthDate"))
+    gdi.setText("BirthDate", r ? r->getDCI().getDate("BirthYear") : L"");
+
+  if (gdi.hasWidget("Nationality"))
+    gdi.setText("Nationality", r ? r->getDCI().getString("Nationality") : L"");
+
+  if (gdi.hasWidget("Phone"))
+    gdi.setText("Phone", r ? r->getDCI().getString("Phone") : L"");
+
+  if (gdi.hasWidget("Rank"))
+    gdi.setTextZeroBlank("Rank", r ? r->getDCI().getInt("Rank") : 0);
+}
+
+void TabRunner::saveExtraFields(gdioutput& gdi, oBase &r) {
+  auto di = r.getDI();
+  if (gdi.hasWidget("DataA"))
+    di.setInt("DataA", gdi.getTextNo("DataA"));
+  if (gdi.hasWidget("DataB"))
+    di.setInt("DataB", gdi.getTextNo("DataB"));
+  if (gdi.hasWidget("TextA"))
+    di.setString("TextA", gdi.getText("TextA"));
+
+  if (gdi.hasWidget("Sex")) {
+    int sc = gdi.getSelectedItem("Sex").first;
+    wstring s = sc == 0 ? L"M" : (sc == 1 ? L"F" : L"");
+    di.setString("Sex", s);
+  }
+
+  if (gdi.hasWidget("BirthDate"))
+    di.setDate("BirthYear", gdi.getText("BirthDate"));
+
+  if (gdi.hasWidget("Nationality"))
+    di.setString("Nationality", gdi.getText("Nationality"));
+
+  if (gdi.hasWidget("Phone"))
+    di.setString("Phone", gdi.getText("Phone"));
+
+  if (gdi.hasWidget("Rank"))
+    di.setInt("Rank", gdi.getTextNo("Rank"));
+}
+
 void TabRunner::addToolbar(gdioutput &gdi) {
 
   const int button_w=gdi.scaleLength(130);
@@ -2905,7 +3412,7 @@ void TabRunner::fillRunnerList(gdioutput &gdi) {
 
 bool TabRunner::canSetStart(pRunner r) const {
   pClass pc = r->getTeam() ? r->getTeam()->getClassRef(false) : r->getClassRef(true);
-  if (r->getTeam() && pc->isQualificationFinalBaseClass())
+  if (pc && r->getTeam() && pc->isQualificationFinalBaseClass())
     pc = r->getClassRef(true);
 
   if (pc && pc->getNumStages() > 0) {
@@ -3059,13 +3566,6 @@ oRunner &TabRunner::EconomyHandler::getRunner() const {
   return *p;
 }
 
-TabRunner::EconomyHandler *TabRunner::getEconomyHandler(oRunner &r) {
-  if (!ecoHandler)
-    ecoHandler = make_shared<EconomyHandler>();
-
-  ecoHandler->init(r);
-  return ecoHandler.get();
-}
 
 void TabRunner::EconomyHandler::updateColor(gdioutput& gdi) {
   int paid = oe->interpretCurrency(gdi.getText("PaidAmount"));
@@ -3165,7 +3665,7 @@ void TabRunner::loadEconomy(gdioutput &gdi, oRunner &r) {
   gdi.fillDown();
   gdi.pushX();
   gdi.addString("", fontMediumPlus, L"Ekonomihantering, X#" + r.getCompleteIdentification());
-  auto h = getEconomyHandler(r);
+  auto h = make_shared<EconomyHandler>(r);
 
   gdi.fillRight();
   gdi.addInput("EntryDate", r.getEntryDate(true), 10, 0, L"Anmälningsdatum:");
@@ -3195,7 +3695,7 @@ void TabRunner::loadEconomy(gdioutput &gdi, oRunner &r) {
 
   pm.insert(pm.begin(), make_pair(lang.tl(L"Faktureras"), 1000));
   gdi.addSelection("PayMode", 110, 100).setHandler(h);
-  gdi.addItem("PayMode", pm);
+  gdi.setItems("PayMode", pm);
   gdi.autoGrow("PayMode");
   gdi.selectItemByData("PayMode", mypm);
   
@@ -3222,8 +3722,101 @@ void TabRunner::loadEconomy(gdioutput &gdi, oRunner &r) {
   gdi.refresh();
 }
 
+oAbstractRunner& TabRunner::CommentHandler::getRunner() const {
+  oAbstractRunner* p = nullptr;
+  if (!isTeam)
+    p = oe->getRunner(runnerId, 0);
+  else
+    p = oe->getTeam(runnerId);
+
+  if (!p)
+    throw meosException("Löpare saknas");
+  return *p;
+}
+
+void TabRunner::CommentHandler::handle(gdioutput& gdi, BaseInfo& info, GuiEventType type) {
+  if (type == GuiEventType::GUI_BUTTON) {
+    ButtonInfo& bi = dynamic_cast<ButtonInfo&>(info);
+    if (bi.id == "Cancel") {
+      gdi.closeWindow();
+      gdi.closeWindow();
+    }
+    else if (bi.id == "Save") {
+      save(gdi);
+      gdi.closeWindow();
+    }
+  }
+}
+
+void TabRunner::CommentHandler::save(gdioutput& gdi) {
+  oAbstractRunner& r = getRunner();
+  wstring comment = gdi.getText("Comments");
+  r.getDI().setString("Annotation", getLocalTime() + L"@" + comment);
+
+  TabRunner::renderComments(oe->gdiBase(), r);
+}
+
+void TabRunner::renderComments(gdioutput& gdi, oAbstractRunner& r) {
+  gdi.restore("Annotation", false);
+  gdi.setRestorePoint("Annotation");
+
+  wstring an = r.getDCI().getString("Annotation");
+
+  if (an.empty())
+    return;
+
+  wstring date;
+  for (int j = 0; j + 1 < an.length(); j++) {
+    if (an[j] == '@') {
+      date = an.substr(0, j);
+      an = an.substr(j + 1);
+    }
+  }
+
+  gdi.fillDown();
+  gdi.newColumn();
+  gdi.dropLine();
+  RECT rc;
+  rc.left = gdi.getCX();
+  rc.top = gdi.getCY();
+  gdi.dropLine(0.5);
+  gdi.setCX(gdi.getCX() + gdi.scaleLength(5));
+
+  gdi.addString("", fontMediumPlus, "Kommentarer");
+  gdi.addString("", 0, date);
+  gdi.dropLine();
+  gdi.addStringUT(gdi.getCY(), gdi.getCX(), breakLines, an, 200);
+  gdi.dropLine();
+  rc.bottom = gdi.getCY();
+  rc.right = gdi.getWidth() + gdi.scaleLength(3);
+  gdi.addRectangle(rc, GDICOLOR::colorLightYellow);
+
+  gdi.refresh();
+}
+
+void TabRunner::loadComments(gdioutput& gdi, oAbstractRunner& r) {
+  gdi.clearPage(false);
+  gdi.fillDown();
+  gdi.pushX();
+  gdi.addString("", fontMediumPlus, L"Kommentarer för X#" + r.getName());
+
+  auto h = make_shared<CommentHandler>(r);
+  wstring an = r.getDCI().getString("Annotation");
+  for (int j = 0; j + 1 < an.length(); j++) {
+    if (an[j] == '@') {
+      an = an.substr(j + 1);
+    }
+  }
+  gdi.addInputBox("Comments", 250, 100, an, nullptr, L"");
+
+  gdi.fillRight();
+  gdi.addButton("Cancel", "Avbryt").setCancel().setHandler(h);
+  gdi.addButton("Save", "Spara").setHandler(h);
+  gdi.refresh();
+}
+
 void TabRunner::handleAutoComplete(gdioutput &gdi, AutoCompleteInfo &info) {
-  auto bi = gdi.setText(info.getTarget(), info.getCurrent().c_str());
+  auto bi = gdi.setText(info.getTarget().c_str(), info.getCurrent(), false, -1, false);
   if (bi->id == "Name") {
     int ix = info.getCurrentInt();
     bi->setExtra(ix);
@@ -3234,10 +3827,10 @@ void TabRunner::handleAutoComplete(gdioutput &gdi, AutoCompleteInfo &info) {
       if (runner && gdi.hasWidget("Club") && gdi.getText("Club").empty()) {
         pClub club = db.getClub(runner->dbe().clubNo);
         if (club)
-          gdi.setText("Club", club->getName());
+          gdi.setText("Club", club->getName(), false, -1, false);
       }
       if (runner && runner->dbe().cardNo > 0 && gdi.hasWidget("CardNo") && gdi.getText("CardNo").empty()) {
-        gdi.setText("CardNo", runner->dbe().cardNo);
+        gdi.setText("CardNo", itow(runner->dbe().cardNo), false, -1, false);
       }
     }
   }
diff --git a/code/TabRunner.h b/code/TabRunner.h
index 30e58e3..7672e9e 100644
--- a/code/TabRunner.h
+++ b/code/TabRunner.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -23,6 +23,7 @@
 #include "tabbase.h"
 #include "Printer.h"
 #include "autocompletehandler.h"
+#include <deque>
 
 class Table;
 struct AutoCompleteRecord;
@@ -43,15 +44,27 @@ private:
 
   void selectRunner(gdioutput &gdi, pRunner r);
 
+  void updateCardStatus(const pCard& pc, gdioutput& gdi);
+  void updatePunchStatus(const pPunch& punch, InputInfo* bb, gdioutput& gdi);
+
+  int numReportRow = 1;
+  int numReportColumn = 1;
+  bool hideReportControls = false;
+  bool showReportHeader = true;
+  void addToReport(int cardNo, bool punchForShowReport);
+  void addToReport(int id);
+  
+  string computeKeyForReport();
+  
   wstring lastSearchExpr;
   unordered_set<int> lastFilter;
   DWORD timeToFill;
   int inputId;
-  int searchCB(gdioutput &gdi, int type, void *data);
 
-  int runnerCB(gdioutput &gdi, int type, void *data);
-  int punchesCB(gdioutput &gdi, int type, void *data);
-  int vacancyCB(gdioutput &gdi, int type, void *data);
+  int searchCB(gdioutput &gdi, GuiEventType type, BaseInfo* data);
+  int runnerCB(gdioutput &gdi, GuiEventType type, BaseInfo* data);
+  int punchesCB(gdioutput &gdi, GuiEventType type, BaseInfo* data);
+  int vacancyCB(gdioutput &gdi, GuiEventType type, BaseInfo* data);
 
   int currentMode;
   pRunner save(gdioutput &gdi, int runnerId, bool dontReloadRunners);
@@ -64,7 +77,7 @@ private:
   int runnerId;
   bool ownWindow;
   bool listenToPunches;
-  vector< pair<int, bool> > runnersToReport;
+  deque<pair<int, bool>> runnersToReport;
 
   vector<pRunner> unknown_dns;
   vector<pRunner> known_dns;
@@ -76,7 +89,19 @@ private:
   PrinterObject splitPrinter;
 
   void showRunnerReport(gdioutput &gdi);
-  static void runnerReport(oEvent &oe, gdioutput &gdi, int id, bool compactReport);
+
+  static void runnerReport(oEvent &oe, gdioutput &gdi, 
+                           int id, bool compactReport, 
+                           int maxWidth, 
+                           RECT& rc);
+
+  static void teamReport(oEvent& oe, gdioutput& gdi,
+                         const oTeam *team,
+                         bool onlySelectedRunner,
+                         const deque<pair<int, bool>> &runners,
+                         int maxWidth,
+                         RECT &rc);
+
 
   void showVacancyList(gdioutput &gdi, const string &method="", int classId=0);
   void showCardsList(gdioutput &gdi);
@@ -94,26 +119,41 @@ private:
   static void autoGrowCourse(gdioutput &gdi);
 
   void loadEconomy(gdioutput &gdi, oRunner &r);
-
+  
   class EconomyHandler : public GuiHandler {
     int runnerId;
     oEvent *oe;
     oRunner &getRunner() const;
     void updateColor(gdioutput& gdi);
+    void init(oRunner& r);
   public:
-    void init(oRunner &r);
+    EconomyHandler(oRunner& r) { init(r); }
     void handle(gdioutput &gdi, BaseInfo &info, GuiEventType type);
     void save(gdioutput &gdi);
   };
 
-  shared_ptr<EconomyHandler> ecoHandler;
-  EconomyHandler *getEconomyHandler(oRunner &r);
+  class CommentHandler : public GuiHandler {
+    int runnerId;
+    bool isTeam = false;
+    oEvent* oe;
+    oAbstractRunner& getRunner() const;
+  public:
+    CommentHandler(oAbstractRunner& r) : oe(r.getEvent()) { 
+      runnerId = r.getId(); isTeam = r.isTeam(); 
+    }
+    void handle(gdioutput& gdi, BaseInfo& info, GuiEventType type);
+    void save(gdioutput& gdi);
+  };
 
   void getAutoCompleteUnpairedCards(gdioutput &gdi, const wstring& w, vector<AutoCompleteRecord>& records);
 
 protected:
   void clearCompetitionData();
 public:
+
+  static void renderComments(gdioutput& gdi, oAbstractRunner& r);
+  static void loadComments(gdioutput& gdi, oAbstractRunner& r);
+
   static pClub extractClub(oEvent *oe, gdioutput &gdi);
 
   void handleAutoComplete(gdioutput &gdi, AutoCompleteInfo &info) override;
@@ -126,13 +166,21 @@ public:
   bool loadPage(gdioutput &gdi);
   bool loadPage(gdioutput &gdi, int runnerId);
 
-  static void generateRunnerReport(oEvent &oe, gdioutput &gdi,  vector<pair<int, bool>> &runnersToReport);
+  static int addExtraFields(const oEvent &oe, gdioutput& gdi, oEvent::ExtraFieldContext context);
+  static void saveExtraFields(gdioutput& gdi, oBase &r);
+  static void loadExtraFields(gdioutput& gdi, const oBase* r);
+
+  static void generateRunnerReport(oEvent &oe, 
+    gdioutput &gdi, 
+    int numX, int numY,
+    bool onlySelectedRunner,
+    const deque<pair<int, bool>> &runnersToReport);
 
   TabRunner(oEvent *oe);
   ~TabRunner(void);
 
-  friend int runnerSearchCB(gdioutput *gdi, int type, void *data);
-  friend int RunnerCB(gdioutput *gdi, int type, void *data);
-  friend int PunchesCB(gdioutput *gdi, int type, void *data);
-  friend int VacancyCB(gdioutput *gdi, int type, void *data);
+  friend int runnerSearchCB(gdioutput *gdi, GuiEventType type, BaseInfo *data);
+  friend int RunnerCB(gdioutput *gdi, GuiEventType type, BaseInfo *data);
+  friend int PunchesCB(gdioutput *gdi, GuiEventType type, BaseInfo *data);
+  friend int VacancyCB(gdioutput *gdi, GuiEventType type, BaseInfo *data);
 };
diff --git a/code/TabSI.cpp b/code/TabSI.cpp
index 5289b77..a1aec25 100644
--- a/code/TabSI.cpp
+++ b/code/TabSI.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -41,6 +41,7 @@
 #include "TabSI.h"
 #include "TabAuto.h"
 #include "TabList.h"
+#include "TabCompetition.h"
 #include "meos_util.h"
 #include <cassert>
 #include "TabRunner.h"
@@ -50,6 +51,8 @@
 #include "RunnerDB.h"
 #include "recorder.h"
 #include "autocomplete.h"
+#include "random.h"
+#include <random>
 
 constexpr bool addTestPort = false;
 void tabForceSync(gdioutput& gdi, pEvent oe);
@@ -65,6 +68,10 @@ TabSI::TabSI(oEvent* poe) :TabBase(poe), activeSIC(ConvertedTimeStatus::Unknown)
   printStartInfo = false;
   savedCardUniqueId = 1;
 
+#ifdef _DEBUG
+  showTestingPanel = true;
+#endif // _DEBUG
+
   manualInput = poe->getPropertyInt("ManualInput", 0) == 1;
 
   mode = SIMode::ModeReadOut;
@@ -75,6 +82,7 @@ TabSI::TabSI(oEvent* poe) :TabBase(poe), activeSIC(ConvertedTimeStatus::Unknown)
   modeName[SIMode::ModeRegisterCards] = "Registrera hyrbrickor";
   modeName[SIMode::ModeEntry] = "Anmälningsläge";
   modeName[SIMode::ModeCardData] = "Print card data";
+  modeName[SIMode::ModeRequestStartTime] = "Boka starttid";
 
   currentAssignIndex = 0;
 
@@ -84,14 +92,10 @@ TabSI::TabSI(oEvent* poe) :TabBase(poe), activeSIC(ConvertedTimeStatus::Unknown)
   minRunnerId = 0;
   inputId = 0;
   printErrorShown = false;
-  NC = 8;
   splitPrinter.onlyChanged = false;
 }
 
-TabSI::~TabSI(void)
-{
-}
-
+TabSI::~TabSI() = default;
 
 static void entryTips(gdioutput& gdi) {
   gdi.fillDown();
@@ -100,9 +104,7 @@ static void entryTips(gdioutput& gdi) {
   gdi.setRestorePoint("EntryLine");
 }
 
-
-void TabSI::logCard(gdioutput& gdi, const SICard& card)
-{
+void TabSI::logCard(gdioutput& gdi, const SICard& card) {
   if (!logger) {
     logger = make_shared<csvparser>();
     wstring readlog = L"sireadlog_" + getLocalTimeFileName() + L".csv";
@@ -123,7 +125,7 @@ void TabSI::logCard(gdioutput& gdi, const SICard& card)
 extern SportIdent* gSI;
 extern pEvent gEvent;
 
-int SportIdentCB(gdioutput* gdi, int type, void* data) {
+int SportIdentCB(gdioutput* gdi, GuiEventType type, BaseInfo * data) {
   TabSI& tsi = dynamic_cast<TabSI&>(*gdi->getTabs().get(TSITab));
 
   return tsi.siCB(*gdi, type, data);
@@ -145,8 +147,7 @@ string TabSI::typeFromSndType(SND s) {
   return "";
 }
 
-int TabSI::siCB(gdioutput& gdi, int type, void* data)
-{
+int TabSI::siCB(gdioutput& gdi, GuiEventType type, BaseInfo * data) {
   if (type == GUI_BUTTON) {
     ButtonInfo bi = *(ButtonInfo*)data;
 
@@ -351,6 +352,12 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       ListBoxInfo lbi;
       if (gdi.getSelectedItem("ComPort", lbi)) {
 
+        if (lbi.data == 9999) {
+          showTestingPanel = !showTestingPanel;
+          loadPage(gdi);
+          return 0;
+        }
+        
         swprintf_s(bf, 64, L"COM%d", lbi.getDataInt());
         wstring port = bf;
 
@@ -530,7 +537,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       }
     }
     else if (bi.id == "PrinterSetup") {
-      if (mode == SIMode::ModeEntry) {
+      if (mode == SIMode::ModeEntry || mode == SIMode::ModeRequestStartTime) {
         printStartInfo = true;
         TabList::splitPrintSettings(*oe, gdi, true, TSITab, TabList::StartInfo);
       }
@@ -548,6 +555,12 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
     else if (bi.id == "RentCardTie") {
       gEvent->setProperty("RentCard", gdi.isChecked(bi.id));
     }
+    else if (bi.id == "EditEntryFields") {
+      TabCompetition& tc = dynamic_cast<TabCompetition&>(*gdi.getTabs().get(TCmpTab));
+      tc.loadSettings(gdi);
+      gdi.selectItemByData("DataFields", int(oEvent::ExtraFieldContext::DirectEntry));
+      tc.showExtraFields(gdi, oEvent::ExtraFieldContext::DirectEntry);
+    }
     else if (bi.id == "TieOK") {
       tieCard(gdi);
     }
@@ -621,7 +634,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
 
             vector< pair<wstring, size_t> > d;
             oe->fillControlTypes(d);
-            gdi.addItem("ControlType", d);
+            gdi.setItems("ControlType", d);
             // oe->fillControlTypes(gdi, "ControlType");
             gdi.selectItemByData("ControlType", oPunch::PunchCheck);
 
@@ -677,7 +690,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       for (size_t k = 0; k < punches.size(); k++) {
         if (dofilter && filter != punches[k].date)
           continue;
-        oe->addFreePunch(punches[k].time, type, 0, punches[k].card, true);
+        oe->addFreePunch(punches[k].time, type, 0, punches[k].card, true, true);
       }
       punches.clear();
       if (origin == 1) {
@@ -701,15 +714,26 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
     }
     else if (bi.id == "Save") {
       SICard sic(ConvertedTimeStatus::Hour24);
+      sic.isDebugCard = true;
+
       sic.CheckPunch.Code = -1;
       sic.CardNumber = gdi.getTextNo("SI");
       int f = convertAbsoluteTimeHMS(gdi.getText("Finish"), oe->getZeroTimeNum());
       int s = convertAbsoluteTimeHMS(gdi.getText("Start"), oe->getZeroTimeNum());
+      int c = convertAbsoluteTimeHMS(gdi.getText("Check"), oe->getZeroTimeNum());
+
+      testStartTime.clear();
+      testFinishTime.clear();
+      testCheckTime.clear();
+      testCardNumber = 0;
+
       if (f < s) {
         f += 24 * timeConstHour;
       }
       sic.FinishPunch.Time = f % (24 * timeConstHour);
       sic.StartPunch.Time = s % (24 * timeConstHour);
+      sic.CheckPunch.Time = c % (24 * timeConstHour);
+      
       if (!gdi.isChecked("HasFinish")) {
         sic.FinishPunch.Code = -1;
         sic.FinishPunch.Time = 0;
@@ -720,9 +744,20 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
         sic.StartPunch.Time = 0;
       }
 
+      if (!gdi.isChecked("HasCheck")) {
+        sic.CheckPunch.Code = -1;
+        sic.CheckPunch.Time = 0;
+      }
+
+      if (NC > testControls.size())
+        testControls.resize(NC);
+
+      for (int i = 0; i < NC; i++)
+        testControls[i] = gdi.getTextNo("C" + itos(i + 1));
+
       double t = 0.1;
       for (sic.nPunch = 0; sic.nPunch<unsigned(NC); sic.nPunch++) {
-        int c = gdi.getTextNo("C" + itos(sic.nPunch + 1));
+        int c = testControls[sic.nPunch];
         sic.Punch[sic.nPunch].Time = ((int(f * t + s * (1.0 - t))/ timeUnitsPerSecond) % (24 * timeConstSecPerHour)) * timeUnitsPerSecond;
         t += ((1.0 - t) * (sic.nPunch + 1) / 10.0) * ((rand() % 100) + 400.0) / 500.0;
         if ((sic.nPunch % 11) == 1 || 5 == (sic.nPunch % 8))
@@ -745,40 +780,43 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
           sic.Punch[i].Time %= (12 * timeConstHour);
         }
       }
-
       gSI->addCard(sic);
     }
     else if (bi.id == "SaveP") {
       SICard sic(ConvertedTimeStatus::Hour24);
       sic.clear(0);
+      sic.isDebugCard = true;
       sic.FinishPunch.Code = -1;
       sic.CheckPunch.Code = -1;
       sic.StartPunch.Code = -1;
-
       sic.CardNumber = gdi.getTextNo("SI");
-      int f = convertAbsoluteTimeHMS(gdi.getText("Finish"), oe->getZeroTimeNum());
-      if (f > 0) {
-        sic.FinishPunch.Time = f;
-        sic.FinishPunch.Code = 1;
+      int t = convertAbsoluteTimeHMS(gdi.getText("PunchTime"), oe->getZeroTimeNum());
+      testPunchTime.clear();
+      testCardNumber = 0;
+
+      if (t > 0) {
+        if (testType == oPunch::PunchStart) {
+          sic.StartPunch.Time = t;
+          sic.StartPunch.Code = 1;
+        }
+        else if (testType == oPunch::PunchFinish) {
+          sic.FinishPunch.Time = t;
+          sic.FinishPunch.Code = 1;
+        }
+        else if (testType == oPunch::PunchCheck) {
+          sic.CheckPunch.Time = t;
+          sic.CheckPunch.Code = 1;
+        }
+        else {
+          sic.Punch[sic.nPunch].Code = gdi.getTextNo("ControlNumber");
+          sic.Punch[sic.nPunch].Time = t;
+          sic.nPunch = 1;
+        }
         sic.punchOnly = true;
+        sic.convertedTime = ConvertedTimeStatus::Hour24;
         gSI->addCard(sic);
         return 0;
       }
-
-      int s = convertAbsoluteTimeHMS(gdi.getText("Start"), oe->getZeroTimeNum());
-      if (s > 0) {
-        sic.StartPunch.Time = s;
-        sic.StartPunch.Code = 1;
-        sic.punchOnly = true;
-        gSI->addCard(sic);
-        return 0;
-      }
-
-      sic.Punch[sic.nPunch].Code = gdi.getTextNo("C1");
-      sic.Punch[sic.nPunch].Time = convertAbsoluteTimeHMS(gdi.getText("C2"), oe->getZeroTimeNum());
-      sic.nPunch = 1;
-      sic.punchOnly = true;
-      gSI->addCard(sic);
     }
     else if (bi.id == "Cancel") {
       int origin = bi.getExtraInt();
@@ -881,7 +919,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
         pRunner r = gEvent->addRunner(gdi.getText("Runners"), club,
           classes[0]->getId(), activeSIC.CardNumber, year, true);
         if (oe->isHiredCard(activeSIC.CardNumber)) {
-          r->getDI().setInt("CardFee", oe->getBaseCardFee());
+          r->setRentalCard(true);
         }
         gdi.setData("RunnerId", r->getId());
 
@@ -900,7 +938,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       gdi.addInput("StartTime", gEvent->getAbsTime(si_copy.StartPunch.Time), 8, 0, L"Starttid:");
 
       gdi.addSelection("Classes", 200, 300, 0, L"Klass:");
-      gEvent->fillClasses(gdi, "Classes", oEvent::extraNone, oEvent::filterNone);
+      gEvent->fillClasses(gdi, "Classes", {}, oEvent::extraNone, oEvent::filterNone);
       gdi.setInputFocus("Classes");
 
       if (classes.size() > 0)
@@ -950,7 +988,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
         lbi.data, activeSIC.CardNumber, year, true);
 
       if (activeSIC.CardNumber > 0 && oe->isHiredCard(activeSIC.CardNumber)) {
-        r->getDI().setInt("CardFee", oe->getBaseCardFee());
+        r->setRentalCard(true);
       }
 
       r->setStartTimeS(gdi.getText("StartTime"));
@@ -1010,7 +1048,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
         pclass->getId(), activeSIC.CardNumber, year, true);
 
       if (activeSIC.CardNumber > 0 && oe->isHiredCard(activeSIC.CardNumber)) {
-        r->getDI().setInt("CardFee", oe->getBaseCardFee());
+        r->setRentalCard(true);
       }
       r->setStartTimeS(gdi.getText("StartTime"));
       r->setCardNo(activeSIC.CardNumber, false);
@@ -1128,16 +1166,14 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
 
       oDataInterface di = r->getDI();
 
-      int cardFee = gdi.isChecked("RentCard") ? oe->getBaseCardFee() : 0;
-
-      di.setInt("CardFee", cardFee);
+      r->setRentalCard(gdi.isChecked("RentCard"));
       di.setInt("Fee", lastFeeNum);
       r->setFlag(oRunner::FlagFeeSpecified, true);
 
-      int totFee = lastFeeNum + (cardFee > 0 ? cardFee : 0);
+      int totFee = lastFeeNum + r->getRentalCardFee(true);
       writePayMode(gdi, totFee, *r);
 
-      di.setString("Phone", gdi.getText("Phone"));
+      TabRunner::saveExtraFields(gdi, *r);
 
       if (gdi.isChecked("NoTiming"))
         r->setStatus(RunnerStatus::StatusNoTiming, true, oBase::ChangeType::Update, false);
@@ -1147,23 +1183,26 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       r->setFlag(oRunner::FlagTransferSpecified, gdi.hasWidget("AllStages"));
       r->setFlag(oRunner::FlagTransferNew, gdi.isChecked("AllStages"));
 
-      r->setStartTimeS(gdi.getText("StartTime"));
-
-      wstring bibIn = gdi.getText("Bib");
+      if (gdi.hasWidget("StartTime")) 
+        r->setStartTimeS(gdi.getText("StartTime"));
+      
       wstring bib;
-      if (bibIn.empty()) {
-        switch (r->autoAssignBib()) {
-        case oRunner::BibAssignResult::Assigned:
-          bib = L", " + lang.tl(L"Nummerlapp: ") + r->getBib();
-          break;
-        case oRunner::BibAssignResult::Failed:
-          bib = L", " + lang.tl(L"Ingen nummerlapp");
-          break;
+      if (gdi.hasWidget("Bib")) {
+        wstring bibIn = gdi.getText("Bib");
+        if (bibIn.empty()) {
+          switch (r->autoAssignBib()) {
+          case oRunner::BibAssignResult::Assigned:
+            bib = L", " + lang.tl(L"Nummerlapp: ") + r->getBib();
+            break;
+          case oRunner::BibAssignResult::Failed:
+            bib = L", " + lang.tl(L"Ingen nummerlapp");
+            break;
+          }
+        }
+        else {
+          r->setBib(bibIn, 0, false);
+          bib = L", " + lang.tl(L"Nummerlapp: ") + r->getBib();
         }
-      }
-      else {
-        r->setBib(bibIn, 0, false);
-        bib = L", " + lang.tl(L"Nummerlapp: ") + r->getBib();
       }
       r->synchronize();
 
@@ -1181,7 +1220,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       }
 
       wstring info(bf);
-      if (r->getDI().getInt("CardFee") != 0)
+      if (r->isRentalCard())
         info += lang.tl(L", Hyrbricka");
 
       vector< pair<wstring, size_t> > modes;
@@ -1217,7 +1256,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
         gdi.addString("", fontMediumPlus, "Varning: Kartorna är slut").setColor(colorRed);
       }
 
-      generateStartInfo(gdi, *r);
+      generateStartInfo(gdi, *r, true);
 
       gdi.setRestorePoint("EntryLine");
       generateEntryLine(gdi, 0);
@@ -1291,6 +1330,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
           for (wstring wc : c) {
             int cn = _wtoi(wc.c_str());
             if (cn > 0) {
+              rentCards.insert(cn);
               oe->setHiredCard(cn, true);
               gdi.addStringUT(0, itos(cn)).setHandler(getResetHiredCardHandler());
             }
@@ -1304,11 +1344,10 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
         vector<pRunner> runners;
         oe->getRunners(0, 0, runners);
         if (!runners.empty() && gdi.ask(L"Vill du sätta hyrbricka på befintliga löpare med dessa brickor?")) {
-          int bcf = oe->getBaseCardFee();
           for (pRunner r : runners) {
-            if (rentCards.count(r->getCardNo()) && r->getDCI().getInt("CardFee") == 0) {
+            if (rentCards.count(r->getCardNo()) && !r->isRentalCard()) {
               gdi.addStringUT(0, r->getCompleteIdentification());
-              r->getDI().setInt("CardFee", bcf);
+              r->setRentalCard(true);
             }
           }
         }
@@ -1411,14 +1450,20 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       updateEntryInfo(gdi);
     }
     else if (bi.id == "ComPort") {
-      wchar_t bf[64];
+      bool active = true;
+      if (bi.data == 9999) 
+        active = showTestingPanel;
+      else {
+        wchar_t bf[64];
+        if (bi.text.substr(0, 3) != L"TCP")
+          swprintf_s(bf, 64, L"COM%d", bi.getDataInt());
+        else
+          wcscpy_s(bf, L"TCP");
 
-      if (bi.text.substr(0, 3) != L"TCP")
-        swprintf_s(bf, 64, L"COM%d", bi.getDataInt());
-      else
-        wcscpy_s(bf, L"TCP");
+        active = gSI->isPortOpen(bf);
+      }
 
-      if (gSI->isPortOpen(bf))
+      if (active)
         gdi.setText("StartSI", lang.tl("Koppla ifrån"));
       else
         gdi.setText("StartSI", lang.tl("Aktivera"));
@@ -1433,7 +1478,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
           showAssignCard(gdi, true);
         }
         else {
-          checkBoxToolBar(gdi, { CheckBox::UseDB, CheckBox::PrintStart });
+          checkBoxToolBar(gdi, { CheckBox::UseDB, CheckBox::PrintStart, CheckBox::ExtraDataFields });
           entryTips(gdi);
           generateEntryLine(gdi, 0);
         }
@@ -1456,6 +1501,9 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       else if (mode == SIMode::ModeRegisterCards) {
         showRegisterHiredCards(gdi);
       }
+      else if (mode == SIMode::ModeRequestStartTime) {
+        showRequestStartTime(gdi);
+      }
       updateReadoutFunction(gdi);
       gdi.refresh();
     }
@@ -1463,9 +1511,15 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       updateEntryInfo(gdi);
     }
     else if (bi.id == "NC") {
+      readTestData(gdi);
       NC = bi.data;
       PostMessage(gdi.getHWNDTarget(), WM_USER + 2, TSITab, 0);
     }
+    else if (bi.id == "TestType") {
+      readTestData(gdi);
+      testType = bi.data;
+      PostMessage(gdi.getHWNDTarget(), WM_USER + 2, TSITab, 0);
+    }
   }
   else if (type == GUI_LINK) {
     TextInfo ti = *(TextInfo*)data;
@@ -1483,6 +1537,13 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
         runnerMatchedId = r->getId();
       }
     }
+    else if (ti.id == "edit") {
+      int rId = ti.getExtraInt();
+      if (oe->getRunner(rId, 0)) {
+        TabRunner& tr = dynamic_cast<TabRunner&>(*gdi.getTabs().get(TRunnerTab));
+        tr.loadPage(gdi, rId);
+      }
+    }
   }
   else if (type == GUI_COMBO) {
     ListBoxInfo bi = *(ListBoxInfo*)data;
@@ -1564,9 +1625,14 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
     }
   }
   else if (type == GUI_TIMER) {
-    TimerInfo& ti = *(TimerInfo*)(data);
-
-    if (ti.id == "TieCard") {
+    TimerInfo& ti = dynamic_cast<TimerInfo&>(*data);
+    if (ti.id == "RequestedStart") {
+      if (requestStartTimeHandler) {
+        requestStartTimeHandler->handle(gdi, ti, type);
+      }
+      return 0;
+    }
+    else if (ti.id == "TieCard") {
       runnerMatchedId = ti.getExtraInt();
       tieCard(gdi);
       return 0;
@@ -1672,16 +1738,25 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
     }
     else if (ii.id == "SI") {
       pRunner r = oe->getRunnerByCardNo(_wtoi(ii.text.c_str()), 0, oEvent::CardLookupProperty::ForReadout);
-      if (r && r->getStartTime() > 0) {
-        gdi.setText("Start", r->getStartTimeS());
-        gdi.check("HasStart", false);
-        int f = r->getStartTime() + (2800 + rand() % 1200) * timeConstSecond;
-        gdi.setText("Finish", oe->getAbsTime(f));
+      if (testType == 0 && r) {
+        if (r->getStartTime() > 0) {
+          gdi.setText("Start", r->getStartTimeS());
+          gdi.check("HasStart", false);
+          int f = r->getStartTime() + (2800 + rand() % 1200) * timeConstSecond;
+          gdi.setText("Finish", oe->getAbsTime(f));
+          int c = r->getStartTime() - (120 + rand() % 30) * timeConstSecond;
+          gdi.setText("Check", oe->getAbsTime(c));
+        }
+        
         pCourse pc = r->getCourse(false);
         if (pc) {
+          if (testControls.size() < pc->getNumControls())
+            testControls.resize(pc->getNumControls());
           for (int n = 0; n < pc->getNumControls(); n++) {
-            if (pc->getControl(n) && n < NC) {
-              gdi.setText("C" + itos(n + 1), pc->getControl(n)->getFirstNumber());
+            if (pc->getControl(n)) {
+              testControls[n] = pc->getControl(n)->getFirstNumber();
+              if (n < NC) 
+                gdi.setText("C" + itos(n + 1), testControls[n]);
             }
           }
         }
@@ -1732,8 +1807,7 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       if (r && r->getCardNo() != si) {
         if (si == 0 || !oe->checkCardUsed(gdi, *r, si)) {
           r->setCardNo(si, false);
-
-          r->getDI().setInt("CardFee", oe->getBaseCardFee());
+          r->setRentalCard(true);
           r->synchronize();
         }
 
@@ -1765,8 +1839,16 @@ int TabSI::siCB(gdioutput& gdi, int type, void* data)
       ListBoxInfo lbi;
       gdi.getSelectedItem("Class", lbi);
       storedInfo.storedClassId = lbi.data;
-      storedInfo.storedPhone = gdi.getText("Phone");
-      storedInfo.storedStartTime = gdi.getText("StartTime");
+      storedInfo.storedPhone = gdi.getText("Phone", true);
+      storedInfo.storedStartTime = gdi.getText("StartTime", true);
+
+      storedInfo.dataA = gdi.getText("DataA", true);
+      storedInfo.dataB = gdi.getText("DataB", true);
+      storedInfo.textA = gdi.getText("TextA", true);
+      storedInfo.nationality = gdi.getText("Nationality", true);
+      storedInfo.birthDate = gdi.getText("BirthDate", true);
+      storedInfo.rank = gdi.getText("Rank", true);
+      storedInfo.sex = gdi.hasWidget("Sex") ? gdi.getSelectedItem("Sex").first : 2;
 
       storedInfo.allStages = gdi.isChecked("AllStages");
       storedInfo.rentState = gdi.isChecked("RentCard");
@@ -1800,8 +1882,26 @@ void TabSI::writeDefaultHiredCards() {
   }
 }
 
-void TabSI::refillComPorts(gdioutput& gdi)
-{
+bool TabSI::anyActivePort() const {
+  if (!gSI) return false;
+
+  if (showTestingPanel)
+    return true;
+
+  list<int> ports;
+  gSI->EnumrateSerialPorts(ports);
+  for (int port : ports) {
+    wstring s = L"COM" + itow(port);
+    if (gSI->isPortOpen(s))
+      return true;
+  }
+  if (gSI->isPortOpen(L"TCP"))
+    return true;
+
+  return false;
+}
+
+void TabSI::refillComPorts(gdioutput& gdi) {
   if (!gSI) return;
 
   list<int> ports;
@@ -1833,7 +1933,11 @@ void TabSI::refillComPorts(gdioutput& gdi)
     gdi.addItem("ComPort", L"TCP [OK]", active);
   }
   else
-    gdi.addItem("ComPort", L"TCP");
+    gdi.addItem("ComPort", L"TCP", 0);
+
+  gdi.addItem("ComPort", lang.tl("Testning"), 9999);
+  if (showTestingPanel)
+    active = 9999;
 
   if (addTestPort)
     gdi.addItem("ComPort", L"TEST");
@@ -1909,7 +2013,7 @@ void TabSI::showReadCards(gdioutput& gdi, vector<SICard>& cards)
     if (r != 0)
       gdi.addStringUT(yp, xp + off[1], 0, r->getName(), off[2] - off[1] + margin);
 
-    gdi.addStringUT(yp, xp + off[2], 0, oe->getAbsTime(cards[k].FinishPunch.Time));
+    gdi.addStringUT(yp, xp + off[2], 0, formatTimeHMS(cards[k].FinishPunch.Time));
     yp += gdi.getLineHeight();
   }
 }
@@ -1941,134 +2045,201 @@ bool TabSI::loadPage(gdioutput& gdi) {
 
     firstLoadedAfterNew = false;
   }
-#ifdef _DEBUG
-  gdi.fillRight();
-  gdi.pushX();
-  gdi.addInput("SI", L"", 10, SportIdentCB, L"SI");
-  int s = timeConstHour + (rand() % 60) * timeConstMinute;
-  int f = s + timeConstHour / 2 + ((rand() % 3600) / 3) * timeConstSecond;
 
-  gdi.setCX(gdi.getCX() + gdi.getLineHeight());
+  if (showTestingPanel) {
+    RECT rc;
+    rc.left = gdi.getCX();
+    rc.top = gdi.getCY();
 
-  gdi.dropLine(1.4);
-  gdi.addCheckbox("HasStart", "");
-  gdi.dropLine(-1.4);
-  gdi.setCX(gdi.getCX() - gdi.getLineHeight());
-  gdi.addInput("Start", oe->getAbsTime(s), 6, 0, L"Start");
+    gdi.setCX(gdi.getCX() + gdi.scaleLength(4));
+    gdi.setCY(gdi.getCY() + gdi.scaleLength(4));
 
-  gdi.dropLine(1.4);
-  gdi.addCheckbox("HasFinish", "");
-  gdi.dropLine(-1.4);
-  gdi.setCX(gdi.getCX() - gdi.getLineHeight());
+    gdi.addString("", fontMediumPlus, "Inmatning Testning");
 
-  gdi.addInput("Finish", oe->getAbsTime(f), 6, 0, L"Mål");
-  gdi.addSelection("NC", 45, 200, SportIdentCB, L"NC");
-  const int src[11] = { 33, 34, 45, 50, 36, 38, 59, 61, 62, 67, 100 };
+    gdi.fillRight();
+    gdi.pushX();
 
-  for (int i = 0; i < 32; i++)
-    gdi.addItem("NC", itow(i), i);
+    gdi.addSelection("TestType", 100, 100, SportIdentCB, L"Typ:");
+    gdi.addItem("TestType", lang.tl("Avläsning"), 0);
+    gdi.addItem("TestType", lang.tl("Mål"), 2);
+    gdi.addItem("TestType", lang.tl("Start"), 1);
+    gdi.addItem("TestType", lang.tl("Check"), 3);
+    gdi.addItem("TestType", lang.tl("Radio"), 10);
 
-  gdi.selectItemByData("NC", NC);
+    gdi.selectItemByData("TestType", testType);
+
+    gdi.addInput("SI", testCardNumber > 0 ? itow(testCardNumber) : L"", 10, SportIdentCB, L"Bricknummer:");
+       
+    if (testType == 0) {
+      int s = timeConstHour + (rand() % 60) * timeConstMinute;
+      int f = s + timeConstHour / 2 + ((rand() % 3600) / 3) * timeConstSecond;
+      wstring ss = oe->getAbsTime(s);
+      wstring fs = oe->getAbsTime(f);
+      wstring cs = oe->getAbsTime(s - (60 + rand() % 60) * timeConstSecond);
+
+      if (!testStartTime.empty())
+        ss = testStartTime;
+      if (!testFinishTime.empty())
+        fs = testFinishTime;
+      if (!testCheckTime.empty())
+        cs = testCheckTime;
+
+      gdi.setCX(gdi.getCX() + gdi.getLineHeight());
+
+      gdi.dropLine(1.6);
+      gdi.addCheckbox("HasCheck", "", nullptr, useTestCheck);
+      gdi.dropLine(-1.6);
+      gdi.setCX(gdi.getCX() - gdi.getLineHeight());
+      gdi.addInput("Check", cs, 6, 0, L"Check:");
+
+      gdi.dropLine(1.6);
+      gdi.addCheckbox("HasStart", "", nullptr, useTestStart);
+      gdi.dropLine(-1.6);
+      gdi.setCX(gdi.getCX() - gdi.getLineHeight());
+      gdi.addInput("Start", ss, 6, 0, L"Start:");
+
+      gdi.dropLine(1.6);
+      gdi.addCheckbox("HasFinish", "", nullptr, useTestFinish);
+      gdi.dropLine(-1.6);
+      gdi.setCX(gdi.getCX() - gdi.getLineHeight());
+
+      gdi.addInput("Finish", fs, 6, 0, L"Mål:");
+      gdi.addSelection("NC", 45, 200, SportIdentCB, L"Stämplingar:");
+      const int src[11] = { 33, 34, 45, 50, 36, 38, 59, 61, 62, 67, 100 };
+
+      for (int i = 0; i < 32; i++)
+        gdi.addItem("NC", itow(i), i);
+
+      gdi.selectItemByData("NC", NC);
+
+      for (int i = 0; i < NC; i++) {
+        int level = min(i, NC - i) / 5;
+        int c;
+        if (i < NC / 2) {
+          int ix = i % 6;
+          c = src[ix] + level * 10;
+          if (c == 100)
+            c = 183;
+        }
+        else {
+          int ix = 10 - (NC - i - 1) % 5;
+          c = src[ix] + level * 10;
+        }
+
+        if (i < testControls.size())
+          c = testControls[i];
+
+        gdi.addInput("C" + itos(i + 1), itow(c), 3, 0, L"#C" + itow(i + 1));
+      }
+
+      gdi.dropLine();
+      gdi.fillDown();
+      gdi.addButton("Save", "Spara", SportIdentCB);
+      gdi.popX();
 
-  for (int i = 0; i < NC; i++) {
-    int level = min(i, NC - i) / 5;
-    int c;
-    if (i < NC / 2) {
-      int ix = i % 6;
-      c = src[ix] + level * 10;
-      if (c == 100)
-        c = 183;
     }
     else {
-      int ix = 10 - (NC - i - 1) % 5;
-      c = src[ix] + level * 10;
+      int p = timeConstHour + (rand() % 60) * timeConstMinute;
+      wstring ps = oe->getAbsTime(p);
+      
+      if (!testPunchTime.empty())
+        ps = testPunchTime;
+      
+      if (testType == 10) 
+        gdi.addInput("ControlNumber", itow(testRadioNumber), 6, 0, L"Kontroll:");
+
+      gdi.addInput("PunchTime", ps, 6, 0, L"Tid:");
+
+      gdi.dropLine();
+      gdi.fillDown();
+      gdi.addButton("SaveP", "Spara", SportIdentCB);
+      gdi.popX();
     }
-
-    gdi.addInput("C" + itos(i + 1), itow(c), 3, 0, L"#C" + itow(i + 1));
+    rc.right = gdi.getWidth();
+    rc.bottom = gdi.getCY();
+    gdi.addRectangle(rc, GDICOLOR::colorLightMagenta);
+    gdi.dropLine();
   }
 
-  gdi.dropLine();
-  gdi.addButton("Save", "Bricka", SportIdentCB);
-  gdi.fillDown();
-
-  gdi.addButton("SaveP", "Stämpling", SportIdentCB);
-  gdi.popX();
-#endif
-  gdi.addString("", boldLarge, "SportIdent");
-  gdi.dropLine();
-
-  gdi.pushX();
-  gdi.fillRight();
-  gdi.addSelection("ComPort", 120, 200, SportIdentCB);
-  gdi.addButton("StartSI", "#Aktivera+++", SportIdentCB);
-  gdi.addButton("SIInfo", "Info", SportIdentCB);
-
-  refillComPorts(gdi);
-
-  gdi.addButton("AutoDetect", "Sök och starta automatiskt...", SportIdentCB);
-  gdi.addButton("PrinterSetup", "Skrivarinställningar...", SportIdentCB, "Skrivarinställningar för sträcktider och startbevis");
-
-  gdi.popX();
-  gdi.fillDown();
-  gdi.dropLine(2.2);
-
   int xb = gdi.getCX();
   int yb = gdi.getCY();
 
-  if (!oe->empty()) {
-    gdi.setCX(xb + gdi.scaleLength(10));
-    gdi.setCY(yb + gdi.scaleLength(10));
+  if (!oe->isKiosk()) {
+    gdi.addString("", boldLarge, "SportIdent");
+    gdi.dropLine();
 
-    if (!lockedFunction) {
-      gdi.fillRight();
-      gdi.addString("", fontMediumPlus, "Funktion:");
-      gdi.addSelection("ReadType", 200, 200, SportIdentCB);
-      auto addItem = [this, &gdi](SIMode mode) {
-        gdi.addItem("ReadType", lang.tl(modeName[mode]), int(mode));
-      };
-      addItem(SIMode::ModeReadOut);
-      addItem(SIMode::ModeEntry);
-      addItem(SIMode::ModeAssignCards);
-      addItem(SIMode::ModeCheckCards);
-      addItem(SIMode::ModeRegisterCards);
-      addItem(SIMode::ModeCardData);
-      /*
-      gdi.addItem("ReadType", lang.tl(modeName[SIMode::ModeReadOut]), SIMode::ModeReadOut);
-      gdi.addItem("ReadType", lang.tl("Tilldela hyrbrickor"), ModeAssignCards);
-      gdi.addItem("ReadType", lang.tl("Avstämning hyrbrickor"), ModeCheckCards);
-      gdi.addItem("ReadType", lang.tl("Registrera hyrbrickor"), ModeRegisterCards);
-      gdi.addItem("ReadType", lang.tl("Anmälningsläge"), ModeEntry);
-      gdi.addItem("ReadType", lang.tl("Print card data"), ModeCardData);*/
-      gdi.selectItemByData("ReadType", int(mode));
+    gdi.pushX();
+    gdi.fillRight();
+    gdi.addSelection("ComPort", 120, 200, SportIdentCB);
+    gdi.addButton("StartSI", "#Aktivera+++", SportIdentCB);
+    gdi.addButton("SIInfo", "Info", SportIdentCB);
 
-      gdi.dropLine(-0.1);
-      gdi.addButton("LockFunction", "Lås funktion", SportIdentCB);
-      readoutFunctionX = gdi.getCX();
-      readoutFunctionY = gdi.getCY();
-      gdi.dropLine(0.3);
+    refillComPorts(gdi);
 
-      gdi.addCheckbox("PlaySound", "Ljud", SportIdentCB, oe->getPropertyInt("PlaySound", 1) != 0,
-        "Spela upp ett ljud för att indikera resultatet av brickavläsningen.");
-      gdi.dropLine(-0.3);
+    gdi.addButton("AutoDetect", "Sök och starta automatiskt...", SportIdentCB);
+    gdi.addButton("PrinterSetup", "Skrivarinställningar...", SportIdentCB, "Skrivarinställningar för sträcktider och startbevis");
 
-      gdi.addButton("SoundChoice", "Ljudval...", SportIdentCB);
+    gdi.popX();
+    gdi.fillDown();
+    gdi.dropLine(2.2);
 
-      gdi.dropLine(0.3);
+    // Update pos
+    xb = gdi.getCX();
+    yb = gdi.getCY();
 
-      updateReadoutFunction(gdi);
-
-      gdi.dropLine(2);
+    if (!oe->empty()) {
       gdi.setCX(xb + gdi.scaleLength(10));
+      gdi.setCY(yb + gdi.scaleLength(10));
+
+      if (!lockedFunction) {
+        gdi.fillRight();
+        gdi.addString("", fontMediumPlus, "Funktion:");
+        gdi.addSelection("ReadType", 200, 200, SportIdentCB);
+        auto addItem = [this, &gdi](SIMode mode) {
+          gdi.addItem("ReadType", lang.tl(modeName[mode]), int(mode));
+        };
+        addItem(SIMode::ModeReadOut);
+        addItem(SIMode::ModeEntry);
+        addItem(SIMode::ModeRequestStartTime);
+        addItem(SIMode::ModeAssignCards);
+        addItem(SIMode::ModeCheckCards);
+        addItem(SIMode::ModeRegisterCards);
+        addItem(SIMode::ModeCardData);
+
+        gdi.selectItemByData("ReadType", int(mode));
+
+        gdi.dropLine(-0.1);
+        gdi.addButton("LockFunction", "Lås funktion", SportIdentCB);
+        readoutFunctionX = gdi.getCX();
+        readoutFunctionY = gdi.getCY();
+        gdi.dropLine(0.3);
+
+        gdi.addCheckbox("PlaySound", "Ljud", SportIdentCB, oe->getPropertyInt("PlaySound", 1) != 0,
+          "Spela upp ett ljud för att indikera resultatet av brickavläsningen.");
+        gdi.dropLine(-0.3);
+
+        gdi.addButton("SoundChoice", "Ljudval...", SportIdentCB);
+
+        gdi.dropLine(0.3);
+
+        updateReadoutFunction(gdi);
+
+        gdi.dropLine(2);
+        gdi.setCX(xb + gdi.scaleLength(10));
+      }
+      else {
+        gdi.addString("", fontMediumPlus, lang.tl(modeName[mode]));
+        gdi.fillRight();
+        gdi.addButton("UnlockFunction", "Lås upp", SportIdentCB);
+        gdi.dropLine(0.2);
+      }
     }
     else {
-      gdi.addString("", fontMediumPlus, lang.tl(modeName[mode]));
-      gdi.fillRight();
-      gdi.addButton("UnlockFunction", "Lås upp", SportIdentCB);
-      gdi.dropLine(0.2);
+      mode = SIMode::ModeCardData;
     }
   }
-  else {
-    mode = SIMode::ModeCardData;
+  else { //Kiosk
+    gdi.pushX();
   }
 
   optionBarPosY = gdi.getCY();
@@ -2086,7 +2257,7 @@ bool TabSI::loadPage(gdioutput& gdi) {
     showAssignCard(gdi, true);
   }
   else if (mode == SIMode::ModeEntry) {
-    checkBoxToolBar(gdi, { CheckBox::UseDB, CheckBox::PrintStart });
+    checkBoxToolBar(gdi, { CheckBox::UseDB, CheckBox::PrintStart, CheckBox::ExtraDataFields });
     entryTips(gdi);
     generateEntryLine(gdi, 0);
   }
@@ -2099,7 +2270,9 @@ bool TabSI::loadPage(gdioutput& gdi) {
   else if (mode == SIMode::ModeRegisterCards) {
     showRegisterHiredCards(gdi);
   }
-
+  else if (mode == SIMode::ModeRequestStartTime) {
+    showRequestStartTime(gdi);
+  }
   // Unconditional clear
   activeSIC.clear(0);
 
@@ -2143,6 +2316,10 @@ void TabSI::checkBoxToolBar(gdioutput& gdi, const set<CheckBox>& items) const {
     gdi.addCheckbox("AutoTieRent", "Automatisk hyrbrickshantering genom registrerade hyrbrickor", SportIdentCB, oe->getPropertyInt("AutoTieRent", 1) != 0);
   }
 
+  if (items.count(CheckBox::ExtraDataFields)) {
+    gdi.dropLine(-0.2);
+    gdi.addButton("EditEntryFields", "Extra datafält", SportIdentCB); // Change
+  }
   if (!items.empty())
     gdi.dropLine(2);
 
@@ -2298,7 +2475,7 @@ pRunner TabSI::autoMatch(const SICard& sic, pRunner db_r)
         r->setCardNo(sic.CardNumber, false);
 
         if (oe->isHiredCard(sic.CardNumber)) {
-          r->getDI().setInt("CardFee", oe->getBaseCardFee());
+          r->setRentalCard(true);
         }
       }
       else r = 0; //Do not assume too much...
@@ -2372,6 +2549,10 @@ void TabSI::insertSICardAux(gdioutput& gdi, SICard& sic)
       checkCard(gdi, sic, true);
     return;
   }
+  else if (mode == SIMode::ModeRequestStartTime) {
+    requestStartTime(gdi, sic);
+    return;
+  }
   else if (mode == SIMode::ModeRegisterCards) {
     if (!pageLoaded) {
       CardQueue.push_back(sic);
@@ -2750,7 +2931,7 @@ void TabSI::startInteractive(gdioutput& gdi, const SICard& sic, pRunner r, pRunn
     gdi.pushX();
 
     gdi.addSelection("Classes", 200, 300, 0, L"Klass:");
-    gEvent->fillClasses(gdi, "Classes", oEvent::extraNone, oEvent::filterNone);
+    gEvent->fillClasses(gdi, "Classes", {}, oEvent::extraNone, oEvent::filterNone);
     gdi.setInputFocus("Classes");
     //Find matching class...
     vector<pClass> classes;
@@ -2782,18 +2963,19 @@ void TabSI::processInsertCard(const SICard& sic)
   card->setReadId(sic);
   card->setCardNo(sic.CardNumber);
   card->setMeasuredVoltage(sic.miliVolt);
+  oCard::PunchOrigin origin = sic.isDebugCard ? oCard::PunchOrigin::Manual : oCard::PunchOrigin::Original;
 
   if (sic.CheckPunch.Code != -1)
-    card->addPunch(oPunch::PunchCheck, sic.CheckPunch.Time, 0, sic.CheckPunch.Code);
+    card->addPunch(oPunch::PunchCheck, sic.CheckPunch.Time, 0, sic.CheckPunch.Code, origin);
 
   if (sic.StartPunch.Code != -1)
-    card->addPunch(oPunch::PunchStart, sic.StartPunch.Time, 0, sic.StartPunch.Code);
+    card->addPunch(oPunch::PunchStart, sic.StartPunch.Time, 0, sic.StartPunch.Code, origin);
 
   for (unsigned i = 0; i < sic.nPunch; i++)
-    card->addPunch(sic.Punch[i].Code, sic.Punch[i].Time, 0, 0);
+    card->addPunch(sic.Punch[i].Code, sic.Punch[i].Time, 0, 0, origin);
 
   if (sic.FinishPunch.Code != -1)
-    card->addPunch(oPunch::PunchFinish, sic.FinishPunch.Time, 0, sic.FinishPunch.Code);
+    card->addPunch(oPunch::PunchFinish, sic.FinishPunch.Time, 0, sic.FinishPunch.Code, origin);
 
   //Update to SQL-source
   card->synchronize();
@@ -2820,18 +3002,19 @@ bool TabSI::processUnmatched(gdioutput& gdi, const SICard& csic, bool silent) {
 
   // Convert punch times to relative times.
   gEvent->convertTimes(nullptr, sic);
+  oCard::PunchOrigin origin = sic.isDebugCard ? oCard::PunchOrigin::Manual : oCard::PunchOrigin::Original;
 
   if (sic.CheckPunch.Code != -1)
-    card->addPunch(oPunch::PunchCheck, sic.CheckPunch.Time, 0, sic.CheckPunch.Code);
+    card->addPunch(oPunch::PunchCheck, sic.CheckPunch.Time, 0, sic.CheckPunch.Code, origin);
 
   if (sic.StartPunch.Code != -1)
-    card->addPunch(oPunch::PunchStart, sic.StartPunch.Time, 0, sic.StartPunch.Code);
+    card->addPunch(oPunch::PunchStart, sic.StartPunch.Time, 0, sic.StartPunch.Code, origin);
 
   for (unsigned i = 0; i < sic.nPunch; i++)
-    card->addPunch(sic.Punch[i].Code, sic.Punch[i].Time, 0, 0);
+    card->addPunch(sic.Punch[i].Code, sic.Punch[i].Time, 0, 0, origin);
 
   if (sic.FinishPunch.Code != -1)
-    card->addPunch(oPunch::PunchFinish, sic.FinishPunch.Time, 0, sic.FinishPunch.Code);
+    card->addPunch(oPunch::PunchFinish, sic.FinishPunch.Time, 0, sic.FinishPunch.Code, origin);
   else
     rout.warnings += lang.tl("Målstämpling saknas.");
 
@@ -2944,6 +3127,7 @@ bool TabSI::processCard(gdioutput& gdi, pRunner runner, const SICard& csic, bool
     runner->setStatus(StatusOK, true, oBase::ChangeType::Update, false);
   SICard sic(csic);
   StoredReadout rout;
+  rout.runnerId = runner->getId();
 
   if (!csic.isManualInput()) {
     pCard card = gEvent->allocateCard(runner);
@@ -2967,20 +3151,21 @@ bool TabSI::processCard(gdioutput& gdi, pRunner runner, const SICard& csic, bool
     pCourse prelCourse = runner->getCourse(false);
     const int finishPT = prelCourse ? prelCourse->getFinishPunchType() : oPunch::PunchFinish;
     bool hasFinish = false;
+    oCard::PunchOrigin origin = sic.isDebugCard ? oCard::PunchOrigin::Manual : oCard::PunchOrigin::Original;
 
     if (sic.CheckPunch.Code != -1)
-      card->addPunch(oPunch::PunchCheck, sic.CheckPunch.Time, 0, sic.CheckPunch.Code);
+      card->addPunch(oPunch::PunchCheck, sic.CheckPunch.Time, 0, sic.CheckPunch.Code, origin);
 
     if (sic.StartPunch.Code != -1)
-      card->addPunch(oPunch::PunchStart, sic.StartPunch.Time, 0, sic.StartPunch.Code);
+      card->addPunch(oPunch::PunchStart, sic.StartPunch.Time, 0, sic.StartPunch.Code, origin);
 
     for (unsigned i = 0; i < sic.nPunch; i++) {
       if (sic.Punch[i].Code == finishPT)
         hasFinish = true;
-      card->addPunch(sic.Punch[i].Code, sic.Punch[i].Time, 0, 0);
+      card->addPunch(sic.Punch[i].Code, sic.Punch[i].Time, 0, 0, origin);
     }
     if (sic.FinishPunch.Code != -1) {
-      card->addPunch(oPunch::PunchFinish, sic.FinishPunch.Time, 0, sic.FinishPunch.Code);
+      card->addPunch(oPunch::PunchFinish, sic.FinishPunch.Time, 0, sic.FinishPunch.Code, origin);
       if (finishPT == oPunch::PunchFinish)
         hasFinish = true;
     }
@@ -3044,8 +3229,8 @@ bool TabSI::processCard(gdioutput& gdi, pRunner runner, const SICard& csic, bool
       rout.statusline += lang.tl(L",      Prel. placering: ") + placeS;
     rout.statusline += lang.tl(L",     Prel. bomtid: ") + runner->getMissedTimeS();
 
-    rout.rentCard = runner->isHiredCard() || oe->isHiredCard(sic.CardNumber);
-
+    rout.rentCard = runner->isRentalCard() || oe->isHiredCard(sic.CardNumber);
+    
     if (!silent) {
       rout.render(gdi, rout.computeRC(gdi));
       gdi.scrollToBottom();
@@ -3075,7 +3260,7 @@ bool TabSI::processCard(gdioutput& gdi, pRunner runner, const SICard& csic, bool
       rout.statusline += L", (" + mpList + +L")";
 
     rout.color = colorLightRed;
-    rout.rentCard = runner->isHiredCard() || oe->isHiredCard(sic.CardNumber);
+    rout.rentCard = runner->isRentalCard() || oe->isHiredCard(sic.CardNumber);
 
     if (!silent) {
       rout.render(gdi, rout.computeRC(gdi));
@@ -3125,6 +3310,12 @@ RECT TabSI::StoredReadout::computeRC(gdioutput& gdi) const {
 void TabSI::StoredReadout::render(gdioutput& gdi, const RECT& rc) const {
   gdi.fillDown();
   gdi.addRectangle(rc, color, true);
+
+  //gdi.addString("edit", rc.right - gdi.scaleLength(30), rc.top+gdi.scaleLength(4), textImage, "S" + itos(gdi.scaleLength(24)));
+  if (runnerId > 0) {
+    gdi.addImage("edit", rc.top + gdi.scaleLength(4), rc.right - gdi.scaleLength(30), 0,
+      itow(IDI_MEOSEDIT), gdi.scaleLength(24), gdi.scaleLength(24), SportIdentCB).setExtra(runnerId);
+  }
   int lh = gdi.getLineHeight();
   int marg = gdi.scaleLength(20);
   int tmarg = gdi.scaleLength(6);
@@ -3215,22 +3406,24 @@ wstring TabSI::getTimeAfterString(const oRunner* runner) {
 
 void TabSI::processPunchOnly(gdioutput& gdi, const SICard& csic)
 {
+  gdi.makeEvent("PunchCard", "sireadout", csic.CardNumber, 0, true);
+
   SICard sic = csic;
   DWORD loaded;
   gEvent->convertTimes(nullptr, sic);
-  oFreePunch* ofp = 0;
+  oFreePunch* ofp = nullptr;
   wstring accessError;
   if (sic.nPunch == 1) {
-    ofp = gEvent->addFreePunch(sic.Punch[0].Time, sic.Punch[0].Code, 0, sic.CardNumber, true);
+    ofp = gEvent->addFreePunch(sic.Punch[0].Time, sic.Punch[0].Code, 0, sic.CardNumber, true, !sic.isDebugCard);
   }
   else if (sic.FinishPunch.Time > 0) {
-    ofp = gEvent->addFreePunch(sic.FinishPunch.Time, oPunch::PunchFinish, sic.FinishPunch.Code, sic.CardNumber, true);
+    ofp = gEvent->addFreePunch(sic.FinishPunch.Time, oPunch::PunchFinish, sic.FinishPunch.Code, sic.CardNumber, true, !sic.isDebugCard);
   }
   else if (sic.StartPunch.Time > 0) {
-      ofp = gEvent->addFreePunch(sic.StartPunch.Time, oPunch::PunchStart, sic.StartPunch.Code, sic.CardNumber, true);
+    ofp = gEvent->addFreePunch(sic.StartPunch.Time, oPunch::PunchStart, sic.StartPunch.Code, sic.CardNumber, true, !sic.isDebugCard);
   }
   else {
-    ofp = gEvent->addFreePunch(sic.CheckPunch.Time, oPunch::PunchCheck, sic.CheckPunch.Code, sic.CardNumber, true);
+    ofp = gEvent->addFreePunch(sic.CheckPunch.Time, oPunch::PunchCheck, sic.CheckPunch.Code, sic.CardNumber, true, !sic.isDebugCard);
   }
   if (ofp) {
     pRunner r = ofp->getTiedRunner();
@@ -3360,7 +3553,7 @@ void TabSI::assignCard(gdioutput& gdi, const SICard& sic)
         gdi.ask(L"Skriv över existerande bricknummer?")) {
 
         r->setCardNo(sic.CardNumber, false);
-        r->getDI().setInt("CardFee", oe->getBaseCardFee());
+        r->setRentalCard(true);
         r->synchronize();
         gdi.setText(ii->id, sicode);
       }
@@ -3408,7 +3601,7 @@ void TabSI::generateEntryLine(gdioutput& gdi, pRunner r) {
     if (d.empty() && oe->getNumClasses() > 0) {
       gdi.alert(L"Inga klasser tillåter direktanmälan. På sidan klasser kan du ändra denna egenskap.");
     }
-    gdi.addItem("Class", d);
+    gdi.setItems("Class", d);
   }
 
   if (storedInfo.storedClassId > 0 && gdi.selectItemByData("Class", storedInfo.storedClassId)) {
@@ -3434,26 +3627,26 @@ void TabSI::generateEntryLine(gdioutput& gdi, pRunner r) {
   gdi.popX();
   gdi.dropLine(3.1);
 
-  gdi.addString("", 0, "Starttid:");
-  gdi.dropLine(-0.2);
-  gdi.addInput("StartTime", storedInfo.storedStartTime, 5, 0, L"");
+  int cnt = TabRunner::addExtraFields(*oe, gdi, oEvent::ExtraFieldContext::DirectEntry);
+  auto setIf = [&gdi](const string& wg, const wstring& val) {
+    if (gdi.hasWidget(wg))
+      gdi.setText(wg, val);
+  };
+  setIf("StartTime", storedInfo.storedStartTime);
+  setIf("Phone", storedInfo.storedPhone);
+  setIf("DataA", storedInfo.dataA);
+  setIf("DataB", storedInfo.dataB);
+  setIf("TextA", storedInfo.textA);
+  setIf("Nationality", storedInfo.nationality);
+  setIf("BirthDate", storedInfo.birthDate);
+  setIf("Rank", storedInfo.rank);
+  if (gdi.hasWidget("Sex"))
+    gdi.selectItemByData("Sex", storedInfo.sex);
 
-  gdi.setCX(gdi.getCX() + gdi.scaleLength(20));
-  gdi.dropLine(0.2);
-
-  gdi.addString("", 0, "Nummerlapp:");
-  gdi.dropLine(-0.2);
-  gdi.addInput("Bib", L"", 5, 0, L"");
-
-  gdi.setCX(gdi.getCX() + gdi.scaleLength(20));
-  gdi.dropLine(0.2);
-
-  gdi.addString("", 0, "Telefon:");
-  gdi.dropLine(-0.2);
-  gdi.addInput("Phone", storedInfo.storedPhone, 12, 0, L"");
-  gdi.dropLine(0.2);
-
-  gdi.setCX(gdi.getCX() + gdi.scaleLength(20));
+  if (cnt > 0) {
+    gdi.setCX(gdi.getCX() + gdi.scaleLength(20));
+    gdi.dropLine(0.2);
+  }
 
   gdi.addCheckbox("RentCard", "Hyrbricka", SportIdentCB, storedInfo.rentState);
   gdi.addCheckbox("NoTiming", "Utan tidtagning", nullptr, false);
@@ -3471,15 +3664,18 @@ void TabSI::generateEntryLine(gdioutput& gdi, pRunner r) {
     }
     gdi.selectItemByData("Class", r->getClassId(true));
 
+    TabRunner::loadExtraFields(gdi, r);
     oDataConstInterface dci = r->getDCI();
     if (gdi.hasWidget("Fee"))
       gdi.setText("Fee", oe->formatCurrency(dci.getInt("Fee")));
 
-    gdi.setText("StartTime", r->getStartTimeS());
-    gdi.setText("Phone", dci.getString("Phone"));
-    gdi.setText("Bib", r->getBib());
+    if (gdi.hasWidget("StartTime"))
+      gdi.setText("StartTime", r->getStartTimeS());
+  
+    if (gdi.hasWidget("Bib"))
+      gdi.setText("Bib", r->getBib());
     gdi.check("NoTiming", r->hasFlag(oAbstractRunner::TransferFlags::FlagNoTiming));
-    gdi.check("RentCard", dci.getInt("CardFee") != 0);
+    gdi.check("RentCard", r->isRentalCard());
     if (gdi.hasWidget("Paid"))
       gdi.check("Paid", dci.getInt("Paid") > 0);
     else if (gdi.hasWidget("PayMode")) {
@@ -3567,10 +3763,10 @@ void TabSI::generateSplits(const pRunner r, gdioutput& gdi)
   }
 }
 
-void TabSI::generateStartInfo(gdioutput& gdi, const oRunner& r) {
+void TabSI::generateStartInfo(gdioutput& gdi, const oRunner& r, bool includeEconomy) {
   if (printStartInfo) {
     gdioutput gdiprint(2.0, gdi.getHWNDTarget(), splitPrinter);
-    r.printStartInfo(gdiprint);
+    r.printStartInfo(gdiprint, includeEconomy);
     printProtected(gdi, gdiprint);
     //gdiprint.print(splitPrinter, oe, false, true);
   }
@@ -3679,7 +3875,7 @@ void TabSI::tieCard(gdioutput& gdi) {
 
   r->synchronize();
   r->setCardNo(card, true, false);
-  r->getDI().setInt("CardFee", rent ? oe->getBaseCardFee() : 0);
+  r->setRentalCard(rent);
   r->synchronize(true);
 
   gdi.restore("ManualTie");
@@ -3707,19 +3903,10 @@ void TabSI::tieCard(gdioutput& gdi) {
 }
 
 void TabSI::showAssignCard(gdioutput& gdi, bool showHelp) {
-  //gdi.fillDown();
-  //gdi.setRestorePoint("AssignCardBase");
   if (interactiveReadout) {
     if (showHelp) {
       checkBoxToolBar(gdi, { CheckBox::Interactive, CheckBox::AutoTie, CheckBox::AutoTieRent });
       gdi.addString("", 10, L"Avmarkera 'X' för att hantera alla bricktildelningar samtidigt.#" + lang.tl("Interaktiv inläsning"));
-      /*gdi.dropLine(0.5);
-      gdi.addCheckbox("AutoTie", "Knyt automatiskt efter inläsning", SportIdentCB, oe->getPropertyInt("AutoTie", 1) != 0);
-      gdi.addCheckbox("AutoTieRent", "Automatisk hyrbrickshantering genom registrerade hyrbrickor", SportIdentCB, oe->getPropertyInt("AutoTieRent", 1) != 0);
-      if (!oe->hasHiredCardData()) {
-        gdi.disableInput("AutoTieRent");
-        gdi.check("AutoTieRent", false);
-      }*/
       gdi.dropLine(0.5);
       gdi.setRestorePoint("ManualTie");
     }
@@ -3730,8 +3917,7 @@ void TabSI::showAssignCard(gdioutput& gdi, bool showHelp) {
       gdi.addString("", 10, L"Markera 'X' för att hantera deltagarna en och en.#" + lang.tl("Interaktiv inläsning"));
     }
 
-    gEvent->assignCardInteractive(gdi, SportIdentCB);
-    gdi.refresh();
+    gEvent->assignCardInteractive(gdi, SportIdentCB, sortAssignCards);
     return;
   }
 
@@ -4260,6 +4446,13 @@ void TabSI::StoredStartInfo::clear() {
   storedClub.clear();
   storedFee.clear();
   storedPhone.clear();
+  dataA.clear();
+  dataB.clear();
+  textA.clear();
+  sex = 2;
+  rank.clear();
+  nationality.clear();
+  birthDate.clear();
   rentState = false;
   storedStartTime.clear();
   hasPaid = false;
@@ -4291,6 +4484,10 @@ void TabSI::clearCompetitionData() {
 
   logger.reset();
   numSavedCardsOnCmpOpen = savedCards.size();
+
+  requestStartTimeHandler.reset();
+
+  sortAssignCards = SortOrder::Custom;
 }
 
 SICard& TabSI::getCard(int id) const {
@@ -4347,11 +4544,6 @@ wstring TabSI::getCardInfo(bool param, vector<int>& count) const {
 void TabSI::showRegisterHiredCards(gdioutput& gdi) {
   checkBoxToolBar(gdi, { });
 
-  /*gdi.disableInput("Interactive");
-  gdi.disableInput("Database", true);
-  gdi.disableInput("PrintSplits");
-  gdi.disableInput("UseManualInput");
-  */
   gdi.fillDown();
   gdi.addString("", 10, "help:registerhiredcards");
 
@@ -4438,7 +4630,7 @@ void TabSI::showCheckCardStatus(gdioutput& gdi, const string& cmd) {
           checkedCardFlags[cno] == CNFRentAndNotRent) {
           int yp = gdi.getCY();
           wstring cp = r[k]->getCompleteIdentification();
-          bool hire = r[k]->isHiredCard();
+          bool hire = r[k]->isRentalCard();
           wstring info = hire ? (L" (" + lang.tl("Hyrd") + L")") : L"";
           gdi.addStringUT(yp, cx, 0, itow(cno) + info);
           gdi.addStringUT(yp, cx + col2, 0, cp);
@@ -4591,7 +4783,7 @@ void TabSI::generatePayModeWidget(gdioutput& gdi) const {
   else {
     pm.insert(pm.begin(), make_pair(lang.tl(L"Faktureras"), 1000));
     gdi.addSelection("PayMode", 110, 100, SportIdentCB);
-    gdi.addItem("PayMode", pm);
+    gdi.setItems("PayMode", pm);
     gdi.selectItemByData("PayMode", storedInfo.payMode);
     gdi.autoGrow("PayMode");
   }
@@ -4706,7 +4898,7 @@ RunnerWDBEntry* TabSI::extractRunner(gdioutput& gdi) const {
 void TabSI::DirectEntryGUI::updateFees(gdioutput& gdi, const pClass cls, int age) {
   int fee = cls->getEntryFee(getLocalDate(), age);
   auto fees = cls->getAllFees();
-  gdi.addItem("Fee", fees);
+  gdi.setItems("Fee", fees);
   if (fee > 0) {
     gdi.selectItemByData("Fee", fee);
     gdi.setText("Fee", tabSI->oe->formatCurrency(fee));
@@ -4959,7 +5151,7 @@ void TabSI::showReadoutStatus(gdioutput& gdi, const oRunner* r,
   GDICOLOR bgColor = GDICOLOR::colorDefault;
 
   if (r != nullptr) {
-    if (r->isHiredCard() || oe->isHiredCard(r->getCardNo()))
+    if (r->isRentalCard() || oe->isHiredCard(r->getCardNo()))
       rentalCard = true;
 
     gdi.addStringUT(h / 3, mrg, boldHuge | textCenter, r->getCompleteIdentification(), w - 2 * mrg);
@@ -5088,7 +5280,7 @@ void TabSI::showReadoutStatus(gdioutput& gdi, const oRunner* r,
 
   if (rentalCard) {
     gdi.addRectangle(rc, colorYellow);
-    gdi.addStringUT(rc.top + (rc.bottom - rc.top) / 3, mrg, boldHuge | textCenter,
+    gdi.addString("", rc.top + (rc.bottom - rc.top) / 3, mrg, boldHuge | textCenter,
       "Vänligen återlämna hyrbrickan.", w - 3 * mrg);
   }
 
@@ -5168,3 +5360,742 @@ void TabSI::fillMappings(gdioutput& gdi) const {
     gdi.addItem("Mappings", itow(mp.first) + L" \u21A6 " + oPunch::getType(mp.second), mp.first);
   }
 }
+
+void TabSI::readTestData(gdioutput& gdi) {
+  testCardNumber = gdi.getTextNo("SI");
+  if (gdi.hasWidget("PunchTime")) {
+    testPunchTime = gdi.getText("PunchTime");
+  }
+  else {
+    useTestCheck = gdi.isChecked("HasCheck");
+    useTestStart = gdi.isChecked("HasStart");
+    useTestFinish = gdi.isChecked("HasFinish");
+
+    testStartTime = gdi.getText("Start");
+    testFinishTime = gdi.getText("Finish");
+    testCheckTime = gdi.getText("Check");
+
+    if (NC > testControls.size())
+      testControls.resize(NC);
+
+    for (int i = 0; i < NC; i++) 
+      testControls[i] = gdi.getTextNo("C" + itos(i+1));
+  }
+}
+
+
+class RequestStart : public GuiHandler, public enable_shared_from_this<RequestStart> {
+private:
+  oEvent* oe;
+  TabSI* si;
+  bool active = false;
+  int storedRunner = 0;
+  int storedCard = 0;
+
+  void save(gdioutput& gdi) {
+    gdi.getSelection("Classes", selectedClasses);
+    firstStart = oe->getRelativeTime(gdi.getText("FirstStart"));
+    lastStart = oe->getRelativeTime(gdi.getText("LastStart"));
+    if (lastStart > 0)
+      oe->setProperty("RequestLastStart", gdi.getText("LastStart"));
+    
+    interval = convertAbsoluteTimeMS(gdi.getText("Interval"));
+    if (interval != NOTIME)
+      oe->setProperty("RequestStartInterval", gdi.getText("Interval"));
+    
+    allowSameCourse = gdi.isChecked("AllowSameCourse");
+    allowSameCourseNeighbour = gdi.isChecked("AllowSameCourseNext");
+    allowSameFirstControl = gdi.isChecked("AllowSameControl");
+    allowClubNeighbour = gdi.isChecked("AllowSameClub");
+    maxParallel = gdi.getTextNo("MaxParallel");
+
+    oe->setProperty("RequestSameCourse", allowSameCourse);
+    oe->setProperty("RequestSameCourseNeighbour", allowSameCourseNeighbour);
+    oe->setProperty("RequestSameFirstControl", allowSameFirstControl);
+    oe->setProperty("RequestClubNeighbour", allowClubNeighbour);
+    oe->setProperty("RequestMaxParallel", maxParallel);
+
+    timeToSuggestion = convertAbsoluteTimeMS(gdi.getText("TimeToFirstStart"));
+    if (timeToSuggestion != NOTIME)
+      oe->setProperty("RequestMinTime", gdi.getText("TimeToFirstStart"));
+
+    provideSuggestions = gdi.isChecked("SuggestTimes");
+    oe->setProperty("RequestProvideSuggestion", provideSuggestions);
+
+    suggestionDistance = convertAbsoluteTimeMS(gdi.getText("TimeInterval"));
+    
+    if (provideSuggestions && suggestionDistance != NOTIME)
+      oe->setProperty("RequestSuggestInterval", gdi.getText("TimeInterval")); 
+  }
+  
+  void makeSuggestions(gdioutput& gdi, pRunner r, int cardNo, int now) {
+    oe->synchronizeList(oListId::oLRunnerId);
+    vector<int> times;
+    int suggestionDist = this->suggestionDistance;
+    if ((suggestionDist % interval) != 0)
+      suggestionDist = suggestionDist - (suggestionDist % interval) + interval;
+
+    int lastTime = now;
+    while (lastTime <= lastStart) {
+      int t = oe->requestStartTime(r->getId(), lastTime, interval, lastStart,
+                                   maxParallel, allowSameCourse, allowSameCourseNeighbour,
+                                   allowSameFirstControl, allowClubNeighbour);
+      if (t > 0) {
+        times.push_back(t);
+        lastTime = t + suggestionDist;
+        suggestionDist = (suggestionDist * 3) / 2;
+        if (suggestionDist > timeConstMinute * 30)
+          suggestionDist = timeConstMinute * 20;
+
+        if ((suggestionDist % interval) != 0)
+          suggestionDist = suggestionDist - (suggestionDist % interval) + interval;
+      }
+      else
+        break;
+    }
+    
+    gdi.restore("SelectStart");
+    gdi.setRestorePoint("SelectStart");
+    gdi.fillDown();
+    gdi.dropLine(2);
+    gdi.addString("", boldHuge, L"Välj starttid för X#" + r->getName() + L", " + r->getClub());
+    gdi.dropLine(3);
+
+    int bz = gdi.scaleLength(150);
+    int xp = gdi.getCX();
+    int base = xp;
+    
+    int yp = gdi.getCY();
+    int w, h;
+    gdi.getTargetDimension(w, h);
+    int margin = gdi.scaleLength(20);
+    
+    auto raw = shared_from_this();
+
+    
+    for (int t : times) {
+      wstring ts = (t % timeConstMinute) == 0 ? oe->getAbsTimeHM(t) : oe->getAbsTime(t);
+
+      gdi.addButton(xp, yp, bz, bz, "SelectStart", ts, 
+                    gdiFonts::boldHuge, nullptr, L"", false, false).setHandler(raw).setExtra(t);
+
+      xp += bz + margin;
+      if (xp > w - 2 * bz) {
+        xp = base;
+        yp += bz + margin;
+      }
+    }
+    gdi.addButton(xp, yp, bz, bz, "Cancel", L"Avbryt",
+      gdiFonts::boldLarge, SportIdentCB, L"", false, false).setCancel();
+
+    storedRunner = r->getId();
+    storedCard = cardNo;
+
+    gdi.dropLine(4);
+    gdi.refresh();
+  }
+
+public:
+
+  bool showSettings() {
+    return !active;
+  }
+
+  int firstStart = 0;
+  int lastStart = 0;
+  int interval = 0;
+  int timeToSuggestion = 0;
+  int suggestionDistance = 0;
+  set<int> selectedClasses;
+  int maxParallel = 10;
+  bool allowSameCourse = false;
+  bool allowSameCourseNeighbour = false;
+  bool allowSameFirstControl = true;
+  bool allowClubNeighbour = false;
+
+  bool provideSuggestions = false;
+  
+  RequestStart(TabSI* si) : oe(si->getEvent()), si(si) {
+    int now = oe->getRelativeTime(oe->getCurrentTimeS());
+    now -= (now % (timeConstMinute*15)) - (timeConstMinute*15);
+    if (now > timeConstHour * 20)
+      now = timeConstHour;
+
+    firstStart = max(timeConstHour, now);
+    lastStart = oe->getRelativeTime(oe->getPropertyString("RequestLastStart", oe->getAbsTime(now)));
+    lastStart = min(max(lastStart, firstStart + timeConstHour * 2), firstStart+timeConstHour*6);
+
+    interval = convertAbsoluteTimeMS(oe->getPropertyString("RequestStartInterval", L"2:00"));
+    if (interval == NOTIME)
+      interval = timeConstMinute * 2;
+
+    timeToSuggestion = convertAbsoluteTimeMS(oe->getPropertyString("RequestMinTime", L"30:00"));
+    if (timeToSuggestion == NOTIME)
+      timeToSuggestion = timeConstMinute * 30;
+
+    provideSuggestions = oe->getPropertyBool("RequestProvideSuggestion", provideSuggestions);
+
+    suggestionDistance = convertAbsoluteTimeMS(oe->getPropertyString("RequestSuggestInterval", L"10:00"));
+    if (suggestionDistance == NOTIME)
+      suggestionDistance = suggestionDistance * 10;
+
+    allowSameCourse = oe->getPropertyBool("RequestSameCourse", allowSameCourse);
+    allowSameCourseNeighbour = oe->getPropertyBool("RequestSameCourseNeighbour", allowSameCourseNeighbour);
+    allowSameFirstControl = oe->getPropertyBool("RequestSameFirstControl", allowSameFirstControl);
+    allowClubNeighbour = oe->getPropertyBool("RequestClubNeighbour", allowClubNeighbour);
+    maxParallel = oe->getPropertyInt("RequestMaxParallel", maxParallel);
+
+    vector<pClass> cls;
+    oe->getClasses(cls, false);
+    for (pClass c : cls) {
+      if (c->hasRequestStart())
+        selectedClasses.insert(c->getId());
+    }
+  };
+
+  RequestStart(const RequestStart &) = delete;
+  RequestStart& operator=(const RequestStart&) = delete;
+  RequestStart(RequestStart&&) = delete;
+  RequestStart& operator=(RequestStart&&) = delete;
+
+  void loadPage(gdioutput& gdi, shared_ptr<RequestStart> &h) {
+    bool settings = h->showSettings();
+    TabSI& tsi = dynamic_cast<TabSI&>(*gdi.getTabs().get(TSITab));
+
+    gdi.fillDown();
+    if (oe->isKiosk()) {
+      int width, height;
+      gdi.getTargetDimension(width, height);
+      gdi.addString("", textImage, "513");
+      gdi.dropLine(3);
+      RECT rc;
+      rc.top = gdi.getCY();
+      rc.bottom = rc.top + 4;
+      rc.left = gdi.scaleLength(30);
+      rc.right = width - rc.left;
+      gdi.addRectangle(rc, GDICOLOR::colorGreyBlue, false);
+
+      gdi.addString("", gdi.getCY(), width/2, gdiFonts::boldHuge | textCenter, "Boka starttid");
+    }
+    else {
+      gdi.addString("", fontLarge, "Boka starttid");
+
+      if (settings) {
+        gdi.dropLine();
+        gdi.pushY();
+        gdi.setRestorePoint("RequestSettings");
+        gdi.addListBox("Classes", 220, 400, nullptr, L"Klasser:", L"", true);
+        gdi.setTabStops("Classes", 170);
+        gEvent->fillClasses(gdi, "Classes", {}, oEvent::extraNone, oEvent::filterNone);
+        gdi.setSelection("Classes", h->selectedClasses);
+        gdi.dropLine();
+
+        auto classesBox = gdi.getDimensionSince("RequestSettings");
+
+        gdi.fillRight();
+        gdi.addButton("SelectDefault", "Återställ").setHandler(h);
+        gdi.addButton("SelectAll", "Välj alla").setHandler(h);
+        gdi.addButton("SelectNone", "Välj ingen").setHandler(h);
+
+        gdi.setCX(classesBox.right + gdi.scaleLength(20));
+        gdi.popY();
+        gdi.pushX();
+
+        gdi.fillRight();
+        gdi.addInput("FirstStart", oe->getAbsTime(h->firstStart), 10, nullptr, L"Första starttid:");
+        gdi.addInput("LastStart", oe->getAbsTime(h->lastStart), 10, nullptr, L"Sista starttid:");
+        gdi.fillDown();
+        gdi.addInput("Interval", formatTimeMS(h->interval, true), 10, nullptr, L"Startintervall (minuter):");
+        gdi.popX();
+        gdi.dropLine(1);
+
+        gdi.fillDown();
+        gdi.addInput("TimeToFirstStart", formatTimeMS(h->timeToSuggestion, true), 10, nullptr, L"Minsta tid till start (minuter):");
+        
+        gdi.dropLine();
+        gdi.addCheckbox("SuggestTimes", "Välj från flera förslag", nullptr, h->provideSuggestions).setHandler(h);
+        
+        gdi.addInput("TimeInterval", formatTimeMS(h->suggestionDistance, true), 10, nullptr, L"Avstånd mellan förslag (minuter):");
+        gdi.setInputStatus("TimeInterval", h->provideSuggestions);
+
+        gdi.popX();
+        gdi.dropLine(0.5);
+        gdi.addCheckbox("AllowSameCourse", "Tillåt klass med samma bana på samma starttid", nullptr, h->allowSameCourse);
+        gdi.addCheckbox("AllowSameCourseNext", "Tillåt klass med samma bana på stattid före/efter", nullptr, h->allowSameCourseNeighbour);
+        gdi.addCheckbox("AllowSameControl", "Tillåt klass med samma första kontroll vid samma starttid", nullptr, h->allowSameFirstControl);
+        gdi.addCheckbox("AllowSameClub", "Tillåt deltagare med samma klubb och klass på närliggande starttid", nullptr, h->allowClubNeighbour);
+        gdi.dropLine(0.5);
+        gdi.addInput("MaxParallel", itow(h->maxParallel), 10, 0, L"Max parallellt startande:");
+       
+        gdi.dropLine(2);
+        gdi.fillRight();
+        gdi.addButton("Save", "Aktivera").setDefault().setHandler(h);
+        
+        auto settingsBox = gdi.getDimensionSince("RequestSettings");
+        gdi.setCX(settingsBox.right + gdi.scaleLength(20));
+        gdi.popY();
+        gdi.pushX();
+
+        gdi.setOnClearCb(h);
+        gdi.addString("", 10, "help:requeststart");
+        return;
+      }
+      else {
+        int now = oe->getRelativeTime(oe->getCurrentTimeS());
+        if (now > timeConstHour * 20)
+          now = timeConstMinute;
+
+        now -= (now % timeConstMinute) - timeConstMinute;        
+        wstring t = oe->getAbsTimeHM(max(firstStart, now + timeToSuggestion));
+               
+        gdi.pushX();
+        gdi.dropLine(1);
+
+        gdi.fillRight();
+        gdi.addButton("Settings", "Inställningar...").setHandler(h);
+        gdi.addButton("Simulate", "Simulering...").setHandler(h);
+       
+        if (tsi.anyActivePort())
+          gdi.addButton("SaveKiosk", "Aktivera kioskläge").setHandler(h);
+
+        gdi.popX();
+        gdi.fillDown();
+
+        gdi.dropLine(3);
+
+        RECT rc;
+        rc.top = gdi.getCY();
+        rc.left = gdi.getCX();
+        gdi.setCX(gdi.getCX() + gdi.getLineHeight());
+        gdi.dropLine();
+        gdi.pushX();
+
+        gdi.addString("", fontMediumPlus, "Manuellt startönskemål");
+        gdi.fillRight();
+        gdi.addSelection("Runners", 200, 400, nullptr, L"Deltagare:");
+        vector<pRunner> rList;
+        oe->getRunners(selectedClasses, rList, true);
+                
+        sort(rList.begin(), rList.end(), [](const pRunner& a, const pRunner& b) -> bool {
+          return CompareString(LOCALE_USER_DEFAULT, 0,
+                               a->getName().c_str(), a->getName().length(),
+                               b->getName().c_str(), b->getName().length()) == CSTR_LESS_THAN; });
+
+        vector<pair<wstring, size_t>> rItem;
+        for (pRunner r : rList) {
+          if (r->getStartTime() == 0) {
+            rItem.emplace_back(r->getCompleteIdentification() + L", " + r->getClass(true), r->getId());
+          }
+        }
+                
+        gdi.setItems("Runners", rItem);
+        gdi.autoGrow("Runners");
+        gdi.addInput("StartTime", t, 10, nullptr, L"Önskad starttid:");
+        gdi.dropLine();
+        gdi.addButton("GetStart", "Tilldela").setHandler(h);
+
+        gdi.dropLine(3);
+        rc.bottom = gdi.getCY();
+        rc.right = gdi.getCX();
+        gdi.addRectangle(rc, GDICOLOR::colorLightCyan);
+
+        gdi.fillDown();
+        gdi.setCX(rc.left);
+        gdi.pushX();
+      }
+    }
+    
+    gdi.setData("RequestStart", 1);
+    gdi.setRestorePoint("RequestStart");
+ 
+    if (!settings) {
+      punchInfo(gdi, !tsi.anyActivePort());
+      gdi.dropLine(6);
+    }
+  }
+
+  void punchInfo(gdioutput& gdi, bool showPortInfo) {
+    gdi.dropLine(3);
+    if (showPortInfo) {
+      gdi.fillRight();
+      gdi.addString("", textImage, "S25");
+      gdi.fillDown();
+      gdi.addString("", 0, "Anslut en SI-enhet och aktivera den.");
+      gdi.popX();
+    }
+    else {
+      if (provideSuggestions)
+        gdi.addString("", boldHuge, L"Stämpla för välja starttid");
+      else
+        gdi.addString("", boldHuge, L"Stämpla för att boka första lediga tid om X minuter#" + itow(timeToSuggestion / timeConstMinute));
+    }
+    gdi.dropLine(3);
+  }
+
+  void handle(gdioutput& gdi, BaseInfo& info, GuiEventType type) final {
+    if (type == GuiEventType::GUI_TIMER) {
+      TimerInfo& ti = dynamic_cast<TimerInfo &>(info);
+
+      if (ti.id == "RequestedStart") {
+        gdi.restore("RequestStart", false);
+        punchInfo(gdi, false);
+        gdi.refreshFast();
+      }
+    }
+    else if (type == GuiEventType::GUI_BUTTON) {
+      const ButtonInfo& bi = dynamic_cast<ButtonInfo&>(info);
+
+      if (bi.id == "Settings") {
+        active = false;
+        si->loadPage(gdi);
+      }
+      else if (bi.id == "Save") {
+        save(gdi);
+        active = true;
+        si->loadPage(gdi);
+      }
+      else if (bi.id == "SaveKiosk") {
+        if (gdi.ask(L"ask:startkiosk")) {
+          //save(gdi);
+          active = true;
+          oe->setKiosk();
+          si->loadPage(gdi);
+        }
+      }
+      else if (bi.id == "SelectAll") {
+        vector<pClass> cls;
+        oe->getClasses(cls, false);
+        for (auto& c : cls)
+          selectedClasses.insert(c->getId());
+        gdi.setSelection("Classes", selectedClasses);
+      }
+      else if (bi.id == "SelectNone") {
+        selectedClasses.clear();
+        gdi.setSelection("Classes", selectedClasses);
+      }
+      else if (bi.id == "SelectDefault") {
+        vector<pClass> cls;
+        oe->getClasses(cls, false);
+        selectedClasses.clear();
+        for (pClass c : cls) {
+          if (c->hasRequestStart())
+            selectedClasses.insert(c->getId());
+        }
+        gdi.setSelection("Classes", selectedClasses);
+      }
+      else if (bi.id == "SuggestTimes") {
+        gdi.setInputStatus("TimeInterval", gdi.isChecked(bi.id));
+      }
+      else if (bi.id == "SelectStart") {
+        int t = bi.getExtraInt();
+        pRunner r = oe->getRunner(storedRunner, 0);
+        if (storedRunner <= 0)
+          throw meosException("Internal error");
+
+        gdi.restore("SelectStart", false);
+        gdi.fillDown();
+        requestStartTime(oe, gdi, r, t);
+        gdi.refresh();
+      }
+      else if (bi.id == "Simulate") {
+        if (gdi.ask(L"ask:simulatestart"))
+          simulation(gdi);
+      }
+      else if (bi.id == "GetStart") {
+        ListBoxInfo lbi;
+        int t = oe->getRelativeTime(gdi.getText("StartTime"));
+        if (t > 0 && gdi.getSelectedItem("Runners", lbi)) {
+          pRunner r = oe->getRunner(lbi.data, 0);
+          if (r) {
+            requestStartTime(oe, gdi, r, t);
+          }
+        }
+      }
+    }
+    else if (type == GuiEventType::GUI_CLEAR) {
+      save(gdi);
+    }
+  }
+
+  void handleCard(gdioutput& gdi, int cardNo) {
+    if (!gdi.hasData("RequestStart"))
+      return;
+
+    oe->synchronizeList(oListId::oLRunnerId);
+    pRunner r = oe->getRunnerByCardNo(cardNo, 0, oEvent::CardLookupProperty::ForReadout);
+
+    gdi.restore("RequestStart", false);
+    gdi.setRestorePoint("RequestStart");
+    gdi.dropLine(4);
+
+    if (!r) {
+      gdi.addString("", gdiFonts::fontLarge, "Bricka X#" + itos(cardNo)).setColor(GDICOLOR::colorRed);
+      gdi.addString("", gdiFonts::boldHuge, "Okänd bricka").setColor(GDICOLOR::colorRed);
+      gdi.refresh();
+    }
+    else {
+      handleRunner(gdi, r, cardNo);
+    }
+    gdi.scrollToBottom();
+    gdi.addTimeoutMilli(30*1000, "RequestedStart", SportIdentCB);
+  }
+
+  void handleRunner(gdioutput& gdi, pRunner r, int cardNo) {
+    bool fail = false;
+
+    if (!selectedClasses.count(r->getClassId(true)) || r->getClassRef(false) == nullptr) {
+      gdi.addStringUT(gdiFonts::fontLarge, r->getCompleteIdentification() + L" / " + r->getClass(true)).setColor(GDICOLOR::colorRed);
+      gdi.addString("", gdiFonts::boldHuge, "Klassen tillåter ej val av starttid").setColor(GDICOLOR::colorRed);
+      if (r->getStartTime() > 0)
+        gdi.addString("", gdiFonts::boldHuge, oe->getAbsTime(r->getStartTime()));
+      fail = true;
+    }
+    else if (r->getStartTime() > 0) {
+      gdi.addStringUT(gdiFonts::fontLarge, r->getCompleteIdentification()).setColor(GDICOLOR::colorRed);
+      gdi.addString("", gdiFonts::boldHuge, "Starttiden är redan tilldelad").setColor(GDICOLOR::colorRed);
+      gdi.addString("", gdiFonts::boldHuge, oe->getAbsTime(r->getStartTime()));
+
+      si->generateStartInfo(gdi, *r, false);
+      fail = true;
+    }
+    else if (r->getCard() || r->getFinishTime() > 0 || r->getStatus() == StatusNotCompetiting) {
+      gdi.addStringUT(gdiFonts::fontLarge, r->getCompleteIdentification()).setColor(GDICOLOR::colorRed);
+      gdi.addString("", gdiFonts::boldHuge, "Starttiden är  låst").setColor(GDICOLOR::colorRed);
+      fail = true;
+    }
+    else {
+      int now = oe->getRelativeTime(oe->getCurrentTimeS());
+
+      if (now >= lastStart) {
+        gdi.addString("", gdiFonts::boldHuge, "Tiden har passerat sista tillåtna starttid").setColor(GDICOLOR::colorRed);
+        fail = true;
+      }
+      else {
+        now -= (now % timeConstMinute) - timeConstMinute;
+
+        if (provideSuggestions) {
+          makeSuggestions(gdi, r, cardNo, max(firstStart, now + timeToSuggestion));
+        }
+        else {
+          requestStartTime(oe, gdi, r, max(firstStart, now + timeToSuggestion));
+        }
+      }
+    }
+
+    gdi.dropLine(4);
+    gdi.refresh();
+  }
+
+  bool requestStartTime(oEvent *oeLocal, gdioutput& gdi, pRunner r, int time) {
+    if (time == firstStart) {
+      int xx = max(2, interval / timeConstMinute);
+      time += timeConstMinute * GetRandomNumber(xx); // To avoid using just even minutes in the beginning
+    }
+    bool fail = false;
+    int iter = 0;
+    const int maxIter = 3;
+    while (++iter <= maxIter) {
+      int st = oeLocal->requestStartTime(r->getId(), time, interval, lastStart, maxParallel,
+        allowSameCourse, allowSameCourseNeighbour, allowSameFirstControl, allowClubNeighbour);
+
+      if (st <= 0) {
+        gdi.addStringUT(gdiFonts::fontLarge, r->getCompleteIdentification()).setColor(GDICOLOR::colorRed);
+        gdi.addString("", gdiFonts::boldHuge, "Ingen ledig starttid kunde hittas.").setColor(GDICOLOR::colorRed);
+        fail = true;
+      }
+      else {
+        pClass cls = r->getClassRef(true);
+        r->setStartTime(st, true, oBase::ChangeType::Update);
+        r->synchronize();
+
+        // There is no locking. Check that time is OK (at least in class)
+        oeLocal->synchronizeList(oListId::oLRunnerId);
+        vector<pRunner> rl;
+        oeLocal->getRunners(r->getClassId(true), 0, rl, false);
+        int nDup = 0;
+        for (pRunner rr : rl) {
+          if (!rr->isRemoved() && rr->getStatus() != StatusNotCompetiting && rr->getStartTime() > 0 && 
+               rr->getStartTime() > st - interval && rr->getStartTime() < st + interval) {
+            nDup++;
+          }
+        }
+        if (nDup > 1) {
+          r->setStartTime(0, true, oBase::ChangeType::Update);
+          r->synchronize();
+          int randomMS = 50 + 10 * GetRandomNumber(50);
+          Sleep(randomMS); // Wait some random time
+          continue; // Try again
+        }
+        wstring start, cname;
+        if (cls) {
+          cname = cls->getName();
+          start = cls->getStart();
+          if (!start.empty())
+            cname += L" (" + start + L")";
+        }
+        gdi.addStringUT(gdiFonts::fontLarge, r->getCompleteIdentification());
+        gdi.addStringUT(gdiFonts::fontLarge, cname);
+        gdi.addString("", gdiFonts::boldHuge, r->getStartTimeS()).setColor(GDICOLOR::colorGreen);
+
+        si->generateStartInfo(gdi, *r, false);
+        break;
+      }
+    }
+    if (iter > maxIter) {
+      gdi.addStringUT(gdiFonts::fontLarge, r->getCompleteIdentification()).setColor(GDICOLOR::colorRed);
+      gdi.addString("", gdiFonts::boldHuge, "Ingen ledig starttid kunde hittas.").setColor(GDICOLOR::colorRed);
+      fail = true;
+    }
+
+    return !fail;
+  }
+
+
+  void simulation(gdioutput& gdi) {
+    wstring tmp = getTempFile();
+    oe->save(tmp, false);
+    oEvent tmpOE(gdi);
+    tmpOE.open(tmp, true, false, true);
+
+    vector<pRunner> rList;
+    tmpOE.getRunners(selectedClasses, rList);
+    vector<pRunner> rListToUse;
+    for (pRunner r : rList) {
+      if (r->getStartTime() == 0 && r->getStatus() != StatusNotCompetiting)
+        rListToUse.push_back(r);
+    }
+
+    gdi.addString("", fontMediumPlus, "Simulerar starttidstilldelning för X deltagare#" + itos(rListToUse.size()));
+    
+    gdi.fillRight();
+    gdi.addString("", 0, "Första starttid:");
+    gdi.fillDown();
+    gdi.addStringUT(0, oe->getAbsTime(firstStart));
+    gdi.popX();
+
+    gdi.fillRight();
+    gdi.addString("", 0, "Sista starttid:");
+    gdi.fillDown();
+    gdi.addStringUT(0, oe->getAbsTime(lastStart));
+    gdi.popX();
+
+    gdi.fillRight();
+    gdi.addString("", 0, "Startintervall (minuter):");
+    gdi.fillDown();
+    gdi.addStringUT(0, formatTimeMS(interval, true));
+    gdi.popX();
+
+    if (allowSameCourse)
+      gdi.addString("", 0, "Tillåt klass med samma bana på samma starttid");
+    if (allowSameCourseNeighbour)
+      gdi.addString("", 0, "Tillåt klass med samma bana på stattid före/efter");
+    if (allowSameFirstControl)
+      gdi.addString("", 0, "Tillåt klass med samma första kontroll vid samma starttid");
+    if (allowClubNeighbour)
+      gdi.addString("", 0, "Tillåt deltagare med samma klubb och klass på närliggande starttid");
+
+    gdi.fillRight();
+    gdi.addString("", 0, L"Max parallellt startande:");
+    gdi.fillDown();
+    gdi.addStringUT(0, itow(maxParallel));
+    gdi.popX();
+
+    map<int, tuple<int, int, int>> classToMaxDelay;
+    
+    std::random_device rd;
+    std::mt19937 g(rd());
+    std::shuffle(rListToUse.begin(), rListToUse.end(), g);
+
+    vector<int> requestTimes(rListToUse.size());
+    int first = firstStart - timeToSuggestion;
+    int last = lastStart - timeToSuggestion;
+    for (int i = 0; i < requestTimes.size(); i++) {
+      int t = ((i+1) * (last-first)) / requestTimes.size() + first;
+      t = max(firstStart, (t / timeConstMinute) * timeConstMinute);
+      requestTimes[i] = t;
+    }
+    bool fail = false;
+    for (int i = 0; i < requestTimes.size(); i++) {
+      gdi.addString("", 0, L"X: Startid för Y kl Z#" + itow(i+1) + L"#" + rListToUse[i]->getClass(true) + L"#" + tmpOE.getAbsTime(requestTimes[i]));
+      if (!requestStartTime(&tmpOE, gdi, rListToUse[i], requestTimes[i])) {
+        gdi.addString("", 0, "FAILED");
+        fail = true;
+        break;
+      }
+      int st = rListToUse[i]->getStartTime();
+      int after = st - requestTimes[i];
+      auto& stat = classToMaxDelay[rListToUse[i]->getClassId(true)];
+      ++get<0>(stat);// Count
+      get<1>(stat) += after;
+      get<2>(stat) = max(get<2>(stat), after);
+
+      if (i % 10 == 9) {
+        gdi.scrollToBottom();
+        gdi.refreshFast();
+      }
+    }
+
+    if (!fail) {
+      gdi.addString("", 1, "Statistik genomsnitt (max) extra väntetid per klass");
+
+      gdi.dropLine(2);
+      for (auto &res : classToMaxDelay) {
+        //gdi.fillRight();
+        auto& stat = res.second;
+        gdi.addStringUT(0, tmpOE.getClass(res.first)->getName()+ L": " + formatTimeMS(get<1>(stat)/get<0>(stat), true, SubSecond::Off) +
+          L" (" + formatTimeMS(get<2>(stat), true, SubSecond::Off) + L")");
+
+        //gdi.fillDown();
+        //gdi.popX();
+      }
+
+      gdi.scrollToBottom();
+      gdi.refresh();
+
+      if (gdi.ask(L"Vill du spara en kopia av tävlingen med starttider för ytterligare analys?")) {
+        vector< pair<wstring, wstring> > ext;
+        ext.push_back(make_pair(L"MeOS-data", L"*.meosxml"));
+        int ix = 0;
+        wstring fileName = gdi.browseForSave(ext, L"meosxml", ix);
+        if (!fileName.empty()) {
+          tmpOE.setAnnotation(L"***ANALYSIS***");
+          tmpOE.save(fileName, false);
+        }
+      }
+    }
+
+    gdi.addButton("Cancel", "Återgå", SportIdentCB).setCancel();
+
+    gdi.scrollToBottom();
+    gdi.refresh();
+
+
+    /*for (pRunner r : rListToUse) {
+      r->setStartTime(0, true, oBase::ChangeType::Update, false);
+      r->synchronize();
+    }*/
+
+  }
+
+};
+
+void TabSI::showRequestStartTime(gdioutput& gdi) {
+  if (!oe->isKiosk())
+    checkBoxToolBar(gdi, {CheckBox::PrintStart });
+
+  if (!requestStartTimeHandler) {
+    requestStartTimeHandler = make_shared<RequestStart>(this);
+  }
+ 
+  shared_ptr<RequestStart> h = dynamic_pointer_cast<RequestStart, GuiHandler>(requestStartTimeHandler);
+
+  h->loadPage(gdi, h);
+}
+
+void TabSI::requestStartTime(gdioutput& gdi, const SICard& sic) {
+  shared_ptr<RequestStart> h = dynamic_pointer_cast<RequestStart, GuiHandler>(requestStartTimeHandler);
+  if (!h)
+    throw std::exception("Internal error");
+
+  h->handleCard(gdi, sic.CardNumber);
+}
diff --git a/code/TabSI.h b/code/TabSI.h
index f265cb2..1355b31 100644
--- a/code/TabSI.h
+++ b/code/TabSI.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -39,6 +39,7 @@ public:
     ModeEntry,
     ModeCardData,
     ModeRegisterCards,
+    ModeRequestStartTime,
   };
 
   map<SIMode, string> modeName;
@@ -94,6 +95,10 @@ private:
   shared_ptr<GuiHandler> resetHiredCardHandler;
   GuiHandler *getResetHiredCardHandler();
 
+  shared_ptr<GuiHandler> requestStartTimeHandler;
+
+  SortOrder sortAssignCards = SortOrder::Custom;
+
   int runnerMatchedId;
   bool printErrorShown;
   void printProtected(gdioutput &gdi, gdioutput &gdiprint);
@@ -110,6 +115,7 @@ private:
 
   void assignCard(gdioutput &gdi, const SICard &sic);
   void entryCard(gdioutput &gdi, const SICard &sic);
+  void requestStartTime(gdioutput& gdi, const SICard& sic);
 
   void updateEntryInfo(gdioutput &gdi);
   void generateEntryLine(gdioutput &gdi, pRunner r);
@@ -120,6 +126,7 @@ private:
   int numSavedCardsOnCmpOpen = 0;
   void showCheckCardStatus(gdioutput &gdi, const string &cmd);
   void showRegisterHiredCards(gdioutput &gdi);
+  void showRequestStartTime(gdioutput &gdi);
 
   wstring getCardInfo(bool param, vector<int> &count) const;
   // Formatting for card tick off
@@ -185,17 +192,32 @@ private:
 
   static int analyzePunch(SIPunch &p, int &start, int &accTime, int &days);
 
-
   void createCompetitionFromCards(gdioutput &gdi);
 
-  int NC;
+  int NC = 8;
+  int  testType = 0;
+  bool showTestingPanel = false;
+  wstring testStartTime;
+  bool useTestStart = true;
+  wstring testFinishTime;
+  bool useTestFinish = true;
+  wstring testCheckTime;
+  bool useTestCheck = false;
+  int testRadioNumber = 50;
+  wstring testPunchTime;
+  vector<int> testControls;
+  int testCardNumber = 0;
+
+  void readTestData(gdioutput& gdi);
+
 
   class EditCardData : public GuiHandler {
     TabSI *tabSI;
-    EditCardData(const EditCardData&);
-    EditCardData &operator=(const EditCardData&);
   public:
     EditCardData() : tabSI(0) {}
+    EditCardData(const EditCardData&) = delete;
+    EditCardData& operator=(const EditCardData&) = delete;
+
     void handle(gdioutput &gdi, BaseInfo &info, GuiEventType type);
     friend class TabSI;
   };
@@ -235,7 +257,8 @@ private:
     Manual,
     SeveralTurns,
     AutoTie, 
-    AutoTieRent
+    AutoTieRent,
+    ExtraDataFields
   };
 
   void checkBoxToolBar(gdioutput& gdi, const set<CheckBox> &items) const;
@@ -252,6 +275,7 @@ private:
     vector<int> MP;
     GDICOLOR color;
     bool rentCard = false;
+    int runnerId = 0;
 
     RECT computeRC(gdioutput &gdi) const;
     void render(gdioutput &gdi, const RECT &rc) const;
@@ -286,6 +310,15 @@ public:
     wstring storedFee;
     wstring storedPhone;
     wstring storedStartTime;
+
+    wstring dataA; 
+    wstring dataB;
+    wstring textA;
+    wstring nationality;
+    int sex = 2; 
+    wstring birthDate;
+    wstring rank;
+
     bool allStages;
     bool rentState;
     bool hasPaid;
@@ -305,11 +338,11 @@ public:
   static SportIdent &getSI(const gdioutput &gdi);
   void printerSetup(gdioutput &gdi);
 
-  void generateStartInfo(gdioutput &gdi, const oRunner &r);
+  void generateStartInfo(gdioutput &gdi, const oRunner &r, bool includeEconomy);
   bool hasPrintStartInfo() const {return printStartInfo;}
   void setPrintStartInfo(bool info) {printStartInfo = info;}
 
-  int siCB(gdioutput &gdi, int type, void *data);
+  int siCB(gdioutput &gdi, GuiEventType type, BaseInfo *data);
 
   void writeDefaultHiredCards();
 
@@ -327,6 +360,7 @@ public:
   void insertSICard(gdioutput &gdi, SICard &sic);
   void clearQueue() { CardQueue.clear(); }
   void refillComPorts(gdioutput &gdi);
+  bool anyActivePort() const;
 
   bool loadPage(gdioutput &gdi) final;
   void showReadoutMode(gdioutput & gdi);
diff --git a/code/TabSpeaker.cpp b/code/TabSpeaker.cpp
index b760127..1ddb249 100644
--- a/code/TabSpeaker.cpp
+++ b/code/TabSpeaker.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -67,8 +67,7 @@ TabSpeaker::~TabSpeaker()
 }
 
 
-int tabSpeakerCB(gdioutput *gdi, int type, void *data)
-{
+int tabSpeakerCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabSpeaker &ts = dynamic_cast<TabSpeaker &>(*gdi->getTabs().get(TSpeakerTab));
 
   switch(type){
@@ -165,7 +164,7 @@ int TabSpeaker::processButton(gdioutput &gdi, const ButtonInfo &bu)
     gdi.addButton("AllClass", "Alla", tabSpeakerCB);
     gdi.addButton("NoClass", "Inga", tabSpeakerCB);
 
-    oe->fillClasses(gdi, "Classes", oEvent::extraNone, oEvent::filterNone);
+    oe->fillClasses(gdi, "Classes", {}, oEvent::extraNone, oEvent::filterNone);
     gdi.setSelection("Classes", classesToWatch);
 
     gdi.fillRight();
@@ -177,7 +176,7 @@ int TabSpeaker::processButton(gdioutput &gdi, const ButtonInfo &bu)
 
     vector< pair<wstring, size_t> > d;
     oe->fillControls(d, oEvent::ControlType::CourseControl);
-    gdi.addItem("Controls", d);
+    gdi.setItems("Controls", d);
 
     gdi.setSelection("Controls", controlsToWatch);
 
@@ -241,11 +240,11 @@ int TabSpeaker::processButton(gdioutput &gdi, const ButtonInfo &bu)
     gdi.dropLine(3);
     gdi.popX();
     gdi.registerEvent("DataUpdate", tabSpeakerCB);
-    vector<pair<int, bool>> runnersToReport;
+    deque<pair<int, bool>> runnersToReport;
     if (runnerId > 0) {
       runnersToReport.emplace_back(runnerId, false);
     }
-    TabRunner::generateRunnerReport(*oe, gdi, runnersToReport);
+    TabRunner::generateRunnerReport(*oe, gdi, 1, 1, false, runnersToReport);
     gdi.refresh();
   }
   else if (bu.id == "Priority") {
@@ -257,7 +256,7 @@ int TabSpeaker::processButton(gdioutput &gdi, const ButtonInfo &bu)
     gdi.pushX();
     gdi.addString("", 0, "Klass:");
     gdi.addSelection("Class", 200, 200, tabSpeakerCB, L"", L"Välj klass");
-    oe->fillClasses(gdi, "Class", oEvent::extraNone, oEvent::filterNone);
+    oe->fillClasses(gdi, "Class", {}, oEvent::extraNone, oEvent::filterNone);
     gdi.addButton("ClosePri", "Stäng", tabSpeakerCB);
     gdi.dropLine(2);
     gdi.popX();
@@ -278,7 +277,7 @@ int TabSpeaker::processButton(gdioutput &gdi, const ButtonInfo &bu)
     gdi_new->pushX();
 
     TabList::makeClassSelection(*gdi_new);
-    oe->fillClasses(*gdi_new, "ListSelection", oEvent::extraNone, oEvent::filterNone);
+    oe->fillClasses(*gdi_new, "ListSelection", {}, oEvent::extraNone, oEvent::filterNone);
     
     gdi_new->popY();
     gdi_new->setCX(gdi_new->getCX() + gdi_new->scaleLength(280));
@@ -1223,7 +1222,7 @@ void TabSpeaker::storeManualTime(gdioutput &gdi)
     throw std::exception(bf);
   }
 
-  oe->addFreePunch(itime, punch, 0, sino, true);
+  oe->addFreePunch(itime, punch, 0, sino, true, false);
 
   gdi.restore("manual", false);
   gdi.addString("", 0, L"Löpare: X, kontroll: Y, kl Z#" + Name + L"#" + oPunch::getType(punch) + L"#" +  oe->getAbsTime(itime));
diff --git a/code/TabSpeaker.h b/code/TabSpeaker.h
index aeade65..e91dc3e 100644
--- a/code/TabSpeaker.h
+++ b/code/TabSpeaker.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/TabTeam.cpp b/code/TabTeam.cpp
index 6d7a7fe..3aeda27 100644
--- a/code/TabTeam.cpp
+++ b/code/TabTeam.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -46,26 +46,19 @@
 
 #include "TabSI.h"
 
-TabTeam::TabTeam(oEvent *poe):TabBase(poe)
-{
+TabTeam::TabTeam(oEvent *poe):TabBase(poe) {
   clearCompetitionData();
 }
 
-TabTeam::~TabTeam(void)
-{
-}
+TabTeam::~TabTeam(void) = default;
 
-int TeamCB(gdioutput *gdi, int type, void *data)
-{
+int TeamCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabTeam &tt = dynamic_cast<TabTeam &>(*gdi->getTabs().get(TTeamTab));
-
   return tt.teamCB(*gdi, type, data);
 }
 
-int teamSearchCB(gdioutput *gdi, int type, void *data)
-{
+int teamSearchCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabTeam &tc = dynamic_cast<TabTeam &>(*gdi->getTabs().get(TTeamTab));
-
   return tc.searchCB(*gdi, type, data);
 }
 
@@ -134,7 +127,7 @@ int TabTeam::searchCB(gdioutput &gdi, int type, void *data) {
       if (filter.empty()) {
         vector< pair<wstring, size_t> > runners;
         runners.push_back(make_pair(lang.tl(L"Ingen matchar 'X'#" + expr), -1));
-        gdi.addItem("Teams", runners);
+        gdi.setItems("Teams", runners);
       }
       else
         gdi.filterOnData("Teams", filter);
@@ -164,7 +157,7 @@ int TabTeam::searchCB(gdioutput &gdi, int type, void *data) {
         runners.swap(runners2);
       }
 
-      gdi.addItem("Teams", runners);
+      gdi.setItems("Teams", runners);
     }
 
     if (type == GUI_TIMER)
@@ -187,8 +180,9 @@ void TabTeam::selectTeam(gdioutput &gdi, pTeam t)
     gdi.enableInput("Save");
     gdi.enableInput("Undo");
     gdi.enableInput("Remove");
+    gdi.enableInput("EditAnnotation");
 
-    oe->fillClasses(gdi, "RClass", oEvent::extraNone, oEvent::filterOnlyMulti);
+    oe->fillClasses(gdi, "RClass", {}, oEvent::extraNone, oEvent::filterOnlyMulti);
     gdi.selectItemByData("RClass", t->getClassId(false));
     gdi.selectItemByData("Teams", t->getId());
 
@@ -209,6 +203,8 @@ void TabTeam::selectTeam(gdioutput &gdi, pTeam t)
       gdi.check("NoRestart", t->preventRestart());
     }
 
+    TabRunner::loadExtraFields(gdi, t);
+
     loadTeamMembers(gdi, 0, 0, t);
   }
   else {
@@ -218,6 +214,7 @@ void TabTeam::selectTeam(gdioutput &gdi, pTeam t)
     gdi.disableInput("Save");
     gdi.disableInput("Undo");
     gdi.disableInput("Remove");
+    gdi.disableInput("EditAnnotation");
 
     ListBoxInfo lbi;
     gdi.getSelectedItem("RClass", lbi);
@@ -342,6 +339,8 @@ bool TabTeam::save(gdioutput &gdi, bool dontReloadTeams) {
     if (gdi.hasWidget("NoRestart"))
       t->preventRestart(gdi.isChecked("NoRestart"));
     
+    TabRunner::saveExtraFields(gdi, *t);
+
     t->apply(oBase::ChangeType::Quiet, nullptr);
 
     if (gdi.hasWidget("Club")) {
@@ -404,6 +403,7 @@ bool TabTeam::save(gdioutput &gdi, bool dontReloadTeams) {
     }
     
     t->setClassId(classId, true);
+    t->adjustMultiRunners();
 
     if (gdi.hasWidget("TimeAdjust")) {
       int time = convertAbsoluteTimeMS(gdi.getText("TimeAdjust"));
@@ -552,14 +552,14 @@ wstring getForking(pClass pc, int key, int maxLen) {
   return crsList;
 }
 
-int TabTeam::teamCB(gdioutput &gdi, int type, void *data) {
+int TabTeam::teamCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   if (type==GUI_BUTTON) {
     ButtonInfo bi=*(ButtonInfo *)data;
-
+ 
     if (bi.id=="Save") {
       return save(gdi, false);
     }
-    if (bi.id == "Cancel") {
+    else if (bi.id == "Cancel") {
        loadPage(gdi);
        return 0;
     }
@@ -582,6 +582,15 @@ int TabTeam::teamCB(gdioutput &gdi, int type, void *data) {
       selectTeam(gdi, t);
       return 0;
     }
+    else if (bi.id == "EditAnnotation") {
+      if (!teamId)
+        return 0;
+      pTeam t = oe->getTeam(teamId);
+      if (t && getExtraWindow("comments", true) == nullptr) {
+        gdioutput* settings = createExtraWindow("comments", L"Kommentarer", gdi.scaleLength(550), gdi.scaleLength(350), true);
+        TabRunner::loadComments(*settings, *t);
+      }
+    }
     else if (bi.id=="Search") {
       ListBoxInfo lbi;
       gdi.getSelectedItem("Teams", lbi);
@@ -744,7 +753,7 @@ int TabTeam::teamCB(gdioutput &gdi, int type, void *data) {
         keys.push_back(make_pair(itow(f+1) + L": " + getForking(pc, f+1, 30), f));
       }
       int currentKey = max(t->getStartNo()-1, 0) % nf;
-      gdi.addItem("ForkKey", keys);
+      gdi.setItems("ForkKey", keys);
       gdi.autoGrow("ForkKey");
       gdi.selectItemByData("ForkKey", currentKey);
 
@@ -911,7 +920,7 @@ int TabTeam::teamCB(gdioutput &gdi, int type, void *data) {
         gdi.fillDown();
         gdi.addButton("Cancel", "Avbryt", TeamCB);
         
-        gdi.addItem("SelectR", otherR);
+        gdi.setItems("SelectR", otherR);
       }
       else { 
         gdi.addButton("Cancel", "Avbryt", TeamCB);
@@ -1265,7 +1274,7 @@ void TabTeam::loadTeamMembers(gdioutput &gdi, int ClassId, int ClubId, pTeam t)
   int yp = gdi.getCY();
   int numberPos = xp;
   xp += gdi.scaleLength(25);
-  const int dxIn[6] = {0, 184, 220, 300, 326, 374};
+  const int dxIn[6] = {0, 184, 220, 300, 326, 364};
   int dx[6];
   dx[0] = 0;
 
@@ -1292,7 +1301,7 @@ void TabTeam::loadTeamMembers(gdioutput &gdi, int ClassId, int ClubId, pTeam t)
     gdi.addStringUT(yp + textOffY, numberPos, 0, pc->getLegNumber(i) + L".");
     if (pc->getLegRunner(i) == i) {
       gdi.addInput(xp + dx[0], yp, bf, L"", 18, TeamCB);//Name
-      gdi.addButton(xp + dx[1], yp - 2, gdi.scaleLength(28), "DR" + itos(i), "<>", TeamCB, "Knyt löpare till sträckan.", false, false); // Change
+      gdi.addButton(xp + dx[1], yp - 2, gdi.scaleLength(28), "DR" + itos(i), L"\u21C6", TeamCB, L"Knyt löpare till sträckan.", false, false); // Change
       sprintf_s(bf_si, "SI%d", i);
       hasSI = true;
       gdi.addInput(xp + dx[2], yp, bf_si, L"", 7, TeamCB).setExtra(i); //Si
@@ -1302,7 +1311,7 @@ void TabTeam::loadTeamMembers(gdioutput &gdi, int ClassId, int ClubId, pTeam t)
       gdi.addInput(xp + dx[0], yp, bf, L"", 18, 0);//Name
       gdi.disableInput(bf);
     }
-    gdi.addButton(xp + dx[4], yp - 2, gdi.scaleLength(38), "MR" + itos(i), "...", TeamCB, "Redigera deltagaren.", false, false); // Change
+    gdi.addButton(xp + dx[4], yp - 2, gdi.scaleLength(28), "MR" + itos(i), L"\u21BA", TeamCB, L"Redigera deltagaren.", false, false); // Change
 
     gdi.addString(("STATUS" + itos(i)).c_str(), yp + textOffY, xp + dx[5], 0, "#MMMMMMMMMMMMMMMM");
     gdi.setText("STATUS" + itos(i), L"", false);
@@ -1335,39 +1344,30 @@ void TabTeam::loadTeamMembers(gdioutput &gdi, int ClassId, int ClubId, pTeam t)
       }
     }
   }
+  if (t)
+    forkingKey(gdi, t);
 
+  gdi.refresh();
+}
+
+void TabTeam::forkingKey(gdioutput& gdi, pTeam t) {
+  pClass pc = t->getClassRef(false);
+  int cx = gdi.getCX();
+  int cy = gdi.getCY();
+  TabRunner::renderComments(gdi, *t);
+  gdi.setCX(cx);
+  gdi.setCY(cy);
+
+  gdi.pushX();
   gdi.setRestorePoint("SelectR");
-  gdi.addString("", 1, "help:7618");
+  gdi.addString("", 0, "help:7618");
   gdi.dropLine();
   int numF = pc->getNumForks();
-  
-  if (numF>1 && t) {
-    gdi.addString ("", 1, "Gafflingsnyckel X#" + itos(1+(max(t->getStartNo()-1, 0) % numF))).setColor(colorGreen);
+
+  if (numF > 1 && t) {
+    gdi.addString("", 1, "Gafflingsnyckel X#" + itos(1 + (max(t->getStartNo() - 1, 0) % numF))).setColor(colorGreen);
     wstring crsList = getForking(pc, t->getStartNo(), 50);
-    /*bool hasCrs = false;
-    for (size_t k = 0; k < pc->getNumStages(); k++) {
-      pCourse crs = pc->getCourse(k, t->getStartNo());
-      wstring cS; 
-      if (crs != 0) {
-        cS = crs->getName();
-        hasCrs = true;
-      }
-      else
-        cS = makeDash(L"-");
     
-      if (!crsList.empty())
-        crsList += L", ";
-      crsList += cS;
-
-      if (hasCrs && crsList.length() > 50) {
-        gdi.addStringUT(0, crsList);
-        crsList.clear();
-      }
-    }
-    if (hasCrs && !crsList.empty()) {
-      gdi.addStringUT(0, crsList);
-    }*/
-
     if (!crsList.empty()) {
       gdi.addStringUT(0, crsList);
       gdi.dropLine(0.5);
@@ -1375,7 +1375,6 @@ void TabTeam::loadTeamMembers(gdioutput &gdi, int ClassId, int ClubId, pTeam t)
       gdi.addButton("ChangeKey", "Ändra lagets gaffling", TeamCB);
     }
   }
-  gdi.refresh();
 }
 
 void TabTeam::enableRunner(gdioutput& gdi, int index, bool enable) {
@@ -1456,8 +1455,7 @@ bool TabTeam::loadPage(gdioutput &gdi)
   }
 
   gdi.addSelection("RClass", 170, 300, TeamCB, L"Klass:");
-  oe->fillClasses(gdi, "RClass", oEvent::extraNone, oEvent::filterOnlyMulti);
-  gdi.addItem("RClass", lang.tl("Ny klass"), 0);
+  oe->fillClasses(gdi, "RClass", {make_pair(lang.tl("Ny klass"), 0)}, oEvent::extraNone, oEvent::filterOnlyMulti);
 
   if (oe->getMeOSFeatures().hasFeature(MeOSFeatures::Economy))
     gdi.addInput("Fee", L"", 5, 0, L"Avgift:");
@@ -1517,11 +1515,11 @@ bool TabTeam::loadPage(gdioutput &gdi)
   }
 
   gdi.addString("TeamInfo", 0, " ").setColor(colorRed);
-  gdi.dropLine(1.5);
 
   const bool multiDay = oe->hasPrevStage();
 
   if (multiDay) {
+    gdi.dropLine(1.5);
     int xx = gdi.getCX();
     int yy = gdi.getCY();
     gdi.dropLine(0.5);
@@ -1552,10 +1550,14 @@ bool TabTeam::loadPage(gdioutput &gdi)
     rc.bottom = gdi.getCY();
 
     gdi.addRectangle(rc, colorLightGreen, true, false);
-    gdi.dropLine(1.5);
     gdi.popX();
   }
   
+  TabRunner::addExtraFields(*oe, gdi, oEvent::ExtraFieldContext::Team);
+  
+  gdi.dropLine(0.5);
+  gdi.popX();
+
   gdi.fillRight();
   gdi.addButton("Save", "Spara", TeamCB, "help:save");
   gdi.disableInput("Save");
@@ -1568,6 +1570,10 @@ bool TabTeam::loadPage(gdioutput &gdi)
   gdi.disableInput("Remove");
   gdi.addButton("Add", "Nytt lag", TeamCB);
 
+  gdi.popX();
+  gdi.dropLine(2.2);
+  gdi.addButton("EditAnnotation", L"Kommentar >>", TeamCB, L"Lägg till eller redigera kommentarer om laget.");
+
   gdi.setOnClearCb(TeamCB);
 
   addToolbar(gdi);
@@ -1880,7 +1886,13 @@ void TabTeam::showRunners(gdioutput &gdi, const char *title,
     usedR.insert(it->second);
     
     if (!any) {
-      gdi.addString("", boldText, title);
+      gdi.dropLine(0.2);
+      int YC = gdi.getCY() + gdi.getLineHeight() / 2;
+      int CX = gdi.getCX();
+      int hy = gdi.scaleLength(2);
+      RECT rc = { CX, YC-hy, CX + gdi.getLineHeight(), YC + hy };
+      gdi.addRectangle(rc, GDICOLOR::colorMediumDarkRed, false);
+      gdi.addString("", boldText|Capitalize, title);
       gdi.dropLine(1.2);
       gdi.popX();
       any = true;
@@ -1891,7 +1903,7 @@ void TabTeam::showRunners(gdioutput &gdi, const char *title,
       gdi.popX();
     }
 
-    gdi.addString("SelectR", 0, L"#" + it->first, TeamCB).setExtra(it->second);
+    gdi.addString("SelectR", 0, L"#" + it->first, TeamCB).setColor(colorRed).setExtra(it->second);
   }
 
   if (any) {
@@ -1906,6 +1918,7 @@ void TabTeam::processChangeRunner(gdioutput &gdi, pTeam t, int leg, pRunner r) {
     gdioutput::AskAnswer ans = gdioutput::AskAnswer::AnswerNo;
     if (r == oldR) {
       gdi.restore("SelectR");
+      forkingKey(gdi, t);
       return;
     }
     else if (oldR) {
@@ -1975,6 +1988,7 @@ void TabTeam::switchRunners(pTeam t, int leg, pRunner r, pRunner oldR) {
     }
     otherTeam->checkValdParSetup();
     otherTeam->apply(oBase::ChangeType::Update, nullptr);
+    otherTeam->adjustMultiRunners();
     otherTeam->synchronize(true);
   }
   else if (oldR) {
@@ -1995,6 +2009,7 @@ void TabTeam::switchRunners(pTeam t, int leg, pRunner r, pRunner oldR) {
   r->evaluateCard(true, mp, 0, oBase::ChangeType::Update);
   t->checkValdParSetup();
   t->apply(oBase::ChangeType::Update, nullptr);
+  t->adjustMultiRunners();
   t->synchronize(true);
 
   if (removeAnnonumousTeamMember)
@@ -2042,7 +2057,7 @@ bool TabTeam::warnDuplicateCard(gdioutput &gdi, string id, int cno, pRunner r) {
 }
 
 void TabTeam::handleAutoComplete(gdioutput &gdi, AutoCompleteInfo &info) {
-  auto bi = gdi.setText(info.getTarget(), info.getCurrent().c_str());
+  auto bi = gdi.setText(info.getTarget().c_str(), info.getCurrent(), false, -1, false);
   if (bi) {
     int ix = info.getCurrentInt();
     bi->setExtra(ix);
@@ -2053,10 +2068,10 @@ void TabTeam::handleAutoComplete(gdioutput &gdi, AutoCompleteInfo &info) {
       if (runner && gdi.hasWidget("Club") && gdi.getText("Club").empty()) {
         pClub club = db.getClub(runner->dbe().clubNo);
         if (club)
-          gdi.setText("Club", club->getName());
+          gdi.setText("Club", club->getName(), false, -1, false);
       }
       if (runner && runner->dbe().cardNo > 0 && gdi.hasWidget("DirCard") && gdi.getText("DirCard").empty()) {
-        gdi.setText("DirCard", runner->dbe().cardNo);
+        gdi.setText("DirCard", itow(runner->dbe().cardNo), false, -1, false);
       }
     }
   }
diff --git a/code/TabTeam.h b/code/TabTeam.h
index 51d9f26..441805f 100644
--- a/code/TabTeam.h
+++ b/code/TabTeam.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -77,6 +77,8 @@ private:
   /** Enable or disable edit for a team runner*/
   void enableRunner(gdioutput &gdi, int index, bool enable);
 
+  /// Show forking key in the window
+  void forkingKey(gdioutput& gdi, pTeam t);
 
 protected:
   void clearCompetitionData();
@@ -87,12 +89,12 @@ public:
   const char * getTypeStr() const {return "TTeamTab";}
   TabType getType() const {return TTeamTab;}
 
-  int teamCB(gdioutput &gdi, int type, void *data);
+  int teamCB(gdioutput &gdi, GuiEventType type, BaseInfo* data);
 
   bool loadPage(gdioutput &gdi, int id);
   bool loadPage(gdioutput &gdi);
   TabTeam(oEvent *oe);
   ~TabTeam(void);
-  friend int teamSearchCB(gdioutput *gdi, int type, void *data);
+  friend int teamSearchCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 
 };
diff --git a/code/Table.cpp b/code/Table.cpp
index 90628f7..5744083 100644
--- a/code/Table.cpp
+++ b/code/Table.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -274,7 +274,7 @@ void Table::filter(int col, const wstring &filt, bool forceFilter)
 
   wchar_t filt_lc[1024];
   wcscpy_s(filt_lc, filt.c_str());
-  CharLowerBuff(filt_lc, filt.length());
+  prepareMatchString(filt_lc, filt.length());
 
   sortIndex.resize(2);
   for (size_t k=2;k<baseIndex.size();k++) {
@@ -707,7 +707,7 @@ bool Table::mouseLeftUp(gdioutput &gdi, int x, int y)
   return false;
 }
 
-int tblSelectionCB(gdioutput *gdi, int type, void *data) {
+int tblSelectionCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   if (type == GUI_LISTBOX) {
     ListBoxInfo lbi = *static_cast<ListBoxInfo *>(data);
     Table &t = gdi->getTable();
@@ -1104,7 +1104,7 @@ bool Table::editCell(gdioutput &gdi, int row, int col) {
               max<int>(int((rc.right-rc.left+1)/gdi.scale), width), (rc.bottom-rc.top)*10,
               tblSelectionCB).setExtra(id);
     }
-    gdi.addItem(tId, out);
+    gdi.setItems(tId, out);
     gdi.selectItemByData(tId, selected);
     return true;
   }
diff --git a/code/Table.h b/code/Table.h
index eb7a1d7..488a8a5 100644
--- a/code/Table.h
+++ b/code/Table.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -26,6 +26,7 @@
 #include <set>
 #include "oBase.h"
 #include "inthashmap.h"
+#include "guihandler.h"
 
 #define TableXMargin 40
 #define TableYMargin 30
@@ -62,7 +63,7 @@ class TableCell
 
   friend class TableRow;
   friend class Table;
-  friend int tblSelectionCB(gdioutput *gdi, int type, void *data);
+  friend int tblSelectionCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 
 public:
   void update(CellType t, const wstring &str) {
diff --git a/code/TimeStamp.cpp b/code/TimeStamp.cpp
index 7f0d480..34cbcfb 100644
--- a/code/TimeStamp.cpp
+++ b/code/TimeStamp.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/TimeStamp.h b/code/TimeStamp.h
index ec3b2e9..cc71e3f 100644
--- a/code/TimeStamp.h
+++ b/code/TimeStamp.h
@@ -10,7 +10,7 @@
 #endif // _MSC_VER > 1000
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/animationdata.cpp b/code/animationdata.cpp
index 37ab197..4c70523 100644
--- a/code/animationdata.cpp
+++ b/code/animationdata.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
 MeOS - Orienteering Software
-Copyright (C) 2009-2023 Melin Software HB
+Copyright (C) 2009-2024 Melin Software HB
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
diff --git a/code/animationdata.h b/code/animationdata.h
index eab4b8a..83314fe 100644
--- a/code/animationdata.h
+++ b/code/animationdata.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
 MeOS - Orienteering Software
-Copyright (C) 2009-2023 Melin Software HB
+Copyright (C) 2009-2024 Melin Software HB
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -39,14 +39,14 @@ class AnimationData : public GuiHandler {
   DWORD nextTime;
   DWORD timeOut;
   bool doAnimation;
-  atomic_bool errorState;
+  std::atomic_bool errorState;
   gdioutput *gdiRef;
 
   void renderSubPage(HDC hDC, gdioutput &gdi, RenderedPage &page, int x, int y, int animationDelay);
 
   void doRender(HDC hDC, gdioutput &gdi, size_t sp, int delay);
 
-  shared_ptr<thread> animationThread;
+  shared_ptr<std::thread> animationThread;
   shared_ptr<AnimationData> delayedTakeOver;
   void takeOverInternal(const shared_ptr<AnimationData> &other);
 
diff --git a/code/announcer24.png b/code/announcer24.png
new file mode 100644
index 0000000..024b4bd
Binary files /dev/null and b/code/announcer24.png differ
diff --git a/code/autocomplete.cpp b/code/autocomplete.cpp
index 04b3113..c9980fd 100644
--- a/code/autocomplete.cpp
+++ b/code/autocomplete.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
 MeOS - Orienteering Software
-Copyright (C) 2009-2023 Melin Software HB
+Copyright (C) 2009-2024 Melin Software HB
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
diff --git a/code/autocomplete.h b/code/autocomplete.h
index 103a160..3fdc234 100644
--- a/code/autocomplete.h
+++ b/code/autocomplete.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/autocompletehandler.h b/code/autocompletehandler.h
index a34a3b0..61a1519 100644
--- a/code/autocompletehandler.h
+++ b/code/autocompletehandler.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/autotask.cpp b/code/autotask.cpp
index ed8f0e6..1fe6c09 100644
--- a/code/autotask.cpp
+++ b/code/autotask.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/autotask.h b/code/autotask.h
index 0943c1c..87f78ea 100644
--- a/code/autotask.h
+++ b/code/autotask.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/binencoder.cpp b/code/binencoder.cpp
index 0ebd2ab..2c0217b 100644
--- a/code/binencoder.cpp
+++ b/code/binencoder.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -26,6 +26,8 @@
 #include <cassert>
 #include "binencoder.h"
 
+using namespace std;
+
 Encoder92::Encoder92() {
   int d = 32;
   fill(reverse_table, reverse_table + 128, 0);
diff --git a/code/binencoder.h b/code/binencoder.h
index 2acd2f2..350e83c 100644
--- a/code/binencoder.h
+++ b/code/binencoder.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/class24.png b/code/class24.png
new file mode 100644
index 0000000..45bae07
Binary files /dev/null and b/code/class24.png differ
diff --git a/code/classconfiginfo.cpp b/code/classconfiginfo.cpp
index 1122965..175b9f4 100644
--- a/code/classconfiginfo.cpp
+++ b/code/classconfiginfo.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/classconfiginfo.h b/code/classconfiginfo.h
index 5dac208..f49a264 100644
--- a/code/classconfiginfo.h
+++ b/code/classconfiginfo.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/clubs24.png b/code/clubs24.png
new file mode 100644
index 0000000..c0ba608
Binary files /dev/null and b/code/clubs24.png differ
diff --git a/code/competition24.png b/code/competition24.png
new file mode 100644
index 0000000..00e410b
Binary files /dev/null and b/code/competition24.png differ
diff --git a/code/course24.png b/code/course24.png
new file mode 100644
index 0000000..1de0540
Binary files /dev/null and b/code/course24.png differ
diff --git a/code/csvparser.cpp b/code/csvparser.cpp
index c6e6705..d431d92 100644
--- a/code/csvparser.cpp
+++ b/code/csvparser.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -35,13 +35,7 @@
 
 #include "meosexception.h"
 
-#ifdef _DEBUG
-#undef THIS_FILE
-static char THIS_FILE[]=__FILE__;
-#define new DEBUG_NEW
-#endif
-
-#include <vector>
+using namespace std;
 
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
@@ -216,7 +210,7 @@ bool csvparser::importOS_CSV(oEvent &oe, const wstring &file) {
           DI.setString("Nationality", sp[OSnat]);
 
           if (sp[rindex + OSRrentcard].length() > 0)
-            DI.setInt("CardFee", oe.getDCI().getInt("CardFee"));
+            r->setRentalCard(true);
 
           //r->setCardNo(atoi(sp[rindex+OSRcard]), false);
           r->setStartTime(oe.convertAbsoluteTime(sp[rindex + OSRstart]), true, oBase::ChangeType::Update);
@@ -383,7 +377,7 @@ bool csvparser::importOE_CSV(oEvent &event, const wstring &file) {
       oDataInterface DI=pr->getDI();
 
       pr->setSex(interpretSex(sp[OEsex]));
-      DI.setInt("BirthYear", extendYear(wtoi(sp[OEbirth])));
+      pr->setBirthDate(sp[OEbirth]);
       DI.setString("Nationality", sp[OEnat]);
 
       if (sp.size()>OEbib && needBib)
@@ -391,7 +385,9 @@ bool csvparser::importOE_CSV(oEvent &event, const wstring &file) {
 
       if (sp.size()>=38) {//ECO
         DI.setInt("Fee", wtoi(sp[OEfee]));
-        DI.setInt("CardFee", wtoi(sp[OErent]));
+        if (wtoi(sp[OErent]))
+          pr->setRentalCard(true);
+
         DI.setInt("Paid", wtoi(sp[OEpaid]));
       }
 
diff --git a/code/csvparser.h b/code/csvparser.h
index a526ae4..23cfcbf 100644
--- a/code/csvparser.h
+++ b/code/csvparser.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -61,8 +61,8 @@ struct TeamLineup {
 class csvparser
 {
 protected:
-  ofstream fout;
-  ifstream fin;
+  std::ofstream fout;
+  std::ifstream fin;
 
   int LineNumber;
   string ErrorMessage;
diff --git a/code/ctrl24.png b/code/ctrl24.png
new file mode 100644
index 0000000..6fb9347
Binary files /dev/null and b/code/ctrl24.png differ
diff --git a/code/download.cpp b/code/download.cpp
index bbdec86..6271245 100644
--- a/code/download.cpp
+++ b/code/download.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -205,10 +205,10 @@ void Download::downloadFile(const wstring &url, const wstring &file, const vecto
     }
   }
 
-  fileno=_wopen(file.c_str(), O_BINARY|O_CREAT|O_WRONLY|O_TRUNC, S_IREAD|S_IWRITE);
-
-  if (fileno==-1) {
-    fileno=0;
+  //fileno=_wopen(file.c_str(), O_BINARY|O_CREAT|O_WRONLY|O_TRUNC, S_IREAD|S_IWRITE);
+  errno_t err = _wsopen_s(&fileno, file.c_str(), _O_BINARY | _O_CREAT | _O_WRONLY | _O_TRUNC, _SH_DENYWR ,_S_IREAD | _S_IWRITE);
+  if (err != 0) {
+    fileno = 0;
     endDownload();
     wchar_t bf[256];
     swprintf_s(bf, L"Error opening '%s' for writing", file.c_str());
@@ -463,7 +463,13 @@ bool Download::httpSendReqEx(HINTERNET hConnect, bool https, const wstring &dest
     }
   }
 
-  int rfileno = _wopen(outFile.c_str(), O_BINARY|O_CREAT|O_WRONLY|O_TRUNC, S_IREAD|S_IWRITE);
+//  int rfileno = _wopen(outFile.c_str(), O_BINARY|O_CREAT|O_WRONLY|O_TRUNC, S_IREAD|S_IWRITE);
+  int rfileno;
+  errno_t err = _wsopen_s(&rfileno, outFile.c_str(), _O_BINARY | _O_CREAT | _O_WRONLY | _O_TRUNC, _SH_DENYWR, _S_IREAD | _S_IWRITE);
+  if (err != 0) {
+    InternetCloseHandle(hRequest);
+    throw meosException(L"Failed to open + " + outFile);
+  }
 
   do {
     dwBytesRead=0;
diff --git a/code/download.h b/code/download.h
index 216079a..93efcd1 100644
--- a/code/download.h
+++ b/code/download.h
@@ -7,7 +7,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/edit.png b/code/edit.png
new file mode 100644
index 0000000..5a19820
Binary files /dev/null and b/code/edit.png differ
diff --git a/code/english.lng b/code/english.lng
index 274ae06..bd70f6e 100644
--- a/code/english.lng
+++ b/code/english.lng
@@ -130,7 +130,7 @@ Automater = Services
 Automatic rogaining point reduction = Automatic rogaining point reduction
 Automatisera = Automatize
 Automatisk = Automatic
-Automatisk hyrbrickshantering genom registrerade hyrbrickor = Automatic handling of hired cards using pre-registered card numbers
+Automatisk hyrbrickshantering genom registrerade hyrbrickor = Automatic handling of rental cards using pre-registered card numbers
 Automatisk lottning = Draw Automatically
 Automatisk omladdning = Automatic update
 Automatisk skroll = Automatic Scroll
@@ -161,7 +161,7 @@ Avmarkera 'X' för att hantera alla bricktildelningar samtidigt = Uncheck 'X' to
 Avmarkera allt = Deselect all
 Avrundad tävlingsavgift = Competition fee, rounded
 Avsluta = Exit
-Avstämning hyrbrickor = Count returned hired cards
+Avstämning hyrbrickor = Count returned rental cards
 Avstånd = Distance
 Bad file format = Bad file format
 Bakgrund = Background
@@ -256,7 +256,7 @@ Checkenhet = Check unit
 Choose result module = Choose result module
 ClassAvailableMaps = Available maps for class
 ClassCourseResult = Class, course, result
-ClassDefaultResult = Class, Default result
+ClassDefaultResult = Class, default result
 ClassFinishTime = Class, finish time
 ClassKnockoutTotalResult = Class, knock-out total result
 ClassLength = Course length for class
@@ -681,8 +681,8 @@ Hoppar över stafettklass: X = Skipping relay class: X
 Huvudlista = Main list
 Hyravgift = Card hire
 Hyrbricka = Hired card
-Hyrbricksrapport = Report with Hired Cards
-Hyrbricksrapport - %s = Hired Cards - %s
+Hyrbricksrapport = Report with Rental Cards
+Hyrbricksrapport - %s = Rental Cards - %s
 Hyrd = Hired
 Hämta (efter)anmälningar från Eventor = Fetch (late) entries from Eventor
 Hämta data från Eventor = Fetch Data from Eventor
@@ -795,7 +795,7 @@ Inget filter = No filter
 Inget nummer = No number
 Inkludera bana = Include course
 Inkludera bomanalys = Include analysis of lost time
-Inkludera individuellt resultat = Include indiviual result
+Inkludera individuellt resultat = Include individual result
 Inkludera information om flera lopp per löpare = Include information about multiple races for a single runner.
 Inkludera resultat från tidigare etapper = Include results from all stages
 Inkludera sträcktider = Include splits
@@ -856,7 +856,7 @@ Klassen X är individuell = The class X is individual
 Klassen X är listad flera gånger = The class X is listed several times
 Klassen använder banpool = The class has a course pool
 Klassen används och kan inte tas bort = The class is in use and cannot be removed
-Klassen lottas inte, startstämpling = Use only start punch
+Klassen lottas inte, startstämpling = Start list not drawn, use start punch
 Klassen måste ha ett namn = The class must have a name
 Klassen saknas = Missing class
 Klassen är full = The class is full
@@ -1941,12 +1941,12 @@ Tillagda: X = Added: X
 Tilldela = Assign
 Tilldela avgifter = Assign Fees
 Tilldela endast avgift till deltagare utan avgift = Assign fee only to competitors without fee
-Tilldela hyrbrickor = Assign cards
+Tilldela hyrbrickor = Assign rental cards
 Tilldela nummerlappar = Assign bibs
 Tilldela nya fakturanummer till alla klubbar? = Assign new invoice numbers to all clubs?
 Tilldela starttider = Assign start times
 Tilldelad = Assigned
-Tilldelning av hyrbrickor = Assign Cards
+Tilldelning av hyrbrickor = Assign Rental Cards
 Tillgängliga automater = Available services
 Tillgängliga filer installerades. Starta om MeOS. = Settings was installed. Please restart MeOS.
 Tillgängliga listor = Available lists
@@ -2122,7 +2122,7 @@ Vi stöder MeOS = We Support MeOS
 Viktiga händelser = Important events
 Vill du använda den nya brickan till alla etapper? = Do you want to use the new card for all stages?
 Vill du att X går in i laget? = Do you want to put X in the team?
-Vill du att X och Y byter sträcka? = Do you want X and Y to switch leg?
+Vill du att X och Y byter sträcka? = Do you want X and Y to swap legs?
 Vill du att X tar sträckan istället för Y? = Do you want X to run the leg instead of Y?
 Vill du dumpa aktuellt tävling och skapa en testtävling? = Do you want to dump the current competition and create a test competition?
 Vill du flytta löpare från X till Y och ta bort Z? = Do you want to move runners from X to Y and remove Z?
@@ -2230,7 +2230,7 @@ X (Saknar e-post) = X (Has no e-mail)
 X (Y deltagare, grupp Z, W) = X (Y competitors, group Z, W)
 X (press Ctrl+Space to confirm) = X (press <Ctrl>+<Space> to confirm)
 X anmälda = X entries
-X går vidare, klass enligt ranking = X qualified, class by ranking
+X går vidare, klass enligt ranking = X qualifies, class by ranking
 X har en tid (Y) som inte är kompatibel med förändringen = X has a time (Y) that is incompatible with this change
 X har redan bricknummer Y. Vill du ändra det? = X already has card number Y. Do you want to change it?
 X har redan ett resultat. Vi du fortsätta? = X already has a result. Do you wish to continue?
@@ -2294,7 +2294,6 @@ edit_in_forest = Manage\nRemaining Runners
 ej aktiv = not active
 elfte = eleventh
 elva = eleventh
-encoding = ANSI
 error:invalidmethod = The selected method gave no distribution. Source data is insufficient.
 ett Mycket Enkelt OrienteringsSystem = a Much Easier Orienteering System
 eventor:help = If you use MeOS for orienteering in Sweden, we recommend that you use MeOS's Eventor connection.
@@ -2375,8 +2374,8 @@ help:restore_backup = Choose a backup to restore by clicking the time when the b
 help:runnerdatabase = By importing a runner and club database, MeOS will automatically recognize unknown runners (by card number), and you will get addresses and phone numbers to clubs. 
 help:save = MeOS automatically saves all settings when needed.
 help:seeding_info = Seeded start time allocation means that an earlier result or ranking controls the process in part. In the field seeding groups you may either enter a single group size, meaning that the entire class is partitioned into groups of this size. The group size "1" means that the seeding order is strictly used. You can also specify several group sizes. "15, 1000" would mean a seeded group with the 15 highest ranked runners and the remaining (at most 1000) runners are placed in a non-seeded group.
-help:selectsound = Select sounds to play. By default MeOS built-in sounds are played.
-help:simulate = This service lets you simulate readout of SI cards. Times and punches are generated for all runners. Also radio contol punches can be simulated.\n\nWARNING: Use for testing only. If you use this on a real event, it will be corrupted.
+help:selectsound = Select sounds to play. By default, MeOS built-in sounds are played.
+help:simulate = This service lets you simulate readout of SI cards. Times and punches are generated for all runners. Also radio control punches can be simulated.\n\nWARNING: Use for testing only. If you use this on a real event, it will be corrupted.
 help:speaker_setup = Choose which classes and courses you want to watch.
 help:speakerprio = Check those runners/teams you wish to watch from start, and as long as the runner/team is doing well. Put two checks to watch even if the result is not so good. No check means monitoring only if the runner/team is doing well (not from start).
 help:splitexport = Decide if you want to export total results, or individual results for each race. If you choose to export all races, numbered files will be created.
@@ -2476,7 +2475,7 @@ prefsOrganizer = Organizer
 prefsPayModes = Modes of payment
 prefsPlaySound = Play sounds
 prefsPort = MySQL network port
-prefsRentCard = Rent card
+prefsRentCard = Rent cards by default
 prefsSeniorAge = Upper (pensioner) age limit
 prefsServer = Default network server
 prefsServicePort = Default service port
@@ -2672,5 +2671,131 @@ Välj bild = Select image
 Välj bland befintliga bilder = Select existing image
 Bevara höjd/bredd-relationen = Preserve aspect ratio
 RunnerLegTeamLeaderName = First competitor in team to finish leg
-info:offsetclassid = If you import entries and classes from different sources to the same competition, it might happen that there are clashes in the Id numbers of the classes. To separate the classes, you may enter an offset for the Class Id when working with files from a particular source; this will be added to the Id numbers.\n\nYou must specify the same offset each time you import from that source.\n\n A suitble number could be1000 (which will work as long as every Id is less that 1000).
+info:offsetclassid = If you import entries and classes from different sources to the same competition, it might happen that there are clashes in the Id numbers of the classes. To separate the classes, you may enter an offset for the Class Id when working with files from a particular source; this will be added to the Id numbers.\n\nYou must specify the same offset each time you import from that source.\n\n A suitable number could be 1000 (which will work as long as every Id is less that 1000).
 Förskjutning av klassers Id = Offset Class ID
+Tilldela nummerlapp till vakanter = Assign bibs to vacancies
+Avläsning = Readout
+Inmatning Testning = Input Testing
+Testning = Testing
+CourseNumControls = Number of controls
+PunchControlPlaceTeamAcc = Total team place at control
+PunchTeamTime = Team total time and split at control
+PunchTeamTotalNamedTime = Total team named split time
+PunchTeamTotalTime = Total team running time to control
+PunchTeamTotalTimeAfter = Team's time after at control
+Aktivera kioskläge = Activate kiosk mode
+Avstånd mellan förslag (minuter) = Distance between suggestions (minutes)
+Boka starttid = Request start time
+Ingen ledig starttid kunde hittas = No free start time was found
+Minsta tid till start (minuter) = Least time to start (minutes)
+Sista starttid = Last start time
+Startintervall (minuter) = Start interval (minutes)
+Tillåt klass med samma bana på samma starttid = Allow class with same course on same start time
+Tillåt klass med samma bana på stattid före/efter = Allow class with same course before and after
+Tillåt klass med samma första kontroll vid samma starttid = Allow class with same first control at the same time
+Tiden har passerat sista tillåtna starttid = Time has passed last allowed start time
+Starttiden är  låst = The start time is locked
+Starttiden är redan tilldelad = The start time is already assigned
+Klassen tillåter ej val av starttid = The class does not allow request of start time
+Klassen lottas inte, boka starttid = Start list not drawn, request start time on the page SportIdent
+Simulerar starttidstilldelning för X deltagare = Simulating start time assignments for X competitors
+Simulering = Simulation
+Välj från flera förslag = Choose start time
+Välj starttid för X = Choose start time for X
+X: Startid för Y kl Z = X: Start time for Y at Z
+Önskad starttid = Desired start time
+ask:startkiosk = If you start a start time reservation kiosk, MeOS enters a state where no other operations are supported or settings can be changed. You need a connected and activated SI unit.\n\nYou should consider password protecting the database if you are exposing a kiosk.\n\nDo you want to start the kiosk mode?
+ask:simulatestart = Carry out a simulation with the settings you have made (classes, starting depth, distance, rules) and with the registered participants who are in the classes. The competition is not affected. The result shows whether it is reasonable that everyone has time to start within the set start depth and how long extra waiting time to start may be required in different classes.\n\nAfterwards, you can also save a copy of the competition with simulated start times to study e.g. minute start list.\n\nDo you want to run the simulation?
+help:requeststart = Requesting start time is something in between free and drawn start time. By requesting a start time, MeOS ensures that there is a certain distance between participants in the same class or on the same course. If you have a requested start time, it is not necessary to use a start punch.\n\nSet parameters for start depth and how many/who are allowed to start at the same time. How far it is from the place where the booking is made to the start determines what is an appropriate minimum time to start value.\n\nYou can let the participants automatically get the first possible available start time after the minimum time to start, or let them choose from a number possible start times. It is possible and appropriate to print out a start certificate to take with you to the start.\n\nIf you are using a live results service, the start time will probably be displayed there when booked.
+Anslut en SI-enhet och aktivera den = Connect and activate a SI unit
+Manuellt startönskemål = Manual start request
+Stämpla för välja starttid = Punch to choose a start time
+Tillåt deltagare med samma klubb och klass på närliggande starttid = Allow competitors from the same club and class on next start time
+prevsExpResFilename = Export results
+prefsExpStaFilename = Export start list
+prefsRequestClubNeighbour = Request start: Allow same club neighbour
+prefsRequestLastStart = Request start: Last start
+prefsRequestMaxParallel = Request start: Max parallel starts
+prefsRequestMinTime = Request start: Time to start
+prefsRequestProvideSuggestion = Request start: Make suggestions
+prefsRequestSameCourse = Request start: Same course
+prefsRequestSameCourseNeighbour = Request start: Same course for neighbour
+prefsRequestSameFirstControl = Request start: Samma first control
+prefsRequestStartInterval = Request start: Interval
+prefsRequestSuggestInterval = Request start: Time between suggestions
+Omstart: X = Restart: X
+Reptid: X = Rope time: X
+Datortid = Computer time
+Start på signal = Start on signal
+Sätt tiden = Set time
+Välj vilken tid du vill sätta = Select which time to set
+Starta nu = Start now
+Alla okvalificerade = Any unqualified
+Antal nivåer = Number of levels
+Använd ranking istället för placering i kval för att placera kvalificerade löpare i klasser = Use ranking instead of placement to distribute qualified runners into classes
+Bästa tid = Best time
+Final = Final
+Klass / placering = Class / place
+Klass X (namnsuffix) = Class X (name suffix)
+Klass efter ranking = Select class by ranking
+Kval = Qualification
+Kvalificeringsregler för X = Qualification Rules for X
+Kvalklass = Qualification class
+Ladda = Load
+N bästa = N best
+Nivå X = Level X
+Placeringar = Placements
+Regler = Rules
+Tidsgräns X = Time limit X
+Tidskval = Time qualification
+Use in X = Use in X
+X bästa okvalificerade = X best unqualified
+X kvalificerade = X qualified
+Övriga okvalificerade = Remaining unqualified
+Lägg till regler = Add rules
+Placering X kvalificerar till Y = Place X qualifies for Y
+X bästa = X best
+Alla övriga = All remaining
+Vill du starta automaten? = Do you want to start the service?
+För kommunikationstest kan man använda en separat testtävling = To test communication, you can use a separate test competition
+Observera att stämplingar före tävlingens nolltid inte kan hämtas = Note MeOS cannot fetch punches preceding the competition zero time
+Individual Rogaining Split Print = Individual Rogaining Split Print
+Lap Count = Lap count
+Lap count with extra punch = Lap count with extra punch
+Live results, radio = Live results, radio
+Patrol results = Patrol results
+Patrol, start list = Patrol, start list
+Resultatlista, Rogaining, lag = Results, Rogaining, team
+Startlista, lag = Start list, team
+Team Rogaining Split Print = Team Rogaining Split Print
+RunnerRentalCard = Rental card
+Primärt = Primary
+Sekundärt = Secondary
+Välj typ av ID att exportera = Select ID types to export
+Ursprunglig tid: X = Original time: X
+Manuellt ändrad stämpling = Manually changed data
+help_second_fee = Use a second raised fee for direct entry at the competition day (for example). The higher fee is applied starting from and including the specified day. The specified percentage is relative the original fee.
+Avgiftshöjning två (procent) = Second fee increase (percent)
+ClassDataA = Class data A
+ClassDataB = Class data B
+ClassTextA = Class text
+Extra data X = Extra data X
+Extra datafält = Extra data fields
+Kommentarer = Comments
+Oförändrad brickdata = Original card data
+Okänd ursprungsstatus = Unknown data origin status
+RunnerDataA = Competitor data A
+RunnerDataB = Competitor data B
+RunnerTextA = Competitor text
+Sida = Page
+Stoppdatum två = Second stop date
+TeamDataA = Team data A
+TeamDataB = Team data B
+TeamTextA = Team text
+Födelsedatum = Birth date
+Kommentar = Comment
+Lägg till eller redigera kommentarer om deltagaren = Add or edit a comment about the competitor
+Lägg till eller redigera kommentarer om deltagaren = Add or edit a comment about the team
+Manuellt ändrad brickdata = Manually modified card data
+Efteranmälan = Late entry
+Reducerad = Reduced
diff --git a/code/french.lng b/code/french.lng
index dae9d89..174b1b9 100644
--- a/code/french.lng
+++ b/code/french.lng
@@ -214,7 +214,9 @@ Bevakar händelser i X = Moniteur d'évènement X
 Bevakningsprioritering = Sélectionner le coureur à surveiller
 Bevara höjd/bredd-relationen = Conserver les proportions
 Bibs = Dossards
+Bild = Image
 Bild under text = Mettre l'image sous le texte
+Bilder = Images
 Block = Bloc
 Blockbredd = Largeur de bloc
 Bläddra = Parcourir
@@ -265,7 +267,7 @@ ClassKnockoutTotalResult = Class, knock-out total result
 ClassLength = Longueur du circuit pour la catégorie
 ClassLiveResult = Live results (temps radios), par catégorie
 ClassName = Catégorie
-ClassNumEntries = Nombre d'inscrits
+ClassNumEntries = Nombre d'inscrits dans la catégorie
 ClassPoints = Catégorie, points
 ClassResult = Catégorie, résultat
 ClassResultFraction = Pourcentage de la catégorie ayant terminé
@@ -422,6 +424,7 @@ Elektronisk godkänd = Accepté électroniquement
 Elit = Élite
 Elitavgift = Frais élites
 Elitklasser = Catégorie élite
+Empty Results Split Print = Temps intermédiaires sans résultats
 En bana med slingor tillåter deltagaren att ta slingorna i valfri ordning = Un circuit avec des boucles autorise le coureur à effectuer les boucles dans n'importe quel ordre.
 En gafflad sträcka = Circuit avec variations
 En klass kan inte slås ihop med sig själv = Vous ne pouvez pas fusionner une catégorie avec elle-même
@@ -621,6 +624,7 @@ Förhindra att laget deltar i någon omstart = Permet à l'équipe de ne pas pre
 Förhindra omstart = Refuser le départ des attardés
 Förhöjd avgift = Frais supplémentaires
 Förskjutning = Déplacement
+Förskjutning av klassers Id = Décalage de l'identifiant de catégorie
 Först = En premier
 Först-i-mål, gemensam = Du premier au dernier, commun
 Först-i-mål, klassvis = Du premier au dernier, par catégorie
@@ -685,6 +689,7 @@ Hittar inte hjälpfilen, X = Documentation introuvable, X
 Hittar inte klass X = Impossible de trouver la catégorie X
 Hjälp = Aide
 Hoppar över stafettklass: X = Sauter la catégorie de relais: X
+Horisontell = Horizontal
 Horizontell = Horizontalement
 Huvudlista = Liste principale
 Hyravgift = Tarif de location
@@ -763,6 +768,8 @@ Inconsistent qualification rule, X = Règle de qualification incohérente, X
 Index = Index
 Index in X[index] = Index en X[index]
 Individual Example = Exemple de course individuelle
+Individual Results Split Print = Avec résultats individuels
+Individual Rogaining Split Print = Avec résultats de la course au score
 Individual result by finish time = Résultat individuel sur l'heure d'arrivée
 Individual results in a club = Résultats individuel au sein du club
 Individuell = par catégorie
@@ -1009,6 +1016,7 @@ Liveresultat, radiotider = Résultats en direct avec radios
 Ljud = Son
 Ljudfiler, baskatalog = Répertoire de base des fichiers sonores
 Ljudval = Sélection des sons
+Lokal kopia från X = Copie locale de X
 Lokalt = Localement
 Long = Longue
 Longitud = Longitude
@@ -1402,6 +1410,8 @@ Relation till föregående = Lien avec le précédent
 Relativ skalfaktor för typsnittets storlek i procent = Facteur d'échelle pour la police (pourcentage)
 Relay Example = Exemple de relais
 Relay Example (Lokal kopia från: localhost) = Exemple de relais (Copie locale depuis : localhost)
+Relay Results Split Print = Avec résultats du relais
+Relay/Team Results Split Print = Avec résultats du relais/de l'équipe
 Relays = Relais
 Rep = Arrêt attardés
 Reparera vald tävling = Réparer la compétition sélectionnée
@@ -1526,6 +1536,7 @@ RunnerId = Licence/ID
 RunnerLeg = Concurrent (variation spécifique)
 RunnerLegNumber = Numéro de relais groupé du coureur
 RunnerLegNumberAlpha = Numéro de relais exact du coureur
+RunnerLegTeamLeaderName = Premier membre de l'équipe à terminer son circuit
 RunnerName = Nom du coureur
 RunnerNationality = Nationalité du coureur
 RunnerPaid = Payé
@@ -1888,6 +1899,7 @@ Tabelläge = Mode table
 Tar bort X = Retrait de X
 Team = Équipe
 Team Rogaining = Course au score en équipe
+Team Rogaining Split Print = Avec résultats de la course au score en équipe
 TeamBib = Dossard de l'équipe
 TeamClub = Club de l'équipe
 TeamCourseName = Nom du circuit pour l'équipe/la branche
@@ -2217,6 +2229,7 @@ Välj alla klasser = Sélectionner toutes les catégories
 Välj allt = Sélectionner tout
 Välj automatiskt = Sélection automatique
 Välj bild = Choisir une image
+Välj bland befintliga bilder = Sélectionner une image existante
 Välj deltagare för förhandsgranskning = Sélectionner un coureur pour prévisualisation
 Välj den etapp som föregår denna tävling = Sélectionner l'étape précédente
 Välj den etapp som kommer efter denna tävling = Sélectionner l'étape suivante
@@ -2428,11 +2441,12 @@ info:mapcontrol = MeOS ne sait pas déterminer la fonction d'un boîtier s'il n'
 info:multieventnetwork = Pour prendre en charge plus d'une étape vous devez travailler localement. Faite une copie de sauvegarde de la compétition, ouvrez-la en local et transférez les résultats à l'étape suivante. Enfin, remontez l'étape suivante sur le serveur.
 info:multiple_start = Un coureur peut faire plusieurs fois le même circuit. Une nouvelle inscription est créée à chaque lecture de la puce
 info:nosplitprint = Chargement de la liste personnalisée impossible\n\nCelle par défaut la remplace
+info:offsetclassid = Si vous importez des inscrits et des catégories depuis des sources différentes dans la même compétition, il peut y avoir des conflits entre les numéros d'identifiant des catégories. Pour différencier les catégories, vous pouvez entrer un décalage de la valeur de l'identifiant des catégorires pour chacune des sources. Celui-ci sera ajouté à l'identifiant existant.\n\nVous pouvez par exemple entrer 1000 (si aucune catégorie n'a déjà un identifiant supérieur à 1000).
 info:pageswithcolumns = Montrer la liste page par page, avec un nombre spécifié de colonnes. Les infos sont mises à jour à chaque bouclage.
 info:readout_action = X: Puce no. Y lue.\nDes actions manuelles sont requises.
 info:readout_queue = X: Puce no. Y lue.\nLa puce a été mise en file d'attente.
 info:readoutbase = Activez le boîtier SI en sélectionnant son port COM ou en recherchant les boîtiers SI installés. Appuyez sur Information pour obtenir le statut du port sélectionné.\n\nLecture Interactive vous permet de gérer directement les problèmes tels qu'un numéro de puce erroné. N'utilisez pas cette possibilité quand les coureurs ayant des problèmes sont pris en charge séparément.\n\nLa base de données des coureurs est utilisée si vous voulez ajouter automatiquement de nouveaux coureurs. Les poinçons sont utilisés pour trouver (détecter) la bonne catégorie.
-info:readoutmore = Verrouillez la fonction pour éviter toute modification accidentelle.\n\nSélection des sons vous permet de lancer différents sons lors de la lecture des puces pour être plus facilement informé des problèmes.\n\n"Fenêtre de prévisualisation coureur" affiche une nouvelle fenêtre destinée au coureur qui lit sa puce, regroupant les informations principales de sa course.\n\nPlusieurs courses pour un coureur est utile si un coureur est autorisé a faire plusieurs fois son circuit. Une nouvelle inscriprion est créée à chaque lecture de la puce.
+info:readoutmore = Verrouillez la fonction pour éviter toute modification accidentelle.\n\nSélection des sons vous permet de lancer différents sons lors de la lecture des puces pour être plus facilement informé des problèmes.\n\n"Fenêtre de prévisualisation coureur" affiche une nouvelle fenêtre destinée au coureur qui lit sa puce, regroupant les informations principales de sa course.\n\nPlusieurs courses pour un coureur est utile si un coureur est autorisé a faire plusieurs fois son circuit. Une nouvelle inscription est créée à chaque lecture de la puce.
 info:readoutwindow = Cette fenêtre affiche les informations principales de chaque lecture de puce
 info:runnerdbonline = Comme vous êtes connecté à un serveur, il n'est pas possible d'éditer les bases de données club et coureurs manuellement. Effectuez les changements avant d'uploader la compétition sur un serveur. Il est également possible de remplacer la base de données existante sur le serveur en important une nouvelle base (à partir de IOF XML).
 info:teamcourseassignment = Le fichier des circuits IOF XML 3.0 contient les variations des équipes. Pour importer ces données, vous devez préparer la compétition en fonction des données du fichier :\n\n1.Assurez-vous que les catégories de relais ont le bon nombre de branches.\n2. Affectez les dossards à chaque catégorie. Passez par la Configuration Rapide dans l'onglet Catégories et renseignez le premier dossard de chaque catégorie (avec la répartition automatique des dossards). Vous pouvez aussi importer les équipes et leur attribuer des dossards comme d'habitude.\n\n\n3. Importez les circuits. Vous pouvez importer plusieurs fois ce fichier si nécessaire pour mettre à jour les variations.
diff --git a/code/gdiconstants.h b/code/gdiconstants.h
index dd3ca73..0c6e80c 100644
--- a/code/gdiconstants.h
+++ b/code/gdiconstants.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/gdifonts.h b/code/gdifonts.h
index a72a06c..79030d7 100644
--- a/code/gdifonts.h
+++ b/code/gdifonts.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -62,6 +62,7 @@ constexpr int skipBoundingBox = 1 << 18;
 constexpr int hiddenText = 1 << 19;
 constexpr int textLimitEllipsis = 1 << 20;
 constexpr int imageNoUpdatePos = 1 << 21;
+constexpr int time24HourClock = 1 << 22;
 
 enum GDICOLOR {
   colorBlack = RGB(0, 0, 0),
diff --git a/code/gdiimpl.h b/code/gdiimpl.h
index 137fb60..fa7ddc2 100644
--- a/code/gdiimpl.h
+++ b/code/gdiimpl.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -59,8 +59,8 @@ public:
 
 class GDIImplFontEnum {
 private:
-  int width;
-  int height;
+  int width = 0;
+  int height = 0;
   double relScale;
   wstring face;
 public:
diff --git a/code/gdioutput.cpp b/code/gdioutput.cpp
index 39b5f06..181daeb 100644
--- a/code/gdioutput.cpp
+++ b/code/gdioutput.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -320,6 +320,18 @@ void gdioutput::initCommon(double _scale, const wstring &font)
 
   fontHeightCache.clear();
   fonts[currentFont].init(scale, currentFont, L"");
+  updateTabFont();
+}
+
+void gdioutput::updateTabFont() {
+  if (this == gdi_main && hWndTab) {
+    HFONT gui = fonts[currentFont].getGUIFont();
+    SendMessage(hWndTab, WM_SETFONT, WPARAM(gui), TRUE);
+
+    RECT rc;
+    GetClientRect(hWndAppMain, &rc);
+    SendMessage(hWndAppMain, WM_SIZE, 0, MAKELONG(rc.right, rc.bottom));
+  }
 }
 
 double getLocalScale(const wstring &fontName, wstring &faceName) {
@@ -888,6 +900,7 @@ TextInfo& gdioutput::addImage(const string& id, int yp, int xp, int format,
 
   imageReferences.push_back(&TI);
 
+  TI.id = id;
   TI.format = format | textImage;
   TI.xp = xp;
   TI.yp = yp;
@@ -1043,9 +1056,14 @@ TextInfo& gdioutput::addString(const char* id, int yp, int xp, int format, const
   TI.format = format;
   TI.xp = xp;
   TI.yp = yp;
-  TI.text = lang.tl(text);
-  if ((format & Capitalize) == Capitalize && lang.capitalizeWords())
-    capitalizeWords(TI.text);
+  if ((format & 0xFF) != textImage) {
+    TI.text = lang.tl(text);
+    if ((format & Capitalize) == Capitalize && lang.capitalizeWords())
+      capitalizeWords(TI.text);
+  }
+  else {
+    TI.text = text;
+  }
   TI.id = id;
   TI.xlimit = xlimit;
   TI.callBack = cb;
@@ -1201,7 +1219,7 @@ void ButtonInfo::moveButton(gdioutput &gdi, int nxp, int nyp) {
   gdi.updatePos(xp, yp, w, h);
 }
 
-void ButtonInfo::getDimension(gdioutput &gdi, int &w, int &h) {
+void ButtonInfo::getDimension(const gdioutput &gdi, int &w, int &h) const {
   RECT rc;
   GetWindowRect(hWnd, &rc);
   w = rc.right - rc.left + gdi.scaleLength(GDI_BUTTON_SPACING);
@@ -1214,12 +1232,21 @@ ButtonInfo &gdioutput::addButton(int x, int y, int w, const string &id,
   return addButton(x, y, w, id, widen(text), cb, widen(tooltip), AbsPos, hasState);
 }
 
-ButtonInfo &gdioutput::addButton(int x, int y, int w, const string &id,
-                                 const wstring &text, GUICALLBACK cb, const wstring &tooltip,
-                                 bool AbsPos, bool hasState)
-{
-  int style = hasState ? BS_CHECKBOX|BS_PUSHLIKE : BS_PUSHBUTTON;
-  
+ButtonInfo& gdioutput::addButton(int x, int y, int w, const string& id,
+  const wstring& text, GUICALLBACK cb, const wstring& toolTip,
+  bool absPos, bool hasState) {
+  return addButton(x, y, w, getButtonHeight(), id, text,
+    gdiFonts::normalText, cb, toolTip, absPos, hasState);
+  }
+
+
+ButtonInfo& gdioutput::addButton(int x, int y, int width, int height,
+  const string& id, const wstring& text,
+  gdiFonts font, GUICALLBACK cb,
+  const wstring& tooltip,
+  bool absPos, bool hasState) {
+  int style = hasState ? BS_CHECKBOX | BS_PUSHLIKE : BS_PUSHBUTTON;
+
   if (text[0] == '@')
     style |= BS_BITMAP;
 
@@ -1234,36 +1261,38 @@ ButtonInfo &gdioutput::addButton(int x, int y, int w, const string &id,
   }
   if (lang.capitalizeWords())
     capitalizeWords(ttext);
-  int height = getButtonHeight();
-  if (AbsPos){
-    if (ttext.find_first_of('\n') != string::npos) { //WCS
+  if (absPos) {
+    if (ttext.find_first_of('\n') != string::npos) { 
       style |= BS_MULTILINE;
       height *= 2;
     }
-    bi.hWnd=CreateWindow(L"BUTTON", ttext.c_str(),  WS_TABSTOP|WS_VISIBLE|WS_CHILD | WS_CLIPSIBLINGS |style|BS_NOTIFY,
-      x-OffsetX, y, w, height, hWndTarget, NULL,
+    bi.hWnd = CreateWindow(L"BUTTON", ttext.c_str(), WS_TABSTOP | WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | style | BS_NOTIFY,
+      x - OffsetX, y, width, height, hWndTarget, NULL,
       (HINSTANCE)GetWindowLongPtr(hWndTarget, GWLP_HINSTANCE), NULL);
   }
   else {
-    bi.hWnd=CreateWindow(L"BUTTON", ttext.c_str(),  WS_TABSTOP|WS_VISIBLE|WS_CHILD | WS_CLIPSIBLINGS |style|BS_NOTIFY,
-      x-OffsetX, y-OffsetY-1, w,  height, hWndTarget, NULL,
+    bi.hWnd = CreateWindow(L"BUTTON", ttext.c_str(), WS_TABSTOP | WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | style | BS_NOTIFY,
+      x - OffsetX, y - OffsetY - 1, width, height, hWndTarget, NULL,
       (HINSTANCE)GetWindowLongPtr(hWndTarget, GWLP_HINSTANCE), NULL);
   }
-  
-  SendMessage(bi.hWnd, WM_SETFONT, (WPARAM) getGUIFont(), 0);
 
-  if (!AbsPos)
-    updatePos(x, y, w+scaleLength(GDI_BUTTON_SPACING), height+5);
+  if (font == gdiFonts::normalText)
+    SendMessage(bi.hWnd, WM_SETFONT, (WPARAM)getGUIFont(), 0);
+  else
+    SendMessage(bi.hWnd, WM_SETFONT, (WPARAM)getCurrentFont().getFont(font), 0);
 
-  bi.xp=x;
-  bi.yp=y;
-  bi.width = w;
-  bi.text=ttext;
-  bi.id=id;
-  bi.callBack=cb;
-  bi.AbsPos=AbsPos;
+  if (!absPos)
+    updatePos(x, y, width + scaleLength(GDI_BUTTON_SPACING), height + 5);
 
-  if (tooltip.length()>0)
+  bi.xp = x;
+  bi.yp = y - 1;
+  bi.width = width;
+  bi.text = ttext;
+  bi.id = id;
+  bi.callBack = cb;
+  bi.AbsPos = absPos;
+
+  if (tooltip.length() > 0)
     addToolTip(id, tooltip, bi.hWnd);
 
   BI.push_back(bi);
@@ -1273,7 +1302,7 @@ ButtonInfo &gdioutput::addButton(int x, int y, int w, const string &id,
   return BI.back();
 }
 
-static int checkBoxCallback(gdioutput *gdi, int type, void *data) {
+static int checkBoxCallback(gdioutput *gdi, GuiEventType type, BaseInfo *data) {
   if (type == GUI_LINK) {
     TextInfo *ti = (TextInfo *)data;
     string cid = ti->id.substr(1);
@@ -1321,23 +1350,23 @@ ButtonInfo &gdioutput::addCheckbox(int x, int y, const string &id, const string
   return addCheckbox(x,y,id, widen(text), cb, Checked, widen(tooltip), AbsPos);
 }
 
-ButtonInfo &gdioutput::addCheckbox(int x, int y, const string &id, const wstring &text,
-                                   GUICALLBACK cb, bool Checked, const wstring &tooltip, bool AbsPos)
+ButtonInfo& gdioutput::addCheckbox(int x, int y, const string& id, const wstring& text,
+  GUICALLBACK cb, bool Checked, const wstring& tooltip, bool AbsPos)
 {
   ButtonInfo bi;
   SIZE size;
 
   wstring ttext = lang.tl(text);
-  HDC hDC=GetDC(hWndTarget);
+  HDC hDC = GetDC(hWndTarget);
   SelectObject(hDC, GetStockObject(DEFAULT_GUI_FONT));
   GetTextExtentPoint32(hDC, L"M", 1, &size);
 
-  int ox=OffsetX;
-  int oy=OffsetY;
+  int ox = OffsetX;
+  int oy = OffsetY;
 
   if (AbsPos) {
-    ox=0;
-    oy=0;
+    ox = 0;
+    oy = 0;
   }
 
   int h = size.cy;
@@ -1345,15 +1374,16 @@ ButtonInfo &gdioutput::addCheckbox(int x, int y, const string &id, const wstring
   GetTextExtentPoint32(hDC, ttext.c_str(), ttext.length(), &size);
   ReleaseDC(hWndTarget, hDC);
 
-  bi.hWnd=CreateWindowEx(0,L"BUTTON", L"",  WS_TABSTOP|WS_VISIBLE|
-          WS_CHILD | WS_CLIPSIBLINGS |BS_AUTOCHECKBOX|BS_NOTIFY,
-          x-ox, y-oy + (size.cy-h)/2, h, h, hWndTarget, NULL,
-          (HINSTANCE)GetWindowLongPtr(hWndTarget, GWLP_HINSTANCE), NULL);
+  int cbY = y + (size.cy - h) / 2;
+  bi.hWnd = CreateWindowEx(0, L"BUTTON", L"", WS_TABSTOP | WS_VISIBLE |
+    WS_CHILD | WS_CLIPSIBLINGS | BS_AUTOCHECKBOX | BS_NOTIFY,
+    x - ox, cbY - oy, h, h, hWndTarget, NULL,
+    (HINSTANCE)GetWindowLongPtr(hWndTarget, GWLP_HINSTANCE), NULL);
 
-  TextInfo &desc = addStringUT(y , x + (3*h)/2, 0, ttext, 0, checkBoxCallback);
+  TextInfo& desc = addStringUT(y, x + (3 * h) / 2, 0, ttext, 0, checkBoxCallback);
   desc.id = "T" + id;
 
-  SendMessage(bi.hWnd, WM_SETFONT, (WPARAM) getGUIFont(), 0);
+  SendMessage(bi.hWnd, WM_SETFONT, (WPARAM)getGUIFont(), 0);
 
   if (Checked)
     SendMessage(bi.hWnd, BM_SETCHECK, BST_CHECKED, 0);
@@ -1366,18 +1396,18 @@ ButtonInfo &gdioutput::addCheckbox(int x, int y, const string &id, const wstring
     else
       updatePos(x, y, size.cx + int(30 * scale), desc.textRect.bottom - desc.textRect.top + scaleLength(4));
   }
-  if (tooltip.length()>0) {
+  if (tooltip.length() > 0) {
     addToolTip(id, tooltip, bi.hWnd);
     addToolTip(desc.id, tooltip, 0, &desc.textRect);
   }
   bi.isCheckbox = true;
-  bi.xp=x;
-  bi.yp=y;
-  bi.width = desc.textRect.right - (x-ox);
-  bi.text=ttext;
-  bi.id=id;
-  bi.callBack=cb;
-  bi.AbsPos=AbsPos;
+  bi.xp = x;
+  bi.yp = cbY;
+  bi.width = desc.textRect.right - (x - ox);
+  bi.text = ttext;
+  bi.id = id;
+  bi.callBack = cb;
+  bi.AbsPos = AbsPos;
   bi.originalState = Checked;
   bi.isEdit(true);
   BI.push_back(bi);
@@ -1514,14 +1544,15 @@ InputInfo &gdioutput::addInputBox(const string &id, int width, int height, const
   return addInputBox(id, CurrentX, CurrentY, width, height, text, cb, explanation);
 }
 
-InputInfo &gdioutput::addInputBox(const string &id, int x, int y, int width, int height,
-                                  const wstring &text, GUICALLBACK cb, const wstring &Explanation)
+InputInfo &gdioutput::addInputBox(const string &id, int x, int y, int widthIn, int heightIn,
+                                  const wstring &text, GUICALLBACK cb, const wstring &explanation)
 {
-  if (Explanation.length()>0) {
-    addString("", y, x, 0, Explanation);
+  if (explanation.length()>0) {
+    addString("", y, x, 0, explanation);
     y+=lineHeight;
   }
-
+  int width = scaleLength(widthIn);
+  int height = scaleLength(heightIn);
   InputInfo ii;
 
   int ox=OffsetX;
@@ -1532,7 +1563,7 @@ InputInfo &gdioutput::addInputBox(const string &id, int x, int y, int width, int
     x-ox, y-oy, width, height, hWndTarget, NULL,
     (HINSTANCE)GetWindowLongPtr(hWndTarget, GWLP_HINSTANCE), NULL);
 
-  updatePos(x, y, width, height);
+  updatePos(x, y, width, height + scaleLength(5));
 
   SendMessage(ii.hWnd, WM_SETFONT, (WPARAM) getGUIFont(), 0);
 
@@ -1545,13 +1576,10 @@ InputInfo &gdioutput::addInputBox(const string &id, int x, int y, int width, int
   ii.focusText = text;
   ii.id=id;
   ii.callBack=cb;
-
   II.push_back(ii);
 
   iiByHwnd[ii.hWnd] = &II.back();
-  //if (Help.length() > 0)
-  //  addToolTip(Help, ii.hWnd);
-
+  
   FocusList.push_back(ii.hWnd);
   return II.back();
 }
@@ -1775,8 +1803,7 @@ ListBoxInfo &gdioutput::addCombo(int x, int y, const string &id, int width, int
   return LBI.back();
 }
 
-bool gdioutput::addItem(const string &id, const wstring &text, size_t data)
-{
+bool gdioutput::addItem(const string &id, const wstring &text, size_t data) {
   list<ListBoxInfo>::reverse_iterator it;
   for (it=LBI.rbegin(); it != LBI.rend(); ++it) {
     if (it->id==id) {
@@ -1784,11 +1811,13 @@ bool gdioutput::addItem(const string &id, const wstring &text, size_t data)
         LRESULT index=SendMessage(it->hWnd, CB_ADDSTRING, 0, LPARAM(text.c_str()));
         SendMessage(it->hWnd, CB_SETITEMDATA, index, data);
         it->data2Index[data] = int(index);
+        it->computed_hash = 0;
       }
       else {
         LRESULT index=SendMessage(it->hWnd, LB_INSERTSTRING, -1, LPARAM(text.c_str()));
         SendMessage(it->hWnd, LB_SETITEMDATA, index, data);
         it->data2Index[data] = int(index);
+        it->computed_hash = 0;
       }
       return true;
     }
@@ -1796,39 +1825,67 @@ bool gdioutput::addItem(const string &id, const wstring &text, size_t data)
   return false;
 }
 
-bool gdioutput::addItem(const string& id, const vector< pair<wstring, size_t> >& items)
-{
-  list<ListBoxInfo>::reverse_iterator it;
-  for (it = LBI.rbegin(); it != LBI.rend(); ++it) {
+bool gdioutput::modifyItemDescription(const string& id, size_t itemData, const wstring &description) {
+  for (auto it = LBI.rbegin(); it != LBI.rend(); ++it) {
     if (it->id == id) {
+      int ix = it->data2Index[itemData];
+      // It is intentioal that the hash is not modified. This method allows "customization" of
+      // some description without reloading a complete listbox
       if (it->IsCombo) {
-        SendMessage(it->hWnd, CB_RESETCONTENT, 0, 0);
-        SendMessage(it->hWnd, CB_INITSTORAGE, items.size(), 48);
-        SendMessage(it->hWnd, WM_SETREDRAW, FALSE, 0);
-        it->data2Index.clear();
-
-        for (size_t k = 0; k < items.size(); k++) {
-          LRESULT index = SendMessage(it->hWnd, CB_ADDSTRING, 0, LPARAM(items[k].first.c_str()));
-          SendMessage(it->hWnd, CB_SETITEMDATA, index, items[k].second);
-          it->data2Index[items[k].second] = int(index);
-        }
-        SendMessage(it->hWnd, WM_SETREDRAW, TRUE, 0);
-        RedrawWindow(it->hWnd, NULL, NULL, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
+        SendMessage(it->hWnd, CB_DELETESTRING, ix, 0);
+        SendMessage(it->hWnd, CB_INSERTSTRING, ix, LPARAM(description.c_str()));
+        SendMessage(it->hWnd, CB_SETITEMDATA, ix, itemData);
       }
       else {
-        SendMessage(it->hWnd, LB_RESETCONTENT, 0, 0);
-        SendMessage(it->hWnd, LB_INITSTORAGE, items.size(), 48);
-        SendMessage(it->hWnd, WM_SETREDRAW, FALSE, 0);
+        SendMessage(it->hWnd, LB_DELETESTRING, ix, 0);
+        SendMessage(it->hWnd, LB_INSERTSTRING, ix, LPARAM(description.c_str()));
+        SendMessage(it->hWnd, LB_SETITEMDATA, ix, itemData);
+      }
+      return true;
+    }
+  }
 
-        it->data2Index.clear();
-        for (size_t k = 0; k < items.size(); k++) {
-          LRESULT index = SendMessage(it->hWnd, LB_INSERTSTRING, -1, LPARAM(items[k].first.c_str()));
-          SendMessage(it->hWnd, LB_SETITEMDATA, index, items[k].second);
-          it->data2Index[items[k].second] = int(index);
+  return false;
+}
+
+bool gdioutput::setItems(const string& id, const vector<pair<wstring, size_t>>& items) {
+  auto hash = ListBoxInfo::computeItemHash(items);
+  for (auto it = LBI.rbegin(); it != LBI.rend(); ++it) {
+    if (it->id == id) {
+      if (it->IsCombo) {
+        if (it->computed_hash == 0 || it->computed_hash != hash) {
+          SendMessage(it->hWnd, CB_RESETCONTENT, 0, 0);
+          SendMessage(it->hWnd, CB_INITSTORAGE, items.size(), 48);
+          SendMessage(it->hWnd, WM_SETREDRAW, FALSE, 0);
+          it->data2Index.clear();
+
+          for (size_t k = 0; k < items.size(); k++) {
+            LRESULT index = SendMessage(it->hWnd, CB_ADDSTRING, 0, LPARAM(items[k].first.c_str()));
+            SendMessage(it->hWnd, CB_SETITEMDATA, index, items[k].second);
+            it->data2Index[items[k].second] = int(index);
+          }
+          SendMessage(it->hWnd, WM_SETREDRAW, TRUE, 0);
+          RedrawWindow(it->hWnd, NULL, NULL, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
+          it->computed_hash = hash;
         }
+      }
+      else {
+        if (it->computed_hash == 0 || it->computed_hash != hash) {
+          SendMessage(it->hWnd, LB_RESETCONTENT, 0, 0);
+          SendMessage(it->hWnd, LB_INITSTORAGE, items.size(), 48);
+          SendMessage(it->hWnd, WM_SETREDRAW, FALSE, 0);
 
-        SendMessage(it->hWnd, WM_SETREDRAW, TRUE, 0);
-        RedrawWindow(it->hWnd, NULL, NULL, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
+          it->data2Index.clear();
+          for (size_t k = 0; k < items.size(); k++) {
+            LRESULT index = SendMessage(it->hWnd, LB_INSERTSTRING, -1, LPARAM(items[k].first.c_str()));
+            SendMessage(it->hWnd, LB_SETITEMDATA, index, items[k].second);
+            it->data2Index[items[k].second] = int(index);
+          }
+
+          SendMessage(it->hWnd, WM_SETREDRAW, TRUE, 0);
+          RedrawWindow(it->hWnd, NULL, NULL, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
+          it->computed_hash = hash;
+        }
       }
       return true;
     }
@@ -1843,6 +1900,7 @@ void gdioutput::filterOnData(const string &id, const unordered_set<int> &filter)
       if (it->IsCombo) {
       }
       else {
+        it->computed_hash = 0;
         const HWND &hWnd = it->hWnd;
         LRESULT count = SendMessage(hWnd, LB_GETCOUNT, 0, 0);
         for (intptr_t ix = count - 1; ix>=0; ix--) {
@@ -1857,17 +1915,18 @@ void gdioutput::filterOnData(const string &id, const unordered_set<int> &filter)
   assert(false);
 }
 
-bool gdioutput::clearList(const string &id)
-{
-  list<ListBoxInfo>::iterator it;
-  for(it=LBI.begin(); it != LBI.end(); ++it){
-    if (it->id==id) {
+bool gdioutput::clearList(const string& id) {
+  for (auto it = LBI.begin(); it != LBI.end(); ++it) {
+    if (it->id == id) {
       it->original = L"";
       it->originalIdx = -1;
+      it->computed_hash = 0;
+      it->data2Index.clear();
+
       if (it->IsCombo)
-        SendMessage(it->hWnd, CB_RESETCONTENT , 0, 0);
+        SendMessage(it->hWnd, CB_RESETCONTENT, 0, 0);
       else
-        SendMessage(it->hWnd, LB_RESETCONTENT , 0, 0);
+        SendMessage(it->hWnd, LB_RESETCONTENT, 0, 0);
       return true;
     }
   }
@@ -1908,6 +1967,17 @@ void ListBoxInfo::copyUserData(ListBoxInfo &dest) const {
   dest.IsCombo = IsCombo;
 }
 
+uint64_t ListBoxInfo::computeItemHash(const vector<pair<wstring, size_t>>& items) {
+  uint64_t res = 1;
+  for (auto& it : items) {
+    res = res * 997 + it.second;
+    for (auto ch : it.first)
+      res = res * 2003 + ch;
+  }
+
+  return res;
+}
+
 bool gdioutput::getSelectedItem(ListBoxInfo &lbi) {
   if (lbi.IsCombo) {
     LRESULT index=SendMessage(lbi.hWnd, CB_GETCURSEL, 0, 0);
@@ -2240,7 +2310,7 @@ void gdioutput::processButtonMessage(ButtonInfo &bi, WPARAM wParam)
       if (bi.isCheckbox)
         bi.checked = SendMessage(bi.hWnd, BM_GETCHECK, 0, 0)==BST_CHECKED;
       bi.synchData();
-      if (bi.callBack || bi.handler) {
+      if (bi.callBack || bi.hasEventHandler()) {
         setWaitCursor(true);
         if (!bi.handleEvent(*this, GUI_BUTTON) && bi.callBack)
           bi.callBack(this, GUI_BUTTON, &bi); //it may be destroyed here...
@@ -3027,10 +3097,8 @@ void gdioutput::doEnter() {
   HWND hWnd=GetFocus();
 
   for (list<ButtonInfo>::iterator it=BI.begin(); it!=BI.end(); ++it)
-    if (it->isDefaultButton() && (it->callBack || it->handler)) {
-      if (it->handler)
-        it->handleEvent(*this, GUI_BUTTON);
-      else
+    if (it->isDefaultButton()) {
+      if (!it->handleEvent(*this, GUI_BUTTON) && it->callBack)
         it->callBack(this, GUI_BUTTON, &*it);
       return;
     }
@@ -3038,13 +3106,11 @@ void gdioutput::doEnter() {
   list<InputInfo>::iterator it;
 
   for(it=II.begin(); it != II.end(); ++it)
-    if (it->hWnd==hWnd && (it->callBack || it->handler)){
+    if (it->hWnd==hWnd && (it->hasEventHandler() || it->callBack)){
       TCHAR bf[1024];
       GetWindowText(hWnd, bf, 1024);
-      it->text=bf;
-      if (it->handler)
-        it->handleEvent(*this, GUI_INPUT);
-      else
+      it->text = bf;
+      if (!it->handleEvent(*this, GUI_INPUT))
         it->callBack(this, GUI_INPUT, &*it);
       return;
     }
@@ -3139,10 +3205,8 @@ void gdioutput::doEscape()
       tit->table->escape(*this);
 
   for (list<ButtonInfo>::iterator it=BI.begin(); it!=BI.end(); ++it) {
-    if (it->isCancelButton() && (it->callBack || it->handler) ) {
-      if (it->handler)
-        it->handleEvent(*this, GUI_BUTTON);
-      else
+    if (it->isCancelButton() && (it->callBack || it->hasEventHandler()) ) {
+      if (!it->handleEvent(*this, GUI_BUTTON))
         it->callBack(this, GUI_BUTTON, &*it);
       return;
     }
@@ -3263,7 +3327,7 @@ void gdioutput::clearPage(bool autoRefresh, bool keepToolbar) {
 
   try {
     if (postClear)
-      postClear(this, GUI_POSTCLEAR, 0);
+      postClear->makeEvent(*this, GUI_POSTCLEAR);
   }
   catch (const meosCancel&) {
   }
@@ -3458,7 +3522,7 @@ BaseInfo *gdioutput::setTextZeroBlank(const char *id, int number, bool Update)
 }
 
 
-BaseInfo *gdioutput::setText(const char *id, const wstring &text, bool Update, int requireExtraMatch)
+BaseInfo *gdioutput::setText(const char *id, const wstring &text, bool update, int requireExtraMatch, bool updateOriginal)
 {
   for (auto it = II.begin(); it != II.end(); ++it) {
     if (it->id == id && it->matchExtra(requireExtraMatch)) {
@@ -3468,7 +3532,8 @@ BaseInfo *gdioutput::setText(const char *id, const wstring &text, bool Update, i
       it->writeLock = oldWR;
       it->text = text;
       it->synchData();
-      it->original = text;
+      if (updateOriginal)
+        it->original = text;
       it->focusText = text;
       return &*it;
     }
@@ -3478,7 +3543,8 @@ BaseInfo *gdioutput::setText(const char *id, const wstring &text, bool Update, i
     if (it->id == id && it->IsCombo && it->matchExtra(requireExtraMatch)) {
       SetWindowText(it->hWnd, text.c_str());
       it->text = text;
-      it->original = text;
+      if (updateOriginal)
+        it->original = text;
       return &*it;
     }
   }
@@ -3503,7 +3569,7 @@ BaseInfo *gdioutput::setText(const char *id, const wstring &text, bool Update, i
 
       bool changed = updatePos(0, 0, it->textRect.right, it->textRect.bottom);
 
-      if (Update && hWndTarget) {
+      if (update && hWndTarget) {
         if (changed)
           InvalidateRect(hWndTarget, 0, true);
         else
@@ -3512,20 +3578,20 @@ BaseInfo *gdioutput::setText(const char *id, const wstring &text, bool Update, i
       return &*it;
     }
   }
-  return 0;
+  return nullptr;
 }
 
 bool gdioutput::insertText(const string &id, const wstring &text)
 {
-  for (list<InputInfo>::iterator it=II.begin();
-                         it != II.end(); ++it) {
-    if (it->id==id) {
+  for (list<InputInfo>::iterator it = II.begin();
+    it != II.end(); ++it) {
+    if (it->id == id) {
       SetWindowText(it->hWnd, text.c_str());
       it->text = text;
 
-      if (it->handler)
+      if (it->hasEventHandler())
         it->handleEvent(*this, GUI_INPUT);
-      else if (it->callBack) 
+      else if (it->callBack)
         it->callBack(this, GUI_INPUT, &*it);
 
       return true;
@@ -3651,7 +3717,6 @@ bool gdioutput::updatePosTight(int x, int y, int width, int height, int marginx,
 
 bool gdioutput::updatePos(int x, int y, int width, int height) {
   return updatePosTight(x, y, width, height, 0, 0);
-
 }
 
 void gdioutput::adjustDimension(int width, int height)
@@ -4385,9 +4450,6 @@ void gdioutput::RenderString(TextInfo &ti, HDC hDC) {
         h = ti.textRect.bottom - ti.textRect.top;
 
         image.drawImage(imgId, Image::ImageMethod::Default, hDC, rc.left, rc.top, w, h);
-
-        //width = image.getWidth(imgId);
-        //height = image.getHeight(imgId);
       }
     }
     if (!fixedRect) {
@@ -4450,7 +4512,7 @@ void gdioutput::RenderString(TextInfo &ti, HDC hDC) {
     memset(&rc, 0, sizeof(rc));
     int width =  scaleLength( (breakLines&ti.format) ? ti.xlimit : 450 );
     rc.right = width;
-    int dx = (breakLines&ti.format) ? 0 : scaleLength(20);
+    int dx = format != 10 ? 0 : scaleLength(20);
     ti.realWidth = width + dx;
     DrawText(hDC, ti.text.c_str(), ti.text.length(), &rc, DT_CALCRECT|DT_LEFT|DT_NOPREFIX|DT_WORDBREAK);
     ti.textRect=rc;
@@ -4459,7 +4521,7 @@ void gdioutput::RenderString(TextInfo &ti, HDC hDC) {
     ti.textRect.top+=ti.yp;
     ti.textRect.bottom+=ti.yp+dx;
 
-    if (ti.format == 10) {
+    if (format == 10) {
       DWORD c = colorLightYellow;// GetSysColor(COLOR_INFOBK);
       double red=GetRValue(c);
       double green=GetGValue(c);
@@ -4715,7 +4777,7 @@ void gdioutput::calcStringSize(TextInfo &ti, HDC hDC_in) const {
   else {
     memset(&rc, 0, sizeof(rc));
     rc.right = scaleLength( (breakLines&ti.format) ? ti.xlimit : 450 );
-    int dx = (breakLines&ti.format) ? 0 : scaleLength(20);
+    int dx = format != 10 ? 0 : scaleLength(20);
     ti.realWidth = rc.right + dx;
     DrawText(hDC, ti.text.c_str(), ti.text.length(), &rc, DT_CALCRECT|DT_LEFT|DT_NOPREFIX|DT_WORDBREAK);
     ti.textRect=rc;
@@ -4937,12 +4999,14 @@ wstring gdioutput::getTimerText(int zeroTime, int format, bool timeInSeconds) {
 
 wstring gdioutput::getTimerText(TextInfo *tit, DWORD T)
 {
-  int rt=(int(T)-int(tit->zeroTime))/1000;
-  int tenth = (abs(int(T)-int(tit->zeroTime))/100)%10;
+  int rt = (int(T) - int(tit->zeroTime)) / 1000;
+  int tenth = (abs(int(T) - int(tit->zeroTime)) / 100) % 10;
   wstring text;
 
   int t=abs(rt);
   wchar_t bf[16];
+  if ((tit->format & time24HourClock) != 0 && t > 0)
+    t = t % (24 * timeConstSecPerHour);
 
   if (tit->format & timeSeconds) {
     if (tit->format & timeWithTenth) 
@@ -5431,30 +5495,75 @@ void gdioutput::restoreInternal(const RestoreInfo &ri)
   }
 }
 
-void gdioutput::restore(const string &id, bool DoRefresh)
-{
-  if (restorePoints.count(id)==0)
+void gdioutput::restore(const string &restorePointId, bool doRefresh) {
+  auto rp = restorePoints.find(restorePointId);
+  if (rp == restorePoints.end())
     return;
-
-  const RestoreInfo &ri=restorePoints[id];
+  const RestoreInfo& ri = rp->second;
 
   restoreInternal(ri);
 
   MaxX=ri.sMX;
   MaxY=ri.sMY;
 
-  if (DoRefresh)
+  if (doRefresh)
     refresh();
 
   setOffset(ri.sOY, ri.sOY, false);
 }
 
-void gdioutput::restoreNoUpdate(const string &id)
-{
-  if (restorePoints.count(id)==0)
+RECT gdioutput::getDimensionSince(const string& restorePointId) const {
+  auto rp = restorePoints.find(restorePointId);
+  if (rp == restorePoints.end())
+    throw meosException("Internal error: " + restorePointId);
+  
+  const RestoreInfo& ri = rp->second;
+  RECT out = {numeric_limits<int>::max(), numeric_limits<int>::max(), 0, 0};
+  
+  auto grow = [&out](int x, int y, int w, int h) {
+    out.left = min<int>(out.left, x);
+    out.right = max<int>(out.right, x + w);
+    out.top = min<int>(out.top, y);
+    out.bottom = max<int>(out.bottom, y + h);
+  };
+
+  int lbiRemove = LBI.size() - ri.nLBI;
+  for (auto it = LBI.rbegin(); lbiRemove > 0; lbiRemove--, ++it) {
+    grow(it->getX(), it->getY(), it->getWidth(), it->getHeight());
+  }
+  
+  int tlRemove = TL.size() - ri.nTL;
+  for (auto it = TL.rbegin(); tlRemove > 0; tlRemove--, ++it) {
+    grow(it->getX(), it->getY(), it->getWidth(), it->getHeight());
+  }
+
+  int biRemove = BI.size() - ri.nBI;
+  for (auto it = BI.rbegin(); biRemove > 0; biRemove--, ++it) {
+    int w, h;
+    it->getDimension(*this, w, h);
+    grow(it->getX(), it->getY(), w, h);
+  }
+
+  int iiRemove = II.size() - ri.nII;
+  for (auto it = II.rbegin(); iiRemove > 0; iiRemove--, ++it) {
+    grow(it->getX(), it->getY(), it->getWidth(), it->getHeight());
+  }
+
+  int rectRemove = Rectangles.size() - ri.nRect;
+  for (auto it = Rectangles.rbegin(); rectRemove > 0; rectRemove--, ++it) {
+    auto& rc = it->getRect();
+    grow(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
+  }
+  
+  return out;
+}
+
+void gdioutput::restoreNoUpdate(const string &restorePointId) {
+  auto rp = restorePoints.find(restorePointId);
+  if (rp == restorePoints.end())
     return;
 
-  const RestoreInfo &ri=restorePoints[id];
+  const RestoreInfo& ri = rp->second;
 
   MaxX=ri.sMX;
   MaxY=ri.sMY;
@@ -5462,24 +5571,13 @@ void gdioutput::restoreNoUpdate(const string &id)
   restoreInternal(ri);
 }
 
-void gdioutput::setPostClearCb(GUICALLBACK cb)
-{
-  postClear=cb;
-}
-
-
-void gdioutput::setOnClearCb(GUICALLBACK cb)
-{
-  onClear=cb;
-}
-
 bool gdioutput::canClear()
 {
   if (!onClear)
     return true;
 
   try {
-    return onClear(this, GUI_CLEAR, 0)!=0;
+    return onClear->makeEvent(*this, GUI_CLEAR)!=0;
   }
   catch (const meosCancel&) {
     return false;
@@ -5503,7 +5601,7 @@ int gdioutput::sendCtrlMessage(const string &id)
 {
   for (list<ButtonInfo>::iterator it=BI.begin(); it != BI.end(); ++it) {
     if (id==it->id) {
-      if (it->handler)
+      if (it->hasEventHandler())
         return it->handleEvent(*this, GUI_BUTTON);
       else if (it->callBack) 
         return it->callBack(this, GUI_BUTTON, &*it); //it may be destroyed here...
@@ -6065,6 +6163,7 @@ ToolInfo &gdioutput::updateToolTip(const string &id, const wstring &tip) {
   for (ToolList::reverse_iterator it = toolTips.rbegin(); it != toolTips.rend(); ++it) {
     if (it->name == id && hWndToolTip) {
       it->tip = lang.tl(tip);
+      it->ti.lpszText = (LPWSTR)it->tip.c_str();
       SendMessage(hWndToolTip, TTM_UPDATETIPTEXTW, 0, (LPARAM) &it->ti);
       return *it;
     }
@@ -6100,11 +6199,10 @@ Table &gdioutput::getTable() const {
   return *const_cast<Table *>(Tables.back().table.get());
 }
 
-static int gdiTableCB(gdioutput *gdi, int type, void *data)
+static int gdiTableCB(gdioutput *gdi, GuiEventType type, BaseInfo *data)
 {
   if (type == GUI_BUTTON) {
     ButtonInfo bi = *static_cast<ButtonInfo *>(data);
-    //gdi->tableCB(bi, static_cast<Table *>(bi.getExtra()));
     gdi->tableCB(bi, &gdi->getTable());
   }
   return 0;
@@ -6112,8 +6210,6 @@ static int gdiTableCB(gdioutput *gdi, int type, void *data)
 
 void gdioutput::tableCB(ButtonInfo &bu, Table *t)
 {
-  #ifndef MEOSDB
-
   if (bu.id=="tblPrint") {
     t->keyCommand(*this, KC_PRINT);
   }
@@ -6212,8 +6308,6 @@ void gdioutput::tableCB(ButtonInfo &bu, Table *t)
   else if (bu.id == "tblInsert") {
     t->keyCommand(*this, KC_INSERT);
   }
-
-  #endif
 }
 
 void gdioutput::enableTables()
@@ -7084,7 +7178,7 @@ void gdioutput::copyToClipboard(const string &html, const wstring &txt) const {
     }
     else {
       // HTML table to text
-      ostringstream result;
+      std::ostringstream result;
       bool started = false;
       bool newline = false;
       bool dowrite = false;
@@ -7201,11 +7295,11 @@ string gdioutput::dbPress(const string &id, int extra) {
       if (it->isCheckbox) {
         check(id, !isChecked(id));
       }
-      else if(!it->callBack && !it->handler)
+      else if(!it->callBack && !it->hasEventHandler())
         throw meosException("Button " + id + " is not active.");
 
       wstring val = it->text;
-      if (it->handler)
+      if (it->hasEventHandler())
         it->handleEvent(*this, GUI_BUTTON);
       else if (it->callBack)
         it->callBack(this, GUI_BUTTON, &*it); //it may be destroyed here...
@@ -7229,11 +7323,11 @@ string gdioutput::dbPress(const string &id, const char *extra) {
       if (it->isCheckbox) {
         check(id, !isChecked(id));
       }
-      else if(!it->callBack && !it->handler)
+      else if(!it->callBack && !it->hasEventHandler())
         throw meosException("Button " + id + " is not active.");
 
       wstring val = it->text;
-      if (it->handler)
+      if (it->hasEventHandler())
         it->handleEvent(*this, GUI_BUTTON);
       else if (it->callBack)
         it->callBack(this, GUI_BUTTON, &*it); //it may be destroyed here...
@@ -7272,12 +7366,12 @@ string gdioutput::dbSelect(const string &id, int data) {
 
 void gdioutput::internalSelect(ListBoxInfo &bi) {
   bi.syncData();
-  if (bi.callBack || bi.handler) {
+  if (bi.callBack || bi.handler || bi.managedHandler) {
     setWaitCursor(true);
     hasCleared = false;
     try {
       bi.writeLock = true;
-      if (bi.handler)
+      if (bi.hasEventHandler())
         bi.handleEvent(*this, GUI_LISTBOX);
       else
         bi.callBack(this, GUI_LISTBOX, &bi); //it may be destroyed here... Then hasCleared is set.
@@ -7304,7 +7398,7 @@ void gdioutput::dbInput(const string &id, const string &text) {
       SetWindowText(it->hWnd, widen(text).c_str());
       it->text = widen(text);
       it->data = -1;
-      if (it->handler)
+      if (it->hasEventHandler())
         it->handleEvent(*this, GUI_COMBO);
       else if (it->callBack)
         it->callBack(this, GUI_COMBO, &*it); //it may be destroyed here...
@@ -7319,7 +7413,7 @@ void gdioutput::dbInput(const string &id, const string &text) {
 
       it->text = widen(text);
       SetWindowText(it->hWnd, widen(text).c_str());
-      if (it->handler)
+      if (it->hasEventHandler())
         it->handleEvent(*this, GUI_INPUT);
       else if (it->callBack)
         it->callBack(this, GUI_INPUT, &*it);
@@ -7357,7 +7451,7 @@ void gdioutput::dbDblClick(const string &id, int data) {
       if (!IsWindowEnabled(it->hWnd))
         throw meosException("Selection " + id + " is not active.");
       selectItemByData(id, data);
-      if (it->handler)
+      if (it->hasEventHandler())
         it->handleEvent(*this, GUI_LISTBOXSELECT);
       else if (it->callBack)
         it->callBack(this, GUI_LISTBOXSELECT, &*it); //it may be destroyed here...
diff --git a/code/gdioutput.h b/code/gdioutput.h
index a55dfcb..98605a2 100644
--- a/code/gdioutput.h
+++ b/code/gdioutput.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -24,25 +24,14 @@
 //
 //////////////////////////////////////////////////////////////////////
 
-#if !defined(AFX_GDIOUTPUT_H__396F60F8_679F_498A_B759_DF8F6F346A4A__INCLUDED_)
-#define AFX_GDIOUTPUT_H__396F60F8_679F_498A_B759_DF8F6F346A4A__INCLUDED_
-
-#if _MSC_VER > 1000
 #pragma once
-#endif // _MSC_VER > 1000
-
 
 #include <set>
 #include <map>
 #include <vector>
 
-#ifdef OLD
-#include <hash_set>
-#include <hash_map>
-#else
 #include <unordered_map>
 #include <unordered_set>
-#endif
 
 #include <algorithm>
 #include "subcommand.h"
@@ -65,8 +54,6 @@ struct PageInfo;
 struct RenderedPage;
 class AnimationData;
 
-typedef int (*GUICALLBACK)(gdioutput *gdi, int type, void *data);
-
 enum GDICOLOR;
 enum KeyCommandCode;
 enum gdiFonts;
@@ -81,13 +68,7 @@ constexpr int baseButtonWidth = 150;
 constexpr int GDI_BUTTON_SPACING = 8;
 
 typedef list<ToolInfo> ToolList;
-/*
-enum FontEncoding {
-  ANSI, Russian, EastEurope, Hebrew
-};*/
-/*
-FontEncoding interpetEncoding(const string &enc);
-*/
+
 struct FontInfo {
   const wstring *name;
   HFONT normal;
@@ -171,8 +152,8 @@ protected:
 
   map<string, RestoreInfo> restorePoints;
 
-  GUICALLBACK onClear;
-  GUICALLBACK postClear;
+  shared_ptr<GuiEvent> onClear;
+  shared_ptr<GuiEvent> postClear;
 
   list<InfoBox> IBox;
 
@@ -365,8 +346,8 @@ public:
   static const string& toUTF8(const wstring& input);
   static const wstring& fromUTF8(const string& input);
 
-  //void setEncoding(FontEncoding encoding);
-  //FontEncoding getEncoding() const;
+  
+  void updateTabFont();
 
   void getFontInfo(const TextInfo& ti, FontInfo& fi) const;
 
@@ -487,14 +468,32 @@ public:
 
   int sendCtrlMessage(const string& id);
   bool canClear();
-  void setOnClearCb(GUICALLBACK cb);
-  void setPostClearCb(GUICALLBACK cb);
+  
+  template<typename H>
+  void setPostClearCb(H cb) {
+    postClear = make_shared<GuiEvent>(cb);
+  }
 
-  void restore(const string& id = "", bool DoRefresh = true);
+  template<typename H>
+  void setOnClearCb(H cb) {
+    onClear = make_shared<GuiEvent>(cb);
+  }
+
+  void clearPostClearCb() {
+    postClear.reset();
+  }
+
+  void clearOnClearCb() {
+    onClear.reset();
+  }
+
+  void restore(const string& restorePointId = "", bool doRefresh = true);
 
   /// Restore, but do not update client area size,
   /// position, zoom, scrollbars, and do not refresh
-  void restoreNoUpdate(const string& id);
+  void restoreNoUpdate(const string& restorePointId);
+
+  RECT getDimensionSince(const string& restorePointId) const;
 
   void setRestorePoint();
   void setRestorePoint(const string& id);
@@ -644,7 +643,8 @@ public:
   pair<int, bool> getSelectedItem(const char* id);
 
   bool addItem(const string& id, const wstring& text, size_t data = 0);
-  bool addItem(const string& id, const vector< pair<wstring, size_t> >& items);
+  bool setItems(const string& id, const vector< pair<wstring, size_t> >& items);
+  bool modifyItemDescription(const string& id, size_t itemData, const wstring &description);
 
   void filterOnData(const string& id, const unordered_set<int>& filter);
 
@@ -687,7 +687,7 @@ public:
   BaseInfo* setTextTranslate(const string& id, const wstring& text, bool update = false);
 
 
-  BaseInfo* setText(const char* id, const wstring& text, bool update = false, int requireExtraMatch = -1);
+  BaseInfo* setText(const char* id, const wstring& text, bool update = false, int requireExtraMatch = -1, bool updateOriginal = true);
   BaseInfo* setText(const wchar_t* id, const wstring& text, bool update = false) {
     return setText(narrow(id), text, update);
   }
@@ -728,7 +728,13 @@ public:
     GUICALLBACK cb = nullptr, const wstring& tooltop = L"");
 
   ButtonInfo& addButton(int x, int y, int w, const string& id, const wstring& text,
-    GUICALLBACK cb, const wstring& tooltop, bool absPos, bool hasState);
+    GUICALLBACK cb, const wstring& tooltip, bool absPos, bool hasState);
+
+  ButtonInfo& addButton(int x, int y, int width, int height, 
+                        const string& id, const wstring& text,
+                        gdiFonts font, GUICALLBACK cb, 
+                        const wstring& tooltip, 
+                        bool absPos, bool hasState);
 
   ButtonInfo& addCheckbox(const string& id, const wstring& text, GUICALLBACK cb = nullptr,
     bool Checked = true, const wstring& tooltip = L"");
@@ -838,4 +844,3 @@ public:
   virtual ~gdioutput();
 };
 
-#endif // !defined(AFX_GDIOUTPUT_H__396F60F8_679F_498A_B759_DF8F6F346A4A__INCLUDED_)
diff --git a/code/gdistructures.h b/code/gdistructures.h
index c325d9f..3815387 100644
--- a/code/gdistructures.h
+++ b/code/gdistructures.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -20,15 +20,13 @@
 
 ************************************************************************/
 
-#ifndef GDI_STRUCTURES
-#define GDI_STRUCTURES
+#pragma once
 
 #include <cassert>
 #include "guihandler.h"
 #include "gdifonts.h"
 
-class BaseInfo
-{
+class BaseInfo {
 protected:
   void *extra;
   GuiHandler *handler;
@@ -88,8 +86,33 @@ public:
   }
 };
 
-class RestoreInfo : public BaseInfo
-{
+class GuiEvent final : public BaseInfo {
+  GUICALLBACK callback = nullptr;
+
+public: 
+  bool makeEvent(gdioutput &gdi, GuiEventType type) {
+    if (callback)
+      return callback(&gdi, type, this) != 0;
+    else
+      return handleEvent(gdi, type);
+
+    return true;
+  }
+
+  GuiEvent(GUICALLBACK callback) : callback(callback) {}
+  
+  GuiEvent(const shared_ptr<GuiHandler> &h)  {
+    setHandler(h);
+  }
+  
+  GuiEvent(const GuiHandler *h) {
+    setHandler(h);
+  }
+
+  HWND getControlWindow() const final { throw std::exception("Unsupported"); }
+};
+
+class RestoreInfo final : public BaseInfo {
 public:
   int nLBI;
   int nBI;
@@ -109,8 +132,8 @@ public:
   int nTooltip;
   int nTables;
 
-  GUICALLBACK onClear;
-  GUICALLBACK postClear;
+  shared_ptr<GuiEvent> onClear;
+  shared_ptr<GuiEvent> postClear;
 
   set<string> restorePoints;
 
@@ -118,11 +141,10 @@ public:
     return nLBI < r.nLBI || nBI < r.nBI || nII < r.nII || nTL < r.nTL || nRect < r.nRect || nData < r.nData;
   }
 
-  HWND getControlWindow() const {throw std::exception("Unsupported");}
+  HWND getControlWindow() const final {throw std::exception("Unsupported");}
 };
 
-class RectangleInfo : public BaseInfo
-{
+class RectangleInfo final : public BaseInfo {
 private:
   DWORD color;
   DWORD color2;
@@ -143,23 +165,20 @@ public:
 
   RectangleInfo &changeDimension(gdioutput &gdi, int dx, int dy); 
 
-  HWND getControlWindow() const {throw std::exception("Unsupported");}
+  HWND getControlWindow() const final {throw std::exception("Unsupported");}
 };
 
-
-class TableInfo : public BaseInfo
-{
+class TableInfo final: public BaseInfo {
 public:
   TableInfo():xp(0), yp(0), table(0) {}
   int xp;
   int yp;
   shared_ptr<Table> table;
 
-  HWND getControlWindow() const {throw std::exception("Unsupported");}
+  HWND getControlWindow() const final {throw std::exception("Unsupported");}
 };
 
-
-class TextInfo : public BaseInfo
+class TextInfo final: public BaseInfo
 {
 public:
 
@@ -178,7 +197,11 @@ public:
 
   bool isFormatInfo() const { return format == pageNewPage || format == pagePageInfo || format == pageNewChapter; }
 
-  int getHeight() {return int(textRect.bottom-textRect.top);}
+  int getHeight() const { return int(textRect.bottom - textRect.top); }
+  int getWidth() const { return realWidth; }
+  int getX() const { return xp; }
+  int getY() const { return yp; }
+
   gdiFonts getGdiFont() const {return gdiFonts(format & 0xFF);}
   // Sets absolute print coordinates in [mm]
   TextInfo &setAbsPrintPos(int x, int y) {
@@ -209,26 +232,25 @@ public:
   bool active;
 
 
-  HWND getControlWindow() const {throw std::exception("Unsupported");}
+  HWND getControlWindow() const final {throw std::exception("Unsupported");}
 
   friend class gdioutput;
 };
 
-class ButtonInfo : public BaseInfo
-{
+class ButtonInfo final : public BaseInfo {
 private:
   bool originalState;
   bool isEditControl;
   bool checked;
-  bool *updateLastData;
-  void synchData() const {if (updateLastData) *updateLastData = checked;}
-  
-public:
-  ButtonInfo(): callBack(0), hWnd(0), AbsPos(false), fixedRightTop(false),
-            flags(0), storedFlags(0), originalState(false), isEditControl(false),
-            isCheckbox(false), checked(false), updateLastData(0) {}
+  bool* updateLastData;
+  void synchData() const { if (updateLastData) *updateLastData = checked; }
 
-  ButtonInfo &isEdit(bool e) {isEditControl=e; return *this;}
+public:
+  ButtonInfo() : callBack(0), hWnd(0), AbsPos(false), fixedRightTop(false),
+    flags(0), storedFlags(0), originalState(false), isEditControl(false),
+    isCheckbox(false), checked(false), updateLastData(0) {}
+
+  ButtonInfo& isEdit(bool e) { isEditControl = e; return *this; }
 
   int xp;
   int yp;
@@ -240,27 +262,28 @@ public:
   int flags;
   int storedFlags;
   bool isCheckbox;
-  bool isDefaultButton() const {return (flags&1)==1;}
-  bool isCancelButton() const {return (flags&2)==2;}
+  bool isDefaultButton() const { return (flags & 1) == 1; }
+  bool isCancelButton() const { return (flags & 2) == 2; }
 
-  ButtonInfo &setSynchData(bool *variable) {updateLastData = variable; return *this;}
+  ButtonInfo& setSynchData(bool* variable) { updateLastData = variable; return *this; }
 
+  int getX() const { return xp; }
+  int getY() const { return yp; }
 
-  void moveButton(gdioutput &gdi, int xp, int yp);
-  void getDimension(gdioutput &gdi, int &w, int &h);
+  void moveButton(gdioutput& gdi, int xp, int yp);
+  void getDimension(const gdioutput& gdi, int& w, int& h) const;
 
-  ButtonInfo &setDefault();
-  ButtonInfo &setCancel() {flags|=2, storedFlags|=2; return *this;}
-  ButtonInfo &fixedCorner() {fixedRightTop = true; return *this;}
+  ButtonInfo& setDefault();
+  ButtonInfo& setCancel() { flags |= 2, storedFlags |= 2; return *this; }
+  ButtonInfo& fixedCorner() { fixedRightTop = true; return *this; }
   GUICALLBACK callBack;
   friend class gdioutput;
 
-  HWND getControlWindow() const {return hWnd;}
+  HWND getControlWindow() const final { return hWnd; }
 };
 
 enum gdiFonts;
-class InputInfo : public BaseInfo
-{
+class InputInfo  final: public BaseInfo {
 public:
   InputInfo();
   wstring text;
@@ -278,13 +301,15 @@ public:
   bool changedInput() const { return text != focusText; }
   InputInfo &setPassword(bool pwd);
   
-  HWND getControlWindow() const {return hWnd;}
+  HWND getControlWindow() const final {return hWnd;}
   
   InputInfo &setSynchData(wstring *variable) {updateLastData = variable; return *this;}
 
   int getX() const {return xp;}
   int getY() const {return yp;}
   int getWidth() const {return int(width);}
+  int getHeight() const { return int(height); }
+
 private:
   HWND hWnd;
   GUICALLBACK callBack;
@@ -305,37 +330,37 @@ private:
   friend class gdioutput;
 };
 
-class ListBoxInfo : public BaseInfo
-{
+class ListBoxInfo final : public BaseInfo {
 public:
   ListBoxInfo() : hWnd(0), callBack(0), IsCombo(false), index(-1),
-              writeLock(false), ignoreCheck(false), isEditControl(true),
-              originalProc(0), lbiSync(0), multipleSelection(false), 
-              xp(0), yp(0), width(0), height(0), data(0), lastTabStop(0),
-              updateLastData(0) {}
+    writeLock(false), ignoreCheck(false), isEditControl(true),
+    originalProc(0), lbiSync(0), multipleSelection(false),
+    xp(0), yp(0), width(0), height(0), data(0), lastTabStop(0),
+    updateLastData(0) {}
   wstring text;
   size_t data;
   int getDataInt() const { return (int)data; }
 
   int index;
-  bool changed() const {return text!=original;}
-  void ignore(bool ig) {ignoreCheck=ig;}
-  ListBoxInfo &isEdit(bool e) {isEditControl=e; return *this;}
-  HWND getControlWindow() const {return hWnd;}
+  bool changed() const { return text != original; }
+  void ignore(bool ig) { ignoreCheck = ig; }
+  ListBoxInfo& isEdit(bool e) { isEditControl = e; return *this; }
+  HWND getControlWindow() const final { return hWnd; }
 
-  void copyUserData(ListBoxInfo &userLBI) const;
-  ListBoxInfo &setSynchData(int *variable) {updateLastData = variable; return *this;}
-  int getWidth() const {return int(width);}
-  int getX() const {return xp;}
-  int getY() const {return yp;}
-  bool isCombo() const {return IsCombo;}
+  void copyUserData(ListBoxInfo& userLBI) const;
+  ListBoxInfo& setSynchData(int* variable) { updateLastData = variable; return *this; }
+  int getWidth() const { return int(width); }
+  int getHeight() const { return int(height); }
+  int getX() const { return xp; }
+  int getY() const { return yp; }
+  bool isCombo() const { return IsCombo; }
 private:
-  void syncData() const {if (updateLastData) *updateLastData = data;}
+  void syncData() const { if (updateLastData) *updateLastData = data; }
   bool IsCombo;
-  int *updateLastData;
-  
+  int* updateLastData;
+
   GUICALLBACK callBack;
-  
+
   int xp;
   int yp;
   double width;
@@ -350,18 +375,20 @@ private:
   size_t originalIdx;
   bool ignoreCheck; // True if changed-state should be ignored
 
-  map<size_t, int> data2Index;
+  unordered_map<size_t, int> data2Index;
+
+  uint64_t computed_hash = 0;
+  static uint64_t computeItemHash(const vector<pair<wstring, size_t>>& items);
 
   // Synchronize with other list box
   WNDPROC originalProc;
-  ListBoxInfo *lbiSync;
+  ListBoxInfo* lbiSync;
 
   friend LRESULT CALLBACK GetMsgProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam);
   friend class gdioutput;
 };
 
-class DataStore
-{
+class DataStore {
 public:
   DataStore() {
     data = 0;
@@ -371,8 +398,7 @@ public:
   string sdata;
 };
 
-class EventInfo : public BaseInfo
-{
+class EventInfo final: public BaseInfo {
 private:
   string origin;
   DWORD data;
@@ -386,17 +412,16 @@ public:
   EventInfo();
   GUICALLBACK callBack;
 
-  HWND getControlWindow() const {throw std::exception("Unsupported");}
+  HWND getControlWindow() const final {throw std::exception("Unsupported");}
 };
 
-class TimerInfo : public BaseInfo
-{
+class TimerInfo  final : public BaseInfo {
 private:
   static int globalTimerId;
   int timerId;
   DWORD dataInt;
   wstring dataString;
-  gdioutput *parent;
+  gdioutput* parent;
   HWND setWnd;
 public:
   ~TimerInfo();
@@ -404,11 +429,11 @@ public:
   TimerInfo(const TimerInfo&) = delete;
   TimerInfo& operator=(const TimerInfo&) = delete;
   int getId() const { return timerId; }
-  BaseInfo &setExtra(const wchar_t *e) {return BaseInfo::setExtra(e);}
-  BaseInfo &setExtra(int e) {return BaseInfo::setExtra(e);}
+  BaseInfo& setExtra(const wchar_t* e) { return BaseInfo::setExtra(e); }
+  BaseInfo& setExtra(int e) { return BaseInfo::setExtra(e); }
 
-  void setData(DWORD d, const wstring &s) {dataInt = d; dataString = s;}
-  const wstring &getDataString() {
+  void setData(DWORD d, const wstring& s) { dataInt = d; dataString = s; }
+  const wstring& getDataString() {
     return dataString;
   }
   DWORD getData() {
@@ -419,12 +444,10 @@ public:
   friend class gdioutput;
   friend void CALLBACK gdiTimerProc(HWND hWnd, UINT a, UINT_PTR ptr, DWORD b);
 
-  HWND getControlWindow() const {throw std::exception("Unsupported");}
+  HWND getControlWindow() const final { throw std::exception("Unsupported"); }
 };
 
-
-class InfoBox : public BaseInfo
-{
+class InfoBox final: public BaseInfo {
 public:
   InfoBox() : callBack(0), HasCapture(0), HasTCapture(0), TimeOut(0) {}
   wstring text;
@@ -439,7 +462,7 @@ public:
 
   DWORD TimeOut;
 
-  HWND getControlWindow() const {throw std::exception("Unsupported");}
+  HWND getControlWindow() const final {throw std::exception("Unsupported");}
 };
 
 typedef list<TextInfo> TIList;
@@ -450,6 +473,3 @@ struct ToolInfo {
   wstring tip;
   uintptr_t id;
 };
-
-
-#endif
diff --git a/code/generalresult.cpp b/code/generalresult.cpp
index 40a86e1..8e4140f 100644
--- a/code/generalresult.cpp
+++ b/code/generalresult.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -1007,6 +1007,12 @@ void DynamicResult::declareSymbols(DynamicMethods m, bool clear) const {
   parser.declareSymbol("InputNumber", "User input number", false);
   parser.declareSymbol("Shorten", "Number of shortenings", false);
 
+  parser.declareSymbol("DataA", "Extra assigned data (A)", false);
+  parser.declareSymbol("DataB", "Extra assigned data (B)", false);
+
+  parser.declareSymbol("ClassDataA", "Extra assigned class data (A)", false);
+  parser.declareSymbol("ClassDataB", "Extra assigned class data (B)", false);
+
   if (isRunner) {
     parser.declareSymbol("CardPunches", "Runner's card, punch codes", true);
     parser.declareSymbol("CardTimes", "Runner's card, punch times", true);
@@ -1040,6 +1046,9 @@ void DynamicResult::declareSymbols(DynamicMethods m, bool clear) const {
     parser.declareSymbol("RunnerCardTimes", "Punch times for each team member", true, true);
     parser.declareSymbol("RunnerCardControls", "Matched control ids (-1 for unmatched) for each team member", true, true);
 
+    parser.declareSymbol("RunnerDataA", "Extra assigned data (A) for each team member", true);
+    parser.declareSymbol("RunnerDataB", "Extra assigned data (B) for each team member", true);
+
     parser.declareSymbol("RunnerCourse", "Runner's course", true, true);
     parser.declareSymbol("RunnerSplitTimes", "Runner's split times", true, true);
 
@@ -1182,6 +1191,19 @@ void DynamicResult::prepareCommon(oAbstractRunner &runner, bool classResult) con
   parser.addSymbol("InputPoints", runner.getInputPoints());
   parser.addSymbol("Shorten", runner.getNumShortening());
 
+  parser.addSymbol("DataA", runner.getDCI().getInt("DataA"));
+  parser.addSymbol("DataB", runner.getDCI().getInt("DataB"));
+
+  pClass cls = runner.getClassRef(true);
+  if (cls) {
+    parser.addSymbol("ClassDataA", cls->getDCI().getInt("DataA"));
+    parser.addSymbol("ClassDataB", cls->getDCI().getInt("DataB"));
+  }
+  else {
+    parser.addSymbol("ClassDataA", 0);
+    parser.addSymbol("ClassDataB", 0);
+  }
+
   vector<RunnerStatus> inst;
   vector<int> times;
   vector<int> points;
@@ -1222,7 +1244,7 @@ void DynamicResult::prepareCalculations(oTeam &team, bool classResult) const {
   GeneralResult::prepareCalculations(team, classResult);
   prepareCommon(team, classResult);
   int nr = team.getNumRunners();
-  vector<int> status(nr), time(nr), start(nr), finish(nr), points(nr);
+  vector<int> status(nr), time(nr), start(nr), finish(nr), points(nr), dataA(nr), dataB(nr);
   vector< vector<int> > runnerOutputTimes(nr);
   vector< vector<int> > runnerOutputNumbers(nr);
 
@@ -1243,6 +1265,8 @@ void DynamicResult::prepareCalculations(oTeam &team, bool classResult) const {
 
       runnerOutputTimes[k] = res.outputTimes;
       runnerOutputNumbers[k] = res.outputNumbers;
+      dataA[k] = r->getDCI().getInt("DataA");
+      dataB[k] = r->getDCI().getInt("DataB");
     }
   }
   parser.removeSymbol("CardControls");
@@ -1270,6 +1294,9 @@ void DynamicResult::prepareCalculations(oTeam &team, bool classResult) const {
   parser.addSymbol("RunnerFinish", finish);
   parser.addSymbol("RunnerPoints", points);
 
+  parser.addSymbol("RunnerDataA", dataA);
+  parser.addSymbol("RunnerDataB", dataB);
+
   parser.addSymbol("PatrolRogainingScore", team.getRogainingPatrolPoints(false));
   parser.addSymbol("PatrolRogainingReduction", team.getRogainingPatrolReduction());
   parser.addSymbol("PatrolRogainingOvertime", team.getRogainingPatrolOvertime());
@@ -1416,7 +1443,7 @@ void DynamicResult::prepareCalculations(oRunner &runner, bool classResult) const
   parser.addSymbol("AgeLowLimit", lowAgeLimit);
   parser.addSymbol("AgeHighLimit", highAgeLimit);
 
-  parser.addSymbol("CheckTime", runner.getCheckTime());
+  parser.addSymbol("CheckTime", runner.getCheckTime() / timeConstSecond);
 }
 
 void DynamicResult::storeOutput(vector<int> &times, vector<int> &numbers) const {
diff --git a/code/generalresult.h b/code/generalresult.h
index 4601a1b..3f16f09 100644
--- a/code/generalresult.h
+++ b/code/generalresult.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/guihandler.h b/code/guihandler.h
index 93e9b03..82f780d 100644
--- a/code/guihandler.h
+++ b/code/guihandler.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -22,8 +22,7 @@
 
 ************************************************************************/
 
-#ifndef MEOS_GUI_HANDLER
-#define MEOS_GUI_HANDLER
+#pragma once
 
 enum GuiEventType {GUI_BUTTON=1, GUI_INPUT=2, GUI_LISTBOX=3,
   GUI_INFOBOX=4, GUI_CLEAR=5, GUI_INPUTCHANGE=6,
@@ -34,6 +33,7 @@ enum GuiEventType {GUI_BUTTON=1, GUI_INPUT=2, GUI_LISTBOX=3,
 
 class gdioutput;
 class BaseInfo;
+typedef int (*GUICALLBACK)(gdioutput* gdi, GuiEventType type, BaseInfo* data);
 
 class GuiHandler {
 public:
@@ -41,5 +41,3 @@ public:
   virtual ~GuiHandler() = 0 {}
   virtual void handle(gdioutput &gdi, BaseInfo &info, GuiEventType type) = 0;
 };
-
-#endif
diff --git a/code/image.cpp b/code/image.cpp
index c451f1a..73b0723 100644
--- a/code/image.cpp
+++ b/code/image.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -230,11 +230,11 @@ uint64_t Image::computeHash(const vector<uint8_t>& data) {
 }
 
 void Image::read_file(const wstring& filename, vector<uint8_t>& data) {
-  ifstream fin;
-  fin.open(filename, ios::binary);
-  fin.seekg(0, ios::end);
+  std::ifstream fin;
+  fin.open(filename, std::ios::binary);
+  fin.seekg(0, std::ios::end);
   int p2 = (int)fin.tellg();
-  fin.seekg(0, ios::beg);
+  fin.seekg(0, std::ios::beg);
   data.resize(p2);
   fin.read((char*)data.data(), data.size());
   fin.close();
diff --git a/code/image.h b/code/image.h
index f9f1d25..7072c7d 100644
--- a/code/image.h
+++ b/code/image.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/importformats.cpp b/code/importformats.cpp
index bf99387..76ee726 100644
--- a/code/importformats.cpp
+++ b/code/importformats.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -99,7 +99,7 @@ wstring ImportFormats::getExtension(ExportFormats fm) {
   case HTML:
     return L"html";
   }
-  throw exception();
+  throw std::exception();
 }
 
 
diff --git a/code/infoserver.cpp b/code/infoserver.cpp
index 57b5d0d..e0e3c0e 100644
--- a/code/infoserver.cpp
+++ b/code/infoserver.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/infoserver.h b/code/infoserver.h
index 6e6d2e0..3b4f22e 100644
--- a/code/infoserver.h
+++ b/code/infoserver.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -205,7 +205,7 @@ class InfoCompetitor : public InfoBaseCompetitor {
 class InfoTeam : public InfoBaseCompetitor {
   protected:
     // The outer level holds legs, the inner level holds (parallel/patrol) runners on each leg.
-    vector< vector<int> > competitors;
+    vector<vector<int>> competitors;
     public:
     bool synchronize(oTeam &t);
     void serialize(xmlbuffer &xml, bool diffOnly) const;
diff --git a/code/inthashmap.h b/code/inthashmap.h
index cea8183..28e1bc3 100644
--- a/code/inthashmap.h
+++ b/code/inthashmap.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/intkeymap.hpp b/code/intkeymap.hpp
index 86f4eb4..f149994 100644
--- a/code/intkeymap.hpp
+++ b/code/intkeymap.hpp
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/intkeymapimpl.hpp b/code/intkeymapimpl.hpp
index d3c544b..c5e20e3 100644
--- a/code/intkeymapimpl.hpp
+++ b/code/intkeymapimpl.hpp
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/iof30interface.cpp b/code/iof30interface.cpp
index 44a05b6..9ae3e96 100644
--- a/code/iof30interface.cpp
+++ b/code/iof30interface.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -35,6 +35,8 @@
 #include "meosException.h"
 #include "localizer.h"
 
+using namespace std;
+
 wstring &getFirst(wstring &inout, int maxNames);
 wstring getMeosCompectVersion();
 
@@ -2160,7 +2162,6 @@ pRunner IOF30Interface::readPersonEntry(gdioutput &gdi, xmlobject &xo, pTeam tea
   di.setInt("Paid", oe.interpretCurrency(paid, currency));
   di.setInt("Taxable", oe.interpretCurrency(fee, currency));
 
-
   // StartTimeAllocationRequest
   xmlobject sar = xo.getObject("StartTimeAllocationRequest");
   if (sar) {
@@ -2171,7 +2172,7 @@ pRunner IOF30Interface::readPersonEntry(gdioutput &gdi, xmlobject &xo, pTeam tea
       if (pRef) {
         wstring sid;
         pRef.getObjectString("Id", sid);
-        __int64 extId = oBase::converExtIdentifierString(sid);
+        int64_t extId = oBase::converExtIdentifierString(sid);
         int pid = oBase::idFromExtId(extId);
         pRunner rRef = oe.getRunner(pid, 0);
         if (rRef && rRef->getExtIdentifier() == extId) {
@@ -2417,17 +2418,20 @@ pRunner IOF30Interface::readPersonResult(gdioutput &gdi, pClass pc, xmlobject &x
         wstring s;
         for (auto &split : splits) {
           int code = split.getObjectInt("ControlCode");
-          int time = split.getObjectInt("Time");
+          wstring out;
+          split.getObjectString("Time", out);
+          double t = _wtof(out.c_str());
+          int time = int(t * timeConstSecond);
           split.getObjectString("status", s);
           if (s != L"missing")
-            card->addPunch(code, st + time, 0, 0);
+            card->addPunch(code, st + time, 0, 0, oCard::PunchOrigin::Original);
 
           if (s != L"additional")
             controls.push_back(code);
         }
 
         if (ft > 0)
-          card->addPunch(oPunch::PunchFinish, ft, 0, 0);
+          card->addPunch(oPunch::PunchFinish, ft, 0, 0, oCard::PunchOrigin::Original);
 
         //Update to SQL-source
         card->synchronize();
@@ -2461,25 +2465,35 @@ pRunner IOF30Interface::readPersonResult(gdioutput &gdi, pClass pc, xmlobject &x
   return r;
 }
 
-void IOF30Interface::readId(const xmlobject &person, int &pid, __int64 &extId) const {
+void IOF30Interface::readId(const xmlobject &person, int &pid, int64_t& extId, int64_t& extId2) const {
   wstring sid;
   pid = 0;
   extId = 0;
-  if (preferredIdProvider.empty()) {
+  extId2 = 0;
+  if (preferredIdProvider.first.empty()) {
     person.getObjectString("Id", sid);
   }
   else {
     xmlList sids;
-    wstring bsid;
+    wstring bsid, sid2;
     person.getObjects("Id", sids);
     for (auto &x : sids) {
       auto type = x.getAttrib("type");
-      if (type && type.getPtr() == preferredIdProvider) {
+      if (type && type.getPtr() == preferredIdProvider.first) {
         sid = x.getWStr();
       }
+      else if (type && type.getPtr() == preferredIdProvider.second) {
+        sid2 = x.getWStr();
+        if (!sid2.empty())
+          bsid = sid2;
+      }
       else if (bsid.empty())
         bsid = x.getWStr();
     }
+
+    if (!sid2.empty())
+      extId2 = oBase::converExtIdentifierString(sid2);
+
     if (sid.empty())
       pid = oBase::idFromExtId(oBase::converExtIdentifierString(bsid));
   }
@@ -2504,34 +2518,8 @@ pRunner IOF30Interface::readPerson(gdioutput &gdi, const xmlobject &person) {
     name = lang.tl("N.N.");
   }
   int pid = 0;
-  __int64 extId = 0;
-  readId(person, pid, extId);
-  /*
-  wstring sid;
-  int pid = 0;
-  __int64 extId = 0;
-  if (preferredIdProvider.empty()) {
-    person.getObjectString("Id", sid);
-  }
-  else {
-    xmlList sids;
-    wstring bsid;
-    person.getObjects("Id", sids);
-    for (auto &x : sids) {
-      auto type = x.getAttrib("type");
-      if (type && type.get() == preferredIdProvider) {
-        sid = x.getw();
-      }
-      else if (bsid.empty())
-        bsid = x.getw();
-    }
-    if (sid.empty())
-      pid = oBase::idFromExtId(oBase::converExtIdentifierString(bsid));
-  }
-  if (!sid.empty()) {
-    extId = oBase::converExtIdentifierString(sid);
-    pid = oBase::idFromExtId(extId);
-  }*/
+  int64_t extId = 0, extId2 = 0;
+  readId(person, pid, extId, extId2);
   pRunner r = 0;
 
   if (pid) {
@@ -2580,6 +2568,8 @@ pRunner IOF30Interface::readPerson(gdioutput &gdi, const xmlobject &person) {
   }
 
   r->setExtIdentifier(extId);
+  if (extId2 != 0)
+    r->setExtIdentifier2(extId2);
 
   oDataInterface DI=r->getDI();
   wstring tmp;
@@ -2602,7 +2592,7 @@ pClub IOF30Interface::readOrganization(gdioutput &gdi, const xmlobject &xclub, b
     return 0;
   wstring clubIdS;
   xclub.getObjectString("Id", clubIdS);
-  __int64 extId = oBase::converExtIdentifierString(clubIdS);
+  int64_t extId = oBase::converExtIdentifierString(clubIdS);
   int clubId = oBase::idFromExtId(extId);
   wstring name, shortName;
   xclub.getObjectString("Name", name);
@@ -2870,7 +2860,7 @@ void IOF30Interface::getAgeLevels(const vector<FeeInfo> &fees, const vector<int>
 int getAgeFromDate(const wstring &date) {
   int y = getThisYear();
   SYSTEMTIME st;
-  convertDateYMS(date, st, false);
+  convertDateYMD(date, st, false);
   if (st.wYear > 1900)
     return y - st.wYear;
   else
@@ -2887,8 +2877,8 @@ void IOF30Interface::FeeInfo::add(IOF30Interface::FeeInfo &fi) {
     fi.toTime = fromTime;
     if (!fi.toTime.empty()) {
       SYSTEMTIME st;
-      convertDateYMS(fi.toTime, st, false);
-      __int64 sec = SystemTimeToInt64TenthSecond(st);
+      convertDateYMD(fi.toTime, st, false);
+      int64_t sec = SystemTimeToInt64TenthSecond(st);
       sec -= timeConstHour;
       fi.toTime = convertSystemDate(Int64TenthSecondToSystemTime(sec));
     }
@@ -3183,7 +3173,7 @@ void IOF30Interface::getLocalDateTime(const string &date, const string &time,
   memset(&st, 0, sizeof(SYSTEMTIME));
 
   int atime = convertAbsoluteTimeISO(wTime);
-  int idate = convertDateYMS(date, st, true);
+  int idate = convertDateYMD(date, st, true);
   if (idate != -1) {
     if (zone == "Z" || zone == "z") {
       st.wHour = atime / timeConstHour;
@@ -3246,7 +3236,7 @@ void IOF30Interface::getLocalDateTime(const wstring &date, const wstring &time,
   memset(&st, 0, sizeof(SYSTEMTIME));
 
   const int atime = convertAbsoluteTimeISO(wTime);
-  int idate = convertDateYMS(date, st, true);
+  int idate = convertDateYMD(date, st, true);
   if (idate != -1) {
     if (zone == L"Z" || zone == L"z") {
       st.wHour = atime / timeConstHour;
@@ -3665,7 +3655,7 @@ void IOF30Interface::writeResult(xmlparser &xml, const oRunner &rPerson, const o
 }
 
 void IOF30Interface::writeFees(xmlparser &xml, const oRunner &r) const {
-  int cardFee = max(0, r.getDCI().getInt("CardFee"));
+  int cardFee = r.getRentalCardFee(false);
   bool paidCard = r.getDCI().getInt("Paid") >= cardFee;
   
   writeAssignedFee(xml, r, paidCard ? cardFee : 0);
@@ -3777,11 +3767,26 @@ void IOF30Interface::writeEvent(xmlparser &xml) {
 void IOF30Interface::writePerson(xmlparser &xml, const oRunner &r) {
   xml.startTag("Person");
 
-  if (r.getExtIdentifier() != 0)
-    xml.write("Id", r.getExtIdentifierString());
-  else if (r.getMainRunner()->getExtIdentifier() != 0)
-    xml.write("Id", r.getMainRunner()->getExtIdentifierString());
- 
+  if (externalIdTypes.empty()) {
+    if (r.getExtIdentifier() != 0)
+      xml.write("Id", r.getExtIdentifierString());
+    else if (r.getMainRunner()->getExtIdentifier() != 0)
+      xml.write("Id", r.getMainRunner()->getExtIdentifierString());
+  }
+  else if (!externalIdTypes[0].empty()) {
+    if (r.getExtIdentifier() != 0)
+      xml.write("Id", externalIdTypes[0], r.getExtIdentifierString());
+    else if (r.getMainRunner()->getExtIdentifier() != 0)
+      xml.write("Id", externalIdTypes[0], r.getMainRunner()->getExtIdentifierString());
+  }
+
+  if (externalIdTypes.size()>1 && !externalIdTypes[1].empty()) {
+    if (r.getExtIdentifier2() != 0)
+      xml.write("Id", externalIdTypes[1], r.getExtIdentifierString2());
+    else if (r.getMainRunner()->getExtIdentifier2() != 0)
+      xml.write("Id", externalIdTypes[1], r.getMainRunner()->getExtIdentifierString2());
+  }
+
   xml.startTag("Name");
   xml.write("Family", r.getFamilyName());
   xml.write("Given", r.getGivenName());
@@ -3804,7 +3809,7 @@ void IOF30Interface::writeClub(xmlparser &xml, const oClub &c, bool writeExtende
   else {
     xml.startTag("Organisation");
   }
-  __int64 id = c.getExtIdentifier();
+  int64_t id = c.getExtIdentifier();
   if (id != 0)
     xml.write("Id", c.getExtIdentifierString());
 
@@ -4143,8 +4148,9 @@ bool IOF30Interface::readXMLCompetitorDB(const xmlobject &xCompetitor,
   if (!person) return false;
   
   int pidI;
-  long long pid;
-  readId(person, pidI, pid);
+  int64_t pid;
+  int64_t ext2; // Ignored
+  readId(person, pidI, pid, ext2);
   
   xmlobject pname = person.getObject("Name");
   if (!pname) return false;
@@ -4693,6 +4699,19 @@ void IOF30Interface::getIdTypes(vector<string> &types) {
   types.insert(types.begin(), idProviders.begin(), idProviders.end());
 }
 
-void IOF30Interface::setPreferredIdType(const string &type) {
+void IOF30Interface::setPreferredIdType(const pair<string, string> &type) {
   preferredIdProvider = type;
+  externalIdTypes.clear();
+  if (!type.first.empty() || !type.second.empty()) {
+    string stype = "type";
+    if (!type.first.empty())
+      externalIdTypes.emplace_back(vector<pair<string, wstring>>({
+             make_pair(stype, gdioutput::widen(type.first)) }));
+    else
+      externalIdTypes.emplace_back();
+
+    if (!type.second.empty())
+      externalIdTypes.emplace_back(vector<pair<string, wstring>>({ 
+             make_pair(stype, gdioutput::widen(type.second)) }));
+  }
 }
diff --git a/code/iof30interface.h b/code/iof30interface.h
index 0e63b69..ccbb312 100644
--- a/code/iof30interface.h
+++ b/code/iof30interface.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -155,7 +155,8 @@ class IOF30Interface {
   bool matchStageFilter(const set<int> &stageFilter, const xmlList &races);
 
   set<string> idProviders;
-  string preferredIdProvider;
+  pair<string, string> preferredIdProvider;
+  vector<vector<pair<string, wstring>>> externalIdTypes;
 
   void readEvent(gdioutput &gdi, const xmlobject &xo,
                  map<int, vector<LegInfo> > &teamClassConfig);
@@ -259,7 +260,7 @@ class IOF30Interface {
 
   bool readXMLCompetitorDB(const xmlobject &xCompetitor,
                            bool onlyWithClub, 
-                           unordered_multimap<size_t, int> &duplicateCheck,
+                           std::unordered_multimap<size_t, int> &duplicateCheck,
                            int &duplicateCount);
   void writeXMLCompetitorDB(xmlparser &xml, const RunnerDB &db, const RunnerWDBEntry &rde) const;
 
@@ -297,7 +298,7 @@ class IOF30Interface {
   void writeFullCourse(xmlparser &xml, const oCourse &c,
                          const map<int, wstring> &ctrlId2ExportId);
 
-  void readId(const xmlobject &person, int &pid, __int64 &extId) const;
+  void readId(const xmlobject &person, int &pid, int64_t &extId, int64_t& extId2) const;
 
   set<int> readCrsIds;
 
@@ -322,7 +323,7 @@ public:
                                string &dateOut, string &timeOut);
 
   void getIdTypes(vector<string> &types);
-  void setPreferredIdType(const string &type);
+  void setPreferredIdType(const pair<string, string>&type);
 
   void readEventList(gdioutput &gdi, xmlobject &xo);
 
diff --git a/code/lib/mysqlpp_vc15.lib b/code/lib/mysqlpp_vc15.lib
deleted file mode 100644
index e32d155..0000000
Binary files a/code/lib/mysqlpp_vc15.lib and /dev/null differ
diff --git a/code/lib64_db/RestBed.lib b/code/lib64_db/RestBed.lib
new file mode 100644
index 0000000..71d9729
Binary files /dev/null and b/code/lib64_db/RestBed.lib differ
diff --git a/code/lib64_db/libharu.lib b/code/lib64_db/libharu.lib
new file mode 100644
index 0000000..3323cf6
Binary files /dev/null and b/code/lib64_db/libharu.lib differ
diff --git a/code/lib64_db/libmysql.lib b/code/lib64_db/libmysql.lib
new file mode 100644
index 0000000..e325a34
Binary files /dev/null and b/code/lib64_db/libmysql.lib differ
diff --git a/code/lib64_db/libpng.lib b/code/lib64_db/libpng.lib
new file mode 100644
index 0000000..c720d21
Binary files /dev/null and b/code/lib64_db/libpng.lib differ
diff --git a/code/lib64_db/zlibstat.lib b/code/lib64_db/zlibstat.lib
new file mode 100644
index 0000000..3edc5f4
Binary files /dev/null and b/code/lib64_db/zlibstat.lib differ
diff --git a/code/lib_db/mysqlpp_vc15.lib b/code/lib_db/mysqlpp_vc15.lib
deleted file mode 100644
index e32d155..0000000
Binary files a/code/lib_db/mysqlpp_vc15.lib and /dev/null differ
diff --git a/code/license.txt b/code/license.txt
index 21cefe3..aa9cd7e 100644
--- a/code/license.txt
+++ b/code/license.txt
@@ -7,7 +7,7 @@ Third Party Code. Additional copyright notices and license terms applicable to p
 All trademarks and registered trademarks mentioned herein are the property of their respective owners.  
 
 ------------------------------------
-Copyright 2007-2023 Melin Software HB.
+Copyright 2007-2024 Melin Software HB.
 
 ------------------------------------
 
diff --git a/code/listeditor.cpp b/code/listeditor.cpp
index d783c2d..638ef77 100644
--- a/code/listeditor.cpp
+++ b/code/listeditor.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -99,7 +99,7 @@ void ListEditor::show(TabBase *dst, gdioutput &gdi) {
   show(gdi);
 }
 
-int editListCB(gdioutput* gdi, int type, void* data);
+int editListCB(gdioutput* gdi, GuiEventType type, BaseInfo* data);
 
 void ListEditor::show(gdioutput &gdi) {
 
@@ -319,8 +319,7 @@ void ListEditor::renderListPreview(gdioutput &gdi) {
   }
 }
 
-int editListCB(gdioutput *gdi, int type, void *data)
-{
+int editListCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   void *clz = gdi->getData("ListEditorClz");
   ListEditor *le = (ListEditor *)clz;
   BaseInfo *bi = (BaseInfo *)data;
@@ -393,7 +392,7 @@ static void getPosFromId(int id, int &groupIx, int &lineIx, int &ix) {
   lineIx = lineIx % 100;
 }
 
-int ListEditor::editList(gdioutput &gdi, int type, BaseInfo &data) {
+int ListEditor::editList(gdioutput &gdi, GuiEventType type, BaseInfo &data) {
   int lineIx, groupIx, ix;
   
   if (type == GUI_EVENT) {
@@ -778,7 +777,7 @@ int ListEditor::editList(gdioutput &gdi, int type, BaseInfo &data) {
       
       gdi.fillRight();
       gdi.addSelection("OpenList", 250, 400, editListCB, L"Välj lista:");
-      gdi.addItem("OpenList", lists);
+      gdi.setItems("OpenList", lists);
       gdi.selectFirstItem("OpenList");
 
 
@@ -907,7 +906,7 @@ int ListEditor::editList(gdioutput &gdi, int type, BaseInfo &data) {
         gdi.getSelectedItem("SortOrder", mlbi);
         currentType = mlbi.data;
       }
-      gdi.addItem("SortOrder", types);
+      gdi.setItems("SortOrder", types);
       gdi.selectItemByData("SortOrder", currentType);
     }
     else if (lbi.id == "OpenList") {
@@ -1170,7 +1169,7 @@ void ListEditor::editListPost(gdioutput &gdi, const MetaListPost &mlp, int id) {
   gdi.fillRight();
   gdi.addSelection("Type", 290, 500, editListCB);
   gdi.dropLine(-1);
-  gdi.addItem("Type", types);
+  gdi.setItems("Type", types);
   gdi.selectItemByData("Type", currentType);
   gdi.addInput("Text", mlp.getText(), 16, editListCB,
                L"Egen text:", L"Använd symbolen X där MeOS ska fylla i typens data.");
@@ -1205,7 +1204,7 @@ void ListEditor::editListPost(gdioutput &gdi, const MetaListPost &mlp, int id) {
   currentList->getAlignTypes(mlp, types, currentType);
   sort(types.begin(), types.end());
   gdi.addSelection("AlignType", 290, 500, editListCB, L"Justera mot:");
-  gdi.addItem("AlignType", types);
+  gdi.setItems("AlignType", types);
   gdi.selectItemByData("AlignType", currentType);
 
   gdi.addInput("AlignText", mlp.getAlignText(), 16, 0, L"Text:");
@@ -1259,7 +1258,7 @@ void ListEditor::editListPost(gdioutput &gdi, const MetaListPost &mlp, int id) {
   mlp.getFonts(fonts, currentFont);
 
   gdi.addSelection("Fonts", 200, 500, 0, L"Format:");
-  gdi.addItem("Fonts", fonts);
+  gdi.setItems("Fonts", fonts);
   gdi.selectItemByData("Fonts", currentFont);
   maxX = max(maxX, gdi.getCX());
 
@@ -1473,7 +1472,7 @@ int ListEditor::selectImage(gdioutput &gdi, uint64_t imgId) {
   vector<pair<wstring, size_t>> img;
   image.enumerateImages(img);
   img.emplace(img.begin(), lang.tl("Ingen[bild]"), -2);
-  gdi.addItem("Image", img);
+  gdi.setItems("Image", img);
 
   int ix = image.getEnumerationIxFromId(imgId);
   if (ix >= 0)
@@ -1665,7 +1664,7 @@ bool ListEditor::legStageTypeIndex(gdioutput &gdi, EPostType type, int leg) {
       for (int j = 1; j <= 50; j++) {
         items.emplace_back(lang.tl("Sträcka X#" + itos(j)), j);
       }
-      gdi.addItem("LegSel", items);
+      gdi.setItems("LegSel", items);
       if (leg >= -1)
         gdi.selectItemByData("LegSel", leg + 1);
       else if (leg == -2)
@@ -1676,7 +1675,7 @@ bool ListEditor::legStageTypeIndex(gdioutput &gdi, EPostType type, int leg) {
       for (int j = 1; j < 20; j++) {
         items.emplace_back(lang.tl("Etapp X#" + itos(j)), j);
       }
-      gdi.addItem("LegSel", items);
+      gdi.setItems("LegSel", items);
       gdi.selectItemByData("LegSel", leg >= 0 ? leg + 1 : -2);
     }
   } 
@@ -1754,26 +1753,26 @@ void ListEditor::editListProp(gdioutput &gdi, bool newList) {
 
   list.getBaseType(types, currentType);
   gdi.addSelection("BaseType", 150, 400, 0, L"Listtyp:");
-  gdi.addItem("BaseType", types);
+  gdi.setItems("BaseType", types);
   gdi.selectItemByData("BaseType", currentType);
   gdi.autoGrow("BaseType");
   
   list.getResultModule(*oe, types, currentType);
   gdi.addSelection("ResultType", 150, 400, editListCB, L"Resultatuträkning:");
-  gdi.addItem("ResultType", types);
+  gdi.setItems("ResultType", types);
   gdi.autoGrow("ResultType");
   gdi.selectItemByData("ResultType", currentType);
 
   list.getSortOrder(false, types, currentType);
   gdi.addSelection("SortOrder", 170, 400, 0, L"Global sorteringsordning:");
-  gdi.addItem("SortOrder", types);
+  gdi.setItems("SortOrder", types);
   gdi.autoGrow("SortOrder");
   
   gdi.selectItemByData("SortOrder", currentType);
 
   list.getSubType(types, currentType);
   gdi.addSelection("SubType", 150, 400, editListCB, L"Sekundär typ:");
-  gdi.addItem("SubType", types);
+  gdi.setItems("SubType", types);
   gdi.selectItemByData("SubType", currentType);
   oListInfo::EBaseType subType = oListInfo::EBaseType(currentType);
 
@@ -1849,7 +1848,7 @@ void ListEditor::editListProp(gdioutput &gdi, bool newList) {
   for (int k = 0; k < 4; k++) {
     string id("Font" + itos(k));
     gdi.addCombo(id, 200, 300, 0, expl[k]);
-    gdi.addItem(id, fonts);
+    gdi.setItems(id, fonts);
 
     gdi.setText(id, list.getFontFace(k));
     gdi.setCX(gdi.getCX()+20);
@@ -1961,7 +1960,7 @@ void ListEditor::splitPrintList(gdioutput& gdi) {
   for (int i = 60; i <= 100; i += 10)
     items.emplace_back(itow(i), i);
   items.emplace_back(lang.tl("Alla"), 1000);
-  gdi.addItem("NumResult", items);
+  gdi.setItems("NumResult", items);
   gdi.selectItemByData("NumResult", isSP ? sp->numClassResults : 3);
 
   statusSplitPrint(gdi, isSP);
diff --git a/code/listeditor.h b/code/listeditor.h
index b3acedc..2fc4c87 100644
--- a/code/listeditor.h
+++ b/code/listeditor.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -51,7 +51,7 @@ private:
   const wchar_t *getIndexDescription(EPostType type);
   wstring lastShownExampleText;
   void showLine(gdioutput &gdi, const vector<MetaListPost> &line, int ix) const;
-  int editList(gdioutput &gdi, int type, BaseInfo &data);
+  int editList(gdioutput &gdi, GuiEventType type, BaseInfo &data);
   void updateType(int iType, gdioutput &gdi);
 
   bool saveListPost(gdioutput &gdi, MetaListPost &mlp);
@@ -118,5 +118,5 @@ public:
   MetaList *getCurrentList() const {return currentList;};
   void handleAutoComplete(gdioutput &gdi, AutoCompleteInfo &info) final;
 
-  friend int editListCB(gdioutput*, int, void *);
+  friend int editListCB(gdioutput*, GuiEventType type, BaseInfo* data);
 };
diff --git a/code/lists24.png b/code/lists24.png
new file mode 100644
index 0000000..e32ce42
Binary files /dev/null and b/code/lists24.png differ
diff --git a/code/liveresult.cpp b/code/liveresult.cpp
index fcad772..a7c9527 100644
--- a/code/liveresult.cpp
+++ b/code/liveresult.cpp
@@ -1,6 +1,6 @@
 /********************i****************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/liveresult.h b/code/liveresult.h
index a6e7ca3..1783254 100644
--- a/code/liveresult.h
+++ b/code/liveresult.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/localizer.cpp b/code/localizer.cpp
index 4f6dc4a..2e1a8c3 100644
--- a/code/localizer.cpp
+++ b/code/localizer.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2022 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -29,6 +29,8 @@
 #include "oFreeImport.h"
 #include "meos_util.h"
 
+using namespace std;
+
 const string &toUTF8(const wstring &winput) {
   string &output = StringCache::getInstance().get();
   size_t alloc = winput.length()*2;
@@ -214,10 +216,14 @@ const wstring &LocalizerImpl::translate(const wstring &str, bool &found)
     return value[i];
   }
 
+  auto isDigit = [](wchar_t c) {
+    return c >= '0' && c <= '9';
+  };
+
 
   wchar_t last = str[len-1];
   if (last != ':' && last != '.' && last != ' ' && last != ',' &&
-      last != ';' && last != '<' && last != '>' && last != '-' && last != 0x96) {
+      last != ';' && last != '<' && last != '>' && last != '-' && last != 0x96 && !isDigit(last)) {
 #ifdef _DEBUG
     if (str.length()>1)
       unknown[str] = L"";
@@ -234,7 +240,7 @@ const wstring &LocalizerImpl::translate(const wstring &str, bool &found)
   while(pos>0) {
     wchar_t last = str[pos];
     if (last != ':' && last != ' ' && last != ',' && last != '.' &&
-        last != ';' && last != '<' && last != '>' && last != '-' && last != 0x96)
+        last != ';' && last != '<' && last != '>' && last != '-' && last != 0x96 && !isDigit(last))
       break;
 
     pos = str.find_last_not_of(last, pos);
diff --git a/code/localizer.h b/code/localizer.h
index ec247ce..aa2ddb3 100644
--- a/code/localizer.h
+++ b/code/localizer.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/machinecontainer.cpp b/code/machinecontainer.cpp
index 66ce905..9c1d665 100644
--- a/code/machinecontainer.cpp
+++ b/code/machinecontainer.cpp
@@ -1,3 +1,25 @@
+/************************************************************************
+    MeOS - Orienteering Software
+    Copyright (C) 2009-2024 Melin Software HB
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License fro more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+    Melin Software HB - software@melin.nu - www.melin.nu
+    Eksoppsvägen 16, SE-75646 UPPSALA, Sweden
+
+************************************************************************/
+
 #include "StdAfx.h"
 
 #include "machinecontainer.h"
diff --git a/code/machinecontainer.h b/code/machinecontainer.h
index 3a4ec0b..f072a38 100644
--- a/code/machinecontainer.h
+++ b/code/machinecontainer.h
@@ -1,4 +1,25 @@
 #pragma once
+/************************************************************************
+    MeOS - Orienteering Software
+    Copyright (C) 2009-2024 Melin Software HB
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License fro more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+    Melin Software HB - software@melin.nu - www.melin.nu
+    Eksoppsv�gen 16, SE-75646 UPPSALA, Sweden
+
+************************************************************************/
 
 #include <string>
 #include <map>
diff --git a/code/meos.cpp b/code/meos.cpp
index afe1768..63f5f2b 100644
--- a/code/meos.cpp
+++ b/code/meos.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -114,7 +114,8 @@ extern const wchar_t *szToolClass;
 
 HHOOK g_hhk; //- handle to the hook procedure.
 
-HWND hMainTab=NULL;
+HWND hMainTab = nullptr;
+HIMAGELIST imageList = nullptr;
 
 list<TabObject> *tabList = nullptr;
 void scrollVertical(gdioutput *gdi, int yInc, HWND hWnd);
@@ -198,7 +199,7 @@ int APIENTRY WinMain(HINSTANCE hInstance,
   int       nCmdShow)
 {
   hInst = hInstance; // Store instance handle in our global variable
-    
+  
   atexit(dumpLeaks);	//
   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
 
@@ -284,6 +285,7 @@ int APIENTRY WinMain(HINSTANCE hInstance,
 
   try {
     gEvent = new oEvent(*gdi_main);
+    gEvent->setMainEvent();
   }
   catch (meosException &ex) {
     gdi_main->alert(wstring(L"Failed to create base event: ") + ex.wwhat());
@@ -314,6 +316,7 @@ int APIENTRY WinMain(HINSTANCE hInstance,
   lang.get().addLangResource(L"Español", L"111");
   lang.get().addLangResource(L"Russian", L"107");
   lang.get().addLangResource(L"Ukrainian", L"112");
+  lang.get().addLangResource(L"Portuguese", L"113");
 
   if (fileExists(L"extra.lng")) {
     lang.get().addLangResource(L"Extraspråk", L"extra.lng");
@@ -416,17 +419,6 @@ int APIENTRY WinMain(HINSTANCE hInstance,
   MyRegisterClass(hInstance);
   registerToolbar(hInstance);
 
-  string encoding = gdi_main->narrow(lang.tl("encoding"));
-/*FontEncoding interpetEncoding(const string &enc) {
-  if (enc == "RUSSIAN")
-    return Russian;
-  else if (enc == "EASTEUROPE")
-    return EastEurope;
-  else if (enc == "HEBREW")
-    return Hebrew;
-  else
-    return ANSI;
-}*/
   int defSize = 0;
   {
     RECT desktop;
@@ -463,6 +455,8 @@ int APIENTRY WinMain(HINSTANCE hInstance,
   gdi_main->init(hWndWorkspace, hWndMain, hMainTab);
   gdi_main->getTabs().get(TCmpTab)->loadPage(*gdi_main);
 
+  image.loadImage(IDI_MEOSEDIT, Image::ImageMethod::Default);
+
   autoTask = new AutoTask(hWndMain, *gEvent, *gdi_main);
 
   autoTask->setTimers();
@@ -946,48 +940,9 @@ const string &getLastExtraWindow() {
   else
     return gdi_extra.back()->getTag();
 }
-//
-//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
-//
-//  PURPOSE:  Processes messages for the main window.
-//
-//  WM_COMMAND	- process the application menu
-//  WM_PAINT	- Paint the main window
-//  WM_DESTROY	- post a quit message and return
-//
-//
-/*
-void CallBack(gdioutput *gdi, int type, void *data)
-{
-  ButtonInfo bi=*(ButtonInfo* )data;
-
-  string t=gdi->getText("input");
-  gdi->ClearPage();
-
-  gdi->addButton(bi.text+" *"+t, bi.xp+5, bi.yp+30, "", CallBack);
-}
-
-void CallBackLB(gdioutput *gdi, int type, void *data)
-{
-  ListBoxInfo lbi=*(ListBoxInfo* )data;
-
-  gdi->setText("input", lbi.text);
-}
-
-void CallBackINPUT(gdioutput *gdi, int type, void *data)
-{
-  InputInfo lbi=*(InputInfo* )data;
-
-  MessageBox(NULL, "MB_OK", 0, MB_OK);
-  //gdi->setText("input", lbi.text);
-}*/
 
 void InsertSICard(gdioutput &gdi, SICard &sic);
 
-#define TabCtrl_InsertItemW(hwnd, iItem, pitem)   \
-    (int)SNDMSG((hwnd), TCM_INSERTITEMW, (WPARAM)(int)(iItem), (LPARAM)(const TC_ITEM *)(pitem))
-
-//static int xPos=0, yPos=0;
 void createTabs(bool force, bool onlyMain, bool skipTeam, bool skipSpeaker,
                 bool skipEconomy, bool skipLists,
                 bool skipRunners, bool skipCourses, bool skipControls)
@@ -1025,9 +980,9 @@ void createTabs(bool force, bool onlyMain, bool skipTeam, bool skipSpeaker,
       to = &*it;
     }
   }
-
-  SendMessage(hMainTab, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT), 0);
-  int id=0;
+  if (gdi_main)
+    gdi_main->updateTabFont();
+  int id = 0;
   TabCtrl_DeleteAllItems(hMainTab);
   for (list<TabObject>::iterator it=tabList->begin();it!=tabList->end();++it) {
     it->setId(-1);
@@ -1056,26 +1011,27 @@ void createTabs(bool force, bool onlyMain, bool skipTeam, bool skipSpeaker,
     if (skipLists && (it->getType() == typeid(TabList) || it->getType() == typeid(TabAuto)))
       continue;
 
-    TCITEMW ti;
-    //char bf[256];
-    //strcpy_s(bf, lang.tl(it->name).c_str());
+    TCITEM ti;
     ti.pszText=(LPWSTR)lang.tl(it->name).c_str();
-    ti.mask=TCIF_TEXT;
+    ti.mask = TCIF_TEXT;
+    if (it->imageId >= 0)
+      ti.mask |= TCIF_IMAGE;
+
+    ti.iImage = it->imageId;
+
     it->setId(id++);
 
-    TabCtrl_InsertItemW(hMainTab, it->id, &ti);
+    TabCtrl_InsertItem(hMainTab, it->id, &ti);
   }
 
   if (to && (to->id)>=0)
     TabCtrl_SetCurSel(hMainTab, to->id);
 }
 
-void hideTabs()
-{
+void hideTabs() {
   TabCtrl_DeleteAllItems(hMainTab);
 }
 
-
 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 {
   int wmId, wmEvent;
@@ -1087,31 +1043,47 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
   {
     case WM_CREATE:
 
-      tabList->push_back(TabObject(gdi_main->getTabs().get(TCmpTab), "Tävling"));
-      tabList->push_back(TabObject(gdi_main->getTabs().get(TRunnerTab), "Deltagare"));
-      tabList->push_back(TabObject(gdi_main->getTabs().get(TTeamTab), "Lag(flera)"));
-      tabList->push_back(TabObject(gdi_main->getTabs().get(TListTab), "Listor"));
+      tabList->emplace_back(gdi_main->getTabs().get(TCmpTab), "Tävling", 10);
+      tabList->emplace_back(gdi_main->getTabs().get(TRunnerTab), "Deltagare", 6);
+      tabList->emplace_back(gdi_main->getTabs().get(TTeamTab), "Lag(flera)", 7);
+      tabList->emplace_back(gdi_main->getTabs().get(TListTab), "Listor", 5);
       {
         TabAuto *ta = (TabAuto *)gdi_main->getTabs().get(TAutoTab);
-        tabList->push_back(TabObject(ta, "Automater"));
+        tabList->emplace_back(ta, "Automater", 4);
         TabAuto::tabAutoRegister(ta);
       }
-      tabList->push_back(TabObject(gdi_main->getTabs().get(TSpeakerTab), "Speaker"));
-      tabList->push_back(TabObject(gdi_main->getTabs().get(TClassTab), "Klasser"));
-      tabList->push_back(TabObject(gdi_main->getTabs().get(TCourseTab), "Banor"));
-      tabList->push_back(TabObject(gdi_main->getTabs().get(TControlTab), "Kontroller"));
-      tabList->push_back(TabObject(gdi_main->getTabs().get(TClubTab), "Klubbar"));
+      tabList->emplace_back(gdi_main->getTabs().get(TSpeakerTab), "Speaker", 3);
+      tabList->emplace_back(gdi_main->getTabs().get(TClassTab), "Klasser", 0);
+      tabList->emplace_back(gdi_main->getTabs().get(TCourseTab), "Banor", 1);
+      tabList->emplace_back(gdi_main->getTabs().get(TControlTab), "Kontroller", 2);
+      tabList->emplace_back(gdi_main->getTabs().get(TClubTab), "Klubbar", 8);
 
-      tabList->push_back(TabObject(gdi_main->getTabs().get(TSITab), "SportIdent"));
+      tabList->emplace_back(gdi_main->getTabs().get(TSITab), "SportIdent", 9);
 
       INITCOMMONCONTROLSEX ic;
 
       ic.dwSize=sizeof(ic);
       ic.dwICC=ICC_TAB_CLASSES ;
       InitCommonControlsEx(&ic);
-      hMainTab=CreateWindowEx(0, WC_TABCONTROL, L"tabs", WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS, 0, 0, 300, 20, hWnd, 0, hInst, 0);
-      createTabs(true, true, false, false, false, false, false, false, false);
+      hMainTab = CreateWindowEx(0, WC_TABCONTROL, L"tabs", WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS, 0, 0, 300, 20, hWnd, 0, hInst, 0);
+      imageList = ImageList_Create(24, 24, ILC_COLOR32, 1, 1);
+      {
+        
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSCLASS24, Image::ImageMethod::Default), nullptr);
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSCOURSE24, Image::ImageMethod::Default), nullptr);
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSCONTROL24, Image::ImageMethod::Default), nullptr);
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSANNOUNCER24, Image::ImageMethod::Default), nullptr);
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSSERVICES24, Image::ImageMethod::Default), nullptr);
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSLIST24, Image::ImageMethod::Default), nullptr);
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSRUNNER24, Image::ImageMethod::Default), nullptr);
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSTEAM24, Image::ImageMethod::Default), nullptr);
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSCLUBS24, Image::ImageMethod::Default), nullptr);
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSCARD24, Image::ImageMethod::Default), nullptr);
+        ImageList_Add(imageList, image.loadImage(IDI_MEOSCOMPETITION24, Image::ImageMethod::Default), nullptr);
 
+        TabCtrl_SetImageList(hMainTab, imageList);
+      }
+      createTabs(true, true, false, false, false, false, false, false, false);
       SetTimer(hWnd, 4, 10000, 0); //Connection check
       break;
 
@@ -1121,13 +1093,19 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
       }
       break;
 
-    case WM_SIZE:
-      MoveWindow(hMainTab, 0,0, LOWORD(lParam), 30, 1);
-      MoveWindow(hWndWorkspace, 0, 30, LOWORD(lParam), HIWORD(lParam)-30, 1);
+    case WM_SIZE: {
+      int h = 30;
+      if (gdi_main) {
+        h = max(h, gdi_main->getFontHeight(0, L"") + gdi_main->scaleLength(6));
+      }
+
+      MoveWindow(hMainTab, 0, 0, LOWORD(lParam), h, 1);
+      MoveWindow(hWndWorkspace, 0, h, LOWORD(lParam), HIWORD(lParam) - h, 1);
 
       RECT rc;
       GetClientRect(hWndWorkspace, &rc);
       PostMessage(hWndWorkspace, WM_SIZE, wParam, MAKELONG(rc.right, rc.bottom));
+    }
       break;
 
     case WM_WINDOWPOSCHANGED:
diff --git a/code/meos.rc b/code/meos.rc
index c2f3092..e18ad33 100644
--- a/code/meos.rc
+++ b/code/meos.rc
@@ -47,12 +47,48 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_DEFAULT
 
 IDB_ECO                 BITMAP                  "bmp00001.bmp"
 
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// PNG
+//
+
+IDI_SPLASHIMAGE         PNG                     "meos.png"
+
+IDI_MEOSIMAGE           PNG                     "title.png"
+
+IDI_MEOSINFO            PNG                     "info24.png"
+
+IDI_MEOSWARN            PNG                     "warn24.png"
+
+IDI_MEOSEDIT            PNG                     "edit.png"
+
+IDI_MEOSCLASS24         PNG                     "class24.png"
+
+IDI_MEOSCOURSE24        PNG                     "course24.png"
+
+IDI_MEOSCONTROL24       PNG                     "ctrl24.png"
+
+IDI_MEOSANNOUNCER24     PNG                     "announcer24.png"
+
+IDI_MEOSSERVICES24      PNG                     "services24.png"
+
+IDI_MEOSLIST24          PNG                     "lists24.png"
+
+IDI_MEOSRUNNER24        PNG                     "runner24.png"
+
+IDI_MEOSTEAM24          PNG                     "team24.png"
+
+IDI_MEOSCLUBS24         PNG                     "clubs24.png"
+
+IDI_MEOSCARD24          PNG                     "readout24.png"
+
+IDI_MEOSCOMPETITION24   PNG                     "competition24.png"
+
 #endif    // Neutral (Default) resources
 /////////////////////////////////////////////////////////////////////////////
 
-IDI_SPLASHIMAGE PNG "meos.png"
-IDI_MEOSIMAGE PNG "title.png"
-IDI_MEOSINFO PNG "info24.png"
+
 /////////////////////////////////////////////////////////////////////////////
 // English (United States) resources
 
@@ -150,8 +186,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 3,8,0,1
- PRODUCTVERSION 3,8,0,1
+ FILEVERSION 4,0,0,1
+ PRODUCTVERSION 4,0,0,1
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -168,12 +204,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "Melin Software HB"
             VALUE "FileDescription", "meos"
-            VALUE "FileVersion", "3.8.0.1"
+            VALUE "FileVersion", "4.0.0.1"
             VALUE "InternalName", "meos"
-            VALUE "LegalCopyright", "Copyright � 2007-2022"
-            VALUE "OriginalFilename", "meos.exe"
+            VALUE "LegalCopyright", "Copyright � 2007-2024"
+            VALUE "OriginalFilename", "MeOS.exe"
             VALUE "ProductName", "  meos"
-            VALUE "ProductVersion", "3.8.0.1"
+            VALUE "ProductVersion", "4.0.0.1"
         END
     END
     BLOCK "VarFileInfo"
diff --git a/code/meos_dpi_manifest.xml b/code/meos_dpi_manifest.xml
new file mode 100644
index 0000000..2fd162a
--- /dev/null
+++ b/code/meos_dpi_manifest.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+  <asmv3:application>
+    <asmv3:windowsSettings>
+      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
+    </asmv3:windowsSettings>
+  </asmv3:application>
+  
+  <assemblyIdentity
+    version="1.0.0.0"
+    processorArchitecture="*"
+    name="Melin Software.MeOS"
+    type="win32"
+  />
+  <description>MeOS - Much Easier Orienteering System</description>
+  <dependency>
+    <dependentAssembly>
+        <assemblyIdentity
+            type="win32"
+            name="Microsoft.Windows.Common-Controls"
+            version="6.0.0.0"
+            processorArchitecture="*"
+            publicKeyToken="6595b64144ccf1df"
+            language="*"
+        />
+    </dependentAssembly>
+</dependency>
+</assembly>
diff --git a/code/meos_util.cpp b/code/meos_util.cpp
index 4510140..cea4f15 100644
--- a/code/meos_util.cpp
+++ b/code/meos_util.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -29,6 +29,8 @@
 #include "meosexception.h"
 #include <WinInet.h>
 
+using namespace std;
+
 StringCache globalStringCache;
 
 namespace MeOSUtil {
@@ -252,12 +254,12 @@ wstring formatDate(int m, bool useIsoFormat) {
   return bf;
 }
 
-int convertDateYMS(const wstring &m, SYSTEMTIME &st, bool checkValid) {
+int convertDateYMD(const wstring &m, SYSTEMTIME &st, bool checkValid) {
   string ms(m.begin(), m.end());
-  return convertDateYMS(ms, st, checkValid);
+  return convertDateYMD(ms, st, checkValid);
 }
 //Absolute time string to SYSTEM TIME
-int convertDateYMS(const string& m, SYSTEMTIME& st, bool checkValid) {
+int convertDateYMD(const string& m, SYSTEMTIME& st, bool checkValid) {
   memset(&st, 0, sizeof(st));
 
   if (m.length() == 0)
@@ -356,16 +358,16 @@ int convertDateYMS(const string& m, SYSTEMTIME& st, bool checkValid) {
 }
 
 //Absolute time string to absolute time int
-int convertDateYMS(const string &m, bool checkValid)
+int convertDateYMD(const string &m, bool checkValid)
 {
   SYSTEMTIME st;
-  return convertDateYMS(m, st, checkValid);
+  return convertDateYMD(m, st, checkValid);
 }
 
-int convertDateYMS(const wstring &m, bool checkValid)
+int convertDateYMD(const wstring &m, bool checkValid)
 {
   SYSTEMTIME st;
-  return convertDateYMS(m, st, checkValid);
+  return convertDateYMD(m, st, checkValid);
 }
 
 bool myIsSpace(wchar_t b) {
@@ -829,6 +831,47 @@ const wstring &unsplit(const vector<wstring> &split_vector, const wstring &separ
   return line;
 }
 
+const wstring &limitText(const wstring& tIn, size_t numChar) {
+  wstring& out = StringCache::getInstance().wget();
+  out.clear();
+  const auto L = tIn.length();
+  //if (L < numChar)
+  //  out = tIn;
+
+  int spacePos = -1;
+  int outP = 0;
+  int i = 0;
+  for (; i < L && outP < numChar-1; i++) {
+    wchar_t c = tIn[i];
+    if (c == '\n' || c == '\r' || c == '\t')
+      c = ' ';
+
+    if (c==' ' && spacePos == outP)
+      continue;  // Skip duplicate space
+
+    out.push_back(c);
+    outP++;
+    if (iswspace(c))
+      spacePos = outP;
+  }
+
+  if (i < L) {
+    if (spacePos <= 2 || spacePos < signed(numChar) - 10)
+      spacePos = numChar - 4;
+    out = out.substr(0, spacePos-1) + L"\u2026";
+  }
+
+  return out;
+}
+
+wstring ensureEndingColon(const wstring& text) {
+  if (text.empty() || text[text.length() - 1] == ':')
+    return text;
+  
+  return text + L":";
+}
+
+
 const wstring &makeDash(const wstring &t) {
   return makeDash(t.c_str());
 }
@@ -919,16 +962,10 @@ string itos(uint64_t i)
   return bf;
 }
 
-
-bool filterMatchString(const string &c, const char *filt_lc)
-{
-  if (filt_lc[0] == 0)
-    return true;
-  char key[2048];
-  strcpy_s(key, c.c_str());
-  CharLowerBuffA(key, c.length());
-
-  return strstr(key, filt_lc)!=0;
+void prepareMatchString(wchar_t* data_c, int size) {
+  CharLowerBuff(data_c, size);
+  for (int j = 0; j < size; j++)
+    data_c[j] = toLowerStripped(data_c[j]);
 }
 
 bool filterMatchString(const wstring &c, const wchar_t *filt_lc, int &score) {
@@ -937,7 +974,11 @@ bool filterMatchString(const wstring &c, const wchar_t *filt_lc, int &score) {
     return true;
   wchar_t key[2048];
   wcscpy_s(key, c.c_str());
-  CharLowerBuff(key, c.length());
+  int cl = c.length();
+  CharLowerBuff(key, cl);
+  for (int j = 0; j < cl; j++)
+    key[j] = toLowerStripped(key[j]);
+
   bool match = wcsstr(key, filt_lc) != 0;
   if (match) {
     while (filt_lc[score] && key[score] && filt_lc[score] == key[score])
@@ -1259,14 +1300,14 @@ int toLowerStripped(wchar_t c) {
     return c;
 
   static wchar_t *map = 0;
-  if (map == 0) {
+  if (map == nullptr) {
     map = new wchar_t[65536];
     for (int i = 0; i < 65536; i++)
       map[i] = i;
 
-    setChar(map, L'Å', L'å');
-    setChar(map, L'Ä', L'ä');
-    setChar(map, L'Ö', L'ö');
+    setChar(map, L'Å', L'a');
+    setChar(map, L'Ä', L'a');
+    setChar(map, L'Ö', L'o');
 
     setChar(map, L'É', L'e');
     setChar(map, L'é', L'e');
@@ -1289,6 +1330,8 @@ int toLowerStripped(wchar_t c) {
     setChar(map, L'ñ', L'n');
     setChar(map, L'Ñ', L'n');
 
+    setChar(map, L'ä', L'a');
+    setChar(map, L'å', L'a');
     setChar(map, L'á', L'a');
     setChar(map, L'Á', L'a');
     setChar(map, L'à', L'a');
@@ -1315,19 +1358,29 @@ int toLowerStripped(wchar_t c) {
     setChar(map, L'Õ', L'o');
     setChar(map, L'ô', L'o');
     setChar(map, L'Ô', L'o');
+    setChar(map, L'ö', L'o');
 
     setChar(map, L'ý', L'y');
     setChar(map, L'Ý', L'Y');
     setChar(map, L'ÿ', L'y');
+    
+    setChar(map, L'Æ', L'a');
+    setChar(map, L'æ', L'a');
 
-    setChar(map, L'Æ', L'ä');
-    setChar(map, L'æ', L'ä');
-
-    setChar(map, L'Ø', L'ö');
-    setChar(map, L'ø', L'ö');
+    setChar(map, L'Ø', L'o');
+    setChar(map, L'ø', L'o');
 
     setChar(map, L'Ç', L'c');
     setChar(map, L'ç', L'c');
+
+    wstring srcEx = L"Ă㥹ĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħĨĩĪīĬĭĮįİıIJijĴĵĶķĸĹĺĻĽľĿŀŁł"
+                    L"ŃńŅņŇňʼnŊŋŌōŎŏŐőŒœŔŕŖŗŘřŚśŜŝŞşŠšŢţŤťŦŧŨũŪūŬŭŮůŰűŲųŴŵŶŷŸŹźŻżŽž";
+    wstring dstEx = L"aaaaccccccccddddeeeeeeeeeegggggggghhhhiiiiiiiiiijjjjkkklllllllll"
+                    L"nnnnnnnnnooooooaarrrrrrssssssssttttttuuuuuuuuuuuuwwyyyzzzzzz";
+
+    assert(srcEx.size() == dstEx.size());
+    for (int j = 0; j < srcEx.size(); j++)
+      setChar(map, srcEx[j], dstEx[j]);
   }
   int a = map[c];
   return a;
@@ -2013,7 +2066,7 @@ void capitalize(wstring &str) {
 
 bool checkValidDate(const wstring &date) {
   SYSTEMTIME st;
-  if (convertDateYMS(date, st, false) <= 0)
+  if (convertDateYMD(date, st, false) <= 0)
     return false;
 
   st.wHour = 12;
@@ -2036,7 +2089,7 @@ int getTimeZoneInfo(const wstring &date) {
   wcscpy_s(lastDate, 16, date.c_str());
 //  TIME_ZONE_INFORMATION tzi;
   SYSTEMTIME st;
-  convertDateYMS(date, st, false);
+  convertDateYMD(date, st, false);
   st.wHour = 12;
   SYSTEMTIME utc;
   if (!TzSpecificLocalTimeToSystemTime(0, &st, &utc)) {
@@ -2211,7 +2264,7 @@ void capitalizeWords(wstring &str) {
     wchar_t c = str[i];
     if (init && c >= 'a' && c <= 'z' && !noCapitalize(str, i))
       str[i] = c + ('A' - 'a');
-    init = iswspace(c) != 0;
+    init = iswspace(c) != 0 || c == '/' || c == '-';
   }
 }
 
diff --git a/code/meos_util.h b/code/meos_util.h
index 3195ca5..36fe7d2 100644
--- a/code/meos_util.h
+++ b/code/meos_util.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -91,11 +91,11 @@ const wstring &formatTimeHMS(int rt, SubSecond mode = SubSecond::Auto);
 
 wstring formatTimeIOF(int rt, int zeroTime);
 
-int convertDateYMS(const string &m, bool checkValid);
-int convertDateYMS(const string &m, SYSTEMTIME &st, bool checkValid);
+int convertDateYMD(const string &m, bool checkValid);
+int convertDateYMD(const string &m, SYSTEMTIME &st, bool checkValid);
 
-int convertDateYMS(const wstring &m, bool checkValid);
-int convertDateYMS(const wstring &m, SYSTEMTIME &st, bool checkValid);
+int convertDateYMD(const wstring &m, bool checkValid);
+int convertDateYMD(const wstring &m, SYSTEMTIME &st, bool checkValid);
 
 // Convert a "general" time string to a MeOS compatible time string
 void processGeneralTime(const wstring &generalTime, wstring &meosTime, wstring &meosDate);
@@ -109,31 +109,34 @@ SYSTEMTIME Int64TenthSecondToSystemTime(__int64 time);
 
 #define NOTIME 0x7FFFFFFF
 
-//Returns a time converted from +/-MM:SS or NOTIME, in seconds
+//Returns a time converted from +/-MM:SS or NOTIME, in MeOS time unit
 int convertAbsoluteTimeMS(const wstring &m);
+int convertAbsoluteTimeMS(const string& m);
+
 // Parses a time on format HH:MM:SS+01:00Z or HHMMSS+0100Z (but ignores time zone)
 int convertAbsoluteTimeISO(const wstring &m);
 
-/** Returns a time converted from HH:MM:SS or -1, in seconds
+/** Returns a time converted from HH:MM:SS or -1, in MeOS time unit 
    @param m time to convert
    @param daysZeroTime -1 do not support days syntax, positive interpret days w.r.t the specified zero time.
 */
 int convertAbsoluteTimeHMS(const string &m, int daysZeroTime);
 
-/** Returns a time converted from HH:MM:SS or -1, in seconds
+/** Returns a time converted from HH:MM:SS or -1, in MeOS time unit
    @param m time to convert
    @param daysZeroTime -1 do not support days syntax, positive interpret days w.r.t the specified zero time.
 */
 int convertAbsoluteTimeHMS(const wstring &m, int daysZeroTime);
 
 const vector<string> &split(const string &line, const string &separators, vector<string> &split_vector);
-//const string &unsplit(const vector<string> &split_vector, const string &separators, string &line);
 
 const vector<wstring> &split(const wstring &line, const wstring &separators, vector<wstring> &split_vector);
 const wstring &unsplit(const vector<wstring> &split_vector, const wstring &separators, wstring &line);
 
 // Compare two strings, ignore case. 0 = equal, != zero compares as the integers.
 int compareStringIgnoreCase(const wstring &a, const wstring &b);
+const wstring &limitText(const wstring& tIn, size_t numChar);
+wstring ensureEndingColon(const wstring &text);
 
 const wstring &makeDash(const wstring &t);
 const wstring &makeDash(const wchar_t *t);
@@ -152,10 +155,13 @@ wstring itow(int64_t i);
 wstring itow(uint64_t i);
 
 
-///Lower case match (filt_lc must be lc)
-bool filterMatchString(const string &c, const char *filt_lc);
+///Lower case match (filt_lc must be lc and stripped of accents)
 bool filterMatchString(const wstring &c, const wchar_t *filt_lc, int &score);
 
+/** To lower case and strip accants */
+void prepareMatchString(wchar_t* data_c, int size);
+
+
 bool matchNumber(int number, const wchar_t *key);
 
 int getMeosBuild();
diff --git a/code/meos_vc15.sln b/code/meos_vc15.sln
deleted file mode 100644
index 291bfa1..0000000
--- a/code/meos_vc15.sln
+++ /dev/null
@@ -1,34 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25420.1
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "meosvc15", "meosvc15.vcxproj", "{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x64 = Debug|x64
-		Debug|x86 = Debug|x86
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-		test|x64 = test|x64
-		test|x86 = test|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.Debug|x64.ActiveCfg = Debug|x64
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.Debug|x64.Build.0 = Debug|x64
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.Debug|x86.ActiveCfg = Debug|Win32
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.Debug|x86.Build.0 = Debug|Win32
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.Release|x64.ActiveCfg = Release|x64
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.Release|x64.Build.0 = Release|x64
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.Release|x86.ActiveCfg = Release|Win32
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.Release|x86.Build.0 = Release|Win32
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.test|x64.ActiveCfg = test|x64
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.test|x64.Build.0 = test|x64
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.test|x86.ActiveCfg = test|Win32
-		{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}.test|x86.Build.0 = test|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal
diff --git a/code/meosexception.h b/code/meosexception.h
index 95dd394..63f0634 100644
--- a/code/meosexception.h
+++ b/code/meosexception.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/meoslang.rc b/code/meoslang.rc
index b09a4ad..4b6adae 100644
--- a/code/meoslang.rc
+++ b/code/meoslang.rc
@@ -8,6 +8,7 @@
 #define IDR_3008                        110
 #define IDR_3011                        111
 #define IDR_3012                        112
+#define IDR_3013                        113
 #define SND_OK                          50
 #define SND_LEADER                      51
 #define SND_NOTOK                       52
@@ -22,6 +23,7 @@ IDR_3006                300     DISCARDABLE     "czech.lng"
 IDR_3008                300     DISCARDABLE     "french.lng"
 IDR_3011                300     DISCARDABLE     "spanish.lng"
 IDR_3012                300     DISCARDABLE     "ukrainian.lng"
+IDR_3013                300     DISCARDABLE     "portuguese.lng"
 
 /////////////////////////////////////////////////////////////////////////////
 
diff --git a/code/meosvc15.vcxproj b/code/meosvc15.vcxproj
deleted file mode 100644
index 0bd6c96..0000000
--- a/code/meosvc15.vcxproj
+++ /dev/null
@@ -1,785 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="test|Win32">
-      <Configuration>test</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="test|x64">
-      <Configuration>test</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{B854EF2A-2BB7-4D62-B08B-96BD64B347E8}</ProjectGuid>
-    <RootNamespace>meos</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v140_xp</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='test|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v140</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v140_xp</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v140_xp</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v140_xp</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='test|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC60.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='test|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC60.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC60.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC60.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC60.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC60.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\Release\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\Release\</IntDir>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\Debug\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\Debug\</IntDir>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='test|Win32'">$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='test|Win32'">$(Configuration)\</IntDir>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='test|Win32'">true</LinkIncremental>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='test|x64'">true</LinkIncremental>
-    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
-    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
-    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
-    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
-    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
-    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
-    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
-    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
-    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='test|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='test|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='test|Win32'" />
-    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='test|x64'" />
-    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='test|Win32'" />
-    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='test|x64'" />
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <TargetName>meos</TargetName>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <TargetName>meos</TargetName>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <TargetName>meos</TargetName>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <TargetName>meos</TargetName>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Midl>
-      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MkTypLibCompatible>true</MkTypLibCompatible>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <TargetEnvironment>Win32</TargetEnvironment>
-      <TypeLibraryName>.\Release/meos.tlb</TypeLibraryName>
-      <HeaderFileName>
-      </HeaderFileName>
-    </Midl>
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <AdditionalIncludeDirectories>meosdb/mysql++;meosdb/mysql50;libharu;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <StringPooling>true</StringPooling>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
-      <PrecompiledHeaderOutputFile>.\Release/meos.pch</PrecompiledHeaderOutputFile>
-      <AssemblerListingLocation>.\Release/</AssemblerListingLocation>
-      <ObjectFileName>.\Release/</ObjectFileName>
-      <ProgramDataBaseFileName>.\Release/</ProgramDataBaseFileName>
-      <WarningLevel>Level3</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DisableSpecificWarnings>4091;4018</DisableSpecificWarnings>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x041d</Culture>
-    </ResourceCompile>
-    <Link>
-      <AdditionalDependencies>Msimg32.lib;comctl32.lib;odbc32.lib;odbccp32.lib;winmm.lib;ws2_32.lib;wininet.lib;zlibstat_vc15.lib;libmysql.lib;libhpdf.lib;RestBed.lib;libpng.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>.\Release/meos.exe</OutputFile>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <AdditionalLibraryDirectories>./lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <ProgramDatabaseFile>.\Release/meos.pdb</ProgramDatabaseFile>
-      <SubSystem>Windows</SubSystem>
-      <RandomizedBaseAddress>false</RandomizedBaseAddress>
-      <DataExecutionPrevention>
-      </DataExecutionPrevention>
-      <TargetMachine>MachineX86</TargetMachine>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <MinimumRequiredVersion>5.01</MinimumRequiredVersion>
-    </Link>
-    <Bscmake>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OutputFile>.\Release/meos.bsc</OutputFile>
-    </Bscmake>
-    <Manifest>
-      <EnableDpiAwareness>PerMonitorHighDPIAware</EnableDpiAwareness>
-    </Manifest>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <Midl>
-      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MkTypLibCompatible>true</MkTypLibCompatible>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <TypeLibraryName>.\Release/meos.tlb</TypeLibraryName>
-      <HeaderFileName>
-      </HeaderFileName>
-    </Midl>
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <AdditionalIncludeDirectories>libharu;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <StringPooling>true</StringPooling>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
-      <PrecompiledHeaderOutputFile>.\x64/meos.pch</PrecompiledHeaderOutputFile>
-      <AssemblerListingLocation>./x64/Release/</AssemblerListingLocation>
-      <ObjectFileName>./x64/Release/</ObjectFileName>
-      <ProgramDataBaseFileName>./x64/Release/</ProgramDataBaseFileName>
-      <WarningLevel>Level3</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DisableSpecificWarnings>4091;4267</DisableSpecificWarnings>
-      <BrowseInformation>false</BrowseInformation>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x041d</Culture>
-    </ResourceCompile>
-    <Link>
-      <AdditionalDependencies>Msimg32.lib;comctl32.lib;odbc32.lib;odbccp32.lib;winmm.lib;ws2_32.lib;wininet.lib;zlibstat.lib;libharu.lib;RestBed.lib;libpng.lib;libmysql.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>$(TargetPath)</OutputFile>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <AdditionalLibraryDirectories>./lib64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <ProgramDatabaseFile>./x64/Release/meos.pdb</ProgramDatabaseFile>
-      <SubSystem>Windows</SubSystem>
-      <RandomizedBaseAddress>false</RandomizedBaseAddress>
-      <DataExecutionPrevention>false</DataExecutionPrevention>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <MinimumRequiredVersion>5.02</MinimumRequiredVersion>
-      <FullProgramDatabaseFile>true</FullProgramDatabaseFile>
-      <SetChecksum>true</SetChecksum>
-    </Link>
-    <Bscmake>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OutputFile>.\Release/meos.bsc</OutputFile>
-    </Bscmake>
-    <Manifest>
-      <EnableDpiAwareness>PerMonitorHighDPIAware</EnableDpiAwareness>
-    </Manifest>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Midl>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MkTypLibCompatible>true</MkTypLibCompatible>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <TargetEnvironment>Win32</TargetEnvironment>
-      <TypeLibraryName>.\Debug/meos.tlb</TypeLibraryName>
-      <HeaderFileName>
-      </HeaderFileName>
-    </Midl>
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>meosdb/mysql++;libharu;meosdb/mysql50;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MinimalRebuild>false</MinimalRebuild>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
-      <PrecompiledHeaderOutputFile>.\Debug/meos.pch</PrecompiledHeaderOutputFile>
-      <AssemblerListingLocation>.\Debug/</AssemblerListingLocation>
-      <ObjectFileName>.\Debug/</ObjectFileName>
-      <ProgramDataBaseFileName>.\Debug/</ProgramDataBaseFileName>
-      <BrowseInformation>false</BrowseInformation>
-      <WarningLevel>Level3</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
-      <DisableSpecificWarnings>4996;4091;4018;%(DisableSpecificWarnings)</DisableSpecificWarnings>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x041d</Culture>
-    </ResourceCompile>
-    <Link>
-      <AdditionalDependencies>Msimg32.lib;comctl32.lib;odbc32.lib;odbccp32.lib;winmm.lib;ws2_32.lib;wininet.lib;zlibstat_vc15.lib;libmysql.lib;libhpdf.lib;RestBed.lib;libpng.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>.\Debug/meos.exe</OutputFile>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <AdditionalLibraryDirectories>./lib_db;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <ProgramDatabaseFile>.\Debug/meos.pdb</ProgramDatabaseFile>
-      <SubSystem>Windows</SubSystem>
-      <DataExecutionPrevention>
-      </DataExecutionPrevention>
-      <TargetMachine>MachineX86</TargetMachine>
-      <IgnoreSpecificDefaultLibraries>
-      </IgnoreSpecificDefaultLibraries>
-    </Link>
-    <Bscmake>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OutputFile>.\Debug/meos.bsc</OutputFile>
-    </Bscmake>
-    <Manifest>
-      <EnableDpiAwareness>PerMonitorHighDPIAware</EnableDpiAwareness>
-    </Manifest>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Midl>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MkTypLibCompatible>true</MkTypLibCompatible>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <TypeLibraryName>.\Debug/meos.tlb</TypeLibraryName>
-      <HeaderFileName>
-      </HeaderFileName>
-    </Midl>
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>meosdb/mysql++;libharu;meosdb/mysql50;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MinimalRebuild>false</MinimalRebuild>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
-      <PrecompiledHeaderOutputFile>.\Debug/meos.pch</PrecompiledHeaderOutputFile>
-      <AssemblerListingLocation>./x64/Debug/</AssemblerListingLocation>
-      <ObjectFileName>./x64/Debug/</ObjectFileName>
-      <ProgramDataBaseFileName>./x64/Debug/</ProgramDataBaseFileName>
-      <BrowseInformation>false</BrowseInformation>
-      <WarningLevel>Level3</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <DisableSpecificWarnings>4996;4091;4267;%(DisableSpecificWarnings)</DisableSpecificWarnings>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x041d</Culture>
-    </ResourceCompile>
-    <Link>
-      <AdditionalDependencies>Msimg32.lib;comctl32.lib;odbc32.lib;odbccp32.lib;winmm.lib;ws2_32.lib;wininet.lib;zlibstat_vc15.lib;mysqlpp_vc15.lib;libhpdf.lib;RestBed.lib;libpng.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>./x64/Debug/meos.exe</OutputFile>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <AdditionalLibraryDirectories>./lib_db;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <ProgramDatabaseFile>./x64/Debug/meos.pdb</ProgramDatabaseFile>
-      <SubSystem>Windows</SubSystem>
-      <RandomizedBaseAddress>false</RandomizedBaseAddress>
-      <DataExecutionPrevention>
-      </DataExecutionPrevention>
-      <IgnoreSpecificDefaultLibraries>
-      </IgnoreSpecificDefaultLibraries>
-    </Link>
-    <Bscmake>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OutputFile>.\Debug/meos.bsc</OutputFile>
-    </Bscmake>
-    <Manifest>
-      <EnableDpiAwareness>PerMonitorHighDPIAware</EnableDpiAwareness>
-    </Manifest>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='test|Win32'">
-    <Midl>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MkTypLibCompatible>true</MkTypLibCompatible>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <TargetEnvironment>Win32</TargetEnvironment>
-      <TypeLibraryName>.\Debug/meos.tlb</TypeLibraryName>
-      <HeaderFileName>
-      </HeaderFileName>
-    </Midl>
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MinimalRebuild>true</MinimalRebuild>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
-      <PrecompiledHeaderOutputFile>.\Debug/meos.pch</PrecompiledHeaderOutputFile>
-      <AssemblerListingLocation>.\Debug/</AssemblerListingLocation>
-      <ObjectFileName>.\Debug/</ObjectFileName>
-      <ProgramDataBaseFileName>.\Debug/</ProgramDataBaseFileName>
-      <BrowseInformation>true</BrowseInformation>
-      <WarningLevel>Level3</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x041d</Culture>
-    </ResourceCompile>
-    <Link>
-      <AdditionalDependencies>Msimg32.lib;comctl32.lib;odbc32.lib;odbccp32.lib;winmm.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>.\Debug/meos.exe</OutputFile>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <ProgramDatabaseFile>.\Debug/meos.pdb</ProgramDatabaseFile>
-      <SubSystem>Windows</SubSystem>
-      <RandomizedBaseAddress>false</RandomizedBaseAddress>
-      <DataExecutionPrevention>
-      </DataExecutionPrevention>
-      <TargetMachine>MachineX86</TargetMachine>
-    </Link>
-    <Bscmake>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OutputFile>.\Debug/meos.bsc</OutputFile>
-    </Bscmake>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='test|x64'">
-    <Midl>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MkTypLibCompatible>true</MkTypLibCompatible>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <TypeLibraryName>.\Debug/meos.tlb</TypeLibraryName>
-      <HeaderFileName>
-      </HeaderFileName>
-    </Midl>
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
-      <PrecompiledHeaderOutputFile>.\Debug/meos.pch</PrecompiledHeaderOutputFile>
-      <AssemblerListingLocation>.\Debug/</AssemblerListingLocation>
-      <ObjectFileName>.\Debug/</ObjectFileName>
-      <ProgramDataBaseFileName>.\Debug/</ProgramDataBaseFileName>
-      <BrowseInformation>true</BrowseInformation>
-      <WarningLevel>Level3</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x041d</Culture>
-    </ResourceCompile>
-    <Link>
-      <AdditionalDependencies>Msimg32.lib;comctl32.lib;odbc32.lib;odbccp32.lib;winmm.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>.\Debug/meos.exe</OutputFile>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <ProgramDatabaseFile>.\Debug/meos.pdb</ProgramDatabaseFile>
-      <SubSystem>Windows</SubSystem>
-      <RandomizedBaseAddress>false</RandomizedBaseAddress>
-      <DataExecutionPrevention>
-      </DataExecutionPrevention>
-    </Link>
-    <Bscmake>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OutputFile>.\Debug/meos.bsc</OutputFile>
-    </Bscmake>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="animationdata.cpp" />
-    <ClCompile Include="autocomplete.cpp" />
-    <ClCompile Include="autotask.cpp" />
-    <ClCompile Include="binencoder.cpp" />
-    <ClCompile Include="classconfiginfo.cpp" />
-    <ClCompile Include="csvparser.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="download.cpp" />
-    <ClCompile Include="gdioutput.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="generalresult.cpp" />
-    <ClCompile Include="HTMLWriter.cpp" />
-    <ClCompile Include="image.cpp" />
-    <ClCompile Include="importformats.cpp" />
-    <ClCompile Include="infoserver.cpp" />
-    <ClCompile Include="iof30interface.cpp" />
-    <ClCompile Include="listeditor.cpp" />
-    <ClCompile Include="liveresult.cpp" />
-    <ClCompile Include="localizer.cpp" />
-    <ClCompile Include="machinecontainer.cpp" />
-    <ClCompile Include="meos.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="MeOSFeatures.cpp" />
-    <ClCompile Include="MeosSQL.cpp" />
-    <ClCompile Include="meos_util.cpp" />
-    <ClCompile Include="meosversion.cpp" />
-    <ClCompile Include="metalist.cpp" />
-    <ClCompile Include="methodeditor.cpp" />
-    <ClCompile Include="mysqldaemon.cpp" />
-    <ClCompile Include="mysqlwrapper.cpp" />
-    <ClCompile Include="newcompetition.cpp" />
-    <ClCompile Include="oBase.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="oCard.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="oClass.cpp" />
-    <ClCompile Include="oClub.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="oControl.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="oCourse.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="oDataContainer.cpp" />
-    <ClCompile Include="oEvent.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="oEventDraw.cpp" />
-    <ClCompile Include="oEventResult.cpp" />
-    <ClCompile Include="oEventSpeaker.cpp" />
-    <ClCompile Include="oEventSQL.cpp" />
-    <ClCompile Include="oevent_transfer.cpp" />
-    <ClCompile Include="oFreeImport.cpp" />
-    <ClCompile Include="oFreePunch.cpp" />
-    <ClCompile Include="oImportExport.cpp" />
-    <ClCompile Include="oListInfo.cpp" />
-    <ClCompile Include="onlineinput.cpp" />
-    <ClCompile Include="onlineresults.cpp" />
-    <ClCompile Include="oPunch.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="oReport.cpp" />
-    <ClCompile Include="oRunner.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="oTeam.cpp" />
-    <ClCompile Include="oTeamEvent.cpp" />
-    <ClCompile Include="parser.cpp" />
-    <ClCompile Include="pdfwriter.cpp" />
-    <ClCompile Include="prefseditor.cpp" />
-    <ClCompile Include="printer.cpp" />
-    <ClCompile Include="progress.cpp" />
-    <ClCompile Include="qualification_final.cpp" />
-    <ClCompile Include="random.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="recorder.cpp" />
-    <ClCompile Include="restserver.cpp" />
-    <ClCompile Include="RestService.cpp" />
-    <ClCompile Include="RunnerDB.cpp" />
-    <ClCompile Include="socket.cpp" />
-    <ClCompile Include="speakermonitor.cpp" />
-    <ClCompile Include="SportIdent.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="StdAfx.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">NotUsing</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='test|Win32'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='test|x64'">Create</PrecompiledHeader>
-    </ClCompile>
-    <ClCompile Include="TabAuto.cpp" />
-    <ClCompile Include="TabBase.cpp" />
-    <ClCompile Include="TabClass.cpp" />
-    <ClCompile Include="TabClub.cpp" />
-    <ClCompile Include="TabCompetition.cpp" />
-    <ClCompile Include="TabControl.cpp" />
-    <ClCompile Include="TabCourse.cpp" />
-    <ClCompile Include="Table.cpp" />
-    <ClCompile Include="TabList.cpp" />
-    <ClCompile Include="TabMulti.cpp" />
-    <ClCompile Include="TabRunner.cpp" />
-    <ClCompile Include="TabSI.cpp" />
-    <ClCompile Include="TabSpeaker.cpp" />
-    <ClCompile Include="TabTeam.cpp" />
-    <ClCompile Include="testmeos.cpp" />
-    <ClCompile Include="tests.cpp" />
-    <ClCompile Include="TimeStamp.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="toolbar.cpp" />
-    <ClCompile Include="xmlparser.cpp">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <ClCompile Include="zip.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="animationdata.h" />
-    <ClInclude Include="autocomplete.h" />
-    <ClInclude Include="autocompletehandler.h" />
-    <ClInclude Include="autotask.h" />
-    <ClInclude Include="binencoder.h" />
-    <ClInclude Include="classconfiginfo.h" />
-    <ClInclude Include="gdiconstants.h" />
-    <ClInclude Include="gdifonts.h" />
-    <ClInclude Include="gdiimpl.h" />
-    <ClInclude Include="gdistructures.h" />
-    <ClInclude Include="generalresult.h" />
-    <ClInclude Include="guihandler.h" />
-    <ClInclude Include="image.h" />
-    <ClInclude Include="infoserver.h" />
-    <ClInclude Include="inthashmap.h" />
-    <ClInclude Include="intkeymap.hpp" />
-    <ClInclude Include="intkeymapimpl.hpp" />
-    <ClInclude Include="iof30interface.h" />
-    <ClInclude Include="listeditor.h" />
-    <ClInclude Include="liveresult.h" />
-    <ClInclude Include="machinecontainer.h" />
-    <ClInclude Include="meosdb\sqltypes.h" />
-    <ClInclude Include="meosdb\targetver.h" />
-    <ClInclude Include="meosexception.h" />
-    <ClInclude Include="MeOSFeatures.h" />
-    <ClInclude Include="MeosSQL.h" />
-    <ClInclude Include="metalist.h" />
-    <ClInclude Include="methodeditor.h" />
-    <ClInclude Include="mysqlwrapper.h" />
-    <ClInclude Include="oEventDraw.h" />
-    <ClInclude Include="oListInfo.h" />
-    <ClInclude Include="onlineinput.h" />
-    <ClInclude Include="onlineresults.h" />
-    <ClInclude Include="oRunner.h" />
-    <ClInclude Include="parser.h" />
-    <ClInclude Include="pdfwriter.h" />
-    <ClInclude Include="prefseditor.h" />
-    <ClInclude Include="Printer.h" />
-    <ClInclude Include="qualification_final.h" />
-    <ClInclude Include="recorder.h" />
-    <ClInclude Include="restserver.h" />
-    <ClInclude Include="RestService.h" />
-    <ClInclude Include="socket.h" />
-    <ClInclude Include="speakermonitor.h" />
-    <ClInclude Include="subcommand.h" />
-    <ClInclude Include="testmeos.h" />
-    <ClInclude Include="timeconstants.hpp" />
-    <ClInclude Include="toolbar.h" />
-    <ClInclude Include="csvparser.h" />
-    <ClInclude Include="download.h" />
-    <ClInclude Include="gdioutput.h" />
-    <ClInclude Include="HTMLWriter.h" />
-    <ClInclude Include="localizer.h" />
-    <ClInclude Include="meos.h" />
-    <ClInclude Include="meos_util.h" />
-    <ClInclude Include="oBase.h" />
-    <ClInclude Include="oCard.h" />
-    <ClInclude Include="oClass.h" />
-    <ClInclude Include="oClub.h" />
-    <ClInclude Include="oControl.h" />
-    <ClInclude Include="oCourse.h" />
-    <ClInclude Include="oDataContainer.h" />
-    <ClInclude Include="oEvent.h" />
-    <ClInclude Include="oFreeImport.h" />
-    <ClInclude Include="oFreePunch.h" />
-    <ClInclude Include="oPunch.h" />
-    <ClInclude Include="ospeaker.h" />
-    <ClInclude Include="oTeam.h" />
-    <ClInclude Include="progress.h" />
-    <ClInclude Include="random.h" />
-    <ClInclude Include="resource.h" />
-    <ClInclude Include="RunnerDB.h" />
-    <ClInclude Include="SportIdent.h" />
-    <ClInclude Include="StdAfx.h" />
-    <ClInclude Include="TabAuto.h" />
-    <ClInclude Include="TabBase.h" />
-    <ClInclude Include="TabClass.h" />
-    <ClInclude Include="TabClub.h" />
-    <ClInclude Include="TabCompetition.h" />
-    <ClInclude Include="TabControl.h" />
-    <ClInclude Include="TabCourse.h" />
-    <ClInclude Include="Table.h" />
-    <ClInclude Include="TabList.h" />
-    <ClInclude Include="TabMulti.h" />
-    <ClInclude Include="TabRunner.h" />
-    <ClInclude Include="TabSI.h" />
-    <ClInclude Include="TabSpeaker.h" />
-    <ClInclude Include="TabTeam.h" />
-    <ClInclude Include="TimeStamp.h" />
-    <ClInclude Include="xmlparser.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="meos.rc">
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='test|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ResourceCompile>
-    <ResourceCompile Include="meoslang.rc" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="bitmap1.bmp" />
-    <None Include="html1.htm">
-      <DeploymentContent>true</DeploymentContent>
-    </None>
-    <None Include="meos.ico" />
-    <None Include="small.ico" />
-  </ItemGroup>
-  <ItemGroup>
-    <Image Include="bmp00001.bmp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
\ No newline at end of file
diff --git a/code/meosversion.cpp b/code/meosversion.cpp
index f51824f..2264070 100644
--- a/code/meosversion.cpp
+++ b/code/meosversion.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -23,23 +23,23 @@
 #include <vector>
 #include "meos_util.h"
 
-//ABCDEFGHIJKLMNOP
+//ABCDEFGHIJKLMNOPQ
 int getMeosBuild() {
-  string revision("$Rev: 1263 $");
+  string revision("$Rev: 1326 $");
   return 174 + atoi(revision.substr(5, string::npos).c_str());
 }
 
 wstring getMeosDate() {
-  wstring date(L"$Date: 2023-05-12 16:11:34 +0200 (fre, 12 maj 2023) $");
+  wstring date(L"$Date: 2024-03-02 21:15:41 +0100 (lör, 02 mar 2024) $");
   return date.substr(7,10);
 }
 
 wstring getBuildType() {
-  return L"U1"; // No parantheses (...)
+  return L"Beta 1"; // No parantheses (...)
 }
 
 wstring getMajorVersion() {
-  return L"3.9";
+  return L"4.0";
 }
 
 wstring getMeosFullVersion() {
@@ -66,8 +66,8 @@ wstring getMeosCompectVersion() {
     return getMajorVersion() + L"." + itow(getMeosBuild()) + L" (" + getBuildType() + L")";
 }
 
-void getSupporters(vector<wstring> &supp, vector<wstring> &developSupp)
-{  
+void getSupporters(vector<wstring>& supp, vector<wstring>& developSupp)
+{
   supp.emplace_back(L"OK Gorm, Denmark");//2020-
   supp.emplace_back(L"Nyköpings OK");
   supp.emplace_back(L"Thomas Engberg, VK Uvarna");
@@ -134,13 +134,25 @@ void getSupporters(vector<wstring> &supp, vector<wstring> &developSupp)
   developSupp.emplace_back(L"OK Måsen");
   supp.emplace_back(L"Ligue PACA");
   supp.emplace_back(L"Kamil Pipek, OK Lokomotiva Pardubice");
-  supp.emplace_back(L"Foothills Wanderers Orienteering Club");  
-  supp.emplace_back(L"Per Eklöf / PE Design / PE Timing"); 
+  supp.emplace_back(L"Foothills Wanderers Orienteering Club");
+  supp.emplace_back(L"Per Eklöf / PE Design / PE Timing");
   supp.emplace_back(L"HEYRIES, ACA Aix en Provence");
   supp.emplace_back(L"Järla Orientering");
   supp.emplace_back(L"Kvarnsvedens GOIF OK");
   supp.emplace_back(L"Ingemar Lindström, OK Österåker");
   supp.emplace_back(L"OK Österåker");
-  
+  supp.emplace_back(L"Guntars Mankus, OK Saldus");
+  supp.emplace_back(L"Orienteering NSW");
+  developSupp.emplace_back(L"OK Enen");
+  supp.emplace_back(L"Hästveda OK");
+  supp.emplace_back(L"Ingemar Carlsson, Sävedalens AIK");
+  supp.emplace_back(L"Lunds OK");
+  supp.emplace_back(L"Ramblers Orienteering Club, Canada");
+  supp.emplace_back(L"CROCO");
+  supp.emplace_back(L"Nässjö OK");
+  supp.emplace_back(L"Silkeborg OK");
+  supp.emplace_back(L"IK Uven");
+  supp.emplace_back(L"Attunda OK");
+
   reverse(supp.begin(), supp.end());
 }
diff --git a/code/metalist.cpp b/code/metalist.cpp
index dad0412..f83063f 100644
--- a/code/metalist.cpp
+++ b/code/metalist.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -391,12 +391,6 @@ void oListParam::deserialize(const xmlobject &xml, const MetaListContainer &cont
   saved = true;
 }
 
-void oListParam::getCustomTitle(wchar_t *t) const
-{
-  if (!title.empty())
-    wcscpy_s(t, 256, makeDash(title).c_str());
-}
-
 bool oListParam::filterInclude(int count, const oAbstractRunner *r) const {
   return filterMaxPer == 0 || count <= filterMaxPer || (r != nullptr && r->matchAbstractRunner(alwaysInclude));
 }
@@ -750,7 +744,7 @@ void MetaList::interpret(oEvent *oe, const gdioutput &gdi, const oListParam &par
             firstStage = -1;
           }
         }
-        if (isAllLegType(lines[j][k])) {
+        else if (isAllLegType(lines[j][k])) {
           if (firstLeg == -1)
             firstLeg = k;
 
@@ -2198,6 +2192,7 @@ void MetaList::initSymbols() {
     typeToSymbol[lCourseUsage] = L"CourseUsage";
     typeToSymbol[lCourseUsageNoVacant] = L"CourseUsageNoVacant";
     typeToSymbol[lCourseClasses] = L"CourseClasses";
+    typeToSymbol[lCourseNumControls] = L"CourseNumControls";
     typeToSymbol[lCourseShortening] = L"CourseShortening";
     typeToSymbol[lRunnerName] = L"RunnerName";
     typeToSymbol[lRunnerGivenName] = L"RunnerGivenName";
@@ -2224,6 +2219,7 @@ void MetaList::initSymbols() {
     typeToSymbol[lRunnerStartZero] = L"RunnerStartZero";
     typeToSymbol[lRunnerClub] = L"RunnerClub";
     typeToSymbol[lRunnerCard] = L"RunnerCard";
+    typeToSymbol[lRunnerRentalCard] = L"RunnerRentalCard";
     typeToSymbol[lRunnerBib] = L"RunnerBib";
     typeToSymbol[lRunnerStartNo] = L"RunnerStartNo";
     typeToSymbol[lRunnerRank] = L"RunnerRank";
@@ -2301,18 +2297,26 @@ void MetaList::initSymbols() {
     typeToSymbol[lPunchNamedTime] = L"PunchNamedTime";
     typeToSymbol[lPunchName] = L"PunchName";
     typeToSymbol[lPunchNamedSplit] = L"PunchNamedSplit";
+    typeToSymbol[lPunchTeamTotalNamedTime] = L"PunchTeamTotalNamedTime";
 
     typeToSymbol[lPunchTime] = L"PunchTime";
+    typeToSymbol[lPunchTeamTime] = L"PunchTeamTime";
+
     typeToSymbol[lPunchControlNumber] = L"PunchControlNumber";
     typeToSymbol[lPunchControlCode] = L"PunchControlCode";
     typeToSymbol[lPunchLostTime] = L"PunchLostTime";
     typeToSymbol[lPunchControlPlace] = L"PunchControlPlace";
     typeToSymbol[lPunchControlPlaceAcc] = L"PunchControlPlaceAcc";
+    typeToSymbol[lPunchControlPlaceTeamAcc] = L"PunchControlPlaceTeamAcc";
 
     typeToSymbol[lPunchSplitTime] = L"PunchSplitTime";
     typeToSymbol[lPunchTotalTime] = L"PunchTotalTime";
+    typeToSymbol[lPunchTeamTotalTime] = L"PunchTeamTotalTime";
+
     typeToSymbol[lPunchAbsTime] = L"PunchAbsTime";
     typeToSymbol[lPunchTotalTimeAfter] = L"PunchTotalTimeAfter";
+    typeToSymbol[lPunchTeamTotalTimeAfter] = L"PunchTeamTotalTimeAfter";
+
     typeToSymbol[lPunchTimeSinceLast] = L"PunchTimeSinceLast";
 
     typeToSymbol[lRogainingPunch] = L"RogainingPunch";
@@ -2333,6 +2337,18 @@ void MetaList::initSymbols() {
     typeToSymbol[lRunnerGeneralPlace] = L"RunnerGeneralPlace";
     typeToSymbol[lRunnerGeneralTimeAfter] = L"RunnerGeneralTimeAfter";
 
+    typeToSymbol[lRunnerDataA] = L"RunnerDataA";
+    typeToSymbol[lRunnerDataB] = L"RunnerDataB";
+    typeToSymbol[lRunnerTextA] = L"RunnerTextA";
+
+    typeToSymbol[lTeamDataA] = L"TeamDataA";
+    typeToSymbol[lTeamDataB] = L"TeamDataB";
+    typeToSymbol[lTeamTextA] = L"TeamTextA";
+
+    typeToSymbol[lClassDataA] = L"ClassDataA";
+    typeToSymbol[lClassDataB] = L"ClassDataB";
+    typeToSymbol[lClassTextA] = L"ClassTextA";
+
     typeToSymbol[lTeamTotalTime] = L"TeamTotalTime";
     typeToSymbol[lTeamTotalTimeStatus] = L"TeamTotalTimeStatus";
     typeToSymbol[lTeamTotalPlace] = L"TeamTotalPlace";
@@ -3461,7 +3477,7 @@ void MetaList::getAutoComplete(const wstring& w, vector<AutoCompleteRecord>& rec
     s_lc[j].resize(ws[j].size() + 1);
     ws[j] = trim(ws[j]);
     wcscpy_s(s_lc[j].data(), s_lc[j].size(), ws[j].c_str());
-    CharLowerBuff(s_lc[j].data(), ws[j].length());
+    prepareMatchString(s_lc[j].data(), ws[j].length());
   }
 
   wstring tl;
diff --git a/code/metalist.h b/code/metalist.h
index 415f371..0c01a20 100644
--- a/code/metalist.h
+++ b/code/metalist.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -434,6 +434,10 @@ public:
 
   static void fillSymbols(vector < pair<wstring, size_t>> &symb);
 
+  static const map<SortOrder, string>& getOrderToSymbol() {
+    return orderToSymbol;
+  }
+
   friend class MetaListPost;
 };
 
@@ -526,6 +530,6 @@ public:
   void synchronizeTo(MetaListContainer &dst) const;
 
   bool interpret(oEvent *oe, const gdioutput &gdi, const oListParam &par, oListInfo &li) const;
-
+  
   void enumerateLists(vector< pair<wstring, pair<string, wstring> > > &out) const;
 };
diff --git a/code/methodeditor.cpp b/code/methodeditor.cpp
index 0042b16..ba63a61 100644
--- a/code/methodeditor.cpp
+++ b/code/methodeditor.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -56,7 +56,7 @@ void MethodEditor::setCurrentResult(DynamicResult *lst, const wstring &fileSrc)
   fileNameSource = fileSrc;
 }
 
-int methodCB(gdioutput *gdi, int type, void *data) {
+int methodCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   void *clz = gdi->getData("MethodEditorClz");
   MethodEditor *le = (MethodEditor *)clz;
   BaseInfo *bi = (BaseInfo *)data;
@@ -233,7 +233,7 @@ void makeScore(wstring &str, const pair<int, int> &score) {
   str = itow(v);
 }
 
-int MethodEditor::methodCb(gdioutput &gdi, int type, BaseInfo &data) {
+int MethodEditor::methodCb(gdioutput &gdi, GuiEventType type, BaseInfo &data) {
   if (type == GUI_BUTTON) {
     ButtonInfo bi = dynamic_cast<ButtonInfo &>(data);
 
@@ -432,7 +432,7 @@ int MethodEditor::methodCb(gdioutput &gdi, int type, BaseInfo &data) {
       sort(lists.begin(), lists.end());
       gdi.fillRight();
       gdi.addSelection("OpenList", 350, 400, methodCB, L"Choose result module:", L"Rader markerade med (*) kommer från en lista i tävlingen.");
-      gdi.addItem("OpenList", lists);
+      gdi.setItems("OpenList", lists);
       gdi.autoGrow("OpenList");
       gdi.selectFirstItem("OpenList");
 
@@ -802,7 +802,7 @@ int MethodEditor::methodCb(gdioutput &gdi, int type, BaseInfo &data) {
       currentResult->declareSymbols(m, true);
       vector< pair<wstring, size_t> > symb;
       currentResult->getSymbols(symb);
-      gdi.addItem("Symbols", symb);
+      gdi.setItems("Symbols", symb);
     }
     else if (lbi.id == "Symbols") {
       wstring name, desc;
diff --git a/code/methodeditor.h b/code/methodeditor.h
index cae33ca..3a72ae1 100644
--- a/code/methodeditor.h
+++ b/code/methodeditor.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -29,6 +29,7 @@ class ButtonInfo;
 class oEvent;
 
 #include <vector>
+#include "guihandler.h"
 
 class TabBase;
 
@@ -52,7 +53,7 @@ private:
   /// Check and ask if there are changes to save
   bool checkSave(gdioutput &gdi);
 
-  int methodCb(gdioutput &gdi, int type, BaseInfo &data);
+  int methodCb(gdioutput &gdi, GuiEventType type, BaseInfo &data);
 
   void makeDirty(gdioutput &gdi, DirtyFlag inside);
 
@@ -79,5 +80,5 @@ public:
 
   DynamicResult *load(gdioutput &gdi, const string &tag, bool forceLoadCopy);
 
-  friend int methodCB(gdioutput*, int, void *);
+  friend int methodCB(gdioutput*, GuiEventType type, BaseInfo* data);
 };
diff --git a/code/mysqldaemon.cpp b/code/mysqldaemon.cpp
index ddbe23e..3d60c80 100644
--- a/code/mysqldaemon.cpp
+++ b/code/mysqldaemon.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -136,7 +136,7 @@ void MySQLReconnect::process(gdioutput &gdi, oEvent *oe, AutoSyncType ast)
   }
 }
 
-int AutomaticCB(gdioutput *gdi, int type, void *data);
+int AutomaticCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 
 void MySQLReconnect::status(gdioutput &gdi) {
   AutoMachine::status(gdi);
diff --git a/code/mysqlwrapper.cpp b/code/mysqlwrapper.cpp
index 5df8298..7b5b7e1 100644
--- a/code/mysqlwrapper.cpp
+++ b/code/mysqlwrapper.cpp
@@ -1,10 +1,31 @@
+/************************************************************************
+    MeOS - Orienteering Software
+    Copyright (C) 2009-2024 Melin Software HB
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License fro more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+    Melin Software HB - software@melin.nu - www.melin.nu
+    Eksoppsvägen 16, SE-75646 UPPSALA, Sweden
+
+************************************************************************/
 
 #include "stdafx.h"
 
 #include "mysql/mysql.h"
 #include "mysqlwrapper.h"
 
-
+using namespace std;
 using namespace sqlwrapper;
 
 const char *CellWrapper::c_str() const {
diff --git a/code/mysqlwrapper.h b/code/mysqlwrapper.h
index 0523172..464c21f 100644
--- a/code/mysqlwrapper.h
+++ b/code/mysqlwrapper.h
@@ -1,4 +1,26 @@
 #pragma once
+/************************************************************************
+    MeOS - Orienteering Software
+    Copyright (C) 2009-2024 Melin Software HB
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License fro more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+    Melin Software HB - software@melin.nu - www.melin.nu
+    Eksoppsv�gen 16, SE-75646 UPPSALA, Sweden
+
+************************************************************************/
+
 
 #include <string>
 #include <map>
diff --git a/code/newcompetition.cpp b/code/newcompetition.cpp
index 53d7a64..ebb60eb 100644
--- a/code/newcompetition.cpp
+++ b/code/newcompetition.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -43,15 +43,14 @@
 #include <io.h>
 #include "csvparser.h"
 
-int CompetitionCB(gdioutput *gdi, int type, void *data);
+int CompetitionCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 
-int NewGuideCB(gdioutput *gdi, int type, void *data) {
+int NewGuideCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   TabCompetition &tc = dynamic_cast<TabCompetition &>(*gdi->getTabs().get(TCmpTab));
   return tc.newGuideCB(*gdi, type, data);
 }
 
-int TabCompetition::newGuideCB(gdioutput &gdi, int type, void *data)
-{
+int TabCompetition::newGuideCB(gdioutput &gdi, GuiEventType type, BaseInfo* data) {
   if (type == GUI_LINK) {
     TextInfo ti = *(TextInfo *)data;
     if (ti.id == "link") {
@@ -209,12 +208,12 @@ int TabCompetition::newGuideCB(gdioutput &gdi, int type, void *data)
       SYSTEMTIME st;
       if (ii.id == "FirstStart") {
         t = convertAbsoluteTimeHMS(ii.text, -1);
-        d = convertDateYMS(gdi.getText("Date"), st, true);
+        d = convertDateYMD(gdi.getText("Date"), st, true);
         ii.setBgColor(t == -1 ? colorLightRed: colorDefault);
       }
       else {
         t = convertAbsoluteTimeHMS(gdi.getText("FirstStart"), -1);
-        d = convertDateYMS(ii.text, st, true);
+        d = convertDateYMD(ii.text, st, true);
         ii.setBgColor(d <= 0 ? colorLightRed: colorDefault);
       }
 
diff --git a/code/oBase.cpp b/code/oBase.cpp
index 9a529b2..f530acf 100644
--- a/code/oBase.cpp
+++ b/code/oBase.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -140,18 +140,18 @@ bool oBase::synchronize(bool writeOnly)
   return true;
 }
 
-void oBase::setExtIdentifier(__int64 id)
+void oBase::setExtIdentifier(int64_t id)
 {
   getDI().setInt64("ExtId", id);
 }
 
-__int64 oBase::getExtIdentifier() const
+int64_t oBase::getExtIdentifier() const
 {
   return getDCI().getInt64("ExtId");
 }
 
 wstring oBase::getExtIdentifierString() const {
-  __int64 raw = getExtIdentifier();
+  int64_t raw = getExtIdentifier();
   wchar_t res[16];
   if (raw == 0)
     return L"";
@@ -164,7 +164,7 @@ wstring oBase::getExtIdentifierString() const {
   return res;
 }
 
-void oBase::converExtIdentifierString(__int64 raw, wchar_t bf[16])  {
+void oBase::converExtIdentifierString(int64_t raw, wchar_t bf[16])  {
   if (raw & BaseGenStringFlag)
     convertDynamicBase(raw & ExtStringMask, 256-32, bf);
   else if (raw & Base36StringFlag)
@@ -173,8 +173,8 @@ void oBase::converExtIdentifierString(__int64 raw, wchar_t bf[16])  {
     convertDynamicBase(raw, 10, bf);
 }
 
-__int64 oBase::converExtIdentifierString(const wstring &str) {
-  __int64 val;
+int64_t oBase::converExtIdentifierString(const wstring &str) {
+  int64_t val;
     int base = convertDynamicBase(str, val);
   if (base == 36)
     val |= Base36StringFlag;
@@ -184,16 +184,16 @@ __int64 oBase::converExtIdentifierString(const wstring &str) {
 }
 
 void oBase::setExtIdentifier(const wstring &str) {
-  __int64 val = converExtIdentifierString(str);
+  int64_t val = converExtIdentifierString(str);
   setExtIdentifier(val);
 }
 
-int oBase::idFromExtId(__int64 val) {
+int oBase::idFromExtId(int64_t val) {
   int basePart = int(val & 0x0FFFFFFF);
   if (basePart == val)
     return basePart;
 
-  __int64 hash = (val&ExtStringMask) % 2000000011ul;
+  int64_t hash = (val&ExtStringMask) % 2000000011ul;
   
   int res = basePart + int(hash&0xFFFFFF);
   if (res == 0)
@@ -203,7 +203,7 @@ int oBase::idFromExtId(__int64 val) {
 }
 
 bool oBase::isStringIdentifier() const {
-  __int64 raw = getExtIdentifier();
+  int64_t raw = getExtIdentifier();
   return (raw & (BaseGenStringFlag|Base36StringFlag)) != 0;
 }
 
diff --git a/code/oBase.h b/code/oBase.h
index 03cc209..74938e0 100644
--- a/code/oBase.h
+++ b/code/oBase.h
@@ -5,7 +5,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -57,18 +57,16 @@ public:
     Quiet,
     Update
   };
-
-private:
-
 protected:
   int Id;
   TimeStamp Modified;
   string sqlUpdated; //SQL TIMESTAMP
 
-private:
   const static unsigned long long BaseGenStringFlag = 1ull << 63;
   const static unsigned long long Base36StringFlag = 1ull << 62;
   const static unsigned long long ExtStringMask = ~(BaseGenStringFlag | Base36StringFlag);
+
+private: 
   shared_ptr<oBaseReference> myReference;
 
 protected:
@@ -174,10 +172,10 @@ public:
   virtual bool canRemove() const = 0;
 
   /// Set an external identifier (0 if none)
-  void setExtIdentifier(__int64 id);
+  void setExtIdentifier(int64_t id);
 
   /// Get an external identifier (or 0) if none
-  __int64 getExtIdentifier() const;
+  int64_t getExtIdentifier() const;
 
   wstring getExtIdentifierString() const;
   void setExtIdentifier(const wstring &str);
@@ -185,9 +183,9 @@ public:
 
   // Convert an external to a int id. The result
   // need not be unique, of course.
-  static int idFromExtId(__int64 extId);
-  static void converExtIdentifierString(__int64 raw, wchar_t bf[16]);
-  static __int64 converExtIdentifierString(const wstring &str);
+  static int idFromExtId(int64_t extId);
+  static void converExtIdentifierString(int64_t raw, wchar_t bf[16]);
+  static int64_t converExtIdentifierString(const wstring &str);
 
   oBase(oEvent *poe);
   oBase(const oBase &in);
diff --git a/code/oCard.cpp b/code/oCard.cpp
index 4f74900..78bd2bd 100644
--- a/code/oCard.cpp
+++ b/code/oCard.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -132,13 +132,17 @@ const wstring &oCard::getCardNoString() const {
   return itow(cardNo);
 }
 
-void oCard::addPunch(int type, int time, int matchControlId, int unit) {
+void oCard::addPunch(int type, int time, int matchControlId, int unit, PunchOrigin origin) {
   oPunch p(oe);
   p.punchTime = time;
   p.type = type;
   p.tMatchControlId = matchControlId;
   p.isUsed =  matchControlId!=0;
   p.punchUnit = unit;
+  if (origin == PunchOrigin::Original)
+    p.origin = p.computeOrigin(oe->getZeroTimeNum() + time, type);
+  else if (origin == PunchOrigin::Manual)
+    p.origin = -1;
 
   if (punches.empty())
     punches.push_back(p);
@@ -288,9 +292,9 @@ bool oCard::fillPunches(gdioutput &gdi, const string &name, oCourse *crs) {
         }
 
         wstring tadj;
-        if (currentTimeAdjust != it->tTimeAdjust) {
-          int adj = it->tTimeAdjust - currentTimeAdjust;
-          currentTimeAdjust = it->tTimeAdjust;
+        if (currentTimeAdjust != it->tTimeAdjust.second) {
+          int adj = it->tTimeAdjust.second - currentTimeAdjust;
+          currentTimeAdjust = it->tTimeAdjust.second;
           if (adj > 0)
             tadj = L" +" + formatTime(adj);
           else
@@ -747,8 +751,8 @@ void oCard::setupFromRadioPunches(oRunner &r) {
   oe->getPunchesForRunner(r.getId(), true, p);
 
   for (size_t k = 0; k < p.size(); k++)
-    addPunch(p[k]->type, p[k]->punchTime, 0, p[k]->punchUnit);
-
+    addPunch(p[k]->type, p[k]->punchTime, 0, p[k]->punchUnit, p[k]->isOriginal() ? oCard::PunchOrigin::Original : oCard::PunchOrigin::Manual);
+  
   cardNo = r.getCardNo();
   readId = ConstructedFromPunches; //Indicates
 }
@@ -815,7 +819,7 @@ wstring oCard::getCardVoltage() const {
 }
 
 wstring oCard::getCardVoltage(int miliVolt) {
-  if (miliVolt == 0)
+  if (miliVolt <= 10)
     return L"";
   int vi = miliVolt / 1000;
   int vd = (miliVolt % 1000) / 10;
@@ -830,9 +834,9 @@ oCard::BatteryStatus oCard::isCriticalCardVoltage() const {
 }
 
 oCard::BatteryStatus oCard::isCriticalCardVoltage(int miliVolt)  {
-  if (miliVolt > 0 && miliVolt < 2445)
+  if (miliVolt > 10 && miliVolt < 2445)
     return BatteryStatus::Bad;
-  else if (miliVolt > 0 && miliVolt <= 2710)
+  else if (miliVolt > 10 && miliVolt <= 2710)
     return BatteryStatus::Warning;
 
   return BatteryStatus::OK;
@@ -843,3 +847,20 @@ wstring oCard::getBatteryDate() const {
     return formatDate(batteryDate, false);
   return _EmptyWString;
 }
+
+oCard::PunchOrigin oCard::isOriginalCard() const {
+  bool isUnknown = false;
+  for (auto& p : punches) {
+    if (p.origin == 0) {
+      isUnknown = true;
+    }
+    else {
+      if (!p.isOriginal())
+        return PunchOrigin::Manual;
+    }
+  }
+  if (isUnknown)
+    return PunchOrigin::Unknown;
+  else
+    return PunchOrigin::Original;
+}
\ No newline at end of file
diff --git a/code/oCard.h b/code/oCard.h
index 988adab..736cf82 100644
--- a/code/oCard.h
+++ b/code/oCard.h
@@ -11,7 +11,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -62,7 +62,7 @@ protected:
   pRunner tOwner;
   oPunch *getPunch(const pPunch punch);
 
-  int getDISize() const {return -1;}
+  int getDISize() const final {return -1;}
 
   /** Get internal data buffers for DI */
   oDataContainer &getDataBuffers(pvoid &data, pvoid &olddata, pvectorstr &strData) const;
@@ -125,7 +125,15 @@ public:
 
   bool fillPunches(gdioutput &gdi, const string &name, oCourse *crs);
 
-  void addPunch(int type, int time, int matchControlId, int unit);
+  enum class PunchOrigin {
+    Unknown,
+    Original,
+    Manual,
+  };
+
+  PunchOrigin isOriginalCard() const;
+
+  void addPunch(int type, int time, int matchControlId, int unit, PunchOrigin origin);
   oPunch *getPunchByType(int type) const;
 
   //Get punch by (matched) control punch id.
diff --git a/code/oClass.cpp b/code/oClass.cpp
index 20fece6..ca8dda9 100644
--- a/code/oClass.cpp
+++ b/code/oClass.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -404,7 +404,7 @@ int oClass::getNumRunners(bool checkFirstLeg, bool noCountVacant, bool noCountNo
     }
   }
   string key = getCountTypeKey(checkFirstLeg ? 0 : -1, 
-                               noCountNotCompeting ? CountKeyType::All : CountKeyType::IncludeNotCompeting,
+                               noCountNotCompeting ? CountKeyType::AllCompeting : CountKeyType::IncludeNotCompeting,
                                !noCountVacant);
 
   auto res = tTypeKeyToRunnerCount.second.find(key);
@@ -419,7 +419,7 @@ int oClass::getNumRunners(bool checkFirstLeg, bool noCountVacant, bool noCountNo
       continue;
     if (noCountVacant && r.isVacant())
       continue;
-    if (noCountNotCompeting && r.getStatus() == StatusNotCompetiting)
+    if (noCountNotCompeting && (r.getStatus() == StatusNotCompetiting || r.getStatus() == StatusCANCEL))
       continue;
 
     int id = r.getClassId(true);
@@ -476,8 +476,8 @@ void oClass::getNumResults(int leg, int &total, int &finished, int &dns) const {
     ClassType ct = c.getClassType();
     auto &cc = cnt[c.Id];
     cc.maxleg = c.getLastStageIndex();
-    if (ct == oClassKnockout)
-      cc.singleClass = true || cc.maxleg == 1;
+    if (ct == oClassKnockout || cc.maxleg == 0)
+      cc.singleClass = true;
 
     if (!(ct == oClassIndividual || ct == oClassIndividRelay || ct == oClassKnockout))
       cnt[c.Id].team = true;
@@ -946,16 +946,16 @@ bool oClass::restartIgnored(int i) const
   return false;
 }
 
-void oClass::fillStartTypes(gdioutput &gdi, const string &name, bool firstLeg)
-{
-  gdi.clearList(name);
+void oClass::fillStartTypes(gdioutput &gdi, const string &name, bool firstLeg) {
+  vector<pair<wstring, size_t>> d;  
+  d.emplace_back(lang.tl("Starttid"), STTime);
+  if (!firstLeg)
+    d.emplace_back(lang.tl("Växling"), STChange);
+  d.emplace_back(lang.tl("Tilldelad"), STDrawn);
+  if (!firstLeg)
+    d.emplace_back(lang.tl("Jaktstart"), STPursuit);
 
-  gdi.addItem(name, lang.tl("Starttid"), STTime);
-  if (!firstLeg)
-    gdi.addItem(name, lang.tl("Växling"), STChange);
-  gdi.addItem(name, lang.tl("Tilldelad"), STDrawn);
-  if (!firstLeg)
-    gdi.addItem(name, lang.tl("Jaktstart"), STPursuit);
+  gdi.setItems(name, d);
 }
 
 StartTypes oClass::getStartType(int leg) const
@@ -1246,7 +1246,7 @@ void oClass::setRopeTime(int leg, const wstring &t)
 
 void oClass::fillLegTypes(gdioutput &gdi, const string &name)
 {
-  vector< pair<wstring, size_t> > types;
+  vector<pair<wstring, size_t>> types;
   types.push_back( make_pair(lang.tl("Normal"), LTNormal));
   types.push_back( make_pair(lang.tl("Parallell"), LTParallel));
   types.push_back( make_pair(lang.tl("Valbar"), LTParallelOptional));
@@ -1255,22 +1255,24 @@ void oClass::fillLegTypes(gdioutput &gdi, const string &name)
   types.push_back( make_pair(lang.tl("Medlöpare"), LTIgnore));
   types.push_back( make_pair(lang.tl("Gruppera"), LTGroup));
 
-  gdi.addItem(name, types);
+  gdi.setItems(name, types);
 }
 
-void oEvent::fillClasses(gdioutput &gdi, const string &id, ClassExtra extended, ClassFilter filter)
+void oEvent::fillClasses(gdioutput &gdi, const string &id, const vector<pair<wstring, size_t>>& extraItems, ClassExtra extended, ClassFilter filter)
 {
-  vector< pair<wstring, size_t> > d;
+  vector<pair<wstring, size_t>> d;
   oe->fillClasses(d, extended, filter);
-  gdi.addItem(id, d);
+  for (auto& ex : extraItems)
+    d.push_back(ex);
+  gdi.setItems(id, d);
 }
 
 const vector< pair<wstring, size_t> > &oEvent::fillClasses(vector< pair<wstring, size_t> > &out,
-                                                          ClassExtra extended, ClassFilter filter)
-{
+                                                          ClassExtra extended, ClassFilter filter) {
   set<int> undrawn;
   set<int> hasRunner;
   out.clear();
+  out.reserve(Classes.size() + 2);
   if (extended == extraDrawn) {
     oRunnerList::iterator rit;
 
@@ -1309,8 +1311,7 @@ const vector< pair<wstring, size_t> > &oEvent::fillClasses(vector< pair<wstring,
         continue;
 
       if (extended == extraNone)
-        out.push_back(make_pair(it->Name, it->Id));
-        //gdi.addItem(name, it->Name, it->Id);
+        out.emplace_back(it->Name, it->Id);
       else if (extended == extraDrawn) {
         wchar_t bf[256];
 
@@ -1321,8 +1322,7 @@ const vector< pair<wstring, size_t> > &oEvent::fillClasses(vector< pair<wstring,
         else {
           swprintf_s(bf, L"%s\t[S]", it->Name.c_str());
         }
-        out.push_back(make_pair(wstring(bf), it->Id));
-        //gdi.addItem(name, bf, it->Id);
+        out.emplace_back(bf, it->Id);
       }
       else if (extended == extraNumMaps) {
         wchar_t bf[256];
@@ -1332,7 +1332,7 @@ const vector< pair<wstring, size_t> > &oEvent::fillClasses(vector< pair<wstring,
         else
           swprintf_s(bf, L"%s ( - %s)", it->Name.c_str(), lang.tl(L"kartor").c_str());
 
-        out.push_back(make_pair(wstring(bf), it->Id));
+        out.emplace_back(bf, it->Id);
       }
     }
   }
@@ -2731,6 +2731,17 @@ bool oClass::hasFreeStart() const
   return fs;
 }
 
+void oClass::setRequestStart(bool quick)
+{
+  getDI().setInt("RequestStart", quick);
+}
+
+bool oClass::hasRequestStart() const
+{
+  bool fs = getDCI().getInt("RequestStart") != 0;
+  return fs;
+}
+
 void oClass::setDirectResult(bool quick)
 {
   getDI().setInt("DirectResult", quick);
@@ -2756,7 +2767,7 @@ void oEvent::fillStarts(gdioutput &gdi, const string &id)
 {
   vector< pair<wstring, size_t> > d;
   oe->fillStarts(d);
-  gdi.addItem(id, d);
+  gdi.setItems(id, d);
 }
 
 const vector< pair<wstring, size_t> > &oEvent::fillStarts(vector< pair<wstring, size_t> > &out)
@@ -2782,7 +2793,7 @@ void oEvent::fillClassTypes(gdioutput &gdi, const string &id)
 {
   vector< pair<wstring, size_t> > d;
   oe->fillClassTypes(d);
-  gdi.addItem(id, d);
+  gdi.setItems(id, d);
 }
 
 ClassMetaType oClass::interpretClassType() const {
@@ -3127,8 +3138,11 @@ bool oClass::isSingleRunnerMultiStage() const
 int oClass::getEntryFee(const wstring &date, int age) const
 {
   oDataConstInterface odc = oe->getDCI();
-  wstring oentry = odc.getDate("OrdinaryEntry");
-  bool late = date > oentry && oentry>=L"2010-01-01";
+  wstring ordEntry = odc.getDate("OrdinaryEntry");
+  wstring lateEntry = odc.getDate("SecondEntryDate");
+  bool late = date > ordEntry && ordEntry>=L"2010-01-01";
+  bool late2 = date >= lateEntry && lateEntry >= L"2010-01-01";
+
   bool reduced = false;
 
   if (age > 0) {
@@ -3138,20 +3152,29 @@ int oClass::getEntryFee(const wstring &date, int age) const
   }
 
   if (reduced) {
+    int veryHigh = getDCI().getInt("SecondHighClassFeeRed");
     int high = getDCI().getInt("HighClassFeeRed");
     int normal = getDCI().getInt("ClassFeeRed");
 
     // Only return these fees if set
-    if (high>0 && late)
+    if (late2 && veryHigh > 0)
+      return veryHigh;
+    else if (late && high>0)
       return high;
     else if (normal>0)
       return normal;
   }
 
-  if (late)
-    return getDCI().getInt("HighClassFee");
+  int veryHigh = getDCI().getInt("SecondHighClassFee");
+  int high = getDCI().getInt("HighClassFee");
+  int normal = getDCI().getInt("ClassFee");
+
+  if (late2 && veryHigh > 0)
+    return high;
+  if (late && high > 0)
+    return high;
   else
-    return getDCI().getInt("ClassFee");
+    return normal;
 }
 
 void oClass::addClassDefaultFee(bool resetFee) {
@@ -3160,7 +3183,6 @@ void oClass::addClassDefaultFee(bool resetFee) {
   if (fee == 0 || resetFee) {
     assignTypeFromName();
     ClassMetaType type = interpretClassType();
-   // if (type.empty())
     switch (type) {
       case ctElite:
         fee = oe->getDCI().getInt("EliteFee");
@@ -3172,12 +3194,11 @@ void oClass::addClassDefaultFee(bool resetFee) {
         fee = oe->getDCI().getInt("EntryFee");
     }
 
-    int reducedFee = oe->getDCI().getInt("YouthFee");
+    const int reducedFee = oe->getDCI().getInt("YouthFee");
 
     double factor = 1.0 + 0.01 * _wtof(oe->getDCI().getString("LateEntryFactor").c_str());
     int lateFee = fee;
     int lateReducedFee = reducedFee;
-
     if (factor > 1) {
       lateFee = int(fee*factor + 0.5);
       lateReducedFee = int(reducedFee*factor + 0.5);
@@ -3186,6 +3207,17 @@ void oClass::addClassDefaultFee(bool resetFee) {
     getDI().setInt("HighClassFee", lateFee);
     getDI().setInt("ClassFeeRed", reducedFee);
     getDI().setInt("HighClassFeeRed", lateReducedFee);
+
+    double factor2 = 1.0 + 0.01 * _wtof(oe->getDCI().getString("SecondEntryFactor").c_str());
+    int lateFee2 = 0;
+    int lateReducedFee2 = 0;
+    if (factor > 1) {
+      lateFee2 = int(fee * factor2 + 0.5);
+      lateReducedFee2 = int(reducedFee * factor2 + 0.5);
+    }
+
+    getDI().setInt("SecondHighClassFee", lateFee2);
+    getDI().setInt("SecondHighClassFeeRed", lateReducedFee2);
   }
 }
 
@@ -3371,6 +3403,29 @@ int oClass::getLegPlace(int ifrom, int ito, int time) const
   return 0;
 }
 
+int oClass::getAccLegControlLeader(int teamLeg, int courseControlId) const {
+  if (teamLeg < teamLegCourseControlToLeaderPlace.size()) {
+    auto res = teamLegCourseControlToLeaderPlace[teamLeg].find(courseControlId);
+    if (res != teamLegCourseControlToLeaderPlace[teamLeg].end()) {
+      return res->second.leader;
+    }
+  }
+  return 0;
+}
+
+int oClass::getAccLegControlPlace(int teamLeg, int courseControlId, int time) const {
+  if (teamLeg < teamLegCourseControlToLeaderPlace.size()) {
+    auto res = teamLegCourseControlToLeaderPlace[teamLeg].find(courseControlId);
+    if (res != teamLegCourseControlToLeaderPlace[teamLeg].end()) {
+      auto& timeToPlace = res->second.timeToPlace;
+      auto v = timeToPlace.find(time);
+      if (v != timeToPlace.end())
+        return v->second;
+    }
+  }
+  return 0;
+}
+
 void oClass::insertAccLegPlace(int courseId, int controlNo, int time, int place)
 { /*
   char bf[256];
@@ -3441,7 +3496,6 @@ int oClass::getAccLegPlace(int courseId, int controlNo, int time) const
   return 0;
 }
 
-
 void oClass::calculateSplits() {
   clearSplitAnalysis();
   set<pCourse> cSet;
@@ -3460,33 +3514,50 @@ void oClass::calculateSplits() {
   LegResult legBestTime;
   vector<pRunner> rCls;
   oe->getRunners(Id, -1, rCls, false);
-  /*
-  if (isQualificationFinalBaseClass() || isQualificationFinalBaseClass()) {
-    
-    for (auto &r : oe->Runners) {
-      if (!r.isRemoved() && r.getClassRef(true) == this)
-        rCls.push_back(&r);
+
+  for (pRunner it : rCls) {
+    pCourse tpc = it->getCourse(false);
+    if (tpc == nullptr)
+      continue;
+    cSet.insert(tpc);
+  }
+
+  map<int, vector<pRunner>> rClsCrs;
+  if (cSet.size() > 1) {
+    for (pRunner it : rCls) {
+      pCourse tpc = it->getCourse(false);
+      if (tpc)
+        rClsCrs[tpc->getId()].push_back(it);
     }
   }
-  else {
-    for (auto &r : oe->Runners) {
-      if (!r.isRemoved() && r.Class == this)
-        rCls.push_back(&r);
-    }
-  }*/
 
-  for (set<pCourse>::iterator cit = cSet.begin(); cit!= cSet.end(); ++cit)  {
-    pCourse pc = *cit;
+  bool multiLeg = getNumStages() > 1; // Perhaps ignore parallell legs...
+
+  if (multiLeg) {
+    teamLegCourseControlToLeaderPlace.resize(getNumStages());
+    for (auto& lp : teamLegCourseControlToLeaderPlace)
+      lp.clear();
+  }
+  else {
+    teamLegCourseControlToLeaderPlace.clear();
+  }
+
+  for (pCourse pc : cSet) {
     // Store all split times in a matrix
     const unsigned nc = pc->getNumControls();
     if (nc == 0)
       return;
 
-    vector< vector<int> > splits(nc+1);
-    vector< vector<int> > splitsAcc(nc+1);
-    vector<bool> acceptMissingPunch(nc+1, true);
+    vector<vector<int>> splits(nc+1);
+    vector<vector<int>> splitsAcc(nc+1);
+    vector<int8_t> acceptMissingPunch(nc+1, true);
+    vector<pRunner>* rList;
+    if (rClsCrs.empty())
+      rList = &rCls;
+    else
+      rList = &rClsCrs[pc->getId()];
 
-    for (pRunner it : rCls) {
+    for (pRunner it : *rList) {
       pCourse tpc = it->getCourse(false);
       if (tpc != pc || tpc == 0)
         continue;
@@ -3504,7 +3575,7 @@ void oClass::calculateSplits() {
       }
     }
 
-    for (pRunner it : rCls) {
+    for (pRunner it : *rList) {
       pCourse tpc = it->getCourse(false);
 
       if (tpc != pc)
@@ -3513,17 +3584,46 @@ void oClass::calculateSplits() {
       const vector<SplitData> &sp = it->getSplitTimes(true);
       const int s = min<int>(nc, sp.size());
 
+      int off = -1;
+      unordered_map<int, PlaceTime>* teamAccTimes = nullptr;
+      if (multiLeg && it->tInTeam) 
+        off = it->tInTeam->getTotalRunningTimeAtLegStart(it->tLeg, false);
+
+      if (off >= 0 && it->tLeg < teamLegCourseControlToLeaderPlace.size()) 
+        teamAccTimes = &teamLegCourseControlToLeaderPlace[it->tLeg];
+
       vector<int> &tLegTimes = it->tLegTimes;
       tLegTimes.resize(nc + 1);
       bool ok = true;
 
+      // Acc team finish time
+      if (teamAccTimes && it->FinishTime > 0 && (it->tStatus == StatusOK || it->tStatus == StatusUnknown)) {
+        int ccId = oPunch::PunchFinish;
+        int t = it->getRunningTime(false);
+        auto& res = (*teamAccTimes)[ccId];
+        if (res.leader <= 0 || res.leader > t + off)
+          res.leader = t + off;
+        // Count times
+        ++res.timeToPlace[t + off];
+      }
+
       for (int k = 0; k < s; k++) {
         if (sp[k].getTime(true) > 0) {
           if (ok) {
             // Store accumulated times
             int t = sp[k].getTime(true) - it->tStartTime;
-            if (it->tStartTime>0 && t>0)
+            if (it->tStartTime > 0 && t > 0) {
               splitsAcc[k].push_back(t);
+              if (teamAccTimes) {
+                int ccId = pc->getCourseControlId(k);
+                auto& res = (*teamAccTimes)[ccId];
+                if (res.leader <= 0 || res.leader > t + off)
+                  res.leader = t + off;
+
+                // Count times
+                ++res.timeToPlace[t + off];
+              }
+            }
           }
 
           if (k == 0) { // start -> first
@@ -3546,7 +3646,7 @@ void oClass::calculateSplits() {
           }
         }
         else
-          ok = acceptMissingPunch[k];
+          ok = acceptMissingPunch[k] != 0;
       }
 
       // last -> finish
@@ -3636,8 +3736,7 @@ void oClass::calculateSplits() {
     }
   }
 
-  for (set<pCourse>::iterator cit = cSet.begin(); cit != cSet.end(); ++cit)  {
-    pCourse pc = *cit;
+  for (pCourse pc : cSet)  {
     const unsigned nc = pc->getNumControls();
     vector<int> normRes(nc+1);
     vector<int> bestRes(nc+1);
@@ -3655,6 +3754,18 @@ void oClass::calculateSplits() {
     swap(tSplitAnalysisData[pc->getId()], normRes);
     swap(tCourseLegLeaderTime[pc->getId()], bestRes);
   }
+
+  // Convert number of competitors with time to place
+  for (auto& courseControlLeaderPlace : teamLegCourseControlToLeaderPlace) {
+    for (auto& leaderPlace : courseControlLeaderPlace) {
+      int place = 1;
+      for (auto& numTimes : leaderPlace.second.timeToPlace) {
+        int num = numTimes.second;
+        numTimes.second = place;
+        place += num;
+      }
+    }
+  }
 }
 
 bool oClass::isRogaining() const {
@@ -4924,18 +5035,22 @@ int oClass::getNumQualificationFinalClasses() const {
   return 0;
 }
 
-void oClass::loadQualificationFinalScheme(const wstring &fileName) {
+void oClass::loadQualificationFinalScheme(const QualificationFinal& scheme) {
   auto qf = make_shared<QualificationFinal>(MaxClassId, Id);
-  qf->import(fileName);
+  qf->setClasses(scheme.getClasses());
   wstring enc;
   qf->encode(enc);
-  int ns = qf->getNumStages();
+  
+  const int oldNS = getNumStages();
+  const int ns = qf->getNumStages();
+
   setNumStages(ns);
   for (int i = 1; i < ns; i++) {
     setStartType(i, StartTypes::STDrawn, true);
     setLegType(i, LegTypes::LTNormal);
     setLegRunner(i, 0);
   }
+
   // Clear any old scheme
   clearQualificationFinal();
   qualificatonFinal = qf;
@@ -4956,48 +5071,82 @@ void oClass::loadQualificationFinalScheme(const wstring &fileName) {
       r.synchronizeAll();
     }
   }
+
+  if (oldNS != ns) {
+    for (oRunner& r : oe->Runners) {
+      r.createMultiRunner(true, true);
+    }
+  }
 }
 
-void oClass::updateFinalClasses(oRunner *causingResult, bool updateStartNumbers) {
+void oClass::updateFinalClasses(oRunner* causingResult, bool updateStartNumbers) {
   if (!qualificatonFinal)
     return;
   assert(!causingResult || causingResult->Class == this);
 
   //oe->gdibase.addStringUT(0, L"UF:" + getName() + L" for " + (causingResult ? causingResult->getName() : L"-"));
-
-  int instance = causingResult ? causingResult->classInstance() : 0;
-  pClass currentInst = getVirtualClass(instance, false);
-  if (qualificatonFinal->isFinalClass(instance))
+  auto computeInstance = [this](const pRunner causingResult) {
+    if (causingResult) {
+      int instance = causingResult->classInstance();
+      pClass currentInst = getVirtualClass(instance, false);
+      if (qualificatonFinal->isFinalClass(instance))
+        return -1; // Final class
+      if (instance > 0) {
+        int baseLevel = qualificatonFinal->getLevel(instance);
+        instance = qualificatonFinal->getMinInstance(baseLevel);
+      }
+      return instance;
+    }
+    return 0;
+  };
+  const int baseInstance = computeInstance(causingResult);
+  if (baseInstance < 0)
     return; // Final class
-  if (instance > 0) {
-    int baseLevel = qualificatonFinal->getLevel(instance);
-    instance = qualificatonFinal->getMinInstance(baseLevel);
-  }
+  int instance = baseInstance;
+
   int maxDepth = getNumStages();
   bool needIter = true;
-  int limit = virtualClasses.size() - 1;
+  const int limit = virtualClasses.size() - 1;
   bool wasReset = false;
 
+  // Store all runners for the class (and runners explicitly set to final class)
+  // Second becomes true for a runner that is qualified  
+  vector<pair<pRunner, bool>> clsRunners;
+  for (oRunner& r : oe->Runners) {
+    if (r.isRemoved() || !r.Class)
+      continue;
+
+    if (r.Class != this && (r.Class->getId() % MaxClassId) != getId())
+      continue;
+
+    clsRunners.emplace_back(&r, r.Class != this);
+  }
+
+  unordered_set<int> qualifiedRunners;
+  unordered_set<int> unQualifiedRunners;
+  unordered_set<int> superQualifiedNext;
+  vector<vector<pRunner>> classSplit(virtualClasses.size());
+  vector<vector<pRunner>> nonQualifiedLevel(getNumStages());
+
   while (needIter && --maxDepth > 0) {
     needIter = false;
     if (size_t(instance) >= virtualClasses.size())
       break; // Final class
 
-    vector< vector<pRunner> > classSplit(virtualClasses.size());
-    vector<pRunner> nonQualified;
-
-    for (oRunner &r : oe->Runners) {
-      if (r.isRemoved() || !r.Class)
-        continue;
-
-      if (r.Class != this && (r.Class->getId() % MaxClassId) != getId())
-        continue;
+    for (auto& c : classSplit)
+      c.clear();
+    for (auto& nq : nonQualifiedLevel)
+      nq.clear();
 
+    for (size_t ix = 0; ix < clsRunners.size(); ix++) {
+      oRunner &r = *clsRunners[ix].first;
       int inst = r.Class == this ? r.classInstance() : (r.Class->getId() - getId()) / MaxClassId;
+      if (r.Class == this && unQualifiedRunners.count(r.getId()))
+        inst = 0;
 
       if (inst == 0 && r.tLeg > 0) {
-        if (r.tLeg < maxDepth - 1 && r.Class == this)
-          nonQualified.push_back(&r);
+        if (r.tLeg < getNumStages() && !clsRunners[ix].second)
+          nonQualifiedLevel[r.tLeg].push_back(&r);
         continue; // Only allow base class for leg 0.
       }
       if (inst < instance || inst >= limit)
@@ -5006,32 +5155,15 @@ void oClass::updateFinalClasses(oRunner *causingResult, bool updateStartNumbers)
       classSplit[inst].push_back(&r);
     }
 
-    // Reset non-qualified
-    if (!wasReset) {
-      for (size_t i = 0; i < nonQualified.size(); i++) {
-        pRunner r = nonQualified[i];
-        pRunner next = r->getMultiRunner(r->tLeg + 1);
-        if (next && next->getClassRef(true) != this) {
-          pClass nextCls = next->getClassRef(true);
-          if (!nextCls->lockedClassAssignment()) {
-            wasReset = true;
-            next->getDI().setInt("Heat", 0);
-            nonQualified.push_back(next);
-          }
-        }
-      }
-      if (wasReset) { // Only do this once.
-        maxDepth++;
-        needIter = true;
-        continue; // Redo
-      }
-    }
+    bool hasRemaining = qualificatonFinal->hasRemainingClass();
     GeneralResult gr;
     qualificatonFinal->prepareCalculations();
-
+    int maxLevel = 0;
     for (int i = instance; i < limit; i++) {
       if (classSplit[i].empty())
         continue;
+      const int thisLevel = qualificatonFinal->getLevel(i);
+      maxLevel = max(maxLevel, thisLevel);
 
       if (i == 0 && qualificatonFinal->noQualification(i)) {
         set<int> allowed;
@@ -5056,23 +5188,26 @@ void oClass::updateFinalClasses(oRunner *causingResult, bool updateStartNumbers)
 
             if (!lockedStartList) {
               classSplit[heat].push_back(r);
-              classSplit[0].erase(classSplit[0].begin() + rix);
+              classSplit[0][rix] = classSplit[0].back();
+              classSplit[0].pop_back();
+              //classSplit[0].erase(classSplit[0].begin() + rix);
               pClass oldClass = r->getClassRef(true);
               oldClass->markSQLChanged(-1, 0);
               di.setInt("Heat", heat);
               r->classInstanceRev.first = -1;
               r->synchronize();
+              oe->classIdToRunnerHash.reset();
             }
           }
         }
       }
 
       gr.calculateIndividualResults(classSplit[i], false, oListInfo::Classwise, true, 0);
+
       int lastPlace = 0, orderPlace = 1;
       int numEqual = 0;
       for (size_t k = 0; k < classSplit[i].size(); k++) {
         const auto &res = classSplit[i][k]->getTempResult();
-        //int heat = 0;
         if (res.getStatus() == StatusOK) {
           int place = res.getPlace();
           if (lastPlace == place)
@@ -5080,56 +5215,144 @@ void oClass::updateFinalClasses(oRunner *causingResult, bool updateStartNumbers)
           else
             numEqual = 0;
 
-          qualificatonFinal->setupNextFinal(classSplit[i][k], i, orderPlace, numEqual);
-          //auto nextFinal = qualificatonFinal->getNextFinal(i, orderPlace, numEqual);
-          //heat = nextFinal.first;
+          qualificatonFinal->provideQualificationResult(classSplit[i][k], i, orderPlace, numEqual);
           lastPlace = place;
         }
+        else if (hasRemaining && res.getStatus() != StatusUnknown) {
+          qualificatonFinal->provideUnqualified(thisLevel, classSplit[i][k]);
+        }
+
         orderPlace++;
       }
     }
 
+    if (hasRemaining) {
+      for (int level = 0; level < maxLevel; level++) {
+        vector<pair<int, pRunner>> sortedByResult;
+        sortedByResult.reserve(nonQualifiedLevel[level].size());
+        for (pRunner r : nonQualifiedLevel[level]) {
+          pRunner finalR = r;
+          int okCount = 0;
+          for (int i = 0; i <= r->tLeg; i++) {
+            if (r->getTeam() && r->getTeam()->getRunner(i)) {
+              pRunner rx = r->getTeam()->getRunner(i);
+              if (rx->getStatus() == StatusOK) {
+                finalR = rx;
+                okCount++;
+              }
+            }
+          }
+          int score = okCount * 10000;
+          if (finalR->getStatus() == StatusOK)
+            score -= finalR->getPlace();
+          sortedByResult.emplace_back(-score, r);
+        }
+        sort(sortedByResult.begin(), sortedByResult.end());
+
+        for (auto rr : sortedByResult)
+          qualificatonFinal->provideUnqualified(level, rr.second);
+      }
+    }
+
     qualificatonFinal->computeFinals();
 
-    for (int i = instance; i < limit; i++) {
-      if (classSplit[i].empty())
-        continue;
+    auto qualifyNext = [&](const oRunner& thisRunner, int thisLevel) {
+      auto res = qualificatonFinal->getNextFinal(thisRunner.getId());
+      int heat = res.first;
+      int nextLevel = qualificatonFinal->getLevel(heat);
+      int levelInc = max(1, nextLevel - thisLevel);
+      if (levelInc > 1) {
+        pRunner runnerBefore = thisRunner.getMultiRunner(thisRunner.getRaceNo() + levelInc - 1);
+        if (runnerBefore)
+          superQualifiedNext.insert(runnerBefore->getId());
+      }
+
+      pRunner runnerToChange = thisRunner.getMultiRunner(thisRunner.getRaceNo() + levelInc);
+
+      if (runnerToChange) {
+        auto di = runnerToChange->getDI();
+        int oldHeat = di.getInt("Heat");
+        if (heat != oldHeat) {
+          bool lockedStartList = (heat != 0 && getVirtualClass(heat)->lockedClassAssignment()) ||
+            (oldHeat != 0 && getVirtualClass(oldHeat)->lockedClassAssignment());
+
+          if (!lockedStartList) {
+            if (heat > 0)
+              qualifiedRunners.insert(runnerToChange->getId());
+            else if (oldHeat > 0)
+              unQualifiedRunners.insert(runnerToChange->getId());
+
+            pClass oldClass = runnerToChange->getClassRef(true);
+            oldClass->markSQLChanged(-1, 0);
+            di.setInt("Heat", heat);
+            runnerToChange->classInstanceRev.first = -1;
+            oe->classIdToRunnerHash.reset();
+
+            //oe->gdibase.addStringUT(0, L"HU:" + thisRunner.getName() + L" " + itow(oldHeat) + L"->" + itow(heat));
+            runnerToChange->apply(ChangeType::Quiet, nullptr);
+            runnerToChange->synchronize();
+            if (runnerToChange->getFinishTime() > 0)
+              needIter = true;
+          }
+        }
+        else {
+          if (heat > 0)
+            qualifiedRunners.insert(runnerToChange->getId());
+        }
+      }
+    };
+
+    for (int i = instance; i < limit; i++) {      
+      const int thisLevel = qualificatonFinal->getLevel(i);
+      const int nextLevel = qualificatonFinal->getLevel(i + 1);
 
       for (size_t k = 0; k < classSplit[i].size(); k++) {
-        oRunner &thisRunner = *classSplit[i][k];
-        pRunner runnerToChange = thisRunner.getMultiRunner(thisRunner.getRaceNo() + 1);
-
-        if (runnerToChange) {
-          auto res = qualificatonFinal->getNextFinal(thisRunner.getId());
-          int heat = res.first;
-
-          auto di = runnerToChange->getDI();
-          int oldHeat = di.getInt("Heat");
-          
-          if (heat != oldHeat) {
-            bool lockedStartList = (heat != 0 && getVirtualClass(heat)->lockedClassAssignment()) ||
-                                   getVirtualClass(oldHeat)->lockedClassAssignment();
-
-            if (!lockedStartList) {
-              pClass oldClass = runnerToChange->getClassRef(true);
-              oldClass->markSQLChanged(-1, 0);
-              di.setInt("Heat", heat);
-              runnerToChange->classInstanceRev.first = -1;
-              //oe->gdibase.addStringUT(0, L"HU:" + thisRunner.getName() + L" " + itow(oldHeat) + L"->" + itow(heat));
-              runnerToChange->apply(ChangeType::Quiet, nullptr);
-              runnerToChange->synchronize();
-              if (runnerToChange->getFinishTime() > 0)
-                needIter = true;
-            }
+        qualifyNext(*classSplit[i][k], thisLevel);
+      }
+      
+      if (hasRemaining) {
+        if (thisLevel != nextLevel) {
+          for (pRunner r : nonQualifiedLevel[thisLevel]) {
+            if (!superQualifiedNext.count(r->getId()))
+              qualifyNext(*r, thisLevel);
           }
         }
       }
-      if (needIter) {
+
+      if (thisLevel != nextLevel && needIter) {
         instance = i+1; // Need not process last class again
         break;
       }
     }
   }
+
+  int nextLevelInstance = baseInstance;
+  int baseLevel = qualificatonFinal->getLevel(baseInstance);
+  while (nextLevelInstance < limit && qualificatonFinal->getLevel(nextLevelInstance) == baseLevel)
+    nextLevelInstance++;
+
+  // Set runners that became unqualified
+  for (auto& cc : clsRunners) {
+    pRunner r = cc.first;
+    int inst = r->Class == this ? r->classInstance() : (r->Class->getId() - getId()) / MaxClassId;
+    
+    if (inst < nextLevelInstance)
+      continue;
+       
+    if (!cc.second && cc.first->tLeg > 0 && !qualifiedRunners.count(cc.first->getId())) {
+      auto di = cc.first->getDI();
+      int oldHeat = di.getInt("Heat");
+      if (oldHeat != 0 && !getVirtualClass(oldHeat)->lockedClassAssignment()) {
+        pClass oldClass = cc.first->getClassRef(true);
+        oldClass->markSQLChanged(-1, 0);
+        di.setInt("Heat", 0);
+        cc.first->classInstanceRev.first = -1;
+        oe->classIdToRunnerHash.reset();
+        cc.first->apply(ChangeType::Quiet, nullptr);
+        cc.first->synchronize();
+      }
+    }
+  }
 }
 
 vector<pair<wstring, size_t>> oClass::getAllFees() const {
diff --git a/code/oClass.h b/code/oClass.h
index a2fe093..0b7eb2b 100644
--- a/code/oClass.h
+++ b/code/oClass.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -25,6 +25,7 @@
 #include <vector>
 #include <set>
 #include <map>
+#include <unordered_map>
 #include "inthashmap.h"
 class oClass;
 typedef oClass* pClass;
@@ -260,9 +261,20 @@ protected:
   inthashmap *tLegTimeToPlace;
   inthashmap *tLegAccTimeToPlace;
 
+  struct PlaceTime {
+    int leader = -1;
+    map<int, int> timeToPlace;
+  };
+
+  vector<unordered_map<int, PlaceTime>> teamLegCourseControlToLeaderPlace;
+  
   void insertLegPlace(int from, int to, int time, int place);
   void insertAccLegPlace(int courseId, int controlNo, int time, int place);
 
+  /** Get relay/team accumulated leader time/place at control. */
+  int getAccLegControlLeader(int teamLeg, int courseControlId) const;
+  int getAccLegControlPlace(int teamLeg, int courseControlId, int time) const;
+     
   // For sub split times
   int tLegLeaderTime;
   mutable int tNoTiming;
@@ -280,8 +292,8 @@ protected:
   // Used to force show of full multi course dialog
   bool tShowMultiDialog;
 
-  static const int dataSize = 512;
-  int getDISize() const {return dataSize;}
+  static constexpr int dataSize = 512+64;
+  int getDISize() const final {return dataSize;}
 
   BYTE oData[dataSize];
   BYTE oDataOld[dataSize];
@@ -357,7 +369,7 @@ protected:
   mutable pair<int, map<string, int>> tTypeKeyToRunnerCount;
 
   enum CountKeyType {
-    All,
+    AllCompeting,
     Finished,
     ExpectedStarting,
     DNS,
@@ -382,9 +394,9 @@ public:
   /** The master class in a qualification/final scheme. */
   const pClass getParentClass() const { return parentClass; }
 
-  const QualificationFinal *getQualificationFinal() const {
+  const shared_ptr<QualificationFinal> &getQualificationFinal() const {
     reinitialize(false);
-    return qualificatonFinal.get();
+    return qualificatonFinal;
   }
 
   void clearQualificationFinal() const;
@@ -404,7 +416,7 @@ public:
 
   /** Returns the number of possible final classes.*/
   int getNumQualificationFinalClasses() const;
-  void loadQualificationFinalScheme(const wstring &fileName);
+  void loadQualificationFinalScheme(const QualificationFinal &scheme);
 
   void updateFinalClasses(oRunner *causingResult, bool updateStartNumbers);
 
@@ -604,6 +616,9 @@ public:
 
   void setFreeStart(bool freeStart);
   bool hasFreeStart() const;
+  
+  void setRequestStart(bool freeStart);
+  bool hasRequestStart() const;
 
   void setDirectResult(bool directResult);
   bool hasDirectResult() const;
@@ -620,7 +635,7 @@ public:
   bool hasTrueMultiCourse() const;
 
   unsigned getNumStages() const {return MultiCourse.size();}
-  /** Get the set of true legs, identifying parallell legs etc. Returns indecs into
+  /** Get the set of true legs, identifying parallell legs etc. Returns indices into
    legInfo of the last leg of the true leg (first), and true leg (second).*/
   struct TrueLegInfo {
   protected:
@@ -634,7 +649,9 @@ public:
 
   void getTrueStages(vector<TrueLegInfo> &stages) const;
 
-  unsigned getLastStageIndex() const {return max<signed>(MultiCourse.size(), 1)-1;}
+  unsigned getLastStageIndex() const {
+    return std::max<int>(MultiCourse.size(), 1) - 1;
+  }
 
   void setNumStages(int no);
 
diff --git a/code/oClub.cpp b/code/oClub.cpp
index 40f3beb..52398e1 100644
--- a/code/oClub.cpp
+++ b/code/oClub.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -263,7 +263,7 @@ void oEvent::fillClubs(gdioutput &gdi, const string &id)
 {
   vector< pair<wstring, size_t> > d;
   oe->fillClubs(d);
-  gdi.addItem(id, d);
+  gdi.setItems(id, d);
 }
 
 
@@ -530,7 +530,7 @@ void oClub::addRunnerInvoiceLine(const pRunner r, bool inTeam,
   }
 
   int fee = r->getDCI().getInt("Fee");
-  int card = r->getDCI().getInt("CardFee");
+  int card = r->getRentalCardFee(false);
   int paid = r->getDCI().getInt("Paid");
   int pm = r->getPaymentMode();
   
@@ -831,7 +831,7 @@ void oEvent::printInvoices(gdioutput &gdi, InvoicePrintType type,
     path.push_back('\\');
 
   if (toFile) {
-    ofstream fout;
+    std::ofstream fout;
 
     if (type == IPTElectronincHTML)
       fout.open((path + L"invoices.txt").c_str());
@@ -861,7 +861,7 @@ void oEvent::printInvoices(gdioutput &gdi, InvoicePrintType type,
         if (type == IPTElectronincHTML && pay > 0) {
           fout << it->getId() << ";" << gdi.toUTF8(it->getName()) << ";" <<
             nr << ";" << gdi.toUTF8(filename) << ";" << gdi.toUTF8(email) << ";"
-                << gdi.toUTF8(formatCurrency(pay))  <<endl;
+                << gdi.toUTF8(formatCurrency(pay))  << std::endl;
         }
 
         if (type == IPTAllPDF) {
@@ -1015,9 +1015,7 @@ void oEvent::setupClubInfoData() {
       bool skip = r.Class && r.Class->getClassStatus() == oClass::ClassStatus::InvalidRefund;
 
       if (!skip) {
-        int cardFee = di.getInt("CardFee");
-        if (cardFee < 0)
-          cardFee = 0;
+        int cardFee = r.getRentalCardFee(false);
         fee[id] += di.getInt("Fee") + cardFee;
       }
       paid[id] += di.getInt("Paid");
diff --git a/code/oClub.h b/code/oClub.h
index b72354e..8de45f0 100644
--- a/code/oClub.h
+++ b/code/oClub.h
@@ -11,7 +11,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -68,7 +68,7 @@ protected:
   wstring tPrettyName;
 
   static const int dataSize = 768;
-  int getDISize() const {return dataSize;}
+  int getDISize() const final {return dataSize;}
   BYTE oData[dataSize];
   BYTE oDataOld[dataSize];
 
diff --git a/code/oControl.cpp b/code/oControl.cpp
index a42b818..04f3aeb 100644
--- a/code/oControl.cpp
+++ b/code/oControl.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -253,7 +253,6 @@ bool oControl::hasNumberUnchecked(int i)
   else return true;
 }
 
-
 int oControl::getNumMulti()
 {
   if (Status== ControlStatus::StatusMultiple)
@@ -262,7 +261,6 @@ int oControl::getNumMulti()
     return 1;
 }
 
-
 wstring oControl::codeNumbers(char sep) const
 {
   wstring n;
@@ -553,6 +551,8 @@ wstring oControl::getRogainingPointsS() const
 }
 
 bool oControl::setTimeAdjust(int v) {
+  if (v == NOTIME)
+    v = 0;
   return getDI().setInt("TimeAdjust", v);
 }
 
@@ -716,7 +716,7 @@ void oEvent::setupControlStatistics() const {
 
   map<int, pair<int, vector<int> > > lostPerControl; // First is "actual" misses,
   vector<int> delta;
-  for (oRunnerList::const_iterator it = Runners.begin(); it != Runners.end(); ++it) {
+  for (auto it = Runners.begin(); it != Runners.end(); ++it) {
     if (it->isRemoved())
       continue;
     pCourse pc = it->getCourse(true);
@@ -725,14 +725,14 @@ void oEvent::setupControlStatistics() const {
     it->getSplitAnalysis(delta);
 
     int nc = pc->getNumControls();
-    if (delta.size()>unsigned(nc)) {
+    if (unsigned(nc) < delta.size()) {
       for (int i = 0; i<nc; i++) {
         pControl ctrl = pc->getControl(i);
         if (ctrl && delta[i]>0) {
-          if (delta[i] < 10 * 60)
+          if (delta[i] < 10 * timeConstMinute)
             ctrl->tMissedTimeTotal += delta[i];
           else
-            ctrl->tMissedTimeTotal += 10*60; // Use max 10 minutes
+            ctrl->tMissedTimeTotal += 10 * timeConstMinute; // Use max 10 minutes
 
           ctrl->tMissedTimeMax = max(ctrl->tMissedTimeMax, delta[i]);
         }
@@ -764,14 +764,26 @@ void oEvent::setupControlStatistics() const {
     if (!it->isRemoved()) {
       int id = it->getId();
 
-      map<int, pair<int, vector<int> > >::iterator res = lostPerControl.find(id);
+      auto res = lostPerControl.find(id);
       if (res != lostPerControl.end()) {
         if (!res->second.second.empty()) {
           sort(res->second.second.begin(), res->second.second.end());
-          int avg = res->second.second[res->second.second.size() / 2];
+          int nMistakes = res->second.second.size();
+          int avg;
+          if (nMistakes % 2 == 1)
+            avg = res->second.second[nMistakes / 2];
+          else
+            avg = (res->second.second[nMistakes / 2] + res->second.second[nMistakes / 2 -1]) / 2;
           it->tMissedTimeMedian = avg;
         }
-        it->tMistakeQuotient = (100 * res->second.first + 50) / it->tNumVisitorsActual; 
+        if (it->tNumVisitorsActual > 0)
+          it->tMistakeQuotient = (int)round((100.00 * res->second.first) / double(it->tNumVisitorsActual));
+        else
+          it->tMistakeQuotient = 0;
+      }
+      else {
+        it->tMistakeQuotient = 0;
+        it->tMissedTimeMedian = 0;
       }
     }
   }
@@ -823,7 +835,7 @@ void oEvent::fillControlStatus(gdioutput &gdi, const string& id) const
 {
   vector< pair<wstring, size_t> > d;
   oe->fillControlStatus(d);
-  gdi.addItem(id, d);
+  gdi.setItems(id, d);
 }
 
 
@@ -902,9 +914,9 @@ void oControl::addTableRow(Table &table) const {
 
   int nv = getNumVisitors(true);
   table.set(row++, it, 50, itow(nv), false);
-  table.set(row++, it, 51, nv > 0 ? formatTime(getMissedTimeMax()) : L"-", false);
-  table.set(row++, it, 52, nv > 0 ? formatTime(getMissedTimeTotal()/nv) : L"-", false);
-  table.set(row++, it, 53, nv > 0 ? formatTime(getMissedTimeMedian()) : L"-", false);
+  table.set(row++, it, 51, nv > 0 ? formatTime(getMissedTimeMax(), SubSecond::Off) : L"-", false);
+  table.set(row++, it, 52, nv > 0 ? formatTime(getMissedTimeTotal()/nv, SubSecond::Off) : L"-", false);
+  table.set(row++, it, 53, nv > 0 ? formatTime(getMissedTimeMedian(),  SubSecond::Off) : L"-", false);
 
   oe->oControlData->fillTableCol(it, table, true);
 }
@@ -1097,7 +1109,7 @@ int oEvent::getUnitAdjustment(oPunch::SpecialPunch type, int unit) const {
     for (auto& c : Controls) {
       if (!c.isRemoved() && c.isUnit()) {
         int adjust = c.getTimeAdjust();
-        if (adjust != 0)
+        if (adjust != 0 && adjust != NOTIME)
           typeUnitPunchTimeAdjustment.second.emplace(make_pair(c.getUnitType(), c.getUnitCode()), adjust);
       }
     }
diff --git a/code/oControl.h b/code/oControl.h
index 7bd6fcc..850de0c 100644
--- a/code/oControl.h
+++ b/code/oControl.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -81,7 +81,7 @@ protected:
   bool decodeNumbers(string s);
 
   static const int dataSize = 64;
-  int getDISize() const {return dataSize;}
+  int getDISize() const final {return dataSize;}
   BYTE oData[dataSize];
   BYTE oDataOld[dataSize];
 
diff --git a/code/oCourse.cpp b/code/oCourse.cpp
index 9a6d6d5..f69344c 100644
--- a/code/oCourse.cpp
+++ b/code/oCourse.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -612,10 +612,12 @@ pCourse oEvent::getCourse(const wstring &n) const {
   return 0;
 }
 
-void oEvent::fillCourses(gdioutput &gdi, const string &id, bool simple) {
-  vector< pair<wstring, size_t> > d;
+void oEvent::fillCourses(gdioutput &gdi, const string &id, const vector<pair<wstring, size_t>> &extraItems, bool simple) {
+  vector<pair<wstring, size_t>> d;
   oe->getCourses(d, L"", simple, true);
-  gdi.addItem(id, d);
+  for (auto& ex : extraItems)
+    d.push_back(ex);
+  gdi.setItems(id, d);
 }
 
 const vector< pair<wstring, size_t> > &oEvent::getCourses(vector<pair<wstring, size_t>>& out,
@@ -628,7 +630,7 @@ const vector< pair<wstring, size_t> > &oEvent::getCourses(vector<pair<wstring, s
   }
 
   vector<pair<pCourse, pair<pCourse, bool>> > ac;
-  ac.reserve(Courses.size());
+  ac.reserve(Courses.size()+2);
   map<int,int> id2ix;
   for (it=Courses.begin(); it != Courses.end(); ++it) {
     if (!it->Removed) {
@@ -653,7 +655,8 @@ const vector< pair<wstring, size_t> > &oEvent::getCourses(vector<pair<wstring, s
 
   vector<wchar_t> filt_lc(filter.length() + 1);
   wcscpy_s(filt_lc.data(), filt_lc.size(), filter.c_str());
-  CharLowerBuff(filt_lc.data(), filter.length());
+  prepareMatchString(filt_lc.data(), filter.length());
+
   int score;
   wstring b;
   for (size_t k = 0; k < ac.size(); k++) {
diff --git a/code/oCourse.h b/code/oCourse.h
index 620ef96..88b7beb 100644
--- a/code/oCourse.h
+++ b/code/oCourse.h
@@ -11,7 +11,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -59,7 +59,7 @@ protected:
   wstring Name;
   int Length;
   static const int dataSize = 128;
-  int getDISize() const {return dataSize;}
+  int getDISize() const final {return dataSize;}
 
   BYTE oData[dataSize];
   BYTE oDataOld[dataSize];
diff --git a/code/oDataContainer.cpp b/code/oDataContainer.cpp
index dabfe93..0055fd8 100644
--- a/code/oDataContainer.cpp
+++ b/code/oDataContainer.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -385,11 +385,15 @@ bool oDataContainer::setDate(void *data, const char *Name, const wstring &V)
   if (odi->Type!=oDTInt)
     throw std::exception("oDataContainer: Variable of wrong type.");
 
-  int year=0,month=0,day=0;
+  int C = convertDateYMD(V, true);
+  if (C <= 0) {
+    C = _wtoi(V.c_str());
+    if (V.length() >= 2 && (C > 0 && C < 100) || (C == 0 && V[0] == '0' && V[1] == '0'))
+      C = extendYear(C);
 
-  swscanf_s(V.c_str(), L"%d-%d-%d", &year, &month, &day);
-
-  int C=year*10000+month*100+day;
+    if (C < 1900 || C > 9999)
+      C = 0;
+  }
 
   LPBYTE vd=LPBYTE(data)+odi->Index;
   if (*((int *)vd)!=C){
@@ -468,7 +472,7 @@ bool oDataContainer::write(const oBase *ob, xmlparser &xml) const {
     const oDataInfo &di=ordered[kk];
     if (di.Type==oDTInt){
       LPBYTE vd=LPBYTE(data)+di.Index;
-      if (di.SubType == oISTime) {
+      if (di.SubType == oISTime || di.SubType == oISTimeAdjust) {
         int nr;
         memcpy(&nr, vd, sizeof(int));
         xml.writeTime(di.Name, nr);
@@ -528,10 +532,10 @@ void oDataContainer::set(oBase *ob, const xmlobject &xo) {
     if (odi) {
       if (odi->Type == oDTInt){
         LPBYTE vd=LPBYTE(data)+odi->Index;
-        if (odi->SubType == oISTime) 
+        if (odi->SubType == oISTime || odi->SubType == oISTimeAdjust)
           *((int *)vd) = it->getRelativeTime();
         else if (odi->SubType == oISDateOrYear) {
-          int val = convertDateYMS(it->getStr(), true);
+          int val = convertDateYMD(it->getStr(), true);
           if (val > 0)
             *((int*)vd) = val;
           else
@@ -582,7 +586,7 @@ vector<InputInfo *> oDataContainer::buildDataFields(gdioutput &gdi, const vector
     string Id=di.Name+string("_odc");
 
     if (di.Type==oDTInt){
-      if (di.SubType == oISDate || di.SubType == oISTime || di.SubType == oISDateOrYear)
+      if (di.SubType == oISDate || di.SubType == oISTime || di.SubType == oISTimeAdjust || di.SubType == oISDateOrYear)
         out.push_back(&gdi.addInput(Id, L"", 10, 0, gdi.widen(di.Description) + L":"));
       else
         out.push_back(&gdi.addInput(Id, L"", 6, 0, gdi.widen(di.Description) + L":"));
@@ -683,12 +687,12 @@ bool oDataContainer::saveDataFields(oBase *ob, gdioutput &gdi, std::set<string>
         no = ob->getEvent()->interpretCurrency(gdi.getText(Id.c_str()));
       }
       else if (di.SubType == oISDate) {
-        no = convertDateYMS(gdi.getText(Id.c_str()), true);
+        no = convertDateYMD(gdi.getText(Id.c_str()), true);
         if (no <= 0)
           no = 0;
       }
       else if (di.SubType == oISDateOrYear) {
-        no = convertDateYMS(gdi.getText(Id.c_str()), true);
+        no = convertDateYMD(gdi.getText(Id.c_str()), true);
         if (no <= 0) {
           no = gdi.getTextNo(Id.c_str());
           if (no < 1900 || no > 9999)
@@ -698,6 +702,9 @@ bool oDataContainer::saveDataFields(oBase *ob, gdioutput &gdi, std::set<string>
       else if (di.SubType == oISTime) {
         no = convertAbsoluteTimeHMS(gdi.getText(Id.c_str()), -1);
       }
+      else if (di.SubType == oISTimeAdjust) {
+        no = convertAbsoluteTimeMS(gdi.getText(Id.c_str()));
+      }
       else if (di.SubType == oISDecimal) {
         wstring str = gdi.getText(Id.c_str());
         for (size_t k = 0; k < str.length(); k++) {
@@ -845,7 +852,7 @@ string oDataContainer::generateSQLDefinition(const std::set<string> &exclude) co
       string name = di.Name;
       if (di.Type==oDTInt){
         if (di.SubType==oIS32 || di.SubType==oISDate || di.SubType==oISCurrency ||
-           di.SubType==oISTime || di.SubType==oISDecimal || di.SubType == oISDateOrYear)
+           di.SubType==oISTime  || di.SubType == oISTimeAdjust || di.SubType==oISDecimal || di.SubType == oISDateOrYear)
           sql+=C_INT(name);
         else if (di.SubType==oIS16)
           sql+=C_SMALLINT(name);
@@ -1174,7 +1181,7 @@ void oDataContainer::buildTableCol(Table *table)
     }
     else if (di.Type == oDTInt) {
       bool right = di.SubType == oISCurrency;
-      bool numeric = di.SubType != oISDate && di.SubType != oISTime && di.SubType != oISDateOrYear;
+      bool numeric = di.SubType != oISDate && di.SubType != oISTime && di.SubType != oISTimeAdjust && di.SubType != oISDateOrYear;
       int w;
       if (di.SubType == oISDecimal)
         w = max( (di.decimalSize+4)*10, 70);
@@ -1206,9 +1213,10 @@ void oDataContainer::buildTableCol(Table *table)
 
 bool oDataContainer::formatNumber(int nr, const oDataInfo &di, wchar_t bf[64]) const {
   if (di.SubType == oISDate) {
-    if (nr>9999 && nr < 99999999) {
-      swprintf_s(bf, 64, L"%d-%02d-%02d", nr/(100*100), (nr/100)%100, nr%100);
-    }
+    if ((nr < 99999999 && nr % 10000 != 0) || nr == 0)
+      swprintf_s(bf, 64, L"%d-%02d-%02d", nr / (100 * 100), (nr / 100) % 100, nr % 100);
+    else if (nr > 0  && nr < 9999)
+      swprintf_s(bf, 64, L"%04d", nr / 10000);
     else {
       bf[0] = '-';
       bf[1] = 0;
@@ -1216,12 +1224,12 @@ bool oDataContainer::formatNumber(int nr, const oDataInfo &di, wchar_t bf[64]) c
     return true;
   } 
   else if (di.SubType == oISDateOrYear) {
-    if (nr > 1900 && nr < 9999) {
-      swprintf_s(bf, 64, L"%d", nr);
-    }
-    else if (nr > 9999 && nr < 99999999) {
-      swprintf_s(bf, 64, L"%d-%02d-%02d", nr / (100 * 100), (nr / 100) % 100, nr % 100);
-    }
+    if (nr > 9999 && nr % 10000 != 0)
+      swprintf_s(bf, 64, L"%04d-%02d-%02d", nr / 10000, (nr / 100) % 100, nr % 100);
+    else if (nr > 9999)
+      swprintf_s(bf, 64, L"%04d", nr / 10000);
+    else if (nr > 1900)
+      swprintf_s(bf, 64, L"%04d", nr);
     else {
       bf[0] = '-';
       bf[1] = 0;
@@ -1250,6 +1258,34 @@ bool oDataContainer::formatNumber(int nr, const oDataInfo &di, wchar_t bf[64]) c
     }
     return true;
   }
+  else if (di.SubType == oISTimeAdjust) {
+    if (nr != 0 && nr != NOTIME) {
+      bool neg = false;
+      int cnt = 0;
+      if (nr < 0) {
+        bf[0] = '-';
+        cnt = 1;
+        nr = -nr;
+      }
+      if (nr < 24 * timeConstHour)
+        cnt += swprintf_s(bf + cnt, 64 - cnt, L"%02d:%02d:%02d", nr / timeConstHour, (nr / timeConstMinute) % 60, (nr / timeConstSecond) % 60);
+      else {
+        int days = nr / (24 * timeConstHour);
+        nr = nr % (24 * timeConstHour);
+        cnt += swprintf_s(bf + cnt, 64 - cnt, L"%d+%02d:%02d:%02d", days, nr / timeConstHour, (nr / timeConstSecond) % 60, (nr / timeConstSecond) % 60);
+      }
+      if (timeConstSecond > 1) {
+        if (nr % 10 != 0) {
+          swprintf_s(bf + cnt, 64 - cnt, L".%01d", nr % 10);
+        }
+      }
+    }
+    else {
+      bf[0] = '-';
+      bf[1] = 0;
+    }
+    return true;
+  }
   else if (di.SubType == oISDecimal) {
     if (nr) {
       int whole = nr / di.decimalScale;
@@ -1364,12 +1400,12 @@ pair<int, bool>  oDataContainer::inputData(oBase *ob, int id,
           no = ob->getEvent()->interpretCurrency(input);
         }
         else if (di.SubType == oISDate) {
-          no = convertDateYMS(input, true);
+          no = convertDateYMD(input, true);
           if (no <= 0)
             no = 0;
         } 
         else if (di.SubType == oISDateOrYear) {
-          no = convertDateYMS(input, true);
+          no = convertDateYMD(input, true);
           if (no <= 0) {
             no = _wtoi(input.c_str());
             if (input.length() >= 2 && (no > 0 && no < 100) || (no == 0 && input[0] == '0' && input[1] == '0'))
@@ -1382,6 +1418,11 @@ pair<int, bool>  oDataContainer::inputData(oBase *ob, int id,
         else if (di.SubType == oISTime) {
           no = convertAbsoluteTimeHMS(input, -1);
         }
+        else if (di.SubType == oISTimeAdjust) {
+          no = convertAbsoluteTimeMS(input);
+          if (no == NOTIME)
+            no = 0;
+        }
         else if (di.SubType == oISDecimal) {
           wstring str = input;
           for (size_t k = 0; k < str.length(); k++) {
diff --git a/code/oDataContainer.h b/code/oDataContainer.h
index 64e412e..1b1e826 100644
--- a/code/oDataContainer.h
+++ b/code/oDataContainer.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -53,7 +53,7 @@ public:
 };
 
 struct oDataInfo {
-  char Name[20];
+  char Name[28];
   int Index;
   int Size;
   int Type;
@@ -132,9 +132,11 @@ protected:
   static string C_STRING(const string & name, int len);
   static string SQL_quote(const wchar_t *in);
 public:
-  enum oIntSize{oISDecimal = 28, oISTime = 29, oISCurrency = 30, 
-    oISDate = 31, oISDateOrYear = 27, oIS64=64,
-    oIS32=32, oIS16=16, oIS8=8, oIS16U=17, oIS8U=9};
+  enum oIntSize {
+    oISDecimal = 28, oISTime = 29, oISTimeAdjust = 26, oISCurrency = 30,
+    oISDate = 31, oISDateOrYear = 27, oIS64 = 64,
+    oIS32 = 32, oIS16 = 16, oIS8 = 8, oIS16U = 17, oIS8U = 9
+  };
 
   enum oStringSubType {oSSString = 0, oSSEnum = 1};
   string generateSQLDefinition(const std::set<string> &exclude) const;
diff --git a/code/oEvent.cpp b/code/oEvent.cpp
index 39e3fe9..5d140a7 100644
--- a/code/oEvent.cpp
+++ b/code/oEvent.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -70,7 +70,7 @@
 extern Image image;
 
 //Version of database
-int oEvent::dbVersion = 90;
+int oEvent::dbVersion = 94;
 
 bool oEvent::useSubSecond() const {
   if (useSubsecondsVersion == dataRevision)
@@ -415,6 +415,36 @@ public:
   }
 };
 
+class AnnotationFormatter : public oDataDefiner {
+  mutable int numChar = 12;
+public:
+  
+  const wstring& formatData(const oBase* obj) const override {
+    const wstring &ws = obj->getDCI().getString("Annotation");
+    if (ws.empty())
+      return ws;
+    int pos = ws.find_first_of('@');
+    if (pos != wstring::npos)
+      return limitText(ws.substr(pos+1), numChar);
+    return limitText(ws, numChar);
+  }
+
+  bool canEdit() const override {
+    return false;
+  }
+
+  pair<int, bool> setData(oBase* obj, const wstring& input, wstring& output, int inputId) const override {
+    return make_pair(0, false);
+  }
+
+  int addTableColumn(Table* table, const string& description, int minWidth) const override {
+    numChar = minWidth / 5;
+    return table->addColumn(description, max(minWidth, 90), false, true);
+  }
+};
+
+
+
 oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
 {
   readOnly = false;
@@ -459,7 +489,7 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   meosFeatures = new MeOSFeatures();
   openFileLock = new MeOSFileLock();
 
-  wchar_t cp[ MAX_COMPUTERNAME_LENGTH + 1];
+  wchar_t cp[MAX_COMPUTERNAME_LENGTH + 1];
   DWORD size = MAX_COMPUTERNAME_LENGTH + 1;
   GetComputerName(cp, &size);
   clientName = cp;
@@ -486,7 +516,10 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   oEventData->addVariableString("Account", 30, "Konto");
   oEventData->addVariableDate("PaymentDue", "Sista betalningsdatum");
   oEventData->addVariableDate("OrdinaryEntry", "Ordinarie anmälningsdatum");
+  oEventData->addVariableDate("SecondEntryDate", "Stoppdatum två");
+
   oEventData->addVariableString("LateEntryFactor", 6, "Avgiftshöjning (procent)");
+  oEventData->addVariableString("SecondEntryFactor", 6, "Avgiftshöjning två (procent)");
 
   oEventData->addVariableString("Organizer", "Arrangör");
   oEventData->addVariableString("CareOf", 31, "c/o");
@@ -540,6 +573,9 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   oEventData->addVariableString("MergeTag", 12, "Tag");
   oEventData->addVariableString("MergeInfo", "MergeInfo");
   oEventData->addVariableString("SplitPrint", 40, "Sträcktidslista"); // Id from MetaListContainer::getUniqueId
+  oEventData->addVariableInt("NoVacantBib", oDataContainer::oIS8U, "Inga vakanta nummerlappar");
+  oEventData->addVariableString("RunnerIdTypes", "External ID types");
+  oEventData->addVariableString("ExtraFields", "Extra fields");
   oEventData->initData(this, dataSize);
 
   oClubData=new oDataContainer(oClub::dataSize);
@@ -580,7 +616,7 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   oRunnerData->addVariableDate("EntryDate", "Anm. datum");
   oRunnerData->addVariableInt("EntryTime", oDataContainer::oISTime, "Anm. tid",  make_shared<AbsoluteTimeFormatter>("EntryTime"));
 
-  vector< pair<wstring,wstring> > sex;
+  vector<pair<wstring,wstring>> sex;
   sex.push_back(make_pair(L"M", L"Man"));
   sex.push_back(make_pair(L"F", L"Kvinna"));
   sex.push_back(make_pair(L"", makeDash(L"-")));
@@ -589,12 +625,14 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   oRunnerData->addVariableString("Nationality", 3, "Nationalitet");
   oRunnerData->addVariableString("Country", 23, "Land");
   oRunnerData->addVariableInt("ExtId", oDataContainer::oIS64, "Externt Id");
+  oRunnerData->addVariableInt("ExtId2", oDataContainer::oIS64, "Externt Id 2");
+
   oRunnerData->addVariableInt("Priority", oDataContainer::oIS8U, "Prioritering");
   oRunnerData->addVariableString("Phone", 20, "Telefon");
 
   oRunnerData->addVariableInt("RaceId", oDataContainer::oIS32, "Lopp-id", make_shared<oRunner::RaceIdFormatter>());
 
-  oRunnerData->addVariableInt("TimeAdjust", oDataContainer::oISTime, "Tidsjustering");
+  oRunnerData->addVariableInt("TimeAdjust", oDataContainer::oISTimeAdjust, "Tidsjustering");
   oRunnerData->addVariableInt("PointAdjust", oDataContainer::oIS32, "Poängjustering");
   oRunnerData->addVariableInt("TransferFlags", oDataContainer::oIS32, "Överföring");
   oRunnerData->addVariableInt("Shorten", oDataContainer::oIS8U, "Avkortning");
@@ -606,8 +644,13 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   oRunnerData->addVariableInt("StartGroup", oDataContainer::oIS32, "Startgrupp", make_shared<StartGroupFormatter>());
   oRunnerData->addVariableInt("Family", oDataContainer::oIS32, "Familj");
 
+  oRunnerData->addVariableInt("DataA", oDataContainer::oIS32, "Data A");
+  oRunnerData->addVariableInt("DataB", oDataContainer::oIS32, "Data B");
+  oRunnerData->addVariableString("TextA", 40, "Text");
+  oRunnerData->addVariableString("Annotation", "Kommentarer", make_shared<AnnotationFormatter>());
+
   oControlData=new oDataContainer(oControl::dataSize);
-  oControlData->addVariableInt("TimeAdjust", oDataContainer::oISTime, "Tidsjustering");
+  oControlData->addVariableInt("TimeAdjust", oDataContainer::oISTimeAdjust, "Tidsjustering");
   oControlData->addVariableInt("MinTime", oDataContainer::oISTime, "Minitid");
   oControlData->addVariableDecimal("xpos", "x", 1);
   oControlData->addVariableDecimal("ypos", "y", 1);
@@ -654,6 +697,8 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   oClassData->addVariableInt("StartBlock", oDataContainer::oIS8U, "Block");
   oClassData->addVariableInt("NoTiming", oDataContainer::oIS8U, "Ej tidtagning", make_shared<DataBoolean>("NoTiming"));
   oClassData->addVariableInt("FreeStart", oDataContainer::oIS8U, "Fri starttid", make_shared<DataBoolean>("FreeStart"));
+  oClassData->addVariableInt("RequestStart", oDataContainer::oIS8U, "Boka starttid", make_shared<DataBoolean>("RequestStart"));
+
   oClassData->addVariableInt("IgnoreStart", oDataContainer::oIS8U, "Ej startstämpling", make_shared<DataBoolean>("IgnoreStart"));
 
   oClassData->addVariableInt("FirstStart", oDataContainer::oISTime, "Första start", make_shared<RelativeTimeFormatter>("FirstStart"));
@@ -661,10 +706,12 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   oClassData->addVariableInt("Vacant", oDataContainer::oIS8U, "Vakanser");
   oClassData->addVariableInt("Reserved", oDataContainer::oIS16U, "Extraplatser");
 
-  oClassData->addVariableCurrency("ClassFee", "Anm. avgift");
-  oClassData->addVariableCurrency("HighClassFee", "Efteranm. avg.");
-  oClassData->addVariableCurrency("ClassFeeRed", "Reducerad avg.");
-  oClassData->addVariableCurrency("HighClassFeeRed", "Red. avg. efteranm.");
+  oClassData->addVariableCurrency("ClassFee", "Avgift");
+  oClassData->addVariableCurrency("HighClassFee", "Sen avgift");
+  oClassData->addVariableCurrency("SecondHighClassFee", "Sen avgift\u00d72");
+  oClassData->addVariableCurrency("ClassFeeRed", "Red. avgift");
+  oClassData->addVariableCurrency("HighClassFeeRed", "Sen red. avgift");
+  oClassData->addVariableCurrency("SecondHighClassFeeRed", "Sen red. avgift\u00d72");
 
   oClassData->addVariableInt("SortIndex", oDataContainer::oIS32, "Sortering");
   oClassData->addVariableInt("MaxTime", oDataContainer::oISTime, "Maxtid");
@@ -689,6 +736,9 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   oClassData->addVariableString("Result", 24, "Result module", make_shared<ResultModuleFormatter>());
   oClassData->addVariableInt("TransferFlags", oDataContainer::oIS32, "Överföring", make_shared<DataHider>());
   oClassData->addVariableString("SplitPrint", 40, "Sträcktidslista", make_shared<SplitPrintListFormatter>());
+  oClassData->addVariableInt("DataA", oDataContainer::oIS32, "Data A");
+  oClassData->addVariableInt("DataB", oDataContainer::oIS32, "Data B");
+  oClassData->addVariableString("TextA", 40, "Text");
 
   oTeamData = new oDataContainer(oTeam::dataSize);
   oTeamData->addVariableCurrency("Fee", "Anm. avgift");
@@ -703,7 +753,7 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   oTeamData->addVariableInt("ExtId", oDataContainer::oIS64, "Externt Id");
   oTeamData->addVariableInt("Priority", oDataContainer::oIS8U, "Prioritering");
   oTeamData->addVariableInt("SortIndex", oDataContainer::oIS16, "Sortering");
-  oTeamData->addVariableInt("TimeAdjust", oDataContainer::oISTime, "Tidsjustering");
+  oTeamData->addVariableInt("TimeAdjust", oDataContainer::oISTimeAdjust, "Tidsjustering");
   oTeamData->addVariableInt("PointAdjust", oDataContainer::oIS32, "Poängjustering");
   oTeamData->addVariableInt("TransferFlags", oDataContainer::oIS32, "Överföring");
   oTeamData->addVariableInt("EntrySource", oDataContainer::oIS32, "Källa");
@@ -711,6 +761,11 @@ oEvent::oEvent(gdioutput &gdi):oBase(0), gdibase(gdi)
   oTeamData->addVariableInt("NoRestart", oDataContainer::oIS8U, "Ej omstart");
   oTeamData->addVariableString("InputResult", "Tidigare resultat", make_shared<DataHider>());
 
+  oTeamData->addVariableInt("DataA", oDataContainer::oIS32, "Data A");
+  oTeamData->addVariableInt("DataB", oDataContainer::oIS32, "Data B");
+  oTeamData->addVariableString("TextA", 40, "Text");
+  oTeamData->addVariableString("Annotation", "Kommentarer", make_shared<AnnotationFormatter>());
+
   generalResults.push_back(GeneralResultCtr("atcontrol", L"Result at a control", make_shared<ResultAtControl>()));
   generalResults.push_back(GeneralResultCtr("totatcontrol", L"Total/team result at a control", make_shared<TotalResultAtControl>()));
 
@@ -1526,7 +1581,7 @@ bool oEvent::open(const xmlparser &xml) {
   xo = xml.getObject("Date");
   if (xo) {
     wstring fDate = xo.getWStr();
-    if (convertDateYMS(fDate, true) > 0)
+    if (convertDateYMD(fDate, true) > 0)
       Date = fDate;
   }
   Name.clear();
@@ -2609,7 +2664,7 @@ wstring oEvent::getTitleName() const {
 void oEvent::setDate(const wstring &m, bool manualSet)
 {
   if (m!=Date) {
-    int d = convertDateYMS(m, true);
+    int d = convertDateYMD(m, true);
     if (d <= 0)
       throw meosException(L"Felaktigt datumformat 'X' (Använd ÅÅÅÅ-MM-DD).#" + m);
     wstring nDate = formatDate(d, true);
@@ -2693,7 +2748,7 @@ wstring oEvent::getAbsDateTimeISO(DWORD time, bool includeDate, bool useGMT) con
       }
       else {
         SYSTEMTIME st;
-        convertDateYMS(Date, st, false);
+        convertDateYMD(Date, st, false);
         __int64 sec = SystemTimeToInt64TenthSecond(st);
         sec = sec + (extraDay * timeConstHour * 24);
         st = Int64TenthSecondToSystemTime(sec);
@@ -2864,7 +2919,7 @@ int oEvent::getRelativeTime(const string &date, const string &absoluteTime, cons
 
   if ((timeZone == "Z" || timeZone == "z") && atime >= 0) {
     SYSTEMTIME st;
-    convertDateYMS(date, st, false);
+    convertDateYMD(date, st, false);
 
     st.wHour = atime / timeConstHour;
     st.wMinute = (atime / timeConstMinute) % 60;
@@ -3140,8 +3195,7 @@ bool oEvent::isClassUsed(int Id) const
       idToCheck.insert(cl->getVirtualClass(i)->getId());
   }
   //Search runners
-  oRunnerList::const_iterator it;
-  for (it=Runners.begin(); it != Runners.end(); ++it){
+  for (auto it=Runners.begin(); it != Runners.end(); ++it){
     if (it->isRemoved())
       continue;
     if (idToCheck.count(it->getClassId(false)))
@@ -3149,9 +3203,8 @@ bool oEvent::isClassUsed(int Id) const
   }
 
   //Search teams
-  oTeamList::const_iterator tit;
-  for (tit=Teams.begin(); tit != Teams.end(); ++tit){
-    if (it->isRemoved())
+  for (auto tit=Teams.begin(); tit != Teams.end(); ++tit){
+    if (tit->isRemoved())
       continue;
     if (idToCheck.count(tit->getClassId(false)))
       return true;
@@ -4147,7 +4200,8 @@ void oEvent::clear()
     generalResults.pop_back();
 
   // Cleanup user interface
-  gdibase.getTabs().clearCompetitionData();
+  if (isMainEvent)
+    gdibase.getTabs().clearCompetitionData();
   
   machineContainer.release();
 
@@ -4781,7 +4835,7 @@ bool oEvent::hasTeam() const
   return Teams.size() > 0;
 }
 
-void oEvent::addBib(int ClassId, int leg, const wstring &firstNumber) {
+void oEvent::addBib(int ClassId, int leg, const wstring &firstNumber, bool assignToVacant) {
   if ( !classHasTeams(ClassId) ) {
     sortRunners(ClassStartTimeClub);
     oRunnerList::iterator it;
@@ -4804,6 +4858,8 @@ void oEvent::addBib(int ClassId, int leg, const wstring &firstNumber) {
         if (it->isRemoved())
           continue;
         if ( (ClassId==0 || it->getClassId(true)==ClassId) && (it->legToRun()==leg || leg == -1)) {
+          if (!assignToVacant && it->isVacant())
+            continue;
           wchar_t bib[32];
           swprintf_s(bib, pattern, num);
           pClass pc = it->getClassRef(true);
@@ -4832,6 +4888,8 @@ void oEvent::addBib(int ClassId, int leg, const wstring &firstNumber) {
       for (auto it = Teams.begin(); it != Teams.end(); ++it) {
         if (it->isRemoved())
           continue;
+        if (!assignToVacant && it->isVacant())
+          continue;
         if (ClassId == 0 || it->getClassId(false) == ClassId) {
           if (it->getClassRef(false) && it->getClassRef(false)->getBibMode() != BibFree) {
             for (size_t i = 0; i < it->Runners.size(); i++) {
@@ -4847,7 +4905,7 @@ void oEvent::addBib(int ClassId, int leg, const wstring &firstNumber) {
       }
     }
 
-    sortTeams(ClassStartTime, 0, true); // Sort on first leg starttime and sortindex
+    sortTeams(ClassStartTimeClub, 0, true); // Sort on first leg starttime and sortindex
 
     if (!firstNumber.empty()) {
       wchar_t pattern[32];
@@ -4856,6 +4914,8 @@ void oEvent::addBib(int ClassId, int leg, const wstring &firstNumber) {
       for (auto it=Teams.begin(); it != Teams.end(); ++it) {
         if (it->isRemoved())
           continue;
+        if (!assignToVacant && it->isVacant())
+          continue;
 
         if (ClassId == 0 || it->getClassId(false) == ClassId) {
           wchar_t bib[32];
@@ -4887,6 +4947,8 @@ void oEvent::addBib(int ClassId, int leg, const wstring &firstNumber) {
 }
 
 void oEvent::addAutoBib() {
+  bool noBibToVacant = oe->getDCI().getInt("NoVacantBib") != 0;
+
   sortRunners(ClassStartTimeClub);
   oRunnerList::iterator it;
   int clsId = -1;
@@ -4907,6 +4969,7 @@ void oEvent::addAutoBib() {
     pClass cls = tit->getClassRef(false);
     if (cls == 0)
       continue;
+
     teamStartNo[tit->getId()] = tit->getStartNo();
 
     wstring bibInfo = cls->getDCI().getString("Bib");
@@ -4935,7 +4998,7 @@ void oEvent::addAutoBib() {
     }
   }
 
-  sortTeams(ClassStartTime, 0, true); // Sort on first leg starttime and sortindex
+  sortTeams(ClassStartTimeClub, 0, true); // Sort on first leg starttime and sortindex
   map<int, vector<pTeam> > cls2TeamList;
 
   for (oTeamList::iterator tit = Teams.begin(); tit != Teams.end(); ++tit) {
@@ -4946,7 +5009,7 @@ void oEvent::addAutoBib() {
   }
 
   map<int, vector<pRunner> > cls2RunnerList;
-  for (it=Runners.begin(); it != Runners.end(); ++it) {
+  for (it = Runners.begin(); it != Runners.end(); ++it) {
     if (it->isRemoved() || !it->getClassId(false))
       continue;
     int clsId = it->getClassId(true);
@@ -5015,17 +5078,23 @@ void oEvent::addAutoBib() {
       else  {
         bool lockedForking = cls->lockedForking();
         for (size_t k = 0; k < tl.size(); k++) {
-          wchar_t buff[32];
-          swprintf_s(buff, pattern, number);
 
-          if (lockedForking) {
-            tl[k]->setBib(buff, number, false);
-            tl[k]->setStartNo(teamStartNo[tl[k]->getId()], ChangeType::Update);
+          if (noBibToVacant && tl[k]->isVacant()) {
+            tl[k]->getDI().setString("Bib", L""); //Remove only bib
           }
           else {
-            tl[k]->setBib(buff, number, true);
+            wchar_t buff[32];
+            swprintf_s(buff, pattern, number);
+
+            if (lockedForking) {
+              tl[k]->setBib(buff, number, false);
+              tl[k]->setStartNo(teamStartNo[tl[k]->getId()], ChangeType::Update);
+            }
+            else {
+              tl[k]->setBib(buff, number, true);
+            }
+            number += interval;
           }
-          number += interval;
           tl[k]->applyBibs();
           tl[k]->evaluate(ChangeType::Update);
         }
@@ -5046,7 +5115,7 @@ void oEvent::addAutoBib() {
         cls->synchronize(true);
       }
       for (size_t k = 0; k < rl.size(); k++) {
-        if (pattern[0]) {
+        if (pattern[0] && (!noBibToVacant || !rl[k]->isVacant())) {
           wchar_t buff[32];
           swprintf_s(buff, pattern, number);
           rl[k]->setBib(buff, number, !locked);
@@ -5104,7 +5173,7 @@ void oEvent::fillStatus(gdioutput &gdi, const string& id)
 {
   vector< pair<wstring, size_t> > d;
   fillStatus(d);
-  gdi.addItem(id, d);
+  gdi.setItems(id, d);
 }
 
 const vector< pair<wstring, size_t> > &oEvent::fillStatus(vector< pair<wstring, size_t> > &out) {
@@ -5267,19 +5336,73 @@ bool compareClubClassTeamName(const oRunner &a, const oRunner &b)
     return a.getClub()<b.getClub();
 }
 
-void oEvent::assignCardInteractive(gdioutput &gdi, GUICALLBACK cb)
+void oEvent::assignCardInteractive(gdioutput& gdi, GUICALLBACK cb, SortOrder& orderRunners)
 {
   gdi.fillDown();
   gdi.dropLine(1);
   gdi.addString("", 2, "Tilldelning av hyrbrickor");
 
-  Runners.sort(compareClubClassTeamName);
+  class SortUpdate : public GuiHandler {
+    SortOrder& orderRunners;
+    oEvent* oe;
+    GUICALLBACK cb;
+  public:
+    SortUpdate(oEvent *oe, GUICALLBACK cb, SortOrder& orderRunners) : 
+      orderRunners(orderRunners), cb(cb), oe(oe) { }
+
+    void handle(gdioutput& gdi, BaseInfo& info, GuiEventType type) final {
+      ListBoxInfo& lb = dynamic_cast<ListBoxInfo&>(info);
+      orderRunners = SortOrder(lb.data);
+      oe->assignCardInteractive(gdi, cb, orderRunners);
+    }
+    ~SortUpdate() {
+    }
+  };
+
+  if (gdi.hasData("AssignCardMark")) {
+    gdi.restore("AssignCardRP", false);
+  }
+  else {
+    auto h = make_shared<SortUpdate>(this, cb, orderRunners);
+    gdi.dropLine(0.5);
+    gdi.addSelection("Sorting", 200, 300, nullptr, L"Sortering:").setHandler(h);
+
+    vector<pair<wstring, size_t> > orders;
+    for (auto ord : MetaList::getOrderToSymbol()) {
+      if (ord.first != SortOrder::Custom && ord.first != SortOrder::ClassDefaultResult)
+        orders.push_back(make_pair(lang.tl(ord.second), ord.first));
+    }
+    sort(orders.begin(), orders.end());
+    orders.insert(orders.begin(), make_pair(lang.tl("Standard"), SortOrder::Custom));
+
+    gdi.setItems("Sorting", orders);
+    gdi.selectItemByData("Sorting", orderRunners);
+
+    gdi.dropLine();
+    gdi.setData("AssignCardMark", 1);
+    gdi.setRestorePoint("AssignCardRP");
+  }
+  
+  if (orderRunners == SortOrder::Custom) {
+    Runners.sort(compareClubClassTeamName);
+  }
+  else {
+    CurrentSortOrder = orderRunners;
+    Runners.sort();
+  }
 
   oRunnerList::iterator it;
-  pClub lastClub=0;
+  pClub lastClub = nullptr;
+  pClass lastClass = nullptr;
 
-  int k=0;
-  for (it=Runners.begin(); it != Runners.end(); ++it) {
+  const int px4 = gdi.scaleLength(4);
+  const int px450 = gdi.scaleLength(450);
+
+  int k = 0;
+  bool groupByClub = orderRunners == SortOrder::Custom || orderRunners == ClubClassStartTime;
+  bool groupByClass = orderByClass(orderRunners);
+
+  for (it = Runners.begin(); it != Runners.end(); ++it) {
 
     if (it->skip() || it->getCardNo() || it->isVacant() || it->needNoCard())
       continue;
@@ -5287,37 +5410,54 @@ void oEvent::assignCardInteractive(gdioutput &gdi, GUICALLBACK cb)
     if (it->getStatus() == StatusDNS || it->getStatus() == StatusCANCEL || it->getStatus() == StatusNotCompetiting)
       continue;
 
-    if (it->Club!=lastClub) {
-      lastClub=it->Club;
+    if (groupByClub && it->Club != lastClub) {
+      lastClub = it->Club;
       gdi.dropLine(0.5);
-      gdi.addString("", 1, it->getClub());
+      gdi.addStringUT(1, it->getClub());
+    }
+    else if (groupByClass && it->Class != lastClass) {
+      lastClass = it->getClassRef(true);
+      gdi.dropLine(0.5);
+      gdi.addStringUT(1, it->getClass(true));
     }
 
     wstring r;
-    if (it->Class)
-      r+=it->getClass(false)+L", ";
+    if (!groupByClass && it->Class)
+      r += it->getClass(false) + L", ";
+    
+    if (!groupByClub && it->Club)
+      r += it->getClub() + L", ";
 
     if (it->tInTeam) {
-      r+=itow(it->tInTeam->getStartNo()) + L" " + it->tInTeam->getName() + L", ";
-    }
+      if (!it->tInTeam->getBib().empty())
+        r += it->tInTeam->getBib() + L" ";
 
+      r += it->tInTeam->getName() + L", ";
+    }
+    else {
+      if (!it->getBib().empty())
+        r += it->getBib() + L" ";
+    }
     r += it->getName() + L":";
+
     gdi.fillRight();
     gdi.pushX();
     gdi.addStringUT(0, r);
     char id[24];
     sprintf_s(id, "*%d", k++);
 
-    gdi.addInput(max(gdi.getCX(), 450), gdi.getCY()-4,
-                 id, L"", 10, cb).setExtra(it->getId());
+    gdi.addInput(max(gdi.getCX(), px450), gdi.getCY() - px4,
+      id, L"", 10, cb).setExtra(it->getId());
 
     gdi.popX();
     gdi.dropLine(1.6);
     gdi.fillDown();
   }
 
-  if (k==0)
+  if (k == 0)
     gdi.addString("", 0, "Ingen löpare saknar bricka");
+
+  gdi.refresh();
 }
 
 void oEvent::calcUseStartSeconds()
@@ -5528,13 +5668,13 @@ void oEvent::generateTestCard(SICard &sic) const
         sic.CardNumber = 100000;
 
       int s = sic.StartPunch.Time = r->tStartTime>0 ? r->tStartTime+ZeroTime : ZeroTime+timeConstHour+rand()%(timeConstHour*3);
-      int tomiss = rand()%(timeConstMinute *10);
-      if (tomiss>timeConstMinute *9)
-        tomiss = rand()%30*timeConstSecond;
+      int tomiss = rand()%(60 *10);
+      if (tomiss>60 *9)
+        tomiss = rand()%30;
       else if (rand()%20 == 3)
         tomiss *= rand()%3;
       
-      int f = sic.FinishPunch.Time = s+((30+pc->getLength()/200)*timeConstMinute+ rand()%(60*10))*timeUnitsPerSecond + tomiss;
+      int f = sic.FinishPunch.Time = s+((30+pc->getLength()/200)*60 + tomiss)*timeUnitsPerSecond;
 
       if (rand()%40==0 || r->tStartTime>0)
         sic.StartPunch.Code=-1;
@@ -5551,7 +5691,7 @@ void oEvent::generateTestCard(SICard &sic) const
       int missed = 0;
 
       for(int k=0;k<pc->nControls;k++) {
-        if (rand()%330 != 50) {
+        if (rand()%930 != 50) {
           sic.Punch[sic.nPunch].Code=pc->getControl(k)->Numbers[0];
           double cc=(k+1)*dt;
 
@@ -5563,7 +5703,7 @@ void oEvent::generateTestCard(SICard &sic) const
               missed = tomiss;
           }
 
-          sic.Punch[sic.nPunch].Time=int((f-tomiss)*cc+s*(1.-cc)) + missed;
+          sic.Punch[sic.nPunch].Time=int(0.1 * ((f-tomiss* timeUnitsPerSecond)*cc+s*(1.-cc) + missed* timeUnitsPerSecond))*10;
           sic.nPunch++;
         }
       }
@@ -5810,6 +5950,10 @@ void oEvent::fillFees(gdioutput &gdi, const string &name, bool onlyDirect, bool
     if (f > 0)
       fees.insert(f);
 
+    f = it->getDCI().getInt("SecondHighClassFee");
+    if (f > 0)
+      fees.insert(f);
+
     if (withAuto) {
       f = it->getDCI().getInt("HighClassFee");
       if (f > 0)
@@ -5818,6 +5962,10 @@ void oEvent::fillFees(gdioutput &gdi, const string &name, bool onlyDirect, bool
       f = it->getDCI().getInt("HighClassFeeRed");
       if (f > 0)
         fees.insert(f);
+
+      f = it->getDCI().getInt("SecondHighClassFeeRed");
+      if (f > 0)
+        fees.insert(f);
     }
   }
   
@@ -5836,13 +5984,13 @@ void oEvent::fillFees(gdioutput &gdi, const string &name, bool onlyDirect, bool
     if (f > 0)
       fees.insert(f);
   }
-  vector< pair<wstring, size_t> > ff;
+  vector<pair<wstring, size_t>> ff;
   if (withAuto)
     ff.push_back(make_pair(lang.tl(L"Från klassen"), -1));
   for (set<int>::iterator it = fees.begin(); it != fees.end(); ++it)
     ff.push_back(make_pair(formatCurrency(*it), *it));
 
-  gdi.addItem(name, ff);
+  gdi.setItems(name, ff);
 }
 
 void oEvent::fillLegNumbers(const set<int> &cls,
@@ -5952,7 +6100,7 @@ void oEvent::generateTableData(const string &tname, Table &table, TableUpdateInf
     if (tui.doRefresh && !tui.doAdd)
       return;
 
-    pFreePunch c = tui.doAdd ? addFreePunch(0,0,0,0, false) : pFreePunch(tui.object);
+    pFreePunch c = tui.doAdd ? addFreePunch(0,0,0,0, false, false) : pFreePunch(tui.object);
     generatePunchTableData(table, c);
     return;
   }
@@ -6051,7 +6199,7 @@ void oEvent::updateTabs(bool force, bool hide) const
   bool hasRunner = !Runners.empty() || !Classes.empty();
   bool hasLists = !empty();
   bool skipCourses = getMeOSFeatures().withoutCourses(*this);
-  if (hide || isReadOnly())
+  if (hide || isKiosk())
     hideTabs();
   else
     createTabs(force, empty(), !hasTeam, !getMeOSFeatures().hasFeature(MeOSFeatures::Speaker),
@@ -6857,3 +7005,117 @@ MachineContainer &oEvent::getMachineContainer() {
 
   return *machineContainer;
 }
+
+void oEvent::setRunnerIdTypes(const pair<string, string>& preferredIdType) {
+  wstring coded = gdioutput::widen(preferredIdType.first + ";" + preferredIdType.second);
+  getDI().setString("RunnerIdTypes", coded);
+}
+
+pair<wstring, wstring> oEvent::getRunnerIdTypes() const {
+  wstring raw = getDCI().getString("RunnerIdTypes");
+  vector<wstring> out;
+  split(raw, L";", out);
+  pair<wstring, wstring> outp;
+  if (out.size() > 0)
+    outp.first = std::move(out[0]);
+  if (out.size() > 1)
+    outp.second = std::move(out[1]);
+  return outp;
+}
+
+namespace {
+  int encodeExtra(oEvent::ExtraFieldContext context, oEvent::ExtraFields field) {
+    return int(context) * 100 + int(field);
+  }
+
+  pair<oEvent::ExtraFieldContext, oEvent::ExtraFields> decodeExtra(int coded) {
+    int context = coded / 100;
+    int field = coded % 100;
+    if (context >= 0 && context < int(oEvent::ExtraFieldContext::MaxContext) &&
+      field >= 0 && field < int(oEvent::ExtraFields::MaxField)) {
+      return make_pair(oEvent::ExtraFieldContext(context), oEvent::ExtraFields(field));
+    }
+    else
+      return make_pair(oEvent::ExtraFieldContext::MaxContext, oEvent::ExtraFields::MaxField);
+  }
+}
+
+map<oEvent::ExtraFields, wstring> oEvent::getExtraFields(oEvent::ExtraFieldContext context) const {
+  map<ExtraFields, wstring> extraFields;
+  wstring ws = getDCI().getString("ExtraFields");
+  vector<wstring> sp;
+  split(ws, L"|", sp);
+
+  for (const wstring& w : sp) {
+    int code = _wtoi(w.c_str());
+    auto cc = decodeExtra(code);
+    if (cc.first != context)
+      continue;
+    size_t descP = w.find_first_of(';');
+    if (descP == wstring::npos)
+      extraFields[cc.second] = L"";
+    else
+      extraFields[cc.second] = w.substr(descP+1);
+  }
+  return extraFields;
+}
+
+map<oEvent::ExtraFields, wstring> oEvent::getExtraFieldNames() const {
+  map<ExtraFields, wstring> extraFields;
+  wstring ws = getDCI().getString("ExtraFields");
+  vector<wstring> sp;
+  split(ws, L"|", sp);
+
+  for (const wstring& w : sp) {
+    int code = _wtoi(w.c_str());
+    auto cc = decodeExtra(code);
+    if (cc.second != ExtraFields::DataA &&
+      cc.second != ExtraFields::DataB &&
+      cc.second != ExtraFields::TextA)
+      continue;
+    size_t descP = w.find_first_of(';');
+    if (descP != wstring::npos)
+      extraFields[cc.second] = w.substr(descP + 1);
+  }
+  return extraFields;
+}
+
+
+void oEvent::updateExtraFields(ExtraFieldContext context, const map<ExtraFields, wstring>& fields) {
+  wstring ws = getDCI().getString("ExtraFields");
+  vector<wstring> sp;
+  split(ws, L"|", sp);
+  vector<wstring> spOut;
+  set<ExtraFields> used;
+  for (const wstring& w : sp) {
+    int code = _wtoi(w.c_str());
+    auto cc = decodeExtra(code);
+    if (cc.first == ExtraFieldContext::MaxContext)
+      continue;
+    if (cc.first != context)
+      spOut.push_back(w); // Not touched
+    else if (auto res = fields.find(cc.second); res != fields.end()) {
+      // Update definition
+      wstring w2 = itow(encodeExtra(cc.first, cc.second));
+      if (!res->second.empty())
+        w2 += L";" + res->second;
+      spOut.push_back(w2);
+      used.insert(cc.second);
+    }
+  }
+
+  // Add new
+  for (auto& in : fields) {
+    if (!used.count(in.first)) {
+      wstring w2 = itow(encodeExtra(context, in.first));
+      if (!in.second.empty())
+        w2 += L";" + in.second;
+      spOut.push_back(w2);
+    }
+  }
+
+  wstring res;
+  unsplit(spOut, L"|", res);
+
+  getDI().setString("ExtraFields", res);
+}
diff --git a/code/oEvent.h b/code/oEvent.h
index 51fc459..dbc11f0 100644
--- a/code/oEvent.h
+++ b/code/oEvent.h
@@ -6,7 +6,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -120,10 +120,10 @@ public:
   Priority getPriority() const {return priority;}
   int getClassId() const {return classId;}
   pair<bool, int> getSource() const {return typeId;}
-  oAbstractRunner *getSource(const oEvent &oe) const;
+  oRunner *getSource(const oEvent &oe) const;
 
   __int64 getTag() const;
-  oTimeLine(int time, TimeLineType type, Priority priority, int classId, int id, oAbstractRunner *source);
+  oTimeLine(int time, TimeLineType type, Priority priority, int classId, int id, oRunner *source);
   virtual ~oTimeLine();
 };
 
@@ -140,8 +140,6 @@ typedef list<oTeam> oTeamList;
 
 typedef list<oFreePunch> oFreePunchList;
 
-typedef int (*GUICALLBACK)(gdioutput *gdi, int type, void *data);
-
 struct ClassInfo;
 struct DrawInfo;
 
@@ -236,6 +234,7 @@ protected:
 
   // Set to true if a global modification is made that should case all lists etc to regenerate.
   bool globalModification;
+  bool isMainEvent = false;
 
   gdioutput &gdibase;
   
@@ -290,7 +289,7 @@ protected:
   oCardList Cards;
 
   oFreePunchList punches;
-  typedef unordered_multimap<int, pFreePunch> PunchIndexType;
+  typedef std::unordered_multimap<int, pFreePunch> PunchIndexType;
   typedef PunchIndexType::iterator PunchIterator;
   typedef PunchIndexType::const_iterator PunchConstIterator;
   /** First level maps a constant based on control number
@@ -396,7 +395,7 @@ protected:
   set<int> modifiedClasses;
 
   static const int dataSize = 1024;
-  int getDISize() const {return dataSize;}
+  int getDISize() const final {return dataSize;}
   BYTE oData[dataSize];
   BYTE oDataOld[dataSize];
   vector<vector<wstring>> dynamicData;
@@ -485,6 +484,8 @@ protected:
   // Temporarily disable recaluclate leader times
   bool disableRecalculate;
 public:
+  /** Mark as main event.*/
+  void setMainEvent() { isMainEvent = true; }
 
   /** Get adjustment for a specific unit*/
   int getUnitAdjustment(oPunch::SpecialPunch type, int unit) const;
@@ -726,16 +727,25 @@ public:
   inline bool useStartSeconds() const {return tUseStartSeconds;}
   void calcUseStartSeconds();
 
-  void assignCardInteractive(gdioutput &gdi, GUICALLBACK cb);
+  void assignCardInteractive(gdioutput &gdi, GUICALLBACK cb, SortOrder& orderRunners);
 
   int getPropertyInt(const char *name, int def);
+  bool getPropertyBool(const char* name, bool def) {
+    return getPropertyInt(name, def ? 1 : 0) != 0;
+  }
   const string &getPropertyString(const char *name, const string &def);
   const wstring &getPropertyString(const char *name, const wstring &def);
   
   string getPropertyStringDecrypt(const char *name, const string &def);
 
   void setProperty(const char *name, int prop);
-  //void setProperty(const char *name, const string &prop);
+  void setProperty(const char* name, bool prop) {
+    setProperty(name, prop ? 1 : 0);
+  }
+  void setProperty(const char* name, size_t prop) {
+    setProperty(name, int(prop));
+  }
+
   void setProperty(const char *name, const wstring &prop);
   
   void setPropertyEncrypt(const char *name, const string &prop);
@@ -820,7 +830,7 @@ public:
 
   void checkOrderIdMultipleCourses(int ClassId);
 
-  void addBib(int ClassId, int leg, const wstring &firstNumber);
+  void addBib(int ClassId, int leg, const wstring &firstNumber, bool assignVacant);
   void addAutoBib();
 
   //Speaker functions.
@@ -834,7 +844,7 @@ public:
   // Get set of controls with registered punches
   void getFreeControls(set<int> &controlId) const;
   // Returns the added punch, of null of already added.
-  pFreePunch addFreePunch(int time, int type, int unit, int card, bool updateRunner);
+  pFreePunch addFreePunch(int time, int type, int unit, int card, bool updateRunner, bool isOriginal);
   pFreePunch addFreePunch(oFreePunch &fp);
 
   bool useLongTimes() const;
@@ -898,7 +908,7 @@ protected:
   bool enumerateBackups(const wstring &file, const wstring &filetype, int type);
   mutable multimap<int, oAbstractRunner*> bibStartNoToRunnerTeam;
 
-  mutable shared_ptr<unordered_multimap<int, pRunner>> cardToRunnerHash;
+  mutable shared_ptr<std::unordered_multimap<int, pRunner>> cardToRunnerHash;
   vector<pRunner> getCardToRunner(int cardNo) const;
 
   mutable shared_ptr<map<int, vector<pRunner>>> classIdToRunnerHash;
@@ -909,7 +919,8 @@ protected:
   int tClubDataRevision;
   int tCalcNumMapsDataRevision = -1;
 
-  bool readOnly;
+  bool readOnly = false;
+  bool kiosk = false;
   mutable int tLongTimesCached;
   mutable map<int, pair<int, int> > cachedFirstStart; //First start per classid.
   map<pair<int, int>, oFreePunch> advanceInformationPunches;
@@ -919,7 +930,7 @@ protected:
 
   unsigned int lastTimeConsistencyCheck = 0;
   mutable bool lastResultCalcPrelState = false;
-
+  mutable bool lastResultCalcSplitResult = false;
 public:
   void updateStartTimes(int delta);
 
@@ -927,6 +938,9 @@ public:
 
   bool isReadOnly() const {return readOnly;}
   void setReadOnly() {readOnly = true;}
+  void setKiosk() { kiosk = true; }
+
+  bool isKiosk() const { return readOnly || kiosk; };
 
   enum IOFVersion {IOF20, IOF30};
 
@@ -970,7 +984,7 @@ public:
   //Returns true if data is changed.
   bool autoSynchronizeLists(bool syncPunches);
    
-  bool synchronizeList(initializer_list<oListId> types);
+  bool synchronizeList(std::initializer_list<oListId> types);
   bool synchronizeList(oListId id, bool preSyncEvent = true, bool postSyncEvent = true);
 
   bool checkDatabaseConsistency(bool force);
@@ -1009,6 +1023,7 @@ public:
   void exportIOFSplits(IOFVersion version, const wchar_t *file, bool oldStylePatrolExport,
                        bool useUTC,
                        const set<int> &classes,
+                       const pair<string, string> &preferredIdTypes,
                        int leg,
                        bool teamsAsIndividual,
                        bool unrollLoops,
@@ -1018,6 +1033,7 @@ public:
 
   void exportIOFStartlist(IOFVersion version, const wchar_t *file,
                           bool useUTC, const set<int> &classes,
+                          const pair<string, string>& preferredIdTypes,
                           bool teamsAsIndividual,
                           bool includeStageInfo,
                           bool forceSplitFee,
@@ -1125,7 +1141,6 @@ public:
   bool sortTeams(SortOrder so, int leg, bool linearLeg, vector<const oTeam *> &teams) const;
   bool sortTeams(SortOrder so, int leg, bool linearLeg, vector<oTeam *> &teams) const;
 
-
   pCard allocateCard(pRunner owner);
 
   /** Optimize the start order based on drawInfo. Result in cInfo */
@@ -1133,7 +1148,7 @@ public:
 
   void loadDrawSettings(const set<int> &classes, DrawInfo &drawInfo, vector<ClassInfo> &cInfo) const;
 
-  void drawRemaining(DrawMethod method, bool placeAfter);
+  void drawRemaining(const set<int> &classSel, DrawMethod method, bool placeAfter);
   void drawListStartGroups(const vector<ClassDrawSpecification> &spec,
                            DrawMethod method, int pairSize, DrawType drawType,
                            bool limitGroupSize = true,
@@ -1145,6 +1160,15 @@ public:
                        int ropeTime, int interval, int pairSize,
                        bool reverse, double scale);
 
+  /** Request a start time for a runner after a specified time. Returns
+      start time (but does not "lock" it)*/
+  int requestStartTime(int runnerId, int afterThisTime, int minTimeInterval,
+                       int lastAllowedTime, int maxParallel, 
+                       bool allowSameCourse, 
+                       bool allowSameCourseNeighbour,
+                       bool allowSameFirstControl,
+                       bool allowClubNeighbour);
+
   wstring getAutoTeamName() const;
   pTeam addTeam(const oTeam &t, bool autoAssignStartNo);
   pTeam addTeam(const wstring &pname, int clubId=0, int classId=0);
@@ -1215,6 +1239,35 @@ public:
                                                    const unordered_set<int> &personFilter);
   void fillRunners(gdioutput &gdi, const string &id, bool longName = false, int filter = 0);
 
+
+  enum class ExtraFields {
+    DataA = 0,
+    DataB = 1,
+    TextA = 2,
+    Nationality = 3,
+    Sex = 4,
+    BirthDate = 5,
+    Rank = 6,
+    Phone = 7,
+    StartTime = 8,
+    Bib = 9,
+    MaxField
+  };
+
+  enum class ExtraFieldContext {
+    Runner = 0,
+    Team = 1,
+    Class = 2,
+    DirectEntry = 3,
+    MaxContext
+  };
+
+  /** Get extra fields to show in UI*/
+  map<ExtraFields, wstring> getExtraFields(ExtraFieldContext context) const;
+  map<ExtraFields, wstring> getExtraFieldNames() const;
+
+  void updateExtraFields(ExtraFieldContext context, const map<ExtraFields, wstring> &fields);
+
   const shared_ptr<Table> &getTable(const string &key) const;
   void setTable(const string &key, const shared_ptr<Table> &table);
   bool hasTable(const string &key) const { return tables.count(key) > 0; }
@@ -1285,7 +1338,7 @@ public:
 
   const vector<pair<wstring, size_t>> &fillClasses(vector<pair<wstring, size_t>> &out,
                     ClassExtra extended, ClassFilter filter);
-  void fillClasses(gdioutput &gdi, const string &id, ClassExtra extended, ClassFilter filter);
+  void fillClasses(gdioutput &gdi, const string &id, const vector<pair<wstring, size_t>>& extraItems, ClassExtra extended, ClassFilter filter);
 
   bool fillClassesTB(gdioutput &gdi);
   const vector<pair<wstring, size_t>> &fillStarts(vector<pair<wstring, size_t>> &out);
@@ -1308,7 +1361,7 @@ public:
   /** Get controls. If calculateCourseControls, duplicate numbers are calculated for each control and course. */
   void getControls(vector<pControl> &controls, bool calculateCourseControls) const;
 
-  void fillCourses(gdioutput &gdi, const string &id, bool simple = false);
+  void fillCourses(gdioutput &gdi, const string &id, const vector<pair<wstring, size_t>>& extraItems, bool simple);
   const vector<pair<wstring, size_t>> &getCourses(vector<pair<wstring, size_t>> &out,
                                                   const wstring &filter,
                                                   bool simple = false, 
@@ -1341,7 +1394,10 @@ public:
   void importXML_EntryData(gdioutput &gdi, const wstring &file, 
                            bool updateClass, bool removeNonexisting,
                            const set<int> &filter, int classIdOffset, 
-                           int courseIdOffset, const string &preferredIdType);
+                           int courseIdOffset, const pair<string, string> &preferredIdType);
+
+  void setRunnerIdTypes(const pair<string, string> &preferredIdType);
+  pair<wstring, wstring> getRunnerIdTypes() const;
 
 protected:
   pClass getXMLClass(const xmlobject &xentry);
diff --git a/code/oEventDraw.cpp b/code/oEventDraw.cpp
index 227bf5f..fd4b16f 100644
--- a/code/oEventDraw.cpp
+++ b/code/oEventDraw.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -510,9 +510,12 @@ private:
       else {
         vector<pRunner> cr;
         oe->getRunners(c_it->getId(), 0, cr, false);
-        for (pRunner r : cr)
+        for (pRunner r : cr) {
+          if (r->getStatus() == StatusNotCompetiting || r->getStatus() == StatusCANCEL)
+            continue;
           if (r->getStartGroup(true) == ci.startGroupId)
             nr++;
+        }
       }
 
       if (ci.nVacant == -1 || !ci.nVacantSpecified || di.changedVacancyInfo) {
@@ -982,7 +985,7 @@ void oEvent::loadDrawSettings(const set<int> &classes, DrawInfo &drawInfo, vecto
 
       cInfo[i].nRunners = pc->getNumRunners(true, true, true) + cInfo[i].nVacant;
 
-      if (cInfo[i].nRunners>0) {
+      if (cInfo[i].nRunners > 0) {
         runnerPerGroup[cInfo[i].unique] += cInfo[i].nRunners;
         runnerPerCourse[cInfo[i].courseId] += cInfo[i].nRunners;
       }
@@ -996,15 +999,20 @@ void oEvent::loadDrawSettings(const set<int> &classes, DrawInfo &drawInfo, vecto
     cInfo[k].nRunnersCourse = runnerPerCourse[cInfo[k].courseId];
   }
 }
-void oEvent::drawRemaining(DrawMethod method, bool placeAfter)
+
+void oEvent::drawRemaining(const set<int>& classSel, DrawMethod method, bool placeAfter)
 {
+  bool all = classSel.size() == 1 && *classSel.begin() == -1;
   DrawType drawType = placeAfter ? DrawType::RemainingAfter : DrawType::RemainingBefore;
 
   for (oClassList::iterator it = Classes.begin(); it !=  Classes.end(); ++it) {
-    vector<ClassDrawSpecification> spec;
-    spec.emplace_back(it->getId(), 0, 0, 0, 0, VacantPosition::Mixed);
-
-    drawList(spec, method, 1, drawType);
+    if (it->isRemoved())
+      continue;
+    if (all || classSel.count(it->getId())) {
+      vector<ClassDrawSpecification> spec;
+      spec.emplace_back(it->getId(), 0, 0, 0, 0, VacantPosition::Mixed);
+      drawList(spec, method, 1, drawType);
+    }
   }
 }
 
@@ -1259,7 +1267,7 @@ void oEvent::drawListStartGroups(const vector<ClassDrawSpecification> &spec,
   }
 
   vector<pair<vector<pRunner>, bool>> uaGroups;
-  unsigned seed = (unsigned)chrono::system_clock::now().time_since_epoch().count();
+  unsigned seed = (unsigned)std::chrono::system_clock::now().time_since_epoch().count();
   auto rnd = std::default_random_engine(seed);
 
   int maxPerGroup = Runners.size();
@@ -1449,10 +1457,10 @@ void oEvent::drawListStartGroups(const vector<ClassDrawSpecification> &spec,
 
     map<int, map<pair<int, int>, int>> classClubCountByGroup;
     for (auto ms : moveFromGroupClassClub) {
-      int groupId = get<0>(ms);
-      int clsId = get<1>(ms);
-      int clubId = get<2>(ms);
-      int cnt = get<3>(ms);
+      int groupId = std::get<0>(ms);
+      int clsId = std::get<1>(ms);
+      int clubId = std::get<2>(ms);
+      int cnt = std::get<3>(ms);
       classClubCountByGroup[groupId][make_pair(clsId, clubId)] = cnt;
     }
 
@@ -1770,13 +1778,13 @@ void oEvent::drawList(const vector<ClassDrawSpecification> &spec,
     for (it=Runners.begin(); it != Runners.end(); ++it) {
       int cid = it->getClassId(true);
       if (!it->isRemoved() && clsId2Ix.count(cid)) {
-        if (it->getStatus() == StatusNotCompetiting)
+        if (it->getStatus() == StatusNotCompetiting || it->getStatus() == StatusCANCEL)
           continue;
         int ix = clsId2Ix[cid];
         if (spec[ix].startGroup != 0 && it->getStartGroup(true) != spec[ix].startGroup)
           continue;
         
-        if (it->legToRun() == spec[ix].leg || spec[ix].leg == -1) {
+        if (it->legToRun() == spec[ix].leg || spec[ix].leg == -1 || it->getClassId(false) != cid ) {
           runners.push_back(&*it);
           spec[ix].ntimes++;
         }
@@ -1792,7 +1800,7 @@ void oEvent::drawList(const vector<ClassDrawSpecification> &spec,
 
     for (it=Runners.begin(); it != Runners.end(); ++it) {
       if (!it->isRemoved() && clsId2Ix.count(it->getClassId(true))) {
-        if (it->getStatus() == StatusNotCompetiting)
+        if (it->getStatus() == StatusNotCompetiting || it->getStatus() == StatusCANCEL)
           continue;
 
         int st = it->getStartTime();
@@ -1860,7 +1868,7 @@ void oEvent::drawList(const vector<ClassDrawSpecification> &spec,
     for (size_t k = 0; k < runners.size(); k++) {
       if (runners[k]->isVacant()) {
         vacant.push_back(runners[k]);
-        swap(runners[k], runners.back());
+        std::swap(runners[k], runners.back());
         runners.pop_back();
         k--;
       }
@@ -2193,7 +2201,7 @@ void oEvent::automaticDrawAll(gdioutput &gdi,
     for (oClassList::iterator it = Classes.begin(); it!=Classes.end(); ++it) {
       if (it->getStart() != start)
         continue;
-      if (it->hasFreeStart())
+      if (it->hasFreeStart() || it->hasRequestStart())
         continue;
 
       maxRunners = max(maxRunners, runnersPerClass[&*it]);
@@ -2238,7 +2246,7 @@ void oEvent::automaticDrawAll(gdioutput &gdi,
           continue;
         if (notDrawn.count(it->getId()) == 0)
           continue; // Only not drawn classes
-        if (it->hasFreeStart())
+        if (it->hasFreeStart() || it->hasRequestStart())
           continue;
 
         di.classes[it->getId()] = ClassInfo(&*it);
@@ -2296,7 +2304,7 @@ void oEvent::automaticDrawAll(gdioutput &gdi,
           continue;
         if (notDrawn.count(it->getId()) == 0)
           continue; // Only not drawn classes
-        if (it->hasFreeStart())
+        if (it->hasFreeStart() || it->hasRequestStart())
           continue;
         //int classID, int leg, int firstStart, int interval, int vacances, oEvent::VacantPosition vp)
         spec.emplace_back(it->getId(), 0, 0, 120, 1, VacantPosition::Mixed);
@@ -2322,7 +2330,7 @@ void oEvent::automaticDrawAll(gdioutput &gdi,
   for (oClassList::iterator it = Classes.begin(); it!=Classes.end(); ++it) {
     if (needsCompletion.count(it->getId())==0)
       continue;
-    if (it->hasFreeStart())
+    if (it->hasFreeStart() || it->hasRequestStart())
       continue;
 
     gdi.addStringUT(0, lang.tl(L"Lottar efteranmälda: ") + it->getName());
@@ -2451,3 +2459,121 @@ void oEvent::drawPersuitList(int classId, int firstTime, int restartTime,
   }
   reCalculateLeaderTimes(classId);
 }
+
+int oEvent::requestStartTime(int runnerId, int afterThisTime, int minTimeInterval,
+                             int lastAllowedTime, int maxParallel,
+                             bool allowSameCourse, bool allowSameCourseNeighbour, 
+                             bool allowSameFirstControl, bool allowClubNeighbour) {
+  synchronizeList({ oListId::oLRunnerId, oListId::oLClassId, oListId::oLCourseId });
+  pRunner runner = getRunner(runnerId, 0);
+  if (!runner || !runner->Class)
+    return -1;
+  
+  assert(minTimeInterval > 0);
+  pCourse crs = runner->getCourse(false);
+  pControl firstC = !allowSameFirstControl && crs ? crs->getControl(0) : nullptr;
+  wstring start = crs ? crs->getStart() : L"";
+
+  set<int> usedStart;
+  set<int> usedStartClass;
+  set<int> usedClassClub;
+  map<int, int> countStartSlots;
+  int timeDivider = std::min(minTimeInterval, timeConstMinute);
+  int slotDist = minTimeInterval / timeDivider;
+  int closestStartSlotClass = numeric_limits<int>::max();
+  int desiredSlot = afterThisTime / timeDivider;
+
+  for (const oRunner &r : Runners) {
+    if (r.isRemoved() || r.getStatus() == StatusNotCompetiting || r.getStatus() == StatusCANCEL)
+      continue;
+
+    if (r.getStartTime() <= 0)
+      continue;
+
+    // If needs to be inserted in map, otherwise just compute closest
+    bool neededInMap = r.getStartTime() >= afterThisTime - timeDivider * slotDist;
+     
+    pCourse otherCrs = r.getCourse(false);
+    int slot = r.getStartTime() / timeDivider;
+    if (maxParallel > 0 && (!otherCrs || otherCrs->getStart() == start))
+      if (neededInMap)
+        ++countStartSlots[slot];
+
+    if (r.Class == runner->Class) {
+      if (abs(slot - desiredSlot) < abs(closestStartSlotClass-desiredSlot))
+        closestStartSlotClass = slot;
+      if (neededInMap) {
+        usedStart.insert(slot);
+        usedStartClass.insert(slot);
+        if (!allowClubNeighbour && r.Club == runner->Club && r.Club && r.getClubId() != oe->getVacantClubIfExist(true)) {
+          usedClassClub.insert(slot);
+        }
+      }
+    }
+    else if (!allowSameCourse && otherCrs == crs) {
+      usedStart.insert(slot);
+      if (allowSameCourseNeighbour) {
+        if (abs(slot - slotDist) < abs(closestStartSlotClass - desiredSlot))
+          closestStartSlotClass = slot;
+
+        if (neededInMap)
+          usedStartClass.insert(slot);
+      }
+    }
+    else if (!allowSameFirstControl && otherCrs && otherCrs->getControl(0) == firstC) {
+      if (neededInMap)
+        usedStart.insert(slot);
+    }
+  }
+
+  if (closestStartSlotClass < 10000) {
+    if (closestStartSlotClass > desiredSlot) {
+      int off = (closestStartSlotClass - desiredSlot) % slotDist;
+      if (off > 0) {
+        afterThisTime += off * timeDivider;
+      }
+    }
+    else if (closestStartSlotClass < desiredSlot) {
+      int off = (desiredSlot - closestStartSlotClass) % slotDist;
+      if (off > 0) {
+        int slotAdjust = slotDist - off;
+        afterThisTime += slotAdjust * timeDivider;
+      }
+    }
+  }
+  for (int startTime = afterThisTime; startTime <= lastAllowedTime; startTime += timeDivider) {
+    int slot = startTime / timeDivider;
+    if (usedStart.count(slot))
+      continue;
+    if (maxParallel > 0) {
+      auto res = countStartSlots.find(slot);
+      if (res != countStartSlots.end() && res->second >= maxParallel)
+        continue;
+    }
+
+    if (usedClassClub.count(slot - slotDist)) {
+      startTime += (slotDist - 1) * timeDivider;
+      continue;
+    }
+    if (usedClassClub.count(slot + slotDist)) {
+      startTime += (2 * slotDist - 1) * timeDivider;
+      continue;
+    }
+
+    bool ok = true;
+    for (int j = 1; j < slotDist; j++) {
+      if (usedStartClass.count(slot + j)) {
+        ok = false;
+        startTime += (j + slotDist - 1) * timeDivider; // Jump forward (optimize)
+        break;
+      }
+      if (usedStartClass.count(slot - j)) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) 
+      return startTime;
+  }
+  return -1; // No time found
+}
diff --git a/code/oEventDraw.h b/code/oEventDraw.h
index 51e6aaa..8d0f9a3 100644
--- a/code/oEventDraw.h
+++ b/code/oEventDraw.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/oEventResult.cpp b/code/oEventResult.cpp
index ef7d895..f5853f2 100644
--- a/code/oEventResult.cpp
+++ b/code/oEventResult.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -42,7 +42,7 @@
 
 template<typename T> struct ResultCalcData {
   int groupId;
-  int score;
+  int64_t score;
   bool operator<(const ResultCalcData<T> &c) const {
     if (groupId != c.groupId)
       return groupId < c.groupId;
@@ -52,12 +52,13 @@ template<typename T> struct ResultCalcData {
   T *dst;
 
   ResultCalcData() {}
-  ResultCalcData(int g, int s, T* d) : groupId(g), score(s), dst(d) {}
+  ResultCalcData(int g, int64_t s, T* d) : groupId(g), score(s), dst(d) {}
 };
 
 template<typename T, typename Apply> void calculatePlace(vector<ResultCalcData<T>> &data, Apply apply) {
   int groupId = -1;
-  int cPlace = 0, vPlace = 0, cScore = 0;
+  int cPlace = 0, vPlace = 0;
+  int64_t cScore = 0;
   bool invalidClass = false;
   bool useResults = true;
   sort(data.begin(), data.end());
@@ -97,6 +98,7 @@ template<typename T, typename Apply> void calculatePlace(vector<ResultCalcData<T
 
 void oEvent::calculateSplitResults(int controlIdFrom, int controlIdTo) {
   oRunnerList::iterator it;
+  lastResultCalcSplitResult = controlIdFrom != oPunch::PunchStart || controlIdTo != oPunch::PunchFinish;
 
   for (it=Runners.begin(); it!=Runners.end(); ++it) {
     int st = 0;
@@ -224,8 +226,9 @@ void oEvent::calculateResults(const set<int> &classes, ResultType resultType, bo
 
     runners.reserve(runnersCls.size());
     
-    bool resOK = lastResultCalcPrelState == includePreliminary;
+    bool resOK = lastResultCalcPrelState == includePreliminary && !lastResultCalcSplitResult;
     lastResultCalcPrelState = includePreliminary;
+    lastResultCalcSplitResult = false;
 
     for (auto it : runnersCls) {
       oRunner &r = *it;
@@ -322,7 +325,8 @@ void oEvent::calculateRunnerResults(ResultType resultType,
   typedef ResultCalcData<const oRunner> DT;
   vector<DT> resData;
   resData.reserve(runners.size());
-  int groupId, score;
+  int groupId;
+  int64_t score;
   for (auto it : runners) {
     int clsId = it->getClassId(true);
     if (classCourseResults) {
@@ -344,8 +348,10 @@ void oEvent::calculateRunnerResults(ResultType resultType,
       else
         st = it->getTotalStatus(false);
 
-      if (st == StatusOK)
-        score = numeric_limits<int>::max() - (timeConstHour * 24 * 7 * max(1, 1 + it->getRogainingPoints(useComputedResult, totalResults)) - it->getRunningTime(false));
+      if (st == StatusOK) {
+        uint64_t rp = int64_t(timeConstHour * 7 * 24) * max<uint64_t>(1, 1 + it->getRogainingPoints(useComputedResult, totalResults));
+        score = numeric_limits<int64_t>::max() - rp + it->getRunningTime(false);
+      }
       else
         score = -1;
     }
@@ -1051,8 +1057,9 @@ void oEvent::computePreliminarySplitResults(const set<int> &classes) const {
       if (ccId <= 0)
         continue;
       int crs = r->getCourse(false)->getId();
-      int time = p.getTimeInt() - r->getStartTime(); //XXX Team time
-      r->tOnCourseResults.emplace_back(ccId, courseCCid2CourseIx[make_pair(crs, ccId)], time);
+      int time = p.getTimeInt() - r->getStartTime(); 
+      int teamTotalTime = time + (r->tInTeam ? r->tInTeam->getTotalRunningTimeAtLegStart(r->tLeg, false) : 0);
+      r->tOnCourseResults.emplace_back(ccId, courseCCid2CourseIx[make_pair(crs, ccId)], time, teamTotalTime);
       int clsId = r->getClassId(true);
       int leg = r->getLegNumber();
       if (cls->getQualificationFinal())
@@ -1072,6 +1079,8 @@ void oEvent::computePreliminarySplitResults(const set<int> &classes) const {
 
     const set<int> &expectedCCid = classLeg2ExistingCCId[make_pair(clsId, leg)];
     size_t nRT = 0;
+    int teamTotalOff = r.tInTeam ? r.tInTeam->getTotalRunningTimeAtLegStart(r.tLeg, false) : 0;
+
     for (auto &radioTimes : r.tOnCourseResults.res) {
       if (expectedCCid.count(radioTimes.courseControlId))
         nRT++;
@@ -1091,8 +1100,9 @@ void oEvent::computePreliminarySplitResults(const set<int> &classes) const {
               }
             }
             if (!added) {
-              int time = p.getTimeInt() - r.getStartTime(); //XXX Team time
-              r.tOnCourseResults.emplace_back(ccId, p.tIndex, time);
+              int time = p.getTimeInt() - r.getStartTime(); 
+              int teamTotalTime = time + teamTotalOff;
+              r.tOnCourseResults.emplace_back(ccId, p.tIndex, time, teamTotalTime);
             }
           }
         }
@@ -1101,11 +1111,13 @@ void oEvent::computePreliminarySplitResults(const set<int> &classes) const {
   }
 
   vector<tuple<int, int, int>> timeRunnerIx;
+  vector<tuple<int, int, int>> totalTimeRunnerIx;
+
   for (auto rList : runnerByClassLeg) {
     auto &rr = rList.second;
     pClass cls = getClass(rList.first.first);
     assert(cls);
-    bool totRes = cls->getNumStages() > 1;
+    //bool totRes = cls->getNumStages() > 1;
 
     set<int> &legCCId = classLeg2ExistingCCId[rList.first];
     legCCId.insert(oPunch::PunchFinish);
@@ -1113,18 +1125,17 @@ void oEvent::computePreliminarySplitResults(const set<int> &classes) const {
       // Leg with negative sign
       int negLeg = 0;
       timeRunnerIx.clear();
+      totalTimeRunnerIx.clear();
+
       int nRun = rr.size();
       if (ccId == oPunch::PunchFinish) {
         negLeg = -1000; //Finish, smallest number
         for (int j = 0; j < nRun; j++) {
           auto r = rr[j];
           if (r->prelStatusOK(true, false, false)) {
-            int time;
-            if (!r->tInTeam || !totRes)
-              time = r->getRunningTime(true);
-            else {
-              time = r->tInTeam->getLegRunningTime(r->tLeg, true, false);
-            }
+            int time = r->getRunningTime(true);
+            int teamTotalTime = r->tInTeam ? r->tInTeam->getLegRunningTime(r->tLeg, true, false) : time;
+            
             int ix = -1;
             int nr = r->tOnCourseResults.res.size();
             for (int i = 0; i < nr; i++) {
@@ -1139,9 +1150,10 @@ void oEvent::computePreliminarySplitResults(const set<int> &classes) const {
               pCourse crs = r->getCourse(false);
               if (crs)
                 nc = crs->getNumControls();
-              r->tOnCourseResults.emplace_back(ccId, nc, time);
+              r->tOnCourseResults.emplace_back(ccId, nc, time, teamTotalTime);
             }
             timeRunnerIx.emplace_back(time, j, ix);
+            totalTimeRunnerIx.emplace_back(teamTotalTime, j, ix);
           }
         }
       }
@@ -1152,37 +1164,51 @@ void oEvent::computePreliminarySplitResults(const set<int> &classes) const {
           for (int i = 0; i < nr; i++) {
             if (r->tOnCourseResults.res[i].courseControlId == ccId) {
               timeRunnerIx.emplace_back(r->tOnCourseResults.res[i].time, j, i);
+              totalTimeRunnerIx.emplace_back(r->tOnCourseResults.res[i].teamTotalTime, j, i);
+
               negLeg = min(negLeg, -r->tOnCourseResults.res[i].controlIx);
               break;
             }
           }
         }
       }
-      sort(timeRunnerIx.begin(), timeRunnerIx.end());
+      
+      auto computeResult = [&rr, &negLeg](vector<tuple<int, int, int>>& timeRunnerIx, bool total) {
+        sort(timeRunnerIx.begin(), timeRunnerIx.end());
 
-      int place = 0;
-      int time = 0;
-      int leadTime = 0;
-      int numPlace = timeRunnerIx.size();
-      for (int i = 0; i < numPlace; i++) {
-        int ct = get<0>(timeRunnerIx[i]);
-        if (time != ct) {
-          time = ct;
-          place = i + 1;
-          if (leadTime == 0)
-            leadTime = time;
-        }
-        auto r = rr[get<1>(timeRunnerIx[i])];
-        int locIx = get<2>(timeRunnerIx[i]);
-        r->tOnCourseResults.res[locIx].place = place;
-        r->tOnCourseResults.res[locIx].after = time - leadTime;
+        int place = 0;
+        int time = 0;
+        int leadTime = 0;
+        int numPlace = timeRunnerIx.size();
+        for (int i = 0; i < numPlace; i++) {
+          int ct = get<0>(timeRunnerIx[i]);
+          if (time != ct) {
+            time = ct;
+            place = i + 1;
+            if (leadTime == 0)
+              leadTime = time;
+          }
+          auto r = rr[get<1>(timeRunnerIx[i])];
+          int locIx = get<2>(timeRunnerIx[i]);
+          if (total) {
+            r->tOnCourseResults.res[locIx].teamTotalPlace = place;
+            r->tOnCourseResults.res[locIx].teamTotalAfter = time - leadTime;
+          }
+          else {
+            r->tOnCourseResults.res[locIx].place = place;
+            r->tOnCourseResults.res[locIx].after = time - leadTime;
 
-        int &legWithTimeIndexNeg = r->currentControlTime.first;
-        if (negLeg < legWithTimeIndexNeg) {
-          legWithTimeIndexNeg = negLeg;
-          r->currentControlTime.second = ct;
+            int& legWithTimeIndexNeg = r->currentControlTime.first;
+            if (negLeg < legWithTimeIndexNeg) {
+              legWithTimeIndexNeg = negLeg;
+              r->currentControlTime.second = ct;
+            }
+          }
         }
-      }
+      };
+
+      computeResult(timeRunnerIx, false);
+      computeResult(totalTimeRunnerIx, true);
     }
   }
 }
diff --git a/code/oEventSQL.cpp b/code/oEventSQL.cpp
index bb81b1e..b5855d6 100644
--- a/code/oEventSQL.cpp
+++ b/code/oEventSQL.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -75,7 +75,7 @@ void oEvent::startReconnectDaemon()
   gdibase.setWindowTitle(oe->getTitleName());
   isConnectedToServer = false;
   if (!isReadOnly()) {
-    // Do not show in kiosk-mode
+    // Do not show in read only-mode
     gdibase.delayAlert(L"warning:dbproblem#" + gdibase.widen(err));
   }
 }
diff --git a/code/oEventSpeaker.cpp b/code/oEventSpeaker.cpp
index 4e07fe7..f3d775c 100644
--- a/code/oEventSpeaker.cpp
+++ b/code/oEventSpeaker.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -42,15 +42,16 @@
 //////////////////////////////////////////////////////////////////////
 
 extern gdioutput *gdi_main;
+extern oEvent* gEvent;
 constexpr int constNoLeaderTime = 10000000;
 constexpr int highlightNewResultTime = 20;
 
-oTimeLine::oTimeLine(int time_, TimeLineType type_, Priority priority_, int classId_, int ID_, oAbstractRunner *source) :
+oTimeLine::oTimeLine(int time_, TimeLineType type_, Priority priority_, int classId_, int ID_, oRunner *source) :
   time(time_), type(type_), priority(priority_), classId(classId_), ID(ID_)
 {
   if (source) {
     typeId.second = source->getId();
-    typeId.first = typeid(*source)==typeid(oTeam);
+    typeId.first = false; // typeid(*source) == typeid(oTeam);
   }
   else {
     typeId.first = false;
@@ -72,12 +73,12 @@ pCourse deduceSampleCourse(pClass pc, vector<oClass::TrueLegInfo > &stages, int
     return pc->getCourse(true);
 }
 
-oAbstractRunner *oTimeLine::getSource(const oEvent &oe) const {
+oRunner *oTimeLine::getSource(const oEvent &oe) const {
   //assert(typeId.second != 0);
   if (typeId.second > 0) {
-    if (typeId.first)
-      return oe.getTeam(typeId.second);
-    else
+    //if (typeId.first)
+    //  return oe.getTeam(typeId.second);
+    //else
       return oe.getRunner(typeId.second, 0);
   }
   return 0;
@@ -183,10 +184,8 @@ bool CompareSOResult(const oSpeakerObject &a, const oSpeakerObject &b)
   return a.names<b.names;
 }
 
-int SpeakerCB (gdioutput *gdi, int type, void *data) {
-  oEvent *oe=0;
-  gdi->getData("oEvent", *LPDWORD(&oe));
-
+int SpeakerCB (gdioutput *gdi, GuiEventType type, BaseInfo* data) {
+  oEvent *oe=gEvent;
   if (!oe)
     return false;
 
@@ -238,12 +237,11 @@ int SpeakerCB (gdioutput *gdi, int type, void *data) {
   return true;
 }
 
-int MovePriorityCB(gdioutput *gdi, int type, void *data) {
+int MovePriorityCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   if (type==GUI_LINK){
-
-    oEvent *oe=0;
-    gdi->getData("oEvent", *LPDWORD(&oe));
-    if (!oe) return false;
+    oEvent *oe = gEvent;
+    if (!oe)
+      return 0;
 
     TextInfo *ti=(TextInfo *)data;
     //gdi->alert(ti->id);
@@ -552,8 +550,6 @@ void oEvent::speakerList(gdioutput &gdi, int ClassId, int leg, int ControlId,
   gdi.setData("TotalResult", totalResults ? 1 : 0);
   gdi.setData("ShortNames", shortNames ? 1 : 0);
 
-  gdi.setData("oEvent", this);
-
   gdi.registerEvent("DataUpdate", SpeakerCB);
   gdi.setData("DataSync", 1);
   gdi.setData("PunchSync", 1);
@@ -1581,9 +1577,16 @@ void oEvent::renderTimeLineEvents(gdioutput &gdi) const
   for (TimeLineMap::const_iterator it = timeLineEvents.begin(); it != timeLineEvents.end(); ++it) {
     int t = it->second.getTime();
     wstring msg = t>0 ? getAbsTime(t) : makeDash(L"--:--:--");
-    oAbstractRunner *r = it->second.getSource(*this);
+    oRunner *r = it->second.getSource(*this);
     if (r) {
-      msg += L" (" + r->getClass(true) + L") ";
+      pClass cls = r->getClassRef(true);
+      if (cls) {
+        auto type = cls->getClassType();
+        if (type == ClassType::oClassRelay || type == ClassType::oClassIndividRelay)
+          msg += L" (" + cls->getName() + L"/" + cls->getLegNumber(r->getLegNumber()) + L") ";
+        else
+          msg += L" (" + cls->getName() + L") ";
+      }
       msg += r->getName() + L", " + r->getClub();
     }
     msg += L", " + lang.tl(it->second.getMessage());
diff --git a/code/oFreeImport.cpp b/code/oFreeImport.cpp
index 87bb0c0..acae332 100644
--- a/code/oFreeImport.cpp
+++ b/code/oFreeImport.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/oFreeImport.h b/code/oFreeImport.h
index 3e0a40d..ea8cea7 100644
--- a/code/oFreeImport.h
+++ b/code/oFreeImport.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/oFreePunch.cpp b/code/oFreePunch.cpp
index a5e00ee..37d4f3c 100644
--- a/code/oFreePunch.cpp
+++ b/code/oFreePunch.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -63,6 +63,7 @@ bool oFreePunch::Write(xmlparser &xml)
   xml.writeTime("Time", punchTime);
   xml.write("Type", type);
   xml.write("Unit", punchUnit);
+  xml.write("Origin", origin);
   xml.write("Id", Id);
   xml.write("Updated", getStamp());
   xml.endTag();
@@ -90,6 +91,9 @@ void oFreePunch::Set(const xmlobject *xo)
     else if (it->is("Unit")) {
       punchUnit = it->getInt();
     }
+    else if (it->is("Origin")) {
+      origin = it->getInt();
+    }
     else if (it->is("Id")){
       Id=it->getInt();
     }
@@ -450,12 +454,14 @@ bool oEvent::isInPunchHash(int card, int code, int time) {
   return readPunchHash.count(make_pair(p1, p2)) > 0;
 }
 
-pFreePunch oEvent::addFreePunch(int time, int type, int unit, int card, bool updateStartFinish) {
+pFreePunch oEvent::addFreePunch(int time, int type, int unit, int card, bool updateStartFinish, bool isOriginal) {
   if (time > 0 && isInPunchHash(card, type, time))
     return 0;
   oFreePunch ofp(this, card, time, type, unit);
+  if (isOriginal)
+    ofp.origin = ofp.computeOrigin(time, type);
 
-  punches.push_back(ofp);
+  punches.emplace_back(ofp);
   pFreePunch fp=&punches.back();
   fp->addToEvent(this, &ofp);
   oFreePunch::rehashPunches(*this, card, fp);
@@ -771,7 +777,7 @@ void oEvent::setHiredCard(int cardNo, bool flag) {
 
   if (isHiredCard(cardNo) != flag) {
     if (flag) {
-      addFreePunch(0, oPunch::HiredCard, 0, cardNo, false);
+      addFreePunch(0, oPunch::HiredCard, 0, cardNo, false, false);
       hiredCardHash.insert(cardNo);
       tHiredCardHashDataRevision = dataRevision;
     }
diff --git a/code/oFreePunch.h b/code/oFreePunch.h
index fe4c39a..b5999ef 100644
--- a/code/oFreePunch.h
+++ b/code/oFreePunch.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/oImportExport.cpp b/code/oImportExport.cpp
index eda2339..698c2b2 100644
--- a/code/oImportExport.cpp
+++ b/code/oImportExport.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -59,7 +59,7 @@ FlowOperation importFilterGUI(oEvent *oe,
                               const set<int>& stages,
                               const vector<string> &idProviders,
                               set<int> & filter,
-                              string &preferredIdProvider);
+                              pair<string, string> &preferredIdProvider);
 
 string conv_is(int i) {
   char bf[256];
@@ -311,7 +311,7 @@ void oEvent::importXML_EntryData(gdioutput &gdi, const wstring &file,
                                  const set<int> &filter,
                                  int classIdOffset,
                                  int courseIdOffset,
-                                 const string &preferredIdType) {
+                                 const pair<string, string> &preferredIdType) {
   vector<pair<int, int>> runnersInTeam;
   for (oRunnerList::iterator it = Runners.begin(); it != Runners.end(); ++it) {
     if (!it->isRemoved() && it->tInTeam) {
@@ -1325,7 +1325,7 @@ void oEvent::importXML_IOF_Data(const wstring &clubfile,
       reader.getIdTypes(idProviders);
 
       if (idProviders.size() > 1) {
-        string preferredIdProvider;
+        pair<string, string> preferredIdProvider;
         set<int> dmy;
         FlowOperation op = importFilterGUI(oe, gdibase, 
                                            {}, idProviders,
@@ -2677,12 +2677,12 @@ void oEvent::exportTeamSplits(xmlparser &xml, const set<int> &classes, bool oldS
     xml.endTag();
     ClassStarted = false;
   }
-
 }
 
 void oEvent::exportIOFSplits(IOFVersion version, const wchar_t *file,
                              bool oldStylePatrolExport, bool useUTC,
-                             const set<int> &classes, int leg,
+                             const set<int> &classes,
+                             const pair<string, string>& preferredIdTypes, int leg,
                              bool teamsAsIndividual, bool unrollLoops,
                              bool includeStageInfo, bool forceSplitFee,
                              bool useEventorQuirks) {
@@ -2705,6 +2705,7 @@ void oEvent::exportIOFSplits(IOFVersion version, const wchar_t *file,
     exportIOFResults(xml, true, classes, leg, oldStylePatrolExport);
   else {
     IOF30Interface writer(this, forceSplitFee, useEventorQuirks);
+    writer.setPreferredIdType(preferredIdTypes);
     writer.writeResultList(xml, classes, leg, useUTC, 
                            teamsAsIndividual, unrollLoops, includeStageInfo);
   }
@@ -2713,7 +2714,9 @@ void oEvent::exportIOFSplits(IOFVersion version, const wchar_t *file,
 }
 
 void oEvent::exportIOFStartlist(IOFVersion version, const wchar_t *file, bool useUTC,
-                                const set<int> &classes, bool teamsAsIndividual,
+                                const set<int> &classes, 
+                                const pair<string, string>& preferredIdTypes,
+                                bool teamsAsIndividual,
                                 bool includeStageInfo, 
                                 bool forceSplitFee,
                                 bool useEventorQuirks) {
@@ -2726,6 +2729,7 @@ void oEvent::exportIOFStartlist(IOFVersion version, const wchar_t *file, bool us
     exportIOFStartlist(xml);
   else {
     IOF30Interface writer(this, forceSplitFee, useEventorQuirks);
+    writer.setPreferredIdType(preferredIdTypes);
     writer.writeStartList(xml, classes, useUTC, teamsAsIndividual, includeStageInfo);
   }
   xml.closeOut();
diff --git a/code/oListInfo.cpp b/code/oListInfo.cpp
index ddf2b5f..dc3c2de 100644
--- a/code/oListInfo.cpp
+++ b/code/oListInfo.cpp
@@ -1,6 +1,6 @@
 /********************i****************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -242,7 +242,6 @@ static double adjustmentFactor(double par, double target) {
 template<typename T, int size> class WordMeasure {
   multimap<int, T> words;
 public:
-
   WordMeasure() {}
 
   void add(const T &word) {
@@ -331,7 +330,8 @@ int oListInfo::getMaxCharWidth(const oEvent *oe,
         break;
       case lPunchName:
       case lControlName:
-      case lPunchNamedTime: {
+      case lPunchNamedTime:
+      case lPunchTeamTotalNamedTime: {
         wstring maxcn = lang.tl("Mål");
         vector<pControl> ctrl;
         oe->getControls(ctrl, false);
@@ -342,6 +342,8 @@ int oListInfo::getMaxCharWidth(const oEvent *oe,
         }
         if (pps[k].type == lPunchNamedTime)
           extra = maxcn + L": 50:50 (50:50)";
+        if (pps[k].type == lPunchTeamTotalNamedTime)
+          extra = maxcn + L": 2:50:50 (50:50)";
         else
           maxcn.swap(extra);
       }
@@ -366,6 +368,7 @@ int oListInfo::getMaxCharWidth(const oEvent *oe,
       case lRunnerTimeAdjustment:
       case lRunnerGeneralTimeAfter:
       case lPunchTotalTimeAfter:
+      case lPunchTeamTotalTimeAfter:
         extra = L"+10:00";
         break;
       case lTeamRogainingPointOvertime:
@@ -390,12 +393,15 @@ int oListInfo::getMaxCharWidth(const oEvent *oe,
       case lRunnerStageStatus:
       case lRunnerTimePlaceFixed:
       case lPunchLostTime:
-      case lPunchTotalTime:
       case lPunchTimeSinceLast:
       case lPunchSplitTime:
       case lPunchNamedSplit:
         extra = L"50:50";
         break;
+      case lPunchTotalTime:
+      case lPunchTeamTotalTime:
+        extra = L"1:50:50";
+        break;
       case lRunnerGeneralTimeStatus:
       case lClassStartTimeRange:
         extra = L"50:50 (50:50)";
@@ -415,7 +421,15 @@ int oListInfo::getMaxCharWidth(const oEvent *oe,
       case lTeamTotalPlace:
       case lPunchControlPlace:
       case lPunchControlPlaceAcc:
-      case lRunnerStagePlace:           
+      case lPunchControlPlaceTeamAcc:
+      case lRunnerStagePlace:
+      case lRunnerDataA:
+      case lRunnerDataB:
+      case lTeamDataA:
+      case lTeamDataB:
+      case lClassDataA:
+      case lClassDataB:
+      
         extra = L"99.";
         break;
       case lRunnerGeneralPlace:
@@ -517,7 +531,7 @@ int oListInfo::getMaxCharWidth(const oEvent *oe,
       pp.linearLegIndex = true;
       int numIter = 1;
 
-      if (pp.type == lPunchNamedTime || pp.type == lPunchTime) {
+      if (pp.type == lPunchNamedTime || pp.type == lPunchTime || pp.type == lPunchTeamTime) {
         row[k] = max(row[k], 10);
         pRunner r = pRunner(&*it);
         numIter = (r && r->getCard()) ? r->getCard()->getNumPunches() + 1 : 1;
@@ -693,14 +707,16 @@ const wstring &oEvent::formatPunchStringAux(const oPrintPost &pp, const oListPar
     }
     break;
   case lPunchTime:
+  case lPunchTeamTime:
   case lPunchControlNumber:
   case lPunchControlCode:
   case lPunchLostTime:
   case lPunchControlPlace:
   case lPunchControlPlaceAcc:
-  
+  case lPunchControlPlaceTeamAcc:
   case lPunchSplitTime:
   case lPunchTotalTime:
+  case lPunchTeamTotalTime:
   case lPunchAbsTime:
     if (punch && r && !invalidClass) {
       if (punch->tIndex >= 0) {
@@ -710,9 +726,14 @@ const wstring &oEvent::formatPunchStringAux(const oPrintPost &pp, const oListPar
         break;
       }
       switch (pp.type) {
-        case lPunchTime: {
+        case lPunchTime:
+        case lPunchTeamTime: {
           if (punch->hasTime()) {
-            swprintf_s(bfw, L"\u2013 (%s)", formatTime(punch->getTimeInt() - r->getStartTime()).c_str());
+            int off = 0;
+            if (pp.type == lPunchTeamTime && r->getTeam())
+              off = r->getTeam()->getTotalRunningTimeAtLegStart(r->getLegNumber(), false);
+
+            swprintf_s(bfw, L"\u2013 (%s)", formatTime(off + punch->getTimeInt() - r->getStartTime(), SubSecond::Off).c_str());
           }
           else {
             wsptr = &makeDash(L"- (-)");
@@ -733,12 +754,24 @@ const wstring &oEvent::formatPunchStringAux(const oPrintPost &pp, const oListPar
         }
         case lPunchAbsTime: {
           if (punch->hasTime())
-            wsptr = &getAbsTime(punch->getTimeInt());
+            wsptr = &getAbsTime(punch->getTimeInt(), SubSecond::Off);
           break;
         }
         case lPunchTotalTime: {
           if (punch->hasTime())
-            wsptr = &formatTime(punch->getTimeInt() - r->getStartTime());
+            wsptr = &formatTime(punch->getTimeInt() - r->getStartTime(), SubSecond::Off);
+          break;
+        }
+        case lPunchTeamTotalTime: {
+          if (punch->hasTime()) {
+            pTeam t = r->getTeam();
+            if (!t || r->getLegNumber() == 0)
+              wsptr = &formatTime(punch->getTimeInt() - r->getStartTime(), SubSecond::Off);
+            else {
+              int input = t->getTotalRunningTimeAtLegStart(r->getLegNumber(), false);
+              wsptr = &formatTime(input + punch->getTimeInt() - r->getStartTime(), SubSecond::Off);
+            }
+          }
           break;
         }
       }
@@ -865,6 +898,11 @@ const wstring &oEvent::formatSpecialStringAux(const oPrintPost &pp, const oListP
       }
     break;
 
+    case lCourseNumControls:
+      if (pc)
+        wsptr = &itow(pc->getNumControls());
+    break;
+
     case lCourseClasses:
       if (pc) {
         vector<pClass> cls;
@@ -946,12 +984,12 @@ const wstring &oEvent::formatSpecialStringAux(const oPrintPost &pp, const oListP
 
     case lControlMedianLostTime:
       if (ctrl) 
-        wsptr = &formatTime(ctrl->getMissedTimeMedian()); 
+        wsptr = &formatTime(ctrl->getMissedTimeMedian(), SubSecond::Off); 
     break;
 
     case lControlMaxLostTime:
       if (ctrl) 
-        wsptr = &formatTime(ctrl->getMissedTimeMax()); 
+        wsptr = &formatTime(ctrl->getMissedTimeMax(), SubSecond::Off);
       break;
     
     case lControlMistakeQuotient:
@@ -1101,7 +1139,7 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
       if (pc) {
         int first, last;
         pc->getStartRange(legIndex, first, last);
-        if (pc->hasFreeStart())
+        if (pc->hasFreeStart() || pc->hasRequestStart())
           wsptr = &lang.tl("Fri starttid");
         else if (first > 0 && first == last) {
           if (oe->useStartSeconds())
@@ -1174,12 +1212,37 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
       }
       break;
 
+    case lClassDataA:
+      if (pc)
+        wsptr = &itow(pc->getDCI().getInt("DataA"));
+      break;
+
+    case lClassDataB:
+      if (pc)
+        wsptr = &itow(pc->getDCI().getInt("DataB"));
+      break;
+
+    case lClassTextA:
+      if (pc)
+        wsptr = &pc->getDCI().getString("TextA");
+      break;
+
     case lCourseClimb:
+    case lCourseUsageNoVacant:
+    case lCourseUsage:
       if (r) {
         pCourse crs = r->getCourse(false);
          return formatSpecialStringAux(pp, par, t, 0, crs, 0, counter);
       }
     break;
+
+    case lCourseNumControls:
+      if (r) {
+        pCourse crs = r->getCourse(true);
+        return formatSpecialStringAux(pp, par, t, 0, crs, 0, counter);
+      }
+      break;
+
     case lCourseShortening:
       if (r) {
         int sh = r->getNumShortening();
@@ -1783,7 +1846,7 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
     case lRunnerTimePlaceFixed:
       if (r && !invalidClass) {
         int t = r->getTimeWhenPlaceFixed();
-        if (t == 0 || (t>0 && t < getComputerTime())) {
+        if (t == 0 || (t > 0 && t < getComputerTime())) {
           wcscpy_s(wbf, lang.tl("klar").c_str());
         }
         else if (t == -1)
@@ -1837,6 +1900,12 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
           wsptr = &bib;
       }
       break;
+    case lRunnerRentalCard:
+      if (r && r->isRentalCard()) {
+        wsptr = &lang.tl("Hyrd");
+      }
+      break;
+
     case lRunnerUMMasterPoint:
       if (r) {
         int total, finished, dns;
@@ -2203,8 +2272,6 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
     case lTeamTotalPlace:
       if (t && !invalidClass && !noTimingTeam()) wcscpy_s(wbf, t->getPrintTotalPlaceS(pp.text.empty()).c_str() );
       break;
-
-      break;
     case lTeamTotalTimeAfter:
       if (t && pc && !invalidClass) {
         int tleg = t->getNumRunners() - 1;
@@ -2237,6 +2304,31 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
       if (r)
         swprintf_s(wbf, L"%d", r->getStartNo());
       break;
+    case lRunnerDataA:
+      if (r)
+        wsptr = &itow(r->getDCI().getInt("DataA"));
+      break;
+    case lRunnerDataB:
+      if (r)
+        wsptr = &itow(r->getDCI().getInt("DataB"));
+      break;
+    case lRunnerTextA:
+      if (r)
+        wsptr = &r->getDCI().getString("TextA");
+      break;
+
+    case lTeamDataA:
+      if (t)
+        wsptr = &itow(t->getDCI().getInt("DataA"));
+      break;
+    case lTeamDataB:
+      if (t)
+        wsptr = &itow(t->getDCI().getInt("DataB"));
+      break;
+    case lTeamTextA:
+      if (t)
+        wsptr = &t->getDCI().getString("TextA");
+      break;
     case lNationality:
       if (r && !(wsptr = &r->getDCI().getString("Nationality"))->empty())
         break;
@@ -2259,17 +2351,22 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
     case lControlName:
     case lPunchName:
     case lPunchNamedTime:
+    case lPunchTeamTotalNamedTime:
     case lPunchNamedSplit:
     case lPunchTime:
+    case lPunchTeamTime:
     case lPunchSplitTime:
     case lPunchTotalTime:
+    case lPunchTeamTotalTime:
     case lPunchControlNumber:
     case lPunchControlCode:
     case lPunchLostTime:
     case lPunchControlPlace:
     case lPunchControlPlaceAcc:
+    case lPunchControlPlaceTeamAcc:
     case lPunchAbsTime:
     case lPunchTotalTimeAfter:
+    case lPunchTeamTotalTimeAfter:
       if (r && r->getCourse(false) && !invalidClass) {
         const pCourse crs=r->getCourse(true);
         const oControl *ctrl = nullptr;
@@ -2281,22 +2378,22 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
         }
         switch (pp.type) {
           case lPunchNamedSplit:
-            if (ctrl && ctrl->hasName() && r->getPunchTime(counter.level3, false, true) > 0) {
-              swprintf_s(wbf, L"%s", r->getNamedSplitS(counter.level3).c_str());
+            if (ctrl && ctrl->hasName() && r->getPunchTime(counter.level3, false, true, false) > 0) {
+              swprintf_s(wbf, L"%s", r->getNamedSplitS(counter.level3, SubSecond::Off).c_str());
             }
           break;
 
           case lPunchNamedTime:
-            if (ctrl && ctrl->hasName() && (!par.lineBreakControlList || r->getPunchTime(counter.level3, false, true) > 0)) {
+          case lPunchTeamTotalNamedTime:
+            if (ctrl && ctrl->hasName() && (!par.lineBreakControlList || r->getPunchTime(counter.level3, false, true, false) > 0)) {
               swprintf_s(wbf, L"%s: %s (%s)", ctrl->getName().c_str(),
-                          r->getNamedSplitS(counter.level3).c_str(),
-                          r->getPunchTimeS(counter.level3, false, true, SubSecond::Off).c_str());
+                         r->getPunchTimeS(counter.level3, false, true, pp.type == lPunchTeamTotalNamedTime, SubSecond::Off).c_str(),
+                         r->getNamedSplitS(counter.level3, SubSecond::Off).c_str());
             }
-          break;
-
+            break;
           case lControlName:
           case lPunchName:
-            if (ctrl && ctrl->hasName() && (!par.lineBreakControlList || r->getPunchTime(counter.level3, false, true) > 0)) {
+            if (ctrl && ctrl->hasName() && (!par.lineBreakControlList || r->getPunchTime(counter.level3, false, true, false) > 0)) {
               swprintf_s(wbf, L"%s", ctrl->getName().c_str());
             }
             else if (counter.level3 == nCtrl) {
@@ -2304,27 +2401,30 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
             }
             break;
 
-          case lPunchTime: {
+          case lPunchTime:
+          case lPunchTeamTime: {
             swprintf_s(wbf, L"%s (%s)",
-                       r->getSplitTimeS(counter.level3, false).c_str(),
-                       r->getPunchTimeS(counter.level3, false, true, SubSecond::Off).c_str());
+                       r->getSplitTimeS(counter.level3, false, SubSecond::Off).c_str(),
+                       r->getPunchTimeS(counter.level3, false, true, pp.type == lPunchTeamTime, SubSecond::Off).c_str());
             break;
           }
           case lPunchSplitTime: {
-            wcscpy_s(wbf, r->getSplitTimeS(counter.level3, false).c_str());
+            wcscpy_s(wbf, r->getSplitTimeS(counter.level3, false, SubSecond::Off).c_str());
             break;
           }
-          case lPunchTotalTime: {
-            if (r->getPunchTime(counter.level3, false, true) > 0) {
-              wcscpy_s(wbf, r->getPunchTimeS(counter.level3, false, true, SubSecond::Off).c_str());
-            }
+          case lPunchTotalTime:
+          case lPunchTeamTotalTime: {
+            int pt = r->getPunchTime(counter.level3, false, true, pp.type == lPunchTeamTotalTime);
+            if (pt > 0) 
+              wsptr = &formatTime(pt, SubSecond::Off);
             break;
           }
-          case lPunchTotalTimeAfter: {
-            if (r->getPunchTime(counter.level3, false, true) > 0) {
-              int rt = r->getLegTimeAfterAcc(counter.level3);
+          case lPunchTotalTimeAfter:
+          case lPunchTeamTotalTimeAfter: {
+            if (r->getPunchTime(counter.level3, false, true, false) > 0) {
+              int rt = r->getLegTimeAfterAcc(counter.level3, pp.type == lPunchTeamTotalTimeAfter);
               if (rt > 0)
-                wcscpy_s(wbf, (L"+" + formatTime(rt)).c_str());
+                wcscpy_s(wbf, (L"+" + formatTime(rt, SubSecond::Off)).c_str());
             }
             break;
           }
@@ -2350,8 +2450,9 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
               swprintf_s(wbf, L"%d", p);
             break;
           }
-          case lPunchControlPlaceAcc: {
-            int p = r->getLegPlaceAcc(counter.level3);
+          case lPunchControlPlaceAcc:
+          case lPunchControlPlaceTeamAcc: {
+            int p = r->getLegPlaceAcc(counter.level3, pp.type == lPunchControlPlaceTeamAcc);
             if (p > 0)
               swprintf_s(wbf, L"%d", p);
             break;
@@ -2361,7 +2462,7 @@ const wstring &oEvent::formatListStringAux(const oPrintPost &pp, const oListPara
             break;
           }
           case lPunchAbsTime: {
-            int t = r->getPunchTime(counter.level3, false, true);
+            int t = r->getPunchTime(counter.level3, false, true, false);
             if (t > 0)
               wsptr = &getAbsTime(r->tStartTime + t);
             break;
@@ -2928,7 +3029,7 @@ bool oListInfo::filterRunner(const oRunner &r) const {
       return true;
   }
 
-  if (filter(EFilterRentCard) && r.getDCI().getInt("CardFee") == 0)
+  if (filter(EFilterRentCard) && !r.isRentalCard())
     return true;
 
   if (filter(EFilterHasCard) && r.getCardNo() == 0)
@@ -2996,6 +3097,7 @@ GeneralResult *oListInfo::applyResultModule(oEvent &oe, vector<pRunner> &rlist)
 
 void oEvent::formatHeader(gdioutput& gdi, const oListInfo& li, const pRunner rInput) {
   vector< pair<EPostType, wstring> > v;
+  int* xLimitForwardUpdate = nullptr;
   for (auto& lp : li.head) {
     bool strUpdate = lp.type == lCmpName || lp.type == lString;
     if (lp.xlimit == 0 && !strUpdate) {
@@ -3011,6 +3113,13 @@ void oEvent::formatHeader(gdioutput& gdi, const oListInfo& li, const pRunner rIn
       gdiFonts font = lp.getFont();
       lp.xlimit = li.getMaxCharWidth(this, gdi, li.getParam().selection, v, font, lp.fontFace.c_str());
     }
+    if (xLimitForwardUpdate)
+      (*xLimitForwardUpdate) += lp.xlimit;
+
+    if (lp.doMergeNext && xLimitForwardUpdate == nullptr)
+      xLimitForwardUpdate = &lp.xlimit;
+    else
+      xLimitForwardUpdate = nullptr;
   }
 
   pTeam team = nullptr;
@@ -3073,6 +3182,8 @@ void oEvent::generateListInternal(gdioutput &gdi, const oListInfo &li, bool form
       calculateTeamResults(li.lp.selection, ResultType::TotalResult);
     if (li.calcCourseResults)
       calculateTeamResults(li.lp.selection, ResultType::CourseResult);
+    if (li.calculateLiveResults || li.sortOrder == SortOrder::ClassLiveResult)
+      calculateResults(li.lp.selection, ResultType::PreliminarySplitResults);
 
     if (li.calcCourseClassResults)
       calculateResults(li.lp.selection, ResultType::ClassCourseResult);
@@ -3125,8 +3236,9 @@ void oEvent::generateListInternal(gdioutput &gdi, const oListInfo &li, bool form
   
   vector<pTeam> tlist;
   tlist.reserve(Teams.size());
+  const bool include_nc = li.filter(EFilterIncludeNotParticipating);
   for (oTeamList::iterator it = Teams.begin(); it != Teams.end(); ++it) {
-    if (it->isRemoved() || it->tStatus == StatusNotCompetiting)
+    if (it->isRemoved() || (!include_nc && it->tStatus == StatusNotCompetiting))
       continue;
 
     if (!li.lp.selection.empty() && li.lp.selection.count(it->getClassId(true)) == 0)
@@ -3160,7 +3272,7 @@ void oEvent::generateListInternal(gdioutput &gdi, const oListInfo &li, bool form
     bool includeSubHead, int &parLegRangeMin, int &parLegRangeMax, pClass &parLegRangeClass) {
     int linearLegSpec = li.lp.getLegNumber(it->getClassRef(false));
 
-    if (gResult && it->getTempResult(0).getStatus() == StatusNotCompetiting)
+    if (gResult && it->getTempResult(0).getStatus() == StatusNotCompetiting && !li.filter(EFilterIncludeNotParticipating))
       return false;
 
     if (li.filter(EFilterExcludeDNS)) {
@@ -3213,6 +3325,11 @@ void oEvent::generateListInternal(gdioutput &gdi, const oListInfo &li, bool form
         }
       }
     }
+    else if (li.filter(EFilterAnyResult)) {
+      pRunner r = it->getRunner(linearLegSpec);
+      if (!r || !r->hasOnCourseResult())
+        return false;
+    }
 
     const bool needParRange = li.subFilter(ESubFilterSameParallel)
                               || li.subFilter(ESubFilterSameParallelNotFirst);
@@ -3359,8 +3476,8 @@ void oEvent::generateListInternal(gdioutput &gdi, const oListInfo &li, bool form
         }
       }
       else if (li.listSubType == li.EBaseTypeCoursePunches ||
-        li.listSubType == li.EBaseTypeAllPunches) {
-        pRunner r = it->Runners.empty() ? 0 : it->Runners[0];
+               li.listSubType == li.EBaseTypeAllPunches) {
+        pRunner r = it->getRunner(linearLegSpec);
         if (!r) 
           return true;
 
@@ -3632,7 +3749,7 @@ void oEvent::fillListTypes(gdioutput &gdi, const string &name, int filter)
     //gdi.addItem(name, it->second.Name, it->first);
   }
   sort(v.begin(), v.end());
-  gdi.addItem(name, v);
+  gdi.setItems(name, v);
 }
 
 void oEvent::getListType(EStdListType type, oListInfo &li)
@@ -3997,7 +4114,7 @@ void oEvent::generateListInfo(const gdioutput& target, EStdListType lt, int clas
   generateListInfo(target, par, li);
 }
 
-int openRunnerTeamCB(gdioutput *gdi, int type, void *data);
+int openRunnerTeamCB(gdioutput *gdi, GuiEventType type, BaseInfo *data);
 
 void oEvent::generateFixedList(gdioutput &gdi, const oListInfo &li)
 {
diff --git a/code/oListInfo.h b/code/oListInfo.h
index 92c8377..3493fdf 100644
--- a/code/oListInfo.h
+++ b/code/oListInfo.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -53,6 +53,10 @@ enum EPostType {
   lClassAvailableMaps,
   lClassTotalMaps,
   lClassNumEntries,
+  lClassDataA,
+  lClassDataB,
+  lClassTextA,
+
   lCourseLength,
   lCourseName,
   lCourseNumber,
@@ -61,6 +65,7 @@ enum EPostType {
   lCourseUsage,
   lCourseUsageNoVacant,
   lCourseClasses,
+  lCourseNumControls,
   lRunnerName,
   lRunnerGivenName,
   lRunnerFamilyName,
@@ -96,6 +101,7 @@ enum EPostType {
   lRunnerStartZero,
   lRunnerClub,
   lRunnerCard,
+  lRunnerRentalCard,
   lRunnerBib,
   lRunnerStartNo,
   lRunnerRank,
@@ -134,6 +140,9 @@ enum EPostType {
   lRunnerEntryDate,
   lRunnerEntryTime,
   lRunnerId,
+  lRunnerDataA,
+  lRunnerDataB,
+  lRunnerTextA,
 
   lTeamName,
   lTeamStart,
@@ -171,20 +180,33 @@ enum EPostType {
   lTeamTotalTimeDiff,
   lTeamPlaceDiff,
 
+  lTeamDataA,
+  lTeamDataB,
+  lTeamTextA,
+
   lPunchNamedTime,
+  lPunchTeamTotalNamedTime,
   lPunchNamedSplit,
+  
   lPunchName,
 
   lPunchTime,
+  lPunchTeamTime,
+
   lPunchControlNumber,
   lPunchControlCode,
   lPunchLostTime,
   lPunchControlPlace,
   lPunchControlPlaceAcc,
+  lPunchControlPlaceTeamAcc,
 
   lPunchSplitTime,
   lPunchTotalTime,
   lPunchTotalTimeAfter,
+
+  lPunchTeamTotalTime,
+  lPunchTeamTotalTimeAfter,
+
   lPunchAbsTime,
   lPunchTimeSinceLast,
 
@@ -341,8 +363,8 @@ struct oPrintPost {
 };
 
 class gdioutput;
+class BaseInfo;
 enum gdiFonts;
-typedef int (*GUICALLBACK)(gdioutput *gdi, int type, void *data);
 class xmlparser;
 class xmlobject;
 class MetaListContainer;
@@ -452,7 +474,6 @@ struct oListParam {
 
   void updateDefaultName(const wstring &pname) const {defaultName = pname;}
   void setCustomTitle(const wstring &t) {title = t;}
-  void getCustomTitle(wchar_t *t) const; // 256 size buffer required. Get title if set
   const wstring &getCustomTitle(const wstring &t) const;
   const wstring &getDefaultName() const {return defaultName;}
   void setName(const wstring &n) {name = n;}
diff --git a/code/oPunch.cpp b/code/oPunch.cpp
index f2860d1..41d6ec6 100644
--- a/code/oPunch.cpp
+++ b/code/oPunch.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -34,12 +34,11 @@
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////
 
-oPunch::oPunch(oEvent *poe): oBase(poe) {
-  type=0;
-  punchTime=0;
-  tTimeAdjust=0;
-  isUsed=false;
-  hasBeenPlayed=false;
+oPunch::oPunch(oEvent* poe) : oBase(poe) {
+  type = 0;
+  punchTime = 0;
+  isUsed = false;
+  hasBeenPlayed = false;
   tMatchControlId = -1;
   tRogainingIndex = 0;
   anyRogainingMatchControlId = -1;
@@ -67,18 +66,24 @@ void oPunch::appendCodeString(string &dst) const {
   else
     ubf[0] = 0;
 
+  char ubo[16];
+  if (origin != 0)
+    sprintf_s(ubo, "#%d", origin);
+  else
+    ubo[0] = 0;
+
   char bf[48];
   if (timeConstSecond > 1 && punchTime != -1) {
     if (punchTime >= 0)
-      sprintf_s(bf, 32, "%d-%d.%d%s;", type, punchTime / timeConstSecond,
-        punchTime % timeConstSecond, ubf);
+      sprintf_s(bf, 32, "%d-%d.%d%s%s;", type, punchTime / timeConstSecond,
+        punchTime % timeConstSecond, ubf, ubo);
     else {
-      sprintf_s(bf, 32, "%d--%d.%d%s;", type, (-punchTime) / timeConstSecond, 
-        (-punchTime) % timeConstSecond, ubf);
+      sprintf_s(bf, 32, "%d--%d.%d%s%s;", type, (-punchTime) / timeConstSecond, 
+        (-punchTime) % timeConstSecond, ubf, ubo);
     }
   }
   else
-    sprintf_s(bf, 32, "%d-%d%s;", type, punchTime, ubf);
+    sprintf_s(bf, 32, "%d-%d%s%s;", type, punchTime, ubf, ubo);
 
   dst.append(bf);
 }
@@ -127,6 +132,18 @@ void oPunch::decodeString(const char *s) {
   else {
     punchUnit = 0;
   }
+
+  while (*s && *s != '#' && *s != ';') {
+    s++;
+  }
+
+  if (*s == '#') {
+    ++s;
+    origin = atoi(s);
+  }
+  else {
+    origin = 0;
+  }
 }
 
 wstring oPunch::getString() const {
@@ -134,8 +151,14 @@ wstring oPunch::getString() const {
 
   const wchar_t *ct;
   wstring time(getTime(false, SubSecond::Auto));
-  ct=time.c_str();
-
+  if (!isOriginal() && origin != 0) {
+    if (time.length() == 1)
+      time = L"\u270E";
+    else
+      time = L"\u270E" + time;
+  }
+  ct = time.c_str();
+  
   wstring typeS = getType();
   const wchar_t *tp = typeS.c_str();
 
@@ -173,24 +196,25 @@ wstring oPunch::getSimpleString() const
 wstring oPunch::getTime(bool adjust, SubSecond mode) const
 {
   if (punchTime >= 0) {
+    int at = getTimeInt();
     if (adjust)
-      return oe->getAbsTime(getTimeInt() + tTimeAdjust, mode);
-    else
-      return oe->getAbsTime(getTimeInt(), mode);
+      at += tTimeAdjust.second;
+    if (at > 0)
+      return oe->getAbsTime(at, mode);
   }
-  else return makeDash(L"-");
+  return makeDash(L"-");
 }
 
 int oPunch::getTimeInt() const {
   if (punchUnit > 0)
     return punchTime + oe->getUnitAdjustment(oPunch::SpecialPunch(type), punchUnit);
-  return punchTime;
+  return punchTime + tTimeAdjust.first; // Adjustment "wrong time" at control
 }
 
 int oPunch::getAdjustedTime() const
 {
   if (punchTime>=0)
-    return getTimeInt() +tTimeAdjust;
+    return getTimeInt() + tTimeAdjust.second;
   else return -1;
 }
 
@@ -201,18 +225,19 @@ void oPunch::setTime(const wstring &t)
     return;
   }
  
-  int tt = oe->getRelativeTime(t);
+  int tt = oe->getRelativeTime(t) - tTimeAdjust.first;
   if (tt < 0)
     tt = 0;
   else if (punchUnit > 0) {
     tt -= oe->getUnitAdjustment(oPunch::SpecialPunch(type), punchUnit);
-
   }
   setTimeInt(tt, false);
 }
 
 void oPunch::setTimeInt(int tt, bool databaseUpdate) {
   if (tt != punchTime) {
+    if (origin == 0)
+      origin = -1; // Manual change
     punchTime = tt;
     if (!databaseUpdate)
       updateChanged();
@@ -269,3 +294,40 @@ const wstring &oPunch::getType(int t) {
 void oPunch::changedObject() {
   // Does nothing
 }
+
+namespace {
+  constexpr uint64_t origin_key = 1300602071;
+}
+
+int oPunch::computeOrigin(int time, int code) {
+  if (time <= 0 || code <= 0)
+    return false;
+  static_assert(timeConstHour == 36000);
+  time = time % (36000 * 24 * 7);
+  code = code % 29;
+  uint64_t xcode = (time * 29 + code) * 7;
+  assert(xcode > 0 && xcode < 1300000000);
+  return (xcode*53458ul) % origin_key;
+}
+
+bool oPunch::isOriginal() const {
+  if (origin <= 0)
+    return false;
+  return computeOrigin(oe->getZeroTimeNum() + punchTime, type) == origin;
+}
+
+int oPunch::getOriginalTime() const {
+  if (origin <= 0)
+    return 0;
+
+  constexpr uint64_t inv = 91551603;
+  int xcode = int((inv * uint64_t(origin)) % origin_key);
+  if (xcode % 7 != 0)
+    return 0;
+
+  int pt = ((xcode/7)-type%29) / 29;
+
+  if (punchUnit > 0)
+    return pt + oe->getUnitAdjustment(oPunch::SpecialPunch(type), punchUnit);
+  return pt + tTimeAdjust.first; // Adjustment "wrong time" at control
+}
diff --git a/code/oPunch.h b/code/oPunch.h
index 8925618..ef6da04 100644
--- a/code/oPunch.h
+++ b/code/oPunch.h
@@ -7,7 +7,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -37,7 +37,7 @@ protected:
   int type = 0;
   int punchTime = 0;
   int punchUnit = 0;
-
+  int origin = 0;
   bool isUsed = false; //Is used in the course...
 
   // Index into course (-1 if unused)
@@ -48,8 +48,9 @@ protected:
   // Number of rogaining points given
   int tRogainingPoints;
 
-  //Adjustment of this punch, loaded from control
-  int tTimeAdjust;
+  //Adjustment of this punch, loaded from control. First is a fixed time adjustment (from control, "wrong time set")
+  // second is dynamic adjustment (minimum time between controls etc)
+  pair<int, int> tTimeAdjust;
 
   int tCardIndex = -1; // Index into card
   int tIndex; // Control match index in course
@@ -58,7 +59,7 @@ protected:
 
   /** Get internal data buffers for DI */
   oDataContainer& getDataBuffers(pvoid& data, pvoid& olddata, pvectorstr& strData) const;
-  int getDISize() const { return -1; }
+  int getDISize() const final { return -1; }
 
   void changedObject();
   mutable int previousPunchTime; /// Note that this is not valid in general
@@ -74,6 +75,10 @@ public:
   void remove();
   bool canRemove() const;
 
+  static int computeOrigin(int time, int code);
+  bool isOriginal() const;
+  int getOriginalTime() const;
+
   wstring getInfo() const;
 
   bool isHiredCard() const { return type == HiredCard; }
@@ -102,8 +107,9 @@ public:
   void setTime(const wstring& t);
   virtual void setTimeInt(int newTime, bool databaseUpdate);
 
-  void setTimeAdjust(int t) { tTimeAdjust = t; }
-  void adjustTimeAdjust(int t) { tTimeAdjust += t; }
+  void clearTimeAdjust() { tTimeAdjust = make_pair(0, 0); }
+  void setTimeAdjust(int t) { tTimeAdjust.first = t; }
+  void adjustTimeAdjust(int t) { tTimeAdjust.second += t; }
 
   wstring getRunningTime(int startTime) const;
 
diff --git a/code/oReport.cpp b/code/oReport.cpp
index c9a1e06..1a5d456 100644
--- a/code/oReport.cpp
+++ b/code/oReport.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/oRunner.cpp b/code/oRunner.cpp
index 4702e1d..23019a7 100644
--- a/code/oRunner.cpp
+++ b/code/oRunner.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -574,7 +574,7 @@ void oAbstractRunner::setClassId(int id, bool isManualUpdate) {
   Class = id ? oe->getClass(id) : nullptr;
 
   if (Class!=pc) {
-    apply(ChangeType::Update, 0);
+    apply(ChangeType::Update, nullptr);
     if (Class) {
       Class->clearCache(true);
     }
@@ -1132,8 +1132,8 @@ bool oAbstractRunner::setTmpStore() {
   return res;
 }*/
 
-bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
-                           int addpunch, ChangeType changeType) {
+bool oRunner::evaluateCard(bool doApply, vector<int>& missingPunches,
+  int addpunch, ChangeType changeType) {
   if (unsigned(status) >= 100u)
     status = StatusUnknown; //Reset bad input
   pClass clz = getClassRef(true);
@@ -1141,8 +1141,8 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   const int oldFT = FinishTime;
   int oldStartTime;
   RunnerStatus oldStatus;
-  int *refStartTime;
-  RunnerStatus *refStatus;
+  int* refStartTime;
+  RunnerStatus* refStatus;
 
   if (doApply) {
     oldStartTime = tStartTime;
@@ -1167,14 +1167,14 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   // Reset card data
   oPunchList::iterator p_it;
   if (Card) {
-    for (p_it=Card->punches.begin(); p_it!=Card->punches.end(); ++p_it) {
-        p_it->tRogainingIndex = -1;
-        p_it->anyRogainingMatchControlId = -1;
-        p_it->tRogainingPoints = 0;
-        p_it->isUsed = false;
-        p_it->tIndex = -1;
-        p_it->tMatchControlId = -1;
-        p_it->tTimeAdjust = 0;
+    for (p_it = Card->punches.begin(); p_it != Card->punches.end(); ++p_it) {
+      p_it->tRogainingIndex = -1;
+      p_it->anyRogainingMatchControlId = -1;
+      p_it->tRogainingPoints = 0;
+      p_it->isUsed = false;
+      p_it->tIndex = -1;
+      p_it->tMatchControlId = -1;
+      p_it->clearTimeAdjust();
     }
   }
 
@@ -1225,10 +1225,10 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
     int maxTimeStatus = 0;
     if (getFinishTime() <= 0)
       *refStatus = StatusDNF;
-    else {      
+    else {
       if (clz) {
         int mt = clz->getMaximumRunnerTime();
-        if (mt>0) {
+        if (mt > 0) {
           if (getRunningTime(false) > mt)
             maxTimeStatus = 1;
           else
@@ -1239,7 +1239,7 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
       }
 
       if (*refStatus == StatusMAX && maxTimeStatus == 2)
-        *refStatus = StatusUnknown;      
+        *refStatus = StatusUnknown;
     }
     if (*refStatus == StatusUnknown || *refStatus == StatusCANCEL || *refStatus == StatusDNS || *refStatus == StatusMAX) {
       if (maxTimeStatus == 1)
@@ -1259,10 +1259,10 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   // Pairs: <control index, point>
   intkeymap<pair<int, int>> rogaining(course->getNumControls());
   unordered_set<int> requiredRG;
-  for (int k = 0; k< course->nControls; k++) {
+  for (int k = 0; k < course->nControls; k++) {
     if (course->Controls[k] && course->Controls[k]->isRogaining(hasRogaining)) {
       int pt = course->Controls[k]->getRogainingPoints();
-      for (int j = 0; j<course->Controls[k]->nNumbers; j++) {
+      for (int j = 0; j < course->Controls[k]->nNumbers; j++) {
         rogaining.insert(course->Controls[k]->Numbers[j], make_pair(k, pt));
       }
       if (course->Controls[k]->getStatus() == oControl::ControlStatus::StatusRogainingRequired)
@@ -1271,11 +1271,11 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   }
 
   if (addpunch && Card->punches.empty()) {
-    Card->addPunch(addpunch, -1, course->Controls[0] ? course->Controls[0]->getId():0, 0);
+    Card->addPunch(addpunch, -1, course->Controls[0] ? course->Controls[0]->getId() : 0, 0, oCard::PunchOrigin::Manual);
   }
 
   if (Card->punches.empty()) {
-    for(int k=0;k<course->nControls;k++) {
+    for (int k = 0; k < course->nControls; k++) {
       if (course->Controls[k]) {
         course->Controls[k]->startCheckControl();
         course->Controls[k]->addUncheckedPunches(missingPunches, hasRogaining);
@@ -1296,7 +1296,7 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   }
 
   // Reset rogaining
-  for (p_it=Card->punches.begin(); p_it!=Card->punches.end(); ++p_it) {
+  for (p_it = Card->punches.begin(); p_it != Card->punches.end(); ++p_it) {
     p_it->tRogainingIndex = -1;
     p_it->anyRogainingMatchControlId = -1;
     p_it->tRogainingPoints = 0;
@@ -1306,11 +1306,11 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
 
 
   //Search for start and update start time.
-  p_it=Card->punches.begin();
-  while ( p_it!=Card->punches.end()) {
+  p_it = Card->punches.begin();
+  while (p_it != Card->punches.end()) {
     if (p_it->type == startPunchCode) {
       if (tUseStartPunch && p_it->getAdjustedTime() != *refStartTime) {
-        p_it->setTimeAdjust(0);
+        p_it->clearTimeAdjust();
         *refStartTime = p_it->getAdjustedTime();
         if (*refStartTime != oldStartTime)
           clearSplitAnalysis = true;
@@ -1321,107 +1321,147 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
     ++p_it;
   }
 
-  inthashmap expectedPunchCount(course->nControls);
-  inthashmap punchCount(Card->punches.size());
-  for (int k=0; k<course->nControls; k++) {
-    pControl ctrl=course->Controls[k];
+  //inthashmap expectedPunchCount(course->nControls);
+  //inthashmap punchCount(Card->punches.size());
+  map<int, int> punchCount;
+  map<int, int> expectedPunchCount;
+  map<int, int> controlToBase; // For multiple controls. Maps control code to base (or -1 for invalid/inconsistent)
+  
+  auto addBaseControl = [&controlToBase](int code, int base) {
+    auto res = controlToBase.emplace(code, base);
+    if (res.second)
+      return base;
+    else {
+      if (base != code && base != res.first->second)
+        res.first->second = -1; // Mark as invalid; control code used in multiple situations
+      return res.first->second;
+    }
+  };
+
+  auto getBaseControl = [&controlToBase](int code) {
+    auto res = controlToBase.find(code);
+    if (res != controlToBase.end())
+      return res->second;
+    else
+      return -1;
+  };
+
+  for (int k = 0; k < course->nControls; k++) {
+    pControl ctrl = course->Controls[k];
     if (ctrl && !ctrl->isRogaining(hasRogaining)) {
-      for (int j = 0; j<ctrl->nNumbers; j++)
-        ++expectedPunchCount[ctrl->Numbers[j]];
+      if (ctrl->Status == oControl::ControlStatus::StatusMultiple) {
+        for (int j = 0; j < ctrl->nNumbers; j++)
+          ++expectedPunchCount[addBaseControl(ctrl->Numbers[j], ctrl->Numbers[j])];
+      }
+      else {
+        constexpr int LargeCode = 1000000;
+        int bc = LargeCode;
+        for (int j = 0; j < ctrl->nNumbers; j++) // Use primary control code as base
+          bc = min(bc, addBaseControl(ctrl->Numbers[j], ctrl->Numbers[0]));
+
+        if (bc > 0 && bc < LargeCode)
+          ++expectedPunchCount[bc];
+      }
     }
   }
 
   for (p_it = Card->punches.begin(); p_it != Card->punches.end(); ++p_it) {
-    if (p_it->type>=10 && p_it->type<=1024)
-      ++punchCount[p_it->type];
+    if (p_it->type >= 10 && p_it->type <= 1024) {
+      int baseCode = getBaseControl(p_it->type);
+      if (baseCode > 0)
+        ++punchCount[baseCode];
+    }
   }
 
   p_it = Card->punches.begin();
   splitTimes.resize(course->nControls, SplitData(NOTATIME, SplitData::SplitStatus::Missing));
-  int k=0;
+  int k = 0;
 
 
-  for (k=0;k<course->nControls;k++) {
+  for (k = 0; k < course->nControls; k++) {
     //Skip start finish check
-    while(p_it!=Card->punches.end() &&
-          (p_it->isCheck() || p_it->isFinish() || p_it->isStart())) {
-      p_it->setTimeAdjust(0);
+    while (p_it != Card->punches.end() &&
+      (p_it->isCheck() || p_it->isFinish() || p_it->isStart())) {
+      p_it->clearTimeAdjust();
       ++p_it;
     }
 
-    if (p_it==Card->punches.end())
+    if (p_it == Card->punches.end())
       break;
 
-    oPunchList::iterator tp_it=p_it;
-    pControl ctrl=course->Controls[k];
+    oPunchList::iterator tp_it = p_it;
+    pControl ctrl = course->Controls[k];
     int skippedPunches = 0;
 
     if (ctrl) {
-      int timeAdjust=ctrl->getTimeAdjust();
+      const int timeAdjustCtrl = ctrl->getTimeAdjust();
       ctrl->startCheckControl();
 
       // Add rogaining punches
       if (addpunch && ctrl->isRogaining(hasRogaining) && ctrl->getFirstNumber() == addpunch) {
-        if ( Card->getPunchByType(addpunch) == 0) {
+        if (Card->getPunchByType(addpunch) == 0) {
           oPunch op(oe);
-          op.type=addpunch;
-          op.punchTime=-1;
-          op.isUsed=true;
+          op.type = addpunch;
+          op.punchTime = -1;
+          op.isUsed = true;
           op.tIndex = k;
-          op.tMatchControlId=ctrl->getId();
+          op.tMatchControlId = ctrl->getId();
           Card->punches.insert(tp_it, op);
           Card->updateChanged();
         }
       }
 
       if (ctrl->getStatus() == oControl::ControlStatus::StatusBad ||
-          ctrl->getStatus() == oControl::ControlStatus::StatusOptional ||
-          ctrl->getStatus() == oControl::ControlStatus::StatusBadNoTiming) {
+        ctrl->getStatus() == oControl::ControlStatus::StatusOptional ||
+        ctrl->getStatus() == oControl::ControlStatus::StatusBadNoTiming) {
         // The control is marked "bad" but we found it anyway in the card. Mark it as used.
-        if (tp_it!=Card->punches.end() && ctrl->hasNumberUnchecked(tp_it->type)) {
-          tp_it->isUsed=true; //Show that this is used when splittimes are calculated.
+        if (tp_it != Card->punches.end() && ctrl->hasNumberUnchecked(tp_it->type)) {
+          tp_it->isUsed = true; //Show that this is used when splittimes are calculated.
                             // Adjust if the time of this control was incorrectly set.
-          tp_it->setTimeAdjust(timeAdjust);
-          tp_it->tMatchControlId=ctrl->getId();
+          tp_it->setTimeAdjust(timeAdjustCtrl);
+          tp_it->tMatchControlId = ctrl->getId();
           tp_it->tIndex = k;
           splitTimes[k].setPunchTime(tp_it->getAdjustedTime());
           ++tp_it;
-          p_it=tp_it;
+          p_it = tp_it;
         }
       }
       else {
-        while(!ctrl->controlCompleted(hasRogaining) && tp_it!=Card->punches.end()) {
+        while (!ctrl->controlCompleted(hasRogaining) && tp_it != Card->punches.end()) {
           if (ctrl->hasNumberUnchecked(tp_it->type)) {
 
-            if (skippedPunches>0) {
+            if (skippedPunches > 0) {
               if (ctrl->Status == oControl::ControlStatus::StatusOK) {
+                // Avoid consuming forward for missing controls that occurres several times
                 int code = tp_it->type;
-                if (expectedPunchCount[code]>1 && punchCount[code] < expectedPunchCount[code]) {
-                  tp_it=Card->punches.end();
+                int baseCode = getBaseControl(tp_it->type);
+                if (baseCode != -1 && expectedPunchCount[baseCode] > 1 && punchCount[baseCode] < expectedPunchCount[baseCode]) {
+                  tp_it = Card->punches.end();
                   ctrl->uncheckNumber(code);
                   break;
                 }
               }
             }
-            tp_it->isUsed=true; //Show that this is used when splittimes are calculated.
+            tp_it->isUsed = true; //Show that this is used when splittimes are calculated.
             // Adjust if the time of this control was incorrectly set.
-            tp_it->setTimeAdjust(timeAdjust);
-            tp_it->tMatchControlId=ctrl->getId();
+            tp_it->setTimeAdjust(timeAdjustCtrl);
+            tp_it->tMatchControlId = ctrl->getId();
             tp_it->tIndex = k;
             if (ctrl->controlCompleted(hasRogaining))
               splitTimes[k].setPunchTime(tp_it->getAdjustedTime());
             ++tp_it;
-            p_it=tp_it;
+            p_it = tp_it;
           }
           else {
-            if (ctrl->hasNumberUnchecked(addpunch)){
+            if (ctrl->hasNumberUnchecked(addpunch)) {
               //Add this punch.
               oPunch op(oe);
-              op.type=addpunch;
-              op.punchTime=-1;
-              op.isUsed=true;
+              op.type = addpunch;
+              op.punchTime = -1;
+              op.isUsed = true;
+              op.origin = -1;
 
-              op.tMatchControlId=ctrl->getId();
+              op.tMatchControlId = ctrl->getId();
               op.tIndex = k;
               Card->punches.insert(tp_it, op);
               Card->updateChanged();
@@ -1430,20 +1470,20 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
             }
             else {
               skippedPunches++;
-              tp_it->isUsed=false;
+              tp_it->isUsed = false;
               ++tp_it;
             }
           }
         }
       }
 
-      if (tp_it==Card->punches.end() && !ctrl->controlCompleted(hasRogaining)
-                    && ctrl->hasNumberUnchecked(addpunch) ) {
-        Card->addPunch(addpunch, -1, ctrl->getId(), 0);
+      if (tp_it == Card->punches.end() && !ctrl->controlCompleted(hasRogaining)
+        && ctrl->hasNumberUnchecked(addpunch)) {
+        Card->addPunch(addpunch, -1, ctrl->getId(), 0, oCard::PunchOrigin::Manual);
         if (ctrl->controlCompleted(hasRogaining))
           splitTimes[k].setPunched();
-        Card->punches.back().isUsed=true;
-        Card->punches.back().tMatchControlId=ctrl->getId();
+        Card->punches.back().isUsed = true;
+        Card->punches.back().tMatchControlId = ctrl->getId();
         Card->punches.back().tIndex = k;
       }
 
@@ -1459,13 +1499,13 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   }
 
   //Add missing punches for remaining controls
-  while (k<course->nControls) {
+  while (k < course->nControls) {
     if (course->Controls[k]) {
       pControl ctrl = course->Controls[k];
       ctrl->startCheckControl();
 
       if (ctrl->hasNumberUnchecked(addpunch)) {
-        Card->addPunch(addpunch, -1, ctrl->getId(), 0);
+        Card->addPunch(addpunch, -1, ctrl->getId(), 0, oCard::PunchOrigin::Manual);
         Card->updateChanged();
         if (ctrl->controlCompleted(hasRogaining))
           splitTimes[k].setNotPunched();
@@ -1476,10 +1516,10 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   }
 
   //Set the rest (if exist -- probably not) to "not used"
-  while(p_it!=Card->punches.end()){
-    p_it->isUsed=false;
+  while (p_it != Card->punches.end()) {
+    p_it->isUsed = false;
     p_it->tIndex = -1;
-    p_it->setTimeAdjust(0);
+    p_it->clearTimeAdjust();
     ++p_it;
   }
 
@@ -1492,7 +1532,7 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   // Rogaining logic
   if (rogaining.size() > 0) {
     unordered_set<int> visitedControls;
-    for (p_it=Card->punches.begin(); p_it != Card->punches.end(); ++p_it) {
+    for (p_it = Card->punches.begin(); p_it != Card->punches.end(); ++p_it) {
       pair<int, int> pt;
       if (rogaining.lookup(p_it->type, pt)) {
         p_it->anyRogainingMatchControlId = course->Controls[pt.first]->getId();
@@ -1520,15 +1560,15 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
     tRogainingPoints = max(0, tRogainingPoints + getPointAdjustment());
 
     int point_limit = course->getMinimumRogainingPoints();
-    if (point_limit>0 && tRogainingPoints<point_limit) {
-      tProblemDescription = L"X poäng fattas.#" + itow(point_limit-tRogainingPoints);
+    if (point_limit > 0 && tRogainingPoints < point_limit) {
+      tProblemDescription = L"X poäng fattas.#" + itow(point_limit - tRogainingPoints);
       OK = false;
     }
 
     // Check this later
     time_limit = course->getMaximumRogainingTime();
 
-    for (int k = 0; k<course->nControls; k++) {
+    for (int k = 0; k < course->nControls; k++) {
       if (course->Controls[k] && course->Controls[k]->isRogaining(hasRogaining)) {
         if (!visitedControls.count(k))
           splitTimes[k].setNotPunched();// = splitTimes[k-1];
@@ -1537,9 +1577,9 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   }
 
   int maxTimeStatus = 0;
-  if (clz && FinishTime>0) {
+  if (clz && FinishTime > 0) {
     int mt = clz->getMaximumRunnerTime();
-    if (mt>0) {
+    if (mt > 0) {
       if (getRunningTime(false) > mt)
         maxTimeStatus = 1;
       else
@@ -1549,11 +1589,11 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
       maxTimeStatus = 2;
   }
 
-  if ( (*refStatus == StatusMAX && maxTimeStatus == 2) || 
-      *refStatus == StatusOutOfCompetition ||
-      *refStatus == StatusNoTiming)
+  if ((*refStatus == StatusMAX && maxTimeStatus == 2) ||
+    *refStatus == StatusOutOfCompetition ||
+    *refStatus == StatusNoTiming)
     *refStatus = StatusUnknown;
-  
+
   if (OK && (*refStatus == 0 || *refStatus == StatusDNS || *refStatus == StatusCANCEL || *refStatus == StatusMP || *refStatus == StatusOK || *refStatus == StatusDNF))
     *refStatus = StatusOK;
   else	*refStatus = RunnerStatus(max(int(StatusMP), int(*refStatus)));
@@ -1571,12 +1611,12 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   if (backIter != Card->punches.rend() && backIter->type == finishPunchCode) {
     FinishTime = backIter->getTimeInt();
     if (finishPunchCode == oPunch::PunchFinish)
-      backIter->tMatchControlId=oPunch::PunchFinish;
+      backIter->tMatchControlId = oPunch::PunchFinish;
   }
-  else if (FinishTime<=0) {
-    *refStatus=RunnerStatus(max(int(StatusDNF), int(tStatus)));
+  else if (FinishTime <= 0) {
+    *refStatus = RunnerStatus(max(int(StatusDNF), int(tStatus)));
     tProblemDescription = L"Måltid saknas.";
-    FinishTime=0;
+    FinishTime = 0;
   }
 
   if (*refStatus == StatusOK && maxTimeStatus == 1)
@@ -1606,8 +1646,8 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
   doAdjustTimes(course);
 
   tRogainingPointsGross = tRogainingPoints;
-  
-  if (oldStatus!=*refStatus || oldFT!=FinishTime) {
+
+  if (oldStatus != *refStatus || oldFT != FinishTime) {
     clearSplitAnalysis = true;
   }
 
@@ -1637,7 +1677,7 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
 
   // Clear split analysis data if necessary
   bool clear = splitTimes.size() != oldTimes.size() || clearSplitAnalysis;
-  for (size_t k = 0; !clear && k<oldTimes.size(); k++) {
+  for (size_t k = 0; !clear && k < oldTimes.size(); k++) {
     if (splitTimes[k].time != oldTimes[k].time)
       clear = true;
   }
@@ -1655,19 +1695,19 @@ bool oRunner::evaluateCard(bool doApply, vector<int> &missingPunches,
     if (tInTeam) {
       int t1 = clz->getTotalLegLeaderTime(oClass::AllowRecompute::No, tLeg, false, false);
       int t2 = tInTeam->getLegRunningTime(tLeg, false, false);
-      if (t2<=t1 && t2>0)
+      if (t2 <= t1 && t2 > 0)
         update = true;
 
       int t3 = clz->getTotalLegLeaderTime(oClass::AllowRecompute::No, tLeg, false, true);
       int t4 = tInTeam->getLegRunningTime(tLeg, false, true);
-      if (t4<=t3 && t4>0)
+      if (t4 <= t3 && t4 > 0)
         update = true;
     }
 
     if (!update) {
       int t1 = clz->getBestLegTime(oClass::AllowRecompute::No, tLeg, false);
       int t2 = getRunningTime(false);
-      if (t2<=t1 && t2>0)
+      if (t2 <= t1 && t2 > 0)
         update = true;
     }
     if (update) {
@@ -1703,7 +1743,7 @@ void oRunner::doAdjustTimes(pCourse course) {
     pControl ctrlPrev = n > 0 ? course->Controls[n - 1] : nullptr;
 
     while (it != Card->punches.end() && !it->isUsed) {
-      it->setTimeAdjust(adjustment);
+      it->adjustTimeAdjust(adjustment);
       ++it;
     }
 
@@ -1748,7 +1788,7 @@ void oRunner::doAdjustTimes(pCourse course) {
 
   // Adjust remaining
   while (it != Card->punches.end()) {
-    it->setTimeAdjust(adjustment);
+    it->adjustTimeAdjust(adjustment);
     ++it;
   }
 
@@ -2027,19 +2067,9 @@ bool oRunner::operator<(const oRunner &c) const {
     pClub cl = getClubRef();
     pClub ocl = c.getClubRef();
     if (cl != ocl) {
-      if (cl == nullptr && ocl)
-        return true;
-      else if (ocl == nullptr)
-        return false;
-      
-      const wstring a = cl->getName();
-      const wstring b = ocl->getName();
-      int res = CompareString(LOCALE_USER_DEFAULT, 0,
-          a.c_str(), a.length(),
-          b.c_str(), b.length());
-
-      if (res != CSTR_EQUAL)
-        return res == CSTR_LESS_THAN;
+      int cres = compareClubs(cl, ocl);
+      if (cres != 2)
+        return cres != 0;
     }
   }
 
@@ -2401,7 +2431,9 @@ bool oRunner::operator<(const oRunner &c) const {
       else return tStartTime < c.tStartTime;
     }
     else if (Club != c.Club) {
-      return getClub() < c.getClub();
+      int cres = compareClubs(Club, c.Club);
+      if (cres != 2)
+        return cres != 0;
     }
   }
   else if (oe->CurrentSortOrder == ClassTeamLeg) {
@@ -2712,16 +2744,87 @@ void oRunner::setCardNo(int cno, bool matchCard, bool updateFromDatabase)
   }
 }
 
-bool oRunner::isHiredCard() const {
+int oRunner::getRentalCardFee(bool forAllRunners) const {
+  const oRunner* parent = this;
+  if (tParentRunner)
+    parent = tParentRunner;
+  
+  if (forAllRunners) {
+    // Count total card fee (case: several different rented cards or own card and then rented card)
+    int fee = parent->getRentalCardFee(false);
+    if (parent->multiRunner.size() > 0) {
+      set<int> cards;
+      for (int i = 0; i < parent->multiRunner.size(); i++) {
+        pRunner r = parent->multiRunner[i];
+        if (parent->cardNumber != r->cardNumber && r->getDCI().getInt("CardFee") > 0) {
+          if (cards.insert(r->cardNumber).second)
+            fee += r->getRentalCardFee(false);
+        }
+      }
+    }
+    return fee;
+  }
+
+  // Return the rental card fee.
+  // The fee is only returned for the "first" runner
+  // in a multi runner having the curren't runners card
+  // to avoid duplicate fees
+  if (!isRentalCard())
+    return 0;
+  
+  bool okFirst = false;
+  int fee = 0;
+  if (parent->getCardNo() == getCardNo()) {
+    if (parent != this)
+      return 0;
+    fee = max<int>(fee, parent->getDCI().getInt("CardFee"));
+    okFirst = true;
+  }
+
+  for (pRunner r : parent->multiRunner) {
+    if (r && r->getCardNo() == getCardNo()) {
+      if (parent != this && !okFirst)
+        return 0; // Was not first runner with this card
+
+      fee = max<int>(fee, r->getDCI().getInt("CardFee"));
+      okFirst = true;
+    }
+  }
+
+  return fee;
+}
+
+/** Set rental card status (does not update fee)*/
+void oRunner::setRentalCard(bool rental) {
+  const bool rentalState = isRentalCard();
+  if (rental && !rentalState) {
+    getDI().setInt("CardFee", oe->getBaseCardFee());
+  }
+  else if (!rental && rentalState) {
+    // Reset card fee
+    oRunner* parent = this;
+    if (tParentRunner)
+      parent = tParentRunner;
+    if (parent->getCardNo() == getCardNo())
+      parent->getDI().setInt("CardFee", 0);
+    for (pRunner r : parent->multiRunner) {
+      if (r && r->getCardNo() == getCardNo()) {
+        r->getDI().setInt("CardFee", 0);
+      }
+    }
+  }
+}
+
+bool oRunner::isRentalCard() const {
   if (getDCI().getInt("CardFee") != 0)
     return true;
   if (tParentRunner && tParentRunner != this)
-    return tParentRunner->isHiredCard(getCardNo());
-
-  return isHiredCard(cardNumber);
+    return tParentRunner->isRentalCard(getCardNo());
+  else
+    return isRentalCard(cardNumber);
 }
 
-bool oRunner::isHiredCard(int cno) const {
+bool oRunner::isRentalCard(int cno) const {
   if (cno == getCardNo())
     return getDCI().getInt("CardFee") != 0;
 
@@ -3012,7 +3115,7 @@ void oEvent::getRunners(int classId, int courseId, vector<pRunner> &r, bool sort
     if (courseId > 0) {
       pCourse pc = it->getCourse(false);
       if (pc == 0 || pc->getId() != courseId)
-        skip = true;
+        skip = true; // May still be used to setup hash
     }
     int clsId = 0;
     if (!skip && classId <= 0 || (clsId = it->getClassId(true)) == classId)
@@ -3099,9 +3202,15 @@ pRunner oEvent::getRunner(int Id, int stage) const
 
 pRunner oRunner::nextNeedReadout() const {
   if (tInTeam) {
+    bool isQF = Class && Class->isQualificationFinalBaseClass();
+
     // For a runner in a team, first the team for the card
     for (size_t k = 0; k < tInTeam->Runners.size(); k++) {
       pRunner tr = tInTeam->Runners[k];
+      if (tr && k > 0 && isQF) {
+        if (tr->getDCI().getInt("Heat") == 0)
+         continue; // Not qualified. Maybe directly qualified for higher final.
+      }
       if (tr && tr->getCardNo() == getCardNo() && !tr->Card && !tr->statusOK(false, false))
         return tr;
     }
@@ -3457,7 +3566,7 @@ void oEvent::fillRunners(gdioutput &gdi, const string &id, bool longName, int fi
 {
   vector< pair<wstring, size_t> > d;
   oe->fillRunners(d, longName, filter, unordered_set<int>());
-  gdi.addItem(id, d);
+  gdi.setItems(id, d);
 }
 
 const vector< pair<wstring, size_t> > &oEvent::fillRunners(vector< pair<wstring, size_t> > &out,
@@ -4173,11 +4282,11 @@ int oRunner::getSplitTime(int controlNumber, bool normalized) const
 {
   if (!Card) {
     if (controlNumber == 0)
-      return getPunchTime(0, false, true);
+      return getPunchTime(0, false, true, false);
     else {
-      int ct = getPunchTime(controlNumber, false, true);
+      int ct = getPunchTime(controlNumber, false, true, false);
       if (ct > 0) {
-        int dt = getPunchTime(controlNumber - 1, false, true);
+        int dt = getPunchTime(controlNumber - 1, false, true, false);
         if (dt > 0 && ct > dt)
           return ct - dt;
       }
@@ -4219,7 +4328,7 @@ int oRunner::getNamedSplit(int controlNumber) const {
     return -1;
 
   int k=controlNumber-1;
-  int ct = getPunchTime(controlNumber, false, true);
+  int ct = getPunchTime(controlNumber, false, true, false);
   if (ct <= 0)
     return -1;
  
@@ -4228,7 +4337,7 @@ int oRunner::getNamedSplit(int controlNumber) const {
     pControl c = crs->Controls[k];
 
     if (c && c->hasName()) {
-      int dt = getPunchTime(k, false, true);
+      int dt = getPunchTime(k, false, true, false);
       if (dt > 0 && ct > dt)
         return max(ct - dt, -1);
       else return -1;
@@ -4240,52 +4349,53 @@ int oRunner::getNamedSplit(int controlNumber) const {
   return ct;
 }
 
-wstring oRunner::getSplitTimeS(int controlNumber, bool normalized) const
+const wstring &oRunner::getSplitTimeS(int controlNumber, bool normalized, SubSecond mode) const
 {
-  return formatTime(getSplitTime(controlNumber, normalized));
+  return formatTime(getSplitTime(controlNumber, normalized), mode);
 }
 
-wstring oRunner::getNamedSplitS(int controlNumber) const
+const wstring &oRunner::getNamedSplitS(int controlNumber, SubSecond mode) const
 {
-  return formatTime(getNamedSplit(controlNumber));
+  return formatTime(getNamedSplit(controlNumber), mode);
 }
 
-int oRunner::getPunchTime(int controlNumber, bool normalized, bool adjusted) const
+int oRunner::getPunchTime(int controlIndex, bool normalized, bool adjusted, bool teamTotal) const
 {
+  int off = teamTotal && tInTeam ? tInTeam->getTotalRunningTimeAtLegStart(getLegNumber(), false) : 0;
+
   if (!Card) {
     pCourse pc = getCourse(false);
-    if (!pc || controlNumber > pc->getNumControls())
+    if (!pc || controlIndex > pc->getNumControls())
       return -1;
 
-    if (controlNumber == pc->getNumControls())
-      return getFinishTime() - tStartTime;
+    if (controlIndex == pc->getNumControls())
+      return getFinishTime() - tStartTime + off;
 
-    int ccId = pc->getCourseControlId(controlNumber);
+    int ccId = pc->getCourseControlId(controlIndex);
     pFreePunch fp = oe->getPunch(Id, ccId, getCardNo());
     if (fp)
-      return fp->getTimeInt() - tStartTime;
+      return fp->getTimeInt() - tStartTime + off;
     return -1;
   }
   const vector<SplitData> &st = getSplitTimes(normalized);
 
-  if (unsigned(controlNumber) < st.size()) {
-    if (st[controlNumber].hasTime())
-      return st[controlNumber].getTime(adjusted) - tStartTime;
+  if (unsigned(controlIndex) < st.size()) {
+    if (st[controlIndex].hasTime())
+      return st[controlIndex].getTime(adjusted) - tStartTime + off;
     else return -1;
   }
-  else if (unsigned(controlNumber) == st.size())
-    return FinishTime - tStartTime;
+  else if (unsigned(controlIndex) == st.size())
+    return FinishTime - tStartTime + off;
 
   return -1;
 }
 
-wstring oRunner::getPunchTimeS(int controlNumber, bool normalized, bool adjusted, SubSecond mode) const
-{
-  return formatTime(getPunchTime(controlNumber, normalized, adjusted), mode);
+const wstring &oRunner::getPunchTimeS(int controlIndex, bool normalized, bool adjusted,
+                                      bool teamTotal, SubSecond mode) const {
+  return formatTime(getPunchTime(controlIndex, normalized, adjusted, teamTotal), mode);
 }
 
-bool oAbstractRunner::isVacant() const
-{
+bool oAbstractRunner::isVacant() const {
   int vacClub = oe->getVacantClubIfExist(false);
   return vacClub > 0 && getClubId()==vacClub;
 }
@@ -4409,7 +4519,8 @@ void oRunner::fillSpeakerObject(int leg, int courseControlId, int previousContro
   }
 }
 
-pRunner oEvent::findRunner(const wstring &s, int lastId, const unordered_set<int> &inputFilter,
+pRunner oEvent::findRunner(const wstring &s, int lastId, 
+                           const unordered_set<int> &inputFilter,
                            unordered_set<int> &matchFilter) const
 {
   matchFilter.clear();
@@ -4417,8 +4528,8 @@ pRunner oEvent::findRunner(const wstring &s, int lastId, const unordered_set<int
   int len = trm.length();
   int sn = _wtoi(trm.c_str());
   wchar_t s_lc[1024];
-  wcscpy_s(s_lc, s.c_str());
-  CharLowerBuff(s_lc, len);
+  wcscpy_s(s_lc, s.c_str());  
+  prepareMatchString(s_lc, len);
   int score;
   pRunner res = 0;
 
@@ -4929,7 +5040,7 @@ void oRunner::printSplits(gdioutput& gdi, const oListInfo* li) const {
   if (pc) {
     for (int n = 0; n < pc->nControls; n++) {
       spMax = max(spMax, getSplitTime(n, false));
-      totMax = max(totMax, getPunchTime(n, false, false));
+      totMax = max(totMax, getPunchTime(n, false, false, false));
     }
   }
   bool moreThanHour = max(totMax, getRunningTime(true)) >= timeConstHour;
@@ -5082,7 +5193,7 @@ void oRunner::printSplits(gdioutput& gdi, const oListInfo* li) const {
             adjust = getTimeAdjust(controlLegIndex);
             sp = getSplitTime(controlLegIndex, false);
             if (sp > 0) {
-              punchTime = getPunchTimeS(controlLegIndex, false, false, SubSecond::Off);
+              punchTime = getPunchTimeS(controlLegIndex, false, false, false, SubSecond::Off);
               gdi.addStringUT(cy, cx + c2, fontSmall | textRight, formatTime(sp, SubSecond::Off));
             }
           }
@@ -5094,7 +5205,7 @@ void oRunner::printSplits(gdioutput& gdi, const oListInfo* li) const {
             gdi.addStringUT(cy, cx + c1, fontSmall, bf);
           }
           if (it->punchTime > 0)
-            gdi.addStringUT(cy, cx + c3, fontSmall, oe->getAbsTime(it->getTimeInt() + adjust, SubSecond::Off));
+            gdi.addStringUT(cy, cx + c3, fontSmall, oe->getAbsTime(it->getAdjustedTime() + adjust, SubSecond::Off));
           else {
             wstring str = makeDash(L"-");
             gdi.addStringUT(cy, cx + c3, fontSmall, str);
@@ -5315,7 +5426,7 @@ void oRunner::printSplits(gdioutput& gdi, const oListInfo* li) const {
   gdi.addString("", fontSmall, "Av MeOS: www.melin.nu/meos");
 }
 
-void oRunner::printStartInfo(gdioutput &gdi) const {
+void oRunner::printStartInfo(gdioutput &gdi, bool includeEconomy) const {
   gdi.setCX(10);
   gdi.fillDown();
   gdi.addString("", boldText, L"Startbevis X#" + oe->getName());
@@ -5341,37 +5452,41 @@ void oRunner::printStartInfo(gdioutput &gdi) const {
   else
     gdi.addStringUT(fontSmall, lang.tl(L"Fri starttid") + startName);
 
-  wstring borrowed = getDCI().getInt("CardFee") != 0 ? L" (" + lang.tl(L"Hyrd") + L")" : L"";
+  wstring borrowed = isRentalCard() ? L" (" + lang.tl(L"Hyrd") + L")" : L"";
       
   gdi.addStringUT(fontSmall, lang.tl(L"Bricka: ") + itow(getCardNo()) +  borrowed);
   
-  int cardFee = getDCI().getInt("CardFee");
+  int cardFee = getRentalCardFee(true);
   if (cardFee < 0)
     cardFee = 0;
 
-  int fee = oe->getMeOSFeatures().hasFeature(MeOSFeatures::Economy) ? getDCI().getInt("Fee") + cardFee : 0;
+  if (includeEconomy) {
+    int fee = oe->getMeOSFeatures().hasFeature(MeOSFeatures::Economy) ? getDCI().getInt("Fee") + cardFee : 0;
 
-  if (fee > 0) {
-    wstring info;
-    if (getDCI().getInt("Paid") == fee)
-      info = lang.tl("Betalat");
-    else
-      info = lang.tl("Faktureras");
-    
-    gdi.addStringUT(fontSmall, lang.tl("Anmälningsavgift: ") + itow(fee)  + L" (" + info + L")");
+    if (fee > 0) {
+      wstring info;
+      if (getDCI().getInt("Paid") == fee)
+        info = lang.tl("Betalat");
+      else
+        info = lang.tl("Faktureras");
+
+      gdi.addStringUT(fontSmall, lang.tl("Anmälningsavgift: ") + itow(fee) + L" (" + info + L")");
+    }
   }
 
-  gdi.dropLine(1);
   vector< pair<wstring, int> > lines;
   oe->getExtraLines("EntryExtra", lines);
 
+  if (!lines.empty())
+    gdi.dropLine(0.5);
+
   for (size_t k = 0; k < lines.size(); k++) {
     gdi.addStringUT(lines[k].second, formatExtraLine(pRunner(this), lines[k].first));
   }
-  if (lines.size()>0)
-    gdi.dropLine(0.5);
+//  if (lines.size()>0)
+//    gdi.dropLine(0.5);
 
-  gdi.addStringUT(fontSmall, L"Av MeOS " + getMeosCompectVersion() + L" / www.melin.nu/meos");
+//  gdi.addStringUT(fontSmall, L"Av MeOS " + getMeosCompectVersion() + L" / www.melin.nu/meos");
 }
 
 vector<pRunner> oRunner::getRunnersOrdered() const {
@@ -5616,7 +5731,7 @@ oRunner::BibAssignResult oRunner::autoAssignBib() {
   return BibAssignResult::NoBib;
 }
 
-void oRunner::getSplitAnalysis(vector<int> &deltaTimes) const {
+void oRunner::getSplitAnalysis(vector<int>& deltaTimes) const {
   deltaTimes.clear();
   vector<int> mp;
 
@@ -5636,7 +5751,7 @@ void oRunner::getSplitAnalysis(vector<int> &deltaTimes) const {
   if (pc->isAdapted())
     reorder = pc->getMapToOriginalOrder();
   else {
-    reorder.reserve(pc->nControls+1);
+    reorder.reserve(pc->nControls + 1);
     for (int k = 0; k <= pc->nControls; k++)
       reorder.push_back(k);
   }
@@ -5645,13 +5760,13 @@ void oRunner::getSplitAnalysis(vector<int> &deltaTimes) const {
   if (cls->tSplitAnalysisData.count(id) == 0)
     cls->calculateSplits();
 
-  const vector<int> &baseLine = cls->tSplitAnalysisData[id];
+  const vector<int>& baseLine = cls->tSplitAnalysisData[id];
   const unsigned nc = pc->getNumControls();
 
-  if (baseLine.size() != nc+1)
+  if (baseLine.size() != nc + 1)
     return;
 
-  vector<double> res(nc+1);
+  vector<double> res(nc + 1);
 
   double resSum = 0;
   double baseSum = 0;
@@ -5665,31 +5780,32 @@ void oRunner::getSplitAnalysis(vector<int> &deltaTimes) const {
     bestTime += baseLine[reorder[k]];
   }
 
-  deltaTimes.resize(nc+1);
+  deltaTimes.resize(nc + 1);
 
   // Adjust expected time by removing mistakes
   for (size_t k = 0; k <= nc; k++) {
-    if (res[k]  > 0) {
-      double part = res[k]*baseSum/(resSum * bestTime);
+    if (res[k] > 0) {
+      double part = res[k] * baseSum / (resSum * bestTime);
       double delta = part - baseLine[reorder[k]] / bestTime;
       int deltaAbs = int(floor(delta * resSum + 0.5));
-      if (res[k]-deltaAbs < baseLine[reorder[k]])
+      if (res[k] - deltaAbs < baseLine[reorder[k]])
         deltaAbs = int(res[k] - baseLine[reorder[k]]);
 
-      if (deltaAbs>0)
+      if (deltaAbs > 0)
         resSum -= deltaAbs;
     }
   }
+  vector<double> resOrig = res;
 
   for (size_t k = 0; k <= nc; k++) {
-    if (res[k]  > 0) {
-      double part = res[k]*baseSum/(resSum * bestTime);
+    if (res[k] > 0) {
+      double part = res[k] * baseSum / (resSum * bestTime);
       double delta = part - baseLine[reorder[k]] / bestTime;
 
       int deltaAbs = int(floor(delta * resSum + 0.5));
 
       if (deltaAbs > 0) {
-        if ( fabs(delta) > 1.0/100 && (20.0*deltaAbs)>res[k] && deltaAbs>=15)
+        if (fabs(delta) > 0.01 && deltaAbs > res[k]*0.1 && deltaAbs >= (20 * timeConstSecond))
           deltaTimes[k] = deltaAbs;
 
         res[k] -= deltaAbs;
@@ -5707,13 +5823,14 @@ void oRunner::getSplitAnalysis(vector<int> &deltaTimes) const {
   }
 
   for (size_t k = 0; k <= nc; k++) {
-    if (res[k]  > 0) {
-      double part = res[k]*baseSum/(resSum * bestTime);
+    if (res[k] > 0) {
+      double part = resOrig[k] * baseSum / (resSum * bestTime);
       double delta = part - baseLine[reorder[k]] / bestTime;
       int deltaAbs = int(floor(delta * resSum + 0.5));
 
-      if (deltaTimes[k]==0 && fabs(delta) > 1.0/100 && deltaAbs>=8)
-        deltaTimes[k] = deltaAbs;
+      //if (fabs(delta) > 1.0 / 100 && deltaAbs >= timeConstSecond * 20)
+      if (fabs(delta) > 0.01 && deltaAbs > resOrig[k] * 0.1 && deltaAbs >= (20 * timeConstSecond))
+        deltaTimes[k] = max(deltaAbs, deltaTimes[k]);
     }
   }
 }
@@ -5807,7 +5924,7 @@ void oRunner::getLegTimeAfter(vector<int> &times) const
   }
 }
 
-void oRunner::getLegTimeAfterAcc(vector<int> &times) const
+void oRunner::getLegTimeAfterAcc(vector<ResultData> &times) const
 {
   times.clear();
   if (splitTimes.empty() || !Class || tStartTime<=0)
@@ -5835,6 +5952,9 @@ void oRunner::getLegTimeAfterAcc(vector<int> &times) const
   //xxx reorder output
   times.resize(nc+1);
 
+  bool isRelayTeam = tInTeam != nullptr;
+  int off = tInTeam ? tInTeam->getTotalRunningTimeAtLegStart(tLeg, false) : 0;
+
   for (unsigned k = 0; k<=nc; k++) {
     int s = 0;
     if (k < sp.size())
@@ -5843,18 +5963,27 @@ void oRunner::getLegTimeAfterAcc(vector<int> &times) const
       s = FinishTime;
 
     if (s>0) {
-      times[k] = s - tStartTime - leaders[k];
-      if (times[k]<0)
-        times[k] = -1;
+      times[k].data = s - tStartTime - leaders[k];
+      if (times[k].data < 0)
+        times[k].data = -1;
     }
     else
-      times[k] = -1;
+      times[k].data = -1;
+
+    if (!isRelayTeam || times[k].data < 0)
+      times[k].teamTotalData = times[k].data;
+    else {
+      if (k < nc)
+        times[k].teamTotalData = s - tStartTime + off - cls->getAccLegControlLeader(tLeg, pc->getCourseControlId(k));
+      else
+        times[k].teamTotalData = s - tStartTime + off - cls->getAccLegControlLeader(tLeg, oPunch::PunchFinish);
+    }
   }
 
    // Normalized order
   const vector<int> &reorder = getCourse(true)->getMapToOriginalOrder();
   if (!reorder.empty()) {
-    vector<int> orderedTimes(times.size());
+    vector<ResultData> orderedTimes(times.size());
     for (size_t k = 0; k < min(reorder.size(), times.size()); k++) {
       orderedTimes[k] = times[reorder[k]];
     }
@@ -5862,7 +5991,7 @@ void oRunner::getLegTimeAfterAcc(vector<int> &times) const
   }
 }
 
-void oRunner::getLegPlacesAcc(vector<int> &places) const
+void oRunner::getLegPlacesAcc(vector<ResultData> &places) const
 {
   places.clear();
   pCourse pc = getCourse(false);
@@ -5880,6 +6009,10 @@ void oRunner::getLegPlacesAcc(vector<int> &places) const
   const unsigned nc = pc->getNumControls();
   const vector<SplitData> &sp = getSplitTimes(true);
   places.resize(nc+1);
+
+  bool isRelayTeam = tInTeam != nullptr;
+  int off = tInTeam ? tInTeam->getTotalRunningTimeAtLegStart(tLeg, false) : 0;
+
   for (unsigned k = 0; k<=nc; k++) {
     int s = 0;
     if (k < sp.size())
@@ -5890,17 +6023,24 @@ void oRunner::getLegPlacesAcc(vector<int> &places) const
     if (s>0) {
       int time = s - tStartTime;
 
-      if (time>0)
-        places[k] = cls->getAccLegPlace(id, k, time);
-      else
-        places[k] = 0;
+      if (time > 0) {
+        places[k].data = cls->getAccLegPlace(id, k, time);
+        if (k < nc)
+          places[k].teamTotalData = cls->getAccLegControlPlace(tLeg, pc->getCourseControlId(k), time + off);
+        else
+          places[k].teamTotalData = cls->getAccLegControlPlace(tLeg, oPunch::PunchFinish, time + off);
+      }
+      else {
+        places[k].data = 0;
+        places[k].teamTotalData = 0;
+      }
     }
   }
 
   // Normalized order
   const vector<int> &reorder = getCourse(true)->getMapToOriginalOrder();
   if (!reorder.empty()) {
-    vector<int> orderedPlaces(reorder.size());
+    vector<ResultData> orderedPlaces(reorder.size());
     for (size_t k = 0; k < reorder.size(); k++) {
       orderedPlaces[k] = places[reorder[k]];
     }
@@ -5974,31 +6114,31 @@ int oRunner::getLegTimeAfter(int ctrlNo) const {
     return -1;
 }
 
-int oRunner::getLegPlaceAcc(int ctrlNo) const {
+int oRunner::getLegPlaceAcc(int ctrlNo, bool teamTotal) const {
   for (auto &res : tOnCourseResults.res) {
     if (res.controlIx == ctrlNo)
-      return res.place;
+      return teamTotal ? res.teamTotalPlace : res.place;
   }
   if (!Card) {
     return 0;
   }
   setupRunnerStatistics();
   if (unsigned(ctrlNo) < tPlaceLegAcc.size())
-    return tPlaceLegAcc[ctrlNo];
+    return tPlaceLegAcc[ctrlNo].get(teamTotal);
   else
     return 0;
 }
 
-int oRunner::getLegTimeAfterAcc(int ctrlNo) const {
+int oRunner::getLegTimeAfterAcc(int ctrlNo, bool teamTotal) const {
   for (auto &res : tOnCourseResults.res) {
     if (res.controlIx == ctrlNo)
-      return res.after;
+      return teamTotal ? res.teamTotalAfter : res.after;
   }
   if (!Card) 
     return -1;
   setupRunnerStatistics();
   if (unsigned(ctrlNo) < tAfterLegAcc.size())
-    return tAfterLegAcc[ctrlNo];
+    return tAfterLegAcc[ctrlNo].get(teamTotal);
   else
     return -1;
 }
@@ -6344,13 +6484,13 @@ void oEvent::selectRunners(const wstring &classType, int lowAge,
 
   int firstD = 0, lastD = 0;
   if (!firstDate.empty()) {
-    firstD = convertDateYMS(firstDate, true);
+    firstD = convertDateYMD(firstDate, true);
     if (firstD <= 0)
       throw meosException(L"Felaktigt datumformat 'X' (Använd ÅÅÅÅ-MM-DD).#" + firstDate);
   }
 
   if (!lastDate.empty()) {
-    lastD = convertDateYMS(lastDate, true);
+    lastD = convertDateYMD(lastDate, true);
     if (lastD <= 0)
       throw meosException(L"Felaktigt datumformat 'X' (Använd ÅÅÅÅ-MM-DD).#" + lastDate);
   }
@@ -7232,3 +7372,30 @@ void oRunner::getNameFormats(vector<pair<wstring, size_t>> &  out) {
   add(NameFormat::Init, "F.E.");
   add(NameFormat::InitLast, "F. Efternamn");
 }
+
+void oRunner::setExtIdentifier2(int64_t id) {
+  getDI().setInt64("ExtId2", id);
+}
+
+int64_t oRunner::getExtIdentifier2() const {
+  return getDCI().getInt64("ExtId2");
+}
+
+wstring oRunner::getExtIdentifierString2() const {
+  int64_t raw = getExtIdentifier2();
+  wchar_t res[16];
+  if (raw == 0)
+    return L"";
+  if (raw & BaseGenStringFlag)
+    convertDynamicBase(raw & ExtStringMask, 256 - 32, res);
+  else if (raw & Base36StringFlag)
+    convertDynamicBase(raw & ExtStringMask, 36, res);
+  else
+    convertDynamicBase(raw, 10, res);
+  return res;
+}
+
+void oRunner::setExtIdentifier2(const wstring& str) {
+  int64_t val = converExtIdentifierString(str);
+  setExtIdentifier2(val);
+}
diff --git a/code/oRunner.h b/code/oRunner.h
index ec81a6f..f5c5359 100644
--- a/code/oRunner.h
+++ b/code/oRunner.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -87,6 +87,25 @@ enum SortOrder {
   SortEnumLastItem
 };
 
+static bool orderByClass(SortOrder so) {
+  switch (so) {
+  case ClassStartTime:
+  case ClassTeamLeg:
+  case ClassResult:
+  case ClassDefaultResult:
+  case ClassCourseResult:
+  case ClassTotalResult:
+  case ClassTeamLegResult:
+  case ClassFinishTime:
+  case ClassStartTimeClub:
+  case ClassPoints:
+  case ClassLiveResult:
+  case ClassKnockoutTotalResult:
+    return true;
+  }
+  return false;
+}
+
 class oRunner;
 typedef oRunner* pRunner;
 typedef const oRunner* cRunner;
@@ -178,6 +197,9 @@ public:
 protected:
   TempResult tmpResult;
 
+  /** Return 1 if a<b, 0 if b<a, otherwise 2.*/
+  static int compareClubs(const oClub* a, const oClub* b);
+
   mutable int tTimeAdjustment;
   mutable int tPointAdjustment;
   mutable int tAdjustDataRevision;
@@ -474,6 +496,8 @@ public:
   void setTimeAdjustment(int adjust);
   void setPointAdjustment(int adjust);
 
+  virtual bool isTeam() const { return false; }
+
   oAbstractRunner(oEvent *poe, bool loading);
   virtual ~oAbstractRunner() {};
 
@@ -551,6 +575,23 @@ public:
 };
 
 class oRunner final: public oAbstractRunner {
+public:
+  struct ResultData {
+  private:
+    int data = 0;
+    int teamTotalData = 0;
+
+  public:
+    ResultData(int data, int teamTotalData) : data(data), teamTotalData(teamTotalData) { }
+    ResultData() = default;
+
+    int get(bool total) const {
+      return total ? teamTotalData : data;
+    }
+
+    friend class oRunner;
+  };
+
 protected:
   pCourse Course;
 
@@ -588,8 +629,8 @@ protected:
   map<int, int> priority;
   int cPriority;
 
-  static const int dataSize = 256;
-  int getDISize() const {return dataSize;}
+  static constexpr int dataSize = 256+64;
+  int getDISize() const final {return dataSize;}
 
   BYTE oData[dataSize];
   BYTE oDataOld[dataSize];
@@ -633,24 +674,32 @@ protected:
 
   void clearOnChangedRunningTime();
 
+  
   // Cached runner statistics
   mutable vector<int> tMissedTime;
   mutable vector<int> tPlaceLeg;
   mutable vector<int> tAfterLeg;
-  mutable vector<int> tPlaceLegAcc;
-  mutable vector<int> tAfterLegAcc;
+  mutable vector<ResultData> tPlaceLegAcc;
+  mutable vector<ResultData> tAfterLegAcc;
     
   // Used to calculate temporary split time results
   struct OnCourseResult {
     OnCourseResult(int courseControlId,
                    int controlIx,
-                   int time) : courseControlId(courseControlId), 
-                               controlIx(controlIx), time(time) {}
+                   int time,
+                   int teamTotalTime) : courseControlId(courseControlId), 
+                                        controlIx(controlIx), time(time),
+                                        teamTotalTime(teamTotalTime) {}
     int courseControlId;
     int controlIx;
     int time;
-    int place;
-    int after;
+    int teamTotalTime;
+
+    int place = -1;
+    int after = -1;
+
+    int teamTotalPlace = -1;
+    int teamTotalAfter = -1;
   };
   mutable pair<int, int> currentControlTime;
 
@@ -660,8 +709,9 @@ protected:
     void clear() { hasAnyRes = false; res.clear(); }
     void emplace_back(int courseControlId,
                       int controlIx,
-                      int time) {
-      res.emplace_back(courseControlId, controlIx, time);
+                      int time,
+                      int teamTotalTime) {
+      res.emplace_back(courseControlId, controlIx, time, teamTotalTime);
       hasAnyRes = true;
     }
     bool empty() const { return hasAnyRes == false; }
@@ -708,13 +758,24 @@ protected:
   /** Internal propagate club.*/
   void propagateClub();
 
-  bool isHiredCard(int card) const;
+  bool isRentalCard(int card) const;
 
   int tmpStartGroup = 0;
 
   int getBuiltinAdjustment() const override;
 
 public:
+  /// Second external ID (local and WRE etc)
+  
+  /// Set a second external identifier (0 if none)
+  void setExtIdentifier2(int64_t id);
+
+  /// Get the second external identifier (or 0) if none
+  int64_t getExtIdentifier2() const;
+
+  wstring getExtIdentifierString2() const;
+  void setExtIdentifier2(const wstring& str);
+
   bool matchAbstractRunner(const oAbstractRunner* target) const override;
 
   static const shared_ptr<Table> &getTable(oEvent *oe);
@@ -867,8 +928,8 @@ public:
   int getMissedTime(int ctrlNo) const;
   int getLegPlace(int ctrlNo) const;
   int getLegTimeAfter(int ctrlNo) const;
-  int getLegPlaceAcc(int ctrlNo) const;
-  int getLegTimeAfterAcc(int ctrlNo) const;
+  int getLegPlaceAcc(int ctrlNo, bool teamTotal) const;
+  int getLegTimeAfterAcc(int ctrlNo, bool teamTotal) const;
 
   /** Calculate the time when the runners place is fixed, i.e,
       when no other runner can threaten the place.
@@ -897,7 +958,7 @@ public:
   void printSplits(gdioutput& gdi) const;
   void printSplits(gdioutput &gdi, const oListInfo *li) const;
 
-  void printStartInfo(gdioutput &gdi) const;
+  void printStartInfo(gdioutput &gdi, bool includeEconomy) const;
 
   /** Take the start time from runner r*/
   void cloneStartTime(const pRunner r);
@@ -957,22 +1018,25 @@ public:
   void getLegPlaces(vector<int> &places) const;
   void getLegTimeAfter(vector<int> &deltaTimes) const;
 
-  void getLegPlacesAcc(vector<int> &places) const;
-  void getLegTimeAfterAcc(vector<int> &deltaTimes) const;
+  void getLegPlacesAcc(vector<ResultData> &places) const;
+  void getLegTimeAfterAcc(vector<ResultData> &deltaTimes) const;
 
   // Normalized = true means permuted to the unlooped version of the course
   int getSplitTime(int controlNumber, bool normalized) const;
   int getTimeAdjust(int controlNumber) const;
 
   int getNamedSplit(int controlNumber) const;
-  wstring getNamedSplitS(int controlNumber) const;
+  const wstring &getNamedSplitS(int controlNumber, SubSecond mode) const;
+
+  /** Get running time from start to a control (specified by its index on the course)
+    normalized: true means permuted to the unlooped version of the course
+    teamTotalTime: true means time is measured from the team's starting time
+  */
+  int getPunchTime(int controlIndex, bool normalized, bool adjusted, bool teamTotalTime) const;
+  const wstring &getPunchTimeS(int controlIndex, bool normalized, bool adjusted, bool teamTotalTime, SubSecond mode) const;
 
   // Normalized = true means permuted to the unlooped version of the course
-  int getPunchTime(int controlNumber, bool normalized, bool adjusted) const;
-  wstring getPunchTimeS(int controlNumber, bool normalized, bool adjusted, SubSecond mode) const;
-
-  // Normalized = true means permuted to the unlooped version of the course
-  wstring getSplitTimeS(int controlNumber, bool normalized) const;
+  const wstring &getSplitTimeS(int controlNumber, bool normalized, SubSecond mode) const;
 
   void addTableRow(Table &table) const;
   pair<int, bool> inputData(int id, const wstring &input,
@@ -1010,7 +1074,19 @@ public:
   int getCourseId() const {if (Course) return Course->Id; else return 0;}
   void setCourseId(int id);
 
-  bool isHiredCard() const;
+  /** Return true if rental card*/
+  bool isRentalCard() const;
+
+  /** Get the rental card fee.
+     If forAllRunners is true, the total
+     fee is computed (for all multirunners)
+     otherwise only the fee for this runner's
+     card is included. */
+  int getRentalCardFee(bool forAllRunners) const;
+
+  /** Set rental card status (does not update fee)*/
+  void setRentalCard(bool rental);
+
 
   int getCardNo() const { return tParentRunner && cardNumber == 0 ? tParentRunner->cardNumber : cardNumber; }
   void setCardNo(int card, bool matchCard, bool updateFromDatabase = false);
diff --git a/code/oTeam.cpp b/code/oTeam.cpp
index 0e82fa0..4986999 100644
--- a/code/oTeam.cpp
+++ b/code/oTeam.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -436,6 +436,17 @@ int oTeam::getLegFinishTime(int leg) const
   else return 0;
 }
 
+int oTeam::getTotalRunningTimeAtLegStart(int leg, bool multidayTotal) const {
+  int off = multidayTotal ? max(0, getInputTime()) : 0;
+  if (!Class || leg == 0)
+    return off;
+  int pleg = Class->getPreceedingLeg(leg);
+  if (pleg < 0)
+    return off;
+
+  return getLegRunningTime(pleg, false, multidayTotal);
+}
+
 int oTeam::getRunningTime(bool computedTime) const {
   return getLegRunningTime(-1, computedTime, false);
 }
@@ -451,13 +462,13 @@ int oTeam::getLegRunningTime(int leg, bool computedTime, bool multidayTotal) con
 
     if (cr.version == oe->dataRevision) {
       if (cr.time > 0)
-        return cr.time + addon + getTimeAdjustment(false);
+        return cr.time + addon; // Time adjustment already included in time ??
       else
         return 0;
     }
   }
-
-  return getLegRunningTimeUnadjusted(leg, multidayTotal, false) + getTimeAdjustment(false);
+  bool isLastLeg = (leg == -1 || leg + 1 == Runners.size());
+  return getLegRunningTimeUnadjusted(leg, multidayTotal, false) + (isLastLeg ? getTimeAdjustment(false) : 0);
 }
 
 int oTeam::getLegRestingTime(int leg, bool useComputedRunnerTime) const {
@@ -812,9 +823,7 @@ wstring oTeam::getLegPrintPlaceS(int leg, bool multidayTotal, bool withDot) cons
   return _EmptyWString;
 }
 
-bool oTeam::compareResultClub(const oTeam& a, const oTeam& b) {
-  pClub ca = a.getClubRef();
-  pClub cb = b.getClubRef();
+int oAbstractRunner::compareClubs(const oClub* ca, const oClub* cb) {
   if (ca != cb) {
     if (ca == nullptr && cb)
       return true;
@@ -830,6 +839,17 @@ bool oTeam::compareResultClub(const oTeam& a, const oTeam& b) {
     if (res != CSTR_EQUAL)
       return res == CSTR_LESS_THAN;
   }
+  return 2;
+}
+
+bool oTeam::compareResultClub(const oTeam& a, const oTeam& b) {
+  pClub ca = a.getClubRef();
+  pClub cb = b.getClubRef();
+  if (ca != cb) {
+    int cres = compareClubs(ca, cb);
+    if (cres != 2)
+      return cres != 0;
+  }
   return compareResult(a, b);
 }
 
@@ -855,8 +875,13 @@ bool oTeam::compareResult(const oTeam &a, const oTeam &b)
 
   int aix = a.getDCI().getInt("SortIndex");
   int bix = b.getDCI().getInt("SortIndex");
-  if (aix != bix)
+  if (aix != bix) {
+    if (aix == 0)
+      aix = numeric_limits<int>::max();
+    if (bix == 0)
+      bix = numeric_limits<int>::max();
     return aix < bix;
+  }
 
   return CompareString(LOCALE_USER_DEFAULT, 0,
                        a.sName.c_str(), a.sName.length(),
@@ -877,6 +902,24 @@ bool oTeam::compareResultNoSno(const oTeam &a, const oTeam &b)
   else if (a.tmpSortTime != b.tmpSortTime)
     return a.tmpSortTime<b.tmpSortTime;
 
+  int aix = a.getDCI().getInt("SortIndex");
+  int bix = b.getDCI().getInt("SortIndex");
+  if (aix != bix) {
+    if (aix == 0)
+      aix = numeric_limits<int>::max();
+    if (bix == 0)
+      bix = numeric_limits<int>::max();
+    return aix < bix;
+  }
+
+  pClub ca = a.getClubRef();
+  pClub cb = b.getClubRef();
+  if (ca != cb) {
+    int cres = compareClubs(ca, cb);
+    if (cres != 2)
+      return cres != 0;
+  }
+
   return CompareString(LOCALE_USER_DEFAULT, 0,
                        a.sName.c_str(), a.sName.length(),
                        b.sName.c_str(), b.sName.length()) == CSTR_LESS_THAN;
@@ -1751,7 +1794,7 @@ pRunner oTeam::getRunner(unsigned leg) const {
   if (leg==-1)
     leg=Runners.size()-1;
 
-  return leg<Runners.size() ? Runners[leg] : 0;
+  return leg<Runners.size() ? Runners[leg] : nullptr;
 }
 
 int oTeam::getRogainingPoints(bool computed, bool multidayTotal) const {
@@ -2179,6 +2222,8 @@ pair<int, bool> oTeam::inputData(int id, const wstring &input,
           inputId = c->getId();
       }
       setClassId(inputId, true);
+      adjustMultiRunners();
+
       synchronize(true);
       output = getClass(true);
       break;
diff --git a/code/oTeam.h b/code/oTeam.h
index bf1eb9a..ed9f826 100644
--- a/code/oTeam.h
+++ b/code/oTeam.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -57,8 +57,8 @@ protected:
   vector<pRunner> Runners;
   void setRunnerInternal(int k, pRunner r);
 
-  static const int dataSize = 160;
-  int getDISize() const {return dataSize;}
+  static const int dataSize = 256;
+  int getDISize() const final {return dataSize;}
   BYTE oData[dataSize];
   BYTE oDataOld[dataSize];
 
@@ -268,7 +268,10 @@ public:
   wstring getLegRunningTimeS(int leg, bool computed, bool multidayTotal, SubSecond mode) const;
 
   int getLegRunningTime(int leg, bool computed, bool multidayTotal) const;
- 
+  
+  // Get the team's total running time when starting specified leg
+  int getTotalRunningTimeAtLegStart(int leg, bool multidayTotal) const;
+
   RunnerStatus getLegStatus(int leg, bool computed, bool multidayTotal) const;
   const wstring &getLegStatusS(int leg, bool computed, bool multidayTotal) const;
 
@@ -292,6 +295,9 @@ public:
 
   void merge(const oBase &input, const oBase *base) final;
 
+  bool isTeam() const final { return true; }
+
+
   oTeam(oEvent *poe, int id);
   oTeam(oEvent *poe);
   virtual ~oTeam(void);
diff --git a/code/oTeamEvent.cpp b/code/oTeamEvent.cpp
index a77e887..bb09074 100644
--- a/code/oTeamEvent.cpp
+++ b/code/oTeamEvent.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -52,7 +52,7 @@ void oEvent::fillTeams(gdioutput &gdi, const string &id, int classId)
 {
   vector< pair<wstring, size_t> > d;
   oe->fillTeams(d, classId);
-  gdi.addItem(id, d);
+  gdi.setItems(id, d);
 }
 
 const vector< pair<wstring, size_t> > &oEvent::fillTeams(vector< pair<wstring, size_t> > &out, int ClassId)
@@ -240,7 +240,7 @@ pTeam oEvent::findTeam(const wstring &s, int lastId, unordered_set<int> &filter)
   int len = trm.length();
   wchar_t s_lc[1024];
   wcscpy_s(s_lc, trm.c_str());
-  CharLowerBuff(s_lc, len);
+  prepareMatchString(s_lc, len);
 
   int sn = _wtoi(s.c_str());
   oTeamList::const_iterator it;
@@ -871,26 +871,27 @@ void oTeam::fillInSortData(SortOrder so, int leg, bool linearLeg, map<int, int>
     setTmpTime(0);
 
     // Count number of races with results
-    int numResult = 0;
+    int maxLevel = -1;
     int lastClassHeat = 0;
-    for (auto &r : Runners) {
+    for (int level = 0; level < Runners.size(); level++) {
+      pRunner r = Runners[level];
       if (r && (r->prelStatusOK(true, true, false) ||
         (r->tStatus != StatusUnknown && r->tStatus != StatusDNS && r->tStatus != StatusCANCEL))) {
 
         if (r->Class && r->tLeg > 0 && r->Class->isQualificationFinalBaseClass() && r->getClassRef(true) == r->Class)
           continue; // Skip if not qualified.
 
-        numResult++;
+        maxLevel = level;
         lastClassHeat = r->getDCI().getInt("Heat");
         tmpCachedStatus = r->tStatus;
         setTmpTime(r->getRunningTime(false));
       }
     }
-    if (lastClassHeat > 50 || lastClassHeat < 0)
+    if (lastClassHeat > 64 || lastClassHeat < 0)
       lastClassHeat = 0;
 
     unsigned rawStatus = tmpCachedStatus;
-    tmpSortStatus = RunnerStatusOrderMap[rawStatus < 100u ? rawStatus : 0] - (numResult * 100 + lastClassHeat) * 1000;
+    tmpSortStatus = RunnerStatusOrderMap[rawStatus < 100u ? rawStatus : 0] - (maxLevel * 100 - lastClassHeat) * 1000;
 
     return;
   }
diff --git a/code/oevent_transfer.cpp b/code/oevent_transfer.cpp
index a8e2e4c..0ce0e73 100644
--- a/code/oevent_transfer.cpp
+++ b/code/oevent_transfer.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
 MeOS - Orienteering Software
-Copyright (C) 2009-2023 Melin Software HB
+Copyright (C) 2009-2024 Melin Software HB
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -601,7 +601,7 @@ wstring oEvent::cloneCompetition(bool cloneRunners, bool cloneTimes,
 
   if (addToDate) {
     SYSTEMTIME st;
-    convertDateYMS(Date, st, false);
+    convertDateYMD(Date, st, false);
     __int64 absD = SystemTimeToInt64TenthSecond(st);
     absD += timeConstHour * 24;
     ce.Date = convertSystemDate(Int64TenthSecondToSystemTime(absD));
diff --git a/code/onlineinput.cpp b/code/onlineinput.cpp
index 8832dba..21d6dfb 100644
--- a/code/onlineinput.cpp
+++ b/code/onlineinput.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -48,9 +48,9 @@
 #include "SportIdent.h"
 #include "TabSI.h"
 
-int AutomaticCB(gdioutput *gdi, int type, void *data);
+int AutomaticCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 
-static int OnlineCB(gdioutput *gdi, int type, void *data) {
+static int OnlineCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   switch (type) {
     case GUI_BUTTON: {
       //Make a copy
@@ -146,6 +146,26 @@ void OnlineInput::settings(gdioutput &gdi, oEvent &oe, State state) {
     gdi.addInput("CmpID", itow(cmpId), 10, 0, L"Tävlingens ID-nummer:");
 
   gdi.dropLine(1);
+
+  int dateNow = convertDateYMD(getLocalDate(), false);
+  int cmpDate = convertDateYMD(oe.getDate(), false);
+  int zt = oe.getZeroTimeNum() / timeConstMinute;
+  int localTime = convertAbsoluteTimeHMS(getLocalTimeOnly(), 0) / timeConstMinute;
+
+  uint64_t tNow = uint64_t(dateNow) * 10000ul + localTime;
+  uint64_t tZero = uint64_t(cmpDate) * 10000ul + zt;
+  if (tNow < tZero) {
+    gdi.pushX();
+    gdi.fillRight();
+    gdi.addString("warningicon", textImage, "516");
+    gdi.dropLine(-0.2);
+    gdi.fillDown();
+    gdi.addString("cmpwarning", 0, "Observera att stämplingar före tävlingens nolltid inte kan hämtas.");
+    gdi.addString("", italicText, "För kommunikationstest kan man använda en separat testtävling");
+    gdi.dropLine(0.5);
+    gdi.popX();
+  }
+
   gdi.addString("", boldText, "Kontrollmappning");
   gdi.dropLine(0.5);
 
@@ -378,7 +398,7 @@ void OnlineInput::processPunches(oEvent &oe, const xmlList &punches) {
       time = 0;
       addInfo(L"Ogiltig tid");
     }
-    oe.addFreePunch(time, code, originalCode, card, true);
+    oe.addFreePunch(time, code, originalCode, card, true, true);
 
     addInfo(L"Löpare: X, kontroll: Y, kl Z#" + rname + L"#" + oPunch::getType(code) + L"#" +  oe.getAbsTime(time));
   }
@@ -413,7 +433,7 @@ void OnlineInput::processPunches(oEvent &oe, list< vector<wstring> > &rocData) {
         time = 0;
         addInfo(L"Ogiltig tid");
       }
-      oe.addFreePunch(time, code, originalCode, card, true);
+      oe.addFreePunch(time, code, originalCode, card, true, true);
 
       lastImportedId = max(lastImportedId, punchId);
 
@@ -478,11 +498,14 @@ void OnlineInput::processEntries(oEvent &oe, const xmlList &entries) {
     bool paid = entry.getObjectBool("paid");
 
     xmlobject xname = entry.getObject("name");
-    wstring birthyear = 0;
+    wstring birthyear;
     if (xname) {
-      xname.getObjectString("birthyear", birthyear);
+      xname.getObjectString("birthdate", birthyear);
+      if (birthyear.empty()) {
+        xname.getObjectString("birthyear", birthyear);
+      }
     }
-
+    
     wstring name;
     entry.getObjectString("name", name);
     if (name.empty())
diff --git a/code/onlineinput.h b/code/onlineinput.h
index 813dbbd..c18504a 100644
--- a/code/onlineinput.h
+++ b/code/onlineinput.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/onlineresults.cpp b/code/onlineresults.cpp
index eb149cf..ed0927c 100644
--- a/code/onlineresults.cpp
+++ b/code/onlineresults.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -43,9 +43,9 @@
 #include "progress.h"
 #include "machinecontainer.h"
 
-int AutomaticCB(gdioutput *gdi, int type, void *data);
+int AutomaticCB(gdioutput *gdi, GuiEventType type, BaseInfo* data);
 
-static int OnlineCB(gdioutput *gdi, int type, void *data) {
+static int OnlineCB(gdioutput *gdi, GuiEventType type, BaseInfo* data) {
   switch (type) {
     case GUI_BUTTON: {
       //Make a copy
@@ -123,7 +123,7 @@ void OnlineResults::settings(gdioutput &gdi, oEvent &oe, State state) {
   gdi.addListBox("Classes", 200,300,0, L"Klasser:", L"", true);
   gdi.pushX();
   vector< pair<wstring, size_t> > d;
-  gdi.addItem("Classes", oe.fillClasses(d, oEvent::extraNone, oEvent::filterNone));
+  gdi.setItems("Classes", oe.fillClasses(d, oEvent::extraNone, oEvent::filterNone));
   gdi.setSelection("Classes", classes);
 
   gdi.popX();
@@ -418,10 +418,10 @@ void OnlineResults::process(gdioutput &gdi, oEvent *oe, AutoSyncType ast) {
     t = getTempFile();
     if (dataType == DataType::IOF2)
       oe->exportIOFSplits(oEvent::IOF20, t.c_str(), false, false,
-                          classes, -1, false, true, true, false, false);
+                          classes, make_pair("",""), - 1, false, true, true, false, false);
     else if (dataType == DataType::IOF3)
       oe->exportIOFSplits(oEvent::IOF30, t.c_str(), false, false, 
-                          classes, -1, false, true, true, false, false);
+                          classes, make_pair("", ""), -1, false, true, true, false, false);
     else
       throw meosException("Internal error");
   }
diff --git a/code/onlineresults.h b/code/onlineresults.h
index 7180b3f..fef4739 100644
--- a/code/onlineresults.h
+++ b/code/onlineresults.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/ospeaker.h b/code/ospeaker.h
index 8db9c58..c73a0e7 100644
--- a/code/ospeaker.h
+++ b/code/ospeaker.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/parser.cpp b/code/parser.cpp
index ae06441..1ba4a7a 100644
--- a/code/parser.cpp
+++ b/code/parser.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/parser.h b/code/parser.h
index 1d06ce8..37ff865 100644
--- a/code/parser.h
+++ b/code/parser.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/pdfwriter.cpp b/code/pdfwriter.cpp
index eb36d64..45fd648 100644
--- a/code/pdfwriter.cpp
+++ b/code/pdfwriter.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -40,6 +40,7 @@
 
 #include "pdfwriter.h"
 
+using namespace std;
 extern Image image;
 
 wstring getMeosCompectVersion();
diff --git a/code/pdfwriter.h b/code/pdfwriter.h
index b43156a..f8f0e14 100644
--- a/code/pdfwriter.h
+++ b/code/pdfwriter.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/portuguese.lng b/code/portuguese.lng
new file mode 100644
index 0000000..08ecc48
--- /dev/null
+++ b/code/portuguese.lng
@@ -0,0 +1,2676 @@
+%s m = %s m
+%s meter = %s metros
+%s, block: %d = %s, quadra: %d
+(har stämplat) = (deu um picote)
+(kopia) = (copiar)
+(ledare) = (líder)
+(lokalt) = (local, sem servidor)
+(okänd) stämplade vid = (desconhecido) picotado em
+(på server) = (no servidor)
+(sekunder) = (segundos)
+(sträckseger) = (pernada campeã)
+ALLA( = Tudo(
+API-nyckel = API key
+Accepterade elektroniska fakturor = Fatura eletrônica aceita
+Adress = Endereço
+Adress och kontakt = Endereço e Contato
+Age (on last day of current year) = Idade (no último dia do ano)
+Age above or equal implies senior/pensioner = Idade superior ou igual implica master/veterano
+Age below or equal implies youth = Idade inferior ou igual implica juvenil
+Aktivera = Ativar
+Aktivera stöd för tider över 24 timmar = Ative o suporte para tempos de corrida superiores a 24 horas.
+Aktivera stöd för tiondels sekunder = Ative o suporte para cronometragem de subsegundos.
+Aktuell tid = Hora atual
+AllPunches = Todos os picotes
+Alla = Todos
+Alla banfiler = Todos os arquivos do percurso
+Alla deltagare måste ha ett namn = Todos os competidores devem ter um nome
+Alla fakturor = Todas as faturas
+Alla funktioner = Todos os recursos
+Alla händelser = Todos os eventos
+Alla lag måste ha ett namn = Todas as equipes devem ter um nome
+Alla listor = Todas as listas
+Alla lopp = Todas as corridas
+Alla lopp som individuella = Cada corrida como individual
+Alla sträckor = Todas as pernas
+Alla sträckor/lopp i separata filer = Todas as pernas/corridas em arquivos separados
+Alla tidigare etapper = Todas as etapas anteriores
+Alla typer = Todos os tipos
+Alla uthyrda brickor har bockats av = Todos os cartões alugados são marcados
+Allmänna resultat = Resultados gerais
+Andel vakanser = Fração de vaga
+Ange en gruppstorlek (som repeteras) eller flera kommaseparerade gruppstorlekar = Forneça um tamanho de grupo (a ser repetido) ou vários tamanhos separados por vírgula
+Ange första nummerlappsnummer eller lämna blankt för inga nummerlappar = Forneça o primeiro número de peitoral ou em branco para nenhum peitoral
+Ange löpande numrering eller första nummer i klassen = Especifique a numeração consecutiva entre categorias ou especifique o primeiro número na categoria
+Ange om kontrollen fungerar och hur den ska användas = Especifique se os controles estão operacionais e como devem ser usados
+Ange relation mellan lagets och deltagarnas nummerlappar = Especifique a relação entre o número de identificação da equipe e os números de identificação do membro da equipe
+Ange startintervall för minutstart = Digite o intervalo de início para reiniciar
+Ange tiden relativt klassens första start = Digite o tempo relativo ao primeiro início da categoria.
+Animation = Animação
+Anm. avg. = Taxa entr.
+Anm. avgift = Taxa de entrada
+Anm. datum = Data de entrada
+Anm. tid = Hora de entrada
+Anmäl = Digitar
+Anmäl X = Digite X para a competição
+Anmäl andra = Nova entrada
+Anmäl inga deltagare nu = Sem entradas
+Anmäl till efterföljande etapper = Entre para as etapas subseqüentes
+Anmälan mottagen = Entrada aceita
+Anmälan måste hanteras manuellt = Sua entrada requer processamento manual.
+Anmälda = Entradas
+Anmälda per distrikt = Inscrições por distrito
+Anmälningar = Entradas
+Anmälningar (IOF (xml) eller OE-CSV) = Entradas (IOF (xml) ou OE-CSV)
+Anmälningsavgift = Taxa de entrada
+Anmälningsdatum = Data entrada
+Anmälningsläge = Modo de entrada rápida
+Anmälningstid = Hora de entrada
+Anonymt namn = Nome anônimo
+Anslut = Conectar
+Anslut till en server = Conectar ao servidor
+Ansluten till = Conectado a
+Ansluter till Internet = Conectando-se à Internet
+Anslutna klienter = Clientes conectados
+Anslutningar = Conexões
+Anslutningsinställningar = Configurações de conexão
+Antal = Número
+Antal banor = Número de percursos
+Antal besökare X, genomsnittlig bomtid Y, största bomtid Z = Número de visitantes X, tempo médio perdido Y, tempo máximo perdido Z
+Antal deltagare = Competidores
+Antal deltagare: X = Número de competidores: X
+Antal förfrågningar: X = Número de solicitações: X
+Antal hämtade uppdateringar X (Y kb) = Número de atualizações recebidas X (Y kb)
+Antal ignorerade: X = Número de entradas ignoradas: X
+Antal importerade = Número de importações
+Antal kartor = Número de mapas
+Antal klasser = Número de categorias
+Antal löpare = Número de corredores
+Antal löpare på vanligaste banan X = Número de corredores no percurso mais utilizado X
+Antal misslyckade: X = Número de entradas com falha: X
+Antal reserverade nummerlappsnummer mellan klasser = Números de números de peito reservados entre categorias
+Antal skickade uppdateringar X (Y kb) = Número de atualizações X (Y kb)
+Antal som inte importerades: X = Número de entidades ignoradas: X
+Antal startande per block = Número de partidas por bloco
+Antal startande per intervall (inklusive redan lottade) = Número de partidas por intervalo (incluindo já sorteadas)
+Antal sträckor = Número de pernas
+Antal vakanser = Número de Vagas
+Antal: %d = Número: %d
+Antal: X = Número: X
+Antalet kolumner i urklipp får inte plats i selektionen = O número de colunas na área de transferência não cabe na seleção
+Antalet kolumner i urklippet är större än antalet kolumner i tabellen = O número de colunas na área de transferência é maior que o número de colunas na tabela
+Antalet rader i urklipp får inte plats i selektionen = O número de linhas na área de transferência não cabe na seleção
+Använd = Usar
+Använd Eventor = Usar Eventor
+Använd ROC-protokoll = Usar protocolo ROC
+Använd banpool = Usar pool de percursos
+Använd befintliga deltagare = Usar competidores já em competição
+Använd endast en bana i klassen = Usar apenas um percurso na categoria
+Använd enhets-id istället för tävlings-id = Usar o ID da unidade em vez do ID da competição
+Använd funktioner för fleretappsklass = Usar função de categoria com múltiplos estágios
+Använd första kontrollen som start = Use o primeiro controle como partida
+Använd listan för sträcktidsutskrift = Usar lista para impressão em tempo parcial
+Använd löpardatabasen = Usar banco de dados de competidores
+Använd om möjligt samma dator som användes vid senaste importen = Se possível, use o mesmo computador que foi usado para importar da última vez
+Använd sista kontrollen som mål = Use o último controle como chegada
+Använd speakerstöd = Usar módulo de anúncios
+Använd stor font = Usar fonte grande
+Använd symbolen X där MeOS ska fylla i typens data = Use o símbolo X onde o MeOS deve preencher os dados
+Användarnamn = Nome usuário
+Anyone = Qualquer um
+Applicera för specifik etapp = Candidate-se a estágio específico
+Applicera för specifik sträcka = Candidate-se a uma perna específica
+Applying rules to the current competition = Aplicação das regras à competição atual
+Arrangör = Organizador
+Assign courses and apply forking to X = Atribuir Percursos e Aplicar Bifurcação a X
+Assign selected courses to selected legs = Atribuir Percursos Selecionados às Pernas Selecionadas
+Att betala = Pagar
+Att betala: X = Pagar: X
+Automater = Serviços
+Automatic rogaining point reduction = Redução automática de ponto cross-country
+Automatisera = Automatizar
+Automatisk = Automático
+Automatisk hyrbrickshantering genom registrerade hyrbrickor = Manuseio automático de chips contratados por meio de números de chips pré-cadastrados
+Automatisk lottning = Desenhar automaticamente
+Automatisk omladdning = Atualização automática
+Automatisk skroll = Rolagem Automática
+Automatisk utskrift = Impressão Automática
+Automatisk utskrift / export = Impressão / Exportação Automática
+Automatnamn = Nome do Serviço
+Av MeOS: www.melin.nu/meos = By MeOS: www.melin.nu/meos
+Available symbols = Símbolos disponíveis
+Avancerat = Avançado
+Avbockade brickor = Chips marcados
+Avbryt = Cancelar
+Avbryt inläsning = Cancelar leitura
+Avdrag = Redução
+Avgift = Taxa
+Avgifter = Honorários
+Avgifter och valuta ställer du in under = Taxas e configurações de moeda são alteradas de
+Avgiftshöjning (procent) = Extensão da taxa (porcentagem)
+Avgjorda klasser (prisutdelningslista) = Classes liquidadas (Lista de Cerimônia de premiação)
+Avgjorda placeringar - %s = Resultados Liquidados - %s
+Avgörande händelser = Eventos Decisivos
+Avgörs X = Pronto em X
+Avgörs kl = Tempo pronto
+Avkortad banvariant = Percurso abreviado
+Avkortar: X = Encurta: X
+Avkortning = Encurtando
+Avläsning/radiotider = Leitura/rádio
+Avmarkera 'X' för att hantera alla bricktildelningar samtidigt = Desmarque 'X' para lidar com todas as atribuições de chips em uma página
+Avmarkera allt = Desmarcar todos
+Avrundad tävlingsavgift = Taxa de Competição, arredondada
+Avsluta = Sair
+Avstämning hyrbrickor = Contagem de chips contratados devolvidos
+Avstånd = Distância
+Bad file format = Formato de arquivo inválido
+Bakgrund = Fundo
+Bakgrundsfärg = Cor de fundo
+Bakåt = Voltar
+Bana = Percurso
+Bana %d = Percurso %d
+Bana med slingor = Percurso com loops
+Banan används och kan inte tas bort = O percurso está em uso
+Banan måste ha ett namn = O percurso deve ter um nome
+Banan saknar rogainingkontroller = O percurso não tem controles de cross-country definidos
+Banan saknas = Falta percurso
+Banans kontroller ger för få poäng för att täcka poängkravet = Os controles cross-country concedem poucos pontos para cobrir o requisito
+Bananvändning = Uso do percurso
+Banmall = Percurso
+Banor = Percursos
+Banor (antal kontroller) = Percursos (número de controles)
+Banor för %s, sträcka %d = Percursos para %s, perna %d
+Banor, IOF (xml) = Percursos, IOF (xml)
+Banor, OCAD semikolonseparerat = Percursos, formato OCAD
+Banpool = Pool de Percursos
+Banpool, gemensam start = Pool de Percursos, partida simultânea
+Banpool, lottad startlista = Pool de Percursos, desenhar lista de partida
+Bantilldelning = Atribuição de percursos
+Bantilldelning hänvisar till en löpare (X) som saknas i laget (Y) = Atribuição de percurso específico para o Competidor (X) que está faltando na equipe (Y)
+Bantilldelning, individuell = Atribuição de percurso, individual
+Bantilldelning, stafett = Atribuição de percurso, revezamento
+Bantilldelningslista - %s = Atribuição de Percursos - %s
+Basera på en tidigare tävling = Base na competição existente
+Baserad på X = Baseado em X
+Basintervall (min) = Intervalo base (min)
+Batteridatum = Data da Bateria
+Batteristatus = Status da Bateria
+Begränsa antal per klass = Número limite por categoria
+Begränsa antal rader per sida = Limitar linhas por página
+Begränsa bredd (klipp text) = Largura limite (cortar texto)
+Begränsa per klass = Limite por categoria
+Begränsning, antal visade per klass = Limitar, número de inscrições por categoria
+Behandlar löpardatabasen = Processando banco de dados de competidores
+Behandlar tävlingsdata = Processando dados da competição
+Behandlar: X = Processando: X
+Bekräfta att %s byter klass till %s = Por favor, confirme que %s mudou de categoria para %s
+Bekräfta att deltagaren har lämnat återbud = Por favor, confirme a desistência deste competidor
+Besökare = Visitantes
+Betalat = Pago
+Betalningsinformation = Detalhes do Pagamento
+Betalningsmetoder = Formas de Pagamento
+Betalsätt = Modo de Pagamento
+Bevakar händelser i X = Monitorando eventos no X
+Bevakningsprioritering = Selecionar o competidor para assistir
+Bibs = Nº Peito
+Block = Bloco
+Blockbredd = Largura do bloco
+Bläddra = Navegar
+Bold = Negrito
+BoldHuge = Negrito, gigante
+BoldLarge = Negrito, grande
+BoldSmall = Negrito, pequeno
+Bomkvot = Quociente de Erro
+Bommade kontroller = Erros de controle
+Bomtid = Tempo perdido
+Bomtid (max) = Tempo perdido (máximo)
+Bomtid (medel) = Tempo perdido (média)
+Bomtid (median) = Tempo perdido (mediana)
+Bomtid: X = Tempo perdido: X
+Borttagna: X = Distante: X
+Bricka = Chip
+Bricka %d används redan av %s och kan inte tilldelas = O chip %d está em uso por %s e não pode ser atribuído
+Bricka X = Chip X
+Bricka X används också av = O chip X também está em uso por
+Brickan används av X = O chip é usado por X
+Brickan redan inläst = O chip já foi lido
+Brickavläsning = Leitura de chip
+Brickhantering = Lidar com chips
+Brickhyra = Taxa do chip
+Bricknr = Número do chip
+Bricknummer = Número do chip
+Bricknummret är upptaget (X) = O chip está em uso (X)
+Brickor = Chips
+Brickor markerade som både uthyrda och egna: X = Chips usados como contratados e próprios: X
+Bygg databaser = Construir banco de dados
+Byt till rätt klass (behåll eventuell starttid) = Mude para a categoria certa (mantenha o horário de partida)
+Byt till vakansplats i rätt klass (om möjligt) = Mudar para uma posição vaga na categoria certa (se possível)
+COM-Port = Porta-COM
+Calculate and apply forking = Calcular e aplicar bifurcação
+Cancel = Cancelar
+Cannot represent ID X = Não é possível representar o ID 'X'
+Centrera = Centro
+Check = Verificar
+Check: X = Verificar: X
+Checkenhet = Verifique a unidade
+Choose result module = Escolha o módulo de resultado
+ClassAvailableMaps = Mapas disponíveis para a categoria
+ClassCourseResult = Categoria, percurso, resultado
+ClassDefaultResult = Categoria, resultado padrão
+ClassFinishTime = Categoria, horário de chegada
+ClassKnockoutTotalResult = Categoria, resultado eliminatório total
+ClassLength = Duração do percurso por categoria
+ClassLiveResult = Resultados ao vivo (tempos de rádio) por categoria
+ClassName = Categoria
+ClassNumEntries = Número de inscrições por categoria
+ClassPoints = Categoria, pontos
+ClassResult = Categoria, resultado
+ClassResultFraction = Fração da categoria completa
+ClassStartName = Horário de partida
+ClassStartTime = Categoria, Horário de partida, nome
+ClassStartTimeClub = Categoria, Horário de partida, clube
+ClassTeamLeg = Categoria, Equipe, perna
+ClassTeamLegResult = Resultado da categoria e perna
+ClassTotalMaps = Número total de mapas por categoria
+ClassTotalResult = Categoria, resultado total
+Classes together = Categorias juntas
+Clear Memory = Limpar memória
+Clear selections = Limpar Seleções
+Climb (m) = Elevação (m)
+Club = Clube
+Club and runner database = Banco de dados de Clube e competidores
+Club id number = Número do Clube
+ClubClassStartTime = Clube, categoria, Horário de partida
+ClubName = Clube
+ClubRunner = Clube (Competidores)
+ClubTeam = Clube (Equipes)
+Clubs = Clubes
+CmpDate = Data Competição
+CmpName = Nome Competição
+Control = Controle
+Control Overview = Visão Geral do Controle
+Control Statistics = Estatísticas do Controle
+Control Statistics - X = Estatísticas do Controle - X
+ControlClasses = Controles das categorias
+ControlCodes = Códigos de Picote dos controles
+ControlCourses = Controles dos percursos
+ControlMaxLostTime = Controle, tempo perdido, máximo
+ControlMedianLostTime = Controle, tempo perdido, mediana
+ControlMistakeQuotient = Controle, quociente de competidores com tempo perdido
+ControlName = Nome do controle
+ControlPunches = Número real de visitantes do controle
+ControlRunnersLeft = Número restante de visitantes do controle
+ControlVisitors = Número esperado de visitantes do controle
+Could not load list 'X' = Não é possível carregar a lista 'X'
+Country = País
+Course = Percurso
+CourseClasses = Categorias dos Percursos
+CourseClimb = Elevação do Percurso
+CourseLength = Distância do Percurso, percurso específico
+CourseName = Nome do Percurso
+CourseNumber = Número do Percurso
+CoursePunches = Picotes (no percurso)
+CourseResult = Percurso, resultado
+CourseShortening = Encurtamento de percurso
+CourseStartTime = Percurso, horário de partida
+CourseUsage = Número de mapas requerido no percurso
+CourseUsageNoVacant = Número de inscritos no percurso excluindo vagas
+Create Competition = Criar Competição
+Created X distinct forkings using Y courses = Criou X bifurcações distintas usando Y percursos
+CurrentTime = Hora Atual
+CustomSort = Pedido personalizado
+DATABASE ERROR = ERRO DE BANCO DE DADOS
+Data from result module (X) = Dados do módulo de resultado (X)
+Databasanslutning = Conexão de Banco de Dados
+Database is used and cannot be deleted = O Banco de Dados está em uso e não pode ser excluído
+Databaskälla = Fonte do Banco de Dados
+Databasvarning: X = Aviso do Banco de Dados: X
+Datorröst som läser upp förvarningar = Voz de computador anunciando os competidores
+Datum = Data
+Datum (för första start) = Data (da primeira partida)
+Datumfilter = Filtro de data
+Debug = Depurar
+Debug Output = Saída de Depuração
+Debug X for Y = Depurar X para Y
+Decimalseparator = Separador decimal
+DefaultFont = Formatação padrão
+Define forking = Definir Bifurcação
+Definierade mappningar = Mapeamentos definidos
+Dela = Dividir
+Dela efter placering = Dividir por resultado
+Dela efter ranking = Dividir por ranking
+Dela efter tid = Dividir por tempo
+Dela klass: X = Dividir por Categoria: X
+Dela klassen = Dividir por Categoria
+Dela klubbvis = Dividir por Clube
+Dela slumpmässigt = Divisão aleatória
+Dela upp = Dividir
+Deltagare = Competidores
+Deltagare %d = Competidor %d
+Deltagaren 'X' deltar i patrullklassen 'Y' men saknar patrull. Klassens start- och resultatlistor kan därmed bli felaktiga = O competidor 'X' está na categoria de patrulha 'Y', mas não possui patrulha. Os resultados nesta categoria podem ser inconsistentes
+Deltagaren 'X' deltar i stafettklassen 'Y' men saknar lag. Klassens start- och resultatlistor kan därmed bli felaktiga = O competidor 'X' está na categoria de revezamento 'Y', mas não tem equipe. Os resultados nesta categoria podem ser inconsistentes
+Deltagaren 'X' saknar klass = O concorrente 'X' não tem categoria
+Deltagarens klass styrs av laget = A categoria é definida pela equipe
+Deltar ej = NTP
+Denna datakälla är aldrig tidigare infogad = Esta fonte de dados nunca foi mesclada
+Denna etapps nummer = Ordinal desta etapa
+Description = Descrição
+Destination: X = Destino: X
+Destinationskatalog = Pasta de destino
+Det finns anmälningsdata för flera etapper = Há dados de entrada para várias etapas
+Det finns multiplia Id-nummer för personer = Existem vários IDs para pessoas
+Det går endast att sätta in vakanser på sträcka 1 = Você só pode adicionar vagas para a primeira etapa
+Det här programmet levereras utan någon som helst garanti. Programmet är = Não há garantia para este programa; é fornecido "como está". o programa é
+Det uppskattade antalet startade lag i klassen är ett lämpligt värde = O número estimado de equipes na categoria é um valor adequado
+Deviation +/- from expected time on course leg = Desvio +/- do tempo esperado na perna do percurso
+Direkt tidtagning = Cronometragem ao vivo
+Direktanmälan = Entrada rápida
+Disk. = DISQ
+District id number = Número de identificação do distrito
+Distriktskod = Código do distrito
+Do you want to clear the card memory? = Deseja limpar a memória do chip?
+Don't know how to align with 'X' = Não sei como alinhar com 'X'
+Du kan använda en SI-enhet för att läsa in bricknummer = Você pode usar uma unidade de controle SI para ler o número do chip
+Du kan importera banor och klasser från OCADs exportformat = Você pode importar percursos e categorias do formato de exportação do OCAD
+Du kan justera tiden för en viss enhet = Você pode ajustar o tempo para uma única unidade de controle
+Du måste ange minst två gafflingsvarienater = Você deve especificar pelo menos 2 variantes
+Du måste välja en klass = Você tem que selecionar uma categoria
+Duplicera = Duplicado
+Duplicerad nummerlapp: X, Y = Número Peito Duplicado: X, Y
+Dölj = Esconder
+Döp om = Renomear
+Döp om X = Renomear X
+E-post = E-mail
+EFilterAPIEntry = Entrada via API
+EFilterIncludeNotParticipating = Incluir não participante
+EFilterWrongFee = Taxa inesperada
+Economy and fees = Economia e taxas
+Edit Clubs = Editar Clubes
+Edit Result Modules = Editar Módulo de Resultados
+Edit rule for = Editar regra para
+Efter = Atrás
+Efter X = Depois X
+Efteranm. avg. = Taxa de atraso
+Efteranmälda (efter ordinarie) = Entradas tardias (Depois)
+Efteranmälda (före ordinarie) = Entradas tardias (Antes)
+Efteranmälda före ordinarie = Entradas atrasadas na frente
+Efteranmälningar = Entradas Atrasadas
+Egen listrubrik = Cabeçalho de lista personalizada
+Egen text = Texto personalizado
+Egenskaper = Propriedades
+Eget fönster = Nova janela
+Egna listor = Listas Personalizadas
+Egna textrader = Linhas de texto personalizadas
+Ej accepterade elektroniska fakturor = Notas Fiscais eletrônicas recusadas
+Ej elektronisk = Não eletrônico
+Ej lottade = Não Desenhado
+Ej lottade, efter = Empate Restante Depois
+Ej lottade, före = Desenhar Restantes Antes
+Ej omstart = Sem reinicialização
+Ej start = DNS
+Ej startstämpling = Ignorar picote de partida
+Ej tidtagning = Sem tempo
+Ekonomi = Economia
+Ekonomihantering, X = Status econômico, X
+Ekonomisk sammanställning = Resumo econômico
+Elektronisk = Eletrônico
+Elektronisk godkänd = Eletrônico aceito
+Elit = Elite
+Elitavgift = Taxa de elite
+Elitklasser = Categoria de Elite
+En bana med slingor tillåter deltagaren att ta slingorna i valfri ordning = Um percurso com loops permite que o competidor faça os loops em qualquer ordem
+En gafflad sträcka = Um estágio bifurcado
+En klass kan inte slås ihop med sig själv = Você não pode mesclar uma categoria com ela mesma
+En klubb kan inte slås ihop med sig själv = Um clube não pode ser mesclado com ele mesmo
+Endast en bana = Percurso único
+Endast grundläggande = Recursos Básicos
+Endast grundläggande (enklast möjligt) = Apenas funcionalidades básicas
+Endast på obligatoriska sträckor = Processe apenas pernas não opcionais.
+Endast tidtagning = Apenas temporização
+Endast tidtagning (utan banor) = Apenas cronometragem (sem percursos)
+Endast tidtagning (utan banor), stafett = Apenas cronometragem (sem percursos), revezamento
+Enhet = Unidade
+Enhetens ID-nummer (MAC) = ID da Unidade (MAC)
+Enhetskod = Código da Unidade
+Enhetstyp = Tipo de Unidade
+EntryTime = Horário de Entrada
+Error in result module X, method Y (Z) = Erro no módulo de resultado 'X', método 'Y'\n\nZ
+Etapp = Etapa
+Etapp X = Etapa X
+Etappresultat = Resultados da Etapa
+Ett långt tävlingsnamn kan ge oväntad nerskalning av utskrifter = Um nome de competição longo pode causar redução indesejada na fonte das listas impressas
+Ett okänt fel inträffade = Ocorreu um erro desconhecido
+Ett startblock spänner över flera starter: X/Y = Um bloco de início abrange mais de um início: X/Y
+Ett startintervall måste vara en multipel av basintervallet = Um intervalo de partida deve ser um múltiplo do intervalo base
+Ett värde vars tolkning beror på listan = Um valor com uma interpretação dependente de lista
+Eventor server = Servidor do Eventor
+Eventorkoppling = Conexão do Eventor
+Eventors tider i UTC (koordinerad universell tid) = Horas do Eventor em UTC (Tempo Universal Coordenado)
+Exempel = Exemplo
+Export av resultat/sträcktider = Exportar Resultados / Parciais
+Export language = Idioma de exportação
+Export split times = Exportar tempos parciais
+Exportera = Exportar
+Exportera / Säkerhetskopiera = Exportar / Backup
+Exportera alla till HTML = Exportar para HTML
+Exportera alla till PDF = Exportar para PDF
+Exportera datafil = Exportar  dados
+Exportera elektroniska fakturor = Exportar Faturas eletrônicas
+Exportera ett kalkylblad med lottningsinställningar som du kan redigera och sedan läsa in igen = Exporte uma planilha desenhada com configurações que você pode editar e importar novamente
+Exportera individuella lopp istället för lag = Exportar como corridas individuais em vez de equipes
+Exportera inställningar och löpardatabaser = Exportar configurações e banco de dados
+Exportera klubbar (IOF-XML) = Exportar Clubes (IOF-XML)
+Exportera löpardatabas = Exportar Banco de Dados de competidores
+Exportera nu = Exportar agora
+Exportera personer (IOF-XML) = Exportar Pessoas (IOF-XML)
+Exportera på fil = Exportar para arquivo
+Exportera resultat på fil = Exportar Resultados para arquivo
+Exportera startlista = Exportar Lista de Partida
+Exportera startlista på fil = Exportar Lista de Partida para arquivo
+Exportera sträcktider = Exportar Parciais
+Exportera tider i UTC = Exportar tempos em UTC
+Exportera till fil = Exportar para arquivo
+Exportera tävlingsdata = Exportar dados
+Exporterar om = Exportando em
+Exportformat = Formato de Exportação
+Exporttyp = Tipo de Exportação
+Exportval, IOF-XML = Configurações de Exportação, IOF-XML
+Externa adresser = Links Externos
+Externt Id = ID Externo
+Extra = Extra
+Extra avstånd ovanför textblock = Distância Extra acima
+Extra stämplingar = Picotes Extra
+Extralöparstafett = Revezamento de competidor
+Extraplatser = Lugares Extra
+FAKTURA = FATURA
+FEL, inget svar = Erro, sem resposta
+FEL: Porten kunde inte öppnas = Erro: A Porta não pode ser aberta
+Failed to generate card = Falha ao gerar chip
+Failed to open 'X' for reading = Falha ao abrir 'X' para leitura
+Failed to read file = Falha ao ler o arquivo.
+Faktiskt startdjup: X minuter = Profundidade inicial real: X minutos
+Faktura = Fatura
+Faktura nr = Fatura Num.
+Fakturadatum = Data da Fatura
+Fakturainställningar = Configurações da fatura
+Fakturanummer = Número da Fatura
+Faktureras = A ser faturado
+Fakturor = Faturas
+Familj = Família
+Fel: Använd X i texten där värdet (Y) ska sättas in = Erro: Use X no texto onde o valor (Y) deve ser usado
+Fel: Denna tävlingsversion är redan infogad = Erro: Esta versão já foi mesclada
+Fel: En tävling kan inte slås ihop med sig själv = Erro: Não é possível mesclar uma competição consigo mesma
+Fel: X = Erro: X
+Fel: hittar inte filen X = Erro. Arquivo 'X' não encontrado
+Felaktig kontroll = Controle Ruim
+Felaktig nyckel = Chave Incorreta
+Felaktig sträcka = Número da perna incorreta
+Felaktigt datum 'X' (Använd YYYY-MM-DD) = Data Incorreta 'X' (Use YYYY-MM-DD)
+Felaktigt datumformat 'X' (Använd ÅÅÅÅ-MM-DD) = Formato de data incorreto 'X' (Use YYYY-MM-DD)
+Felaktigt filformat = Formato de arquivo inválido
+Felaktigt rankingformat i X. Förväntat: Y = Formato de ranking incorreto em X.\n Esperado: Y
+Felaktigt tidsformat 'X' (Använd TT:MM:SS) = Formato de hora 'X' incorreto (Use HH:MM:SS)
+Felst. = MP
+Fil att exportera till = Exportar arquivo para
+Fil: X = Nome do arquivo: X
+Filen (X) innehåller IOF-XML tävlingsdata och kan importeras i en existerande tävling = O arquivo (X) contém os dados da competição IOF-XML. Você pode importá-lo para uma competição existente.
+Filen (X) är en listdefinition = O arquivo (X) é uma definição de lista
+Filen (X) är en resultatmodul = O arquivo (X) é um módulo de resultado
+Filen (X) är inte en MeOS-tävling = O arquivo (X) não é uma competição MeOS
+Filen finns redan: X = O destino já existe: X
+Filnamn = Nome do arquivo
+Filnamn (OCAD banfil) = Nome do arquivo (Percursos OCAD)
+Filnamn IOF (xml) eller OE (csv) med löpare = Nome do arquivo IOF (xml) ou OE (csv) com competidores
+Filnamn IOF (xml) med klubbar = Nome do arquivo IOF (xml) com clubes
+Filnamn IOF (xml) med löpare = Nome do arquivo IOF (xml) com competidores
+Filnamnet får inte vara tomt = O nome do arquivo não deve estar vazio
+Filnamnsprefix = Prefixo do nome do arquivo
+Filter = Filtragem
+FilterAnyResult = Com radio tempo/resultado
+FilterHasCard = Com chip
+FilterNamedControl = Controles nomeados
+FilterNoCancel = Não cancelado
+FilterNoCard = Sem chip
+FilterNotFinish = Excluir chegada
+FilterNotVacant = Sem vaga
+FilterOnlyVacant = Apenas vago
+FilterPrelResult = Resultado preliminar
+FilterRentCard = Chip contratado
+FilterResult = Com resultado
+FilterSameParallel = Colete pernas paralelas
+FilterSameParallelNotFirst = Colete pernas paralelas, pule primeiro
+FilterStarted = Começou
+Filtrera = Filtro
+Filtrering = Filtragem
+Finish order = Finalizar pedido
+Finish time for each team member = Horário de chegada para cada membro da equipe
+FinishTime = Horário de chegada, nome
+FinishTimeReverse = Horário de chegada invertido (último primeiro)
+First to finish = Primeiro a terminar
+Flera banor = Vários percursos
+Flera banor / stafett / patrull / banpool = Múltiplos Percursos / Revezamento / Patrulha / Pool de Percursos
+Flera banor/stafett = Vários Percursos / Revezamento
+Flera lopp i valfri ordning = Várias corridas em qualquer ordem
+Flera starter per deltagare = Múltiplas corridas por competidor
+Flytta deltagare från överfulla grupper = Mover competidores de grupos completos
+Flytta höger = Mover para a direita
+Flytta ner = Mover para baixo
+Flytta upp = Mover para cima
+Flytta vänster = Mover para a esquerda
+Forked individual courses = Percursos individuais bifurcados
+Forking setup = Configuração de Bifurcação
+Forkings = Bifurcações
+Forkings for X = Bifurcações para X
+Format = Formatar
+Formaterat webbdokument (html) = Documento web gratuito (html)
+Formatering = Formatação
+Formateringsregler = Regras de formatação
+Formulärläge = Modo formulário
+Fortsätt = Continuar
+Fri anmälningsimport = Importação de Entrada Livre
+Fri starttid = Horário de partida livre
+Fria starttider = Horários de partida livre
+Fritt = Livre
+Från den här listan kan man skapa etiketter att klistra på kartor = A partir desta lista, você pode criar rótulos para colar nos mapas
+Från första = De Primeiro
+Från klassen = Da Categoria
+Från klubben = Do Clube
+Från kontroll = Do Controle
+Från lag = Da Equipe
+Från laget = Da Equipe
+Från löpardatabasen = Do Banco de Dados de competidor
+Från löpardatabasen i befintliga klubbar = Do Banco de Dados de competidor em clubes existentes
+Fullskärm = Tela Cheia
+Fullskärm (rullande) = Tela Cheia (rolando)
+Fullskärm (sidvis) = Tela Cheia (página por página)
+Funktion = Função
+Funktioner = Funções
+Funktioner i MeOS = Recursos MeOS
+Fyll obesatta sträckor i alla lag med anonyma tillfälliga lagmedlemmar (N.N.) = Preencher pernas vagas em todas as equipes com membros temporários anônimos da equipe (X)
+Färg = Cor
+Färre slingor = Menos voltas
+Födelseår = Ano de Nascimento
+Följande deltagare deltar ej = Os seguintes competidores não participarão
+Följande deltagare har bytt klass = Os seguintes competidores mudaram de categoria
+Följande deltagare har bytt klass (inget totalresultat) = Os seguintes competidores mudaram de categoria (sem resultado total)
+Följande deltagare har tilldelats en vakant plats = Os seguintes competidores ocuparam uma posição vaga
+Följande deltagare är anmälda till nästa etapp men inte denna = Os seguintes competidores estão inscritos para a próxima etapa, mas não esta
+Följande deltagare är nyanmälda = Os seguintes competidores geraram novas entradas
+Följande deltagare överfördes ej = Os seguintes competidores foram ignorados
+Fönster = Janela
+Fönster (rullande) = Janela (rolando)
+För att delta i en lagklass måste deltagaren ingå i ett lag = Para participar de uma categoria de equipe, você precisa atribuir uma equipe ao competidor
+För att ändra måltiden måste löparens målstämplingstid ändras = Para alterar o horário de chegada, o horário do picote final deve ser alterado
+För muspekaren över en markering för att få mer information = Passe o ponteiro do mouse sobre uma marcação para obter mais informações
+För många kontroller = Muitos controles
+Förbered lottning = Preparar tempos
+Fördefinierade tävlingsformer = Competições pré-definidas
+Fördela starttider = Distribuir horários
+Före X = Antes de X
+Föregående = Anterior
+Föregående etapp = Fase precedente
+Föregående kontroll = Controle precedente
+Förekomst = Ocorrência
+Förhandsgranskning, import = Pré-visualização de Importação
+Förhindra att laget deltar i någon omstart = Impedir que a equipe participe de um reinício
+Förhindra omstart = Impedir reinicialização
+Förhöjd avgift = Taxa estendida
+Först = Primeiro
+Först-i-mål, gemensam = Primeiro a terminar, comum
+Först-i-mål, klassvis = Primeiro a terminar, em termos de categoria
+Första (ordinarie) start = Primeira largada (comum)
+Första fakturanummer = Número da primeira fatura
+Första kontrollen = Primeiro Controle	
+Första omstartstid = Primeiro Horário para reiniciar
+Första ordinarie starttid = Primeiro Horário regular de início
+Första start = Primeira partida
+Första starttid = Primeiro horário de partida
+Första sträckan kan inte vara parallell = A primeira perna não pode ser paralela
+Första tillåtna starttid = Primeira hora de início possível
+Försvunnen = Ausente
+Försöket misslyckades = Operação falhou
+Förvarning på (SI-kod): alla stämplingar = Aviso prévio (Código SI): todos os picotes
+Förvarningsröst = Voz de Advertência
+Förväntad = Esperado
+Förväntad andel efteranmälda = Fração esperada de entradas tardias
+Förväntat antal besökare: X = Número esperado de visitantes: X
+Gafflade banor = Percursos com bifurcação
+Gafflingar i tabellformat = Bifurcações em formato de tabela
+Gafflingsnyckel = Chave de bifurcação
+Gafflingsnyckel X = Chave de bifurcação X
+Gamla brickor utan stöd för långa tider = Chips antigos sem suporte para longos tempos de execução
+Gata = Rua
+Gemensam start = Partida simultânea
+General = Em geral
+Generera = Gerar
+Generera testtävling = Gerar competição de teste
+Genererad = Gerado em
+Genomsnittlig svarstid: X ms = Tempo médio de resposta: X ms
+Geografisk fördelning = Distribuição geográfica
+Global sorteringsordning = Ordem de classificação global
+Godkänd = OK
+Godkänd API-nyckel = Chave API aceita
+Granska inmatning = Visualização
+Grund avg. = Taxa base
+Grundavgift = Taxa base
+Grundinställningar = Configurações básicas
+Gruppera = Grupo	
+Gräns för maxtid = Limite tempo máximo (OMT)
+HTML Export = Exportação HTML
+HTML Export för 'X' = Exportação HTML de 'X'
+HTML formaterad genom listinställningar = HTML formatado por configurações de lista
+HTML med AutoRefresh = HTML com atualização automática
+Hantera brickor = Gerenciar chips
+Hantera deltagare som bytt klass = Tratamento de competidores que mudaram de classe
+Hantera egna listor = Gerenciar listas personalizadas
+Hantera flera etapper = Gerenciar vários estágios
+Hantera jaktstart = Lidar com Perseguição
+Hantera klubbar = Gerenciar clubes
+Hantera klubbar och ekonomi = Gerenciar clubes e economia
+Hantera kvar-i-skogen = Gerenciar competidores restantes
+Hantera laget = Gerenciar equipe
+Hantera löparbrickor = Gerenciar chips de competidores
+Heat = Aquecer
+Hela banan = Percurso inteiro
+Hemsida = Página inicial
+Hindra att deltagare från samma klubb startar på angränsande tider = Impedir que competidores do mesmo clube comecem em horários de início adjacentes.
+Hittar inte hjälpfilen, X = Não foi possível encontrar a documentação, X
+Hittar inte klass X = Não é possível X não encontrado
+Hjälp = Ajuda
+Hoppar över stafettklass: X = Pular categoria de revezamento: X
+Huvudlista = Lista principal
+Hyravgift = Aluguel de chip
+Hyrbricka = Chip contratado
+Hyrbricksrapport = Relatório com chips contratados
+Hyrbricksrapport - %s = Chips contratados - %s
+Hyrd = Contratado
+Hämta (efter)anmälningar från Eventor = Buscar entradas (atrasadas) do Eventor
+Hämta data från Eventor = Obter dados do Eventor
+Hämta efteranmälningar = Obter entradas atrasadas
+Hämta inställningar från föregående lottning = Buscar configurações da sessão anterior
+Hämta löpardatabasen = Buscar Banco de Dados de Competidores
+Hämta stämplingar m.m. från nätet = Buscar picotes etc. na internet.
+Hämta svar om elektroniska fakturor = Obtenha dados sobre faturas aceitas
+Hämta tävlingsdata = Buscar dados da competição
+Hämta tävlingsdata för X = Buscar dados da competição para X
+Hämtar anmälda = Obtendo entradas
+Hämtar information om = Coletando informações sobre
+Hämtar klasser = Buscando categorias
+Hämtar klubbar = Buscando clubes
+Hämtar löpardatabasen = Buscando banco de dados de competidores
+Hämtar tävling = Buscando competição
+Händelser = Eventos
+Händelser - tidslinje = Eventos - Linha do tempo
+Håll ihop med = Mantenha as colunas fechadas
+Hög avgift = Taxa de atraso
+Höger = Certo
+IOF (xml) = IOF (xml)
+IOF Klubbdatabas, version 3.0 (xml) = Lista de Organizações IOF, versão 3.0 (xml)
+IOF Löpardatabas, version 3.0 (xml) = Lista de Competidores IOF, versão 3.0 (xml)
+IOF Resultat (xml) = Resultados IOF (xml)
+IOF Resultat, version 2.0.3 (xml) = Resultados IOF, versão 2.0.3 (xml)
+IOF Resultat, version 3.0 (xml) = Resultados IOF, versão 3.0 (xml)
+IOF Startlista (xml) = Lista de Partida IOF (xml)
+IOF Startlista, version 2.0.3 (xml) = Lista de Partida IOF, versão 2.0.3 (xml)
+IOF Startlista, version 3.0 (xml) = Lista de Partida IOF, versão 3.0 (xml)
+IP-adress eller namn på en MySQL-server = Endereço IP ou o nome de um servidor MySQL
+Id = Id
+Identifierar X unika inledningar på banorna = Identificadas X vagas únicas de cursos
+Ignorera startstämpling = Ignorar picote de partida
+Ignorerade X duplikat = Duplicatas X ignoradas
+Image = Imagem
+Importera = Importação
+Importera IOF (xml) = Importação IOF (xml)
+Importera anmälda = Importar Entradas
+Importera anmälningar = Importar Entradas
+Importera banor = Importar Percursos
+Importera banor/klasser = Importar Percursos e categorias
+Importera en tävling från fil = Importar competição do arquivo
+Importera fil = Importar arquivo
+Importera från OCAD = Importar do OCAD
+Importera från fil = Importar do arquivo
+Importera laguppställningar = Importar escalações de Equipes
+Importera löpardatabas = Importar Banco de Dados de Competidores
+Importera löpare = Importar Competidores
+Importera löpare och klubbar / distriktsregister = Importar Competidores e Clubes
+Importera stämplingar = Importar Picotes
+Importera tävling = Importar Competição
+Importera tävlingsdata = Importar Dados
+Importerar = Importando
+Importerar OCAD csv-fil = Importando OCAD CSV
+Importerar OE2003 csv-fil = Importando OE2003 CSV
+Importerar OS2003 csv-fil = Importando OS2003 CSV
+Importerar RAID patrull csv-fil = Importando dados de patrulha RAID
+Importerar anmälningar (IOF, xml) = Importando entradas (IOF, xml)
+Importerar banor (IOF, xml) = Importando percursos (IOF, xml)
+Importerar klasser (IOF, xml) = Importando categorias (IOF, xml)
+Importerar klubbar (IOF, xml) = Importando clubes (IOF, xml)
+Importerar lottningsinställningar = Importando configurações de desenho
+Importerar ranking = Importando ranking
+Importerar tävlingsdata (IOF, xml) = Importação de dados da competição (IOF, xml)
+Importerbara = Importável
+Importinställning = Configuração de importação
+Inconsistent qualification rule, X = Regra de qualificação inconsistente, X
+Index = Índice
+Index in X[index] = Índice em X[index]
+Individual Example = Exemplo Individual
+Individual result by finish time = Resultado Individual por hora de chegada
+Individual results in a club = Resultados individuais dentro de um clube
+Individuell = Individual
+Individuell resultatlista, alla lopp = Lista de resultados individuais, todas as corridas
+Individuell resultatlista, sammanställning av flera lopp = Resultados individuais, resumo
+Individuell resultatlista, visst lopp = Resultados individuais, corrida
+Individuell resultatlista, visst lopp (STOR) = Resultados individuais, corrida (GRANDE)
+Individuell startlista, visst lopp = Lista de partida individual, corrida
+Individuell tävling = Competição individual
+Individuella deltagare = Competição individual
+Individuella resultat = Resultado Individual
+Individuella slutresultat = Resultado Individual Final
+Individuella totalresultat = Resultado Individual Total
+Individuellt = Individual
+Individuellt, gafflat = Bifucardo Individual
+Info = Informação
+Infoga version: X = Mesclar versão: X
+Informationsserver = Servidor de Informações
+Inga = Nenhum
+Inga bommar registrerade = Nenhum erro de controle detectado
+Inga deltagare = Sem competidores
+Inga klasser tillåter direktanmälan. På sidan klasser kan du ändra denna egenskap. = Nenhuma categoria está marcada para permitir entrada rápida.\n\n Na página Categorias você pode alterar esta propriedade.
+Inga vakanser tillgängliga. Vakanser skapas vanligen vid lottning = Não há vagas disponíveis. As vagas geralmente são criadas ao desenhar as categorias
+Ingen = Nenhum
+Ingen / okänd = Nenhum / desconhecido
+Ingen bana = Sem Percurso
+Ingen deltagare matchar sökkriteriet = Nenhum competidor corresponde aos critérios de pesquisa
+Ingen deltagare vald = Nenhum competidor selecionado
+Ingen klass = Sem categoria
+Ingen klass vald = Nenhuma categoria selecionada
+Ingen löpare saknar bricka = Todos os competidores tem um chip
+Ingen matchar 'X' = Nenhuma correspondência para 'X'
+Ingen nummerlapp = Sem número peito
+Ingen parstart = Partida Individual
+Ingen reducerad avgift = Sem redução de taxa
+Ingen rogaining = Sem cross-country
+Ingen[competition] = Nenhum
+Inget filter = Sem filtro
+Inget nummer = Nenhum número
+Inkludera bana = Incluir percurso
+Inkludera bomanalys = Incluir análise de tempo perdido
+Inkludera individuellt resultat = Incluir resultado individual
+Inkludera information om flera lopp per löpare = Inclua informações sobre várias corridas para um único competidor.
+Inkludera resultat från tidigare etapper = Incluir resultados de todas as etapas
+Inkludera sträcktider = Incluir divisões
+Inkludera tempo = Incluir tempo
+Inkommande = Entrada
+Inläst bricka ställd i kö = O chip foi colocado na fila
+Inlästa brickor = Ler chip
+Inlästa stämplar = Ler picotes
+Inmatning av mellantider = Digite os horários de Rádio
+Inmatning online = Entrada Remota
+Input Results = Resultados de entrada
+Input Results - X = Resultados de entrada - X
+Inspekterar klasser = Inspeção de categorias
+Installera = Instalar
+Installerbara listor = Listas Instaláveis
+Inställningar = Configurações
+Inställningar MeOS = Configurações MeOS
+Inställningar startbevis = Imprimir Configurações do Certificado de Partida
+Inställningar sträcktidsutskrift = Imprimir configurações de tempos parciais
+Interaktiv inläsning = Leitura Interativa
+Intervall = Intervalo
+Intervall (sekunder). Lämna blankt för att uppdatera när tävlingsdata ändras = Intervalo (segundos). Deixe em branco para atualizar quando os dados da competição forem alterados.
+Intervallet måste anges på formen MM:SS = O intervalo deve ser especificado como MM:SS
+Invalid filter X = Filtro inválido X
+Invalid font X = Fonte inválida X
+Invalid operator X = Operador inválido X
+Italic = Itálico
+ItalicMediumPlus = Itálico, um pouco maior
+Ja = Sim
+Jag sköter lottning själv = Eu mesmo gerencio o desenho da lista de partida
+Jaktstart = Perseguição
+Justera blockvis = Ajuste em bloco
+Justera mot = Alinhar com
+Justera visningsinställningar = Ajustar as configurações de exibição
+Justering i sidled = Ajuste horizontal
+Jämna klasser (placering) = Fazer categorias iguais (resultado)
+Jämna klasser (ranking) = Fazer categorias iguais (ranking)
+Jämna klasser (tid) = Fazer categorias iguais (tempo)
+Kalkylblad/csv = Planilha/csv
+Kartor = Mapas
+Klart = Finalizado
+Klart. Antal importerade: X = Finalizado. Número de entradas importadas: X
+Klart. X deltagare importerade = Finalizado. X competidores importados
+Klart. X lag importerade = Finalizado. X equipes importadas
+Klart. X patruller importerade = Finalizado. X patrulhas importadas
+Klart. X värden tilldelade = Completo. X valores atribuídos.
+Klart: alla klasser lottade = Concluído: todas as categorias desenhadas
+Klart: inga klasser behövde lottas = Concluído: não é necessário desenhar categorias
+Klass = Categoria
+Klass %d = Categoria %d
+Klass / klasstyp = Categoria / Tipo
+Klass X = Categoria X
+Klass att slå ihop = Categoria para mesclar com
+Klass saknad = Categoria ausente
+Klassbyte = Mudar Categoria
+Klassen 'X' har jaktstart/växling på första sträckan = A categoria 'X' tem perseguição/mudança na primeira perna
+Klassen X är individuell = A categoria X é individual
+Klassen X är listad flera gånger = A categoria X está listado várias vezes
+Klassen använder banpool = A categoria tem um pool de percursos
+Klassen används och kan inte tas bort = A categoria está em uso e não pode ser removida
+Klassen lottas inte, startstämpling = Use apenas o picote de partida
+Klassen måste ha ett namn = A categoria deve ter um nome
+Klassen saknas = Falta categoria
+Klassen är full = A categoria está cheia
+Klassens bana = Categorias do percurso
+Klasser = Categorias
+Klasser (IOF, xml) = Categorias (IOF, xml)
+Klasser där nyanmälningar ska överföras = Categorias para onde serão transferidas novas inscrições
+Klasserna X och Y har samma externa id. Använd tabelläget för att ändra id = As categorias X e Y tem o mesmo id externo. Use o modo de tabela para corrigir o id
+Klassinställningar = Configurações de categoria
+Klassnamn = Nome da categoria
+Klasstyp = Tipo de categoria
+Klassval = Seleção de categoria
+Klassval för 'X' = Seleção de categoria para 'X'
+Klientnamn = Nome do cliente
+Klistra in = Colar
+Klistra in data från urklipp (X) = Colar da área de transferência (X)
+Klocktid: X = Relógio: X
+Klubb = Clube
+Klubb att ta bort = Clube para remover
+Klubb: X = Clube: X
+KlubbId = Id Clube
+Klubbar = Clubes
+Klubbar (IOF, xml) = Clubes (IOF, xml)
+Klubbar som inte svarat = Clubes que não responderam
+Klubbdatabasen = Banco de dados de Clube
+Klubblös = Sem clube
+Klubbresultat = Resultados do Clube
+Klubbresultatlista = Resultados do Clube
+Klubbresultatlista - %s = Resultados do Clube - %s
+Klubbstartlista = Lista de Partida do Clube
+Klubbstartlista - %s = Lista de Partida do Clube - %s
+Klungstart = Partida agrupada
+Knockout sammanställning = Suprimir resumo
+Knockout total = Suprimir resumo
+Knyt automatiskt efter inläsning = Atribuição automática na leitura
+Knyt bricka / deltagare = Atribuir chip ao competidor
+Knyt löpare till sträckan = Vincule um competidor na perna
+Knyt löparna till banor från en pool vid målgång = Vincule os competidores aos percursos na leitura
+Knyt redan anmälda deltagare till laget (identifiera genom namn och/eller bricka) = Agrupar competidores já existentes na equipe (identificados por nome e/ou número do chip)
+Kod = Código
+Kolumner = Colunas
+Kom ihåg listan = Lembre-se da Lista
+Kommentar / version = Comunicação / Versão
+Kommunikation = Comunicação
+Kommunikationen med en SI-enhet avbröts = Conexão perdida com a unidade SportIdent
+Kontant = Dinheiro
+Kontant betalning = Dinheiro
+Konto = Conta
+Kontroll = Controle
+Kontroll %s = Controle %s
+Kontroll X = Controle X
+Kontroll inför tävlingen = Verifique a competição
+Kontrollen används och kan inte tas bort = O controle está em uso e não pode ser removido
+Kontrollens ID-nummer = ID do Controle
+Kontroller = Controles
+Kontrollmappning = Mapeamento de Controle
+Kontrollnamn = Nome do controle
+Kontrollrapport - X = Relatório de Controle - X
+Koordinater (mm) för adressfält = Coordenadas (mm) para o campo de endereço
+Kopia (X) = Copiar (X)
+Kopia X = Copiar X
+Kopiera = Copiar
+Kopiera länken till urklipp = Copiar link para a área de transferência
+Kopiera selektionen till urklipp (X) = Copiar seleção para a área de transferência (X)
+Kopiera till urklipp = Copiar para a área de transferência
+Koppla ifrån = Desconectar
+Koppla ner databas = Desconectar Banco de Dados
+Kopplar ifrån SportIdent på = Desconectando SportIdent em
+Kortast teoretiska startdjup utan krockar är X minuter = Partida com a menor profundidade teórica sem conflitos e de X minutos
+Kortnamn = Nome curto
+Kunde inte ansluta till Eventor = Não foi possível conectar ao Eventor
+Kunde inte ladda X\n\n(Y) = Não foi possível carregar X\n\n(Y)
+Kunde inte ladda upp löpardatabasen (X) = Não foi possível carregar o banco de dados (X)
+Kunde inte ladda upp tävlingen (X) = Falha ao carregar a competição (X)
+Kunde inte öppna databasen (X) = Não foi possível carregar o banco de dados (X)
+Kunde inte öppna tävlingen = Não foi possível abrir a competição
+Kval/final-schema = Qualificação/Esquema final
+Kvalschema = Esquema de Qualificação
+Kvar-i-skogen = Competidores na Floresta
+Kvinna = Mulher
+Kvinnor = Mulheres
+Källa = Fonte
+Källkatalog = Pasta de origem
+Kön = Gênero
+Kör kontroll inför tävlingen = Executar verificação da Competição
+Ladda upp öppnad tävling på server = Carregar Competição para o Servidor
+Lag = Equipe
+Lag %d = Equipe %d
+Lag + sträcka = Equipe + perna
+Lag och stafett = Equipe e revezamento
+Lag utan nummerlapp: X = Equipe sem número de peito: X
+Lag(flera) = Equipes
+Laget 'X' saknar klass = A equipe 'X' não tem categoria
+Laget hittades inte = Equipe não encontrada
+Lagmedlem = Membro da Equipe
+Lagnamn = Nome da Equipe
+Lagra inställningar = Armazenar configurações
+Lagrade säkerhetskopior = Backups armazenados
+Laguppställning = Escalação da equipe
+Laguppställningen hade fel, som har rättats = A escalação da equipe teve erros, que foram corrigidos
+Lagändringblankett = Formulário de mudança de equipe
+Land = País
+LargeFont = Texto grande
+Latest Results = Últimos Resultados
+Latitud = Latitude
+Leg X = Perna X
+Leg X: Do not modify = Perna X: Não modifique
+Leg X: Use Y = Perna X: Use Y
+Leg number in team, zero indexed = Número da perna na equipe, zero indexado
+Legs = Pernas
+Length of course = Distância do percurso
+LineBreak = Quebra de linha
+List Error: X = Erro de lista: X
+List definition = Definição de lista
+Lista = Lista
+Lista av typ 'X' = Lista do tipo 'X'
+Lista med mellantider = Lista com tempos parciais
+Lista med sträcktider = Lista com tempos parciais
+Listan kan inte visas = Não é possível mostrar a lista
+Listan togs bort från tävlingen = A lista foi removida da competição
+Listegenskaper = Propriedades da Lista
+Listnamn = Nome da Lista
+Listor = Listas
+Listor i tävlingen = Listas na Competição
+Listor och sammanställningar = Listas e resumos
+Listparameter = Parâmetro da lista
+Listpost = Entrada da lista
+Listredigerare = Editor da lista
+Listredigerare – X = Editor da lista – X
+Listrubrik = Cabeçalho da Lista
+Listtyp = Tipo de lista
+Listval = Escolha da lista
+Liveresultat = Resultado ao vivo
+Liveresultat, deltagare = Resultado individual ao vivo
+Liveresultat, radiotider = Resultado ao vivo com tempos de rádio
+Ljud = Som
+Ljudfiler, baskatalog = Arquivo de som, pasta base
+Ljudval = Seleção de som
+Lokalt = Localmente
+Long = Longo
+Longitud = Longitude
+Lopp %d = Corrida %d
+Lopp %s = Corrida %s
+Lopp X = Corrida X
+Lopp-id = Corrida Id
+Lotta = Desenhar
+Lotta / starttider = Desenhar / Gerenciar Horários de Partida
+Lotta flera klasser = Desenhar horários de partida para várias categorias
+Lotta klassen = Desenhar Categorias
+Lotta klassen X = Desenhar a Categoria 'X'
+Lotta klasser med banan X = Desenhar categorias com percurso 'X'
+Lotta klasser med samma bana gemensamt = Desenhe juntas as categorias com o mesmo percurso
+Lotta löpare som saknar starttid = Desenhe competidores sem horário de partida
+Lotta med startgrupper = Desenhe grupos com horário de partida
+Lotta om hela klassen = Redesenhar categoria
+Lotta starttider = Sorteio Horário de Partida
+Lottad = Desenhado
+Lottad startlista = Lista de Partida desenhada
+Lottar efteranmälda = Desenhando entradas tardias
+Lottar: X = Desenho Lista de Partida: X
+Lottat = Desenhado
+Lottning = Desenhar aleatoriamente
+Low = Baixo
+Lyssna = Ouvir
+Lyssnar på X = Ouvindo X
+Lägg till = Adicionar
+Lägg till alla = Adicionar tudo
+Lägg till bild = Adicionar imagem
+Lägg till en ny rad i tabellen (X) = Adicionar linha a tabela (X)
+Lägg till klasser = Adicionar / Atualizar categorias
+Lägg till ny = Adicionar Novo
+Lägg till ny etapp = Adicionar Nova etapa
+Lägg till rad = Adicionar Linha
+Lägg till stämpling = Adicionar Picote
+Lägger till klubbar = Adicionando Clubes
+Lägger till löpare = Adicionando Competidores
+Längd = Comprimento
+Längd (m) = Comprimento (m)
+Längsta svarstid: X ms = Maior tempo de resposta: X ms
+Längsta tid i sekunder att vänta med utskrift = Maior tempo de resposta em segundos para aguardar a impressão
+Länk till resultatlistan = Link para Resultados
+Länk till startlistan = Link para a Lista de Partida
+Läs brickor = Ler Chip
+Läser klubbar = Leitura de clubes
+Läser löpare = Leitura de competidores
+Långt namn = Nome completo
+Lås funktion = Função de Bloqueio
+Lås gafflingar = Bloquear Bifurcações
+Lås startlista = Bloquear Lista de Partida
+Lås upp = Desbloquear
+Låst gaffling = Bifurcação bloqueada
+Låt de bästa start först = Deixe o melhor classificado começar primeiro
+Låt klassen ha mer än en bana eller sträcka = Deixe a categoria ter mais de uma perna ou percurso.
+Löpande = Consecutivo
+Löpande information om viktiga händelser i tävlingen = Receba notificações de eventos da competição
+Löparbricka %d = Chip %d
+Löpardatabasen = Banco de Dados Competidor
+Löpare = Competidor
+Löpare per klass = Competidor por categoria
+Löpare saknar klass eller bana = Competidor sem categoria ou percurso
+Löpare saknas = Sem competidor
+Löpare som förekommer i mer än ett lag = Competidores existentes em mais de uma equipe
+Löpare utan SI-bricka: %d = Competidor sem chip: %d
+Löpare utan bana: %d = Competidor sem percurso: %d
+Löpare utan klass: %d = Competidor sem categoria: %d
+Löpare utan klubb: %d = Competidor sem clube: %d
+Löpare utan starttid: %d = Competidores sem horário de partida: %d
+Löpare, Ej Start, med registrering (kvar-i-skogen!?) = Status DNS para competidores com registro (Em Floresta!?)
+Löpare, Status Okänd, med registrering (kvar-i-skogen) = Status Desconhecido, para competidores com registro (Em floresta)
+Löpare, Status Okänd, som saknar registrering = Status Desconhecido, para competidores com picote ausente
+Löpare: = Competidores:
+Löpare: X, kontroll: Y, kl Z = Competidor: X, controle: Y, tempo: Z
+Löparen hittades inte = Competidor não encontrado
+Löptid = Tempo de corrida
+Lösenord = Senha
+Man = Homem
+Manual point reductions and adjustments = Ajuste manual e redução de pontos
+Manual time penalties and adjustments = Ajuste manual de penalidade de tempo
+Manuell = Manual
+Manuell inmatning = Entrada Manual
+Manuell lottning = Desenhar Manualmente
+Manuella avgifter = Taxas manuais
+Manuellt gjorda justeringar = Ajustes feitos manualmente
+Mapp = Pasta
+Mappa rootadressen (http:///localhost:port/) till funktion = Mapear endereço (http:///localhost:port/) para funcionar
+Mappnamnet får inte vara tomt = O nome da pasta não pode estar vazio
+Marginal = Margem
+Markera 'X' för att hantera deltagarna en och en = Marque 'X' para manipular os competidores um por um
+Markera allt (X) = Selecionar tudo (X)
+Markera för att förhindra oavsiktlig ändring av gafflingsnycklar = Verificação para evitar a alteração não intencional das chaves de bifurcação
+Markera inget (X) = Selecione nenhum (X)
+Markera kolumn = Selecione coluna
+Mata in första nummerlappsnummer, eller blankt för att ta bort nummerlappar = Insira o primeiro número de peito ou deixe em branco para remover os números de peito
+Mata in radiotider manuellt = Insira manualmente os horários de rádio
+Matched control ids (-1 for unmatched) for each team member = IDS de controles correspondentes (-1 para único) para cada membro da equipe
+Max antal brickor per sida = Número máximo de chips por página
+Max antal gaffllingsvarianter att skapa = Número máximo de bifurcações a serem criadas
+Max antal gemensamma kontroller = Número máximo de controles comuns
+Max parallellt startande = Número máximo de partidas paralelas
+Max. vakanser (per klass) = Número máximo de vagas (por categoria)
+Maxbom = Erro máximo
+Maximal tid efter ledaren för att delta i jaktstart = Tempo máximo atrás do líder para participar da perseguição.
+Maximum allowed running time = Tempo máximo permitido para a competição
+Maxtid = OMT
+Maxtid efter = Tempo máximo atrasado
+MeOS = MeOS
+MeOS Features = Recursos MeOS
+MeOS Funktioner = Recursos MeOS
+MeOS Informationsserver REST-API = Informação REST-API servidor MeOS
+MeOS Three Days Race X = MeOS Competição de 3 dias X
+MeOS Timing = Sincronização MeOS
+MeOS lokala datakatalog är = A pasta de dados local do MeOS é
+MeOS utvecklinsstöd = Suporte de Desenvolvimento MeOS
+MeOS – Funktioner = Recursos - MeOS
+MeOS – Resultatkiosk = Quioes que Resultado - MeOS
+MeOS-data = Dados-MeOS
+Med anmälningsavgift (lagets klubb) = Com taxa de inscrição (para a equipe/clube)
+Med avkortning = Com encurtamento
+Med direktanmälan = Com entrada direta
+Med km-tid = Incluir tempo (min/km)
+Med resultat = Com resultados
+Med stafettklasser = Com revezamento
+Med sträcktidsanalys = Com análise parcial
+Medianbom = Mediana de erro
+Medium = Médio
+MediumFont = Texto médio
+MediumPlus = Texto um pouco maior
+Medlöpare = Co-competidor
+Mellan X och Y = Entre X e Y
+Mellantider visas för namngivna kontroller = Tempos intermediários são mostrados para controles nomeados
+Metod = Método
+Min. vakanser (per klass) = Min. vagas (por categoria)
+Minitid = Min. tempo
+Minst MySQL X krävs. Du använder version Y = O MeOS precisa do MySQL X ou posterior. Você está usando a versão Y
+Minsta blockbredd = Largura mínima
+Minsta intabbning = Menor recuo	
+Minsta intervall i klass = Menor intervalo da categoria
+Minsta startintervall = Menor intervalo de partida
+Minsta sträcktid = Menor tempo da perna
+Minutstartlista = Lista de partida Tempo
+Misslyckades med att ladda upp onlineresultat = Falha ao carregar resultados online
+Motion = Exercício
+Multipel = Múltiplo
+MySQL Server / IP-adress = Endereço IP / Servidor MySQL
+Män = Homens
+Mål = Chegada
+Målenhet = Controle Chegada
+Målfil = Destino do arquivo
+Målstämpling saknas = Picote de chegada ausente
+Målstämpling tillåts inte (X) = Picote de chegada não permitido (X)
+Måltid = Tempo de chegada
+Måltid saknas = Tempo de chegada faltando
+Måltid: X = Tempo final: X
+N.N. = X
+Name of result module = Nome do módulo de resultado
+Namn = Nome
+Namn och tidpunkt = Nome e tempo
+Namnet kan inte vara tomt = O nome não pode estar vazio
+Narrow Results = Limitar Lista de Resultado
+Nationalitet = Nacionalidade
+Nationality = Nacionalidade
+Nej = Não
+New Result Module = Novo Módulo de Resultado
+New Set of Result Rules = Novo conjunto de regras de resultados
+Nollställ = Livre
+Nollställ avgifter = Redefinir taxas
+Nollställ databaser = Limpar banco de dados
+Nollställ minnet; markera alla brickor som icke avbockade = Limpar memória; apagar todas as marcações dos chips
+Nollställde avgift för X deltagare = Taxa liberada para X competidor(es)
+Nolltid = Tempo Zero
+None = Nenhum
+Normal = Normal
+NormalFont = Texto Normal
+Normalavgift = Taxa Normal
+Not implemented = Não implementado
+Not yet implemented = Ainda não implementado
+Nr = Número
+NumEntries = Número de entradas
+NumStarts = Número de partidas
+Number of shortenings = Número de encurtamentos
+Nummerlapp = Número peito
+Nummerlapp, SI eller Namn = Número peito, número chip, ou nome
+Nummerlapp, lopp-id eller namn = Número peito, id competição, ou nome
+Nummerlappar = Número Peito
+Nummerlappar i X = Número peito para X
+Nummerlappshantering = Gerenciar número peito
+Nuvarande innehavare: X = Proprietário atual: X
+Ny bana = Novo Percurso
+Ny deltagare = Novo Competidor
+Ny klass = Nova Categoria
+Ny klubb = Novo Clube
+Ny kontroll = Novo Controle
+Ny ledare i klassen = Novo líder de categoria
+Ny lista = Nova Lista
+Ny startgrupp = Novo grupo de partida
+Ny tävling = Nova Competição
+Nyckel för Eventor = Chave Eventor
+Nytt fönster = Nova Janela
+Nytt lag = Nova Equipe
+Nästa = Próximo
+Nästa etapp = Próxima Etapa
+Nästa försök = Próxima tentativa
+OE Semikolonseparerad (csv) = OE Separado por vírgula (csv)
+OK = OK
+OL-Skytte med tidstillägg = Orientação/Sprint com Punição de Tempo
+OL-Skytte stafettresultat = Orientação/Sprint com revezamento
+OL-Skytte utan tidstillägg = Orientação/Sprint sem Punição de Tempo
+Oberoende = Independente
+Ogiltig banfil. Kontroll förväntad på position X, men hittade 'Y' = Arquivo de percurso inválido. Esperada um número de controle com posição X, mas encontrou 'Y'
+Ogiltig destination X = Destino inválido X
+Ogiltig funktion = Função inválida
+Ogiltig föregående/efterföljande etapp = Etapa anterior/próximo inválida
+Ogiltig första starttid. Måste vara efter nolltid = Primeira hora de partida inválida. Deve ser depois do tempo zero
+Ogiltig kontrollkod = Código de controle inválido
+Ogiltig omstartstid = Hora de reinício inválida
+Ogiltig repdragningstid = Hora delimitada inválida
+Ogiltig starttid X = Horário de partida inválido X
+Ogiltig starttid i 'X' på sträcka Y = Horário de partida inválido para 'X' na perna Y
+Ogiltig starttid: X = Horário de partida inválido: X
+Ogiltig storlek på seedningsgrupper X = Tamanho inválido na semeadura dos grupos: X
+Ogiltig tid = Hora inválida
+Ogiltigt antal sekunder: X = Número inválido de segundos: X
+Ogiltigt basintervall = Intervalo base inválido
+Ogiltigt bricknummer = Número de chip inválido
+Ogiltigt bricknummer X = Número de chip inválido X
+Ogiltigt filformat = Formato de arquivo inválido.
+Ogiltigt lag på rad X = Equipe inválida na linha X
+Ogiltigt maximalt intervall = Intervalo máximo inválido
+Ogiltigt minimalt intervall = Intervalo mais curto inválido
+Ogiltigt startintervall X = Intervalo de partida inválido X
+Okänd = Desconhecido
+Okänd bricka = Chip desconhecido
+Okänd funktion = Modo desconhecido
+Okänd klass = Categoria desconhecida
+Okänd klass på rad X = Categoria desconhecida na linha X
+Okänd klubb med id X = Clube desconhecido com id X
+Om MeOS = Sobre MeOS
+Om MeOS – ett Mycket Enkelt OrienteringsSystem = Sobre MeOS – Um Sistema Eletrônico de Orientação Muito Fácil
+Om du vill kan du namnge automaten = Você pode dar um nome ao serviço
+Omstart = Reiniciar
+Omstart i stafettklasser = Reiniciar revezamento
+Omstartstid = Horário de reiniciar	
+Omvänd jaktstart = Perseguição invertida
+Online Input Error X = Erro de entrada remota X
+Online Results Error X = Erro de Resultados Online X
+Onlineinput = Entrada remota
+Onlineresultat = Resultados Online
+Onlineservern svarade felaktigt = O servidor remoto deu um resposta inesperada (Configuração incorreta?)
+Onlineservern svarade: Felaktigt lösenord = Resposta do servidor remoto: Senha incorreta
+Onlineservern svarade: Felaktigt tävlings-id = Resposta do servidor remoto: ID da competição errado
+Onlineservern svarade: Serverfel = Resposta do servidor remoto: Erro de Servidor
+Onlineservern svarade: ZIP stöds ej = Resposta do servidor remoto: ZIP não suportado.
+Oordnade parallella = Paralelo não ordenado
+Oordnade parallella sträckor = Pernas paralelas fora de ordem
+Oparad = Não Pareado
+Open = Abrir
+Open X = Abrir X
+Open a Copy = Abrir como cópia
+Operationen misslyckades = Operação sem sucesso
+Operationen stöds ej = Operação não suportada
+Optimerar startfördelning = Otimizando a distribuição do horário de partida
+Ordinarie anmälningsdatum = Última data de entrada
+Ordinarie avgift = Taxa Normal
+Ordnat = Ordenado
+Organisation = Organização
+Organisatör = Organizador
+Oväntad kontroll 'X' i bana Y = Controle inesperado 'X' no percurso Y
+PDF = PDF
+Packa stora filer (zip) = Compactar arquivos grandes (zip)
+Packar upp löpardatabas = Expandindo banco de dados de competidor
+Pages with columns = Páginas com colunas
+Pages with columns, no header = Páginas com colunas, sem cabeçalho
+Par- eller singelklass = Patrulha ou categoria única
+Para ihop = Parear
+Para ihop bricka X med en deltagare = Parear chip X com o competidor
+Parallell = Paralelo
+Parvis (två och två) = Emparelhar (dois por dois)
+Patrol Team Rogaining = Equipe Patrulha Cross-Country
+PatrolClubNameNames = Clube(s) do competidor (ou patrulha)
+PatrolNameNames = Nome(s) do(s) competidor(es) (ou patrulha)
+Patrols = Patrulhas
+Patrull = Patrulha
+Patrull, 1 SI-pinne = Patrulha, Um chip
+Patrull, 2 SI-pinnar = Patrulha, dois chips
+Patrullresultat (STOR) = Resultados da Patrulha (GRANDE)
+Personer = Pessoas
+Plac. = Colocação
+Plac. E[stageno] = Pos. S
+Place on course leg = Colocação na perna do percurso
+Placering = Colocação
+Placering in = Colocar em
+Plats = Colocação
+Point calculation for runner = Cálculo de pontos para competidor
+Point calculation for team = Cálculo de pontos para equipe
+Points as computed by your point method = Pontos calculados pelo seu método de ponto
+Port = Porta
+Port för TCP = Porta TCP/IP
+Portable Document Format (PDF) = Formato de arquivo (PDF)
+Postadress = Endereço Postal
+Postkod = ZIP
+Poäng = Pontos
+Poäng E[stageno] = Pontos S
+Poäng in = Pontos em
+Poängavdrag = Redução de Pontos
+Poängavdrag (per minut) = Redução de Pontos (por minuto)
+Poängavdrag per påbörjad minut = Redução de pontos para cada minuto iniciado
+Poänggräns = Limite de pontos
+Poängjustering = Ajuste de ponto
+Poängreduktion = Redução
+Prel. bomtid = Prel. tempo perdido
+Prel. placering = Prel. colocação
+Prepare start lists = Preparar lista de partida
+Press Enter to continue = Pressione <Enter> para continuar
+Print card data = Imprimir dados do chip
+Printing failed (X: Y) Z = A impressão falhou (X: Y) Z
+Prioritering = Priorização
+Prisutdelningslista = Lista da cerimônia de premiação
+Programinställningar = Configurações do Programa
+Programmera stationen utan AUTOSEND = Programe a unidade com AUTO ENVIO desligado
+Prolog + jaktstart = Preliminar + perseguição
+Prologue + Pursuit = Preliminar + Perseguição
+Publicera resultat = Publicar Resultados
+Publicera resultat direkt på nätet = Publicar resultados diretamente na internet
+Publicera resultat och sträcktider på Eventor och WinSplits online = Publicar resultados e tempos parciais online no Eventor e WinSplits
+Publicera startlista = Publicar lista de partida
+Publicera startlistan på Eventor = Publicar lista de partida no Eventor
+Publicerar resultat = Publicando resultados
+Publicerar startlistan = Publicando lista de partida
+Punch codes for each team member = Códigos dos controles para cada membro da equipe
+Punch times for each team member = Tempos dos picotes para cada membro da equipe
+PunchAbsTime = Picote, tempo real
+PunchControlCode = Código controle
+PunchControlNumber = Código picote
+PunchControlPlace = Colocação, controle da perna
+PunchControlPlaceAcc = Colocação, total do controle
+PunchLostTime = Tempo perdido no controle
+PunchName = Picote, nome do controle
+PunchNamedSplit = Tempo desde o último controle nomeado
+PunchNamedTime = Tempo parcial nomeado
+PunchSplitTime = Tempo desde o último controle (tempo parcial)
+PunchTime = Tempo picote
+PunchTimeSinceLast = Tempo entre controles
+PunchTotalTime = Tempo de controle
+PunchTotalTimeAfter = Tempo atrasado no controle
+Punches = Picotes
+På banan = Em andamento
+Rad X är ogiltig = A linha X é inválida
+Rader = Linhas
+Rader markerade med (*) kommer från en lista i tävlingen = Linhas com (*) são originárias de uma lista de competição
+Radera = Delete
+Radera alla klubbar = Delete todos os clubes
+Radera alla klubbar och ta bort klubbtillhörighet = Remova todos os clubes e limpe as associações dos clubes
+Radera listan från aktuell tävling = Excluir lista desta competição
+Radera permanent = Excluir Permanentemente
+Radera starttider = Excluir horários de partida
+Radera tävlingen = Remover Competição
+Radera vakanser = Excluir vagas
+Radio = Radio
+Radio tillåts inte (X) = Controles de rádio não permitidos	 (X)
+Radiotider, kontroll = Tempos de rádio, controle
+Ranking = Ranking
+Ranking (IOF, xml, csv) = Ranking (IOF, xml, csv)
+Rapport = Relatório
+Rapport inför = Relatório para
+Rapporter = Relatórios
+Rapportläge = Modo Relatório
+Red. avg. efteranm = Red. taxa de atraso
+Red. avgift = Taxa reduzida
+Redigera = Editar
+Redigera deltagaren = Editar competidor
+Redigera lista = Edição de Lista
+Redigera listpost = Editar lista de entrada
+Redigera sträcklängder = Editar comprimentos das pernas
+Redigera sträcklängder för X = Editar comprimentos das pernas para 'X'
+Reducerad avg = Taxa reduzida
+Reducerad avgift = Taxa reduzida
+Reducerad avgift för = Taxa reduzida para
+Reduktionsmetod = Método de redução
+Referens = Referência
+Region = Região
+Registrera hyrbrickor = Registra aluguel de chips
+Relation till föregående = Relação ao anterior
+Relativ skalfaktor för typsnittets storlek i procent = Fator de escala relativo para tipo de letra (percentual)
+Relay Example = Exemplo Revezamento
+Relays = Revezamentos
+Rep = Pista
+Reparera vald tävling = Reparar Competição Selecionada
+Reparerar tävlingsdatabasen = Reparando banco de dados da competição
+Repdragningstid = Tempo da pista
+Repdragningstiden måste ligga före omstartstiden = O horário da pista deve ser antes do horário de reinício 
+Replace[battery] = Substituir
+Reserverade = Reservado
+Result Calculation = Cálculo de Resultado
+Result Module – X = Módulo de Resultado – X
+Result Modules = Módulos de Resultados
+Result at a control = Resultado em um controle
+Result module = Módulo de Resultados
+Result module identifier = Identificador do módulo de resultado
+Result score calculation for runner = Cálculo da pontuação do resultado para o competidor
+Result score calculation for team = Cálculo da pontuação do resultado para a equipe
+ResultDescription = Nome do tipo de resultado
+ResultModuleNumber = Módulo de Resultado: Número
+ResultModuleNumberTeam = Módulo de Resultado: Número (para Equipe)
+ResultModuleTime = Módulo de Resultado: Tempo
+ResultModuleTimeTeam = Módulo de Resultado: Tempo (para Equipe)
+Resultat = Resultado
+Resultat && sträcktider = Resultados e Parciais
+Resultat (STOR) = Resultados (GRANDE)
+Resultat - %s = Resultados - %s
+Resultat - X = Resultados - X
+Resultat banvis per klass = Resultado percurso por categoria
+Resultat efter klass och bana - X = Resultado por categoria e percurso - X
+Resultat efter sträcka X = Resultados depois da perna X
+Resultat efter sträckan = Resultados depois da perna
+Resultat från tidigare etapper = Resultados das Etapas Anteriores	
+Resultat för ett visst lopp = Resultados para uma determinada competição
+Resultat lopp X - Y = Resultado competição X - Y
+Resultat online = Resultados Online
+Resultat per bana = Resultado por percurso
+Resultat per bana - X = Resultado por percurso - X
+Resultat vid målstämpling = Resultado no picote de chegada
+Resultat, generell = Resultados, geral
+Resultat, individuell = Resultados, individual
+Resultat, patrull = Resultados, patrulha
+Resultatkiosk = Quiosque de Resultado
+Resultatlista - %s = Resultados - %s
+Resultatlista – inställningar = Resultados – Configurações
+Resultatlistor = Resultados
+Resultatmodulen används i X = O Módulo de Resultado está sendo usado em X
+Resultatuträkning = Cálculo do resultado
+Resultatutskrift = Imprimir Resultados
+Resultatutskrift / export = Imprimir / Exportar Resultados
+Rogaining = Cross-Country
+Rogaining points before automatic reduction = Pontos cross-country antes da redução automática
+Rogaining points for each team member = Pontos de cross-country para cada membro da equipe
+Rogaining results for a patrol = Resultados cross-country para patrulha de dois ou mais competidores.
+Rogaining results for a team, where each team member collects points individually = Resultados cross-country para uma equipe, onde cada competidor da equipe acumula pontos individualmente
+Rogaining, individuell = Cross-country, individual
+Rogaining-poäng = Pontos de cross-country
+RogainingPunch = Picotes, cross-country
+Rogainingresultat - %s = Resultados cross-country - %s
+Rubrik = Cabeçalho
+Rulla upp och ner automatiskt = Role para cima e para baixo automaticamente
+Runner = Competidor
+Runner check time = Tempo de verificação do competidor
+Runner's card, matched control ids (-1 for unmatched punches) = Chip do competidor, IDs de controle correspondentes (-1 para picotes não correspondentes)
+Runner's card, punch codes = Chip do competidor, código dos picotes
+Runner's card, punch times = Chip do competidor, tempo do picotes
+Runner's course = Percurso do competidor
+Runner's method output numbers = Método de saída de número do competidor
+Runner's method output times = Método de saída de tempo do competidor
+Runner's split times = Tempos parciais do competidor
+Runner's total running time to control = Tempo total de competição do competidor por controle
+Runner/team earlier stage places = Colocações das etapas anteriores Competidor/Equipe
+Runner/team earlier stage points = Pontos das etapas anteriores Competidor/Equipe
+Runner/team earlier stage running times = Tempo de competição das etapas anteriores Competidor/Equipe
+Runner/team earlier stage statuses = Status das etapas anteriores Competidor/Equipe
+Runner/team fee = Taxa Competidor/Equipe
+Runner/team finish time = Tempo de chegada Competidor/Equipe
+Runner/team input place = Colocação de entrada Competidor/Equipe
+Runner/team input points = Pontos de entrada Competidor/Equipe
+Runner/team input running time = Tempo de competição de entrada do Competidor/Equipe
+Runner/team input status = Status de entrada Competidor/Equipe
+Runner/team place = Colocação Competidor/Equipe
+Runner/team rogaining overtime = Tempo extra cross-country Competidor/Equipe
+Runner/team rogaining points = Pontos de cross-country Competidor/Equipe
+Runner/team rogaining points adjustment = Ajustes de pontos cross-country do Competidor/Equipe
+Runner/team running time = Tempo de competição Competidor/Equipe
+Runner/team start time = Hora de Partida Competidor/Equipe
+Runner/team status = Status Competidor/Equipe
+Runner/team time adjustment = Ajuste de tempo Competidor/Equipe
+Runner/team total place = Colocação Total Competidor/Equipe
+Runner/team total running time = Tempo Total de Competição Competidor/Equipe
+Runner/team total status = Status Total Competidor/Equipe
+RunnerAge = Idade do Competidor
+RunnerBib = Número peito do Competidor
+RunnerBirthDate = Data de nascimento
+RunnerBirthYear = Ano de nascimento do Competidor
+RunnerCard = Número chip
+RunnerCardVoltage = Voltagem do chip
+RunnerCheck = Checagem do tempo de picote
+RunnerClassCoursePlace = Posição no percurso dentro da categoria
+RunnerClassCourseTimeAfter = Tempo atrasado no percurso dentro da categoria
+RunnerClub = Clube do Competidor
+RunnerCompleteName = Nome Completo
+RunnerCourse = Percurso do competidor
+RunnerCoursePlace = Colocação do competidor no percurso
+RunnerEntryDate = Data de entrada do competidor
+RunnerEntryTime = Hora de entrada do competidor
+RunnerExpectedFee = Taxa esperada dos competidores
+RunnerFamilyName = Sobrenome
+RunnerFee = Taxa do competidor
+RunnerFinish = Tempo de chegada do competidor
+RunnerGeneralPlace = Colocação da equipe ou individual
+RunnerGeneralTimeAfter = Tempo atraso da equipe ou competidor individual
+RunnerGeneralTimeStatus = Tempo/status equipe ou competidor individual
+RunnerGivenName = Primeiro nome
+RunnerGlobal = Competidor (categorias juntas)
+RunnerGrossTime = Tempo do competidor antes do ajuste
+RunnerId = ID externo do competidor
+RunnerLeg = Competidor (perna específica)
+RunnerLegNumber = Número da perna agrupada por Competidor
+RunnerLegNumberAlpha = Número exato da perna do competidor
+RunnerName = Nome do competidor
+RunnerNationality = Nacionalidade do competidor
+RunnerPaid = Quantidade paga
+RunnerPayMethod = Meio de pagamento
+RunnerPhone = Telefone do competidor
+RunnerPlace = Colocação do competidor
+RunnerPlaceDiff = Diferença de colocação do competidor
+RunnerPointAdjustment = Ajuste de pontos do competidor
+RunnerRank = Ranking
+RunnerRogainingOvertime = Prorrogação do competidor (cross-country)
+RunnerRogainingPoint = Pontos cross-country
+RunnerRogainingPointGross = Cross-country pontos antes da redução
+RunnerRogainingPointTotal = Total de pontos do competidor
+RunnerRogainingReduction = Redução de pontos do competidor
+RunnerSex = Gênero do competidor
+RunnerStageNumber = Número da etapa (para resultado da etapa anterior)
+RunnerStagePlace = Colocação do competidor (na etapa)
+RunnerStagePoints = Pontos do competidor (na etapa)
+RunnerStageStatus = Status do competidor (na etapa)
+RunnerStageTime = Tempo do competidor (na etapa)
+RunnerStageTimeStatus = Tempo ou status do competidor (na etapa)
+RunnerStart = Hora de partida do competidor
+RunnerStartCond = Hora de partida do competidor (se individual)
+RunnerStartNo = Número da partida do competidor
+RunnerStartZero = Horário de partida relativo do competidor (tempo zero)
+RunnerTempTimeAfter = Tempo de atraso do competidor no controle selecionado
+RunnerTempTimeStatus = Tempo/status do competidor no controle selecionado
+RunnerTime = Tempo do competidor
+RunnerTimeAdjustment = Ajuste de tempo do competidor
+RunnerTimeAfter = Tempo atrasado do competidor
+RunnerTimeAfterDiff = Diferença de tempo entre o competidor
+RunnerTimeLost = Tempo perdido do competidor
+RunnerTimePerKM = Velocidade min/km (tempo)
+RunnerTimePlaceFixed = Tempo quando o competidor tem colocação definida
+RunnerTimeStatus = Tempo/status do competidor
+RunnerTotalPlace = Colocação total do competidor
+RunnerTotalTime = Tempo total do competidor
+RunnerTotalTimeAfter = Tempo de atraso total do competidor
+RunnerTotalTimeStatus = Tempo total / status do Competidor
+RunnerUMMasterPoint = Reunião de Uppsala, pontos principais
+Running time for each team member = Tempo de corrida para cada membro da equipe
+SI X inläst. Brickan tillhör Y som saknar klass = Chip X foi lido. O chip é de Y, que não tem categoria
+SI X inläst. Brickan är inte knuten till någon löpare (i skogen) = Chip X foi lido. O chip não está vinculado para um corredor (na floresta)
+SI X är redan inläst. Använd interaktiv inläsning om du vill läsa brickan igen = Chip X já foi lido. Use a leitura interativa para lê-lo novamente.
+SI X är redan inläst. Ska den läsas in igen? = Chip X já foi lido. Ler novamente?
+SI på = Chip ligado
+SI-dubbletter: %d = Chip duplicado: %d
+SOFT-avgift = Taxa SOFT
+SOFT-lottning = Método de desenho herdado padrão Sueco
+SRR Dongle = Dongle SRR
+Saknad starttid = Horário de Partida Ausente
+Saknat lag mellan X och Y = Falta equipe entre X e Y
+Samlade poäng = Pontos acumulados
+Samma = Mesmo
+Samma bastävling = Competição de mesma base
+Sammanfattning, uppdateradet poster = Resumo, entidades de dados atualizadas
+Sammanslagning fungerar om samma uppsättning banor/kontroller används = A mescla funcionará se o mesmo conjunto de percursos e controles for usado
+Sammanslagning klar = Mescla completa
+Sammanställning = Resumo
+Sammanställning, ekonomi = Resumo, finanças
+Sammanställning, klasser = Resumo, categorias
+Samtliga deltagare tilldelades resultat = Todos os competidores receberam um resultado
+Save = Salvar
+Save changes = Salvar alterações
+Save changes in rule code? = Salvar alterações no código de regras?
+Seedad lottning = Grupo de partida semeado
+Seedningsgrupper = Semeando grupos
+Seedningskälla = Semeando fonte
+Sekundär typ = Tipo secundário
+Selektionens storlek matchar inte urklippets storlek. Klistra in i alla fall? = O tamanho da seleção e da área de transferência não coincidem. Colar mesmo assim?
+Semikolonseparerad (csv) = Separado por vírgula (csv)
+Sen avgift = Taxa de atraso
+Sen red. avgift = Então red. Cobrar
+Senast sedd: X vid Y = Visto pela última vez: X em Y
+Server = Servidor
+Server startad på X = Servidor rodando na porta X
+Server version: X = Versão do servidor: X
+Server: [X] Y = Servidor: [X] Y
+Several MeOS Clients in a network = Vários clientes MeOS em uma rede
+Several races for a runner = Várias corridas para um corredor
+Several stages = Várias etapas
+Short = Curto
+Shortest time in class = Menor tempo na categoria
+Show forking = Mostrar bifurcação	
+Sidbrytning mellan klasser = Quebra de página
+Sidbrytning mellan klasser / klubbar = Quebra de página entre categorias / clubes
+Sidor per skärm = Páginas por tela
+Simulera inläsning av stämplar = Simular leitura
+Sist = Último
+Sista betalningsdatum = Pagamento devido
+Sista ordinarie anmälningsdatum = Última data de entrada normal
+Sista start (nu tilldelad) = Partida mais recente (atribuído agora)
+Sista start (nu tilldelad): X = Última partida (atribuído agora): X
+Sista sträckan = Última perna
+Ska X raderas från tävlingen? = Deseja remover da competição?
+Skalfaktor = Fator de scala
+Skapa = Criar
+Skapa anonyma lagmedlemmar = Nomear competidor anônimo para a Equipe
+Skapa en klass för varje bana = Crie uma categoria para cada percurso
+Skapa en ny tävling med data från Eventor = Crie uma nova competição com dados do Eventor
+Skapa en ny, tom, tävling = Crie uma nova competição vazia
+Skapa fakturor = Criar faturas
+Skapa generell lista = Criar Lista Geral
+Skapa listan = Criar Lista
+Skapa ny klass = Criar nova categoria
+Skapa tävlingen = Criar competição
+Skapad av = Criado por
+Skapade en bana för klassen %s med %d kontroller från brickdata (SI-%d) = Criou um percurso para a categoria %s com %d controles no chip %d.
+Skapade en lokal kopia av tävlingen = Criou uma cópia local da competição
+Skapade lokal säkerhetskopia (X) innan sammanslagning = Backup local criado (X) antes da mescla
+Skapar ny etapp = Criar novo estágio
+Skapar ny tävling = Criando nova competição
+Skapar saknad klass = Categoria ausente criada
+Skapar tävling = Criando competição
+Skattad avgift = Taxa tributável
+Skicka och ta emot snabb förhandsinformation om stämplingar och resultat = Envie e receba rapidamente informações avançadas sobre o resultado dos picotes de controle
+Skicka till webben = Enviar para web
+Skippar lottning = Ignorar ordem de partida desenhada
+Skript = Script
+Skript att köra efter export = Executar script após a exportação
+Skriv endast ut ändade sidor = Imprimir apenas páginas modificadas
+Skriv första bokstaven i klubbens namn och tryck pil-ner för att leta efter klubben = Digite as primeiras letras do nome do clube e pressione a seta para baixo para encontrar o clube.
+Skriv första starttid på formen HH:MM:SS = Escreve o primeiro horário de partida como HH:MM:SS
+Skriv ut = Imprimir
+Skriv ut alla = Imprimir tudo
+Skriv ut dem utan e-post = Imprimir todos os e-mails ausentes
+Skriv ut ej accepterade elektroniska = Imprimir todos não aceitos
+Skriv ut eller exportera listan automatiskt = Imprima ou exporte a lista automaticamente
+Skriv ut fakturan = Imprimir fatura
+Skriv ut listan = Imprimir a lista
+Skriv ut nu = Imprimir agora
+Skriv ut rapporten = Imprimir o relatório
+Skriv ut startbevis = Imprimir certificado de partida
+Skriv ut startbevis för deltagaren = Imprimir certificado de partida por competidor
+Skriv ut sträcktider = Imprimir parciais
+Skriv ut tabellen = Imprimir a tabela
+Skriv ut tabellen (X) = Imprimir a tabela (X)
+Skriv över existerande bricknummer? = Substituir o número do chip existente?
+Skrivare = Impressora
+Skrivarinställningar = Configurações da Impressora
+Skrivarinställningar för sträcktider = Configurações da Impressora
+Skrivarinställningar för sträcktider och startbevis = Configurações da impressora para tempos parciais e lista de partida
+Skriver sträcktider när tävlingsdata ändras = Escrevendo arquivo quando os dados da competição são alterados
+Skriver sträcktider om = Imprimindo em
+Slut = Fim
+Slutresultat = Resultado Final
+Sluttid = Tempo Final
+Slå ihop = Mesclar
+Slå ihop X = Mesclar com X
+Slå ihop klass: X = Mesclar categoria: X
+Slå ihop klass: X (denna klass behålls) = Mesclar categoria com X (Mantenha esta categoria)
+Slå ihop klasser = Mesclar categorias
+Slå ihop klubb = Mesclar Clubes
+Slå ihop med = Mesclar com
+Slå ihop med befintlig lista = Mesclar com lista existente
+Slå ihop text = Anexar texto (compartilhar coluna)
+Slå ihop text med föregående = Mesclar com o anterior
+Slå ihop tävlingar = Mesclar competições
+SmallFont = texto pequeno
+SmallItalic = Texto pequeno em itálico
+Snabbinställningar = Configurações rápidas
+SortLastNameOnly = Nome de família
+SortNameOnly = Nome
+Sortera fallande = Ordenar decrescente
+Sortera stigande = Ordenar crescente
+Sortering = Ordenação
+Sortering: %s, antal rader: %d = Classificação: %s, número de linhas: %d
+Source code = Código fonte
+Spara = Salvar
+Spara anmälningar = Salvar Entradas
+Spara den här listan som en favoritlista = Salvar esta lista como uma lista de favoritos
+Spara fil = Salvar arquivos
+Spara fönster- och speakerinställningar på datorn = Salvar janelas e configurações neste computador
+Spara för webben = Salvar documento web
+Spara i aktuell tävling = Salvar nesta Competição
+Spara inmatade tider i tävlingen utan att tilldela starttider = Salvar tempos e configurações para cada categoria para que você possa continuar trabalhando mais tarde
+Spara inställningar = Salvar configurações
+Spara laguppställningar = Salvar escalações de equipe
+Spara oparad bricka = Salvar chip não pareado
+Spara på disk = Salvar no disco
+Spara som = Salvar como
+Spara som PDF = Salvar como PDF
+Spara som fil = Salvar como Arquivo
+Spara starttider = Salvar tempo de partida
+Spara sträcktider till en fil för automatisk synkronisering med WinSplits = Salvar parciais em arquivos para sincronização automática com WinSplits
+Spara tid = Salvar tempo
+Sparade automater = Serviços salvos
+Sparade listval = Listar armazenadas
+Speaker = Locutor
+Speakerstöd = Módulo Locutor
+Spela upp ett ljud för att indikera resultatet av brickavläsningen = Toque um som para indicar a leitura do chip.
+SportIdent = SportIdent
+Språk = Linguagem
+Spänning = Voltagem
+Stad = Cidade
+Stafett = Revezamento
+Stafett (sammanställning) = Revezamento (Resumo)
+Stafett - sammanställning = Revezamento - Resumo
+Stafett - sträcka = Revezamento - Perna
+Stafett - total = Revezamento - Total
+Stafettklasser = Revezamento categorias
+Stafettresultat = Resultados Revezamento
+Stafettresultat, delsträckor = Resultados revezamento, pernas
+Stafettresultat, lag = Revezamento resultados, equipes
+Stafettresultat, sträcka = Revezamento resultado, perna
+Stafettresultat, sträcka (STOR) = Resultados do revezamento, perna (Grande)
+Standard = Padrão
+Start = Partida
+Start nr = Partida no.
+Start time for each team member = Horário de partida para cada membro da partida
+Start: X = Partida: X
+StartTime = Horário de partida, nome
+StartTimeClass = Horário de partida, categoria
+StartTimeForClass = Horário de partida comum, categoria
+StartTimeForClassRange = Intervalo de horário de partida da categoria 
+Starta = Partida
+Starta automaten = Iniciar serviço
+Starta en guide som hjälper dig göra klassinställningar = Iniciar um guia que o ajude a configurar as categorias
+Startade automater = Serviço iniciado
+Startande = Iniciando
+Startar SI på = Iniciando SI em
+Startbevis = Certificado partida
+Startbevis X = Certificado partida X
+Startblock = Bloco de partida
+Startblock: %d = Bloco de partida: %d
+Startenhet = Iniciar unidade
+Startgrupp = Grupo Inicial
+Startgrupp med id X tilldelad Y finns inte = O grupo incial com ID X definido para Y não existe
+Startgrupper = Iniciando grupos
+Startgrupperna X och Y överlappar = Os grupos iniciais X e Y estão sobrepostos
+Startintervall = Intervalo de partida
+Startintervall (min) = Intervalo de partida (min)
+Startintervallet får inte vara kortare än basintervallet = Um intervalo de partida não pode ser menor que o intervalo base
+Startlista = Lista de Partida
+Startlista %%s - sträcka %d = Lista de partida %%s - Perna %d
+Startlista - %s = Lista de partida - %s
+Startlista - X = Lista de partida - X
+Startlista ett visst lopp = Lista de Partida para uma corrida
+Startlista lopp X - Y = Lista de partida Corrida X - Y
+Startlista, banvis = Lista de partida, por percurso
+Startlista, individuell = Lista de partida, individual
+Startlista, patrull = Start list, patrulha
+Startlista, stafett (lag) = Lista de partida, revezamento (equipe)
+Startlista, stafett (sträcka) = Lista de partida, revezamento (perna)
+Startlistor = Lista de partida
+Startmetod = Método de partida
+Startnamn = Nome da partida
+Startnummer = Número da partida
+Startstämpling tillåts inte (X) = Picote inicial não permitido (X)
+Starttid = Horário de partida
+Starttid (HH:MM:SS) = Horário de partida (HH:MM:SS)
+Starttid: X = Hora de partida: X
+Starttiden är definerad genom klassen eller löparens startstämpling = A hora de partida é definida através da categoria ou através do picote inicial
+Starttiden är upptagen = O horário de partida não está disponível
+Starttyp = Tipo de partida
+Status = Status
+Status E[stageno] = Status S
+Status OK = Status OK
+Status as computed by your status method = Status calculado pelo método de status
+Status calculation for runner = Cálculo de status por competidor
+Status calculation for team = Cálculo de status por equipe
+Status code for a missing punch = Código de status para um picote ausente
+Status code for a time over the maximum = Código de status por um tempo acima do máximo
+Status code for a valid result = Código de status para um resultado válido
+Status code for an unknown result = Código de status para um resultado desconhecido
+Status code for cancelled entry = Código de status para entrada cancelada
+Status code for disqualification = Código de status para desqualificação
+Status code for no timing = Código do status sem tempo
+Status code for not competing = Código do status por não competir
+Status code for not finishing = Código do status por não terminar
+Status code for not starting = Código do status por não iniciar
+Status code for running out-of-competition = Código do status para correr fora da competição (OOC)
+Status for each team member = Status de cada membro da equipe
+Status in = Status da entrada
+Status inte OK (röd utgång) = Status Não OK (saída vermelha)
+Status matchar inte data i löparbrickan = O status não corresponde aos dados picotados no chip.
+Status matchar inte deltagarnas status = O status não corresponde ao status do competidor.
+Stigning = Elevação
+Stoppa automaten = Pare o serviço
+Stor = Grande
+Str. = Perna
+Str. %d = Perna %d
+Str. X = Perna X
+String = Texto
+Struken = Cancelado
+Struken med återbetalning = Cancelado, taxa reembolsada
+Struken utan återbetalning = Cancelado, sem reembolso
+Strukturerat exportformat = Formato de exportação estruturado
+Strukturerat webbdokument (html) = Documento web estruturado (html)
+Sträcka = Perna
+Sträcka %d = Perna %d
+Sträcka X = Perna X
+Sträcka att lotta = Perna para desenhar
+Sträckans banor = Percursos por perna
+Sträcktider = Tempo Parcial
+Sträcktider (WinSplits) = Tempos Parciais (WinSplits)
+Sträcktider / WinSplits = Tempos Parciais / WinSplits
+Sträcktider i kolumner (för standardpapper) = Tempos em colunas (para papel padrão)
+Sträcktider/WinSplits = Parciais/WinSplits
+Sträcktidsfil = Nome do arquivo
+Sträcktidslista = Lista de tempo parcial
+Sträcktidsutskrift = Imprimir parciais
+Sträcktidsutskrift[check] = Imprimir parciais automaticamente
+Sträcktilldelning, stafett = Atribuir perna, revezamento
+Sträcktyp = Tipo de perna
+Stämpelkod = Código do controle
+Stämpelkod(er) = Código(s) de picote
+Stämpelkoder = Códigos de picote
+Stämplar om = Picotando
+Stämpling = Picote
+Stämplingar = Picotes
+Stämplingar saknas: X = Faltam picotes: X
+Stämplingsautomat = Serviço de picote de controle
+Stämplingsintervall (MM:SS) = Intervalo de picote (MM:SS)
+Stämplingsintervall, rogaining-patrull = Intervalo de picote dentro de patrulha cross-country
+Stämplingstest = Teste de Picote
+Stämplingstest [!] = Teste de Picote [!]
+Stämplingstid = Tempo de picote
+Stäng = Fechar
+Stäng tävlingen = Competição Fechada
+Större = Maior
+Störst = Maior
+Största gruppen med samma inledning har X platser = O maior grupo com a mesma abertura de percurso tem X competidores
+Största intervall i klass = Maior intervalo da categoria
+SubCounter = Contador secundário
+SubSubCounter = Contador terciário
+Summera = Soma
+Support intermediate legs = Suporte específico perna de revezamento
+Support time from control = Tempo de suporte para controle
+Support time to control = Tempo de suporte para controle
+Symboler = Símbolos
+Synkronisera med Eventor = Sincronizar com o Eventor
+Säkerhetskopiera = Backup / Salvar como
+Säkerhetskopierar om = Fazendo backup em
+Säkerhetskopiering = Intervalo de Backup
+Sätt okända löpare utan registrering till <Ej Start> = Definir Status <DNS> para competidores sem registro
+Sätt som oparad = Desemparelhar
+Sätter reptid (X) och omstartstid (Y) för = Aplicando tempo de pista (X) e tempo de reinício (Y) para
+Sök = Procurar
+Sök (X) = Procurar (X)
+Sök deltagare = Encontrar Competidor
+Sök och starta automatiskt = Pesquisa automática e início
+Sök på namn, bricka eller startnummer = Pesquise um nome, chip ou número inicial
+Sök symbol = Pesquisar símbolo
+Söker efter SI-enheter = Procurando por unidade SportIdent
+TCP: Port %d, Nolltid: %s = TCP: Porta %d, Hora Zero: %s
+TRASIG( = Ruim(
+Ta bort = Remover
+Ta bort / slå ihop = Remover / Mesclar
+Ta bort eventuella avanmälda deltagare = Remova as entradas canceladas, se houver
+Ta bort listposten = Remover entrada da lista
+Ta bort markerad = Remover Selecionado
+Ta bort stämpling = Remover Picote
+Ta bort valda rader från tabellen (X) = Remova as linhas seleciondas da tabela (X)
+Tabell = Tabela
+Tabellverktyg = Ferramentas de tabela
+Tabelläge = Modo tabela
+Tar bort X = Removendo X
+Team = Equipe
+Team Rogaining = Equipe cross-country
+TeamBib = Número de peito da Equipe
+TeamClub = Equipes do clube
+TeamCourseName = Nome do percurso para equipe/perna
+TeamCourseNumber = Número do percurso para equipe/perna
+TeamFee = Taxa da equipe
+TeamGlobal = Taxa da equipe
+TeamGrossTime = Tempo da equipe antes do ajuste
+TeamLegName = Nome da perna
+TeamLegTimeAfter = Tempo de atraso da equipe na perna
+TeamLegTimeStatus = Tempo / status da equipe na perna
+TeamName = Nome da equipe
+TeamPlace = Posição da equipe após a perna
+TeamPlaceDiff = Diferença de posição da equipe (Estas etapas)
+TeamPointAdjustment = Ajuste de ponto da equipe
+TeamRogainingOvertime = Prorrogação da equipe (cross-country)
+TeamRogainingPoint = Pontos de cross-country da equipe
+TeamRogainingPointTotal = Total de pontos da equipe
+TeamRogainingReduction = Redução de pontos da equipe
+TeamRunner = Nome de membro da equipe
+TeamRunnerCard = Número do chip do membro da equipe
+TeamStart = Hora de início da equipe
+TeamStartCond = Hora de início da equipe (Se individual)
+TeamStartNo = Número inicial da equipe
+TeamStartZero = Horário de início relativo da equipe (tempo zero)
+TeamStatus = Status da equipe
+TeamTime = Tempo da equipe
+TeamTimeAdjustment = Ajuste de tempo da equipe
+TeamTimeAfter = Tempo de atraso da equipe
+TeamTimeStatus = Tempo / status da equipe
+TeamTotalPlace = Posição sumarizado da equipe (Todas equipes)
+TeamTotalTime = Tempo sumarizado da equipe (Todas etapas)
+TeamTotalTimeAfter = Tempo somado da equipe depois (Todas etapas)
+TeamTotalTimeDiff = Tempo somado da equipe anterior (Todas etapas)
+TeamTotalTimeStatus = Tempo somado ou status da equipe (Todas etapas)
+Teams and forking = Equipes e bifurcação
+Telefon = Telefone
+Test = Teste
+Test Result Module = Testar Módulo Resultado
+Test av stämplingsinläsningar = Teste picote
+Testa = Teste
+Testa rösten = Teste de voz
+Testa servern = Testar o servidor
+Text = Texto
+Text: X = Texto: X
+Texten ska innehålla tecknet X, som byts ut mot tävlingsspecifik data = O texto deve incluir o símbolo X, que é substituído por dados específicos da competição
+Textfiler = Arquivos de texto
+Textfärg = Cor do texto
+Textjustering = Ajuste de texto
+Textstorlek = Tamanho do texto
+The forking is fair = A bifurcação é justa
+The forking is not fair = A bifurcação não é justa
+There is no result module with X as identifier = Não há módulo de resultado com X como identificador
+Tid = Tempo
+Tid E[stageno] = Tempo S
+Tid efter: X = Tempo atrasado: X
+Tid efter: X; har tagit in Y = Tempo atrasado: X; ganhou Y
+Tid efter: X; har tappat Y = Tempo atrasado: X; perdeu Y
+Tid in = Tempo em
+Tid: X, nuvarande placering Y/Z = Hora: X, local atual Y/Z
+Tidpunkt = Tempo
+Tidsavdrag = Redução
+Tidsavdrag: X poäng = Pontos de redução: X pontos
+Tidsförluster (kontroll-tid) = Tempo perdido (controle/tempo)
+Tidsgräns = Tempo limite
+Tidsinmatning = Tempos Manuais
+Tidsintervall (MM:SS) = Intervalo de tempo (MM:SS)
+Tidsintervall (sekunder) = Intervalo de tempo (segundos)
+Tidsjustering = Ajuste de tempo
+Tidslinje – X = Linha do tempo – X
+Tidsskalning = Escala de tempo
+Tidstillägg = Punição de tempo
+Tidszon = Fuso horário
+Till exempel X = Por exemplo X
+Till huvudsidan = Para a página principal
+Till kontroll = Para controle
+Till sista = Continuar
+Till vilka klasser = Para quais categorias
+Tillagda: X = Adicionado: X
+Tilldela = Atribuir
+Tilldela avgifter = Atribuir taxas
+Tilldela endast avgift till deltagare utan avgift = Atribuir taxa apenas aos competidores sem taxa
+Tilldela hyrbrickor = Atribuir Chips
+Tilldela nummerlappar = Atribuir números de peito
+Tilldela nya fakturanummer till alla klubbar? = Atribuir novos números de fatura a todos os clubes?
+Tilldela starttider = Atribuir horários de início
+Tilldelad = Atribuído
+Tilldelning av hyrbrickor = Atribuir Chips
+Tillgängliga automater = Serviços disponíveis
+Tillgängliga filer installerades. Starta om MeOS. = As configurações foram instaladas. Por favor reinicie o MeOS.
+Tillgängliga listor = Listas disponíveis
+Tillsatte vakans = Vaga preenchida
+Tillsätt = Nomear 
+Tillsätt tillfälliga anonyma lagmedlemmar = Nomear membros anônimos da equipe
+Tillsätt vakans = Preencher vaga
+Tillsätt ytterligare vakans = Preencher outra vaga
+Tillämpa parstart = Comece em pares
+Tillåt = Permitir
+Tillåt anmälan = Permitir entrada
+Tillåt borttagning av löpare (med mera) som raderats i den importerade tävlingen = Permitir remoção de competidores (etc) que foram deletados na versão de importada.
+Tillåt decimaler = Permitir decimais
+Tillåt direktanmälan = Permitir entrada rápida
+Tillåt gafflingsändringar = Permitir modificação da bifurcação
+Tillåt löpare inom en parallell grupp att springa gruppens banor i godtycklig ordning = Permitir que os competidores de um grupo paralelo realizem os percursos do grupo em qualquer ordem
+Tillåt ny klass, behåll resultat från annan klass = Permitir nova categoria e manter resultados de outras turmas
+Tillåt ny klass, inget totalresultat = Permitir nova categoria mas sem resultado total
+Tillåt samma bana inom basintervall = Permitir o mesmo percurso dentro do intervalo base (categorias entrelaçadas)
+Tillåt valutauttryck med decimaler = Permitir expressões monetárias com decimais
+Time after leg winner = Tempo perdido da perna campeã
+Time as computed by your time method = Tempo calculado pelo seu método de tempo
+Time calculation for runner = Cálculo de tempo para competidor
+Time calculation for team = Cálculo de tempo para equipe
+Time: X = Tempo: X
+Timekeeping = Cronometragem
+TimingFrom = Nome do ponto de partida
+TimingTo = Nome do ponto de chegada  
+Tips: ställ in rätt tid innan du lägger till fler grupper = Dica: Insira os horários corretos antes de adicionar mais grupos.
+Tjänstebeställningar (IOF XML) = Solicitações de serviço (IOF XML)
+Tjänster (IOF XML) = Serviços (IOF XML)
+Tolkning av radiostämplingar med okänd typ = Interpretação de picotes do tipo desconhecido
+Topplista, N bästa = Tabela de classificação, N melhor
+Total = Total
+Total tävlingsavgift = Taxa total da competição
+Total/team result at a control = Resultado total/equipe em um controle
+TotalCounter = Contador primário
+TotalRunLength = Distância total da corrida
+TotalRunTime = Tempo total de corrida
+Totalresultat = Resultado Total
+Totalresultat - X = Resultado Total - X
+Totalt = Total
+Totalt antal etapper = Número total de etapas
+Totalt antal unika avbockade brickor: X = Número de mapas exclusivos marcados: X
+Totalt faktureras = Faturar
+Totalt kontant = Dinheiro total
+Totaltid = Tempo total
+Track runners in forest = Acompanhe competidores na floresta
+Trasig = Ruim
+Träning = Treinamento
+Tvåmannastafett = Revezamento de dois competidores
+Typ = Tipo
+Typ av delning = Tipo de divisão
+Typ av export = Tipo de exportação
+Typ av lista = Tipo de lista
+Typsnitt = Tipo de letra
+Tävling = Competição
+Tävling från Eventor = Competição do Eventor
+Tävling med lag = Competição entre Equipes
+Tävlingen innehåller inga resultat = Ainda não há resultados
+Tävlingen måste avgöras mellan X och Y = A competição deve ocorrer entre X e Y
+Tävlingen måste ha ett namn = A competição deve ser nomeada
+Tävlingens ID-nummer = Número ID da competição
+Tävlingens namn = Nome da competição
+Tävlingens namn: X = Nome da competição: X
+Tävlingsdata har sparats = Os dados da competição foram salvos
+Tävlingsinställningar = Configurações da competição
+Tävlingsinställningar (IOF, xml) = Configurações da competição (IOF, xml)
+Tävlingsnamn = Nome da competição
+Tävlingsrapport = Relatório da Competição
+Tävlingsregler = Regras da Competição
+Tävlingsstatistik = Estatísticas da Competição
+Töm = Limpar
+Töm databasen = Limpar Banco de Dados
+URL = URL
+URL måste anges = URL ausente
+Ultra Long = Ultra Longo
+Underfilter = Subfiltro
+Underlag för tävlingsavgift = Dados para taxa de competição
+Underlag saknas för bomanalys = Não há dados para erros de controle
+Underlista = Sublista
+Underrubrik = Subtítulo
+Undre datumgräns = Limite inferior de data
+Undre gräns (år) = Limite inferior (anos)
+Undre ålder = Menor idade
+Unexpected Fee = Taxa de entrada inesperadas
+Unfair control legs = Pernas de controle injustas
+Unga, till och med X år = Jovens, até X anos
+Ungdom = Juventude
+Ungdomar och äldre kan få reducerad avgift = Idosos e jovens podem ter taxa reduzida
+Ungdomsavgift = Taxa juvenil
+Ungdomsklasser = Categorias juvenis
+Unknown symbol X = Símbolo desconhecido X
+Unroll split times for loop courses = Desenrole tempos parciais para percursos em loop
+Uppdatera = Atualizar
+Uppdatera alla klubbar = Atualizar todos os clubes
+Uppdatera alla värden i tabellen = Atualizar tabela
+Uppdatera alla värden i tabellen (X) = Atualize todos os valores da tabela (X)
+Uppdatera från Eventor = Atualização do Eventor
+Uppdatera fördelning = Distribuição de atualizações
+Uppdatera fördelningen av starttider med hänsyn till manuella ändringar ovan = Atualizar a distribuição dos horários de partida levando em consideração as alterações manuais
+Uppdatera inte starttiden vid startstämpling = Não atualize o horário de partida com picote de partida
+Uppdatera klubbar && löpare = Atualizar Clubes && Competidores
+Uppdatera klubbarnas och löparnas uppgifter med data från löpardatabasen/distriktsregistret = Atualize clubes e competidores usando o banco de dados de competidores.
+Uppdatera klubbarnas uppgifter med data från löpardatabasen/distriktsregistret = Atualize os clubes usando o banco de dados dos competidores.
+Uppdatera klubbens uppgifter med data från löpardatabasen/distriktsregistret = Atualize o clube usando o banco de dados de competidores.
+Uppdatera löpardatabasen = Atualizar banco de dados de competidores
+Uppdaterade: X = Modificado: X
+Urval = Filtro
+Urval %c%s = Filtro %c%s
+Use initials in names = Use iniciais dos nomes
+User input number = Parâmetro de entrada definido pelo usuário
+Utan inställningar = Sem configurações
+Utan tidtagning = Sem tempo
+Utbyt tävlingsdata med Eventor = Troque dados de competição com Eventor
+Utför lottning = Execute o desenho
+Utfört = Feito
+Utg. = DNF
+Utgått = DNF
+Uthyrda brickor som inte avbockats = Chips locados que não estão marcados
+Uthyrda: X, Egna: Y, Avbockade uthyrda: Z = Chips locados: X, chips próprios: Y, chips locados e marcados: Z
+Utom tävlan = OOC
+Utrymme: X = Tamanho: X
+Utseende = Aparência
+Utskrift = Imprimir 
+Utskrift / export = Imprimir / Exportar
+Utskriftsintervall (MM:SS) = Intervalo de impressão (MM:SS)
+Utökat protokoll = Protocolo estendido
+VALFRI( = Um de(
+Vacancies and entry cancellations = Vagas e cancelamentos de entrada
+Vak. ranking = Ranking de vagas
+Vakanser = Vagas	
+Vakanser - X = Vagas - X
+Vakanser / klassbyte = Mudanças tardias
+Vakanser och efteranmälda = Vagas e entradas atrasadas
+Vakanser stöds ej i stafett = Vagas não suportadas em revezamentos
+Vakansplacering = Colocação de vagas
+Vakant = Vaga
+Val av export = Escolha exportar
+Valbar = Opcional
+Vald bricka = Chip escolhido
+Valfri = Opcional
+Valuta = Moeda
+Valutakod = Código da moeda
+Valutasymbol = Símbolo da moeda
+Valutasymbol före = Símbolo da moeda na frente
+Variabler = Variáveis
+Varning: Banan 'X' finns inte = Atenção o percurso 'X' não existe
+Varning: Banan 'X' förekommer flera gånger = Atenção: O percurso 'X' é especificado mais de uma vez
+Varning: Brickan X används redan av Y = Aviso: O chip X já é usado por Y
+Varning: Deltagaren 'X' finns inte = Aviso: O competidor 'X' não existe
+Varning: Följande deltagare har ett osäkert resultat = Aviso: As atribuições para os seguintes competidores não são claras
+Varning: Ingen organisatör/avsändare av fakturan angiven (Se tävlingsinställningar) = Aviso: Nenhum organizador foi fornecido (Veja as configurações da competição)
+Varning: Inget kontonummer angivet (Se tävlingsinställningar) = Aviso: Nenhuma conta fornecida (Consulte as configurações da competição)
+Varning: Inget sista betalningsdatum angivet (Se tävlingsinställningar) = Aviso: Pagamento devido não efetuado (Ver configurações da competição)
+Varning: Kartorna är slut = Aviso: Fora dos mapas
+Varning: Kunde inte hitta föregående version av tävlingen (X) = Aviso: Não foi possível encontrar a versão anterior da competição (X)
+Varning: Laget 'X' finns inte = Aviso: A equipe 'X' não existe
+Varning: Olika bastävlingar = Aviso: Diferentes bases de dados das competições
+Varning: avgiften kan ej faktureras = Aviso: Não é possível gerar fatura para esta taxa
+Varning: deltagare med blankt namn påträffad. MeOS kräver att alla deltagare har ett namn, och tilldelar namnet 'N.N.' = Aviso: Foi encontrado um competidor sem nome. MeOS requer um nome, e atribuiu o nome 'N.N.'
+Varning: lag utan namn påträffat. MeOS kräver att alla lag har ett namn, och tilldelar namnet 'N.N.' = Aviso: Foi encontrada uma equipe sem nome. MeOS requer um nome e atribuiu o nome 'N.N.'
+Varning: ändringar i X blev överskrivna = Aviso: As alterações no X foram substituídas
+Varningar i X = Avisos para X
+Varvningskontroll = Controle comum
+Varvräkning = Contar voltas
+Varvräkning med mellantid = Conte voltas com tempo extra
+Vem får anmäla sig = Quem pode entrar
+Verkställ = Aplicar
+Verktyg = Ferramentas
+Version X = Versão X
+Vi stöder MeOS = Apoiamos MeOS
+Viktiga händelser = Eventos importantes
+Vill du använda den nya brickan till alla etapper? = Quer usar um novo chip para todas as etapas?
+Vill du att X går in i laget? = Você quer colocar X na equipe?
+Vill du att X och Y byter sträcka? = Você quer que X e Y troquem de perna?
+Vill du att X tar sträckan istället för Y? = Você quer que X corra a perna em vez de Y?
+Vill du dumpa aktuellt tävling och skapa en testtävling? = Você quer abandonar a competição atual e criar uma competição-teste?
+Vill du flytta löpare från X till Y och ta bort Z? = Você deseja mover os competidores de X para Y e remover Z?
+Vill du göra om avbockningen från början igen? = Quer reiniciar e começar tudo de novo?
+Vill du klistra in X nya rader i tabellen? = Deseja colar X novas linhas na tabela?
+Vill du koppla isär X från inläst bricka Y? = Gostaria de desconectar X do chip Y?
+Vill du lägga till banan 'X' (Y)? = Deseja adicionar o percurso 'X' (Y)?
+Vill du lägga till deltagaren 'X'? = Deseja adicionar o competidor 'X'?
+Vill du lägga till klassen 'X'? = Deseja adicionar a categoria 'X'?
+Vill du lägga till laget 'X'? = Deseja adicionar a equipe 'X'?
+Vill du nollställa alla manuellt tilldelade banor? = Deseja limpar todos os percursos atribuídos manualmente?
+Vill du radera X rader från tabellen? = Deseja excluir X linhas da tabela?
+Vill du radera alla vakanser från tävlingen? = Quer retirar todas as vagas da competição?
+Vill du skapa en ny klass? = Deseja criar uma nova categoria?
+Vill du spara ändringar? = Você quer salvar as alterações?
+Vill du sätta hyrbricka på befintliga löpare med dessa brickor? = Você deseja aplicar os dados do chip locado aos competidores existentes?
+Vill du sätta resultatet från tidigare etapper till <Deltar ej>? = Deseja alterar o resultado das etapas anteriores para <NPT> Não Participar)?
+Vill du ta bort 'X'? = Deseja remover 'X'?
+Vill du ta bort alla klubbar från tävlingen? Alla deltagare blir klubblösa = Deseja remover todos os clubes da competição? Nenhum competidor terá clube.
+Vill du ta bort brickan från hyrbrickslistan? = Deseja remover o chip da lista de chips alugados?
+Vill du ta bort schemat? = Deseja remover o esquema?
+Vill du tömma listan med hyrbrickor? = Quer limpar a lista de chips alugados?
+Vill du uppdatera alla nummerlappar? = Quer atualizar todos os números de peito?
+Vill du verkligen radera alla starttider i X? = Você realmente deseja limpar os horários de partida no X?
+Vill du verkligen radera starttider i X klasser? = Você realmente deseja apagar os horários de partida das categorias X?
+Vill du verkligen radera tävlingen? = Deseja remover a competição?/
+Vill du verkligen stänga MeOS? = Deseja fechar o MeOS?
+Vill du verkligen ta bort laget? = Você deseja remover a equipe?
+Vill du verkligen ta bort löparen? = Deseja remover o competidor?
+Visa = Mostrar
+Visa alla = Mostrar Tudo
+Visa avancerade funktioner = Mostrar configurações avançadas
+Visa detaljerad rapport för viss deltagare = Mostre um relatório detalhado para um competidor específico
+Visa en tabell över alla stämplingar = Mostre uma tabela com os picotes
+Visa klubbdatabasen = Mostrar banco de dados do clube
+Visa listan i fullskärm = Mostrar uma lista em tela cheia
+Visa löpardatabasen = Mostrar banco de dados de competidor
+Visa mellantider = Mostrar tempos parciais
+Visa och hantera löpardatabasen = Mostrar e gerenciar banco de dados de competidores
+Visa rubrik = Mostrar título
+Visa rubrik mellan listorna = Mostrar cabeçalho entre listas
+Visa rullande tider mellan kontroller i helskärmsläge = Mostrar tempos de rolagem entre controles no modo de tela inteira
+Visa senast inlästa deltagare = Mostrar último competidor lido
+Visa startlistan = Mostrar lista de partida
+Visa tillgängliga säkerhetskopior = Mostrar backups disponíveis
+Visa valda deltagare = Mostrar competidores selecionados
+Visar de X bästa = Mostrando o X superior
+Visning = Modo de exibição
+Visningsinställningar för 'X' = Ver configurações para 'X'
+Visningstid = Mostrar tempo
+Vissa inställningar kräver omstart av MeOS för att ha effekt = Algumas configurações exigem a reinicialização do MeOS para terem efeito
+Visualisera startfältet = Visualizar campo inicial
+Vuxen = Adulto
+Vuxenklasser = Categoria Adulto
+Vuxna = Adultos
+Välj Spara för att lagra brickorna. Interaktiv inläsning är INTE aktiverad = Clique em <Salvar> para armazenar os chips. A leitura interativa não está ativada
+Välj Spara för att lagra brickorna. Interaktiv inläsning är aktiverad = Clique em <Salvar> para armazenar os chips. A leitura interativa está ativada
+Välj X = Selecionar 
+Välj alla = Selecionar Tudo
+Välj alla klasser = Selecionar todas as categorias
+Välj allt = Selecionar tudo
+Välj automatiskt = Seleção Automática
+Välj deltagare för förhandsgranskning = Selecione o concorrente para visualização
+Välj den etapp som föregår denna tävling = Selecione a etapa anterior a esta etapa
+Välj den etapp som kommer efter denna tävling = Selecione a etapa seguinte a esta etapa
+Välj en vakant plats nedan = Escolha abaixo uma vaga
+Välj etapp att importera = Selecione a etapa para importar
+Välj från lista = Seleção detalhada
+Välj ingen = Selecione nenhum
+Välj inget = Selecione Nenhum
+Välj klass = Selecione categoria
+Välj klass och starttid nedan = Escolha uma categoria e o horário de partida abaixo
+Välj klasser = Escolha categorias
+Välj klasser där alla löpare saknar starttid = Selecione categorias onde nenhum competidor tem horário de partida
+Välj klasser där någon löpare saknar starttid = Selecione categorias onde algum competidor perdeu o horário de partida
+Välj klasser med nya anmälningar = Especifique as categorias onde novas entradas são permitidas 
+Välj kolumner = Escolha Colunas
+Välj kolumner att visa = Escolha colunas para mostrar
+Välj kolumner för tabellen X = Escolha colunas para a tabela X
+Välj lista = Selecionar lista
+Välj lopp = Selecione a competição
+Välj löpare = Escolha o competidor
+Välj löpare att prioritera bevakning för = Selecione competidores para priorizar
+Välj löpare för sträcka X = Definir competidor para perna X
+Välj skrivare = Escolha a impressora
+Välj tävling = Escolha a competição
+Välj vilka funktioner du vill använda = Selecione quais recursos do MeOS você precisa para esta competição 
+Välj vilka klasser och kontroller du vill bevaka = Selecione as categorias e os controles que deseja assistir
+Välj vilka klasser och kontroller som bevakas = Selecione quais categorias e controles assistir
+Välj vilka kolumner du vill visa = Escolha colunas para mostrar
+Välj vilken typ du vill importera = Selecione o tipo de ID a ser importado
+Välj vy = Escolha a visualização
+Välkommen till MeOS = Bem-vindo ao MeOS
+Vänligen betala senast = Por favor pague o mais tardar
+Vänligen återlämna hyrbrickan = Por favor devolva o seu chip alugado
+Vänster = Esquerda
+Växel = Mudança
+Växling = Mudança
+Webb = Documento Web
+Webbdokument = Documento Web
+Webbdokument (html) = Documento Web (html)
+Webben (html) = The web (html)
+Without courses = Sem percursos
+X (Saknar e-post) = X (não tem e-mail)
+X (Y deltagare, grupp Z, W) = X (Y competidores, grupo Z, W)
+X (press Ctrl+Space to confirm) = X (pressione <Ctrl>+<Space> para confirmar)
+X anmälda = X entradas
+X går vidare, klass enligt ranking = X qualificado, categoria por ranking
+X har en tid (Y) som inte är kompatibel med förändringen = X tem um tempo (Y) incompatível com esta mudança
+X har redan bricknummer Y. Vill du ändra det? = X já possui o número do chip Y. Quer alterá-lo?
+X har redan ett resultat. Vi du fortsätta? = X já tem um resultado. Você deseja continuar?
+X har startat = X começou
+X kontroller = X controles
+X m = X m
+X meter = X metros
+X och Y[N by N] = X por Y
+X p = X p
+X platser. Startar Y = X lugares. Começa Y
+X poäng fattas = X pontos faltando
+X rader kunde inte raderas = X linha(s) não puderam ser excluídas
+X senaste = X mais recente
+X stämplingar = X picotes
+X är inget giltigt index = X não é um índice válido
+X är inget giltigt sträcknummer = X não é um número per perna válido
+X: Y. Tryck <Enter> för att spara = X: Y. Pressione <Enter> para salvar
+X:e = X:th
+Year of birth = Ano de nascimento
+Youth Cup X = Taça juvenil X 
+Zooma in (Ctrl + '+') = Aumentar o zoom (Ctrl + '+')
+Zooma ut (Ctrl + '-') = Diminuir o zoom (Ctrl + '-')
+[Bevaka] = [Assistir]
+[Bort] = [Remover]
+[Flytta ner] = [Mover para baixo]
+[Klassens bana] = [Da Categoria]
+[Radera] = [Delete]
+[Uppdaterad anmälan] = [Entrada atualizada]
+[VARNING] ingen/okänd = [AVISO] nenhum/desconhecido
+[Återställ] = [Reiniciar]
+andra = segundos
+ask:addpunches = Nenhum chip foi lido para este competidor. Gostaria de adicionar picote manualmente?
+ask:changedclassfee = O valor da inscrição foi alterado em algumas categorias. Você deseja aplicar as novas taxas aos competidores existentes nessas categorias? \n\AVISO: As taxas atribuídas manualmente serão substituídas.
+ask:changedcmpfee = As taxas de inscrição são modificadas. Você deseja aplicar as novas taxas aos competidores e categorias existentes?\n\nAVISO: As taxas atribuídas manualmente serão substituídas.
+ask:cleardb = Quer limpar os bancos de dados de competidores e clubes?
+ask:convert_to_patrol = Algumas categorias contêm solicitações de horário de partida comum para alguns competidores. Você deseja converter essas categorias em categorias patrulha?
+ask:firstasstart = Existem competidores com resultados para esse percurso. Se você usar o primeiro controle como início, serão substituídos.\n\nDeseja continuar?
+ask:hasVacant = Ainda há vagas. \n\nDeseja remover todas as vagas antes de exportar os resultados?
+ask:importcopy = Já existe uma competição (X) com a mesma origem. Você pode importar a competição como uma versão dessa competição ou como uma nova cópia independente. Se for o mesmo evento com modificações, é melhor importá-lo como uma versão.\n\nDeseja importá-lo como uma versão?
+ask:kiosk = Ao iniciar um quiosque de resultados, você coloca o MeOS em modo onde só é possível mostrar relatórios de resultados. Nenhuma, outra operação é permitida até que o programa seja reiniciado. Se houver um dispositivo SI ativo conectado ao computador, o MeOS mostrará automaticamente os resultados do último chip lido.\n\nVocê deve considerar proteger o banco de dados com uma senha, se expor publicamente um quiosque de resultados.\n\nVocê deseja iniciar um quiosque de resultados?
+ask:loadspeaker = Deseja restaurar janelas salvas anteriormente neste computador?
+ask:missingcourse = Algumas categorias (X) não tem percurso.\n\nMeOS utiliza os percursos ao desenhar para evitar que competidores com o os mesmos primeiros controles comecem ao mesmo tempo.\n\nDeseja continuar mesmo assim?
+ask:outofmaps = Fora dos mapas. Você deseja adicionar este competidor mesmo assim?
+ask:overwrite_server = A competição já está no servidor. Quer sobrescrever a competição no servidor?
+ask:overwriteconfirm = Você optou por substituir a competição. Certifique-se de que mais ninguém esteja conectado.\n\nDeseja continuar?
+ask:overwriteresult = X já tem um resultado. Você deseja sobrescrever isso?
+ask:removescheme = Os resultados serão perdidos se você remover o esquema. Você deseja continuar?
+ask:repair = Repare o banco de dados somente se tiver problemas.\n\nIMPORTANTE:\n- Certifique-se de que ninguém mais esteja conectado ao banco de dados.\n- Se o servidor travar ou ficar inativo durante o reparo, você deverá reiniciá-lo e tentar novamente o reparo antes de fazer qualquer outra coisa. Se você fizer qualquer outra operação com o banco de dados, todos os dados serão perdidos.\n\nDeseja tentar uma operação de reparo agora?
+ask:savespeaker = Deseja salvar as configurações atuais de categoria e janelas nesse computador?
+ask:updatelegs = As extensões dos trechos individuais do percurso podem exigir uma atualização após essa alteração.\n\nDeseja corrigir isso agora?
+ask:updatetimes = Você deseja manter todos os horários de partida atualmente atribuídos se possível? Responda NÃO para avançar a competição com tempo.
+ask:usecourseinclass = O percurso não é usado por nenhum outro competidor nesta categoria.\n\nVocê gostaria de usá-lo mesmo assim?
+backup = backup
+blue channel = blue channel
+c/o = c/o
+check (X) = um check (X)
+classcourseresult = Resultados em categorias e em termos de percurso
+delar placering med X = Divide lugar com X
+documentation = meos_doc_eng.html
+edit_in_forest = Gerenciar\nCompetidores restantes
+ej aktiv = Não ativo
+elfte = Décima
+elva = Décimo
+encoding = ANSI
+error:invalidmethod = O método selecionado não deu distribuição. Os dados de origem são insuficientes.
+ett Mycket Enkelt OrienteringsSystem = Um sistema de orientação muito fácil
+eventor:help = Se utiliza o MeOS para orientação na Suécia, nós recomendamos a conexão do MeOS com o Eventor.
+eventor:question = X\n\nVocê deseja conectar ao Eventor?
+false[boolean] = falso
+femma = quinta
+femte = quinto
+fjärde = quarto
+fritt att använda och du är välkommen att distribuera det under vissa villkor = de uso gratuito e você pode redistribuí-lo sobre certas condições
+fyra = quarto
+går i mål på X plats med tiden Y = termina como X com o tempo Y
+går i mål på X plats, efter Y, på tiden Z = termina como X, atrás de Y, com tempo Z
+går i mål på delad X plats med tiden Y = termina em um lugar X compartilhado com tempo Y
+går upp i delad ledning med tiden X = assume uma liderança compartilhada com o tempo X
+går upp i delad ledning vid X med tiden Y = compartilha a liderança em X, tempo Y
+handskakning = aperto de mãos
+har startat = começou
+help:10000 = Um serviço no MeOS é um pequeno programa que faz algo automaticamente de vez em quando ou quando os dados da competição são alterados. 
+help:12138 = Selecione uma categoria para mesclar com essa categoria. Se os horários de partida forem sorteados, você pode querer empatar novamente, já que os competidores mantêm os seus horários de partida.
+help:12290 = A competição é criada por outra versão do MeOS e não pode ser aberta a partir de um servidor. No entanto, você pode importar a competição do arquivo.
+help:12352 = Esta operação remove o clube que você escolheu (%s, id=%d) e move todos os competidores desse clube para o novo clube que você escolher abaixo. A operação não pode ser desfeita.
+help:12662 = Adicione controles adicionando uma sequência de números de controle (números de controle) Você não precisa especificar o acabamento. Exemplo: 31, 50, 36, 50, 37, 100.
+help:14070 = A porta TCP é usada para receber perfurações sobre TCP de outros sistemas. Especifique a porta usada. O horário zero do protocolo é 00:00:00.
+help:14343 = Uma lista com chip lido é mostrada. Para vincular um competidor a outro mapa, clique duas vezes no mapa ou competidor que deseja mover.
+help:146122 = Você pode ampliar o conhecimento do MeOS sobre competidores, clubes e categorias pesquisando banco de dados no formato MeOS ou (xml) IOF.\n\nDeseja continuar?
+help:14692 = Insira o número de controle, competidor (número inicial ou número do chip) e hora do relógio (HH:MM:SS). Você pode deixar o campo de hora em branco; então o relógio do computador é usado. Pressione <Enter> para salvar.
+help:15491 = Você pode exportar configurações, bancos de dados de clubes e competidores para uma pasta específica. Essas configurações e banco de dados podem ser importados para outro computador.
+help:21576 = Se você cometer um erro, clique no nome dos competidores para alterar a entrada. Use os competidores de página para remover entradas. Para visualizar uma turma na lista abaixo, ela deve estar marcada para entrada rápida na página turmas.
+help:25041 = Aqui você define seus percursos. Um percurso é então vinculado a uma ou mais categorias (ou competidores). Também é possível importar percursos do OCAD ou outro software de percurso. Se você especificar o número de mapas, o MeOS acompanhará os mapas disponíveis no formulário de entrada rápida.
+help:26963 = Um conjunto de percursos é usado para definir um conjunto de percursos para uma etapa. O percurso está vinculado ao competidor na chegada por correspondência de controle. Defina percursos no pool adicionando-os em Vários percursos/retransmissão. Um [S] após a categoria significa que todos os seus competidores têm horário de largada.
+help:29191 = Você pode instalar configurações, clubes e banco de dados de competidores a partir de uma pasta de origem especificada. Suas configurações locais serão substituídas. O MeOS pode ser reiniciado após a instalação.\n\nO botão <Exportar> leva você a uma página onde você pode exportar suas configurações atuais.
+help:29758 = Aqui você gerencia clubes e imprime faturas. Você pode atribuir taxas de competição com base no tipo de categoria e na data de inscrição. Clubes duplicados (com erros ortográficos) podem ser mesclados com o clube correto correspondente. Você também pode atualizar os endereços dos clubes no registro.
+help:30750 = Você pode criar muitos tipos diferentes de listas e relatórios. Eles podem ser exibidos na tela, impressos ou salvos em formato web. A lista é atualizada automaticamente quando os dados da competição são alterados. A impressão automática dos resultados é feita na página Serviços. Para exportar dados de competição, por exemplo tempos parciais, acesse a página Competição.
+help:31661 = Um reinício é definido por um tempo de pista e um tempo de reinício. Na hora da pista, a passagem é encerrada e nenhum competidor sai para a floresta. Os competidores restantes começam na hora da pista. É possível especificar tempos diferentes para etapas individuais, mas usando esta função você pode lidar rapidamente com categorias inteiras.
+help:33940 = Importe entradas em formato de texto livre. Especifique nome, clube, categoria e número do chip (possivelmente também horário de início), de preferência separados por vírgula, um competidor (equipe) por linha. Também é possível especificar muitos competidores no mesmo clube/categoria, omitindo parcialmente estes campos. Também é possível importar dados formatados de outras formas.
+help:41072 = Selecione um picote da lista para alterá-lo ou removê-lo. Você pode adicionar pontos ausentes no modelo do percurso. Se faltar o tempo de chegada, o competidor recebe o status Não terminou <Did Not Finish>. Se um picote estiver faltando, o status será Falta picote <Missing Puch>. Não é possível atribuir status incompatível com os picotes. Se houver um picote de chegada, você deverá modificá-lo para definir um tempo de chegada manual. O mesmo princípio se aplica ao picote de partida.
+help:41641 = Insira uma primeira hora de partida e um intervalo de partida. Sorteio aleatório fornece uma ordem de partida incondicionalmente aleatória. O método de sorteio sueco usa regras especiais para distribuir competidores do mesmo clube. Partida agrupada significa que toda a categoria começa em pequenos grupos durante o intervalo especificado (Partida em massa estendida). Na perna do campo, você pode especificar qual perna será sorteada, caso a categoria tenha várias.
+help:425188 = Você pode lidar com competidores que não iniciaram automaticamente lendo as estações SI (limpar/verificar/iniciar/controles) no SportIdent Config+. Salve a leitura como um arquivo de texto separado por ponto e vírgula e importe esse arquivo para o MeOS. Os competidores nesta importação obtêm um picote. Então você pode atribuir o status DNS a todos os competidores sem picote. Se você importar mais competidores posteriormente, poderá redefinir o status (de DNS para Desconhecido) nos competidores agora importados.
+help:50431 = Agora você está conectado a um servidor. Para abrir uma competição no servidor, selecione-a na lista e clique em abrir. Adicione uma competição ao servidor, abra a competição localmente e selecione upload. Ao abrir uma competição no servidor, você verá todos os outros clientes MeOS conectados.
+help:52726 = Conecte-se a um servidor abaixo.\n\nInstalação\nBaixe e instale o MySQL (Community Edition) em www.mysql.com. Você pode usar as configurações padrão. Só é necessário instalar o MySQL no servidor do computador atuante. Quando o MySQL estiver instalado, inicie o MySQL Command Line Client e crie uma conta de usuário para MeOS. Você escreve assim:\n\n> CREATE USER meos;\nGRANT ALL ON *.* TO meos;\n\nAgora você criou um usuário meos sem senha. Digite o nome do servidor abaixo (talvez seja necessário configurar firewalls para permitir a passagem do tráfego).\n\nComo alternativa, você pode usar a conta root integrada do MySQL. O nome de usuário é 'root' e a senha é aquela que você forneceu ao instalar o MySQL.
+help:5422 = Não foi encontrada nenhuma unidade SI. Eles estão conectados e iniciados?
+help:59395 = Neste formulário, você pode fazer rapidamente configurações básicas para muitas categorias em uma única etapa.\n\nInício é o nome do início conforme está impresso na lista de partida.\n\nBloco é um número entre 0 e 100 que pode fornecer uma distribuição ainda melhor de competidores. As categorias do mesmo bloco serão impressas na mesma lista de partida minutos. \n\nÍndice é uma chave de classificação. As equipes são ordenadas por esta chave em todas as listas.\n\nO percurso pode ser especificado para equipes que possuem exatamente um percurso; se houver vários percursos possíveis, você precisará usar o formulário de equipe padrão.\n\nA entrada rápida determina se a equipe suporta o modo de entrada rápida, ou seja, é uma escolha possível na lista de equipes de entrada rápida.
+help:59395_more = As taxas das categorias, que mostram se você ativou os recursos da Economia, são usadas para novas entradas. Se você alterar uma taxa, o MeOS perguntará se você deseja aplicar a alteração aos competidores existentes.\n\nPara números de peito você tem as opções Nenhum, Consecutivo e Manual. Você também pode digitar o primeiro caracter da categoria, por exemplo A100 ou 50. Consecutivo significa que o último número da categoria anterior é usado para definir o primeiro número desta categoria. Os números de peito reservados fornecem uma lacuna (da largura especificada) na numeração entre as categorias.\n\nO MeOS atualiza os números de peitos quando você desenha horários de partida ou altera as configurações. Manual significa que o MeOS nunca atualizará automaticamente os números de peito.\n\nPara categorias com equipes, a configuração Membro da equipe controla a relação entre o número da equipe e os números de peito. Pode ser igual, crescente (100, 101, 102), dependente da perna (100-1, 100-2, etc.) ou totalmente independente.
+help:7618 = O número de competidores de uma equipe é especificado na página Categorias.
+help:7620 = Intervalo (segundos). Deixe o campo em branco para atualizar quando a competição for alterada.
+help:89064 = Para cada controle, você especifica um ou mais números de código (códigos SI). Em um percurso, você se refere ao controle pelo seu número de identificação. Normalmente, você não precisa adicionar controles manualmente, pois o MeOS adiciona automaticamente todos os controles necessários.\n\nMais de um código SI é útil para substituir controles com defeito ou para criar bifurcações simples. Para um controle normal, é necessário que o competidor visite um dos controles especificados. Se o status do controle for <Múltiplo>, todos os controles especificados deverão ser visitados (em qualquer ordem). Se o status for <Ruim>, o controle é ignorado.\n\nO status <Perdido> funciona como <Ruim>, mas além disso o tempo de execução para o próximo controle é ignorado; no momento final não importa quanto tempo foi gasto procurando o controle perdido.\n\nSe você especificar um nome de controle, é possível imprimir listas de resultados com tempos intermediários em controles nomeados.\n\nO ajuste de tempo pode ser usado se descobrir que um controle está com a hora errada. O formato de hora é +/-MM:SS ou +/-HH:MM:SS.\n\nO tempo de trecho mais curto define o menor tempo possível nesse trecho. Nenhum competidor terá menos tempo para esse controle, por mais rápido que seja. Isto pode ser usado, por exemplo, se uma estrada perigosa precisar ser atravessada.\n\nStatus <Sem cronometragem> significa que o tempo para o controle é ignorado; o tempo total será o mesmo, independentemente do tempo real para esse controle.
+help:9373 = Forneça um ou mais números de controle (códigos SI) usados por esse controle.\nExemplo: 31, 250.
+help:9615 = Não recebi resposta. Deseja abrir a porta no modo passivo; o MeOS deveria ouvir os picotes recebidos?
+help:DirectResult = - Se não houver percurso, o status será definido como OK no picote final.\n\n- Se houver um percurso, os picotes de rádio serão usados como controles. Nenhuma leitura do chip é necessária.
+help:LockStartList = O MeOS não atualizará a atribuição para uma categoria bloqueada, mesmo que os resultados da qualificação sejam alterados.
+help:analyzecard = Esta função permite imprimir dados do chip sem usar concorrência, como uma unidade de impressão independente. Selecione Imprimir Divisões para selecionar e configurar a impressora.\n\nOs chips também são salvos na memória (mas não na competição). Você pode editar o nome e o clube de um chip clicando no nome (ou em 'Desconhecido'). Você também pode salvar os chips em arquivo (Salvar) ou criar uma nova competição a partir dos dados do chip. Observe que se uma competição estiver aberta no momento, você deverá fechá-la para disponibilizar esta opção.
+help:anonymous_team = Criar e nomear membros (temporários) para todas as equipes, aos quais você pode atribuir SI Card, Percurso etc.
+help:assignfee = O MeOS cuidará das taxas de inscrição automaticamente para você em muitos casos. Os competidores recebem taxas com base na idade e data de inscrição (você define os limites em Configurações da Competição). Cada categoria define suas taxas. Você fornece valores padrão para diferentes tipos de categorias nas Configurações da competição, mas também pode alterar manualmente as configurações das categorias usando as Configurações rápidas da categoria.\n\nEsta página permite usar manualmente diferentes idades e limites de tempo para diferentes taxas. Na página dos competidores, você pode ajustar manualmente a taxa para competidores individuais, se necessário.
+help:assignforking = Esta função calcula um padrão de bifurcação ideal a partir de percursos selecionados. Atribua um ou mais percursos aos percursos selecionando percursos e percursos nas listas acima. Todos os percursos podem ter o mesmo conjunto de percursos (bifurcação igual) ou é possível usar diferentes conjuntos de percursos para etapas diferentes. Também neste caso, o MeOS irá bifurcar esses percursos entre si, se os percursos permitirem.
+help:baudrate = Velocidade de transmissão/taxa de transmissão: use 4800 ou 38400.
+help:bibs = Você pode manusear os números de peito de forma automática ou manual. Aqui você pode atribuir números de peito manualmente para uma determinada equipe especificando o método Manual e fornecendo o primeiro número da equipe.\n\nO método automático funciona da mesma forma, com a diferença que o MeOS atualizará os números de peito de todas as equipes de uma vez. Embora seja possível fazer esta configuração aqui, é melhor usar as configurações rápidas das categorias para obter uma visão geral de todas as categorias.\n\nUse o método Automático junto com os métodos Nenhum ou Consecutivo, o que significa que o último número em a categoria anterior é usada como primeiro número. O número de peito reservados especifica o salto realizado na numeração entre as categorias.\n\nPara categorias de equipe você pode especificar como os números de peito dos competidores se relacionam com o número de peito da equipe. Pode ser Igual, Independente, Crescente (Equipe 1: 101, 102, 103, 104, Equipe 2: 111, 112, 113, 114, etc) ou Perna (100-1, 100-2, 100-3 etc).
+help:checkcards = Utilize esta função para contar e assinalar os chips contratados para verificar se todos foram devolvidos. Anexe uma unidade SI (de preferência programada como controle ou chegada, pois é mais rápida que a leitura do chip) e picote todos os chips devolvidos. Aperte o botão Reportar para ver se algum chip está faltando.\n\n A verificação é feita localmente neste computador e não modifica a competição.
+help:computer_voice = Um picote recebido é comparado a um número de partida e reproduz o arquivo <N.wav>, onde N é o número de partida. Os arquivos estão localizados na pasta abaixo. Se o competidor/equipe pertencer tiver nacionalidade NAT, o MeOS primeiro tenta reproduzir o arquivo <NAT/N.wav>, que deverá conter o número em uma versão de idioma apropriado.
+help:custom_text_lines = Você pode inserir dados específicos personalizados digitando [Nome do símbolo]. Os símbolos disponíveis podem ser vistos na lista à direita.\n\n Exemplo: Muito bem, [RunnerName]!
+help:dbage = O banco de dados do competidor tem mais de dois meses. Deseja baixar um novo banco de dados do Eventor?
+help:duplicate = Faça uma cópia local desta competição.
+help:eventorkey = Digite a chave API do Eventor (Suécia) do seu clube. Você obtém a chave do administrador do Eventor do seu clube.
+help:exportdraw = Você pode exportar uma planilha em formato csv, contendo equipes, quantidade de competidores e configurações de sorteio de cada equipe. É então possível editar os dados iniciais e importá-los de volta para o MeOS para desenhar as categorias de acordo.
+help:fullscreen = Você pode ajustar a velocidade de rolagem usando Ctrl+M (aumentar) e Ctrl+N (diminuir) no teclado. Para sair do modo de tela cheia, pressione Esc.
+help:import_entry_data = Você pode importar competidores, categorias, clubes e inscrições de diversos formatos de texto e XML diferentes. Não é necessário fornecer todos os arquivos abaixo. Por exemplo, um arquivo OE-CSV com entradas contém clubes e categorias, portanto, nesse caso, esses campos devem ser deixados vazios.\n\nSe o mesmo competidor for importado várias vezes, você não obterá várias cópias do competidor. Em vez disso, a entrada é atualizada. Isso significa que é inofensivo reimportar ou importar um arquivo estendido com entradas.
+help:importcourse = Você pode importar percursos e categorias (por exemplo) de uma exportação OCAD ou outros.
+help:liveresultat = Este método inicia um cronômetro em modo de tela cheia (tela grande) quando um competidor de uma categoria selecionada aperta o controle <De> e mede o tempo até que o controle <Para> seja alcançado. Caso contrário, será mostrada uma lista com os melhores resultados. É claro que ambos os controles precisam ser controles on-line e se você usar uma rede, certifique-se de ativar <informações de avanço rápido sobre picotes de controle> para obter um temporizador responsivo.
+help:long_times = A data da competição é a data em que todas as categorias começam. O horário zero é à meia-noite.
+help:merge = É possível mesclar competições e resultados, desde que baseados no mesmo conjunto de percursos e controles. Diferentes grupos de participantes podem completar a competição em diferentes ocasiões e depois as diferentes competições podem ser fundidas numa única competição com uma lista comum de resultados. Outra possibilidade é ter locais diferentes para equipes diferentes. Caso não seja possível configurar uma rede comum, você poderá trocar periodicamente os arquivos da competição para incorporar as alterações.\n\n1. Prepare toda a competição.\n2. Salve uma cópia e importe-a para os computadores terceirizados (ou redes locais).\n3. Para transferir as alterações, exporte o evento do computador (ou computadores) terceirizado e mescle-o com este recurso. Em seguida, exporte uma cópia do computador principal e faça a importação correspondente nos computadores terceirizados. \n4. O procedimento pode ser repetido várias vezes para transferir continuamente os resultados.\n\nObservação: se você fizer alterações (por exemplo) no mesmo participante em vários locais, algumas das alterações serão substituídas sem aviso prévio. Certifique-se de que cada local terceirizado mude apenas em sua parte da competição.\n\nDica: Faça uma transferência assim que as competições terceirizadas começarem, antes de qualquer alteração ser feita, para testar se tudo foi configurado corretamente.
+help:ocad13091 = Se você tiver acesso aos percursos (por exemplo, do OCAD ou outro) poderá fornecer aqui o nome do arquivo de percurso. Caso contrário, você poderá adicionar percursos posteriormente.
+help:onlineinput = O serviço é utilizado para receber picotes de rádio da Internet, por exemplo, um controle de rádio conectado através de um telefone celular. Também é possível construir um formulário web simples, onde você pode inserir manualmente o número de inscrição dos competidores conforme a passagem.\n\nO protocolo de serviço também suporta outros tipos de entrada de dados, como escalação da equipe, entradas diretas, alterações de chip, etc. Se quiser desenvolver os seus próprios serviços, pode encontrar documentação e exemplos no site do MeOS: www.melin.nu/meos.
+help:onlineresult = O serviço é usado para enviar automaticamente resultados e listas de partida para a Internet para publicação imediata de alguma forma. Você precisa fazer configurações adaptadas ao serviço remoto que deseja usar: o provedor do serviço remoto pode lhe fornecer os detalhes necessários.\n\nSe você pode desenvolver seus próprios serviços, você pode encontrar documentação e exemplos no site do MeOS: www.melin.nu/meos.
+help:paymentmodes = Você pode definir formas de pagamento personalizadas, além do faturamento, para distingui-las na inscrição.
+help:registerhiredcards = Pré-registre chips picotados como chips de aluguel para obter o status automático do chip contratado quando o chip for atribuído.
+help:relaysetup = Use o guia abaixo para escolher entre vários formulários de competição pré definidos. Depois de aplicar as configurações, é possível adaptá-las manualmente para cada etapa e configurar percursos.\n\nAlgumas explicações:\n- O revezamento é usado para diferentes tipos de revezamentos.\n- Revezamento de dois competidores significa que dois competidores formam uma equipe e se revezam na corrida.\n- O revezamento de co-competidores às vezes é usado nas categorias juvenis e permite mais de um competidor em algumas pernas. (O primeiro competidor muda).\n- Uma corrida de patrulha pode ser realizada com um ou dois chips.\n- Prólogo + perseguição é individual, mas com duas corridas.\n- Pool de percursos significa que existem diversas variantes de percurso, mas que não é decidido antecipadamente quem dirige qual curso; é decidido automaticamente quando o competidor termina.
+help:rest = A API REST do MeOS permite acessar dados da competição por meio de uma conexão web. Você pode mostrar listas de resultados diretamente em um navegador da web, mas também pode solicitar dados e resultados da competição em formato XML, adequado para processamento posterior em programas e aplicativos de terceiros.
+help:restore_backup = Escolha um backup para restaurar clicando na hora em que o backup foi criado.
+help:runnerdatabase = Ao importar um banco de dados de competidores e clubes, o MeOS reconhecerá automaticamente competidores desconhecidos (pelo número do chip) e você obterá endereços e números de telefone dos clubes.
+help:save = O MeOS salva automaticamente todas as configurações quando necessário.
+help:seeding_info = A alocação de tempo de partida inicial significa que um resultado ou classificação anterior controla parcialmente o processo. No campo propagação de grupos você pode inserir um único tamanho de grupo, o que significa que toda a equipe é particionada em grupos desse tamanho. O tamanho do grupo "1" significa que a ordem de propagação é estritamente usada. Você também pode especificar vários tamanhos de grupo. "15.1000" significaria um grupo classificado com os 15 competidores com melhor classificação e os competidores restantes (no máximo 1.000) seriam colocados em um grupo não classificado.
+help:selectsound = Selecione sons para tocar. Por padrão, os sons integrados do MeOS são reproduzidos.
+help:simulate = Este serviço permite simular a leitura de chips SI. Tempos e picotes são gerados para todos os competidores. Também é possível simular picotes de controle de rádio.\n\nAVISO: Use apenas para teste. Se você usar isso em um evento real, ele será corrompido.
+help:speaker_setup = Escolha quais categorias e percursos você deseja assistir.
+help:speakerprio = Verifique os competidores/equipes que você deseja assistir desde o início e desde que o competidor/equipe esteja bem. Faça duas verificações para observar mesmo que o resultado não seja tão bom. Nenhuma verificação significa monitorar apenas se o competidor/equipe está indo bem (não desde o início).
+help:splitexport = Decida se deseja exportar resultados totais ou resultados individuais para cada competição. Se você optar por exportar todas as competições, serão criados arquivos numerados.
+help:startgroup = Os grupos iniciais são usados para controlar o desenho da lista de partida. Os competidores de um grupo começarão no horário de início do grupo.
+help:startmethod = O MeOS aplicará automaticamente o método de partida escolhido. Não importa o que você escolha aqui, você sempre pode alterar o método de partida ou redesenhar as listas posteriormente.
+help:teamlineup = Aqui você pode importar escalações de equipes a partir de um formato estruturado baseado em texto, que é fácil de produzir manualmente a partir de um programa de planilha. O arquivo deverá ter o seguinte formato:\n\nTurma;Nome da equipe;[Clube]\nCompetidor 1;[Nº Chip];[Clube];[Percurso];[Categoria do competidor]\nCompetidor 2;[Nº Chip];[ Clube];[Percurso];[Categoria do competidor]\n...\nCategoria;Nome da equipe;[Clube]\n...\n\nCampos marcados com [] poderão ser excluídos. Observe que as referidas categorias e percursos devem existir, e que o número de etapas da categoria deve corresponder ao número de fileiras de competidores após a categoria. Linhas vazias podem ser usadas se não houver competidores. A opção <Usar competidores já em competição> significa que apenas os competidores já em competição são transferidos para a equipe; outros competidores especificados são ignorados.
+help:teamwork = Os competidores trocam de posição. Você pode fazer uma sequência de trocas para chegar à nova escalação da equipe.
+help:winsplits_auto = Este serviço salva os tempos parciais em um arquivo IOF (xml) em intervalos regulares. Se você abrir este arquivo no WinSplits, as divisões serão atualizadas ao vivo.
+help:zero_time = Defina o tempo zero para uma hora antes do primeiro início planejado.
+help_autodraw = Forneça um primeiro horário de partida (normal), um intervalo mínimo de partida (dentro de uma equipe) e a fração de vagas. Você também pode escolher o método a ser usado no sorteio e se os lançamentos atrasados devem começar antes ou depois dos lançamentos normais. O primeiro horário de partida deverá ser posterior ao tempo zero da competição.\n\nSe você clicar em <Sorteio Automático>, o MeOS irá inspecionar todas as categorias. Se a equipe não for sorteada, será, se houver inscrições atrasadas sem horário de início em uma equipe, estas serão sorteadas.\n\nO MeOS garante que competidores com percursos semelhantes não largam simultaneamente, e o espaço será reservado para permitir entradas atrasadas sob as mesmas condições.\n\nSe você clicar em <Desenhar Manualmente> você poderá controlar exatamente quais categorias serão desenhadas e com quais parâmetros.
+help_draw = Você desenha a lista de partida em um processo de duas etapas. Primeiro você escolhe quais categorias desenhar e faz algumas configurações básicas. Quando você pressiona <Distribuir horários> o MeOS usará suas configurações para distribuir os horários de partida entre as categorias. O MeOS garante que as categorias com percursos semelhantes não comecem no mesmo horário, levando em consideração as equipes já sorteadas. Um objetivo é uma distribuição uniforme de entradas.\n\nA distribuição calculada é apresentada em uma tabela, onde você pode fazer suas próprias alterações ou deixar que o MeOS atualize sua distribuição, levando em consideração suas alterações. Quando estiver satisfeito com a distribuição, deixe o MeOS desenhar as categorias selecionadas.\n\nAs configurações básicas que você deve fazer é fornecer um primeiro horário permitido para iniciar e um menor intervalo permitido. O número máximo de largadas paralelas determina quantos competidores podem largar ao mesmo tempo. Um valor aumentado proporciona uma profundidade inicial mais curta.\n\nA fração de posições vagas controla o número de posições vagas. Se não precisar de vagas, digite 0%. O número esperado de inscrições tardias reserva espaço para estes na lista de partida com a garantia de que nenhum competidor que comece no mesmo horário terá o mesmo percurso.
+htmlhelp = O HTML pode ser exportado como uma tabela estruturada ou como um documento formatado livremente (mais semelhante às listas MeOS). Você também pode usar modelos de exportação para formatação personalizada: colunas, viradas de página base JavaScript, rolagem automática, etc. É possível adicionar modelos personalizados adicionando arquivos '.template' na pasta de dados MeOS. Se você usar um modelo, há vários parâmetros a serem definidos abaixo. A interpretação exata depende do modelo.\n\nSe você selecionar <Configurações da loja>, a lista e suas configurações serão armazenadas permanentemente na competição. Você pode então acessar a lista usando o MeOS como um servidor web (o serviço 'Servidor de Informações') ou exportar a lista automaticamente em intervalos regulares.
+info:advanceinfo = Falha ao iniciar o serviço para transferência instantânea de resultados. Os resultados serão recebidos com alguns segundos de atraso. Este é o comportamento esperado se mais de um processo MeOS for iniciado neste computador.
+info:customsplitprint = Você pode usar uma lista personalizada para a impressão dividida. Projete a lista e use a função 'Para tempos fracionados' no editor de lista para fazer alterações na impressão dividida.\n\nVocê pode controlar a lista a ser usada por equipe usando o modo de tabela.
+info:mapcontrol = O MeOS não consegue determinar qual função uma unidade possui, a menos que esteja diretamente conectada ao computador. Portanto, o código de picote programado é usado para determinar o tipo. Você pode controlar a interpretação abaixo. Números maiores que 30 são sempre interpretados como controles.\n\nTenha cuidado ao usar picotes e partida; eles podem substituir permanentemente o horário de partida sorteado.
+info:multieventnetwork = Para lidar com mais de um estágio você deve trabalhar localmente. Salve uma cópia da competição, abra-a localmente e transfira os resultados para a próxima etapa. Em seguida, carregue o próximo estágio no servidor.
+info:multiple_start = Um competidor pode fazer múltiplas partidas com o mesmo chip. Nova entrada automática para cada leitura.
+info:nosplitprint = Não é possível carregar a lista especificada.\n\nUsando padrões.
+info:pageswithcolumns = Mostra a lista uma página por vez, com o número especificado de colunas. Recarregue automaticamente os dados para cada rodada.
+info:readout_action = X: Chip nº. Y foi lido.\nAções manuais necessárias.
+info:readout_queue = X: Chip nº. Y foi lido.\nO chip foi colocado na fila.
+info:readoutbase = Ative a unidade de controle SI selecionando sua porta COM ou procurando unidades de controle SI instaladas. Pressione Informações para obter o status da porta selecionada.\n\nA leitura interativa permite lidar diretamente com problemas, como número de chip errado. Não use esta opção quando executores com problemas forem tratados separadamente.\n\nO banco de dados de executores será usado se você quiser adicionar novos executores automaticamente. Os picotes são usados para encontrar (adivinhar) a categoria certa.
+info:readoutmore = Bloqueie a função para evitar alterações acidentais.\n\nA seleção de som permite ativar a reprodução de sinais sonoros ao ler um chip.\n\nOpen Readout Window mostra uma nova janela projetada para ser mostrada em uma tela voltada para o competidor, mostrando informações sobre a última leitura.\n\nMúltiplas competições por competidor podem ser usadas se você tiver permissão para fazer várias tentativas no percurso. Uma nova entrada é criada para cada leitura.
+info:readoutwindow = A janela de leitura mostra informações sobre a última leitura de chip.
+info:runnerdbonline = Como você está conectado a um servidor, não é possível editar manualmente os bancos de dados de clubes e competidores. Faça alterações antes de enviar a competição para um servidor. Também é possível substituir o banco de dados existente no servidor importando um novo banco de dados (do IOF XML). Como você está conectado a um servidor, não é possível editar manualmente os bancos de dados de clubes e competidores. Faça alterações antes de enviar a competição para um servidor. Também é possível substituir o banco de dados existente no servidor importando um novo banco de dados (do IOF XML).
+info:teamcourseassignment = O arquivo importado contém dados de bifurcação para equipes. Para importar esses dados, você deve preparar a competição para corresponder ao arquivo importado: \n\n1. Certifique-se de que todas as categorias estejam configuradas com o número correto de etapas.\n2. Forneça números de peito em cada categoria. Use Configurações rápidas na página Equipes e insira o primeiro número de peito em cada Equipe (ou seja, configuração automática de peito). Você também pode importar as equipes primeiro e atribuir os coletes normalmente.\n3. Importe os percursos. Você pode importar esse arquivo várias vezes, se necessário, para atualizar a bifurcação.
+info_shortening = Selecione um percurso existente que encurte o percurso atual. Vários níveis de encurtamento são possíveis.
+inforestwarning = Nenhum competidor parece estar em curso. Como os dados por trás desta conclusão podem estar incorretos, você deve verificar se nenhum competidor foi deixado na floresta por outros meios.
+kartor = mapas
+klar = estável
+kontroll = controle
+kontroll X (Y) = controle X (Y)
+leder med X = lidera com X
+leder med X; har tappat Y = lidera com X; perdeu Y
+leder med X; sprang Y snabbare än de jagande = lidera com X; correu Y mais rápido que os outros
+listinfo:inputresults = Mostrar resultados de entrada de etapas anteriores.
+listinfo:singleclub = Crie uma lista de resultados para um único clube.\nUse o parâmetro de entrada para especificar o ID do clube.
+localhost = localhost
+lopp = corrida
+min/km = min/km
+mål = terminar
+målet = o final
+målet (X) = o final (X)
+newcmp:featuredesc = Selecione qual recurso MeOS você precisa para esta competição. Você pode adicionar ou remover recursos a qualquer momento selecionando <MeOS Features> na página Competição.
+nia = nona
+nionde = nono
+olshooting:notimepunishment = Lista de resultados Orientação/Tiro sem Punição de Tempo.\n\nAtive o suporte para cross-country e ajustes manuais de pontos. Utilize o campo Redução de pontos na página Competidores para especificar erros no formulário LLSS, onde LL significa erros deitados e SS significa erros em pé. Exemplo: 0201 significa 2 falso positivos e 1 erro em pé.
+olshooting:timepunishment = Lista de resultados Orientação/Tiro com Punição de Tempo.\n\nAtivar suporte para cross-country e ajustes manuais de pontos. Utilizar o campo Redução de pontos na página Competidores para especificar erros no formulário PPPLLSS, onde PPP é o erro de orientação por ponto em milímetros, LL erro deitado e SS é erro em pé. Exemplo 30201 significa erro de 3 mm, 2 erros de falso positivo e 1 erro de pé.
+open_error = Falha ao abrir X.\n\nY.
+open_error_locked = Esta competição já está aberta no MeOS.\n\nÉ necessário utilizar um banco de dados para abrir mais de uma instância da competição.
+prefsAccount = Número de conta padrão
+prefsAddress = Endereço padrão
+prefsAdvancedClassSettings = Mostrar configurações avançadas de categoria
+prefsAutoSaveTimeOut = Intervalo de backup automático (ms)
+prefsAutoTie = Empate competidor/chip automaticamente
+prefsAutoTieRent = Tratamento automático de chips contratados
+prefsCardFee = Taxa de chip padrão
+prefsClient = Nome do cliente em uma rede
+prefsCodePage = Tabela de códigos para texto de 8 bits na importação/exportação.
+prefsControlFrom = Último do controle
+prefsControlTo = Último a controlar
+prefsCurrencyFactor = Fator de escala monetária
+prefsCurrencyPreSymbol = Coloque o símbolo da moeda na frente
+prefsCurrencySeparator = Separador decimal de moeda
+prefsCurrencySymbol = Símbolo de moeda
+prefsDatabase = Usar banco de dados de competidores
+prefsDatabaseEngine = Tipo de tabela de banco de dados para novas competições (MySQL)
+prefsDatabaseUpdate = Atualização do banco de dados do último competidor
+prefsDefaultDrawMethod = Método de desenho padrão
+prefsDirectPort = Porta de rede para dados avançados de picote
+prefsDrawInterlace = Entrelace categoria/percurso ao desenhar listas iniciais
+prefsEMail = E-Mail
+prefsEliteFee = Taxa elite padrão
+prefsEntryFee = Taxa de entrada padrão
+prefsEventorBase = URL to Eventor
+prefsExpResFilename = Nome de arquivo de exportação padrão
+prefsExpTypeIOF = Tipo de exportação padrão
+prefsExpWithRaceNo = Incluir número da corrida ao exportar
+prefsExportCSVSplits = Incluir quebras na exportação csv
+prefsExportFormat = Formato de exportação preferido
+prefsFirstInvoice = Número da primeira fatura
+prefsFirstTime = Primeira inicialização
+prefsHomepage = Página inicial
+prefsImportOptions = Opção de importação preferida
+prefsInteractive = Manuseio interativo de chips
+prefsLastExportTarget = Último destino de exportação
+prefsLateEntryFactor = Fator para taxa de entrada tardia
+prefsLiveResultFont = Fonte usada para resultados ao vivo
+prefsMIPURL = URL para servidor MIP
+prefsMOPFolderName = Pasta MOP local
+prefsMOPURL = URL para servidor MOP
+prefsManualInput = Usar entrada manual de resultados
+prefsMaximumSpeakerDelay = Atraso máximo na atualização da visualização do locutor
+prefsNameMode = Formato do nome: 0 = 'Família N', 1 = 'Família, N'
+prefsNumSplitsOnePage = Número de chips por página
+prefsOrganizer = Organizador
+prefsPayModes = Modos de pagamento
+prefsPlaySound = Reproduzir sons
+prefsPort = Porta de Rede MySQL
+prefsRentCard = Aluguel de Chip
+prefsSeniorAge = Limite idade superior (pensionista)
+prefsServer = Servidor de rede padrão
+prefsServicePort = Porta de serviço padrão
+prefsServiceRootMap = Função padrão para root do servidor web
+prefsSoundAction = Arquivo de som, ação necessária
+prefsSoundLeader = Arquivo de som, líder da categoria
+prefsSoundNotOK = Arquivo de som, status não OK
+prefsSoundOK = Arquivo de som, status OK.
+prefsSpeakerShortNames = Use iniciais nos nomes
+prefsSplitLateFees = Divida as taxas atrasadas em parte normal e atrasada para exportação XML IOF
+prefsSplitPrintMaxWait = Tempo máximo de espera para impressão dividida
+prefsStreet = Endereço do organizador
+prefsSynchronizationTimeOut = Tempo limite de atualização da rede (ms)
+prefsTextFont = Fonte de texto MeOS
+prefsUseDirectSocket = Use dados de picote avançados
+prefsUseEventor = Usar Eventor
+prefsUseEventorUTC = Use o tempo coordenada universal UTC com Eventor
+prefsUseHourFormat = Use o formato HH:MM:SS em vez de MMM:SS
+prefsUserName = Nome de usuário MySQL
+prefsVacantPercent = Porcentagem de vaga padrão
+prefsVacantPosition = Colocação de vagas
+prefsWideSplitFormat = Imprimir dividido em colunas
+prefsYouthAge = Limite de idade baixo
+prefsYouthFee = Taxa reduzida
+prefsaddressxpos = Endereço coordenada x
+prefsaddressypos = Endereço coordenada y
+prefsclasslimit = Limite de resultados mostrados por categoria
+prefsintertime = Mostrar tempos intermediários
+prefspagebreak = Adicionar quebras de página
+prefsshowheader = Mostrar cabeçalhos de página
+prefssplitanalysis = Realizar análise de tempo parcial
+radio X = radio X
+red channel = canal vermelho
+reused card = chip reutilizado
+saknas = ausente
+se license.txt som levereras med programmet = consulte License.txt que é entregue com o software
+sekund = segundo
+sekunder = segundo
+serverbackup = backup do servidor
+sexa = sexto
+sjua = sétimo
+sjunde = sétimo
+sjätte = sexto
+skicka stämplar = enviar picotes
+skickar ut X = envia X
+sortering: X, antal rader: Y = ordem de classificação: X, número de linhas: Y
+starten (X) = a partida (X)
+sträcka X = perna X
+stämplade vid = picotado no
+stämplar vid X som Y, på tiden Z = picote X com Y, com tempo Z
+tar ledningen med tiden X = assume a liderança com o tempo X
+tar ledningen vid X med tiden Y = assume a liderança em X, tempo Y
+tia = décimo
+till = para
+tionde = décimo
+tolfte = décimo segundo
+tolva = décimo segundo
+tooltip:analyze = Analise dados e visualize a importação.
+tooltip:builddata = Amplie o conhecimento do MeOS sobre competidores, clubes e categorias analisando dados de competição.
+tooltip:import = Importe entradas do arquivo.
+tooltip:inforest = Lista de competidores na floresta e competidores que não largaram.
+tooltip:paste = Cole entradas da área de transferência.
+tooltip:resultprint = Imprimir resultados para exibir
+tooltip:voice = Avisos prévios de leitura de voz computacional.
+tooltip_explain_status = - = Status desconhecido (nenhum resultado ainda)\nOK = Resultado válido\nDNS = Não iniciado\nCancelado = Entrada cancelada (mostrada na lista inicial)\nMP = Picote ausente\nDNF = Não finalizou\nDISQ = Desqualificado\nOMT = Acima do tempo máximo \nOOC = Fora de competição\nNTP = Não participa
+trea = terceiro
+tredje = terceiro
+true[boolean] = verdadeiro(
+tvåa = segundo
+var först i mål med tiden X = foi o primeiro a terminar com o tempo X
+var först vid X med tiden Y = foi o primeiro em X com o tempo Y
+var först vid växeln med tiden X = foi o primeiro a fazer a mudança com o tempo X
+vid kontroll X = no Controle X
+väntas till X om någon minut = é esperado em breve para X
+väntas till X om någon minut, och kan i så fall ta en Y plats = é esperado para X em um minuto e pode ocupar o lugar Y
+väntas till X om någon minut, och kan i så fall ta ledningen = é esperado para X em um minuto e pode assumir a liderança
+växeln = a mudança
+växlar på X plats med tiden Y = muda como X com o tempo Y
+växlar på X plats, efter Y, på tiden Z = muda em um lugar X, atrás de Y, com o tempo Z
+växlar på delad X plats med tiden Y = muda como X com o tempo Y
+warn:changedtimezero = Não é recomendado alterar o tempo zero para uma competição com resultados.\n\nDeseja prosseguir mesmo assim?
+warn:changeid = O campo ID externo geralmente é usado para combinar entidades com outros bancos de dados (como sistemas de entrada, resultado ou economia). Se você fizer alterações incompatíveis, poderão surgir problemas diversos e difíceis de entender.
+warn:latestarttime = Não é recomendado usar horários de início mais de X horas após o horário zero, pois os chips SI mais antigos possuem apenas um relógio de 12 horas.\n\nDeseja continuar mesmo assim?
+warn:missingResult = X competidores ainda estão sem resultados e portanto, são excluídos.\n\nVocê deve gerenciar os competidores na floresta para atribuir o status <DNS> aos competidores restantes.
+warn:mysqlbinlog = Aviso de desempenho: não foi possível desativar o log binário. O upload pode ser lento.\n\nX
+warn:notextended = INFO: Programe a unidade com protocolo estendido no SportIdent Config+ para agilizar a leitura do chip.
+warn:olddbversion = O banco de dados está em uso por uma versão posterior do MeOS. A atualização é recomendada.
+warn:opennewversion = A competição é criada no MeOS X. Os dados podem ser perdidos se você continuar.\n\nDeseja continuar?
+warn:printmodeonly = Observe que você gerará apenas uma impressão do conteúdo do chip.\n\nPara salvar um resultado na competição você precisa selecionar a função leitura/rádio.
+warn:updatelegs = Os comprimentos dos trechos individuais do percurso podem exigir uma atualização após esta alteração. 
+warning:dbproblem = AVISO. Problemas com conexão ao banco de dados: 'X'. A conexão será restaurada automaticamente. Continue trabalhando normalmente.
+warning:direct_result = Observe que usar <Resultado no picote final> requer que todos os picotes de controle no percurso tenham sido enviados como controles de rádio ou que o MeOS seja usado apenas para cronometragem sem um percurso.\n\nUsar resultado no picote final?
+warning:drawresult = A categoria já tem resultados, os horários de partida serão substituídos. Você quer prosseguir?
+warning:has_entries = A categoria já tem competidores. Alterar a distribuição dos trechos neste estágio pode causar perda de dados.\n\nDeseja continuar?
+warning:has_results = A categoria já tem resultados. Alterar a distribuição das pernas neste estágio não é comum.\n\nDeseja continuar?
+xml-data = dados xml
+Äldre protokoll = protocolo antigo
+Äldre, från och med X år = Idosos, X anos e acima
+Ändra = Mudar
+Ändra MeOS lokala systemegenskaper = Alterar as propriedades do sistema local MeOS
+Ändra X = Alterar X
+Ändra grundläggande inställningar och gör en ny fördelning = Modifique as configurações básicas e faça uma nova distribuição
+Ändra inställningar = Modificar configurações
+Ändra klassinställningar = Alterar configurações de categoria
+Ändra lag = Mudar equipe
+Ändra lagets gaffling = Alterar bifurcação de equipe
+Ändra lokala inställningar = Alterar configurações locais
+Ändra sträckindelning = Modificar configuração da perna
+Ändrad = Modificado
+Ändrade avgift för X deltagare = Taxa modificada para X competidor(es)
+Åldersfilter = Filtro de idade
+Åldersfiltrering = Filtro de idade
+Åldersgräns ungdom = Limite de idade, baixo (jovens)
+Åldersgräns äldre = Limite de idade, alto (aposentado)
+Åldersgränser, reducerad anmälningsavgift = Limites de idade, redução de taxas
+Ångra = Desfazer
+Återansluten mot databasen, tävlingen synkroniserad = Reconectado ao banco de dados, competição sincronizada
+Återbud = Sair
+Återbud[status] = Cancelado
+Återgå = Retornar
+Återskapa = Restaurar Janelas
+Återskapa tidigare sparade fönster- och speakerinställningar = Recrie janelas e configurações salvas anteriormente
+Återställ = Reverter
+Återställ / uppdatera klasstillhörighet = Redefinir/atualizar categoria do competidor
+Återställ <Ej Start> till <Status Okänd> = Redefinir <DNS> para <Desconhecido>
+Återställ löpare <Ej Start> med registrering till <Status Okänd> = Redefinir status <DNS> para <Desconhecido> para competidores com registro
+Återställ säkerhetskopia = Restaurar backup
+Återställ tabeldesignen och visa allt = Restaurar design da tabela
+Åtgärd krävs = Ação necessária
+ÅÅÅÅ-MM-DD = YYYY-MM-DD
+Ökande = Aumentando
+Öppen = Abrir
+Öppen klass = Abrir Categoria
+Öppna = Abrir
+Öppna avläsningsfönster = Abrir janela de leitura
+Öppna fil = Abrir arquivo
+Öppna från aktuell tävling = Aberto desta competição
+Öppna föregående = Abrir precedente
+Öppna föregående etapp = Abrir etapa anterior
+Öppna i ett nytt fönster = Abrir em uma nova janela
+Öppna klasser, ungdom = Categorias abertas, jovens
+Öppna klasser, vuxna = Categorias abertas, adultos
+Öppna nästa = Abrir próximo
+Öppna nästa etapp = Abrir próxima etapa
+Öppna tävling = Competição Aberta
+Öppna vald tävling = Abrir competição selecionada
+Öppnad tävling = Competição aberta
+Överför anmälda = Transferir entradas
+Överför nya deltagare i ej valda klasser med status "deltar ej" = Transferir novos competidores nas demais categorias com status <Não participante>
+Överför resultat = Resultados da transferência
+Överför resultat till X = Transferindo resultados para X
+Överför resultat till nästa etapp = Transferir resultados para a próxima etapa
+Överföring = Transferir
+Övertid = Fora do tempo
+Övre datumgräns = Limite superior de data
+Övre gräns (år) = Limite superior (anos)
+Övre ålder = Idade avançada
+Övriga = Outro
+Övrigt = Diversos 
+är X efter = está X atrás
+är X efter Y = é X atrás de Y
+är X efter; har tagit in Y = está X atrás; ganhou Y
+är X efter; har tappat Y = está X atrás; perdeu Y
+är X före Y = é X antes de Y
+är först i mål med tiden X = é o primeiro a terminar com o tempo X
+är först vid X med tiden Y = é o primeiro em X com o tempo Y
+är först vid växeln med tiden X = é o primeiro a fazer a mudança com o tempo X
+är inte godkänd = é desclassificado
+är nu på X plats med tiden Y = está agora em um lugar X com o tempo Y
+är nu på delad X plats med tiden Y = está agora em um lugar X compartilhado com o tempo Y
+återställd = restaurado
+åtta = oito
+åttonde = oitavo
+övriga = outro
+Bild = Imagem
+Bild under text = Imagem atrás do texto
+Bilder = Imagens
+Bredd = Largura
+Empty Results Split Print = Impressão separada de resultados vazios
+Förskjutning = Deslocamento
+Gafflingar lagvis = Bifurcações, em equipe
+Horisontell = Horizontal
+Höjd = Altura
+Individual Results Split Print = Impressão separada de resultados individuais
+Ingen[bild] = Nenhum
+Klubbstartlista, lag = Lista de partida do clube, equipe
+Ny bild = Nova imagem
+Relay Results Split Print = Impressão dividida dos resultados do revezamento
+Relay/Team Results Split Print = Impressão separada de resultados de revezamento/equipe
+Tolka vitt som genomskinligt = Branco como transparente
+Vertikal = Vertical
+Välj bild = Selecione a imagem
+Välj bland befintliga bilder = Selecione a imagem existente
+Bevara höjd/bredd-relationen = Preservar proporção
+RunnerLegTeamLeaderName = Primeiro competidor da equipe a terminar a perna
+info:offsetclassid = Se você importar inscrições e categorias de fontes diferentes para a mesma competição, pode acontecer que haja conflitos nos números de ID das categorias. Para separar as categorias, você pode inserir um deslocamento para o ID da categoria ao trabalhar com arquivos de uma fonte específica; isso será adicionado aos números de Id.\n\nVocê deve especificar o mesmo deslocamento cada vez que importar dessa fonte.\n\n Um número adequado pode ser 1000 (que funcionará desde que cada Id seja menor que 1000).
+Förskjutning av klassers Id = ID da categoria de corte
diff --git a/code/prefseditor.cpp b/code/prefseditor.cpp
index 869384e..30540e2 100644
--- a/code/prefseditor.cpp
+++ b/code/prefseditor.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -51,7 +51,7 @@ void PrefsEditor::showPrefs(gdioutput &gdi) {
 
   const int bw = gdi.scaleLength(80);
   int basePos = gdi.getCX();
-  int valuePos = basePos + gdi.scaleLength(160);
+  int valuePos = basePos + gdi.scaleLength(200);
   int editPos = valuePos + gdi.scaleLength(280);
   int descPos = editPos + bw + gdi.scaleLength(10);
 
diff --git a/code/prefseditor.h b/code/prefseditor.h
index 029d92b..fedfbd7 100644
--- a/code/prefseditor.h
+++ b/code/prefseditor.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/printer.cpp b/code/printer.cpp
index c5f336b..3208943 100644
--- a/code/printer.cpp
+++ b/code/printer.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -768,10 +768,10 @@ void PageInfo::renderPages(const list<TextInfo> &tl,
 
     pages.back().calculateCS(text.ti);
 #ifdef _DEBUG
-    static wchar_t breakbuff[8] = L"1429586";
+    /*static wchar_t breakbuff[8] = L"1429586";
     if (text.ti.text == breakbuff) {
       text.ti.text.empty(); // Break when hitting symbol
-    }
+    }*/
 #endif
 
     if (k + 1 < indexedTL.size() && tlp->yp != indexedTL[k+1].yp) {
diff --git a/code/progress.cpp b/code/progress.cpp
index 40d3805..428c1ec 100644
--- a/code/progress.cpp
+++ b/code/progress.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/progress.h b/code/progress.h
index 5adadab..21a717c 100644
--- a/code/progress.h
+++ b/code/progress.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/qf_editor.cpp b/code/qf_editor.cpp
new file mode 100644
index 0000000..a3e9212
--- /dev/null
+++ b/code/qf_editor.cpp
@@ -0,0 +1,796 @@
+/************************************************************************
+    MeOS - Orienteering Software
+    Copyright (C) 2009-2024 Melin Software HB
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+    Melin Software HB - software@melin.nu - www.melin.nu
+    Eksoppsv�gen 16, SE-75646 UPPSALA, Sweden
+
+************************************************************************/
+
+#include "stdafx.h"
+#include "gdioutput.h"
+#include "qf_editor.h"
+#include "qualification_final.h"
+#include "localizer.h"
+#include "oClass.h"
+#include "meosexception.h"
+#include "TabBase.h"
+
+QFEditor::QFEditor() {
+  emptyScheme();
+}
+
+QFEditor::~QFEditor() = default;
+
+void QFEditor::emptyScheme() {
+  currentQF = make_shared<QualificationFinal>(0, 0);
+  data.clear();
+  data.resize(2, { 1, {} });
+  data[0].second.emplace_back(lang.tl("Kval"));
+  data[1].second.emplace_back(lang.tl("Final"));
+  numLevels = 2;
+  makeDirty(DirtyFlag::ClearDirty, DirtyFlag::ClearDirty);
+}
+
+void QFEditor::load(const shared_ptr<QualificationFinal>& qf) {
+  currentQF = make_shared<QualificationFinal>(*qf);
+  data.clear();
+  data.resize(currentQF->getNumLevels());
+  for (int j = 0; j < currentQF->getNumClasses(); j++) {
+    int level = currentQF->getLevel(j+1);
+    data.at(level).second.push_back(currentQF->getInstance(j));
+    data[level].first++;
+  }
+  numLevels = data.size();
+}
+
+void QFEditor::makeQF() {
+  vector<QFClass> linear;
+  for (int j = 0; j < numLevels; j++) {
+    for (int i = 0; i < data[j].first; i++) {
+      linear.push_back(data[j].second[i]);
+      linear.back().level = j;
+    }
+  }
+  
+  currentQF->setClasses(linear);
+}
+
+
+void QFEditor::show(gdioutput& gdi) {
+  gdi.clearPage(false);
+  gdi.pushX();
+  gdi.fillRight();
+  gdi.addButton("CloseEditor", "St�ng").setHandler(this);
+  gdi.addButton("New", "Nytt").setHandler(this);
+  gdi.addButton("Load", "Ladda").setHandler(this);
+  gdi.addButton("Save", "Exportera").setHandler(this);
+  if (cls)
+    gdi.addButton("Use", L"Use in X#" + cls->getName()).setHandler(this);
+  
+  gdi.popX();
+
+  updateActions(gdi);
+
+  gdi.fillDown();
+  gdi.dropLine(3);
+  gdi.addSelection("Levels", 100, 100, nullptr, L"Antal niv�er:").setHandler(this);
+  
+  vector<pair<wstring, size_t>> levels;
+  for (int i = 2; i <= 10; i++) 
+    levels.emplace_back(itow(i), i);
+
+  gdi.setItems("Levels", levels);
+  gdi.selectItemByData("Levels", numLevels);
+  gdi.autoGrow("Levels");
+  gdi.setRestorePoint("LevelView");
+
+  showLevels(gdi);
+  gdi.refresh();
+}
+
+void QFEditor::showLevels(gdioutput& gdi) const {
+  for (int level = 0; level < numLevels; level++) {
+    showLevel(gdi, level, data[level].first, data[level].second);
+  }
+}
+
+void QFEditor::showLevel(gdioutput& gdi, int level, size_t numRaces, const vector<QFClass>& classes) const {
+  const int cxBase = gdi.getCX();
+  int cy = gdi.getCY();
+
+  gdi.setRestorePoint("Level" + itos(level));
+  gdi.fillDown(); 
+
+  RECT rcR = { cxBase, cy, cxBase + gdi.scaleLength(400), cy + gdi.scaleLength(2) };
+  gdi.addRectangle(rcR, colorDarkBlue);
+
+  gdi.addString("", fontMediumPlus, "Niv� X#" + itos(level + 1));
+  string cKey = "NumCls" + itos(level);
+  gdi.addSelection(cKey, 100, 100, nullptr, L"Antal klasser:").setHandler(this).setExtra(level);
+
+  vector<pair<wstring, size_t>> levels;
+  
+  for (int i = 1; i <= 32; i++)
+    levels.emplace_back(itow(i), i);
+
+  gdi.setItems(cKey, levels);
+  gdi.autoGrow(cKey.c_str());
+  gdi.selectItemByData(cKey, numRaces);
+  bool rankBased = classes.size() > 0 && classes[0].rankLevel;
+
+  if (level > 0) {
+    gdi.addCheckbox("Rank" + itos(level), "Klass efter ranking", nullptr, rankBased,
+      "Anv�nd ranking ist�llet f�r placering i kval f�r att placera kvalificerade l�pare i klasser").setExtra(level).setHandler(this);
+  }
+//  auto rc = gdi.getDimensionSince("Level" + itos(level));
+
+  gdi.setCX(gdi.scaleLength(230));
+  
+  const int cxCls = gdi.getCX();
+  int cx = cxCls;
+  gdi.fillDown();
+  cy += gdi.scaleLength(10);
+  const int w = gdi.scaleLength(24 * 10);
+  int ww, hh;
+  gdi.getTargetDimension(ww, hh);
+  ww = max(ww, gdi.scaleLength(500));
+  for (int i = 0; i < numRaces; i++) {
+    gdi.setCY(cy);
+    gdi.setCX(cx);
+    string CK = getKeyTag(level, i);
+    auto& ref = gdi.addInput("Name" + CK, classes[i].name.empty() ? wstring(L"???") : classes[i].name, 24, nullptr,
+      L"Klass X (namnsuffix):#" + itow(i + 1));
+    ref.setHandler(this).setExtra(code(level, i));
+    
+    if (level > 0) {
+      gdi.addString("QInfo" + CK, 0, classes[i].getQualInfo());
+      gdi.addButton("Edit", "Redigera...").setHandler(this).setExtra(code(level, i));
+    }
+    cx += w;
+    if (cx + w > ww) {
+      cx = cxCls;
+      gdi.dropLine(2);
+      cy = gdi.getCY();
+    }
+  }
+
+  gdi.dropLine(3);
+  gdi.setCX(cxBase);
+}
+
+void QFEditor::loadQualificationView(gdioutput& gdi, const QFClass& cls, int cCode) {
+  gdi.clearPage(false);
+  gdi.fillDown();
+  gdi.addString("", boldLarge, L"Kvalificeringsregler f�r X#" + cls.name);
+
+  gdi.pushY();
+  gdi.setRestorePoint("X");
+  gdi.addListBox("Rules", 120, 150, nullptr, L"Regler").setExtra(cCode).setHandler(this);
+  gdi.setItems("Rules", getRules(cls));
+  gdi.addButton("RemoveRule", "Ta bort").setHandler(this).setExtra(cCode);
+  gdi.disableInput("RemoveRule");
+
+
+  gdi.popY();
+  gdi.dropLine();
+  auto rc = gdi.getDimensionSince("X");
+  gdi.setCX(rc.right + gdi.scaleLength(10));
+
+  rcRuleForm.left = gdi.getCX();
+  rcRuleForm.top = gdi.getCY();
+  gdi.dropLine(0.8);
+  gdi.setCX(rcRuleForm.left + gdi.scaleLength(10));
+  gdi.pushX();
+  gdi.fillDown();
+  gdi.addString("", fontMediumPlus, "L�gg till regler");
+  gdi.dropLine();
+
+  gdi.addSelection("RuleType", 200, 100).setHandler(this).setExtra(cCode);
+
+  vector<pair<wstring, size_t>> ruleType;
+  for (auto* type : { "Klass / placering", "B�sta tid", "�vriga okvalificerade"}) {
+    ruleType.emplace_back(lang.tl(type), ruleType.size());
+  }
+  gdi.setItems("RuleType", ruleType);
+  gdi.selectFirstItem("RuleType");
+  gdi.setRestorePoint("RuleType");
+  //other.emplace_back(lang.tl("Inga"), 0);
+  
+  //gdi.addString("", gdiFonts::boldText, "Klass / placering");
+  addRuleClassPlace(cCode, gdi);
+
+  /*gdi.dropLine(2.5);
+  rcE.bottom = gdi.getCY();
+  rcE.right = gdi.getWidth();
+  gdi.addRectangle(rcE, GDICOLOR::colorLightCyan);
+  gdi.dropLine();
+
+  gdi.setCX(rcE.right - gdi.scaleLength(75));
+  gdi.setCY(gdi.getHeight());
+  gdi.addButton("Close", "St�ng").setHandler(this);
+  gdi.refresh();*/
+}
+
+void QFEditor::addRuleClassPlace(int cCode, gdioutput& gdi) {
+  pair<int, int> levelClass = decode(cCode);
+  gdi.addSelection("Classes", 150, 200, nullptr, L"Kvalklass:");
+  if (levelClass.first > 0 && levelClass.first < data.size()) {
+    vector<pair<wstring, size_t>> prevLevel;
+    for (int i = levelClass.first - 1; i >= 0; i--) {
+      auto& dLine = data[i];
+      for (int j = 0; j < dLine.first; j++)
+        prevLevel.emplace_back(dLine.second[j].name, code(i, j));
+    }
+    gdi.setItems("Classes", prevLevel);
+    gdi.autoGrow("Classes");
+    gdi.selectFirstItem("Classes");
+  }
+  gdi.fillRight();
+  gdi.addInput("Places", L"", 10, nullptr, L"Placeringar");
+  gdi.fillDown();
+  gdi.dropLine(0.9);
+  gdi.addButton("AddClassPlace", "L�gg till").setHandler(this).setExtra(cCode);
+  gdi.popX();
+  endAddRuleForm(gdi);
+}
+
+void QFEditor::addRuleTime(int cCode, gdioutput& gdi) {
+  gdi.dropLine();
+  gdi.addString("", gdiFonts::boldText, "B�sta tid");
+  gdi.addButton("AddBestTime", "L�gg till").setHandler(this).setExtra(cCode);
+  endAddRuleForm(gdi);
+}
+
+void QFEditor::addRuleOther(int cCode, gdioutput &gdi) {
+//  gdi.addString("", gdiFonts::boldText, "�vriga okvalificerade:");
+
+  gdi.pushX();
+  gdi.fillRight();
+  gdi.addSelection("Other", 100, 200).setExtra(cCode).setHandler(this);
+  vector<pair<wstring, size_t>> other;
+  other.emplace_back(lang.tl("Inga"), 0);
+  other.emplace_back(lang.tl("Alla"), 1);
+  other.emplace_back(lang.tl("N b�sta"), 2);
+  other.emplace_back(lang.tl("Tidskval"), 3);
+  gdi.setItems("Other", other);
+  gdi.autoGrow("Other");
+
+  gdi.addButton("AddOther", "L�gg till").setHandler(this).setExtra(cCode);
+
+  gdi.popX();
+  gdi.dropLine(3);
+  QFClass& cls = getQFClass(cCode);
+
+  int toSel = 1;
+  if (cls.extraQualification == QFClass::ExtraQualType::All)
+    toSel = 1;
+  else if (cls.extraQualification == QFClass::ExtraQualType::NBest)
+    toSel = 2;
+  else if (cls.extraQualification == QFClass::ExtraQualType::TimeLimit)
+    toSel = 3;
+
+  gdi.selectItemByData("Other", toSel);
+  extraSelPosX = gdi.getCX();
+  extraSelPosY = gdi.getCY();
+  updateExtraField(gdi, cls, cCode);
+  gdi.setCY(extraSelPosY);
+  gdi.dropLine(3);
+  endAddRuleForm(gdi);
+}
+
+void QFEditor::endAddRuleForm(gdioutput &gdi) {
+  gdi.dropLine(2.5);
+  rcRuleForm.bottom = gdi.getCY();
+  rcRuleForm.right = gdi.getWidth();
+  gdi.addRectangle(rcRuleForm, GDICOLOR::colorLightCyan);
+  gdi.dropLine();
+
+  gdi.setCX(rcRuleForm.right - gdi.scaleLength(75));
+  gdi.setCY(gdi.getHeight());
+  gdi.addButton("Close", "St�ng").setHandler(this);
+  gdi.refresh();
+}
+
+void QFEditor::updateExtraField(gdioutput& gdi, const QFClass& cls, int code) {
+  int type = gdi.getSelectedItem("Other").first;
+  if (type == 2) {
+    wstring def = cls.extraQualification == QFClass::ExtraQualType::NBest ? itow(cls.extraQualData) : L"0";
+    if (!gdi.hasWidget("NBest"))
+      gdi.addInput(extraSelPosX, extraSelPosY, "NBest", def, 6).setHandler(this).setExtra(code);
+    else
+      gdi.setText("NBest", def)->setExtra(code);
+  }
+  else if (gdi.hasWidget("NBest"))
+    gdi.removeWidget("NBest");
+
+  if (type == 3) {
+    wstring def = cls.extraQualification == QFClass::ExtraQualType::TimeLimit ?
+      formatTimeMS(cls.extraQualData, false) : L"0:00";
+
+    if (!gdi.hasWidget("TimeLimit"))
+      gdi.addInput(extraSelPosX, extraSelPosY, "TimeLimit", def , 6).setHandler(this).setExtra(code);
+    else
+      gdi.setText("TimeLimit", def)->setExtra(code);
+  }
+  else if (gdi.hasWidget("TimeLimit"))
+    gdi.removeWidget("TimeLimit");
+}
+
+vector<pair<wstring, size_t>> QFEditor::getRules(const QFClass& cls) const {
+  vector<pair<wstring, size_t>> qf;
+  for (int j = 0; j < cls.qualificationMap.size(); j++) {
+    auto& q = cls.qualificationMap[j];
+    int qIx = q.first;
+    pair<int, int> ix = getLevelIndexFromLinear(qIx);
+    if (ix.first == -1)
+      qf.emplace_back(L"???", -1);
+    else {
+      qf.emplace_back(itow(j+1) + L": " + data[ix.first].second[ix.second].name + L" / " + itow(q.second), j);
+    }
+  }
+
+  int base = cls.qualificationMap.size() + 1;
+  for (int j = 0; j < cls.numTimeQualifications; j++) {
+    qf.emplace_back(itow(base++) + lang.tl(" B�sta tid"), 1000 + j);
+  }
+
+  if (cls.extraQualification == QFClass::ExtraQualType::All)
+    qf.emplace_back(itow(base++) + lang.tl(" Alla �vriga"), 10000);
+  else if(cls.extraQualification == QFClass::ExtraQualType::NBest)
+    qf.emplace_back(itow(base++) + lang.tl(" X b�sta#" + itos(cls.extraQualData) ), 10000);
+  else if (cls.extraQualification == QFClass::ExtraQualType::TimeLimit)
+    qf.emplace_back(itow(base++) + lang.tl(L" Tidskval: X#" + formatTimeMS(cls.extraQualData, false)), 10000);
+
+  return qf;
+}
+
+QFClass& QFEditor::getQFClass(int id) {
+  auto key = decode(id);
+  if (key.first < data.size() && key.second < data[key.first].second.size()) {
+    return data[key.first].second[key.second];
+  }
+  throw meosException("Internal error");
+}
+
+const QFClass& QFEditor::getQFClass(int id) const {
+  return const_cast<QFEditor*>(this)->getQFClass(id);
+}
+
+int QFEditor::getLinearIndex(int level, int ix) const {
+  int lx = 0;
+  for (int j = 0; j <= level; j++) {
+    if (j < level)
+      lx += data[j].first;
+    else
+      return lx + ix + 1; // One indexed
+  }
+  return -1;
+}
+
+pair<int, int> QFEditor::getLevelIndexFromLinear(int linearIndex) const {
+  int lx = 0;
+  for (int j = 0; j <= numLevels; j++) {
+    if (lx + data[j].first < linearIndex)
+      lx += data[j].first;
+    else {
+      return make_pair(j, linearIndex - lx - 1); // linearIndex is one indexed
+    }
+  }
+  return make_pair(-1, -1);
+}
+
+vector<pair<int, int>> QFEditor::getLevelIndex() const {
+  vector<pair<int, int>> out;
+  out.emplace_back(-1, -1);
+  for (int j = 0; j < numLevels; j++) {
+    for (int i = 0; i < data[j].first; i++)
+      out.emplace_back(j+1, i+1);
+  }
+  return out;
+}
+
+void QFEditor::updateLevelMap(const vector<pair<int, int>>& oldIndex) {
+  auto newIndex = getLevelIndex();
+  map<pair<int, int>, int> levelMap;
+  for (int j = 1; j < newIndex.size(); j++) 
+    levelMap[newIndex[j]] = j;
+  
+  for (auto& d : data) {
+    for (auto &dc : d.second) {
+      for (auto& clpPlace : dc.qualificationMap) {
+        if (clpPlace.first < oldIndex.size()) {
+          auto res = levelMap.find(oldIndex[clpPlace.first]);
+          if (res == levelMap.end())
+            clpPlace.first = -1;
+          else
+            clpPlace.first = res->second;
+        }
+        else {
+          clpPlace.first = -1;
+        }
+      }
+      auto it = remove_if(dc.qualificationMap.begin(), dc.qualificationMap.end(), [](auto v)->bool {return v.first == -1; });
+      dc.qualificationMap.erase(it, dc.qualificationMap.end());
+    }
+  }
+}
+
+QFClass& QFEditor::getQFClassFromIndex(int linearIndex) {
+  auto v = getLevelIndexFromLinear(linearIndex);
+  return data[v.first].second[v.second];
+}
+
+void QFEditor::handle(gdioutput& gdi, BaseInfo& info, GuiEventType type) {
+  if (type == GUI_TIMER) {
+    if (info.id == "Reload") {
+      gdi.restore("LevelView", false);
+      showLevels(gdi);
+      gdi.refresh();
+    }
+  }
+  else if (type == GUI_INPUTCHANGE) {
+    InputInfo& ii = dynamic_cast<InputInfo&>(info);
+    if (ii.id.substr(0, 4) == "Name") {
+      if (trim(ii.text).empty())
+        ii.setBgColor(GDICOLOR::colorLightRed);
+      else {
+        ii.setBgColor(GDICOLOR::colorDefault);
+      }
+      ii.refresh();
+    }
+  }
+  else if (type == GUI_INPUT) {
+    InputInfo& ii = dynamic_cast<InputInfo&>(info);
+    if (ii.id.substr(0, 4) == "Name") {
+      QFClass& cls = getQFClass(ii.getExtraInt());
+      wstring tt = trim(ii.text);
+      if (!tt.empty()) {
+        if (tt != cls.name && !(cls.name.empty() && tt == ii.getPreviousText())) {
+          cls.name = tt;
+          edit(gdi);
+        }
+      }
+      else {
+        gdi.setText(ii.id, ii.getPreviousText());
+        ii.setBgColor(GDICOLOR::colorDefault);
+      }
+    }
+  }
+  else if (type == GUI_BUTTON) {
+    ButtonInfo& bi = dynamic_cast<ButtonInfo&>(info);
+    if (bi.id == "AddClassPlace") {
+      wstring place = gdi.getText("Places");
+      vector<wstring> sPlace;
+      split(place, L" ;,", sPlace);
+      vector<int> iPlace;
+      for (auto& sp : sPlace) {
+        int p = _wtoi(sp.c_str());
+        if (p > 0)
+          iPlace.push_back(p);
+      }
+      if (iPlace.empty())
+        throw meosException("Ange vilka placeringar i kalssen som kvalificerar hit, t.ex. '1,3'");
+      
+      pair<int, int> levelCls = decode(bi.getExtraInt());
+      QFClass& cls = getQFClass(bi.getExtraInt());
+
+      int codedTarget = gdi.getSelectedItem("Classes").first;
+      pair<int, int> levelClsTgt = decode(codedTarget);
+      
+      int linearCode = getLinearIndex(levelClsTgt.first, levelClsTgt.second);
+      int level = levelCls.first;
+      wstring errInfo;
+      for (int place : iPlace) {
+        pair<int, int> codedClassPlace(linearCode, place);
+
+        bool add = true;
+        for (int j = 0; j < data.size(); j++) {
+          for (int i = 0; i < data[j].first; i++) {
+            auto& c = data[j].second[i];
+            if (count(c.qualificationMap.begin(), c.qualificationMap.end(), codedClassPlace)) {
+              wstring info = lang.tl(L"Placering X kvalificerar till Y#" + itow(place) + L"#" + c.name);
+              if (errInfo.empty())
+                errInfo = info;
+              else
+                errInfo = L"\n" + info;
+              add = false;
+              break;
+            }
+          }
+        }
+        if (add)
+          cls.qualificationMap.push_back(codedClassPlace);
+
+        // Clear from unused data
+        for (int j = 0; j < data.size(); j++) {
+          for (int i = data[j].first; i < data[j].second.size(); i++) {
+            auto& c = data[j].second[i];
+            if (!c.qualificationMap.empty())
+              c.qualificationMap.erase(remove(c.qualificationMap.begin(), c.qualificationMap.end(), codedClassPlace));
+          }
+        }
+      }
+      sort(cls.qualificationMap.begin(), cls.qualificationMap.end());
+      gdi.setItems("Rules", getRules(cls));
+      updateQInfo(cls);
+      gdi.setText("Places", L"", true);
+      if (!errInfo.empty()) {
+        gdi.alert(errInfo);
+      }
+    }
+    else if (bi.id == "AddBestTime") {
+      QFClass& cls = getQFClass(bi.getExtraInt());
+      cls.numTimeQualifications++;
+      gdi.setItems("Rules", getRules(cls));
+      updateQInfo(cls);
+      gdi.setText("Places", L"", true);
+    }
+    else if (bi.id == "AddOther") {
+      QFClass& cls = getQFClass(bi.getExtraInt());
+      ListBoxInfo lbi;
+      gdi.getSelectedItem("Other", lbi);
+      int tp = lbi.data;
+      if (tp == 0)
+        cls.extraQualification = QFClass::ExtraQualType::None;
+      else if (tp == 1)
+        cls.extraQualification = QFClass::ExtraQualType::All;
+      else if (tp == 2) {       
+        cls.extraQualification = QFClass::ExtraQualType::NBest;
+        cls.extraQualData = max(_wtoi(gdi.getText("NBest").c_str()), 0);
+      }
+      else if (tp == 3) {       
+        cls.extraQualification = QFClass::ExtraQualType::TimeLimit;
+        cls.extraQualData = convertAbsoluteTimeMS(gdi.getText("TimeLimit").c_str());
+        if (cls.extraQualData == NOTIME || cls.extraQualData < 0)
+          cls.extraQualData = 0;
+      }
+
+      gdi.setItems("Rules", getRules(cls));
+      updateQInfo(cls);
+    }
+    else if (bi.id == "RemoveRule") {
+      auto sel = gdi.getSelectedItem("Rules");
+      QFClass& cls = getQFClass(bi.getExtraInt());
+      if (sel.second) {
+        int id = sel.first;
+        if (id < 1000) {
+          cls.qualificationMap.erase(cls.qualificationMap.begin() + id);
+        }
+        else if (id < 10000 && cls.numTimeQualifications > 0)
+          cls.numTimeQualifications--;
+        else if (id == 10000)
+          cls.extraQualification = QFClass::ExtraQualType::None;
+
+        gdi.setItems("Rules", getRules(cls));
+        updateQInfo(getQFClass(bi.getExtraInt()));
+        gdi.disableInput("RemoveRule");
+      }
+    }
+    else if (bi.id.substr(0, 4) == "Rank") {
+      int level = bi.getExtraInt();
+      if (level < data.size()) {
+        edit(gdi);
+        bool rnk = gdi.isChecked(bi.id);
+        for (auto& d : data[level].second)
+          d.rankLevel = rnk;
+      }
+      else
+        throw meosException("Internal error");
+    }
+    else if (bi.id == "Edit") {
+      QFClass& qfc = getQFClass(bi.getExtraInt());
+      pair<int, int> LIX = decode(bi.getExtraInt());
+      infoTextTag = "QInfo" + getKeyTag(LIX.first, LIX.second);
+      infoTextGdi = &gdi;
+
+      gdioutput* qual_settings = getExtraWindow("qualification", true);
+      if (!qual_settings) {
+        qual_settings = createExtraWindow("qualification", L"Qualification", gdi.scaleLength(700), gdi.scaleLength(500), true);
+        loadQualificationView(*qual_settings, qfc, bi.getExtraInt());
+      }
+    }
+    else if (bi.id == "Close") {
+      gdioutput* qual_settings = getExtraWindow("qualification", false);
+      if (qual_settings) {
+        qual_settings->closeWindow();
+        infoTextGdi = nullptr;
+      }
+    }
+    else if (bi.id == "New" || bi.id == "CloseEditor") {
+      if (checkSave(gdi)) {
+        gdioutput* qual_settings = getExtraWindow("qualification", false);
+        if (qual_settings) {
+          qual_settings->closeWindow();
+          infoTextGdi = nullptr;
+        }
+        if (bi.id == "New") {
+          emptyScheme();
+          if (cls  && cls->getQualificationFinal())
+            cls = nullptr; // Clear connection to class
+          show(gdi);
+        }
+        else {
+          gdi.getTabs().get(TClassTab)->loadPage(gdi);
+          return;
+        }
+      }
+    }
+    else if (bi.id == "Use") {
+      if (cls) {
+        use();
+        updateActions(gdi);
+      }
+    }
+    else if (bi.id == "Load") {
+      vector<pair<wstring, wstring>> ext;
+      ext.push_back(make_pair(L"Qualfication/Final", L"*.xml"));
+      wstring fileName = gdi.browseForOpen(ext, L"xml");
+      if (!fileName.empty()) {
+        auto newQF = make_shared<QualificationFinal>(0, 0);
+        newQF->importXML(fileName);
+        load(newQF);
+        makeDirty(QFEditor::DirtyFlag::MakeDirty, QFEditor::DirtyFlag::ClearDirty);
+        show(gdi);
+      }
+    }
+    else if (bi.id == "Save") {
+      if (save(gdi))
+        updateActions(gdi);
+    }
+  }
+  else if (type == GUI_LISTBOX) {
+    ListBoxInfo& lbi = dynamic_cast<ListBoxInfo&>(info);
+
+    if (lbi.id == "Levels") {
+      auto origiIndex = getLevelIndex();
+      numLevels = lbi.data;
+      if (numLevels > data.size()) {
+        data.resize(numLevels);
+        for (auto& d : data) {
+          if (d.first == 0) {
+            d.first = 1;
+            d.second.emplace_back(lang.tl("Klass"));
+          }
+        }
+      }
+      edit(gdi);
+      updateLevelMap(origiIndex);
+      gdi.addTimeoutMilli(25, "Reload", nullptr).setHandler(this);
+      gdioutput* qual_settings = getExtraWindow("qualification", false);
+      if (qual_settings)
+        qual_settings->closeWindow();
+    }
+    else if (lbi.id.substr(0, 6) == "NumCls") {
+      int numCls = lbi.data;
+      int level = lbi.getExtraInt();
+      if (level < data.size()) {
+        auto origiIndex = getLevelIndex();
+        wstring bn = lang.tl("Class");
+        bool rnk = false;
+        if (!data[level].second.empty()) {
+          bn = data[level].second.back().name;
+          rnk = data[level].second.front().rankLevel;
+        }
+        while (numCls >= data[level].second.size()) {
+          data[level].second.emplace_back(bn);
+          data[level].second.back().rankLevel = rnk;
+        }
+        data[level].first = numCls;
+        updateLevelMap(origiIndex);
+      }
+      else
+        throw meosException("Internal error");
+
+      edit(gdi);
+      gdi.addTimeoutMilli(25, "Reload", nullptr).setHandler(this);
+      gdioutput* qual_settings = getExtraWindow("qualification", false);
+      if (qual_settings)
+        qual_settings->closeWindow();
+    }
+    else if (lbi.id == "Rules") {
+      gdi.setInputStatus("RemoveRule", lbi.data != -1);
+    }
+    else if (lbi.id == "RuleType") {
+      int cCode = lbi.getExtraInt();
+      gdi.restoreNoUpdate("RuleType");
+      if (lbi.data == 0)
+        addRuleClassPlace(cCode, gdi);
+      else if (lbi.data == 1)
+        addRuleTime(cCode, gdi);
+      else if (lbi.data == 2)
+        addRuleOther(cCode, gdi);
+    }
+    else if (lbi.id == "Other") {
+      QFClass& cls = getQFClass(lbi.getExtraInt());
+      updateExtraField(gdi, cls, lbi.getExtraInt());
+    }
+  }
+}
+
+string QFEditor::getKeyTag(int level, int ix) {
+  return "L" + itos(level) + "C" + itos(ix);
+}
+
+void QFEditor::updateQInfo(const QFClass& cls) {
+  if (infoTextGdi) {
+    edit(*infoTextGdi);
+    infoTextGdi->setText(infoTextTag, lang.tl(cls.getQualInfo()), true);
+  }
+}
+
+bool QFEditor::checkSave(gdioutput& gdi) {
+  if (cls != nullptr && dirtyInt) {
+    auto ans = gdi.askCancel(L"Vill du uppdatera X med �ndringarna?#" + cls->getName());
+    if (ans == gdioutput::AskAnswer::AnswerCancel)
+      return false;
+    else if (ans == gdioutput::AskAnswer::AnswerYes)
+      use();
+  }
+  else if (cls == nullptr && dirtyExt) {
+    auto ans = gdi.askCancel(L"Vill du spara �ndringar?");
+    if (ans == gdioutput::AskAnswer::AnswerCancel)
+      return false;
+    else if (ans == gdioutput::AskAnswer::AnswerYes) {
+      if (!save(gdi))
+        return false;
+    } 
+  }
+  return true;
+}
+
+void QFEditor::makeDirty(DirtyFlag inside, DirtyFlag outside) {
+  if (inside == DirtyFlag::ClearDirty)
+    dirtyInt = false;
+  else if (inside == DirtyFlag::MakeDirty)
+    dirtyInt = true;
+
+  if (outside == DirtyFlag::ClearDirty)
+    dirtyExt = false;
+  else if (outside == DirtyFlag::MakeDirty)
+    dirtyExt = true;
+}
+
+void QFEditor::edit(gdioutput& gdi) {
+  makeDirty(DirtyFlag::MakeDirty, DirtyFlag::MakeDirty);
+  updateActions(gdi);
+}
+
+void QFEditor::updateActions(gdioutput& gdi) {
+  gdi.setInputStatus("Use", dirtyInt, true);
+  gdi.setInputStatus("Save", dirtyExt);
+}
+
+void QFEditor::use() {
+  makeQF();
+  cls->loadQualificationFinalScheme(*currentQF);
+  cls->updateFinalClasses(0, true);
+  makeDirty(QFEditor::DirtyFlag::ClearDirty, QFEditor::DirtyFlag::NoTouch);
+}
+
+bool QFEditor::save(gdioutput& gdi) {
+  vector<pair<wstring, wstring>> ext;
+  ext.push_back(make_pair(L"Qualfication/Final", L"*.xml"));
+  int fx = 0;
+  wstring fileName = gdi.browseForSave(ext, L"xml", fx);
+  if (!fileName.empty()) {
+    makeQF();
+    currentQF->exportXML(fileName);
+    makeDirty(QFEditor::DirtyFlag::NoTouch, QFEditor::DirtyFlag::ClearDirty);
+    return true;
+  }
+  return false;
+}
diff --git a/code/qf_editor.h b/code/qf_editor.h
new file mode 100644
index 0000000..a62e908
--- /dev/null
+++ b/code/qf_editor.h
@@ -0,0 +1,116 @@
+  #pragma once
+
+/************************************************************************
+    MeOS - Orienteering Software
+    Copyright (C) 2009-2024 Melin Software HB
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+    Melin Software HB - software@melin.nu - www.melin.nu
+    Eksoppsvägen 16, SE-75646 UPPSALA, Sweden
+
+************************************************************************/
+
+class gdioutput;
+class oEvent;
+class QualificationFinal;
+
+#include <vector>
+#include <memory>
+#include "qualification_final.h"
+
+#include "autocompletehandler.h"
+
+class oClass;
+
+class QFEditor : public GuiHandler {
+private:
+  enum SaveType {NotSaved, SavedInside, SavedFile};
+  shared_ptr<QualificationFinal> currentQF;
+  
+  wstring savedFileName;
+  bool dirtyExt = false;
+  bool dirtyInt = false;
+  SaveType lastSaved = NotSaved;
+  oClass* cls;
+  
+  /// Check and ask if there are changes to save
+  bool checkSave(gdioutput &gdi);
+
+  void edit(gdioutput& gdi);
+  void updateActions(gdioutput& gdi);
+
+  vector<pair<size_t, vector<QFClass>>> data; // First is number of classes (for convenient undo)
+  size_t numLevels = 0; // Allow larger data than levels (for convenient "undo")
+
+  void showLevels(gdioutput& gdi) const;
+  void showLevel(gdioutput& gdi, int level, size_t numRaces, const vector<QFClass>& classes) const;
+
+  static int code(int level, int cls) {
+    return level * 256 + cls;
+  }
+
+  static pair<int, int> decode(int c) {
+    return make_pair(c / 256, c % 256);
+  }
+
+  QFClass& getQFClass(int id);
+  const QFClass& getQFClass(int id) const;
+
+  void loadQualificationView(gdioutput &gdi, const QFClass &cls, int code);
+
+  int getLinearIndex(int level, int ix) const;
+  QFClass &getQFClassFromIndex(int linearIndex);
+  pair<int, int> getLevelIndexFromLinear(int linearIndex) const;
+  vector<pair<int, int>> getLevelIndex() const;
+
+  void updateLevelMap(const vector<pair<int, int>>& oldIndex);
+
+  vector<pair<wstring, size_t>> getRules(const QFClass& cls) const;
+  void emptyScheme();
+
+  static string getKeyTag(int level, int ix);
+  string infoTextTag;
+  gdioutput *infoTextGdi = nullptr;
+  void updateQInfo(const QFClass& cls);
+  
+  void makeQF();
+
+  int extraSelPosX = 0;
+  int extraSelPosY = 0;
+  void updateExtraField(gdioutput &gdi, const QFClass &cls, int code);
+
+  RECT rcRuleForm;
+  void endAddRuleForm(gdioutput& gdi);
+  void addRuleOther(int cCcode, gdioutput& gdi);
+  void addRuleClassPlace(int cCode, gdioutput& gdi);
+  void addRuleTime(int cCode, gdioutput& gdi);
+
+  void use();
+  bool save(gdioutput &gdi);
+public:
+  QFEditor();
+  virtual ~QFEditor();
+
+  enum class DirtyFlag { MakeDirty, ClearDirty, NoTouch };
+  void makeDirty(DirtyFlag inside, DirtyFlag outside);
+
+  void load(const shared_ptr<QualificationFinal>& qf);
+  void show(gdioutput &gdi);
+
+  void setClass(oClass* cls) { this->cls = cls; }
+
+  // Inherited via GuiHandler
+  virtual void handle(gdioutput& gdi, BaseInfo& info, GuiEventType type);
+};
diff --git a/code/qualification_final.cpp b/code/qualification_final.cpp
index ab80c12..69a2968 100644
--- a/code/qualification_final.cpp
+++ b/code/qualification_final.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -32,7 +32,7 @@
 #include "oRunner.h"
 #include "localizer.h"
 
-pair<int, int> QualificationFinal::getNextFinal(int instance, int orderPlace, int numSharedPlaceNext) const {
+pair<int, int> QualificationFinal::getPrelFinalFromPlace(int instance, int orderPlace, int numSharedPlaceNext) {
   pair<int, int> key(instance, orderPlace);
   int iter = 0;
   while (numSharedPlaceNext >= 0) {
@@ -46,13 +46,16 @@ pair<int, int> QualificationFinal::getNextFinal(int instance, int orderPlace, in
         if (res2 != sourcePlaceToFinalOrder.end()) {
           auto ans = res2->second;
           ans.second += iter + extraSub;
+          ++numExtraAssigned[ans.first]; // More than specified
           return ans;
         }
       }
 
-
       auto ans = res->second;
       ans.second += iter;
+      if (iter > 0)
+        ++numExtraAssigned[ans.first]; // More than specified
+
       return ans;
     }
     --key.second;
@@ -68,10 +71,10 @@ bool QualificationFinal::noQualification(int instance) const {
     return false;
 
   return classDefinition[instance].qualificationMap.empty() &&
-         classDefinition[instance].timeQualifications.empty();
+         classDefinition[instance].numTimeQualifications == 0 &&
+    classDefinition[instance].extraQualification == QFClass::ExtraQualType::None;
 }
 
-
 void QualificationFinal::getBaseClassInstances(set<int> &base) const {
   for (size_t k = 0; k < classDefinition.size(); k++) {
     if (noQualification(k))
@@ -81,7 +84,77 @@ void QualificationFinal::getBaseClassInstances(set<int> &base) const {
 
 }
 
-void QualificationFinal::import(const wstring &file) {
+void QualificationFinal::exportXML(const wstring& file) const {
+  xmlparser xml;
+  xml.openOutputT(file.c_str(), false, "QualificationRules");
+  int cLevel = -1;
+
+  for (int j = 0; j < classDefinition.size(); j++) {
+    int level = getLevel(j+1);
+    if (level != cLevel) {
+      if (cLevel >= 0)
+        xml.endTag();
+
+      cLevel = level;
+      if (classDefinition[j].rankLevel)
+        xml.startTag("Level", "distribution", "Ranking");
+      else
+        xml.startTag("Level");
+    }
+
+    vector<wstring> pv;
+    pv.emplace_back(L"name");
+    pv.emplace_back(classDefinition[j].name.empty() ? lang.tl("Kval") + itow(j + 1) : classDefinition[j].name);
+    pv.emplace_back(L"id");
+    pv.emplace_back(itow(j + 1));
+    xml.startTag("Class", pv);
+
+    vector<pair<string, wstring>> psv(2);;
+    psv[0].first = "id";
+    psv[1].first = "place";
+ 
+    for (auto& qmap : classDefinition[j].qualificationMap) {
+      psv[0].second = itow(qmap.first);
+      psv[1].second = itow(qmap.second);
+      xml.write("Qualification", psv, L"");
+    }
+
+    if (classDefinition[j].numTimeQualifications > 0) {
+      psv[0].first = "time";
+      psv[0].second = itow(classDefinition[j].numTimeQualifications);
+      psv.resize(1);
+      xml.write("Qualification", psv, L"");
+    }
+
+    if (classDefinition[j].extraQualification != QFClass::ExtraQualType::None) {
+      psv[0].first = "type";
+      switch (classDefinition[j].extraQualification) {
+      case QFClass::ExtraQualType::All:
+        psv.resize(1);
+        psv[0].second = L"All";
+        break;
+      case QFClass::ExtraQualType::NBest:
+        psv.resize(2);
+        psv[0].second = L"Best";
+        psv[1].first = "number";
+        psv[1].second = itow(classDefinition[j].extraQualData);
+        break;
+      case QFClass::ExtraQualType::TimeLimit:
+        psv.resize(2);
+        psv[0].second = L"Time";
+        psv[1].first = "limit";
+        psv[1].second = formatTimeMS(classDefinition[j].extraQualData, false);
+        break;
+      }
+      xml.write("Remaining", psv, L"");
+    }
+
+    xml.endTag();
+  }
+  xml.closeOut();
+}
+
+void QualificationFinal::importXML(const wstring &file) {
   xmlparser xml;
   xml.read(file);
 
@@ -91,7 +164,6 @@ void QualificationFinal::import(const wstring &file) {
   map<int, int> idToIndex;
   map<int, set<int> > qualificationRelations;
   int numBaseLevels = 0;
-  int iLevel = 0;
   for (size_t iLevel = 0; iLevel < levels.size(); iLevel++) {
     auto &level = levels[iLevel];
     wstring rankS;
@@ -106,7 +178,11 @@ void QualificationFinal::import(const wstring &file) {
     level.getObjects("Class", classes);
     for (auto &cls : classes) {
       wstring name;
-      cls.getObjectString("Name", name);
+
+      cls.getObjectString("name", name);
+      if (name.empty())
+        cls.getObjectString("Name", name);
+
       if (name.empty())
         throw meosException("Klassen måste ha ett namn.");
       int classId = cls.getObjectInt("id");
@@ -117,11 +193,39 @@ void QualificationFinal::import(const wstring &file) {
 
       xmlList rules;
       cls.getObjects("Qualification", rules);
-      if (rules.empty())
+
+      
+      xmlobject remaining = cls.getObject("Remaining");
+
+      if (rules.empty() && !remaining)
         numBaseLevels = 1; // Instance zero is not used as qualification,
 
       idToIndex[classId] = classDefinition.size() + numBaseLevels;
-      classDefinition.push_back(Class());
+      classDefinition.emplace_back();
+      classDefinition.back().level = iLevel;
+      if (remaining) {
+        wstring rtype;
+        remaining.getObjectString("type", rtype);
+        if (rtype == L"All") {
+          classDefinition.back().extraQualification = QFClass::ExtraQualType::All;
+        }
+        else if (rtype == L"Best") {
+          classDefinition.back().extraQualification = QFClass::ExtraQualType::NBest;
+          classDefinition.back().extraQualData = remaining.getObjectInt("number");
+          if (classDefinition.back().extraQualData > 10000 || classDefinition.back().extraQualData < 0)
+            classDefinition.back().extraQualData = 0;
+        }
+        else if (rtype == L"Time") {
+          classDefinition.back().extraQualification = QFClass::ExtraQualType::TimeLimit;
+          wstring wt;
+          remaining.getObjectString("limit", wt);
+          classDefinition.back().extraQualData = convertAbsoluteTimeMS(wt);
+          if (classDefinition.back().extraQualData == NOTIME || classDefinition.back().extraQualData < 0)
+            classDefinition.back().extraQualData = 0;
+
+        }
+      }
+
       classDefinition.back().name = name;
       classDefinition.back().rankLevel = rankSort;
       for (auto &qf : rules) {
@@ -138,110 +242,115 @@ void QualificationFinal::import(const wstring &file) {
             throw meosException("Unknown class with id " + itos(id));
         }
         else {
-          string time;
-          qf.getObjectString("place", time);
-          if (time == "time") {
-            string ids;
-            qf.getObjectString("id", ids);
-            vector<string> vid;
-            split(ids, ",;", vid);
-            vector<int> ivid;
-            for (auto &s : vid) {
-              int i = atoi(s.c_str());
-              if (!idToIndex.count(i))
-                throw meosException("Unknown class with id " + itos(i));
-              ivid.push_back(idToIndex[i]);
-            }
-
-            if (ivid.empty())
-              throw meosException(L"Empty time qualification for " + name);
-            classDefinition.back().timeQualifications.push_back(ivid);
+          int numTime = qf.getObjectInt("time");
+          if (numTime > 0) 
+            classDefinition.back().numTimeQualifications += numTime;
+          else if (qf.got("time")) {
+            throw meosException(L"Empty time qualification for " + name);
           }
-          else throw meosException("Unknown classification rule " + time);
+          else throw meosException(L"Unknown classification rule for " + name);
         }
       }
     }
   }
-  /*classDefinition.resize(3);
-  classDefinition[0].name = L"Semi A";
-  classDefinition[1].name = L"Semi B";
-  classDefinition[2].name = L"Final";
-
-  for (int i = 0; i < 4; i++) {
-    classDefinition[0].qualificationMap.push_back(make_pair(0, i * 2 + 1));
-    classDefinition[1].qualificationMap.push_back(make_pair(0, i * 2 + 2));
-    classDefinition[2].qualificationMap.push_back(make_pair(i%2+1, i/2 + 1));
-  }
-  */
   initgmap(true);
 }
 
 void QualificationFinal::init(const wstring &def) {
   serializedFrom = def;
-  vector <wstring> races, rtdef, rdef; 
+  vector<wstring> races, rtdef, rdef; 
   split(def, L"|", races);
   classDefinition.resize(races.size());
   bool valid = true;
   bool first = true;
   for (size_t k = 0; k < races.size(); k++) {
+    if (races[k].size() > 0 && races[k][0] == '@') {
+      // Explicit level, since 4.0
+      classDefinition[k].level = _wtoi(races[k].c_str() + 1);
+      int mx = 1;
+      while (mx < races[k].size() && races[k][mx] != '@')
+        mx++;
+      int mx2 = mx + 1;
+      while (mx2 < races[k].size() && races[k][mx2] != '@')
+        mx2++; 
+
+      if (mx2 >= races[k].size() || classDefinition[k].level > k) {
+        valid = false;
+        break;
+      }
+      races[k][mx2] = 0;
+      classDefinition[k].name = races[k].c_str() + mx + 1;
+      races[k] = races[k].substr(mx2 + 1);
+    }
     bool rankLevel = false;
     if (races[k].size() > 0 && races[k][0] == 'R') {
       rankLevel = true;
       races[k] = races[k].substr(1);
     }
+    
+    if (races[k].size() > 0 && QFClass::deserialType(races[k][0]) != QFClass::ExtraQualType::None) {
+      first = false;
+      classDefinition[k].extraQualification = QFClass::deserialType(races[k][0]);
+      if (classDefinition[k].extraQualification == QFClass::ExtraQualType::NBest ||
+        classDefinition[k].extraQualification == QFClass::ExtraQualType::TimeLimit) {
+        classDefinition[k].extraQualData = _wtoi(races[k].c_str() + 1);
+      }
+      int end = 1;
+      while (end < races[k].size() && races[k][end-1] != ';')
+        end++;
+      races[k] = races[k].substr(end);
+    }
     split(races[k], L"T", rtdef);
     classDefinition[k].qualificationMap.clear();
-    classDefinition[k].timeQualifications.clear();
+    classDefinition[k].numTimeQualifications = 0;
     classDefinition[k].rankLevel = rankLevel;
 
-    if (first && rtdef.empty())
+    if (rtdef.empty())
+      continue; // Remaining qualified
+
+    first = false;
+
+    split(rtdef[0], L";", rdef);
+    bool thisValid = rdef.size()%2 == 0 &&
+         (rdef.size() > 0 || (rtdef.size() == 2 && !rtdef[1].empty()));
+    
+    if (!thisValid)
       continue;
 
-    valid = rtdef.size() > 0;
-    if (!valid)
-      break;
-    first = false;
-    
-    split(rtdef[0], L";", rdef);
-    valid = rdef.size() > 0 && rdef.size()%2 == 0;
-    if (!valid)
-      break;
-
     for (size_t j = 0; j < rdef.size(); j+=2) {
-      size_t src = _wtoi(rdef[j].c_str());
-      if (src > k) {
-        valid = false;
+      int src = _wtoi(rdef[j].c_str());
+      if (src > k || src <= 0) {
+        thisValid = false;
         break;
       }
       const wstring &rd = rdef[j + 1];
-      size_t d1 = _wtoi(rd.c_str());
-      size_t d2 = d1;
+      int d1 = _wtoi(rd.c_str());
+      if (d1 < 1 || d1>1000) {
+        thisValid = false;
+        break;
+      }
+      int d2 = d1;
       size_t range = rd.find_first_of('-', 0);
       if (range < rd.size())
         d2 = _wtoi(rd.c_str()+range+1);
 
       if (d1 > d2) {
-        valid = false;
+        thisValid = false;
         break;
       }
 
       while (d1 <= d2) {
-        classDefinition[k].qualificationMap.push_back(make_pair(int(src), int(d1)));
+        classDefinition[k].qualificationMap.emplace_back(src, d1);
         d1++;
       }
     }
 
-    for (size_t i = 1; valid && i < rtdef.size(); i++) {
-      split(rtdef[i], L";", rdef);
-      classDefinition[k].timeQualifications.push_back(vector<int>());
-      for (size_t j = 0; valid && j < rdef.size(); j += 2) {
-        size_t src = _wtoi(rdef[j].c_str());
-        if (src > k) {
-          valid = false;
-          break;
-        }
-        classDefinition[k].timeQualifications.back().push_back(src);
-      }
+    if (!thisValid)
+      classDefinition[k].qualificationMap.clear();
+
+    if (rtdef.size() > 1) {
+      int numTime = _wtoi(rtdef[1].c_str());
+      classDefinition[k].numTimeQualifications = numTime;
     }
   }
 
@@ -251,6 +360,31 @@ void QualificationFinal::init(const wstring &def) {
   initgmap(false);
 }
 
+
+void QualificationFinal::setClasses(const vector<QFClass>& def) {
+  classDefinition = def;
+  initgmap(true);
+  wstring tmp;
+  encode(tmp);
+}
+
+wstring QualificationFinal::validName(const wstring& name) {
+  wstring out;
+  out.reserve(name.size());
+  for (int j = 0; j < name.length(); j++)
+    if (isValidNameChar(name[j]))
+      out.push_back(name[j]);
+
+  return out;
+}
+
+bool QualificationFinal::isValidNameChar(wchar_t c) {
+  if (c == 0 || c == '|' || c == '@')
+    return false;
+
+  return true;
+}
+
 void QualificationFinal::encode(wstring &output) const {
   output.clear();
 
@@ -258,9 +392,13 @@ void QualificationFinal::encode(wstring &output) const {
     if (k > 0)
       output.append(L"|");
 
+    output.append(L"@"+ itow(getLevel(k+1)) + L"@" + validName(classDefinition[k].name) + L"@");
+    
     if (classDefinition[k].rankLevel)
       output.append(L"R");
 
+    output.append(classDefinition[k].serialExtra());
+
     auto &qm = classDefinition[k].qualificationMap;
 
     for (size_t j = 0; j < qm.size(); j++) {
@@ -282,40 +420,38 @@ void QualificationFinal::encode(wstring &output) const {
       } 
     }
 
-    auto &tqm = classDefinition[k].timeQualifications;
-    for (auto &source :  tqm) {
+    if (classDefinition[k].numTimeQualifications > 0) {
       output.append(L"T");
-      for (size_t i = 0; i < source.size(); i++) {
-        if (i > 0)
-          output.append(L";");
-        output.append(itow(source[i]));
-      }
+      output.append(itow(classDefinition[k].numTimeQualifications));
     }
   }
 
   serializedFrom = output;
 }
 
-int QualificationFinal::getNumStages(int stage) const {
-  if (stage == 0 || classDefinition[stage-1].qualificationMap.empty())
-    return 1;
+wstring QFClass::serialExtra() const {
+  if (extraQualification == ExtraQualType::All)
+    return L"A;";
+  else if (extraQualification == ExtraQualType::TimeLimit)
+    return L"L" + itow(extraQualData) + L";";
+  else if (extraQualification == ExtraQualType::NBest)
+    return L"B" + itow(extraQualData) + L";";
+  return L"";
+}
 
-  set<int> races;
-  for (auto &qm : classDefinition[stage - 1].qualificationMap) {
-    if (qm.first == stage)
-      throw meosException("Invalid qualification scheme");
-    races.insert(qm.first);
-  }
-
-  int def = 0;
-  for (int r : races)
-    def = max(def, 1 + getNumStages(r));
-
-  return def;
+int QFClass::getMinQualInst() const {
+  if (qualificationMap.empty())
+    return -1;
+  int ret = 1024;
+  for (auto& cp : qualificationMap)
+    ret = min(ret, cp.first);
+  return ret;
 }
 
 void QualificationFinal::initgmap(bool check) {
+  level2DefningInstance.clear();
   sourcePlaceToFinalOrder.clear();
+  levels.clear();
   levels.resize(getNumLevels(), LevelInfo::Normal);
 
   for (int ix = 0; ix < (int)classDefinition.size(); ix++) {
@@ -354,21 +490,41 @@ int QualificationFinal::getLevel(int instance) const {
 }
 
 bool QualificationFinal::isFinalClass(int instance) const {
-  return instance > 0 && sourcePlaceToFinalOrder.count(make_pair(instance, 1)) == 0;
+  return instance > 0 && getLevel(instance) + 1 == getNumLevels();
 }
 
 int QualificationFinal::getNumLevels() const {
-  return getLevel(classDefinition.size() - 1) + 1;
+  return getLevel(classDefinition.size()) + 1;
 }
 
-int QualificationFinal::getMinInstance(int level) const {
+int QualificationFinal::getMinInstance(const int levelIn) const {
+  int level = levelIn;
+  auto res = level2DefningInstance.find(levelIn);
+  if (res != level2DefningInstance.end())
+    return res->second;
+
   int minInst = classDefinition.size() - 1;
   for (int i = classDefinition.size() - 1; i >= 0; i--) {
     if (i == 0 && minInst == 1)
       break; // No need to include base instance.
-    if (getLevel(i) == level)
+    int thisLevel = getLevel(i+1);
+    if (thisLevel > level) {
+      int minQualInst = classDefinition[i].getMinQualInst();
+      if (minQualInst >= 0) {
+        // If there are direct qualification to this level from an 
+        // earlier level, we must start from that level.
+        int qualLevel = getLevel(minQualInst+1);
+        if (qualLevel < level) {
+          level = qualLevel;
+          i = classDefinition.size(); // Restart
+        }
+      }
+    }
+    else if (thisLevel == level)
       minInst = i;
   }
+
+  level2DefningInstance[levelIn] = minInst;
   return minInst;
 }
 
@@ -390,27 +546,136 @@ int QualificationFinal::getHeatFromClass(int finalClassId, int baseClassId) cons
 void QualificationFinal::prepareCalculations() {
   storedInfoLookup.clear();
   storedInfo.clear();
+  numExtraAssigned.clear();
 }
 
 /** Retuns the final class and the order within that class. */
-void QualificationFinal::setupNextFinal(pRunner r, int instance, int orderPlace, int numSharedPlaceNext) {
+void QualificationFinal::provideQualificationResult(pRunner r, int instance, int orderPlace, int numSharedPlace) {
   storedInfo.resize(getNumClasses());
 
-  pair<int, int> res = getNextFinal(instance, orderPlace, numSharedPlaceNext);
+  pair<int, int> res = getPrelFinalFromPlace(instance, orderPlace, numSharedPlace);
   int level = getLevel(instance);
   storedInfo[level].emplace_back(r, res.first, res.second);
 }
 
+void QualificationFinal::provideUnqualified(int level, pRunner r) {
+  storedInfo.resize(getNumClasses());
+  storedInfo[level].emplace_back(r, -1, storedInfo[level].size());
+}
+
 /** Do internal calculations. */
 void QualificationFinal::computeFinals() {
   if (storedInfo.empty())
     return;
   int nl = getNumLevels();
+
+  // Handle time qualifications
+  vector<pair<int, ResultInfo*>> timeToIx;
+  set<pair<int, ResultInfo*>> remainingTimeQualified;
+  int lastLevel = -1;
+  vector<int> levelClasses;
+
+  auto distributeRemaning = [&]() {
+    if (levelClasses.empty())
+      return;
+    int cIx = 0;
+    for (auto& tq : remainingTimeQualified) {
+      tq.second->instance = levelClasses[cIx];
+      tq.second->order = 100 + cIx;
+      cIx++;
+      if (cIx >= levelClasses.size())
+        cIx = 0;
+    }
+  };
+
+  for (int j = 1; j < classDefinition.size(); j++) {
+    int level = getLevel(j + 1) - 1;
+    if (level != lastLevel) {
+      distributeRemaning();
+      levelClasses.clear();
+      remainingTimeQualified.clear();
+      lastLevel = level;
+    }
+    levelClasses.push_back(j + 1);
+    int NT = classDefinition[j].numTimeQualifications;
+    auto res = numExtraAssigned.find(j + 1);
+    if (res != numExtraAssigned.end()) {
+      NT -= res->second; // Already assigned from (duplicate) places
+    }
+    for (int i = 0; i < NT; i++) {
+      timeToIx.clear();
+      int order = 0;
+      // Select the best time from unqualified competitors
+      if (level < storedInfo.size()) {
+        for (auto& res : storedInfo[level]) {
+          if (res.instance == 0) {
+            int t = res.r->getRunningTime(false);
+            if (timeToIx.empty() || t <= timeToIx.front().first) {
+              // Select the current best time
+
+              if (!timeToIx.empty() && t < timeToIx.front().first)
+                timeToIx.clear(); // Found better time
+
+              timeToIx.emplace_back(t, &res);
+            }
+          }
+          else {
+            order = std::max(res.order, order);
+          }
+        }
+      }
+      if (!timeToIx.empty()) {
+        timeToIx[0].second->instance = j + 1;
+        timeToIx[0].second->order = ++order;
+        for (int j = 1; j < timeToIx.size(); j++) {
+          // Qualified by time, but not yet in a race (tie position)
+          remainingTimeQualified.insert(timeToIx[j]);
+        }
+      }
+    }
+  }
+  // Allow both to advance on tie
+  distributeRemaning();
+
+  for (int j = 1; j < classDefinition.size(); j++) {
+    int level = getLevel(j + 1) - 1;
+
+    if (classDefinition[j].extraQualification == QFClass::ExtraQualType::All) {
+      // All remaining
+      for (auto& si : storedInfo[level]) {
+        if (si.instance <= 0)
+          si.instance = j + 1;
+      }
+    }
+    else if (classDefinition[j].extraQualification == QFClass::ExtraQualType::NBest) {
+      // N best competitors
+      int count = 0;
+      for (auto& si : storedInfo[level]) {
+        if (si.instance <= 0) {
+          si.instance = j + 1;
+          if (++count >= classDefinition[j].extraQualData)
+            break;
+        }
+      }
+    }
+    else if (classDefinition[j].extraQualification == QFClass::ExtraQualType::TimeLimit) {
+      // Fixed time limit
+      for (auto& si : storedInfo[level]) {
+        if (si.instance == 0 && 
+          si.r->getStatus() == StatusOK &&
+          si.r->getRunningTime(false) < classDefinition[j].extraQualData){
+          si.instance = j + 1;
+        }
+      }
+    }
+  }
+
+
   for (int level = 1; level < nl; level++) {
     vector<int> placeCount(classDefinition.size(), 0);
     if (levels[level] == LevelInfo::RankSort) {
-      vector< pair<int, int> > rankIx;
-      vector< pair<int, int> > placeQueue;
+      vector<pair<int, int>> rankIx;
+      vector<pair<int, int>> placeQueue;
       
       set<int> numClassCount;
       auto &si = storedInfo[level-1];
@@ -460,32 +725,6 @@ void QualificationFinal::computeFinals() {
         reverse(placementOrder.begin() + i, placementOrder.begin() + i + numClass);
       }
       reverse(placementOrder.begin(), placementOrder.end());
-      /*
-      vector<int> work;
-
-      int ix = placeQueue.size() - 1;
-      int iteration = 0;
-      bool versionA = false;
-      while (ix>=0) {
-        work.clear();
-        for (int i = 0; i < numClass && ix >= 0; i++) {
-          work.push_back(ix--);
-        }
-        if (versionA) {
-          if (work.size() == numClass)
-            rotate(work.begin(), work.begin() + iteration, work.end());
-          iteration = rotmap[iteration];
-        }
-        else {
-          if (iteration % 2 == 1)
-            reverse(work.begin(), work.end());
-          iteration++;
-        }
-
-        for (size_t i = 1; i <= work.size(); i++) {
-          placementOrder[ix + i] = work[work.size() - i];
-        }
-      }*/
 
       for (auto &rankRes : rankIx) {
         si[rankRes.second].instance = placeQueue[placementOrder.back()].second;
@@ -494,7 +733,7 @@ void QualificationFinal::computeFinals() {
       }
     }
   }
-
+  
   for (auto & si : storedInfo) {
     for (auto &res : si) {
       storedInfoLookup[res.r->getId()] = &res;
@@ -509,57 +748,85 @@ pair<int, int> QualificationFinal::getNextFinal(int runnerId) const {
     return make_pair(0, -1); 
   }
   
-  return make_pair(res->second->instance, res->second->order);
+  return make_pair(max(res->second->instance, 0), res->second->order);
 }
 
-void QualificationFinal::printScheme(oClass * cls, gdioutput &gdi) const {
+void QualificationFinal::printScheme(const oClass& cls, gdioutput &gdi) const {
   vector<wstring> cname;
-//  vector<map<int, int> > targetCls(classDefinition.size());
 
   for (size_t i = 0; i < classDefinition.size(); i++) {
-    pClass inst = cls->getVirtualClass(i + 1);
+    pClass inst = cls.getVirtualClass(i + 1);
     cname.push_back(inst ? inst->getName() : lang.tl("Saknad klass"));
- //   for (auto d : classDefinition[i].qualificationMap) {
- //     targetCls[i].push_back(d.first);
- //   }
   }
 
   int ylimit = gdi.getHeight();
   gdi.pushY();
   for (size_t i = 0; i < classDefinition.size(); i++) {
     gdi.dropLine();
-
     gdi.addStringUT(1, itow(i+1) + L" " + cname[i]);
-    bool rankingBased = false;
+    
+    if (getLevel(i + 1) == 0) {
+      //gdi.addStringUT(italicText, "Kval").setColor(GDICOLOR::colorDarkGrey);
+    }
+    else {
+      gdi.addString("", italicText, classDefinition[i].getQualInfo()).setColor(GDICOLOR::colorDarkGreen);
+    }
+    gdi.dropLine(0.2);
+    int rankingBased = 0;
     vector<wstring> dst;
 
-    for (int place = 1; place < 20; place++) {
+    for (int place = 1; place < 100; place++) {
       auto res = sourcePlaceToFinalOrder.find(make_pair(i + 1, place));
       
       if (res != sourcePlaceToFinalOrder.end()) {
-        if (classDefinition[res->second.first - 1].rankLevel)
-          rankingBased = true;
-        dst.push_back(itow(place) + L". ➞ " + cname[res->second.first - 1]);
+        int level = getLevel(res->second.first);
+        if (levels[level] == LevelInfo::RankSort)
+          ++rankingBased;
+        else
+          dst.push_back(itow(place) + L". ➞ " + cname[res->second.first - 1]);
       }
       else break;
     }
 
     if (rankingBased) {
-      gdi.addString("", 0, L"X går vidare, klass enligt ranking#" +  itow(dst.size()));
+      gdi.addString("", 0, L"  X går vidare, klass enligt ranking#" +  itow(rankingBased));
     }
-    else {
-      for (auto &c : dst) {
-        gdi.addStringUT(0, c);
-      }
+    for (auto &c : dst) {
+      gdi.addStringUT(0, L"  " + c);
     }
-
+    
     if (gdi.getCY() > ylimit) {
       gdi.newColumn();
       gdi.popY();
       gdi.pushX();
-
     }
   }
 
   gdi.refresh();
 }
+
+wstring QFClass::getQualInfo() const {
+  if (extraQualification == ExtraQualType::All)
+    return L"Alla övriga";
+  else if (extraQualification == ExtraQualType::NBest)
+    return L"X bästa#" + itow(extraQualData);
+  else if (extraQualification == ExtraQualType::TimeLimit)
+    return L"Tidsgräns X#" + formatTimeMS(extraQualData, false);
+
+  int nq = qualificationMap.size() + numTimeQualifications;
+  if (nq > 0 && numTimeQualifications == 0)
+    return L"X kvalificerade#" + itow(nq);
+  else if (nq > 0)
+    return L"X kvalificerade#" + itow(qualificationMap.size()) + L" + " + itow(numTimeQualifications);
+  
+  return L"Ingen";
+}
+
+
+bool QualificationFinal::hasRemainingClass() const {
+  for (auto& c : classDefinition) {
+    if (c.extraQualification != QFClass::ExtraQualType::None)
+      return true;
+  }
+  return false;
+}
diff --git a/code/qualification_final.h b/code/qualification_final.h
index 7054353..15d5f43 100644
--- a/code/qualification_final.h
+++ b/code/qualification_final.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
 MeOS - Orienteering Software
-Copyright (C) 2009-2023 Melin Software HB
+Copyright (C) 2009-2024 Melin Software HB
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -29,24 +29,55 @@ Eksoppsvägen 16, SE-75646 UPPSALA, Sweden
 #include <set>
 
 class oRunner;
-typedef oRunner * pRunner;
+typedef oRunner *pRunner;
 class oClass;
 
+struct QFClass {
+  QFClass() = default;
+  QFClass(const wstring& name) : name(name) {}
+
+  wstring name;
+  vector<pair<int, int>> qualificationMap;
+  int numTimeQualifications = 0;
+
+  enum class ExtraQualType {
+    None,
+    All,
+    NBest,
+    TimeLimit,
+  };
+
+  ExtraQualType extraQualification = ExtraQualType::None;
+  int extraQualData = 0;
+
+  static ExtraQualType deserialType(wchar_t dc) {
+    switch (dc) {
+    case 'A':
+      return ExtraQualType::All;
+    case 'B':
+      return ExtraQualType::NBest;
+    case 'L':
+      return ExtraQualType::TimeLimit;
+
+    }
+    return ExtraQualType::None;
+  }
+
+  wstring serialExtra() const;
+  // Get the minimum qualification instance
+  int getMinQualInst() const;
+  bool rankLevel = false;
+  mutable int level = -1;
+  wstring getQualInfo() const;
+};
+
 class QualificationFinal {
 private:
   mutable wstring serializedFrom;
   int maxClassId;
   int baseId;
 
-  struct Class {
-    wstring name;
-    vector< pair<int, int> > qualificationMap;
-    vector< vector<int> > timeQualifications;
-    bool rankLevel = false;
-    mutable int level = -1;
-  };
-
-  enum LevelInfo {
+  enum class LevelInfo {
     Normal,
     RankSort,
   };
@@ -58,23 +89,33 @@ private:
     int instance;
     int order;
   };
-
  
   vector<vector<ResultInfo>> storedInfo;
   map<int, ResultInfo *> storedInfoLookup;
+  map<int, int> numExtraAssigned; // Number of extra assigned competitors (per race/instance)
 
-  vector<Class> classDefinition;
-
+  vector<QFClass> classDefinition;
   map<pair<int, int>, pair<int, int>> sourcePlaceToFinalOrder;
+  mutable map<int, int> level2DefningInstance;
 
   void initgmap(bool check);
 
-  // Recursive implementation
-  int getNumStages(int stage) const;
+  /** Retuns the final class and the order within that class. */
+  pair<int, int> getPrelFinalFromPlace(int instance, int orderPlace, int numSharedPlaceNext);
+
+  static wstring validName(const wstring& name);
+
 public:
 
+  void setClasses(const vector<QFClass>& def);
+  const vector<QFClass>& getClasses() const {
+    return classDefinition;
+  }
+
   QualificationFinal(int maxClassId, int baseId) : maxClassId(maxClassId), baseId(baseId) {}
   
+  static bool isValidNameChar(wchar_t c);
+
   bool matchSerialization(const wstring &ser) const {
     return serializedFrom == ser;
   }
@@ -83,6 +124,10 @@ public:
     return classDefinition.size();
   }
 
+  const QFClass& getInstance(int instance) const {
+    return classDefinition[instance];
+  }
+
   const wstring getInstanceName(int inst) {
     return classDefinition.at(inst-1).name;
   }
@@ -92,33 +137,39 @@ public:
 
   // Count number of stages
   int getNumStages() const {
-    return getNumStages(classDefinition.size());
+    return getNumLevels();
+    //return getNumStages(classDefinition.size());
   }
 
   int getHeatFromClass(int finalClassId, int baseClassId) const;
   
-  void import(const wstring &file);
+  void importXML(const wstring &file);
+  void exportXML(const wstring& file) const;
 
   void init(const wstring &def);
   void encode(wstring &output) const;
 
+  /** Return true of any class is of type remaining */
+  bool hasRemainingClass() const;
+
   /** Calculate the level of a particular instance. */
   int getLevel(int instance) const;
 
   /** Calculate the number of levels. */
   int getNumLevels() const;
 
-  /** Get the minimum number instance of a specified level. */
-  int getMinInstance(int level) const;
-
-  /** Retuns the final class and the order within that class. */
-  pair<int,int> getNextFinal(int instance, int orderPlace, int numSharedPlaceNext) const;
+  /** Get the minimum number instance of a specified level
+      affecting later level qualifications. */
+  int getMinInstance(const int level) const;
 
   /** Clear previous staus data*/
   void prepareCalculations();
 
-  /** Return the final class and the order within that class. */
-  void setupNextFinal(pRunner r, int instance, int orderPlace, int numSharedPlaceNext);
+  /** Prove result to compute final classes. */
+  void provideQualificationResult(pRunner r, int instance, int orderPlace, int numSharedPlace);
+
+  /** Provide data for non-qualified competitors */
+  void provideUnqualified(int level, pRunner r);
 
   /** Do internal calculations. */
   void computeFinals();
@@ -132,5 +183,5 @@ public:
   /** Fills in the set of no-qualification classes*/
   void getBaseClassInstances(set<int> &base) const;
 
-  void printScheme(oClass * cls, gdioutput &gdi) const;
+  void printScheme(const oClass &cls, gdioutput &gdi) const;
 };
diff --git a/code/random.cpp b/code/random.cpp
index 789ee13..775ad2b 100644
--- a/code/random.cpp
+++ b/code/random.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/random.h b/code/random.h
index 646cd26..c84b8fc 100644
--- a/code/random.h
+++ b/code/random.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/readout24.png b/code/readout24.png
new file mode 100644
index 0000000..3014f20
Binary files /dev/null and b/code/readout24.png differ
diff --git a/code/recorder.cpp b/code/recorder.cpp
index d7a04e0..2e2b0d6 100644
--- a/code/recorder.cpp
+++ b/code/recorder.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -44,17 +44,17 @@ void Recorder::record(const string &cmd) {
 }
 
 void Recorder::saveRecordings(const string &file) {
-  ofstream fout(file.c_str(), ios::trunc|ios::out);
-  fout << "void run() {" << endl;
+  std::ofstream fout(file.c_str(), std::ios::trunc|std::ios::out);
+  fout << "void run() {" << std::endl;
   for (list<string>::iterator it = records.begin(); it != records.end(); ++it) {
     if (it->find_first_of("\n") == string::npos)
-      fout << "  " << *it << endl;
+      fout << "  " << *it << std::endl;
     else {
       vector<string> splt;
       split(*it, "\n", splt);
       int ls = splt[0].find_last_of('\"');
       if (splt.size() > 1 && ls != string::npos) {
-        fout << "  " << splt[0] << "\"" << endl;      
+        fout << "  " << splt[0] << "\"" << std::endl;      
         int ind = splt[0].length() + 2 - ls;
         for (size_t j = 1; j < splt.size(); j++) {
           for (int k = 0; k < ind; k++)
@@ -62,13 +62,13 @@ void Recorder::saveRecordings(const string &file) {
           fout << "\"";
           fout << splt[j];
           if (j + 1 == splt.size())
-            fout << endl;
+            fout << std::endl;
           else
-            fout << "\"" << endl;
+            fout << "\"" << std::endl;
         }
       }
     }
   }
-  fout << "}" << endl;
+  fout << "}" << std::endl;
 }
 
diff --git a/code/recorder.h b/code/recorder.h
index 810376c..7352f8f 100644
--- a/code/recorder.h
+++ b/code/recorder.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/resource.h b/code/resource.h
index 2bb1870..c1789ae 100644
--- a/code/resource.h
+++ b/code/resource.h
@@ -17,6 +17,19 @@
 #define IDI_SPLASHIMAGE                 512
 #define IDI_MEOSIMAGE                   513
 #define IDI_MEOSINFO                    514
+#define IDI_MEOSEDIT                    515
+#define IDI_MEOSWARN                    516
+#define IDI_MEOSCLASS24                 517
+#define IDI_MEOSCOURSE24                518
+#define IDI_MEOSCONTROL24               519
+#define IDI_MEOSANNOUNCER24             520
+#define IDI_MEOSSERVICES24              521
+#define IDI_MEOSLIST24                  522
+#define IDI_MEOSRUNNER24                523
+#define IDI_MEOSTEAM24                  524
+#define IDI_MEOSCLUBS24                 525
+#define IDI_MEOSCARD24                  526
+#define IDI_MEOSCOMPETITION24           527
 
 // Next default values for new objects
 // 
diff --git a/code/restserver.cpp b/code/restserver.cpp
index cc486eb..bd1f82f 100644
--- a/code/restserver.cpp
+++ b/code/restserver.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
 MeOS - Orienteering Software
-Copyright (C) 2009-2023 Melin Software HB
+Copyright (C) 2009-2024 Melin Software HB
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -43,6 +43,7 @@ Eksoppsvägen 16, SE-75646 UPPSALA, Sweden
 
 extern Image image;
 using namespace restbed;
+using namespace std;
 
 vector< shared_ptr<RestServer> > RestServer::startedServers;
 
@@ -527,8 +528,9 @@ void RestServer::getData(oEvent &oe, const string &what, const multimap<string,
     set<int> cls;
     if (param.count("class") > 0)
       getSelection(param.find("class")->second, cls);
+    pair<string, string> preferredIdTypes;
 
-    oe.exportIOFSplits(oEvent::IOF30, exportFile.c_str(), false, useUTC, cls, -1, false, false, true, false, false);
+    oe.exportIOFSplits(oEvent::IOF30, exportFile.c_str(), false, useUTC, cls, preferredIdTypes, -1, false, false, true, false, false);
     ifstream fin(exportFile.c_str());
     string rbf;
     while (std::getline(fin, rbf)) {
@@ -543,8 +545,9 @@ void RestServer::getData(oEvent &oe, const string &what, const multimap<string,
     set<int> cls;
     if (param.count("class") > 0)
       getSelection(param.find("class")->second, cls);
+    pair<string, string> preferredIdTypes;
 
-    oe.exportIOFStartlist(oEvent::IOF30, exportFile.c_str(), useUTC, cls, false, true, false, false);
+    oe.exportIOFStartlist(oEvent::IOF30, exportFile.c_str(), useUTC, cls, preferredIdTypes, false, true, false, false);
     ifstream fin(exportFile.c_str());
     string rbf;
     while (std::getline(fin, rbf)) {
@@ -1150,7 +1153,7 @@ void RestServer::lookup(oEvent &oe, const string &what, const multimap<string, s
         auto &sd = r->getSplitTimes(false);
         vector<int> after;
         r->getLegTimeAfter(after);
-        vector<int> afterAcc;
+        vector<oRunner::ResultData> afterAcc;
         r->getLegTimeAfterAcc(afterAcc);
         vector<int> delta;
         r->getSplitAnalysis(delta);
@@ -1177,8 +1180,8 @@ void RestServer::lookup(oEvent &oe, const string &what, const multimap<string, s
                 else
                   analysis[0].second = L"";
 
-                if (afterAcc[ix] > 0)
-                  analysis[1].second = formatTime(afterAcc[ix]);
+                if (afterAcc[ix].get(0) > 0)
+                  analysis[1].second = formatTime(afterAcc[ix].get(false));
                 else
                   analysis[1].second = L"";
 
@@ -1190,7 +1193,7 @@ void RestServer::lookup(oEvent &oe, const string &what, const multimap<string, s
                 int place = r->getLegPlace(ix);
                 analysis[3].second = place > 0 ? itow(place) : L"";
                  
-                int placeAcc = r->getLegPlaceAcc(ix);
+                int placeAcc = r->getLegPlaceAcc(ix, false);
                 analysis[4].second = placeAcc > 0 ? itow(placeAcc) : L"";
 
                 xml.write("Analysis", analysis, L"");
@@ -1407,8 +1410,7 @@ void RestServer::newEntry(oEvent &oe, const multimap<string, string> &param, str
       if (r) {
         int cf = 0;
         if (cardNo > 0 && oe.isHiredCard(cardNo)) {
-          cf = oe.getBaseCardFee();
-          r->getDI().setInt("CardFee", cf);
+          r->setRentalCard(true);
         }
         r->setFlag(oRunner::FlagAddedViaAPI, true);
         r->addClassDefaultFee(true);
diff --git a/code/restserver.h b/code/restserver.h
index 978d031..a330748 100644
--- a/code/restserver.h
+++ b/code/restserver.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
 MeOS - Orienteering Software
-Copyright (C) 2009-2023 Melin Software HB
+Copyright (C) 2009-2024 Melin Software HB
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -66,7 +66,7 @@ private:
     multimap<string, string> parameters;
     string answer;
     vector<uint8_t> image;
-    atomic_bool state; //false - asked, true - answerd
+    std::atomic_bool state; //false - asked, true - answerd
 
     bool isCompleted() { 
       return state; 
@@ -76,11 +76,11 @@ private:
   EntryPermissionClass  epClass = EntryPermissionClass::None;
   EntryPermissionType epType = EntryPermissionType::None;
   
-  mutex lock;
-  atomic_bool hasAnyRequest;
-  shared_ptr<thread> service;
+  std::mutex lock;
+  std::atomic_bool hasAnyRequest;
+  shared_ptr<std::thread> service;
   shared_ptr<restbed::Service> restService;
-  condition_variable waitForCompletion;
+  std::condition_variable waitForCompletion;
 
   deque<shared_ptr<EventRequest>> requests;
   void getData(oEvent &ref, const string &what, const multimap<string, string> &param, string &answer);
@@ -131,7 +131,7 @@ private:
     InfoServerContainer(int s, int e) : nextInstanceId(s), instanceIncrementor(e) {}
   };
 
-  shared_ptr<default_random_engine> randGen;
+  shared_ptr<std::default_random_engine> randGen;
   list<InfoServerContainer> isContainers;
   int getNewInstanceId();
   xmlbuffer *getMOPXML(oEvent &oe, int id, int &nextId);
@@ -154,8 +154,8 @@ public:
   void setRootMap(const string &rootMap);
   const string &getRootMap() const { return root; }
 
-  tuple<EntryPermissionClass, EntryPermissionType> getEntryPermission() const {
-    return make_tuple(epClass, epType);
+  std::tuple<EntryPermissionClass, EntryPermissionType> getEntryPermission() const {
+    return std::make_tuple(epClass, epType);
   }
 
   struct Statistics {
diff --git a/code/runner24.png b/code/runner24.png
new file mode 100644
index 0000000..a5e981f
Binary files /dev/null and b/code/runner24.png differ
diff --git a/code/services24.png b/code/services24.png
new file mode 100644
index 0000000..6eefd0a
Binary files /dev/null and b/code/services24.png differ
diff --git a/code/socket.cpp b/code/socket.cpp
index c26ec7d..3f307c4 100644
--- a/code/socket.cpp
+++ b/code/socket.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/socket.h b/code/socket.h
index bc5a533..7511249 100644
--- a/code/socket.h
+++ b/code/socket.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/speakermonitor.cpp b/code/speakermonitor.cpp
index 68197d2..0a43d5d 100644
--- a/code/speakermonitor.cpp
+++ b/code/speakermonitor.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/speakermonitor.h b/code/speakermonitor.h
index 8559875..b03961e 100644
--- a/code/speakermonitor.h
+++ b/code/speakermonitor.h
@@ -1,7 +1,7 @@
 #pragma once
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/subcommand.h b/code/subcommand.h
index c2b318d..89fb27d 100644
--- a/code/subcommand.h
+++ b/code/subcommand.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
 MeOS - Orienteering Software
-Copyright (C) 2009-2023 Melin Software HB
+Copyright (C) 2009-2024 Melin Software HB
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
diff --git a/code/swedish.lng b/code/swedish.lng
index 6177cc5..78b233b 100644
--- a/code/swedish.lng
+++ b/code/swedish.lng
@@ -374,7 +374,7 @@ Don't know how to align with 'X' = Kan inte justera mot 'X'
 Du kan använda en SI-enhet för att läsa in bricknummer = Du kan använda en SI-enhet för att läsa in bricknummer
 Du kan importera banor och klasser från OCADs exportformat = Du kan importera banor och klasser från OCAD:s exportformat
 Du kan justera tiden för en viss enhet = Du kan justera tiden för en viss enhet
-Du måste ange minst två gafflingsvarienater = Du måste ange minst två gafflingsvarienater
+Du måste ange minst två gafflingsvarienater = Du måste ange minst två gafflingsvarianter
 Du måste välja en klass = Du måste välja en klass
 Duplicera = Duplicera
 Duplicerad nummerlapp: X, Y = Duplicerad nummerlapp: X, Y
@@ -1347,7 +1347,7 @@ PunchSplitTime = Tid sedan föregående kontroll
 PunchTime = Stämplingstid
 PunchTimeSinceLast = Tid mellan stämplingar
 PunchTotalTime = Tid till stämpling
-PunchTotalTimeAfter = Tid efter vid kontroll
+PunchTotalTimeAfter = Tid efter, vid kontroll
 Punches = Stämplingar
 På banan = På banan
 Rad X är ogiltig = Rad X är ogiltig
@@ -2147,7 +2147,7 @@ Vill du nollställa alla manuellt tilldelade banor? = Vill du nollställa alla m
 Vill du radera X rader från tabellen? = Vill du radera X rader från tabellen?
 Vill du radera alla vakanser från tävlingen? = Vill du radera alla vakanser från tävlingen?
 Vill du skapa en ny klass? = Vill du skapa en ny klass?
-Vill du spara ändringar? = Vill du spara ändringar?
+Vill du spara ändringar? = Vill du spara ändringarna?
 Vill du sätta hyrbricka på befintliga löpare med dessa brickor? = Vill du sätta hyrbricka på befintliga löpare med dessa brickor?
 Vill du sätta resultatet från tidigare etapper till <Deltar ej>? = Vill du sätta resultatet från tidigare etapper till <Deltar ej>?
 Vill du ta bort 'X'? = Vill du ta bort 'X'?
@@ -2349,7 +2349,7 @@ help:59395 = I det här formuläret kan du snabbt göra grundläggande inställn
 help:59395_more = Klassernas avgifter, som visas om du har aktiverat Ekonomifunktionerna, används för nya deltagare. Ändrar du dem får du en fråga om att uppdatera avgifterna för redan anmälda.\n\nFör nummerlapp finns alternativet Ingen, Löpande och Manuell. Du kan också skriva in ett första nummerlappsnummer i klassen, t.ex. A100, eller 50. Löpande betyder att sista nummerlappsnummer i föregående klass används för att sätta första nummer i denna klass. Reserverade nummerlappsnummer innebär att ett motsvarande hopp görs i numreringen mellan klasser.\n\nMeOS uppdaterar nummerlappar vid lottning, eller om inställningarna ändras. Manuell betyder att MeOS aldrig automatiskt ändrar klassens nummerlappar.\n\nFör klasser med lag styr inställningen Lagmedlem löparnas nummerlapp i förhållande till lagets. De kan vara samma, ökande (100, 101, 102), bero på sträcka (100-1, 100-2, etc.) eller vara helt oberoende. 
 help:7618 = Antalet löpare i laget ställer man in på sidan klasser.
 help:7620 = Intervall (sekunder). Lämna blankt för att uppdatera när tävlingsdata ändras
-help:89064 = Till varje kontroll anger man en eller flera kodsiffror (SI-kod). När man lägger banor refererar man till kontrollens ID-nummer. Man behöver normalt inte själv lägga till kontroller eftersom MeOS automatiskt lägger till de kontroller som används. \n\nFlera kodsiffror är användbart för att ersätta trasiga kontroller eller för att skapa enkla gafflingar. För en vanlig kontroll krävs att löparen besökt en av de angivna kontrollerna. Sätts status till <Multipel> måste löparen besöka samtliga listade kontroller i valfri ordning.\n\nOm man sätter kontrollens status till <Trasig>, kommer den inte att användas i stämplingskontrollen.\n\nFörsvunnen fungerar som trasig, men dessutom hoppas tidtagning över till nästa kontroll; det spelar ingen roll hur länge man letade efter den försvunna kontrollen.\n\nEn kontroll kan tilldelas ett namn, t.ex. 'Varvning'. Det går att skriva ut resultatlistor som innehåller mellantider för namngivna kontroller.\n\nTidsjustering används om det visar sig att en kontrolls klocka går fel:formatet är +/-MM:SS eller +/-HH:MM:SS.\n\nMinsta sträcktid kan användas exempelvis vid vägpassage. Ingen löpare kan få en bättre sträcktid in mot kontrollen än den angivna tiden. Överskrider löparen den angivna tiden, används löparens faktiska tid.\n\nStatus <Utan tidtagning> betyder att löparens tid till kontrollen ignoreras; sluttiden blir densamma oavsett faktisk sträcktid.
+help:89064 = Till varje kontroll anger man en eller flera kodsiffror (SI-kod). När man lägger banor refererar man till kontrollens ID-nummer. Man behöver normalt inte själv lägga till kontroller eftersom MeOS automatiskt lägger till de kontroller som används. \n\nFlera kodsiffror är användbart för att ersätta trasiga kontroller eller för att skapa enkla gafflingar. För en vanlig kontroll krävs att löparen besökt en av de angivna kontrollerna. Sätts status till <Multipel> måste löparen besöka samtliga listade kontroller i valfri ordning.\n\nOm man sätter kontrollens status till <Trasig>, kommer den inte att användas i stämplingskontrollen.\n\nFörsvunnen fungerar som trasig, men dessutom hoppas tidtagning över till nästa kontroll; det spelar ingen roll hur länge man letade efter den försvunna kontrollen.\n\nEn kontroll kan tilldelas ett namn, t.ex. 'Varvning'. Det går att skriva ut resultatlistor som innehåller mellantider för namngivna kontroller.\n\nTidsjustering används om det visar sig att en kontrolls klocka går fel: formatet är +/-MM:SS eller +/-HH:MM:SS.\n\nMinsta sträcktid kan användas exempelvis vid vägpassage. Ingen löpare kan få en bättre sträcktid in mot kontrollen än den angivna tiden. Överskrider löparen den angivna tiden, används löparens faktiska tid.\n\nStatus <Utan tidtagning> betyder att löparens tid till kontrollen ignoreras; sluttiden blir densamma oavsett faktisk sträcktid.
 help:9373 = Ange en eller flera kodsiffror (SI-kod) som används av den här kontrollen, t.ex. 31, 250.
 help:9615 = Fick inget svar. Ska porten öppnas i passivt läge; ska MeOS lyssna efter inkommande stämplingar?
 help:DirectResult = - Om bana ej tilldelats godkänns deltagaren vid målstämpling.\n\n- Om en bana finns används radiostämplingar som kontroller. Ingen brickavläsning ska göras.
@@ -2368,11 +2368,11 @@ help:duplicate = Gör en lokal kopia på av den aktuella tävlingen.
 help:eventorkey = Mata in klubbens API-nyckel för Eventor, den behövs för att du ska kunna ansluta till Eventor och hämta anmälningar och löparregister. Nyckeln får du av klubbens Eventor-administratör.
 help:exportdraw = Du kan exportera ett kalkylark i CSV-format innehållande klasser, antal anmälda och lottningsinställningar för varje klass. Därefter kan du redigera lottningsuppgifterna och importera dem tillbaka till MeOS för lottning.
 help:fullscreen = Du kan justera farten med Ctrl+M (öka) respektive Ctrl+N (minska) på tangentbordet. För att lämna fullskärmsläge, tryck på Esc.
-help:import_entry_data = Du kan importera löpare, klasser, klubbar och anmälningar från en antal olika text- och XML-format. Det är inte nödvändigt att ange samtliga filer. Till exempel innehåller OE-CSV formatet för anmälningar även klasser och klubbar, så i det fallet ska fälten för klasser och klubbar lämnas tomma.\n\nOm samma löpare importeras flera gånger, kommer löparen att uppdateras den andra gången. Man får inte flera kopior på löparen. Det innebär att man kan importera efteranmälningar genom att läsa in en utökad fil med anmälda.
+help:import_entry_data = Du kan importera löpare, klasser, klubbar och anmälningar från ett antal olika text- och XML-format. Det är inte nödvändigt att ange samtliga filer. Till exempel innehåller OE-CSV formatet för anmälningar även klasser och klubbar, så i det fallet ska fälten för klasser och klubbar lämnas tomma.\n\nOm samma löpare importeras flera gånger, kommer löparen att uppdateras den andra gången. Man får inte flera kopior på löparen. Det innebär att man kan importera efteranmälningar genom att läsa in en utökad fil med anmälda.
 help:importcourse = Du kan importera banor och klasser från (exempelvis) OCAD:s eller Condes exportformat.
 help:liveresultat = Den här funktionen startar en timer i helskärmsläge (storbildsskärm) när en deltagare i vald klass stämplar kontrollen från, och tar tid tills slutkontrollen nås. Däremellan visas en topplista med de bästa resultaten. Gör de inställningar som krävs, dra fönstret till den skärm som ska användas och tryck på <Starta>. Vid användning av nätverk bör <snabb förhandsinformation om stämplingar> vara aktiverat för att undvika fördröjningar.
 help:long_times = Tävlingsdatum avser det datum då alla klasser startar. Nolltiden är 00:00:00.
-help:merge = Det är möjligt att slå ihop tävlingar och resultat, givet att de är grundade på samma uppsättning banor och kontroller. Olika grupper deltagare kan genomföra tävlingen vid olika tillfällen och sedan kan de olika tävlingarna slås ihop till en tävling med gemensam resultatlista. En annan möjlighet är att ha olika TC för olika klasser. Om det inte är möjligt att att sätt upp ett gemensamt nätverk, kan man med jämna mellanrum utbyta tävlingsfiler för att införliva ändringar.\n\n1. Förbered hela tävlingen.\n2. Spara en kopia och importera den på de utlokaliserade datorerna (eller lokala nätverken).\n3. För att överföra ändringar, exportera tävlingen från den utlokaliserade datorn (eller datorerna) och slå ihop den med denna funktion. Exportera sedan en kopia från huvuddatorn och gör motsvarande import på de utlokaliserade datorerna.\n4 Proceduren kan upprepas flera gånger för att kontinuerligt överföra resultaten. \n\n Observera: Om du gör ändringar i (t.ex.) samma deltagare på flera ställen, blir vissa av ändringarna överskrivna utan varning. Se till att varje utlokaliserat ställe endast ändrar i sin del av tävlingen.\n\nTips: Gör en överföring så snart de utlokaliserade tävlingarna är startade innan någon ändring utförts, för att testa att allt blivit rätt uppsatt. 
+help:merge = Det är möjligt att slå ihop tävlingar och resultat, givet att de är grundade på samma uppsättning banor och kontroller. Olika grupper deltagare kan genomföra tävlingen vid olika tillfällen och sedan kan de olika tävlingarna slås ihop till en tävling med gemensam resultatlista. En annan möjlighet är att ha olika TC för olika klasser. Om det inte är möjligt att sätta upp ett gemensamt nätverk, kan man med jämna mellanrum utbyta tävlingsfiler för att införliva ändringar.\n\n1. Förbered hela tävlingen.\n2. Spara en kopia och importera den på de utlokaliserade datorerna (eller lokala nätverken).\n3. För att överföra ändringar, exportera tävlingen från den utlokaliserade datorn (eller datorerna) och slå ihop den med denna funktion. Exportera sedan en kopia från huvuddatorn och gör motsvarande import på de utlokaliserade datorerna.\n4 Proceduren kan upprepas flera gånger för att kontinuerligt överföra resultaten. \n\n Observera: Om du gör ändringar i (t.ex.) samma deltagare på flera ställen, blir vissa av ändringarna överskrivna utan varning. Se till att varje utlokaliserat ställe endast ändrar i sin del av tävlingen.\n\nTips: Gör en överföring så snart de utlokaliserade tävlingarna är startade innan någon ändring utförts, för att testa att allt blivit rätt uppsatt. 
 help:ocad13091 = Om du har tillgång till banorna på fil (till exempel från OCAD or Condes) kan du ange filens namn här. Annars kan du lägga in banorna senare.
 help:onlineinput = Automaten används för att ta emot radiostämplingar från internet, t.ex. radiokontroller anslutna via mobiltelefon. Det är också möjligt att ha ett enkelt webbformulär där personer vid en bemannad radiokontroll fyller i nummerlappsnummer på dem som passerar.\n\nAutomatens protokoll stöder också andra typer av inmatningar, såsom laguppställningar, direktanmälningar, brickändringar m.m. Om du vill utveckla egna tjänster finns dokumentation och exempel på MeOS hemsida: www.melin.nu/meos.
 help:onlineresult = Automaten används för att skicka resultat och startlistor för direkt visning på webben eller i appar. Du måste göra inställningar som är anpassade för den tjänst du vill utnyttja: tjänsteleverantören kan ge dig detaljer.\n\nOm du vill utveckla egna tjänster finns dokumentation och exempel på MeOS hemsida: www.melin.nu/meos.
@@ -2399,7 +2399,7 @@ help_autodraw = Mata in första (ordinarie) starttid, minsta startintervall (ino
 help_draw = Lottning görs i två steg. Först anger du vilka klasser du vill lotta och gör grundläggande inställningar. När du trycker på <Fördela starttider> använder MeOS inställningarna för att fördela starttider mellan klasser. MeOS ser till att klasser med liknande banor inte startar samtidigt och tar hänsyn till redan lottade klasser. Målet är ett så jämnt flöde av startande som möjligt.\n\nFördelningen presenteras i en tabell, där du kan göra egna förändringar och eventuellt låta MeOS göra en ny fördelning med hänsyn till de ändringar du gjort. När du är nöjd med fördelningen låter du MeOS lotta de valda klasserna.\n\nDe grundläggande inställningar du måste göra är första starttid och minsta startintervall. Inställningen max parallellt startande anger hur många löpare som får samtidigt. Ett större värde ger ett kortare startdjup.\n\nAndel vakanser anger om MeOS ska lotta in vakanta platser i startfältet. Ange 0% för inga vakanser. Förväntat antal efteranmälde används för att reservera plats i startfältet för efteranmälda. Inga vakanta platser sätts in, men det lämnas utrymme i startlistan med garanti för att inga samtidigt startande ska ha samma bana.
 htmlhelp = HTML kan exporteras som en strukturerad tabell, eller som ett fritt formaterat dokument (som mer liknar listorna i MeOS). Man kan också använda exportmallar för speciell formatering: kolumner, automatisk visning av sidor, rullning, etc. Du kan egna skapa mallar genom att lägga till '.template'-filter i MeOS datakatalog. Om du använder en mall finns ett antal parametrar att styra nedan. Exakt hur de tolkas beror på mallen.\n\nOm du väljer att <Lagra inställningar> sparas listan och inställningarna permanent i tävlingen. Du kan då komma åt listan genom att använda MeOS som webbserver (Automaten informationsserver) eller exportera listan till fil automatiskt med jämna mellanrum.
 info:advanceinfo = Det gick inte att starta tjänsten för förhandsinformation om resultat; resultat kommer med några sekunders fördröjning. Detta är väntat om fler än en MeOS-process körs på samma dator.
-info:customsplitprint = Du kan använda en egen lista för sträcktidstskrifter. Designa listan och använd knappen 'Sträcktidslista' i listredigeraren för att göra inställningar för sträcktidsutskrift.\n\nDu kan ändra styra lista per klass genom att välja lista i tabelläget för klasser.
+info:customsplitprint = Du kan använda en egen lista för sträcktidsutskrifter. Designa listan och använd knappen 'Sträcktidslista' i listredigeraren för att göra inställningar för sträcktidsutskrift.\n\nDu kan ändra styra lista per klass genom att välja lista i tabelläget för klasser.
 info:mapcontrol = MeOS kan inte automatiskt avgöra vilken funktion en enhet har som inte är direkt ansluten till datorn. För dessa använder MeOS den programmerade stämplingskoden för att bestämma vilken typ av enhet det är; du kan själv ställa in hur olika enheter ska tolkas. Kodsiffror högre än 30 tolkas alltid som kontroller.\n\nVar noggrann om du använder startstämplingar för att inte av misstag ändra den lottade starttiden.
 info:multieventnetwork = För att administrera flera etapper måste du arbeta lokalt. Spara en kopia av tävlingen, öppna den lokalt och överför resultat till nästa etapp. Därefter laddar du upp nästa etapp på servern för att genomföra den.
 info:multiple_start = En deltagare kan göra valfritt antal starter med samma bricka. Automatisk nyanmälan för varje varv.
@@ -2433,7 +2433,7 @@ newcmp:featuredesc = Välj vilka funktioner som ska vara tillgängliga för den
 nia = nia
 nionde = nionde
 olshooting:notimepunishment = Resultatlista OL-Skytte utan tidstillägg.\n\nFör att använda listan aktiverar du stöd för Rogaining och manuell poängjustering. Använd sedan fältet poängavdrag på sidan deltagare för att ange bommar på formatet LLSS där LL är antal liggande bom och SS är antal stående bom. Exempel: 0201 betyder 2 liggande och 1 stående bom.
-olshooting:timepunishment = Resultatlista OL-Skytte med tidstillägg.\n\nFör att använda listan aktiverar du stöd för Rogaining och manuell poängjustering. Använd sedan fältet poängavdrag på sidan deltagare för att ange bommar på formatet PPPLLSS där PPP är är mm fel i punktorientering, LL är antal liggande bom och SS är antal stående bom. Exempel 30201 betyder 3 mm fel, 2 liggande och 1 stående bom.
+olshooting:timepunishment = Resultatlista OL-Skytte med tidstillägg.\n\nFör att använda listan aktiverar du stöd för Rogaining och manuell poängjustering. Använd sedan fältet poängavdrag på sidan deltagare för att ange bommar på formatet PPPLLSS där PPP är mm fel i punktorientering, LL är antal liggande bom och SS är antal stående bom. Exempel 30201 betyder 3 mm fel, 2 liggande och 1 stående bom.
 open_error = Kan inte öppna X.\n\nY.
 open_error_locked = Tävlingen är redan öppnad i MeOS.\n\nDu måste använda en databas för att öppna flera instanser av tävlingen.
 prefsAccount = Förvalt kontonummer
@@ -2485,7 +2485,7 @@ prefsOrganizer = Organisatör
 prefsPayModes = Betalningsalternativ
 prefsPlaySound = Spela ljud vid brickavläsning
 prefsPort = MySQL nätverksport
-prefsRentCard = Hyr brickor
+prefsRentCard = Knyt hyrbrickor
 prefsSeniorAge = Åldersgräns för pensionärsavgift
 prefsServer = Förvald nätverksserver
 prefsServicePort = Förvald serviceport
@@ -2673,7 +2673,7 @@ Individual Results Split Print = Individuell sträcktidsutskrift
 Ingen[bild] = Ingen
 Klubbstartlista, lag = Klubbstartlista, lag
 Ny bild = Ny bild
-Relay Results Split Print = Relay Results Split Print
+Relay Results Split Print = Stafett Sträcktidsutskrift
 Relay/Team Results Split Print = Lag/stafett sträcktidsutskrift
 Tolka vitt som genomskinligt = Tolka vitt som genomskinligt
 Vertikal = Vertikal
@@ -2683,3 +2683,129 @@ Bevara höjd/bredd-relationen = Bevara höjd/bredd-relationen
 RunnerLegTeamLeaderName = Först i mål på sträckan
 info:offsetclassid = Om du importerar anmälningar och klasser från olika källor till samma tävling kan det hända att klassernas Id-nummer krockar. För att hålla isär klasserna kan du då ange en förskjutning av Id-nummer när du arbetar med datafiler från en viss källa; denna kommer att adderas till klassernas Id-nummer.\n\nDu måste ange samma förskjutning varje gång du importerar från en viss källa. Ett lämpligt värde kan vara 1000 (som fungerar om all Id-nummer är mindre än 1000).
 Förskjutning av klassers Id = Förskjutning av klassers Id
+Tilldela nummerlapp till vakanter = Tilldela nummerlapp till vakanter
+Avläsning = Avläsning
+Inmatning Testning = Inmatning Testning
+Testning = Testning
+CourseNumControls = Antal kontroller
+PunchControlPlaceTeamAcc = Lags totala placering vid kontroll
+PunchTeamTime = Lags totala tid och sträcktid till kontroll
+PunchTeamTotalNamedTime = Lags totala namngivna mellantid
+PunchTeamTotalTime = Lags totala löptid till kontroll
+PunchTeamTotalTimeAfter = Lags tid efter, vid kontroll
+Aktivera kioskläge = Aktivera kioskläge
+Avstånd mellan förslag (minuter) = Avstånd mellan förslag (minuter)
+Boka starttid = Boka starttid
+Ingen ledig starttid kunde hittas = Ingen ledig starttid kunde hittas
+Minsta tid till start (minuter) = Minsta tid till start (minuter)
+Sista starttid = Sista starttid
+Startintervall (minuter) = Startintervall (minuter)
+Tillåt klass med samma bana på samma starttid = Tillåt klass med samma bana på samma starttid
+Tillåt klass med samma bana på starttid före/efter = Tillåt klass med samma bana på stattid före/efter
+Tillåt klass med samma första kontroll vid samma starttid = Tillåt klass med samma första kontroll vid samma starttid
+Tiden har passerat sista tillåtna starttid = Tiden har passerat sista tillåtna starttid
+Starttiden är  låst = Starttiden är  låst
+Starttiden är redan tilldelad = Starttiden är redan tilldelad
+Klassen tillåter ej val av starttid = Klassen tillåter ej val av starttid
+Klassen lottas inte, boka starttid = Klassen lottas inte, boka starttid på sidan SportIdent.
+Simulerar starttidstilldelning för X deltagare = Simulerar starttidstilldelning för X deltagare
+Simulering = Simulering
+Välj från flera förslag = Välj från flera förslag
+Välj starttid för X = Välj starttid för X
+X: Startid för Y kl Z = X: Startid för Y kl Z
+Önskad starttid = Önskad starttid
+ask:startkiosk = Om du startar en kiosk för bokning av starttid hamnar MeOS i ett läge där inga andra operationer stöds eller inställningar kan ändras. Du behöver en ansluten och aktiverad SI-enhet.\n\nDu bör överväga att lösenordsskydda databasen om du exponerar en kiosk.\n\nVill du starta kioskläget?
+ask:simulatestart = Genomför en simulering med de inställningar du gjort (klasser, startdjup, avstånd, regler) och med de anmälda deltagare som finns i klasserna. Tävlingen påverkas inte. Resultatet visar om det är rimligt att alla hinner starta inom utsatt startdjup och hur lång extra väntetid till start som kan krävas i olika klasser.\n\nEfteråt kan du också spara en kopia på tävlingen med simulerade starttider för att studera t.ex. minutstartlistan.\n\nVill du genomföra simuleringen?
+help:requeststart = Bokad starttid är ett mellanting mellan fri och lottad starttid. Genom att boka en starttid ser MeOS till att det är ett visst avstånd mellan deltagare i samma klass eller på samma bana. Har man en bokad starttid är det inte nödvändigt att startstämpla.\n\nStäll in parametrar för startdjup och hur många/vilka som får starta samtidigt. Hur långt det är från platsen där bokningen sker till starten avgör vad som är ett lämpligt värde på minsta tid till start.\n\nDu kan låta deltagarna automatiskt få första möjliga lediga starttid efter minsta tid till start, eller låta dem välja från ett antal möjliga starttider. Det är möjligt och lämpligt att skriva ut ett startbevis som tas med till start.\n\nOm du använder en tjänst för liveresultat visas troligtvis starttiden där när den bokats. 
+Anslut en SI-enhet och aktivera den = Anslut en SI-enhet och aktivera den
+Manuellt startönskemål = Manuellt startönskemål
+Stämpla för välja starttid = Stämpla för välja starttid
+Tillåt deltagare med samma klubb och klass på närliggande starttid = Tillåt deltagare med samma klubb och klass på närliggande starttid
+prevsExpResFilename = Exportera resultat
+prefsExpStaFilename = Exportera startlista
+prefsRequestClubNeighbour = Boka starttid: Samma klubb på granntid
+prefsRequestLastStart = Boka starttid: Sista start
+prefsRequestMaxParallel = Boka starttid: Max parallellt startande
+prefsRequestMinTime = Boka starttid: Tid till start
+prefsRequestProvideSuggestion = Boka starttid: Ge förslag
+prefsRequestSameCourse = Boka starttid: Samma bana
+prefsRequestSameCourseNeighbour = Boka starttid: Samma bana på granntid
+prefsRequestSameFirstControl = Boka starttid: Samma första kontroll
+prefsRequestStartInterval = Boka starttid: Intervall
+prefsRequestSuggestInterval = Boka starttid: Tid mellan förslag
+Omstart: X = Omstart: X
+Reptid: X = Reptid: X
+Datortid = Datortid
+Start på signal = Start på signal
+Sätt tiden = Sätt tiden
+Välj vilken tid du vill sätta = Välj vilken tid du vill sätta
+Starta nu = Starta nu
+Alla okvalificerade = Alla okvalificerade
+Antal nivåer = Antal nivåer
+Använd ranking istället för placering i kval för att placera kvalificerade löpare i klasser = Använd ranking istället för placering i kval för att placera kvalificerade löpare i klasser
+Bästa tid = Bästa tid
+Final = Final
+Klass / placering = Klass / placering
+Klass X (namnsuffix) = Klass X (namnsuffix)
+Klass efter ranking = Klass efter ranking
+Kval = Kval
+Kvalificeringsregler för X = Kvalificeringsregler för X
+Kvalklass = Kvalklass
+Ladda = Ladda
+N bästa = N bästa
+Nivå X = Nivå X
+Placeringar = Placeringar
+Regler = Regler
+Tidsgräns X = Tidsgräns X
+Tidskval = Tidskval
+Use in X = Använd i X
+X kvalificerade = X kvalificerade
+Övriga okvalificerade = Övriga okvalificerade
+Lägg till regler = Lägg till regler
+Placering X kvalificerar till Y = Placering X kvalificerar till Y
+X bästa = X bästa
+Alla övriga = Alla övriga
+Vill du starta automaten? = Vill du starta automaten?
+För kommunikationstest kan man använda en separat testtävling = För kommunikationstest kan man använda en separat testtävling
+Observera att stämplingar före tävlingens nolltid inte kan hämtas = Observera att stämplingar före tävlingens nolltid inte kan hämtas
+Individual Rogaining Split Print = Sträcktidsutskrift, Rogaining 
+Lap Count = Varvräkning
+Lap count with extra punch = Varvräkning med extra stämpling
+Live results, radio = Liveresultat, radio
+Patrol results = Patrullresultat
+Patrol, start list = Patrullstartlista
+Resultatlista, Rogaining, lag = Resultatlista, Rogaining, lag
+Startlista, lag = Startlista, lag
+Team Rogaining Split Print = Sträcktidsutskrift, Rogaining lag
+X bästa okvalificerade = X bästa okvalificerade
+RunnerRentalCard = Hyrbricka
+Primärt = Primärt
+Sekundärt = Sekundärt
+Välj typ av ID att exportera = Välj typ av ID att exportera
+Ursprunglig tid: X = Ursprunglig tid: X
+Manuellt ändrad stämpling = Manuellt ändrad stämpling
+help_second_fee = Använd en andra förhöjd avgift för att ange en högre avgift för anmälan på tävlingsdagen (till exempel). Avgiften tas ut från och med det datum som anges. Procentsatsen är relativ ordinarie avgift
+Avgiftshöjning två (procent) = Avgiftshöjning två (procent)
+ClassDataA = Klassdata A
+ClassDataB = Klassdata B
+ClassTextA = Extra klasstext
+Extra data X = Extra data X
+Extra datafält = Extra datafält
+Kommentarer = Kommentarer
+Oförändrad brickdata = Oförändrad brickdata
+Okänd ursprungsstatus = Okänd ursprungsstatus
+RunnerDataA = Deltagardata A
+RunnerDataB = Deltagardata B
+RunnerTextA = Extra deltagartext
+Sida = Sida
+Stoppdatum två = Stoppdatum två
+TeamDataA = Lagdata A
+TeamDataB = Lagdata B
+TeamTextA = Extra lagtext
+Födelsedatum = Födelsedatum
+Kommentar = Kommentar
+Lägg till eller redigera kommentarer om deltagaren = Lägg till eller redigera kommentarer om deltagaren
+Lägg till eller redigera kommentarer om laget = Lägg till eller redigera kommentarer om laget
+Manuellt ändrad brickdata = Manuellt ändrad brickdata
+Efteranmälan = Efteranmälan
+Reducerad = Reducerad
diff --git a/code/team24.png b/code/team24.png
new file mode 100644
index 0000000..0aeb440
Binary files /dev/null and b/code/team24.png differ
diff --git a/code/testmeos.cpp b/code/testmeos.cpp
index 1241556..cfeec5f 100644
--- a/code/testmeos.cpp
+++ b/code/testmeos.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -123,8 +123,8 @@ void TestMeOS::run() const {
 
 void TestMeOS::runProtected(bool protect) const {
   cleanup();
-  gdi_main->setOnClearCb(0);
-  gdi_main->setPostClearCb(0);
+  gdi_main->clearOnClearCb();
+  gdi_main->clearPostClearCb();
   gdi_main->clearPage(false, false);
   gdi_main->dbRegisterSubCommand(0, "");
   subWindows.clear();
@@ -150,8 +150,8 @@ void TestMeOS::runProtected(bool protect) const {
     gdi_main->clearDialogAnswers(true);
     status = PASSED;
     if (protect) {
-      gdi_main->setOnClearCb(0);
-      gdi_main->setPostClearCb(0);
+      gdi_main->clearOnClearCb();
+      gdi_main->clearPostClearCb();
       gdi_main->clearPage(false, false);
       oe_main->clear();
       showTab(TCmpTab);
diff --git a/code/testmeos.h b/code/testmeos.h
index d58e6f2..491391e 100644
--- a/code/testmeos.h
+++ b/code/testmeos.h
@@ -2,7 +2,7 @@
 
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/timeconstants.hpp b/code/timeconstants.hpp
index 9369166..8308c11 100644
--- a/code/timeconstants.hpp
+++ b/code/timeconstants.hpp
@@ -1,4 +1,26 @@
 #pragma once
+/************************************************************************
+    MeOS - Orienteering Software
+    Copyright (C) 2009-2024 Melin Software HB
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License fro more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+    Melin Software HB - software@melin.nu - www.melin.nu
+    Eksoppsvägen 16, SE-75646 UPPSALA, Sweden
+
+************************************************************************/
+
 constexpr int timeUnitsPerSecond = 10;
 
 constexpr int timeConstHour = 3600 * timeUnitsPerSecond;
diff --git a/code/toolbar.cpp b/code/toolbar.cpp
index 1b47fea..1dc409d 100644
--- a/code/toolbar.cpp
+++ b/code/toolbar.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/toolbar.h b/code/toolbar.h
index f05041a..4324e2c 100644
--- a/code/toolbar.h
+++ b/code/toolbar.h
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/code/warn24.png b/code/warn24.png
new file mode 100644
index 0000000..bd13cb5
Binary files /dev/null and b/code/warn24.png differ
diff --git a/code/xmlparser.cpp b/code/xmlparser.cpp
index 5cf29a9..1e51d2c 100644
--- a/code/xmlparser.cpp
+++ b/code/xmlparser.cpp
@@ -1,6 +1,6 @@
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -37,6 +37,8 @@
 
 extern gdioutput *gdi_main;
 
+using namespace std;
+
 xmlparser::xmlparser() : utfConverter(gdi_main)
 {
   progress = 0;
@@ -45,6 +47,8 @@ xmlparser::xmlparser() : utfConverter(gdi_main)
   isUTF = false;
   cutMode = false;
   toString = false;
+  strbuff.resize(buff_pre_alloc);
+  strbuffw.resize(buff_pre_alloc);
 }
 
 xmlparser::~xmlparser()
@@ -930,7 +934,7 @@ const char *xmlobject::getPtr() const {
   if (parser->isUTF) {
     int len = strlen(ptr);
     len = min(len+1, buff_pre_alloc-10);
-    int wlen = MultiByteToWideChar(CP_UTF8, 0, ptr, len, parser->strbuffw, buff_pre_alloc);
+    int wlen = MultiByteToWideChar(CP_UTF8, 0, ptr, len, parser->strbuffw.data(), buff_pre_alloc);
     parser->strbuffw[wlen-1] = 0;
     for (int k = 0; k< wlen; k++) {
       buff[k] = parser->strbuffw[k] & 0xFF; 
@@ -1020,16 +1024,16 @@ string &xmlobject::getObjectString(const char *pname, string &out) const
   if (x) {
     const char *bf = x.getRawPtr();
     if (bf) {
-      parser->convertString(bf, parser->strbuff, buff_pre_alloc);
-      out = parser->strbuff;
+      parser->convertString(bf, parser->strbuff.data(), buff_pre_alloc);
+      out = parser->strbuff.data();
       return out;
     }
   }
 
   xmlattrib xa(getAttrib(pname));
   if (xa && xa.data) {
-    parser->convertString(xa.getPtr(), parser->strbuff, buff_pre_alloc);
-    out = parser->strbuff;
+    parser->convertString(xa.getPtr(), parser->strbuff.data(), buff_pre_alloc);
+    out = parser->strbuff.data();
   }
   else
     out = "";
@@ -1050,8 +1054,8 @@ wstring &xmlobject::getObjectString(const char *pname, wstring &out) const
 
   xmlattrib xa(getAttrib(pname));
   if (xa && xa.data) {
-    parser->convertString(xa.getPtr(), parser->strbuffw, buff_pre_alloc);
-    out = parser->strbuffw;
+    parser->convertString(xa.getPtr(), parser->strbuffw.data(), buff_pre_alloc);
+    out = parser->strbuffw.data();
   }
   else
     out = L"";
diff --git a/code/xmlparser.h b/code/xmlparser.h
index 21d0e51..b441c44 100644
--- a/code/xmlparser.h
+++ b/code/xmlparser.h
@@ -10,7 +10,7 @@
 #endif // _MSC_VER > 1000
 /************************************************************************
     MeOS - Orienteering Software
-    Copyright (C) 2009-2023 Melin Software HB
+    Copyright (C) 2009-2024 Melin Software HB
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -91,10 +91,10 @@ protected:
   int tagStackPointer;
 
   bool toString;
-  ofstream foutFile;
-  ostringstream foutString;
+  std::ofstream foutFile;
+  std::ostringstream foutString;
 
-  ifstream fin;
+  std::ifstream fin;
 
   std::ostream &fOut() {
     if (toString)
@@ -122,8 +122,8 @@ protected:
   bool cutMode;
 
   bool isUTF;
-  char strbuff[buff_pre_alloc]; // Temporary buffer for processing (no threading allowed)
-  wchar_t strbuffw[buff_pre_alloc]; // Temporary buffer for processing (no threading allowed)
+  vector<char> strbuff; // Temporary buffer for processing (no threading allowed)
+  vector<wchar_t> strbuffw; // Temporary buffer for processing (no threading allowed)
 
   ProgressWindow *progress;
   int lastIndex;