/****************************************************************************
** Leistungsorientierte Krankenanstaltenfinanzierung (LKF)                 **
** Scoring-C-Sourcen V2026.1                                               **
** (C) 2026 BMASGPK                                                        **
*****************************************************************************
** plaus5.c - MBDS-Plausibilitaetsueberpruefungen                          **
**                                                                         **
**		 Alex.Holzer@chello.at                                             **
**       Bernhard.Pesec@dothealth.at                                       **
****************************************************************************/

#include "lkfint5.h"
#include <ctype.h>
#include <time.h>

/* static functions: argument prototypes *************************************/

static void ABTDAT_Check  (LKF_AUFENTHALT *pAufenthalt);
static void ABTFC_Check   (LKF_AUFENTHALT *pAufenthalt);
static void MEL_JoinEqual (LKF_AUFENTHALT *pAufenthalt, int *tmp_melanz);
static int  ENTDAT_Check  (LKF_AUFENTHALT *pAufenthalt, int cmb_jahr, char period_type, int period_val);
static int  AUFDAT_Check  (LKF_AUFENTHALT *pAufenthalt);
static void GEBDAT_Check  (LKF_AUFENTHALT *pAufenthalt, int cmb_jahr);
static void AUFART_Check  (LKF_AUFENTHALT *pAufenthalt);
static void PSYCH_Check (LKF_AUFENTHALT *pAufenthalt);
static void STAAT_Check   (LKF_AUFENTHALT *pAufenthalt);
static void KOST_Check    (LKF_AUFENTHALT *pAufenthalt);
static int Hauptdiagnose_Check   (LKF_AUFENTHALT *pAufenthalt, unsigned int i, int *diag_ambulant, int *options);
static int Zusatzdiagnose_Check  (LKF_AUFENTHALT *pAufenthalt, unsigned int i, int *diag_ambulant, int *options);
static void SternKreuz_Check (LKF_AUFENTHALT *pAufenthalt);
static void Einzelleistung_Check (LKF_AUFENTHALT *pAufenthalt, unsigned int i, int anz, int *diag_ambulant);
static void MEL_MEL_Check (LKF_AUFENTHALT *pAufenthalt, unsigned int i);
static void MELDIAG_Check (LKF_AUFENTHALT *pAufenthalt, MEL_ARRAY_STRUC *pMel, int mel, unsigned int i, STAMM2001 *pStamm);

static int Insert_Error (int code, int index, LKF_AUFENTHALT *pAufenthalt, LKF_ERROR_LIST **ppLast);
static int Insert_NewError (int errorindex, LKF_ERROR_LIST **ppFirst, LKF_ERROR_LIST **ppLast, LKF_CONTEXT *pContext);
/*
static void Plaus_Error (LKF_AUFENTHALT *, int code, int index);
void	    Plaus_Warn  (LKF_AUFENTHALT *, int code, int index);
*/

#define DIAG_OPTION_HAS_STROKEABT      1
#define DIAG_OPTION_NO_STROKEABT       2
#define DIAG_OPTION_AMBLEIST_VERPFLICHTEND  4
#define DIAG_OPTION_AMBLEIST_NICHTVERPFLICHTEND  8

/*************************************************************************
** Errors und Warnings                                                  **
*************************************************************************/

#define LKF_MBDSERROR_NOINFO	 0
#define LKF_MBDSERROR_NOINFO_M03 103 /* V9.2 */
#define LKF_MBDSERROR_NOINFO_M04 104 /* V9.2 */
#define LKF_MBDSERROR_NOINFO_M05 105 /* V9.2 */
#define LKF_MBDSERROR_GEBDAT	 2
#define LKF_MBDSERROR_ENTDAT	 3
#define LKF_MBDSERROR_ABTDAT	 4
#define LKF_MBDSERROR_GESCHL	 5
#define LKF_MBDSERROR_AUFART	 6
#define LKF_MBDSERROR_ENTART	 7
#define LKF_MBDSERROR_ABTFC		 8 
#define LKF_MBDSERROR_HD		 9
#define LKF_MBDSERROR_ZD		10
#define LKF_MBDSERROR_MEL		11
#define LKF_MBDSERROR_MELABT    41
#define LKF_MBDSERROR_ENTZEIT   42
#define LKF_MBDSERROR_GEMEINDEZIFFER 43
#define LKF_MBDSERROR_AUFZEIT   44
#define LKF_MBDSERROR_ABRECHRELEVANZ 45
#define LKF_MBDSERROR_SOZQUARTAL 46
#define LKF_MBDSERROR_PFLEGFC    47
#define LKF_MBDSERROR_FACHFC     48
#define LKF_MBDSERROR_MELFC      49
#define LKF_MBDSERROR_PLZGEMCO   50
#define LKF_MBDSERROR_TRANSPORTART 51
#define LKF_MBDSERROR_BEHANDLUNGSART 52
#define LKF_MBDSERROR_MELKANR    53

#define LKF_MBDSERROR_MELANZ	12
#define LKF_MBDSERROR_MELDAT	13
#define LKF_MBDSERROR_KANR		14
#define LKF_MBDSERROR_ALTER		15
#define LKF_MBDSERROR_STAATW	16
#define LKF_MBDSERROR_STAATB	17
#define LKF_MBDSERROR_PLZW		18
#define LKF_MBDSERROR_KOST		19
#define LKF_MBDSERROR_ORIGMEL	20
#define LKF_MBDSERROR_GESVD		21
#define LKF_MBDSERROR_ABTID		22
#define LKF_MBDSERROR_AUFDAT    23
#define LKF_MBDSERROR_ABT		24
#define LKF_MBDSERROR_DIAG		25
#define	LKF_MBDSERROR_IAUFART	27
#define LKF_MBDSERROR_SAPSII    28
#define LKF_MBDSERROR_ABTENTDAT 29
#define LKF_MBDSERROR_ABTENTZEIT 30
#define LKF_MBDSERROR_ABTZEIT   31
#define LKF_MBDSERROR_AUFENTZEIT 32

#define LKF_MBDSERROR_KANR_VON 33
#define LKF_MBDSERROR_KANR_AN 34
#define LKF_MBDSERROR_AUFART2 35

#define LKF_MBDSERROR_MELDATMEL	36

#define LKF_MBDSERRORMELCOMPARE_STANDARD 0
#define LKF_MBDSERRORMELCOMPARE_MEL_DAY 1
#define LKF_MBDSERRORMELCOMPARE_MEL    2

#define LKF_MBDS_ACCEPTABLE     LKF_SEV_ACCEPTABLE /* V9.2 */

#ifdef SUPPORT_PRE2017
static const LKF_SATZART_ERROR_PROPERTIES LKFErrorNurFonds = {1, 0, 0, 0, 0, 0},
             LKFErrorNurFondsBis2012 = {1, 1, 2012, &LKFErrorNurFonds, 0, 0}, /* V18.0 */
             LKFErrorNurFondsbis2013 = {1, 1, 2013, &LKFErrorNurFonds, 0, 0}, /* V18.1 */
             LKFErrorNurFondsbis2014 = {1, 1, 2014, &LKFErrorNurFonds, 0, 0}; /* V19.1 */
#else
static const LKF_SATZART_ERROR_PROPERTIES LKFErrorNurFonds = {1, 0, 0, 0, 0, 0};
#endif
 /* V10.1 */
    
    //LKFErrorFondsNichtFonds = {1, 1, 0, 0, 0, 0}
                        /* V12.1 */
    //LKFErrorNurFondsAb2007 = {1, 0, 2006, &LKFErrorFondsNichtFonds, 0, 0},  /* V12.1 */
	//LKFErrorNurFondsBis2012 = {1, 1, 2012, &LKFErrorNurFonds, 0, 0}, /* V18.0 */
	//LKFErrorNurFondsbis2013 = {1, 1, 2013, &LKFErrorNurFonds, 0, 0}, /* V18.1 */
	//LKFErrorNurFondsbis2014 = {1, 1, 2014, &LKFErrorNurFonds, 0, 0}; /* V19.1 */

const LKF_SATZART_ERRORDEF
	LKFErrorKeineAufnahmezahl =		{  1, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,					  1, "Aufnahmezahl fehlt"},
	LKFErrorGEBDATfehlt =			{  2, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,					  2, "Geburtsdatum fehlt"},
	LKFErrorGEBDATfalsch =			{  3, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_GEBDAT,  4, "Geburtsdatum ung\xc3\xbc""ltig"},
	LKFErrorGEBDATnachAUFDAT =		{  4, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_GEBDAT,  3, "Geburtsdatum nach Aufnahmedatum"},
    LKFErrorGESCHLfehlt2021 =       {  5, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, 0, 57, "Geschlecht fehlt"},
    LKFErrorGESCHLfehlt =			{  5, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,					 57, "Geschlecht fehlt"},
	LKFErrorGESCHLfalsch =			{  6, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_GESCHL, 16, "Geschlecht ung\xc3\xbc""ltig"},
	LKFErrorSTAATWfehlt2005 =		{  7, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,					 58, "Hauptwohnsitz-Staat fehlt"},
	LKFErrorSTAATWfalsch2005 =		{  8, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_STAATW, 59, "Hauptwohnsitz-Staat ung\xc3\xbc""ltig"},
	LKFErrorPLZWfehlt2005 =			{  9, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,					 60, "Hauptwohnsitz-Postleitzahl fehlt"},
	LKFErrorPLZWfalsch2005 =		{ 10, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_PLZW,	 61, "Hauptwohnsitz-Postleitzahl ung\xc3\xbc""ltig"},
	LKFErrorAUFARTfehlt =			{ 11, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,					 62, "Aufnahmeart fehlt"},
	LKFErrorAUFARTfehlt2017 =		{ 11, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,					 62, "Aufnahmeart 1 fehlt"},
    LKFErrorAUFARTfalsch2017 =		{ 76, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFART, 17, "Aufnahme-/Zugangsart 1 ung\xc3\xbc""ltig"},
    LKFErrorAUFARTfalsch =			{ 76, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFART, 17, "Aufnahmeart ung\xc3\xbc""ltig"},
	LKFErrorAUFARTABTFCfalsch =		{ 77, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTFC,  38, "Aufnahmeart in Kombination mit Funktionscode ung\xc3\xbc""ltig"},
    LKFErrorAUFDATfehlt2017 =		{ 78, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,	  9, "Aufnahme-/Kontaktdatum fehlt"},
    LKFErrorAUFDATfehlt =			{ 78, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,	  9, "Aufnahmedatum fehlt"},
	LKFErrorAUFDATfalsch =			{ 12, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFDAT, 10, "Aufnahmedatum ung\xc3\xbc""ltig"},
    LKFErrorAUFDATfalsch2017 =		{ 12, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFDAT, 10, "Aufnahme-/Kontaktdatum ung\xc3\xbc""ltig"},
    LKFErrorAUFDATnachENTDAT =		{ 13, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFDAT, 11, "Aufnahmedatum nach Entlassungsdatum"},
	LKFErrorENTARTfehlt =			{ 14, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,					 63, "Entlassungsart fehlt"},
    LKFErrorENTARTfalsch2017 =			{ 15, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ENTART, 18, "Entlassungs-/Abgangsart ung\xc3\xbc""ltig"},
    LKFErrorENTARTfalsch =			{ 15, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ENTART, 18, "Entlassungsart ung\xc3\xbc""ltig"},
	LKFErrorENTARTVerbleib =		{ 16, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ENTART, 64, "Entlassungsart f\xc3\xbc""r Verbleibende nicht korrekt"},
	LKFErrorENTDATfehlt =			{ 17, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,					  5, "Entlassungsdatum fehlt"},
	LKFErrorENTDATfalsch =			{ 18, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ENTDAT,  6, "Entlassungsdatum ung\xc3\xbc""ltig"},
	LKFErrorENTDATVerbleib =		{ 19, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ENTDAT, 65, "Entlassungsdatum f\xc3\xbc""r Verbleibende nicht zu bef\xc3\xbc""llen"},
	LKFErrorENTDATBerichtsperiode = { 20, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ENTDAT,  8, "Entlassungsdatum au\xc3\x9f""erhalb der Berichtsperiode"},
    LKFErrorAUFDATungleichABTDAT2017 =  { 21, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFDAT, 43, "Aufnahme-/Kontaktdatum ungleich Zugangs-/Kontaktdatum der ersten Abteilung"},
    LKFErrorAUFDATungleichABTDAT =  { 21, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFDAT, 43, "Aufnahmedatum ungleich Zugangsdatum der aufnehmenden Abteilung"},
	LKFErrorVerlSpezUngueltig =     { 23, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,	 51, "Verlegungen f\xc3\xbc""r diesen speziellen Leistungsbereich ung\xc3\xbc""ltig"}, /* V9.2 - Abteilung anzeigen */
	LKFErrorAbtPosNrNichtVollst =   { 24, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTID,	 67, "Abteilungspositionsnummern nicht vollst\xc3\xa4""ndig"},
	LKFErrorAbtPosNrFalsch =		{ 25, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTID,	 68, "Abteilungspositionsnummer ung\xc3\xbc""ltig"},
	LKFErrorABTFCfehlt =			{ 26, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,	 14, "Funktionscode fehlt"},
	LKFErrorABTFCfalsch =			{ 27, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTFC,  19, "Funktionscode ung\xc3\xbc""ltig"},
	LKFErrorSpezOhneLeistung =		{ 28, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTFC,  56, "Aufnahme in einen speziellen Leistungsbereich ohne entsprechende medizinische Leistung"},
	LKFErrorABTDATfehlt2017 =		{ 29, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,	 20, "Zugangs-/Kontaktdatum fehlt"},

    LKFErrorABTDATfehlt =			{ 29, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,	 20, "Zugangsdatum fehlt"},
    LKFErrorABTDATfalsch2017 =		{ 30, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTDAT, 13, "Zugangs-/Kontaktdatum ung\xc3\xbc""ltig"},
    LKFErrorABTDATfalsch =			{ 30, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTDAT, 13, "Zugangsdatum ung\xc3\xbc""ltig"},
	LKFErrorABTDATaussAufenthalt =	{ 31, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTDAT, 70, "Zugangsdatum au\xc3\x9f""erhalb des Aufenthaltszeitraumes"},
#ifdef SUPPORT_PRE2017
    LKFErrorIntEinhOhneVollstBer =  { 22, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_ABT,     66, "Eingestufte Intensivbehandlungseinheit ohne vollst\xc3\xa4""ndigen Intensivbericht", &LKFErrorNurFondsbis2013 /* V18.1 */},
	LKFErrorABTZEITfehlt =			{ 32, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,	 71, "Zugangsuhrzeit fehlt", &LKFErrorNurFondsbis2013 /* V19.0 */},
	LKFErrorABTZEITfalsch =			{ 33, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTZEIT,72, "Zugangsuhrzeit ung\xc3\xbc""ltig", &LKFErrorNurFondsbis2013 /* V19.0 */},
#else
    LKFErrorIntEinhOhneVollstBer =  { 22, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_ABT,     66, "Eingestufte Intensivbehandlungseinheit ohne vollst\xc3\xa4""ndigen Intensivbericht"},
    LKFErrorABTZEITfehlt =            { 32, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,     71, "Zugangsuhrzeit fehlt"},
    LKFErrorABTZEITfalsch =            { 33, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTZEIT,72, "Zugangsuhrzeit ung\xc3\xbc""ltig"},
#endif
	LKFErrorAUFARTIntfehlt =		{ 34, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,	 73, "Aufnahmeart Intensiv fehlt", &LKFErrorNurFonds},
	LKFErrorAUFARTIntfalsch =		{ 35, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_IAUFART,   74, "Aufnahmeart Intensiv ung\xc3\xbc""ltig", &LKFErrorNurFonds},
	LKFErrorAUFTYPSAPS2fehlt =		{ 36, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,    75, "Aufnahmetyp SAPS II fehlt", &LKFErrorNurFonds},
	LKFErrorAUFTYPSAPS2falsch =		{ 37, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_SAPSII, 76, "Aufnahmetyp SAPS II ung\xc3\xbc""ltig", &LKFErrorNurFonds},
	LKFErrorCoexistErkrfalsch =		{ 39, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,    78, "Coexistierende Erkrankungen ung\xc3\xbc""ltig", &LKFErrorNurFonds},
	LKFErrorVerlegungenChrono =		{ 43, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   15, "Verlegungen nicht chronologisch"},
	
#ifdef SUPPORT_PRE2017
    LKFErrorABTENTDATfehlt =        { 40, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,    79, "Abgangsdatum fehlt", &LKFErrorNurFondsbis2013 /* V19.0 */},
    LKFErrorABTENTDATfalsch =        { 41, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTENTDAT,   80, "Abgangsdatum ung\xc3\xbc""ltig", &LKFErrorNurFondsbis2013 /* V19.0 */},
    LKFErrorABTENTDATaussAufenthalt = { 42, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTENTDAT, 81, "Abgangsdatum au\xc3\x9f""erhalb des Aufenthaltszeitraumes", &LKFErrorNurFondsbis2013 /* V19.0 */},
    LKFErrorVerlegungenUeberlapp =    { 44, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   83, "Verlegungen \xc3\xbc""berlappend", &LKFErrorNurFondsbis2013 /* V19.0 */},
    LKFErrorABTENTZEITfehlt =        { 45, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   84, "Abgangsuhrzeit fehlt", &LKFErrorNurFondsbis2013 /* V19.0 */},
    LKFErrorABTENTZEITfalsch =        { 46, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTENTZEIT, 85, "Abgangsuhrzeit ung\xc3\xbc""ltig", &LKFErrorNurFondsbis2013 /* V19.0 */},
    LKFErrorABTENTARTfehlt =        { 47, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   86, "Abgangsart fehlt", &LKFErrorNurFondsbis2013 /* V19.0 */},
    LKFErrorABTENTARTfalsch =        { 48, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   87, "Abgangsart ung\xc3\xbc""ltig", &LKFErrorNurFondsbis2013 /* V19.0 */},
    LKFErrorABTENTARTKombENTART =	{ 49, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   88, "Abgangsart in Kombination mit Entlassungsart ung\xc3\xbc""ltig", &LKFErrorNurFondsBis2012 /* V18.0 */},
    LKFErrorMELFC =                    { 70, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL,   50, "Medizinische Leistung ohne entsprechenden Funktionscode"},
    LKFErrorMELAlter =                { 61, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MEL,   32, "Medizinische Leistung in Kombination mit Alter ung\xc3\xbc""ltig"},
#else
LKFErrorABTENTDATfehlt =        { 40, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,    79, "Abgangsdatum fehlt"},
LKFErrorABTENTDATfalsch =        { 41, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTENTDAT,   80, "Abgangsdatum ung\xc3\xbc""ltig"},
LKFErrorABTENTDATaussAufenthalt = { 42, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTENTDAT, 81, "Abgangsdatum au\xc3\x9f""erhalb des Aufenthaltszeitraumes"},
LKFErrorVerlegungenUeberlapp =    { 44, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   83, "Verlegungen \xc3\xbc""berlappend"},
LKFErrorABTENTZEITfehlt =        { 45, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   84, "Abgangsuhrzeit fehlt"},
LKFErrorABTENTZEITfalsch =        { 46, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTENTZEIT, 85, "Abgangsuhrzeit ung\xc3\xbc""ltig"},
LKFErrorABTENTARTfehlt =        { 47, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   86, "Abgangsart fehlt"},
LKFErrorABTENTARTfalsch =        { 48, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   87, "Abgangsart ung\xc3\xbc""ltig"},
LKFErrorABTENTARTKombENTART =    { 49, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT,   88, "Abgangsart in Kombination mit Entlassungsart ung\xc3\xbc""ltig"},

#endif
	LKFErrorHDfehlt =				{ 50, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_NOINFO_M03, 23, "Hauptdiagnose fehlt"},
    LKFErrorHDmehrfach =            { 51, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_HD,    49, "Hauptdiagnose mehrfach gemeldet"},

    LKFErrorHDmehrfach2021amb =			{ 51, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_HD,	49, "Hauptdiagnose mehrfach gemeldet"},
	LKFErrorHDfalsch =				{ 52, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_HD,    21, "Diagnose als Hauptdiagnose ung\xc3\xbc""ltig"},
	LKFErrorDiagfalsch =			{ 53, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_DIAG,  22, "Diagnose ung\xc3\xbc""ltig"},
	LKFErrorDiag4stellig =			{ 54, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_DIAG,  45, "Diagnosencodierung vierstellig (.0 bis .9) verpflichtend"},
	LKFErrorDiagTypfehlt =			{ 55, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ZD,    89, "Diagnosentyp fehlt"},
	LKFErrorDiagTypfalsch =			{ 56, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ZD,    90, "Diagnosentyp ung\xc3\xbc""ltig"},
	LKFErrorDiagAlter =				{ 57, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_DIAG,  25, "Diagnose in Kombination mit Alter ung\xc3\xbc""ltig"},
	LKFErrorDiagGeschl =			{ 58, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_DIAG,  26, "Diagnose in Kombination mit Geschlecht ung\xc3\xbc""ltig"},
    LKFErrorMELfalsch2016 =			{ 59, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT,   36, "Medizinische Leistung ung\xc3\xbc""ltig"},

    LKFErrorMELohneAnzahl2016 =		{ 60, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT,	31, "Medizinische Leistung ohne Anzahl"},
    LKFErrorMELAlter2016 =			{ 61, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MELABT,   32, "Medizinische Leistung in Kombination mit Alter ung\xc3\xbc""ltig"},
    LKFErrorMELGeschl2016 =			{ 62, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MELABT,   33, "Medizinische Leistung in Kombination mit Geschlecht ung\xc3\xbc""ltig"},
    LKFErrorMELANZfalsch2016 =		{ 63, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 34, "Anzahl der medizinischen Leistung ung\xc3\xbc""ltig"},
	LKFErrorMELANZohneMEL =			{ 64, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELANZ,35, "Anzahl ohne medizinische Leistung"},
    LKFErrorMELANZmaxErr2016 =		{ 65, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MELABT,   37, "H\xc3\xb6""chstanzahl der Leistungserbringung w\xc3\xa4""hrend des Aufenthalts \xc3\xbc""berschritten"},
	LKFErrorMELANZmaxErr2009 =		{ 65, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MEL,   37, "H\xc3\xb6""chstanzahl der Leistungserbringung w\xc3\xa4""hrend des Aufenthalts \xc3\xbc""berschritten"},
	LKFErrorMELDATfehlt2005 =		{ 66, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL,   91, "Datum der medizinischen Leistung fehlt"},
	LKFErrorMELDATfalsch2005 =		{ 67, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELDAT,92, "Datum der medizinischen Leistung ung\xc3\xbc""ltig"},
    LKFErrorMEL0Tage2024 =            { 68, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MELABT,   40, "Medizinische Leistung f\xc3\xbc""r 0-Tagesaufenthalt bzw. am Entlassungstag ung\xc3\xbc""ltig"},
    LKFErrorMEL0Tage2016 =			{ 68, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MELABT,   40, "Medizinische Leistung f\xc3\xbc""r 0-Tagesaufenthalt ung\xc3\xbc""ltig"},
    LKFErrorMELENTART2016 =				{ 69, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MELABT,   41, "Medizinische Leistung mit ung\xc3\xbc""ltiger Entlassungsart"},
    LKFErrorMELFC2016 =					{ 70, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT,   50, "Medizinische Leistung ohne entsprechenden Funktionscode"},
    LKFErrorMEL4Tage2016 =				{ 71, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT,   54, "Behandlungsserie l\xc3\xa4""nger als 4 zusammenh\xc3\xa4""ngende Tage unterbrochen"},
    LKFErrorBehAbschliessen2016 =		{ 72, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT,					55, "Behandlungen am Ende des Kalendermonats abschlie\xc3\x9f""en"},
    LKFErrorMELDATaussAufenthalt2017 =  { 73, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MELDATMEL,93, "Medizinische Leistungserbringung au\xc3\x9f""erhalb Aufenthalt/Kontakt"},
	LKFErrorMELDATaussAufenthalt2005 =  { 73, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELDAT,93, "Medizinische Leistungserbringung au\xc3\x9f""erhalb des Aufenthalts"},
	LKFErrorKOSTfehlt2005 =				{ 74, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,					94, "Kostentr\xc3\xa4""ger fehlt"},
	LKFErrorKOSTfalsch2005 =			{ 75, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KOST,  95, "Kostentr\xc3\xa4""ger ung\xc3\xbc""ltig"},
	LKFErrorMBDSKAfalsch =		   { 79, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KANR,  48, "Krankenanstalt falsch"},
    LKFErrorKAAnFalsch2017 =  {80, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KANR_AN, 0, "Zugewiesene Krankenanstalt ung\xc3\xbc""ltig"},
    LKFErrorKAAnFalsch =  {80, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KANR_AN, 0, "Zugewiesene Krankenanstalt ungueltig"},
	LKFErrorKAAnFehlt =   {81, LKF_FAC_MBDS, LKF_SEV_ERROR, 0, 0, "Zugewiesene Krankenanstalt fehlt"},
    LKFErrorKAVonFalsch2017 =   {82, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KANR_VON, 0, "Zuweisende Krankenanstalt ung\xc3\xbc""ltig"},
    LKFErrorKAVonFalsch =   {82, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KANR_VON, 0, "Zuweisende Krankenanstalt ungueltig"},
	LKFErrorKAVonFehlt =    {83, LKF_FAC_MBDS, LKF_SEV_ERROR, 0, 0, "Zuweisende Krankenanstalt fehlt"},
    LKFErrorAufart2Falsch2017 =		   {84, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFART2, 0, "Aufnahme-/Zugangsart 2 ung\xc3\xbc""ltig"},
    LKFErrorAufart2Falsch =		   {84, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFART2, 0, "Aufnahmeart 2 ungueltig"},
	LKFErrorAufart2Fehlt =		   {85, LKF_FAC_MBDS, LKF_SEV_ERROR, 0, 0, "Aufnahmeart 2 fehlt"},
    LKFErrorMELfKAunplaus2016 =			{86, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MELABT,    0, "Medizinische Leistung f\xc3\xbc""r diese KA unplausibel"},
#ifdef SUPPORT_PRE2017
    LKFErrorOEMELKA2016 = {87, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort nicht \xc3\x96""SG-konform", &LKFErrorNurFondsbis2014 /* V19.1 */},
	LKFErrorOEMELKA = {87, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MEL, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort nicht \xc3\x96""SG-konform", &LKFErrorNurFondsbis2014 /* V19.1 */},
    LKFErrorOEMELKAAlter2016 = {88, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort laut \xc3\x96""SG nur f\xc3\xbc""r Erwachsene erbringbar",  &LKFErrorNurFondsbis2014 /* V19.1 */},
    LKFErrorOEMELKAAlter = {88, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MEL, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort laut \xc3\x96""SG nur f\xc3\xbc""r Erwachsene erbringbar",  &LKFErrorNurFondsbis2014 /* V19.1 */},
    LKFErrorMELfKAunplaus2007 =            {86, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MEL,    0, "Medizinische Leistung f\xc3\xbc""r diese KA unplausibel"},
    LKFErrorMEL4Tage =                { 71, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL,   54, "Behandlungsserie l\xc3\xa4""nger als 4 zusammenh\xc3\xa4""ngende Tage unterbrochen"},
    LKFErrorBehAbschliessen =        { 72, LKF_FAC_MBDS, LKF_SEV_ERROR, 0,                    55, "Behandlungen am Ende des Kalendermonats abschlie\xc3\x9f""en"},
#else
    LKFErrorOEMELKA2016 = {87, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort nicht \xc3\x96""SG-konform"},
    LKFErrorOEMELKAAlter2016 = {88, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort laut \xc3\x96""SG nur f\xc3\xbc""r Erwachsene erbringbar"},
#endif
	
	LKFErrorKAAnNurBeiT = {89, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KANR_AN, 0, "Zugewiesene Krankenanstalt nur f\xc3\xbc""r Entlassungsart 'T' g\xc3\xbc""ltig"},
	LKFErrorKAVonNurBeiT = {90, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KANR_VON, 0, "Zuweisende Krankenanstalt nur f\xc3\xbc""r Aufnahmeart 'T' g\xc3\xbc""ltig"},
	LKFErrorVerlAkutPflege = {91, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTFC, 0, "Verlegungen zwischen Akut- und Pflegeabteilungen nicht zul\xc3\xa4""ssig"},
	LKFErrorAufartPflege = {92, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTFC, 0, "Aufnahmen auf Abteilungen mit Funktionscode '19xxxx' nur in Kombination mit Aufnahmeart1 'P' oder 'L' zul\xc3\xa4""ssig"},
	LKFErrorAufartPflege2 = {93, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTFC, 0, "Aufnahmeart1 'P' oder 'L' nur in Kombination mit Abteilungen mit Funktionscode '19xxxx' zul\xc3\xa4""ssig"},
	LKFErrorAufartPflege2_2010 = {93, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTFC, 0, "Aufnahmeart1 'P' nur in Kombination mit Abteilungen mit Funktionscode '19xxxx' zul\xc3\xa4""ssig"}, /* V14.2 */
    LKFErrorKassenfreiFalsch2017 = {94, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Abrechnungsrelevanz ung\xc3\xbc""ltig"},
    LKFErrorKassenfreiFalsch2016 = {94, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Kassenfrei-Flag falsch"},
    LKFErrorMELANZmaxErrTag2016 =	{ 95, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MELABT,   0, "H\xc3\xb6""chstanzahl der Leistungserbringung am selben Tag \xc3\xbc""berschritten"}, /* V13.0 - ab Modell 2009 */
	LKFErrorUnterbrechung0Tage = {96, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTID, 0, "Unterbrechung k\xc3\xbc""rzer als 1 Nacht ung\xc3\xbc""ltig"}, /* V14.0 */
	LKFErrorUnterbrechung1TagH = {97, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTID, 0, "1-Tage-Unterbrechung bei Aufnahmeart 'H' ung\xc3\xbc""ltig"}, /* V14.0 */
	LKFErrorUnterbrechung6Tage = {98, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTID, 0, "Unterbrechung l\xc3\xa4""nger als 5 N\xc3\xa4""chte ung\xc3\xbc""ltig"}, /* V14.0 */
	LKFErrorUnterbrechungAufDat = {99, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE /* V15.0 */ | LKF_SEV_ERROR, LKF_MBDSERROR_ABTID, 0, "Unterbrechung unmittelbar nach 0-Tagesaufenthalt ung\xc3\xbc""ltig"}, /* V14.0 */
	LKFErrorUnterbrechungEntDat = {100, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE /* V15.0 */ | LKF_SEV_ERROR, LKF_MBDSERROR_ABTID, 0, "Unterbrechung unmittelbar vor 0-Tagesaufenthalt ung\xc3\xbc""ltig"}, /* V14.0 */
	LKFErrorUnterbrechungMEL = {101, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELDAT /* V14.1 */, 0, "MEL w\xc3\xa4""hrend Aufenthaltsunterbrechung ung\xc3\xbc""ltig"}, /* V14.0 */
	LKFErrorSTAATBfehlt2013 =	{102, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR,  LKF_MBDSERROR_STAATB,  0, "Staatsb\xc3\xbc""rgerschaft fehlt"}, /* V17.0 */
	LKFErrorSTAATBfalsch2013 =	{103, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR,  LKF_MBDSERROR_STAATB,  0, "Staatsb\xc3\xbc""rgerschaft ung\xc3\xbc""ltig"}, /* V17.0 */
    LKFErrorMELSeiteUngueltig2016 = {104, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Seitenlokalisation ung\xc3\xbc""ltig"},
    LKFErrorMELhatkeineSeite2016 = {105, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Seitenlokalisation unzul\xc3\xa4""ssig"},
    LKFErrorMELSeiteFehlt2016 = {106, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Seitenlokalisation fehlt"},
    LKFErrorMELSeiteFehlt2017 = {106, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Seitenlokalisation fehlt"},
	LKFErrorMELSeiteUngueltig = {104, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL, 0, "Seitenlokalisation ung\xc3\xbc""ltig"}, /* V17.0 */
	LKFErrorMELhatkeineSeite = {105, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL, 0, "Seitenlokalisation unzul\xc3\xa4""ssig"}, /* V17.0 */
	LKFErrorMELSeiteFehlt = {106, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL, 0, "Seitenlokalisation fehlt"}, /* V17.0 */
	LKFErrorAbtFC2013falsch = {107, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTFC, 0, "Funktionscode f\xc3\xbc""r das Berichtsjahr 2013 ung\xc3\xbc""ltig"}, /* V17.1 */
#ifdef SUPPORT_PRE2017
	LKFErrorIntUebwEinhOhneVollstBer =  {108, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_ABT,	0, "Eingestufte Intensiv\xc3\xbc""berwachungseinheit ohne vollst\xc3\xa4""ndigen Intensivbericht", &LKFErrorNurFondsbis2013 /* V18,1 */},
    LKFErrorMELANZmaxErrTag =    { 95, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MEL,   0, "H\xc3\xb6""chstanzahl der Leistungserbringung am selben Tag \xc3\xbc""berschritten"}, /* V13.0 - ab Modell 2009 */
    LKFErrorRevisionGrund =        {115, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL, 0, "Revisionseingriff an H\xc3\xbc""ftendoprothese ohne Revisionsgrund"}, /* V19.0 */
    LKFErrorRevisionGrund2016 =        {115, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Revisionseingriff an H\xc3\xbc""ftendoprothese ohne Revisionsgrund"},

#else
    LKFErrorIntUebwEinhOhneVollstBer =  {108, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_ABT,    0, "Eingestufte Intensiv\xc3\xbc""berwachungseinheit ohne vollst\xc3\xa4""ndigen Intensivbericht"},
#endif
    LKFErrorABTFCSpezfalschError2017 = {109, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTFC, 0, "Funktionscode f\xc3\xbc""r den speziellen Leistungsbereich ung\xc3\xbc""ltig"},
    LKFErrorABTFCSpezfalschError2013 = {109, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTFC, 0, "Funktionscode f\xc3\xbc""r den speziellen Leistungsbereich ab Berichtsjahr 2013 ung\xc3\xbc""ltig"},
    LKFError_AlterGruppeFehlt = {110, LKF_FAC_MBDS, LKF_SEV_ERROR, 0, 0, "Altersgruppe fehlt"} /* V19.0 */,
    LKFError_AlterGruppeFalsch = {111, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ALTER, 0, "Altersgruppe falsch"} /* V19.0 */,
    LKFError_AbtAlterGruppeFehlt = {112, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTID, 0, "Abteilungs-Altersgruppe fehlt"} /* V19.0 */,
    LKFError_AbtAlterGruppeFalsch = {113, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTID, 0, "Abteilungs-Altersgruppe falsch"} /* V19.0 */,
    LKFError_AbtNeugeborenesFalsch = {114, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABTID, 0, "Neugeborenen-Kennzeichen falsch"}, /* V19.0 */
    LKFErrorRevisionGrund2017 =		{115, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Revisionseingriff an H\xc3\xbc""ft-/Knieendoprothese ohne Revisionsgrund"},

    LKFErrorDiag9Code2015 =		{116, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_DIAG,   0, "Zur traumatologischen Diagnose wurde kein 9-Code (9xx.x) dokumentiert"}, /* V19.0 */

    LKFErrorGemeindezifferFalsch =      {117, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_GEMEINDEZIFFER, 0, "Hauptwohnsitz-Gemeindecode ung\xc3\xbc""ltig"},
    LKFErrorAUFZEITfalsch = {119, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFZEIT, 0, "Aufnahme-/Kontaktuhrzeit ung\xc3\xbc""ltig"}, /* V21.0 */

	LKFErrorAUFZEITfehlt =   {120, LKF_FAC_MBDS, LKF_SEV_ERROR, 0, 0, "Aufnahme-/Kontaktuhrzeit fehlt"}, /* V21.2 */

    LKFAmbErrorTransportartFalsch = {121, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_TRANSPORTART, 0, "Transportart ung\xc3\xbc""ltig"}, /* V21.0 */

    LKFErrorDIAGENTART =        {122, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_DIAG,   0, "Diagnose mit ung\xc3\xbc""ltiger Entlassungsart"}, /* V21.0 */
    LKFErrorAmbAufenthaltDauer = {123, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, 0, 0, "Ambulanter Aufenthalt mit Belagsdauer gr\xc3\xb6""\xc3\x9f""er 1 Tag unplausibel"},
    LKFAmbErrorPhysAnwFalsch =      {124, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT, 0, "Physische Anwesenheit ung\xc3\xbc""ltig"}, /* V21.0 */
    LKFAmbErrorDiagArtFalsch =      {125, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_DIAG, 0, "Diagnosenart ung\xc3\xbc""ltig"}, /* V21.0 */

    LKFAmbErrorMELUhrzeitFalsch =   {126, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Uhrzeit der medizinischen Leistung ung\xc3\xbc""ltig"}, /* V21.0 */
    LKFAmbErrorMELNichtBett = {128, LKF_FAC_MBDS, LKF_SEV_ERROR, 0, 0, "Ambulante Leistungserbringung ausschliesslich in nichtbettenf\xc3\xbc""hrenden Einrichtungen zul\xc3\xa4""ssig"},
    LKFErrorENTZEITfehlt = {129, LKF_FAC_MBDS, LKF_SEV_ERROR, 0, 0, "Entlassungsuhrzeit fehlt"},
    LKFErrorENTZEITfalsch = {130, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ENTZEIT, 0, "Entlassungsuhrzeit ung\xc3\xbc""ltig"},
    LKFErrorENTZEITvorAUFZEIT = {131, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ENTZEIT, 0, "Entlassungsuhrzeit vor Aufnahmeuhrzeit"},
    LKFErrorBEHANDLUNGSARTfehlt = {132, LKF_FAC_MBDS, LKF_SEV_ERROR, 0, 0, "Behandlungsart fehlt"},
    LKFErrorBEHANDLUNGSARTfalsch = {133, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_BEHANDLUNGSART, 0, "Behandlungsart ung\xc3\xbc""ltig"},

    // impl (fehlt ?)
    LKFErrorFachFCfalsch = {134, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_FACHFC, 0, "Fachlicher Funktionscode ung\xc3\xbc""ltig"},
    LKFErrorABRECHRELEVANZfalsch = {135, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABRECHRELEVANZ, 0, "Fondsrelevanz ung\xc3\xbc""ltig"},
    LKFErrorPflegFCfalsch = {136, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_PFLEGFC, 0, "Pflegerischer Funktionscode ung\xc3\xbc""ltig"},
    LKFErrorAUFDATBerichtsperiode = {137, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_AUFDAT,  0, "Kontaktdatum au\xc3\x9f""erhalb der Berichtsperiode"},
    LKFErrorAMBMELDIAGfehlt = {138, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MEL, 0, "Diagnose f\xc3\xbc""r ambulante Leistung fehlt"},
    LKFErrorMELFUCOfalsch = {139, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELFC, 0, "Funktionscode der medizinischen Leistung ung\xc3\xbc""ltig"}, /* V21.2 */
    LKFErrorMELKANRfalsch = {140, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELKANR, 0, "Krankenanstalt der medizinischen Leistung ung\xc3\xbc""ltig"}, /* V21.2 */
	LKFErrorAmbMELANZmaxErr = {141, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MELABT,   0, "H\xc3\xb6""chstanzahl der Leistungserbringung w\xc3\xa4""hrend des ambulanten Besuchs \xc3\xbc""berschritten"}, /* V21.2 */
    LKFErrorFondsRelevanzUnplaus = {142, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KOST, 0, "Fondsrelevanz unplausibel"}, /* V21.3 */
    LKFErrorAUFNRSTATmehrfach =	{143, LKF_FAC_MBDS,	LKF_SEV_ERROR, 0, 0, "Idente Aufnahmezahl mehrfach gemeldet"},
    LKFErrorAltersgruppeAUFARTG = {146, LKF_FAC_MBDS, LKF_SEV_ERROR, 0, 0, "Aufnahmeart 1 in Kombination mit Alter ung\xc3\xbc""ltig"},  /* V22.0 */
    LKFErrorMELohneBN =         {144, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT,    0, "Medizinische Leistung ohne Angabe des Kostentr\xc3\xa4""gers 'BN'"},
    LKFErrorBNohneMEL =  {145, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KOST,    0, "Kostentr\xc3\xa4""ger 'BN' ohne Angabe der medizinische Leistung 'ZZ050'"},
    LKFErrorMELStatUngueltig = {147, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL,    0, "Medizinische Leistung f\xc3\xbc""r station\xc3\xa4""ren Aufenthalt ung\xc3\xbc""ltig"}, /* V2019.0 */
    LKFErrorRankinMissing = {148, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_DIAG,    0, "Schlaganfall ohne entsprechende Zusatzdokumentation (MRS)"}, /* V2019.0 */
    LKFErrorKAAnUnplaus2019 =            {149, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KANR_AN, 0, "Zugewiesen an eigene KA ung\xc3\xbc""ltig"}, /* V2019.0 */
    LKFErrorKAVonUnplaus2019 =            {150, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_KANR_VON, 0, "Zugewiesen von eigener KA ung\xc3\xbc""ltig"}, /* V2019.0 */
/*
    LKFErrorAMBMELDIAGung = {151, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Diagnose f\xc3\xbc""r ambulante Leistung ung\xc3\xbc""ltig"}, V2019.0, weg V2019.1 */
    LKFErrorFucoLeist = {152, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Funktionscode f\xc3\xbc""r diese Leistung unzul\xc3\xa4""ssig"}, /* V2019.0 */
    LKFErrorStrokeOhneLeistung = {153, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_ABT, 0, "SchlaganfallpatientIn auf Stroke Unit ohne entsprechende Leistung"}, /* V2019.0 */
    LKFErrorBirthNoZD = {154, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Entbindung ohne entsprechende Zusatzdokumentation (Gestationsalter)"}, /* V2020.0 */
    LKFErrorBirthMultiZDAkzeptierbar = {155, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MELABT, 0, "Gestationsalter bei Entbindung mehrfach gemeldet"}, /* V2020.0 */
    LKFErrorFCLeistKostPlan2020 = {156, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELFC, 0, "Leistungserbringender Funktionscode nicht im Kostenstellenplan enthalten", &LKFErrorNurFonds}, /* V2020.0 */
    LKFErrorKombPhysJN = {157, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Kombination von Leistungen mit der Kennzeichnung Physische Anwesenheit 'J' bzw. 'N' w\xc3\xa4""hrend des gleichen ambulanten Besuchs unzul\xc3\xa4""ssig"},
    LKFErrorGemeindezifferFehlt2023 =   {158, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, 0, 0, "Hauptwohnsitz-Gemeindecode fehlt"}, /* V2023.0 */
    LKFErrorPLZGEMCOfalsch2023 = {159, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_PLZGEMCO, 0, "Kombination Hauptwohnsitz-Postleitzahl und Hauptwohnsitz-Gemeindecode ung\xc3\xbc""ltig"},
    LKFErrorUnterbrecherEntlassung = {160, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE /* V15.0 */ | LKF_SEV_ERROR, LKF_MBDSERROR_ABTID, 0, "Entlassung w\xc3\xa4""hrend Unterbrechung ung\xc3\xbc""ltig"}, /* V2023.1 */
    LKFErrorUeberliegerDaten = {161, LKF_FAC_MBDS, LKF_SEV_ERROR, 0, 0, "Ung\xc3\xbc""ltige Daten f\xc3\xbc""r \xc3\x9c""berlieger gemeldet" }; /* V2025.0 */
	
    const LKF_SATZART_ERROR_PROPERTIES
        LKFErrorPropertiesBirthMultiZDProp = {1, 1, 0, 0, 2024, &LKFErrorBirthMultiZDAkzeptierbar};

    const LKF_SATZART_ERRORDEF
        LKFErrorBirthMultiZD = {155, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELABT, 0, "Gestationsalter bei Entbindung mehrfach gemeldet", &LKFErrorPropertiesBirthMultiZDProp };

    const LKF_SATZART_ERRORDEF
	LKFErrorAlter =					{101, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_ALTER,   1, "PatientIn \xc3\xa4""lter 110 Jahre"},
	LKFErrorSTAATBfehlt =			{102, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR,  0,				      5, "Staatsb\xc3\xbc""rgerschaft fehlt"},
	LKFErrorSTAATBfalsch =			{103, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR,  LKF_MBDSERROR_STAATB,  4, "Staatsb\xc3\xbc""rgerschaft ung\xc3\xbc""ltig"},
	LKFErrorAUFARTBelagsdauer =		{104, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR,  LKF_MBDSERROR_AUFART, 18, "Aufnahmeart in Kombination mit Belagsdauer unplausibel"},
	LKFErrorABTFC19 =				{105, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR,  LKF_MBDSERROR_ABTFC,  39, "Aufenthalt auf Pflegeabteilung bei Punkteberechnung nicht ber\xc3\xbc""cksichtigt"},
	LKFErrorABTFCSpezfalsch =		{106, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR,  LKF_MBDSERROR_ABTFC,  38, "Funktionscode f\xc3\xbc""r speziellen Leistungsbereich ung\xc3\xbc""ltig"},
	LKFErrorZDmehrfach =			{107, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR,  LKF_MBDSERROR_ZD,     40, "Zusatzdiagnose mehrfach gemeldet"},
    LKFErrorDiagmehrfach =			{107, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR,  LKF_MBDSERROR_DIAG,     40, "Diagnose mehrfach gemeldet"},
LKFErrorDiagfalschWarn2017 =	{108, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_DIAG,   10, "Diagnose unwahrscheinlich"},
    LKFErrorDiagfalschWarn =		{108, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_DIAG,   10, "Diagnose unplausibel"},
	LKFErrorDiagUCode =				{109, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_DIAG,   11, "Diagnose ohne U-Code"},
	LKFErrorDiag9Code =				{109, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_DIAG,   11, "Zur traumatologischen Diagnose wurde kein 9-Code (9xx.x) dokumentiert"}, /* V17.0 */
	LKFErrorDiag0Tage =				{110, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_DIAG,   21, "Diagnose f\xc3\xbc""r 0-Tagesaufenthalt unplausibel"},
	LKFErrorHDstatfalsch =			{111, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_HD,     22, "Hauptdiagnose f\xc3\xbc""r station\xc3\xa4""ren Aufenthalt unplausibel"},
	LKFErrorSternKreuzHD =			{112, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_HD,     25, "Stern(*)-Hauptdiagnose ohne Kreuz(+)-Diagnose"},
	LKFErrorSternKreuzZD =			{113, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_ZD,	 24, "Stern(*)-Zusatzdiagnose ohne Kreuz(+)-Diagnose"},
    LKFErrorMELAnzWarn2016 =		{114, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,	 13, "Warnstufe der Leistungserbringung w\xc3\xa4""hrend des Aufenthalts \xc3\xbc""berschritten"},
	LKFErrorMELAnzWarn2009 =		{114, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,	 13, "Warnstufe der Leistungserbringung w\xc3\xa4""hrend des Aufenthalts \xc3\xbc""berschritten"},
    LKFErrorMELohneDiag2016 =		{115, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,    14, "Medizinische Leistung ohne plausible Diagnose"},
	LKFErrorMELohneDiag =			{115, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,    14, "Medizinische Leistung ohne plausible Diagnose"},
 	LKFErrorMELfKAunplaus =			{116, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,    15, "Medizinische Leistung f\xc3\xbc""r diese KA unplausibel"},
    LKFErrorMELAmbulant2016 =		{117, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,    20, "Medizinische Leistung aus dem ambulanten Bereich"},
    LKFErrorMELAmbulant =			{117, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,    20, "Medizinische Leistung aus dem ambulanten Bereich"},
    LKFErrorMEL0TageWarn2024 =        {118, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,    23, "Medizinische Leistung f\xc3\xbc""r 0-Tagesaufenthalt bzw. am Entlassungstag unplausibel"},
    LKFErrorMEL0TageWarn2016 =		{118, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,    23, "Medizinische Leistung f\xc3\xbc""r 0-Tagesaufenthalt unplausibel"},
	LKFErrorMEL0TageWarn =			{118, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,    23, "Medizinische Leistung f\xc3\xbc""r 0-Tagesaufenthalt unplausibel"},
    LKFErrorMELohneSpez2023 =        {119, LKF_FAC_MBDS, LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,    17, "Medizinische Leistung ohne Angabe einer speziell eingestuften Abteilung", &LKFErrorNurFonds}, /* V2023.0 */
    LKFErrorMELohneAUFART2016 =		{120, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR,  LKF_MBDSERROR_MELABT,    31, "Medizinische Leistung ohne entsprechende Aufnahmeart"},
	LKFErrorMELTag2009 =			{121, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_NOINFO_M04,					 37, "Kombination medizinischer Leistungen am gleichen Tag (auf einer Seite) unplausibel"},
	LKFErrorMELAufenthalt =			{122, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_NOINFO_M04,					 26, "Kombination medizinischer Leistungen im gleichen Aufenthalt unplausibel"},
	LKFErrorNPfehlt =				{124, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_ABTID,  32, "Kriterium f\xc3\xbc""r neonatologische/paediatrische Intensiveinheit nicht erf\xc3\xbc""llt"},
	LKFErrorNPAlter =				{125, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_ABTID,  33, "Neonatologisches Kriterium f\xc3\xbc""r neonatologische/paediatrische Intensiveinheit erf\xc3\xbc""llt, aber Altersgrenze \xc3\xbc""berschritten"},
	LKFErrorNPUeberwachung =		{126, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_ABTID,  34, "Nur \xc3\x9c""berwachungskriterium auf neonatologischer/paediatrischer Intensivbehandlungseinheit erf\xc3\xbc""llt"},
	LKFErrorNP7299 =				{127, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_ABTID,  35, "Unspezifische medizinische Leistung 7299 codiert"},
    LKFErrorMELignoriert2016 =		{128, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,    36, "Medizinische Leistung wird bei der Punkteberechnung nicht ber\xc3\xbc""cksichtigt"},
    LKFErrorMELENTDAT2016 =			{129, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,    41, "Leistungserbringung am Entlassungstag unplausibel"},
	LKFErrorMELDATfehlt =			{134, LKF_FAC_MBDS, LKF_SEV_WARNING_KORR, LKF_MBDSERROR_MEL,     28, "Datum der medizinischen Leistung fehlt"},
	LKFErrorMELDATfalsch =			{135, LKF_FAC_MBDS, LKF_SEV_WARNING_KORR, LKF_MBDSERROR_MELDAT,  27, "Datum der medizinischen Leistung ung\xc3\xbc""ltig"},
	LKFErrorMELEntfernt =			{139, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,    16, "Medizinische Leistung wird ignoriert (nicht im aktuellen Katalog enthalten)"},
	LKFErrorNPPlausMELOhneDatum =   {140, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,     0, "Leistung bei Neonatologie/P\xc3\xa4""diatrie-Aufenthalt ohne Datum"}, /* V10.0 */
	LKFErrorEntVorAufZeit =			{141, LKF_FAC_MBDS, LKF_SEV_WARNING_KORR, LKF_MBDSERROR_AUFENTZEIT, 0, "Zugangszeitpunkt nach Abgangszeitpunkt"}, /* V10.1 */
	LKFErrorKAAnUnplaus =			{142, LKF_FAC_MBDS, LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_KANR_AN, 0, "Zugewiesen an eigene KA unplausibel"}, /* V11.0 */
	LKFErrorKAVonUnplaus =			{143, LKF_FAC_MBDS, LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_KANR_VON, 0, "Zugewiesen von eigener KA unplausibel"}, /* V11.0 */
	LKFErrorRemobUeber28ab2009 =	{144, LKF_FAC_MBDS, LKF_SEV_WARNING_PRUEF, 0, 0, "Gesamtaufenthalt auf Remobilisation/Nachsorge > 28 Tage, Punkteberechnung mit 28 Belagstagen begrenzt"}, /* V13.1 - nicht mehr akzeptierbar */
    LKFErrorVerlegungenLoechrig2023 =    {145, LKF_FAC_MBDS, LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_ABT,   0, "Verlegungen nicht unmittelbar aufeinanderfolgend", &LKFErrorNurFonds}, /* V2023.0 */
    LKFErrorMELAnzWarnTag2016 =		{146, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,	 0, "Warnstufe der Leistungserbringung am selben Tag \xc3\xbc""berschritten"},

#ifdef SUPPORT_PRE2017
    LKFWarningOEMELKA2016 =			{ 87, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort nicht \xc3\x96""SG-konform", &LKFErrorNurFondsbis2014 /* V19.1 */}, /* V14.2 */
    LKFWarningOEMELKAAlter2016 =	{ 88, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort laut \xc3\x96""SG nur f\xc3\xbc""r Erwachsene erbringbar", &LKFErrorNurFondsbis2014 /* V19.1 */}, /* V14.2 */
	LKFWarningOEMELKA =				{ 87, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_MEL, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort nicht \xc3\x96""SG-konform", &LKFErrorNurFondsbis2014 /* V19.1 */}, /* V14.2 */
	LKFWarningOEMELKAAlter =		{ 88, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_MEL, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort laut \xc3\x96""SG nur f\xc3\xbc""r Erwachsene erbringbar", &LKFErrorNurFondsbis2014 /* V19.1 */}, /* V14.2 */
    LKFErrorMELfalsch =                { 59, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL,   36, "Medizinische Leistung ung\xc3\xbc""ltig"},
    LKFErrorMELohneAnzahl =            { 60, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL,    31, "Medizinische Leistung ohne Anzahl"},
    KFErrorMELAlter =                { 61, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MEL,   32, "Medizinische Leistung in Kombination mit Alter ung\xc3\xbc""ltig"},
    LKFErrorMELANZfalsch =            { 63, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MELANZ,34, "Anzahl der medizinischen Leistung ung\xc3\xbc""ltig"},
    LKFErrorMELGeschl =                { 62, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MEL,   33, "Medizinische Leistung in Kombination mit Geschlecht ung\xc3\xbc""ltig"},
    LKFErrorMEL0Tage =                { 68, LKF_FAC_MBDS, LKF_SEV_ERROR | LKF_MBDS_ACCEPTABLE, LKF_MBDSERROR_MEL,   40, "Medizinische Leistung f\xc3\xbc""r 0-Tagesaufenthalt ung\xc3\xbc""ltig"},
    LKFErrorKassenfreiFalsch = {94, LKF_FAC_MBDS, LKF_SEV_ERROR, LKF_MBDSERROR_MEL, 0, "Kassenfrei-Flag falsch"},
    LKFErrorMELohneAUFART =            {120, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR,  LKF_MBDSERROR_MEL,    31, "Medizinische Leistung ohne entsprechende Aufnahmeart"},
    LKFErrorMELignoriert =            {128, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,    36, "Medizinische Leistung wird bei der Punkteberechnung nicht ber\xc3\xbc""cksichtigt"},
    LKFErrorMELAnzWarnTag =            {146, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,     0, "Warnstufe der Leistungserbringung am selben Tag \xc3\xbc""berschritten"},
    LKFErrorMELENTDAT =                {129, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,    41, "Leistungserbringung am Entlassungstag unplausibel"},
    LKFErrorMELohneSpez =            {119, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MEL,    17, "Medizinische Leistung ohne Angabe einer speziell eingestuften Abteilung", &LKFErrorNurFonds},

#else
    LKFWarningOEMELKA2016 =            { 87, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort nicht \xc3\x96""SG-konform"}, /* V14.2 */
    LKFWarningOEMELKAAlter2016 =    { 88, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung f\xc3\xbc""r diesen Standort laut \xc3\x96""SG nur f\xc3\xbc""r Erwachsene erbringbar"}, /* V14.2 */
#endif
	LKFWarningChemoTag =			{147, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_NOINFO_M04, 0, "Kombination von Chemotherapien am gleichen Tag unplausibel"},
    LKFWarningChemoTag2021 =            {147, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_NOINFO_M04, 0, "Kombination von Chemotherapien am gleichen/Folgetag unplausibel"},
	LKFWarningI64 =					{148, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_HD, 0, "Unzureichend abgekl\xc3\xa4""rte Hauptdiagnose"},
	LKFWarningDiagDiag =			{149, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, 0, 0, "Diagnosenkombination unplausibel"}, /* V18.0 */
    LKFWarningDiagDiag2020 =            {149, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_DIAG, 0, "Diagnosenkombination unplausibel"}, /* V18.0 */
    LKFWarningDiagMel =				{150, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_DIAG, 0, "Diagnose ohne entsprechende Leistung unplausibel"}, /* V18.0 */
    LKFWarningUICCFehlt =			{152, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_DIAG, 0, "Tumorstadium nach UICC nicht erfasst"}, /* V19.0 */
    LKFWarningStatErworben =        {153, LKF_FAC_MBDS, LKF_SEV_WARNING, LKF_MBDSERROR_DIAG, 0, "Im station\xc3\xa4""ren Aufenthalt erworben ung\xc3\xbc""ltig"}, /* V21.0 */
    LKFWarningStatErworben2018 =		{153, LKF_FAC_MBDS, LKF_SEV_WARNING, LKF_MBDSERROR_DIAG, 0, "Im station\xc3\xa4""ren Aufenthalt erworben ist bei Pneumonie zu bef\xc3\xbc""llen"}, /* V22.1 */
    LKFWarningTKLAmbulant =			{154, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING, LKF_MBDSERROR_MELABT, 0, "Tagesklinisch abrechenbare Leistung ambulant abgerechnet"}, /* V21.0 */
    LKFErrorGemeindezifferFehlt =   {155, LKF_FAC_MBDS, LKF_SEV_WARNING | LKF_MBDS_ACCEPTABLE, 0, 0, "Hauptwohnsitz-Gemeindecode fehlt"}, /* V21.0 */
    LKFErrorMELFUCOfehlt = {156, LKF_FAC_MBDS, LKF_SEV_WARNING, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung ohne Funktionscode"}, /* V21.2 */
    LKFErrorPLZGEMCOfalsch = {157, LKF_FAC_MBDS, LKF_SEV_WARNING, LKF_MBDSERROR_PLZGEMCO, 0, "Kombination Hauptwohnsitz-Postleitzahl und Hauptwohnsitz-Gemeindecode ung\xc3\xbc""ltig"}, /* V21.2 */
    LKFErrorPLZGEMCOIntl = {158, LKF_FAC_MBDS, LKF_SEV_WARNING, LKF_MBDSERROR_PLZGEMCO, 0, "Postleitzahl und Gemeindecode sind bei ausl\xc3\xa4""ndischem Wohnsitz nicht zu bef\xc3\xbc""llen"}, /* V21.2 */
    LKFErrorAmbMELAnzWarn =		{159, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,	 0, "Warnstufe der Leistungserbringung w\xc3\xa4""hrend des ambulanten Besuchs \xc3\xbc""berschritten"}, /* V21.2 */
    LKFErrorStatErworbenHD = {160, LKF_FAC_MBDS, LKF_SEV_WARNING, LKF_MBDSERROR_HD, 0, "W\xc3\xa4""hrend des Aufenthalts erworbene Erkrankung als Hauptdiagnose unzul\xc3\xa4""ssig"} /* V22.1 */,
    LKFErrorMELBettHKUnplaus = {161, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT, 0, "Bettenf\xc3\xbc""hrender Funktionscode bzw. Neben- oder Hilfskostenstelle f\xc3\xbc""r diese Leistung unplausibel", &LKFErrorNurFonds}, /* V2019.1; Textaenderung V2019.2 */
    LKFErrorKALeistFCLeist = {162, LKF_FAC_MBDS, LKF_SEV_WARNING_KORR, LKF_MBDSERROR_MELABT, 0, "Gleichzeitige Bef\xc3\xbc""llung leistungserbringender Funktionscode und leistungserbringende Krankenanstalt unzul\xc3\xa4""ssig"}, /* V2019.1 */
    LKFErrorFCLeistKostPlan = {163, LKF_FAC_MBDS, LKF_SEV_WARNING_KORR, LKF_MBDSERROR_MELFC, 0, "Leistungserbringender Funktionscode nicht im Kostenstellenplan enthalten", &LKFErrorNurFonds}, /* V2019.1 */
    LKFErrorChemoKomb = {164, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_NOINFO_M04, 0, "Kombination von Chemotherapie Kinder/Erwachsene w\xc3\xa4""hrend des gleichen Aufenthalts/ambulanten Besuchs unplausibel"}, /* V2020.0 */
    LKFErrorSecInsuffizient2023 = {165, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_DIAG, 0, "Zur sekund\xc3\xa4""ren Rechtsherzinsuffizienz (I50.01) wurde kein Code f\xc3\xbc""r die Linksherzinsuffizienz (I50.11 bis I50.19) dokumentiert"},
    LKFErrorAmbHDfehlt2025 = { 166, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, 0, 0, "Ambulanter Besuch ohne Hauptdiagnose"},
    LKFErrorAmbHDfehlt2026 = { 166, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, 0, 0, "Ambulanter Besuch ohne Diagnosen (weder Haupt- noch Zusatzdiagnose)"},
    LKFErrorAmbHDmultiple2025 = { 167, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, 0, 0, "Hauptdiagnose mehrfach gemeldet"},
    LKFErrorStatDiag5stellig = { 168, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, LKF_MBDSERROR_DIAG, 0, "Diagnosencodierung im station\xc3\xa4""ren Bereich f\xc3\xbc""nfstellig verpflichtend"},
    LKFErrorZN410OpMel = { 169, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, LKF_MBDSERROR_MELABT, 0, "OP-Roboter-Leistung ohne entsprechende operative Leistung unplausibel"},
    LKFErrorAN011VW = { 170, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung in Kombination mit Belagsdauer unplausibel (Minimum 2 Belagstage)"},
    LKFErrorEB040 = { 171, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, LKF_MBDSERROR_MELABT, 0, "Medizinische Leistung ohne entsprechende Zusatzdokumentation (ICD-10 211.x/215.x)"},
    /* V2026.0 */
    LKFErrorZN173 = { 172, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, LKF_MBDSERROR_MELABT, 0, "Keine Linearbeschleuniger-Behandlung gemeldet"},
    LKFErrorDD020 = { 173, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, LKF_MBDSERROR_MELABT, 0, "Keine Katheterangiographie gemeldet"},
    LKFErrorHM070 = { 174, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, LKF_MBDSERROR_MELABT, 0, "Keine ERCP gemeldet"},
    LKFErrorAmbHDfehltZDvorhanden2026 = { 175, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_KORR, 0, 0, "Ambulanter Besuch mit Zusatzdiagnose(n) aber ohne Hauptdiagnose"};

const LKF_SATZART_ERRORDEF
	LKFHinweisMELMEL =              {  1, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_INFO, LKF_MBDSERROR_NOINFO_M04, 0, "Kombination medizinischer Leistungen am gleichen Tag definitionsgem\xc3\xa4""\xc3\x9f"" ohne Leistungszuschlag"},
LKFErrorMELignoriert2018 =        {2, LKF_FAC_MBDS, LKF_SEV_INFO, LKF_MBDSERROR_MELABT,    0, "Medizinische Leistung wird bei der Punkteberechnung nicht ber\xc3\xbc""cksichtigt"}, /* V2019.0 */
LKFWarningTKLAmbulant2018 =            {3, LKF_FAC_MBDS, LKF_SEV_INFO, LKF_MBDSERROR_MELABT, 0, "Tagesklinisch abrechenbare Leistung ambulant abgerechnet"}, /* V2019.0 */
LKFWarningStatMELAmbulant = {4, LKF_FAC_MBDS, LKF_SEV_INFO, LKF_MBDSERROR_MELABT, 0, "Nach dem station\xc3\xa4""ren LKF-Modell abrechenbare Leistung ambulant abgerechnet"}, /* V2020.0 */
LKFInfoOnkoIgnore = {5, LKF_FAC_MBDS, LKF_SEV_INFO, LKF_MBDSERROR_MELABT, 0, "Onkologische medizinische Leistung ohne onkologische Diagnose wird bei der Punkteberechnung nicht ber\xc3\xbc""cksichtigt"}; /* V2021.0 */

/* with alternates */

/* V2023.0 - Changes */

const LKF_SATZART_ERROR_PROPERTIES LKFErrorPropertiesVerlegungenLoechrig = {1, 0, 0, 0, 2023, &LKFErrorVerlegungenLoechrig2023},
                                LKFErrorPropertiesMELohneSpez2016 = {1, 0, 0, 0, 2023, &LKFErrorMELohneSpez2023},
                                LKFErrorPropertiesSecInsuffizient = {1, 1, 0, 0, 2023, &LKFErrorSecInsuffizient2023};

const LKF_SATZART_ERRORDEF LKFErrorVerlegungenLoechrig =    {145, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_ABT,   0, "Verlegungen nicht unmittelbar aufeinanderfolgend", &LKFErrorPropertiesVerlegungenLoechrig},
LKFErrorMELohneSpez2016 =        {119, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_MELABT,    17, "Medizinische Leistung ohne Angabe einer speziell eingestuften Abteilung", &LKFErrorPropertiesMELohneSpez2016},
LKFErrorSecInsuffizient = {165, LKF_FAC_MBDS, LKF_MBDS_ACCEPTABLE | LKF_SEV_WARNING_PRUEF, LKF_MBDSERROR_DIAG, 0, "Zur sekund\xc3\xa4""ren Rechtsherzinsuffizienz wurde kein Code f\xc3\xbc""r die Linksherzinsuffizienz dokumentiert", &LKFErrorPropertiesSecInsuffizient};

#ifdef SUPPORT_PRE2017
const LKF_SATZART_ERRORDEF *ppAllErrors2009[] = { /* V13.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
&LKFErrorGESCHLfalsch, /* &LKFErrorSTAATWfehlt, &LKFErrorSTAATWfalsch, &LKFErrorPLZWfehlt, &LKFErrorPLZWfalsch, */
&LKFErrorAUFARTfehlt, &LKFErrorAUFARTfalsch, &LKFErrorAUFDATfehlt, &LKFErrorAUFARTABTFCfalsch, &LKFErrorAUFDATfalsch,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT, &LKFErrorIntEinhOhneVollstBer, 
&LKFErrorVerlSpezUngueltig, &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch, 
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt, &LKFErrorABTDATfalsch, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt, 
&LKFErrorABTZEITfalsch, &LKFErrorAUFARTIntfehlt, &LKFErrorAUFARTIntfalsch, &LKFErrorAUFTYPSAPS2fehlt, &LKFErrorAUFTYPSAPS2falsch,
/* &LKFErrorCoexistErkrfehlt, V9.3 entfernt */ &LKFErrorCoexistErkrfalsch, &LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt, 
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt, 
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch, 
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter, 
&LKFErrorDiagGeschl, &LKFErrorMELfalsch, &LKFErrorMELohneAnzahl, &LKFErrorMELAlter, &LKFErrorMELGeschl, 
&LKFErrorMELANZfalsch, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2009, /* &LKFErrorMELDATfehlt, &LKFErrorMELDATfalsch, */ 
&LKFErrorMEL0Tage, &LKFErrorMELFC, &LKFErrorMEL4Tage, &LKFErrorBehAbschliessen,
/* &LKFErrorMELDATaussAufenthalt, &LKFErrorKOSTfehlt, &LKFErrorKOSTfalsch, */
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt, &LKFErrorSTAATBfalsch, &LKFErrorAUFARTBelagsdauer ,
&LKFErrorABTFCSpezfalsch, &LKFErrorZDmehrfach, &LKFErrorDiagfalschWarn, &LKFErrorDiagUCode, &LKFErrorDiag0Tage, 
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2009, &LKFErrorMELohneDiag, 
&LKFErrorMELfKAunplaus2007, &LKFErrorMELAmbulant, &LKFErrorMEL0TageWarn, &LKFErrorMELohneSpez, &LKFErrorMELohneAUFART, 
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, /* &LKFErrorNP7299, V13.0 */ &LKFErrorMELignoriert, &LKFErrorMELENTDAT, 
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2005, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
&LKFErrorMELEntfernt, &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit, 
&LKFErrorKAAnFalsch, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch, &LKFErrorAufart2Fehlt, 
&LKFErrorKAAnUnplaus, &LKFErrorKAVonUnplaus, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig, 
&LKFErrorOEMELKA /* V11.1 */, &LKFErrorOEMELKAAlter /* V11.1 */, &LKFErrorKAAnNurBeiT /* V12.0 */, &LKFErrorKAVonNurBeiT /* V12.0 */, &LKFErrorVerlAkutPflege /* V12.0 */,
&LKFErrorAufartPflege /* V12.0 */, &LKFErrorAufartPflege2 /* V12.0 */, &LKFErrorKassenfreiFalsch /* V13.0 */, &LKFErrorMELAnzWarnTag, &LKFErrorMELANZmaxErrTag, &LKFHinweisMELMEL, 
&LKFWarningOEMELKA /* V14.2 */, &LKFWarningOEMELKAAlter /* V14.2 */, 0};


const LKF_SATZART_ERRORDEF *ppAllErrors2010[] = { /* V14.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt, &LKFErrorAUFARTfalsch, &LKFErrorAUFDATfehlt, &LKFErrorAUFARTABTFCfalsch, &LKFErrorAUFDATfalsch,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT, &LKFErrorIntEinhOhneVollstBer, 
&LKFErrorVerlSpezUngueltig, &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch, 
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt, &LKFErrorABTDATfalsch, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt, 
&LKFErrorABTZEITfalsch, &LKFErrorAUFARTIntfehlt, &LKFErrorAUFARTIntfalsch, &LKFErrorAUFTYPSAPS2fehlt, &LKFErrorAUFTYPSAPS2falsch, 
&LKFErrorCoexistErkrfalsch, &LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt, 
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt, 
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch, 
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter, 
&LKFErrorDiagGeschl, &LKFErrorMELfalsch, &LKFErrorMELohneAnzahl, &LKFErrorMELAlter, &LKFErrorMELGeschl, 
&LKFErrorMELANZfalsch, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2009,
&LKFErrorMEL0Tage, &LKFErrorMELFC, &LKFErrorMEL4Tage, &LKFErrorBehAbschliessen,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt, &LKFErrorSTAATBfalsch, &LKFErrorAUFARTBelagsdauer,
&LKFErrorABTFCSpezfalsch, &LKFErrorZDmehrfach, &LKFErrorDiagfalschWarn, &LKFErrorDiagUCode, &LKFErrorDiag0Tage, 
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2009, &LKFErrorMELohneDiag, 
&LKFErrorMELfKAunplaus2007, &LKFErrorMELAmbulant, &LKFErrorMEL0TageWarn, &LKFErrorMELohneSpez, &LKFErrorMELohneAUFART, 
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert, &LKFErrorMELENTDAT, 
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2005, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
&LKFErrorMELEntfernt, &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit, 
&LKFErrorKAAnFalsch, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch, &LKFErrorAufart2Fehlt, 
&LKFErrorKAAnUnplaus, &LKFErrorKAVonUnplaus, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig, 
&LKFErrorOEMELKA , &LKFErrorOEMELKAAlter , &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch, &LKFErrorMELAnzWarnTag, &LKFErrorMELANZmaxErrTag, &LKFHinweisMELMEL, 
/* V14.0 */
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung1TagH, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA /* V14.2 */, &LKFWarningOEMELKAAlter /* V14.2 */, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2011[] = { /* V15.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt, &LKFErrorAUFARTfalsch, &LKFErrorAUFDATfehlt, &LKFErrorAUFARTABTFCfalsch, &LKFErrorAUFDATfalsch,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT, &LKFErrorIntEinhOhneVollstBer, 
&LKFErrorVerlSpezUngueltig, &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch, 
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt, &LKFErrorABTDATfalsch, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt, 
&LKFErrorABTZEITfalsch, &LKFErrorAUFARTIntfehlt, &LKFErrorAUFARTIntfalsch, &LKFErrorAUFTYPSAPS2fehlt, &LKFErrorAUFTYPSAPS2falsch, 
&LKFErrorCoexistErkrfalsch, &LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt, 
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt, 
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch, 
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter, 
&LKFErrorDiagGeschl, &LKFErrorMELfalsch, &LKFErrorMELohneAnzahl, &LKFErrorMELAlter, &LKFErrorMELGeschl, 
&LKFErrorMELANZfalsch, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2009,
&LKFErrorMEL0Tage, &LKFErrorMELFC, &LKFErrorMEL4Tage, &LKFErrorBehAbschliessen,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt, &LKFErrorSTAATBfalsch, &LKFErrorAUFARTBelagsdauer,
&LKFErrorABTFCSpezfalsch, &LKFErrorZDmehrfach, &LKFErrorDiagfalschWarn, &LKFErrorDiagUCode, &LKFErrorDiag0Tage, 
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2009, &LKFErrorMELohneDiag, 
&LKFErrorMELfKAunplaus2007, &LKFErrorMELAmbulant, &LKFErrorMEL0TageWarn, &LKFErrorMELohneSpez, &LKFErrorMELohneAUFART, 
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert, &LKFErrorMELENTDAT, 
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2005, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
&LKFErrorMELEntfernt, &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit, 
&LKFErrorKAAnFalsch, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch, &LKFErrorAufart2Fehlt, 
&LKFErrorKAAnUnplaus, &LKFErrorKAVonUnplaus, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig, 
&LKFErrorOEMELKA , &LKFErrorOEMELKAAlter , &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch, &LKFErrorMELAnzWarnTag, &LKFErrorMELANZmaxErrTag, &LKFHinweisMELMEL, 
/* V14.0 */
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung1TagH, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA /* V14.2 */, &LKFWarningOEMELKAAlter /* V14.2 */, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2012[] = { /* V15.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt, &LKFErrorAUFARTfalsch, &LKFErrorAUFDATfehlt, &LKFErrorAUFARTABTFCfalsch, &LKFErrorAUFDATfalsch,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT, &LKFErrorIntEinhOhneVollstBer, 
&LKFErrorVerlSpezUngueltig, &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch, 
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt, &LKFErrorABTDATfalsch, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt, 
&LKFErrorABTZEITfalsch,
&LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt, 
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch, 
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter, 
&LKFErrorDiagGeschl, &LKFErrorMELfalsch, &LKFErrorMELohneAnzahl, &LKFErrorMELAlter, &LKFErrorMELGeschl, 
&LKFErrorMELANZfalsch, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2009,
&LKFErrorMEL0Tage, &LKFErrorMELFC, &LKFErrorMEL4Tage, &LKFErrorBehAbschliessen,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt, &LKFErrorSTAATBfalsch, &LKFErrorAUFARTBelagsdauer,
&LKFErrorABTFCSpezfalsch, &LKFErrorZDmehrfach, &LKFErrorDiagfalschWarn, &LKFErrorDiagUCode, &LKFErrorDiag0Tage, 
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2009, &LKFErrorMELohneDiag, 
&LKFErrorMELfKAunplaus2007, &LKFErrorMELAmbulant, &LKFErrorMEL0TageWarn, &LKFErrorMELohneSpez, &LKFErrorMELohneAUFART, 
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert, &LKFErrorMELENTDAT, 
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2005, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
&LKFErrorMELEntfernt, &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit, 
&LKFErrorKAAnFalsch, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch, &LKFErrorAufart2Fehlt, 
&LKFErrorKAAnUnplaus, &LKFErrorKAVonUnplaus, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig, 
&LKFErrorOEMELKA , &LKFErrorOEMELKAAlter , &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch, &LKFErrorMELAnzWarnTag, &LKFErrorMELANZmaxErrTag, &LKFHinweisMELMEL, 
/* V14.0 */
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung1TagH, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA /* V14.2 */, &LKFWarningOEMELKAAlter /* V14.2 */, &LKFWarningChemoTag /* V16.0 */, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2013[] = { /* V17.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt, &LKFErrorAUFARTfalsch, &LKFErrorAUFDATfehlt, &LKFErrorAUFARTABTFCfalsch, &LKFErrorAUFDATfalsch,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT, &LKFErrorIntEinhOhneVollstBer, 
&LKFErrorVerlSpezUngueltig, &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch, 
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt, &LKFErrorABTDATfalsch, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt, 
&LKFErrorABTZEITfalsch,
&LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt, 
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch, 
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter, 
&LKFErrorDiagGeschl, &LKFErrorMELfalsch, &LKFErrorMELohneAnzahl, &LKFErrorMELAlter, &LKFErrorMELGeschl, 
&LKFErrorMELANZfalsch, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2009,
&LKFErrorMEL0Tage, &LKFErrorMELFC, &LKFErrorMEL4Tage, &LKFErrorBehAbschliessen,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt2013 /* V17.0 */, &LKFErrorSTAATBfalsch2013 /* V17.0 */, &LKFErrorAUFARTBelagsdauer,
&LKFErrorABTFCSpezfalsch, &LKFErrorZDmehrfach, &LKFErrorDiagfalschWarn, &LKFErrorDiag9Code, &LKFErrorDiag0Tage, 
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2009, &LKFErrorMELohneDiag, 
&LKFErrorMELfKAunplaus2007, &LKFErrorMELAmbulant, &LKFErrorMEL0TageWarn, &LKFErrorMELohneSpez, &LKFErrorMELohneAUFART, 
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert, &LKFErrorMELENTDAT, 
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2005, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
/* &LKFErrorMELEntfernt, */ &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit, 
&LKFErrorKAAnFalsch, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch, &LKFErrorAufart2Fehlt, 
&LKFErrorKAAnUnplaus, &LKFErrorKAVonUnplaus, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig, 
&LKFErrorOEMELKA , &LKFErrorOEMELKAAlter , &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch, &LKFErrorMELAnzWarnTag, &LKFErrorMELANZmaxErrTag, &LKFHinweisMELMEL, 
/* V14.0 */
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung1TagH, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA /* V14.2 */, &LKFWarningOEMELKAAlter /* V14.2 */, &LKFWarningChemoTag /* V16.0 */, &LKFErrorMELSeiteUngueltig, &LKFErrorMELhatkeineSeite, 
&LKFWarningI64 /* V17.1 */, &LKFErrorMELSeiteFehlt /* V17.1 */, &LKFErrorAbtFC2013falsch /* V17.1 */, &LKFErrorIntUebwEinhOhneVollstBer, &LKFErrorABTFCSpezfalschError2013, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2014[] = { /* V18.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt, &LKFErrorAUFARTfalsch, &LKFErrorAUFDATfehlt, &LKFErrorAUFARTABTFCfalsch, &LKFErrorAUFDATfalsch,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT, &LKFErrorIntEinhOhneVollstBer, 
&LKFErrorVerlSpezUngueltig, &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch, 
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt, &LKFErrorABTDATfalsch, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt, 
&LKFErrorABTZEITfalsch,
&LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt, 
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch, 
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter, 
&LKFErrorDiagGeschl, &LKFErrorMELfalsch, &LKFErrorMELohneAnzahl, &LKFErrorMELAlter, &LKFErrorMELGeschl, 
&LKFErrorMELANZfalsch, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2009,
&LKFErrorMEL0Tage, &LKFErrorMELFC, &LKFErrorMEL4Tage, &LKFErrorBehAbschliessen,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt2013 /* V17.0 */, &LKFErrorSTAATBfalsch2013 /* V17.0 */, &LKFErrorAUFARTBelagsdauer,  
&LKFErrorABTFCSpezfalsch, &LKFErrorZDmehrfach, &LKFErrorDiagfalschWarn, &LKFErrorDiag9Code, &LKFErrorDiag0Tage, 
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2009, &LKFErrorMELohneDiag, 
&LKFErrorMELfKAunplaus2007, &LKFErrorMELAmbulant, &LKFErrorMEL0TageWarn, &LKFErrorMELohneSpez, &LKFErrorMELohneAUFART, 
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert, &LKFErrorMELENTDAT, 
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2005, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
/* &LKFErrorMELEntfernt, */ &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit, 
&LKFErrorKAAnFalsch, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch, &LKFErrorAufart2Fehlt, 
&LKFErrorKAAnUnplaus, &LKFErrorKAVonUnplaus, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig, 
&LKFErrorOEMELKA , &LKFErrorOEMELKAAlter , &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch, &LKFErrorMELAnzWarnTag, &LKFErrorMELANZmaxErrTag, &LKFHinweisMELMEL, 
/* V14.0 */
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung1TagH, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA /* V14.2 */, &LKFWarningOEMELKAAlter /* V14.2 */, &LKFWarningChemoTag /* V16.0 */, &LKFErrorMELSeiteUngueltig, &LKFErrorMELhatkeineSeite, 
&LKFWarningI64 /* V17.1 */, &LKFErrorMELSeiteFehlt /* V17.1 */, &LKFErrorIntUebwEinhOhneVollstBer, &LKFErrorABTFCSpezfalschError2013,
&LKFWarningDiagDiag /* V18.0 */, &LKFWarningDiagMel, /* V18.0 */ 0};


const LKF_SATZART_ERRORDEF *ppAllErrors2015[] = { /* V19.0 */
    &LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
    &LKFErrorGESCHLfalsch,
    &LKFErrorAUFARTfehlt, &LKFErrorAUFARTfalsch, &LKFErrorAUFDATfehlt, &LKFErrorAUFARTABTFCfalsch, &LKFErrorAUFDATfalsch,
    &LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
    &LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT, &LKFErrorIntEinhOhneVollstBer,
    &LKFErrorVerlSpezUngueltig, &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
    &LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt, &LKFErrorABTDATfalsch, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
    &LKFErrorABTZEITfalsch,
    &LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
    &LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
    &LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch,
    &LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
    &LKFErrorDiagGeschl, &LKFErrorMELfalsch, &LKFErrorMELohneAnzahl, &LKFErrorMELAlter, &LKFErrorMELGeschl,
    &LKFErrorMELANZfalsch, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2009,
    &LKFErrorMEL0Tage, &LKFErrorMELFC, &LKFErrorMEL4Tage, &LKFErrorBehAbschliessen,
    /* Warnings */
    &LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
    &LKFErrorABTFCSpezfalsch, &LKFErrorZDmehrfach, &LKFErrorDiagfalschWarn, &LKFErrorDiag9Code2015 /* V19.0 */, &LKFErrorDiag0Tage,
    &LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2009, &LKFErrorMELohneDiag,
    &LKFErrorMELfKAunplaus2007, &LKFErrorMELAmbulant, &LKFErrorMEL0TageWarn, &LKFErrorMELohneSpez, &LKFErrorMELohneAUFART,
    &LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
    &LKFErrorNPUeberwachung, &LKFErrorMELignoriert, &LKFErrorMELENTDAT,
    &LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
    &LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
    &LKFErrorMELDATaussAufenthalt2005, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
    &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
    &LKFErrorKAAnFalsch, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch, &LKFErrorAufart2Fehlt,
    &LKFErrorKAAnUnplaus, &LKFErrorKAVonUnplaus, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
    &LKFErrorOEMELKA , &LKFErrorOEMELKAAlter , &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
    &LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch, &LKFErrorMELAnzWarnTag, &LKFErrorMELANZmaxErrTag, &LKFHinweisMELMEL,
    &LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung1TagH, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
    &LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
    &LKFWarningOEMELKA, &LKFWarningOEMELKAAlter, &LKFWarningChemoTag, &LKFErrorMELSeiteUngueltig, &LKFErrorMELhatkeineSeite,
    &LKFWarningI64, &LKFErrorMELSeiteFehlt, &LKFErrorIntUebwEinhOhneVollstBer, &LKFErrorABTFCSpezfalschError2013,
    &LKFWarningDiagDiag, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2016[] = { /* V20.1 */
    &LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
    &LKFErrorGESCHLfalsch,
    &LKFErrorAUFARTfehlt, &LKFErrorAUFARTfalsch, &LKFErrorAUFDATfehlt, &LKFErrorAUFARTABTFCfalsch, &LKFErrorAUFDATfalsch,
    &LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
    &LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT, &LKFErrorIntEinhOhneVollstBer,
    &LKFErrorVerlSpezUngueltig, &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
    &LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt, &LKFErrorABTDATfalsch, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
    &LKFErrorABTZEITfalsch,
    &LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
    &LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
    &LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch,
    &LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
    &LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
    &LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
    &LKFErrorMEL0Tage2016, &LKFErrorMELFC2016, &LKFErrorMEL4Tage2016, &LKFErrorBehAbschliessen2016,
    /* Warnings */
    &LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
    &LKFErrorABTFCSpezfalsch, &LKFErrorZDmehrfach, &LKFErrorDiagfalschWarn, &LKFErrorDiag9Code2015 /* V19.0 */, &LKFErrorDiag0Tage,
    &LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
    &LKFErrorMELfKAunplaus2016, &LKFErrorMELAmbulant2016, &LKFErrorMEL0TageWarn2016, &LKFErrorMELohneSpez2016, &LKFErrorMELohneAUFART2016,
    &LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
    &LKFErrorNPUeberwachung, &LKFErrorMELignoriert2016, &LKFErrorMELENTDAT2016,
    &LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
    &LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
    &LKFErrorMELDATaussAufenthalt2005, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
    &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
    &LKFErrorKAAnFalsch, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch, &LKFErrorAufart2Fehlt,
    &LKFErrorKAAnUnplaus, &LKFErrorKAVonUnplaus, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
    &LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
    &LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2016, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
    &LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung1TagH, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
    &LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
    &LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
    &LKFWarningI64, &LKFErrorMELSeiteFehlt2016, &LKFErrorIntUebwEinhOhneVollstBer, &LKFErrorABTFCSpezfalschError2013,
    &LKFWarningDiagDiag, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2016, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch, 0};
#endif

const LKF_SATZART_ERRORDEF *ppAllErrors2017[] = { /* V21.0 */
    &LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
    &LKFErrorGESCHLfalsch,
    &LKFErrorAUFARTfehlt2017, &LKFErrorAUFARTfalsch2017, &LKFErrorAUFDATfehlt2017, &LKFErrorAUFARTABTFCfalsch, &LKFErrorAUFDATfalsch2017,
    &LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch2017, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
    &LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT2017, &LKFErrorIntEinhOhneVollstBer,
    &LKFErrorVerlSpezUngueltig, &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
    &LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt2017, &LKFErrorABTDATfalsch2017, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
    &LKFErrorABTZEITfalsch,
    &LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
    &LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
    &LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch,
    &LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
    &LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
    &LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
    &LKFErrorMEL0Tage2016, &LKFErrorMELENTART2016, &LKFErrorMELFC2016, &LKFErrorMEL4Tage2016, &LKFErrorBehAbschliessen2016,
    /* Warnings */
    &LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
    &LKFErrorABTFCSpezfalsch, &LKFErrorDiagmehrfach, &LKFErrorDiagfalschWarn2017, &LKFErrorDiag9Code2015 /* V19.0 */, &LKFErrorDiag0Tage,
    &LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
    &LKFErrorMELfKAunplaus2016, /* &LKFErrorMELAmbulant2016, V21.0 */ &LKFErrorMEL0TageWarn2016, &LKFErrorMELohneSpez2016, &LKFErrorMELohneAUFART2016,
    &LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
    &LKFErrorNPUeberwachung, &LKFErrorMELignoriert2016, &LKFErrorMELENTDAT2016,
    &LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
    &LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
    &LKFErrorMELDATaussAufenthalt2017, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
    &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
    &LKFErrorKAAnFalsch2017, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch2017, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch2017, &LKFErrorAufart2Fehlt,
    &LKFErrorKAAnUnplaus, &LKFErrorKAVonUnplaus, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
    &LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
    &LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2017, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
    &LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung1TagH, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
    &LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
    &LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
    &LKFWarningI64, &LKFErrorMELSeiteFehlt2017, &LKFErrorIntUebwEinhOhneVollstBer, &LKFErrorABTFCSpezfalschError2017,
    &LKFWarningDiagDiag, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2017 /* V21.3 */, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch,
    &LKFErrorGemeindezifferFalsch, &LKFErrorGemeindezifferFehlt, &LKFErrorAUFZEITfalsch,
    &LKFAmbErrorTransportartFalsch, &LKFErrorDIAGENTART, &LKFAmbErrorPhysAnwFalsch, &LKFAmbErrorDiagArtFalsch, &LKFAmbErrorMELUhrzeitFalsch, 
    &LKFErrorENTZEITfehlt, &LKFErrorENTZEITfalsch, &LKFErrorENTZEITvorAUFZEIT, &LKFErrorBEHANDLUNGSARTfehlt, &LKFErrorBEHANDLUNGSARTfalsch, &LKFErrorABRECHRELEVANZfalsch, &LKFErrorAmbAufenthaltDauer, &LKFErrorAUFDATBerichtsperiode, &LKFErrorAMBMELDIAGfehlt,
    &LKFErrorFachFCfalsch, &LKFErrorPflegFCfalsch, &LKFWarningStatErworben, &LKFWarningTKLAmbulant, &LKFErrorAUFZEITfehlt, &LKFErrorMELFUCOfehlt, &LKFErrorMELFUCOfalsch, &LKFErrorPLZGEMCOfalsch, &LKFErrorPLZGEMCOIntl, &LKFErrorMELKANRfalsch, &LKFErrorAmbMELANZmaxErr, &LKFErrorAmbMELAnzWarn, &LKFErrorFondsRelevanzUnplaus, &LKFErrorAUFNRSTATmehrfach, 0};


const LKF_SATZART_ERRORDEF *ppAllErrors2018[] = { /* V22.0 */
    &LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
    &LKFErrorGESCHLfalsch,
    &LKFErrorAUFARTfehlt2017, &LKFErrorAUFARTfalsch2017, &LKFErrorAUFDATfehlt2017, &LKFErrorAUFARTABTFCfalsch, &LKFErrorAUFDATfalsch2017,
    &LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch2017, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
    &LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT2017, &LKFErrorIntEinhOhneVollstBer,
    &LKFErrorVerlSpezUngueltig, &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
    &LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt2017, &LKFErrorABTDATfalsch2017, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
    &LKFErrorABTZEITfalsch,
    &LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
    &LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
    &LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch,
    &LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
    &LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
    &LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
    &LKFErrorMEL0Tage2016, &LKFErrorMELENTART2016, &LKFErrorMELFC2016, &LKFErrorMEL4Tage2016, &LKFErrorBehAbschliessen2016,
    /* Warnings */
    &LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
    &LKFErrorABTFCSpezfalsch, &LKFErrorDiagmehrfach, &LKFErrorDiagfalschWarn2017, &LKFErrorDiag9Code2015 /* V19.0 */, &LKFErrorDiag0Tage,
    &LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
    &LKFErrorMELfKAunplaus2016, /* &LKFErrorMELAmbulant2016, V21.0 */ &LKFErrorMEL0TageWarn2016, &LKFErrorMELohneSpez2016, &LKFErrorMELohneAUFART2016,
    &LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
    &LKFErrorNPUeberwachung, &LKFErrorMELignoriert2018, &LKFErrorMELENTDAT2016,
    &LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
    &LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
    &LKFErrorMELDATaussAufenthalt2017, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
    &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
    &LKFErrorKAAnFalsch2017, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch2017, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch2017, &LKFErrorAufart2Fehlt,
    &LKFErrorKAAnUnplaus, &LKFErrorKAVonUnplaus, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
    &LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
    &LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2017, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
    &LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung1TagH, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
    &LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
    &LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
    &LKFWarningI64, &LKFErrorMELSeiteFehlt2017, &LKFErrorIntUebwEinhOhneVollstBer, &LKFErrorABTFCSpezfalschError2017,
    &LKFWarningDiagDiag, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2017 /* V21.3 */, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch,
    &LKFErrorGemeindezifferFalsch, &LKFErrorGemeindezifferFehlt, &LKFErrorAUFZEITfalsch,
    &LKFAmbErrorTransportartFalsch, &LKFErrorDIAGENTART, &LKFAmbErrorPhysAnwFalsch, &LKFAmbErrorDiagArtFalsch, &LKFAmbErrorMELUhrzeitFalsch,
    &LKFErrorENTZEITfehlt, &LKFErrorENTZEITfalsch, &LKFErrorENTZEITvorAUFZEIT, &LKFErrorBEHANDLUNGSARTfehlt, &LKFErrorBEHANDLUNGSARTfalsch, &LKFErrorABRECHRELEVANZfalsch, &LKFErrorAmbAufenthaltDauer, &LKFErrorAUFDATBerichtsperiode, &LKFErrorAMBMELDIAGfehlt,
    &LKFErrorFachFCfalsch, &LKFErrorPflegFCfalsch, &LKFWarningStatErworben2018, &LKFWarningTKLAmbulant2018, &LKFErrorAUFZEITfehlt, &LKFErrorMELFUCOfehlt, &LKFErrorMELFUCOfalsch, &LKFErrorPLZGEMCOfalsch, &LKFErrorPLZGEMCOIntl,
    &LKFErrorMELKANRfalsch, &LKFErrorAmbMELANZmaxErr, &LKFErrorAmbMELAnzWarn, &LKFErrorFondsRelevanzUnplaus, &LKFErrorAUFNRSTATmehrfach, &LKFErrorMELohneBN, &LKFErrorBNohneMEL, &LKFErrorAltersgruppeAUFARTG, &LKFErrorStatErworbenHD /* V22.1 */, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2019[] = { /* V22.0 */
    &LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
    &LKFErrorGESCHLfalsch,
    &LKFErrorAUFARTfehlt2017, &LKFErrorAUFARTfalsch2017, &LKFErrorAUFDATfehlt2017, &LKFErrorAUFDATfalsch2017,
    &LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch2017, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
    &LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT2017, &LKFErrorIntEinhOhneVollstBer,
    &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
    &LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt2017, &LKFErrorABTDATfalsch2017, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
    &LKFErrorABTZEITfalsch,
    &LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
    &LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
    &LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch,
    &LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
    &LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
    &LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
    &LKFErrorMEL0Tage2016, &LKFErrorMELENTART2016, &LKFErrorMELFC2016,
    /* Warnings */
    &LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
    &LKFErrorABTFCSpezfalsch, &LKFErrorDiagmehrfach, &LKFErrorDiagfalschWarn2017, &LKFErrorDiag9Code2015 /* V19.0 */, &LKFErrorDiag0Tage,
    &LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
    &LKFErrorMELfKAunplaus2016, /* &LKFErrorMELAmbulant2016, V21.0 */ &LKFErrorMEL0TageWarn2016, &LKFErrorMELohneSpez2016, &LKFErrorMELohneAUFART2016,
    &LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
    &LKFErrorNPUeberwachung, &LKFErrorMELignoriert2018, &LKFErrorMELENTDAT2016,
    &LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
    &LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
    &LKFErrorMELDATaussAufenthalt2017, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
    &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
    &LKFErrorKAAnFalsch2017, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch2017, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch2017, &LKFErrorAufart2Fehlt,
    &LKFErrorKAAnUnplaus2019, &LKFErrorKAVonUnplaus2019, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
    &LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
    &LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2017, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
    &LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
    &LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
    &LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
    &LKFWarningI64, &LKFErrorMELSeiteFehlt2017, &LKFErrorIntUebwEinhOhneVollstBer, &LKFErrorABTFCSpezfalschError2017,
    &LKFWarningDiagDiag, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2017 /* V21.3 */, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch,
    &LKFErrorGemeindezifferFalsch, &LKFErrorGemeindezifferFehlt, &LKFErrorAUFZEITfalsch,
    &LKFAmbErrorTransportartFalsch, &LKFErrorDIAGENTART, &LKFAmbErrorPhysAnwFalsch, &LKFAmbErrorDiagArtFalsch, &LKFAmbErrorMELUhrzeitFalsch,
    &LKFErrorENTZEITfehlt, &LKFErrorENTZEITfalsch, &LKFErrorENTZEITvorAUFZEIT, &LKFErrorBEHANDLUNGSARTfehlt, &LKFErrorBEHANDLUNGSARTfalsch, &LKFErrorABRECHRELEVANZfalsch, &LKFErrorAmbAufenthaltDauer, &LKFErrorAUFDATBerichtsperiode, /* V2019.1 weg: &LKFErrorAMBMELDIAGfehlt, */
    &LKFErrorFachFCfalsch, &LKFErrorPflegFCfalsch, &LKFWarningStatErworben2018, &LKFWarningTKLAmbulant2018, &LKFErrorAUFZEITfehlt, &LKFErrorMELFUCOfehlt, &LKFErrorMELFUCOfalsch, &LKFErrorPLZGEMCOfalsch, &LKFErrorPLZGEMCOIntl,
    &LKFErrorMELKANRfalsch, &LKFErrorAmbMELANZmaxErr, &LKFErrorAmbMELAnzWarn, &LKFErrorFondsRelevanzUnplaus, &LKFErrorAUFNRSTATmehrfach, &LKFErrorMELohneBN, &LKFErrorBNohneMEL, &LKFErrorAltersgruppeAUFARTG, &LKFErrorStatErworbenHD /* V22.1 */, &LKFErrorMELStatUngueltig, &LKFErrorRankinMissing, /* &LKFErrorAMBMELDIAGung, */ &LKFErrorFucoLeist, &LKFErrorStrokeOhneLeistung, &LKFErrorMELBettHKUnplaus /* V2019.1 */, &LKFErrorKALeistFCLeist, &LKFErrorFCLeistKostPlan, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2020[] = { /* V2020.0 */
    &LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt,
    &LKFErrorGESCHLfalsch,
    &LKFErrorAUFARTfehlt2017, &LKFErrorAUFARTfalsch2017, &LKFErrorAUFDATfehlt2017, &LKFErrorAUFDATfalsch2017,
    &LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch2017, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
    &LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT2017, &LKFErrorIntEinhOhneVollstBer,
    &LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
    &LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt2017, &LKFErrorABTDATfalsch2017, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
    &LKFErrorABTZEITfalsch,
    &LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
    &LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
    &LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach, &LKFErrorHDfalsch,
    &LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
    &LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
    &LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
    &LKFErrorMEL0Tage2016, &LKFErrorMELENTART2016, &LKFErrorMELFC2016,
    /* Warnings */
    &LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
    &LKFErrorABTFCSpezfalsch, &LKFErrorDiagmehrfach, &LKFErrorDiagfalschWarn2017, &LKFErrorDiag9Code2015 /* V19.0 */, &LKFErrorDiag0Tage,
    &LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
    &LKFErrorMELfKAunplaus2016, /* &LKFErrorMELAmbulant2016, V21.0 */ &LKFErrorMEL0TageWarn2016, &LKFErrorMELohneSpez2016, &LKFErrorMELohneAUFART2016,
    &LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
    &LKFErrorNPUeberwachung, &LKFErrorMELignoriert2018, &LKFErrorMELENTDAT2016,
    &LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
    &LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
    &LKFErrorMELDATaussAufenthalt2017, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
    &LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
    &LKFErrorKAAnFalsch2017, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch2017, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch2017, &LKFErrorAufart2Fehlt,
    &LKFErrorKAAnUnplaus2019, &LKFErrorKAVonUnplaus2019, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
    &LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
    &LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2017, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
    &LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
    &LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
    &LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
    &LKFWarningI64, &LKFErrorMELSeiteFehlt2017, &LKFErrorIntUebwEinhOhneVollstBer, &LKFErrorABTFCSpezfalschError2017,
    &LKFWarningDiagDiag2020, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2017 /* V21.3 */, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch,
    &LKFErrorGemeindezifferFalsch, &LKFErrorGemeindezifferFehlt, &LKFErrorAUFZEITfalsch,
    &LKFAmbErrorTransportartFalsch, &LKFErrorDIAGENTART, &LKFAmbErrorPhysAnwFalsch, &LKFAmbErrorDiagArtFalsch, &LKFAmbErrorMELUhrzeitFalsch,
    &LKFErrorENTZEITfehlt, &LKFErrorENTZEITfalsch, &LKFErrorENTZEITvorAUFZEIT, &LKFErrorBEHANDLUNGSARTfehlt, &LKFErrorBEHANDLUNGSARTfalsch, &LKFErrorABRECHRELEVANZfalsch, &LKFErrorAmbAufenthaltDauer, &LKFErrorAUFDATBerichtsperiode, /* V2019.1 weg: &LKFErrorAMBMELDIAGfehlt, */
    &LKFErrorFachFCfalsch, &LKFErrorPflegFCfalsch, &LKFWarningStatErworben2018, &LKFWarningTKLAmbulant2018, &LKFErrorAUFZEITfehlt, &LKFErrorMELFUCOfehlt, &LKFErrorMELFUCOfalsch, &LKFErrorPLZGEMCOfalsch, &LKFErrorPLZGEMCOIntl,
    &LKFErrorMELKANRfalsch, &LKFErrorAmbMELANZmaxErr, &LKFErrorAmbMELAnzWarn, &LKFErrorFondsRelevanzUnplaus, &LKFErrorAUFNRSTATmehrfach, &LKFErrorMELohneBN, &LKFErrorBNohneMEL, &LKFErrorAltersgruppeAUFARTG, &LKFErrorStatErworbenHD /* V22.1 */, &LKFErrorMELStatUngueltig, &LKFErrorRankinMissing, /* &LKFErrorAMBMELDIAGung, */ &LKFErrorFucoLeist, &LKFErrorStrokeOhneLeistung, &LKFErrorMELBettHKUnplaus /* V2019.1 */, &LKFErrorKALeistFCLeist, &LKFErrorFCLeistKostPlan2020, &LKFErrorBirthNoZD, &LKFErrorBirthMultiZD, &LKFWarningStatMELAmbulant, &LKFErrorChemoKomb, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2021[] = { /* V2021.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt2021 /* V2021.1: akzeptierbar */,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt2017, &LKFErrorAUFARTfalsch2017, &LKFErrorAUFDATfehlt2017, &LKFErrorAUFDATfalsch2017,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch2017, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT2017, &LKFErrorIntEinhOhneVollstBer,
&LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt2017, &LKFErrorABTDATfalsch2017, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
&LKFErrorABTZEITfalsch,
&LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach2021amb /* V2021.2 */, &LKFErrorHDfalsch,
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
&LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
&LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
&LKFErrorMEL0Tage2016, &LKFErrorMELENTART2016, &LKFErrorMELFC2016,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
&LKFErrorABTFCSpezfalsch, &LKFErrorDiagmehrfach, &LKFErrorDiagfalschWarn2017, &LKFErrorDiag9Code2015 /* V19.0 */, &LKFErrorDiag0Tage,
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
&LKFErrorMELfKAunplaus2016, /* &LKFErrorMELAmbulant2016, V21.0 */ &LKFErrorMEL0TageWarn2016, &LKFErrorMELohneSpez2016, &LKFErrorMELohneAUFART2016,
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert2018, &LKFErrorMELENTDAT2016,
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2017, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
&LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
&LKFErrorKAAnFalsch2017, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch2017, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch2017, &LKFErrorAufart2Fehlt,
&LKFErrorKAAnUnplaus2019, &LKFErrorKAVonUnplaus2019, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
&LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2017, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag2021 /* V2021.0 */, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
&LKFWarningI64, &LKFErrorMELSeiteFehlt2017, &LKFErrorIntUebwEinhOhneVollstBer, /* &LKFErrorABTFCSpezfalschError2017, 2021.2 */
&LKFWarningDiagDiag2020, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2017 /* V21.3 */, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch,
&LKFErrorGemeindezifferFalsch, &LKFErrorGemeindezifferFehlt, &LKFErrorAUFZEITfalsch,
&LKFAmbErrorTransportartFalsch, &LKFErrorDIAGENTART, &LKFAmbErrorPhysAnwFalsch, &LKFAmbErrorDiagArtFalsch, &LKFAmbErrorMELUhrzeitFalsch,
&LKFErrorENTZEITfehlt, &LKFErrorENTZEITfalsch, &LKFErrorENTZEITvorAUFZEIT, &LKFErrorBEHANDLUNGSARTfehlt, &LKFErrorBEHANDLUNGSARTfalsch, &LKFErrorABRECHRELEVANZfalsch, &LKFErrorAmbAufenthaltDauer, &LKFErrorAUFDATBerichtsperiode, /* V2019.1 weg: &LKFErrorAMBMELDIAGfehlt, */
&LKFErrorFachFCfalsch, &LKFErrorPflegFCfalsch, &LKFWarningStatErworben2018, &LKFWarningTKLAmbulant2018, &LKFErrorAUFZEITfehlt, &LKFErrorMELFUCOfehlt, &LKFErrorMELFUCOfalsch, &LKFErrorPLZGEMCOfalsch, &LKFErrorPLZGEMCOIntl,
&LKFErrorMELKANRfalsch, &LKFErrorAmbMELANZmaxErr, &LKFErrorAmbMELAnzWarn, &LKFErrorFondsRelevanzUnplaus, &LKFErrorAUFNRSTATmehrfach, &LKFErrorMELohneBN, &LKFErrorBNohneMEL, &LKFErrorAltersgruppeAUFARTG, &LKFErrorStatErworbenHD /* V22.1 */, &LKFErrorMELStatUngueltig, &LKFErrorRankinMissing, /* &LKFErrorAMBMELDIAGung, */ &LKFErrorFucoLeist, &LKFErrorStrokeOhneLeistung, &LKFErrorMELBettHKUnplaus /* V2019.1 */, &LKFErrorKALeistFCLeist, &LKFErrorFCLeistKostPlan2020, &LKFErrorBirthNoZD, &LKFErrorBirthMultiZD, &LKFWarningStatMELAmbulant, &LKFErrorChemoKomb,
    &LKFInfoOnkoIgnore /* V2021.0 */, 0};


const LKF_SATZART_ERRORDEF *ppAllErrors2022[] = { /* V2022.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt2021,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt2017, &LKFErrorAUFARTfalsch2017, &LKFErrorAUFDATfehlt2017, &LKFErrorAUFDATfalsch2017,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch2017, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT2017, &LKFErrorIntEinhOhneVollstBer,
&LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt2017, &LKFErrorABTDATfalsch2017, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
&LKFErrorABTZEITfalsch,
&LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach2021amb, &LKFErrorHDfalsch,
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
&LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
&LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
&LKFErrorMEL0Tage2016, &LKFErrorMELENTART2016, &LKFErrorMELFC2016,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
&LKFErrorABTFCSpezfalsch, &LKFErrorDiagmehrfach, &LKFErrorDiagfalschWarn2017, &LKFErrorDiag9Code2015, &LKFErrorDiag0Tage,
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
&LKFErrorMELfKAunplaus2016, &LKFErrorMEL0TageWarn2016, &LKFErrorMELohneSpez2016, &LKFErrorMELohneAUFART2016,
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert2018, &LKFErrorMELENTDAT2016,
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2017, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
&LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
&LKFErrorKAAnFalsch2017, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch2017, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch2017, &LKFErrorAufart2Fehlt,
&LKFErrorKAAnUnplaus2019, &LKFErrorKAVonUnplaus2019, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
&LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2017, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag2021, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
&LKFWarningI64, &LKFErrorMELSeiteFehlt2017, &LKFErrorIntUebwEinhOhneVollstBer,
&LKFWarningDiagDiag2020, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2017, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch,
&LKFErrorGemeindezifferFalsch, &LKFErrorGemeindezifferFehlt, &LKFErrorAUFZEITfalsch,
&LKFAmbErrorTransportartFalsch, &LKFErrorDIAGENTART, &LKFAmbErrorPhysAnwFalsch, &LKFAmbErrorDiagArtFalsch, &LKFAmbErrorMELUhrzeitFalsch,
&LKFErrorENTZEITfehlt, &LKFErrorENTZEITfalsch, &LKFErrorENTZEITvorAUFZEIT, &LKFErrorBEHANDLUNGSARTfehlt, &LKFErrorBEHANDLUNGSARTfalsch, &LKFErrorABRECHRELEVANZfalsch, &LKFErrorAmbAufenthaltDauer, &LKFErrorAUFDATBerichtsperiode,
&LKFErrorFachFCfalsch, &LKFErrorPflegFCfalsch, &LKFWarningStatErworben2018, &LKFWarningTKLAmbulant2018, &LKFErrorAUFZEITfehlt, &LKFErrorMELFUCOfehlt, &LKFErrorMELFUCOfalsch, &LKFErrorPLZGEMCOfalsch, &LKFErrorPLZGEMCOIntl,
    &LKFErrorMELKANRfalsch, &LKFErrorAmbMELANZmaxErr, &LKFErrorAmbMELAnzWarn, &LKFErrorFondsRelevanzUnplaus, &LKFErrorAUFNRSTATmehrfach, &LKFErrorMELohneBN, &LKFErrorBNohneMEL, &LKFErrorAltersgruppeAUFARTG, &LKFErrorStatErworbenHD, &LKFErrorMELStatUngueltig, &LKFErrorRankinMissing, &LKFErrorFucoLeist, &LKFErrorStrokeOhneLeistung, &LKFErrorMELBettHKUnplaus, &LKFErrorKALeistFCLeist, &LKFErrorFCLeistKostPlan2020, &LKFErrorBirthNoZD, &LKFErrorBirthMultiZD, &LKFWarningStatMELAmbulant, &LKFErrorChemoKomb,
    &LKFInfoOnkoIgnore, &LKFErrorKombPhysJN, &LKFErrorSecInsuffizient, &LKFErrorUnterbrecherEntlassung /* V2023.1 */, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2023[] = { /* V2023.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt2021,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt2017, &LKFErrorAUFARTfalsch2017, &LKFErrorAUFDATfehlt2017, &LKFErrorAUFDATfalsch2017,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch2017, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT2017, &LKFErrorIntEinhOhneVollstBer,
&LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt2017, &LKFErrorABTDATfalsch2017, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
&LKFErrorABTZEITfalsch,
&LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach2021amb, &LKFErrorHDfalsch,
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
&LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
&LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
&LKFErrorMEL0Tage2016, &LKFErrorMELENTART2016, &LKFErrorMELFC2016,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
&LKFErrorABTFCSpezfalsch, &LKFErrorDiagmehrfach, &LKFErrorDiagfalschWarn2017, &LKFErrorDiag9Code2015, &LKFErrorDiag0Tage,
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
&LKFErrorMELfKAunplaus2016, &LKFErrorMEL0TageWarn2016, &LKFErrorMELohneSpez2023 /* V2023.0 */, &LKFErrorMELohneAUFART2016,
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert2018, &LKFErrorMELENTDAT2016,
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2017, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
&LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
&LKFErrorKAAnFalsch2017, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch2017, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch2017, &LKFErrorAufart2Fehlt,
&LKFErrorKAAnUnplaus2019, &LKFErrorKAVonUnplaus2019, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
&LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2017, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag2021, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
&LKFWarningI64, &LKFErrorMELSeiteFehlt2017, &LKFErrorIntUebwEinhOhneVollstBer,
&LKFWarningDiagDiag2020, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2017, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch,
&LKFErrorGemeindezifferFalsch, &LKFErrorGemeindezifferFehlt2023 /* V2023.0 */, &LKFErrorAUFZEITfalsch,
&LKFAmbErrorTransportartFalsch, &LKFErrorDIAGENTART, &LKFAmbErrorPhysAnwFalsch, &LKFAmbErrorDiagArtFalsch, &LKFAmbErrorMELUhrzeitFalsch,
&LKFErrorENTZEITfehlt, &LKFErrorENTZEITfalsch, &LKFErrorENTZEITvorAUFZEIT, &LKFErrorBEHANDLUNGSARTfehlt, &LKFErrorBEHANDLUNGSARTfalsch, &LKFErrorABRECHRELEVANZfalsch, &LKFErrorAmbAufenthaltDauer, &LKFErrorAUFDATBerichtsperiode,
&LKFErrorFachFCfalsch, &LKFErrorPflegFCfalsch, &LKFWarningStatErworben2018, &LKFWarningTKLAmbulant2018, &LKFErrorAUFZEITfehlt, &LKFErrorMELFUCOfehlt, &LKFErrorMELFUCOfalsch, &LKFErrorPLZGEMCOfalsch2023 /* V2023.0 */, &LKFErrorPLZGEMCOIntl,
    &LKFErrorMELKANRfalsch, &LKFErrorAmbMELANZmaxErr, &LKFErrorAmbMELAnzWarn, &LKFErrorFondsRelevanzUnplaus, &LKFErrorAUFNRSTATmehrfach, &LKFErrorMELohneBN, &LKFErrorBNohneMEL, &LKFErrorAltersgruppeAUFARTG, &LKFErrorStatErworbenHD, &LKFErrorMELStatUngueltig, &LKFErrorRankinMissing, &LKFErrorFucoLeist, &LKFErrorStrokeOhneLeistung, &LKFErrorMELBettHKUnplaus, &LKFErrorKALeistFCLeist, &LKFErrorFCLeistKostPlan2020, &LKFErrorBirthNoZD, &LKFErrorBirthMultiZD, &LKFWarningStatMELAmbulant, &LKFErrorChemoKomb,
    &LKFInfoOnkoIgnore, &LKFErrorKombPhysJN, &LKFErrorSecInsuffizient,
    &LKFErrorUnterbrecherEntlassung /* V2023.1 */, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2024[] = { /* V2024.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt2021,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt2017, &LKFErrorAUFARTfalsch2017, &LKFErrorAUFDATfehlt2017, &LKFErrorAUFDATfalsch2017,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch2017, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT2017, &LKFErrorIntEinhOhneVollstBer,
&LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt2017, &LKFErrorABTDATfalsch2017, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
&LKFErrorABTZEITfalsch,
&LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach2021amb, &LKFErrorHDfalsch,
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
&LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
&LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
&LKFErrorMEL0Tage2024, &LKFErrorMELENTART2016, &LKFErrorMELFC2016,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
&LKFErrorABTFCSpezfalsch, &LKFErrorDiagmehrfach, &LKFErrorDiagfalschWarn2017, &LKFErrorDiag9Code2015, &LKFErrorDiag0Tage,
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
&LKFErrorMELfKAunplaus2016, &LKFErrorMEL0TageWarn2024, &LKFErrorMELohneSpez2023 /* V2023.0 */, &LKFErrorMELohneAUFART2016,
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert2018, &LKFErrorMELENTDAT2016,
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2017, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
&LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
&LKFErrorKAAnFalsch2017, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch2017, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch2017, &LKFErrorAufart2Fehlt,
&LKFErrorKAAnUnplaus2019, &LKFErrorKAVonUnplaus2019, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
&LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2017, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag2021, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
&LKFWarningI64, &LKFErrorMELSeiteFehlt2017, &LKFErrorIntUebwEinhOhneVollstBer,
&LKFWarningDiagDiag2020, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2017, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch,
&LKFErrorGemeindezifferFalsch, &LKFErrorGemeindezifferFehlt2023 /* V2023.0 */, &LKFErrorAUFZEITfalsch,
&LKFAmbErrorTransportartFalsch, &LKFErrorDIAGENTART, &LKFAmbErrorPhysAnwFalsch, &LKFAmbErrorDiagArtFalsch, &LKFAmbErrorMELUhrzeitFalsch,
&LKFErrorENTZEITfehlt, &LKFErrorENTZEITfalsch, &LKFErrorENTZEITvorAUFZEIT, &LKFErrorBEHANDLUNGSARTfehlt, &LKFErrorBEHANDLUNGSARTfalsch, &LKFErrorABRECHRELEVANZfalsch, &LKFErrorAmbAufenthaltDauer, &LKFErrorAUFDATBerichtsperiode,
&LKFErrorFachFCfalsch, &LKFErrorPflegFCfalsch, &LKFWarningStatErworben2018, &LKFWarningTKLAmbulant2018, &LKFErrorAUFZEITfehlt, &LKFErrorMELFUCOfehlt, &LKFErrorMELFUCOfalsch, &LKFErrorPLZGEMCOfalsch2023 /* V2023.0 */, &LKFErrorPLZGEMCOIntl,
    &LKFErrorMELKANRfalsch, &LKFErrorAmbMELANZmaxErr, &LKFErrorAmbMELAnzWarn, &LKFErrorFondsRelevanzUnplaus, &LKFErrorAUFNRSTATmehrfach, &LKFErrorMELohneBN, &LKFErrorBNohneMEL, &LKFErrorAltersgruppeAUFARTG, &LKFErrorStatErworbenHD, &LKFErrorMELStatUngueltig, &LKFErrorRankinMissing, &LKFErrorFucoLeist, &LKFErrorStrokeOhneLeistung, &LKFErrorMELBettHKUnplaus, &LKFErrorKALeistFCLeist, &LKFErrorFCLeistKostPlan2020, &LKFErrorBirthNoZD, &LKFErrorBirthMultiZD, &LKFWarningStatMELAmbulant, &LKFErrorChemoKomb,
    &LKFInfoOnkoIgnore, &LKFErrorKombPhysJN, /* &LKFErrorSecInsuffizient, V2025.0 deaktiviert */
    &LKFErrorUnterbrecherEntlassung /* V2023.1 */, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2025[] = { /* V2025.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt2021,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt2017, &LKFErrorAUFARTfalsch2017, &LKFErrorAUFDATfehlt2017, &LKFErrorAUFDATfalsch2017,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch2017, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT2017, &LKFErrorIntEinhOhneVollstBer,
&LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt2017, &LKFErrorABTDATfalsch2017, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
&LKFErrorABTZEITfalsch,
&LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach2021amb, &LKFErrorHDfalsch,
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
&LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
&LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
&LKFErrorMEL0Tage2024, &LKFErrorMELENTART2016, &LKFErrorMELFC2016,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
&LKFErrorABTFCSpezfalsch, &LKFErrorDiagmehrfach, &LKFErrorDiagfalschWarn2017, &LKFErrorDiag9Code2015, &LKFErrorDiag0Tage,
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
&LKFErrorMELfKAunplaus2016, &LKFErrorMEL0TageWarn2024, &LKFErrorMELohneSpez2023 /* V2023.0 */, &LKFErrorMELohneAUFART2016,
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert2018, &LKFErrorMELENTDAT2016,
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2017, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
&LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
&LKFErrorKAAnFalsch2017, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch2017, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch2017, &LKFErrorAufart2Fehlt,
&LKFErrorKAAnUnplaus2019, &LKFErrorKAVonUnplaus2019, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
&LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2017, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag2021, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
&LKFWarningI64, &LKFErrorMELSeiteFehlt2017, &LKFErrorIntUebwEinhOhneVollstBer,
&LKFWarningDiagDiag2020, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2017, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch,
&LKFErrorGemeindezifferFalsch, &LKFErrorGemeindezifferFehlt2023 /* V2023.0 */, &LKFErrorAUFZEITfalsch,
&LKFAmbErrorTransportartFalsch, &LKFErrorDIAGENTART, &LKFAmbErrorPhysAnwFalsch, &LKFAmbErrorDiagArtFalsch, &LKFAmbErrorMELUhrzeitFalsch,
&LKFErrorENTZEITfehlt, &LKFErrorENTZEITfalsch, &LKFErrorENTZEITvorAUFZEIT, &LKFErrorBEHANDLUNGSARTfehlt, &LKFErrorBEHANDLUNGSARTfalsch, &LKFErrorABRECHRELEVANZfalsch, &LKFErrorAmbAufenthaltDauer, &LKFErrorAUFDATBerichtsperiode,
&LKFErrorFachFCfalsch, &LKFErrorPflegFCfalsch, &LKFWarningStatErworben2018, &LKFWarningTKLAmbulant2018, &LKFErrorAUFZEITfehlt, &LKFErrorMELFUCOfehlt, &LKFErrorMELFUCOfalsch, &LKFErrorPLZGEMCOfalsch2023 /* V2023.0 */, &LKFErrorPLZGEMCOIntl,
    &LKFErrorMELKANRfalsch, &LKFErrorAmbMELANZmaxErr, &LKFErrorAmbMELAnzWarn, &LKFErrorFondsRelevanzUnplaus, &LKFErrorAUFNRSTATmehrfach, &LKFErrorMELohneBN, &LKFErrorBNohneMEL, &LKFErrorAltersgruppeAUFARTG, &LKFErrorStatErworbenHD, &LKFErrorMELStatUngueltig, &LKFErrorRankinMissing, &LKFErrorFucoLeist, &LKFErrorStrokeOhneLeistung, &LKFErrorMELBettHKUnplaus, &LKFErrorKALeistFCLeist, &LKFErrorFCLeistKostPlan2020, &LKFErrorBirthNoZD, &LKFErrorBirthMultiZD, &LKFWarningStatMELAmbulant, &LKFErrorChemoKomb,
    &LKFInfoOnkoIgnore, &LKFErrorKombPhysJN, /* &LKFErrorSecInsuffizient,  V2025.0 deaktiviert */
    &LKFErrorUnterbrecherEntlassung /* V2023.1 */, &LKFErrorUeberliegerDaten, &LKFErrorAmbHDfehlt2025, &LKFErrorAmbHDmultiple2025, &LKFErrorStatDiag5stellig, &LKFErrorZN410OpMel, &LKFErrorAN011VW, &LKFErrorEB040, 0};

const LKF_SATZART_ERRORDEF *ppAllErrors2026[] = { /* V2026.0 */
&LKFErrorKeineAufnahmezahl, &LKFErrorGEBDATfehlt, &LKFErrorGEBDATfalsch, &LKFErrorGEBDATnachAUFDAT, &LKFErrorGESCHLfehlt2021,
&LKFErrorGESCHLfalsch,
&LKFErrorAUFARTfehlt2017, &LKFErrorAUFARTfalsch2017, &LKFErrorAUFDATfehlt2017, &LKFErrorAUFDATfalsch2017,
&LKFErrorAUFDATnachENTDAT, &LKFErrorENTARTfehlt, &LKFErrorENTARTfalsch2017, &LKFErrorENTARTVerbleib, &LKFErrorENTDATfehlt,
&LKFErrorENTDATfalsch, &LKFErrorENTDATVerbleib, &LKFErrorENTDATBerichtsperiode, &LKFErrorAUFDATungleichABTDAT2017, &LKFErrorIntEinhOhneVollstBer,
&LKFErrorAbtPosNrNichtVollst, &LKFErrorAbtPosNrFalsch, &LKFErrorABTFCfehlt, &LKFErrorABTFCfalsch,
&LKFErrorSpezOhneLeistung, &LKFErrorABTDATfehlt2017, &LKFErrorABTDATfalsch2017, &LKFErrorABTDATaussAufenthalt, &LKFErrorABTZEITfehlt,
&LKFErrorABTZEITfalsch,
&LKFErrorABTENTDATfehlt, &LKFErrorABTENTDATfalsch, &LKFErrorABTENTDATaussAufenthalt,
&LKFErrorVerlegungenChrono, &LKFErrorVerlegungenUeberlapp, &LKFErrorABTENTZEITfehlt, &LKFErrorABTENTZEITfalsch, &LKFErrorABTENTARTfehlt,
&LKFErrorABTENTARTfalsch, &LKFErrorABTENTARTKombENTART, &LKFErrorHDfehlt, &LKFErrorHDmehrfach2021amb, &LKFErrorHDfalsch,
&LKFErrorDiagfalsch, &LKFErrorDiag4stellig, &LKFErrorDiagTypfehlt, &LKFErrorDiagTypfalsch, &LKFErrorDiagAlter,
&LKFErrorDiagGeschl, &LKFErrorMELfalsch2016, &LKFErrorMELohneAnzahl2016, &LKFErrorMELAlter2016, &LKFErrorMELGeschl2016,
&LKFErrorMELANZfalsch2016, &LKFErrorMELANZohneMEL, &LKFErrorMELANZmaxErr2016,
&LKFErrorMEL0Tage2024, &LKFErrorMELENTART2016, &LKFErrorMELFC2016,
/* Warnings */
&LKFErrorAlter, &LKFErrorSTAATBfehlt2013, &LKFErrorSTAATBfalsch2013, &LKFErrorAUFARTBelagsdauer,
&LKFErrorABTFCSpezfalsch, &LKFErrorDiagmehrfach, &LKFErrorDiagfalschWarn2017, &LKFErrorDiag9Code2015, &LKFErrorDiag0Tage,
&LKFErrorHDstatfalsch, &LKFErrorSternKreuzHD, &LKFErrorSternKreuzZD, &LKFErrorMELAnzWarn2016, &LKFErrorMELohneDiag2016,
&LKFErrorMELfKAunplaus2016, &LKFErrorMEL0TageWarn2024, &LKFErrorMELohneSpez2023 /* V2023.0 */, &LKFErrorMELohneAUFART2016,
&LKFErrorMELTag2009, &LKFErrorMELAufenthalt, &LKFErrorNPfehlt, &LKFErrorNPAlter,
&LKFErrorNPUeberwachung, &LKFErrorMELignoriert2018, &LKFErrorMELENTDAT2016,
&LKFErrorSTAATWfehlt2005, &LKFErrorSTAATWfalsch2005, &LKFErrorPLZWfehlt2005, &LKFErrorPLZWfalsch2005,
&LKFErrorMELDATfehlt2005, &LKFErrorMELDATfalsch2005,
&LKFErrorMELDATaussAufenthalt2017, &LKFErrorKOSTfehlt2005, &LKFErrorKOSTfalsch2005,
&LKFErrorNPPlausMELOhneDatum, &LKFErrorEntVorAufZeit,
&LKFErrorKAAnFalsch2017, &LKFErrorKAAnFehlt, &LKFErrorKAVonFalsch2017, &LKFErrorKAVonFehlt, &LKFErrorAufart2Falsch2017, &LKFErrorAufart2Fehlt,
&LKFErrorKAAnUnplaus2019, &LKFErrorKAVonUnplaus2019, &LKFErrorRemobUeber28ab2009, &LKFErrorVerlegungenLoechrig,
&LKFErrorOEMELKA2016 , &LKFErrorOEMELKAAlter2016, &LKFErrorKAAnNurBeiT, &LKFErrorKAVonNurBeiT, &LKFErrorVerlAkutPflege,
&LKFErrorAufartPflege, &LKFErrorAufartPflege2_2010, &LKFErrorKassenfreiFalsch2017, &LKFErrorMELAnzWarnTag2016, &LKFErrorMELANZmaxErrTag2016, &LKFHinweisMELMEL,
&LKFErrorUnterbrechung0Tage, &LKFErrorUnterbrechung6Tage, &LKFErrorUnterbrechungAufDat,
&LKFErrorUnterbrechungEntDat, &LKFErrorUnterbrechungMEL,
&LKFWarningOEMELKA2016, &LKFWarningOEMELKAAlter2016, &LKFWarningChemoTag2021, &LKFErrorMELSeiteUngueltig2016, &LKFErrorMELhatkeineSeite2016,
&LKFWarningI64, &LKFErrorMELSeiteFehlt2017, &LKFErrorIntUebwEinhOhneVollstBer,
&LKFWarningDiagDiag2020, &LKFWarningDiagMel, &LKFError_AlterGruppeFehlt, &LKFError_AlterGruppeFalsch, &LKFErrorRevisionGrund2017, &LKFWarningUICCFehlt, &LKFError_AbtAlterGruppeFehlt, &LKFError_AbtAlterGruppeFalsch, &LKFError_AbtNeugeborenesFalsch,
&LKFErrorGemeindezifferFalsch, &LKFErrorGemeindezifferFehlt2023 /* V2023.0 */, &LKFErrorAUFZEITfalsch,
&LKFAmbErrorTransportartFalsch, &LKFErrorDIAGENTART, &LKFAmbErrorPhysAnwFalsch, &LKFAmbErrorDiagArtFalsch, &LKFAmbErrorMELUhrzeitFalsch,
&LKFErrorENTZEITfehlt, &LKFErrorENTZEITfalsch, &LKFErrorENTZEITvorAUFZEIT, &LKFErrorBEHANDLUNGSARTfehlt, &LKFErrorBEHANDLUNGSARTfalsch, &LKFErrorABRECHRELEVANZfalsch, &LKFErrorAmbAufenthaltDauer, &LKFErrorAUFDATBerichtsperiode,
&LKFErrorFachFCfalsch, &LKFErrorPflegFCfalsch, &LKFWarningStatErworben2018, &LKFWarningTKLAmbulant2018, &LKFErrorAUFZEITfehlt, &LKFErrorMELFUCOfehlt, &LKFErrorMELFUCOfalsch, &LKFErrorPLZGEMCOfalsch2023 /* V2023.0 */, &LKFErrorPLZGEMCOIntl,
    &LKFErrorMELKANRfalsch, &LKFErrorAmbMELANZmaxErr, &LKFErrorAmbMELAnzWarn, &LKFErrorFondsRelevanzUnplaus, &LKFErrorAUFNRSTATmehrfach, &LKFErrorMELohneBN, &LKFErrorBNohneMEL, &LKFErrorAltersgruppeAUFARTG, &LKFErrorStatErworbenHD, &LKFErrorMELStatUngueltig, &LKFErrorRankinMissing, &LKFErrorFucoLeist, &LKFErrorStrokeOhneLeistung, &LKFErrorMELBettHKUnplaus, &LKFErrorKALeistFCLeist, &LKFErrorFCLeistKostPlan2020, &LKFErrorBirthNoZD, &LKFErrorBirthMultiZD, &LKFWarningStatMELAmbulant, &LKFErrorChemoKomb,
    &LKFInfoOnkoIgnore, &LKFErrorKombPhysJN, /* &LKFErrorSecInsuffizient,  V2025.0 deaktiviert */
    &LKFErrorUnterbrecherEntlassung /* V2023.1 */, &LKFErrorUeberliegerDaten, &LKFErrorAmbHDfehlt2026, &LKFErrorAmbHDmultiple2025, &LKFErrorStatDiag5stellig, &LKFErrorZN410OpMel, &LKFErrorAN011VW, &LKFErrorEB040, &LKFErrorZN173, &LKFErrorDD020, &LKFErrorHM070, &LKFErrorAmbHDfehltZDvorhanden2026, 0};

#define IS_TRACE_INFO(pContext) (lkf_isTraceInfo (pContext, LKF_FAC_MBDS))
#define IS_TRACE_DETAIL(pContext) (lkf_isTraceDetail (pContext, LKF_FAC_MBDS))
#define IS_TRACE_INPUT(pContext) (lkf_isTraceInput (pContext, LKF_FAC_MBDS))

#define TRACE_INFO(pAufenthalt,nAbtFC,sLine) (lkf_addTraceAufenthaltLine ((pAufenthalt)->pScoringContext, pAufenthalt, (int)(nAbtFC), sLine, LKF_FAC_MBDS, LKF_TRACE_INFO)) 
#define TRACE_DETAIL(pAufenthalt,nAbtFC,sLine) (lkf_addTraceAufenthaltLine ((pAufenthalt)->pScoringContext, pAufenthalt, (int)(nAbtFC), sLine, LKF_FAC_MBDS, LKF_TRACE_DETAIL))

const LKF_SATZART_ERRORDEF **GetAllMBDSErrors (int nModelljahr)
{
	switch (nModelljahr)
	{
#ifdef SUPPORT_PRE2017
		case 2009:
			return ppAllErrors2009;
		case 2010:
			return ppAllErrors2010;
		case 2011:
			return ppAllErrors2011;
		case 2012:
			return ppAllErrors2012;
		case 2013:
			return ppAllErrors2013;
		case 2014:
			return ppAllErrors2014;
        case 2015:
            return ppAllErrors2015;
		case 2016:
			return ppAllErrors2016;
#endif
        case 2017:
            return ppAllErrors2017;
        case 2018:
            return ppAllErrors2018;
        case 2019:
            return ppAllErrors2019;
        case 2020:
            return ppAllErrors2020;
        case 2021:
            return ppAllErrors2021;
        case 2022:
            return ppAllErrors2022;
        case 2023:
            return ppAllErrors2023;
        case 2024:
            return ppAllErrors2024;
        case 2025:
            return ppAllErrors2025;
        case 2026:
            return ppAllErrors2026;
        default:
            return 0;
	}
}

/* function lkf_plaus_GetErrorAnz ****************************************
**     Liefert die Anzahl Fehler des letzten Plausibilit\xc3\xa4""tslaufs zur\xc3\xbc""ck **
**     (also den Wert, der auch in errors vermerkt wird                 **
*************************************************************************/

_SCORING_EXPORT int lkf_plaus_GetErrorAnz (LKF_AUFENTHALT *pAufenthalt, int *accepted)
{ 
	if (accepted) *accepted = pAufenthalt->akerr_count;
	return pAufenthalt->plaus_err; 
}

/* function lkf_plaus_GetWarningAnz **************************************
**     Liefert die Anzahl Warnings des letzten Laufs zur\xc3\xbc""ck             **
*************************************************************************/

_SCORING_EXPORT int lkf_plaus_GetWarningAnz (LKF_AUFENTHALT *pAufenthalt, int *accepted)
{ 
	if (accepted) *accepted = pAufenthalt->akwarn_count;
	return pAufenthalt->plaus_warn; 
}

/* function lkf_plaus_GetInfoAnz *****************************************
**     Liefert die Anzahl Hinweise des letzten Laufs zur\xc3\xbc""ck             **
*************************************************************************/

_SCORING_EXPORT int lkf_plaus_GetInfoAnz (LKF_AUFENTHALT *pAufenthalt, int *accepted)
{ /* V13.1 */
	if (accepted) *accepted = pAufenthalt->akinfo_count;
	return pAufenthalt->plaus_info; 
}

/* function lkf_plaus_GetMeldeDiagAnz ***************************************
**     Liefert die Anzahl meldepflichtiger Diagnosen f\xc3\xbc""r diesen Aufenthalt **
*** V7.0 *******************************************************************/

_SCORING_EXPORT int  lkf_plaus_GetMeldeDiagAnz (LKF_AUFENTHALT *pAufenthalt)
{
	return pAufenthalt->melde_count;
}


const LKF_SATZART_ERRORDEF *lkf_plaus_getErrorDef (const LKF_CONTEXT *pContext, unsigned int nr)
{ /* Liefert die Error-Definition zur Nummer */
	if (pContext->pStamm2001 && pContext->pStamm2001->pMBDSErrors)
	{
		LKF_ERRORGROUP *pErrorGroup = pContext->pStamm2001->pMBDSErrors;
		if (pErrorGroup) {
			const LKF_SATZART_ERRORDEF *pErrorDef;
			if (((unsigned int) nr) <= pErrorGroup->errordefindex_count) /* V17.1 */
				pErrorDef = pErrorGroup->ppErrorDefIndex[nr];
			else pErrorDef = 0;		
			return pErrorDef;
		}
	}
	return 0;
}


/* function lkf_plaus_WarningCode2Text *********************************
**     Liefert zu einem Warning-Code den zugeh\xc3\xb6""rigen Text.            **
** Parameter:                                                         **
**     nr         Warning-Code                                        **
** Return:                                                            **
**     zugeh\xc3\xb6""riger Text oder NULL bei ung\xc3\xbc""ltigem Code                 **
***********************************************************************/

_SCORING_EXPORT const char * lkf_plaus_WarningCode2Text (LKF_CONTEXT *pContext, int nr)
{
	unsigned int nSev;

	if (pContext) {
		const LKF_SATZART_ERRORDEF *pErrorDef;
        pErrorDef = lkf_plaus_getErrorDef (pContext, (unsigned int)nr + LKF_WARNING_OFFSET);
		nSev = lkf_getSeverity (pContext, pErrorDef);
        if (pErrorDef && (nSev & LKF_SEV_WARNING))
            return lkf_context_formatted_text (pContext, pErrorDef->sText, pContext->errortext);
	}
    return "Unbekannte Warning";
}

_SCORING_EXPORT void lkf_getErrorCodeMinMax (const LKF_CONTEXT *pContext, unsigned int *emin, unsigned int *emax)
{
	if (pContext->pStamm2001 && pContext->pStamm2001->pMBDSErrors) {
        *emin = pContext->pStamm2001->pMBDSErrors->min_error;
        *emax = pContext->pStamm2001->pMBDSErrors->max_error;
	}
	else *emin = *emax = 0;
}

_SCORING_EXPORT void lkf_getWarningCodeMinMax (const LKF_CONTEXT *pContext, unsigned int *emin, unsigned int *emax)
{
    if (pContext->pStamm2001 && pContext->pStamm2001->pMBDSErrors) {
			*emin = pContext->pStamm2001->pMBDSErrors->min_warning;
			*emax = pContext->pStamm2001->pMBDSErrors->max_warning;
	}
	else *emin = *emax = 0;
}


#ifdef LKF_INCLUDE_DEPRECATED_FUNCTIONALITY

_SCORING_EXPORT unsigned int lkf_convertMBDSErrorCode (const LKF_CONTEXT *pContext, unsigned int olderrorcode)
{
	return 0;
}


_SCORING_EXPORT unsigned int lkf_convertMBDSWarningCode (const LKF_CONTEXT *pContext, unsigned int oldwarningcode)
{
	return 0;
}

_SCORING_EXPORT void lkf_get_errorcode_minmax (unsigned int *emin, unsigned int *emax)
{ /* bitte statt dieser Funktion lkf_getErrorCodeMinMax verwenden */
    *emin = 0;
    *emax = 0;
}

_SCORING_EXPORT void lkf_get_warningcode_minmax (unsigned int *wmin, unsigned int *wmax)
{ /* bitte statt dieser Funktion lkf_getWarningCodeMinMax verwenden */
    *wmin = 0;
    *wmax = 0;
}


#endif

_SCORING_EXPORT unsigned int lkf_context_errorcode_count (const LKF_CONTEXT *pContext, unsigned int ka, unsigned int code)
{
    if (pContext->pStamm2001 && pContext->pStamm2001->pMBDSErrors) {
		LKF_ERRORGROUP *pMBDSErrors = pContext->pStamm2001->pMBDSErrors;
		if (code >= pMBDSErrors->min_error && code <= pMBDSErrors->max_error)
			return pContext->ka[ka].error_counts[code - pMBDSErrors->min_error];
	}
	return 0;
}

_SCORING_EXPORT unsigned int lkf_context_warningcode_count (const LKF_CONTEXT *pContext, unsigned int ka, unsigned int code)
{
    if (pContext->pStamm2001 && pContext->pStamm2001->pMBDSErrors) {
		LKF_ERRORGROUP *pMBDSErrors = pContext->pStamm2001->pMBDSErrors;
		if (code >= pMBDSErrors->min_warning && code <= pMBDSErrors->max_warning)
			return pContext->ka[ka].warning_counts[code - pMBDSErrors->min_warning];
	}
	return 0;
}

_SCORING_EXPORT int lkf_plaus_WarningCode2Massnahme (const LKF_CONTEXT *pContext, int nr)
{
	if (pContext) {
		const LKF_SATZART_ERRORDEF *pErrorDef = lkf_plaus_getErrorDef (pContext, (unsigned int) nr + 100);
		if (pErrorDef) {
			unsigned int nSev = lkf_getSeverity (pContext, pErrorDef);
			if (nSev == LKF_SEV_WARNING_KORR) return MASSNAHME_KORR;
			else if (nSev == LKF_SEV_WARNING_PRUEF) return MASSNAHME_PRUEF;
			else return 0;
		}
		else return 0;
	}
    return 0;
}

/* function lkf_plaus_ErrorCode2Text ***********************************
**     Liefert zu einem Error-Code den zugeh\xc3\xb6""rigen Text.              **
** Parameter:                                                         **
**     nr         Error-Code                                          **
** Return:                                                            **
**     zugeh\xc3\xb6""riger Text oder NULL bei ung\xc3\xbc""ltigem Code                 **
***********************************************************************/

_SCORING_EXPORT const char * lkf_plaus_ErrorCode2Text (LKF_CONTEXT *pContext, int nr)
{
	unsigned int nSev;
	if (pContext) {
		const LKF_SATZART_ERRORDEF *pErrorDef = lkf_plaus_getErrorDef (pContext, (unsigned int) nr);
		nSev = lkf_getSeverity (pContext, pErrorDef);
		if (pErrorDef && (nSev & LKF_SEV_ERROR)) return lkf_context_formatted_text (pContext, pErrorDef->sText, pContext->sErrorBuf);
		else
            return "Unbekannter Error";
	}
    return 0;
}

/******************************************************************************************
** Liefert zur Meldepflichtnummer die zugeh\xc3\xb6""rige Meldepflicht                            **
******************************************************************************************/

_SCORING_EXPORT const char *lkf_plaus_meldediag_text (const LKF_CONTEXT *pContext, char nr)
{
	switch (nr)
	{
		case '1': return "Meldepflicht bei Erkrankung, Todesfall innerhalb einer Woche nach Diagnosestellung direkt an das Bundesministerium.";
		case '2': return "Meldepflicht bei Erkrankung, Todesfall innerhalb von 3 Tagen nach Diagnosestellung an zust\xc3\xa4""ndige Bezirksverwaltungsbeh\xc3\xb6""rde (Wohnsitz)";
		case '3': return "Meldepflicht bei Verdacht, Erkrankung, Todesfall innerhalb von 24 Stunden an zust\xc3\xa4""ndige Bezirksverwaltungsbeh\xc3\xb6""rde (Wohnsitz)";
		case '4': return "Meldepflicht bei Ausscheidern, Verdacht, Erkrankung, Todesfall innerhalb von 24 Stunden an zust\xc3\xa4""ndige Bezirksverwaltungsbeh\xc3\xb6""rde (Wohnsitz)";
		case '5': return "Meldepflicht bei Erkrankung, Todesfall innerhalb von 24 Stunden an zust\xc3\xa4""ndige Bezirksverwaltungsbeh\xc3\xb6""rde (Wohnsitz)";
		case '6': return "Meldepflicht bei Todesfall innerhalb von 24 Stunden an zust\xc3\xa4""ndige Bezirksverwaltungsbeh\xc3\xb6""rde (Wohnsitz)";
		case '7': return "monatliche anonymisierte Sammelmeldung (Anzahl der F\xc3\xa4""lle/Monat nach Wohnsitz) an zust\xc3\xa4""ndige Bezirksverwaltungsbeh\xc3\xb6""rde ";
		case '8': return "Meldepflicht bei Verdacht, Erkrankung, Todesfall innerhalb von 24 Stunden an zust\xc3\xa4""ndige Bezirksverwaltungsbeh\xc3\xb6""rde (Wohnsitz) sowie an die Bundesstaatliche bakteriologisch-serologische Untersuchungsanstalt Wien";
		default:  return "";
	}
}

_SCORING_EXPORT const char *lkf_plaus_meldediag_text_fmt(const LKF_CONTEXT *pContext, char nr, char *buf) {
	const char *v = lkf_plaus_meldediag_text(pContext, nr);
	if (v && *v)
	{
		if (pContext)
			return lkf_context_formatted_text(pContext, v, buf);
		else
			strcpy(buf, v);
	}
	else {
		buf[0] = 0;
	}
	return buf;
}

/******************************************************************************************
** Liefert zur Meldepflichtnummer den zugeh\xc3\xb6""rigen Typ                                    **
******************************************************************************************/

_SCORING_EXPORT const char *lkf_plaus_meldediag_typ (const LKF_CONTEXT *pContext, char nr)
{
	switch (nr)
	{
		case '1': return "AIDS";
		case '2': return "Tuberkulose ";
		case '3': return "Verdacht, Erkrankung, Todesfall";
		case '4': return "Ausscheider, Verdacht, Erkrankung, Todesfall";
		case '5': return "Erkrankung, Todesfall";
		case '6': return "Todesfall";
		case '7': return "Geschlechtskrankheiten (Unterliegen nicht der Meldepflicht)";
		case '8': return "Legionellen";
		 default: return "";
	}
}

_SCORING_EXPORT const char *lkf_plaus_meldediag_typ_fmt(const LKF_CONTEXT *pContext, char nr, char *buf) {
	const char *v = lkf_plaus_meldediag_typ(pContext, nr);
	if (*v)
	{
		if (pContext)
			return lkf_context_formatted_text(pContext, v, buf);
		else
			strcpy(buf, v);
	}
	else {
		buf[0] = 0;
	}
	return buf;
}

const char *FormatDate8 (const char *date8, char *destbuf)
{ /* konvertiert ein Datum von YYYYMMDD auf DD.MM.YYYY */
	static char buf[12];
	unsigned int i;
	if (!destbuf) destbuf = buf;
	for (i = 0; i < 8; i++) {
		if (!date8[i])
		{
			strcpy (destbuf, "  .  .    ");
		}
	}
	sprintf (destbuf, "%2.2s.%2.2s.%4.4s", date8 + 6, date8 + 4, date8);
	return destbuf;
}

/*********************************************************************************************************
** lkf_getErrorMBDSField:																			    **
**           Liefert zu einem bestimmten Error den Wert des zugeh\xc3\xb6""rigen Felds aus den Aufenthaltsdaten. **
*********************************************************************************************************/

_SCORING_EXPORT const char *lkf_getErrorMBDSField (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERROR *pError, char *text, unsigned int len)
{
	unsigned int errfield, erradd;
    int abtIndex; /* V20.1 */
    if (!pAufenthalt || !pError) {
        errfield = erradd = 0;
        abtIndex = -1;
    }
	else {
		errfield = pError->pErrorDef->nAddInfo;
		erradd = pError->nAddInfo;
        abtIndex = pError->nAbtIndex;
    }
	return lkf_getErrorMBDSFieldEx (pAufenthalt, errfield, erradd, text, len, abtIndex);
}

/**********************************************************************************************************
** lkf_getErrorMBDSIdent:                                                                                **
**      Liefert die Identifikation einer MBDS-Satzart-Zeile.                                             **
**********************************************************************************************************/

const char *lkf_getErrorMBDSIdent (LKF_AUFENTHALT *pAufenthalt, unsigned int errfield, unsigned int erradd, unsigned int len, char *text)
{
	char buf[50];

    switch (errfield) {
        default:
        case LKF_MBDSERROR_KANR:
        case LKF_MBDSERROR_ENTART:
        case LKF_MBDSERROR_AUFART:
        case LKF_MBDSERROR_NOINFO:
        case LKF_MBDSERROR_GEBDAT:
        case LKF_MBDSERROR_ENTDAT:
        case LKF_MBDSERROR_ENTZEIT:
        case LKF_MBDSERROR_ABRECHRELEVANZ:
        case LKF_MBDSERROR_SOZQUARTAL:
        case LKF_MBDSERROR_GEMEINDEZIFFER:
        case LKF_MBDSERROR_BEHANDLUNGSART:
        case LKF_MBDSERROR_TRANSPORTART:
        case LKF_MBDSERROR_PLZGEMCO:
        case LKF_MBDSERROR_AUFZEIT:
        case LKF_MBDSERROR_GESCHL:
        case LKF_MBDSERROR_ALTER:
        case LKF_MBDSERROR_STAATW:
        case LKF_MBDSERROR_STAATB:
        case LKF_MBDSERROR_PLZW:
        case LKF_MBDSERROR_GESVD:
        case LKF_MBDSERROR_AUFDAT:
        case LKF_MBDSERROR_KANR_VON:
        case LKF_MBDSERROR_KANR_AN:
        case LKF_MBDSERROR_AUFART2:
            if (SAFEIS2017ORLATER(pAufenthalt))
                strcpy (buf, "X01 MBDS");
            else
                strcpy (buf, "M01 MBDS");
            break;
        case LKF_MBDSERROR_ABTFC:
        case LKF_MBDSERROR_ABTDAT:
        case LKF_MBDSERROR_ABTID:
        case LKF_MBDSERROR_ABT:
        case LKF_MBDSERROR_IAUFART:
        case LKF_MBDSERROR_SAPSII :
        case LKF_MBDSERROR_ABTENTDAT:
        case LKF_MBDSERROR_ABTENTZEIT:
        case LKF_MBDSERROR_ABTZEIT:
        case LKF_MBDSERROR_AUFENTZEIT:
        case LKF_MBDSERROR_FACHFC:
        case LKF_MBDSERROR_PFLEGFC:
            if (!pAufenthalt->abt_anz) {
                strcpy (buf, "            ");
            }
            else if (SAFEIS2017ORLATER(pAufenthalt))
                sprintf (buf, "X02 %3.3s/%8.8s", pAufenthalt->abt[erradd].ABTPOS, pAufenthalt->abt[erradd].ABTFC);
            else
                sprintf (buf, "M02 %2.2s/%8.8s", pAufenthalt->abt[erradd].ABTPOS, pAufenthalt->abt[erradd].ABTFC);
            break;
        case LKF_MBDSERROR_NOINFO_M03:
            if (SAFEIS2017ORLATER(pAufenthalt))
                strcpy (buf, "X03 MBDS");
            else
                strcpy (buf, "M03 MBDS");
            break;
        case LKF_MBDSERROR_NOINFO_M04:
            if (SAFEIS2017ORLATER(pAufenthalt))
                strcpy (buf, "X04 MBDS");
            else
                strcpy (buf, "M04 MBDS");
            break;
        case LKF_MBDSERROR_NOINFO_M05:
            if (SAFEIS2017ORLATER(pAufenthalt))
                strcpy (buf, "X01 MBDS");
            else
                strcpy (buf, "M05 MBDS");
            break;
            
        case LKF_MBDSERROR_ZD:
            if (SAFEIS2017ORLATER(pAufenthalt))
                sprintf (buf, "X03 Z%6.6s", pAufenthalt->diag[erradd].DIAG);
            else
                sprintf (buf, "M03 Z%6.6s", pAufenthalt->diag[erradd].DIAG);
            break;
            
        case LKF_MBDSERROR_HD:
            if (SAFEIS2017ORLATER(pAufenthalt)) {
                if (erradd == 0 || pAufenthalt->diag_anz <= erradd) sprintf (buf, "X03 H%6.6s", pAufenthalt->HD);
                else sprintf (buf, "X03 H%6.6s", pAufenthalt->diag[erradd].DIAG);
            }
            else {
                if (erradd == 0 || pAufenthalt->diag_anz <= erradd) sprintf (buf, "M03 H%6.6s", pAufenthalt->HD);
                else sprintf (buf, "M03 H%6.6s", pAufenthalt->diag[erradd].DIAG);
            }
            break;
        case LKF_MBDSERROR_DIAG:
            sprintf (buf, "X03 %c%6.6s", pAufenthalt->diag[erradd].DIAGTYP[0], pAufenthalt->diag[erradd].DIAG);
			break;
		case LKF_MBDSERROR_ORIGMEL:
		case LKF_MBDSERROR_MEL:
        case LKF_MBDSERROR_MELFC:
        case LKF_MBDSERROR_MELKANR:
        case LKF_MBDSERROR_MELABT:
		case LKF_MBDSERROR_MELANZ:
		case LKF_MBDSERROR_MELDAT:
        case LKF_MBDSERROR_MELDATMEL:
            if (SAFEIS2017ORLATER(pAufenthalt))
                sprintf (buf, "X04 %-10.10s", pAufenthalt->mel[erradd].MEL);
            else
                sprintf (buf, "M04 %5.5s", pAufenthalt->mel[erradd].MEL); /* V20.1 */
            break;
		case LKF_MBDSERROR_KOST:
            if (SAFEIS2017ORLATER(pAufenthalt))
                strcpy (buf, "X01 MBDS");
            else
                strcpy (buf, "M05 KOST");
			break;
	}

	strncpy (text, buf, len);
	
	return text;
}

/***************************************************************************************************************************
** lkf_getErrorMBDSSatzart:                                                                                               **
**       Liefert die zu einem MBDS-Error geh\xc3\xb6""rende Satzart.                                                               **
***************************************************************************************************************************/

const char *lkf_getErrorMBDSSatzart (LKF_AUFENTHALT *pAufenthalt, unsigned int errfield, unsigned int len, char *text)
{

	const char *satzart;

	switch (errfield) {
		default:
		case LKF_MBDSERROR_KANR:
		case LKF_MBDSERROR_ENTART:
		case LKF_MBDSERROR_AUFART:
		case LKF_MBDSERROR_NOINFO:
		case LKF_MBDSERROR_GEBDAT:
		case LKF_MBDSERROR_ENTDAT:
        case LKF_MBDSERROR_ENTZEIT:
        case LKF_MBDSERROR_ABRECHRELEVANZ:
        case LKF_MBDSERROR_SOZQUARTAL:
        case LKF_MBDSERROR_GEMEINDEZIFFER:
        case LKF_MBDSERROR_BEHANDLUNGSART:
        case LKF_MBDSERROR_TRANSPORTART:
        case LKF_MBDSERROR_PLZGEMCO:
        case LKF_MBDSERROR_AUFZEIT:
        case LKF_MBDSERROR_GESCHL:
		case LKF_MBDSERROR_ALTER:
		case LKF_MBDSERROR_STAATW:
		case LKF_MBDSERROR_STAATB:
		case LKF_MBDSERROR_PLZW:
		case LKF_MBDSERROR_GESVD:
		case LKF_MBDSERROR_AUFDAT:
		case LKF_MBDSERROR_KANR_VON:
		case LKF_MBDSERROR_KANR_AN:
		case LKF_MBDSERROR_AUFART2:
            satzart = SAFEIS2017ORLATER(pAufenthalt) ? "X01" : "M01";
			break;
		case LKF_MBDSERROR_ABTFC:
		case LKF_MBDSERROR_ABTDAT:
		case LKF_MBDSERROR_ABTID:
		case LKF_MBDSERROR_ABT:
		case LKF_MBDSERROR_IAUFART:
		case LKF_MBDSERROR_SAPSII :
		case LKF_MBDSERROR_ABTENTDAT:
		case LKF_MBDSERROR_ABTENTZEIT:
		case LKF_MBDSERROR_ABTZEIT:
		case LKF_MBDSERROR_AUFENTZEIT:
        case LKF_MBDSERROR_PFLEGFC:
        case LKF_MBDSERROR_FACHFC:
			satzart = SAFEIS2017ORLATER(pAufenthalt) ? "X02" :"M02";
			break;
		case LKF_MBDSERROR_ZD:
		case LKF_MBDSERROR_HD:
		case LKF_MBDSERROR_DIAG:
		case LKF_MBDSERROR_NOINFO_M03:
			satzart = SAFEIS2017ORLATER(pAufenthalt) ? "X03" :"M03";
			break;
		case LKF_MBDSERROR_ORIGMEL:
		case LKF_MBDSERROR_MEL:
		case LKF_MBDSERROR_MELANZ:
		case LKF_MBDSERROR_MELDAT:
        case LKF_MBDSERROR_MELDATMEL:
		case LKF_MBDSERROR_NOINFO_M04:
        case LKF_MBDSERROR_MELABT:
        case LKF_MBDSERROR_MELFC:
        case LKF_MBDSERROR_MELKANR:
			satzart = SAFEIS2017ORLATER(pAufenthalt) ? "X04" :"M04";
			break;
		case LKF_MBDSERROR_KOST:
		case LKF_MBDSERROR_NOINFO_M05:
            satzart = SAFEIS2017ORLATER(pAufenthalt) ? "X01" : "M05";
            break;
            
	}
    

	strncpy (text, satzart, len);
    if (len > 3) text[3] = 0;

	return text;
}

const char *lkf_getErrorMBDSFieldId (const LKF_CONTEXT *pContext, unsigned int errfield)
{
	switch (errfield) {
		default:
		case LKF_MBDSERROR_NOINFO_M03:
		case LKF_MBDSERROR_NOINFO_M04:
		case LKF_MBDSERROR_NOINFO_M05:
		case LKF_MBDSERROR_NOINFO:		return "";
		case LKF_MBDSERROR_GEBDAT:		return "GEBDAT";
		case LKF_MBDSERROR_ENTDAT:		return "ENTDAT";
        case LKF_MBDSERROR_ENTZEIT:     return "ENTZEIT"; /* V21.0 */
        case LKF_MBDSERROR_GEMEINDEZIFFER:
                                        return "GEMEINDECODE"; /* V21.0 */
        case LKF_MBDSERROR_BEHANDLUNGSART:
                                        return "BEHANDLUNGSART"; /* V21.2 */
        case LKF_MBDSERROR_TRANSPORTART:
                                        return "TRANSPORTART"; /* V21.2 */
        case LKF_MBDSERROR_PLZGEMCO:
                                        return "PLZ/GEMCO"; /* V21.2 */
        case LKF_MBDSERROR_ABRECHRELEVANZ:
                                        return "RELEVANZ"; /* V21.0 */
        case LKF_MBDSERROR_FACHFC:
                                        return "FACHFC"; /* V21.0 */
        case LKF_MBDSERROR_PFLEGFC:
                                        return "PFLEGEFC"; /* V21.0 */
        case LKF_MBDSERROR_SOZQUARTAL:
                                        return "SOZQUARTAL"; /* V21.0 */
        case LKF_MBDSERROR_AUFZEIT:
                                        return "AUFZEIT"; /* V21.0 */
        case LKF_MBDSERROR_ABTDAT:		return "ABTDAT";
		case LKF_MBDSERROR_GESCHL:		return "GESCHL";
		case LKF_MBDSERROR_AUFART:		return "AUFART";
		case LKF_MBDSERROR_ENTART:		return "ENTART";
		case LKF_MBDSERROR_ABTFC:		return "ABTFC";
		case LKF_MBDSERROR_HD:			return "HD";
		case LKF_MBDSERROR_ZD:			return "ZD";
		case LKF_MBDSERROR_MEL:			return "MEL";
        case LKF_MBDSERROR_MELABT:      return "ABT:MEL";
        case LKF_MBDSERROR_MELFC:       return "MELFC";
        case LKF_MBDSERROR_MELKANR:     return "MELKANR";
		case LKF_MBDSERROR_MELANZ:		return "MELANZ";
		case LKF_MBDSERROR_MELDAT:		return "MELDAT";
        case LKF_MBDSERROR_MELDATMEL:   return "MELDAT:MEL";
		case LKF_MBDSERROR_KANR:		return "KANR";
		case LKF_MBDSERROR_KANR_VON:
										return "KANR_VON";
		case LKF_MBDSERROR_KANR_AN:
										return "KANR_AN";
		case LKF_MBDSERROR_AUFART2:
										return "AUFART2";
		case LKF_MBDSERROR_ALTER:		return "ALTER";
		case LKF_MBDSERROR_STAATW:		return "STAATW";
		case LKF_MBDSERROR_STAATB:		return "STAATB";
		case LKF_MBDSERROR_PLZW:		return "PLZW";
		case LKF_MBDSERROR_KOST:		return "KOST";
		case LKF_MBDSERROR_ORIGMEL:		return "MEL";
		case LKF_MBDSERROR_GESVD:		return "GESVD";
		case LKF_MBDSERROR_ABT:			return "ABT";
		case LKF_MBDSERROR_ABTID:		return "ABTID";
		case LKF_MBDSERROR_AUFDAT:		return "AUFDAT";
		case LKF_MBDSERROR_DIAG:		return "DIAG";
		case LKF_MBDSERROR_IAUFART:		return "INTAUFART";
		case LKF_MBDSERROR_SAPSII :		return "SAPSII";
		case LKF_MBDSERROR_ABTENTDAT:	return "ABTENTDAT";
		case LKF_MBDSERROR_ABTENTZEIT:	return "ABTENTZEIT";
		case LKF_MBDSERROR_ABTZEIT:		return "ABTZEIT";
		case LKF_MBDSERROR_AUFENTZEIT:  return "AUFENTZEIT";

	}
}

char *lkf_format_abtpos(LKF_AUFENTHALT_ABT *pAbt, char *buf)
{ /* V21.2 */
	sprintf(buf, "%03d", pAbt->abtposNumeric);
	return buf;
}

char*lkf_format_abtpos_string (const char *ABTPOS, char *buf)
{ /* V21.2 */
    int abtpos_numeric = atoi (ABTPOS);
    sprintf(buf, "%03d", abtpos_numeric);
    return buf;
    
}

const char *lkf_getErrorMBDSFieldEx (LKF_AUFENTHALT *pAufenthalt, unsigned int errfield, unsigned int erradd, char *text, unsigned int len, int abtIndex /* V20.1 */)
{
	char errbuf[20], datfield[12];
	char abtposbuf[4] /* V21.2 */;


	switch (errfield) {
		default:
		case LKF_MBDSERROR_NOINFO_M03:
		case LKF_MBDSERROR_NOINFO_M04:
		case LKF_MBDSERROR_NOINFO_M05:
		case LKF_MBDSERROR_NOINFO:
			strcpy (errbuf, "            "); 
			break;
		case LKF_MBDSERROR_GEBDAT:
			sprintf (errbuf, "%s  ", FormatDate8 (pAufenthalt->GEBDAT, datfield));
			break;
		case LKF_MBDSERROR_ENTDAT:
			sprintf (errbuf, "%s  ", FormatDate8 (pAufenthalt->ENTDAT, datfield));
			break;
        case LKF_MBDSERROR_ENTZEIT:
            sprintf(errbuf, "%4.4s      ", pAufenthalt->ENTZEIT);
            break;
        case LKF_MBDSERROR_ABRECHRELEVANZ:
            sprintf(errbuf, "%c           ", pAufenthalt->ABRECH_RELEVANT);
            break;
        case LKF_MBDSERROR_SOZQUARTAL:
            sprintf(errbuf, "%5.5s     ", pAufenthalt->ABRECH_QUARTAL);
            break;
        case LKF_MBDSERROR_AUFZEIT:
            sprintf(errbuf, "%4.4s      ", pAufenthalt->AUFZEIT);
            break;
        case LKF_MBDSERROR_GEMEINDEZIFFER:
            sprintf(errbuf, "%-5.5s     ", pAufenthalt->GEMEINDEZIFFER);
            break;
        case LKF_MBDSERROR_BEHANDLUNGSART:
            sprintf(errbuf, "%c         ", pAufenthalt->BEHANDLUNGSART);
            break;
        case LKF_MBDSERROR_TRANSPORTART:
            sprintf(errbuf, "%c         ", pAufenthalt->TRANSPORTART);
            break;
        case LKF_MBDSERROR_PLZGEMCO:
            sprintf(errbuf, "%-4.4s/%-5.5s", pAufenthalt->PLZW, pAufenthalt->GEMEINDEZIFFER);
            break;
        case LKF_MBDSERROR_ABTDAT:
            if (!pAufenthalt->abt_anz) {
                strcpy (errbuf, "            ");
            }
            else if (SAFEIS2017ORLATER(pAufenthalt))
                sprintf (errbuf, "%3.3s: %s", lkf_format_abtpos(pAufenthalt->abt + erradd, abtposbuf), FormatDate8 (pAufenthalt->abt[erradd].ABTDAT, datfield));
            else
                sprintf (errbuf, "%2.2s: %s", pAufenthalt->abt[erradd].ABTPOS, FormatDate8 (pAufenthalt->abt[erradd].ABTDAT, datfield));
			break;
		case LKF_MBDSERROR_GESCHL:
			sprintf (errbuf, "%c           ", pAufenthalt->GESCHL);
			break;
		case LKF_MBDSERROR_AUFART:
			sprintf (errbuf, "%c           ", pAufenthalt->AUFART);
			break;
		case LKF_MBDSERROR_ENTART:
			sprintf (errbuf, "%c           ", pAufenthalt->ENTART);
			break;
		case LKF_MBDSERROR_ABTFC:
			sprintf (errbuf, "%8.8s    ", pAufenthalt->abt[erradd].ABTFC);
			break;
		case LKF_MBDSERROR_HD:
            if (erradd == 0 || pAufenthalt->diag_anz <= erradd) sprintf (errbuf, "%6.6s      ", pAufenthalt->HD);
            else sprintf (errbuf, "%6.6s      ", pAufenthalt->diag[erradd].DIAG);
            break;

		case LKF_MBDSERROR_ZD:
			sprintf (errbuf, "%6.6s      ", pAufenthalt->diag[erradd].DIAG);
			break;
        case LKF_MBDSERROR_MEL:
			if (SAFEEXPORTMELPOS(pAufenthalt) && !IsBlank (pAufenthalt->mel[erradd].MELPOS, 4)) {
				sprintf (errbuf, "%5.5s:%-4.4s  ", pAufenthalt->mel[erradd].ORIG_MEL, pAufenthalt->mel[erradd].MELPOS);
			}
            else if (SAFEIS2017ORLATER(pAufenthalt)) {
                sprintf (errbuf, "%5.5s       ", pAufenthalt->mel[erradd].ORIG_MEL);
            }
            else
				sprintf (errbuf, "%10.10s  ", pAufenthalt->mel[erradd].ORIG_MEL);
			break;
        case LKF_MBDSERROR_MELFC:
            if (SAFEEXPORTMELPOS(pAufenthalt) && !IsBlank (pAufenthalt->mel[erradd].MELPOS, 4)) {
                sprintf (errbuf, "%-8.8s:%-4.4s  ", pAufenthalt->mel[erradd].FCLEIST, pAufenthalt->mel[erradd].MELPOS);
            }
            else {
                sprintf (errbuf, "%-8.8s     ", pAufenthalt->mel[erradd].FCLEIST);
            }
            break;
        case LKF_MBDSERROR_MELKANR:
            if (SAFEEXPORTMELPOS(pAufenthalt) && !IsBlank (pAufenthalt->mel[erradd].MELPOS, 4)) {
                sprintf (errbuf, "%-4.4s:%-4.4s  ", pAufenthalt->mel[erradd].KALEIST, pAufenthalt->mel[erradd].MELPOS);
            }
            else {
                sprintf (errbuf, "%-6.6s     ", pAufenthalt->mel[erradd].KALEIST);
            }
            break;
        case LKF_MBDSERROR_MELABT:
            if (SAFEEXPORTMELPOS(pAufenthalt) && !IsBlank (pAufenthalt->mel[erradd].MELPOS, 4)) {
                sprintf (errbuf, "%5.5s:%-4.4s  ", pAufenthalt->mel[erradd].ORIG_MEL, pAufenthalt->mel[erradd].MELPOS);
            }
            else if (abtIndex >= 0) {
                if (SAFEIS2017ORLATER(pAufenthalt))
                    sprintf (errbuf, "%3.3s:%-10.10s  ", lkf_format_abtpos(pAufenthalt->abt + abtIndex, abtposbuf), pAufenthalt->mel[erradd].ORIG_MEL);
                else
                    sprintf (errbuf, "%2.2s:%5.5s   ", pAufenthalt->abt[abtIndex].ABTPOS, pAufenthalt->mel[erradd].ORIG_MEL);
            }
            else if (SAFEIS2017ORLATER(pAufenthalt)) {
                sprintf (errbuf, "%5.5s       ", pAufenthalt->mel[erradd].ORIG_MEL);
            }
            else
                sprintf (errbuf, "%10.10s  ", pAufenthalt->mel[erradd].ORIG_MEL);
            break;
		case LKF_MBDSERROR_MELANZ:
			sprintf (errbuf, "%4.4s        ", pAufenthalt->mel[erradd].MELANZ);
			break;
		case LKF_MBDSERROR_MELDAT:
			sprintf (errbuf, "%s  ", FormatDate8 (pAufenthalt->mel[erradd].MELDAT, datfield));
			break;
        case LKF_MBDSERROR_MELDATMEL:
            sprintf (errbuf, "%s:%5.5s  ", FormatDate8 (pAufenthalt->mel[erradd].MELDAT, datfield), pAufenthalt->mel[erradd].MEL);
            break;
		case LKF_MBDSERROR_KANR:
			sprintf (errbuf, "%4.4s        ", pAufenthalt->KANR);
			break;
		case LKF_MBDSERROR_KANR_VON:
			sprintf (errbuf, "%4.4s        ", pAufenthalt->KANR_VON);
			break;
		case LKF_MBDSERROR_KANR_AN:
			sprintf (errbuf, "%4.4s        ", pAufenthalt->KANR_AN);
			break;
		case LKF_MBDSERROR_AUFART2:
			sprintf (errbuf, "%c           ", pAufenthalt->AUFART2);
			break;
		case LKF_MBDSERROR_ALTER:
			sprintf (errbuf, "%-10d  ", pAufenthalt->Alter);
			break;
		case LKF_MBDSERROR_STAATW:
			sprintf (errbuf, "%3.3s         ", pAufenthalt->STAATW);
			break;
		case LKF_MBDSERROR_STAATB:
			sprintf (errbuf, "%3.3s         ", pAufenthalt->STAATB);
			break;
		case LKF_MBDSERROR_PLZW:
			sprintf (errbuf, "%6.6s      ", pAufenthalt->PLZW);
			break;
		case LKF_MBDSERROR_KOST:
			sprintf (errbuf, "%2.2s          ", pAufenthalt->KOST);
			break;
		case LKF_MBDSERROR_ORIGMEL:
            sprintf (errbuf, "%5.5s       ", pAufenthalt->mel[erradd].MEL);
			break;
		case LKF_MBDSERROR_GESVD:
			sprintf (errbuf, "%-9ld   ", pAufenthalt->GESVD + pAufenthalt->GESVD_KORR);
			break;
		case LKF_MBDSERROR_ABT:
		case LKF_MBDSERROR_ABTID:
            if (pAufenthalt->abt_anz == 0) {
                strcpy (errbuf, "            ");
            }
			else if (SAFEIS2017ORLATER(pAufenthalt))
				sprintf(errbuf, "%3.3s         ", lkf_format_abtpos(pAufenthalt->abt + erradd, abtposbuf));
			else
				sprintf(errbuf, "%2.2s          ", pAufenthalt->abt[erradd].ABTPOS);
			break;
        case LKF_MBDSERROR_FACHFC:
            sprintf (errbuf, "%8.8s    ", pAufenthalt->abt[erradd].FACHFC);
            break;
        case LKF_MBDSERROR_PFLEGFC:
            sprintf (errbuf, "%8.8s    ", pAufenthalt->abt[erradd].PFLEGFC);
            break;
        case LKF_MBDSERROR_AUFDAT:
			sprintf (errbuf, "%s  ", FormatDate8 (pAufenthalt->AUFDAT, datfield));
			break;
		case LKF_MBDSERROR_DIAG:
			sprintf (errbuf, "%6.6s      ", pAufenthalt->diag[erradd].DIAG);
			break;
		case LKF_MBDSERROR_ABTZEIT:
            
            if (SAFEIS2017ORLATER(pAufenthalt)) {
                sprintf (errbuf, "%3.3s: %2.02s.%2.02s   ", lkf_format_abtpos (pAufenthalt->abt + erradd, abtposbuf), pAufenthalt->abt[erradd].ABTZEIT, pAufenthalt->abt[erradd].ABTZEIT + 2);
            }
            else {
                sprintf (errbuf, "%2.2s: %2.02s.%2.02s   ", pAufenthalt->abt[erradd].ABTPOS, pAufenthalt->abt[erradd].ABT_INTSATZ, pAufenthalt->abt[erradd].ABT_INTSATZ+2);
            }
            break;
		case LKF_MBDSERROR_AUFENTZEIT:
            
            if (SAFEIS2017ORLATER(pAufenthalt)) {
                sprintf (errbuf, "%3.3s: %4.4s%4.4s  ", lkf_format_abtpos(pAufenthalt->abt + erradd, abtposbuf), pAufenthalt->abt[erradd].ABTZEIT, pAufenthalt->abt[erradd].ENTZEIT);
            }
			else if (pAufenthalt->pScoringContext->modelljahr >= 2012 && (pAufenthalt->pScoringContext->flags & LKFCONTEXT_NICHTFONDSKA))
				sprintf (errbuf, "%2.2s%4.4s%4.4s  ", pAufenthalt->abt[erradd].ABTPOS, pAufenthalt->abt[erradd].ABT_INTSATZ, pAufenthalt->abt[erradd].ABT_INTSATZ + 34 - 22);
			else
				sprintf (errbuf, "%2.2s%4.4s%4.4s  ", pAufenthalt->abt[erradd].ABTPOS, pAufenthalt->abt[erradd].ABT_INTSATZ, pAufenthalt->abt[erradd].ABT_INTSATZ + 34);
			break;
		case LKF_MBDSERROR_IAUFART:
            if (SAFEIS2017ORLATER(pAufenthalt)) {
                /* wird nach 2012 nicht mehr ausgeloest */
                sprintf (errbuf, "%3.3s: %c      ", lkf_format_abtpos(pAufenthalt->abt + erradd, abtposbuf), '?');
            }
            else {
                sprintf (errbuf, "%2.2s: %c       ", pAufenthalt->abt[erradd].ABTPOS, pAufenthalt->abt[erradd].ABT_INTSATZ[4]);
            }
            break;
		case LKF_MBDSERROR_SAPSII :
            if (SAFEIS2017ORLATER(pAufenthalt)) {
                /* wird nach 2012 nicht mehr ausgeloest */
                sprintf (errbuf, "%3.3s: %c      ", lkf_format_abtpos(pAufenthalt->abt + erradd, abtposbuf), '?');
            }
            else {
                sprintf (errbuf, "%2.2s: %c       ", pAufenthalt->abt[erradd].ABTPOS, pAufenthalt->abt[erradd].ABT_INTSATZ[5]);
            }
			break;
		case LKF_MBDSERROR_ABTENTDAT:
            if (SAFEIS2017ORLATER(pAufenthalt)) {
                sprintf (errbuf, "%3.3s: %s ", lkf_format_abtpos(pAufenthalt->abt + erradd, abtposbuf), FormatDate8 (pAufenthalt->abt[erradd].ENTDAT, datfield));
            }
			else if (pAufenthalt->pScoringContext->modelljahr >= 2012 && (pAufenthalt->pScoringContext->flags & LKFCONTEXT_NICHTFONDSKA))
				sprintf (errbuf, "%2.2s: %s ", pAufenthalt->abt[erradd].ABTPOS, FormatDate8 (pAufenthalt->abt[erradd].ABT_INTSATZ + 26 - 22, datfield));
			else
				sprintf (errbuf, "%2.2s: %s ", pAufenthalt->abt[erradd].ABTPOS, FormatDate8 (pAufenthalt->abt[erradd].ABT_INTSATZ + 26, datfield));
			break;
		case LKF_MBDSERROR_ABTENTZEIT:
            if (SAFEIS2017ORLATER(pAufenthalt)) {
                sprintf (errbuf, "%3.3s: %2.02s.%2.02s   ", lkf_format_abtpos(pAufenthalt->abt + erradd, abtposbuf), pAufenthalt->abt[erradd].ENTZEIT, pAufenthalt->abt[erradd].ENTZEIT + 2);
            }
			else if (pAufenthalt->pScoringContext->modelljahr >= 2012 && (pAufenthalt->pScoringContext->flags & LKFCONTEXT_NICHTFONDSKA))
				sprintf (errbuf, "%2.2s: %2.02s.%2.02s   ", pAufenthalt->abt[erradd].ABTPOS, pAufenthalt->abt[erradd].ABT_INTSATZ + 34 - 22, pAufenthalt->abt[erradd].ABT_INTSATZ + 36 - 22);
			else
				sprintf (errbuf, "%2.2s: %2.02s.%2.02s   ", pAufenthalt->abt[erradd].ABTPOS, pAufenthalt->abt[erradd].ABT_INTSATZ + 34, pAufenthalt->abt[erradd].ABT_INTSATZ + 36);
			break;
	}

	strncpy (text, errbuf, len);

	if (len > 18) text[18] = 0;
	else text[len-1] = 0;

	return text;
}


_SCORING_EXPORT int lkf_plaus_GetErrorText (LKF_AUFENTHALT *pAufenthalt, const LKF_ERROR_LIST *pError, char *text, int len)
{
	int i;
	char errbuf[20];
	char errtxtbuf[200];
	char logbuf[600];

	char entdat[12], aufdat[12], gebdat[12];
	char entabt[9];
	char errornumbuf[10];

	if (!lkf_plaus_GetErrorText4 (pAufenthalt, pError, errtxtbuf, errbuf)) return 0;

	FormatDate8 (pAufenthalt->GEBDAT, gebdat);
	if (pAufenthalt->abt_anz) FormatDate8 (pAufenthalt->abt[0].ABTDAT, aufdat);
	else FormatDate8 ("        ", aufdat);
	FormatDate8 (pAufenthalt->ENTDAT, entdat);

	/* Ermittle Entlassungsabteilung */
	for (i = (int) pAufenthalt->abt_anz - 1; i >= 0 && IsEmpty (pAufenthalt->abt[i].ABTFC, 8); i--) ;
	if (i >= 0) memcpy (entabt, pAufenthalt->abt[i].ABTFC, 8);
	else memset (entabt, ' ', 8);
	entabt[8] = 0;

	if (pError->nNewError >= 0) {
		const LKF_SATZART_ERROR *pSatzartError = pAufenthalt->pScoringContext->pSatzartErrors->pErrors + pError->nNewError;
        lkf_getErrorIdent (pAufenthalt->pScoringContext, pSatzartError->pErrorDef, 10, errornumbuf);
	}
	else {
		strcpy (errornumbuf, "E???");
	}

	sprintf (logbuf, "%4.4s       ; %10.10s ; %s ; %c      ; %s ; %s ; %s ; %s; %-4.4s      ; * %s *",
				pAufenthalt->KANR, pAufenthalt->PATID, gebdat, pAufenthalt->GESCHL, aufdat, entdat, entabt, errbuf, errornumbuf, errtxtbuf);

	i = (int) strlen (logbuf);

	if (i < len) {
		memcpy (text, logbuf, i);
		text[i] = 0;

	}
	else {
		memcpy (text, logbuf, len - 1);
		text[len-1] = 0;
	}
	return 1;
}

/* function Plaus_GetWarningText ****************************************
**     Analoge Funktion zu Plaus_GetErrorText f\xc3\xbc""r Warnings             **
************************************************************************/

_SCORING_EXPORT int lkf_plaus_GetWarningText (LKF_AUFENTHALT *pAufenthalt, const LKF_ERROR_LIST *pError, char *text, int len)
{

	static const char *massnahme[] = {"?????????", "Korrektur", "Pr\xc3\xbc""fung  "};
	unsigned int nSev;
	int i;
	char errbuf[20];
	char logbuf[600];
	char errtxtbuf[200];

	char entdat[12], aufdat[12], gebdat[12];
	char entabt[9];
	char warningnumbuf[10], massnahme_int;

	if (!lkf_plaus_GetWarningText4 (pAufenthalt, pError, errtxtbuf, errbuf)) return 0; 

	FormatDate8 (pAufenthalt->GEBDAT, gebdat);
	FormatDate8 (pAufenthalt->AUFDAT, aufdat);
	FormatDate8 (pAufenthalt->ENTDAT, entdat);

	/* Ermittle Entlassungsabteilung */
	for (i = (int) pAufenthalt->abt_anz - 1; i >= 0 && IsEmpty (pAufenthalt->abt[i].ABTFC, 8); i--) ;
	if (i >= 0) memcpy (entabt, pAufenthalt->abt[i].ABTFC, 8);
	else memset (entabt, ' ', 8);
	entabt[8] = 0;

	if (pError->nNewError >= 0) {
		const LKF_SATZART_ERROR *pSatzartError = pAufenthalt->pScoringContext->pSatzartErrors->pErrors + pError->nNewError;
        lkf_getErrorIdent (pAufenthalt->pScoringContext, pSatzartError->pErrorDef, 10, warningnumbuf);
		nSev = lkf_getSeverity (pAufenthalt->pScoringContext, pSatzartError->pErrorDef);
		if (nSev & LKF_SEV_WARNING_PRUEF) massnahme_int = 2;
		else if (nSev & LKF_SEV_WARNING_KORR) massnahme_int = 1;
		else massnahme_int = 0;
	}
	else {
		strcpy (warningnumbuf, "W???");
        massnahme_int = 0;
	}

	sprintf (logbuf, "%4.4s       ; %10.10s ; %s ; %c      ; %s ; %s ; %s ; %s ; %s; %4.4s      ; ??? %s ???",
				pAufenthalt->KANR, pAufenthalt->PATID, gebdat, pAufenthalt->GESCHL, aufdat, entdat, entabt, 
				massnahme[massnahme_int], errbuf, warningnumbuf, errtxtbuf);

	i = (int) strlen (logbuf);

	if (i < len) {
		memcpy (text, logbuf, i);
		text[i] = 0;
	}
	else {
		memcpy (text, logbuf, len-1);
		text[len -1] = 0;
	}
	return 1;
}

/**************************************************************************
** function lkf_plaus_GetMeldeDiagText:                                  **
**    Liefert fuer eine meldepflichtige Diagnose die Meldezeile zurueck. **
**************************************************************************/

_SCORING_EXPORT int  lkf_plaus_GetMeldeDiagText (LKF_AUFENTHALT *pAufenthalt, const LKF_ERROR_LIST *pMeldeDiag, char *text, int len)
{
	char buf[2048];
    char targetText[512];
	char diag[10], diagtype[6];

	lkf_auf_get_diag (pAufenthalt, (unsigned int) pMeldeDiag->index, diag, diagtype);
    
    if (pAufenthalt->pScoringContext) {
		if (pAufenthalt->pScoringContext->modelljahr >= 2017)
	        sprintf (buf, "%4.4s       ; %-12.12s ; %-6.6s     ; %s", pAufenthalt->KANR, pAufenthalt->PATID, diag,
                 lkf_context_formatted_text (pAufenthalt->pScoringContext, lkf_plaus_meldediag_text (pAufenthalt->pScoringContext, (char) pMeldeDiag->code), targetText));
		else
			sprintf(buf, "%4.4s       ; %-10.10s ; %-6.6s     ; %s", pAufenthalt->KANR, pAufenthalt->PATID, diag,
				lkf_context_formatted_text(pAufenthalt->pScoringContext, lkf_plaus_meldediag_text(pAufenthalt->pScoringContext, (char)pMeldeDiag->code), targetText));
    }
    else {
        sprintf (buf, "%4.4s       ; %-10.10s ; %-6.6s     ; %s", pAufenthalt->KANR, pAufenthalt->PATID, diag,
                 lkf_plaus_meldediag_text (pAufenthalt->pScoringContext, (char) pMeldeDiag->code));
    }
    

	strncpy (text, buf, len);
	text[len-1] = 0;

	return 1;
}


/* procedure Insert_NewError *************************************************
**    Traegt eine Fehlermeldung in die angegebene Fehlerliste ein            **
*****************************************************************************/

static int Insert_NewError (int errorindex, LKF_ERROR_LIST **ppFirst, LKF_ERROR_LIST **ppLast, LKF_CONTEXT *pContext)
{
	LKF_ERROR_LIST *pNew = (LKF_ERROR_LIST *) LKF_MALLOC (pContext, "Insert_NewError", sizeof (LKF_ERROR_LIST));

    if (!pNew) return LKF_OUTOFMEMORY_ERROR;
	if (!*ppFirst) *ppFirst = *ppLast = pNew;
	else *ppLast = (*ppLast)->next = pNew; 

	pNew->code = 0;
	pNew->index = 0;
	pNew->next = 0;
	pNew->nNewError = errorindex;
	pNew->pContext = pContext;
    return 0;
}

/* procedure Plaus_Error *************************************************
**    Traegt eine Fehlermeldung in die Fehlerliste ein                  **
*************************************************************************/

static void *storeAcceptedValue (LKF_AUFENTHALT *pAufenthalt, unsigned int akwarnIndex, const char *value) {
    if (!pAufenthalt->akwarn[akwarnIndex].nHitCount) {
        strncpy (pAufenthalt->akwarn[akwarnIndex].acceptedValue, value, 21);
        pAufenthalt->akwarn[akwarnIndex].acceptedValue[20] = 0;
        pAufenthalt->akwarn[akwarnIndex].nHitCount++;
    }
    else if (!strcmp (pAufenthalt->akwarn[akwarnIndex].acceptedValue, value) || !(pAufenthalt->pScoringContext->flags & LKFCONTEXT_AKWARNREPLACEVALUE)) {
        pAufenthalt->akwarn[akwarnIndex].nHitCount++;
    }
    else {
        unsigned int followUp = pAufenthalt->akwarn[akwarnIndex].followUpIndex;
        unsigned int lastIndex = akwarnIndex;
        while (followUp) {
            if (!strcmp (pAufenthalt->akwarn[followUp].acceptedValue, value)) {
                pAufenthalt->akwarn[followUp].nHitCount++;
                return pAufenthalt->akwarn + followUp;
            }
            followUp = pAufenthalt->akwarn[lastIndex = followUp].followUpIndex;
        }
        
        if (pAufenthalt->akwarn_alloc == pAufenthalt->akwarn_anz) {
            pAufenthalt->akwarn = LKF_REALLOC (pAufenthalt->pScoringContext, "storeAcceptedValue", pAufenthalt->akwarn, sizeof (LKF_AUFENTHALT_AKWARN) * (pAufenthalt->akwarn_alloc += 5));
            if (!pAufenthalt->akwarn) {
                return 0;
            }
        }

        memcpy (pAufenthalt->akwarn + pAufenthalt->akwarn_anz, pAufenthalt->akwarn + akwarnIndex, sizeof ( LKF_AUFENTHALT_AKWARN));
        pAufenthalt->akwarn[lastIndex].followUpIndex = pAufenthalt->akwarn_anz;
        pAufenthalt->akwarn[pAufenthalt->akwarn_anz].followUpIndex = 0;
        pAufenthalt->akwarn[pAufenthalt->akwarn_anz].value[0] = 0;
        strncpy (pAufenthalt->akwarn[pAufenthalt->akwarn_anz].acceptedValue, value, 21);
        pAufenthalt->akwarn[pAufenthalt->akwarn_anz].nHitCount++;
        pAufenthalt->akwarn_anz++;
    }
    return pAufenthalt->akwarn + akwarnIndex;
}

static void *checkAcceptedWarning2017 (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef, const char *value, int flag)
{ /* V21.2 */
    unsigned int i;
    char sErrorIdent[5];
	int valueLength;
	char trimmedValue[21];
	strncpy (trimmedValue, value, 20);
	trimmedValue[20] = 0;

	valueLength = (int) strlen (trimmedValue);

	while (valueLength > 0 && trimmedValue[valueLength-1] == ' ') --valueLength;
	trimmedValue[valueLength] = 0;

    lkf_getErrorIdent (pAufenthalt->pScoringContext, pErrorDef, 5, sErrorIdent);
    
    for (i = 0; i < pAufenthalt->akwarn_anz; i++)
    {
        if (!memcmp (pAufenthalt->akwarn[i].s4DigitCode, sErrorIdent, 4)) {
            
            if (!strcmp (trimmedValue, pAufenthalt->akwarn[i].value))
            {
                pAufenthalt->akwarn[i].nHitCount++;
                return pAufenthalt->akwarn + i;
            }
            else if (!memcmp(pAufenthalt->akwarn[i].value, "000:", 4)) { /* V2020.2 */
                if (valueLength > 4 && !strcmp (trimmedValue + 4, pAufenthalt->akwarn[i].value + 4)) {
                    return storeAcceptedValue(pAufenthalt, i, trimmedValue);
                }
                if (!strcmp (trimmedValue, pAufenthalt->akwarn[i].value + 4)) {
                    return storeAcceptedValue(pAufenthalt, i, trimmedValue);
                }
            }
            else if (pAufenthalt->pScoringContext->modelljahr == 2017)
            {
                if (flag & LKF_ACCEPTED_MELABT2017)
                {
                    if (valueLength == 9 && trimmedValue[3] == ':' && !strcmp(trimmedValue + 4, pAufenthalt->akwarn[i].value + 4)) {
                        pAufenthalt->akwarn[i].nHitCount++;
                        return pAufenthalt->akwarn + i;
                    }
                }
                else if (!strcmp(sErrorIdent, "WX3B") || !strcmp(sErrorIdent, "WX3C") || !strcmp(sErrorIdent, "WX3E") || !strcmp(sErrorIdent, "WX4P") || !strcmp(sErrorIdent, "WX4R")) {
                    pAufenthalt->akwarn[i].nHitCount++;
                    return pAufenthalt->akwarn + i;
                }
            }
        }

    }
    return 0;
}

void *checkAcceptedWarning (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef, const char *value, int flag)
{
	unsigned int i;
	char sErrorIdent[5];
    
    if (SAFEIS2017ORLATER(pAufenthalt))
        return checkAcceptedWarning2017(pAufenthalt, pErrorDef, value, flag);
    
	lkf_getErrorIdent (pAufenthalt->pScoringContext, pErrorDef, 5, sErrorIdent);

	for (i = 0; i < pAufenthalt->akwarn_anz; i++) 
	{
		if ((pAufenthalt->akwarn[i].code == (int) pErrorDef->nCode || !memcmp (pAufenthalt->akwarn[i].s4DigitCode, sErrorIdent, 4)) &&
			TrimCompare (value, 10, pAufenthalt->akwarn[i].value, PAT_KRIT_EQUAL))
		{
			pAufenthalt->akwarn[i].nHitCount++; /* V12.1 */
			return pAufenthalt->akwarn + i;
		}
	}
	return 0;
}

static void *checkAcceptedError2017 (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef, const char *value, int flag)
{ /* V21.2 */
    unsigned int i;
    char sErrorIdent[5];
	int valueLength;
	char trimmedValue[21];
	strncpy (trimmedValue, value, 20);
	trimmedValue[20] = 0;

	valueLength = (int) strlen (trimmedValue);

	while (valueLength > 0 && trimmedValue[valueLength-1] == ' ') --valueLength;
	trimmedValue[valueLength] = 0;

	lkf_getErrorIdent (pAufenthalt->pScoringContext, pErrorDef, 5, sErrorIdent);
    
    for (i = 0; i < pAufenthalt->akwarn_anz; i++)
    {
        if (!memcmp (pAufenthalt->akwarn[i].s4DigitCode, sErrorIdent, 4))
        {
            if (!strcmp (trimmedValue, pAufenthalt->akwarn[i].value)) {
                pAufenthalt->akwarn[i].nHitCount++;
                return pAufenthalt->akwarn + i;
            }
            else if (!memcmp(pAufenthalt->akwarn[i].value, "000:", 4)) { /* V2020.2 */
                if (valueLength > 4 && !strcmp (trimmedValue + 4, pAufenthalt->akwarn[i].value + 4)) {
                    return storeAcceptedValue(pAufenthalt, i, trimmedValue);
                }
                if (!strcmp (trimmedValue, pAufenthalt->akwarn[i].value + 4)) {
                    return storeAcceptedValue(pAufenthalt, i, trimmedValue);
                }
            }
            else if (!memcmp (sErrorIdent, "EX1L", 4)) 
            { /* V205.0 */
                return storeAcceptedValue(pAufenthalt, i, trimmedValue);
            }
            else if (pAufenthalt->pScoringContext->modelljahr == 2017)
            { /* V21.4: Kompatibilitaet von X06 fuer EX3A */
                if (flag & LKF_ACCEPTED_MELABT2017) {
                    if (valueLength == 9 && trimmedValue[3] == ':' && !strcmp(trimmedValue + 4, pAufenthalt->akwarn[i].value + 4)) {
                        pAufenthalt->akwarn[i].nHitCount++;
                        return pAufenthalt->akwarn + i;
                    }
                }
                else if (!strcmp(sErrorIdent, "EX29"))
                { /* V21.5 */
                    if (!memcmp (trimmedValue, pAufenthalt->akwarn[i].value,10) &&
                        !pAufenthalt->akwarn[i].value[10])
                        return pAufenthalt->akwarn + i;
                }
                else if (!strcmp(sErrorIdent, "EX1T") || !strcmp(sErrorIdent, "EX1U") || !strcmp(sErrorIdent, "EX3M") || !strcmp(sErrorIdent, "EX3U") || !strcmp(sErrorIdent, "EX3X")) {
                    pAufenthalt->akwarn[i].nHitCount++;
                    return pAufenthalt->akwarn + i;
                }
            }
        }
    }
    return 0;
}


void *checkAcceptedError (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef, const char *value, int flag)
{
    unsigned int i;
	char sErrorIdent[5];
    
    if (SAFEIS2017ORLATER(pAufenthalt))
        return checkAcceptedError2017(pAufenthalt, pErrorDef, value, flag);
    
	lkf_getErrorIdent (pAufenthalt->pScoringContext, pErrorDef, 5, sErrorIdent);

	for (i = 0; i < pAufenthalt->akwarn_anz; i++) 
	{
		if ((pAufenthalt->akwarn[i].code == (int) pErrorDef->nCode || !memcmp (pAufenthalt->akwarn[i].s4DigitCode, sErrorIdent, 4)) &&
			TrimCompare (value, 10, pAufenthalt->akwarn[i].value, PAT_KRIT_EQUAL)) 
		{
			pAufenthalt->akwarn[i].nHitCount++;
			return pAufenthalt->akwarn + i;
		}
	}
	return 0;
}

#define ERROR_ACCEPTED 16
#define IS_ERROR_ACCEPTED(x) ((x)&16)

static int Satzart_ReportMBDSError3 (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef, unsigned int addinfo, const char *sInfo, int nAbtIndex, int mainErrorIndex, int *pErrorIndex, const char *kanr)
{ /* V2020.1 */
	int nRet;
	STAT_KA *pKA;
	LKF_CONTEXT *pContext;
	LKF_SATZART_ERROR *pError;
	char errorfield[20];
	const char *pErrorInfo;
	unsigned int severity;
	int errorindex;
	char sErrorIdent[6];
	char sTraceLine[1024];
    int acceptedflag = 0;
	pContext = pAufenthalt->pScoringContext;

#ifdef SIM2025_DEACTIVATE_ERRORS
    if (pErrorDef == &LKFErrorIntUebwEinhOhneVollstBer || pErrorDef == &LKFErrorIntEinhOhneVollstBer || pErrorDef == &LKFErrorStrokeOhneLeistung || pErrorDef == &LKFErrorBirthNoZD ||
        pErrorDef == &LKFErrorMEL0Tage2024 || pErrorDef == &LKFErrorMEL0Tage2016) {
        return 0;
    }
    
    if (pErrorDef == &LKFErrorDiagfalsch && pAufenthalt->isAmb) {
        return 0;
    }
#endif
        
    if (pErrorDef->pProperties && pErrorDef->pProperties->nAlternateErrorModelljahr && pErrorDef->pProperties->nAlternateErrorModelljahr <= pContext->modelljahr) {
        const LKF_SATZART_ERRORDEF *pAlternateErrorDef = pErrorDef->pProperties->pAlternateError;
        if (pAlternateErrorDef) {
            return Satzart_ReportMBDSError3(pAufenthalt, pAlternateErrorDef, addinfo, sInfo, nAbtIndex, mainErrorIndex, pErrorIndex, kanr);
        }
        return 0;
    }

    if (pErrorIndex) *pErrorIndex = -1;
    
    
	if (!lkf_getErrorRelevance (pErrorDef, pContext))
		return 0;
    
	severity = lkf_getSeverity (pContext, pErrorDef);
    if (!pContext->pSatzartErrors) {
        pContext->pSatzartErrors = Satzart_AllocErrorStructure(pContext);
        if (!pContext->pSatzartErrors) {
            return LKF_OUTOFMEMORY_ERROR;
        }
    }
    
	if (sInfo)
		pErrorInfo = sInfo;
	else
	{
		lkf_getErrorMBDSFieldEx (pAufenthalt, pErrorDef->nAddInfo, addinfo, errorfield, 20, nAbtIndex);
		pErrorInfo = errorfield;
	}
        
    if (pErrorDef->nAddInfo == LKF_MBDSERROR_MELABT) {
        acceptedflag = LKF_ACCEPTED_MELABT2017;
    }
    
	if (mainErrorIndex == -1 && (pErrorDef->nSeverity & LKF_MBDS_ACCEPTABLE) && (severity & LKF_SEV_ERROR) &&
		((pContext->flags & LKFCONTEXT_ACCEPT_ALL_ERRORS) || checkAcceptedError (pAufenthalt, pErrorDef, pErrorInfo, acceptedflag)))
	{
		++pAufenthalt->akerr_count;
		if (LKF_IS_TRACE_INFO (pContext->nTraceAufenthalt))
		{
			sprintf (sTraceLine, "MBDS-Error %s akzeptiert (Info='%s', Text: %s)", lkf_getErrorIdent (pContext, pErrorDef, 6, sErrorIdent),
				pErrorInfo ? pErrorInfo : "", pErrorDef->sText);
			TRACE_INFO (pAufenthalt, -1, sTraceLine);
		}
		nRet = (LKF_SEV_ERROR+ERROR_ACCEPTED);
        pError = 0;
	}
	else if (mainErrorIndex == -1 && (pErrorDef->nSeverity & LKF_MBDS_ACCEPTABLE) && (severity & (LKF_SEV_WARNING|LKF_SEV_INFO)) && 
		((pContext->flags & LKFCONTEXT_ACCEPT_ALL_WARNINGS) || checkAcceptedWarning (pAufenthalt, pErrorDef, pErrorInfo, acceptedflag)))
	{
		if (severity & LKF_SEV_INFO)
		{
			++pAufenthalt->akinfo_count;
			if (LKF_IS_TRACE_INFO (pContext->nTraceAufenthalt))
			{
				sprintf (sTraceLine, "MBDS-Info %s akzeptiert (Info='%s', Text: %s)", lkf_getErrorIdent (pContext, pErrorDef, 6, sErrorIdent),
					pErrorInfo ? pErrorInfo : "", pErrorDef->sText);
				TRACE_INFO (pAufenthalt, -1, sTraceLine);
			}
			nRet = (LKF_SEV_INFO+ERROR_ACCEPTED);
		}
		else
		{
			++pAufenthalt->akwarn_count;
			if (LKF_IS_TRACE_INFO (pContext->nTraceAufenthalt))
			{
				sprintf (sTraceLine, "MBDS-Warning %s akzeptiert (Info='%s', Text: %s)", lkf_getErrorIdent (pContext, pErrorDef, 6, sErrorIdent),
					pErrorInfo ? pErrorInfo : "", pErrorDef->sText);
				TRACE_INFO (pAufenthalt, -1, sTraceLine);
			}
			nRet = (LKF_SEV_WARNING+ERROR_ACCEPTED);
		}
        pError = 0;
	}
	else {
		errorindex = (int) Satzart_GetNextFreeErrorIndex (pContext, pContext->pSatzartErrors);
        if (errorindex == LKF_OUTOFMEMORY_UINTERROR) return LKF_OUTOFMEMORY_ERROR;

        if (pErrorIndex) *pErrorIndex = errorindex;
		pError = Satzart_GetSatzartError (pContext->pSatzartErrors, errorindex);
		switch (pErrorDef->nSeverity & 15) {
		case LKF_SEV_INFO:
			pContext->pSatzartErrors->nInfoCount++;
			break;
		case LKF_SEV_ERROR:
			pContext->pSatzartErrors->nErrorCount++;
			break;
		case LKF_SEV_FATAL:
			pContext->pSatzartErrors->nFatalCount++;
			break;
		case LKF_SEV_WARNING:
			pContext->pSatzartErrors->nWarningCount++;
			break;
		default:
			break;
		}
		pError->pErrorDef = pErrorDef;
		pError->pFeld = 0;
		pError->pSatzartInfo = 0;
		pError->pLine = 0;
		pError->nAddInfo = addinfo;
		pError->pAufenthalt = pAufenthalt;
		pError->nAufNextErrorIndex = -1;
		pError->nAbtIndex = nAbtIndex;
        pError->mainErrorIndex = mainErrorIndex;
        pError->nErrorLfdNr = (unsigned int) errorindex;
        
        if (kanr) {
            strncpy (pError->KANR, kanr, 6);
            pError->KANR[6] = 0;
        }
        else {
            pError->KANR[0] = 0;
        }

		if (sInfo)
		{
			strncpy (pError->sErrorFeld, sInfo, sizeof(pError->sErrorFeld));
			pError->sErrorFeld[sizeof(pError->sErrorFeld)-1] = 0;
		}
		else pError->sErrorFeld[0] = 0;

		if (LKF_IS_TRACE_INFO (pContext->nTraceAufenthalt))
		{
			sprintf (sTraceLine, "MBDS-%s %s (Info='%s', Text: %s)", (severity & LKF_SEV_WARNING) ? "Warning" : "Error",
					 lkf_getErrorIdent (pContext, pErrorDef, 6, sErrorIdent),
				     pError->sErrorFeld, pErrorDef->sText);
			TRACE_INFO (pAufenthalt, -1, sTraceLine);
		}

		if (pAufenthalt->nSatzartNextError >= 0) {
			LKF_SATZART_ERROR *pPrevious = Satzart_GetSatzartError (pContext->pSatzartErrors, pAufenthalt->nSatzartNextError);
			pPrevious->nAufNextErrorIndex = errorindex;
		}
		else pAufenthalt->nSatzartFirstError = errorindex;
		pAufenthalt->nSatzartNextError = errorindex;

		if (severity & LKF_SEV_ERROR) {
			nRet = LKF_SEV_ERROR;
			++pAufenthalt->plaus_err;
			Insert_NewError (errorindex, &pAufenthalt->pFirstError, &pAufenthalt->pLastError, pContext);
			if (pAufenthalt->kanr != -1) 
			{
				pKA = pContext->ka + pAufenthalt->kanr;
				if (pErrorDef->nCode >= pKA->error_code_min && pErrorDef->nCode <= pKA->error_code_max)
					pKA->error_counts[pErrorDef->nCode - pKA->error_code_min]++;
			}
		}
		else if (severity & LKF_SEV_WARNING) {
			nRet = LKF_SEV_WARNING;
			++pAufenthalt->plaus_warn;
			Insert_NewError (errorindex, &pAufenthalt->pFirstWarning, &pAufenthalt->pLastWarning, pContext);
			if (pAufenthalt->kanr != -1) 
			{
				pKA = pContext->ka + pAufenthalt->kanr;
				if (pErrorDef->nCode >= pKA->warning_code_min && pErrorDef->nCode <= pKA->warning_code_max)
					pKA->warning_counts[pErrorDef->nCode - pKA->warning_code_min]++;
			}
		}
		else if (severity & LKF_SEV_INFO)
		{
			nRet = LKF_SEV_INFO;
			++pAufenthalt->plaus_info;
			Insert_NewError (errorindex, &pAufenthalt->pFirstInfo, &pAufenthalt->pLastInfo, pContext);
		}
		else
			nRet = 0;
	}
    if (pError)
        lkf_context_count_error (pAufenthalt->pScoringContext, pError);
	return nRet;
}

static int Satzart_ReportMBDSError2 (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef, unsigned int addinfo, const char *sInfo, int nAbtIndex)
{
    return Satzart_ReportMBDSError3(pAufenthalt, pErrorDef, addinfo, sInfo, nAbtIndex, -1, 0, 0);
}

static int Satzart_ReportMBDSError2KANR (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef, unsigned int addinfo, const char *sInfo, int nAbtIndex, const char *kanr)
{
    return Satzart_ReportMBDSError3(pAufenthalt, pErrorDef, addinfo, sInfo, nAbtIndex, -1, 0, kanr);
}

static int error_matching_mel (unsigned int sourceIndex, const LKF_AUFENTHALT_MEL *pSource, const LKF_AUFENTHALT_MEL *pCandidate, int compareMode)
{ /* V2020.1 */
    switch (compareMode) {
        case LKF_MBDSERRORMELCOMPARE_STANDARD:
            if (pCandidate->mel_nr == sourceIndex) return 1;
            return 0;
        case LKF_MBDSERRORMELCOMPARE_MEL:
            if (pSource->cSeite == pCandidate->cSeite && pSource->nMelIndex == pCandidate->nMelIndex)
                return 1;
            return 0;
        case LKF_MBDSERRORMELCOMPARE_MEL_DAY:
            if (pSource->cSeite == pCandidate->cSeite && pSource->nMelIndex == pCandidate->nMelIndex && !memcmp (pSource->MELDAT, pCandidate->MELDAT, 8))
                return 1;
            return 0;
        default:
            return 0;
    }
}

static int Satzart_ReportMBDSErrorMEL (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef, unsigned int addinfo, const char *sInfo, int nAbtIndex, unsigned int addinfo2, int compareMode)
{
    int mainErrorIndex;
    int ret = Satzart_ReportMBDSError3(pAufenthalt, pErrorDef, addinfo, sInfo, nAbtIndex, -1, &mainErrorIndex,0);

    if (ret == LKF_OUTOFMEMORY_ERROR) return ret;
    
    if (!ret || (ret & ERROR_ACCEPTED))
        return ret;
    
    if ((pAufenthalt->pScoringContext->flags & LKFCONTEXT_EXTENDED_ERROR_INFO) && addinfo < pAufenthalt->mel_anz) {
        unsigned int i;
        const LKF_AUFENTHALT_MEL *pSource = pAufenthalt->mel + addinfo;
        const LKF_AUFENTHALT_MEL *pSource2 = (addinfo2 != addinfo) ? pAufenthalt->mel + addinfo2 : 0;
        for (i = 0; i < pAufenthalt->mel_anz; i++) {
            
            if (i == addinfo)
                continue;
            
            if (error_matching_mel (addinfo, pSource, pAufenthalt->mel + i, compareMode)) {
                Satzart_ReportMBDSError3(pAufenthalt, pErrorDef, i, sInfo, nAbtIndex, mainErrorIndex, 0, 0);
                continue;
            }
            
            if (i == addinfo2) {
                Satzart_ReportMBDSError3(pAufenthalt, pErrorDef, i, sInfo, nAbtIndex, mainErrorIndex, 0, 0);
                continue;
            }
                
            if (pSource2 && error_matching_mel (addinfo, pSource2, pAufenthalt->mel + i, compareMode)) {
                Satzart_ReportMBDSError3(pAufenthalt, pErrorDef, i, sInfo, nAbtIndex, mainErrorIndex, 0, 0);
            }
        }
        
    }
    return ret;
}

static int Satzart_ReportMBDSErrorDoubleIndex (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef, unsigned int addinfo, const char *sInfo, int nAbtIndex, unsigned int addInfo2) {
    int mainErrorIndex;
    int ret = Satzart_ReportMBDSError3(pAufenthalt, pErrorDef, addinfo, sInfo, nAbtIndex, -1, &mainErrorIndex, 0);
        
    if (!ret || (ret & ERROR_ACCEPTED))
        return ret;
        
    if ((pAufenthalt->pScoringContext->flags & LKFCONTEXT_EXTENDED_ERROR_INFO) && mainErrorIndex >= 0) {
        Satzart_ReportMBDSError3(pAufenthalt, pErrorDef, addInfo2, sInfo, nAbtIndex, mainErrorIndex, 0, 0);
    }
    return ret;
}


void PlausReportIntensivError (LKF_AUFENTHALT *pAufenthalt, int bWarning, int nErrorIndex)
{
	if (bWarning)
	{
		Insert_NewError (nErrorIndex, &pAufenthalt->pFirstWarning, &pAufenthalt->pLastWarning, pAufenthalt->pScoringContext);
		pAufenthalt->plaus_warn++; /* V12.0 */
	}
	else
	{
		Insert_NewError (nErrorIndex, &pAufenthalt->pFirstError, &pAufenthalt->pLastError, pAufenthalt->pScoringContext);
		pAufenthalt->plaus_err++; /* V12.0 */
	}
}

int Satzart_ReportMBDSError (LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef, unsigned int addinfo)
{
	return Satzart_ReportMBDSError2 (pAufenthalt, pErrorDef, addinfo, 0, -1);
}

/* procedure Plaus_MeldeDiag (V7.0) *******************************************************
**    fuegt eine meldepflichtige Diagnose in die Liste der meldepflichtigen Diagnosen ein**
******************************************************************************************/

static int Insert_Error (int code, int index, LKF_AUFENTHALT *pAufenthalt, LKF_ERROR_LIST **ppLast)
{
    LKF_ERROR_LIST *pNew = (LKF_ERROR_LIST *) LKF_MALLOC (pAufenthalt->pScoringContext, "Insert_Error", sizeof (LKF_ERROR_LIST));
    
    if (!pNew) return LKF_OUTOFMEMORY_ERROR;
    if (!pAufenthalt->pFirstMeldeDiag) pAufenthalt->pFirstMeldeDiag = *ppLast = pNew;
    else *ppLast = (*ppLast)->next = pNew;
    pNew->code = code;
    pNew->index = index;
    pNew->next = 0;
    pNew->nNewError = -1;
    pNew->pAufenthalt = pAufenthalt;
    pNew->pContext = pAufenthalt->pScoringContext;
    return 0;
}

static void Plaus_MeldeDiag (LKF_AUFENTHALT *pAufenthalt, char code, int index)
{
	++pAufenthalt->melde_count;
	Insert_Error ((int)code, index, pAufenthalt, &pAufenthalt->pLastMeldeDiag);
}


/* procedure MEL_JoinEqual **********************************************
**    Die eingetragenen Anzahlen der Einzelleistungen werden ermittelt **
**    und mehrfach vorkommende Einzelleistungen zusammensummiert.      **
**    Diese Werte werden in tmp_melanz zurueckgeliefert.               **
************************************************************************/

static int mel_relevanz_equal (char a, char b)
{ /* V22.5 */
    return (a == b) || (strchr(" J", a) && strchr(" J", b)) || (!strchr(" J", a) && !strchr(" J", b));
}

static void MEL_JoinEqual (LKF_AUFENTHALT *pAufenthalt, int *tmp_melanz)
{
	int i, j, erg;

	for (i = (int) pAufenthalt->mel_anz - 1; i >= 0; i--) 
	{
		if (GetInt (pAufenthalt->mel[i].MELANZ, LKF_AUFENTHALT_MELANZ_LEN, &erg)) {
			tmp_melanz[i] = erg;

			for (j = i + 1; j < (int)pAufenthalt->mel_anz; j++) 
				if (tmp_melanz[j] && !memcmp (pAufenthalt->mel[i].MEL, pAufenthalt->mel[j].MEL, LKF_AUFENTHALT_NEWMEL_LEN) && pAufenthalt->mel[i].cSeite == pAufenthalt->mel[j].cSeite /* V17.1 */) {
                    
                    if (pAufenthalt->pScoringContext->modelljahr < 2018 || mel_relevanz_equal (pAufenthalt->mel[i].MEL_RELEVANT, pAufenthalt->mel[j].MEL_RELEVANT)) {
                        tmp_melanz[i] += tmp_melanz[j];
                        tmp_melanz[j] = 0;
                    }
				}
		}
		else tmp_melanz[i] = 0;
	}
}

/* function ENTDAT_Check *************************************************
**     Ueberpruefung des Entlassungsdatums in pAufenthalt, und zwar:    **
**        - ob es fehlt (ENTDAT_FEHLT)                                  **
**        - ob es ein ungueltiges Format aufweist (ENTDAT_FALSCH)       **
**        - ob es im Meldejahr (cmb_jahr) liegt (ENTDAT_NOERHEBUNG)     **
**        - ob es nicht nach Periodenende liegt (ENTDAT_NOPERIODE)      **
** Return: 1, wenn Datum korrekt, sonst 0                               **
*************************************************************************/

#define ENTDAT_NOPERIODE	  8

static int ENTZEIT_Check (LKF_AUFENTHALT *pAufenthalt)
{ /* V21.0 */
    long aufzeit, entzeit, aufdat;
    if (IsBlank(pAufenthalt->ENTZEIT, 4)) {
         return 0;
    }
    entzeit = lkf_time2int (pAufenthalt->ENTZEIT);
    if (entzeit == 0) {
        Satzart_ReportMBDSError(pAufenthalt, &LKFErrorENTZEITfalsch, 0);
        return 0;
    }
    
    aufdat = lkf_dat2int(pAufenthalt->AUFDAT);
    aufzeit = lkf_time2int(pAufenthalt->AUFZEIT);
    
    if (entzeit && aufzeit && aufdat && aufdat == pAufenthalt->lEntDat && entzeit < aufzeit)
    {
        Satzart_ReportMBDSError(pAufenthalt, &LKFErrorENTZEITvorAUFZEIT, 0);
        return 0;
    }
    
    return 1;
}

static int ENTZEIT_Check_Strict (LKF_AUFENTHALT *pAufenthalt)
{ /* V21.0 */
    long aufzeit, entzeit, aufdat;
    if (IsBlank(pAufenthalt->ENTZEIT, 4)) {
         return 0;
    }
    entzeit = lkf_time2intStrict (pAufenthalt->ENTZEIT);
    if (entzeit == 0) {
        Satzart_ReportMBDSError(pAufenthalt, &LKFErrorENTZEITfalsch, 0);
        return 0;
    }
    
    aufdat = lkf_dat2intStrict (pAufenthalt->AUFDAT);
    aufzeit = lkf_time2intStrict (pAufenthalt->AUFZEIT);
    
    if (entzeit && aufzeit && aufdat && aufdat == pAufenthalt->lEntDat && entzeit < aufzeit)
    {
        Satzart_ReportMBDSError(pAufenthalt, &LKFErrorENTZEITvorAUFZEIT, 0);
        return 0;
    }
    
    return 1;
}


static int ENTDAT_Check (LKF_AUFENTHALT *pAufenthalt, int cmb_jahr, char period_type, int period_val)
{
	int year, month, day;
	int plaus_flag;
    int hasEntZeit = 0;
    char *entdat;
    int modelljahr;
    
    modelljahr = pAufenthalt->pScoringContext->modelljahr;
    
    if (pAufenthalt->pScoringContext->model2017errors) {
        hasEntZeit = !IsBlank(pAufenthalt->ENTZEIT, 4);
		if (!hasEntZeit && !pAufenthalt->isAmb && pAufenthalt->ENTART != 'V')
		{ /* V21.2 */
			Satzart_ReportMBDSError(pAufenthalt, &LKFErrorENTZEITfehlt, 0);
		}
    }
    if (pAufenthalt->isAmb)
    { /* V21.0 */
        if (IsBlank (pAufenthalt->ENTDAT, 8))
            entdat = pAufenthalt->AUFDAT;
        else
            entdat = pAufenthalt->ENTDAT;
    }
	/* ENTDAT: kein Datum vorhanden -> ERROR */
	else if (IsBlank (pAufenthalt->ENTDAT, 8)) {
		if (pAufenthalt->ENTART != 'V') {
			/* Plaus_Error (pAufenthalt, ENTDAT_FEHLT, 0); */
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorENTDATfehlt, 0);
		}
        else if (hasEntZeit) {
            if (pAufenthalt->pScoringContext->modelljahr >= LKF_DATETIME_STRICT_MODEL) {
                ENTZEIT_Check_Strict(pAufenthalt);
            }
            else {
                ENTZEIT_Check(pAufenthalt);
            }
        }
		return 0;
	}
	else if (pAufenthalt->ENTART == 'V') {
		Satzart_ReportMBDSError (pAufenthalt, &LKFErrorENTDATVerbleib, 0);
        entdat = pAufenthalt->ENTDAT;
    }
    else {
        entdat = pAufenthalt->ENTDAT;
    }

    if (modelljahr > LKF_DATETIME_STRICT_MODEL) {
        pAufenthalt->lEntDat = lkf_dat2intStrict (entdat);
    }
    else {
        pAufenthalt->lEntDat = lkf_dat2int (entdat);
    }

	/* ENTDAT: Eintrag vorhanden, ungueltiges Format -> ERROR	*/
	if (!pAufenthalt->lEntDat && pAufenthalt->AUFDAT != entdat) {
        if (pAufenthalt->ENTART != 'V' || modelljahr < 2017)
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorENTDATfalsch, 0);
		return 0;
	}

	if (cmb_jahr ? 1 : 0) {

		if (pAufenthalt->isAmb)
            GetDate8(pAufenthalt->AUFDAT, &year, &month, &day);
        else
            GetDate8 (entdat, &year, &month, &day);

		if (year == cmb_jahr) {

			/* ENTDAT: Meldejahr stimmt ueberein, Periode falsch -> ERROR */
			plaus_flag = 0;

			switch (period_type) {
			
				case PERIODE_TAG: /* case 'T' */
					
					if (period_val < DayOfYear (year, month, day))
						plaus_flag = ENTDAT_NOPERIODE;

					break;
					
				case PERIODE_MONAT: /* case 'M'	*/

					if (period_val < month)
						plaus_flag = ENTDAT_NOPERIODE;
					break;

				case PERIODE_QUARTAL: /* case 'Q' */

					if (period_val * 3 < month)
						plaus_flag = ENTDAT_NOPERIODE;
					break;

				case PERIODE_HALBJAHR: /* case 'H' */

					if (period_val * 6 < month)
						plaus_flag = ENTDAT_NOPERIODE;
					break;
				case PERIODE_JAHR: /* case 'J' */
					break;
				default:
					plaus_flag = ENTDAT_NOPERIODE; /* V2.01 */
					break;
			
			}

			if (plaus_flag == ENTDAT_NOPERIODE) {
                Satzart_ReportMBDSError (pAufenthalt, pAufenthalt->isAmb ? &LKFErrorAUFDATBerichtsperiode : &LKFErrorENTDATBerichtsperiode, 0);
			}
		}
		/* ENTDAT: Gueltiges Format, stimmt nicht mit dem Meldejahr ueberein -> ERROR */
		else {			
			Satzart_ReportMBDSError (pAufenthalt, pAufenthalt->isAmb ? &LKFErrorAUFDATBerichtsperiode : &LKFErrorENTDATBerichtsperiode, 0);
		}
        if (hasEntZeit) {
            if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
                ENTZEIT_Check_Strict(pAufenthalt);
            }
            else {
                ENTZEIT_Check(pAufenthalt);
            }
        }
	}
    
	return 1;
}

/* procedure STAAT_Check **************************************************
**  Ueberpruefung, ob die Staatsbuergerschaft (STAATB)                   **
**          - befuellt ist (sonst Warning STAATB_FEHLT)                  **
**          - gueltig ist (sonst Warning STAATB_FALSCH)                  **
**  Ueberpruefung, ob der Wohnsitzstaat (STAATW)                         **
**          - befuellt ist (sonst Warning STAATW_FEHLT)                  **
**          - gueltig ist (sonst Warning STAATW_FALSCH)                  **
**  Bei Wohnsitz in Oesterreich wird die Postleitzahl ueberprueft, und zwar **
**          - ob diese ausgefuellt ist (sonst Warning PLZ_FEHLT)         **
**          - ob diese gueltig ist (sonst Warning PLZ_FALSCH)            **
**************************************************************************/

static void STAAT_Check (LKF_AUFENTHALT *pAufenthalt)
{
	char trimmed_staat[3];
	char trimmed_plz[6];
	size_t trimmed_plz_len;
	int Modelljahr;

	Modelljahr = pAufenthalt->pScoringContext->modelljahr; /* V9.1: alle Zeilen mit Modelljahr -> Error/Warning je nach Modelljahr */

	/* STAATB: keine STAATB vorhanden -> WARNING */
	if (IsBlank (pAufenthalt->STAATB, 3)) {
		if (Modelljahr >= 2013) 
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSTAATBfehlt2013, 0);
		else
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSTAATBfehlt, 0);
	}
	/* STAATB: STAATB ungueltig -> WARNING */
	else if (!StaatInArray (pAufenthalt->pScoringContext, pAufenthalt->STAATB)) {
		
        if (Modelljahr >= 2013)
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSTAATBfalsch2013, 0); /* V17.0 */
        else
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSTAATBfalsch, 0);
	}
	/* STAATW: keine STAATW vorhanden -> WARNING */
	if (IsBlank (pAufenthalt->STAATW, 3)) {
		Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSTAATWfehlt2005, 0);
	}
	/* STAATW: STAATW ung\xc3\xbc""ltig -> WARNING */
	else if (!StaatInArray (pAufenthalt->pScoringContext, pAufenthalt->STAATW)) {
        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSTAATWfalsch2005, 0);
	}
	/* PLZ: wenn STAATW="A" und keine PLZ vorhanden -> WARNING */
	simLTrim (trimmed_staat, pAufenthalt->STAATW, 3);
	if (!memcmp (pAufenthalt->STAATW, "AT ", 3)) {
        int plzok = 1;
		trimmed_plz_len = (size_t) simTrim (trimmed_plz, pAufenthalt->PLZW, 6);

		if (!trimmed_plz_len) {
			Satzart_ReportMBDSError(pAufenthalt, &LKFErrorPLZWfehlt2005, 0);
            plzok = 0;
        }
		/* PLZ: PLZ ungueltig -> WARNING */
		else if (trimmed_plz_len > 4 || !PLZInArray (pAufenthalt->pScoringContext, trimmed_plz)) {
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorPLZWfalsch2005, 0);
            plzok = 0;
        }
        
        if (Modelljahr >= 2017) {
            
            if (IsBlank(pAufenthalt->GEMEINDEZIFFER, 5)) {
                if (!(pAufenthalt->pScoringContext->flags & LKFCONTEXT_IGNORE_2017ERRORS)) {
                    Satzart_ReportMBDSError (pAufenthalt, Modelljahr >= 2023 ? &LKFErrorGemeindezifferFehlt2023 : &LKFErrorGemeindezifferFehlt, 0);
                }
            }
            else
            {
                if (!FindGKZ (pAufenthalt->pScoringContext, pAufenthalt->GEMEINDEZIFFER)) {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorGemeindezifferFalsch, 0);
                }
                else if (plzok && !FindPLZGemco(pAufenthalt->pScoringContext, pAufenthalt->PLZW, pAufenthalt->GEMEINDEZIFFER)) {
                    Satzart_ReportMBDSError (pAufenthalt, Modelljahr >= 2023 ? &LKFErrorPLZGEMCOfalsch2023 : &LKFErrorPLZGEMCOfalsch, 0);
                }
            }
        }
	}
    else if ((!IsBlank(pAufenthalt->PLZW, 4) || !IsBlank(pAufenthalt->GEMEINDEZIFFER, 5)) && pAufenthalt->pScoringContext->modelljahr >= 2017) {
        if (!(pAufenthalt->pScoringContext->flags & LKFCONTEXT_IGNORE_2017ERRORS)) {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorPLZGEMCOIntl, 0);
        }
    }
}


/* function AUFDAT_Check ***************************************************
**    Ueberpruefung des Aufnahmedatums (ABTDAT[0]), und zwar:               **
**         - ob AUFDAT befuellt ist (AUFDAT_FEHLT)                         **
**         - ob AUFDAT ein gueltiges Format hat (AUFDAT_FALSCH)            **
**         - ob das AUFDAT hinter dem ENTDAT liegt (AUFDAT_NACH_ENTDAT)   **
** Return: 1 wenn OK, sonst 0                                             **
***************************************************************************/

static int AUFDAT_Check (LKF_AUFENTHALT *pAufenthalt)
{
    int modelljahr;
    modelljahr = pAufenthalt->pScoringContext->modelljahr;

	/* AUFDAT: kein Datum vorhanden -> ERROR */
	if (IsBlank (pAufenthalt->AUFDAT, 8)) {
        Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorAUFDATfehlt2017 : &LKFErrorAUFDATfehlt, 0);
	}
	else {
		
        if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            pAufenthalt->lAufDat = lkf_dat2intStrict (pAufenthalt->AUFDAT);
        }
        else {
            pAufenthalt->lAufDat = lkf_dat2int (pAufenthalt->AUFDAT);
        }
		/* AUFDAT: Eintrag vorhanden, ungueltiges Format -> ERROR */
		if (!pAufenthalt->lAufDat) {
            Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorAUFDATfalsch2017 : &LKFErrorAUFDATfalsch, 0);
		}
		/* AUFDAT: Eintrag vorhanden, nach Entlassungsdatum -> ERROR	*/
		else if (pAufenthalt->lEntDat && pAufenthalt->lAufDat > pAufenthalt->lEntDat) {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAUFDATnachENTDAT, 0);
		}
        
        if (IS2017ORLATER(pAufenthalt)) {
            if (!IsBlank(pAufenthalt->AUFZEIT, 4))
            {
                long aufzeit;
                
                if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
                    aufzeit = lkf_time2intStrict(pAufenthalt->AUFZEIT);
                }
                else {
                    aufzeit = lkf_time2int(pAufenthalt->AUFZEIT);
                }
                
                if (aufzeit == 0) {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAUFZEITfalsch, 0);
                }
            }
			else if (pAufenthalt->pScoringContext->model2017errors)
            { /* V21.2 */
				Satzart_ReportMBDSError(pAufenthalt, &LKFErrorAUFZEITfehlt, 0);
			}

            
            if (pAufenthalt->isAmb && pAufenthalt->lAufDat && pAufenthalt->lEntDat > pAufenthalt->lAufDat + 1) {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAmbAufenthaltDauer, 0);
            }
        }
	}
	return 0;
}

static void ALTER_Check (LKF_AUFENTHALT *pAufenthalt, int cmb_jahr)
{ /* V19.0 */
    unsigned int i = 0;
    if (!pAufenthalt->ALTERSGRUPPE[0]) {
        Satzart_ReportMBDSError2(pAufenthalt, &LKFError_AlterGruppeFehlt, 0, 0, 0);
        return;
    }
    
    while (i < 3 && pAufenthalt->ALTERSGRUPPE[i] == ' ') ++i;
    
    for (; pAufenthalt->ALTERSGRUPPE[i] && pAufenthalt->ALTERSGRUPPE[i] != ' '; i++) {
        if (pAufenthalt->ALTERSGRUPPE[i] < '0' || pAufenthalt->ALTERSGRUPPE[i] > '9') {
            Satzart_ReportMBDSError2(pAufenthalt, &LKFError_AlterGruppeFalsch, 0, 0, 0);
            return;
        }
    }
    
    for (; i < 3 && pAufenthalt->ALTERSGRUPPE[i]; i++) {
        if (pAufenthalt->ALTERSGRUPPE[i] != ' ') {
            Satzart_ReportMBDSError2(pAufenthalt, &LKFError_AlterGruppeFalsch, 0, 0, 0);
            return;            
        }
    }
    
    pAufenthalt->Alter = (short) atoi (pAufenthalt->ALTERSGRUPPE);
    
    if (pAufenthalt->Alter > 95 || ((pAufenthalt->Alter % 5 != 0) && (pAufenthalt->Alter != 1))) {
        Satzart_ReportMBDSError2(pAufenthalt, &LKFError_AlterGruppeFalsch, 0, 0, 0);
    }
}

/* procedure GEBDAT_Check ***************************************************
**     Ueberpruefung des Geburtsdatums, und zwar:                            **
**         - ob das GEBDAT leer ist und STAATB/STAATW bekannt ist          **
**           (GEBDAT_CHECK)												   **
**         - ob das Format korrekt ist (AUFDAT_VOR_GEBDAT)                 **
**         - ob das GEBDAT nach dem AUFDAT liegt (AUFDAT_VOR_GEBDAT)       **
**         - ob das Alter groesser 100 Jahre ist (Warning HOHES_ALTER)       **
****************************************************************************/

static void GEBDAT_Check (LKF_AUFENTHALT *pAufenthalt, int cmb_jahr)
{

	/* GEBDAT: (1) kein Datum vorhanden -> ERROR
				au\xc3\x9f""er unbekannte Staatsb\xc3\xbc""rgerschaft und
				unbekannter ordentl. Wohnsitz (Staat) */
    
	if (IsBlank (pAufenthalt->GEBDAT, 8)) {
		if (!memcmp (pAufenthalt->STAATB, "ZZ", 2) &&
			!memcmp (pAufenthalt->STAATW, "ZZ", 2)) {

			sprintf (pAufenthalt->GEBDAT, "%4d", cmb_jahr - 30);
			memcpy (pAufenthalt->GEBDAT + 4, "0701", 4);
		}
		else {
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorGEBDATfehlt, 0);	
			/* Plaus_Error (pAufenthalt, GEBDAT_FEHLT, 0); */
		}
	}
	else { 
		
        long lGebDat;
        
        if (pAufenthalt->pScoringContext->modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            lGebDat = lkf_dat2intStrict (pAufenthalt->GEBDAT);
        }
        else {
            lGebDat = lkf_dat2int (pAufenthalt->GEBDAT);
        }
        
        
        pAufenthalt->lGebDat = lGebDat; /* V19.0 */
        
		/* GEBDAT: Eintrag vorhanden, ung\xc3\xbc""ltiges Format -> ERROR */
		if (!lGebDat) {
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorGEBDATfalsch, 0);		
			/* Plaus_Error (pAufenthalt, GEBDAT_FALSCH, 0); */
		}
		/* GEBDAT: wenn Datum > Aufnahmedatum, ung\xc3\xbc""ltiges Format -> ERROR */
		else { 

			if (pAufenthalt->lAufDat && pAufenthalt->lAufDat < lGebDat) {
				Satzart_ReportMBDSError (pAufenthalt, &LKFErrorGEBDATnachAUFDAT, 0);			
				/* Plaus_Error (pAufenthalt, AUFDAT_VOR_GEBDAT, 0); */
			}
			/* GEBDAT: wenn Alter > 110 -> WARNING */
			if (pAufenthalt->lEntDat) {
                if (pAufenthalt->isAmb && IsBlank(pAufenthalt->ENTDAT, 8))
                    pAufenthalt->Alter = (short) GetYearDiffDate8 (pAufenthalt->GEBDAT, pAufenthalt->AUFDAT);
                else
                    pAufenthalt->Alter = (short) GetYearDiffDate8 (pAufenthalt->GEBDAT, pAufenthalt->ENTDAT);
				if (pAufenthalt->Alter > 110) {
					/* Plaus_Warn (pAufenthalt, HOHES_ALTER, 0); */
					Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAlter, 0);			
				}
			}		
		}
	}
}

/* function ABTDAT_Check *******************************************************
**    Ueberpruefung der weiteren ABTDATs, und zwar:                           **
**        - ob das erste ABTDAT dem AUFDAT entspricht                         **
**        - ob das ABTDAT[i]-Format gueltig ist (ABTDAT_FALSCH)               **
**        - ob ein dazugehoeriger ABTFC eingetragen ist (ABT_FC_FEHLT)        **
**     [Check fuer 2. - 5. ABTDAT/ABTFC, 1. wird in AUFDAT_Check ueberprueft] **
**        - ob die ABTDATs chronologisch geordnet sind und vor dem ENTDAT     **
**          liegen (NO_CHRONO_DAT)                                            **
*******************************************************************************/

static int UnterbrechungCovidOk (LKF_AUFENTHALT *pAufenthalt)
{ /* V2020.2 */
    KA_LIST_STRING *pKAInfo;
    LKF_CONTEXT *pContext;
    
    pContext = pAufenthalt->pScoringContext;

    if (pContext->modelljahr < 2020) {
        return 0;
    }
    
    pKAInfo = KAInArray(pContext->pStamm2001, pContext->KANR);
    if (pKAInfo && (*pKAInfo)[28] == 'N')
        return 1;
    if (pKAInfo && pContext->modelljahr >= 2022 && (*pKAInfo)[28] == 'P')
        return 1; /* V023.1 */
    
    return 0;
}

static void ABTDAT_Check (LKF_AUFENTHALT *pAufenthalt)
{
	unsigned int i, j; 
	int quit_check;
	long *plAbtDat;
	int last_day;
    int modelljahr;
	unsigned int untbr_maxabt; /* V15.2 */
    long lAufenthaltEntDat; /* V2019.1 */
    
	if (!pAufenthalt->abt_anz) return;

	plAbtDat = (long *) LKF_CALLOC (pAufenthalt->pScoringContext, "ABTDAT_Check", sizeof (long), pAufenthalt->abt_anz + 1);
    if (!plAbtDat) return;
    modelljahr = pAufenthalt->pScoringContext->modelljahr;
    
    if (modelljahr >= 2018 && pAufenthalt->isAmb) {
        lAufenthaltEntDat = pAufenthalt->lAufDat + 1;
    }
    else {
        lAufenthaltEntDat = pAufenthalt->lEntDat;
    }
    
	for (i = 0; i < pAufenthalt->abt_anz; i++) {

		if (!IsBlank (pAufenthalt->abt[i].ABTDAT, 8)) {

            if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
                plAbtDat[i] = lkf_dat2intStrict (pAufenthalt->abt[i].ABTDAT);
                pAufenthalt->abt[i].lAbtZeit = lkf_time2intStrict (pAufenthalt->abt[i].ABTZEIT);
            }
            else {
                plAbtDat[i] = lkf_dat2int (pAufenthalt->abt[i].ABTDAT);
                pAufenthalt->abt[i].lAbtZeit = lkf_time2int(pAufenthalt->abt[i].ABTZEIT);
            }
			

			pAufenthalt->abt[i].lAbtDat = (unsigned int) plAbtDat[i];

			if (i == 0 && plAbtDat[0] != pAufenthalt->lAufDat) {
                Satzart_ReportMBDSError2 (pAufenthalt, modelljahr >= 2017 ? &LKFErrorAUFDATungleichABTDAT2017 : &LKFErrorAUFDATungleichABTDAT, 0, 0, 0);
			}
			if (!plAbtDat[i]) {
                Satzart_ReportMBDSError2 (pAufenthalt, modelljahr >= 2017 ? &LKFErrorABTDATfalsch2017 : &LKFErrorABTDATfalsch, i, 0, (int) i);
			}

			if (plAbtDat[i] && ((pAufenthalt->lAufDat && plAbtDat[i] < pAufenthalt->lAufDat) ||
				(lAufenthaltEntDat && plAbtDat[i] > lAufenthaltEntDat))) {
				Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTDATaussAufenthalt, i, 0, (int) i);
			}
		}
		else plAbtDat[0] = -1;
	}

	last_day = 0;

	untbr_maxabt = pAufenthalt->abt_anz;

	/* ABTDAT: keine Chronologie vorhanden -> ERROR	*/
	if (pAufenthalt->lAufDat && lAufenthaltEntDat) {
		
		quit_check = 0;

		plAbtDat[pAufenthalt->abt_anz] = lAufenthaltEntDat;

		for (i = 0; !quit_check && i < pAufenthalt->abt_anz && plAbtDat[i]>0; i++) {
			for (j = i + 1; j < pAufenthalt->abt_anz && plAbtDat[j]<=0; j++) ;
			if (plAbtDat[j]< plAbtDat[i]) {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorVerlegungenChrono, j < pAufenthalt->abt_anz ? j : i);
				quit_check = 1;
			}
		}
	}
	else if (pAufenthalt->ENTART == 'V' && !pAufenthalt->lEntDat)
	{
		char dat[10];
		sprintf (dat, "%4.4d1231", pAufenthalt->pScoringContext->cmb_jahr);
		last_day = (int) lkf_dat2int (dat);
		plAbtDat[pAufenthalt->abt_anz] = last_day;
		untbr_maxabt = pAufenthalt->abt_anz - 1;

		if (pAufenthalt->pScoringContext->modelljahr >= 2010)
		{
			for (i = pAufenthalt->abt_anz - 1; i > 0 && plAbtDat[i] > last_day; i--)
			{
				plAbtDat[i] = last_day;
				untbr_maxabt = i-1;
			}
		}
	}

	if (pAufenthalt->isAmb) {
		for (i = 0; i < pAufenthalt->abt_anz; i++)
		{
			pAufenthalt->abt[i].ABTVD = 0;
		}
	}
	else {
		for (i = 0; i < pAufenthalt->abt_anz; i++)
		{
			if (plAbtDat[i] > 0 && plAbtDat[i + 1] > 0)
				pAufenthalt->abt[i].ABTVD = plAbtDat[i + 1] - plAbtDat[i];

			if (pAufenthalt->pScoringContext->modelljahr >= 2010 && !memcmp(pAufenthalt->abt[i].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
			{
				if (pAufenthalt->abt[i].ABTVD == 0 && i < untbr_maxabt)
					Satzart_ReportMBDSError(pAufenthalt, &LKFErrorUnterbrechung0Tage, i);
                else if (modelljahr >= 2022 && pAufenthalt->ENTART != 'V' && i + 1 == pAufenthalt->abt_anz) {
                    Satzart_ReportMBDSError(pAufenthalt, &LKFErrorUnterbrecherEntlassung, i); /* V2023.1 */
                }
                else if (!UnterbrechungCovidOk(pAufenthalt)) {
                    if (pAufenthalt->abt[i].ABTVD == 1 && pAufenthalt->AUFART == 'H' && pAufenthalt->pScoringContext->modelljahr < 2019 && i < untbr_maxabt)
                        Satzart_ReportMBDSError(pAufenthalt, &LKFErrorUnterbrechung1TagH, i);
                    else if (pAufenthalt->abt[i].ABTVD > 5)
                        Satzart_ReportMBDSError(pAufenthalt, &LKFErrorUnterbrechung6Tage, i);
                    else if (pAufenthalt->AUFART != 'H')
                    {
                        if (pAufenthalt->abt[i].lAbtDat == pAufenthalt->lAufDat)
                            Satzart_ReportMBDSError(pAufenthalt, &LKFErrorUnterbrechungAufDat, i);
                        else
                        {
                            int bOk = 0;

                            if (i + 1 == pAufenthalt->abt_anz && (pAufenthalt->ENTART == LKF_ENTART_REVERS || pAufenthalt->ENTART == 'V' || pAufenthalt->ENTART == 'S' || pAufenthalt->ENTART == 'T')) /* V15.0: S/T */
                                bOk = 1; /* V14.1 */
                            else
                            {
                                for (j = i + 1; !bOk && j < pAufenthalt->abt_anz && memcmp(pAufenthalt->abt[j].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN); j++)
                                {
                                    if (j + 1 == pAufenthalt->abt_anz)
                                    {
                                        if ((pAufenthalt->ENTART == 'V' || pAufenthalt->ENTART == 'S' || pAufenthalt->ENTART == 'T' || pAufenthalt->ENTART == LKF_ENTART_REVERS) || pAufenthalt->lEntDat > (long) pAufenthalt->abt[i + 1].lAbtDat)
                                            bOk = 1;
                                    }
                                    else if (pAufenthalt->abt[j + 1].lAbtDat > pAufenthalt->abt[i + 1].lAbtDat)
                                        bOk = 1;
                                }
                            }
                            if (!bOk)
                                Satzart_ReportMBDSError(pAufenthalt, &LKFErrorUnterbrechungEntDat, i);
                        }
                    }
                }
			}
		}
	}

	LKF_FREE (pAufenthalt->pScoringContext, "ABTDAT_Check", plAbtDat);
}

/* procedure AUFART_Check *******************************************************
**    Ueberpruefung der Aufnahmeart, und zwar:                                   **
**        - ob es gueltig ist (A, T, W, R, P, H, K oder L) -> AUFART_FALSCH     **
**        - bei A, T, W, H: Warning VD_LANG bei Verweildauer > 200 Tage        **
**        - bei K: Warning IST_KURZLIEGER bei Verweildauer > 1 Tag             **
**        - bei H: HALBSTAT_ERR, wenn nicht alle ABTFCs H-Codes sind.          **
********************************************************************************/

static void AUFART_Check (LKF_AUFENTHALT *pAufenthalt)
{
    int modelljahr = pAufenthalt->pScoringContext->modelljahr;
    
	/* AUFART: ungueltige Aufnahmeart -> ERROR */
	if (pAufenthalt->AUFART == ' ' && !pAufenthalt->isAmb) {
		Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorAUFARTfehlt2017 : &LKFErrorAUFARTfehlt, 0);
	}
    else if (pAufenthalt->isAmb) {
        if (!strchr (" 1234569", pAufenthalt->AUFART)) {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAUFARTfalsch2017, 0);
        }
		return;
    }
	else if (!strchr ("ATWRPKL", pAufenthalt->AUFART)) {
        if ((pAufenthalt->AUFART != 'G' || modelljahr < 2018) &&
            (pAufenthalt->AUFART != 'H' || modelljahr > 2018)) /* V2019.0: AUFART 'H' ungueltig ab Modell 2019 */
        { /* V22.0 - neue Aufnahmeart G fuer Neugeborene ab 2018 */
            Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorAUFARTfalsch2017 : &LKFErrorAUFARTfalsch, 0);
        }
	}

	if (pAufenthalt->lAufDat && pAufenthalt->lEntDat) {

		/* AUFART: <> L,R,P,K und VD>200 -> WARNING */
		if (strchr ("ATWH", pAufenthalt->AUFART) && pAufenthalt->GESVD > 200) {
			/* Plaus_Warn (pAufenthalt, VD_LANG, 0); */
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAUFARTBelagsdauer, 0);
		}

		/* AUFART: Tagesklinik K und VD>1 Tag -> WARNING */
		/* V15.0: ab Modell 2011 Warning bei K und > 0 Tage */
		if (pAufenthalt->AUFART == 'K' && (pAufenthalt->GESVD > 1
			 || (pAufenthalt->GESVD > 0 && modelljahr >= 2011))) {
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAUFARTBelagsdauer, 0);
		}
	}

	if (modelljahr >= 2010)
	{   /* V14.2: ab 2008 muss fuer 19er-Aufnahme die AUFART P sein */
		if (pAufenthalt->AUFART != 'P' && pAufenthalt->AUFART != 'L' &&
			pAufenthalt->abt_anz >= 1 && !memcmp (pAufenthalt->abt[0].ABTFC, "19", 2))
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAufartPflege, 0, 0, 0);
		else if ((pAufenthalt->AUFART == 'P') &&
			pAufenthalt->abt_anz >= 1 && memcmp (pAufenthalt->abt[0].ABTFC, "19", 2))
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAufartPflege2_2010, 0, 0, 0);
		/* V12.1: EM2X nur mehr fuer AUFART=P */
	}
	else
	{   /* V12.0: ab 2008 muss fuer 19er-Aufnahme die AUFART P oder L sein */
		if (pAufenthalt->AUFART != 'P' && pAufenthalt->AUFART != 'L' &&
			pAufenthalt->abt_anz >= 1 && !memcmp (pAufenthalt->abt[0].ABTFC, "19", 2))
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAufartPflege, 0, 0, 0);
		else if ((pAufenthalt->AUFART == 'P' || (pAufenthalt->AUFART == 'L' && modelljahr>=2010)) && /* V14.0: AUFART=L hinzugefuegt */
			pAufenthalt->abt_anz >= 1 && memcmp (pAufenthalt->abt[0].ABTFC, "19", 2))
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAufartPflege2, 0, 0, 0);
		/* V12.1: EM2X nur mehr fuer AUFART=P, nicht fuer AUFART=L */
	}

    if (modelljahr < 2019) {
        if (pAufenthalt->psych_mode && pAufenthalt->psych_mode < 1024) { /* V7.0 */
            if (pAufenthalt->AUFART != 'H' && !pAufenthalt->isAmb) {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAUFARTABTFCfalsch, 0);
            }
        }
        else if (pAufenthalt->AUFART == 'H') {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAUFARTABTFCfalsch, 0);
        }
    }
}


static void HKLE_Check (LKF_AUFENTHALT *pAufenthalt)
{ /* V22.0 */
    unsigned int i;
    int found = 0;
    
    if (!memcmp (pAufenthalt->KOST, "BN", 2)) {
        for (i = 0; i < pAufenthalt->mel_anz; i++) {
            if (IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_ZZ050, pAufenthalt->mel[i].nMelIndex)) {
                found = 1;
                break;
            }
        }
        if (!found) {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorBNohneMEL, 0);
        }
    }
    else {
        for (i = 0; i < pAufenthalt->mel_anz; i++) {
            if (IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_ZZ050, pAufenthalt->mel[i].nMelIndex)) {
                
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneBN, i, 0, pAufenthalt->mel[i].nMelAbtIndex);
                break;
            }
        }
    }
    
}

/* Neue Kriterien fuer tagesklinische und tagesstrukturierende Psychatrie */
static void PSYCH_Check (LKF_AUFENTHALT *pAufenthalt)
{
	unsigned int i, abtindex = 0;
	char search_string[20];
	int psych;
	const SPEZ_LIST_STRING *pSpez;
	char sTraceLine[1024];
	unsigned int abtcount; /* V14.0 */
    int modelljahr;
    
    int strokeUnit; /* V2019.0 */
    LKF_CONTEXT *pContext = pAufenthalt->pScoringContext;

	psych = strokeUnit = 0;
    modelljahr = pContext->modelljahr;
    abtindex = 0;
    
    pAufenthalt->psych_flag = 0;
    
	if (!(pAufenthalt->pScoringContext->flags & LKFCONTEXT_ALLOWQUICKSCORE) || pAufenthalt->abt_anz > 0) {
	/* Ueberpruefung, ob irgendeine Abteilung eine tagesklinische oder tagesstrukturierende
	   Abteilung ist. */

		for (i = 0; (psych == 0 || pAufenthalt->isAmb) && i< pAufenthalt->abt_anz; i++) {
            psych = 0;
			sprintf (search_string, ".....%4.4s%8.8s", pAufenthalt->KANR, pAufenthalt->abt[i].ABTFC);
			
			pSpez = SpezInArray (pAufenthalt->pScoringContext, search_string);

			if (pSpez && !ABTFC_Spez_Check (pAufenthalt, (int) i, pSpez, 1))
			{
				pSpez = 0; /* V8.0 */
				if (LKF_IS_TRACE_DETAIL(pAufenthalt->pScoringContext->nTraceAufenthalt))
				{
					sprintf (sTraceLine, "PSYCH; Spez-Check; Suchstring '%s'; Gefunden: '%.*s', aber ungueltig (ABTFC_Spez_Check)", search_string, (int) sizeof(SPEZ_LIST_STRING), (const char *) pSpez);
					TRACE_DETAIL(pAufenthalt, i, sTraceLine);
				}
			}
			else if (!pSpez && IS_TRACE_DETAIL (pAufenthalt->pScoringContext))
			{
				sprintf (sTraceLine, "PSYCH; Spez-Check; Suchstring '%s'; nicht gefunden", search_string);
				TRACE_DETAIL(pAufenthalt, i, sTraceLine);
			}

			if (pSpez) {
				if (IS_TRACE_DETAIL (pAufenthalt->pScoringContext))
				{
					sprintf (sTraceLine, "PSYCH; Spez-Check; Suchstring '%s'; Gefunden: '%.*s'", search_string, (int) sizeof(SPEZ_LIST_STRING), (const char *) pSpez);
					if ((*pSpez)[0] != 'P' && (*pSpez)[0] != 'G' && (*pSpez)[0] != 'O' /* V15.0 */) strcat (sTraceLine, ", aber nicht relevant f\xc3\xbc""r PSYCH!");
					TRACE_DETAIL(pAufenthalt, i, sTraceLine);
				}
				if ((*pSpez)[0] == 'P') {
					if (!memcmp ((*pSpez) + 27, "TK", 2)) psych = 1;
					else if (!memcmp ((*pSpez) + 27, "TS", 2)) {

						if (modelljahr == 2013)
						{ /* V17.1 */
							if (!memcmp (pAufenthalt->AUFDAT, "2013", 4)) psych = 23;
							else
							{
								if (!memcmp (pAufenthalt->abt[i].ABTFC + 4, "85", 2)) psych = 2;
								else if (!memcmp (pAufenthalt->abt[i].ABTFC + 4, "86", 2)) psych = 3;
								else psych = 23;
							}


						} 
						else if (modelljahr > 2013) psych = 23; /* V17.1 */
						else if (!memcmp (pAufenthalt->abt[i].ABTFC + 4, "85", 2)) psych = 2;
						else psych = 3;
					}
					abtindex = i;
				}

				/* AG/R tagesklinisch */
				else if ((*pSpez)[0] == 'G' && !memcmp ((*pSpez) + 27, "TK", 2)) {
					psych = 4; 
					abtindex = i;
				}

				/* PSYCHOSOMATIK */
				else if ((*pSpez)[0] == 'O' && ((modelljahr >= 2022 &&  !memcmp ((*pSpez) + 27, "ET", 2))
                                                || (modelljahr >= 2011 && modelljahr < 2022 && !memcmp ((*pSpez) + 27, "TK", 2))))
				{
					psych = 5;
					abtindex = i;
				}
                else if ((*pSpez)[0] == 'O' && modelljahr >= 2022 &&  !memcmp ((*pSpez) + 27, "KT", 2))
                {
                    psych = 8;
                    abtindex = i;
                }
				else if (modelljahr >= 2013 && (*pSpez)[0] == 'J' && !memcmp ((*pSpez) + 27, "TK", 2))
				{ /* V17.0 */
					psych = 6; 
					abtindex = i;
				}
                
                else if (modelljahr >= 2017 && (*pSpez)[0] == 'J' && !memcmp ((*pSpez) + 27, "TS", 2)) {
                    psych = 7;
                    abtindex = i;
                }
                else if (modelljahr >= 2019 && (*pSpez)[0] == 'S') {
                    if ((*pSpez)[27] == '0' && (*pSpez)[28] == '1') {
                        strokeUnit = 1;
                    }
                }
                
                if (psych) {

					if (pAufenthalt->isAmb)
					{
						int found = 0;
						unsigned int j;

						for (j = 0; !found && j< pAufenthalt->mel_anz; j++) 
						{
							switch (psych) {
							case 1:
								if (IsConstMEL (pContext, CONSTMEL_AM060_7596, pAufenthalt->mel[j].nMelIndex))
									found = 1;
                                else if (pContext->modelljahr >= 2018) {
                                    if (IsConstMEL (pContext, CONSTMEL_AM070_7597, pAufenthalt->mel[j].nMelIndex))
                                        found = 1;
                                    else if (IsConstMEL (pContext, CONSTMEL_AM080_7598, pAufenthalt->mel[j].nMelIndex))
                                        found = 1;
                                }
								break;
							case 23:
								if (IsConstMEL (pContext, CONSTMEL_AM070_7597, pAufenthalt->mel[j].nMelIndex))
									found = 1;
								else if (IsConstMEL (pContext, CONSTMEL_AM080_7598, pAufenthalt->mel[j].nMelIndex))
									found = 1;
								break;
							case 4:
								if (IsConstMEL (pContext, CONSTMEL_AM090_7601, pAufenthalt->mel[j].nMelIndex))
									found = 1;
								break;
							case 5:
								if (IsConstMEL (pContext, CONSTMEL_AM110, pAufenthalt->mel[j].nMelIndex))
									found = 1;
								break;
                            case 8: /* V2022.0 */
                                if (IsConstMEL (pContext, CONSTMEL_AM150, pAufenthalt->mel[j].nMelIndex))
                                    found = 1;
                                break;
							case 6:
								if (IsConstMEL (pContext, CONSTMEL_AM120, pAufenthalt->mel[j].nMelIndex))
									found = 1;
                                if (modelljahr >= 2017 && IsConstMEL (pContext, CONSTMEL_AM130, pAufenthalt->mel[j].nMelIndex))
                                    found = 1;
								break;
							case 7:
								if (IsConstMEL (pContext, CONSTMEL_AM130, pAufenthalt->mel[j].nMelIndex))
									found = 1;
								break;
							default:
								break;
							}
						}

						if (!found)
							psych = 0;
					}

					if (psych) {
                        if (psych == 23)
                            pAufenthalt->psych_flag |= (1<<2) + (1<<3);
                        else
                            pAufenthalt->psych_flag |= (1<<psych);
					}
                }
                if (strokeUnit) {
                    int needsDiag = 1;
                    unsigned int j;
                    
                    for (j = 0; j < pAufenthalt->mel_anz; j++) {
                        if (IsConstMEL(pContext, CONSTMEL_AA040_7401, pAufenthalt->mel[j].nMelIndex)) {
                            needsDiag = 0;
                            break;
                        }
                    }
                    
                    if (needsDiag) {
                        needsDiag = 0;
                        for (j = 0; j < pAufenthalt->diag_anz; j++) {
                            if (!memcmp (pAufenthalt->diag[j].DIAG, "I61", 3) || !memcmp (pAufenthalt->diag[j].DIAG, "I63", 3)) {
                                needsDiag = 1;
                                break;
                            }
                        }
                    }
                    
                    
                    if (needsDiag) {
                        Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorStrokeOhneLeistung, i, 0, i);
                    }
                    
                }
			}
		}

        if (pAufenthalt->isAmb)
        { /* V21.2 */
            int psychmel = 0;
            int psychflag = pAufenthalt->psych_flag;
            
            for (i = 0; !psychmel && i < pAufenthalt->mel_anz; i++) {
                if ((psychflag & 14) && MELInIndexList (pAufenthalt->pScoringContext, MEL_PLAUS_PSYCH1, pAufenthalt->mel[i].nMelIndex)) psychmel = 1;
                else if ((psychflag & 16) && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM090_7601, pAufenthalt->mel[i].nMelIndex)) psychmel = 1;
                else if ((psychflag & 32) && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM110, pAufenthalt->mel[i].nMelIndex)) psychmel = 1;
                else if ((psychflag & 64) && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM120, pAufenthalt->mel[i].nMelIndex)) psychmel = 1;
                else if ((psychflag & 128) && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM130, pAufenthalt->mel[i].nMelIndex)) psychmel = 1;
                else if ((psychflag & 256) && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM150, pAufenthalt->mel[i].nMelIndex)) psychmel = 1;
                else if (modelljahr >= 2017 && (psychflag & 64) && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM130, pAufenthalt->mel[i].nMelIndex)) psychmel = 1;
                
            }
            
            if (!psychmel) psych = 1024;
            else psych = 0;
        }
        
        else if (psych)
        {
			int psychmel = 0;

            for (i = 0; !psychmel && i < pAufenthalt->mel_anz; i++) {
                if ((psych == 1 || psych == 2 || psych == 3 || psych == 23 /* V17.1 */) && MELInIndexList (pAufenthalt->pScoringContext, MEL_PLAUS_PSYCH1, pAufenthalt->mel[i].nMelIndex)) psychmel = 1;
                else if (psych == 4 && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM090_7601, pAufenthalt->mel[i].nMelIndex)) psychmel = 1;
                else if (psych == 5 && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM110, pAufenthalt->mel[i].nMelIndex)) psychmel = 1; /* V15.0 */
                else if (psych == 6 && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM120, pAufenthalt->mel[i].nMelIndex)) psychmel = 1; /* V17.0 */
                else if (psych == 7 && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM130, pAufenthalt->mel[i].nMelIndex)) psychmel = 1; /* V17.0 */
                else if (psych == 8 && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM150, pAufenthalt->mel[i].nMelIndex)) psychmel = 1; /* V17.0 */
                else if (modelljahr >= 2017 && psych == 6 && IsConstMEL (pAufenthalt->pScoringContext, CONSTMEL_AM130, pAufenthalt->mel[i].nMelIndex)) psychmel = 1; /* V17.0 */
            }

			if ((pAufenthalt->pScoringContext->flags & LKFCONTEXT_ALLOWQUICKSCORE) && pAufenthalt->AUFART == ' ' && pAufenthalt->ENTART == ' ') {
				if (!psychmel || pAufenthalt->pScoringContext->modelljahr >= 2019) {
					pAufenthalt->AUFART = 'A';
					pAufenthalt->ENTART = 'E';
					psych |= 1024;
				}
				else {
					pAufenthalt->AUFART = 'H';
					pAufenthalt->ENTART = 'H';
				}
				
			}

            if (pAufenthalt->AUFART != 'H') {
                psych |= 1024;
            }
			else if (!psychmel) {
				Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSpezOhneLeistung, 0);
			}

			abtcount = pAufenthalt->abt_anz;
			if (abtcount > 1 && pAufenthalt->pScoringContext->modelljahr >= 2010)
			{
				for (i = 1; i < pAufenthalt->abt_anz; i++)
				{
					if (!memcmp (pAufenthalt->abt[i].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN) ||
						!memcmp (pAufenthalt->abt[i].ABTFC, pAufenthalt->abt[0].ABTFC, 8))
						abtcount--;
				}
			}

			if (abtcount > 1 && psych < 1024 && modelljahr < 2019)
				Satzart_ReportMBDSError (pAufenthalt, &LKFErrorVerlSpezUngueltig, 1);
		}
	}
	pAufenthalt->psych_mode = psych;
}
/* procedure ABTFC_Spez_Check ******************************************
**    Ueberpruefung, ob die Abteilung fuer den speziellen Leistungs-  **
**    bereich geeignet ist und es wird eine Warning erzeugt, wenn     **
**    das nicht der Fall ist (V8.0)                                   **
***********************************************************************/

/* lkf_check_spez_abtfc *****************************************************
**    Ueberprueft, ob der Abteilungs-Funktionscode fuer den Spezialbereich **
**    gueltig ist (1 = ok, 2 = nicht)                                      **
****************************************************************************/


int abt_in_patternlist (const char *abt, const char **ppValidABTFCs)
{
	const char *cand_abt;
	unsigned int k, j = 0;

	while (ppValidABTFCs[j]) {
		cand_abt = ppValidABTFCs[j++];
		for (k = 0; k < LKF_AUFENTHALT_ABTFC_LEN && (cand_abt[k] == 'x' || cand_abt[k] == abt[k]) ; k++) ;
		if (k == LKF_AUFENTHALT_ABTFC_LEN) return 1;
	}

	return 0;
}


static int isBereich (const char *Bereich, char b)
{
	if ((Bereich[0] == b && Bereich[1] == ' ') ||
		(Bereich[0] == ' ' && Bereich[1] == b)) return 1;
	else return 0;
}

static void lkf_plaus_hasintscoring (LKF_AUFENTHALT *pAufenthalt, int abtid, int uebw)
{
    LKF_CONTEXT *pContext = pAufenthalt->pScoringContext;
    const LKF_INT_AUFENTHALT *pIntAufenthalt;
 
    if (pContext->flags & LKFCONTEXT_NUR_MBDS) {
        return;
    }
    
#ifdef SUPPORT_PRE2017
    if (pContext->modelljahr < 2014 && (pContext->flags & LKFCONTEXT_NICHTFONDSKA)) {
        return;
    }
#endif

    if (pAufenthalt->abt[abtid].ABTVD == 0 && pContext->modelljahr < 2019 /* V2019.1 */ &&
        ((pAufenthalt->ENTART != LKF_ENTART_REVERS && pAufenthalt->ENTART != 'S' && pAufenthalt->ENTART != 'T') || ((unsigned int) abtid + 1) < pAufenthalt->abt_anz))
        return;
    if (pAufenthalt->ENTART == 'V')
        return;

    pIntAufenthalt = pAufenthalt->pIntAufenthalt;
    
#ifdef SUPPORT_PRE2017
    if ((pIntAufenthalt->int01_count == 0 && pIntAufenthalt->int11_count == 0) ||
        (pIntAufenthalt->int02_count == 0 && pIntAufenthalt->int12_count == 0) ||
        !pIntAufenthalt->ppAbt[abtid]
        || (!pIntAufenthalt->ppAbt[abtid]->nInt01Count && !pIntAufenthalt->ppAbt[abtid]->nInt11Count)
        || (!pIntAufenthalt->ppAbt[abtid]->nInt02Count && !pIntAufenthalt->ppAbt[abtid]->nInt12Count))
    {

        if (uebw) /* V17.1 */
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorIntUebwEinhOhneVollstBer, (unsigned int) abtid, 0, abtid);
        else
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorIntEinhOhneVollstBer, (unsigned int) abtid, 0, abtid);
    }
#else
    if (pIntAufenthalt->int11_count == 0 || pIntAufenthalt->int12_count == 0 ||
        !pIntAufenthalt->ppAbt[abtid]
        || !pIntAufenthalt->ppAbt[abtid]->nInt11Count
        || !pIntAufenthalt->ppAbt[abtid]->nInt12Count)
    {

        if (uebw) /* V17.1 */
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorIntUebwEinhOhneVollstBer, (unsigned int) abtid, 0, abtid);
        else
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorIntEinhOhneVollstBer, (unsigned int) abtid, 0, abtid);
    }
#endif
}


int ABTFC_Spez_Check (LKF_AUFENTHALT *pAufenthalt, int abtid, const SPEZ_LIST_STRING *pSpez, int warn)
{
	const char *abtfc = pAufenthalt->abt[abtid].ABTFC;
    int ok = 1;
	char SpezTyp;
	const char *SpezBereich;
    int modelljahr;
	int error = 0;

    /* Funktionscodes bis Modell 2012 -> ab Modell 2013 in ABTFC_Spez_Match */
    static const char *SpezIE0[] = {"121117xx", "12xx81xx", 0};
	static const char *SpezIE123[] = {"12xx81xx", 0};
	static const char *SpezIK[] = {"125112xx", "125181xx", "122781xx", 0};
	static const char *SpezNB[] = {"126331xx", 0};
	static const char *SpezNC[] = {"136331xx", 0};
	static const char *SpezGA[] = {"1x1136xx", "1x6336xx", 0};
	static const char *SpezGTK[] = {"141136xx", "146336xx", 0};
	static const char *SpezL01[] = {"1x9137xx", 0};
	static const char *SpezJ[] = {"1x61xxxx", "1x62xxxx", "1x63xxxx", "1x64xxxx", "1x5115xx", "1x5163xx", "1x5168xx", 0};
	static const char *SpezPA1[] = {"1x61xxxx", "1x62xxxx", "1x64xxxx", "1x5115xx", "1x5163xx", "1xxx68xx", 0};
	static const char *SpezP0103[] = {"1x62xxxx", "1xxx68xx", 0};
	static const char *SpezPTK[] = {"1x6185xx", "1x6285xx", "1x6485xx", 0};
	static const char *SpezPTS[] =  {"1x6185xx", "1x6285xx", "1x6485xx", "1x6186xx", "1x6286xx", "1x6486xx", 0};
	static const char *SpezA[] = {"1x6215xx", 0};
	static const char *SpezR[] = {"1x9135xx", 0};
	static const char *SpezJ_2010[] = {"1x62xxxx", "1x63xxxx", "1x64xxxx", "1x5115xx", "1x5163xx", "1x5168xx", 0};
	static const char *SpezPA1_2010[] = {"1x62xxxx", "1x64xxxx", "1x5115xx", "1x5163xx", "1xxx68xx", 0};
	static const char *SpezPTK_2010[] = {"1x6285xx", "1x6485xx", 0};
	static const char *SpezPTS_2010[] =  {"1x6285xx", "1x6485xx", "1x6286xx", "1x6486xx", 0};
	static const char *SpezP0103_2011[] = {"1x62xxxx", 0};
	static const char *SpezPA1_2011[] = {"1x62xxxx", "1x64xxxx", "1x5115xx", "1x5163xx", 0};
	static const char *SpezO[] = {"1xxx68xx", 0}; /* V15.0 */
    static const char *SpezOKS[] = {"1x5168xx", "1x6468xx", 0}; /* AM140 */
    static const char *SpezOKT[] = {"165168xx", "166468xx", 0}; /* AM150 */
    
	const char **pSpezPattern;

	SpezTyp = (*pSpez)[0];
	SpezBereich = (*pSpez) + 27;

    modelljahr = pAufenthalt->pScoringContext->modelljahr;
    
	if (modelljahr >= 2013)
	{ /* V17.0 */
		int flag = 0; /* V17.1 */
		if (!memcmp (abtfc, "19", 2)) return 0; /* V8.0: 19xxxxxx-Abteilungen werden ignoriert, keine zusaetzliche Warning */
		
        if (pAufenthalt->isAmb) {
            if (modelljahr < 2021) {
                /* Kein AbtFC-Check fuer ambulante Leistungen */
                return 1;
            }
            ok = ABTFC_Spez_Match (pAufenthalt->pScoringContext, abtfc, SpezTyp, SpezBereich, 0);
        }
        else {
            if (modelljahr == 2013 && memcmp (pAufenthalt->abt[abtid].ABTDAT, "2013", 4)<0)
                flag = 1;
            
            ok = ABTFC_Spez_Match (pAufenthalt->pScoringContext, abtfc, SpezTyp, SpezBereich, flag);
            if (!ok && !flag && warn && modelljahr < 2021)
            {
                error = ABTFC_Spez_Match (pAufenthalt->pScoringContext, abtfc, SpezTyp, SpezBereich, 1);
            }
        }
	}
	else
	{
		if (!memcmp (abtfc, "19", 2)) return 0; /* V8.0: 19xxxxxx-Abteilungen werden ignoriert, keine zusaetzliche Warning */

		switch (SpezTyp) {
			case 'I':
				if (SpezBereich[0] == 'E') {
                    if (SpezBereich[1] == '0')
                        ok = abt_in_patternlist (abtfc, SpezIE0); /* V21.3 */
					else if (SpezBereich[1] >= '1' && SpezBereich[1] <= '3') ok = abt_in_patternlist (abtfc, SpezIE123);
				}
				else if (SpezBereich[0] == 'K') {
					if (SpezBereich[1] == '0' || SpezBereich[1] == '1') ok = abt_in_patternlist (abtfc, SpezIK);
				}

				break;
			case 'N':
				if (isBereich (SpezBereich, 'B')) 
					ok = abt_in_patternlist (abtfc, SpezNB);
				else if (isBereich (SpezBereich, 'C')) 
					ok = abt_in_patternlist (abtfc, SpezNC);
				break;
			case 'S':
				ok = 1;
				break;
			case 'R':
				ok = abt_in_patternlist (abtfc, SpezR);
				break;
			case 'M':
				ok = 1;
				break;
			case 'G':
				if (isBereich (SpezBereich, 'A')) 
					ok = abt_in_patternlist (abtfc, SpezGA);
				else if (!memcmp (SpezBereich, "TK", 2)) 
					ok = abt_in_patternlist (abtfc, SpezGTK);
				break;
			case 'L':
				if (!memcmp (SpezBereich, "01", 2)) ok = abt_in_patternlist (abtfc, SpezL01);
				break;
			case 'J':
				pSpezPattern = (modelljahr >= 2010) ? SpezJ_2010 : SpezJ;
				
				if (isBereich (SpezBereich, 'I')) 
					ok = abt_in_patternlist (abtfc, pSpezPattern);
				else if (isBereich (SpezBereich, 'R')) 
					ok = abt_in_patternlist (abtfc, pSpezPattern);
				else if (SpezBereich[0] == '0' && SpezBereich[1] >= '1' && SpezBereich[1] <= '3') 
					ok = abt_in_patternlist (abtfc, pSpezPattern);
				break;
			case 'P':
				if (!memcmp (SpezBereich, "A1", 2))
				{
					if (modelljahr >= 2011)
						ok = abt_in_patternlist (abtfc, SpezPA1_2011); /* V15.0 */
					else if (modelljahr == 2010)
						ok = abt_in_patternlist (abtfc, SpezPA1_2010);
					else
						ok = abt_in_patternlist (abtfc, SpezPA1);
				}
				else if (!memcmp (SpezBereich, "A2", 2) && modelljahr > 2010) /* V15.0 */
				{
					ok = abt_in_patternlist (abtfc, SpezPA1_2011);
				}
				else if (SpezBereich[0] == 'T' && SpezBereich[1] == 'K')
				{
					if (modelljahr >= 2010)
						ok = abt_in_patternlist (abtfc, SpezPTK_2010);
					else
						ok = abt_in_patternlist (abtfc, SpezPTK);
				}
				else if (SpezBereich[0] == 'T' && SpezBereich[1] == 'S')
				{
					if (modelljahr >= 2010)
						ok = abt_in_patternlist (abtfc, SpezPTS_2010);
					else
						ok = abt_in_patternlist (abtfc, SpezPTS);
				}
				else if (SpezBereich[0] == '0' && SpezBereich[1] >= '1' && SpezBereich[1] <= '3')
				{
					if (modelljahr >= 2011)
					ok = abt_in_patternlist (abtfc, SpezP0103_2011); /* V15.0 */ 
					else
					ok = abt_in_patternlist (abtfc, SpezP0103); 
				}
				break;
			case 'O':
                if (modelljahr >= 2022) {
                    
                    if (!memcmp (SpezBereich, "KS", 2)) {
                        ok = abt_in_patternlist (abtfc, SpezOKS);
                    }
                    else if (!memcmp (SpezBereich, "KT", 2)) {
                        ok = abt_in_patternlist (abtfc, SpezOKT);
                    }
                    else {
                        ok = abt_in_patternlist (abtfc, SpezO);
                    }
                }
                else {
                    ok = abt_in_patternlist (abtfc, SpezO); /* V15.0 */
                }
				break;
			case 'A':
				if (SpezBereich[0] == '0' && SpezBereich[1] >= '1' && SpezBereich[1] <= '3') 
					ok = abt_in_patternlist (abtfc, SpezA);
				break;
			default:
				ok = 1;
				break;
		}
	}

	if (ok && SpezTyp == 'I' && warn) 
	{
		if (SpezBereich[0] == 'E' && strchr ("123", SpezBereich[1]))
			lkf_plaus_hasintscoring (pAufenthalt, abtid, 0);
		else if (SpezBereich[0] == 'E' && SpezBereich[1] == '0' && (pAufenthalt->pScoringContext->flags & LKFCONTEXT_CHECKINTE0))
			lkf_plaus_hasintscoring (pAufenthalt, abtid, 1); /* V17.1 */
	}

	if (!ok && warn) {
		if (error)
		{
            if (modelljahr >= 2017)
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTFCSpezfalschError2017, (unsigned int) abtid, 0, abtid);
            else
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTFCSpezfalschError2013, (unsigned int) abtid, 0, abtid);
		}
		else {
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTFCSpezfalsch, (unsigned int) abtid, 0, abtid);
		}
	}
	return ok;
}

int ABTFC_SpezList_Match (LKF_CONTEXT *pContext, const SPEZ_LIST_STRING *pSpez)
{ /* V17.0 */
    const char *abtfc = (*pSpez) + 9;
    if (pContext->modelljahr >= 2021) {
        return ABTFC_Spez_Match (pContext, abtfc, (*pSpez)[0], (*pSpez) + 27, 0);
    }
    
    if (pContext->modelljahr >= 2017) {
        if (strchr("678", abtfc[1]) && abtfc[0] == '1')
            return 1;
    }
    
	return ABTFC_Spez_Match (pContext, abtfc, (*pSpez)[0], (*pSpez) + 27, 0);
}

int ABTFC_Spez_Match (LKF_CONTEXT *pContext, const char *abtfc, char SpezTyp, const char *SpezBereich, int flag)
{ /* V17.0 */
    int ok = 1;

    static const char *SpezIE0_2017[] = {"121117xx", "12xx81xx", "120617xx", "120717xx", 0};
	static const char *SpezIE0[] = {"121117xx", "12xx81xx", 0};
	static const char *SpezIE123[] = {"12xx81xx", 0};
	static const char *SpezIK[] = {"125112xx", "125181xx", "122781xx", 0};

	static const char *SpezR2012[] = {"1x9135xx", 0};
	static const char *SpezR[] = {"139135xx", 0};
	static const char *SpezGA2012[] = {"1x1136xx", "1x6336xx", 0};
	static const char *SpezGA[] = {"131136xx", "136336xx", 0};
    static const char *SpezGTK[] = {"141136xx", "146336xx", 0};
    static const char *SpezGTK_2021[] = {"161136xx", "166336xx", 0}; /* V2021.2 */
	static const char *SpezL01_2012[] = {"1x9137xx", 0};
    static const char *SpezL01[] = {"139137xx", 0};
    static const char *SpezL01_2021[] = {"139137xx", "135137xx", 0}; /* V2021.0 */
	static const char *SpezNB[] = {"126331xx", 0};
	static const char *SpezNC[] = {"136331xx", 0};

	static const char *SpezA[] = {"1x6215xx", 0};
	static const char *SpezO[] = {"1xxx68xx", 0};
    static const char *SpezOTK_2021[] = {"16xx68xx", 0}; /* V2021.2 */

	static const char *SpezS2012[] = {"1xxxxxxx", 0};
	static const char *SpezS[] = {"116381xx", 0};
	static const char *SpezP0103[] = {"1xxx68xx", 0};
	static const char *SpezJ[] = {"1x64xxxx", "1x5115xx", "1x5163xx", "1x5168xx", 0};
	static const char *SpezJE2014[] = {"1x62xxxx", "1x64xxxx", "1x5115xx", "1x5163xx", "1x5168xx", 0};
    static const char *SpezJTK[] = {"1464xxxx", 0};
	static const char *SpezPTK2012[] = {"1x6285xx", "1x6485xx", 0};
	static const char *SpezPTK[] = {"1462xxxx", "1464xxxx", 0};
	static const char *SpezPTS2012[] = {"1x6285xx", "1x6485xx", "1x6286xx", "1x6486xx", 0};
	static const char *SpezPTS[] = {"1462xxxx", "1464xxxx", 0};
    static const char *SpezPT_2021[] = {"1662xxxx", "1664xxxx", 0}; /* V2021.2 */
    static const char *SpezPA1[] = {"1x62xxxx", "1x64xxxx", "1x5115xx", "1x5163xx", 0};
    
	switch (SpezTyp) {
		case 'I':

			if (SpezBereich[0] == 'E') {
                if (SpezBereich[1] == '0') ok = abt_in_patternlist (abtfc, pContext->modelljahr >= 2017 ? SpezIE0_2017 : SpezIE0); /* V21.3 */
				else if (SpezBereich[1] >= '1' && SpezBereich[1] <= '3') ok = abt_in_patternlist (abtfc, SpezIE123);
			}
			else if (SpezBereich[0] == 'K') {
				if (SpezBereich[1] == '0' || SpezBereich[1] == '1') ok = abt_in_patternlist (abtfc, SpezIK);
			}

			break;
		case 'R': /* V11.0 */
			ok = abt_in_patternlist (abtfc, SpezR);
			if (!ok && flag && pContext->modelljahr < 2021) ok = abt_in_patternlist (abtfc, SpezR2012);
			break;
		case 'G':
			if (isBereich (SpezBereich, 'A')) 
			{
				ok = abt_in_patternlist (abtfc, SpezGA);
				if (!ok && flag && pContext->modelljahr < 2021) ok = abt_in_patternlist (abtfc, SpezGA2012);
			}
            else if (!memcmp (SpezBereich, "TK", 2)) {
                if (pContext->modelljahr >= 2021) { /* V2021. 2*/
                    ok = abt_in_patternlist (abtfc, SpezGTK_2021);
                }
                else {
                    ok = abt_in_patternlist (abtfc, SpezGTK);
                }
            }
			break;
		case 'L':
			if (!memcmp (SpezBereich, "01", 2)) 
			{
                ok = abt_in_patternlist (abtfc, pContext->modelljahr >= 2021 ? SpezL01_2021 : SpezL01);
				if (!ok && flag && pContext->modelljahr < 2021) ok = abt_in_patternlist (abtfc, SpezL01_2012);
			}
			break;
		case 'N':
			if (isBereich (SpezBereich, 'B')) 
				ok = abt_in_patternlist (abtfc, SpezNB);
			else if (isBereich (SpezBereich, 'C')) 
				ok = abt_in_patternlist (abtfc, SpezNC);
			break;
		case 'S':
			ok = abt_in_patternlist (abtfc, SpezS);
			if (!ok && flag && pContext->modelljahr < 2021) ok = abt_in_patternlist (abtfc, SpezS2012);
			break;
		case 'O':
            if (pContext->modelljahr >= 2021 && !memcmp (SpezBereich, "TK", 2)) {
                ok = abt_in_patternlist (abtfc, SpezOTK_2021);
            }
            else {
                ok = abt_in_patternlist (abtfc, SpezO); /* V15.0 */
            }
            break;
		case 'A':
			if (SpezBereich[0] == '0' && SpezBereich[1] >= '1' && SpezBereich[1] <= '3') 
				ok = abt_in_patternlist (abtfc, SpezA);
			break;
		case 'M':
			ok = 1;
			break;
		case 'J':

            if (pContext->modelljahr >= 2022) {
                ok = abt_in_patternlist (abtfc, SpezJE2014);
            }
            else if (pContext->modelljahr >= 2021) {
                if (isBereich(SpezBereich, 'E'))
                {
                    ok = abt_in_patternlist (abtfc, SpezJE2014);
                }
                else {
                    ok = abt_in_patternlist (abtfc, SpezJ);
                }
            }
			else if (!memcmp (SpezBereich, "TK", 2))
			{
				ok = abt_in_patternlist (abtfc, SpezJTK);
			}
			else if (isBereich(SpezBereich, 'E') && pContext->modelljahr>= 2014)
            { /* V18.0 */
				ok = abt_in_patternlist (abtfc, SpezJE2014);
            }
            else
			{
				ok = abt_in_patternlist (abtfc, SpezJ);
			}
			break;
		case 'P':
			if (!memcmp (SpezBereich, "A1", 2))
			{
				ok = abt_in_patternlist (abtfc, SpezPA1);
			}
			else if (!memcmp (SpezBereich, "A2", 2))
			{
				ok = abt_in_patternlist (abtfc, SpezPA1);
			}
			else if (SpezBereich[0] == 'T' && SpezBereich[1] == 'K')
			{
                if (pContext->modelljahr >= 2021) {
                    ok = abt_in_patternlist (abtfc, SpezPT_2021);
                }
                else {
                    ok = abt_in_patternlist (abtfc, SpezPTK);
                    if (!ok && flag) ok = abt_in_patternlist (abtfc, SpezPTK2012);
                }
			}
			else if (SpezBereich[0] == 'T' && SpezBereich[1] == 'S')
			{
                if (pContext->modelljahr >= 2021) {
                    ok = abt_in_patternlist (abtfc, SpezPT_2021);
                }
                else {
                    ok = abt_in_patternlist (abtfc, SpezPTS);
                    if (!ok && flag) ok = abt_in_patternlist (abtfc, SpezPTS2012);
                }
			}
            else if (SpezBereich[0] == '0' && SpezBereich[1] >= '1' && SpezBereich[1] <= '3') {
                if (pContext->modelljahr >= 2021) {
                    ok = 0;
                }
                else {
                    ok = abt_in_patternlist (abtfc, SpezP0103);
                }
            }
			break;
		default:
			ok = 1;
			break;
	}

	return ok;
}

static int lkf_setAltersGruppe (char *alterGruppe, const char *gebdat, const char *curdat) {
    
    
    long alter = (curdat[0]-gebdat[0])*1000 + (curdat[1]-gebdat[1]) * 100 + (curdat[2]-gebdat[2]) * 10 + curdat[3] - gebdat[3];
    
    if (alter >= 0 && alter <= 200) {
        if (strncmp (gebdat + 4, curdat + 4, 4) > 0) --alter;
        if (alter >= 1 && alter < 5) alter = 1;
        else if (alter > 95) alter = 95;
        else alter = alter / 5 * 5;
        sprintf (alterGruppe, "%-3ld", alter); /* 19.1 */
        return 1;
    }
    return 0;
}

/* procedure ABTFC_Check ***********************************************
**    \xc3\x9c""berpr\xc3\xbc""fung der Abteilungs-Funktionscodes, und zwar             **
**        - ob, sie ein ABTDAT haben (sonst ABTFC_DAT_FEHLT)          **
**        - ob sie g\xc3\xbc""ltig sind (sonst ABTFC_FALSCH)                   **
***********************************************************************/

static void ABTFC_Check (LKF_AUFENTHALT *pAufenthalt)
{
	int bNur19;
	int bLast19;
	unsigned int i;
	char help_string[5];
	int v;
    LKF_CONTEXT *pContext;
    LKF_AUFENTHALT_ABT *pAbt;
#ifdef SUPPORT_PRE2017
	const LKF_INT_SCORING_ABT *pIntAbt;
#endif
	int check_chrono_pos;
    int neonatCheck;

	/* ABTFC: Keine Abteilung definiert */
	if (!pAufenthalt->abt_anz || !atoi (pAufenthalt->abt[0].ABTFC)) {
		Satzart_ReportMBDSError (pAufenthalt, &LKFErrorABTFCfehlt, 0);	
	}
    
    pContext = pAufenthalt->pScoringContext;

    check_chrono_pos = 1;
    
    neonatCheck = (pContext->modelljahr >= 2015 && ((pContext->isBM & 2) || (!pContext->isBM && (FILL_ALTERSGRUPPE(pAufenthalt) ||(pContext->flags & LKFCONTEXT_FILL_BMG)))));
    
    if (pContext->modelljahr >= 2017) {
        unsigned int expected_pos = 1;
        char pos[4];
        char *endpos;
        expected_pos = 1;
        for (i = 0; i < pAufenthalt->abt_anz; i++) {
            pAbt = pAufenthalt->abt + i;
            strncpy (pos, pAufenthalt->abt[i].ABTPOS, 3);
            pos[3] = 0;
            pAbt->abtposNumeric = (unsigned int) strtoul(pos, &endpos, 10);
            while (*endpos == ' ') ++endpos;
            if (*endpos) {
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAbtPosNrFalsch, i, 0, (int) i);
                check_chrono_pos = 0;
            }
            else if (check_chrono_pos && pAbt->abtposNumeric != expected_pos++) {
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAbtPosNrNichtVollst, i, 0, (int) i);
                check_chrono_pos = 0;
            }
        }
    }
    else {
        char expected_posnr[4];
        
        strcpy (expected_posnr, "01");
        for (i = 0; i < pAufenthalt->abt_anz; i++) {
            pAbt = pAufenthalt->abt + i;
            if (((pAbt->ABTPOS[0] < '0' || pAbt->ABTPOS[0] > '9') && pAbt->ABTPOS[0] != ' ' && pAbt->ABTPOS[0]) ||
                pAbt->ABTPOS[1] < '0' || pAbt->ABTPOS[1] > '9')
            {
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAbtPosNrFalsch, i, 0, (int) i);
                check_chrono_pos = 0;
            }
            else if (check_chrono_pos && strncmp (pAbt->ABTPOS, expected_posnr, 2))
            {
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAbtPosNrNichtVollst, i, 0, (int) i);
                check_chrono_pos = 0;
            }
            if (check_chrono_pos) {
                
                if (expected_posnr[1] == '9') {
                    expected_posnr[1] = '0';
                    expected_posnr[0]++;
                }
                else expected_posnr[1]++;
            }
        }
        
    }
    
    bNur19 = 1;
	bLast19 = -1;
	for (i = 0; bNur19 && i < pAufenthalt->abt_anz; i++)
	{
		pAbt = pAufenthalt->abt + i;
        if (neonatCheck) pAbt->ISNEONAT = ' ';
		if (!IsBlank (pAbt->ABTFC, 8)) {
			if (memcmp (pAbt->ABTFC, "19", 2)) bNur19 = 0;
		}
	}

	for (i = 0; i < pAufenthalt->abt_anz; i++) {
		pAbt = pAufenthalt->abt + i;
		if (!IsBlank (pAbt->ABTFC, 8)) {

			/* ABTFC: kein ABTDAT vorhanden -> ERROR */
			if (IsBlank (pAbt->ABTDAT, 8)) {
                Satzart_ReportMBDSError2 (pAufenthalt, pAufenthalt->pScoringContext->modelljahr >= 2017 ? &LKFErrorABTDATfehlt2017 : &LKFErrorABTDATfehlt, i, 0, (int) i);
			}

            if (neonatCheck) {
                lkf_setNeonatologie (pAufenthalt, i);
                lkf_setAltersGruppe (pAbt->ALTERSGRUPPE, pAufenthalt->GEBDAT, pAbt->ABTDAT);
            }

			if (pContext->modelljahr >= 2010 && !memcmp (pAbt->ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
				continue;

			/* ABTFC 1-5: FC ungueltig -> ERROR */
			memcpy (help_string, pAbt->ABTFC, 2);
			help_string[2] = 0;
			v = atoi (help_string);

			
            if ((bLast19 == 0 && v == 19) || (bLast19 == 1 && v != 19))
            {
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorVerlAkutPflege, i, 0, (int) i);
            }
            bLast19 = (v == 19) ? 1 : 0;
				
			if ((pAufenthalt->isAmb && (v == 16 || v == 17 || v == 18)) ||
                (!pAufenthalt->isAmb && ((v >= 11 && v <= 15) || v == 19))) {
				if (v != 19) {

                    int funkOK = 1;
                    if (pContext->modelljahr >= 2017)
                    {
                        if (!FunkInArray(pContext->pStamm2001, pAbt->ABTFC))
                            funkOK = 0;
                    }
                    else
                    {
                        GetInt (pAbt->ABTFC + 2, 4, &v);
                        if (!pContext->pStamm2001->funk_quick[v]) {
                            funkOK = 0;
                        }
                    }
                    
                    if (!funkOK) {
                        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTFCfalsch, i, 0, (int) i);
                        
                    }
					else if (pContext->modelljahr == 2013 && !memcmp (pAbt->ABTDAT, "2013", 4))
					{ /* V17.1 */
						if (v == 2114 || v == 2116 || v == 7212 || v == 7216 || v == 7217 || v == 7218 || v == 7273) 
						{ 
							Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAbtFC2013falsch, i, 0, (int) i);
						}
					}
				}
#ifdef SUPPORT_PRE2017
                if (pAufenthalt->pScoringContext->modelljahr >= 2017) {
                    int needsIntAbt = !(pContext->flags & LKFCONTEXT_NUR_MBDS) && pAufenthalt->pIntAufenthalt && pAufenthalt->pIntAufenthalt->ppAbt && pAufenthalt->pIntAufenthalt->ppAbt[i];
                    lkf_plaus_abtcheck_2017(pAufenthalt, (int) i, pAbt, needsIntAbt);
                }
                else if (pContext->modelljahr >= 2014) {
                    if (!(pContext->flags & LKFCONTEXT_NUR_MBDS) && pAufenthalt->pIntAufenthalt && pAufenthalt->pIntAufenthalt->ppAbt) {
						pIntAbt = pAufenthalt->pIntAufenthalt->ppAbt[i];
						if (pIntAbt) lkf_plaus_intabtcheck (pAufenthalt, (int) i, pAbt, pIntAbt);
                    }
				}
                else if (!(pContext->flags & (LKFCONTEXT_NICHTFONDSKA | LKFCONTEXT_NUR_MBDS))) 
				{
					if (pAufenthalt->pIntAufenthalt && pAufenthalt->pIntAufenthalt->ppAbt) {
						pIntAbt = pAufenthalt->pIntAufenthalt->ppAbt[i];
						if (pIntAbt) lkf_plaus_intabtcheck (pAufenthalt, (int) i, pAbt, pIntAbt);
					}
				}
#else
                lkf_plaus_abtcheck_2017(pAufenthalt, (int) i , pAbt,
                                        !(pContext->flags & LKFCONTEXT_NUR_MBDS) && pAufenthalt->pIntAufenthalt && pAufenthalt->pIntAufenthalt->ppAbt && pAufenthalt->pIntAufenthalt->ppAbt[i]);
#endif
                if (pContext->isBM) {
                    if ((pContext->modelljahr >= 2017 && pAbt->ISNEONAT == ' ') /* V17.0 */ || !strchr (" JN", pAbt->ISNEONAT)) {
                        Satzart_ReportMBDSError2 (pAufenthalt, &LKFError_AbtNeugeborenesFalsch, i, 0, (int) i);
                    }

                    if (!pAbt->ALTERSGRUPPE[0]) {
                        Satzart_ReportMBDSError2(pAufenthalt, &LKFError_AbtAlterGruppeFehlt, i, 0, (int) i);
                    }
                    else {
                        int j = 0, throwError = 0;
                    
                        while (j < 3 && pAbt->ALTERSGRUPPE[j] == ' ') ++j;
                        
                        for (; pAbt->ALTERSGRUPPE[j] && pAbt->ALTERSGRUPPE[j] != ' '; j++) {
                            if (pAbt->ALTERSGRUPPE[j] < '0' || pAbt->ALTERSGRUPPE[j] > '9') {
                                throwError = 1;
                                break;
                            }
                        }
                    
                        if (!throwError) {
                            for (; j < 3 && pAbt->ALTERSGRUPPE[j]; j++) {
                                if (pAbt->ALTERSGRUPPE[j] != ' ') {
                                    throwError = 1;
                                    break;
                                }
                            }
                        }
                        
                        if (!throwError) {
                            int alter = atoi (pAbt->ALTERSGRUPPE);
                            
                            if (alter > 95 || ((alter % 5 != 0) && (alter != 1))) {
                                throwError = 1;
                            }

                        }
                        
                        if (throwError) {
                            Satzart_ReportMBDSError2(pAufenthalt, &LKFError_AbtAlterGruppeFalsch, i, 0, (int) i);
                        }
                    }
                }
			}
			else {
				Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTFCfalsch, i, 0, (int) i);
			}
            
            if (pContext->modelljahr >= 2017) {
                if (!IsBlank(pAbt->PFLEGFC, 8)) {
                    if (!FunkInArray (pContext->pStamm2001, pAbt->PFLEGFC)) {
                        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorPflegFCfalsch, i, 0, (int) i);
                    }
                    
                }
                if (!IsBlank(pAbt->FACHFC, 8)) {
                    if (pContext->modelljahr >= 2021) {
                        if (!FunkInArray(pContext->pStamm2001, pAbt->FACHFC)) { /* V2021.0 -> FACHFC */
                            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorFachFCfalsch, i, 0, (int) i);
                        }
                    }
                    else if (!FunkInArray(pContext->pStamm2001, pAbt->PFLEGFC)) { /* buggy bis Modell 2020 */
                        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorFachFCfalsch, i, 0, (int) i);
                    }
                }
            }
		}
		else  
		{
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTFCfehlt, i, 0, (int) i);
            if (neonatCheck) { /* V20.0 */
                lkf_setNeonatologie (pAufenthalt, i);
                lkf_setAltersGruppe (pAbt->ALTERSGRUPPE, pAufenthalt->GEBDAT, pAbt->ABTDAT);
            }
		}
	}
}

/***************************************************************************************************
** lkf_plaus_intabtcheck (V8.1):                                                                  **
**      Ueberpruefung der Intensiv-Meldung von Satzart M02.                                         **
***************************************************************************************************/

#ifdef SUPPORT_PRE2017
static int lkf_isIntNeu (LKF_AUFENTHALT *pAufenthalt, int abtid)
{
	const LKF_INT_AUFENTHALT *pIntAufenthalt = pAufenthalt->pIntAufenthalt;
	if (!pIntAufenthalt->int01_count && !pIntAufenthalt->int02_count && !pIntAufenthalt->int03_count)
		return 1;
	if (!pIntAufenthalt->int11_count && !pIntAufenthalt->int12_count)
		return 0;
	if (!pIntAufenthalt->ppAbt[abtid])
		return 1;
	if (pIntAufenthalt->ppAbt[abtid]->nInt01Count || pIntAufenthalt->ppAbt[abtid]->nInt02Count || pIntAufenthalt->ppAbt[abtid]->nInt03Count)
		return 0;
	return 1;
}
#endif

void lkf_plaus_abtcheck_2017 (LKF_AUFENTHALT *pAufenthalt, int abtid, LKF_AUFENTHALT_ABT *pAbt, int needsInt)
{
	int lAbtEntDat, lAbtAufDat;
	int lAbtEntZeit, lAbtAufZeit;
    int modelljahr;
	char cAbArt;

    if (!pAufenthalt->pScoringContext->model2017errors)
        return;

    modelljahr = pAufenthalt->pScoringContext->modelljahr;
    
    /* Ueberpruefung des Abteilungs-Entlassungsdatums */
	if (IsEmpty (pAbt->ENTDAT, 8)) {
        if (needsInt) {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTDATfehlt, (unsigned int) abtid, 0, abtid);
        }
		lAbtAufDat = 0;
		lAbtEntDat = 0;
	}
	else {
        if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            lAbtAufDat = (int) lkf_dat2int (pAbt->ABTDAT);
            lAbtEntDat = (int) lkf_dat2int (pAbt->ENTDAT);
        }
        else {
            lAbtAufDat = (int) lkf_dat2intStrict (pAbt->ABTDAT);
            lAbtEntDat = (int) lkf_dat2intStrict (pAbt->ENTDAT);
        }
        
		if (!lAbtEntDat) {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTDATfalsch, (unsigned int) abtid, 0, abtid);
		}
		else if ((pAufenthalt->lAufDat && lAbtEntDat < pAufenthalt->lAufDat) ||
					(pAufenthalt->lEntDat && lAbtEntDat > pAufenthalt->lEntDat) ||
					(lAbtAufDat && lAbtEntDat < lAbtAufDat))
		{
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTDATaussAufenthalt, (unsigned int) abtid, 0, abtid);
		}
		else if (lAbtEntDat) {
			int lNextAufDat;
			if (abtid + 1 < (int)pAufenthalt->abt_anz) lNextAufDat = (int) lkf_dat2int (pAufenthalt->abt[abtid+1].ABTDAT);
			else lNextAufDat = (int) pAufenthalt->lEntDat;
			if (lNextAufDat && lNextAufDat != lAbtEntDat) {

                if (lAbtEntDat < lNextAufDat) {
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorVerlegungenLoechrig, (unsigned int) abtid, 0, abtid);
                }
                else {
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorVerlegungenUeberlapp, (unsigned int) abtid, 0, abtid);
                }
			}
		}
	}
	/* Ueberpruefung der Abteilungs-Aufnahmezeit */
	if (IsEmpty (pAbt->ABTZEIT, 4)) {
		lAbtAufZeit = 0;
        if (needsInt) {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTZEITfehlt, (unsigned int) abtid, 0, abtid);
        }
	}
	else {
        if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            lAbtAufZeit = (int) lkf_time2intStrict (pAbt->ABTZEIT);
        }
        else {
            lAbtAufZeit = (int) lkf_time2int (pAbt->ABTZEIT);
        }
		
		if (!lAbtAufZeit) 
		{
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTZEITfalsch, (unsigned int) abtid, 0, abtid);
		}
	}

	/* Ueberpruefung der Abteilungs-Entlassungszeit */
	if (IsEmpty (pAbt->ENTZEIT, 4))
	{
		lAbtEntZeit = 0;
        if (needsInt) {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTZEITfehlt, (unsigned int) abtid, 0, abtid);
        }
	}
	else 
	{
        if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            lAbtEntZeit = (int) lkf_time2intStrict (pAbt->ENTZEIT);
        }
        else {
            lAbtEntZeit = (int) lkf_time2int (pAbt->ENTZEIT);
        }

		if (!lAbtEntZeit) 
		{
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTZEITfalsch, (unsigned int) abtid, 0, abtid);
		}
	}

	if (lAbtAufDat && lAbtAufDat == lAbtEntDat && lAbtEntZeit && lAbtAufZeit &&
		lAbtAufZeit > lAbtEntZeit)
	{
		Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorEntVorAufZeit, (unsigned int) abtid, 0, abtid);
	}

	/* Ueberpruefung der Abgangsart */
    cAbArt = pAbt->ENTART;
	if (cAbArt == ' ' || cAbArt == 0)
	{
        if (needsInt) {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTARTfehlt, (unsigned int) abtid, 0, abtid);
        }
	}
	else if (!strchr ("1234", cAbArt)) 
	{
		Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTARTfalsch, (unsigned int) abtid, 0, abtid);
	}
	else if (strchr ("34", cAbArt) && pAufenthalt->ENTART != 'S') 
	{
		Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTARTKombENTART, (unsigned int) abtid, 0, abtid);
	}
	else if (pAufenthalt->ENTART == 'S') {
        if (abtid + 1 == (int) pAufenthalt->abt_anz)
        {
            if (strchr("12", cAbArt))
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTARTKombENTART, (unsigned int) abtid, 0, abtid);
        }
        else
        {
            if (strchr("34", cAbArt))
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTARTKombENTART, (unsigned int) abtid, 0, abtid);
        }
    }
    
    cAbArt = pAbt->PHYS_ANW;
    if (cAbArt != 'J' && cAbArt != 'N' && (pAufenthalt->isAmb || (cAbArt != 0 && cAbArt != ' '))) {
        Satzart_ReportMBDSError2(pAufenthalt, &LKFAmbErrorPhysAnwFalsch, (unsigned int) abtid, 0, abtid);
    }
}

void lkf_plaus_intabtcheck (LKF_AUFENTHALT *pAufenthalt, int abtid, LKF_AUFENTHALT_ABT *pAbt, const LKF_INT_SCORING_ABT *pIntAbt)
{ /* gilt bis Modell 2016 */

    int lAbtEntDat, lAbtAufDat;
    int lAbtEntZeit, lAbtAufZeit;
#ifdef SUPPORT_PRE2017
    int nAbtIntLen;
    char cAufArt, cAufArtSAPS;
#endif
    char cAbArt;
    int NichtFondsOffset = 0; /* V16.0 */
    int modelljahr;
    
    modelljahr = pAufenthalt->pScoringContext->modelljahr;
    
    if (modelljahr >= 2012 && pAufenthalt->pScoringContext->flags & LKFCONTEXT_NICHTFONDSKA)
        NichtFondsOffset = 22; /* V16.0: Verschiebung der M02-Intensiv-Erweiterungen für NichtFonds-Häuser */
    
    /* Überprüfung des Abteilungs-Entlassungsdatums */
    if (IsEmpty (pAbt->ABT_INTSATZ + 26 - NichtFondsOffset, 8)) {
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTDATfehlt, (unsigned int) abtid, 0, abtid);
        lAbtAufDat = 0;
        lAbtEntDat = 0;
    }
    else {
        if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            lAbtAufDat = (int) lkf_dat2intStrict (pAbt->ABTDAT);
            lAbtEntDat = (int) lkf_dat2intStrict (pAbt->ABT_INTSATZ + 26 - NichtFondsOffset);
        }
        else {
            lAbtAufDat = (int) lkf_dat2int (pAbt->ABTDAT);
            lAbtEntDat = (int) lkf_dat2int (pAbt->ABT_INTSATZ + 26 - NichtFondsOffset);
        }
        if (!lAbtEntDat) {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTDATfalsch, (unsigned int) abtid, 0, abtid);
        }
        else if ((pAufenthalt->lAufDat && lAbtEntDat < pAufenthalt->lAufDat) ||
                 (pAufenthalt->lEntDat && lAbtEntDat > pAufenthalt->lEntDat) ||
                 (lAbtAufDat && lAbtEntDat < lAbtAufDat))
        {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTDATaussAufenthalt, (unsigned int) abtid, 0, abtid);
        }
        else if (lAbtEntDat) {
            int lNextAufDat;
            if (abtid + 1 < (int)pAufenthalt->abt_anz) lNextAufDat = (int) lkf_dat2int (pAufenthalt->abt[abtid+1].ABTDAT);
            else lNextAufDat = (int) pAufenthalt->lEntDat;
            if (lNextAufDat && lNextAufDat != lAbtEntDat) {
                
                if (lAbtEntDat < lNextAufDat)
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorVerlegungenLoechrig, (unsigned int) abtid, 0, abtid);
                else
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorVerlegungenUeberlapp, (unsigned int) abtid, 0, abtid);
            }
        }
        
        
    }
    /* Ueberpruefung der Abteilungs-Aufnahmezeit */
    if (IsEmpty (pAbt->ABT_INTSATZ, 4)) {
        lAbtAufZeit = 0;
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTZEITfehlt, (unsigned int) abtid, 0, abtid);
    }
    else {
        if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            lAbtAufZeit = (int) lkf_time2intStrict (pAbt->ABT_INTSATZ);
        }
        else {
            lAbtAufZeit = (int) lkf_time2int (pAbt->ABT_INTSATZ);
        }
        
        if (!lAbtAufZeit)
        {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTZEITfalsch, (unsigned int) abtid, 0, abtid);
        }
    }
    
    /* Überprüfung der Abteilungs-Entlassungszeit */
    if (IsEmpty (pAbt->ABT_INTSATZ + 34 - NichtFondsOffset, 4))
    {
        lAbtEntZeit = 0;
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTZEITfehlt, (unsigned int) abtid, 0, abtid);
    }
    else
    {
        if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            lAbtEntZeit = (int) lkf_time2intStrict (pAbt->ABT_INTSATZ + 34 - NichtFondsOffset);
        }
        else {
            lAbtEntZeit = (int) lkf_time2int (pAbt->ABT_INTSATZ + 34 - NichtFondsOffset);
        }
        
        if (!lAbtEntZeit)
        {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTZEITfalsch, (unsigned int) abtid, 0, abtid);
        }
    }
    
    if (pAufenthalt->pScoringContext->modelljahr >= 2006 && lAbtAufDat && lAbtAufDat == lAbtEntDat && lAbtEntZeit && lAbtAufZeit &&
        lAbtAufZeit > lAbtEntZeit)
    {
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorEntVorAufZeit, (unsigned int) abtid, 0, abtid);
    }
#ifdef SUPPORT_PRE2017
    if (modelljahr < 2012)
    {
        
        /* Überprüfung Aufnahmeart Intensiv */
        cAufArt = pAbt->ABT_INTSATZ[4];
        if (cAufArt == ' ')
        {
            if (pAufenthalt->pScoringContext->modelljahr < 2011 || !lkf_isIntNeu (pAufenthalt, abtid))
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAUFARTIntfehlt, (unsigned int) abtid, 0, abtid);
        }
        else if (cAufArt != '1' && cAufArt != '2')
        {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAUFARTIntfalsch, (unsigned int) abtid, 0, abtid);
        }
        
        /* Überprüfung der SAPS-II-Aufnahmeart */
        cAufArtSAPS = pAbt->ABT_INTSATZ[5];
        if (cAufArtSAPS == ' ')
        {
            if (pAufenthalt->pScoringContext->modelljahr < 2011 || !lkf_isIntNeu (pAufenthalt, abtid))
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAUFTYPSAPS2fehlt, (unsigned int) abtid, 0, abtid);
        }
        else if (!strchr ("123", cAufArtSAPS))
        {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAUFTYPSAPS2falsch, (unsigned int) abtid, 0, abtid);
        }
        
        
        nAbtIntLen = (int) strlen (pAbt->ABT_INTSATZ);
        
        if (!IsEmpty (pAbt->ABT_INTSATZ + 6, 20) && (
                                                     (nAbtIntLen > 6 && !strchr (" 01", pAbt->ABT_INTSATZ[6])) ||
                                                     (nAbtIntLen > 7 && !strchr (" 01", pAbt->ABT_INTSATZ[7])) ||
                                                     (nAbtIntLen > 8 && !strchr (" 01", pAbt->ABT_INTSATZ[8]))))
        {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorCoexistErkrfalsch, (unsigned int) abtid, 0, abtid);
        }
    }
#endif
    /* Überprüfung der Abgangsart */
    cAbArt = pAbt->ABT_INTSATZ[38-NichtFondsOffset];
    if (cAbArt == ' ' || (!cAbArt && pAufenthalt->pScoringContext->modelljahr >= 2012) /* V16.1 */)
    {
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTARTfehlt, (unsigned int) abtid, 0, abtid);
    }
    else if (!strchr ("1234", cAbArt)) 
    {
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTARTfalsch, (unsigned int) abtid, 0, abtid);
    }
    else if (strchr ("34", cAbArt) && pAufenthalt->ENTART != 'S') 
    {
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTARTKombENTART, (unsigned int) abtid, 0, abtid);
    }
    else if (modelljahr >= 2014)
    { /* V18.0 */
        if (pAufenthalt->ENTART == 'S') {
            if (abtid + 1 == (int) pAufenthalt->abt_anz)
            {
                if (strchr("12", cAbArt))
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTARTKombENTART, (unsigned int) abtid, 0, abtid);
            }
            else 
            {
                if (strchr("34", cAbArt))
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorABTENTARTKombENTART, (unsigned int) abtid, 0, abtid);
            }
        }
    }
}




/* procedure KOST_Check *************************************************
**    \xc3\x9c""berpr\xc3\xbc""fung des Kostentr\xc3\xa4""gers:                                   **
**        - ob er leer ist (Warning KOST_FEHLT)                        **
**        - ob er ung\xc3\xbc""ltig ist (Warning KOST_FALSCH)                   **
************************************************************************/       

static void KOST_Check (LKF_AUFENTHALT *pAufenthalt)
{
    char trimmed_kost[9];
    
	/* KOST: kein KOST vorhanden -> WARNING */
	if (IsBlank (pAufenthalt->KOST, 2)) {
		if (pAufenthalt->ENTART != 'V') 
		{
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorKOSTfehlt2005, 0);
		}
	}
	/* KOST: ungueltig -> WARNING */
	else {
		simLTrim (trimmed_kost + 6, pAufenthalt->KOST, 2);

		if (!KostInArray (pAufenthalt->pScoringContext, trimmed_kost)) {
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorKOSTfalsch2005, 0);
		}
	}
}

/* function Hauptdiagnose_Check ***********************************************
**  Ueberpruefung der Hauptdiagnose                                          **
******************************************************************************/

#define ACT_GESCHLECHT_POS			30
#define ACT_MINDESTALTER_POS	    32
#define ACT_HOECHSTALTER_POS		36
#define ACT_UNWAHRSCHEINLICH_POS    40
#define ACT_AMBULANT_POS		    42  
#define ACT_BDGR0_POS				44 
#define ACT_MELDEDIAG_POS		    46	 

static int Tumor_Check (LKF_AUFENTHALT *pAufenthalt, const char *diag)
{ /* V19.0 */
    if (diag[0] != 'C' || diag[5] != ' ') return 0;
    if (!memcmp(diag, "C18", 3) || !memcmp(diag, "C19", 3) || !memcmp(diag, "C20", 3))
        return 1;
    return 0;
}

static int HasTumorCheckMelGroup (LKF_AUFENTHALT *pAufenthalt) 
{ /* V20.0 */
	int hasMelGroup = 0;
	unsigned int i;
	const STAMM2001 *pStamm2001;
	MEL_ARRAY_STRUC *pStruc;
	int melIndex;

	pStamm2001 = pAufenthalt->pScoringContext->pStamm2001;
    
    if (pAufenthalt->isAmb && (pAufenthalt->pScoringContext->modelljahr < 2026 || pAufenthalt->isAmb == 1))
    { /* V21.3 */
        for (i = 0; i < pAufenthalt->mel_anz; i++) {
            melIndex = pAufenthalt->mel[i].nMelIndex;
            if (melIndex < 0) continue;
            pStruc = GetMELArrayFromIndex (pAufenthalt->pScoringContext, (unsigned int) melIndex);
            if (!memcmp (pStruc->sAmbGruppe, "AMG21", 5) || !memcmp (pStruc->sAmbGruppe, "AMG25", 5)) {
                hasMelGroup = 1;
                break;
            }
        }
    }
    else {
        for (i = 0; i < pAufenthalt->mel_anz; i++) {
            melIndex = pAufenthalt->mel[i].nMelIndex;
            if (melIndex < 0) continue;
            pStruc = GetMELArrayFromIndex (pAufenthalt->pScoringContext, (unsigned int) melIndex);
            if (!memcmp (pStruc->sGruppe, "MEL05", 5) || !memcmp (pStruc->sGruppe, "MEL06", 5) || !memcmp (pStruc->sGruppe, "MEL22", 5) || !memcmp(pStruc->sGruppe, "MEL25", 5)) {
                hasMelGroup = 1;
                break;
            }
        }
    }
	

	return hasMelGroup;
}

static int Stroke_Check (LKF_AUFENTHALT *pAufenthalt, const char *diag, int *options)
{ /* V2019.0 */
    
    if (*options == DIAG_OPTION_HAS_STROKEABT)
        return 0;
    if (*options == DIAG_OPTION_NO_STROKEABT)
        return 0; /* Fehler nur einmal ausgeben */
    

    if (pAufenthalt->pScoringContext->modelljahr >= 2025 && pAufenthalt->isAmb == 1) {
        return 0; /* V2025.2: */
    }
    
    if (!memcmp (diag, "I61.", 4) || !memcmp (diag, "I63.", 4)) {
        unsigned int i;
        char tmp_spez_buf[20];
        const SPEZ_LIST_STRING *spezlistString; /* V2019.2 */
        for (i = 0; i < pAufenthalt->abt_anz; i++) {
            sprintf (tmp_spez_buf, "S....%4.4s%8.8s", pAufenthalt->KANR, pAufenthalt->abt[i].ABTFC);
            
            spezlistString = SpezInArray(pAufenthalt->pScoringContext, tmp_spez_buf);
            
            if (spezlistString && (*spezlistString)[0] == 'S') {
                *options = DIAG_OPTION_HAS_STROKEABT;
                return 0;
            }
        }
        *options = DIAG_OPTION_NO_STROKEABT;
        return 1;
    }
    return 0;
}

static int Rankin_Ok (LKF_AUFENTHALT *pAufenthalt)
{ /* V2019.0 */
    int has201 = 0, has202 = 0, has203 = 0, has204 = 0;
    unsigned int i;
    for (i = 0; i < pAufenthalt->diag_anz; i++) {
        const char *diag = pAufenthalt->diag[i].DIAG;
        if (diag[0] == '2' && diag[1] == '0') {
            switch (diag[2]) {
                case '1':
                    has201 = 1;
                    break;
                case '2':
                    has202 = 1;
                    break;
                case '3':
                    has203 = 1;
                    break;
                case '4':
                    has204 = 1;
                    break;
                default:
                    break;
            }
        }
    }
    
    if ((has201 && has202 && has203) || has204) {
        return 1;
    }
    
    if (pAufenthalt->pScoringContext->modelljahr && pAufenthalt->pScoringContext->modelljahr >= 2023) {
        unsigned int i;
        for (i = 0; i < pAufenthalt->mel_anz; i++) {
            if (!memcmp (pAufenthalt->mel[i].MEL, "ZZ723", 5)) {
                return 1;
            }
        } 
    }
    
    return 0;
}



#define HD_UNGUELTIG		 21
#define HD_FALSCH			 22
#define HD_FEHLT			 23
#define HD_STAT_FALSCH       24
#define HD_DREISTELLER		 45
#define HD_KEIN_UCODE		 11

static int IsENTARTSDiag (const char *diag)
{ /* V21.0 */
    return diag[0] == 'R' && diag[1] == '9' && strchr("56789", diag[2]);
}

static int DisableGenderCheck (LKF_AUFENTHALT *pAufenthalt, int modelljahr)
{ /* V2020.5 */
    unsigned int i;
    
    if (modelljahr >= 2021 && pAufenthalt->GESCHL != 'W' && pAufenthalt->GESCHL != 'M')
        return 1;
    
    if (modelljahr >= 2020 && pAufenthalt->GESCHL == 'X')
        return 1;
    
    if (modelljahr < 2020)
        { /* Modell < 2020 -> nur erste HD checken, um Ergebnis nicht zu aendern */
        if (!memcmp (pAufenthalt->HD, "F64.0", 5)) return 1;
        for (i = 0; i < pAufenthalt->diag_anz; i++) {
            if (!pAufenthalt->diag[i].isHD && !memcmp (pAufenthalt->diag[i].DIAG, "F64.0", 5)) return 1;
        }
        return 0;
    }
    for (i = 0; i < pAufenthalt->diag_anz; i++) {
        if (!memcmp (pAufenthalt->diag[i].DIAG, "F64.0", 5)) return 1;
    }
    return 0;
}

static int HasLinksHerzInsuffizienz (LKF_AUFENTHALT *pAufenthalt)
{ /* V20220 */
    
    unsigned int i, count;
    count = pAufenthalt->diag_anz;
    for (i = 0; i< count; i++) {
        if (!memcmp (pAufenthalt->diag[i].DIAG, "I50.1", 5))
            return 1;
    }
    return 0;
}

static int StatInvalidDiag5 (LKF_CONTEXT *pContext, const char *diag) {
    if (!memcmp (diag, "I50", 3)) {
        if (diag[4] == '0' || diag[4] == '1') {
            return 1;
        }
    }
    else if (!memcmp (diag, "J44", 3)) {
        if (strchr ("0189", diag[4])) {
            return 1;
        }
    }
    else if (!memcmp (diag, "K91.8", 5)) {
        return 1;
    }
    return 0;
}

static int Hauptdiagnose_Check (LKF_AUFENTHALT *pAufenthalt, unsigned int diag_index, int *diag_ambulant, int *options)
{

	int plaus_flag;

	char act_geschlecht,
		 act_unwahrscheinlich,
		 act_ambulant,
		 act_bdgr0;

	char act_meldediag;
	int	act_mindestalter,
		act_hoechstalter;
	int i;
    LKF_CONTEXT *pContext;
    unsigned int modelljahr;
    STAMM2001 *pStamm;
    

	char hd[LKF_AUFENTHALT_DIAG_LEN];
    int len;
	ICD_LIST_STRING *pDiaglist = 0;

    pContext = pAufenthalt->pScoringContext;
    modelljahr = pContext->modelljahr;
	pStamm = pContext->pStamm2001;

	plaus_flag = 0;
    if (pAufenthalt->hdiag_anz == 0) {
        hd[0] = 0;
        len = 0;
    }
    else if (diag_index == 0 && (pAufenthalt->hdiag_anz < 2 || modelljahr < 2020)) { /* V2020.5: HD-Fix ab Modell 2020 */
        CopyLTrim (hd, pAufenthalt->HD, LKF_AUFENTHALT_DIAG_LEN);
        len = GetLength (hd, LKF_AUFENTHALT_DIAG_LEN);
    }
    else {
        CopyLTrim (hd, pAufenthalt->diag[diag_index].DIAG, LKF_AUFENTHALT_DIAG_LEN);
        len = GetLength (hd, LKF_AUFENTHALT_DIAG_LEN);
    }

    if (!pAufenthalt->isAmb && pAufenthalt->hdiag_anz > 1 && modelljahr != 2020)
    { /* V2021.2 */
        int first = 1;
        for (i = 0; i < (int) pAufenthalt->diag_anz; i++) {
            if (!pAufenthalt->diag[i].isHD) {
                continue;
            }
            if (first) {
                first = 0;
                continue;
            }
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorHDmehrfach, (unsigned int) i);
        }
    }
    
    /* HD: fehlt -> ERROR */
	if (!len) plaus_flag = HD_FEHLT;
	/* Laenge der Diagnose < 3 -> ERROR */
	else if (len < 3) plaus_flag = HD_FALSCH;
	/* Leerzeichen innerhalb der Diagnose -> ERROR */
	else if (HasBlanks (hd, (unsigned int) len)) plaus_flag = HD_FALSCH;
	else {

		pDiaglist = FindDiag6 (pStamm, hd);

		if (!pDiaglist && len == 6 && modelljahr < 2013)
		{
			pDiaglist = FindDiag5 (pStamm, hd);
			if (!pDiaglist &&  hd[4] != 'x') plaus_flag = HD_FALSCH;
			else if (!pDiaglist) {
				pDiaglist = FindDiag3 (pStamm, hd);
				if (!pDiaglist) plaus_flag = HD_FALSCH;
			}
		}
		else if (!pDiaglist) plaus_flag = HD_FALSCH;
        else if (len == 5 && !pAufenthalt->isAmb && modelljahr >= 2025 && StatInvalidDiag5 (pContext, hd)) {
            plaus_flag = HD_STAT_FALSCH;
        }

		if (pDiaglist) {

            pAufenthalt->diagInfo[diag_index] = pStamm->diag_info + (pDiaglist - pStamm->icd_list);

            if (len == 5 && !memcmp (hd+3, ".-", 2)) plaus_flag = HD_DREISTELLER;
            else if (pAufenthalt->isAmb && modelljahr >= 2019)
            { /* V2019.1 */
                if (*options & DIAG_OPTION_AMBLEIST_VERPFLICHTEND) {
                    switch ((*pDiaglist)[7]) {
                        case '#':
                            if (!(*options & DIAG_OPTION_AMBLEIST_NICHTVERPFLICHTEND))
                                plaus_flag = HD_FALSCH;
                            else if (modelljahr >= 2021 && pAufenthalt->isAmb == 2)
                                plaus_flag = HD_FALSCH; /* V2021.3 */
                            break;
                        case '!':
                            // TODO2025: wenn DIAG verpflichtend, sind dann hier ambulant !-Diagnosen zulŠssig?
                            //if (!pAufenthalt->isAmb || modelljahr < 2025) {

                            if (pAufenthalt->isAmb == 2 || modelljahr < 2025) { /* V2025.2 */
                                plaus_flag = HD_UNGUELTIG;
                            }
                            else {
                                plaus_flag = 0;
                            }
                            //}
                            break;
                        default:
                            break;
                    }
                }

                // TODO2025: keine HDG, nicht ! -> ambulant ungŸltig?
                if (modelljahr >= 2026 && hd[0]>='0' && hd[0]<='9') {
                    plaus_flag = HD_UNGUELTIG;
                }
                else if (modelljahr >= 2025 && memcmp ((*pDiaglist)+9, "HDG", 3) && (*pDiaglist)[7] != '!') {
                    plaus_flag = HD_UNGUELTIG;
                }

            }
            else if (memcmp ((*pDiaglist)+9, "HDG", 3)) {
                plaus_flag = HD_UNGUELTIG;
            }
            
            if (modelljahr >= 2015) {
                if (Tumor_Check (pAufenthalt, hd) && HasTumorCheckMelGroup(pAufenthalt))
					   Satzart_ReportMBDSError(pAufenthalt, &LKFWarningUICCFehlt, diag_index);
            }
            if (modelljahr >= 2019 && Stroke_Check(pAufenthalt, hd, options) && !Rankin_Ok(pAufenthalt)) {
                Satzart_ReportMBDSError(pAufenthalt, &LKFErrorRankinMissing, diag_index);
            }
		}
	}

    switch (plaus_flag) {
        case HD_FALSCH:
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagfalsch, diag_index);
            return 0;
        case HD_DREISTELLER:
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiag4stellig, diag_index);
            return 0;
        case HD_STAT_FALSCH:
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorStatDiag5stellig, diag_index);
            return 0;
        case HD_UNGUELTIG:
            if (!pAufenthalt->isAmb || modelljahr >= 2019) {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorHDfalsch, diag_index);
            }
            return 0;
        case HD_FEHLT:
            if (pAufenthalt->ENTART != 'V' && (!pAufenthalt->isAmb || modelljahr < 2025)) /* V21.1: mehrere ZD's erlaubt */
            {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorHDfehlt, diag_index);
            }
            return 0;
        default:
            break;
	}

    if (modelljahr >= 2017) {
        if (pAufenthalt->isAmb && modelljahr >= 2019 && !(*options & DIAG_OPTION_AMBLEIST_VERPFLICHTEND)) {
            // V2019.1: kein WX4M
        }
        else if (!memcmp (hd, "I64", 3))
        {
            Satzart_ReportMBDSError (pAufenthalt, &LKFWarningI64, diag_index);
        }
        else if (hd[0] == 'R' && hd[1] == '9')
        {
            if (!memcmp (hd, "R96.0",5) || !memcmp (hd, "R96.1",5) || !memcmp (hd, "R98",3) || !memcmp (hd, "R99",3))
                Satzart_ReportMBDSError (pAufenthalt, &LKFWarningI64, diag_index);
        }
        else if (modelljahr >= 2018)
        { /* V22.1 */
            if (!memcmp(hd, "J44.", 4) && hd[5] == '9') {
                
                Satzart_ReportMBDSError (pAufenthalt, &LKFWarningI64, diag_index);
            }
            else if (!memcmp(hd, "I21.9", 5) || !memcmp(hd, "I50.19", 6)) {
                
                Satzart_ReportMBDSError (pAufenthalt, &LKFWarningI64, diag_index);
            }
            else if (modelljahr >= 2024 && !memcmp(hd, "I51.9", 5))
            { /* V2024.0 */
                Satzart_ReportMBDSError (pAufenthalt, &LKFWarningI64, diag_index);
            }
        }
    }
    else if (modelljahr >= 2013 && !memcmp (hd, "I64", 3))
	{ /* V17.1 */	
		Satzart_ReportMBDSError (pAufenthalt, &LKFWarningI64, diag_index);
	} else if (modelljahr >= 2014 && (hd[0] == 'R' && hd[1] == '9'))
	{ /* V18.1 */
		if (!memcmp (hd, "R96.0",5) || !memcmp (hd, "R96.1",5) || !memcmp (hd, "R98",3) || !memcmp (hd, "R99",3))
			Satzart_ReportMBDSError (pAufenthalt, &LKFWarningI64, diag_index);
	}

    if (diag_index > 0 && modelljahr >= 2017) {
        unsigned int j;
        char compare_diag[LKF_AUFENTHALT_DIAG_LEN+2];
        for (j = 0; j < diag_index; j++) {
            if (!pAufenthalt->diag[j].isHD) {
                continue;
            }
            CopyLTrim (compare_diag, pAufenthalt->diag[j].DIAG, LKF_AUFENTHALT_DIAG_LEN);
            if (!memcmp (hd, compare_diag, LKF_AUFENTHALT_DIAG_LEN))
            {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagmehrfach, diag_index);
                return 0;
            }
        }
    }
    
    if ((modelljahr == 2022 || modelljahr == 2023) && !memcmp (hd, "I50.01", 6) && !HasLinksHerzInsuffizienz(pAufenthalt)) {
        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSecInsuffizient, diag_index);
    }
    
	act_meldediag = (*pDiaglist)[ACT_MELDEDIAG_POS];
	act_geschlecht = (*pDiaglist)[ACT_GESCHLECHT_POS];
	GetInt (*pDiaglist + ACT_MINDESTALTER_POS, 3, &act_mindestalter);
	if (modelljahr >= 2016)
	{ /* V16.0 */
		if (IsEmpty(*pDiaglist + ACT_HOECHSTALTER_POS, 3))
			act_hoechstalter = 1000;
		else
			GetInt(*pDiaglist + ACT_HOECHSTALTER_POS, 3, &act_hoechstalter);
	}
	else
	{
		GetInt(*pDiaglist + ACT_HOECHSTALTER_POS, 3, &act_hoechstalter);
		if (act_hoechstalter == 0) act_hoechstalter = 1000;
	}
	act_unwahrscheinlich = (*pDiaglist)[ACT_UNWAHRSCHEINLICH_POS];
	act_ambulant = (*pDiaglist)[ACT_AMBULANT_POS];		
	act_bdgr0 = (*pDiaglist)[ACT_BDGR0_POS]; 

	act_meldediag = (*pDiaglist)[ACT_MELDEDIAG_POS];
	if (act_meldediag != ' ') Plaus_MeldeDiag (pAufenthalt, act_meldediag, (int) diag_index);

	if (((pAufenthalt->lAufDat && pAufenthalt->lEntDat) || (pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE)) && pAufenthalt->GESVD == 0 && pAufenthalt->ENTART == 'E' && act_bdgr0 == 'J') {
		Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiag0Tage, diag_index);
	}
    if (act_ambulant == 'J') {
        if (!pAufenthalt->isAmb && LKF_IS_TRACE_DETAIL(pAufenthalt->pScoringContext->nTraceAufenthalt))
        {
            char sTraceLine[1024];
            sprintf (sTraceLine, "Ambulante Hauptdiagnose '%-6.6s' -> WX3F?", hd);
            TRACE_DETAIL(pAufenthalt, 0, sTraceLine);
        }
        *diag_ambulant = 1;
        
    }

	if (!(pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE) || pAufenthalt->GESCHL != ' ') { /* V7.1 */
		if (act_geschlecht != ' ' && act_geschlecht != pAufenthalt->GESCHL) {
            if (pContext->modelljahr < 2020 || !DisableGenderCheck(pAufenthalt, pContext->modelljahr)) {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagGeschl, diag_index);
            }
		}
	}

	if (pAufenthalt->Alter != -99 && (act_hoechstalter < pAufenthalt->Alter || act_mindestalter > pAufenthalt->Alter)) { /* V20.1: Alter immer pruefen - Wert "0" gilt fuer Alter = 0 Jahre */
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagAlter, diag_index);
	}

	if (act_unwahrscheinlich == 'J') {
        Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorDiagfalschWarn2017 : &LKFErrorDiagfalschWarn, diag_index);
	}
    
    if (pAufenthalt->ENTART != 'S' && modelljahr >= 2017 && IsENTARTSDiag(hd)
        && (pAufenthalt->isAmb != 1 || modelljahr < 2021)) { /* V2021.1 */
        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDIAGENTART, diag_index);
    }
    

    if (!pAufenthalt->isAmb || modelljahr > 2026 /* erst ab Modell 2027 auch ambulant */ || modelljahr < 2019 || (*options & DIAG_OPTION_AMBLEIST_VERPFLICHTEND)) /* V2019.1 */
    {
        if (hd[0] == 'S' || (hd[0] == 'T' && memcmp (hd + 1, "80", 2) < 0))
        {
            int zd;
            
            plaus_flag = HD_KEIN_UCODE;
            
            if (modelljahr > 2012)
            { /* V17.0 - U-Codes durch 9-Codes ersetzen */
                for (i = 0; i < (int) pAufenthalt->diag_anz && plaus_flag == HD_KEIN_UCODE; i++) {
                    
                    if (pAufenthalt->diag[i].DIAG[0] == '9' && GetInt (pAufenthalt->diag[i].DIAG + 1, 2, &zd) && zd &&
                        FindDiag3 (pStamm, pAufenthalt->diag[i].DIAG)) plaus_flag = 0;
                }
                
                if (plaus_flag == HD_KEIN_UCODE) {
                    if (modelljahr >= 2015)
                        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiag9Code2015, diag_index);
                    else
                        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiag9Code, 0);
                }
            }
            else
            {
                for (i = 0; i < (int) pAufenthalt->diag_anz && plaus_flag == HD_KEIN_UCODE; i++) {
                    
                    if (pAufenthalt->diag[i].DIAG[0] == 'U' && GetInt (pAufenthalt->diag[i].DIAG + 1, 2, &zd) && zd &&
                        FindDiag3 (pStamm, pAufenthalt->diag[i].DIAG)) plaus_flag = 0;
                }
                
                if (plaus_flag == HD_KEIN_UCODE) {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagUCode, 0);
                }
            }
        }
    }
    
	/* Stern-Kreuz-Ueberpruefung */

	if (modelljahr < STERNKR_NEW_MODEL)
    {
        if ((*pDiaglist)[7] == '*') {
            STERNKR_LIST_STRING *pSternkr;
            if (hd[4] == 'x') pSternkr = FindSternKr3 (pStamm, hd);
            else pSternkr = FindSternKr5 (pStamm, hd);
            pAufenthalt->sternkr[0] = pSternkr;
        }
        else pAufenthalt->sternkr[0] = 0;
    }
    
    if (modelljahr >= 2017 && pAufenthalt->hdiag_anz > 0) {
        char ds;
        char art = pAufenthalt->diag[diag_index].DIAGART;
        if (art != 0 && art != ' ' && art != 'D' && art != 'V')
            Satzart_ReportMBDSError(pAufenthalt, &LKFAmbErrorDiagArtFalsch, diag_index);
        
        ds = pAufenthalt->diag[diag_index].DIAGSTAT;
        
        if (pAufenthalt->isAmb)
        { /* V21.2 */
            if (ds != 0 && ds != ' ') {
                Satzart_ReportMBDSError(pAufenthalt, modelljahr >= 2018 ? &LKFWarningStatErworben2018 : &LKFWarningStatErworben, diag_index);
            }
        }
        else if ((ds != 'J' && ds != 'N') && ((ds != 0 && ds != ' ') || (*pDiaglist)[47] == 'J'))
        { /* WK4T */
            Satzart_ReportMBDSError(pAufenthalt, modelljahr >= 2018 ? &LKFWarningStatErworben2018 : &LKFWarningStatErworben, diag_index);
        }
        else if (ds == 'J' && modelljahr >= 2018)
        { /* V22.1 - WX50 */
            Satzart_ReportMBDSError(pAufenthalt, &LKFErrorStatErworbenHD, diag_index);
        }
    }
    
	return 1;
}

/* function Zusatzdiagnose_Check **************************************************
**    Ueberpruefungen der (i+1). Zusatzdiagnose                                  **
**********************************************************************************/

#define ZD_STAT_FALSCH       24
#define ZD_FALSCH			 27
#define ZD_DREISTELLER		 46

static int Zusatzdiagnose_Check (LKF_AUFENTHALT *pAufenthalt, unsigned int i, int *diag_ambulant, int *options)
{
	int plaus_flag;

	char diag[LKF_AUFENTHALT_DIAG_LEN+2], compare_diag[LKF_AUFENTHALT_DIAG_LEN+2];
	int len;

    unsigned int zdiag_index = i; /* V21.0 */
    
	LKF_AUFENTHALT_DIAG *pDiag;
	STAMM2001 *pStamm = pAufenthalt->pScoringContext->pStamm2001;
	ICD_LIST_STRING *pDiaglist = 0;
	STERNKR_LIST_STRING *pSternkr;

	char act_geschlecht,
		 act_unwahrscheinlich,
		 act_ambulant,
		 act_hdg[3],
		 act_meldediag;
	int	act_mindestalter,
		act_hoechstalter;
    unsigned int modelljahr;
    LKF_CONTEXT *pContext;
    
    pContext = pAufenthalt->pScoringContext;
    modelljahr = pContext->modelljahr;


	plaus_flag = 0;
	pDiag = pAufenthalt->diag + i;

	CopyLTrim (diag, pDiag->DIAGTYP, 2);
	len = GetLength (diag, 2);

	if (len == 0) 
	{
		Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagTypfehlt, i);
	}
	else if (diag[0] != 'Z' || (diag[1] && diag[1] != ' ')) 
	{
		Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagTypfalsch, i);
	}

	CopyLTrim (diag, pDiag->DIAG, LKF_AUFENTHALT_DIAG_LEN);
	len = GetLength (diag, LKF_AUFENTHALT_DIAG_LEN);

	/* Leere Diagnose -> OK (ignorieren) */
	if (!len) return 1;
	
	/* Leerzeichen innerhalb der Diagnose -> ZD_FALSCH */
	if (HasBlanks (diag, (unsigned int) len)) plaus_flag = ZD_FALSCH;
	else {
		pDiaglist = FindDiag6 (pStamm, diag);
		if (!pDiaglist && len == 6 && modelljahr < 2013 /* V17.0 */) {
			pDiaglist = FindDiag5 (pStamm, diag);
			if (!pDiaglist && diag[4] != 'x') plaus_flag = ZD_FALSCH;
            else if (len == 5 && !pAufenthalt->isAmb && modelljahr >= 2025 && StatInvalidDiag5 (pContext, diag)) {
                plaus_flag = ZD_STAT_FALSCH;
            }
			else {
				pDiaglist = FindDiag3 (pStamm, diag);
				if (!pDiaglist) plaus_flag = ZD_FALSCH;
			}
		}
		else if (!pDiaglist) plaus_flag = ZD_FALSCH;
		else
		{
            if (pAufenthalt->isAmb && (*options & DIAG_OPTION_AMBLEIST_VERPFLICHTEND) && (*pDiaglist)[7] == '#' && !(*options & DIAG_OPTION_AMBLEIST_NICHTVERPFLICHTEND)) {
                plaus_flag = ZD_FALSCH;
            }
            else if (pDiaglist && len == 5 && !memcmp (diag+3, ".-", 2)) plaus_flag = ZD_DREISTELLER;
            pAufenthalt->diagInfo[zdiag_index] = pStamm->diag_info + (pDiaglist - pStamm->icd_list);
		}
        
        if (pDiaglist) {
            if (modelljahr >= 2015 && Tumor_Check (pAufenthalt, diag) && HasTumorCheckMelGroup(pAufenthalt)) {
					Satzart_ReportMBDSError(pAufenthalt, &LKFWarningUICCFehlt, zdiag_index);
            }
            if (modelljahr >= 2019 && Stroke_Check(pAufenthalt, diag, options) && !Rankin_Ok(pAufenthalt)) {
                Satzart_ReportMBDSError(pAufenthalt, &LKFErrorRankinMissing, zdiag_index);
            }
        }
	}

	if (plaus_flag == ZD_FALSCH) 
	{
		Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagfalsch, zdiag_index);
		return 0;
	}
    else if (plaus_flag == ZD_STAT_FALSCH) {
        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorStatDiag5stellig, zdiag_index);
    }
	else if (plaus_flag == ZD_DREISTELLER)
    {
        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiag4stellig, zdiag_index);
    }

    compare_diag[0] = 0;
    if (pAufenthalt->hdiag_anz >= 1) {
        unsigned int j;
        for (j = 0; j < pAufenthalt->diag_anz; j++) {
            if (pAufenthalt->diag[j].isHD) {
                CopyLTrim (compare_diag, pAufenthalt->diag[j].DIAG, LKF_AUFENTHALT_DIAG_LEN);
                break;
            }
        }
    }
		

    if (modelljahr < 2017) {
        if (pAufenthalt->hdiag_anz >= 1 && !memcmp (diag, compare_diag, LKF_AUFENTHALT_DIAG_LEN))
        {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorZDmehrfach, i);
            return 0;
        }
        else
        {
            unsigned int j;
            for (j = 0; j < i; j++)
            {
                if (pAufenthalt->diag[j].isHD) {
                    continue;
                }
                CopyLTrim (compare_diag, pAufenthalt->diag[j].DIAG, LKF_AUFENTHALT_DIAG_LEN);
                if (!memcmp (diag, compare_diag, LKF_AUFENTHALT_DIAG_LEN))
                {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorZDmehrfach, i);
                    return 0;
                }
            }
        }
    }
    else
    {
        unsigned int j;
        for (j = 0; j < i; j++)
        {
            CopyLTrim (compare_diag, pAufenthalt->diag[j].DIAG, LKF_AUFENTHALT_DIAG_LEN);
            if (!memcmp (diag, compare_diag, LKF_AUFENTHALT_DIAG_LEN))
            {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagmehrfach, zdiag_index);
                return 0;
            }
        }
    }

	act_geschlecht = (*pDiaglist)[ACT_GESCHLECHT_POS];
	GetInt (*pDiaglist + ACT_MINDESTALTER_POS, 3, &act_mindestalter);
	GetInt (*pDiaglist + ACT_HOECHSTALTER_POS, 3, &act_hoechstalter);
	act_unwahrscheinlich = (*pDiaglist)[ACT_UNWAHRSCHEINLICH_POS];
	act_ambulant = (*pDiaglist)[ACT_AMBULANT_POS];		
	CopyUCaseLTrim (act_hdg, (*pDiaglist) + 9, 3);

	act_meldediag = (*pDiaglist)[ACT_MELDEDIAG_POS];
	if (act_meldediag != ' ') Plaus_MeldeDiag (pAufenthalt, act_meldediag, (int) i);

    if (diag_ambulant && act_ambulant != 'J' && !memcmp (act_hdg, "HDG", 3)) {
        if (*diag_ambulant > 0 && LKF_IS_TRACE_DETAIL(pAufenthalt->pScoringContext->nTraceAufenthalt))
        {
            char sTraceLine[1024];
            sprintf (sTraceLine, "HDG-Zusatzdiagnose '%6.6s' (%3.3s) -> kein WX3F", diag, act_hdg);
            TRACE_DETAIL(pAufenthalt, 0, sTraceLine);
        }
        *diag_ambulant = 0;
    }
		

	if (!(pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE) || pAufenthalt->GESCHL != ' ') {
		if (act_geschlecht != ' ' && act_geschlecht != pAufenthalt->GESCHL) {
            if (pContext->modelljahr < 2020 || !DisableGenderCheck(pAufenthalt, pContext->modelljahr)) {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagGeschl, zdiag_index /* V21.3 */);
            }
        }
	}

	if (pAufenthalt->Alter != -99 && act_hoechstalter && 
		(act_hoechstalter < pAufenthalt->Alter || act_mindestalter > pAufenthalt->Alter)) {
			Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDiagAlter, zdiag_index /* V21.3 */);
		}
	if (act_unwahrscheinlich == 'J') {
        Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorDiagfalschWarn2017 : &LKFErrorDiagfalschWarn, zdiag_index /* V21.3 */);
	}
    
   if (pAufenthalt->ENTART != 'S' && modelljahr >= 2017 && IsENTARTSDiag(diag)
       && (pAufenthalt->isAmb != 1 || modelljahr < 2021)) { /* V2021.1 */
        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorDIAGENTART, zdiag_index /* V21.3 */);
    }

    if (modelljahr < STERNKR_NEW_MODEL)
    {
        /* Stern-Kreuz-Ueberpruefung */
        if ((*pDiaglist)[7] == '*') {
            if (diag[4] == 'x') pSternkr = FindSternKr3 (pStamm, diag);
            else pSternkr = FindSternKr5 (pStamm, diag);
            pAufenthalt->sternkr[i + 1] = pSternkr;
        }
        else pAufenthalt->sternkr[i + 1] = 0;
    }
    
    if (modelljahr >= 2017)
    { /* V21.0 */
        char ds;
        char art = pAufenthalt->diag[i].DIAGART;
        if (art != 0 && art != ' ' && art != 'D' && art != 'V')
            Satzart_ReportMBDSError(pAufenthalt, &LKFAmbErrorDiagArtFalsch, zdiag_index /* V21.3 */);
        
        ds = pAufenthalt->diag[i].DIAGSTAT;
        
        if (pAufenthalt->isAmb)
        { /* V21.2 */
            if (ds != 0 && ds != ' ') {
                Satzart_ReportMBDSError(pAufenthalt, modelljahr >= 2018 ? &LKFWarningStatErworben2018 : &LKFWarningStatErworben, zdiag_index /* V21.3 */);
            }
        }
        else if ((ds != 'J' && ds != 'N') && ((ds != 0 && ds != ' ') || (*pDiaglist)[47] == 'J'))
        { /* WK4T */
            Satzart_ReportMBDSError(pAufenthalt, modelljahr >= 2018 ? &LKFWarningStatErworben2018 : &LKFWarningStatErworben, zdiag_index /* V21.3 */);
        }
    }
    
    /* V2024.0: WX55 deaktiviert fuer Zusatzdiagnosen ab Mod. 2024 */
    if ((modelljahr == 2022 || modelljahr == 2023) && !memcmp (diag, "I50.01", 6) && !HasLinksHerzInsuffizienz(pAufenthalt)) {
        Satzart_ReportMBDSError (pAufenthalt,
                                 &LKFErrorSecInsuffizient, zdiag_index);
    }

	return 1;
}

/* procedure SternKreuz_Check **********************************************************
**     Fuehrt die Stern-Kreuz-Ueberpruefung der Hauptdiagnose und der                 **
**     Zusatzdiagnosen durch.                                                         **
***************************************************************************************/

static void SternKreuz_Check (LKF_AUFENTHALT *pAufenthalt)
{
	unsigned int i, j;
	STERNKR_LIST_STRING *pSternKr, *pSternKreuzCheck;
	int stern_kreuz;

	for (i = 0; i < pAufenthalt->diag_anz; i++) {
		pSternKr = pAufenthalt->sternkr[i];
		if (pSternKr) {
			stern_kreuz = 0;
			for (j = 0; j <= pAufenthalt->diag_anz && !stern_kreuz; j++) {
			
                if (j > 0 && pAufenthalt->diag[j].isHD) {
                    continue;
                }
                
				if (!pAufenthalt->sternkr[j]) {

					pSternKreuzCheck = pSternKr;
					while (!stern_kreuz && !memcmp (*pSternKr, *pSternKreuzCheck, 6)) {
					
                        if (memcmp (pAufenthalt->diag[j].DIAG, (*pSternKreuzCheck) + 14, 6) >= 0 &&
                            memcmp (pAufenthalt->diag[j].DIAG, (*pSternKreuzCheck) + 21, 6) <= 0)
                            stern_kreuz = 1;
						++pSternKreuzCheck;
					}

				}
			}

			if (!stern_kreuz) {
			
				if (pAufenthalt->diag[i].isHD) {
					Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSternKreuzHD, 0);
				}
				else {
					Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSternKreuzZD, i);
				}
			}
		}
	}
}

static void SternKreuz_Check_2014 (LKF_AUFENTHALT *pAufenthalt)
{
	unsigned int i, j, k;
    DIAG_INFO *pDiagInfo, *pKreuzDiagInfo;
    const char *kreuzDiag, *sternDiag;
	STERNKR_LIST_STRING *pSternKr, *pSternKreuzCheck;
	int stern_kreuz;
    int dreisteller;
    unsigned int diag_anz;
    LKF_CONTEXT *pContext;
    unsigned int modelljahr;
    
    pContext = pAufenthalt->pScoringContext;
    modelljahr = pContext->modelljahr;
    
    diag_anz = pAufenthalt->diag_anz;

    for (i = 0; i < diag_anz; i++) {
        
        pDiagInfo = pAufenthalt->diagInfo[i];
        if (!pDiagInfo || !pDiagInfo->max_sternkr || !pDiagInfo->stern_Diagnose) continue;
        sternDiag = (const char *) (pDiagInfo->icd_list_string);
        dreisteller = (sternDiag[4] == ' ' || sternDiag[4] == 'x');
        stern_kreuz = 0;
		pSternKr = pAufenthalt->pScoringContext->pStamm2001->sternkr_list;
        
        for (j = 0; j < diag_anz && !stern_kreuz; j++) {
        
            pKreuzDiagInfo = pAufenthalt->diagInfo[j];

            if (!pKreuzDiagInfo || pKreuzDiagInfo->stern_Diagnose || pKreuzDiagInfo->max_sternkr) continue;
            
            kreuzDiag = (const char *) (pKreuzDiagInfo->icd_list_string);
            
            for (k = pDiagInfo->min_sternkr; k < pDiagInfo->max_sternkr && !stern_kreuz; k++) {
            
                pSternKreuzCheck = pSternKr + k;
                if (dreisteller && (*pSternKreuzCheck)[4] != ' ' && (*pSternKreuzCheck)[4] != 'x')
                    continue;
                if (!dreisteller && ((*pSternKreuzCheck)[4] == ' ' || (*pSternKreuzCheck)[4] == 'x'))
                    continue;
                
                if (memcmp (kreuzDiag, (*pSternKreuzCheck) + 14, 6) >= 0 &&
                    memcmp (kreuzDiag, (*pSternKreuzCheck) + 21, 6) <= 0) {

                
                    if (dreisteller) {
                        if (((*pSternKreuzCheck)[4] == ' ' || (*pSternKreuzCheck)[4] == 'x') &&
                            memcmp (sternDiag, (*pSternKreuzCheck), 3) >= 0 &&
                            memcmp (sternDiag, (*pSternKreuzCheck)+ 7, 3) <= 0)
                            stern_kreuz = 1;
                    } else {
                        if ((*pSternKreuzCheck)[4] != ' ' && (*pSternKreuzCheck)[4] != 'x' &&
                            memcmp (sternDiag, (*pSternKreuzCheck), 6) >= 0 &&
                            memcmp (sternDiag, (*pSternKreuzCheck)+ 7, 6) <= 0)
                            stern_kreuz = 1;
                    }
                }
            }
        }
        
        if (!stern_kreuz) {
        
            
            if (modelljahr >= 2017) {
                if (i < pAufenthalt->hdiag_anz) {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSternKreuzHD, i);
                }
                else {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSternKreuzZD, i);
                }
            }
            else if (!i) {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSternKreuzHD, 0);
            }
            else {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorSternKreuzZD, i);
            }
		}
	}
}


/***********************************************************************************************
** MELDIAG_Check: Fuehrt die MELDIAG-Ueberpruefung durch (wenn die MEL bestimmte MELDIAGs     **
**    definiert hat, muss zumindest eine dieser Diagnosen mit dem Aufenthalt gemeldet werden).**
***********************************************************************************************/

#define MEL_DIAG_ERR		 14

static void MELDIAG_Check (LKF_AUFENTHALT *pAufenthalt, MEL_ARRAY_STRUC *pMel, int melindex, unsigned int i, STAMM2001 *pStamm)
{
	int k;
	unsigned int l;
	int plaus_flag;
	MEL_DIAG_STRUC6 *pMELDiag;
	const char *diag;
    int modelljahr;
    
    modelljahr = pAufenthalt->pScoringContext->modelljahr;

	if (pAufenthalt->isAmb && (!pMel->cDiagVerpflichtend || (pAufenthalt->mel[i].melPlausFlags & LKF_MELCHECKFLAG_DISABLE_WX3L)))
	{
		return; /* V21.2 */
	}

	if (pMel->mel_diag_ug > 0) {
		
		plaus_flag = MEL_DIAG_ERR;
		/* fuer alle Eintraege zu dieser MEL */
		for (l = pMel->mel_diag_ug - 1; plaus_flag == MEL_DIAG_ERR && l < pStamm->mel_diag_gesamt && l <= pMel->mel_diag_og; l++) {

            unsigned int diag_anz;
            
			pMELDiag = GetMELDiag6 (pStamm, l);

			if (!pMELDiag || (modelljahr >= 2006 && (melindex < pMELDiag->mel_min || melindex > pMELDiag->mel_max))) continue;

            diag_anz = pAufenthalt->diag_anz;
            
			/* fuer alle Diagnosen (zu aktueller MEL) */
			for (k = 0; plaus_flag == MEL_DIAG_ERR && k < (int)diag_anz; k++) {

                diag = pAufenthalt->diag[k].DIAG;
                
				if (memcmp (diag, pMELDiag->hdg_min, 3) >= 0 && memcmp (diag, pMELDiag->hdg_max, 3) <= 0) {
				
					if (pMELDiag->hdg4_min != ' ' && pMELDiag->hdg4_max != ' ') {
						if (diag[4] >= pMELDiag->hdg4_min && diag[4] <= pMELDiag->hdg4_max) plaus_flag = 0;
					}
					else plaus_flag = 0;
				}
			}
		}

		if (plaus_flag) {
            Satzart_ReportMBDSError2 (pAufenthalt, modelljahr >= 2016 ? &LKFErrorMELohneDiag2016 : &LKFErrorMELohneDiag, i,0,pAufenthalt->mel[i].nMelAbtIndex);
		}
	}
}


/* function Einzelleistung_Check ******************************************************
**     Ueberprueft die (i+1). Einzelleistung (MEL) des Patienten                     **
***************************************************************************************/

#ifdef SUPPORT_PRE2017
static int mel_in_array (const char *mel, unsigned int nMelCount, const char **mellist)
{
    unsigned int i;
    for (i = 0; i < nMelCount; i++)
    {
        if (!memcmp (mel, mellist[i], LKF_AUFENTHALT_NEWMEL_LEN))
            return 1;
    }
    return 0;
}

static int ismel_entfernt_new (const LKF_CONTEXT *pContext, const char *mel)
{

static const char *entfernte_mels_2010[] = 
	{
		"AJ160", "AJ170", "FC050", "HD010", "HE020", "ME219", "ZZ010"
	};

static const char *entfernte_mels_2011[] = 
    {
		"LH050", "LH090", "LH100"
	};

static const char *entfernte_mels_2012[] =
	{
		"JC020", "LD050", "LD060", "LZ020", "LZ030", "MZ030", "MZ040", "NZ030", "NZ040",
		"PA060", "PD020", "PD030", "XN010"
	};

	switch (pContext->modelljahr)
	{
		case 2009:
			return 0;
		case 2010:
			return mel_in_array (mel, sizeof(entfernte_mels_2010)/sizeof(const char*), entfernte_mels_2010); /* V14.0 */
		case 2011:
			return mel_in_array (mel, sizeof(entfernte_mels_2011)/sizeof(const char*), entfernte_mels_2011); /* V15.0 */
		case 2012:
			return mel_in_array (mel, sizeof(entfernte_mels_2012)/sizeof(const char*), entfernte_mels_2012); /* V16.0 */
		default:
			return 0; /* ab 2013 gestrichen, normale Behandlung als Error */
	}
}
#endif

static int MelEntDatError (const LKF_CONTEXT *pContext, LKF_AUFENTHALT_MEL *pMel, const MEL_ARRAY_STRUC *pMelDef)
{
	return pMelDef->cOp == 'J' && pMelDef->MEL[4]!='9';
}

int lkf_MELABTOK_Check (LKF_AUFENTHALT *pAufenthalt) {
    int j;
    char tmp_spez_list[20];
    const SPEZ_LIST_STRING *pSpezListString;

    LKF_CONTEXT *pContext = pAufenthalt->pScoringContext;
    int melabt_ok = MELABTOK_CHECKED;
    
    if (pContext->modelljahr < 2010)
        melabt_ok |= MELABTOK_AJ140 | MELABTOK_AK010 | MELABTOK_LH010 | MELABTOK_LH021 | MELABTOK_DB020;
    if (pContext->modelljahr < 2017)
        melabt_ok |= MELABTOK_AM110;
    
    
    for (j = 0; j < (int)pAufenthalt->abt_anz; j++) if (!IsEmpty (pAufenthalt->abt[j].ABTFC, 8))
    {
        
        sprintf (tmp_spez_list, ".....%4.4s%8.8s", pAufenthalt->KANR, pAufenthalt->abt[j].ABTFC);
        pSpezListString = SpezInArray (pContext, tmp_spez_list);
        
        if (pSpezListString && !ABTFC_Spez_Check (pAufenthalt, j, pSpezListString, 0 /* V9.4 */)) pSpezListString = 0;
        
        if (pSpezListString) {
            switch ((*pSpezListString)[0]) {
                    
                case 'M':
                    
                    
                    if (pContext->modelljahr >= 2010)
                    { /* Mehrfacheintraege in der Spezlist moeglich */
                        
                        
                        tmp_spez_list[0] = 'M';
                        pSpezListString = FirstSpezInArray (pContext, pSpezListString, tmp_spez_list);
                        
                        do
                        {
                            if ((*pSpezListString)[27] == '0')
                            {
                                switch ((*pSpezListString)[28])
                                {
                                    case '1':
                                        melabt_ok |= MELABTOK_LH020;
                                        break;
                                    case '2':
                                        melabt_ok |= MELABTOK_AJ140;
                                        break;
                                    case '3':
                                        melabt_ok |= MELABTOK_AK010;
                                        break;
                                    case '4':
                                        melabt_ok |= MELABTOK_DB020;
                                        break;
                                    case '5':
                                        melabt_ok |= MELABTOK_LH010;
                                        break;
                                    case '6':
                                        melabt_ok |= MELABTOK_LH021;
                                        break;
                                    default:
                                        break;
                                }
                            }
                            pSpezListString = NextSpezInArray (pContext, pSpezListString, tmp_spez_list);
                        } while (pSpezListString);
                    }
                    else
                    {
                        if ((*pSpezListString)[27] == '0' && (*pSpezListString)[28] == '1')
                            melabt_ok |= MELABTOK_LH020;
                        else if ((*pSpezListString)[27] == '0' && (*pSpezListString)[28] == '2')
                            melabt_ok |= MELABTOK_DB020;
                    }
                    break;
                    
                case 'A':
                    
                    if ((*pSpezListString)[27] == '0')
                        switch ((*pSpezListString)[28]) {
                                
                            case '1':    melabt_ok |= MELABTOK_AM040;
                                break;
                                
                            case '2':    melabt_ok |= MELABTOK_AM050;
                                break;
                                
                            case '3':    melabt_ok |= MELABTOK_AM040 | MELABTOK_AM050;
                                break;
                            default: ;
                        }
                    break;
                    
                case 'J':
                    if (pContext->modelljahr >= 2013)
                    { /* V17.0 */
                        if (!memcmp ((*pSpezListString)+27, "TK", 2))
                        {
                            melabt_ok |= MELABTOK_AM120;
                            if (pContext->modelljahr >= 2017) melabt_ok |= MELABTOK_AM130; /* V22.1 */
                        }
                        else if (!memcmp ((*pSpezListString)+27, "TS", 2) && pContext->modelljahr >= 2017)
                        {
                            melabt_ok |= MELABTOK_AM130;
                        }
                    }
                    else
                    {
                        if ((*pSpezListString)[27] == '0')
                            switch ((*pSpezListString)[28]) {
                                    
                                case '1':    melabt_ok |= MELABTOK_AM030;
                                    break;
                                    
                                case '2':    melabt_ok |= MELABTOK_AM020;
                                    break;
                                    
                                case '3':    melabt_ok |= MELABTOK_AM020 | MELABTOK_AM030;
                                    break;
                                default: ;
                            }
                    }
                    break;
                    
                case 'O':
                    
                    if (pContext->modelljahr >= 2022) {
                        if (!memcmp ((*pSpezListString)+27, "ES", 2)) {
                            melabt_ok |= MELABTOK_AM100;
                        }
                        else if (!memcmp ((*pSpezListString)+27, "ET", 2)) {
                            melabt_ok |= MELABTOK_AM110;
                        }
                        else if (!memcmp ((*pSpezListString)+27, "KS", 2)) {
                            melabt_ok |= MELABTOK_AM140;
                        }
                        else if (!memcmp ((*pSpezListString)+27, "KT", 2)) {
                            melabt_ok |= MELABTOK_AM150;
                        }
                    }
                    else {
                        if ((*pSpezListString)[27] == '0' &&
                            ((*pSpezListString)[28] == '1' || (*pSpezListString)[28] == '2'))
                            melabt_ok |= MELABTOK_AM100;
                        else if (!memcmp ((*pSpezListString)+27, "TK", 2))
                            melabt_ok |= MELABTOK_AM110; /* V21.1 */
                    }
                    
                    break;
                case 'P':
                    if (!memcmp (pAufenthalt->abt[j].ABTFC + 2, "6215", 4)) {
                        melabt_ok |= MELABTOK_AM040 | MELABTOK_AM050;
                    }
                    
                    break;
                    
                case 'S':
                    if ((*pSpezListString)[27] == '0' && (*pSpezListString)[28] == '1') {
                        melabt_ok |= MELABTOK_AA040;
                    }
                    break;
                    
                default: break;
                    
            }
        }
    }
    pAufenthalt->melabt_ok = melabt_ok;
    return melabt_ok;
}

static int search_funk6 (const void *key, const void *elem) {
    return memcmp (key, *(const char**) elem, 6);
}


static int search_funk36 (const void *key, const void *elem) {
    return memcmp (key, *(const char**) elem, 4);
}

/*
static int lkf_diaghasgrp (const LKF_CONTEXT *pContext, const char *diag) {
    ICD_LIST_STRING *pDiaglist;
    pDiaglist = FindDiag6 (pContext->pStamm2001, diag);
    return pDiaglist && !memcmp ((*pDiaglist)+9, "HDG", 3);
}
*/

static int lkf_IsNBettHK (LKF_CONTEXT *pContext, const char *sAbtFC)
{ /* V2019.1 */
    return sAbtFC[0] == '1' && strchr("678", sAbtFC[1]);
}

static int isJNMEL (const char *mel)
{ /* V2020.0 */
    if (mel[0] != 'J' || mel[1] != 'N' || mel[2] != '0' || mel[4] != '0')
        return 0;
    if (strchr ("2345", mel[3]))
        return 1;
    return 0;
    
    // !memcmp(pMelDef->sGruppe, "MEL13.09", 8)
}

static int GetOnkoDiagNumber (char *diag) {
    return (diag[1] - '0') * 10 + (diag[2] - '0');
}

static int IsOnkoDiag (char *diag, int modelljahr, int option)
{ /* V2021.0 */
    int onkodiagnumber;
    switch (diag[0]) {
        case 'C':
            onkodiagnumber = GetOnkoDiagNumber(diag);
            if (onkodiagnumber >= 0 && onkodiagnumber <= 97)
                return 1;
            return 0;
        case 'B':
            if (modelljahr < 2026) {
                return 0;
            }
            onkodiagnumber = GetOnkoDiagNumber(diag);
            if (onkodiagnumber == 21) {
                return 1;
            }
            return 0;
        case 'D':
            onkodiagnumber = GetOnkoDiagNumber(diag);
            if (onkodiagnumber == 32 || onkodiagnumber == 33 || (onkodiagnumber >= 37 && onkodiagnumber <= 48))
                return 1;
            if (option == 2) {
                if (onkodiagnumber == 60 || onkodiagnumber == 61 || onkodiagnumber == 70 || onkodiagnumber == 76) {
                    return 1;
                }
                if (onkodiagnumber == 69 && strchr("3456", diag[4]))
                    return 1;
                if (onkodiagnumber == 63 && diag[4] == '0')
                    return 1;
                if (onkodiagnumber == 64 && diag[4] == '8')
                    return 1;
            }
            return 0;
        default:
            return 0;
    }
}


static int lkf_isEntDat (LKF_AUFENTHALT *pAufenthalt, unsigned int lDat, int aufEntDat)
{ /* V2024.0 */
    unsigned int k;
    if (lDat == 0) {
        return 0;
    }
    if (aufEntDat && lDat == pAufenthalt->lEntDat) {
        return 1;
    }
    
    for (k = 0; k < pAufenthalt->abt_anz; k++)
    {
        if (pAufenthalt->abt[k].lAbtDat == lDat && !memcmp (pAufenthalt->abt[k].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
        {
            return 1;
        }
    }
    return 0;
}

static unsigned int lkf_maxAmbMELAnzPer34 (LKF_AUFENTHALT *pAufenthalt, unsigned int significantMELIndex)
{ /* V2024.0 */
    
    unsigned int i, j, fc34count;
    char fc34key[8][10];
    char curKey[8];
    unsigned int fc34MelAnz[10];
    LKF_AUFENTHALT_MEL *pMel;
    unsigned int nTagMelAnz;
    
    memset (fc34key, 0, sizeof (fc34key));
    memset (fc34MelAnz, 0, sizeof (fc34MelAnz));
    fc34count = 0;
    nTagMelAnz = 0;
    
    for (i = 0, pMel = pAufenthalt->mel; i < pAufenthalt->mel_anz; i++, pMel++) {
        if (pMel->significantMELIndex != significantMELIndex) {
            continue;
        }
        if (pMel->FCLEIST[0]) {
            sprintf (curKey, "%2.2s", pMel->FCLEIST + 2);
        }
        else if (pMel->KALEIST[0]) {
            sprintf (curKey, "%-6s", pMel->KALEIST);
        }
        else {
            continue;
        }
        
        for (j = 0; j < fc34count; j++) {
            if (!strcmp (curKey, fc34key[j])) {
                fc34MelAnz[j] += pMel->nOrigTagMelAnzRelevant;
                if (fc34MelAnz[j] > nTagMelAnz) {
                    nTagMelAnz = fc34MelAnz[j];
                }
                break;
            }
        }

        if (j == fc34count && fc34count < 10) {
            strcpy (fc34key[fc34count], curKey);
            fc34MelAnz[fc34count] = pMel->nOrigTagMelAnzRelevant;
            if (fc34MelAnz[fc34count] > nTagMelAnz) {
                nTagMelAnz = pMel->nOrigTagMelAnzRelevant;
            }
            fc34count++;
        }
    }

    return nTagMelAnz;
}

static int NeedsOnkoDiag (char *mel, int modelljahr)
{ /* V2021.1 */
    if (modelljahr >= 2021 &&  mel[0] == 'X' && strchr("ABC", mel[1])) {
        
        if (mel[1] == 'A') {
            if (memcmp (mel + 2, "250", 3) > 0) {
                return 0;
            }
            if (memcmp (mel + 2, "150", 3) >= 0)
            { /* V2021.2 / V2022.0: 200 -> 150 */
                return 2;
            }
            return 1;
        }
        else {
            return 1;
        }
        return 0;
    }
    return 0;
}

static void lkf_plaus_ignoreMelChecks (LKF_AUFENTHALT *pAufenthalt, LKF_CONTEXT *pContext, unsigned int i, int modelljahr)
{
    int needsOnkoDiag;
    LKF_AUFENTHALT_MEL *pMel;
    
    pMel = pAufenthalt->mel + i;
    
    if ((pContext->flags & LKFCONTEXT_OSG) || (pContext->flags & LKFCONTEXT_OSG_WARN))
    { /* V11.1 */
        unsigned int nFlagPos = 11; /* V13.0 */
        unsigned int nAbtIndex, nFoundAbtIndex = 0;
        char sStandort[8]; /* V14.1 */
        LKF_CONTEXT_ABTEILUNG *pAbtContext;
        const char *pAbtKANR6; /* V19.1 */
        const char *pDefaultKANR6; /* V19.1 */
        const char *pErrorKANR6; /* V2020.2 */
        char cErbringbar = 'X';
        
        int fcleist_modus = modelljahr >= 2020 || (pContext->flags & LKFCONTEXT_SIM4);
        pErrorKANR6 = 0;
        
        if (fcleist_modus && !IsBlank (pMel->KALEIST, 6) && memcmp (pMel->KALEIST, pContext->KANR, 4)) {
            const char *sOEMelKa;
            
            if (!memcmp(pMel->KALEIST + 2, "00", 2) || pMel->KALEIST[0] == 'E' || pMel->KALEIST[0] == 'A')
            {
                cErbringbar = 'J';
            }
            else {
                sOEMelKa = (const char *) FindOeMelka (pContext, pMel->KALEIST, pMel->MEL, nFlagPos);
                if (!sOEMelKa) {
                    cErbringbar = HasOeMelka(pContext, pMel->KALEIST) ? 'N' : 'J'; /* V2020.2 */
                }
                else {
                    cErbringbar = sOEMelKa[nFlagPos];
                    memcpy (sStandort, pMel->KALEIST, 6);
                }
                /* pErrorKANR6 = pMEL->KALEIST; V2020.5: nur in eigener KA den Standort ausgeben */
            }
            nFoundAbtIndex = pMel->nMelAbtIndex; /* V2020.2 */
        }
        else if (fcleist_modus && !IsBlank(pMel->FCLEIST, 8)) {
            const char *sOEMelKa;
            pAbtContext = lkf_context_find_abteilung (pContext, pMel->FCLEIST);
            pAbtKANR6 = pAbtContext ? pAbtContext->sKANR6 : pContext->KANR;
            pErrorKANR6 = pAbtKANR6;
            sOEMelKa = (const char *) FindOeMelka (pContext, pAbtKANR6, pMel->MEL, 0);
            nFoundAbtIndex = pMel->nMelAbtIndex; /* V2020.2 */
            if (!sOEMelKa) {
                cErbringbar = 0;
            }
            else {
                cErbringbar = sOEMelKa[nFlagPos];
                memcpy (sStandort, pAbtKANR6, 6);
            }
        }
        else {
            unsigned lMelDat;
            pDefaultKANR6 = modelljahr >= 2015 ? pContext->KANR : 0;
            lMelDat =  pMel->meldat_nr;
            if (lMelDat)
            {
                for (nAbtIndex = 0; nAbtIndex < pAufenthalt->abt_anz && pAufenthalt->abt[nAbtIndex].lAbtDat && pAufenthalt->abt[nAbtIndex].lAbtDat < lMelDat; nAbtIndex++) ;
                for (; nAbtIndex < pAufenthalt->abt_anz && memcmp (pAufenthalt->abt[nAbtIndex].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN) && pAufenthalt->abt[nAbtIndex].lAbtDat == lMelDat; nAbtIndex++) ; /* V19.1 */
                if (nAbtIndex > 0) --nAbtIndex;
            }
            else nAbtIndex = 0;

            sStandort[0] = 0;
            while (nAbtIndex < pAufenthalt->abt_anz && cErbringbar && (!lMelDat || (pAufenthalt->abt[nAbtIndex].lAbtDat <= lMelDat)))
            {
                /* suche K01-Satz */
                pAbtContext = lkf_context_find_abteilung (pContext, pAufenthalt->abt[nAbtIndex].ABTFC);
                pAbtKANR6 = pAbtContext ? pAbtContext->sKANR6 : pDefaultKANR6;
                if (pAbtKANR6)
                {
                    const char *sOEMelKa = (const char *) FindOeMelka (pContext, pAbtKANR6, pMel->MEL, 0);
                    if (!sOEMelKa || sOEMelKa[nFlagPos] == 'J' /* V12.0 */) {
                        nFoundAbtIndex = nAbtIndex;
                        cErbringbar = 0;
                    }
                    else {
                        switch (cErbringbar)
                        {
                            case 'X':
                                cErbringbar = sOEMelKa[nFlagPos];
                                nFoundAbtIndex = nAbtIndex;
                                memcpy (sStandort, pAbtKANR6, 6);
                                break;
                            case 'N':
                                if (sOEMelKa[nFlagPos] == 'E') /* V13.5 - Korrektur nFlagPos */
                                {
                                    cErbringbar = sOEMelKa[nFlagPos];
                                    nFoundAbtIndex = nAbtIndex;
                                    memcpy (sStandort, pAbtContext->sKANR6, 6);
                                    break;
                                }
                            case 'E':
                                break;
                        }
                    }
                }
                ++nAbtIndex;
            }
        }
        
#ifdef SUPPORT_PRE2017
        if (cErbringbar == 'N')
        {
            if (pContext->flags & LKFCONTEXT_OSG_WARN)
            {
                if (!(Satzart_ReportMBDSError2KANR (pAufenthalt, modelljahr >= 2016 ? &LKFWarningOEMELKA2016 : &LKFWarningOEMELKA, (unsigned int) i, 0, (int) nFoundAbtIndex, pErrorKANR6) & ERROR_ACCEPTED))
                    pMel->nIgnoreMel = 1;
            }
            else
            {
                Satzart_ReportMBDSError2KANR (pAufenthalt, modelljahr >= 2016 ? &LKFErrorOEMELKA2016 : &LKFErrorOEMELKA, (unsigned int) i, 0, (int) nFoundAbtIndex, pErrorKANR6);
            }
        }
        else if (cErbringbar == 'E' && pAufenthalt->Alter < 15)
        {
            if (pContext->flags & LKFCONTEXT_OSG_WARN)
            {
                if (!(Satzart_ReportMBDSError2KANR (pAufenthalt, modelljahr >= 2016 ? &LKFWarningOEMELKAAlter2016 : &LKFWarningOEMELKAAlter, (unsigned int) i, 0, (int)  nFoundAbtIndex, pErrorKANR6) & ERROR_ACCEPTED))
                    pMel->nIgnoreMel = 1;
            }
            else
                Satzart_ReportMBDSError2KANR (pAufenthalt, modelljahr >= 2016 ? &LKFErrorOEMELKAAlter2016 : &LKFErrorOEMELKAAlter, (unsigned int) i, 0, (int) nFoundAbtIndex, pErrorKANR6);
        }
#else
        if (cErbringbar == 'N')
        {
            if (pContext->flags & LKFCONTEXT_OSG_WARN)
            {
                if (!(Satzart_ReportMBDSError2KANR (pAufenthalt, &LKFWarningOEMELKA2016, (unsigned int) i, 0, (int) nFoundAbtIndex, pErrorKANR6) & ERROR_ACCEPTED))
                    pMel->nIgnoreMel = 1;
            }
            else
            {
                Satzart_ReportMBDSError2KANR (pAufenthalt, &LKFErrorOEMELKA2016, (unsigned int) i, 0, (int) nFoundAbtIndex, pErrorKANR6);
            }
        }
        else if (cErbringbar == 'E' && pAufenthalt->Alter < 15)
        {
            if (pContext->flags & LKFCONTEXT_OSG_WARN)
            {
                if (!(Satzart_ReportMBDSError2KANR (pAufenthalt, &LKFWarningOEMELKAAlter2016, (unsigned int) i, 0, (int)  nFoundAbtIndex, pErrorKANR6) & ERROR_ACCEPTED))
                    pMel->nIgnoreMel = 1;
            }
            else
                Satzart_ReportMBDSError2KANR (pAufenthalt, &LKFErrorOEMELKAAlter2016, (unsigned int) i, 0, (int) nFoundAbtIndex, pErrorKANR6);
        }
#endif
    }

    
    needsOnkoDiag = NeedsOnkoDiag (pMel->MEL, modelljahr);
        
    if (needsOnkoDiag) {
        int hasOnko = 0;
        unsigned int k;
        for (k = 0; k < pAufenthalt->diag_anz; k++) {
            if (IsOnkoDiag(pAufenthalt->diag[k].DIAG, modelljahr, needsOnkoDiag)) {
                hasOnko = 1;
                break;
            }
        }
        if (!hasOnko) {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFInfoOnkoIgnore, i, 0, pMel->nMelAbtIndex);
            pAufenthalt->mel[i].nIgnoreMel = 1;
        }
    }
}

static int HasOpMel (LKF_AUFENTHALT *pAufenthalt) {
    unsigned int i;
    LKF_CONTEXT *pContext;
    pContext = pAufenthalt->pScoringContext;
    
    for (i = 0; i < pAufenthalt->mel_anz; i++) {
        MEL_ARRAY_STRUC *pMelDef;
        if (pAufenthalt->mel[i].nMelIndex < 0) {
            continue;
        }
        pMelDef = GetMELArrayFromIndex(pContext, pAufenthalt->mel[i].nMelIndex);
        if (pMelDef && pMelDef->cOp == 'J') {
            return 1;
        }
    }
    return 0;
}

static int HasEBDiag (LKF_AUFENTHALT *pAufenthalt) {
    unsigned int i;
    int has211 = 0, has215 = 0;
    
    for (i = 0; i < pAufenthalt->diag_anz; i++) {
        if (!memcmp (pAufenthalt->diag[i].DIAG, "211.", 4)) {
            if (has215) return 1;
            has211 = 1;
        }
        else if (!memcmp (pAufenthalt->diag[i].DIAG, "215.", 4)) {
            if (has211) return 1;
            has215 = 1;
        }
    }
    return 0;
}

static void Einzelleistung_Check (LKF_AUFENTHALT *pAufenthalt, unsigned int i, int anz, int *diag_ambulant)
{
	int melindex;
	int melanz;
	MEL_ARRAY_STRUC *pMelDef;
	LKF_CONTEXT *pContext = pAufenthalt->pScoringContext;
	STAMM2001 *pStamm = pContext->pStamm2001;
	char act_geschlecht;
	int act_mindestalter,
		act_hoechstalter;
	char act_ambulant, act_bdgr0;
	int j;
	unsigned int lMelDat;
	unsigned int spezmelindex;
	char tmp_mel_ka[12];
	int has_datum;

	int bKassenfrei;

	int mel_psych_ungueltig;
    int nMelAbtIndex;
    int postFixOffset = 1;

#ifdef SUPPORT_PRE2017
    int new_abtmel_errors; /* V20.1 */
    char cRelevant;
#endif
    
    int modelljahr;
    LKF_AUFENTHALT_MEL *pMEL;
    int melabt_ok;
    
    modelljahr = pContext->modelljahr;
    pMEL = pAufenthalt->mel + i;
    
    lMelDat = (unsigned int) pMEL->meldat_nr;
    
#ifdef SUPPORT_PRE2017
    
    new_abtmel_errors = modelljahr >= 2016; /* V20.1 */

    nMelAbtIndex = (new_abtmel_errors /* V20.1 */ || pAufenthalt->pScoringContext->standortInfo) ? pMEL->nMelAbtIndex : -1;

	if (IsBlank (pMEL->MEL, 5) || TrimEqual (pMEL->MEL, 5, "0") || !memcmp (pMEL->MEL, "00000", LKF_AUFENTHALT_NEWMEL_LEN)) return;

	bKassenfrei = 0;
    melindex = pMEL->nMelIndex;
    
    if (modelljahr >= 2012) postFixOffset = 2; /* V17.0: vorletzte Stelle = Seite */
    
    if (!IsBlank (pMEL->ORIG_MEL + LKF_AUFENTHALT_NEWMEL_LEN, LKF_AUFENTHALT_ORIGMEL_LEN - LKF_AUFENTHALT_NEWMEL_LEN - postFixOffset))
    {
        Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELfalsch2016 : &LKFErrorMELfalsch, i, 0, nMelAbtIndex);
        return;
    }
    
    if (pContext->modelljahr >= 2017)
        cRelevant = pMEL->MEL_RELEVANT;
    else
        cRelevant = pMEL->ORIG_MEL[9];
    
    switch (cRelevant)
    {
        case 'K': /* V21.1 */
            if (modelljahr >= 2017)
                bKassenfrei = 1;
            else {
                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorKassenfreiFalsch2016 : &LKFErrorKassenfreiFalsch, i, 0, nMelAbtIndex);
            }
            break;
        case 'N':
            bKassenfrei = 1;
            break;
        case 'J':
            bKassenfrei = 0;
            break;
        case 0:
        case ' ':
            if (modelljahr >= 2017 && pContext->model2017errors)
            { /* V21.2: ab Modell 2017 ist blank nicht mehr zulaessig */
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorKassenfreiFalsch2017, i, 0, nMelAbtIndex);
            }
            bKassenfrei = 0;
            break;
        default:
            if (modelljahr >= 2017)
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorKassenfreiFalsch2017, i, 0, nMelAbtIndex);
            else
                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorKassenfreiFalsch2016 : &LKFErrorKassenfreiFalsch, i, 0, nMelAbtIndex);
            return;
    }
    
    if (melindex < 0)
    {
        if (ismel_entfernt_new (pContext, pMEL->MEL))
        {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELEntfernt, i, 0, nMelAbtIndex);
            memcpy (pMEL->MEL, "    0", 5);
            memcpy (pMEL->MELANZ, "   0", 4);
        }
        else {
            Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELfalsch2016 : &LKFErrorMELfalsch, i, 0, nMelAbtIndex);
        }
        return;
    }
    if (modelljahr < 2017)
        pMEL->MEL_RELEVANT = bKassenfrei ? 'N' : ' ';
#else
    nMelAbtIndex = pMEL->nMelAbtIndex;

    if (IsBlank (pMEL->MEL, 5) || TrimEqual (pMEL->MEL, 5, "0") || !memcmp (pMEL->MEL, "00000", LKF_AUFENTHALT_NEWMEL_LEN)) return;

    bKassenfrei = 0;
    melindex = pMEL->nMelIndex;
    
    postFixOffset = 2; /* V17.0: vorletzte Stelle = Seite */
    
    if (!IsBlank (pMEL->ORIG_MEL + LKF_AUFENTHALT_NEWMEL_LEN, LKF_AUFENTHALT_ORIGMEL_LEN - LKF_AUFENTHALT_NEWMEL_LEN - postFixOffset))
    {
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELfalsch2016, i, 0, nMelAbtIndex);
        return;
    }
    
    switch (pMEL->MEL_RELEVANT)
    {
        case 'K': /* V21.1 */
            if (modelljahr >= 2017)
                bKassenfrei = 1;
            else {
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorKassenfreiFalsch2016, i, 0, nMelAbtIndex);
            }
            break;
        case 'N':
            bKassenfrei = 1;
            break;
        case 'J':
            bKassenfrei = 0;
            break;
        case 0:
        case ' ':
            if (pContext->model2017errors) {
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorKassenfreiFalsch2017, i, 0, nMelAbtIndex);
                bKassenfrei = 0;
            }
            break;
        default:
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorKassenfreiFalsch2017, i, 0, nMelAbtIndex);
            return;
    }

    if (melindex < 0)
    {
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELfalsch2016, i, 0, nMelAbtIndex);
        return;
    }
#endif
	pMelDef = pStamm->mel_array + melindex;
    
    if (pMelDef->ambFixPunkte) {
        if (!pAufenthalt->isAmb) {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELStatUngueltig, i, 0, nMelAbtIndex);
            return;
        }

        if (pAufenthalt->isAmb == 2 && modelljahr >= 2025) {
            pMEL->ambFixPunkte = pMelDef->ambFixPunkte * pMEL->nTagMelAnzRelevant;
            pMEL->punkteRelevant = 1;
        }
    }
    
	/* MEL: Verknuepfungen zu den Bedingungen Alter, Geschlecht */

	mel_psych_ungueltig = 0;

    if (pAufenthalt->isAmb) {
        
        if (IsConstMEL (pContext, CONSTMEL_AM060_7596, melindex)) {
            if (!(pAufenthalt->psych_flag & 2)) mel_psych_ungueltig = 1;
        }
        else if (IsConstMEL (pContext, CONSTMEL_AM070_7597, melindex)) {
            if (!(pAufenthalt->psych_flag & 4)) mel_psych_ungueltig = 1;
        }
        else if (IsConstMEL (pContext, CONSTMEL_AM080_7598, melindex)) {
            if (!(pAufenthalt->psych_flag & 8)) mel_psych_ungueltig = 1;
        }
        else if (IsConstMEL (pContext, CONSTMEL_AM090_7601, melindex)) {
            if (!(pAufenthalt->psych_flag & 16)) mel_psych_ungueltig = 1;
        }
        else if (IsConstMEL (pContext, CONSTMEL_AM110, melindex)) {
            if (!(pAufenthalt->psych_flag & 32)) mel_psych_ungueltig = 1;
        }
        else if (modelljahr >= 2022 && IsConstMEL (pContext, CONSTMEL_AM150, melindex)) {
            if (!(pAufenthalt->psych_flag & 256)) mel_psych_ungueltig = 1;
        }
        else if (IsConstMEL (pContext, CONSTMEL_AM120, melindex)) {
            if (!(pAufenthalt->psych_flag & 64)) mel_psych_ungueltig = 1;
        }
        else if (IsConstMEL (pContext, CONSTMEL_AM130, melindex)) {
            if (pAufenthalt->pScoringContext->modelljahr >= 2017) {
                if (!(pAufenthalt->psych_flag & 192)) mel_psych_ungueltig = 1;
            }
            else if (!(pAufenthalt->psych_flag & 128)) mel_psych_ungueltig = 1;
        }
        else if (pAufenthalt->psych_flag) {
            mel_psych_ungueltig = 33;
        }
    }
    else {
        switch (pAufenthalt->psych_mode) {
            case 1: if (!IsConstMEL (pContext, CONSTMEL_AM060_7596, melindex)) mel_psych_ungueltig = 3;
                break;
            case 2: if (!IsConstMEL (pContext, CONSTMEL_AM070_7597, melindex)) mel_psych_ungueltig = 3;
                break;
            case 3: if (!IsConstMEL (pContext, CONSTMEL_AM080_7598, melindex)) mel_psych_ungueltig = 3;
                break;
            case 23: /* V17.1 */
                if (!IsConstMEL (pContext, CONSTMEL_AM080_7598, melindex) &&
                    !IsConstMEL (pContext, CONSTMEL_AM070_7597, melindex)) mel_psych_ungueltig = 3;
                break;
            case 4: if (!IsConstMEL (pContext, CONSTMEL_AM090_7601, melindex)) mel_psych_ungueltig = 3;
                break;
            case 5:
                if (!IsConstMEL (pContext, CONSTMEL_AM110, melindex)) mel_psych_ungueltig = 3;
                break;
            case 8:
                if (!IsConstMEL (pContext, CONSTMEL_AM150, melindex)) mel_psych_ungueltig = 3;
                break;
            case 6:
                if (modelljahr >= 2017) {
                    if (!IsConstMEL (pContext, CONSTMEL_AM120, melindex) && !IsConstMEL (pContext, CONSTMEL_AM130, melindex)) mel_psych_ungueltig = 3;
                }
                else if (!IsConstMEL (pContext, CONSTMEL_AM120, melindex)) mel_psych_ungueltig = 3;
                break;
            case 7:
                if (!IsConstMEL (pContext, CONSTMEL_AM130, melindex)) mel_psych_ungueltig = 3;
                break;
            case 1025: case 1026: case 1027: case 1047: /* V17.1 */
                if (IsConstMEL (pContext, CONSTMEL_AM060_7596, melindex) ||
                    IsConstMEL (pContext, CONSTMEL_AM070_7597, melindex) ||
                    IsConstMEL (pContext, CONSTMEL_AM080_7598, melindex)) mel_psych_ungueltig = 2;
                break;
            case 1028:
                if (IsConstMEL (pContext, CONSTMEL_AM090_7601, melindex)) mel_psych_ungueltig = 2;
                break;
            case 1029:
                if (IsConstMEL (pContext, CONSTMEL_AM110, melindex)) mel_psych_ungueltig = 2;
                break;
            case 1032: /* V2022.0 */
                if (IsConstMEL (pContext, CONSTMEL_AM150, melindex)) mel_psych_ungueltig = 2;
                break;
            case 1030: /* V17.0 */
                if (modelljahr >= 2017) {
                    if (IsConstMEL (pContext, CONSTMEL_AM120, melindex) || IsConstMEL (pContext, CONSTMEL_AM130, melindex)) mel_psych_ungueltig = 3;
                }
                else if (IsConstMEL (pContext, CONSTMEL_AM120, melindex)) mel_psych_ungueltig = 2;
                break;
            case 1031: /* V21.1 */
                if (IsConstMEL (pContext, CONSTMEL_AM130, melindex)) mel_psych_ungueltig = 2;
                break;
            default: if (IsConstMEL (pContext, CONSTMEL_AM060_7596, melindex) ||
                         IsConstMEL (pContext, CONSTMEL_AM070_7597, melindex) ||
                         IsConstMEL (pContext, CONSTMEL_AM080_7598, melindex) ||
                         IsConstMEL (pContext, CONSTMEL_AM090_7601, melindex)) mel_psych_ungueltig = 1;
                if (pContext->modelljahr >= 2013 && IsConstMEL (pContext, CONSTMEL_AM120, melindex)) mel_psych_ungueltig = 1; /* V17.0 */
                if (pContext->modelljahr >= 2017 && IsConstMEL (pContext, CONSTMEL_AM130, melindex)) mel_psych_ungueltig = 1; /* V21.1 */
                if (pContext->modelljahr >= 2017 && IsConstMEL (pContext, CONSTMEL_AM110, melindex)) mel_psych_ungueltig = 1; /* V21.1 */
                if (pContext->modelljahr >= 2022 && IsConstMEL (pContext, CONSTMEL_AM150, melindex)) mel_psych_ungueltig = 1; /* V2022.0 */
                break;
        }
    }
    
    
    if (mel_psych_ungueltig == 2) {

#ifdef SUPPORT_PRE2017
        Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneAUFART2016 : &LKFErrorMELohneAUFART, i, 0, nMelAbtIndex);
#else
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneAUFART2016, i, 0, nMelAbtIndex);
#endif
	}
    else if (mel_psych_ungueltig == 33) {
        if (!IsEmpty (pMelDef->sAmbGruppe, 8))
        { /* nur bei berechnungsrelevanten Leistungen eine Warning ausgeben */
            if (modelljahr >= 2018)
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELignoriert2018, i, 0, nMelAbtIndex);
            else
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELignoriert2016, i, 0, nMelAbtIndex);
        }
        
    }
	else if (mel_psych_ungueltig == 3) {
		if (!IsEmpty (pMelDef->sGruppe, 8))
		{ /* nur bei berechnungsrelevanten Leistungen eine Warning ausgeben */
            if (modelljahr >= 2018)
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELignoriert2018, i, 0, nMelAbtIndex);
            else
#ifdef SUPPORT_PRE2017
                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELignoriert2016 : &LKFErrorMELignoriert, i, 0, nMelAbtIndex);
#else
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELignoriert2016, i, 0, nMelAbtIndex);
#endif
		}
	}
	else if (mel_psych_ungueltig) {
#ifdef SUPPORT_PRE2017
        Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELFC2016 : &LKFErrorMELFC, i, 0, nMelAbtIndex);
#else
        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELFC2016, i, 0, nMelAbtIndex);
#endif
        lkf_stat_register_case(pAufenthalt, "EX26", pAufenthalt->mel[i].MEL);
	}
	else {

        if (modelljahr >= 2017)
        { /* V22.1 */
            if (pMelDef->cStatVerpflichtend) {
                if (*diag_ambulant > 0 && LKF_IS_TRACE_DETAIL(pAufenthalt->pScoringContext->nTraceAufenthalt))
                {
                    char sTraceLine[1024];
                    sprintf (sTraceLine, "Stationaer verpflichtende MEL '%s' -> kein WX3F", pMelDef->MEL);
                    TRACE_DETAIL(pAufenthalt, 0, sTraceLine);
                }
                *diag_ambulant = 0;
            }
                 
        }
        else
            *diag_ambulant = 0;

        if (pAufenthalt->isAmb)
        { /* V21.2 */
            if (!memcmp (pMelDef->MEL, "ZN8", 3) && (!memcmp (pMelDef->MEL + 3, "00", 2) || !memcmp (pMelDef->MEL + 3, "10", 2)) && pAufenthalt->ENTART != '8' && pAufenthalt->ENTART != ' ' && pAufenthalt->ENTART) {
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELENTART2016, i, 0, nMelAbtIndex);
            
            }
        }
        else if (modelljahr >= 2017 && pAufenthalt->ENTART != 'S' && !memcmp (pMelDef->MEL, "ZN8", 3) && (!memcmp (pMelDef->MEL + 3, "00", 2) || !memcmp (pMelDef->MEL + 3, "10", 2))) {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELENTART2016, i, 0, nMelAbtIndex);
            
        }

		act_geschlecht = pMelDef->cGeschlecht;
		act_mindestalter = pMelDef->nAltermin;
		act_hoechstalter = pMelDef->nAltermax;
		act_ambulant = pMelDef->cAmbulant;
		act_bdgr0 = pMelDef->cBdgr0;

        if (pAufenthalt->GESVD == 0 && act_ambulant == 'J' && !pAufenthalt->isAmb && (pAufenthalt->ENTART == 'E' || (modelljahr >= 2022 && pAufenthalt->ENTART == LKF_ENTART_REVERS)))
        {
#ifdef SUPPORT_PRE2017
            Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELAmbulant2016 : &LKFErrorMELAmbulant, i, 0, nMelAbtIndex);
#else
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELAmbulant2016, i, 0, nMelAbtIndex);
#endif
        }
        
		if (pAufenthalt->isAmb
            || (pAufenthalt->GESVD == 0 &&
                 (pAufenthalt->ENTART == 'E' || (modelljahr >= 2022 && pAufenthalt->ENTART == LKF_ENTART_REVERS)))
            || (modelljahr >= 2024 && (pMelDef->cLE != 'B' && pMelDef->cLE != 'E' /* V2024.1 */) && lkf_isEntDat(pAufenthalt, lMelDat, (pAufenthalt->ENTART == 'E' || pAufenthalt->ENTART == LKF_ENTART_REVERS)))) {
		
			
			if (act_bdgr0 == 'E') {
                
                if (modelljahr >= 2024) {
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMEL0Tage2024, i, 0, nMelAbtIndex);
                }
                else {
#ifdef SUPPORT_PRE2017
                    Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMEL0Tage2016 : &LKFErrorMEL0Tage, i, 0, nMelAbtIndex);
#else
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMEL0Tage2016, i, 0, nMelAbtIndex);
#endif
                }
                pMEL->melPlausFlags |= LKF_MELCHECKFLAG_WX3P_EX24;
			}
			else if (act_bdgr0 == 'W') {
                int acc;
                
                if (modelljahr >= 2024) {
                    acc = Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMEL0TageWarn2024, i, 0, nMelAbtIndex);
                }
                else {
#ifdef SUPPORT_PRE2017
                    acc = Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMEL0TageWarn2016 : &LKFErrorMEL0TageWarn, i, 0, nMelAbtIndex);
#else
                    acc = Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMEL0TageWarn2016, i, 0, nMelAbtIndex);
#endif
                }
                if (acc & ERROR_ACCEPTED)
                {
                    pMEL->melPlausFlags |= LKF_MELCHECKFLAG_WX3P_ACCEPTED;
                }
                pMEL->melPlausFlags |= LKF_MELCHECKFLAG_WX3P_EX24;
			}
		}

		if (!(pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE) || pAufenthalt->GESCHL != ' ') {
			if (act_geschlecht != ' ' && act_geschlecht != pAufenthalt->GESCHL) {
                
                if ((pContext->modelljahr < 2020 && !DisableGenderCheck(pAufenthalt, pContext->modelljahr)) ||
                    (pContext->modelljahr >= 2020 && !DisableGenderCheck(pAufenthalt, pContext->modelljahr))) {
#ifdef SUPPORT_PRE2017
                    Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELGeschl2016 : &LKFErrorMELGeschl, i, 0, nMelAbtIndex);
#else
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELGeschl2016, i, 0, nMelAbtIndex);
#endif
                }
			}
		}

#ifdef SUPPORT_PRE2017
		if (pAufenthalt->Alter != -99 &&
			(pAufenthalt->Alter < act_mindestalter || pAufenthalt->Alter > act_hoechstalter)) { /* V20.1: Alter immer pruefen - Wert "0" gilt fuer Alter = 0 Jahre */
            Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELAlter2016 : &LKFErrorMELAlter, i, 0, nMelAbtIndex);
			}
		
		/* MELANZ: Verknuepfungen zum Feld MELANZAHL */
		if (!GetInt (pMEL->MELANZ, LKF_AUFENTHALT_MELANZ_LEN, &melanz)) {
            Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELANZfalsch2016 : &LKFErrorMELANZfalsch, i, 0, nMelAbtIndex);
		}
		else if (melanz < 1) /* V9.2: EM1W statt EM1Z */		
		{
			Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneAnzahl2016 : &LKFErrorMELohneAnzahl, i, 0, nMelAbtIndex);
		}
#else
        if (pAufenthalt->Alter != -99 &&
            (pAufenthalt->Alter < act_mindestalter || pAufenthalt->Alter > act_hoechstalter)) { /* V20.1: Alter immer pruefen - Wert "0" gilt fuer Alter = 0 Jahre */
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELAlter2016, i, 0, nMelAbtIndex);
            }
        
        /* MELANZ: Verknuepfungen zum Feld MELANZAHL */
        if (!GetInt (pMEL->MELANZ, LKF_AUFENTHALT_MELANZ_LEN, &melanz)) {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELANZfalsch2016, i, 0, nMelAbtIndex);
        }
        else if (melanz < 1) /* V9.2: EM1W statt EM1Z */
        {
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneAnzahl2016, i, 0, nMelAbtIndex);
        }
#endif
        
        if (pAufenthalt->isAmb) {
            if (pMelDef->amb_melanz_error && anz >= pMelDef->amb_melanz_error) {
                if (modelljahr >= 2024) {
                    unsigned int adjustedAnz = lkf_maxAmbMELAnzPer34(pAufenthalt, i);
                    if (adjustedAnz >= (unsigned int) pMelDef->amb_melanz_error) {
                        Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorAmbMELANZmaxErr, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL);
                    }
                    else if (adjustedAnz >= (unsigned int) pMelDef->amb_melanz_warn) {
                        Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorAmbMELAnzWarn, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL);
                    }
                }
                else {
                    Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorAmbMELANZmaxErr, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL);
                }
                
            }
            else if (pMelDef->amb_melanz_warn && anz >= pMelDef->amb_melanz_warn) {
                
                if (modelljahr >= 2024) {
                    unsigned int adjustedAnz = lkf_maxAmbMELAnzPer34(pAufenthalt, i);
                    if (adjustedAnz >= (unsigned int) pMelDef->amb_melanz_warn) {
                        Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorAmbMELAnzWarn, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL);
                    }
                }
                else {
                    Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorAmbMELAnzWarn, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL);
                }
            }
        }
        else if ((!pAufenthalt->psych_mode || pAufenthalt->psych_mode > 1024) && !pMelDef->cDisableLimitCheck) {
            /* MEL: Hoechstanzahl, Warngrenze */
            
#ifdef SUPPORT_PRE2017
            if (anz >= pMelDef->mel_anz) {
				if (pMelDef->mel_anz)
                    Satzart_ReportMBDSErrorMEL (pAufenthalt, new_abtmel_errors ? &LKFErrorMELANZmaxErr2016 : &LKFErrorMELANZmaxErr2009, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL);

			}
			else if (anz >= pMelDef->mel_warn) {
				if (pMelDef->mel_warn)
                    Satzart_ReportMBDSErrorMEL (pAufenthalt, new_abtmel_errors ? &LKFErrorMELAnzWarn2016 : &LKFErrorMELAnzWarn2009, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL);

			}
#else
            if (anz >= pMelDef->mel_anz) {
                if (pMelDef->mel_anz)
                    Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorMELANZmaxErr2016, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL);

            }
            else if (anz >= pMelDef->mel_warn) {
                if (pMelDef->mel_warn)
                    Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorMELAnzWarn2016, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL);

            }
#endif
		}

		if (!pMelDef->cDisableLimitCheck && !pAufenthalt->isAmb /* V21.2 */)
		{
			int nTagMelAnz = (int) pMEL->nTagMelAnz;
			if (nTagMelAnz > 0)
			{
#ifdef SUPPORT_PRE2017
				if (nTagMelAnz >= pMelDef->tag_mel_anz)
                    Satzart_ReportMBDSErrorMEL (pAufenthalt, new_abtmel_errors ? &LKFErrorMELANZmaxErrTag2016 : &LKFErrorMELANZmaxErrTag, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL_DAY);
				else if (nTagMelAnz >= pMelDef->tag_mel_warn)
                    Satzart_ReportMBDSErrorMEL (pAufenthalt, new_abtmel_errors ? &LKFErrorMELAnzWarnTag2016 : &LKFErrorMELAnzWarnTag, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL_DAY);
#else
                if (nTagMelAnz >= pMelDef->tag_mel_anz)
                    Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorMELANZmaxErrTag2016, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL_DAY);
                else if (nTagMelAnz >= pMelDef->tag_mel_warn)
                    Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorMELAnzWarnTag2016, i, 0, nMelAbtIndex, i, LKF_MBDSERRORMELCOMPARE_MEL_DAY);
#endif
			}
		}

		/* MEL: Laenderfonds-PLAUS (3) MEL-KA */
        if (modelljahr >= 2024 && pMEL->KALEIST[0]  && pMEL->KALEIST[0] != ' ') {
            sprintf (tmp_mel_ka, "%4.4s %5.5s", pMEL->KALEIST, pMEL->MEL);
        }
        else {
            sprintf (tmp_mel_ka, "%4.4s %5.5s", pAufenthalt->KANR, pMEL->MEL);
        }
	
        if (pContext->modelljahr >= 2020 && isJNMEL(pMEL->MEL)) {
        
			unsigned int k;
            char first301DIAG[8];
			int count_301 = 0;

            for (k = 0; k < pAufenthalt->diag_anz; k++) {
                if (!memcmp (pAufenthalt->diag[k].DIAG, "301", 3)) {
                    
                    if (count_301 == 0) {
                        memcpy (first301DIAG, pAufenthalt->diag[k].DIAG, 6);
                        ++count_301;
                    }
                    else if (memcmp (first301DIAG, pAufenthalt->diag[k].DIAG, 6)) {
                        ++count_301;
                    }
                }
            }
            
            if (count_301 == 0) {
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorBirthNoZD, i, 0, nMelAbtIndex);
            }
            else if (count_301 > 1) {
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorBirthMultiZD, i, 0, nMelAbtIndex);
            }
        }
        
        
        if (GetMELKA (pContext, tmp_mel_ka)) {
#ifdef SUPPORT_PRE2017
            Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELfKAunplaus2016 : &LKFErrorMELfKAunplaus2007, (unsigned int) i, 0, nMelAbtIndex);
#else
            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELfKAunplaus2016, (unsigned int) i, 0, nMelAbtIndex);
#endif
		}

		/* Ueberpuefung des MEL-Datums */
		has_datum = 0;
		for (j = 0; !has_datum && j < LKF_AUFENTHALT_DAT_LEN; j++) {
			if (pMEL->MELDAT[j] != '0' && pMEL->MELDAT[j] != ' ') has_datum = 1;
		}

        if (pAufenthalt->isAmb) {
            if (pMelDef->cDiagVerpflichtend && modelljahr < 2019 /* V2019.0 */) {
                if (pAufenthalt->diag_anz == 0 && pAufenthalt->hdiag_anz == 0) {
                    int acc = Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAMBMELDIAGfehlt, (unsigned int) i, 0, nMelAbtIndex);
                    if (acc & ERROR_ACCEPTED)
                    {
                        pMEL->melPlausFlags |= LKF_MELCHECKFLAG_DISABLE_WX3L;
                    }
                }
                /* V2019.1: check bei den Diagnosen
                else if (modelljahr >= 2019) {
                    unsigned int k;
                    int diaghasgrp = 0;
                    for (k = 0; !diaghasgrp && k < pAufenthalt->hdiag_anz; k++) {
                        diaghasgrp = lkf_diaghasgrp (pContext, pAufenthalt->hdiag[k].DIAG);
                    }
                    
                    if (!diaghasgrp) {
                        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorAMBMELDIAGung, i,0,pAufenthalt->mel[i].nMelAbtIndex);
                    }
                }
                */
            }
            if (pMelDef->cTKL == 'J') {
                Satzart_ReportMBDSError2 (pAufenthalt, (modelljahr >= 2018) ? &LKFWarningTKLAmbulant2018 : &LKFWarningTKLAmbulant, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (modelljahr >= 2020 && !memcmp (pMelDef->sAmbGruppe, "AMG00.90", 8)) {
                if (modelljahr < 2022 || !IsEmpty(pMelDef->sGruppe, 8)) {
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFWarningStatMELAmbulant, (unsigned int) i, 0, nMelAbtIndex);
                }
            }
        }

        if (!bKassenfrei)
        { /* V21.3: MELDIAG nach hinten verlegt, falls EX4A akzeptiert ist */
            MELDIAG_Check (pAufenthalt, pMelDef, melindex, i, pStamm);
        }

		if (has_datum) {
			if (!lMelDat) {
				Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELDATfalsch2005, (unsigned int) i, 0, nMelAbtIndex);
			}
			else 
			{
                
				if (!(pMelDef->melflags & LKF_MEL_FLAG_NOAUFDATE) &&
					 ((pAufenthalt->lAufDat && pAufenthalt->lAufDat > (int) lMelDat) ||
					 (pAufenthalt->lEntDat && pAufenthalt->lEntDat < (int) lMelDat))) 
				{
                    if (!pAufenthalt->isAmb || (pAufenthalt->lAufDat > (int) lMelDat /* V21.2 */ || pAufenthalt->lAufDat + 1 < (int) lMelDat)) {
                        
                        if (!(pMelDef->melflags & LKF_MEL_FLAG_NOAUFDATE2017)
                            || ((pAufenthalt->isAmb || modelljahr < 2019) && pAufenthalt->lEntDat && pAufenthalt->lAufDat + 30 < (int) lMelDat)
                            || (!pAufenthalt->isAmb && modelljahr >= 2019 && pAufenthalt->lEntDat && pAufenthalt->lEntDat + 30 < (int) lMelDat)
                            || (pAufenthalt->lAufDat && pAufenthalt->lAufDat > (int) lMelDat))
                        { /* V21.4 */
                            Satzart_ReportMBDSError2 (pAufenthalt, (pAufenthalt->pScoringContext->modelljahr >= 2017) ? &LKFErrorMELDATaussAufenthalt2017 : &LKFErrorMELDATaussAufenthalt2005, (unsigned int) i, 0, nMelAbtIndex);
                        }
                    }
				}

                
                if (modelljahr >= 2017) {
                    if (MelEntDatError(pContext, pMEL, pMelDef) &&
                        pMelDef->cTKL != 'J' &&
                        pAufenthalt->lAufDat < pAufenthalt->lEntDat - 1 &&
                        (act_bdgr0 == 'W' || act_bdgr0 == 'E')) {
                            
                        if (!(pMEL->melPlausFlags & LKF_MELCHECKFLAG_WX3P_EX24)
                            && lkf_isEntDat(pAufenthalt, lMelDat, pAufenthalt->ENTART != LKF_ENTART_REVERS && pAufenthalt->ENTART != 'S' && pAufenthalt->ENTART != 'T')) {
                            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELENTDAT2016, (unsigned int) i, 0, nMelAbtIndex);
                        }
                        /*
                        if (pAufenthalt->lEntDat == lMelDat &&
                            pAufenthalt->ENTART != LKF_ENTART_REVERS && pAufenthalt->ENTART != 'S' && pAufenthalt->ENTART != 'T')
                        {
                            
                            if (modelljahr < 2024 || !(pMEL->melPlausFlags & LKF_MELCHECKFLAG_WX3P_EX24)) {
                                
                                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELENTDAT2016, (unsigned int) i, 0, nMelAbtIndex);
                            }
                        }
                        else if (modelljahr < 2024 || !(pMEL->melPlausFlags & LKF_MELCHECKFLAG_WX3P_EX24)) {
                            unsigned int k;
                            for (k = 0; k < pAufenthalt->abt_anz; k++)
                            {
                                if (pAufenthalt->abt[k].lAbtDat == lMelDat && !memcmp (pAufenthalt->abt[k].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
                                {
                                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELENTDAT2016, (unsigned int) i, 0, nMelAbtIndex);
                                    break;
                                }
                            }
                        }
                        */
                    }
                }
                else if (MelEntDatError(pContext, pAufenthalt->mel + i, pMelDef) &&
					 (!pMelDef->cDisableLimitCheck || pContext->modelljahr < 2015) && /* V19.1 */
					pMelDef->cTKL != 'J' &&									/* Ausnahme: TKL-MEL ok */
					pAufenthalt->lAufDat < pAufenthalt->lEntDat - 1 &&			/* mind. 2 taegiger Aufenthalt */
					act_ambulant != 'J')										/* Ausnahme: ambulante MELs ok */
				{
#ifdef SUPPORT_PRE2017
					if (pAufenthalt->lEntDat == lMelDat &&							/* Leistungserbringung am Entlassungstag */
                        pAufenthalt->ENTART != LKF_ENTART_REVERS && pAufenthalt->ENTART != 'S' && pAufenthalt->ENTART != 'T') {
                        Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELENTDAT2016 : &LKFErrorMELENTDAT, (unsigned int) i, 0, nMelAbtIndex);
                    }
					else if (modelljahr >= 2010)
					{
						unsigned int k;
						for (k = 0; k < pAufenthalt->abt_anz; k++)
						{
							if (pAufenthalt->abt[k].lAbtDat == lMelDat && !memcmp (pAufenthalt->abt[k].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
							{
                                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELENTDAT2016 : &LKFErrorMELENTDAT, (unsigned int) i, 0, nMelAbtIndex);
								break;
							}
						}
					}
#else
                    if (pAufenthalt->lEntDat == lMelDat &&                            /* Leistungserbringung am Entlassungstag */
                        pAufenthalt->ENTART != LKF_ENTART_REVERS && pAufenthalt->ENTART != 'S' && pAufenthalt->ENTART != 'T') {
                        Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELENTDAT2016, (unsigned int) i, 0, nMelAbtIndex);
                    }
                    else
                    {
                        unsigned int k;
                        for (k = 0; k < pAufenthalt->abt_anz; k++)
                        {
                            if (pAufenthalt->abt[k].lAbtDat == lMelDat && !memcmp (pAufenthalt->abt[k].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
                            {
                                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELENTDAT2016, (unsigned int) i, 0, nMelAbtIndex);
                                break;
                            }
                        }
                    }
#endif
				}

				if (modelljahr < 2019 && !pAufenthalt->isAmb && pAufenthalt->psych_mode && pAufenthalt->psych_mode < 1024 && !mel_psych_ungueltig) {
					if (i > 0 && !memcmp (pAufenthalt->mel[i-1].MEL, pMEL->MEL, LKF_AUFENTHALT_NEWMEL_LEN)) {
						long lPrevMelDat = lkf_dat2int (pAufenthalt->mel[i-1].MELDAT);
						if (lPrevMelDat && lMelDat > (unsigned int) lPrevMelDat + 5)
#ifdef SUPPORT_PRE2017
                            Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMEL4Tage2016 : &LKFErrorMEL4Tage, (unsigned int) i, 0, nMelAbtIndex);
#else
                            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMEL4Tage2016, (unsigned int) i, 0, nMelAbtIndex);
#endif
					}
				}

			}
		}
		else if (!(pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE)) {
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELDATfehlt2005, (unsigned int) i, 0, nMelAbtIndex);
		}
        
        if (pMelDef->melflags & LKF_MEL_FLAG_REVISION) {
            /* V19.0: Zusatzdiagnose 101 - 104 erforderlich */
            unsigned int diagIndex;
            int found = 0;
            for (diagIndex = 0; !found && diagIndex < pAufenthalt->diag_anz; diagIndex++) {
                const char *diag = pAufenthalt->diag[diagIndex].DIAG;
                if (diag[0] == '1' && diag[1] == '0') {
                    if (diag[2] == '1' || diag[2] == '2' || diag[2] == '3' || diag[2] == '4') {
                        found = 1;
                    }
                    else if (SAFEIS2017ORLATER(pAufenthalt) && (diag[2] == '5' || diag[2] == '6' || diag[2] == '7'))
                    { /* V21.2 */
                        found = 1;
                    }
                }
            }
            
            if (!found) {
#ifdef SUPPORT_PRE2017
                if (modelljahr >= 2017) {
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorRevisionGrund2017, (unsigned int) i, 0, nMelAbtIndex);
                }
                else {
                    Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorRevisionGrund2016 : &LKFErrorRevisionGrund, (unsigned int) i, 0, nMelAbtIndex);
                }
#else
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorRevisionGrund2017, (unsigned int) i, 0, nMelAbtIndex);
#endif
            }
        }

        /* Modell 2021: Check Onko-Diagnose (HX05) */
        if (modelljahr < 2025) {
            lkf_plaus_ignoreMelChecks(pAufenthalt, pContext, i, modelljahr);
        }

        /* KJNP, Psych, Stroke-MEL erbracht, aber Abteilung nicht definiert -> Warning */
		if  (MELInIndexList (pContext, CONSTMEL_LIST1, melindex)
		   || (pContext->modelljahr >= 2010 && MELInIndexList (pContext, CONSTMEL_LIST3, melindex))
		   || (pContext->modelljahr >= 2013 && MELInIndexList (pContext, CONSTMEL_LIST4, melindex))) /* V17.0 */
		{
            
            if (!pAufenthalt->melabt_ok) {
                lkf_MELABTOK_Check(pAufenthalt);
            }
            melabt_ok = pAufenthalt->melabt_ok;

            
            if (modelljahr >= 2012 && lkf_SpezMelOhneGenehmigung (pAufenthalt, (unsigned int) i, &spezmelindex))
            {
                ; /* do nothing -> Block nach hinten geschoben */
            }
            else if ((IsConstMEL(pContext, CONSTMEL_AM030_7501, melindex) && !(melabt_ok & MELABTOK_AM030)) ||
                     (IsConstMEL(pContext, CONSTMEL_AM020_7506, melindex) && !(melabt_ok & MELABTOK_AM020)) ||
                     (IsConstMEL(pContext, CONSTMEL_AA040_7401, melindex) && !(melabt_ok & MELABTOK_AA040)) ||
                     (IsConstMEL(pContext, CONSTMEL_AM040_7316, melindex) && !(melabt_ok & MELABTOK_AM040)) ||
                     (IsConstMEL(pContext, CONSTMEL_AM050_7321, melindex) && !(melabt_ok & MELABTOK_AM050)) ||
                     ((IsConstMEL(pContext, CONSTMEL_LH020_1255, melindex) && !(melabt_ok & MELABTOK_LH020)) && modelljahr < 2012))
            {
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                
#ifdef SUPPORT_PRE2017
                if ((Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneSpez2016 : &LKFErrorMELohneSpez, (unsigned int) i, 0, nMelAbtIndex) & ERROR_ACCEPTED) && modelljahr >= 2010)
                {
                    if (IsConstMEL(pContext, CONSTMEL_LH020_1255, melindex))
                        pAufenthalt->acceptedMEL |= ACCEPTED_MEL_LH020;
                }
#else
                if ((Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneSpez2016, (unsigned int) i, 0, nMelAbtIndex) & ERROR_ACCEPTED))
                {
                    if (IsConstMEL(pContext, CONSTMEL_LH020_1255, melindex))
                        pAufenthalt->acceptedMEL |= ACCEPTED_MEL_LH020;
                }
#endif
            }
#ifdef SUPPORT_PRE2017
            else if ((modelljahr == 2010 || modelljahr == 2011) && (
                                                                                        (IsConstMEL(pContext, CONSTMEL_DB020, melindex) && !(melabt_ok & MELABTOK_DB020)) ||
                                                                                        (IsConstMEL(pContext, CONSTMEL_AJ140, melindex) && !(melabt_ok & MELABTOK_AJ140)) ||
                                                                                        (IsConstMEL(pContext, CONSTMEL_AK010, melindex) && !(melabt_ok & MELABTOK_AK010)) ||
                                                                                        (IsConstMEL(pContext, CONSTMEL_LH010, melindex) && !(melabt_ok & MELABTOK_LH010)) ||
                                                                                        (IsConstMEL(pContext, CONSTMEL_LH021, melindex) && !(melabt_ok & MELABTOK_LH021))
                                                                                        ))
            {
                if (Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneSpez, (unsigned int) i, 0, nMelAbtIndex) & ERROR_ACCEPTED)
                { /* akzeptierte MEL merken */
                    if (IsConstMEL(pContext, CONSTMEL_DB020, melindex))
                        pAufenthalt->acceptedMEL |= ACCEPTED_MEL_DB020;
                    else if (IsConstMEL(pContext, CONSTMEL_AJ140, melindex))
                        pAufenthalt->acceptedMEL |= ACCEPTED_MEL_AJ140;
                    else if (IsConstMEL(pContext, CONSTMEL_AK010, melindex))
                        pAufenthalt->acceptedMEL |= ACCEPTED_MEL_AK010;
                    else if (IsConstMEL(pContext, CONSTMEL_LH010, melindex))
                        pAufenthalt->acceptedMEL |= ACCEPTED_MEL_LH010;
                    else if (IsConstMEL(pContext, CONSTMEL_LH021, melindex))
                        pAufenthalt->acceptedMEL |= ACCEPTED_MEL_LH021;
                }
            }
            else if (modelljahr >= 2017 && IsConstMEL(pContext, CONSTMEL_AM130, melindex) && !(melabt_ok & MELABTOK_AM130))
            { /* V17.0 */
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneSpez2016 : &LKFErrorMELohneSpez, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (modelljahr >= 2013 && IsConstMEL(pContext, CONSTMEL_AM120, melindex) && !(melabt_ok & MELABTOK_AM120))
            { /* V17.0 */
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneSpez2016 : &LKFErrorMELohneSpez, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (modelljahr >= 2017 && IsConstMEL(pContext, CONSTMEL_AM110, melindex) && !(melabt_ok & MELABTOK_AM110))
            { /* V17.0 */
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneSpez2016 : &LKFErrorMELohneSpez, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (modelljahr >= 2010 && IsConstMEL(pContext, CONSTMEL_AM100, melindex) && !(melabt_ok & MELABTOK_AM100))
            {
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneSpez2016 : &LKFErrorMELohneSpez, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (modelljahr >= 2022 && IsConstMEL(pContext, CONSTMEL_AM140, melindex) && !(melabt_ok & MELABTOK_AM140))
            {
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneSpez2016 : &LKFErrorMELohneSpez, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (modelljahr >= 2022 && IsConstMEL(pContext, CONSTMEL_AM150, melindex) && !(melabt_ok & MELABTOK_AM150))
            {
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneSpez2016 : &LKFErrorMELohneSpez, (unsigned int) i, 0, nMelAbtIndex);
            }
#else
            else if (IsConstMEL(pContext, CONSTMEL_AM130, melindex) && !(melabt_ok & MELABTOK_AM130))
            { /* V17.0 */
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt,  &LKFErrorMELohneSpez2016, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (IsConstMEL(pContext, CONSTMEL_AM120, melindex) && !(melabt_ok & MELABTOK_AM120))
            { /* V17.0 */
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneSpez2016, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (IsConstMEL(pContext, CONSTMEL_AM110, melindex) && !(melabt_ok & MELABTOK_AM110))
            { /* V17.0 */
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneSpez2016, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (IsConstMEL(pContext, CONSTMEL_AM100, melindex) && !(melabt_ok & MELABTOK_AM100))
            {
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneSpez2016, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (modelljahr >= 2022 && IsConstMEL(pContext, CONSTMEL_AM140, melindex) && !(melabt_ok & MELABTOK_AM140))
            {
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneSpez2016, (unsigned int) i, 0, nMelAbtIndex);
            }
            else if (modelljahr >= 2022 && IsConstMEL(pContext, CONSTMEL_AM150, melindex) && !(melabt_ok & MELABTOK_AM150))
            {
                lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneSpez2016, (unsigned int) i, 0, nMelAbtIndex);
            }

#endif
        }
#ifdef SUPPORT_PRE2017
		if (modelljahr >= 2012 && lkf_SpezMelOhneGenehmigung (pAufenthalt, (unsigned int) i, &spezmelindex))
		{
            lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
			if (Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneSpez2016 : &LKFErrorMELohneSpez, (unsigned int) i, 0, nMelAbtIndex) & ERROR_ACCEPTED)
				pAufenthalt->acceptedMEL |= 1<<spezmelindex;
			else
				pMEL->nIgnoreMel = 1;
		}
#else
        if (lkf_SpezMelOhneGenehmigung (pAufenthalt, (unsigned int) i, &spezmelindex))
        {
            lkf_stat_register_case(pAufenthalt, "WX3Q", pAufenthalt->mel[i].MEL);
            if (Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneSpez2016, (unsigned int) i, 0, nMelAbtIndex) & ERROR_ACCEPTED)
                pAufenthalt->acceptedMEL |= 1<<spezmelindex;
            else
                pMEL->nIgnoreMel = 1;
        }
#endif
	}

	if (modelljahr >= 2010)
	{
		int bOk = 0;
		int bUnterbrechung = 0;
		unsigned int nAbtIndex;
		for (nAbtIndex = 0; !bOk && nAbtIndex < pAufenthalt->abt_anz && pAufenthalt->abt[nAbtIndex].lAbtDat && pAufenthalt->abt[nAbtIndex].lAbtDat <= lMelDat; nAbtIndex++) /* V14.1: < -> <= */
		{
			if ((nAbtIndex+1 == pAufenthalt->abt_anz && lMelDat <= (unsigned int) pAufenthalt->lEntDat) || (nAbtIndex+1 < pAufenthalt->abt_anz && lMelDat <= pAufenthalt->abt[nAbtIndex+1].lAbtDat))  /* V14.2: MEL am Entlassungstag beruecksichtigen V14.2 */
			{
				if (memcmp (pAufenthalt->abt[nAbtIndex].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
					bOk = 1;
				else
					bUnterbrechung = 1;
			}
		}

		if (bUnterbrechung && !bOk)
			Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorUnterbrechungMEL, (unsigned int) i, 0, nMelAbtIndex);

	}
    
    if (modelljahr >= 2022 && pAufenthalt->isAmb && pMelDef->cPhysAnw == 'N') {
        MEL_ARRAY_STRUC *pMelDef;
        unsigned int j;
        for (j = 0; j < pAufenthalt->mel_anz; j++) {
            if (i == j)
                continue;;
            pMelDef = FindMel(pContext, pAufenthalt->mel[j].MEL);
            if (pMelDef && pMelDef->cPhysAnw == 'J') {
                
                unsigned int abtstat;
                if (modelljahr >= 2023 && pAufenthalt->abt_anz > 1) {
                    unsigned int i;
                    abtstat = 0;
                    for (i = 0; i < pAufenthalt->abt_anz; i++) {
                        switch (pAufenthalt->abt[i].PHYS_ANW) {
                            case 'J':
                                abtstat |= 1;
                                break;
                            case 'N':
                                abtstat |= 2;
                                break;
                            default:
                                break;
                        }
                    }
                }
                else {
                    abtstat = 0;
                }
                
                if (abtstat < 3) {
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorKombPhysJN, (unsigned int) i, 0, nMelAbtIndex);
                }
                
                break;
            }
        }
    }
    
    if (modelljahr >= 2017) {
        
        if (!IsBlank(pMEL->MELZEIT, 4))
        { /* V21.0 */
            int lMelZeit;
            
            if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
                lMelZeit = (int) lkf_time2intStrict (pMEL->MELZEIT);
            }
            else {
                lMelZeit = (int) lkf_time2int (pMEL->MELZEIT);
            }
            
            if (!lMelZeit)
                Satzart_ReportMBDSError2(pAufenthalt, &LKFAmbErrorMELUhrzeitFalsch, (unsigned int) i, 0, (int) nMelAbtIndex);
        }
        if (IsBlank(pAufenthalt->mel[i].KALEIST, 6) || !memcmp (pAufenthalt->KANR, pMEL->KALEIST, 4)) {
            if (IsBlank(pAufenthalt->mel[i].FCLEIST, 8)) {
                if (pAufenthalt->pScoringContext->model2017errors) {
                    Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorMELFUCOfehlt, (unsigned int) i, 0, (int) nMelAbtIndex);
                }
            }
            else if (!FunkInArray(pAufenthalt->pScoringContext->pStamm2001, pMEL->FCLEIST)) {
                Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorMELFUCOfalsch, (unsigned int) i, 0, (int) nMelAbtIndex);
            }
            else if (modelljahr >= 2019 && !(pContext->flags & LKFCONTEXT_NICHTFONDSKA))
            { /* V2019.1 */
                // LF: FUCO im Kostenplan enthalten "Funktionscode der med. Leistung nicht im Kostenstellenplan enthalten"

                if (lkf_has_k01 (pContext, pMEL->FCLEIST) == 0) {
                    char curYear[6];
                    sprintf (curYear, "%04d", pContext->cmb_jahr); /* V2019.2 */
                    if (pMEL->meldat_nr == 0 || !memcmp(curYear, pMEL->MELDAT, 4)) {
                        if (modelljahr >= 2020) {
                            Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorFCLeistKostPlan2020, (unsigned int) i, 0, (int) nMelAbtIndex);
                        }
                        else {
                            Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorFCLeistKostPlan, (unsigned int) i, 0, (int) nMelAbtIndex);
                        }
                    }
                }
                
                if (!(pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE)) { /* V2020.0 */
                    /*
                    if (LKF_IS_TRACE_DETAIL(pAufenthalt->pScoringContext->nTraceAufenthalt))
                    {
                        char sTraceLine[1024];
                        sprintf (sTraceLine, "MEL %s: FCLEIST=%8.8s, Amb=%d, BettFC=%s", pMelDef->MEL, pMEL->FCLEIST, pAufenthalt->isAmb, pMelDef->cBettFC ? "JA": "NEIN");
                        TRACE_DETAIL(pAufenthalt, 0, sTraceLine);
                    }
                    */
                    if (!lkf_IsNBettHK(pContext, pMEL->FCLEIST) && (pAufenthalt->isAmb || !pMelDef->cBettFC))
                    {
                        char curYear[6];
                        if (pContext->cmb_jahr)
                            sprintf (curYear, "%04d", pContext->cmb_jahr); /* V2019.2 */
                        else
                            sprintf (curYear, "%04d", pContext->modelljahr); /* V2022.1 */
                        if (pMEL->meldat_nr == 0 || !memcmp(curYear, pMEL->MELDAT, 4)) {
                            Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorMELBettHKUnplaus, (unsigned int) i, 0, (int) nMelAbtIndex);
                        }
                        else if (LKF_IS_TRACE_DETAIL(pAufenthalt->pScoringContext->nTraceAufenthalt))
                        {
                            char sTraceLine[1024];
                            sprintf (sTraceLine, "MEL %s: kein WX51, weil Leistungsdatum nicht im Abrechnungsjahr", pMelDef->MEL);
                            TRACE_DETAIL(pAufenthalt, 0, sTraceLine);
                        }
                    }
                }
            }
        }
        else if (!KAInArray(pContext->pStamm2001, pMEL->KALEIST)) {
            Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorMELKANRfalsch, (unsigned int) i, 0, (int) nMelAbtIndex);
        }
        else if (modelljahr >= 2019 && !IsBlank(pAufenthalt->mel[i].FCLEIST, 8))
        {   /* V2019.1: check of FCLEIST leer? */
            Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorKALeistFCLeist, (unsigned int) i, 0, (int) nMelAbtIndex);
        }
    }
    
    if (!(pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE)) {
        if (modelljahr >= 2019 && pAufenthalt->isAmb && !memcmp (pMEL->MEL,"ZZ710",5)) {
            if (modelljahr >= 2020) {
                static const char *zz710_abtPrefix[] = {"160750", "161150", "162250", "163050", "163150", "163350", "165150", "166250", "166450", "169046", "169146"};
                
                if (!bsearch (pMEL->FCLEIST, zz710_abtPrefix, sizeof(zz710_abtPrefix)/sizeof(const char *), sizeof(const char *), search_funk6)) {
                    Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorFucoLeist, i, 0, (int) nMelAbtIndex);
                }
            }
            else {
                static const char *zz710_abtPrefix[] = {"160750", "161150", "162250", "163050", "163150", "163350", "165150", "166250", "166450", "169044", "169045", "169046", "169144","169145", "169146"};
                
                if (!bsearch (pMEL->FCLEIST, zz710_abtPrefix, sizeof(zz710_abtPrefix)/sizeof(const char *), sizeof(const char *), search_funk6)) {
                    Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorFucoLeist, i, 0, (int) nMelAbtIndex);
                }
            }
        }
    }
    
    if (!(pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE)) {
        if (modelljahr >= 2022 && !memcmp (pMEL->MEL,"AN01",4) && IsEmpty(pMEL->KALEIST, 4)) {
            if (pMEL->MEL[4] == '0') {
                static const char *an010_abtPrefix[] = {"0980", "1180", "1280", "4280", "5180", "6380", "9180"};
                if (pMEL->FCLEIST[0] != '1' || !bsearch (pMEL->FCLEIST + 2, an010_abtPrefix, sizeof(an010_abtPrefix)/sizeof(const char *), sizeof(const char *), search_funk36)) {
                    Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorFucoLeist, i, 0, (int) nMelAbtIndex);
                }
            }
            else if (pMEL->MEL[4] == '1') {
                static const char *an011_abtPrefix[] = {"5180", "6380", "9180"};
                if (pMEL->FCLEIST[0] != '1' || !bsearch (pMEL->FCLEIST + 2, an011_abtPrefix, sizeof(an011_abtPrefix)/sizeof(const char *), sizeof(const char *), search_funk36)) {
                    Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorFucoLeist, i, 0, (int) nMelAbtIndex);
                }
            }
        }
    }
    
    if (pMelDef->pCustomCheck) {
        
        const LKF_MEL_CUSTOM_CHECK *pCustomCheck = pMelDef->pCustomCheck;
        
        while (pCustomCheck) {
            if (pCustomCheck->checkFunction(pAufenthalt, i, nMelAbtIndex)) {
                Satzart_ReportMBDSError2(pAufenthalt, pCustomCheck->pError, i, 0, (int) nMelAbtIndex);
                pCustomCheck = pCustomCheck->nextTrue;
            }
            else {
                pCustomCheck = pCustomCheck->nextFalse;
            }
        }
    }
}

static void MEL_MEL_SetPool (LKF_AUFENTHALT *pAufenthalt, unsigned int nErrorRet, unsigned int i, unsigned int j, int nStatisch, const LKF_SATZART_ERRORDEF *pErrorDef)
{ /* definiert den MEL-MEL-Pool, in dem sich diese MEL befindet */
    unsigned int melPool;
    char errorCode[6];

	if (IS_ERROR_ACCEPTED (nErrorRet))
		return;
    if (!pAufenthalt->pMelMel) {
		pAufenthalt->pMelMel = (unsigned char *) LKF_CALLOC (pAufenthalt->pScoringContext, "MEL_MEL_SetPool", pAufenthalt->mel_anz * pAufenthalt->mel_anz, sizeof (unsigned char));
        if (!pAufenthalt->pMelMel) return;
        pAufenthalt->pMelMelInfo = (MELMEL_ERRORCODE *) LKF_CALLOC (pAufenthalt->pScoringContext, "MEL_MEL_SetPool.info", pAufenthalt->mel_anz + 1, sizeof(MELMEL_ERRORCODE));
        if (!pAufenthalt->pMelMelInfo) {
            LKF_FREE(pAufenthalt->pScoringContext, "MEL_MEL_SetPool", pAufenthalt->pMelMel);
            pAufenthalt->pMelMel = 0;
            return;
        }
    }
    
    if (!pAufenthalt->mel[i].nMelMelIndex)
	{	
		if (pAufenthalt->mel[j].nMelMelIndex)
		{
            melPool = pAufenthalt->mel[j].nMelMelIndex;
            pAufenthalt->mel[i].nMelMelIndex = melPool;
		}
		else
		{
            melPool = ++(pAufenthalt->nMelMelCount);
			pAufenthalt->mel[i].nMelMelIndex = melPool;
            pAufenthalt->mel[j].nMelMelIndex = melPool;
		}
	}
	else
	{
        if (!pAufenthalt->mel[j].nMelMelIndex) {
            melPool = pAufenthalt->mel[i].nMelMelIndex;
            pAufenthalt->mel[j].nMelMelIndex = melPool;
        }

		else if (pAufenthalt->mel[i].nMelMelIndex != pAufenthalt->mel[j].nMelMelIndex)
		{
			unsigned int k;
			unsigned int nOldPool;
			nOldPool = pAufenthalt->mel[j].nMelMelIndex;
            melPool = pAufenthalt->mel[i].nMelMelIndex;
			for (k = 0; k < pAufenthalt->mel_anz; k++)
			{
				if (pAufenthalt->mel[k].nMelMelIndex == nOldPool)
					pAufenthalt->mel[k].nMelMelIndex = melPool;
			}
		}
        else {
            melPool = pAufenthalt->mel[j].nMelMelIndex;
        }
	}

	
	pAufenthalt->mel[i].nMelMelNotAccepted = 1;
	pAufenthalt->mel[j].nMelMelNotAccepted = 1;
    
    if (pErrorDef) {
        lkf_getErrorIdent (pAufenthalt->pScoringContext, pErrorDef, 5, errorCode);
        if (pAufenthalt->pMelMelInfo[melPool][0] != 'H' || *errorCode != 'W') {
            strcpy (pAufenthalt->pMelMelInfo[melPool], errorCode);
        }
    }
    
	if (i == j)
		pAufenthalt->pMelMel[AUFENTHALT_MELMELINDEX (pAufenthalt,i,i)] = MELMELGROUP_DYN;
	else if (nStatisch)
	{
		pAufenthalt->pMelMel[AUFENTHALT_MELMELINDEX (pAufenthalt,i,j)] = MELMELGROUP_LOSE;
		pAufenthalt->pMelMel[AUFENTHALT_MELMELINDEX (pAufenthalt,j,i)] = MELMELGROUP_WIN;

        
        if (pAufenthalt->pMelMelInfo[melPool]) {
            strcpy (pAufenthalt->mel[i].melmelInfo, pAufenthalt->pMelMelInfo[melPool]);
        }
        
	}
	else
	{
		pAufenthalt->pMelMel[AUFENTHALT_MELMELINDEX (pAufenthalt,i,j)] = MELMELGROUP_DYN;
		pAufenthalt->pMelMel[AUFENTHALT_MELMELINDEX (pAufenthalt,j,i)] = MELMELGROUP_DYN;
	}
}

static int MEL_MEL_IgnoreHX01 (LKF_AUFENTHALT *pAufenthalt, unsigned int i)
{
    if (SAFEIS2017ORLATER(pAufenthalt)) {
        
        if (pAufenthalt->psych_flag) {
            return 1;
        }

        if (!pAufenthalt->isAmb && pAufenthalt->mel[i].nMelIndex >= 0) {
            MEL_ARRAY_STRUC *pS = GetMELArrayFromIndex((const LKF_CONTEXT *) pAufenthalt->pScoringContext, pAufenthalt->mel[i].nMelIndex);
            if (pS && IsBlank (pS->sGruppe, 8))
                return 1;
        }
    }
    return 0;
}

static int wx4kl_meldat (int meldat1, int meldat2, int modelljahr) {
    /* V2021.0 */
    
    int diff = meldat1 - meldat2;
    
    if (meldat1 == meldat2) return 1;
    if (modelljahr >= 2021) {
        return diff < 2 && diff > -2 ? 1 : 0;
    }
    return diff == 0;
}

static void MEL_MEL_Check (LKF_AUFENTHALT *pAufenthalt, unsigned int i)
{ /* Erweiterung auf Unterscheidung zwischen gaenzlich verbotenen Kombinationen und
           am nur selben Tag verbotenen Leistungen */
	unsigned int j;
	int melanz;
	int meldat;
	int sameday_warning;
	char sMelMelString[12];
	MEL_MEL_STRING *pMelMel;
    LKF_AUFENTHALT_MEL *pMEL, *pOtherMEL;

	int nErrorRet;
	int nStatisch;

	int nModellJahr;
    char cSeite;

    LKF_CONTEXT *pContext = pAufenthalt->pScoringContext;
	STAMM2001 *pStamm = pContext->pStamm2001;
	nModellJahr = pContext->modelljahr;
	
	sameday_warning = 0;
	
    pMEL = pAufenthalt->mel + i;
    
    melanz = (int) pMEL->nTagMelAnz;
    if (melanz == 0 || pMEL->nMelIndex < 0)
        return;
	

    if (pMEL->ambFixPunkte > 0) { /* V2025.2 */
        return;
    }


    if (melanz > 1)
	{
        pMelMel = GetMEL_MEL2009 (pStamm, pMEL->MEL, pMEL->MEL);
        if (pMelMel && ((*pMelMel)[10] == 'T' || nModellJahr >= 2016))
        {
            const LKF_SATZART_ERRORDEF *pErrorDef = 0;
            nStatisch = (*pMelMel)[12] != 'D';
            sprintf (sMelMelString, "%5.5s%5.5s", pMEL->MEL, pMEL->MEL);
            if ((*pMelMel)[11] == 'H')
            {
                if (!MEL_MEL_IgnoreHX01(pAufenthalt, i)) {
                    pErrorDef = &LKFHinweisMELMEL;
                    nErrorRet = Satzart_ReportMBDSErrorMEL (pAufenthalt, pErrorDef, (unsigned int) i, sMelMelString, -1, LKF_MBDSERRORMELCOMPARE_STANDARD, i);
                }
                else
                    nErrorRet = 0;
            }
            else if ((*pMelMel)[10] != 'T') {
                pErrorDef = &LKFErrorMELAufenthalt;

                nErrorRet = Satzart_ReportMBDSErrorMEL(pAufenthalt, pErrorDef, (unsigned int) i, sMelMelString, -1, LKF_MBDSERRORMELCOMPARE_STANDARD, i);
            }
            else {
                pErrorDef = &LKFErrorMELTag2009;
                nErrorRet = Satzart_ReportMBDSErrorMEL (pAufenthalt, pErrorDef, (unsigned int) i, sMelMelString, -1, LKF_MBDSERRORMELCOMPARE_STANDARD, i);
            }
            MEL_MEL_SetPool (pAufenthalt, (unsigned int) nErrorRet, i, i, nStatisch, pErrorDef);
        }
	}

    cSeite = pMEL->cSeite; /* V17.0 */
    
    for (j = 0; j < pAufenthalt->mel_anz; j++) {
        
        pOtherMEL = pAufenthalt->mel + j;
        if (pOtherMEL->nTagMelAnz == 0 || pOtherMEL->nMelIndex < 0)
            continue;
        
        if (cSeite && pOtherMEL->cSeite && cSeite != pOtherMEL->cSeite)
            continue; /* V17.0 */
        
        if (nModellJahr >= LKF_DATETIME_STRICT_MODEL) {
            meldat = (int) lkf_dat2intStrict (pMEL->MELDAT);
        }
        else {
            meldat = (int) lkf_dat2int (pMEL->MELDAT);
        }
        
        if (i != j) {
    
            if (nModellJahr >= 2016 && i > j && pMEL->nMelIndex == pOtherMEL->nMelIndex) {
                continue;
            }
    
            pMelMel = GetMEL_MEL2009 (pStamm, pMEL->MEL, pOtherMEL->MEL);
            if (pMelMel) {
                const LKF_SATZART_ERRORDEF *pErrorDef = 0;
                nStatisch = (*pMelMel)[12] != 'D';
                if ((*pMelMel)[10] == 'T') {
                    if ((meldat != 0 || ((pAufenthalt->pScoringContext->flags& LKFCONTEXT_ALLOWQUICKSCORE))) && pOtherMEL->meldat_nr == meldat) {
                        if (!sameday_warning)
                        {
                            sprintf (sMelMelString, "%5.5s%5.5s", pMEL->MEL, pOtherMEL->MEL);
                            if ((*pMelMel)[11] == 'H')
                            {
                                if (!MEL_MEL_IgnoreHX01(pAufenthalt, i) && !MEL_MEL_IgnoreHX01(pAufenthalt, j)) {
                                    pErrorDef = &LKFHinweisMELMEL;
                                    nErrorRet = Satzart_ReportMBDSErrorMEL (pAufenthalt, pErrorDef, (unsigned int) i, sMelMelString, -1, LKF_MBDSERRORMELCOMPARE_STANDARD, j);
 
                                }
                                else
                                    nErrorRet = 0;
                            }
                            else {
                                pErrorDef = &LKFErrorMELTag2009;
                                nErrorRet = Satzart_ReportMBDSErrorMEL (pAufenthalt, pErrorDef, (unsigned int) i, sMelMelString, -1, LKF_MBDSERRORMELCOMPARE_STANDARD, j);
                            }
                            MEL_MEL_SetPool (pAufenthalt, (unsigned int) nErrorRet, i, j, nStatisch, pErrorDef);
                        }
                    }
                }
                else {
                    sprintf (sMelMelString, "%5.5s%5.5s", pMEL->MEL, pOtherMEL->MEL);
                    nErrorRet = Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorMELAufenthalt, (unsigned int) i, sMelMelString, -1, LKF_MBDSERRORMELCOMPARE_STANDARD, j);
                    if (!IS_ERROR_ACCEPTED (nErrorRet) || nModellJahr < 2016)
                    { /* V20.2 */
                        MEL_MEL_SetPool (pAufenthalt, (unsigned int) nErrorRet, i, j, nStatisch, &LKFErrorMELAufenthalt);
                        if (pAufenthalt->pScoringContext->modelljahr < 2016)
                            return;
                    }
                }
            }
            /* CHECK-BP: letzte Bedingung weg ab 2023? -> KlŠrung BP */
            else if (j > (unsigned int) i && nModellJahr >= 2012 && meldat && wx4kl_meldat(pAufenthalt->mel[j].meldat_nr, meldat, nModellJahr)
                     && !memcmp (pMEL->MEL, "XC", 2) && !memcmp (pOtherMEL->MEL, "XC", 2)
                     && (nModellJahr >= 2024 || memcmp (pMEL->MEL, pOtherMEL->MEL, 5)))
            {
                const LKF_SATZART_ERRORDEF *pErrorDef;
                sprintf (sMelMelString, "%5.5s%5.5s", pMEL->MEL, pOtherMEL->MEL);
                                
                pErrorDef = nModellJahr >= 2021 ? &LKFWarningChemoTag2021 : &LKFWarningChemoTag;
                nErrorRet = Satzart_ReportMBDSErrorMEL (pAufenthalt, pErrorDef, (unsigned int) i, sMelMelString, -1, LKF_MBDSERRORMELCOMPARE_STANDARD, j);

                MEL_MEL_SetPool (pAufenthalt, (unsigned int) nErrorRet, i, j, 0, pErrorDef);
            }
            else if (j > (unsigned int) i && nModellJahr >= 2020
                     && !memcmp (pMEL->MEL, "XB", 2) && !memcmp (pOtherMEL->MEL, "XC", 2))
            { /* V2020.0 */
                sprintf (sMelMelString, "%5.5s%5.5s", pMEL->MEL, pOtherMEL->MEL);
                nErrorRet = Satzart_ReportMBDSErrorMEL (pAufenthalt, &LKFErrorChemoKomb, (unsigned int) i, sMelMelString, -1, LKF_MBDSERRORMELCOMPARE_STANDARD, j);
                MEL_MEL_SetPool (pAufenthalt, (unsigned int) nErrorRet, i, j, 0, &LKFErrorChemoKomb);
            }
        }
    }
}

/* function Util_Abteilung ****************************************************
**     Modifiziert die Abteilungszaehler aufgrund der Daten des Patienten     **
******************************************************************************/

static int Util_Abteilung (LKF_CONTEXT *pContext, LKF_AUFENTHALT *pAufenthalt)
{
	STAT_KA *pKA;
	unsigned int i;
	int minimum, maximum, cur, cmp;

	if (pAufenthalt->kanr == -1) return -1;

	pKA = pContext->ka + pAufenthalt->kanr;

	for (i = 0; i < pAufenthalt->abt_anz; i++) {
		if (!IsEmpty (pAufenthalt->abt[i].ABTFC, 8)) {
	
			/* Finde Position fuer die Abteilung im Array (binary search) */
			minimum = 0;
			maximum = (int) pKA->abt_gesamt;
			cur = 0;
			cmp = 1;

			while (cmp && maximum > minimum) {
				cur = (minimum + maximum) >> 1;
				cmp = memcmp (pKA->abt[cur].abt_fc, pAufenthalt->abt[i].ABTFC, 8);
				if (cmp > 0) maximum = cur;
				else if (cmp < 0) {
					if (minimum + 1 == maximum) cur = minimum = maximum;
					else minimum = cur;
				}
			}

			if (!pKA->abt_gesamt) cmp = 1; 
			else if (cmp && i < pKA->abt_gesamt) cmp = memcmp (pKA->abt[cur].abt_fc, pAufenthalt->abt[i].ABTFC, 8);
			

			/* Wenn notwendig, neue Abteilung einfuegen */
			if (cmp) {

				/* Abteilungs-Array vergroessern */
				if (pKA->abt_alloc == pKA->abt_gesamt) {
				
					pKA->abt_alloc += LKF_CONTEXT_EXTEND_ABT;

					if (pKA->abt_gesamt) pKA->abt = (STAT_ABTEILUNG *) LKF_REALLOC (pContext, "Util_Abteilung", pKA->abt, sizeof (STAT_ABTEILUNG) * pKA->abt_alloc);
					else pKA->abt = pKA->abt = (STAT_ABTEILUNG *) LKF_MALLOC (pContext, "Util_Abteilung", sizeof (STAT_ABTEILUNG) * pKA->abt_alloc);
                    
                    if (!pKA->abt) {
                        pKA->abt_alloc = pKA->abt_gesamt = 0;
                        return LKF_OUTOFMEMORY_ERROR;
                    }
				}

				if ((unsigned int) cur < pKA->abt_gesamt) memmove (pKA->abt + cur + 1, pKA->abt + cur, 
															  sizeof (STAT_ABTEILUNG) * (pKA->abt_gesamt - (unsigned int) cur));

				
				memcpy (pKA->abt[cur].abt_fc, pAufenthalt->abt[i].ABTFC, 8);
				pKA->abt[cur].abt_bd = 0;
				pKA->abt[cur].abt_patanz = 0;
				pKA->abt[cur].abt_error = 0;
				++pKA->abt_gesamt;
			}

			if (pAufenthalt->ENTART != 'V')
			{
				/* Abteilungsdaten uebertragen */
				if (pAufenthalt->FLAG < '4' || !pAufenthalt->plaus_err) {
					pKA->abt[cur].abt_patanz++;
					pKA->abt[cur].abt_bd += Util_Diff_Tage (pAufenthalt, (short) i);
				}
				else pKA->abt[cur].abt_error++;
			}
		}
	}
    return 0;
}

int lkf_stamm_check_consistency (LKF_CONTEXT *pContext)
{ /* \xc3\x9c""berpruefung, ob die Aufruf-Flags mit den vorhandenen Stammdaten zusammenpassen
        1. ab Modell 2007 m\xc3\xbc""ssen f\xc3\xbc""r Fonds-H\xc3\xa4""user die NeoP\xc3\xa4""d-Stammdaten vorhanden sein
		2. wenn das NP-Flag explizit eingeschaltet ist, m\xc3\xbc""ssen die NeoP\xc3\xa4""d-Stammdaten vorhanden sein
		3. wenn das OSG-Flag explizit eingeschaltet ist, m\xc3\xbc""ssen die OSG-Stammdaten vorhanden sein
	*/

	if (!pContext->pStamm2001)
	{
		strcpy (pContext->errortext, "Stammdaten nicht korrekt, Abarbeitung ist nicht moeglich");
		return -21;
	}

	if (pContext->pStamm2001->nNPDisabled)
	{
		if (!(pContext->flags & LKFCONTEXT_NICHTFONDSKA))
		{
			strcpy (pContext->errortext, "Abarbeitung f\xc3\xbc""r Fonds-Haeuser nicht moeglich, da keine Neo/Paed-Stammdaten vorhanden sind.");
			return -22;
		}

		if (pContext->flags & LKFCONTEXT_NPPLAUS)
		{
			strcpy (pContext->errortext, "Abarbeitung mit gesetztem NeoPaed-Flag nicht moeglich, da keine Neo/Paed-Stammdaten vorhanden sind.");
			return -23;
		}
	}

	if (pContext->pStamm2001->nOSGDisabled)
	{
		if ((pContext->flags & LKFCONTEXT_OSG) || (pContext->flags & LKFCONTEXT_OSG_WARN))
		{
			strcpy (pContext->errortext, "Abarbeitung mit gesetztem OSG-Flag nicht moeglich, da keine OSG-Stammdaten vorhanden sind.");
			return -24;
		}
	}
    
    if ((pContext->flags & LKFCONTEXT_NUR_MBDS) && !(pContext->flags & LKFCONTEXT_OSG) && !(pContext->flags & LKFCONTEXT_OSG_WARN)) { /* V21.1 - Standortinfo ein bei NUR_MBDS, wenn OSG/OSG_WARN */
        pContext->standortInfo = 0;
    }
	return 0;
}

const char *lkf_plaus_get_error_valuefield_description (const LKF_CONTEXT *pContext, const LKF_SATZART_ERRORDEF *pErrorDef)
{ /* V20.1 */

    if (pErrorDef->nFacility == LKF_FAC_INTSCOR && pContext->modelljahr >= 2017)
        return "ABT:DATUM"; /* V21.2 */
    if (!pErrorDef->nAddInfo || pErrorDef->nAddInfo == LKF_MBDSERROR_NOINFO_M04) {
		if (pErrorDef->nFacility != LKF_FAC_MBDS) return "";
		if (pErrorDef == &LKFWarningDiagDiag || pErrorDef == &LKFWarningDiagDiag2020)
			return "DIAG/DIAG";
		else if (pErrorDef == &LKFWarningChemoTag2021 || pErrorDef == &LKFWarningChemoTag || pErrorDef == &LKFErrorMELAufenthalt || pErrorDef == &LKFErrorMELTag2009 || pErrorDef == &LKFHinweisMELMEL || pErrorDef == &LKFErrorChemoKomb)
			return "MEL/MEL";
		return "";
	}
    
    return lkf_getErrorMBDSFieldId (pContext, pErrorDef->nAddInfo);
}



static int lkf_context_plaus_internal (LKF_CONTEXT *pContext, unsigned int anzahl, int initka)
{
	LKF_AUFENTHALT *pAufenthalt;
	unsigned int i, j;
	int ret;

	ret = lkf_stamm_check_consistency (pContext);
	if (ret) return ret;

	if (anzahl == 0) pContext->plaus_work_count = 0;

	if (!pContext->plaus_work_count && initka) {
		
        /* V22.1 */
        if (!pContext->pCheckContext) {
            pContext->pCheckContext = lkf_get_contextcheckcontext (pContext);
        }
        if (!pContext->pCheckContext->pKKContext) {
            pContext->pCheckContext->pKKContext = lkf_alloc_kk_context (pContext);
        }
        
		lkf_NPPlaus_Init (pContext);

		for (i = 0; i < pContext->ka_gesamt; i++) {
			pContext->ka[i].error_anz = 0;
			pContext->ka[i].warning_anz = 0;
			pContext->ka[i].akwarn_anz = 0;
			pContext->ka[i].akerr_anz = 0;
			pContext->ka[i].akinfo_anz = 0;
			pContext->ka[i].info_anz = 0;
			pContext->ka[i].melde_count = 0;

			for (j = 0; j < pContext->ka[i].error_code_max - pContext->ka[i].error_code_min + 1; j++)
				pContext->ka[i].error_counts[j] = 0;

			for (j = 0; j < pContext->ka[i].warning_code_max - pContext->ka[i].warning_code_min + 1; j++)
				pContext->ka[i].warning_counts[j] = 0;

			if (pContext->ka[i].abt) LKF_FREE (pContext, "lkf_context_plaus_internal", pContext->ka[i].abt);
			pContext->ka[i].abt = 0;
			pContext->ka[i].abt_alloc = 0;
			pContext->ka[i].abt_gesamt = 0;
		}
		lkf_context_sort_private_stamm (pContext);
	}

	for (i = 0; (!anzahl || i < anzahl) && pContext->plaus_work_count < pContext->patient_anz; i++) {

		pAufenthalt = pContext->ppAufenthalt[pContext->plaus_work_count];
        pAufenthalt->indexInContext = pContext->plaus_work_count;
		++pContext->plaus_work_count;

		if (!(pAufenthalt->mark & 1)) continue;

        ret = lkf_plaus (pContext, pAufenthalt);
        if (ret == LKF_OUTOFMEMORY_ERROR) return ret;
		
		++pContext->plaus_count;

		lkf_add_ka_stats (pContext, pAufenthalt, 2);

	
	}

	if (pContext->plaus_work_count >= pContext->patient_anz) lkf_NPPlaus_End (pContext);

	return (int) i;
}

_SCORING_EXPORT int lkf_context_plaus_package (LKF_CONTEXT *pContext, int first)
{
    return lkf_context_plaus_internal(pContext, 0, first);
}

_SCORING_EXPORT int lkf_context_plaus (LKF_CONTEXT *pContext, unsigned int anzahl)
{
    return lkf_context_plaus_internal(pContext, anzahl, 1);
}

/* procedure lkf_plaus ******************************************************
**    F\xc3\xbc""hrt die Plausibilit\xc3\xa4""ts-\xc3\x9c""berpr\xc3\xbc""fungen durch.                        **
**    Mitzugeben ist der LKF_CONTEXT mit den Einstellungen und den     **
**    Error-Z\xc3\xa4""hlern sowie der Patient, der berechnet werden soll.          **
**    Ist pAufenthalt NULL, werden alle Patienten aus dem Scoring-Context     **
**    berechnet.                                                           **
****************************************************************************/

_SCORING_EXPORT int lkf_plaus (LKF_CONTEXT *pContext, LKF_AUFENTHALT *pAufenthalt)
{
	int ret;
	/* Berechne alle Patienten aus dem Scoring-Context, wenn pAufenthalt = NULL */
	if (!pAufenthalt) {
		pContext->plaus_work_count = 0;
		pContext->plaus_count = 0;
		lkf_context_plaus (pContext, 0);
		return 0;
	}

	ret = lkf_stamm_check_consistency (pContext);
	if (ret) return ret;

	return lkf_plaus_compute (pContext, pAufenthalt);
}

static int IsPflegeKA (const LKF_CONTEXT *pContext, const char *ka) 
{
	return (ka && KAInArray2 (pContext->pStamm2001, ka, 4));
}

static void DiagDiag_Check (LKF_AUFENTHALT *pAufenthalt) 
{ /* V18.0 */
    unsigned int i, j, diaganz;
	const char *diag, *otherDiag;
	const DIAG_DIAG_STRING *pDiagString;
    const LKF_CONTEXT *pContext;
    
    pContext = pAufenthalt->pScoringContext;
    diaganz = pAufenthalt->diag_anz;

	for (i = 0; i < diaganz; i++)
	{
        diag = pAufenthalt->diag[i].DIAG;

        if (!has_diagdiag(pContext, diag)) continue;
        
		for (j = 0; j < diaganz; j++)
		{
			if (i == j) continue;
            otherDiag = pAufenthalt->diag[j].DIAG;

			pDiagString = diag_diag_find (pAufenthalt->pScoringContext, diag, otherDiag);
			if (pDiagString) 
			{
				char buf[14];
                if (pContext->modelljahr >= 2018)
                { /* V22.2 */
                    sprintf (buf, "%-6.6s%-6.6s", diag, otherDiag);
                }
                else {
                    sprintf (buf, "%-5.5s%-5.5s", diag, otherDiag);
                }
                if (pContext->modelljahr >= 2020) {
                    Satzart_ReportMBDSErrorDoubleIndex (pAufenthalt, &LKFWarningDiagDiag2020, j, buf, 0, i);
                }
                else {
                    Satzart_ReportMBDSError2 (pAufenthalt, &LKFWarningDiagDiag, 0, buf, 0);
                }
			}
		}
	}
}

static int hasMEL (LKF_AUFENTHALT *pAufenthalt, const char *mel)
{
	unsigned int i;
	for (i = 0; i < pAufenthalt->mel_anz; i++) 
	{
		if (!memcmp (mel, pAufenthalt->mel[i].MEL, 5)) return 1;
	}
	return 0;
}

static void DiagMel_Check (LKF_AUFENTHALT *pAufenthalt)
{ /* V18.0 */
	unsigned int i;
	const char *diag;
	const DIAG_MEL_STRING *cur;
	const LKF_CONTEXT *pContext;
    unsigned int diag_anz; /* V22.1 */

	pContext = pAufenthalt->pScoringContext;

    diag_anz = pAufenthalt->diag_anz;
    
	for (i = 0; i < diag_anz; i++) /* V18.1 */
	{
        diag = pAufenthalt->diag[i].DIAG;
		cur = diag_mel_find (pContext, diag);

		if (cur) 
		{
			int found = 0;
			do 
			{
				if (hasMEL (pAufenthalt, ((const char*)cur) + 6))
				{
					found = 1;
					break;
				}
			} while ((cur = diag_mel_next (pContext, cur)));
			if (!found)
				Satzart_ReportMBDSError  (pAufenthalt, &LKFWarningDiagMel, i);
		}
	}
}

static int ENTARTV_Check (LKF_AUFENTHALT *pAufenthalt) {
    if (pAufenthalt->mel_anz > 0) {
        Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorUeberliegerDaten, 0, "X04", -1);
        return 1;
    }
    if (pAufenthalt->diag_anz > 0) {
        Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorUeberliegerDaten, 0, "X03", -1);
        return 1;
    }
    if (pAufenthalt->abt_anz > 0) {
        unsigned int i = 0;
        char thisYearBuf[12];
        sprintf (thisYearBuf, "%4d", pAufenthalt->pScoringContext->cmb_jahr);
        for (i = 0; i < pAufenthalt->abt_anz; i++) {
            if (memcmp(pAufenthalt->abt[i].ABTDAT, thisYearBuf, 4) > 0) {
                sprintf(thisYearBuf, "X02-%3.3s", pAufenthalt->abt[i].ABTPOS);
                Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorUeberliegerDaten, 0, thisYearBuf, -1);
                return 1;
            }
        }
    }
    if (pAufenthalt->akerr_count > 0 || pAufenthalt->akwarn_count > 0) {
        Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorUeberliegerDaten, 0, "X06", -1);
        return 1;
    }
    if (pAufenthalt->kommentar != 0) {
        Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorUeberliegerDaten, 0, "X07", -1);
        return 1;
    }
    if (pAufenthalt->pIntensiv != 0) {
        Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorUeberliegerDaten, 0, "INTENSIV", -1);
        return 1;
    }
    return 0;
}

static void lkf_plaus_removeErrorsFromContext (LKF_CONTEXT *pContext, LKF_AUFENTHALT *pAufenthalt) {
    
    if (pAufenthalt->nSatzartFirstError >= 0) {
        
        int errorIndex = pAufenthalt->nSatzartFirstError;
        
        while (errorIndex >= 0) {
            LKF_SATZART_ERROR *pError = pContext->pSatzartErrors->pErrors + errorIndex;
            errorIndex = pError->nAufNextErrorIndex;
            pError->mainErrorIndex = -99;
            pError->nAufNextErrorIndex = -1;
        }
        
        pAufenthalt->nSatzartFirstError = -1;
        pAufenthalt->nSatzartNextError = -1;
    }
    
    
}

int lkf_plaus_compute (LKF_CONTEXT *pContext, LKF_AUFENTHALT *pAufenthalt)
{
    int *tmp_melanz;
    int melanz;
    
    unsigned int i,j;
    int diag_ambulant;
    
    unsigned int nIntSeverity;
    
    unsigned int nRemobTage = 0;
    
    int quickscore_enabled;
    char kost_lkf_check[10];
    
    char sTraceLine[1024];
    
    char sSearchString[20];
    const SPEZ_LIST_STRING *pSpez;
    
    int nFirst = -1;
    
    int new_abtmel_errors; /* V20.1 */
    unsigned int lMelDat; /* V20.1 */
    
    int diag_options = 0; /* V2019.0 */
    int modelljahr = pContext->modelljahr;
    int hdiag_index = 0;
    pAufenthalt->nStatus = 1;
    pAufenthalt->melabt_ok = 0;
    new_abtmel_errors = modelljahr >= 2016;
    
    if (pContext->pTraceSettings && pContext->pTraceSettings->nMBDSSeverity)
    {
        if (pContext->pTraceSettings->sPATID[0])
        {
            unsigned int nPatIdLen = (unsigned int) strlen (pContext->pTraceSettings->sPATID);
            
            if (pContext->isBM) {
                if (!memcmp (pContext->pTraceSettings->sPATID, pAufenthalt->UCASE_PATID, nPatIdLen))
                    pContext->nTraceAufenthalt = pContext->pTraceSettings->nMBDSSeverity;
            }
            else {
                if (!memcmp (pContext->pTraceSettings->sPATID, pAufenthalt->PATID, nPatIdLen))
                    pContext->nTraceAufenthalt = pContext->pTraceSettings->nMBDSSeverity;
            }
        }
        else
        {
            pContext->nTraceAufenthalt = pContext->pTraceSettings->nMBDSSeverity;
            pContext->nTraceAufenthaltIntScor = pContext->pTraceSettings->nIntSeverity;
        }
    }
    
    quickscore_enabled = (pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE);
    
    if (quickscore_enabled)
        pContext->model2017errors = 0;
    
    pAufenthalt->pScoringContext = pContext;
    
    if (pAufenthalt->nSatzartFirstError >= 0) {
        lkf_plaus_removeErrorsFromContext (pContext, pAufenthalt);
    }
    
    if (pAufenthalt->pCategory) {
        pAufenthalt->category_alloc = pAufenthalt->category_count = 0;
        LKF_FREE(pContext, "lkf_plaus_compute", pAufenthalt->pCategory);
        pAufenthalt->pCategory = 0;
    }

    pContext->errortext[0] = 0;
    
    nIntSeverity = 0;
    
    pAufenthalt->lAufDat = 0;
    pAufenthalt->lEntDat = 0;
    pAufenthalt->GESVD = -1;
    
    if (pAufenthalt->pMelMel)
    {
        LKF_FREE (pContext, "lkf_plaus_compute", pAufenthalt->pMelMel);
        pAufenthalt->pMelMel = 0;
    }
    
    if (pAufenthalt->pMelMelInfo)
    {
        LKF_FREE (pContext, "lkf_plaus_compute", pAufenthalt->pMelMelInfo);
        pAufenthalt->pMelMelInfo = 0;
    }
    
    pAufenthalt->nMelMelCount = 0;
    for (i = 0; i < pAufenthalt->mel_anz; i++) {
        pAufenthalt->mel[i].nMelMelIndex = 0;
        pAufenthalt->mel[i].melmelInfo[0] = 0;
    }

    
    if (IS_TRACE_INFO(pContext))
    {
        sprintf (sTraceLine, "Start MBDS-Plausibilit\xc3\xa4""t f\xc3\xbc""r Aufenthalt '%10.10s'; Abr: %4.4d-%c%03d; Modell: %4.4d; Flags: %5d)",
                 pAufenthalt->PATID, pContext->cmb_jahr, pContext->period_type, pContext->period_val, modelljahr, pContext->flags);
        TRACE_INFO (pAufenthalt, -1, sTraceLine);
    }
    
    if (IS_TRACE_INPUT (pContext))
    {
        lkf_trace_mbds_aufenthalt (pContext, pAufenthalt);
    }
    
    if (pAufenthalt->akwarn) {
        for (i = 0; i < pAufenthalt->akwarn_anz; i++)
        {
            pAufenthalt->akwarn[i].nHitCount = 0;
            pAufenthalt->akwarn[i].acceptedValue[0] = 0;
            if (pAufenthalt->akwarn[i].followUpIndex > 0) {
                if (pAufenthalt->akwarn[i].followUpIndex < pAufenthalt->akwarn_anz) {
                    pAufenthalt->akwarn_anz = pAufenthalt->akwarn[i].followUpIndex;
                }
                pAufenthalt->akwarn[i].followUpIndex = 0;
            }
        }
    }
    
    /* Initialisierung der Zaehler */
    lkf_aufenthalt_plaus_init (pAufenthalt);
    
    /* Sortierung der Verlegungsdaten */
    lkf_sort_aufenthalt (pAufenthalt);
    
    /* V9.2a: Initialisierung der gemeldeten Intensiv-Scoring-Daten, falls nicht ueber lkf_check aufgerufen */
#ifdef SUPPORT_PRE2017
    if (!pContext->pIntScoring) {
        
        if (modelljahr >= 2017)
            lkf_int_alloc_structure_2017(pContext);
        else
            lkf_int_alloc_structure (pContext);
    }
    if (!pAufenthalt->pIntAufenthalt) {
        if (modelljahr >= 2017)
            lkf_int_alloc_structure_aufenthalt_2017 (pContext, pAufenthalt, pContext->pIntScoring);
        else
            lkf_int_alloc_structure_aufenthalt (pContext, pAufenthalt, pContext->pIntScoring);
    }

#else
    if (!pContext->pIntScoring) {
        lkf_int_alloc_structure_2017(pContext);
    }
    if (!pAufenthalt->pIntAufenthalt) {
        lkf_int_alloc_structure_aufenthalt_2017 (pContext, pAufenthalt, pContext->pIntScoring);
    }
#endif
    
    pAufenthalt->status |= 1;
    
    /* Krankenanstalt ueberpruefen (Anm.: Nur im Quickscore-Fall interessant */
    if (!IsEmpty (pAufenthalt->KANR, 6) && !KAInArray (pContext->pStamm2001, pAufenthalt->KANR))
    {
        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorMBDSKAfalsch, 0);
    }
    
    if (modelljahr >= 2017) {
        switch (pAufenthalt->BEHANDLUNGSART) {
            case 'I':
                pAufenthalt->isAmb = 1;
                break;
            case 'S':
                pAufenthalt->isAmb = 0;
                break;
            case 0:
            case ' ':
                pAufenthalt->isAmb = 0;
                if (pAufenthalt->pScoringContext->model2017errors) {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorBEHANDLUNGSARTfehlt, 0);
                }
                break;
            default:
            case 'E':
                pAufenthalt->isAmb = 0;
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorBEHANDLUNGSARTfalsch, 0);
                break;
        }
        
        if (pAufenthalt->BEHANDLUNGSART == 'S' && pAufenthalt->indexInContext >= 0)
        { /* V21.3 */
            int curInd;
            int error = 0;
            int compare_len = pContext->isBM ? 64 : 12;
            for (curInd = pAufenthalt->indexInContext + 1; curInd < (int) pContext->patient_anz && !strncmp (pAufenthalt->UCASE_PATID, pContext->ppAufenthalt[curInd]->UCASE_PATID, compare_len); curInd++) {
                if (pContext->ppAufenthalt[curInd]->BEHANDLUNGSART == 'S') {
                    error = 1;
                    break;
                }
            }
            
            if (!error) {
                for (curInd = pAufenthalt->indexInContext - 1; curInd >= 0 && !strncmp (pAufenthalt->UCASE_PATID, pContext->ppAufenthalt[curInd]->UCASE_PATID, compare_len); curInd--) {
                    if (pContext->ppAufenthalt[curInd]->BEHANDLUNGSART == 'S') {
                        error = 1;
                        break;
                    }
                }
            }
            if (error && !IsEmpty(pAufenthalt->UCASE_PATID, compare_len)) {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAUFNRSTATmehrfach, 0);
            }
        }
    }
    else
        pAufenthalt->isAmb = 0;
    
#ifdef LKF_AMB2025_ADD_HD
    if (pAufenthalt->hdiag_anz == 0 && pAufenthalt->isAmb) {
        lkf_add_diag(pAufenthalt, "103.1", "H");
        pAufenthalt->nStatus = 1;
    }
#endif
    
    /* PATID: Vorhandensein ERROR */
    /* derzeit keine Ueberpruefung auf Duplicates */
    
    /* Defaultwert annehmen */
    pAufenthalt->Alter = -99;
    
    if (pAufenthalt->pScoringContext->isBM) {
        if (!quickscore_enabled && IsBlank(pAufenthalt->UCASE_PATID, 64)) {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorKeineAufnahmezahl, 0);
            pAufenthalt->plaus_err = 1;
            pAufenthalt->FLAG = '4';
            return 0; /* V19.0 */
        }
    } else if (!quickscore_enabled && IsBlank (pAufenthalt->PATID, 10)) {
        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorKeineAufnahmezahl, 0);
        pAufenthalt->plaus_err = 1;
        pAufenthalt->FLAG = '4';
        return 0; /* V19.0 */
    }
    
    if (IS2017ORLATER(pAufenthalt)) {
        if (pAufenthalt->ABRECH_RELEVANT != 'J' && pAufenthalt->ABRECH_RELEVANT != 'N' && pAufenthalt->ABRECH_RELEVANT != 'K')
        { /* V21.2: blank/leer nicht mehr zulaessig */
            if (pAufenthalt->pScoringContext->model2017errors) {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorABRECHRELEVANZfalsch, 0);
            }
        }
        if (pAufenthalt->ABRECH_RELEVANT == 'J')
        { /* V21.3 */
            KOST_LIST_STRING *kostArray;
            sprintf (kost_lkf_check, "      %2.2s", pAufenthalt->KOST);
            kostArray = KostInArray (pContext, kost_lkf_check);
            if (kostArray) {
                int error = 0;
                switch ((*kostArray)[8]) {
                    case 'N':
                        error = 1;
                        break;
                    case 'I':
                        if (!pAufenthalt->isAmb) error = 1;
                        break;
                    case 'S':
                        if (pAufenthalt->isAmb) error = 1;
                        break;
                    default:
                        break;
                }
                
                if (error) {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorFondsRelevanzUnplaus, 0);
                }
            }
        }
    }
    
    /* V20.1 - AUFDAT/ENTDAT/MEL-Abts */
    if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
        pAufenthalt->lAufDat = lkf_dat2intStrict (pAufenthalt->AUFDAT);
        pAufenthalt->lEntDat = lkf_dat2intStrict (pAufenthalt->ENTDAT);
    }
    else {
        pAufenthalt->lAufDat = lkf_dat2int(pAufenthalt->AUFDAT);
        pAufenthalt->lEntDat = lkf_dat2int(pAufenthalt->ENTDAT);
    }
    
    for (i = 0; i < pAufenthalt->abt_anz; i++) {
        pAufenthalt->abt[i].lAbtDat = 0;
        pAufenthalt->abt[i].lAbtZeit = 0;
    }
    
    /* Quickscore-Modus fuer Gesamt-Verweildauer und Abteilungsverweildauern */
    if (!quickscore_enabled || pAufenthalt->AUFDAT[0] != '#') {
        /* ENTDAT: diverse Checks */
        
        if (ENTDAT_Check (pAufenthalt, pContext->cmb_jahr, pContext->period_type, pContext->period_val))
            pAufenthalt->lEntDat = lkf_dat2int (pAufenthalt->ENTDAT);
        
        AUFDAT_Check (pAufenthalt);
        
        if (pAufenthalt->isAmb && modelljahr >= 2018)
            pAufenthalt->GESVD = 0;
        else if (pAufenthalt->lAufDat && pAufenthalt->lEntDat) /* V2020.2 */
            pAufenthalt->GESVD = pAufenthalt->lEntDat - pAufenthalt->lAufDat;
        else if (pAufenthalt->lAufDat)
        {
            char datbuf[10];
            sprintf (datbuf, "%4.4d1231", pContext->cmb_jahr);
            pAufenthalt->GESVD = lkf_dat2int (datbuf) - pAufenthalt->lAufDat;
        }
        
        else AUFDAT_Check (pAufenthalt);
        ABTDAT_Check (pAufenthalt);
    }
    else {
        int k,l;
        for (k = (int) pAufenthalt->abt_anz - 1; k>=0 && pAufenthalt->abt[k].ABTDAT[0]=='#'; k--) ;
        for (l = 0; l <= k; l++) {
            if (Util_Datum_Format (pAufenthalt->abt[l].ABTDAT)) {
                Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorABTDATfalsch2017 : &LKFErrorABTDATfalsch, (unsigned int) k);
            }
        }
        if (lkf_GetInt (pAufenthalt->AUFDAT + 1, 7, &l))
            pAufenthalt->GESVD = l;
    }
    
    if (modelljahr >= 2024 /* V2025.0 */ && pAufenthalt->ENTART == 'V' && !quickscore_enabled && ENTARTV_Check(pAufenthalt)) {
        pAufenthalt->plaus_err = 1;
        pAufenthalt->FLAG = '4';
        return 0;
    }
    
    if (pAufenthalt->isAmb && !pAufenthalt->lEntDat) pAufenthalt->lEntDat = pAufenthalt->lAufDat; /* V21.1 */
    
    
    for (i = 0; i < pAufenthalt->mel_anz; i++)
    {
        LKF_AUFENTHALT_MEL *pMel = pAufenthalt->mel + i;
        pMel->nIgnoreMel = 0;
        pMel->melPlausFlags = 0;
        if (!IsBlank(pMel->MEL + 5, 5))
            pMel->nMelIndex = -1;
        else
            pMel->nMelIndex = FindMelIndex (pContext, pMel->MEL);
        if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            pMel->meldat_nr = (int) lkf_dat2intStrict (pMel->MELDAT);
        }
        else {
            pMel->meldat_nr = (int) lkf_dat2int (pMel->MELDAT);
        }
        
        lMelDat = (unsigned int) pMel->meldat_nr;
        
        if (lMelDat > (unsigned int) pAufenthalt->lEntDat && pAufenthalt->isAmb)
            lMelDat = (unsigned int) pAufenthalt->lEntDat;
        
        if (lMelDat && (new_abtmel_errors || pAufenthalt->pScoringContext->standortInfo)) {
            unsigned int nAbtIndex;
            
            if ((int)lMelDat < pAufenthalt->lAufDat || (int)lMelDat > pAufenthalt->lEntDat) {
                pMel->nMelAbtIndex = -1;
            }
            else {
                
                char *sExplicitAbtFC = 0;
                int nExplicitAbtIndex = -1;
                int nAbtZeitHasExplicitAbtFC = 0;
                long nMelZeit;
                int nAbtZeitValid = 1;
                int nZeitAbtIndex = -1;
                
                if (SAFEIS2017ORLATER(pAufenthalt))
                { /* V21.3: inkl. AbtFC-Check */
                    if (!IsBlank (pAufenthalt->mel[i].FCLEIST, 8)) {
                        sExplicitAbtFC = pMel->FCLEIST;
                    }
                }
                
                nMelZeit = lkf_time2int(pMel->MELZEIT);
                
                nAbtIndex = 0;
                while (nAbtIndex < pAufenthalt->abt_anz && pAufenthalt->abt[nAbtIndex].lAbtDat && pAufenthalt->abt[nAbtIndex].lAbtDat < lMelDat) nAbtIndex++ ;
                while (nAbtIndex < pAufenthalt->abt_anz && memcmp (pAufenthalt->abt[nAbtIndex].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN) && (pAufenthalt->abt[nAbtIndex].lAbtDat <= lMelDat))
                {
                    
                    if (nAbtZeitValid) {
                        if (!pAufenthalt->abt[nAbtIndex].lAbtZeit) {
                            nAbtZeitValid = 0;
                        }
                        else if (pAufenthalt->abt[nAbtIndex].lAbtZeit <= nMelZeit) /* V22.0: kleiner-gleich statt kleiner */
                        {
                            nZeitAbtIndex = (int) nAbtIndex;
                            nAbtZeitHasExplicitAbtFC = (sExplicitAbtFC && !memcmp (pAufenthalt->abt[nAbtIndex].ABTFC, sExplicitAbtFC, 8));
                        }
                    }
                    
                    if (sExplicitAbtFC && !memcmp (pAufenthalt->abt[nAbtIndex].ABTFC, sExplicitAbtFC, 8))
                        nExplicitAbtIndex = (int) nAbtIndex; /* V21.2 */
                    ++nAbtIndex; /* V19.1 */
                    
                }
                
                if (nAbtZeitValid && nAbtZeitHasExplicitAbtFC) {
                    pMel->nMelAbtIndex = nZeitAbtIndex;
                }
                else if (nExplicitAbtIndex >= 0) {
                    pMel->nMelAbtIndex = nExplicitAbtIndex;
                }
                else if (nAbtZeitValid && nZeitAbtIndex >= 0) {
                    pMel->nMelAbtIndex = nZeitAbtIndex;
                }
                else
                    pMel->nMelAbtIndex = (int) nAbtIndex - 1;
            }
        }
    }
    
    /* Zusammenfassen gleicher MEL's */
    if (pAufenthalt->mel_anz)
    {
        MEL_ARRAY_STRUC *pMel;
        for (i = 0; i < pAufenthalt->mel_anz; i++)
        {
            if (pAufenthalt->mel[i].nMelIndex < 0)
                continue;
            pMel = pContext->pStamm2001->mel_array	+ pAufenthalt->mel[i].nMelIndex;
            if (!pMel) continue;
            if (modelljahr >= 2012)
            { /* V17.0: Seite */
                char cSeite;
                
                if (modelljahr >= 2017)
                    cSeite = pAufenthalt->mel[i].cSeite;
                else
                {
                    pAufenthalt->mel[i].cSeite = 0;
                    cSeite = pAufenthalt->mel[i].ORIG_MEL[8];
                }
                
                if (cSeite && strchr (" LR", cSeite) == 0)
                    Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELSeiteUngueltig2016 : &LKFErrorMELSeiteUngueltig, i, 0, pAufenthalt->mel[i].nMelAbtIndex); /* V20.1 */
                else if (cSeite && cSeite != ' ')
                {
                    if (pMel->cSeite != 'J')
                        Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELhatkeineSeite2016 : &LKFErrorMELhatkeineSeite, i, 0, pAufenthalt->mel[i].nMelAbtIndex); /* V20.1 */
                    else
                        pAufenthalt->mel[i].cSeite = cSeite;
                }
                else if (modelljahr >= 2014)
                { /* V18.0 */
                    if (pMel->cSeite == 'J') {
                        
                        if (modelljahr >= 2017) {
                            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELSeiteFehlt2017, i, 0, pAufenthalt->mel[i].nMelAbtIndex);
                        }
                        else if (modelljahr == 2016) {
                            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELSeiteFehlt2016, i, 0, pAufenthalt->mel[i].nMelAbtIndex);
                        }
                        else {
                            Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELSeiteFehlt, i, 0, pAufenthalt->mel[i].nMelAbtIndex);
                        }
                        
                    }
                }
            }
        }
        
        tmp_melanz = (int *) LKF_CALLOC (pContext, "lkf_plaus_compute", pAufenthalt->mel_anz, sizeof (int));
        if (!tmp_melanz) {
            return LKF_OUTOFMEMORY_ERROR;
        }
        MEL_JoinEqual (pAufenthalt, tmp_melanz);
    }
    else tmp_melanz = 0;
    
    if (modelljahr >= 2017) {
        if (modelljahr >= 2025) {
            
            if (quickscore_enabled && pAufenthalt->GEBDAT[0] == '#')
            {
                int alter;
                GetInt (pAufenthalt->GEBDAT + 1, 7, &alter);
                pAufenthalt->Alter = (short) alter;
                if (pAufenthalt->Alter > 110) {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAlter, 0);
                }
            }
            else if (pAufenthalt->pScoringContext->isBM) {
                if (pAufenthalt->pScoringContext->isBM == 2) {
                    long lGebDat;
                    
                    if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
                        lGebDat = lkf_dat2intStrict (pAufenthalt->GEBDAT);
                    }
                    else {
                        lGebDat = lkf_dat2int (pAufenthalt->GEBDAT);
                    }
                    
                    pAufenthalt->lGebDat = lGebDat;
                    if (pAufenthalt->lGebDat) {
                        const char *entDat = 0;
                        char entBuf[10];
                        if (pAufenthalt->isAmb)
                            entDat = pAufenthalt->AUFDAT;
                        else if (pAufenthalt->lEntDat && pAufenthalt->ENTART != 'V')
                            entDat = pAufenthalt->ENTDAT;
                        else {
                            entDat = entBuf;
                            sprintf (entBuf, "%4.4d1231", pAufenthalt->pScoringContext->cmb_jahr);
                        }
                            
                        lkf_setAltersGruppe (pAufenthalt->ALTERSGRUPPE, pAufenthalt->GEBDAT, entDat);
                    }
                }
                ALTER_Check(pAufenthalt, pContext->cmb_jahr);
            }
            else {
                GEBDAT_Check (pAufenthalt, pContext->cmb_jahr);
                if (((pContext->flags & LKFCONTEXT_FILL_BMG) || FILL_ALTERSGRUPPE(pAufenthalt)) && pAufenthalt->lGebDat && pAufenthalt->lAufDat) {
                    if (pAufenthalt->isAmb)
                        lkf_setAltersGruppe(pAufenthalt->ALTERSGRUPPE, pAufenthalt->GEBDAT, pAufenthalt->AUFDAT);
                    else if (pAufenthalt->lEntDat && pAufenthalt->ENTART != 'V')
                        lkf_setAltersGruppe (pAufenthalt->ALTERSGRUPPE, pAufenthalt->GEBDAT, pAufenthalt->ENTDAT);
                    else {
                        char entbuf[10];
                        sprintf (entbuf, "%4.4d1231", pAufenthalt->pScoringContext->cmb_jahr);
                        lkf_setAltersGruppe (pAufenthalt->ALTERSGRUPPE, pAufenthalt->GEBDAT, entbuf);
                    }
                }
            }

            for (i = 0; i < pAufenthalt->mel_anz; i++) {
                lkf_plaus_ignoreMelChecks (pAufenthalt, pContext, i, modelljahr);
            }
        }
        
        if (modelljahr >= 2020 && pAufenthalt->isAmb == 1) {
            for (i = 0; i < pAufenthalt->mel_anz; i++) {
                LKF_AUFENTHALT_MEL *pMel = pAufenthalt->mel + i;
                if (pMel->MEL_RELEVANT != 'N' && pMel->MEL_RELEVANT != 'K' && !pMel->nIgnoreMel) {
                    MEL_ARRAY_STRUC *pMelDef = FindMel (pContext, pMel->MEL);
                    
                    if (pMelDef && pMelDef->cAmbModus2 == 'J') {
                        char tmp_mel_ka[12];
                        
                        if (modelljahr >= 2024 && pMel->KALEIST[0] && pMel->KALEIST[0] != ' ') {
                            sprintf (tmp_mel_ka, "%4.4s %5.5s", pMel->KALEIST, pMel->MEL);
                        }
                        else {
                            sprintf (tmp_mel_ka, "%4.4s %5.5s", pAufenthalt->KANR, pMel->MEL);
                        }
                        
                        
                        if (!GetMELKATKLContext (pContext, tmp_mel_ka)) {

                            pAufenthalt->mel[i].ambtklmel = 1;
                            pAufenthalt->isAmb = 2;
                            lkf_auf_add_category(pAufenthalt, "AMB2", pMel->MEL, 5);
                            if (pAufenthalt->hdiag_anz > 1) {
                                unsigned int hi;
                                ICD_LIST_STRING *pICD = 0;
                                for (hi = 0; hi < pAufenthalt->diag_anz; hi++) {
                                    ICD_LIST_STRING *pCurIcd;
                                    
                                    if (!pAufenthalt->diag[hi].isHD) {
                                        continue;
                                    }
                                    
                                    pCurIcd = FindDiag6(pContext->pStamm2001, pAufenthalt->diag[hi].DIAG);
                                    if (pCurIcd && !strchr("#!", (*pCurIcd)[7])) {
                                        if (!pICD)
                                            pICD = pCurIcd;
                                        else if (memcmp(pCurIcd, pICD, 6) < 0) {
                                            pICD = pCurIcd;
                                        }
                                    }
                                }
                                
                                if (pICD) {
                                    memcpy (pAufenthalt->HD, pICD, 6);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    if (modelljahr < 2025) {
        
        
        /* Quickscore-Modus fuer Geburtsdatum und Alter*/
        if (quickscore_enabled && pAufenthalt->GEBDAT[0] == '#')
        {
            int alter;
            GetInt (pAufenthalt->GEBDAT + 1, 7, &alter);
            pAufenthalt->Alter = (short) alter;
            if (pAufenthalt->Alter > 110) {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAlter, 0);
            }
        }
        else if (pAufenthalt->pScoringContext->isBM) {
            if (pAufenthalt->pScoringContext->isBM == 2) {
                long lGebDat;
                
                if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
                    lGebDat = lkf_dat2intStrict (pAufenthalt->GEBDAT);
                }
                else {
                    lGebDat = lkf_dat2int (pAufenthalt->GEBDAT);
                }
                
                pAufenthalt->lGebDat = lGebDat; /* V19.0 */
                if (pAufenthalt->lGebDat) {
                    const char *entDat = 0;
                    char entBuf[10];
                    if (pAufenthalt->isAmb)
                        entDat = pAufenthalt->AUFDAT;
                    else if (pAufenthalt->lEntDat && pAufenthalt->ENTART != 'V')
                        entDat = pAufenthalt->ENTDAT;
                    else {
                        entDat = entBuf;
                        sprintf (entBuf, "%4.4d1231", pAufenthalt->pScoringContext->cmb_jahr);
                    }
                    
                    lkf_setAltersGruppe (pAufenthalt->ALTERSGRUPPE, pAufenthalt->GEBDAT, entDat);
                }
            }
            ALTER_Check(pAufenthalt, pContext->cmb_jahr);
        }
        else {
            /* GEBDAT: diverse Checks */
            GEBDAT_Check (pAufenthalt, pContext->cmb_jahr);
            if (((pContext->flags & LKFCONTEXT_FILL_BMG) || FILL_ALTERSGRUPPE(pAufenthalt)) && pAufenthalt->lGebDat && pAufenthalt->lAufDat) {
                if (pAufenthalt->isAmb)
                    lkf_setAltersGruppe(pAufenthalt->ALTERSGRUPPE, pAufenthalt->GEBDAT, pAufenthalt->AUFDAT);
                else if (pAufenthalt->lEntDat && pAufenthalt->ENTART != 'V')
                    lkf_setAltersGruppe (pAufenthalt->ALTERSGRUPPE, pAufenthalt->GEBDAT, pAufenthalt->ENTDAT);
                else {
                    char entbuf[10];
                    sprintf (entbuf, "%4.4d1231", pAufenthalt->pScoringContext->cmb_jahr);
                    lkf_setAltersGruppe (pAufenthalt->ALTERSGRUPPE, pAufenthalt->GEBDAT, entbuf);
                }
            }
        }
    }
    
    if (modelljahr >= 2018 && !pContext->isBM && !pAufenthalt->isAmb && pAufenthalt->lAufDat && pAufenthalt->lGebDat) {
        if (pAufenthalt->AUFART == 'G' && pAufenthalt->lAufDat - pAufenthalt->lGebDat > 1)
        {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAltersgruppeAUFARTG, 0);
        }
        else if (pAufenthalt->AUFART != 'G' && pAufenthalt->lAufDat - pAufenthalt->lGebDat < 2) {
            
            if (memcmp (pAufenthalt->AUFDAT, "20180101", 8) >= 0)
            {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAltersgruppeAUFARTG, 0);
            }
        }
    }
    

    if (!(pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE) || pAufenthalt->GESCHL != ' ') {
        /* GESCHLECHT: ung\xc3\xbc""ltiges Geschlecht -> ERROR */
        if (pAufenthalt->GESCHL == ' ')
        {
            Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2021 ? &LKFErrorGESCHLfehlt2021 : &LKFErrorGESCHLfehlt, 0);
        }
        else if (pAufenthalt->GESCHL != 'M' && pAufenthalt->GESCHL != 'W') {
            if (pAufenthalt->GESCHL != 'K' || modelljahr < 2024) {
                if ((pAufenthalt->GESCHL != 'I' && pAufenthalt->GESCHL != 'O') || modelljahr < 2021)
                { /* V2021.1 */
                    if (pAufenthalt->GESCHL != 'X' || modelljahr < 2020)
                    { /* V2020.0 */
                        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorGESCHLfalsch, 0);
                    }
                }
            }
        }
    }
    
	if (pContext->noStamm) {
		ABTFC_Check(pAufenthalt);
		return 0;
	}
    
    
    if (modelljahr >= 2018)
    { /* V22.0 */
        HKLE_Check (pAufenthalt);
    }
    
    /* PSYCH-Check */
    PSYCH_Check (pAufenthalt);

    
    
    if (!pAufenthalt->isAmb && pAufenthalt->lAufDat && pAufenthalt->lEntDat && pAufenthalt->psych_mode && pAufenthalt->psych_mode < 1024 && modelljahr < 2019) {
        if (memcmp (pAufenthalt->AUFDAT, pAufenthalt->ENTDAT, 6)) {
#ifdef SUPPORT_PRE2017
            if (new_abtmel_errors)
                Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorBehAbschliessen2016, 0, 0, 0);
            else
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorBehAbschliessen, 0);
#else
            Satzart_ReportMBDSError2(pAufenthalt, &LKFErrorBehAbschliessen2016, 0, 0, 0);
#endif
        }
    }
    
    
    /* AUFART: diverse Checks */
    if (quickscore_enabled && !pAufenthalt->isAmb /* V21.1 */ && pAufenthalt->AUFART == ' ') {
        if (pAufenthalt->psych_mode && modelljahr < 2019) pAufenthalt->AUFART = 'H';
        else pAufenthalt->AUFART = 'A';
    }
    
    AUFART_Check (pAufenthalt);
    
    if (pAufenthalt->AUFART == 'T' || pAufenthalt->AUFART == 'G' /* V22.0 */)
    {
        if (IsEmpty (pAufenthalt->KANR_VON, 6))
        {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorKAVonFehlt, 0);
        }
        else if (!memcmp (pAufenthalt->KANR, pAufenthalt->KANR_VON, 4))
        {
            if (pAufenthalt->AUFART != 'G')
                Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2019 ? &LKFErrorKAVonUnplaus2019 : &LKFErrorKAVonUnplaus, 0);
        }
        else if (!KAInArray2 (pContext->pStamm2001, pAufenthalt->KANR_VON, 1) ||
                 !memcmp (pAufenthalt->KANR, pAufenthalt->KANR_VON, 4))
        {
            if (modelljahr < 2017 || memcmp (pAufenthalt->KANR_VON, "K000", 4))
            { /* K000 fuer Transfer aus dem Ausland ok */
                
                if (pAufenthalt->AUFART != 'G' && memcmp (pAufenthalt->KANR_VON, "E000", 4)) {
                    Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorKAVonFalsch2017 : &LKFErrorKAVonFalsch, 0);
                }
            }
        }
    }
    else if (!IsEmpty (pAufenthalt->KANR_VON, 6))
    {
        if (modelljahr < 2014 || !IsPflegeKA (pContext, pAufenthalt->KANR_VON))
        {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorKAVonNurBeiT, 0);
        }
    }
    
    if (quickscore_enabled && !pAufenthalt->isAmb && pAufenthalt->AUFART2 == ' ')
        pAufenthalt->AUFART2 = 'A';
    
    if (pAufenthalt->AUFART2 == ' ') {
        if (!pAufenthalt->isAmb) Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAufart2Fehlt, 0);
    }
    else if (modelljahr >= 2025) { /* V2025.0 */
        if (!strchr ("PAKS", pAufenthalt->AUFART2)) {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAufart2Falsch2017, 0);
        }
    }
    else if (modelljahr >= 2020) {
        if (!strchr ("PAK", pAufenthalt->AUFART2)) {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAufart2Falsch2017, 0);
        }
    }
    else if (!strchr ("PA", pAufenthalt->AUFART2))
        Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorAufart2Falsch2017 : &LKFErrorAufart2Falsch, 0);
    
    /* ENTART: ungueltige Entlassungsart -> ERROR */
    if (quickscore_enabled && !pAufenthalt->isAmb && pAufenthalt->ENTART == ' ') {
        if (pAufenthalt->psych_mode && modelljahr < 2019) pAufenthalt->ENTART = 'H';
        else pAufenthalt->ENTART = 'E';
    }
    
    if (pAufenthalt->isAmb) {
        if (!strchr (" 12356789", pAufenthalt->ENTART)) {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorENTARTfalsch2017, 0);
        }
    }
    else if (pAufenthalt->ENTART == ' ') {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorENTARTfehlt, 0);
    }
    else if (pAufenthalt->ENTART != 'V' && IsBlank (pAufenthalt->ENTDAT, 8))
    {
        if (!quickscore_enabled) Satzart_ReportMBDSError (pAufenthalt, &LKFErrorENTARTVerbleib, 0);
    }
    else if (pAufenthalt->psych_mode && pAufenthalt->psych_mode < 1024) {
        if (pAufenthalt->ENTART != 'H') {
            Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorENTARTfalsch2017 : &LKFErrorENTARTfalsch, 0);
        }
    }
    else if (!strchr ("ETSARPLV", pAufenthalt->ENTART)) {
        
        if ((pAufenthalt->ENTART != LKF_ENTART_REVERS || modelljahr < 2014) /* V18.0 */
            && (pAufenthalt->ENTART != 'H' || modelljahr > 2018)) /* V2019.0 */
            Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorENTARTfalsch2017 : &LKFErrorENTARTfalsch, 0);
    }
    
    if (pAufenthalt->ENTART == 'T')
    {
        
        if (IsEmpty (pAufenthalt->KANR_AN, 6))
        {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorKAAnFehlt, 0);
        }
        else if (!memcmp (pAufenthalt->KANR, pAufenthalt->KANR_AN, 4))
        {
            Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2019 ? &LKFErrorKAAnUnplaus2019 : &LKFErrorKAAnUnplaus, 0);
        }
        else if (!KAInArray2 (pContext->pStamm2001, pAufenthalt->KANR_AN, 1) ||
                 !memcmp (pAufenthalt->KANR, pAufenthalt->KANR_AN, 4))
        {
            if (modelljahr < 2017 || memcmp (pAufenthalt->KANR_VON, "K000", 4))
            { /* K000 fuer Transfer ins Ausland ok */
                Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2017 ? &LKFErrorKAAnFalsch2017 : &LKFErrorKAAnFalsch, 0);
            }
        }
    }
    else if (!IsEmpty (pAufenthalt->KANR_AN, 6)) {
        /* KANR_AN darf nur bei ENTART = T bef\xc3\xbc""llt sein */
        if (modelljahr < 2014 || pAufenthalt->ENTART == 'S' || !IsPflegeKA (pContext, pAufenthalt->KANR_AN))
        {
            Satzart_ReportMBDSError (pAufenthalt, &LKFErrorKAAnNurBeiT, 0);
        }
    }
    
    /* STAATB, STAATW, PLZ: diverse Checks */
    if (!quickscore_enabled) STAAT_Check (pAufenthalt);
        
    if (!quickscore_enabled || pAufenthalt->abt_anz > 0) {
        /* ABTFC-Check */
        ABTFC_Check (pAufenthalt);
    }
    
    if (pAufenthalt->pScoringContext->isBM & 2) {
        memset (pAufenthalt->GEBDAT, ' ', 8);
    }
    
    /* \xc3\x9c""berpr\xc3\xbc""fung, ob mehr als 28 Tage f\xc3\xbc""r Remob */
    nRemobTage = 0;
    for (i = 0; i < pAufenthalt->abt_anz && nRemobTage <= 28; i++)
    {
        sprintf (sSearchString, ".....%4.4s%8.8s", pAufenthalt->KANR, pAufenthalt->abt[i].ABTFC);
        pSpez = SpezInArray (pAufenthalt->pScoringContext, sSearchString);
        
        if (pSpez && (*pSpez)[0] == 'R' && !memcmp ((*pSpez) + 27, "RN", 2))
        {
            nRemobTage += pAufenthalt->abt[i].ABTVD;
            
            if (nRemobTage > 28)
            {
                Satzart_ReportMBDSError (pAufenthalt, &LKFErrorRemobUeber28ab2009, 0);
            }
        }
    }
    
    
    /* Kostentraeger-Checks */
    if (!quickscore_enabled) KOST_Check (pAufenthalt);
    
    /* Ueberpruefung der Hauptdiagnose */
    diag_ambulant = 0;
    
    /* V21.0 - Ambulanz-Checks */
    if (modelljahr >= 2017) {
        char f;
        f = pAufenthalt->TRANSPORTART;
        if (f && !strchr (" HNRSZK", f))
            Satzart_ReportMBDSError(pAufenthalt, &LKFAmbErrorTransportartFalsch, 0);
    }
    
    if (modelljahr < STERNKR_NEW_MODEL)
    {
        pAufenthalt->diagInfo = 0;
        pAufenthalt->sternkr = (STERNKR_LIST_STRING **) LKF_CALLOC (pContext, "lkf_plaus_compute.sternkr", sizeof (STERNKR_LIST_STRING *), pAufenthalt->diag_anz);
        if (!pAufenthalt->sternkr) {
            return LKF_OUTOFMEMORY_ERROR;
        }
    }
    else if (modelljahr >= 2017)
    {
        pAufenthalt->sternkr = 0;
		if (pAufenthalt->diag_anz > 0) {
			pAufenthalt->diagInfo = (DIAG_INFO **)LKF_CALLOC(pContext, "lkf_plaus_compute.diaginfo", sizeof(DIAG_INFO *), pAufenthalt->diag_anz);
            if (!pAufenthalt->diagInfo) {
                return LKF_OUTOFMEMORY_ERROR;
            }
		}
		else {
			pAufenthalt->diagInfo = 0;
		}
    }
    else
    {
        pAufenthalt->sternkr = 0;
        pAufenthalt->diagInfo = (DIAG_INFO **) LKF_CALLOC(pContext, "lkf_plaus_compute.diaginfo", sizeof (DIAG_INFO *), pAufenthalt->diag_anz);
    }
    
    if (pAufenthalt->isAmb)
    {
        if (modelljahr >= 2019)
        { /* V2019.1 */
			unsigned int i;
            int diagVerpflichtend = 0;
            int diagNichtVerpflichtend = 0; /* V2019.2 */
            
            if (pAufenthalt->mel_anz > 0) {
                for (i = 0; i < pAufenthalt->mel_anz; i++) {
                    
                    int nMelIndex = pAufenthalt->mel[i].nMelIndex;
                    if (nMelIndex >= 0) {
                        MEL_ARRAY_STRUC *pMel = GetMELArrayFromIndex (pContext, nMelIndex);
                        if (pMel) {
                            if (pMel->cDiagVerpflichtend) {
                                diagVerpflichtend++;
                            }
                            else {
                                diagNichtVerpflichtend++;
                            }
                        }
                    }
                }
            }
            
            if (diagVerpflichtend) {
                diag_options |= DIAG_OPTION_AMBLEIST_VERPFLICHTEND;
            }
            if (diagNichtVerpflichtend) {
                diag_options |= DIAG_OPTION_AMBLEIST_NICHTVERPFLICHTEND;
            }
            if (pAufenthalt->hdiag_anz == 0) {
                
                if (diagVerpflichtend || modelljahr >= 2027 /* EX1K erst ab Modell 2027 */) {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorHDfehlt, 0);
                }
                else if (modelljahr >= 2026) {
                    if (pAufenthalt->diag_anz > 0) {
                        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAmbHDfehltZDvorhanden2026, 0);
                    }
                    else {
                        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAmbHDfehlt2026, 0);
                    }
                }
                else if (modelljahr == 2025) {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAmbHDfehlt2025, 0);
                }
            }
            else if (pAufenthalt->hdiag_anz > 1)
            {
                if (modelljahr >= 2027) { /* EX1L hier erst ab Modell 2027 */
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorHDmehrfach2021amb, 0);
                }
                else {
                    unsigned int maxHD;
                    unsigned int i, j;
                    
                    maxHD = 1;
                    for (i = 1; i < pAufenthalt->abt_anz; i++) {
                        for (j = 0; j < i; j++) {
                            if (!memcmp (pAufenthalt->abt[i].ABTFC + 2, pAufenthalt->abt[j].ABTFC + 2, 4)) { /* V2019.2: 2 -> 4 Stellen */
                                break;
                            }
                        }
                        if (j == i) {
                            ++maxHD;
                        }
                    }
                    
                    if (pAufenthalt->hdiag_anz > maxHD) {
                        Satzart_ReportMBDSError (pAufenthalt, modelljahr >= 2021 ? &LKFErrorHDmehrfach2021amb /* V2021.2 accept */ : &LKFErrorHDmehrfach, 0);
                    }
                    else if (modelljahr == 2025) {
                        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorAmbHDmultiple2025, 0);
                    }
                }
            }
        }
        
        for (i = 0; i < pAufenthalt->diag_anz; i++) {
            if (pAufenthalt->diag[i].isHD) {
                Hauptdiagnose_Check (pAufenthalt, i, &diag_ambulant, &diag_options);
            }
        }
    }
    else {
        for (i = 0; i < pAufenthalt->diag_anz; i++) {
            if (pAufenthalt->diag[i].isHD) {
                Hauptdiagnose_Check (pAufenthalt, i, &diag_ambulant, &diag_options);
                hdiag_index++;
                break;
            }
        }
        if (hdiag_index == 0) {
            Hauptdiagnose_Check (pAufenthalt, 0, &diag_ambulant, &diag_options); /* HD fehlt */
        }
    }
    
    /* Ueberpruefung der Zusatzdiagnosen */
    for (i = 0; i < pAufenthalt->diag_anz; i++) {
        if (pAufenthalt->diag[i].isHD) {
            continue;
        }
        Zusatzdiagnose_Check (pAufenthalt, i, (modelljahr < 2021) ? &diag_ambulant : 0, &diag_options);
    }
    
    /* Stern-Kreuz-Check */
    if (modelljahr < STERNKR_NEW_MODEL)
        SternKreuz_Check (pAufenthalt);
    else
        SternKreuz_Check_2014 (pAufenthalt);
    
    if (pAufenthalt->sternkr) LKF_FREE (pContext, "lkf_plaus_compute.sternkr", pAufenthalt->sternkr);
    if (pAufenthalt->diagInfo) LKF_FREE (pContext, "lkf_plaus_compute.diaginfo", pAufenthalt->diagInfo);
    
    if (modelljahr >= 2014)
    {
        DiagDiag_Check (pAufenthalt);
        DiagMel_Check (pAufenthalt);
    }
    
    /* V20.1: Ermittlung der MEL-Abteilungen (vorverlegt - ab V21.3 fuer 2017 noch weiter vorne) */
    if (modelljahr < 2017) {
        for (i = 0; i < pAufenthalt->mel_anz; i++) {
            lMelDat = (unsigned int) pAufenthalt->mel[i].meldat_nr;
            
            if (lMelDat && pAufenthalt->pScoringContext->standortInfo) {
                unsigned int nAbtIndex;
                
                if (lMelDat > (unsigned int) pAufenthalt->lEntDat && pAufenthalt->isAmb)
                    lMelDat = (unsigned int) pAufenthalt->lEntDat;
                
                if ((int)lMelDat < pAufenthalt->lAufDat || (int)lMelDat > pAufenthalt->lEntDat) {
                    pAufenthalt->mel[i].nMelAbtIndex = -1;
                }
                else  {
                    
                    for (nAbtIndex = 0; nAbtIndex < pAufenthalt->abt_anz && pAufenthalt->abt[nAbtIndex].lAbtDat && pAufenthalt->abt[nAbtIndex].lAbtDat < lMelDat; nAbtIndex++) ;
                    
                    while (nAbtIndex < pAufenthalt->abt_anz && memcmp (pAufenthalt->abt[nAbtIndex].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN) && (pAufenthalt->abt[nAbtIndex].lAbtDat <= lMelDat)) {
                        ++nAbtIndex; /* V19.1 */
                    }
                    
                    pAufenthalt->mel[i].nMelAbtIndex = (int) nAbtIndex - 1 /* V19.1p */;
                }
            }
        }
    }
    
    /* MELANZ: Ueberpruefe, ob MEL vorhanden */
    for (i = 0; i < pAufenthalt->mel_anz; i++) {
        if (!IsBlank (pAufenthalt->mel[i].MELANZ, LKF_AUFENTHALT_MELANZ_LEN) &&
            !TrimEqual (pAufenthalt->mel[i].MELANZ, LKF_AUFENTHALT_MELANZ_LEN, "0")) {
            if (GetInt (pAufenthalt->mel[i].MELANZ, LKF_AUFENTHALT_MELANZ_LEN, &melanz)) {
                if (melanz > 0 && (IsBlank (pAufenthalt->mel[i].MEL, LKF_AUFENTHALT_NEWMEL_LEN) ||
                                   TrimEqual (pAufenthalt->mel[i].MEL, LKF_AUFENTHALT_NEWMEL_LEN, "0"))) {
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorMELANZohneMEL, i);
                }
                else if (melanz < 0) {
#ifdef SUPPORT_PRE2017
                    Satzart_ReportMBDSError (pAufenthalt, new_abtmel_errors ? &LKFErrorMELANZfalsch2016 : &LKFErrorMELANZfalsch, i);
#else
                    Satzart_ReportMBDSError (pAufenthalt, &LKFErrorMELANZfalsch2016, i);
#endif
                }
            }
            else {
#ifdef SUPPORT_PRE2017
                Satzart_ReportMBDSError2 (pAufenthalt, new_abtmel_errors ? &LKFErrorMELohneAnzahl2016 : &LKFErrorMELohneAnzahl, i, 0, pAufenthalt->mel[i].nMelAbtIndex);
#else
                Satzart_ReportMBDSError2 (pAufenthalt, &LKFErrorMELohneAnzahl2016, i, 0, pAufenthalt->mel[i].nMelAbtIndex);
#endif
            }
        }
    }
    
    for (i = 0; i < pAufenthalt->mel_anz; i++)
    {
        if (!GetInt (pAufenthalt->mel[i].MELANZ, LKF_AUFENTHALT_MELANZ_LEN, (int *) &pAufenthalt->mel[i].nTagMelAnz))
        {
            pAufenthalt->mel[i].nTagMelAnz = 0;
            pAufenthalt->mel[i].nTagMelAnzRelevant = 0;
            pAufenthalt->mel[i].nOrigTagMelAnzRelevant = 0;
            pAufenthalt->mel[i].punkteIndex = 0;
            pAufenthalt->mel[i].gruppeIndex = 0;
            pAufenthalt->mel[i].significantMELIndex = i;
        }
        else if (nFirst >= 0 && !memcmp (pAufenthalt->mel[nFirst].MEL, pAufenthalt->mel[i].MEL, LKF_AUFENTHALT_NEWMEL_LEN) &&
                 (pAufenthalt->isAmb || !memcmp (pAufenthalt->mel[nFirst].MELDAT, pAufenthalt->mel[i].MELDAT, LKF_AUFENTHALT_DAT_LEN)) &&
                 pAufenthalt->mel[nFirst].cSeite == pAufenthalt->mel[i].cSeite /* V17.1 */
                 && (modelljahr < 2018 || mel_relevanz_equal (pAufenthalt->mel[nFirst].MEL_RELEVANT, pAufenthalt->mel[i].MEL_RELEVANT)))
        {
            pAufenthalt->mel[nFirst].nTagMelAnz += pAufenthalt->mel[i].nTagMelAnz;
            if (pAufenthalt->mel[i].MEL_RELEVANT != 'N' && pAufenthalt->mel[i].MEL_RELEVANT != 'K') {
                pAufenthalt->mel[nFirst].nTagMelAnzRelevant += pAufenthalt->mel[i].nTagMelAnz;
                pAufenthalt->mel[i].nOrigTagMelAnzRelevant = pAufenthalt->mel[i].nTagMelAnz;
                pAufenthalt->mel[i].punkteIndex = pAufenthalt->mel[nFirst].punkteIndex;
                pAufenthalt->mel[i].gruppeIndex = pAufenthalt->mel[nFirst].gruppeIndex;

            }
            else {
                pAufenthalt->mel[i].nOrigTagMelAnzRelevant = 0;
            }
            pAufenthalt->mel[i].nTagMelAnzRelevant = 0;
            pAufenthalt->mel[i].nTagMelAnz = 0;
            pAufenthalt->mel[i].significantMELIndex = (unsigned int) nFirst;
        }
        else
        {
            nFirst = (int) i;
            pAufenthalt->mel[i].significantMELIndex = i;
            pAufenthalt->mel[i].nTagMelAnzRelevant = (pAufenthalt->mel[i].MEL_RELEVANT == 'N' || pAufenthalt->mel[i].MEL_RELEVANT == 'K') ? 0 : pAufenthalt->mel[i].nTagMelAnz;
            
            pAufenthalt->mel[i].nOrigTagMelAnzRelevant = pAufenthalt->mel[i].nTagMelAnzRelevant;

            if (pAufenthalt->mel[i].nTagMelAnzRelevant) {
                pAufenthalt->mel[i].punkteIndex = i;
                pAufenthalt->mel[i].gruppeIndex = i;
            }
            else {
                pAufenthalt->mel[i].punkteIndex = 0;
                pAufenthalt->mel[i].gruppeIndex = 0;
            }
        }
    }
    
    /* Ueberpruefung der med.Einzelleistungen */
    for (i = 0; i < pAufenthalt->mel_anz; i++) {
        pAufenthalt->mel[i].melmelInfo[0] = 0;
        Einzelleistung_Check (pAufenthalt, i, tmp_melanz[i], &diag_ambulant);
    }
    
    if (tmp_melanz) LKF_FREE (pContext, "lkf_plaus_compute", tmp_melanz);
    
    
    for (i = 0; i < pAufenthalt->mel_anz; i++)
    {
        if ((pAufenthalt->mel[i].MEL_RELEVANT != 'N' && pAufenthalt->mel[i].MEL_RELEVANT != 'K') || modelljahr >= 2011)
            MEL_MEL_Check (pAufenthalt, i);
    }
    
    for (i = 0; i < pAufenthalt->mel_anz; i++) pAufenthalt->mel[i].nMelMelIndexSep = pAufenthalt->mel[i].nMelMelIndex;

    /* V14.2 - Pools zusammenfassen, die MELs am gleichen Tag haben */
    for (i = 1; i < pAufenthalt->mel_anz; i++)
    {
        if (pAufenthalt->mel[i].nMelMelIndex == 0)
            continue;
        for (j = 0; j < i; j++)
        {
            if (pAufenthalt->mel[j].nMelMelIndex == 0 || pAufenthalt->mel[j].nMelMelIndex == pAufenthalt->mel[i].nMelMelIndex)
                continue;
            if (pAufenthalt->isAmb || (!memcmp (pAufenthalt->mel[i].MELDAT, pAufenthalt->mel[j].MELDAT, 8)))
            { /* Pools zusammenfassen */
                unsigned int k;
                for (k = 0; k < pAufenthalt->mel_anz; k++)
                {
                    if (pAufenthalt->mel[k].nMelMelIndex == pAufenthalt->mel[j].nMelMelIndex)
                        pAufenthalt->mel[k].nMelMelIndex = pAufenthalt->mel[i].nMelMelIndex;
                }
            }
        }
    }
    
    if (diag_ambulant && !pAufenthalt->isAmb /* V22.1 */) {
        Satzart_ReportMBDSError (pAufenthalt, &LKFErrorHDstatfalsch, 0);
    }
    if (pContext->flags & LKFCONTEXT_NPPLAUS) 
    { /* V7.2: NP-Plaus, wenn eingeschaltet */
        lkf_NPPlaus_Check (pContext, pAufenthalt);
    }

	if (pContext->flags & LKFCONTEXT_NUR_MBDS)
		nIntSeverity = 0;
	else if ((pContext->flags & LKFCONTEXT_NICHTFONDSKA) && modelljahr < 2012)
		nIntSeverity = 0;
	else /* V16.0: ab Modell 2012 Intensiv-Check auch fuer Nicht-Fonds-Haeuser */
		nIntSeverity = lkf_int_check (pContext, pAufenthalt);

	/* Mascherl setzen */
	if (pAufenthalt->plaus_err || pAufenthalt->akerr_count || (nIntSeverity&15) >= LKF_SEV_ERROR) pAufenthalt->FLAG = '4';
	else if (pAufenthalt->plaus_warn || pAufenthalt->akwarn_count || (nIntSeverity&15) >= LKF_SEV_WARNING) pAufenthalt->FLAG = '2';
	else pAufenthalt->FLAG = '0';

    if (pContext->modelljahr >= 2017) {
        if (pAufenthalt->ABRECH_RELEVANT == 'N' || pAufenthalt->ABRECH_RELEVANT == 'K') pAufenthalt->FLAG++;
		else if (pAufenthalt->ABRECH_RELEVANT != 'J') 
		{ /* V21.3 - wenn Relevanz falsch (fehlt), nimm Relevanz aus KOST.dat */
			sprintf (kost_lkf_check, "%2.2sJ", pAufenthalt->KOST);	
	        if (!KostInArray2 (pContext, kost_lkf_check)) {			
				kost_lkf_check[2] = pAufenthalt->isAmb ? 'I' : 'S';
				if (!KostInArray2 (pContext, kost_lkf_check))
					pAufenthalt->FLAG++;
			}
		}
    }
    else {
        sprintf (kost_lkf_check, "%2.2sJ", pAufenthalt->KOST);
        if (!KostInArray2 (pContext, kost_lkf_check)) pAufenthalt->FLAG++;
    }
    
    return Util_Abteilung (pContext, pAufenthalt);
}

/* procedure ComposeFilename *******************************************************
**     Baut aus cmb_jahr, period_type, period_len und type den dazugeh\xc3\xb6""rigen      **
**     Filenamen auf.                                                             **
** Parameter:                                                                     **
**     cmb_jahr, period_type, period_val: siehe Plaus_Check                       **
**     act_ka:   Krankenanstalt (4stellig) 										  **
**     type:     'p' f\xc3\xbc""r ge-Plaus-tes File, 's' f\xc3\xbc""r ge-Scor-tes File,             **
**               'e' f\xc3\xbc""r Plaus-Errorfile, 'w' f\xc3\xbc""r Plaus-Warningfile               **
**     filename: Filename wird zur\xc3\xbc""ckgeliefert (8.3-Syntax, Buffer mu\xc3\x9f"" 13stellig  **
**               sein)                                                            **
***********************************************************************************/

_SCORING_EXPORT void lkf_compose_filename (LKF_CONTEXT *pContext, const char *act_ka, char type, char *filename)
{

	char *f;
	if (!act_ka)
		 sprintf (f = filename, "SUM%c%03d.%c%02d", pContext->period_type, pContext->period_val, type, pContext->cmb_jahr % 100);
	else if (!memcmp (act_ka, "    ", 4))
		 sprintf (f = filename, "xxxx%c%03d.%c%02d", pContext->period_type, pContext->period_val, type, pContext->cmb_jahr % 100);
	else sprintf (f = filename, "%4.4s%c%03d.%c%02d", act_ka, pContext->period_type, pContext->period_val, type, pContext->cmb_jahr % 100);
	while (*f) {
		if (isupper (*f)) *f = (char) tolower (*f);
		++f;
	}
}


#ifdef LKF_INCLUDE_DEPRECATED_FUNCTIONALITY

/* procedure Plaus_WriteWEHeader **************************************
**     Erzeugt die Headerfiles fuer Warning- und Errorfile            **
**********************************************************************/

_SCORING_EXPORT void lkf_plaus_WriteWEHeader (LKF_CONTEXT *pContext, FILE *err, FILE *warn, unsigned int kanr, const char *input_file)
{
	if (err) lkf_plaus_WriteFileHeader (pContext, err, LKF_FILE_ERROR, kanr, input_file, 0);
	if (warn) lkf_plaus_WriteFileHeader (pContext, warn, LKF_FILE_WARNING, kanr, input_file, 0);
}

/* procedure Plaus_WriteWEFooter **************************************
**     Erzeugt die Headerfiles fuer Warning- und Errorfile            **
**********************************************************************/

_SCORING_EXPORT void lkf_plaus_WriteWEFooter (LKF_CONTEXT *pContext, FILE *err, FILE *warn, unsigned int kanr, const char *ausgabedatei)
{

	if (err) lkf_plaus_WriteFileFooter (pContext, err, LKF_FILE_ERROR, kanr, ausgabedatei, 0);
	if (warn) lkf_plaus_WriteFileFooter (pContext, warn, LKF_FILE_WARNING, kanr, ausgabedatei, 0);
}

#endif

/* lkf_plaus_WriteFileHeader (V7.0) ***********************************
**      Schreibt den Header f\xc3\xbc""r Error-, Warning- und Meldediag-File  **
**********************************************************************/

_SCORING_EXPORT void lkf_plaus_WriteFileHeader (LKF_CONTEXT *pContext, FILE *fp, unsigned int filenr, unsigned int kanr, const char *ausgabedatei, void *additional)
{
	char buf[1024];
    char utf8buf[512];
	time_t tim;					/* Datentyp zur Ermittlung von akt. Uhrzeit und Datum */
	struct tm *tm;				/* Struktur fuer akt. Uhrzeit und Datum */
	char ka_text[32];			/* Text zur Krankenanstalt V14.2:  24->32 */
	const char *ka;

	ka = pContext->ka[kanr].ka;
	lkf_KA_to_Name (pContext, ka, ka_text);
	tim = time (0);
	tm = localtime (&tim);

	switch (filenr) {
	
		case LKF_FILE_ERROR:
			sprintf (buf, "LKF%4d    ;            ;            ;        ;            ;            ;", pContext->modelljahr);
			fprintf (fp,  "%s          ;             ;           ; %4.4s %20.20s\n", buf, ka, ka_text);
			sprintf (buf, "           ;            ;            ;        ;            ;            ;");
			fprintf (fp,  "%s          ;             ;           ; Eingabedatei:%s\n", buf, ausgabedatei);
			sprintf (buf, "%02d.%02d.%04d ; %02d:%02d      ;            ;        ;            ;            ;", tm->tm_mday, tm->tm_mon + 1, tm->tm_year + 1900, tm->tm_hour, tm->tm_min);
			fprintf (fp,  "%s          ;             ;           ; Fehlerprotokoll %s\n", buf, lkf_context_formatted_text (pContext, "(nicht scoref\xc3\xa4""hige F\xc3\xa4""lle)", utf8buf));
			sprintf (buf, "           ;            ;            ;        ;            ;            ;");
			fprintf (fp,  "%s          ;             ;           ;\n", buf);
			sprintf (buf, "KANR       ; AUFZAHL    ; GEBDAT     ; GESCHL ; AUFDAT     ; ENTDAT     ; ENTABT   ; ");
			fprintf (fp,  "%sWERT        ; ERRORCODE ; KOMMENTAR\n", buf);
			break;
		case LKF_FILE_WARNING:
			sprintf (buf, "LKF%4d    ;            ;            ;        ;            ;            ;", pContext->modelljahr);
			fprintf (fp, "%s          ;           ;             ;           ; %4.4s %20.20s\n", buf, ka, ka_text);
			sprintf (buf, "           ;            ;            ;        ;            ;            ;");
			fprintf (fp, "%s          ;           ;             ;           ; Eingabedatei:%s\n", buf, ausgabedatei);
			sprintf (buf, "%02d.%02d.%04d ; %02d:%02d      ;            ;        ;            ;            ;", tm->tm_mday, tm->tm_mon + 1, tm->tm_year + 1900, tm->tm_hour, tm->tm_min);
			fprintf (fp, "%s          ;           ;             ;           ; Warnungsprotokoll %s\n", buf, lkf_context_formatted_text (pContext, "(scoref\xc3\xa4""hige F\xc3\xa4""lle)", utf8buf));
			sprintf (buf, "           ;            ;            ;        ;            ;            ;");
			fprintf (fp, "%s          ;           ;             ;           ;\n", buf);
			sprintf (buf, "KANR       ; AUFZAHL    ; GEBDAT     ; GESCHL ; AUFDAT     ; ENTDAT     ; ENTABT   ; ");
			fprintf (fp, "%sMASSNAHME ; WERT        ; WARNCODE  ; KOMMENTAR\n", buf);
			break;
		case LKF_FILE_ABT:
			fprintf (fp, "LKF%4d    ;          ;        ;        ; %4.4s %20.20s\n", pContext->modelljahr, ka, ka_text);
			fprintf (fp, "           ;          ;        ;        ;\n");
			fprintf (fp, "%02d.%02d.%04d ; %02d:%02d    ;        ;        ; Abteilungsergebnis\n", tm->tm_mday, tm->tm_mon + 1, tm->tm_year + 1900, tm->tm_hour, tm->tm_min);
			fprintf (fp, "           ;          ;        ;        ;\n");
			fprintf (fp, "KANR       ; ABTFC    ; PATANZ ; ERRANZ ; BDGES\n");
			break;
		case LKF_FILE_MELDEDIAG:
			if (pContext->modelljahr >= 2017) {
				fprintf(fp, "LKF%4d    ;              ;            ; %4.4s %20.20s\n", pContext->modelljahr, ka, ka_text);
				fprintf(fp, "           ;              ;            ;\n");
				fprintf(fp, "%02d.%02d.%04d ; %02d:%02d        ;            ; Meldepflichtige Diagnosen\n", tm->tm_mday, tm->tm_mon + 1, tm->tm_year + 1900, tm->tm_hour, tm->tm_min);
				fprintf(fp, "           ;              ;            ;\n");
				fprintf(fp, "KANR       ; AUFZAHL      ; DIAGNOSE   ; KOMMENTAR\n");
				break;
			}
			
			fprintf (fp, "LKF%4d    ;            ;            ; %4.4s %20.20s\n", pContext->modelljahr, ka, ka_text);
			fprintf (fp, "           ;            ;            ;\n");
			fprintf (fp, "%02d.%02d.%04d ; %02d:%02d      ;            ; Meldepflichtige Diagnosen\n", tm->tm_mday, tm->tm_mon + 1, tm->tm_year + 1900, tm->tm_hour, tm->tm_min);
			fprintf (fp, "           ;            ;            ;\n");
			fprintf (fp, "KANR       ; AUFZAHL    ; DIAGNOSE   ; KOMMENTAR\n");
			break;
		default:
			break;
	}

}

/* lkf_plaus_WriteFileFooter (V7.0) ******************************************
**      Schreibt die Abschlu\xc3\x9f""zeilen f\xc3\xbc""r Error-, Warning- und Meldediag-File **
*****************************************************************************/

_SCORING_EXPORT void lkf_plaus_WriteFileFooter (LKF_CONTEXT *pContext, FILE *fp, unsigned int filenr, unsigned int kanr, const char *ausgabedatei, void *additional)
{
	char buf[1024];


	switch (filenr) {
	
		case LKF_FILE_ERROR:
			sprintf (buf, "   ;            ;            ;        ;            ;            ;");
			fprintf (fp, "        %s          ;             ;           ;        \n", buf);
			fprintf (fp, "Ergebnis%s          ;             ;           ; %ld Fehler/ %ld akzeptierte Fehler/ %d Gepr\xc3\xbc""fte F\xc3\xa4""lle\n", buf, 
					pContext->ka[kanr].error_anz, pContext->ka[kanr].akerr_anz, pContext->ka[kanr].anz);
			if (ausgabedatei) fprintf (fp, "        %s          ;             ;           ;\n", buf);
			break;
		case LKF_FILE_WARNING:
			sprintf (buf, "   ;            ;            ;        ;            ;            ;");
			fprintf (fp, "        %s          ;           ;             ;           ;\n", buf);
			fprintf (fp, "Ergebnis%s          ;           ;             ;           ; %ld Warnungen/ %ld akzeptierte Warnungen/ %d Gepr\xc3\xbc""fte F\xc3\xa4""lle\n", 
					 buf, pContext->ka[kanr].warning_anz, pContext->ka[kanr].akwarn_anz, pContext->ka[kanr].anz);
			if (ausgabedatei) fprintf (fp, "        %s          ;           ;             ;           ;\n", buf);
			break;
		case LKF_FILE_ABT:
			{
				STAT_KA *pKA;
				unsigned int i;
				const char *ka;
				pKA = pContext->ka + kanr;
				ka = pKA->ka;
				for (i = 0; i < pKA->abt_gesamt; i++) 
					fprintf (fp, "%4.4s       ; %8.8s ; %6d ; %6d ; %7d\n",
								ka, pKA->abt[i].abt_fc, pKA->abt[i].abt_patanz, 
									pKA->abt[i].abt_error, pKA->abt[i].abt_bd); 
			}
			break;

		case LKF_FILE_MELDEDIAG:
			break; /* no foot lines */
		default:
			break;
	}

}


/* procedure Plaus_WriteAbtHeader *************************************
**     Erzeugt den Header des Abteilungsfiles                        **
****** V2.1 **********************************************************/

_SCORING_EXPORT void lkf_plaus_WriteAbtHeader (LKF_CONTEXT *pContext, FILE *abt, unsigned int kanr)
{
	lkf_plaus_WriteFileHeader (pContext, abt, LKF_FILE_ABT, kanr, "", 0);
}

/* procedure Plaus_WriteAbtFooter ***************************************
**     Erzeugt die Statistikinformation der einzelnen Abteilungen im   **
**     Abteilungsfile.                                                 **
****** V2.1 ************************************************************/

_SCORING_EXPORT void lkf_plaus_WriteAbtFooter (LKF_CONTEXT *pContext, FILE *f_abt, unsigned int kanr)
{
	lkf_plaus_WriteFileFooter (pContext, f_abt, LKF_FILE_ABT, kanr, "", 0);
}



/* function lkf_plaus_GetErrorText4 *************************************
**     Liefert einen Errortext des letzten Durchlaufs zur\xc3\xbc""ck. Die in   **
**     pAufenthalt \xc3\xbc""bergebene Adresse mu\xc3\x9f"" zum Zeitpunkt des Aufrufs der   **
**     Funktion noch auf den \xc3\xbc""berpr\xc3\xbc""ften Patientenrecord zeigen.       **
** Parameter:														   **
**	   nr:		Nummer des Errortexts                                  **
**     text:    Der Errortext wird zur\xc3\xbc""ckgeliefert                     **
**     len:     L\xc3\xa4""nge des Buffers - dieser wird mit Leerzeichen        **
**              auf diese L\xc3\xa4""nge aufgef\xc3\xbc""llt                             **
** Return:															   **
**     1 bei zur\xc3\xbc""ckgeliefertem Fehler, 0 wenn nr nicht im g\xc3\xbc""ltigen     **
**     Intervall (siehe Plaus_GetError) liegt.                         **
************************************************************************/

_SCORING_EXPORT int lkf_plaus_GetErrorText4 (LKF_AUFENTHALT *pAufenthalt, const LKF_ERROR_LIST *pError, char *errortext, char *errorfield)
{
	if (pError->nNewError >= 0) {
        const char *pBuf;
		LKF_SATZART_ERROR *pSatzartError = pAufenthalt->pScoringContext->pSatzartErrors->pErrors + pError->nNewError;
		lkf_getErrorMBDSField (pAufenthalt, pSatzartError, errorfield, 20);
        pBuf = lkf_context_formatted_text(pAufenthalt->pScoringContext, pSatzartError->pErrorDef->sText, errortext);
        if (pBuf != errortext)
            strcpy (errortext, pBuf);
	}
	else {
        strcpy(errortext, "unknown error");
        errorfield[0] = 0;
        return 0;
    }

	return 1;
}

/* function lkf_plaus_GetWarningText4 ***********************************
**     Liefert nur den Warningtext und den Wert des Feldes, in dem die **
**     Warning passiert ist.                                           **
************************************************************************/

_SCORING_EXPORT int lkf_plaus_GetWarningText4 (LKF_AUFENTHALT *pAufenthalt, const LKF_ERROR_LIST *pWarning, char *warningtext, char *warningfield)
{
	if (pWarning->nNewError >= 0) {
        const char *pBuf;
		LKF_SATZART_ERROR *pSatzartError = pAufenthalt->pScoringContext->pSatzartErrors->pErrors + pWarning->nNewError;
		lkf_getErrorMBDSField (pAufenthalt, pSatzartError, warningfield, 20);		
        pBuf = lkf_context_formatted_text(pAufenthalt->pScoringContext, pSatzartError->pErrorDef->sText, warningtext);
        if (pBuf != warningtext)
            strcpy (warningtext, pBuf);
	}
	else {
        strcpy(warningtext, "unknown error");
        warningfield[0] = 0;
        return 0;
	}
	return 1;
}

/*********************************************************************
** lkf_getPlausWarningErrorDef (V8.1):                              **
**     Retourniert die ErrorDef-Strukturen zu den NP-Plaus-Errors   **
*********************************************************************/

const LKF_SATZART_ERRORDEF *lkf_getPlausNPWarningErrorDef (int warncode)
{
	switch (warncode) 
	{
		default:
		case NPPLAUS_WARNING:		return &LKFErrorNPfehlt;
		case NPPLAUS_NUR_UEB:		return &LKFErrorNPUeberwachung;
		case NPPLAUS_7299:			return &LKFErrorNP7299;
		case NPPLAUS_NUR_NEON:		return &LKFErrorNPAlter;
		case NPPLAUS_MELOHNEDAT:	return &LKFErrorNPPlausMELOhneDatum;

	}
}

/* Custom MEL Checks */

static int checkfunc_zn410 (LKF_AUFENTHALT *pAufenthalt, unsigned int melIndex, int nMelAbtIndex) {
    //&LKFErrorZN410OpMel
    return !HasOpMel(pAufenthalt);
}

static int checkfunc_an011 (LKF_AUFENTHALT *pAufenthalt, unsigned int melIndex, int nMelAbtIndex) {
    // &LKFErrorAN011VW
    return (pAufenthalt->GESVD_KORR + pAufenthalt->GESVD  < 2);
}

static int checkfunc_eb040 (LKF_AUFENTHALT *pAufenthalt, unsigned int melIndex, int nMelAbtIndex) {
    // &LKFErrorEB040
    return !HasEBDiag(pAufenthalt);
}

static int checkfunc_zn173 (LKF_AUFENTHALT *pAufenthalt, unsigned int melIndex, int nMelAbtIndex) {
    unsigned int i;
    for (i = 0; i < pAufenthalt->mel_anz; i++) {
        if (i != melIndex && (!memcmp (pAufenthalt->mel[i].MEL, "ZN171", 5) ||
                              !memcmp (pAufenthalt->mel[i].MEL, "ZN172", 5) ||
                              !memcmp (pAufenthalt->mel[i].MEL, "ZN180", 5))) {
            return 0;
        }
    }
    return 1;
}

static int checkfunc_dd020 (LKF_AUFENTHALT *pAufenthalt, unsigned int melIndex, int nMelAbtIndex) {
    unsigned int i;
    for (i = 0; i < pAufenthalt->mel_anz; i++) {
        if (i != melIndex && (!memcmp (pAufenthalt->mel[i].MEL, "DD010", 5))) {
            return 0;
        }
    }
    return 1;
}

static int checkfunc_hm070 (LKF_AUFENTHALT *pAufenthalt, unsigned int melIndex, int nMelAbtIndex) {
    unsigned int i;
    for (i = 0; i < pAufenthalt->mel_anz; i++) {
        if (i != melIndex && (!memcmp (pAufenthalt->mel[i].MEL, "HM060", 5))) {
            return 0;
        }
    }
    return 1;
}

static LKF_MEL_CUSTOM_CHECK checkZN410 = {checkfunc_zn410, &LKFErrorZN410OpMel, 0},
                        checkAN011 = {checkfunc_an011, &LKFErrorAN011VW, 0},
                        checkEB040 = {checkfunc_eb040, &LKFErrorEB040, 0},
                        checkZN173 = {checkfunc_zn173, &LKFErrorZN173, 0},
                        checkDD020 = {checkfunc_dd020, &LKFErrorDD020, 0},
                        checkHM070 = {checkfunc_hm070, &LKFErrorHM070, 0};


static MEL_CUSTOM_CHECKFUNCTION_DESCRIPTION checkfunctions[] = {
    { checkfunc_zn410, "Aufenthalt hat keine OP-MEL" },
    { checkfunc_an011, "Gesamtverweildauer < 2 Tage" },
    { checkfunc_eb040, "Keine EB-Diagnosen (211.x und 215.x) vorhanden" },
    { checkfunc_zn173, "ZN170/ZN171/ZN180 nicht gemeldet" },
    { checkfunc_dd020, "DD010 nicht gemeldet" },
    { checkfunc_hm070, "HM060 nicht gemeldet" }
};


const char *lkf_get_function_Description (int (*checkFunction)(LKF_AUFENTHALT *, unsigned int i, int nMelAbtIndex)) {
    unsigned int i;
    unsigned int count = sizeof(checkfunctions) / sizeof (MEL_CUSTOM_CHECKFUNCTION_DESCRIPTION);
    for (i = 0; i < count; i++) {
        if (checkfunctions[i].checkFunction == checkFunction) {
            return checkfunctions[i].description;
        }
    }
    return 0;
}

typedef struct ADD_CUSTOM_MEL_CHECK {
    const char *mel;
    const char *maxMel;
    const LKF_MEL_CUSTOM_CHECK *pCheck;
    unsigned int previousYear;
    struct ADD_CUSTOM_MEL_CHECK *pPrevious;
} ADD_CUSTOM_MEL_CHECK;

static ADD_CUSTOM_MEL_CHECK melChecks2025[] = {
    {"ZN410", 0, &checkZN410 },
    {"AN011", 0, &checkAN011 },
    {"EB040", 0, &checkEB040 },
    {"EB060", 0, &checkEB040 },
    {"ZN173", 0, &checkZN173, 2025, 0 },
    {"ZN174", 0, &checkZN173, 2025, 0 },
    {"DD020", "DD120", &checkDD020, 2025, 0 },
    {"XN120", 0, &checkDD020, 2025, 0 },
    {"HM070", 0, &checkHM070, 2025, 0 },
    {"HM080", 0, &checkHM070, 2025, 0 }
};

void apply_custom_melChecks (STAMM2001 *pStamm) {
    unsigned int i;
    unsigned checkSize;
    ADD_CUSTOM_MEL_CHECK *pChecks;
    MEL_ARRAY_STRUC *pStruc;
    
    if (pStamm->nModellJahr < 2025) {
        return;
    }
    
    checkSize = sizeof(melChecks2025) / sizeof(ADD_CUSTOM_MEL_CHECK);
    pChecks = melChecks2025;
    
    for (i = 0; i < checkSize; i++) {
        
        ADD_CUSTOM_MEL_CHECK *pCheck = pChecks + i;
        
        if (pCheck->previousYear && pCheck->previousYear >= pStamm->nModellJahr) {
            pCheck = pCheck->pPrevious;
            while (pCheck && pCheck->previousYear >= pStamm->nModellJahr) {
                pCheck = pCheck->pPrevious;
            }
            if (!pCheck) {
                continue;
            }
        }
        
        pStruc = FindMelStamm(pStamm, pCheck->mel);
        
        if (pCheck->maxMel == 0) {
            if (!pStruc) {
                continue;
            }
            pStruc->pCustomCheck = pCheck->pCheck;
        }
        else {
            MEL_ARRAY_STRUC *pMaxStruc = FindMelStamm(pStamm, pCheck->maxMel);
            if (!pMaxStruc) {
                int melIndex = FindMelIndexStammWeak (pStamm, pCheck->maxMel, 1);
                if (melIndex >= 0) pMaxStruc = pStamm->mel_array + melIndex;
            }
            if (!pStruc) {
                int melIndex = FindMelIndexStammWeak (pStamm, pCheck->mel, 0);
                if (melIndex >= 0) pMaxStruc = pStamm->mel_array + melIndex;
            }
            if (!pStruc || !pMaxStruc) {
                continue;
            }
            for (; pStruc <= pMaxStruc; pStruc++) {
                pStruc->pCustomCheck = pCheck->pCheck;
            }
        }
    }
}
