/****************************************************************************
** Leistungsorientierte Krankenanstaltenfinanzierung (LKF)                 **
** Scoring-C-Sourcen V2026.1                                               **
** (C) 2026 BMASGPK                                                        **
*****************************************************************************
** lkfstru5.c - Routinen zum Zugriff auf zusaetzliche Satzarten ab 2004    **
**                                                                         **
**		 Alex.Holzer@chello.at                                             **
**       Bernhard.Pesec@dothealth.at                                       **
***************************************************************************/

#include "lkfint5.h"
#include "lkfstru5.h"

#define DOUBLE_0_VALUE 0.000001

static void lkf_trace_int (LKF_CHECK_CONTEXT *pCheckContext, const char *sLine, int nSeverity)
{

	char sAbtFC[10];
	char sTraceLine[1024];

	if (!pCheckContext)
		return;

	if (pCheckContext->nAbtIndex >= 0)
		sprintf (sAbtFC, "%8.8s", pCheckContext->pAufenthalt->abt[pCheckContext->nAbtIndex].ABTFC);
	else
		sAbtFC[0] = 0;

	if (pCheckContext->pCurrentCheck && pCheckContext->pCurrentCheck->pErrorDef)
	{
		char sErrorCode[6];
		lkf_getErrorIdent (pCheckContext->pContext, pCheckContext->pCurrentCheck->pErrorDef, 6, sErrorCode);
		
		if (sLine)
			sprintf (sTraceLine, "%4.4s ; %s", sErrorCode, sLine);
		else
			sprintf (sTraceLine, "%4.4s ; error/warning: %s", sErrorCode, pCheckContext->pCurrentCheck->pErrorDef->sText);

		lkf_addTraceAbteilungLine (pCheckContext->pContext, sAbtFC, sTraceLine, LKF_FAC_INTSCOR, nSeverity);
	}
	else if (sLine)
	{
		sprintf (sTraceLine, "     ; %s", sLine);
		lkf_addTraceAbteilungLine (pCheckContext->pContext, sAbtFC, sTraceLine, LKF_FAC_INTSCOR, nSeverity);
	}
}

static void lkf_trace_kk (LKF_CHECK_CONTEXT *pCheckContext, const char *sLine, int nSeverity)
{
	char sAbtFC[12];
	char sTraceLine[1024];

	if (!pCheckContext)
		return;

	if (pCheckContext->pKKContext && pCheckContext->pKKContext->pAktAbteilung)
	{
		switch (pCheckContext->pKKContext->nCurrentCheckSatzart)
		{
			case  0:
			case  7:
			case  8:
			case  9:
				strncpy (sAbtFC, pCheckContext->pKKContext->pAktAbteilung->sAbtFC, 8);
				sAbtFC[8] = 0;
			default:
				sAbtFC[0] = 0;
				break;
		}
	}
	else
		sAbtFC[0] = 0;

	if (pCheckContext->pCurrentCheck && pCheckContext->pCurrentCheck->pErrorDef)
	{
		char sErrorCode[6];
		lkf_getErrorIdent (pCheckContext->pContext, pCheckContext->pCurrentCheck->pErrorDef, 6, sErrorCode);
		
		if (sLine)
			sprintf (sTraceLine, "%4.4s ; %s", sErrorCode, sLine);
		else
			sprintf (sTraceLine, "%4.4s ; error/warning: %s", sErrorCode, pCheckContext->pCurrentCheck->pErrorDef->sText);

		lkf_addTraceAbteilungLine (pCheckContext->pContext, sAbtFC, sTraceLine, LKF_FAC_KAS_KORE, nSeverity);
	}
	else if (sLine)
	{
		sprintf (sTraceLine, "     ; %s", sLine);
		lkf_addTraceAbteilungLine (pCheckContext->pContext, sAbtFC, sTraceLine, LKF_FAC_KAS_KORE, nSeverity);
	}
}

static void lkf_trace_kk_info (LKF_CHECK_CONTEXT *pCheckContext, const char *sLine)
{
	lkf_trace_kk (pCheckContext, sLine, LKF_TRACE_INFO);
}

static void lkf_trace_kk_detail (LKF_CHECK_CONTEXT *pCheckContext, const char *sLine)
{
	lkf_trace_kk (pCheckContext, sLine, LKF_TRACE_DETAIL);
}

static void lkf_trace_int_info (LKF_CHECK_CONTEXT *pCheckContext, const char *sLine)
{
	lkf_trace_int (pCheckContext, sLine, LKF_TRACE_INFO);
}

static void lkf_trace_int_detail (LKF_CHECK_CONTEXT *pCheckContext, const char *sLine)
{
	lkf_trace_int (pCheckContext, sLine, LKF_TRACE_DETAIL);
}

/* Error-Codes */

static const LKF_SATZART_ERROR_PROPERTIES
LKFErrorNurFonds = {1, 0, 0, 0},
LKFErrorIgnore = {0, 0, 0, 0},
LKFErrorAb2018 = {1, 1, 2017, &LKFErrorIgnore},                   /* V2019.0 */
LKFErrorAb2014 = {1, 1, 2013, &LKFErrorIgnore},                   /* V17.1 */
LKFErrorAb2012 = {1, 1, 2011, &LKFErrorIgnore};                   /* V17.0 */

const LKF_SATZART_ERRORDEF
	LKFErrorKAfalsch =			    {800, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Krankenanstaltennummer ung\xc3\xbc""ltig"},
	LKFErrorKAfehlt =			    {801, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Krankenanstaltennummer fehlt"},
	LKFErrorFCfalsch =			    {802, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Funktionscode ung\xc3\xbc""ltig"},
	LKFErrorFCfehlt =			    {803, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Funktionscode fehlt"},
	LKFErrorFCnichtimKostPlan =		{804, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Funktionscode nicht im Kostenstellenplan enthalten"},
	LKFErrorKAmultibel =			{805, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Mehrere Krankenanstaltennummern in Datenmeldung enthalten"},
/*	LKFErrorSatzartReihenfolge =	{806, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzartreihenfolge ung\xc3\xbc""ltig"}, */
	LKFErrorSatzartFehlt =			{807, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzart fehlt"},
	LKFErrorM01AUFNRmehrfach =		{808, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzart M01 - Aufnahmezahl mehrfach"},
	LKFErrorM02PosMehrfach =		{809, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzart M02 - Positionsnummer bei einem Aufenthalt mehrfach vergeben"},
	LKFErrorM05FCmehrfach =			{810, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzart M05 - Aufnahmezahl mehrfach"},
	LKFErrorM06FCmehrfach =			{811, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzart M06 - Aufnahmezahl mehrfach"},
	LKFErrorM08FCmehrfach =			{812, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzart M08 - Aufnahmezahl mehrfach"},
	LKFErrorSatzartKZfalsch =		{813, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzartenkennzeichen ung\xc3\xbc""ltig"},
	LKFErrorSatzartKZfehlt =		{814, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzartenkennzeichen fehlt"},
	LKFErrorM01fehlt =				{815, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlender Datensatz M01"},
	LKFErrorM02fehlt =				{816, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlender Datensatz M02"},
	LKFErrorK01fehlt =				{817, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlender Datensatz K01"},
	LKFErrorG01fehlt =				{818, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlender Datensatz G01"},
	LKFErrorK08fehlt =				{819, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlende Datenmeldung M02 und K08"},
    LKFErrorX01fehlt =				{815, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlender Datensatz X01"},
    LKFErrorX02fehlt =				{816, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlender Datensatz X02"},
    LKFErrorX01AUFNRmehrfach =		{808, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzart X01 - Aufnahmezahl mehrfach"},
    LKFErrorX02PosMehrfach =		{809, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzart X02 - Positionsnummer bei einem Aufenthalt mehrfach vergeben"},
    LKFErrorX05FCmehrfach =			{811, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzart X05 - Aufnahmezahl mehrfach"},
    LKFErrorX07FCmehrfach =			{812, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Satzart X07 - Aufnahmezahl mehrfach"},
    LKFErrorK08fehlt2017 =			{819, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlende Datenmeldung X02 und K08"},
    LKFErrorFormat =                {820, LKF_FAC_ALL,     LKF_SEV_FATAL, 0, 0, "Formatfehler - zu langer Feldwert"},
    LKFErrorSPEZAbt =               {825, LKF_FAC_ALL,     LKF_SEV_FATAL, 0, 0, "Abteilung mehrfach in L01", &LKFErrorAb2018},
    LKFErrorSPEZAbt2024 =           {825, LKF_FAC_ALL,     LKF_SEV_FATAL, 0, 0, "SPEZLIST-Eintrag mehrfach gemeldet"};

static const LKF_SATZART_ERRORDEF *ppGeneralErrors[] =
	{&LKFErrorKAfalsch, &LKFErrorKAfehlt, &LKFErrorFCfalsch, &LKFErrorFCfehlt, &LKFErrorFCnichtimKostPlan,
	 &LKFErrorKAmultibel,  /*&LKFErrorSatzartReihenfolge, V9.1 */ &LKFErrorSatzartFehlt, &LKFErrorM01AUFNRmehrfach, &LKFErrorM02PosMehrfach, 
	 &LKFErrorM05FCmehrfach, &LKFErrorM06FCmehrfach, &LKFErrorM08FCmehrfach, &LKFErrorSatzartKZfalsch, &LKFErrorSatzartKZfehlt,
	 &LKFErrorM01fehlt, &LKFErrorM02fehlt, &LKFErrorK01fehlt, &LKFErrorK08fehlt, 0};

static const LKF_SATZART_ERRORDEF *ppGeneralErrors2017[] =
{&LKFErrorKAfalsch, &LKFErrorKAfehlt, &LKFErrorFCfalsch, &LKFErrorFCfehlt, &LKFErrorFCnichtimKostPlan,
    &LKFErrorKAmultibel,  /*&LKFErrorSatzartReihenfolge, V9.1 */ &LKFErrorSatzartFehlt, &LKFErrorX01AUFNRmehrfach, &LKFErrorX02PosMehrfach,
    &LKFErrorX05FCmehrfach, &LKFErrorX07FCmehrfach, &LKFErrorSatzartKZfalsch, &LKFErrorSatzartKZfehlt,
    &LKFErrorX01fehlt, &LKFErrorX02fehlt, &LKFErrorK01fehlt, &LKFErrorK08fehlt2017, &LKFErrorFormat, 0};

const LKF_SATZART_ERRORDEF
	LKFErrorBHKPosFehlt =		{  1, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Bettenf\xc3\xbc""hrende Hauptkostenstelle - Positionsnummer fehlt"},
	LKFErrorErhebDatFehlt =		{  2, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Erhebungsdatum fehlt"},
	LKFErrorErhebDatFalsch =	{  3, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Erhebungsdatum falsch"},
	LKFErrorErhebDatAussAuf =   {  4, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Erhebungsdatum au\xc3\x9f""erhalb des Abteilungsaufenthalts"},
	LKFErrorErhebDatIdent =     {  5, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Daten mit identem Erhebungsdatum mehrfach gemeldet"},
	LKFErrorSIIndikator =       {  6, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "SI-Indikator ung\xc3\xbc""ltig"},
	LKFErrorAtmungsmodus =      {  8, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Atmungsmodus ung\xc3\xbc""ltig"},
	LKFErrorBlutbildLeukozyten ={  9, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Blutbild - Leukozyten ung\xc3\xbc""ltig"},
	LKFErrorGCSmotReak =        { 10, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Glasgow Coma Scale - motorische Reaktion ung\xc3\xbc""ltig"},
	LKFErrorGCSverbReak =       { 11, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Glasgow Coma Scale - verbale Reaktion ung\xc3\xbc""ltig"},
	LKFErrorGCSvisReak =        { 12, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Glasgow Coma Scale - visuelle Reaktion ung\xc3\xbc""ltig"},
	LKFErrorHarn =              { 13, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Harn - Volumen in 24h ung\xc3\xbc""ltig"},
	LKFErrorHerzfrequenz =      { 14, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Herzfrequenz ung\xc3\xbc""ltig"},
	LKFErrorSauerstoffkonz =    { 15, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Sauerstoffkonzentration inspiratorisch ung\xc3\xbc""ltig"},
	LKFErrorKoerpertemp =       { 16, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "K\xc3\xb6""rpertemperatur ung\xc3\xbc""ltig"},
	LKFErrorSAPSIIPulmonaliskath={17, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "SAPSII - Pulmonaliskatheter ung\xc3\xbc""ltig"},
	LKFErrorSerumBikarbonat =   { 18, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Serum - Bikarbonat ung\xc3\xbc""ltig"},
	LKFErrorSerumBilirubin  =   { 19, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Serum - Gesamt-Bilirubin ung\xc3\xbc""ltig"},
	LKFErrorSerumHarnstoff =    { 20, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Serum - Harnstoff ung\xc3\xbc""ltig"},
	LKFErrorSerumHarnstoffN =   { 21, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Serum - Harnstoff-N ung\xc3\xbc""ltig"},
	LKFErrorSerumKalium =       { 22, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Serum - Kalium ung\xc3\xbc""ltig"},
	LKFErrorSerumNatrium =      { 23, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Serum - Natrium ung\xc3\xbc""ltig"},
	LKFErrorSystArtBlutdruck =  { 24, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Systolischer arterieller Blutdruck ung\xc3\xbc""ltig"},
	LKFErrorStandardMonitoring ={ 25, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Standard-Monitoring ung\xc3\xbc""ltig"},
	LKFErrorLabor =             { 26, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Labor ung\xc3\xbc""ltig"},
	LKFErrorMedEinmalig =       { 27, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Medikation einmalig ung\xc3\xbc""ltig"},
	LKFErrorMedMehrfach =       { 28, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Medikation mehrfach ung\xc3\xbc""ltig"},
	LKFErrorRoutineverbandsw =  { 29, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Routineverbandswechsel ung\xc3\xbc""ltig"},
	LKFErrorVerbandswHaeufig =  { 30, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Verbandswechsel h\xc3\xa4""ufig ung\xc3\xbc""ltig"},
	LKFErrorDrainagenpflege =   { 31, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Drainagenpflege ung\xc3\xbc""ltig"},
	LKFErrorBeatmungMech =      { 32, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Beatmung mechanisch ung\xc3\xbc""ltig"},
	LKFErrorAtemunterstuetzung ={ 33, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Atemunterst\xc3\xbc""tzung ung\xc3\xbc""ltig"},
	LKFErrorTubuspflege =       { 34, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Tubuspflege ung\xc3\xbc""ltig"},
	LKFErrorAtemtherapie =      { 35, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Atemtherapie ung\xc3\xbc""ltig"},
	LKFErrorMedVasoEinmalig =   { 36, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Medikation vasoaktiv - einmalig ung\xc3\xbc""ltig"},
	LKFErrorMedVasoMehrfach =   { 37, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Medikation vasoaktiv - mehrfach ung\xc3\xbc""ltig"},
	LKFErrorFluessigkeitsers =  { 38, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Fl\xc3\xbc""ssigkeitsersatz massiv ung\xc3\xbc""ltig"},
	LKFErrorKatheterArteriell = { 39, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Katheter arteriell ung\xc3\xbc""ltig"},
	LKFErrorPulmunalisKath =    { 40, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Pulmonaliskatheter ung\xc3\xbc""ltig"},
	LKFErrorKathZentralvenoes = { 41, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Katheter zentralven\xc3\xb6""s ung\xc3\xbc""ltig"},
	LKFErrorReanimationKardio = { 42, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Reanimation kardiopulmonal ung\xc3\xbc""ltig"},
	LKFErrorNierenErsatzTher =  { 43, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Nierenersatztherapie ung\xc3\xbc""ltig"},
	LKFErrorHarnbilanzierung =  { 44, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Harnbilanzierung ung\xc3\xbc""ltig"},
	LKFErrorDiurese =           { 45, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Diurese aktiv ung\xc3\xbc""ltig"},
	LKFErrorHirndruckmessung =  { 46, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Hirndruckmessung ung\xc3\xbc""ltig"},
	LKFErrorBehMetabolEntgl =   { 47, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Behandlung metabolischer Entgleisungen ung\xc3\xbc""ltig"},
	LKFErrorErnaehrungEnteral = { 48, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Ern\xc3\xa4""hrung enteral ung\xc3\xbc""ltig"},
	LKFErrorErnaehrungParental ={ 49, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Ern\xc3\xa4""hrung parenteral ung\xc3\xbc""ltig"},
	LKFErrorInterventEinfach =  { 50, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Intervention einfach ung\xc3\xbc""ltig"},
	LKFErrorInterventMehrfach = { 51, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Intervention mehrfach ung\xc3\xbc""ltig"},
	LKFErrorDiagnostTherAuss =  { 52, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Diagnostik und Therapie ausserhalb der IBS ung\xc3\xbc""ltig"},
	LKFErrorAISAbdomen =        { 53, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "AIS - Abdomen ung\xc3\xbc""ltig"},
	LKFErrorAISExtern =         { 54, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "AIS - Extern ung\xc3\xbc""ltig"},
	LKFErrorAISExtremitaeten =  { 55, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "AIS - Extremit\xc3\xa4""ten ung\xc3\xbc""ltig"},
	LKFErrorAISGesicht =        { 56, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "AIS - Gesicht ung\xc3\xbc""ltig"},
	LKFErrorAISHalsKopf =       { 57, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "AIS - Hals/Kopf ung\xc3\xbc""ltig"},
	LKFErrorAISThorax =         { 58, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "AIS - Thorax ung\xc3\xbc""ltig"},
	LKFErrorAISTyp =            { 59, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "AIS - Typ ung\xc3\xbc""ltig"},
	LKFErrorGCSAufMotReak =     { 60, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Glasgow Coma Scale bei Aufnahme - motorische Reaktion ung\xc3\xbc""ltig"},
	LKFErrorGCSAufVerbReak =    { 61, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Glasgow Coma Scale bei Aufnahme - verbale Reaktion ung\xc3\xbc""ltig"},
	LKFErrorGCSAufVisReak =     { 62, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Glasgow Coma Scale bei Aufnahme - visuelle Reaktion ung\xc3\xbc""ltig"},
	LKFErrorSystArtBlutAuf =    { 63, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Systolischer arterieller Blutdruck bei Aufnahme ung\xc3\xbc""ltig"},
	LKFErrorAtemfrequenzAuf =   { 64, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Atemfrequenz bei Aufnahme ung\xc3\xbc""ltig"},
	LKFErrorSauerstoffPart =    { 65, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Sauerstoff-Partialdruck arteriell ung\xc3\xbc""ltig"},
	LKFErrorIntMix =			{ 66, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Mischen von I01/I02/I03 und I11/I12 nicht m\xc3\xb6""glich"}, /* V15.1 */
	LKFErrorAkuterInfekt =      { 67, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Akute Infektion bei Aufnahme ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorGrundAnderer =      { 68, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: Anderer, nicht klassifiziert ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorGrundBasisPflege =  { 69, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: Basispflege und Observanz ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorGrundGastro =       { 70, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: Gastrointestinal ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorGrundHaemat =       { 71, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: H\xc3\xa4""matologisch ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorGrundKardio =       { 72, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: Kardiovaskul\xc3\xa4""r ung\xc3\xbc""ltig"}, /* V15.1 */ 
	LKFErrorGrundLeber =        { 73, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: Leber ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorGrundMetabolisch =  { 74, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: Metabolisch ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorGrundNeuro =        { 75, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: Neurologisch ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorGrundRenal =        { 76, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: Renal ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorGrundRespi =        { 77, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: Respiratorisch ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorGrundTrauma =       { 78, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmegrund: Schweres Trauma ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorAufnahmeTyp =       { 79, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Aufnahmetyp ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorBlutbildLeuko2011 = { 80, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Blutbild: Leukozyten (Minimum) ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorBlutbildPH =        { 81, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Blutbild: pH-Wert ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorBlutbildThrombo =   { 82, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Blutbild: Thrombozyten (Minimum) ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorChirurgieEingriff = { 83, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Chirurgie - Eingriff ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorChirurgischerStatus = { 84, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Chirurgischer Status ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorKoexistErkrank =    { 85, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Koexistierende Erkrankungen ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorKoerpertemp2011 =   { 86, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "K\xc3\xb6""rpertemperatur ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorMechBeatmung =      { 87, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Mechanische Beatmung ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorSauerstoffPart2011 = {88, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Sauerstoff-Partialdruck arteriell ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorSauerstoffkonz2011 ={ 89, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Sauerstoffkonzentration inspiratorisch ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorSystArtBlutdruck2011 = { 90, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Systolischer Blutdruck (Minimum) ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorSerumBilirubin2011 ={ 91, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Serum: Bilirubin (Maximum) ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorSerumKreatinin =    { 92, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Serum: Kreatinin (Maximum) ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorSystBlutdruckMin =  { 93, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Systolischer Blutdruck (Minimum) ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorTheraepeutischeMN = { 94, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Therapeutische Ma\xc3\x9f""nahmen (vor IBS) ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorZutransferierung =  { 95, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Zutransferierung ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorMedikamente =		{ 96, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Medikamente ung\xc3\xbc""ltig"}, /* V15.1 */ 
	LKFErrorVerbandswechsel =	{ 97, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Verbandswechsel ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorAtmungsmodus2011 =  { 98, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Atmungsmodus ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorAtemwegszugang =	{ 99, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Atemwegszugang ung\xc3\xbc""ltig"}, /* V15.1 */ 
	LKFErrorMedikamenteVasoaktiv = {100, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Medikamente vasoaktiv ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorMonitoringHaemo =	{101, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Monitoring h\xc3\xa4""modynamisch ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorInterventionen =	{102, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Intervention ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorAgitation =			{103, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Agitation und Delirium ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorAssistKardial =		{104, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Assist kardial ung\xc3\xbc""ltig"}, /* V15.1 */ 
	LKFErrorAssistPulmonal =	{105, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Assist pulmonal ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorHypothermie =		{106, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Hypothermie therapeutisch ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorLeberSupport =		{107, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Lebersupport extrakorporal ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorAntikonvulsiveTherapie = {108, LKF_FAC_INTSCOR, LKF_SEV_ERROR, 0, 0, "Kontinuierliche intraven\xc3\xb6""se antikonvulsive Therapie ung\xc3\xbc""ltig"}, /* V15.1 */
	LKFErrorKombAtmung =        {109, LKF_FAC_INTSCOR, LKF_SEV_ERROR | LKF_SEV_ACCEPTABLE, 0, 0, "Kombination von Atmungsmodus und Atemwegszugang ung\xc3\xbc""ltig"}, /* V15.2 */
	LKFErrorTISS28unvollst =    {101, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "TISS28 - Tage unvollst\xc3\xa4""ndig"},
	LKFErrorSAPSII =            {102, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "SAPS II - Dokumentation f\xc3\xbc""r Zugangstag fehlt"},
	LKFErrorKombSAPSaufGCS =    {103, LKF_FAC_INTSCOR, LKF_SEV_WARNING | LKF_SEV_ACCEPTABLE, 0, 0, "Kombination SAPS-Aufnahmeart und GCS-Wert unplausibel"},
	LKFErrorKombSAPSmech =      {104, LKF_FAC_INTSCOR, LKF_SEV_WARNING | LKF_SEV_ACCEPTABLE, 0, 0, "Kombination SAPS-FiO2 und mechanische Ventilation unplausibel"},
	LKFErrorSerBimetabEntgl =   {105, LKF_FAC_INTSCOR, LKF_SEV_WARNING | LKF_SEV_ACCEPTABLE, 0, 0, "Kombination Serum-Bikarbonat nicht pathologisch und metabolische Entgleisung unplausibel"},
	LKFErrorKombMedikation =	{106, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "Kombination einmalige und mehrfache Medikation unplausibel"},
	LKFErrorKombAtemunterst =   {107, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "Kombination Atemunterst\xc3\xbc""tzung und mechanische Beatmung unplausibel"},
	LKFErrorKombvasoMed =		{108, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "Kombination einmalige und mehrfache vasoaktive Medikation unplausibel"},
	LKFErrorKombIntervent =     {109, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "Kombination einfache und mehrfache Intervention unplausibel"},
	LKFErrorTISS28ohneStdmon =  {110, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "TISS28-Tag ohne Standardmonitoring unplausibel"},
	LKFErrorSAPS3 =				{111, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "SAPS 3 - Dokumentation f\xc3\xbc""r Zugangstag fehlt"}, /* V15.1 */
	LKFErrorKombChirurgGCS =    {112, LKF_FAC_INTSCOR, LKF_SEV_WARNING | LKF_SEV_ACCEPTABLE, 0, 0, "Kombination chirurgischer Status und GCS-Wert unplausibel"}, /* V15.1 */
	LKFErrorKombSAPSAtmungsmodus = {113, LKF_FAC_INTSCOR, LKF_SEV_WARNING | LKF_SEV_ACCEPTABLE, 0, 0, "Kombination SAPS-FiO2 und Atmungsmodus unplausibel"}, /* V15.1 */
	LKFErrorTISSAunvollst =     {114, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "TISS-A - Tage unvollst\xc3\xa4""ndig"}, /* V15.1 */
	LKFErrorTISSAohneStdmon =   {115, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "TISS-A-Tag ohne Standardmonitoring unplausibel"}, /* V15.1 */
	LKFErrorKeinGrund =         {116, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "Kein SAPS3-Aufnahmegrund erhoben"}, /* 18.1 */ 
	LKFErrorKeinAufnahmeTyp =   {117, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "Aufnahmetyp nicht erhoben"}, /* 18.1 */ 
	LKFErrorKeinChirurgStatus = {118, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "Chirurgischer Status nicht erhoben"}, /* 18.1 */
LKFErrorZutransNichtErhoben = {119, LKF_FAC_INTSCOR, LKF_SEV_WARNING, 0, 0, "Zutransferierung nicht erhoben"}; /* V19.0 */

const LKF_SATZART_ERRORCHECK_INTRANGE
	LKF_INTRANGE_0_9990 = {0, 9990},
	LKF_INTRANGE_1_2 = {1,2},
	LKF_INTRANGE_1_6 = {1,6},
	LKF_INTRANGE_0_6 = {0,6},
	LKF_INTRANGE_1_5 = {1,5},
	LKF_INTRANGE_1_4 = {1,4},
	LKF_INTRANGE_0_50000 = {0,50000},
	LKF_INTRANGE_0_600 = {0,600},
	LKF_INTRANGE_0_100 = {0,100},
	LKF_INTRANGE_0_450 = {0,450},
	LKF_INTRANGE_0_1   = {0,1},
	LKF_INTRANGE_1_1   = {1,1},
	LKF_INTRANGE_0_990 = {0,990},
	LKF_INTRANGE_0_300 = {0,300},
	LKF_INTRANGE_50_200 = {50, 200},
	LKF_INTRANGE_0_2   = {0,2},      /* V15.1 */
	LKF_INTRANGE_0_3   = {0,3},      /* V15.1 */
	LKF_INTRANGE_1_3   = {1,3},      /* V18.1 */
	LKF_INTRANGE_0_4   = {0,4},      /* V15.1 */
	LKF_INTRANGE_0_5   = {0,5},      /* V15.1 */
	LKF_INTRANGE_0_7   = {0,7},      /* V15.1 */
    LKF_INTRANGE_1_7   = {1,7},      /* V19.0 */
	LKF_INTRANGE_0_12  = {0,12},     /* V15.1 */
	LKF_INTRANGE_0_42  = {0,42},     /* V15.1 */
	LKF_INTRANGE_10_100  = {10,100},     /* V15.1 */
	LKF_INTRANGE_0_400 = {0, 400},   /* V15.1 */
	LKF_INTRANGE_0_900  = {0,900},   /* V15.1 */
	LKF_INTRANGE_600_800 = {600,800},
	LKF_INTRANGE_0_5000 = {0, 5000};

	
static int intcheck_erhebdat_zeitraum (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int lAbt = (unsigned int) Satzart_GetValueDate (ds, len, pFeld);
	if ((pCheckContext->lAbtAufDat && lAbt < pCheckContext->lAbtAufDat) ||
		(pCheckContext->lAbtEntDat && lAbt > pCheckContext->lAbtEntDat)) return 1;
	else return 0;
}

static int intcheck_erhebdat_doppelt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int lAbt = (unsigned int) Satzart_GetValueDate (ds, len, pFeld);
	if (lAbt) {
		if (pCheckContext->lLetzteMeldung == lAbt) return 1;
		else pCheckContext->lLetzteMeldung = lAbt;
	}
	return 0;
}

static const SATZART_FELD Feld_Aufarten = {31, 0, 32, 12, 0, 0, 0, 0, 0};

static int intcheck_aufgrund (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V18.1 */
	unsigned int i;
    char aufgrundBuffer[20];
    
    if (pCheckContext->pContext->modelljahr >= 2017)
    { /* V21.2 */
        static unsigned int fields_to_check[] = {I11_AUFN_ANDERER, I11_AUFN_BASISPFLEGE_OBSERVANZ, I11_AUFN_GASTROINTESTINAL, I11_AUFN_HAEMATOLOGISCH, I11_AUFN_KARDIOVASKULAER,
            I11_AUFN_LEBER, I11_AUFN_METABOLISCH, I11_AUFN_NEUROLOGISCH, I11_AUFN_RENAL, I11_AUFN_RESPIRATORISCH, I11_AUFN_SCHWERESTRAUMA};
        
        const SATZART_INFO *pI11 = (pCheckContext->pContext->pSatzartDefs) ? pCheckContext->pContext->pSatzartDefs->ppI[11] : 0;
        if (!pI11) return 1;
        
        for (i = 0; i < 11; i++)
        {
            const SATZART_FELD *pFeld = pI11->ppRef[fields_to_check[i]];
            if (pFeld) {
                Satzart_GetValueStringExp((const LKF_EXPANDED_LINE *) ds, pFeld, aufgrundBuffer, 10);
                if (atoi(aufgrundBuffer)) return 0;
            }
        }
    }
    else {
        Satzart_GetValueString (ds, len, &Feld_Aufarten, aufgrundBuffer, 19);
        
        for (i = 0; i < Feld_Aufarten.nLen; i++) {
            if (aufgrundBuffer[i] && aufgrundBuffer[i] != '0' && aufgrundBuffer[i] != ' ') return 0;
        }
    }
    
	return 1;
}


static int intcheck_si_einheit (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	if (Satzart_GetValueInt (ds, len, pFeld, &pCheckContext->si_einheit) == LKF_FIELD_ERROR) return 1;

	if (pCheckContext->si_einheit != 1 && pCheckContext->si_einheit != 2) 
	{
		pCheckContext->si_einheit = 0;
		return 1;
	}
	else 
	{
		if (LKF_IS_TRACE_DETAIL (pCheckContext->pContext->nTraceAufenthaltIntScor))
		{
			char sTraceLine[1024];
			sprintf (sTraceLine, "SI-Einheit = %d", pCheckContext->si_einheit);
			lkf_trace_int_detail (pCheckContext, sTraceLine);
		}
		return 0;
	}
}

static int intcheck_gesamtbilirubin (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int gesamtbilirubin;
	if (Satzart_GetValueInt (ds, len, pFeld, &gesamtbilirubin) == LKF_FIELD_ERROR) return 1;
	
	if (pCheckContext->si_einheit != 2)
	{
		if (gesamtbilirubin < 0 || gesamtbilirubin > 2000) return 1;
	}
	else 
	{
		if (gesamtbilirubin < 0 || gesamtbilirubin > 34200) return 1;
	}
	return 0;
}

static int intcheck_sauerstoffpart (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int sauerstoffpart;
	if (Satzart_GetValueInt (ds, len, pFeld, &sauerstoffpart) == LKF_FIELD_ERROR) return 1;
	
	if (pCheckContext->si_einheit != 2)
	{
		if (sauerstoffpart < 0 || sauerstoffpart > 700) return 1;
	}
	else 
	{
		if (sauerstoffpart < 0 || sauerstoffpart > 933) return 1;
	}
	return 0;
} 

static int intcheck_harnstoff (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int harnstoff;
	
	if (Satzart_GetValueInt (ds, len, pFeld, &harnstoff) == LKF_FIELD_ERROR) return 1;

    if (pCheckContext->si_einheit != 2)
    {
        if (harnstoff < 0 || harnstoff > 642) return 1;
    }
    else
    {
        if (harnstoff < 0 || harnstoff > 1066) return 1;
    }
	return 0;
} 


static int intcheck_harnstoff_n (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int harnstoff;
	
	if (Satzart_GetValueInt (ds, len, pFeld, &harnstoff) == LKF_FIELD_ERROR) return 1;

	if (pCheckContext->si_einheit != 2)
	{
		if (harnstoff < 0 || harnstoff > 300) return 1;
	}
	else 
	{
		if (harnstoff < 0 || harnstoff > 830) return 1;
	}
	return 0;
} 

static int intcheck_syst_art_blutdruck (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int syst_art_blutdruck;
	
	if (Satzart_GetValueInt (ds, len, pFeld, &syst_art_blutdruck) == LKF_FIELD_ERROR) return 1;
	
	if (pCheckContext->si_einheit != 2)
	{
		if (syst_art_blutdruck < 0 || syst_art_blutdruck > 500) return 1;
	}
	else 
	{
		if (syst_art_blutdruck < 0 || syst_art_blutdruck > 667) return 1;
	}
	return 0;
} 

static int intcheck_komb_med (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int medikation_mehrfach, medikation_einfach;
	Satzart_GetValueInt (ds, len, pFeld, &medikation_mehrfach);
	Satzart_GetValueInt (ds, len, pCheckContext->pContext->pIntScoring->pInt02->ppRef[I02_MEDIKATION_EINMALIG], &medikation_einfach);

	if (medikation_mehrfach == 1 && medikation_einfach == 1) return 1;
	else return 0;
}

static int intcheck_komb_atemunt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int atemunterstuetzung, mech_beatmung;
	Satzart_GetValueInt (ds, len, pFeld, &atemunterstuetzung);
	Satzart_GetValueInt (ds, len, pCheckContext->pContext->pIntScoring->pInt02->ppRef[I02_BEATMUNG_MECH], &mech_beatmung);

	if (atemunterstuetzung == 1 && mech_beatmung == 1) return 1;
	else return 0;
}

static int intcheck_komb_med_vaso (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int medikation_mehrfach, medikation_einfach;
	Satzart_GetValueInt (ds, len, pFeld, &medikation_mehrfach);
	Satzart_GetValueInt (ds, len, pCheckContext->pContext->pIntScoring->pInt02->ppRef[I02_MEDIKATION_VAS_EINMALIG], &medikation_einfach);

	if (medikation_mehrfach == 1 && medikation_einfach == 1) return 1;
	else return 0;
}

static int intcheck_komb_intervention (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int intervention_mehrfach, intervention_einfach;
	Satzart_GetValueInt (ds, len, pFeld, &intervention_mehrfach);
	Satzart_GetValueInt (ds, len, pCheckContext->pContext->pIntScoring->pInt02->ppRef[I02_INTERVENTION_EINFACH], &intervention_einfach);

	if (intervention_mehrfach == 1 && intervention_einfach == 1) return 1;
	else return 0;
}

static int intcheck_metabol (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int metabol;
	if (pCheckContext->lAbtAufDat == pCheckContext->lLetzteMeldung) 
	{
        if ((Satzart_GetValueInt (ds, len, pFeld, &metabol) == LKF_FIELD_ERROR) || (metabol == 1 && pCheckContext->lSerumBikarbonat >= 220 && pCheckContext->lSerumBikarbonat <= 280))
		{

            if (pCheckContext->pContext->modelljahr < 2017)
            { /* V21.2 */
                char sErhebDat[10];
                char sAbtPos[4];
                const SATZART_INFO *pInt02;
                if (pCheckContext->pContext->modelljahr >= 2011)
                {
                    pInt02 = pCheckContext->pContext->pIntScoring->pInt12;
                }
                else {
                    pInt02 = pCheckContext->pContext->pIntScoring->pInt02;
                }
                Satzart_GetValueString (ds, len, pInt02->ppRef[GEN_ERHEBDAT], sErhebDat, 10);
                Satzart_GetValueString (ds, len, pInt02->ppRef[GEN_ABTPOS], sAbtPos, 4);
                sprintf (pCheckContext->sErrorAdditionalInfo, "%2.02s%-8.8s", sAbtPos, sErhebDat);
            }
			return 1;
		}
	}
	return 0;
}

static int int_check_fio2 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int ok, fio2, lDate;
	ok = Satzart_GetValueInt (ds, len, pFeld, &fio2);
	if ((ok == LKF_FIELD_ERROR) || (!ok && (fio2 < 1 || fio2 > 100)))
	{
		return 1;
	}
	lDate = Satzart_GetValueDate (ds, len, pCheckContext->pContext->pIntScoring->pInt01->ppRef[GEN_ERHEBDAT]);
	if (lDate == (int)pCheckContext->lAbtAufDat) pCheckContext->fio2 = fio2;
	return 0;
}

static int int_check_fio2_2011 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V16.1 */
	int ok, fio2, lDate;
	ok = Satzart_GetValueInt (ds, len, pFeld, &fio2);
	if ((ok == LKF_FIELD_ERROR) || (!ok && (fio2 < 10 || fio2 > 100)))
	{
		return 1;
	}
	lDate = Satzart_GetValueDate (ds, len, pCheckContext->pContext->pIntScoring->pInt11->ppRef[GEN_ERHEBDAT]); /* V16.1 */
	if (lDate == (int)pCheckContext->lAbtAufDat) pCheckContext->fio2 = fio2;
	return 0;
}


static int intcheck_komb_saps_gcs (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int erhebdat, gcs_mot, gcs_verb, gcs_vis;
	const SATZART_INFO *pInt01;

	if (pCheckContext->cSAPSAufnahmeart == '2')
	{
		pInt01 = pCheckContext->pContext->pIntScoring->pInt01;
		erhebdat = Satzart_GetValueDate (ds, len, pInt01->ppRef[GEN_ERHEBDAT]);
		if (erhebdat == (int)pCheckContext->lAbtAufDat)
		{
			if (Satzart_GetValueInt (ds, len, pInt01->ppRef[I01_COMASCALE_MOTORISCH], &gcs_mot) == LKF_FIELD_ERROR) return 0;
			if (Satzart_GetValueInt (ds, len, pInt01->ppRef[I01_COMASCALE_VERBAL], &gcs_verb) == LKF_FIELD_ERROR) return 0;
			if (Satzart_GetValueInt (ds, len, pInt01->ppRef[I01_COMASCALE_VISUELL], &gcs_vis) == LKF_FIELD_ERROR) return 0;

			if (!gcs_mot) gcs_mot = 6;
			if (!gcs_verb) gcs_verb = 5;
			if (!gcs_vis) gcs_vis = 4;


			if (gcs_mot + gcs_verb + gcs_vis <= 8) 
			{
                char sErhebDat[10];
                char sAbtPos[4];
                Satzart_GetValueString (ds, len, pInt01->ppRef[GEN_ERHEBDAT], sErhebDat, 10);
				Satzart_GetValueString (ds, len, pInt01->ppRef[GEN_ABTPOS], sAbtPos, 4);
				sprintf (pCheckContext->sErrorAdditionalInfo, "%2.02s%-8.8s", sAbtPos, sErhebDat);
				return 1;
			}
		}
	}

	return 0;
}


static int intcheck_komb_chirurg_gcs (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.1 */
	int erhebdat, gcs_mot, gcs_verb, gcs_vis, chirurg_status;
	const SATZART_INFO *pInt11;

	pInt11 = pCheckContext->pContext->pIntScoring->pInt11;
	Satzart_GetValueInt (ds, len, pInt11->ppRef[I11_CHIRURG_STATUS], &chirurg_status);

	if (chirurg_status == 1)
	{
		erhebdat = Satzart_GetValueDate (ds, len, pInt11->ppRef[GEN_ERHEBDAT]);
		if (erhebdat == (int)pCheckContext->lAbtAufDat)
		{
			if (Satzart_GetValueInt (ds, len, pInt11->ppRef[I01_COMASCALE_MOTORISCH], &gcs_mot) == LKF_FIELD_ERROR) return 0;
			if (Satzart_GetValueInt (ds, len, pInt11->ppRef[I01_COMASCALE_VERBAL], &gcs_verb) == LKF_FIELD_ERROR) return 0;
			if (Satzart_GetValueInt (ds, len, pInt11->ppRef[I01_COMASCALE_VISUELL], &gcs_vis) == LKF_FIELD_ERROR) return 0;

			if (!gcs_mot) gcs_mot = 6;
			if (!gcs_verb) gcs_verb = 5;
			if (!gcs_vis) gcs_vis = 4;


			if (gcs_mot + gcs_verb + gcs_vis <= 8) 
			{
            
                if (pCheckContext->pContext->modelljahr < 2017)
                { /* V21.2 */
                    char sErhebDat[10];
                    char sAbtPos[4];
                    Satzart_GetValueString (ds, len, pInt11->ppRef[GEN_ERHEBDAT], sErhebDat, 10);
                    Satzart_GetValueString (ds, len, pInt11->ppRef[GEN_ABTPOS], sAbtPos, 4);
                    sprintf (pCheckContext->sErrorAdditionalInfo, "%2.02s%-8.8s", sAbtPos, sErhebDat);
                }
				return 1;
			}
		}
	}

	return 0;
}


static int intcheck_komb_sapsfio2_mechvent (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int mechvent, lDate = Satzart_GetValueDate (ds, len, pCheckContext->pContext->pIntScoring->pInt02->ppRef[GEN_ERHEBDAT]);
	
	if (lDate == (int) pCheckContext->lAbtAufDat)
	{
		Satzart_GetValueInt (ds, len, pFeld, &mechvent);
		if (mechvent && pCheckContext->fio2 >= 0 && pCheckContext->fio2 <= 21)
		{
			if (pCheckContext->fio2 < 21)
			{
				char sErhebDat[10];
				char sAbtPos[4];
				const SATZART_INFO *pInt02 = pCheckContext->pContext->pIntScoring->pInt02;
				Satzart_GetValueString (ds, len, pInt02->ppRef[GEN_ERHEBDAT], sErhebDat, 10);
				Satzart_GetValueString (ds, len, pInt02->ppRef[GEN_ABTPOS], sAbtPos, 4);
				sprintf (pCheckContext->sErrorAdditionalInfo, "%2.02s%-8.8s", sAbtPos, sErhebDat);
				return 1;
			}
		}
	}
	return 0;
}


static int intcheck_komb_sapsfio2_atmung (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.1 */
	int atmungsmodus, lDate = Satzart_GetValueDate (ds, len, pCheckContext->pContext->pIntScoring->pInt12->ppRef[GEN_ERHEBDAT]);
	
	if (lDate == (int) pCheckContext->lAbtAufDat)
	{
		Satzart_GetValueInt (ds, len, pFeld, &atmungsmodus);
		if (atmungsmodus && pCheckContext->fio2 >= 0 && pCheckContext->fio2 < 21)
		{
            if (pCheckContext->pContext->modelljahr < 2017)
            { /* V21.2 */
                char sErhebDat[10];
                char sAbtPos[4];
                const SATZART_INFO *pInt02 = pCheckContext->pContext->pIntScoring->pInt12;
                Satzart_GetValueString (ds, len, pInt02->ppRef[GEN_ERHEBDAT], sErhebDat, 10);
                Satzart_GetValueString (ds, len, pInt02->ppRef[GEN_ABTPOS], sAbtPos, 4);
                sprintf (pCheckContext->sErrorAdditionalInfo, "%2.02s%-8.8s", sAbtPos, sErhebDat);
            }
			return 1;
		}
	}
	return 0;
}

static int intcheck_01 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int i;
	char feld[50];

	Satzart_GetValueString (ds, len, pFeld, feld, 50);
	for (i = 0; i < pFeld->nLen; i++)
	{
		if (feld[i] != '0' && feld[i] != '1')
			return 1;
	}
	return 0;
}

static int intcheck_floatrange (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext, double minval, double maxval)
{
	double dv;
	if (Satzart_GetValueFloat (ds, len, pFeld, &dv, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR)
		return 1;
	if (dv < minval || dv > maxval)
		return 1;
	return 0;
}
static int intcheck_leuko (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return intcheck_floatrange (ds, len, pFeld, pCheck, pCheckContext, 0.0, 999.0);
}

static int intcheck_gesamtbilirubin_2011 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return intcheck_floatrange (ds, len, pFeld, pCheck, pCheckContext, 0.0, 200.0);
}

static int intcheck_blutbild_ph (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return intcheck_floatrange (ds, len, pFeld, pCheck, pCheckContext, 6.0, 8.0);
}

static int intcheck_kreatinin (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return intcheck_floatrange (ds, len, pFeld, pCheck, pCheckContext, 0.0, 50.0);
}

static int intcheck_koerpertemp (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return intcheck_floatrange (ds, len, pFeld, pCheck, pCheckContext, 0.0, 45.0);
}

static int intcheck_kombination_atmungsmodus (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char atmungsmodus[2], atemwegszugang[2];
	Satzart_GetValueString (ds, len, pFeld, atemwegszugang, 1);
	Satzart_GetValueString (ds, len, pCheckContext->pContext->pIntScoring->pInt12->ppRef[I02_BEATMUNG_MECH], atmungsmodus, 1);

	switch (atmungsmodus[0])
	{
		case '0':
			if (strchr ("23", atemwegszugang[0]))
				break;
            return 0;
		case '1':
		case '2':
		case '3':
		case '4':
			if (strchr ("01", atemwegszugang[0]))
				break;
            return 0;
		case '5':
			if (strchr ("0123", atemwegszugang[0]))
                break;
            return 0;
        case '6':
            if (atemwegszugang[0] != '1')
                break;
            return 0;
		default:
			return 0;
	}

    if (pCheckContext->pContext->modelljahr >= 2017) {
        return 1; /* V21.2: Standard-Error-Wert */
    }
	if (pCheckContext->pContext->modelljahr >= 2014) 
	{ /* V18.0 */
		char sErhebDat[10];
		LKF_AUFENTHALT_ABT *pAbt = pCheckContext->pAufenthalt->abt + pCheckContext->nAbtIndex;	
		Satzart_GetValueString (ds, len, pCheckContext->pContext->pIntScoring->pInt12->ppRef[GEN_ERHEBDAT], sErhebDat, 9);
		sprintf (pCheckContext->sErrorAdditionalInfo, "%2.2s%8.8s", pAbt->ABTPOS, sErhebDat);	
	}
	else if (pCheckContext->pContext->modelljahr >= 2012) {
		/* V16.1 */
		LKF_AUFENTHALT_ABT *pAbt = pCheckContext->pAufenthalt->abt + pCheckContext->nAbtIndex;	
		sprintf (pCheckContext->sErrorAdditionalInfo, "%2.2s%8.8s", pAbt->ABTPOS, pAbt->ABTDAT);
	}
	else	
		sprintf (pCheckContext->sErrorAdditionalInfo, "%c/%c", atmungsmodus[0], atemwegszugang[0]);
	return 1;
}

static int intcheck_pao2_2011 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.1 */
	return intcheck_floatrange (ds, len, pFeld, pCheck, pCheckContext, 0.0, 900.0);
}

const LKF_SATZART_ERRORCHECK
	LKFCheckBHKPos =			{LKF_CHECKFUNC_EXISTS, 0, &LKFErrorBHKPosFehlt, 0, 0},
	LKFCheckErhebDatIdent =		{LKF_CHECKFUNC_FUNCTION, intcheck_erhebdat_doppelt, &LKFErrorErhebDatIdent, 0, 0},
	LKFCheckErhebDatAussAuf =   {LKF_CHECKFUNC_FUNCTION, intcheck_erhebdat_zeitraum, &LKFErrorErhebDatAussAuf, 0, &LKFCheckErhebDatIdent},
	LKFCheckErhebDatFalsch =	{LKF_CHECKFUNC_FORMAT, 0, &LKFErrorErhebDatFalsch, 0, &LKFCheckErhebDatAussAuf},
	LKFCheckErhebDat =			{LKF_CHECKFUNC_EXISTS, 0, &LKFErrorErhebDatFehlt, 0, &LKFCheckErhebDatFalsch},
	LKFCheckSIIndikator =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_si_einheit, &LKFErrorSIIndikator, 0, 0},
	LKFCheckSauerstoffPart =	{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_sauerstoffpart, &LKFErrorSauerstoffPart, 0, 0},
	LKFCheckSauerstoffPart2011 ={LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_pao2_2011, &LKFErrorSauerstoffPart2011, 0, 0},
	LKFCheckAtmungsmodus =      {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_6, &LKFErrorAtmungsmodus, 0, 0},
	LKFCheckBlutbildLeukozyten ={LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_9990, &LKFErrorBlutbildLeukozyten, 0, 0},
	LKFCheckBlutbildLeuko2011  ={LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_leuko, &LKFErrorBlutbildLeuko2011, 0, 0},
	LKFCheckGCSmotReak =        {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_6, &LKFErrorGCSmotReak, 0, 0},
	LKFCheckGCSverbReak =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_5, &LKFErrorGCSverbReak, 0, 0},
	LKFCheckKombSAPSaufGCS =    {LKF_CHECKFUNC_FUNCTION, intcheck_komb_saps_gcs, &LKFErrorKombSAPSaufGCS, 0, 0}, 
	LKFCheckGCSvisReak =        {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_4, &LKFErrorGCSvisReak, 0, &LKFCheckKombSAPSaufGCS},
	LKFCheckKombChirurgGCS =	{LKF_CHECKFUNC_FUNCTION, intcheck_komb_chirurg_gcs, &LKFErrorKombChirurgGCS, 0, 0}, /* V15.1 */
	LKFCheckGCSvisReak2011 =	{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_4, &LKFErrorGCSvisReak, 0, &LKFCheckKombChirurgGCS}, /* V15.1 */
	LKFCheckHarn =              {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_50000, &LKFErrorHarn, 0, 0},
	LKFCheckHerzfrequenz =      {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_600, &LKFErrorHerzfrequenz, 0, 0},
	LKFCheckSauerstoffkonz =    {LKF_CHECKFUNC_FUNCTION, int_check_fio2, &LKFErrorSauerstoffkonz, 0, 0},
/*	LKFCheckSauerstoffkonz2011 =    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_10_100, &LKFErrorSauerstoffkonz2011, 0, 0}, */
	LKFCheckSauerstoffkonz2011 =    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, int_check_fio2_2011, &LKFErrorSauerstoffkonz2011, 0, 0},
	LKFCheckKoerpertemp =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_450, &LKFErrorKoerpertemp, 0, 0},
	LKFCheckKoerpertemp2011 =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_koerpertemp, &LKFErrorKoerpertemp2011, 0, 0},
	LKFCheckSAPSIIPulmonaliskath={LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorSAPSIIPulmonaliskath, 0, 0},
	LKFCheckSerumBikarbonat =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_990, &LKFErrorSerumBikarbonat, 0, 0},
	LKFCheckSerumBilirubin  =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_gesamtbilirubin, &LKFErrorSerumBilirubin, 0, 0},
	LKFCheckSerumBilirubin2011  =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_gesamtbilirubin_2011, &LKFErrorSerumBilirubin2011, 0, 0},
	LKFCheckSerumHarnstoff =    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_harnstoff, &LKFErrorSerumHarnstoff, 0, 0},
	LKFCheckSerumHarnstoffN =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_harnstoff_n, &LKFErrorSerumHarnstoffN, 0, 0},
	LKFCheckSerumKalium =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_300, &LKFErrorSerumKalium, 0, 0},
	LKFCheckSerumNatrium =      {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_50_200, &LKFErrorSerumNatrium, 0, 0},

	LKFCheckSystArtBlutdruck =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_syst_art_blutdruck, &LKFErrorSystArtBlutdruck, 0, 0},
	LKFCheckSystArtBlutdruck2011 = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_400, &LKFErrorSystArtBlutdruck2011, 0, 0}, /* V15.1 */
	
	LKFCheckStandMonWarn =		{LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_1, &LKFErrorTISS28ohneStdmon, 0, 0},
	LKFCheckStandMonWarn2011 =		{LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_1, &LKFErrorTISSAohneStdmon, 0, 0}, /* V15.1 */
	LKFCheckStandardMonitoring ={LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorStandardMonitoring, 0, &LKFCheckStandMonWarn},
	LKFCheckStandardMonitoring2013 = {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorStandardMonitoring, 0, &LKFCheckStandMonWarn2011}, /* V17.1 */
	LKFCheckStandardMonitoring2011 = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorStandardMonitoring, 0, &LKFCheckStandMonWarn2011, 2013, &LKFCheckStandardMonitoring2013},
	LKFCheckLabor2013 =         {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorLabor, 0, 0}, /* V17.1 */
	LKFCheckLabor =             {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorLabor, 0, 0, 2013, &LKFCheckLabor2013},
	LKFCheckMedKomb =			{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_komb_med, &LKFErrorKombMedikation, 0, 0},
	LKFCheckMedEinmalig =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorMedEinmalig, 0, 0},
	LKFCheckMedMehrfach =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorMedMehrfach, 0, &LKFCheckMedKomb},
	LKFCheckRoutineverbandsw =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorRoutineverbandsw, 0, 0},
	LKFCheckVerbandswHaeufig =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorVerbandswHaeufig, 0, 0}, 
	LKFCheckDrainagenpflege2013 =   {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorDrainagenpflege, 0, 0}, /* V17.1 */
	LKFCheckDrainagenpflege =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorDrainagenpflege, 0, 0, 2013, &LKFCheckDrainagenpflege2013},
	LKFCheckKombSAPSAtmungsmodus = {LKF_CHECKFUNC_FUNCTION, intcheck_komb_sapsfio2_atmung, &LKFErrorKombSAPSAtmungsmodus, 0, 0}, /* V15.1 */
    LKFCheckAtmungsmodus2026 =    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_6, &LKFErrorAtmungsmodus2011, 0, &LKFCheckKombSAPSAtmungsmodus},
    LKFCheckAtmungsmodus2013 =	{LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_5, &LKFErrorAtmungsmodus2011, 0, &LKFCheckKombSAPSAtmungsmodus, 2026, &LKFCheckAtmungsmodus2026},
	LKFCheckAtmungsmodus2011 =	{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_5, &LKFErrorAtmungsmodus2011, 0, &LKFCheckKombSAPSAtmungsmodus, 2013, &LKFCheckAtmungsmodus2013},
	LKFCheckKombAtmung =		{LKF_CHECKFUNC_FUNCTION, intcheck_kombination_atmungsmodus, &LKFErrorKombAtmung, 0, 0}, /* V15.2 */
	LKFCheckAtemwegszugang2013 =	{LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_5, &LKFErrorAtemwegszugang, 0, &LKFCheckKombAtmung}, /* V17.1 */
	LKFCheckAtemwegszugang =	{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_5, &LKFErrorAtemwegszugang, 0, &LKFCheckKombAtmung, 2013, &LKFCheckAtemwegszugang2013},
	LKFCheckKombBeatmung =      {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_komb_atemunt, &LKFErrorKombAtemunterst, 0, 0},
	LKFCheckKombSAPSmech =      {LKF_CHECKFUNC_FUNCTION, intcheck_komb_sapsfio2_mechvent, &LKFErrorKombSAPSmech, 0, 0},
	LKFCheckBeatmungMech2013 =      {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorBeatmungMech, 0, &LKFCheckKombSAPSmech}, /* V17.1 */
	LKFCheckBeatmungMech =      {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorBeatmungMech, 0, &LKFCheckKombSAPSmech, 2013, &LKFCheckBeatmungMech2013},
	LKFCheckAtemunterstuetzung ={LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorAtemunterstuetzung, 0, &LKFCheckKombBeatmung},
	LKFCheckTubuspflege2013 =       {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorTubuspflege, 0, 0}, /* V17.1 */
	LKFCheckTubuspflege =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorTubuspflege, 0, 0, 2013, &LKFCheckTubuspflege2013},
	LKFCheckAtemtherapie2013 =      {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorAtemtherapie, 0, 0}, /* V17.1 */
	LKFCheckAtemtherapie =      {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorAtemtherapie, 0, 0, 2013, &LKFCheckAtemtherapie2013},
	LKFCheckKombMedVaso =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_komb_med_vaso, &LKFErrorKombvasoMed, 0, 0},
	LKFCheckMedVasoEinmalig =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorMedVasoEinmalig, 0, 0},
	LKFCheckMedVasoMehrfach =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorMedVasoMehrfach, 0, &LKFCheckKombMedVaso},
	LKFCheckFluessigkeitsers2013 =  {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorFluessigkeitsers, 0, 0}, /* V17.1 */
	LKFCheckFluessigkeitsers =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorFluessigkeitsers, 0, 0, 2013, &LKFCheckFluessigkeitsers2013},
	LKFCheckKatheterArteriell2013 = {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorKatheterArteriell, 0, 0}, /* V17.1 */
	LKFCheckKatheterArteriell = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorKatheterArteriell, 0, 0, 2013, &LKFCheckKatheterArteriell2013},
	LKFCheckPulmunalisKath =    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorPulmunalisKath, 0, 0},
	LKFCheckKathZentralvenoes2013 = {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorKathZentralvenoes, 0, 0}, /* V17.1 */
	LKFCheckKathZentralvenoes = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorKathZentralvenoes, 0, 0, 2013, &LKFCheckKathZentralvenoes2013},
	LKFCheckReanimationKardio2013 = {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorReanimationKardio, 0, 0}, /* V17.1 */
	LKFCheckReanimationKardio = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorReanimationKardio, 0, 0, 2013, &LKFCheckReanimationKardio2013},
	LKFCheckNierenErsatzTher2013 =  {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorNierenErsatzTher, 0, 0}, /* V17.1 */
	LKFCheckNierenErsatzTher =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorNierenErsatzTher, 0, 0, 2013, &LKFCheckNierenErsatzTher2013},
	LKFCheckHarnbilanzierung2013 =  {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorHarnbilanzierung, 0, 0}, /* V17.1 */
	LKFCheckHarnbilanzierung =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorHarnbilanzierung, 0, 0, 2013, &LKFCheckHarnbilanzierung2013},
	LKFCheckDiurese2013 =           {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorDiurese, 0, 0}, /* V17.1 */
	LKFCheckDiurese =           {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorDiurese, 0, 0, 2013, &LKFCheckDiurese2013},
	LKFCheckHirndruckmessung2013 =  {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorHirndruckmessung, 0, 0}, /* V17.1 */
	LKFCheckHirndruckmessung =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorHirndruckmessung, 0, 0, 2013, &LKFCheckHirndruckmessung2013},
	LKFCheckMetabolKomb	=       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_metabol, &LKFErrorSerBimetabEntgl, 0, 0},
	LKFCheckBehMetabolEntgl2013 =   {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorBehMetabolEntgl, 0, 0 /* V21.2 */}, /* V17.1 */
	LKFCheckBehMetabolEntgl =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorBehMetabolEntgl, 0, &LKFCheckMetabolKomb, 2013, &LKFCheckBehMetabolEntgl2013},
	LKFCheckErnaehrungEnteral2013 = {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorErnaehrungEnteral, 0, 0}, /* V17.1 */
	LKFCheckErnaehrungEnteral = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorErnaehrungEnteral, 0, 0, 2013, &LKFCheckErnaehrungEnteral2013},
	LKFCheckErnaehrungParental2013 = {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorErnaehrungParental, 0, 0}, /* V17.1 */
	LKFCheckErnaehrungParental ={LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorErnaehrungParental, 0, 0, 2013, &LKFCheckErnaehrungParental2013},
	LKFCheckInterventKomb =     {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_komb_intervention, &LKFErrorKombIntervent, 0, 0},
	LKFCheckInterventEinfach =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorInterventEinfach, 0, 0},
	LKFCheckInterventMehrfach = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorInterventMehrfach, 0, &LKFCheckInterventKomb},
	LKFCheckDiagnostTherAuss2013 =  {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorDiagnostTherAuss, 0, 0}, /* V17.1 */
	LKFCheckDiagnostTherAuss =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorDiagnostTherAuss, 0, 0, 2013, &LKFCheckDiagnostTherAuss2013},
	LKFCheckAISAbdomen =        {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_6, &LKFErrorAISAbdomen, 0, 0},
	LKFCheckAISExtern =         {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_6, &LKFErrorAISExtern, 0, 0},
	LKFCheckAISExtremitaeten =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_6, &LKFErrorAISExtremitaeten, 0, 0},
	LKFCheckAISGesicht =        {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_6, &LKFErrorAISGesicht, 0, 0},
	LKFCheckAISHalsKopf =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_6, &LKFErrorAISHalsKopf, 0, 0},
	LKFCheckAISThorax =         {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_6, &LKFErrorAISThorax, 0, 0},
	LKFCheckAISTyp =            {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_2, &LKFErrorAISTyp, 0, 0},
	LKFCheckGCSAufMotReak =     {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_6, &LKFErrorGCSAufMotReak, 0, 0},
	LKFCheckGCSAufVerbReak =    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_5, &LKFErrorGCSAufVerbReak, 0, 0},
	LKFCheckGCSAufVisReak =     {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_4, &LKFErrorGCSAufVisReak, 0, 0},
	LKFCheckSystArtBlutAuf =    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_syst_art_blutdruck, &LKFErrorSystArtBlutAuf, 0, 0},
	LKFCheckAtemfrequenzAuf =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_100, &LKFErrorAtemfrequenzAuf, 0, 0},
	LKFCheckMedikamente2013 =   {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_2, &LKFErrorMedikamente, 0, 0}, /* V17.1 */
	LKFCheckMedikamente =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_2, &LKFErrorMedikamente, 0, 0, 2013, &LKFCheckMedikamente2013}, /* V15.1 */
	LKFCheckVerbandswechsel2013 =   {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_3, &LKFErrorVerbandswechsel, 0, 0}, /* V17.1 */
	LKFCheckVerbandswechsel =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_3, &LKFErrorVerbandswechsel, 0, 0, 2013, &LKFCheckVerbandswechsel2013}, /* V15.1 */
	LKFCheckMedikamenteVasoaktiv2013 = {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_2, &LKFErrorMedikamenteVasoaktiv, 0, 0}, /* V17.1 */
	LKFCheckMedikamenteVasoaktiv = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_2, &LKFErrorMedikamenteVasoaktiv, 0, 0, 2013, &LKFCheckMedikamenteVasoaktiv2013}, /* V15.1 */
	LKFCheckInterventionen2013 =    {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_2, &LKFErrorInterventionen, 0, 0}, /* V17.1 */
	LKFCheckInterventionen =    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_2, &LKFErrorInterventionen, 0, 0, 2013, &LKFCheckInterventionen2013}, /* V15.1 */
	LKFCheckAgitation2013 =			{LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_7, &LKFErrorAgitation, 0, 0}, /* V17.1 */
	LKFCheckAgitation =			{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_7, &LKFErrorAgitation, 0, 0, 2013, &LKFCheckAgitation2013}, /* V15.1 */
	LKFCheckAssistKardial2013 =		{LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorAssistKardial, 0, 0}, /* V17.1 */
	LKFCheckAssistKardial =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorAssistKardial, 0, 0, 2013, &LKFCheckAssistKardial2013}, /* V15.1 */
	LKFCheckAssistPulmonal2013 =	{LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorAssistPulmonal, 0, 0}, /* V17.1 */
	LKFCheckAssistPulmonal =	{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorAssistPulmonal, 0, 0, 2013, &LKFCheckAssistPulmonal2013}, /* V15.1 */
	LKFCheckHypothermie2013 =		{LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorHypothermie, 0, 0}, /* V17.1 */
	LKFCheckHypothermie =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorHypothermie, 0, 0, 2013, &LKFCheckHypothermie2013}, /* V15.1 */
	LKFCheckLeberSupport2013 =		{LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorLeberSupport, 0, 0}, /* V17.1 */
	LKFCheckLeberSupport =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorLeberSupport, 0, 0, 2013, &LKFCheckLeberSupport2013}, /* V15.1 */
	LKFCheckAntikonvulsiveTherapie2013 = {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorAntikonvulsiveTherapie, 0, 0}, /* V17.1 */
	LKFCheckAntikonvulsiveTherapie = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorAntikonvulsiveTherapie, 0, 0, 2013, &LKFCheckAntikonvulsiveTherapie2013}, /* V15.1 */
	LKFCheckMonitoringHaemo2013 =   {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_5, &LKFErrorMonitoringHaemo, 0, 0}, /* V17.1 */
	LKFCheckMonitoringHaemo =   {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_5, &LKFErrorMonitoringHaemo, 0, 0, 2013, &LKFCheckMonitoringHaemo2013}, /* V15.1 */
	LKFCheckAkuterInfekt =      {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_01, &LKFErrorAkuterInfekt, 0, 0}, /* V15.1 */
	LKFCheckKeinGrund =         {LKF_CHECKFUNC_FUNCTION, intcheck_aufgrund, &LKFErrorKeinGrund, 0, 0}, /* V18.1 */
	LKFCheckGrundAnderer2014 =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorGrundAnderer, 0, &LKFCheckKeinGrund}, /* V18.1 */
	LKFCheckGrundAnderer =      {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorGrundAnderer, 0, 0, 2014, &LKFCheckGrundAnderer2014}, /* V15.1 */
	LKFCheckGrundBasisPflege =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_3, &LKFErrorGrundBasisPflege, 0, 0}, /* V15.1 */
	LKFCheckGrundGastro =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_4, &LKFErrorGrundGastro, 0, 0}, /* V15.1 */
	LKFCheckGrundHaemat =	    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_3, &LKFErrorGrundHaemat, 0, 0}, /* V15.1 */
	LKFCheckGrundKardio =       {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_12, &LKFErrorGrundKardio, 0, 0}, /* V15.1 */
  	LKFCheckGrundLeber =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_2, &LKFErrorGrundLeber, 0, 0}, /* V15.1 */
	LKFCheckGrundMetabolisch =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_4, &LKFErrorGrundMetabolisch, 0, 0}, /* V15.1 */
	LKFCheckGrundNeuro =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_5, &LKFErrorGrundNeuro, 0, 0}, /* V15.1 */
	LKFCheckGrundRenal =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_4, &LKFErrorGrundRenal, 0, 0}, /* V15.1 */
	LKFCheckGrundRespi =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_3, &LKFErrorGrundRespi, 0, 0}, /* V15.1 */
	LKFCheckGrundTrauma =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorGrundTrauma, 0, 0}, /* V15.1 */
	LKFCheckKeinAufnahmeTyp =   {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_2, &LKFErrorKeinAufnahmeTyp, 0, 0}, /* V18.1 */
    LKFCheckAufnahmeTyp2015 =	{LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_2, &LKFErrorAufnahmeTyp, 0, 0}, /* V19.0 */
	LKFCheckAufnahmeTyp2014 =	{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_2, &LKFErrorAufnahmeTyp, 0, &LKFCheckKeinAufnahmeTyp, 2015, &LKFCheckAufnahmeTyp2015}, /* V18.1 */
	LKFCheckAufnahmeTyp =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_2, &LKFErrorAufnahmeTyp, 0, 0, 2014, &LKFCheckAufnahmeTyp2014}, /* V15.1 */
	LKFCheckBlutbildPH =		{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_blutbild_ph, &LKFErrorBlutbildPH, 0, 0}, /* V15.1 */
	LKFCheckBlutbildThrombo =	{LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_5000, &LKFErrorBlutbildThrombo, 0, 0}, /* V15.1 */
	LKFCheckChirurgieEingriff = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_42, &LKFErrorChirurgieEingriff, 0, 0}, /* V15.1 */
	LKFCheckKeinChirurgStatus = {LKF_CHECKFUNC_INTRANGE,  &LKF_INTRANGE_1_3, &LKFErrorKeinChirurgStatus, 0, 0}, /* V18.1 */
    LKFCheckChirurgischerStatus2015 = {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_3, &LKFErrorChirurgischerStatus, 0, 0}, /* V19.0 */
	LKFCheckChirurgischerStatus2014 = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_3, &LKFErrorChirurgischerStatus, 0, &LKFCheckKeinChirurgStatus, 2015, &LKFCheckChirurgischerStatus2015}, /* V15.1 */
	LKFCheckChirurgischerStatus = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_3, &LKFErrorChirurgischerStatus, 0, 0, 2014, &LKFCheckChirurgischerStatus2014}, /* V15.1 */
	LKFCheckKoexistErkrank =    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_01, &LKFErrorKoexistErkrank, 0, 0}, /* V15.1 */
	LKFCheckMechBeatmung =      {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_1, &LKFErrorMechBeatmung, 0, 0}, /* V15.1 */
	LKFCheckSerumKreatinin =    {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_kreatinin, &LKFErrorSerumKreatinin, 0, 0}, /* V15.1 */
	LKFCheckTheraepeutischeMN = {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_FUNCTION, intcheck_01, &LKFErrorTheraepeutischeMN, 0, 0}, /* V15.1 */
    LKFCheckKeineZutransferierung =  {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_7, &LKFErrorZutransNichtErhoben, 0, 0}, /* V19.0 */
    LKFCheckZutransferierung2016 =  {LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_1_7, &LKFErrorZutransferierung, 0, 0}, /* V20.0 */
    LKFCheckZutransferierung2015 =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_7, &LKFErrorZutransferierung, 0, &LKFCheckKeineZutransferierung, 2016, &LKFCheckZutransferierung2016}, /* V19.0 */
	LKFCheckZutransferierung =  {LKF_CHECK_BYPASS_EMPTY | LKF_CHECKFUNC_INTRANGE, &LKF_INTRANGE_0_7, &LKFErrorZutransferierung, 0, 0, 2015, &LKFCheckZutransferierung2015}; /* V15.1 */

/* Satzart I01: Physiologische Daten */

const int i01_ident[] = {0,1,2,3,-1};

const SATZART Int01 = {"I01", 0, 24, 24, (const int *) &i01_ident, "Physiologische Daten", 0, {
	{GEN_KANR,						TYP_ALPHA, 	 4,  6, 0, 0, "KANR"},
	{GEN_AUFNR,						TYP_ALPHA,	10, 10, 0, 0, "AUFNR"},
	{GEN_ABTPOS,					TYP_NUM,	20,  2, &LKFCheckBHKPos, 0, "ABTPOS"},
	{GEN_ERHEBDAT,					TYP_DAT,	22,  8, &LKFCheckErhebDat, 0, "ERHEBDAT"}, 
	{I01_SI_INDIKATOR,				TYP_NUM,	30,  1, &LKFCheckSIIndikator, 0, "SI_INDIKATOR"},
	{I01_SAUERSTOFFPART,			TYP_NUM,	31,  3, &LKFCheckSauerstoffPart, 0, "SAUERSTOFFPART"},
	{I01_ATMUNGSMODUS,				TYP_NUM,	34,  1, &LKFCheckAtmungsmodus, 0, "ATMUNGSMODUS"},
	{I01_BLUTBILD_LEUKOZYTEN,		TYP_NUM,	35,  4, &LKFCheckBlutbildLeukozyten, 0, "BLUTBILD_LEUKOZYTEN"},
	{I01_COMASCALE_MOTORISCH,		TYP_NUM,	39,  1, &LKFCheckGCSmotReak, 0, "COMASCALE_MOTORISCH"},
	{I01_COMASCALE_VERBAL,			TYP_NUM,	40,  1, &LKFCheckGCSverbReak, 0, "COMASCALE_VERBAL"},
	{I01_COMASCALE_VISUELL,			TYP_NUM,	41,  1, &LKFCheckGCSvisReak, 0, "COMASCALE_VISUELL"},
	{I01_HARN_VOLUMEN24H,			TYP_NUM,	42,  5, &LKFCheckHarn, 0, "HARN_VOLUMEN24H"},
	{I01_HERZFREQUENZ,				TYP_NUM,	47,  3, &LKFCheckHerzfrequenz, 0, "HERZFREQUENZ"},
	{I01_SAUERSTOFFKONZ_INSP,		TYP_NUM,	50,  3, &LKFCheckSauerstoffkonz, 0, "SAUERSTOFFKONZ_INSP"},
	{I01_KOERPERTEMP,				TYP_NUM,	53,  3, &LKFCheckKoerpertemp, 0, "KOERPERTEMP"},
	{I01_PULMONALISKATHETER,		TYP_NUM,	56,  1, &LKFCheckSAPSIIPulmonaliskath, 0, "PULMONALISKATHETER"},
	{I01_SERUM_BIKARBONAT,			TYP_NUM,	57,  3, &LKFCheckSerumBikarbonat, 0, "SERUM_BIKARBONAT"}, 
	{I01_SERUM_GESAMT_BILIRUBIN,	TYP_NUM,	60,  5, &LKFCheckSerumBilirubin, 0, "SERUM_GESAMT_BILIRUBIN"},
	{I01_SERUM_HARNSTOFF,			TYP_NUM,	65,  3, &LKFCheckSerumHarnstoff, 0, "SERUM_HARNSTOFF"},
	{I01_SERUM_HARNSTOFF_N,			TYP_NUM,	68,  3, &LKFCheckSerumHarnstoffN, 0, "SERUM_HARNSTOFF_N"},
	{I01_SERUM_KALIUM,				TYP_NUM,	71,  3, &LKFCheckSerumKalium, 0, "SERUM_KALIUM"},
	{I01_SERUM_NATRIUM,				TYP_NUM,	74,  3, &LKFCheckSerumNatrium, 0, "SERUM_NATRIUM"},
	{I01_SYSTOL_ARTER_BLUTDRUCK,	TYP_NUM,	77,  3, &LKFCheckSystArtBlutdruck, 0, "SYSTOL_ARTER_BLUTDRUCK"},
	{GEN_LINEID,					TYP_ALPHA,	80,  4, 0, 0, "ZEILEN-ID"}
}};

/* Satzart I02: TISS-Daten */

const SATZART Int02 = {"I02", 0, 33, 33, (const int *) &i01_ident, "TISS28-Daten", 0, {
	{GEN_KANR,					    TYP_ALPHA,   4,  6, 0, 0, "KANR"},
	{GEN_AUFNR,					    TYP_ALPHA,  10, 10, 0, 0, "AUFNR"},
	{GEN_ABTPOS,					TYP_NUM,    20,  2, &LKFCheckBHKPos, 0, "ABTPOS"},
	{GEN_ERHEBDAT,				    TYP_DAT,	22,  8, &LKFCheckErhebDat, 0, "ERHEBDAT"},
	{I02_STANDARD_MONITORING,		TYP_NUM,	30,  1, &LKFCheckStandardMonitoring, 5, "STANDARD_MONITORING"},
	{I02_LABOR,						TYP_NUM,	31,	 1, &LKFCheckLabor, 1, "LABOR"},
	{I02_MEDIKATION_EINMALIG,		TYP_NUM,	32,  1, &LKFCheckMedEinmalig, 2, "MEDIKATION_EINMALIG"},
	{I02_MEDIKATION_MEHRFACH,		TYP_NUM,	33,  1, &LKFCheckMedMehrfach, 3, "MEDIKATION_MEHRFACH"},
	{I02_ROUTINEVERBANDSWECHSEL,	TYP_NUM,	34,  1, &LKFCheckRoutineverbandsw, 1, "ROUTINEVERBANDSWECHSEL"},
	{I02_VERBANDSWECHSEL_HAEUFIG,	TYP_NUM,	35,  1, &LKFCheckVerbandswHaeufig, 1, "VERBANDSWECHSEL_HAEUFIG"},
	{I02_DRAINAGENPFLEGE,			TYP_NUM,	36,  1, &LKFCheckDrainagenpflege, 3, "DRAINAGENPFLEGE"},
	{I02_BEATMUNG_MECH,				TYP_NUM,	37,  1, &LKFCheckBeatmungMech, 5, "BEATMUNG_MECH"},
	{I02_ATEMUNTERSTUETZUNG,		TYP_NUM,	38,  1, &LKFCheckAtemunterstuetzung, 2, "ATEMUNTERSTUETZUNG"},
	{I02_TUBUSPFLEGE,				TYP_NUM,	39,  1, &LKFCheckTubuspflege, 1, "TUBUSPFLEGE"},
	{I02_ATEMTHERAPIE,				TYP_NUM,	40,  1, &LKFCheckAtemtherapie, 1, "ATEMTHERAPIE"},
	{I02_MEDIKATION_VAS_EINMALIG, 	TYP_NUM,	41,  1, &LKFCheckMedVasoEinmalig, 3, "MEDIKATION_VAS_EINMALIG"},
	{I02_MEDIKATION_VAS_MEHRFACH,	TYP_NUM,	42,  1, &LKFCheckMedVasoMehrfach, 4, "MEDIKATION_VAS_MEHRFACH"},
	{I02_FLUESSIGERSATZ_MASSIV,		TYP_NUM,	43,  1, &LKFCheckFluessigkeitsers, 4, "FLUESSIGERSATZ_MASSIV"},
	{I02_KATHETER_ARTERIELL,		TYP_NUM,	44,  1, &LKFCheckKatheterArteriell, 5, "KATHETER_ARTERIELL"},
	{I02_PULMONALISKATHETER,		TYP_NUM,	45,  1, &LKFCheckPulmunalisKath, 8, "PULMONALISKATHETER"},
	{I02_KATHETER_ZENTRALVENOES,	TYP_NUM,	46,  1, &LKFCheckKathZentralvenoes, 2, "KATHETER_ZENTRALVENOES"},
	{I02_REANIMATION_KARDIO,		TYP_NUM,	47,  1, &LKFCheckReanimationKardio, 3, "REANIMATION_KARDIO"},
	{I02_NIERENERSATZTHERAPIE,		TYP_NUM,	48,  1, &LKFCheckNierenErsatzTher, 3, "NIERENERSATZTHERAPIE"},
	{I02_HARNBILANZIERUNG,			TYP_NUM,	49,  1, &LKFCheckHarnbilanzierung, 2, "HARNBILANZIERUNG"},
	{I02_DIURESE_AKTIV,				TYP_NUM,	50,  1, &LKFCheckDiurese, 3, "DIURESE_AKTIV"},
	{I02_HIRNDRUCKMESSUNG,			TYP_NUM,	51,  1, &LKFCheckHirndruckmessung, 4, "HIRNDRUCKMESSUNG"},
	{I02_METABOL_ENTGLEISUNGEN,		TYP_NUM,	52,  1, &LKFCheckBehMetabolEntgl, 4, "METABOL_ENTGLEISUNGEN"},
	{I02_ERNAEHRUNG_ENTERAL,		TYP_NUM,	53,  1, &LKFCheckErnaehrungEnteral, 2, "ERNAEHRUNG_ENTERAL"},
	{I02_ERNAEHRUNG_PARENTERAL, 	TYP_NUM,	54,  1, &LKFCheckErnaehrungParental, 3, "ERNAEHRUNG_PARENTERAL"},
	{I02_INTERVENTION_EINFACH,		TYP_NUM,	55,  1, &LKFCheckInterventEinfach, 3, "INTERVENTION_EINFACH"},
	{I02_INTERVENTION_MEHRFACH,		TYP_NUM,	56,  1, &LKFCheckInterventMehrfach, 5, "INTERVENTION_MEHRFACH"},
	{I02_DIAGTHER_AUSS_IBS,			TYP_NUM,	57,  1, &LKFCheckDiagnostTherAuss, 5, "DIAGTHER_AUSS_IBS"},
	{GEN_LINEID,					TYP_ALPHA,	58,  4, 0, 0, "ZEILEN-ID"}
}};

/* Satzart I03: TRISS-Daten */

const int i03_ident[] = {0,1,2,-1};

const SATZART Int03 = {"I03", 0, 16, 16, (const int *) &i03_ident, "TRISS-Daten", 0, {
	{GEN_KANR,					    TYP_ALPHA,   4,  6, 0, 0, "KANR"},
	{GEN_AUFNR,					    TYP_ALPHA,  10, 10, 0, 0, "AUFNR"},
	{GEN_ABTPOS,					TYP_NUM,    20,  2, &LKFCheckBHKPos, 0, "ABTPOS"},
	{I03_AIS_ABDOMEN,				TYP_NUM,    22,  1, &LKFCheckAISAbdomen, 0, "AIS_ABDOMEN"},
	{I03_AIS_EXTERN,				TYP_NUM,    23,  1, &LKFCheckAISExtern, 0, "AIS_EXTERN"},
	{I03_AIS_EXTREMITAETEN,			TYP_NUM,    24,  1, &LKFCheckAISExtremitaeten, 0, "AIS_EXTREMITAETEN"},
	{I03_AIS_GESICHT,				TYP_NUM,    25,  1, &LKFCheckAISGesicht, 0, "AIS_GESICHT"},
	{I03_AIS_HALS_KOPF,				TYP_NUM,    26,  1, &LKFCheckAISHalsKopf, 0, "AIS_HALS_KOPF"},
	{I03_AIS_THORAX,				TYP_NUM,    27,  1, &LKFCheckAISThorax, 0, "AIS_THORAX"},
	{I03_AIS_TYP,					TYP_NUM,    28,  1, &LKFCheckAISTyp, 0, "AIS_TYP"},
	{I03_COMASCALE_AUF_MOTREAK,		TYP_NUM,    29,  1, &LKFCheckGCSAufMotReak, 0, "COMASCALE_AUF_MOTREAK"},
	{I03_COMASCALE_AUF_VERBREAK,	TYP_NUM,    30,  1, &LKFCheckGCSAufVerbReak, 0, "COMASCALE_AUF_VERBREAK"},
	{I03_COMASCALE_AUF_VISREAK,		TYP_NUM,    31,  1, &LKFCheckGCSAufVisReak, 0, "COMASCALE_AUF_VISREAK"},
	{I03_SYST_BLUTDRUCK_AUFNAHME,	TYP_NUM,    32,  3, &LKFCheckSystArtBlutAuf, 0, "SYST_BLUTDRUCK_AUFNAHME"},
	{I03_ATEMFREQUENZ_AUFNAHME,		TYP_NUM,    35,  3, &LKFCheckAtemfrequenzAuf, 0, "ATEMFREQUENZ_AUFNAHME"},
	{GEN_LINEID,					TYP_ALPHA,	38,  4, 0, 0, "ZEILEN-ID"}
}};

/* Satzart I11 (V15.1 - Modell 2011) */

static const int i11_ident[] = {0,1,2,-1};

static const SATZART_FELD I12_LineId = {GEN_LINEID,					TYP_ALPHA,	124,  4, 0, 0, "ZEILEN-ID"},
				   I11_LineId = {GEN_LINEID,					TYP_ALPHA, 181,  4, 0, 0, "ZEILEN-ID"};

const SATZART Int11 = {"I11", 0, 37, 37, (const int *) &i11_ident, "SAPS3-Daten", 0, {
	{GEN_KANR,						TYP_ALPHA, 	 4,  6, 0, 0, "KANR"},
	{GEN_AUFNR,						TYP_ALPHA,	10, 10, 0, 0, "AUFNR"},
	{GEN_ABTPOS,					TYP_NUM,	20,  2, &LKFCheckBHKPos, 0, "ABTPOS"},
	{GEN_ERHEBDAT,					TYP_DAT,	22,  8, &LKFCheckErhebDat, 0, "ERHEBDAT"}, 
	{I11_AKUTEINF_AUFNAHME,			TYP_NUM,	30,  2, &LKFCheckAkuterInfekt, 0, "AKUTE INFEKTION BEI AUFNAHME"},
	{I11_AUFN_ANDERER,				TYP_NUM,	32,  1, &LKFCheckGrundAnderer, 0, "AUFNAHMEGRUND: ANDERER, NICHT KLASSIFIZIERT"},
	{I11_AUFN_BASISPFLEGE_OBSERVANZ,TYP_NUM,    33,  1, &LKFCheckGrundBasisPflege, 0, "AUFNAHMEGRUND: BASISPFLEGE UND OBSERVANZ"},
	{I11_AUFN_GASTROINTESTINAL,		TYP_NUM,    34,  1, &LKFCheckGrundGastro, 0, "AUFNAHMEGRUND: GASTROINTESTINAL"},
	{I11_AUFN_HAEMATOLOGISCH,		TYP_NUM,	35,  1, &LKFCheckGrundHaemat, 0, "AUFNAHMEGRUND: HAEMATOLOGISCH"},
	{I11_AUFN_KARDIOVASKULAER,		TYP_NUM,	36,  2, &LKFCheckGrundKardio, 0, "AUFNAHMEGRUND: KARDIOVASKULAER"},
	{I11_AUFN_LEBER,				TYP_NUM,	38,  1, &LKFCheckGrundLeber, 0, "AUFNAHMEGRUND: LEBER"},
	{I11_AUFN_METABOLISCH,			TYP_NUM,    39,  1, &LKFCheckGrundMetabolisch, 0, "AUFNAHMEGRUND: METABOLISCH"},
	{I11_AUFN_NEUROLOGISCH,			TYP_NUM,    40,  1, &LKFCheckGrundNeuro, 0, "AUFNAHMEGRUND: NEUROLOGISCH"},
	{I11_AUFN_RENAL,				TYP_NUM,	41,  1, &LKFCheckGrundRenal, 0, "AUFNAHMEGRUND: RENAL"},
	{I11_AUFN_RESPIRATORISCH,		TYP_NUM,    42,  1, &LKFCheckGrundRespi, 0, "AUFNAHMEGRUND: RESPIRATORISCH"},
	{I11_AUFN_SCHWERESTRAUMA,		TYP_NUM,	43,  1, &LKFCheckGrundTrauma, 0, "AUFNAHMEGRUND: SCHWERES TRAUMA"},
	{I11_AUFNAHMETYP,				TYP_NUM,    44,  1, &LKFCheckAufnahmeTyp, 0, "AUFNAHMETYP"},
	{I01_BLUTBILD_LEUKOZYTEN,		TYP_FLOAT,	45,  5, &LKFCheckBlutbildLeuko2011, 0, "BLUTBILD: LEUKOZYTEN (MINIMUM)"},
	{I11_BLUTBILD_PH,				TYP_FLOAT,	50,  4, &LKFCheckBlutbildPH, 0, "BLUTBILD: PH-WERT"},
	{I11_BLUTBILD_THROMBO,			TYP_NUM,	54,  4, &LKFCheckBlutbildThrombo, 0, "BLUTBILD: THROMBOZYTEN"},
	{I11_CHIRURGIE_EINGRIFF,		TYP_NUM,	58,  2, &LKFCheckChirurgieEingriff, 0, "CHIRURGIE-EINGRIFF"},
	{I11_CHIRURG_STATUS,			TYP_NUM,	60,  1, &LKFCheckChirurgischerStatus, 0, "CHIRURGISCHER STATUS"},
	{I01_COMASCALE_MOTORISCH,		TYP_NUM,	61,  1, &LKFCheckGCSmotReak, 0, "COMASCALE MOTORISCH"},
	{I01_COMASCALE_VERBAL,			TYP_NUM,	62,  1, &LKFCheckGCSverbReak, 0, "COMASCALE VERBAL"},
	{I01_COMASCALE_VISUELL,			TYP_NUM,	63,  1, &LKFCheckGCSvisReak2011, 0, "COMASCALE VISUELL"},
	{I01_HERZFREQUENZ,				TYP_NUM,	64,  3, &LKFCheckHerzfrequenz, 0, "HERZFREQUENZ (MAXIMUM)"},
	{I11_KOEXIST_ERKRANKUNGEN,		TYP_NUM,	67, 21, &LKFCheckKoexistErkrank, 0, "KOEXISTIERENDE ERKRANKUNGEN"},
	{I01_KOERPERTEMP,				TYP_FLOAT,	88,  4, &LKFCheckKoerpertemp2011, 0, "KOERPERTEMPERATUR (MAXIMUM)"},
	{I11_MECHANISCHE_BEATMUNG,		TYP_NUM,	92,  1, &LKFCheckMechBeatmung, 0, "MECHANISCHE BEATMUNG"},
	{I01_SAUERSTOFFPART,			TYP_FLOAT,	93,  5, &LKFCheckSauerstoffPart2011, 0, "SAUERSTOFF-PARTIALDRUCK ARTERIELL (PAO2)"},
	{I01_SAUERSTOFFKONZ_INSP,		TYP_NUM,	98,  3, &LKFCheckSauerstoffkonz2011, 0, "SAUERSTOFFKONZ INSP. (FIO2)"},
	{I01_SERUM_GESAMT_BILIRUBIN,	TYP_FLOAT, 101,  5, &LKFCheckSerumBilirubin2011, 0, "SERUM BILIRUBIN (MAXIMUM)"},
	{I11_SERUM_KREATININ,			TYP_FLOAT, 106,  4, &LKFCheckSerumKreatinin, 0, "SERUM KREATININ (MAXIMUM)"},
	{I01_SYSTOL_ARTER_BLUTDRUCK,	TYP_NUM,   110,  3, &LKFCheckSystArtBlutdruck2011, 0, "SYSTOLISCHER BLUTDRUCK (MINIMUM)"},
	{I11_THERAPEUTISCHE_MASSN,		TYP_NUM,   113,  3, &LKFCheckTheraepeutischeMN, 0, "THERAPEUTISCHE MASSNAHMEN (VOR IBS)"},
	{I11_ZUTRANSFERIERUNG,			TYP_NUM,   116,  1, &LKFCheckZutransferierung, 0, "ZUTRANSFERIERUNG"},
	{GEN_LINEID,					TYP_ALPHA, 117,  4, 0, 0, "ZEILEN-ID", 2015, &I11_LineId}
}};

const SATZART Int11_2017 = {"I11", 0, 39, 38, (const int *) &i11_ident, "SAPS3-Daten", 0, {
    {GEN_KANR,						TYP_ALPHA, 	 4, 20, 0, 0, "KANR"},
    {GEN_AUFNR,						TYP_ALPHA,	24, 12, 0, 0, "AUFNR"},
    {I11_DATENSATZID,				TYP_ALPHA,	36, 64, 0, 0, "DATENSATZ-ID"},
    {I11_AUFNAHMEDATUM,				TYP_ALPHA, 100,  8, 0, 0, "AUFNAHMEDATUM"},
    {GEN_ABTPOS,					TYP_NUM,   108,  3, &LKFCheckBHKPos, 0, "ABTPOS"},
    {GEN_ERHEBDAT,					TYP_DAT,   111,  8, &LKFCheckErhebDat, 0, "ERHEBDAT"},
    {I11_AKUTEINF_AUFNAHME,			TYP_NUM,   119,  2, &LKFCheckAkuterInfekt, 0, "AKUTE INFEKTION BEI AUFNAHME"},
    {I11_AUFN_ANDERER,				TYP_NUM,   121,  1, &LKFCheckGrundAnderer, 0, "AUFNAHMEGRUND: ANDERER, NICHT KLASSIFIZIERT"},
    {I11_AUFN_BASISPFLEGE_OBSERVANZ,TYP_NUM,   122,  1, &LKFCheckGrundBasisPflege, 0, "AUFNAHMEGRUND: BASISPFLEGE UND OBSERVANZ"},
    {I11_AUFN_GASTROINTESTINAL,		TYP_NUM,   123,  1, &LKFCheckGrundGastro, 0, "AUFNAHMEGRUND: GASTROINTESTINAL"},
    {I11_AUFN_HAEMATOLOGISCH,		TYP_NUM,   124,  1, &LKFCheckGrundHaemat, 0, "AUFNAHMEGRUND: HAEMATOLOGISCH"},
    {I11_AUFN_KARDIOVASKULAER,		TYP_NUM,   125,  2, &LKFCheckGrundKardio, 0, "AUFNAHMEGRUND: KARDIOVASKULAER"},
    {I11_AUFN_LEBER,				TYP_NUM,   127,  1, &LKFCheckGrundLeber, 0, "AUFNAHMEGRUND: LEBER"},
    {I11_AUFN_METABOLISCH,			TYP_NUM,   128,  1, &LKFCheckGrundMetabolisch, 0, "AUFNAHMEGRUND: METABOLISCH"},
    {I11_AUFN_NEUROLOGISCH,			TYP_NUM,   129,  1, &LKFCheckGrundNeuro, 0, "AUFNAHMEGRUND: NEUROLOGISCH"},
    {I11_AUFN_RENAL,				TYP_NUM,   130,  1, &LKFCheckGrundRenal, 0, "AUFNAHMEGRUND: RENAL"},
    {I11_AUFN_RESPIRATORISCH,		TYP_NUM,   131,  1, &LKFCheckGrundRespi, 0, "AUFNAHMEGRUND: RESPIRATORISCH"},
    {I11_AUFN_SCHWERESTRAUMA,		TYP_NUM,   132,  1, &LKFCheckGrundTrauma, 0, "AUFNAHMEGRUND: SCHWERES TRAUMA"},
    {I11_AUFNAHMETYP,				TYP_NUM,   133,  1, &LKFCheckAufnahmeTyp, 0, "AUFNAHMETYP"},
    {I01_BLUTBILD_LEUKOZYTEN,		TYP_FLOAT, 134,  5, &LKFCheckBlutbildLeuko2011, 0, "BLUTBILD: LEUKOZYTEN (MINIMUM)"},
    {I11_BLUTBILD_PH,				TYP_FLOAT, 139,  4, &LKFCheckBlutbildPH, 0, "BLUTBILD: PH-WERT"},
    {I11_BLUTBILD_THROMBO,			TYP_NUM,   143,  4, &LKFCheckBlutbildThrombo, 0, "BLUTBILD: THROMBOZYTEN"},
    {I11_CHIRURGIE_EINGRIFF,		TYP_NUM,   147,  2, &LKFCheckChirurgieEingriff, 0, "CHIRURGIE-EINGRIFF"},
    {I11_CHIRURG_STATUS,			TYP_NUM,   149,  1, &LKFCheckChirurgischerStatus, 0, "CHIRURGISCHER STATUS"},
    {I01_COMASCALE_MOTORISCH,		TYP_NUM,   150,  1, &LKFCheckGCSmotReak, 0, "COMASCALE MOTORISCH"},
    {I01_COMASCALE_VERBAL,			TYP_NUM,   151,  1, &LKFCheckGCSverbReak, 0, "COMASCALE VERBAL"},
    {I01_COMASCALE_VISUELL,			TYP_NUM,   152,  1, &LKFCheckGCSvisReak2011, 0, "COMASCALE VISUELL"},
    {I01_HERZFREQUENZ,				TYP_NUM,   153,  3, &LKFCheckHerzfrequenz, 0, "HERZFREQUENZ (MAXIMUM)"},
    {I11_KOEXIST_ERKRANKUNGEN,		TYP_NUM,   156, 21, &LKFCheckKoexistErkrank, 0, "KOEXISTIERENDE ERKRANKUNGEN"},
    {I01_KOERPERTEMP,				TYP_FLOAT, 177,  4, &LKFCheckKoerpertemp2011, 0, "KOERPERTEMPERATUR (MAXIMUM)"},
    {I11_MECHANISCHE_BEATMUNG,		TYP_NUM,   181,  1, &LKFCheckMechBeatmung, 0, "MECHANISCHE BEATMUNG"},
    {I01_SAUERSTOFFPART,			TYP_FLOAT, 182,  5, &LKFCheckSauerstoffPart2011, 0, "SAUERSTOFF-PARTIALDRUCK ARTERIELL (PAO2)"},
    {I01_SAUERSTOFFKONZ_INSP,		TYP_NUM,   187,  3, &LKFCheckSauerstoffkonz2011, 0, "SAUERSTOFFKONZ INSP. (FIO2)"},
    {I01_SERUM_GESAMT_BILIRUBIN,	TYP_FLOAT, 190,  5, &LKFCheckSerumBilirubin2011, 0, "SERUM BILIRUBIN (MAXIMUM)"},
    {I11_SERUM_KREATININ,			TYP_FLOAT, 195,  4, &LKFCheckSerumKreatinin, 0, "SERUM KREATININ (MAXIMUM)"},
    {I01_SYSTOL_ARTER_BLUTDRUCK,	TYP_NUM,   199,  3, &LKFCheckSystArtBlutdruck2011, 0, "SYSTOLISCHER BLUTDRUCK (MINIMUM)"},
    {I11_THERAPEUTISCHE_MASSN,		TYP_NUM,   202,  3, &LKFCheckTheraepeutischeMN, 0, "THERAPEUTISCHE MASSNAHMEN (VOR IBS)"},
    {I11_ZUTRANSFERIERUNG,			TYP_NUM,   205,  1, &LKFCheckZutransferierung, 0, "ZUTRANSFERIERUNG"},
    {GEN_LINEID,					TYP_ALPHA, 206,  4, 0, 0, "ZEILEN-ID", 2015, &I11_LineId}
}};


/* Satzart I12 (V15.1 - Modell 2011) */


static const int i12_ident[] = {0,1,2,-1};


const SATZART Int12 = {"I12", 0, 35, 35, (const int *) &i12_ident, "TISS-A-Daten", 0, {
    {GEN_KANR,					    TYP_ALPHA,   4,  6, 0, 0, "KANR"},
    {GEN_AUFNR,					    TYP_ALPHA,  10, 10, 0, 0, "AUFNR"},
    {GEN_ABTPOS,					TYP_NUM,    20,  2, &LKFCheckBHKPos, 0, "ABTPOS"},
    {GEN_ERHEBDAT,				    TYP_DAT,	22,  8, &LKFCheckErhebDat, 0, "ERHEBDAT"},
    {I02_STANDARD_MONITORING,		TYP_NUM,	30,  1, &LKFCheckStandardMonitoring2011, 0, "STANDARD_MONITORING"},
    {I02_LABOR,						TYP_NUM,	31,	 1, &LKFCheckLabor, 0, "LABOR"},
    {I12_MEDIKAMENTE,				TYP_NUM,	32,  1, &LKFCheckMedikamente, 0, "MEDIKAMENTE"},
    {I12_VERBANDSWECHSEL,			TYP_NUM,	33,  1, &LKFCheckVerbandswechsel, 0, "VERBANDSWECHSEL"},
    {I02_DRAINAGENPFLEGE,			TYP_NUM,	34,  1, &LKFCheckDrainagenpflege, 0, "DRAINAGENPFLEGE"},
    {I02_BEATMUNG_MECH,				TYP_NUM,	35,  1, &LKFCheckAtmungsmodus2011, 0, "ATMUNGSMODUS"},
    {I02_ATEMUNTERSTUETZUNG,		TYP_NUM,	36,  1, &LKFCheckAtemwegszugang, 0, "ATEMWEGSZUGANG"},
    {I02_TUBUSPFLEGE,				TYP_NUM,	37,  1, &LKFCheckTubuspflege, 0, "TUBUS-/STOMAPFLEGE"},
    {I02_ATEMTHERAPIE,				TYP_NUM,	38,  1, &LKFCheckAtemtherapie, 0, "ATEMTHERAPIE"},
    {I12_MEDIKAMENTE_VASOAKTIV,		TYP_NUM,	39,  1, &LKFCheckMedikamenteVasoaktiv, 0, "MEDIKAMENTE VASOAKTIV"},
    {I02_FLUESSIGERSATZ_MASSIV,		TYP_NUM,	40,  1, &LKFCheckFluessigkeitsers, 0, "FLUESSIGKEITSERSATZ_MASSIV"},
    {I02_KATHETER_ARTERIELL,		TYP_NUM,	41,  1, &LKFCheckKatheterArteriell, 0, "KATHETER ARTERIELL"},
    {I12_MONITORING_HAEMO,			TYP_NUM,	42,  1, &LKFCheckMonitoringHaemo, 0, "MONITORING HAEMODYNAMISCH"},
    {I02_KATHETER_ZENTRALVENOES,	TYP_NUM,	43,  1, &LKFCheckKathZentralvenoes, 0, "KATHETER ZENTRALVENOES"},
    {I02_REANIMATION_KARDIO,		TYP_NUM,	44,  1, &LKFCheckReanimationKardio, 0, "REANIMATION KARDIOPULMONAL"},
    {I02_NIERENERSATZTHERAPIE,		TYP_NUM,	45,  1, &LKFCheckNierenErsatzTher, 0, "NIERENERSATZTHERAPIE"},
    {I02_HARNBILANZIERUNG,			TYP_NUM,	46,  1, &LKFCheckHarnbilanzierung, 0, "HARNBILANZIERUNG"},
    {I02_DIURESE_AKTIV,				TYP_NUM,	47,  1, &LKFCheckDiurese, 0, "DIURESE"},
    {I02_HIRNDRUCKMESSUNG,			TYP_NUM,	48,  1, &LKFCheckHirndruckmessung, 0, "HIRNDRUCKMESSUNG"},
    {I02_METABOL_ENTGLEISUNGEN,		TYP_NUM,	49,  1, &LKFCheckBehMetabolEntgl, 0, "BEHANDLUNG METABOL. ENTGLEISUNGEN"},
    {I02_ERNAEHRUNG_ENTERAL,		TYP_NUM,	50,  1, &LKFCheckErnaehrungEnteral, 0, "ERNAEHRUNG ENTERAL"},
    {I02_ERNAEHRUNG_PARENTERAL, 	TYP_NUM,	51,  1, &LKFCheckErnaehrungParental, 0, "ERNAEHRUNG PARENTERAL"},
    {I12_INTERVENTIONEN,			TYP_NUM,	52,  1, &LKFCheckInterventionen, 0, "INTERVENTIONEN"},
    {I02_DIAGTHER_AUSS_IBS,			TYP_NUM,	53,  1, &LKFCheckDiagnostTherAuss, 0, "DIAGNOSTIK/THERAPIE AUSS. IBS"},
    {I12_AGITATION_DELIRIUM,		TYP_NUM,	54,  1, &LKFCheckAgitation, 0, "AGITATION UND DELIRIUM"},
    {I12_ASSIST_KARDIAL,			TYP_NUM,	55,  1, &LKFCheckAssistKardial, 0, "ASSIST KARDIAL"},
    {I12_ASSIST_PULMONAL,			TYP_NUM,	56,  1, &LKFCheckAssistPulmonal, 0, "ASSIST PULMONAL"},
    {I12_HYPOTHERMIE_THERAP,		TYP_NUM,	57,  1, &LKFCheckHypothermie, 0, "HYPOTHERMIE THERAPEUTISCH"},
    {I12_LEBERSUPPORT_EXTRAKORP,	TYP_NUM,	58,	 1, &LKFCheckLeberSupport, 0, "LEBERSUPPORT EXTRAKORPORAL"},
    {I12_KONT_INTRA_AKONVU_THERAP,	TYP_NUM,	59,  1, &LKFCheckAntikonvulsiveTherapie, 0, "KONTINUIERL. INTRAVEN. ANTIKONVULSIVE THERAPIE"},
    {GEN_LINEID,					TYP_ALPHA,	60,  4, 0, 0, "ZEILEN-ID", 2015, &I12_LineId}
}};


const SATZART Int12_2017 = {"I12", 0, 37, 36,(const int *) &i12_ident, "TISS-A-Daten", 0, {
    {GEN_KANR,						TYP_ALPHA, 	 4, 20, 0, 0, "KANR"},
    {GEN_AUFNR,						TYP_ALPHA,	24, 12, 0, 0, "AUFNR"},
    {I12_DATENSATZID,				TYP_ALPHA,	36, 64, 0, 0, "DATENSATZ-ID"},
    {I12_AUFNAHMEDATUM,				TYP_ALPHA, 100,  8, 0, 0, "AUFNAHMEDATUM"},
    {GEN_ABTPOS,					TYP_NUM,   108,  3, &LKFCheckBHKPos, 0, "ABTPOS"},
	{GEN_ERHEBDAT,				    TYP_DAT,   111,  8, &LKFCheckErhebDat, 0, "ERHEBDAT"},
	{I02_STANDARD_MONITORING,		TYP_NUM,   119,  1, &LKFCheckStandardMonitoring2011, 0, "STANDARD_MONITORING"},
	{I02_LABOR,						TYP_NUM,   120,	 1, &LKFCheckLabor, 0, "LABOR"},
	{I12_MEDIKAMENTE,				TYP_NUM,   121,  1, &LKFCheckMedikamente, 0, "MEDIKAMENTE"},
	{I12_VERBANDSWECHSEL,			TYP_NUM,   122,  1, &LKFCheckVerbandswechsel, 0, "VERBANDSWECHSEL"},
	{I02_DRAINAGENPFLEGE,			TYP_NUM,   123,  1, &LKFCheckDrainagenpflege, 0, "DRAINAGENPFLEGE"},
	{I02_BEATMUNG_MECH,				TYP_NUM,   124,  1, &LKFCheckAtmungsmodus2011, 0, "ATMUNGSMODUS"},
	{I02_ATEMUNTERSTUETZUNG,		TYP_NUM,   125,  1, &LKFCheckAtemwegszugang, 0, "ATEMWEGSZUGANG"},
	{I02_TUBUSPFLEGE,				TYP_NUM,   126,  1, &LKFCheckTubuspflege, 0, "TUBUS-/STOMAPFLEGE"},
	{I02_ATEMTHERAPIE,				TYP_NUM,   127,  1, &LKFCheckAtemtherapie, 0, "ATEMTHERAPIE"},
	{I12_MEDIKAMENTE_VASOAKTIV,		TYP_NUM,   128,  1, &LKFCheckMedikamenteVasoaktiv, 0, "MEDIKAMENTE VASOAKTIV"},
	{I02_FLUESSIGERSATZ_MASSIV,		TYP_NUM,   129,  1, &LKFCheckFluessigkeitsers, 0, "FLUESSIGKEITSERSATZ_MASSIV"},
	{I02_KATHETER_ARTERIELL,		TYP_NUM,   130,  1, &LKFCheckKatheterArteriell, 0, "KATHETER ARTERIELL"},
	{I12_MONITORING_HAEMO,			TYP_NUM,   131,  1, &LKFCheckMonitoringHaemo, 0, "MONITORING HAEMODYNAMISCH"},
	{I02_KATHETER_ZENTRALVENOES,	TYP_NUM,   132,  1, &LKFCheckKathZentralvenoes, 0, "KATHETER ZENTRALVENOES"},
	{I02_REANIMATION_KARDIO,		TYP_NUM,   133,  1, &LKFCheckReanimationKardio, 0, "REANIMATION KARDIOPULMONAL"},
	{I02_NIERENERSATZTHERAPIE,		TYP_NUM,   134,  1, &LKFCheckNierenErsatzTher, 0, "NIERENERSATZTHERAPIE"},
	{I02_HARNBILANZIERUNG,			TYP_NUM,   135,  1, &LKFCheckHarnbilanzierung, 0, "HARNBILANZIERUNG"},
	{I02_DIURESE_AKTIV,				TYP_NUM,   136,  1, &LKFCheckDiurese, 0, "DIURESE"},
	{I02_HIRNDRUCKMESSUNG,			TYP_NUM,   137,  1, &LKFCheckHirndruckmessung, 0, "HIRNDRUCKMESSUNG"},
	{I02_METABOL_ENTGLEISUNGEN,		TYP_NUM,   138,  1, &LKFCheckBehMetabolEntgl, 0, "BEHANDLUNG METABOL. ENTGLEISUNGEN"},
	{I02_ERNAEHRUNG_ENTERAL,		TYP_NUM,   139,  1, &LKFCheckErnaehrungEnteral, 0, "ERNAEHRUNG ENTERAL"},
	{I02_ERNAEHRUNG_PARENTERAL, 	TYP_NUM,   140,  1, &LKFCheckErnaehrungParental, 0, "ERNAEHRUNG PARENTERAL"},
	{I12_INTERVENTIONEN,			TYP_NUM,   141,  1, &LKFCheckInterventionen, 0, "INTERVENTIONEN"},
	{I02_DIAGTHER_AUSS_IBS,			TYP_NUM,   142,  1, &LKFCheckDiagnostTherAuss, 0, "DIAGNOSTIK/THERAPIE AUSS. IBS"},
	{I12_AGITATION_DELIRIUM,		TYP_NUM,   143,  1, &LKFCheckAgitation, 0, "AGITATION UND DELIRIUM"},
	{I12_ASSIST_KARDIAL,			TYP_NUM,   144,  1, &LKFCheckAssistKardial, 0, "ASSIST KARDIAL"},
	{I12_ASSIST_PULMONAL,			TYP_NUM,   145,  1, &LKFCheckAssistPulmonal, 0, "ASSIST PULMONAL"},
	{I12_HYPOTHERMIE_THERAP,		TYP_NUM,   146,  1, &LKFCheckHypothermie, 0, "HYPOTHERMIE THERAPEUTISCH"},
	{I12_LEBERSUPPORT_EXTRAKORP,	TYP_NUM,   147,	 1, &LKFCheckLeberSupport, 0, "LEBERSUPPORT EXTRAKORPORAL"},
	{I12_KONT_INTRA_AKONVU_THERAP,	TYP_NUM,   148,  1, &LKFCheckAntikonvulsiveTherapie, 0, "KONTINUIERL. INTRAVEN. ANTIKONVULSIVE THERAPIE"},
	{GEN_LINEID,					TYP_ALPHA, 149,  4, 0, 0, "ZEILEN-ID", 2015, &I12_LineId}
}};

/* Satzart M02: Zusaetzliche Daten des M02-Satzes fuer Intensivscoring */

const SATZART IntAbt = {"M02", 35, 7, 7, 0, "Abteilungssatz - Intscoringerweiterungen", 0, {
	{M02_ZUGANGSUHRZEIT,		TYP_ZEIT,	 1,  4, 0, 0, "ZUGANGSUHRZEIT"},
	{M02_AUFART_INTENSIV,		TYP_NUM,	 5,  1, 0, 0, "AUFART_INTENSIV"},
	{M02_AUFART_SAPSII,			TYP_NUM,	 6,  1, 0, 0, "AUFART_SAPSII"},
	{M02_COEXIST_ERKRANKUNGEN,	TYP_NUM,	 7, 20, 0, 0, "COEXIST_ERKRANKUNGEN"},
	{M02_ABGANGSDATUM,			TYP_DAT,	27,  8, 0, 0, "ABGANGSDATUM"},
	{M02_ABGANGSUHRZEIT,		TYP_ZEIT,	35,  4, 0, 0, "ABGANGSUHRZEIT"},
	{M02_ABGANGSART,			TYP_NUM,	39,  1, 0, 0, "ABGANGSART"}
}};

/* V16.0: Satzart M02: Zusaetzliche Daten des M02-Satzes fuer Intensivscoring (Nicht-Fonds) */

const SATZART IntAbt_NFonds = {"M02NF", 35, 4, 4, 0, "NICHT-FONDS: Abteilungssatz - Intscoringerweiterungen", 0, {
	{M02_ZUGANGSUHRZEIT,		TYP_ZEIT,	 1,  4, 0, 0, "ZUGANGSUHRZEIT"},
	{M02_ABGANGSDATUM,			TYP_DAT,	 5,  8, 0, 0, "ABGANGSDATUM"},
	{M02_ABGANGSUHRZEIT,		TYP_ZEIT,	13,  4, 0, 0, "ABGANGSUHRZEIT"},
	{M02_ABGANGSART,			TYP_NUM,	17,  1, 0, 0, "ABGANGSART"}
}};


const int sum_ident[] = {0,1,2,3,4,-1};

const SATZART SumSatz = {"S01", 0, 51, 51, (const int *) &sum_ident, "Pruef- und Summensatz", 0, {
	{GEN_JAHR,					TYP_NUM,     4,  4, 0, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,   8,  6, 0, 0, "KANR"},
	{S01_PERIODE,				TYP_ALPHA,  14,  1, 0, 0, "PERIODE"},
	{S01_PERIODENNUMMER,		TYP_ALPHA,  15,  3, 0, 0, "PERIODENNUMMER"},
	{S01_LFDNR,					TYP_ALPHA,  18,  2, 0, 0, "LFDNR"},
	{S01_ANZAHL_M+1,			TYP_NUM,	20, 10, 0, 0, "ANZAHL_M01"},
	{S01_ANZAHL_M+2,			TYP_NUM,	30, 10, 0, 0, "ANZAHL_M02"},
	{S01_ANZAHL_M+3,			TYP_NUM,	40, 10, 0, 0, "ANZAHL_M03"},
	{S01_ANZAHL_M+4,			TYP_NUM,	50, 10, 0, 0, "ANZAHL_M04"},
	{S01_ANZAHL_M+5,			TYP_NUM,	60, 10, 0, 0, "ANZAHL_M05"},
	{S01_ANZAHL_M+6,			TYP_NUM,	70, 10, 0, 0, "ANZAHL_M06"},
	{S01_ANZAHL_M+7,			TYP_NUM,	80, 10, 0, 0, "ANZAHL_M07"},
	{S01_ANZAHL_M+8,			TYP_NUM,	90, 10, 0, 0, "ANZAHL_M08"},
	{S01_ANZAHL_I+1,			TYP_NUM,	100, 10, 0, 0, "ANZAHL_I01"},
	{S01_ANZAHL_I+2,			TYP_NUM,	110, 10, 0, 0, "ANZAHL_I02"},
	{S01_ANZAHL_I+3,			TYP_NUM,	120, 10, 0, 0, "ANZAHL_I03"},
	{S01_ANZAHL_L+1,			TYP_NUM,	130, 10, 0, 0, "ANZAHL_L01"},
	{S01_ANZAHL_L+2,			TYP_NUM,	140, 10, 0, 0, "ANZAHL_L02"},
	{S01_ANZAHL_L+3,			TYP_NUM,	150, 10, 0, 0, "ANZAHL_L03"},
	{S01_ANZAHL_L+4,			TYP_NUM,	160, 10, 0, 0, "ANZAHL_L04"},
	{S01_ANZAHL_K+1,			TYP_NUM,	170, 10, 0, 0, "ANZAHL_K01"},
	{S01_ANZAHL_K+2,			TYP_NUM,	180, 10, 0, 0, "ANZAHL_K02"},
	{S01_ANZAHL_K+3,			TYP_NUM,	190, 10, 0, 0, "ANZAHL_K03"},
	{S01_ANZAHL_K+4,			TYP_NUM,	200, 10, 0, 0, "ANZAHL_K04"},
	{S01_ANZAHL_K+5,			TYP_NUM,	210, 10, 0, 0, "ANZAHL_K05"},
	{S01_ANZAHL_K+6,			TYP_NUM,	220, 10, 0, 0, "ANZAHL_K06"},
	{S01_ANZAHL_K+7,			TYP_NUM,	230, 10, 0, 0, "ANZAHL_K07"},
	{S01_ANZAHL_K+8,			TYP_NUM,	240, 10, 0, 0, "ANZAHL_K08"},
	{S01_ANZAHL_K+9,			TYP_NUM,	250, 10, 0, 0, "ANZAHL_K09"},
	{S01_ANZAHL_K+10,			TYP_NUM,	260, 10, 0, 0, "ANZAHL_K10"},
	{S01_ANZAHL_K+11,			TYP_NUM,	270, 10, 0, 0, "ANZAHL_K11"},
	{S01_ANZAHL_K+12,			TYP_NUM,	280, 10, 0, 0, "ANZAHL_K12"},
	{S01_ANZAHL_K+13,			TYP_NUM,	290, 10, 0, 0, "ANZAHL_K13"},
	{S01_ANZAHL_K+14,			TYP_NUM,	300, 10, 0, 0, "ANZAHL_K14"},
	{S01_ANZAHL_K+15,			TYP_NUM,	310, 10, 0, 0, "ANZAHL_K15"},
	{S01_ANZAHL_K+16,			TYP_NUM,	320, 10, 0, 0, "ANZAHL_K16"},
	{S01_ANZAHL_G+1,			TYP_NUM,	330, 10, 0, 0, "ANZAHL_G01"},
	{S01_ANZAHL_G+2,			TYP_NUM,	340, 10, 0, 0, "ANZAHL_G02"},
	{S01_ANZAHL_FEHLER,			TYP_NUM,	350, 10, 0, 0, "ANZAHL_FEHLER"},
	{S01_ANZAHL_WARNINGS,		TYP_NUM,	360, 10, 0, 0, "ANZAHL_WARNINGS"},
	{S01_PUNKTE_LDF_LEIST,		TYP_NUM,	370, 10, 0, 0, "PUNKTE_LDF_LEIST"},
	{S01_PUNKTE_LDF_TAG,		TYP_NUM,	380, 10, 0, 0, "PUNKTE_LDF_TAG"},
	{S01_PUNKTE_BELAG_UNTEN_LEIST,	TYP_NUM,	390, 10, 0, 0, "PUNKTE_BELAG_UNTEN_LEIST"},
	{S01_PUNKTE_BELAG_UNTEN_TAG,	TYP_NUM,	400, 10, 0, 0, "PUNKTE_BELAG_UNTEN_TAG"},
	{S01_ZUSATZPUNKTE_BELAG_OBEN,	TYP_NUM,	410, 10, 0, 0, "ZUSATZPUNKTE_BELAG_OBEN"},
	{S01_ZUSATZPUNKTE_INTENSIV,		TYP_NUM,	420, 10, 0, 0, "ZUSATZPUNKTE_INTENSIV"},
	{S01_ZUSATZPUNKTE_MEHRFACH_MEL,	TYP_NUM,	430, 10, 0, 0, "ZUSATZPUNKTE_MEHRFACH_MEL"},
	{S01_PUNKTE_SPEZ,				TYP_NUM,	440, 10, 0, 0, "PUNKTE_SPEZ"},
	{S01_PUNKTE_TOT_INNERHALB_LKF,	TYP_NUM,	450, 10, 0, 0, "PUNKTE_TOT_INNERHALB_LKF"},
	{S01_PUNKTE_TOT_AUSSERHALB_LKF, TYP_NUM,	460, 10, 0, 0, "PUNKTE_TOT_AUSSERHALB_LKF"},
	{S01_KOMMENTAR,					TYP_NUM,	470, 200, 0, 0, "KOMMENTAR"}
}};

const SATZART SumSatz2012 = {"S11", 0, 51, 51, (const int *) &sum_ident, "Pruef- und Summensatz", 0, {
	{GEN_JAHR,					TYP_NUM,     4,  4, 0, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,   8,  6, 0, 0, "KANR"},
	{S01_PERIODE,				TYP_ALPHA,  14,  1, 0, 0, "PERIODE"},
	{S01_PERIODENNUMMER,		TYP_ALPHA,  15,  3, 0, 0, "PERIODENNUMMER"},
	{S01_LFDNR,					TYP_ALPHA,  18,  2, 0, 0, "LFDNR"},
	{S01_ANZAHL_M+1,			TYP_NUM,	20, 10, 0, 0, "ANZAHL_M01"},
	{S01_ANZAHL_M+2,			TYP_NUM,	30, 10, 0, 0, "ANZAHL_M02"},
	{S01_ANZAHL_M+3,			TYP_NUM,	40, 10, 0, 0, "ANZAHL_M03"},
	{S01_ANZAHL_M+4,			TYP_NUM,	50, 10, 0, 0, "ANZAHL_M04"},
	{S01_ANZAHL_M+5,			TYP_NUM,	60, 10, 0, 0, "ANZAHL_M05"},
	{S01_ANZAHL_M+6,			TYP_NUM,	70, 10, 0, 0, "ANZAHL_M06"},
	{S01_ANZAHL_M+7,			TYP_NUM,	80, 10, 0, 0, "ANZAHL_M07"},
	{S01_ANZAHL_M+8,			TYP_NUM,	90, 10, 0, 0, "ANZAHL_M08"},
	{S01_ANZAHL_I+1,			TYP_NUM,	100, 10, 0, 0, "ANZAHL_I11"},
	{S01_ANZAHL_I+2,			TYP_NUM,	110, 10, 0, 0, "ANZAHL_I12"},
	{S01_ANZAHL_I+3,			TYP_NUM,	120, 10, 0, 0, "LEER"},
	{S01_ANZAHL_L+1,			TYP_NUM,	130, 10, 0, 0, "ANZAHL_L01"},
	{S01_ANZAHL_L+2,			TYP_NUM,	140, 10, 0, 0, "ANZAHL_L02"},
	{S01_ANZAHL_L+3,			TYP_NUM,	150, 10, 0, 0, "ANZAHL_L03"},
	{S01_ANZAHL_L+4,			TYP_NUM,	160, 10, 0, 0, "ANZAHL_L04"},
	{S01_ANZAHL_K+1,			TYP_NUM,	170, 10, 0, 0, "ANZAHL_K01"},
	{S01_ANZAHL_K+2,			TYP_NUM,	180, 10, 0, 0, "ANZAHL_K02"},
	{S01_ANZAHL_K+3,			TYP_NUM,	190, 10, 0, 0, "ANZAHL_K03"},
	{S01_ANZAHL_K+4,			TYP_NUM,	200, 10, 0, 0, "ANZAHL_K04"},
	{S01_ANZAHL_K+5,			TYP_NUM,	210, 10, 0, 0, "ANZAHL_K05"},
	{S01_ANZAHL_K+6,			TYP_NUM,	220, 10, 0, 0, "ANZAHL_K06"},
	{S01_ANZAHL_K+7,			TYP_NUM,	230, 10, 0, 0, "ANZAHL_K07"},
	{S01_ANZAHL_K+8,			TYP_NUM,	240, 10, 0, 0, "ANZAHL_K08"},
	{S01_ANZAHL_K+9,			TYP_NUM,	250, 10, 0, 0, "ANZAHL_K09"},
	{S01_ANZAHL_K+10,			TYP_NUM,	260, 10, 0, 0, "ANZAHL_K10"},
	{S01_ANZAHL_K+11,			TYP_NUM,	270, 10, 0, 0, "ANZAHL_K11"},
	{S01_ANZAHL_K+12,			TYP_NUM,	280, 10, 0, 0, "ANZAHL_K12"},
	{S01_ANZAHL_K+13,			TYP_NUM,	290, 10, 0, 0, "ANZAHL_K13"},
	{S01_ANZAHL_K+14,			TYP_NUM,	300, 10, 0, 0, "ANZAHL_K14"},
	{S01_ANZAHL_K+15,			TYP_NUM,	310, 10, 0, 0, "ANZAHL_K15"},
	{S01_ANZAHL_K+16,			TYP_NUM,	320, 10, 0, 0, "ANZAHL_K16"},
	{S01_ANZAHL_G+1,			TYP_NUM,	330, 10, 0, 0, "ANZAHL_G01"},
	{S01_ANZAHL_G+2,			TYP_NUM,	340, 10, 0, 0, "ANZAHL_G02"},
	{S01_ANZAHL_FEHLER,			TYP_NUM,	350, 10, 0, 0, "ANZAHL_FEHLER"},
	{S01_ANZAHL_WARNINGS,		TYP_NUM,	360, 10, 0, 0, "ANZAHL_WARNINGS"},
	{S01_PUNKTE_LDF_LEIST,		TYP_NUM,	370, 10, 0, 0, "PUNKTE_LDF_LEIST"},
	{S01_PUNKTE_LDF_TAG,		TYP_NUM,	380, 10, 0, 0, "PUNKTE_LDF_TAG"},
	{S01_PUNKTE_BELAG_UNTEN_LEIST,	TYP_NUM,	390, 10, 0, 0, "PUNKTE_BELAG_UNTEN_LEIST"},
	{S01_PUNKTE_BELAG_UNTEN_TAG,	TYP_NUM,	400, 10, 0, 0, "PUNKTE_BELAG_UNTEN_TAG"},
	{S01_ZUSATZPUNKTE_BELAG_OBEN,	TYP_NUM,	410, 10, 0, 0, "ZUSATZPUNKTE_BELAG_OBEN"},
	{S01_ZUSATZPUNKTE_INTENSIV,		TYP_NUM,	420, 10, 0, 0, "ZUSATZPUNKTE_INTENSIV"},
	{S01_ZUSATZPUNKTE_MEHRFACH_MEL,	TYP_NUM,	430, 10, 0, 0, "ZUSATZPUNKTE_MEHRFACH_MEL"},
	{S01_PUNKTE_SPEZ,				TYP_NUM,	440, 10, 0, 0, "PUNKTE_SPEZ"},
	{S01_PUNKTE_TOT_INNERHALB_LKF,	TYP_NUM,	450, 10, 0, 0, "PUNKTE_TOT_INNERHALB_LKF"},
	{S01_PUNKTE_TOT_AUSSERHALB_LKF, TYP_NUM,	460, 10, 0, 0, "PUNKTE_TOT_AUSSERHALB_LKF"},
	{S01_KOMMENTAR,					TYP_NUM,	470, 200, 0, 0, "KOMMENTAR"}
}};

const SATZART SumSatz2017 = {"S11", 0, 55, 55,(const int *) &sum_ident, "Pruef- und Summensatz", 0, {
    {GEN_JAHR,					TYP_NUM,      4,  4, 0, 0, "JAHR"},
    {GEN_KANR,					TYP_ALPHA,    8, 20, 0, 0, "KANR"},
    {S01_ANZAHL_M+1,			TYP_NUM,	 28, 10, 0, 0, "ANZAHL_X01"},
    {S01_ANZAHL_M+2,			TYP_NUM,	 38, 10, 0, 0, "ANZAHL_X02"},
    {S01_ANZAHL_M+3,			TYP_NUM,	 48, 10, 0, 0, "ANZAHL_X03"},
    {S01_ANZAHL_M+4,			TYP_NUM,	 58, 10, 0, 0, "ANZAHL_X04"},
    {S01_ANZAHL_M+5,			TYP_NUM,	 68, 10, 0, 0, "ANZAHL_X05"},
    {S01_ANZAHL_M+6,			TYP_NUM,	 78, 10, 0, 0, "ANZAHL_X06"},
    {S01_ANZAHL_M+7,			TYP_NUM,	 88, 10, 0, 0, "ANZAHL_X07"},
    {S01_ANZAHL_I+1,			TYP_NUM,	 98, 10, 0, 0, "ANZAHL_I11"},
    {S01_ANZAHL_I+2,			TYP_NUM,	108, 10, 0, 0, "ANZAHL_I12"},
    {S01_ANZAHL_L+1,			TYP_NUM,	118, 10, 0, 0, "ANZAHL_L01"},
    {S01_ANZAHL_L+2,			TYP_NUM,	128, 10, 0, 0, "ANZAHL_L02"},
    {S01_ANZAHL_L+3,			TYP_NUM,	138, 10, 0, 0, "ANZAHL_L03"},
    {S01_ANZAHL_L+4,			TYP_NUM,	148, 10, 0, 0, "ANZAHL_L04"},
    {S11_E01,                   TYP_NUM,	158, 10, 0, 0, "ANZAHL_E01"},
    {S11_P01,                   TYP_NUM,	168, 10, 0, 0, "ANZAHL_P01"},
    {S11_P02,                   TYP_NUM,	178, 10, 0, 0, "ANZAHL_P02"},
    {S01_ANZAHL_K+1,			TYP_NUM,	188, 10, 0, 0, "ANZAHL_K01"},
    {S01_ANZAHL_K+2,			TYP_NUM,	198, 10, 0, 0, "ANZAHL_K02"},
    {S01_ANZAHL_K+3,			TYP_NUM,	208, 10, 0, 0, "ANZAHL_K03"},
    {S01_ANZAHL_K+4,			TYP_NUM,	218, 10, 0, 0, "ANZAHL_K04"},
    {S01_ANZAHL_K+5,			TYP_NUM,	228, 10, 0, 0, "ANZAHL_K05"},
    {S01_ANZAHL_K+6,			TYP_NUM,	238, 10, 0, 0, "ANZAHL_K06"},
    {S01_ANZAHL_K+7,			TYP_NUM,	248, 10, 0, 0, "ANZAHL_K07"},
    {S01_ANZAHL_K+8,			TYP_NUM,	258, 10, 0, 0, "ANZAHL_K08"},
    {S01_ANZAHL_K+9,			TYP_NUM,	268, 10, 0, 0, "ANZAHL_K09"},
    {S01_ANZAHL_K+10,			TYP_NUM,	278, 10, 0, 0, "ANZAHL_K10"},
    {S01_ANZAHL_K+11,			TYP_NUM,	288, 10, 0, 0, "ANZAHL_K11"},
    {S01_ANZAHL_K+12,			TYP_NUM,	298, 10, 0, 0, "ANZAHL_K12"},
    {S01_ANZAHL_K+13,			TYP_NUM,	308, 10, 0, 0, "ANZAHL_K13"},
    {S01_ANZAHL_K+14,			TYP_NUM,	318, 10, 0, 0, "ANZAHL_K14"},
    {S01_ANZAHL_K+15,			TYP_NUM,	328, 10, 0, 0, "ANZAHL_K15"},
    {S01_ANZAHL_K+16,			TYP_NUM,	338, 10, 0, 0, "ANZAHL_K16"},
    {S01_ANZAHL_G+1,			TYP_NUM,	348, 10, 0, 0, "ANZAHL_G01"},
    {S01_ANZAHL_G+2,			TYP_NUM,	358, 10, 0, 0, "ANZAHL_G02"},
    {S11_ANZAHL_B+1,			TYP_NUM,	368, 10, 0, 0, "ANZAHL_B01"},
    {S11_ANZAHL_B+2,			TYP_NUM,	378, 10, 0, 0, "ANZAHL_B02"},
    {S11_ANZAHL_B+3,			TYP_NUM,	388, 10, 0, 0, "ANZAHL_B03"},
    {S11_ANZAHL_B+4,			TYP_NUM,	398, 10, 0, 0, "ANZAHL_B04"},
    {S11_ANZAHL_B+5,			TYP_NUM,	408, 10, 0, 0, "ANZAHL_B05"},
    {S11_ANZAHL_B+6,			TYP_NUM,	418, 10, 0, 0, "ANZAHL_B06"},
    {S01_ANZAHL_FEHLER,			TYP_NUM,	428, 10, 0, 0, "ANZAHL_FEHLER"},
    {S01_ANZAHL_WARNINGS,		TYP_NUM,	438, 10, 0, 0, "ANZAHL_WARNINGS"},
    {S01_PUNKTE_LDF_LEIST,		TYP_NUM,	448, 10, 0, 0, "PUNKTE_LDF_LEIST"},
    {S01_PUNKTE_LDF_TAG,		TYP_NUM,	458, 10, 0, 0, "PUNKTE_LDF_TAG"},
    {S01_PUNKTE_BELAG_UNTEN_LEIST,	TYP_NUM,	468, 10, 0, 0, "PUNKTE_BELAG_UNTEN_LEIST"},
    {S01_PUNKTE_BELAG_UNTEN_TAG,	TYP_NUM,	478, 10, 0, 0, "PUNKTE_BELAG_UNTEN_TAG"},
    {S01_ZUSATZPUNKTE_BELAG_OBEN,	TYP_NUM,	488, 10, 0, 0, "ZUSATZPUNKTE_BELAG_OBEN"},
    {S01_ZUSATZPUNKTE_INTENSIV,		TYP_NUM,	498, 10, 0, 0, "ZUSATZPUNKTE_INTENSIV"},
    {S01_ZUSATZPUNKTE_MEHRFACH_MEL,	TYP_NUM,	508, 10, 0, 0, "ZUSATZPUNKTE_MEHRFACH_MEL"},
    {S01_PUNKTE_SPEZ,				TYP_NUM,	518, 10, 0, 0, "PUNKTE_SPEZ"},
    {S01_PUNKTE_TOT_INNERHALB_LKF,	TYP_NUM,	528, 10, 0, 0, "PUNKTE_TOT_INNERHALB_LKF"},
    {S01_PUNKTE_TOT_AUSSERHALB_LKF, TYP_NUM,	538, 10, 0, 0, "PUNKTE_TOT_AUSSERHALB_LKF"},
    {S01_KOMMENTAR,					TYP_NUM,	548, 200, 0, 0, "KOMMENTAR"}
}};


const SATZART SumSatz2025 = {"S11", 0, 55, 55,(const int *) &sum_ident, "Pruef- und Summensatz", 0, {
    {GEN_JAHR,                  TYP_NUM,      4,  4, 0, 0, "JAHR"},
    {GEN_KANR,                  TYP_ALPHA,    8, 20, 0, 0, "KANR"},
    {S01_ANZAHL_M+1,            TYP_NUM,     28, 10, 0, 0, "ANZAHL_X01"},
    {S01_ANZAHL_M+2,            TYP_NUM,     38, 10, 0, 0, "ANZAHL_X02"},
    {S01_ANZAHL_M+3,            TYP_NUM,     48, 10, 0, 0, "ANZAHL_X03"},
    {S01_ANZAHL_M+4,            TYP_NUM,     58, 10, 0, 0, "ANZAHL_X04"},
    {S01_ANZAHL_M+5,            TYP_NUM,     68, 10, 0, 0, "ANZAHL_X05"},
    {S01_ANZAHL_M+6,            TYP_NUM,     78, 10, 0, 0, "ANZAHL_X06"},
    {S01_ANZAHL_M+7,            TYP_NUM,     88, 10, 0, 0, "ANZAHL_X07"},
    {S01_ANZAHL_I+1,            TYP_NUM,     98, 10, 0, 0, "ANZAHL_I11"},
    {S01_ANZAHL_I+2,            TYP_NUM,    108, 10, 0, 0, "ANZAHL_I12"},
    {S01_ANZAHL_L+1,            TYP_NUM,    118, 10, 0, 0, "ANZAHL_L01"},
    {S01_ANZAHL_L+2,            TYP_NUM,    128, 10, 0, 0, "ANZAHL_L02"},
    {S01_ANZAHL_L+3,            TYP_NUM,    138, 10, 0, 0, "ANZAHL_L03"},
    {S01_ANZAHL_L+4,            TYP_NUM,    148, 10, 0, 0, "ANZAHL_L04"},
    {S01_ANZAHL_K+1,            TYP_NUM,    158, 10, 0, 0, "ANZAHL_K01"},
    {S01_ANZAHL_K+2,            TYP_NUM,    168, 10, 0, 0, "ANZAHL_K02"},
    {S01_ANZAHL_K+3,            TYP_NUM,    178, 10, 0, 0, "ANZAHL_K03"},
    {S01_ANZAHL_K+4,            TYP_NUM,    188, 10, 0, 0, "ANZAHL_K04"},
    {S01_ANZAHL_K+5,            TYP_NUM,    198, 10, 0, 0, "ANZAHL_K05"},
    {S01_ANZAHL_K+6,            TYP_NUM,    208, 10, 0, 0, "ANZAHL_K06"},
    {S01_ANZAHL_K+7,            TYP_NUM,    218, 10, 0, 0, "ANZAHL_K07"},
    {S01_ANZAHL_K+8,            TYP_NUM,    228, 10, 0, 0, "ANZAHL_K08"},
    {S01_ANZAHL_K+9,            TYP_NUM,    238, 10, 0, 0, "ANZAHL_K09"},
    {S01_ANZAHL_K+10,           TYP_NUM,    248, 10, 0, 0, "ANZAHL_K10"},
    {S01_ANZAHL_K+11,           TYP_NUM,    258, 10, 0, 0, "ANZAHL_K11"},
    {S01_ANZAHL_K+12,           TYP_NUM,    268, 10, 0, 0, "ANZAHL_K12"},
    {S01_ANZAHL_K+13,           TYP_NUM,    278, 10, 0, 0, "ANZAHL_K13"},
    {S01_ANZAHL_K+14,           TYP_NUM,    288, 10, 0, 0, "ANZAHL_K14"},
    {S01_ANZAHL_K+15,           TYP_NUM,    298, 10, 0, 0, "ANZAHL_K15"},
    {S01_ANZAHL_K+16,           TYP_NUM,    308, 10, 0, 0, "ANZAHL_K16"},
    {S01_ANZAHL_G+1,            TYP_NUM,    318, 10, 0, 0, "ANZAHL_G01"},
    {S01_ANZAHL_G+2,            TYP_NUM,    328, 10, 0, 0, "ANZAHL_G02"},
    {S11_ANZAHL_B+1,            TYP_NUM,    338, 10, 0, 0, "ANZAHL_B01"},
    {S11_ANZAHL_B+2,            TYP_NUM,    348, 10, 0, 0, "ANZAHL_B02"},
    {S11_ANZAHL_B+3,            TYP_NUM,    358, 10, 0, 0, "ANZAHL_B03"},
    {S11_ANZAHL_B+4,            TYP_NUM,    368, 10, 0, 0, "ANZAHL_B04"},
    {S11_ANZAHL_B+5,            TYP_NUM,    378, 10, 0, 0, "ANZAHL_B05"},
    {S11_ANZAHL_B+6,            TYP_NUM,    388, 10, 0, 0, "ANZAHL_B06"},
    {S11_A01,                   TYP_NUM,    398, 10, 0, 0, "ANZAHL_A01"},
    {S01_ANZAHL_FEHLER,         TYP_NUM,    408, 10, 0, 0, "ANZAHL_FEHLER"},
    {S01_ANZAHL_WARNINGS,       TYP_NUM,    418, 10, 0, 0, "ANZAHL_WARNINGS"},
    {S01_PUNKTE_LDF_LEIST,      TYP_NUM,    428, 10, 0, 0, "PUNKTE_LDF_LEIST"},
    {S01_PUNKTE_LDF_TAG,        TYP_NUM,    438, 10, 0, 0, "PUNKTE_LDF_TAG"},
    {S01_PUNKTE_BELAG_UNTEN_LEIST, TYP_NUM, 448, 10, 0, 0, "PUNKTE_BELAG_UNTEN_LEIST"},
    {S01_PUNKTE_BELAG_UNTEN_TAG,   TYP_NUM, 458, 10, 0, 0, "PUNKTE_BELAG_UNTEN_TAG"},
    {S01_ZUSATZPUNKTE_BELAG_OBEN,  TYP_NUM, 468, 10, 0, 0, "ZUSATZPUNKTE_BELAG_OBEN"},
    {S01_ZUSATZPUNKTE_INTENSIV,    TYP_NUM, 478, 10, 0, 0, "ZUSATZPUNKTE_INTENSIV"},
    {S01_ZUSATZPUNKTE_MEHRFACH_MEL,TYP_NUM, 488, 10, 0, 0, "ZUSATZPUNKTE_MEHRFACH_MEL"},
    {S01_PUNKTE_SPEZ,              TYP_NUM, 498, 10, 0, 0, "PUNKTE_SPEZ"},
    {S01_PUNKTE_TOT_INNERHALB_LKF, TYP_NUM, 508, 10, 0, 0, "PUNKTE_TOT_INNERHALB_LKF"},
    {S01_PUNKTE_TOT_AUSSERHALB_LKF,TYP_NUM, 518, 10, 0, 0, "PUNKTE_TOT_AUSSERHALB_LKF"},
    {S01_KOMMENTAR,                TYP_NUM, 528, 200, 0, 0, "KOMMENTAR"}
}};



const int l01internal_ident[] = {3,0,5,-1};

const SATZART L01SatzartInternal = {"L01", 0, 7, 7, (const int *) &l01internal_ident, "Spezielle Leistungsbereiche", 0, {
	{L01_LEISTUNGSBEREICH,		TYP_ALPHA,	 1,  1, 0, 0, "LEISTUNGSBEREICH"},
	{GEN_JAHR,					TYP_NUM,	 2,  4, 0, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 6,  4, 0, 0, "KANR"},
	{GEN_ABTFC,					TYP_NUM,	10,  8, 0, 0, "ABTFC"},
	{L01_FILL,					TYP_ALPHA,	18, 10, 0, 0, "FILL"},
	{L01_GRUPPE_STUFE,			TYP_ALPHA,	28,  2, 0, 0, "GRUPPE_STUFE"},
	{L01_PUNKTE,				TYP_NUM,	30,  6, 0, 0, "PUNKTE"}
}};


const int l01_ident[] = {0,1,2,3,4,-1};

const SATZART L01Satzart = {"L01", 0, 6, 6, (const int *) &l01_ident, "Spezielle Leistungsbereiche", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, 0, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{GEN_ABTFC,					TYP_NUM,	14,  8, 0, 0, "ABTFC"},
	{L01_LEISTUNGSBEREICH,		TYP_ALPHA,	22,  1, 0, 0, "LEISTUNGSBEREICH"},
	{L01_GRUPPE_STUFE,			TYP_ALPHA,	23,  2, 0, 0, "GRUPPE_STUFE"},
	{L01_PUNKTE,				TYP_NUM,	25,  6, 0, 0, "PUNKTE"}
}};

const int l02_ident[] = {0,1,2,-1};

const SATZART L02Satzart = {"L02", 0, 4, 4, (const int *) &l02_ident, "Abrechnungsrelevante Kostentraeger", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, 0, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{L02_KOSTENTRAEGER_CODE,	TYP_ALPHA,	14,  3, 0, 0, "KOSTENTRAEGER_CODE"},
	{L02_LKF_RELEVANZ,			TYP_ALPHA,	17,  1, 0, 0, "LKF_RELEVANZ"}
}};

const int l03_ident[] = {0,1,2,-1};

const SATZART L03Satzart = {"L03", 0, 3, 3, (const int *) &l03_ident, "Exklusionen med. Einzelleistungen", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, 0, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{L03_MEL,					TYP_ALPHA,	14, 10, 0, 0, "MEL"}
}};

const SATZART L04Satzart = {"L04", 0, 3, 3, (const int *) &l03_ident, "Exklusionen tagesklin. med. Einzelleistungen", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, 0, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{L04_MEL,					TYP_ALPHA,	14, 10, 0, 0, "MEL"}
}};

/* Satzart O02 */

const int o02_ident[] = {0,1,2,3,-1};

const SATZART O02Satzart = {"O02", 0, 24, 24, (const int *) &o02_ident, "OEMELKA", 0, {
    {GEN_JAHR,              TYP_NUM,     4,  4, 0, 0, "JAHR"},
    {GEN_KANR,              TYP_ALPHA,   8,  6, 0, 0, "KANR"},
    {O02_MEL,               TYP_ALPHA,  14,  5, 0, 0, "MEL"},
    {O02_GESAMT,            TYP_ALPHA,  19,  1, 0, 0, "GESAMT"},
    {O02_ERG_MVS,           TYP_ALPHA,  20,  1, 0, 0, "Ergebnis MVS"},
    {O02_ERG_MINK,          TYP_ALPHA,  21,  1, 0, 0, "Ergebnis Mindest-K-Typ"},
    {O02_ERG_INTE,          TYP_ALPHA,  22,  1, 0, 0, "Ergebnis Intensiv-Erw"},
    {O02_ERG_KOZ,           TYP_ALPHA,  23,  1, 0, 0, "Ergebnis KOZ"},
    {O02_ERG_HP,            TYP_ALPHA,  24,  1, 0, 0, "Ergebnis HP"},
    {O02_ERG_BASIS,         TYP_ALPHA,  25,  1, 0, 0, "Ergebnis Basisversorgung"},
    {O02_ERG_INTNP,         TYP_ALPHA,  26,  1, 0, 0, "Ergebnis Intensiv NP"},
    {O02_UNUSED1,           TYP_ALPHA,  27,  1, 0, 0, "Unused"},
    {O02_UNUSED2,           TYP_ALPHA,  28,  1, 0, 0, "Unused"},
    {O02_ERG_MFS,           TYP_ALPHA,  29,  1, 0, 0, "Ergebnis MFS"},
    {O02_KRIT_MVS,          TYP_ALPHA,  30,  1, 0, 0, "Kriterium MVS"},
    {O02_KRIT_MINK,         TYP_ALPHA,  31,  1, 0, 0, "Kriterium Mindest-K-Typ"},
    {O02_KRIT_INTE,         TYP_ALPHA,  32,  1, 0, 0, "Kriterium Intensiv-Erw"},
    {O02_KRIT_KOZ,          TYP_ALPHA,  33,  1, 0, 0, "Kriterium KOZ"},
    {O02_KRIT_HP,           TYP_ALPHA,  34,  1, 0, 0, "Kriterium HP"},
    {O02_KRIT_BASIS,        TYP_ALPHA,  35,  1, 0, 0, "Kriterium Basisversorgung"},
    {O02_KRIT_INTNP,        TYP_ALPHA,  36,  1, 0, 0, "Kriterium Intensiv NP"},
    {O02_UNUSED3,           TYP_ALPHA,  37,  1, 0, 0, "Unused"},
    {O02_UNUSED4,           TYP_ALPHA,  38,  1, 0, 0, "Unused"},
    {O02_KRIT_MFS,          TYP_ALPHA,  39,  1, 0, 0, "Kriterium MFS"},
}};


/*******************************************************************************************************
** Errors und Warnings fuer KAS-KORE-Check                                                             **
*******************************************************************************************************/


const LKF_SATZART_ERRORDEF
LKFKKErrorBerichtsjahrfehlt =		{  1, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Berichtsjahr fehlt"},
LKFKKErrorBerichtsjahrfalsch  =		{  2, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Berichtsjahr - ung\xc3\xbc""ltige Jahresangabe"},
/*LKFKKErrorFunktionscodefehlt  =		{  3, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Funktionscode fehlt"},
LKFKKErrorFunktionscodefalsch  = {  4, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Funktionscode ung\xc3\xbc""ltig"}, */
LKFKKErrorFunktionscodemehrfach  =  {  5, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Funktionscode mehrfach gemeldet"},
LKFKKErrorSpezOrgfalsch  =			{  6, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Spezielle Organisationsform ung\xc3\xbc""ltig"},
LKFKKErrorSpezOrgfalsch2012  =		{  6, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Spezielle Organisations-/Betriebsform ung\xc3\xbc""ltig"}, /* V17.0 */
LKFKKErrorSpezOrgnurHK  =			{  7, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Spezielle Organisationsform nur bei Hauptkostenstellen anzugeben"},
LKFKKErrorSpezOrgnurHK2012  =		{  7, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Spezielle Organisations-/Betriebsform nur bei bettenf\xc3\xbc""hrenden Hauptkostenstellen anzugeben"}, /* V17.0 */
LKFKKErrorAerztlLeitungfehlt  =		{  8, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "\xc3\x84""rztliche Leitung fehlt"},
LKFKKErrorVerwLeitungfehlt  =		{  9, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Verwaltungsleitung fehlt"},
LKFKKErrorPflegeLeitungfehlt  =	    { 10, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Pflegedienstleitung fehlt"},
LKFKKErrorAerztlLeitungfalsch  =	{ 11, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "\xc3\x84""rztliche Leitung ung\xc3\xbc""ltig"},
LKFKKErrorVerwLeitungfalsch  =		{ 12, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Verwaltungsleitung ung\xc3\xbc""ltig"},
LKFKKErrorPflegeLeitungfalsch  =    { 13, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Pflegedienstleitung ung\xc3\xbc""ltig"},
LKFKKErrorSystBettenInsgfehlt  =	{ 14, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Systemisierte Betten insgesamt fehlt"},
LKFKKErrorSystBettenInsgfalsch  =	{ 15, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Systemisierte Betten insgesamt ung\xc3\xbc""ltig"},
LKFKKErrorSystBettenInsgSonderkl  = { 16, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Systemisierte Betten insgesamt < systemisierte Betten Sonderklasse"},
LKFKKErrorSystBettenInsgK08  =		{ 17, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Systemisierte Betten insgesamt ungleich systemisierten Betten auf den bettenf\xc3\xbc""hrenden Hauptkostenstellen"},
LKFKKErrorSystBettenSondfalsch  =   { 18, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Systemisierte Betten Sonderklasse ung\xc3\xbc""ltig"},
LKFKKErrorTatsBettenInsgfehlt  =	{ 19, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Tats\xc3\xa4""chlich aufgestellte Betten insgesamt fehlt"},
LKFKKErrorTatsBettenInsgfalsch  =	{ 20, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Tats\xc3\xa4""chlich aufgestellte Betten insgesamt ung\xc3\xbc""ltig"},
LKFKKErrorTatsBettenInsgSonderkl  = { 21, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Tats\xc3\xa4""chlich aufgestellte Betten insgesamt < tats\xc3\xa4""chlich aufgestellte Betten Sonderklasse"},
LKFKKErrorTatsBettenInsgK08  =		{ 22, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Tats\xc3\xa4""chlich aufgestellte Betten insgesamt ungleich tats\xc3\xa4""chlich aufgestellten Betten auf den bettenf\xc3\xbc""hrenden Hauptkostenstellen"},
LKFKKErrorTatsBettenSondfalsch  =   { 23, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Tats\xc3\xa4""chlich aufgestellte Betten Sonderklasse ung\xc3\xbc""ltig"},
LKFKKErrorSondBelagstagefalsch  =   { 24, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Belagstage Sonderklasse ung\xc3\xbc""ltig"},
LKFKKErrorSondAufnahmenfalsch  =    { 25, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Aufnahmen Sonderklasse ung\xc3\xbc""ltig"},
LKFKKErrorSondVorjahrfalsch  =      { 26, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vom Vorjahr Verbliebene Sonderklasse ung\xc3\xbc""ltig"},
LKFKKErrorSondEntlassungenfalsch  = { 27, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Entlassungen Sonderklasse ung\xc3\xbc""ltig"},
LKFKKErrorSondVerstorbenefalsch  =  { 28, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Verstorbene Sonderklasse ung\xc3\xbc""ltig"},
LKFKKErrorBegleitAufnahmenfalsch  = { 29, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Aufnahmen von Begleitpersonen ung\xc3\xbc""ltig"},
LKFKKErrorBegleitBelagstagefalsch  ={ 30, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Belagstage von Begleitpersonen ung\xc3\xbc""ltig"},
LKFKKErrorAmbPatfalsch  =			{ 31, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Ambulante Patienten/innen ung\xc3\xbc""ltig"},
LKFKKErrorOPTischefalsch  =			{ 32, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "OP-Tische ung\xc3\xbc""ltig"},
LKFKKErrorEntbindPlaetzefalsch  =	{ 33, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Entbindungspl\xc3\xa4""tze ung\xc3\xbc""ltig"},
LKFKKErrorPostOPUebPlaetzefalsch  = { 34, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Postoperative \xc3\x9c""berwachungspl\xc3\xa4""tze ung\xc3\xbc""ltig"},
LKFKKErrorDialysePlaetzefalsch  =	{ 35, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Dialysepl\xc3\xa4""tze ung\xc3\xbc""ltig"},
LKFKKErrorObdukAnstfalsch  =		{ 36, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Obduktionen durch Anstaltspersonal ung\xc3\xbc""ltig"},
LKFKKErrorObdukFremdfalsch  =		{ 37, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Obduktionen durch Fremdpersonal ung\xc3\xbc""ltig"},
LKFKKErrorEntbindLebendfalsch  =	{ 38, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Entbindungen Lebendgeborene ung\xc3\xbc""ltig"},
LKFKKErrorEntbindTotfalsch  =		{ 39, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Entbindungen Totgeborene ung\xc3\xbc""ltig"},
LKFKKErrorAngabenSonderklasse  =	{ 40, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Angaben zur Sonderklasse unvollst\xc3\xa4""ndig"},
LKFKKErrorBelagSondGross =          { 41, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Belagstage Sonderklasse > Belagstage gesamt"},
LKFKKErrorAufnahmenSondGross =      { 42, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Aufnahmen Sonderklasse > Aufnahmen gesamt"},
LKFKKErrorEntlassungenSondGross =   { 43, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Entlassungen Sonderklasse > Entlassungen gesamt"},
LKFKKErrorVerstorbeneSondGross =    { 44, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Verstorbene Sonderklasse > Verstorbene gesamt"},
LKFKKErrorAmbPatungleich =          { 45, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Ambulante Patient/innen ungleich ambulante Patient/innen auf nicht-bettenf\xc3\xbc""hrenden Hauptkostenstellen"},
LKFKKErrorPersGruppenIndexfehlt =   { 46, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personalgruppenindex fehlt"},
LKFKKErrorPersGruppenIndexfalsch =  { 47, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personalgruppenindex ung\xc3\xbc""ltig"},
LKFKKErrorVollzeitAqufehlt =        { 48, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personal-Vollzeit\xc3\xa4""quivalente fehlt"},
LKFKKErrorVollzeitAqufalsch =       { 49, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personal-Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorPersKalkAngGross =        { 50, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kalkulatorisch angesetztes Personal > Personal gesamt"},
LKFKKErrorPersKeineKosten =         { 51, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personal, aber keine Kosten"},
LKFKKErrorPersVollzeit1 =           { 52, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personal-Vollzeit\xc3\xa4""quivalente gesamt ungleich Personal-Vollzeit\xc3\xa4""quivalente der Kostenstellen"},
LKFKKErrorPersVollzeit2 =           { 53, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personal-Vollzeit\xc3\xa4""quivalente gesamt < Personal-Vollzeit\xc3\xa4""quivalente der Kostenstellen", &LKFErrorNurFonds},
LKFKKErrorFachhauptfehlt =          { 54, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Fachhauptbereichsindex fehlt"},
LKFKKErrorFachhauptfalsch =         { 55, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Fachhauptbereichsindex ung\xc3\xbc""ltig"},
LKFKKErrorFachhauptohneAerztPers =  { 56, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Fachhauptbereiche ohne Angaben \xc3\xbc""ber fach\xc3\xa4""rztliches Personal", &LKFErrorNurFonds},
LKFKKErrorFacharztKopffalsch =      { 58, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Fach\xc3\xa4""rzte/innen Kopfzahl ung\xc3\xbc""ltig"},
LKFKKErrorAllgarztKopffalsch =      { 59, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "\xc3\x84""rzte/innen f\xc3\xbc""r Allgemeinmedizin Kopfzahl ung\xc3\xbc""ltig"},
LKFKKErrorFacharztAusbKopffalsch =  { 60, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Fach\xc3\xa4""rzte/innen in Ausbildung Kopfzahl ung\xc3\xbc""ltig"},
LKFKKErrorAllgarztAusbKopffalsch =  { 61, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "\xc3\x84""rzte/innen f\xc3\xbc""r Allgemeinmedizin in Ausbildung Kopfzahl ung\xc3\xbc""ltig"},
LKFKKErrorFachrichtungsindexfehlt = { 62, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Fachrichtungsindex fehlt"},
LKFKKErrorFachrichtungsindexfalsch= { 63, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Fachrichtungsindex ung\xc3\xbc""ltig"},
LKFKKErrorKonsisliarfalsch =        { 64, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Konsiliar\xc3\xa4""rzte/innen Kopfzahl ung\xc3\xbc""ltig"},
LKFKKErrorIndexNarztBerufefehlt =   { 65, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Index nicht-\xc3\xa4""rztliche Gesundheitsberufe fehlt"},
LKFKKErrorIndexNarztBerufefalsch =  { 66, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Index nicht-\xc3\xa4""rztliche Gesundheitsberufe ung\xc3\xbc""ltig"},
LKFKKErrorNArztOhnePers =           { 67, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Nicht-\xc3\xa4""rztliche Gesundheitsberufe ohne Angaben \xc3\xbc""ber Personal"},
LKFKKErrorMPersKopfzahlfalsch =     { 68, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personal m\xc3\xa4""nnlich Kopfzahl ung\xc3\xbc""ltig"},
LKFKKErrorWPersKopfzahlfalsch =     { 69, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personal weiblich Kopfzahl ung\xc3\xbc""ltig"},
LKFKKErrorEUAuslKopfzahlfalsch =    { 70, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Darunter EU-Ausl\xc3\xa4""nder/innen insgesamt Kopfzahl ung\xc3\xbc""ltig"},
LKFKKErrorNEUAuslKopfzahlfalsch =   { 71, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Darunter Nicht-EU-Ausl\xc3\xa4""nder/innen insgesamt Kopfzahl ung\xc3\xbc""ltig"},
LKFKKErrorPersonalAuslGross =       { 72, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personal Ausl\xc3\xa4""nder/innen > Personal gesamt"},
LKFKKErrorABTFCHKFalsch =			{ 73, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Funktionscode f\xc3\xbc""r bettenf\xc3\xbc""hrende Hauptkostenstellen unzul\xc3\xa4""ssig"},
LKFKKErrorK08TatsBettenFehlt =		{ 75, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Tats\xc3\xa4""chlich aufgestellte Betten fehlt"},
LKFKKErrorK08NettogrundrissFehlt =	{ 76, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Nettogrundrissfl\xc3\xa4""che fehlt"},
LKFKKErrorK08SystBettenFalsch =		{ 77, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Systemisierte Betten ung\xc3\xbc""ltig"},
LKFKKErrorK08TatsBettenFalsch =		{ 78, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Tats\xc3\xa4""chlich aufgestellte Betten ung\xc3\xbc""ltig"},
LKFKKErrorK08NettogrundrissFalsch = { 79, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Nettogrundrissfl\xc3\xa4""che ung\xc3\xbc""ltig"},
LKFKKErrorK08ArztAquFalsch =		{ 80, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "\xc3\x84""rzte/innen Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorApoChemAquFalsch =		{ 81, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Apotheker/innen, Chemiker/innen, Physiker/ innen u.\xc3\xa4"". Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorHebammenAquFalsch =		{ 82, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Hebammen Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorGehoberDienstAquFalsch =	{ 83, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Gehobener Dienst f\xc3\xbc""r Gesundheits- und Krankenpflege und weitere Gesundheitsberufe Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorMedTechnDienstAquFalsch = { 84, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Gehobene med.-techn. Dienste, med.-techn. Fachdienst und Masseure/innen Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorPflegeAquFalsch =			{ 85, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Pflegehilfe und Sanit\xc3\xa4""tshilfsdienste Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorVerwKanzleiAquFalsch =	{ 86, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Verwaltungs- und Kanzleipersonal Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorBetriebspersAquFalsch =	{ 87, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Betriebspersonal Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorSonstPersAquFalsch =		{ 88, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Sonstiges Personal Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorPersonalKostenFalsch =	{ 89, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personalkosten ung\xc3\xbc""ltig"},
LKFKKErrorKostMedGueterFalsch =		{ 90, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten f\xc3\xbc""r medizinische Gebrauchs- und Verbrauchsg\xc3\xbc""ter ung\xc3\xbc""ltig"},
LKFKKErrorKostNichtMedGueterFalsch = {91, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten f\xc3\xbc""r nicht-medizinische Gebrauchs- und Verbrauchsg\xc3\xbc""ter ung\xc3\xbc""ltig"},
LKFKKErrorKostenMedFremdLStFalsch = { 92, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten f\xc3\xbc""r medizinische Fremdleistungen ung\xc3\xbc""ltig"},
LKFKKErrorKostenNichtMedFremdLStFalsch = {93, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten f\xc3\xbc""r nicht-medizinische Fremdleistungen ung\xc3\xbc""ltig"},
LKFKKErrorEnergieKostenFalsch =		{ 94, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Energiekosten ung\xc3\xbc""ltig"},
LKFKKErrorAbgabenFalsch =			{ 95, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Abgaben, Beitr\xc3\xa4""ge, Geb\xc3\xbc""hren und sonstige Kosten ung\xc3\xbc""ltig"},
LKFKKErrorKalkAnlageKostenFalsch =	{ 96, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kalkulatorische Anlagekapitalkosten ung\xc3\xbc""ltig"},
LKFKKErrorKostMedEntsorgungFalsch = { 97, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten der vorwiegend medizinisch bedingten Ver- und Entsorgung ung\xc3\xbc""ltig"},
LKFKKErrorKostNMedEntsorgungFalsch = {98, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten der vorwiegend nicht-medizinisch bedingten Ver- und Entsorgung ung\xc3\xbc""ltig"},
LKFKKErrorKostVerwaltungFalsch =	{ 99, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten der Verwaltung ung\xc3\xbc""ltig"},
LKFKKErrorKostSekundaerFalsch =		{100, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Andere Sekund\xc3\xa4""rkosten ung\xc3\xbc""ltig"},
LKFKKErrorKostenminderungFalsch =	{101, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenminderungen ung\xc3\xbc""ltig"},
LKFKKErrorSummeLeistungenFalsch =	{102, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Summe abgegebener innerbetrieblicher Leistungen ung\xc3\xbc""ltig"},
LKFKKErrorUnterUeberdeckungFalsch = {103, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Unter- oder \xc3\x9c""berdeckung ung\xc3\xbc""ltig"},
LKFKKErrorEndkostenFalsch =			{104, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten der Kostenstelle ung\xc3\xbc""ltig"},
LKFKKErrorPersonalKostenOhnePers =	{107, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personalkosten aber kein Personal", &LKFErrorNurFonds},
LKFKKErrorPersonalOhneKosten =		{108, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personal aber keine Personalkosten"},
LKFKKErrorEndkostenFalschBerechnet ={109, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten falsch berechnet"},
LKFKKErrorAbweichungUnterUeberdeckung = {110, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Abweichung Unter- oder \xc3\x9c""berdeckung  von Summe abgegebener innerbetrieblicher Leistungen > 10% "},
LKFKKErrorAbweichungUnterUeberdeckung2017 = {110, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Abweichung Unter- oder \xc3\x9c""berdeckung von Summe abgegebener innerbetrieblicher Leistungen > 10% "},
LKFKKErrorKostenstelleOhneKosten =	{111, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenstelle ohne Kosten"},
LKFKKErrorKostenstelleimPlanOhneDaten = {112, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenstelle im Kostenstellenplan ohne Daten"},
LKFKKErrorK09_AbtFCFalsch =			{113, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Funktionscode f\xc3\xbc""r nicht-bettenf\xc3\xbc""hrende Hauptkostenstellen unzul\xc3\xa4""ssig"},
LKFKKErrorAmbPatFalsch =			{114, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Ambulante Patienten/innen ung\xc3\xbc""ltig"},
LKFKKErrorFreqAmbPatFalsch =		{115, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Frequenzen an ambulanten Patienten/innen ung\xc3\xbc""ltig"},
LKFKKErrorFreqStatPatFalsch =		{116, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Frequenzen an station\xc3\xa4""ren Patienten/innen ung\xc3\xbc""ltig"},
LKFKKErrorFreqStatPatAndKAFalsch =	{117, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Frequenzen an station\xc3\xa4""ren Patienten/innen anderer Krankenh\xc3\xa4""user ung\xc3\xbc""ltig"},
LKFKKErrorAmbPat_Freq =				{118, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Ambulante Patienten/innen > Frequenzen ambulanter Patienten/innen"},
LKFKKErrorAmbPatOhneEndkosten =		{119, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Ambulante Patienten/innen aber keine Endkosten"},
LKFKKErrorFreqStatPatOhneUmlage =	{120, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Frequenzen an station\xc3\xa4""ren Patienten/innen aber keine Umlage"},
LKFKKErrorK10_AbtFCFalsch =			{121, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Funktionscode f\xc3\xbc""r Neben- oder Hilfskostenstellen unzul\xc3\xa4""ssig"},
LKFKKErrorPersInsgAquFalsch =		{122, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personal insgesamt Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
LKFKKErrorHilfsKostmitEndkosten =	{123, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Hilfskostenstelle mit Endkosten ungleich 0"},
LKFKKErrorPersonalKostenFehlt =		{124, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Personalkosten fehlt"},
LKFKKErrorK11_KostMedVerbrauchFehlt =			{125, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten f\xc3\xbc""r medizinische Gebrauchs- und Verbrauchsg\xc3\xbc""ter fehlt"},
LKFKKErrorK11_KostNichtMedVerbrauchFehlt =		{126, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten f\xc3\xbc""r nicht-medizinische Gebrauchs- und Verbrauchsg\xc3\xbc""ter fehlt"},
LKFKKErrorK11_KostMedFremdleistungenFehlt =		{127, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten f\xc3\xbc""r medizinische Fremdleistungen fehlt"},
LKFKKErrorK11_KostNMedFremdleistungenFehlt =	{128, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten f\xc3\xbc""r nicht-medizinische Fremdleistungen fehlt"},
LKFKKErrorK11_EnergiekostenFehlt =  {129, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Energiekosten fehlt"},
LKFKKErrorK11_AbgabenFehlt =		{130, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Abgaben, Beitr\xc3\xa4""ge, Geb\xc3\xbc""hren und sonstige Kosten fehlt"},
LKFKKErrorK11_KalkAnlagekapitalkostenFehlt =	{131, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kalkulatorische Anlagekapitalkosten fehlt"},
LKFKKErrorK11_SummePrimaerkostenFehlt =			{132, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Summe Prim\xc3\xa4""rkosten fehlt"},
LKFKKErrorK11_KostenmindFehlt =		{133, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenminderungen fehlt"},
LKFKKErrorK11_EndkostenKAFehlt =	{134, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten der Krankenanstalt fehlt"},
LKFKKErrorK11_SummeKalkAbschrFehlt ={135, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Summe der kalkulatorischen Abschreibungen fehlt"}, 
LKFKKErrorK11_EndkostenStatPatFehlt =			{136, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten der station\xc3\xa4""ren Patientenversorgung fehlt"},
LKFKKErrorK11_EndkostenNebenHKFehlt =			{137, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten der Nebenkostenstellen fehlt"},
LKFKKErrorK11_SummePrimaerkostenFalsch =		{138, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Summe Prim\xc3\xa4""rkosten ung\xc3\xbc""ltig"},
LKFKKErrorK11_KostenmindFalsch =	{139, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenminderungen ung\xc3\xbc""ltig"},
LKFKKErrorK11_EndkostenKAFalsch =	{140, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten der Krankenanstalt ung\xc3\xbc""ltig"},
LKFKKErrorK11_SummeKalkAbschlFalsch =			{141, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Summe der kalkulatorischen Abschreibungen ung\xc3\xbc""ltig"},
LKFKKErrorK11_KalkAbschrAnlageRest0Falsch2007 =		{142, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kalkulatorische Abschreibungen f\xc3\xbc""r Anlageg\xc3\xbc""ter mit Restwert 0 ung\xc3\xbc""ltig"},
LKFKKErrorK11_KalkAbschrAusgeschAnlagenFalsch2007 = {143, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kalkulatorische Abschreibungen von Restwerten ausgeschiedener oder stillgelegter Anlagen ung\xc3\xbc""ltig"},
LKFKKErrorK11_SummeKalkZinsenFalsch =			{144, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Summe der kalkulatorischen Zinsen ung\xc3\xbc""ltig"},
LKFKKErrorK11_SummeKalkMietenFalsch =			{145, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Summe der kalkulatorischen Mieten ung\xc3\xbc""ltig"},
LKFKKErrorK11_KalkAbschrFalsch2007 =	{147, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Summe der kalk.Abschreibungen kleiner als (Restwert 0 + stillgelegte Anlagen)"},
LKFKKErrorK11_EndkostenStatPatUng = {148, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten der station\xc3\xa4""ren Patientenversorgung ung\xc3\xbc""ltig"},
LKFKKErrorK11_EndkostenAmbPatUng =	{149, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten der ambulanten Patientenversorgung ung\xc3\xbc""ltig"},
LKFKKErrorK11_EndkostenNebenHKUng = {150, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten der Nebenkostenstellen ung\xc3\xbc""ltig"},
LKFKKErrorKOAGR01KostDiff =			{155, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR01 Gesamt ungleich KOAGR01 der Kostenstellen"},
LKFKKErrorKOAGR02KostDiff =			{156, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR02 Gesamt ungleich KOAGR02 der Kostenstellen"},
LKFKKErrorKOAGR03KostDiff =			{157, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR03 Gesamt ungleich KOAGR03 der Kostenstellen"},
LKFKKErrorKOAGR04KostDiff =			{158, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR04 Gesamt ungleich KOAGR04 der Kostenstellen"},
LKFKKErrorKOAGR05KostDiff =			{159, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR05 Gesamt ungleich KOAGR05 der Kostenstellen"},
LKFKKErrorKOAGR06KostDiff =			{160, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR06 Gesamt ungleich KOAGR06 der Kostenstellen"},
LKFKKErrorKOAGR07KostDiff =			{161, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR07 Gesamt ungleich KOAGR07 der Kostenstellen"},
LKFKKErrorKOAGR08KostDiff =			{162, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR08 Gesamt ungleich KOAGR08 der Kostenstellen"},
LKFKKErrorKostenmindDiff =			{163, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenminderungen Gesamt ungleich Kostenminderungen der Kostenstellen"},
LKFKKErrorEndkostenDiff =			{164, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten Gesamt ungleich Endkosten der Kostenstellen"},
LKFKKErrorPrimaerkostenFalsch =		{165, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Prim\xc3\xa4""rkosten falsch berechnet"},
LKFKKErrorKOAGR01SummenblattDiff =	{166, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR01 Sammel-Kostennachweis Summenblatt ungleich KOAGR01 Sammel-Kostennachweis Detailbl\xc3\xa4""tter"},
LKFKKErrorKOAGR02SummenblattDiff =	{167, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR02 Sammel-Kostennachweis Summenblatt ungleich KOAGR02 Sammel-Kostennachweis Detailbl\xc3\xa4""tter"},
LKFKKErrorKOAGR03SummenblattDiff =	{168, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR03 Sammel-Kostennachweis Summenblatt ungleich KOAGR03 Sammel-Kostennachweis Detailbl\xc3\xa4""tter"},
LKFKKErrorKOAGR04SummenblattDiff =	{169, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR04 Sammel-Kostennachweis Summenblatt ungleich KOAGR04 Sammel-Kostennachweis Detailbl\xc3\xa4""tter"},
LKFKKErrorKOAGR05SummenblattDiff =	{170, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR05 Sammel-Kostennachweis Summenblatt ungleich KOAGR05 Sammel-Kostennachweis Detailbl\xc3\xa4""tter"},
LKFKKErrorKOAGR06SummenblattDiff =	{171, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR06 Sammel-Kostennachweis Summenblatt ungleich KOAGR06 Sammel-Kostennachweis Detailbl\xc3\xa4""tter"},
LKFKKErrorKOAGR07SummenblattDiff =	{172, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR07 Sammel-Kostennachweis Summenblatt ungleich KOAGR07 Sammel-Kostennachweis Detailbl\xc3\xa4""tter"},
LKFKKErrorKOAGR08SummenblattDiff =	{173, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "KOAGR08 Sammel-Kostennachweis Summenblatt ungleich KOAGR08 Sammel-Kostennachweis Detailbl\xc3\xa4""tter"},
LKFKKErrorPrimKostSummenblattPrimDetDiff ={174, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Summe Prim\xc3\xa4""rkosten Sammel-Kostennachweis Summenblatt ungleich Summe Prim\xc3\xa4""rkosten Detailbl\xc3\xa4""tter"},
LKFKKErrorKostenmindSummenblattKostDetDiff ={175, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenminderungen Sammel-Kostennachweis Summenblatt ungleich Kostenminderungen kalkulatorischer Anhang"},
LKFKKErrorGesamtumlageKOAGR11unplaus =		{176, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Gesamtumlage bei KOAGR11 und FC31xxxx unplausibel"},
LKFKKErrorGesamtumlageKOAGR12unplaus =		{177, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Gesamtumlage bei KOAGR12 und FC32xxxx unplausibel"},
LKFKKErrorGesamtumlageKOAGR13unplaus =		{178, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Gesamtumlage bei KOAGR13 und FC33xxxx unplausibel"},
LKFKKErrorGesamtumlageKOAGR14unplaus =		{179, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Gesamtumlage bei KOAGR14 und FC1xxxxx und FC2xxxxx unplausibel"},
LKFKKErrorBlattnummerFehlt =		{180, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Blattnummer fehlt"},
LKFKKErrorBlattnummerFalsch =		{181, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Blattnummer ung\xc3\xbc""ltig"},
LKFKKErrorMLVNummerFehlt =			{182, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "MLV-Nummer fehlt"},
LKFKKErrorMLVNummerFalsch =			{183, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "MLV-Nummer ung\xc3\xbc""ltig"},
LKFKKErrorKombMLVBlattFalsch =		{184, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kombination von MLV-Nummer und Blattnummer ung\xc3\xbc""ltig"},
LKFKKErrorMLVAbhaengigkeit =		{185, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "MLV in Abh\xc3\xa4""ngigkeit zu Funktionscode und Kosten, Vorsteuer und Pensionen "},
LKFKKErrorK12_KostenOhnePersonal =	{186, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten aber kein Personal"},
LKFKKErrorK12_KostenFalsch =		{187, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten ung\xc3\xbc""ltig"},
LKFKKErrorIndexKostMindFehlt =		{188, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Index Kostenminderungsart fehlt"},
LKFKKErrorIndexKostMindFalsch =		{189, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Index Kostenminderungsart ung\xc3\xbc""ltig"},
LKFKKErrorKostMindFalsch =			{190, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenminderungen ung\xc3\xbc""ltig"},
LKFKKErrorKlinischerMehraufwandNurUni =		{191, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Klinischer Mehraufwand nur f\xc3\xbc""r Uni-Kliniken zul\xc3\xa4""ssig"},
LKFKKErrorKostBereichKZIndexFalsch =		{192, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenbereichs-Kennzahlenindex ung\xc3\xbc""ltig"},
LKFKKErrorK15_KostenFalsch =		{193, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten ung\xc3\xbc""ltig"},
LKFKKErrorK15_BezugsgroesseFalsch = {194, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Bezugsgr\xc3\xb6""\xc3\x9f""e ung\xc3\xbc""ltig"},
LKFKKErrorK16_KostenIndexFalsch =	{195, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenindex ung\xc3\xbc""ltig"},
LKFKKErrorK16_KostenFalsch =		{196, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten ung\xc3\xbc""ltig"},
LKFKKErrorGesamtumlageFehlerhaft =	{197, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Gesamtumlage fehlerhaft"},
LKFKKErrorPensionskostenUnvollst =	{199, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Pensionskosten unvollst\xc3\xa4""ndig gemeldet"},
LKFKKErrorKostenstellePensNichtOK = {200, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenstelle Pensionen nicht ordnungsgem\xc3\xa4""\xc3\x9f"" gemeldet"},
LKFKKErrorVorsteuerUnvollst =		{201, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vorsteuer unvollst\xc3\xa4""ndig gemeldet"},
LKFKKErrorKostVorsteuerNichtOK =	{202, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenstelle Vorsteuer nicht ordnungsgem\xc3\xa4""\xc3\x9f"" gemeldet"},
LKFKKErrorKostMindVorsteuerFalsch = {203, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenminderungen Vorsteuer fehlerhaft"},
LKFKKErrorAquMLV11unplaus =			{206, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalenten MLV1-1 auf Kostenstellenebene unplausibel"},
LKFKKErrorAquMLV12unplaus =			{207, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalenten MLV1-2 auf Kostenstellenebene unplausibel"},
LKFKKErrorAquMLV13unplaus =			{208, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalenten MLV1-3 auf Kostenstellenebene unplausibel"},
LKFKKErrorAquMLV14unplaus =			{209, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalenten MLV1-4 auf Kostenstellenebene unplausibel"},
LKFKKErrorAquMLV15unplaus =			{210, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalenten MLV1-5 auf Kostenstellenebene unplausibel"},
LKFKKErrorAquMLV16unplaus =			{211, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalenten MLV1-6 auf Kostenstellenebene unplausibel"},
LKFKKErrorAquMLV17unplaus =			{212, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalenten MLV1-7 auf Kostenstellenebene unplausibel"},
LKFKKErrorAquMLV18unplaus =			{213, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalenten MLV1-8 auf Kostenstellenebene unplausibel"},
LKFKKErrorAquMLV19unplaus =			{214, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalenten MLV1-9 auf Kostenstellenebene unplausibel"},
LKFKKErrorK08_Kostenstelleunvollst ={215, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenstelle unvollst\xc3\xa4""ndig gemeldet"},
LKFKKErrorK09_Kostenstelleunvollst ={216, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenstelle unvollst\xc3\xa4""ndig gemeldet"},
LKFKKErrorAbtFCDLBOhneStat =		{217, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Funktionscode mit DLB-Daten ohne Kostenstellenstatistik und -nachweis"},
LKFKKErrorAbtFCStatohneDLB =		{218, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Funktionscode mit Kostenstellenstatistik und -nachweis ohne DLB-Daten"},
LKFKKErrorK11_EndkostenAmbPatFehlt = {220, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten der ambulanten Patientenversorgung fehlt"},
LKFErrorTBETTunplausErr =			 {221, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Anzahl der tats\xc3\xa4""chlich aufgestellten Betten unplausibel"},
LKFErrorEndKostenOhneAmbPat =		 {222, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Endkosten aber keine ambulanten Patienten/innen"}, /* V9.2 */
LKFErrorUmlageOhneStatFrequenz =	 {223, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Keine Frequenzen an station\xc3\xa4""ren Patienten/innen (und anderer KH) aber Umlage"}, /* V9.2, V9.4 eliminieren, V11.0 wieder rein ab 2006 */
LKFErrorSummeKostenKrankenanstalt =  {224, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Summe der korrigierten Bereichsendkosten ungleich Endkosten der Krankenanstalt"}, /* V9.2 */
LKFErrorKeineVPatienten =            {225, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Keine am Jahresende verbleibenden Patienten/innen gemeldet"}, /* V9.2a */
LKFErrorEinartTraegerFalsch =		 {226, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Einnahmeart/Finanzierungstr\xc3\xa4""ger nicht zul\xc3\xa4""ssig"}, /* V10.0 */
LKFErrorEinnahmenFalsch =			 {227, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Einnahmen ung\xc3\xbc""ltig"},                             /* V10.0 */
LKFErrorFreqKeinePat =				 {228, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Ambulante Frequenzen aber keine ambulanten Patienten/innen"}, /* V10.2 */
LKFErrorBelagstageDifferenz =		 {229, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Belagstage gesamt ungleich Belagstage auf den bettenf\xc3\xbc""hrenden Hauptkostenstellen (bettenf\xc3\xbc""hrende Hauptkostenstelle m\xc3\xb6""glicherweise nicht angelegt)"},
LKFKKErrorK14_BuchwertUngleichZeile = {231, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Buchwert am Ende des Berichtsjahres ungleich Zeilenergebnis"},
LKFKKErrorK12_KostenUngleichZeile = {232, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten gesamt ungleich Zeilenergebnis"},
LKFKKErrorKeinAerztlichesPersonal = {230, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "\xc3\x84""rztliches Personal fehlt"},
LKFKKErrorK15Kostenfehlen = {233, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kosten fehlen"},
LKFKKErrorK15Bezugsgroessefehlt = {234, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Bezugsgr\xc3\xb6""\xc3\x9f""e fehlt"},
LKFErrorStandortFehlt = {235, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Standort fehlt"},
LKFErrorStandortFalsch = {236, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Standort falsch"},
LKFErrorK04K07Hebamme = {237, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Hebammen: Differenz der Vollzeit\xc3\xa4""quivalente zwischen Dienstverh\xc3\xa4""ltnis (K04) und Berufsgruppenaufteilung (K07)"},
LKFErrorK04K07GehDienst = {238, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Geh. Dienst f\xc3\xbc""r Gesundheits- und Krankenpflege: Differenz der Vollzeit\xc3\xa4""quivalente zwischen Dienstverh\xc3\xa4""ltnis (K04) und Berufsgruppenaufteilung (K07)"},
LKFErrorK04K07GehMedTechn = {239, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Geh. med.-techn. Dienste: Differenz der Vollzeit\xc3\xa4""quivalente zwischen Dienstverh\xc3\xa4""ltnis (K04) und Berufsgruppenaufteilung (K07)"},
LKFErrorK04K07Pflege = {240, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Pflege- und Sanit\xc3\xa4""tshilfsdienste: Differenz der Vollzeit\xc3\xa4""quivalente zwischen Dienstverh\xc3\xa4""ltnis (K04) und Berufsgruppenaufteilung (K07)"},
LKFErrorK04K05VZEQunter = {241, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalente im \xc3\xa4""rztlichen Dienst (K05) kleiner 75% der Vollzeit\xc3\xa4""quivalente nach Dienstverh\xc3\xa4""ltnis (K04)"},
LKFErrorK04K05VZEQueber = {242, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalente im \xc3\xa4""rztlichen Dienst (K05) gr\xc3\xb6""\xc3\x9f""er Vollzeit\xc3\xa4""quivalente nach Dienstverh\xc3\xa4""ltnis (K04)"},
LKFKKErrorAnschaffKostenFalsch2008 =	{243, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Anschaffungs- und Herstellungskosten ung\xc3\xbc""ltig"},
LKFKKErrorZugaengeFalsch2008 =			{244, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Zug\xc3\xa4""nge ung\xc3\xbc""ltig"},
LKFKKErrorAbgaengeFalsch2008 =			{245, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Abg\xc3\xa4""nge ung\xc3\xbc""ltig"},
LKFKKErrorUmbuchungenFalsch2008 =		{246, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Umbuchungen ung\xc3\xbc""ltig"},
LKFKKErrorKumAbschrFalsch2008 =			{247, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kumulierte Abschreibungen ung\xc3\xbc""ltig"},
LKFKKErrorBuchwerteEndeFalsch2008 =		{248, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Buchwerte am Ende des Berichtsjahres ung\xc3\xbc""ltig"},
LKFKKErrorBuchwerteVorjahrFalsch2008 =	{249, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Buchwerte Vorjahr ung\xc3\xbc""ltig"},
LKFKKErrorAbschrLfdFalsch2008 =			{250, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Abschreibungen laufendes Berichtsjahr ung\xc3\xbc""ltig"},
LKFKKErrorAnlagenindexFalsch2008 =		{251, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Anlagenindex ung\xc3\xbc""ltig"},
LKFKKErrorKostMindFLAFFalsch =			{252, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenminderungen FLAF-Ausgleich fehlerhaft", &LKFErrorNurFonds},
LKFKKErrorFLAFFalsch =					{253, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Auf Kostenstelle '202511' sind nur Kostenminderungen zul\xc3\xa4""ssig", &LKFErrorNurFonds},
LKFKKErrorAbt19 =						{256, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Abteilungen mit Funktionscode '19xxxx' in landesgesundheitsfondsfinanzierten Krankenanstalten unzul\xc3\xa4""ssig"}, /* V17.0 */
LKFKKErrorSpezOrgFehlt =				{257, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Spezielle Organisations-/Betriebsform fehlt"},           /* V17.0 */
LKFKKErrorSpezOrgFK =					{258, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Funktionscode in Kombination mit Organisations-/Betriebsform ung\xc3\xbc""ltig", &LKFErrorAb2012}, /* V17.0 */
LKFKKErrorFuncLeistBereich =			{259, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Funktionscode in Kombination mit speziellem Leistungsbereich ung\xc3\xbc""ltig", &LKFErrorAb2014}, /* V17.0 */
LKFKKErrorKennzahlunvollst =			{260, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenbereichs-Kennzahlenindex unvollst\xc3\xa4""ndig gemeldet", &LKFErrorAb2012}, /* V17.0 */
LKFKKErrorVirtKSt =                     {262, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kostenstellennummer der virtuellen Kostenstelle nicht vorhanden"}, /* V18.0 */
LKFKKErrorBasisAusbKopfzahl =           {263, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Kopfzahl f\xc3\xbc""r Basisausbildung nur in Kombination mit \xc3\x84""rzten/innen f\xc3\xbc""r Allgemeinmedizin in Ausbildung zul\xc3\xa4""ssig"},  /* V20.0 */
LKFKKErrorBasisAusbVollzeit =           {264, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Vollzeit\xc3\xa4""quivalente f\xc3\xbc""r Basisausbildung nur in Kombination mit \xc3\x84""rzten/innen f\xc3\xbc""r Allgemeinmedizin in Ausbildung zul\xc3\xa4""ssig"}, /* V20.0 */
LKFKKErrorK03AmbBetreuungFalsch =       {265, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Ambulante Betreuungspl\xc3\xa4""tze insgesamt ung\xc3\xbc""ltig"},
LKFKKErrorK09AmbBetreuungFalsch =       {266, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Ambulante Betreuungspl\xc3\xa4""tze ung\xc3\xbc""ltig"},
LKFKKErrorAmbBettenInsgK09  =           {267, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Ambulante Betreuungspl\xc3\xa4""tze insgesamt ungleich ambulante Betreuungspl\xc3\xa4""tze auf den nicht-bettenf\xc3\xbc""hrenden Hauptkostenstellen"},
LKFKKErrorAuslastungK03 =               {268, LKF_FAC_KAS_KORE, LKF_SEV_ERROR, 0, 0, "Betten-Auslastung > 100% unplausibel"};

/* next = 268 */

const LKF_SATZART_ERRORDEF
	LKFKKErrorIntKostNrFehlt =			{  1, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Interne Kostenstellennummer fehlt"},
	LKFKKErrorIntKostMehrfach =			{  2, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Interne Kostenstelle mehrfach gemeldet"},
	LKFKKErrorIntKostBezFehlt =			{  3, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Interne Kostenstellenbezeichnung fehlt"},
	LKFKKErrorKABezFehlt =				{  4, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Krankenanstalt-Bezeichnung fehlt"},
	LKFKKErrorKAStrasseFehlt =			{  5, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Krankenanstalt-Stra\xc3\x9f""e fehlt"},
	LKFKKErrorKAPLZFehlt =				{  6, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Krankenanstalt-Postleitzahl fehlt"},
	LKFKKErrorKAPLZFalsch =				{  7, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Krankenanstalt-Postleitzahl ung\xc3\xbc""ltig"},
	LKFKKErrorKAOrtFehlt =				{  8, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Krankenanstalt-Ort fehlt"},
	LKFKKErrorKATelFehlt =				{  9, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Krankenanstalt-Telefon fehlt"},
	LKFKKErrorKAFaxFehlt =				{ 10, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Krankenanstalt-Fax fehlt"},
	LKFKKErrorKAHomepageFehlt =			{ 11, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Krankenanstalt-Homepage fehlt"},
	LKFKKErrorRechtsBezFehlt =			{ 12, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Rechtstr\xc3\xa4""ger-Bezeichnung fehlt"},
	LKFKKErrorRechtsStrasseFehlt =		{ 13, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Rechtstr\xc3\xa4""ger-Stra\xc3\x9f""e fehlt"},
	LKFKKErrorRechtsPLZFehlt =			{ 14, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Rechtstr\xc3\xa4""ger-Postleitzahl fehlt"},
	LKFKKErrorRechtsPLZFalsch =			{ 15, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Rechtstr\xc3\xa4""ger-Postleitzahl ung\xc3\xbc""ltig"},
	LKFKKErrorRechtsOrtFehlt =			{ 16, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Rechtstr\xc3\xa4""ger-Ort fehlt"},
	LKFKKErrorRechtsTelFehlt =			{ 17, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Rechtstr\xc3\xa4""ger-Telefon fehlt"},
	LKFKKErrorRechtsFaxFehlt =			{ 18, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Rechtstr\xc3\xa4""ger-Fax fehlt"},
	LKFKKErrorRechteHomepageFehlt =		{ 19, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Rechtstr\xc3\xa4""ger-Homepage fehlt"},
	LKFKKErrorSystBettenSondFehlt =		{ 20, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Systemisierte Betten Sonderklasse fehlt"},
	LKFKKError25PSKLBettenSyst =		{ 21, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Anteil systemisierte Betten Sonderklasse mehr als 25%"},
	LKFKKError25PSKLBettenTats =		{ 22, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Anteil tats\xc3\xa4""chliche Betten Sonderklasse mehr als 25%"},
	LKFKKErrorTatsBettenVerbleib =		{ 23, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Tats\xc3\xa4""chlich aufgestellte Betten insgesamt < am Jahresende Verbleibende"},
	LKFKKErrorTatsBettenSondVerbleib =	{ 24, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Tats\xc3\xa4""chlich aufgestellte Betten Sonderklasse < vom Vorjahr Verbliebene Sonderklasse"},
	LKFKKErrorBelagSonderklasseFehlt =	{ 25, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Belagstage Sonderklasse fehlt"},
	LKFKKErrorBegleitpersBelagstage =	{ 26, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Aufnahmen von Begleitpersonen > Belagstage von Begleitpersonen"},
	LKFKKErrorNArztVergleich =			{ 27, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Nicht-\xc3\xa4""rztliche Gesundheitsberufe nach Berufsgruppen (Kopfzahl) kleiner nicht-\xc3\xa4""rztliche Gesundheitsberufe nach Dienstverh\xc3\xa4""ltnis (Vollzeit)"},
	LKFKKErrorFacharztAquFalsch =		{ 28, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Fach\xc3\xa4""rzte/innen Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
	LKFKKErrorAllgArztAquFalsch =		{ 29, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "\xc3\x84""rzte/innen f\xc3\xbc""r Allgemeinmedizin Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
	LKFKKErrorFachArztAusbAquFalsch =	{ 30, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Fach\xc3\xa4""rzte/innen in Ausbildung Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
	LKFKKErrorAllgArztAusbAquFalsch =	{ 31, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "\xc3\x84""rzte/innen f\xc3\xbc""r Allgemeinmedizin in Ausbildung Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
	LKFKKErrorPersMaennAquFalsch =		{ 33, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Personal m\xc3\xa4""nnlich Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
	LKFKKErrorPersWeibAquFalsch =		{ 34, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Personal weiblich Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
	LKFKKErrorEUAuslAquFalsch =			{ 35, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Darunter EU-Ausl\xc3\xa4""nder/innen insgesamt Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
	LKFKKErrorNEUAuslAquFalsch =		{ 36, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Darunter Nicht-EU-Ausl\xc3\xa4""nder/innen insgesamt Vollzeit\xc3\xa4""quivalente ung\xc3\xbc""ltig"},
	LKFKKErrorArztAquFehlt =			{ 37, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "\xc3\x84""rzte/innen Vollzeit\xc3\xa4""quivalente fehlt"},
	LKFKKErrorGehDienstAquFehlt =		{ 38, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Gehobener Dienst f\xc3\xbc""r Gesundheits- und Krankenpflege und weitere Gesundheitsberufe Vollzeit\xc3\xa4""quivalente fehlt"},
	LKFKKErrorTBETTENohneSBETTEN =		{ 40, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "nur tats\xc3\xa4""chliche Betten gemeldet"},
	LKFKKErrorNurSBETT =				{ 41, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "nur systemisierte Betten gemeldet"},
	LKFKKErrorMedTechnDienstAquFehlt =	{ 42, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Gehobene med.-techn. Dienste, med.-techn. Fachdienst und Masseure/innen Vollzeit\xc3\xa4""quivalente fehlt"},
	LKFKKErrorIntOhneArztPers =			{ 43, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Intensivabteilung ohne \xc3\xa4""rztliches Personal"},
	LKFKKErrorOPOhneArztPers =			{ 44, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "OP ohne \xc3\xa4""rztliches Personal"},
	LKFKKErrorLaborOhneMedTechn =		{ 45, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Labor ohne Gehobene med.-techn. Dienste, med.-techn. Fachdienst"},
	LKFKKErrorNebenKostEndkosten =		{ 46, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Nebenkostenstelle mit Endkosten <= 0"},
	LKFKKErrorAufwandFalsch =			{ 47, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Aufwand gem\xc3\xa4""\xc3\x9f"" Finanzbuchf\xc3\xbc""hrung ung\xc3\xbc""ltig"},
	LKFKKErrorNeutralerAufwandFalsch =	{ 48, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Neutraler Aufwand ung\xc3\xbc""ltig"},
	LKFKKErrorKalkKostenFalsch =		{ 49, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Kalkulatorische Kosten ung\xc3\xbc""ltig"},
	LKFKKErrorAnlagenindexFalsch =		{ 50, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Anlagenindex ung\xc3\xbc""ltig"},
	LKFKKErrorAbschrLfdFalsch =			{ 58, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Abschreibungen laufendes Berichtsjahr ung\xc3\xbc""ltig"},
	LKFKKErrorNegKosten1000 =			{ 59, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Negative Kosten <-1.000 angegeben"},
	LKFErrorVerbleibUnplaus =		    { 60, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Anzahl der am Jahresende verbleibenden unplausibel"},
	LKFErrorTBETTunplausWarn =		    { 61, LKF_FAC_KAS_KORE,	LKF_SEV_WARNING, 0, 0, "Anzahl der tats\xc3\xa4""chlich aufgestellten Betten unplausibel"},
	LKFKKErrorArztFachK04DienstKopf =   { 63, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "\xc3\x84""rzte der Fachhauptbereiche < \xc3\x84""rzte nach Dienstverh\xc3\xa4""ltnis"},
	LKFKKErrorK08SystBettenFehlt =		{ 74, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Systemisierte Betten fehlt"},
    LKFKKErrorMaennlicheHebamme2017 =	{ 75, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "M\xc3\xa4""nnliche Hebammen unplausibel"},
    LKFKKErrorMaennlicheHebamme =		{ 75, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Maennliche Hebammen unplausibel"}, /* V11.0 */
	LKFGGErrorPosNichtVorhanden =		{ 14, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Gro\xc3\x9f""ger\xc3\xa4""t ohne Angabe von Leistungsdaten"},
	LKFGGErrorStrahlentherapie =		{  8, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Angaben zur Strahlentherapie unvollst\xc3\xa4""ndig"},
	LKFGGErrorAvgDauerFreqFehlt =		{ 15, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Durchschnittliche Dauer je Frequenz fehlt"},
	LKFKKErrorHebammenVZFalsch =		{ 76, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "M\xc3\xa4""nnliche Hebammen Vollzeit-\xc3\x84""quivalente unplausibel"}, /* V12.0 */
	LKFKKErrorKopfVZEQ =				{ 65, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Vollzeit\xc3\xa4""quivalente gesamt gleich Kopfzahl gesamt"}, /* V13.1 */
	LKFKKErrorAbt19_2012 =				{ 96, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Abteilungen mit Funktionscode '19xxxx' in landesgesundheitsfondsfinanzierten Krankenanstalten unzul\xc3\xa4""ssig"}, /* V17.0 */
    LKFKKErrorAuslastungK08 =           { 77, LKF_FAC_KAS_KORE, LKF_SEV_WARNING, 0, 0, "Betten-Auslastung > 100% unplausibel"};

/* next warn = 67, ausser 74/75/76 */

/*********************************************************************************************
** Satzart K01                                                                              **
*********************************************************************************************/

static int IsHK (LKF_CONTEXT *pContext, const char *sAbtFC)
{
	if (sAbtFC[0] == '1') return 1;
	else return 0;
}

static int lkf_IsBettHK (LKF_CONTEXT *pContext, const char *sAbtFC)
{
	if (sAbtFC[0] == '1' && strchr ("123459", sAbtFC[1]))
	{
		switch (sAbtFC[2])
		{
			case '7':
				if (sAbtFC[3] != '8') return 1;
				else return 0;
			case '8':
				if (strchr ("123", sAbtFC[3])) return 0;
				else return 1;
			default:
				return 1;
		}
	}
	else return 0;
}

static int IsNBettHK (LKF_CONTEXT *pContext, const char *sAbtFC)
{
	if (sAbtFC[0] == '1' && strchr ("678", sAbtFC[1])) return 1;
	else return 0;
}

static int IsNebenHK (LKF_CONTEXT *pContext, const char *sAbtFC)
{
	if (sAbtFC[0] == '2') return 1;
	else return 0;
}

static int IsHilfsHK (LKF_CONTEXT *pContext, const char *sAbtFC)
{
	if (sAbtFC[0] == '3') return 1;
	else return 0;
}

static int HasKAS (LKF_KK_CONTEXT *pKKContext)
{
	if (pKKContext->pSatzartCount[1] > 0) return 1;
	else return 0;
}

static int kaskore_berichtsjahr (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nVal;
	if (Satzart_GetValueInt (ds, len, pFeld, &nVal) == LKF_FIELD_ERROR) return 1;
	if (nVal != pCheckContext->pContext->cmb_jahr) return 1;
	else return 0;
}

static int kaskore_checkfunc (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sAbtFC[10];
	Satzart_GetValueString (ds, len, pFeld, sAbtFC, 10);

	if (!FunkInArray (pCheckContext->pContext->pStamm2001, sAbtFC)) return 1; 
	return 0;
}

static int kaskore_checkfunc_mehrfach (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbt;
	char sAbtFC[10];
	Satzart_GetValueString (ds, len, pFeld, sAbtFC, 10);

    if (!pCheckContext->pKKContext) return 1;
	pKKAbt = pCheckContext->pKKContext->pAktAbteilung;
	if (!pKKAbt || pKKAbt->pK01) return 1;
	
	pKKAbt->nK01Len = len;
	pKKAbt->pK01 = ds;
	return 0;
}

static int kaskore_spezorghk (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sAbtFC[10], sWert[5];
	if (Satzart_IsEmpty (ds, len, pFeld)) return 0;
	Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppKKSatzarten[0]->ppRef[GEN_ABTFC], sAbtFC, 10);

	if (IsHK (pCheckContext->pContext, pCheckContext->pKKContext->pAktAbteilung->sAbtFC)) return 0;
	else if (pCheckContext->pContext->modelljahr >= 2012 && pCheckContext->pKKContext->pAktAbteilung->sAbtFC[0] == '9') return 0;
	else
	{
		Satzart_GetValueString (ds, len, pFeld, sWert, 5);
        
        if (pCheckContext->pContext->modelljahr >= 2018 && IsNBettHK(pCheckContext->pContext, pCheckContext->pKKContext->pAktAbteilung->sAbtFC) && *sWert == 'H')
            return 0; /* V2019.0 */
        
		sprintf (pCheckContext->sErrorAdditionalInfo, "%8.8s: %1s", sAbtFC, sWert);
		return 1;
	}
}

static int k01_check_intkost_mehrfach (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sIntKost[10];
	if (pCheckContext->pKKContext->pAktAbteilung)
	{
		unsigned int i;
        unsigned int kstlen = (pCheckContext->pContext->modelljahr >= 2017) ? 8 : 6;

		if (pCheckContext->pKKContext->pAktAbteilung->sAbtFC[0] == '9' && pCheckContext->pContext->modelljahr >= 2012)
			return 0; /* V17.1 */

		Satzart_GetValueString (ds, len, pFeld, sIntKost, 10);
		for (i = 0; i < pCheckContext->pKKContext->nAbtCount; i++)
		{

			if (pCheckContext->pKKContext->pKKAbteilung[i].sAbtFC[0] == '9' && pCheckContext->pContext->modelljahr >= 2012)
				continue; /* V17.1 */

			if (!strncmp (pCheckContext->pKKContext->pKKAbteilung[i].sIntKost, sIntKost, kstlen))
			{
				if (pCheckContext->bKKTraceDetail)
				{
					char sTraceLine[512];
                    if (kstlen == 8) {
                        sprintf (sTraceLine, "Abteilung '%8.8s' hat die gleiche Kostenstelle ('%8.8s')",
                                 pCheckContext->pKKContext->pKKAbteilung[i].sAbtFC, sIntKost);
                    }
                    else {
                        sprintf (sTraceLine, "Abteilung '%8.8s' hat die gleiche Kostenstelle ('%6.6s')",
                                 pCheckContext->pKKContext->pKKAbteilung[i].sAbtFC, sIntKost);
                    }
					lkf_trace_kk_detail (pCheckContext, sTraceLine);
				}
				return 1;
			}
			
		}
		strncpy (pCheckContext->pKKContext->pAktAbteilung->sIntKost, sIntKost, kstlen);
		pCheckContext->pKKContext->pAktAbteilung->sIntKost[kstlen] = 0;
	}
	return 0;
}

static int lkf_IsFondsKA (LKF_CHECK_CONTEXT *pCheckContext)
{
	if (pCheckContext->pContext->flags & LKFCONTEXT_NICHTFONDSKA) return 0;
	return 1;
}

static int k01_check_spezorg_fehlt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V17.0 */
	char sFeld[2];
	char sAbtFC[10];
	if (pCheckContext->pContext->modelljahr < 2013 && pCheckContext->pContext->period_type != 'J') return 0;
	Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppKKSatzarten[0]->ppRef[GEN_ABTFC], sAbtFC, 9);
	if (sAbtFC[0] != '9' && sAbtFC[0] != '1') return 0;
	if (IsNBettHK(pCheckContext->pContext, sAbtFC)) return 0;
	if (!memcmp (sAbtFC, "100000", 6)) return 0; /* V17.1 */
	Satzart_GetValueString (ds, len, pFeld, sFeld, 1);
	if (!sFeld[0] || sFeld[0]== ' ') return 1;
	return 0;
}

static int k01_check_standort_falsch (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sKANR[8];
	Satzart_GetValueString (ds, len, pFeld, sKANR, 8);

	if (!sKANR[4] || (sKANR[4] == ' ' && (!sKANR[5] || sKANR[5] == ' ')))
		return 0; /* Standort leer */

	if (!FindOEKASO6 (pCheckContext->pContext->pStamm2001, sKANR))
		return 1; /* Angegebener Standort existiert nicht -> Fehler */

	return 0;
}

static int k01_check_standort_fehlt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sKANR[8];
	Satzart_GetValueString (ds, len, pFeld, sKANR, 8);
	if (sKANR[4] && (sKANR[4] != ' ' || (sKANR[5] && sKANR[5] != ' ')))
		return 0; /* Standort nicht leer */
	
	if (FindOEKASO4 (pCheckContext->pContext->pStamm2001, sKANR))
		return 1; /* Das KA hat Standorte -> Fehler */

	return 0;
}

static int k01_check19 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V17.0 */
	char sAbtFC[10];
	Satzart_GetValueString (ds, len, pFeld, sAbtFC, 9);
	if (!memcmp (sAbtFC, "19", 2)) return 1;
	return 0;
}

static int k01_virtKSTCheck (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V18.0: virtuelle Kostenstellen muessen zumindest eine Kostenstelle referenzieren */
	const SATZART_FELD *pSpezOrgFeld;
	const SATZART_FELD *pAbtFCFeld;
	char sSpezOrg[4];
	char sAbtFC[10];
	unsigned int i;
	int found = 0;
	char sKst[10], sCurKst[10], sTestAbtFC[10];
	const SATZART_FELD *pKstFeld = pCheckContext->pKKContext->ppKKSatzarten[0]->ppRef[K01_INT_KOSTNR];
    const char **ppK01 = (len == LKF_LEN_FOR_EXPANDEDLINE) ? (const char **) pCheckContext->pKKContext->pppExpandedLines[0] : pCheckContext->pKKContext->pppSatzartRecords[0];
    
	pSpezOrgFeld = pCheckContext->pKKContext->ppKKSatzarten[0]->ppRef[K01_SPEZ_ORG];
	pAbtFCFeld = pCheckContext->pKKContext->ppKKSatzarten[0]->ppRef[GEN_ABTFC];

	Satzart_GetValueString (ds, len, pFeld, sAbtFC, 9);
   	Satzart_GetValueString (ds, len, pSpezOrgFeld, sSpezOrg, 2);
	Satzart_GetValueString (ds, len, pKstFeld, sKst, 9);

    if (sAbtFC[0] != '9') return 0;
    
	for (i=0; i < pCheckContext->pKKContext->pSatzartCount[0]; i++) 
	{
        unsigned int len01 = (len == LKF_LEN_FOR_EXPANDEDLINE) ? LKF_LEN_FOR_EXPANDEDLINE : (unsigned int) strlen (ppK01[i]);
		Satzart_GetValueString (ppK01[i], len01, pAbtFCFeld, sTestAbtFC, 9);
		if (sTestAbtFC[0] != '9') 
		{
			Satzart_GetValueString (ppK01[i], len01, pKstFeld, sCurKst, 9);
			if (!strcmp (sKst, sCurKst))
			{
				found = 1;
				break;
			}
		}
	}
	return found ? 0 : 1;
}


static int k01_spezorgfunkhk (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V17.0; V17.1 Ueberarbeitet */
	const SATZART_FELD *pSpezOrgFeld;
	const SATZART_FELD *pAbtFCFeld;
	char sSpezOrg[4];
	char sAbtFC[10];
    int modelljahr;
    
    static const char *SpezOrgH[] = {"14xxxxxx", "16xxxxxx", "17xxxxxx", "18xxxxxx",0};
    static const char *SpezOrgTKH[] = {"14xxxxxx", 0};
    static const char *SpezOrgRbis2023[] =   {"xx1153xx", "xx1196xx", "xx2196xx", "xx2811xx", "xx2911xx", "xx3253xx", "xx5171xx", "xx5196xx", "xx5158xx", "xx7553xx", "xx2854xx", "xx1996xx", 0}; /* V21.2 */
    static const char *SpezOrgR2024[] =   {"xx0496xx", "xx1153xx", "xx1196xx", "xx2196xx", "xx2811xx", "xx2911xx", "xx3253xx", "xx5171xx", "xx5196xx", "xx5158xx", "xx7553xx", "xx2854xx", "xx1996xx", 0}; /* V21.2 */
    static const char *SpezOrgR[] =   {"xx0496xx", "xx1196xx", "xx2196xx", "xx2811xx", "xx2911xx", "xx3253xx", "xx5171xx", "xx5196xx", "xx5158xx", "xx7553xx", "xx2854xx", "xx1996xx", "xx0460xx", "xx1160xx", "xx5160xx", 0}; /* V21.2 */

    static const char *SpezOrgZSbis2023[] =  {"xx3258xx", "xx1112xx", "xx1158xx", "xx1171xx", "xx1258xx", "xx2113xx", "xx2158xx", "xx3158xx", "xx6358xx", "xx7258xx", "xx2011xx", "xx0711xx", "xx0458xx", "xx1958xx", "xx9158xx", "xx0811xx", 0}; /* V21.2 */
    static const char *SpezOrgZS[] =  {"xx0958xx", "xx3258xx", "xx1112xx", "xx1158xx", "xx1171xx", "xx1258xx", "xx2113xx", "xx2158xx", "xx3158xx", "xx6358xx", "xx7258xx", "xx2011xx", "xx0711xx", "xx0458xx", "xx1958xx", "xx9158xx", "xx0811xx", 0}; /* V21.2 */
    
    
    static const char *SpezOrgV[] =   {"xx6340xx", "xx6341xx", "xx6342xx", 0}; /* V2025.0 */
    
#ifdef SUPPORT_PRE2017
    static const char *SpezOrgRbis2013[] =   {"xx2114xx" /* V17.1 */, "xx2116xx" /* V17.1 */, "xx1153xx" /* V17.1 */, "xx1196xx", "xx2196xx", "xx2811xx", "xx2911xx", "xx3253xx", "xx5171xx", "xx5196xx", "xx5158xx", "xx7553xx", 0};
    static const char *SpezOrgRbis2016[] =   {"xx1153xx" /* V17.1 */, "xx1196xx", "xx2196xx", "xx2811xx", "xx2911xx", "xx3253xx", "xx5171xx", "xx5196xx", "xx5158xx", "xx7553xx", 0};
    static const char *SpezOrgZSbis2016[] =  {"xx3258xx" /* V17.1 */, "xx1112xx", "xx1158xx", "xx1171xx", "xx1258xx", "xx2113xx", "xx2158xx", "xx3158xx", "xx6358xx", "xx7258xx", 0};
#endif
    
    modelljahr = pCheckContext->pContext->modelljahr;
    
	pSpezOrgFeld = pCheckContext->pKKContext->ppKKSatzarten[0]->ppRef[K01_SPEZ_ORG];
	pAbtFCFeld = pCheckContext->pKKContext->ppKKSatzarten[0]->ppRef[GEN_ABTFC];

	Satzart_GetValueString (ds, len, pSpezOrgFeld, sSpezOrg, 2);
	Satzart_GetValueString (ds, len, pAbtFCFeld, sAbtFC, 9);
    
    if (sSpezOrg[0] == 'H' && modelljahr >= 2019)
    { /* V2019.2 */
        return abt_in_patternlist (sAbtFC, SpezOrgH) ? 0 : 1;
    }
	else if (sSpezOrg[0] == 'T' || sSpezOrg[0] == 'K' || sSpezOrg[0] == 'H')
	{
		return abt_in_patternlist (sAbtFC, SpezOrgTKH) ? 0 : 1;
	}
	else if (sSpezOrg[0] == 'R' || sSpezOrg[0] == 'Z' || sSpezOrg[0] == 'S' || sSpezOrg[0] == 'V')
	{
		unsigned int i;
		int found = 0;
		char sKst[10], sCurKst[10], sTestAbtFC[10];
		char sCurSpezOrg[3];
		const SATZART_FELD *pKstFeld = pCheckContext->pKKContext->ppKKSatzarten[0]->ppRef[K01_INT_KOSTNR];
    
		switch (sSpezOrg[0]) 
		{
			case 'R':
#ifdef SUPPORT_PRE2017
                if (modelljahr >= 2025) {
                    if (abt_in_patternlist (sAbtFC, SpezOrgR)) return 0;
                }
                else if (modelljahr == 2024) {
                    if (abt_in_patternlist (sAbtFC, SpezOrgR2024)) return 0;
                }
                else if (modelljahr >= 2017)
                {
                    if (abt_in_patternlist (sAbtFC, SpezOrgRbis2023)) return 0;
                }
                else if (modelljahr > 2013)
                {
                    if (abt_in_patternlist (sAbtFC, SpezOrgRbis2016)) return 0;
                }
				else if (abt_in_patternlist (sAbtFC, SpezOrgRbis2013)) return 0;
#else
                if (modelljahr >= 2025) {
                    if (abt_in_patternlist (sAbtFC, SpezOrgR)) return 0;
                }
                else if (modelljahr == 2024) {
                    if (abt_in_patternlist (sAbtFC, SpezOrgR2024)) return 0;
                }
                else {
                    if (abt_in_patternlist (sAbtFC, SpezOrgRbis2023)) return 0;
                }
#endif
				break;
            case 'Z':
            case 'S':
#ifdef SUPPORT_PRE2017
                if (modelljahr >= 2024)
                {
                    if (abt_in_patternlist (sAbtFC, SpezOrgZS)) return 0;
                }
                if (modelljahr >= 2017)
                {
                    if (abt_in_patternlist (sAbtFC, SpezOrgZSbis2023)) return 0;
                }
                else if (abt_in_patternlist (sAbtFC, SpezOrgZSbis2016)) return 0;
#else
                if (modelljahr >= 2024)
                {
                    if (abt_in_patternlist (sAbtFC, SpezOrgZS)) return 0;
                }
                else {
                    if (abt_in_patternlist (sAbtFC, SpezOrgZSbis2023)) return 0;
                }
#endif
				break;
            case 'V':
                if (abt_in_patternlist (sAbtFC, SpezOrgV)) return 0;
			default:
				break;
		}

        if (sAbtFC[0] == '9') {
            if (modelljahr >= 2024) {
                sprintf (pCheckContext->sErrorAdditionalInfo, "%8.8s/%c", sAbtFC, sSpezOrg[0]);
            }
            return 1;
        }

		Satzart_GetValueString (ds, len, pKstFeld, sKst, 9);

        if (modelljahr >= 2017)
        {
            const LKF_EXPANDED_LINE **ppK01 = pCheckContext->pKKContext->pppExpandedLines[0];
            
            for (i=0; i < pCheckContext->pKKContext->pSatzartCount[0]; i++)
            {
                Satzart_GetValueStringExp(ppK01[i], pSpezOrgFeld, sCurSpezOrg, 2);
                
                if (sSpezOrg[0] == sCurSpezOrg[0] || (sSpezOrg[0] == 'R' && (sCurSpezOrg[0] == 'Z' || sCurSpezOrg[0] == 'S' || sCurSpezOrg[0] == 'V')))
                {
                    Satzart_GetValueStringExp (ppK01[i], pAbtFCFeld, sTestAbtFC, 9);
                    
                    if (sTestAbtFC[0] == '9')
                    {
                        Satzart_GetValueStringExp (ppK01[i], pKstFeld, sCurKst, 9);
                        if (!strcmp (sKst, sCurKst))
                        {
                            found = 1;
                            break;
                        }
                    }
                }
            }
        }
#ifdef SUPPORT_PRE2017
        else
        {
            const char **ppK01 = pCheckContext->pKKContext->pppSatzartRecords[0];
            
            for (i=0; i < pCheckContext->pKKContext->pSatzartCount[0]; i++)
            {
                unsigned int len01 = (unsigned int) strlen (ppK01[i]);
                Satzart_GetValueString (ppK01[i], len01, pSpezOrgFeld, sCurSpezOrg, 2);
                
                if (sSpezOrg[0] == sCurSpezOrg[0] || (sSpezOrg[0] == 'R' && (sCurSpezOrg[0] == 'Z' || sCurSpezOrg[0] == 'S')))
                {
                    Satzart_GetValueString (ppK01[i], len01, pAbtFCFeld, sTestAbtFC, 9);
                    
                    if (sTestAbtFC[0] == '9')
                    {
                        Satzart_GetValueString (ppK01[i], len01, pKstFeld, sCurKst, 7);
                        if (!strcmp (sKst, sCurKst))
                        {
                            found = 1;
                            break;
                        }
                    }
                }
            }
        }
#endif
        if (found) {
            return 0;
        }
        if (modelljahr >= 2024) {
            sprintf (pCheckContext->sErrorAdditionalInfo, "%8.8s/%c", sAbtFC, sSpezOrg[0]);
        }
        return 1;
	}

	return 0;
}

const LKF_SATZART_ERRORCHECK_STRINGLIST 
	stringlist_SpezOrg2006 = {7, {"D", "F", "T", "A", "R", "B", ""}},
	stringlist_SpezOrgFk2012 = {14, {"A", "R", "Z", "S", "D", "F", "T", "W", "K", "H", "M", "X", "B", ""}}, /* V17.0 */
	stringlist_SpezOrgFk2013 = {13, {"A", "R", "Z", "S", "D", "F", "T", "W", "K", "H", "M", "X", ""}}, /* V17.0 */
    stringlist_SpezOrgFk2025 = {14, {"A", "R", "Z", "S", "D", "F", "T", "W", "K", "H", "M", "X", "V", ""}}; /* V2025.0 */

const LKF_SATZART_ERRORCHECK
	LKFKKCheckStandortFalsch =				{LKF_CHECKFUNC_FUNCTION, k01_check_standort_falsch, &LKFErrorStandortFalsch, 0, 0}, /* V13.0 */
	LKFKKCheckStandortFehlt =				{LKF_CHECKFUNC_FUNCTION, k01_check_standort_fehlt, &LKFErrorStandortFehlt, 0, &LKFKKCheckStandortFalsch},
	LKFKKCheckIntKostMehrfach =				{LKF_CHECKFUNC_FUNCTION, k01_check_intkost_mehrfach, &LKFKKErrorIntKostMehrfach, 0, 0},
	LKFKKCheckIntKostNrFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorIntKostNrFehlt, 0, &LKFKKCheckIntKostMehrfach},
	LKFKKCheckIntKostBezFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorIntKostBezFehlt, 0, 0},
	LKFKKCheckBerichtsjahrfalsch =			{LKF_CHECKFUNC_FUNCTION, kaskore_berichtsjahr, &LKFKKErrorBerichtsjahrfalsch, 0, 0},
	LKFKKCheckBerichtsjahr =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorBerichtsjahrfehlt, 0, &LKFKKCheckBerichtsjahrfalsch},
	LKFKKCheck19 =							{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k01_check19, &LKFKKErrorAbt19, 0, 0},        /* V17.0 */
	LKFKKCheck19_2012 =						{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k01_check19, &LKFKKErrorAbt19_2012, 0, 0},   /* V17.0 */
    LKFKKCheckVirt =                        {LKF_CHECKFUNC_FUNCTION, k01_virtKSTCheck, &LKFKKErrorVirtKSt, 0, &LKFKKCheck19},
    LKFKKCheckFunktionscodemehrfach_2013 =	{LKF_CHECKFUNC_FUNCTION, kaskore_checkfunc_mehrfach, &LKFKKErrorFunktionscodemehrfach, 0, &LKFKKCheckVirt},
	LKFKKCheckFunktionscodemehrfach_2012 =	{LKF_CHECKFUNC_FUNCTION, kaskore_checkfunc_mehrfach, &LKFKKErrorFunktionscodemehrfach, 0, &LKFKKCheck19_2012, 2013, &LKFKKCheckFunktionscodemehrfach_2013},
	LKFKKCheckFunktionscodemehrfach =		{LKF_CHECKFUNC_FUNCTION, kaskore_checkfunc_mehrfach, &LKFKKErrorFunktionscodemehrfach, 0, 0, 2012, &LKFKKCheckFunktionscodemehrfach_2012},
	LKFKKCheckSpezOrgnurHK =				{LKF_CHECKFUNC_FUNCTION, kaskore_spezorghk, &LKFKKErrorSpezOrgnurHK, 0, 0},
	LKFKKCheckSpezOrgFK2012 =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k01_spezorgfunkhk, &LKFKKErrorSpezOrgFK, 0, 0}, /* V17.0 */
	LKFKKCheckSpezOrgnurHK2012 =			{LKF_CHECKFUNC_FUNCTION, kaskore_spezorghk, &LKFKKErrorSpezOrgnurHK2012, 0, &LKFKKCheckSpezOrgFK2012}, /* V17.0 */
    LKFKKCheckSpezOrg2025 =                    {LKF_CHECKFUNC_STRINGLIST, &stringlist_SpezOrgFk2025, &LKFKKErrorSpezOrgfalsch2012, 0, &LKFKKCheckSpezOrgnurHK2012}, /* V17.0 */
	LKFKKCheckSpezOrg2013 =					{LKF_CHECKFUNC_STRINGLIST, &stringlist_SpezOrgFk2013, &LKFKKErrorSpezOrgfalsch2012, 0, &LKFKKCheckSpezOrgnurHK2012, 2025, &LKFKKCheckSpezOrg2025}, /* V17.0 */
	LKFKKCheckSpezOrg2012 =					{LKF_CHECKFUNC_STRINGLIST, &stringlist_SpezOrgFk2012, &LKFKKErrorSpezOrgfalsch2012, 0, &LKFKKCheckSpezOrgnurHK2012, 2013, &LKFKKCheckSpezOrg2013}, /* V17.0 */
	LKFKKCheckSpezOrgFehlt2013 =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k01_check_spezorg_fehlt, &LKFKKErrorSpezOrgFehlt, 0, &LKFKKCheckSpezOrg2012}, /* V17.0 */
	LKFKKCheckSpezOrgFehlt =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k01_check_spezorg_fehlt, &LKFKKErrorSpezOrgFehlt, 0, &LKFKKCheckSpezOrg2012, 2013, &LKFKKCheckSpezOrgFehlt2013}, /* V17.0 */
    LKFKKCheckSpezOrg =                     {LKF_CHECKFUNC_STRINGLIST, &stringlist_SpezOrg2006, &LKFKKErrorSpezOrgfalsch, 0, &LKFKKCheckSpezOrgnurHK};

const int k01_ident[] = {0,1,2,-1};

const SATZART_FELD K01KANR2009 = {GEN_KANR,	TYP_ALPHA,	 8,  6, &LKFKKCheckStandortFehlt, 0, "KANR"};
const SATZART_FELD K01SpezOrg2012 = {K01_SPEZ_ORG, TYP_ALPHA,  78,  1, &LKFKKCheckSpezOrgFehlt, 0, "SPEZIELLE ORGANISATIONSFORM"};

const SATZART K01Satzart = {"K01", 0,  6, 6,(const int *) &k01_ident, "Kostenstellenplan", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR", 2009, &K01KANR2009},
	{GEN_ABTFC,					TYP_NUM,    14,  8, &LKFKKCheckFunktionscodemehrfach, 0, "FUNKTIONSCODE"},
	{K01_INT_KOSTNR,			TYP_ALPHA,	22,  6, &LKFKKCheckIntKostNrFehlt, 0, "INT. KOSTENSTELLENNUMMER"},
	{K01_INT_KOSTBEZ,			TYP_ALPHA,  28, 50, &LKFKKCheckIntKostBezFehlt, 0, "INT. KOSTENSTELLENBEZ."},
	{K01_SPEZ_ORG,				TYP_ALPHA,  78,  1, &LKFKKCheckSpezOrg, 0, "SPEZIELLE ORGANISATIONSFORM", 2012, &K01SpezOrg2012}
}};

const SATZART K01Satzart2017 = {"K01", 0,  6, 6,(const int *) &k01_ident, "Kostenstellenplan", 0, {
    {GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
    {GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR", 2009, &K01KANR2009},
    {GEN_ABTFC,					TYP_NUM,    14,  8, &LKFKKCheckFunktionscodemehrfach, 0, "FUNKTIONSCODE"},
    {K01_INT_KOSTNR,			TYP_ALPHA,	22,  8, &LKFKKCheckIntKostNrFehlt, 0, "INT. KOSTENSTELLENNUMMER"},
    {K01_INT_KOSTBEZ,			TYP_ALPHA_TRUNC,  30, 50, &LKFKKCheckIntKostBezFehlt, 0, "INT. KOSTENSTELLENBEZ."},
    {K01_SPEZ_ORG,				TYP_ALPHA,  80,  1, &LKFKKCheckSpezOrgFehlt, 0, "SPEZIELLE ORGANISATIONSFORM"}
}}; /* V21.3 (INT_KOSTNR von 6 auf 8 Byte) */


/*********************************************************************************************
** Satzart K02                                                                              **
*********************************************************************************************/

static int kaskore_leitungsformat (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	static const char *sSpecialUCase = "/\xc3\xa4""\xc3\xb6""\xc3\xbc""";

	unsigned int nLen, nPos;
	char sBuf[200];
	Satzart_GetValueString (ds, len, pFeld, sBuf, 200);
	
	nPos = 0;
	nLen = (unsigned int) strlen (sBuf);

	while (nPos < nLen && (sBuf[nPos] < 'a' || sBuf[nPos] > 'z') && !strchr (sSpecialUCase, sBuf[nPos])) ++nPos;
	if (nPos == nLen || sBuf[nPos++] != '/') return 1;

	while (nPos < nLen && sBuf[nPos] != '/') ++nPos;
	if (nPos == nLen) return 0;
	++nPos;
	while (nPos < nLen && sBuf[nPos] != '/') ++nPos;
	if (nPos < nLen) return 1;
	return 0;
}

static int check_plz (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int trimmed_plz_len;
	char sPlz[8], sTrimmedPlz[8];
	Satzart_GetValueString (ds, len, pFeld, sPlz, 8);
	trimmed_plz_len = simTrim (sTrimmedPlz, sPlz, 6);

	if (trimmed_plz_len == 4 && PLZInArray (pCheckContext->pContext, sTrimmedPlz)) return 0;
	return 1; /* PLZ ung\xc3\xbc""ltig */
}

const LKF_SATZART_ERRORCHECK
	LKFKKCheckKABezFehlt =					{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorKABezFehlt, 0, 0},
	LKFKKCheckKAStrasseFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorKAStrasseFehlt, 0, 0},
	LKFKKCheckKAPLZFalsch =					{LKF_CHECKFUNC_FUNCTION, check_plz, &LKFKKErrorKAPLZFalsch, 0, 0},
	LKFKKCheckKAPLZFehlt =					{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorKAPLZFehlt, 0, &LKFKKCheckKAPLZFalsch},
	LKFKKCheckKAOrtFehlt =					{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorKAOrtFehlt, 0, 0},
	LKFKKCheckKATelFehlt =					{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorKATelFehlt, 0, 0},
	LKFKKCheckKAFaxFehlt =					{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorKAFaxFehlt, 0, 0},
	LKFKKCheckKAHomepageFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorKAHomepageFehlt, 0, 0},
	LKFKKCheckRechtsBezFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorRechtsBezFehlt, 0, 0},
	LKFKKCheckRechtsStrasseFehlt =			{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorRechtsStrasseFehlt, 0, 0},
	LKFKKCheckRechtsPLZFalsch =				{LKF_CHECKFUNC_FUNCTION, check_plz, &LKFKKErrorRechtsPLZFalsch, 0, 0},
	LKFKKCheckRechtsPLZFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorRechtsPLZFehlt, 0, &LKFKKCheckRechtsPLZFalsch},
	LKFKKCheckRechtsOrtFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorRechtsOrtFehlt, 0, 0},
	LKFKKCheckRechtsTelFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorRechtsTelFehlt, 0, 0},
	LKFKKCheckRechtsFaxFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorRechtsFaxFehlt, 0, 0},
	LKFKKCheckRechteHomepageFehlt =			{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorRechteHomepageFehlt, 0, 0},
	LKFKKCheckAerztlLeitungfalsch =			{LKF_CHECKFUNC_FUNCTION, kaskore_leitungsformat, &LKFKKErrorAerztlLeitungfalsch, 0, 0},
	LKFKKCheckAerztlLeitung =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorAerztlLeitungfehlt, 0, &LKFKKCheckAerztlLeitungfalsch},
	LKFKKCheckVerwLeitungfalsch =			{LKF_CHECKFUNC_FUNCTION, kaskore_leitungsformat, &LKFKKErrorVerwLeitungfalsch, 0, 0},
	LKFKKCheckVerwLeitung =					{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorVerwLeitungfehlt, 0, &LKFKKCheckVerwLeitungfalsch},
	LKFKKCheckPflegeLeitungfalsch =			{LKF_CHECKFUNC_FUNCTION, kaskore_leitungsformat, &LKFKKErrorPflegeLeitungfalsch, 0, 0},
	LKFKKCheckPflegeLeitung =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorPflegeLeitungfehlt, 0, &LKFKKCheckPflegeLeitungfalsch};

const SATZART K02Satzart = {"K02", 0, 19, 19, (const int *) &k01_ident, "KA-Stammdaten", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K02_BEZEICHNUNG,			TYP_ALPHA,  14,150, &LKFKKCheckKABezFehlt, 0, "BEZEICHNUNG"},
	{K02_STRASSE,				TYP_ALPHA, 164, 50, &LKFKKCheckKAStrasseFehlt, 0, "STRASSE"},
	{K02_PLZ,					TYP_ALPHA, 214,  6, &LKFKKCheckKAPLZFehlt, 0, "PLZ"},
	{K02_ORT,					TYP_ALPHA, 220, 50, &LKFKKCheckKAOrtFehlt, 0, "ORT"},
	{K02_TELEFON,				TYP_ALPHA, 270, 20, &LKFKKCheckKATelFehlt, 0, "TELEFON"},
	{K02_FAX,					TYP_ALPHA, 290, 20, &LKFKKCheckKAFaxFehlt, 0, "FAX"},
	{K02_HOMEPAGE,				TYP_ALPHA, 310,100, &LKFKKCheckKAHomepageFehlt, 0, "HOMEPAGE"},
	{K02_RECHT_BEZEICHNUNG,		TYP_ALPHA, 410,150, &LKFKKCheckRechtsBezFehlt, 0, "RECHTSTRAEGER-BEZEICHNUNG"},
	{K02_RECHT_STRASSE,			TYP_ALPHA, 560, 50, &LKFKKCheckRechtsStrasseFehlt, 0, "RECHTSTRAEGER-STRASSE"},
	{K02_RECHT_PLZ,				TYP_ALPHA, 610,  6, &LKFKKCheckRechtsPLZFehlt, 0, "RECHTSTRAEGER-PLZ"},
	{K02_RECHT_ORT,				TYP_ALPHA, 616, 50, &LKFKKCheckRechtsOrtFehlt, 0, "RECHTSTRAEGER-ORT"},
	{K02_RECHT_TELEFON,			TYP_ALPHA, 666, 20, &LKFKKCheckRechtsTelFehlt, 0, "RECHTSTRAEGER-TELEFON"},
	{K02_RECHT_FAX,				TYP_ALPHA, 686, 20, &LKFKKCheckRechtsFaxFehlt, 0, "RECHTSTRAEGER-FAX"},
	{K02_RECHT_HOMEPAGE,		TYP_ALPHA, 706,100, &LKFKKCheckRechteHomepageFehlt, 0, "RECHTSTRAEGER-HOMEPAGE"},
	{K02_AERZTLICHE_LEITUNG,	TYP_ALPHA, 806,100, &LKFKKCheckAerztlLeitung, 0, "AERZTLICHE LEITUNG"},
	{K02_VERWALTUNGSLEITUNG,	TYP_ALPHA, 906,100, &LKFKKCheckVerwLeitung, 0, "VERWALTUNGSLEITUNG"},
	{K02_PFLEGEDIENSTLEITUNG,   TYP_ALPHA,1006,100, &LKFKKCheckPflegeLeitung, 0, "PFLEGEDIENSTLEITUNG"}
}};

/*********************************************************************************************
** Satzart K03                                                                              **
*********************************************************************************************/

static int check_ambbetten (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V21.0 */
    unsigned int i, nCountK09;
    const SATZART_FELD *pSum;
    int nAmbBetr, nSum, nAct;
	const LKF_EXPANDED_LINE **ppK09;

    Satzart_GetValueInt (ds, len, pFeld, &nAmbBetr);
    
    nCountK09 = pCheckContext->pKKContext->pSatzartCount[8];
    pSum = pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K09_AMBPLAETZE];
    nSum = 0;
    ppK09 = pCheckContext->pKKContext->pppExpandedLines[8];

    for (i = 0; i < nCountK09; i++)
    {
        if (Satzart_GetValueIntExp (ppK09[i], pSum, &nAct)) return 0;
        nSum += nAct;
    }
    
    if (nSum < nAmbBetr) return 1;
    return 0;
}

static int kaskore_systbetten_k08 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    unsigned int i, nCountK08;
    const SATZART_FELD *pSum;
    int nSystBetten, nSum, nAct;
    Satzart_GetValueInt (ds, len, pFeld, &nSystBetten);
    
    nCountK08 = pCheckContext->pKKContext->pSatzartCount[7];
    
    pSum = pCheckContext->pKKContext->ppKKSatzarten[7]->ppRef[K08_SYST_BETTEN];
    
    nSum = 0;
    
    if (pCheckContext->pContext->modelljahr >= 2017) {
        const LKF_EXPANDED_LINE **ppK08 = pCheckContext->pKKContext->pppExpandedLines[7];
        for (i = 0; i < nCountK08; i++)
        {
            if (Satzart_GetValueIntExp (ppK08[i], pSum, &nAct)) return 0;
            nSum += nAct;
        }
    }
    else {
        const char **ppK08 = pCheckContext->pKKContext->pppSatzartRecords[7];
        for (i = 0; i < nCountK08; i++)
        {
            if (Satzart_GetValueInt (ppK08[i], (unsigned int) strlen (ppK08[i]), pSum, &nAct)) return 0;
            nSum += nAct;
        }
    }
    
    if (nSum != nSystBetten) return 1;
    return 0;
}

static int kaskore_systbetten_sond (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int systbett_insg, systbett_sond;

	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_SYST_BETTEN_SUM], &systbett_insg)) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_SYST_BETTEN_SOND], &systbett_sond)) return 0;
	if (systbett_insg < systbett_sond) return 1;
	return 0;
}

static int kaskore_tatsbetten_k08 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int i, nCountK08;
	const SATZART_FELD *pSum;
	int nTatsBetten, nSum, nAct;
	Satzart_GetValueInt (ds, len, pFeld, &nTatsBetten);
	
	nCountK08 = pCheckContext->pKKContext->pSatzartCount[7];

	pSum = pCheckContext->pKKContext->ppKKSatzarten[7]->ppRef[K08_TATS_BETTEN];

	nSum = 0;

    if (pCheckContext->pContext->modelljahr >= 2017) {
        const LKF_EXPANDED_LINE **ppK08 = pCheckContext->pKKContext->pppExpandedLines[7];
        for (i = 0; i < nCountK08; i++)
        {
            if (Satzart_GetValueIntExp (ppK08[i], pSum, &nAct)) return 0;
            nSum += nAct;
        }
    }
    else {
        const char **ppK08 = pCheckContext->pKKContext->pppSatzartRecords[7];
                for (i = 0; i < nCountK08; i++)
        {
            if (Satzart_GetValueInt (ppK08[i], (unsigned int) strlen (ppK08[i]), pSum, &nAct)) return 0;
            nSum += nAct;
        }
    }

	if (nSum != nTatsBetten) return 1;
	return 0;
}

static int kaskore_tatsbetten_sond (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int tatsbett_insg, tatsbett_sond;

	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_TATS_BETTEN_INSG], &tatsbett_insg)) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_TATS_BETTEN_SOND], &tatsbett_sond)) return 0;
	if (tatsbett_insg < tatsbett_sond) return 1;
	return 0;
}

static int IsAmgChemo (LKF_AUFENTHALT *pAufenthalt) {
    if (pAufenthalt->pScoringContext->modelljahr >= 2025)
    { /* V2025.1 */
        if (!memcmp (pAufenthalt->GRP, "MEL22", 5)) {
            return memcmp (pAufenthalt->GRP + 5, ".11", 3) ? 1 : 0;
        }
        if (!memcmp (pAufenthalt->GRP, "AMG21", 5)) {
            char first = pAufenthalt->GRP[6],
                 second = pAufenthalt->GRP[7];
            if (second == '5' && (first == '1' || first == '2')) return 1;
            if (first == '5' && (second == '1' || second == '2')) return 1;
            return 0;
        }
        return 0;
    }
    else if (!memcmp (pAufenthalt->GRP, "AMG21", 5)) {
        
        char first = pAufenthalt->GRP[6],
             second = pAufenthalt->GRP[7];
        
        switch (first) {
            case '0':
                if (strchr("1234567", second)) return 1;
                return 0;
            case '1':
                if (strchr("345689", second)) {
                    if (second == '3' && pAufenthalt->pScoringContext->modelljahr < 2019) return 0; /* V2019.0 */
                        return 1;
                }return 0;
            case '2':
                if (strchr("02357", second)) {
                    if (second == '7' && pAufenthalt->pScoringContext->modelljahr < 2019) return 0; /* V2019.0 */
                    return 1;
                }
                else if ((second == '8' || second == '9') && pAufenthalt->pScoringContext->modelljahr >= 2020)
                { /* V2020.0 */
                    return 1;
                }
                return 0;
            case '5':
                if (strchr("12345", second)) {
                    if (second > '2' && pAufenthalt->pScoringContext->modelljahr >= 2019) return 0; /* V2019.0 */
                    return 1;
                }
                 return 0;
            default:
                return 0;
        }
    }
    return 0;
}

static int IsAmbPsychTag (LKF_AUFENTHALT *pAufenthalt) {
    // TODO: explizit anführen
    if (!memcmp (pAufenthalt->GRP, "AMG20", 5)) {
        char first = pAufenthalt->GRP[6],
        second = pAufenthalt->GRP[7];
        
        switch (first) {
            case '0':
                if (strchr("5678", second)) return 1;
                return 0;
            case '1':
                if (strchr("12", second)) return 1;
                if (second == '3' && pAufenthalt->pScoringContext->modelljahr >= 2022) return 1; /* V2022.0 */
                return 0;
            default:
                return 0;
        }
       
    }
    return 0;
}

static int IsAmbTKLMEL (LKF_AUFENTHALT *pAufenthalt)
{ /* V2019.0 */
    unsigned int i;
    LKF_AUFENTHALT_MEL *pMel;
    MEL_ARRAY_STRUC *pMelDef;
    for (i = 0; i < pAufenthalt->mel_anz; i++) {
        pMel = pAufenthalt->mel + i;
        pMelDef = FindMel(pAufenthalt->pScoringContext, pMel->MEL);
        if (pMelDef && pMelDef->cTKL == 'J' && memcmp (pMelDef->MEL, "ZZ710", 5)) {
            return 1;
        }
    }
    return 0;
}

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

static int lkf_abtfc_find_index (LKF_CONTEXT *pContext, const char *pKst) {
    if (pContext->abtFCStat) {
        int min, max, cur, cmp;
        min = 0;
        max = pContext->abtfcstatcount;
            
        while (min < max - 1) {
            cur = (min + max) / 2;
            cmp = memcmp (pContext->abtFCStat[cur].abtfc, pKst, 8);
            if (cmp == 0)
                return cur;
            if (cmp < 0) {
                min = cur;
            }
            else {
                max = cur;
            }
        }
        if (memcmp (pContext->abtFCStat[min].abtfc, pKst, 8) >= 0)
            return min;
        return max;
    }
    return 0;
}

static void lkf_stat_add_kst_amb_counter (LKF_CONTEXT *pContext, const char *pKst, int index) {
    LKF_CONTEXT_ABTFC_STAT *pKstStat;
    unsigned int statIndex = lkf_abtfc_find_index(pContext, pKst);
    if (statIndex < pContext->abtfcstatcount && !memcmp (pContext->abtFCStat[statIndex].abtfc, pKst, 8)) {
        pContext->abtFCStat[statIndex].lAmbCounter[index]++;
    }
    else {
        if (pContext->abtfcstatcount == pContext->abtfcstatalloc) {
            LKF_CONTEXT_ABTFC_STAT *pOld;
            pContext->abtfcstatalloc += 10;
            pOld = pContext->abtFCStat;
            pContext->abtFCStat = LKF_MALLOC(pContext, "lkf_stat_add_kst_amb_counter", sizeof (LKF_CONTEXT_ABTFC_STAT) * pContext->abtfcstatalloc);
            if (!pContext->abtFCStat) {
                if (pOld) LKF_FREE(pContext, "lkf_stat_add_kst_amb_counter", pOld);
                return;
            }
            if (pOld) {
                memcpy (pContext->abtFCStat, pOld, sizeof (LKF_CONTEXT_ABTFC_STAT) * pContext->abtfcstatcount);
                LKF_FREE (pContext, "lkf_stat_add_kst_amb_counter", pOld);
            }
        }
        if (statIndex < pContext->abtfcstatcount) {
            memmove (pContext->abtFCStat + statIndex + 1, pContext->abtFCStat + statIndex, sizeof (LKF_CONTEXT_ABTFC_STAT) * (pContext->abtfcstatcount - statIndex));
        }
        memset (pContext->abtFCStat + statIndex, 0, sizeof(LKF_CONTEXT_ABTFC_STAT));
        pKstStat = pContext->abtFCStat + statIndex;
        pKstStat->lAmbCounter[index] = 1;
        memcpy(pKstStat->abtfc, pKst, 8);
        pKstStat->abtfc[8] = 0;
        pContext->abtfcstatcount++;
    }
}

static const char *lkf_stat_get_leistKst (LKF_AUFENTHALT *pAufenthalt) {
    if (pAufenthalt->maxMelIndex >= 0) {
        const char *leistKst = pAufenthalt->mel[pAufenthalt->maxMelIndex].FCLEIST;
        if (IsBlank(leistKst, 8))
            return 0;
        return leistKst;
    }
    return 0;
}

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

/*
static int lkf_stat_isopfc (const char *fc) {
    return *fc == '1' && !memcmp (fc + 4, "95", 2);
}

static int lkf_stat_islabor (LKF_CONTEXT *pContext, const char *fc) {
    
    FUNK_LIST_STRING *pFunc = FunkInArray(pContext->pStamm2001, fc);
    if (pFunc && !memcmp (((const char *)pFunc) + 107, "AFG01", 5))
        return 1;
    
    if (*fc == '1' && (((fc[4] == '4') && strchr ("456", fc[5])) || !memcmp (fc + 4, "50",2)))
        return 1;
    
    return 0;
}

static const char *lkf_stat_get_abtKst (LKF_AUFENTHALT *pAufenthalt)
{
    if (pAufenthalt->abt_anz > 0) {
        unsigned int i;
        const char *leistKst = 0;

        for (i = 0; i < pAufenthalt->abt_anz; i++) {
            const char *fc = pAufenthalt->abt[i].ABTFC;
            if (lkf_stat_islabor(pAufenthalt->pScoringContext, fc)) {
                continue;
            }
            if (lkf_stat_isopfc(fc)) {
                unsigned int j;
                for (j = i + 1; j < pAufenthalt->abt_anz; j++) {
                    const char *fc2 = pAufenthalt->abt[j].ABTFC;
                    if (!lkf_stat_islabor(pAufenthalt->pScoringContext, fc2) && !lkf_stat_isopfc(fc2)) {
                        return fc2;
                    }
                }
                return leistKst;
            }
            if (!leistKst)
                leistKst = fc;
        }
        return leistKst;
    }
    return 0;
}
*/

int lkf_scoring_mbdsstat (LKF_CONTEXT *pContext) {
    LKF_AUFENTHALT **ppAufenthalt, *pAufenthalt;
    unsigned int i, nAufCount;
     
    ppAufenthalt = pContext->ppAufenthalt;
    nAufCount = pContext->patient_anz;

    if (!pContext->scoring_stat_initialized) {
        pContext->scoring_stat_initialized = 1;
        pContext->lAmbCounter[LKF_AMBCOUNT_CHEMO] =
        pContext->lAmbCounter[LKF_AMBCOUNT_PSYCHTAG] =
        pContext->lAmbCounter[LKF_AMBCOUNT_TKL] =
        pContext->lAmbCounter[LKF_AMBCOUNT_ZAE] = 0; /* V22.0 */

    }
    
    for (i = 0; i < nAufCount; i++)
    {
        pAufenthalt = ppAufenthalt[i];
        if (pAufenthalt->isAmb) {
            if (pContext->modelljahr >= 2019) {
                const char *kst;
                if (IsAmbPsychTag(pAufenthalt))
                {
                    pContext->lAmbCounter[LKF_AMBCOUNT_PSYCHTAG]++;
                    kst = lkf_stat_get_leistKst(pAufenthalt);
                    if (kst) lkf_stat_add_kst_amb_counter (pContext, kst, LKF_AMBCOUNT_PSYCHTAG);
                }
                else if (IsAmgChemo(pAufenthalt))
                {
                    pContext->lAmbCounter[LKF_AMBCOUNT_CHEMO]++;
                    kst = lkf_stat_get_leistKst(pAufenthalt);
                    if (kst) lkf_stat_add_kst_amb_counter (pContext, kst, LKF_AMBCOUNT_CHEMO);
                }
                else if (IsAmbTKLMEL(pAufenthalt))
                { /* V2020.1 - vorgezogen + else */
                    pContext->lAmbCounter[LKF_AMBCOUNT_TKL]++;
              
                    /*
                    kst = lkf_stat_get_abtKst (pAufenthalt);
                    if (!kst)
                        kst = lkf_stat_get_leistKst(pAufenthalt);
                    */
                    if (pAufenthalt->abt_anz) {
                        kst = pAufenthalt->abt[0].ABTFC;
                    }
                    else
                    {
                        kst = 0;
                    }
                    
                    if (kst) lkf_stat_add_kst_amb_counter (pContext, kst, LKF_AMBCOUNT_TKL);
                }
                else if (IsAmbZAE(pAufenthalt)) {
                    pContext->lAmbCounter[LKF_AMBCOUNT_ZAE]++;
                    kst = lkf_stat_get_leistKst_mel (pAufenthalt, "ZZ710");
                    if (kst) lkf_stat_add_kst_amb_counter (pContext, kst, LKF_AMBCOUNT_ZAE);
                }
            }
            else {
                if (IsAmbZAE(pAufenthalt))
                    pContext->lAmbCounter[LKF_AMBCOUNT_ZAE]++;
                if (IsAmgChemo(pAufenthalt))
                    pContext->lAmbCounter[LKF_AMBCOUNT_CHEMO]++;
                else if (IsAmbPsychTag(pAufenthalt))
                    pContext->lAmbCounter[LKF_AMBCOUNT_PSYCHTAG]++;
            }
        }
    }
    return 0;
}

int k03_mbdsstat (LKF_CHECK_CONTEXT *pCheckContext, int incremental)
{ /* V21.5: neuer Parameter */
	LKF_AUFENTHALT **ppAufenthalt, *pAufenthalt;
	unsigned int nAufCount;
	char sDatBuf[10];
	unsigned int i, j;
	int lFirstDay, lLastDay, lAufDat, lEntDat, lFirstDayToleranz;
	LKF_KK_CONTEXT *pKKContext;
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbteilung;
	unsigned int abt_anz;
    int modelljahr;
    
    modelljahr = pCheckContext->pContext->modelljahr;

	pKKContext = pCheckContext->pKKContext;

    if (!pKKContext->lStatInitialized) {
        pKKContext->lAufnahmen = 0;
        pKKContext->lBelagsTage = 0;
        pKKContext->lEntlassungen = 0;
        pKKContext->lVerstorbene = 0;
        pKKContext->lVerbleib = 0;
        pKKContext->lHasUnterUeber = -1;
        pKKContext->lStatInitialized = 1;
    }
    if (!incremental)
        pKKContext->lMBDSStatOk = 1;
    
	sprintf (sDatBuf, "%4.4d1231", pCheckContext->pContext->cmb_jahr - 1);
	lFirstDay = (int) lkf_dat2int (sDatBuf);
	lFirstDayToleranz = lFirstDay + 15;
	sprintf (sDatBuf, "%4.4d1231", pCheckContext->pContext->cmb_jahr);
	lLastDay = (int) lkf_dat2int (sDatBuf);

	nAufCount = pCheckContext->pContext->patient_anz;
	ppAufenthalt = pCheckContext->pContext->ppAufenthalt;
	for (i = 0; i < nAufCount; i++)
	{
		pAufenthalt = ppAufenthalt[i];
        if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            lAufDat = (int) lkf_dat2intStrict (pAufenthalt->AUFDAT);
        }
        else {
            lAufDat = (int) lkf_dat2int (pAufenthalt->AUFDAT);
        }
		
        if (pAufenthalt->isAmb) {
            lEntDat = lAufDat; /* V21.2 */
        }
        else if (pAufenthalt->ENTART == 'V') {
            lEntDat = lLastDay + 1;
        }
        else if (modelljahr >= LKF_DATETIME_STRICT_MODEL) {
            lEntDat = (int) lkf_dat2intStrict (pAufenthalt->ENTDAT);
        }
        else {
            lEntDat = (int) lkf_dat2int (pAufenthalt->ENTDAT);
        }
        
		if (!lAufDat || !lEntDat) {
			continue;
		}
		if (lAufDat < lFirstDay) lAufDat = lFirstDay;
		else pKKContext->lAufnahmen++;
        if (lEntDat > lLastDay) {
            if (modelljahr >= 2025) lEntDat = lLastDay;
            else lEntDat = lLastDay + 1;
        }
        else
		{
			if (pAufenthalt->ENTART == 'S') pKKContext->lVerstorbene++;
			else pKKContext->lEntlassungen++;
		}

		if (pAufenthalt->ENTART == 'V') pKKContext->lVerbleib++;
		pKKContext->lBelagsTage += lEntDat - lAufDat;
        abt_anz = pAufenthalt->abt_anz;
        
        if (modelljahr >= 2012 && abt_anz > 1)
        {
            do
            {
                lAufDat = (int) lkf_dat2int (pAufenthalt->abt[abt_anz-1].ABTDAT);
                if (lAufDat > lLastDay) --abt_anz;
                else break;
            } while (abt_anz);
        }
        
        for (j = 0; j < abt_anz; j++)
        {
            pKKAbteilung = lkf_check_kk_abteilung (pKKContext, pAufenthalt->abt[j].ABTFC, 1);
            if (!pKKAbteilung) {
                return LKF_OUTOFMEMORY_ERROR;
            }
            lAufDat = (int) lkf_dat2int (pAufenthalt->abt[j].ABTDAT);
			if (j + 1 == pAufenthalt->abt_anz) {
				lEntDat = (int)lkf_dat2int(pAufenthalt->ENTDAT);
				if (lEntDat == 0 && pAufenthalt->isAmb)
					lEntDat = (int)lkf_dat2int(pAufenthalt->AUFDAT);
			}
            else
                lEntDat = (int) lkf_dat2int (pAufenthalt->abt[j+1].ABTDAT);
            
            if (j + 1 == abt_anz && pAufenthalt->ENTART == 'V')
            {
                pKKAbteilung->nVerbleibPat++;
                if (!lEntDat) lEntDat = lLastDay + 1;
            }

            if (lEntDat > pKKAbteilung->lLatestEntDat) {
                pKKAbteilung->lLatestEntDat = lEntDat;
            }

            pKKAbteilung->nHasM02++;
            
            if (lEntDat && lEntDat > lFirstDay && (lAufDat < lLastDay || (lAufDat==lEntDat && lAufDat==lLastDay)))
                pKKAbteilung->nHasM02Jahr++;
            
            if (lEntDat && lEntDat <= lLastDay && lEntDat >= lFirstDay + 1)
            {
                if (lEntDat > lFirstDayToleranz) pKKAbteilung->nHasM02Toleranz++;
            }

            if (lAufDat && lEntDat)
            {
                if (lAufDat < lFirstDay) {
                    lAufDat = lFirstDay;
                    if (lEntDat < lFirstDay) lEntDat = lFirstDay;
                }
                if (lEntDat > lLastDay) {
                    if (modelljahr >= 2025) lEntDat = lLastDay;
                    else lEntDat = lLastDay + 1;
                }
                pKKAbteilung->nBelagstage += lEntDat - lAufDat;
                
                if (pCheckContext->pContext->modelljahr >= 2010 && !memcmp(pAufenthalt->abt[j].ABTFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
                    pKKContext->lBelagsTage -= (lEntDat - lAufDat); /* V14.0 */
            }
        }
	}
    return 0;
}

static int k03_belagsondgross (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int lBelagSond;
	if (Satzart_GetValueInt (ds, len, pFeld, &lBelagSond)) return 0;
	if (!pCheckContext->pKKContext->lMBDSStatOk) k03_mbdsstat (pCheckContext,0);
	if (pCheckContext->pKKContext->lMBDSStatOk > 1) return 0;
	if (lBelagSond > pCheckContext->pKKContext->lBelagsTage)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", lBelagSond, pCheckContext->pKKContext->lBelagsTage);	
		return 1;
	}
	return 0;
}

static int k03_aufsondgross (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int lAufSond;
	if (Satzart_GetValueInt (ds, len, pFeld, &lAufSond)) return 0;
	if (!pCheckContext->pKKContext->lMBDSStatOk) k03_mbdsstat (pCheckContext,0);
	if (pCheckContext->pKKContext->lMBDSStatOk > 1) return 0;
	if (lAufSond > pCheckContext->pKKContext->lAufnahmen) 
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", lAufSond, pCheckContext->pKKContext->lAufnahmen);	
		return 1;
	}
	return 0;
}

static int k03_entlsondgross (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int lEntlSond;
	if (Satzart_GetValueInt (ds, len, pFeld, &lEntlSond)) return 0;
	if (!pCheckContext->pKKContext->lMBDSStatOk) k03_mbdsstat (pCheckContext,0);
	if (pCheckContext->pKKContext->lMBDSStatOk > 1) return 0;
	if (lEntlSond > pCheckContext->pKKContext->lEntlassungen) 
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", lEntlSond, pCheckContext->pKKContext->lEntlassungen);
		return 1;
	}
	return 0;
}

static int k03_verstsondgross (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int lVerstSond;
	if (Satzart_GetValueInt (ds, len, pFeld, &lVerstSond)) return 0;
	if (!pCheckContext->pKKContext->lMBDSStatOk) k03_mbdsstat (pCheckContext,0);
	if (pCheckContext->pKKContext->lMBDSStatOk > 1) return 0;
	if (lVerstSond > pCheckContext->pKKContext->lVerstorbene) 
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", lVerstSond, pCheckContext->pKKContext->lVerstorbene);
		return 1;
	}
	return 0;
}

static int k03_ambpatungleich (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int lAmbPat, lAmbPatNHKGesamt, lAmbPatNHK;
	unsigned int i;
	const SATZART_FELD *pK09Feld;
	LKF_KK_CONTEXT *pKKContext;
	if (Satzart_GetValueInt (ds, len, pFeld, &lAmbPat)) return 0;

	lAmbPatNHKGesamt = 0;
	pKKContext = pCheckContext->pKKContext;
	pK09Feld = pKKContext->ppKKSatzarten[8]->ppRef[K09_AMBULANTE_PATIENTEN];

    if (pCheckContext->pContext->modelljahr >= 2017) {
        const LKF_EXPANDED_LINE **ppK09 = pKKContext->pppExpandedLines[8];
        for (i = 0; i < pKKContext->pSatzartCount[8]; i++)
        {
            if (Satzart_GetValueIntExp (ppK09[i], pK09Feld, &lAmbPatNHK) == LKF_FIELD_ERROR) return 0;
            lAmbPatNHKGesamt += lAmbPatNHK;
        }
    }
    else {
        for (i = 0; i < pKKContext->pSatzartCount[8]; i++)
        {
            if (Satzart_GetValueInt (pKKContext->pppSatzartRecords[8][i], pKKContext->ppSatzartRecordLen[8][i], pK09Feld, &lAmbPatNHK) == LKF_FIELD_ERROR) return 0;
            lAmbPatNHKGesamt += lAmbPatNHK;
        }
    }

	if (lAmbPat != lAmbPatNHKGesamt)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", lAmbPat, lAmbPatNHKGesamt);
		return 1;
	}

	return 0;
}

static int k03_check_tats_verbleib_sond (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{

	int verbleib_sond, betten_sond;

	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_VORJAHR_SOND], &verbleib_sond)) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_TATS_BETTEN_SOND], &betten_sond)) return 0;

	if (betten_sond < verbleib_sond) 
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", betten_sond, verbleib_sond);
		return 1;
	}
	return 0;
}

static int k03_check_sklbettensys (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int lSystSond, lSystSum;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_SYST_BETTEN_SUM], &lSystSum)) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_SYST_BETTEN_SOND], &lSystSond)) return 0;

	if (lSystSond * 4 > lSystSum)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", lSystSond, lSystSum);
		return 1;
	}

	return 0;
}

static int k03_check_tats_verbleib (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int lTatsBetten;

	if (Satzart_GetValueInt (ds, len, pFeld, &lTatsBetten)) return 0;
	if (!pCheckContext->pKKContext->lMBDSStatOk) k03_mbdsstat (pCheckContext,0);

	if (lTatsBetten < pCheckContext->pKKContext->lVerbleib)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", lTatsBetten, pCheckContext->pKKContext->lVerbleib);
		return 1;
	}
	return 0;
}

static int k03_check_sklbettentats (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int lTatsSond, lTatsSum;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_TATS_BETTEN_INSG], &lTatsSum)) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_TATS_BETTEN_SOND], &lTatsSond)) return 0;

	if (lTatsSond * 4 > lTatsSum)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", lTatsSond, lTatsSum);
		return 1;
	}

	return 0;
}

static int k03_check_begleitbelagstage (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int lAufnahmenBegleitPers, lBelagstageBegleitPers;

	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_AUFNAHME_BEGLEIT], &lAufnahmenBegleitPers)) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[2]->ppRef[K03_BELAGSTAGE_BEGLEIT], &lBelagstageBegleitPers)) return 0;
	
	if (lAufnahmenBegleitPers > lBelagstageBegleitPers)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", lAufnahmenBegleitPers, lBelagstageBegleitPers);
		return 1;
	}
	return 0; 
}

static int check_angaben_sonderklasse (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V9.1 */
	int lNum; /* V12.1 - int statt unsigned int */

	if (Satzart_GetValueInt (ds, len, pFeld, &lNum) != LKF_FIELD_ERROR && lNum == 0)
	{
		const SATZART_INFO *pSatzart = pCheckContext->pKKContext->ppKKSatzarten[2];
		if (Satzart_GetValueInt (ds, len, pSatzart->ppRef[K03_BELAGSTAGE_SOND],  &lNum) != LKF_FIELD_ERROR && lNum != 0) return 1;
		if (Satzart_GetValueInt (ds, len, pSatzart->ppRef[K03_AUFNAHMEN_SOND],   &lNum) != LKF_FIELD_ERROR && lNum != 0) return 1;
		if (Satzart_GetValueInt (ds, len, pSatzart->ppRef[K03_TATS_BETTEN_SOND], &lNum) != LKF_FIELD_ERROR && lNum != 0) return 1;
	}
	return 0;
}

static int k03_check_auslastung (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V2026.0 */
    int lNum;
    int dayCount;
    double auslastung;
    LKF_KK_CONTEXT *pKKContext;
    const SATZART_INFO *pSatzart;
    pKKContext = pCheckContext->pKKContext;
    pSatzart = pCheckContext->pKKContext->ppKKSatzarten[2];
    dayCount = (pCheckContext->pContext->cmb_jahr % 4) ? 365 : 366;
    if (Satzart_GetValueInt (ds, len, pSatzart->ppRef[K03_TATS_BETTEN_INSG], &lNum) == LKF_FIELD_ERROR) return 0;
    if (lNum == 0) {
        return 0;
    }
    
    auslastung = pKKContext->lBelagsTage;
    auslastung /= lNum * dayCount;
    
    if (auslastung > 1.0) {
        sprintf (pCheckContext->sErrorAdditionalInfo, "%.2f%%", auslastung * 100);
        return 1;
    }
    
    return 0;
}


const LKF_SATZART_ERRORCHECK
	LKFKKCheckK03unvollstBelag =			{LKF_CHECKFUNC_FUNCTION, check_angaben_sonderklasse, &LKFKKErrorAngabenSonderklasse, 0, 0},
	LKFKKCheckK03unvollstAufnahmen =		{LKF_CHECKFUNC_FUNCTION, check_angaben_sonderklasse, &LKFKKErrorAngabenSonderklasse, 0, 0},
/*	LKFKKCheckK03unvollstSystBetten =		{LKF_CHECKFUNC_FUNCTION, check_angaben_sonderklasse, &LKFKKErrorAngabenSonderklasse, 0, 0}, V9.4 */
	LKFKKCheckBelagSondGross =				{LKF_CHECKFUNC_FUNCTION, k03_belagsondgross, &LKFKKErrorBelagSondGross, &LKFKKCheckK03unvollstBelag, &LKFKKCheckK03unvollstBelag},
	LKFKKCheckAufnahmenSondGross =			{LKF_CHECKFUNC_FUNCTION, k03_aufsondgross, &LKFKKErrorAufnahmenSondGross, &LKFKKCheckK03unvollstAufnahmen, &LKFKKCheckK03unvollstAufnahmen},
	LKFKKCheckEntlassungenSondGross =		{LKF_CHECKFUNC_FUNCTION, k03_entlsondgross, &LKFKKErrorEntlassungenSondGross, 0, 0},
	LKFKKCheckVerstorbeneSondGross =		{LKF_CHECKFUNC_FUNCTION, k03_verstsondgross, &LKFKKErrorVerstorbeneSondGross, 0, 0},
	LKFKKCheckAmbPatungleich =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k03_ambpatungleich, &LKFKKErrorAmbPatungleich, 0, 0},
	LKFKKCheckSystBettenInsgK08 =			{LKF_CHECKFUNC_FUNCTION, kaskore_systbetten_k08, &LKFKKErrorSystBettenInsgK08, 0, 0},
	LKFKKCheckSystBettenInsgSonderkl =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, kaskore_systbetten_sond, &LKFKKErrorSystBettenInsgSonderkl, 0, &LKFKKCheckSystBettenInsgK08},
	LKFKKCheckSystBettenInsgfalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorSystBettenInsgfalsch, 0, &LKFKKCheckSystBettenInsgSonderkl},
	LKFKKCheckSystBettenInsgfehlt =			{LKF_CHECKFUNC_EXISTS_NOT0, 0, &LKFKKErrorSystBettenInsgfehlt, 0, &LKFKKCheckSystBettenInsgfalsch},
	LKFKKCheckTatsBettenSondVerbleib  =		{LKF_CHECKFUNC_FUNCTION, k03_check_tats_verbleib_sond, &LKFKKErrorTatsBettenSondVerbleib , 0, 0, /*&LKFKKCheckK03unvollstSystBetten, &LKFKKCheckK03unvollstSystBetten*/},
	LKFKKCheck25PSKLBettenSyst  =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k03_check_sklbettensys, &LKFKKError25PSKLBettenSyst , 0, 0/* V9.4 &LKFKKCheckTatsBettenSondVerbleib, &LKFKKCheckTatsBettenSondVerbleib */},
	LKFKKCheckSystBettenSondfalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorSystBettenSondfalsch, 0, &LKFKKCheck25PSKLBettenSyst},	
/*	LKFKKCheckSystBettenSondfehlt =			{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorSystBettenSondFehlt, 0, &LKFKKCheckSystBettenSondfalsch}, V9.4 */
	LKFKKCheckTatsBettenVerbleib  =			{LKF_CHECKFUNC_FUNCTION, k03_check_tats_verbleib, &LKFKKErrorTatsBettenVerbleib , 0, 0},
	LKFKKCheckTatsBettenInsgK08 =			{LKF_CHECKFUNC_FUNCTION, kaskore_tatsbetten_k08, &LKFKKErrorTatsBettenInsgK08, &LKFKKCheckTatsBettenVerbleib, &LKFKKCheckTatsBettenVerbleib},
	LKFKKCheck25PSKLBettenTats  =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k03_check_sklbettentats, &LKFKKError25PSKLBettenTats , &LKFKKCheckTatsBettenInsgK08, &LKFKKCheckTatsBettenInsgK08},
	LKFKKCheckTatsBettenInsgSonderkl =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, kaskore_tatsbetten_sond, &LKFKKErrorTatsBettenInsgSonderkl, &LKFKKCheck25PSKLBettenTats, &LKFKKCheck25PSKLBettenTats},
	LKFKKCheckTatsBettenInsgfalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorTatsBettenInsgfalsch, 0, &LKFKKCheckTatsBettenInsgSonderkl},
    LKFKKCheckTatsBettenInsgfehlt =			{LKF_CHECKFUNC_EXISTS_NOT0, 0, &LKFKKErrorTatsBettenInsgfehlt,0, &LKFKKCheckTatsBettenInsgfalsch},
	LKFKKCheckK03unvollstTatsBetten =		{LKF_CHECKFUNC_FUNCTION, check_angaben_sonderklasse, &LKFKKErrorAngabenSonderklasse, &LKFKKCheckTatsBettenSondVerbleib, &LKFKKCheckTatsBettenSondVerbleib /* V9.4 0, 0 */},
	LKFKKCheckTatsBettenSondfalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorTatsBettenSondfalsch, 0, &LKFKKCheckK03unvollstTatsBetten},
	LKFKKCheckSondBelagstagefalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorSondBelagstagefalsch, 0, &LKFKKCheckBelagSondGross},
	LKFKKCheckSondAufnahmenfalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorSondAufnahmenfalsch, 0, &LKFKKCheckAufnahmenSondGross},
	LKFKKCheckSondVorjahrfalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorSondVorjahrfalsch, 0, 0},
	LKFKKCheckSondEntlassungenfalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorSondEntlassungenfalsch, 0, &LKFKKCheckEntlassungenSondGross},
	LKFKKCheckSondVerstorbenefalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorSondVerstorbenefalsch, 0, &LKFKKCheckVerstorbeneSondGross},
	LKFKKCheckBegleitpersBelagstage =		{LKF_CHECKFUNC_FUNCTION, k03_check_begleitbelagstage, &LKFKKErrorBegleitpersBelagstage, 0, 0},
	LKFKKCheckBegleitAufnahmenfalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorBegleitAufnahmenfalsch, &LKFKKCheckBegleitpersBelagstage, &LKFKKCheckBegleitpersBelagstage},
	LKFKKCheckBegleitBelagstagefalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorBegleitBelagstagefalsch, 0, 0},
	LKFKKCheckAmbPatfalsch =				{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorAmbPatfalsch, 0, &LKFKKCheckAmbPatungleich},
	LKFKKCheckOPTischefalsch =				{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorOPTischefalsch, 0, 0},
	LKFKKCheckEntbindPlaetzefalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorEntbindPlaetzefalsch, 0, 0},
	LKFKKCheckPostOPUebPlaetzefalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorPostOPUebPlaetzefalsch, 0, 0},
	LKFKKCheckDialysePlaetzefalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorDialysePlaetzefalsch, 0, 0},
	LKFKKCheckObdukAnstfalsch =				{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorObdukAnstfalsch, 0, 0},
	LKFKKCheckObdukFremdfalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorObdukFremdfalsch, 0, 0},
	LKFKKCheckEntbindLebendfalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorEntbindLebendfalsch, 0, 0},
	LKFKKCheckEntbindTotfalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorEntbindTotfalsch, 0, 0},
	LKFKKCheckBelagSonderklasseFehlt  =		{LKF_CHECKFUNC_EXISTS,   0, &LKFKKErrorBelagSonderklasseFehlt , 0, &LKFKKCheckSondBelagstagefalsch},
    LKFKKCheckAmbBettenInsgK09 =            {LKF_CHECKFUNC_FUNCTION, check_ambbetten, &LKFKKErrorAmbBettenInsgK09, 0, 0},
    LKFKKCheckAmbBetreuung =                {LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorK03AmbBetreuungFalsch, 0, &LKFKKCheckAmbBettenInsgK09}, /* V21.0 */
    LKFKKCheckK03Auslastung2025 =           {LKF_CHECKFUNC_FUNCTION, k03_check_auslastung, &LKFKKErrorAuslastungK03, 0, 0}, /* V2026.0 */
    LKFKKCheckK03Auslastung =               {LKF_CHECKFUNC_NONE, 0, 0, 0, 0, 2025, &LKFKKCheckK03Auslastung2025};                    /* V2026.0 */


#ifdef SUPPORT_PRE2027
const SATZART K03Satzart = {"K03", 0, 22, 22,(const int *) &k01_ident, "KA-Statistik (Ressourcen und Inanspruchnahme)", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K03_SYST_BETTEN_SUM,		TYP_NUM,	14,  6, &LKFKKCheckSystBettenInsgfehlt, 0, "SYST. BETTEN INSG."},
	{K03_SYST_BETTEN_SOND,		TYP_NUM,	20,  6, &LKFKKCheckSystBettenSondfalsch, 0, "SYST. BETTEN SONDERKLASSE"},
	{K03_TATS_BETTEN_INSG,		TYP_NUM,	26,  6, &LKFKKCheckTatsBettenInsgfehlt, 0, "TATS. BETTEN INSG."},
	{K03_TATS_BETTEN_SOND,		TYP_NUM,	32,  6, &LKFKKCheckTatsBettenSondfalsch, 0, "TATS. BETTEN SONDERKLASSE"},
	{K03_BELAGSTAGE_SOND,		TYP_NUM,	38,  6, &LKFKKCheckBelagSonderklasseFehlt, 0, "BELAGSTAGE SONDERKLASSE"},
	{K03_AUFNAHMEN_SOND,		TYP_NUM,	44,  6, &LKFKKCheckSondAufnahmenfalsch, 0, "AUFNAHMEN SONDERKLASSE"},
	{K03_VORJAHR_SOND,			TYP_NUM,	50,  6, &LKFKKCheckSondVorjahrfalsch, 0, "VORJAHR SONDERKLASSE"},
	{K03_ENTLASSUNGEN_SOND,		TYP_NUM,	56,  6, &LKFKKCheckSondEntlassungenfalsch, 0, "ENTLASSUNGEN SONDERKLASSE"},
	{K03_VERSTORBENE_SOND,		TYP_NUM,	62,  6, &LKFKKCheckSondVerstorbenefalsch, 0, "VERSTORBENE SONDERKLASSE"},
	{K03_AUFNAHME_BEGLEIT,		TYP_NUM,	68,  6, &LKFKKCheckBegleitAufnahmenfalsch, 0, "AUFNAHME BEGLEITPERSONEN"},
	{K03_BELAGSTAGE_BEGLEIT,	TYP_NUM,	74,  6, &LKFKKCheckBegleitBelagstagefalsch, 0, "BELAGSTAGE BEGLEITPERSONEN"},
	{K03_AMBULANTE_PAT,			TYP_NUM,	80,  6, &LKFKKCheckAmbPatfalsch, 0, "AMBULANTE PATIENTEN"},
	{K03_OP_TISCHE,				TYP_NUM,	86,	 6, &LKFKKCheckOPTischefalsch, 0, "OP-TISCHE"},
	{K03_ENTBINDUNGSPLAETZE,	TYP_NUM,	92,  6, &LKFKKCheckEntbindPlaetzefalsch, 0, "ENTBINDUNGSPLAETZE"},
	{K03_POSTOP_UEB_PLAETZE,	TYP_NUM,	98,  6, &LKFKKCheckPostOPUebPlaetzefalsch, 0, "POSTOP. UEBERWACHUNGSPLAETZE"},
	{K03_DIALYSEPLAETZE,		TYP_NUM,   104,  6, &LKFKKCheckDialysePlaetzefalsch, 0, "DIALYSEPLAETZE"},
	{K03_OBDUK_ANSTPERS,		TYP_NUM,   110,  6, &LKFKKCheckObdukAnstfalsch, 0, "OBDUKTIONEN ANSTALTSPERS."},
	{K03_OBDUK_FREMDPERS,		TYP_NUM,   116,  6, &LKFKKCheckObdukFremdfalsch, 0, "OBDUKTIONEN FREMDPERS."},
	{K03_ENTBIND_LEBEND,		TYP_NUM,   122,  6, &LKFKKCheckEntbindLebendfalsch, 0, "ENTBINDUNGEN LEBENDGEB."},
	{K03_ENTBIND_TOT,			TYP_NUM,   128,  6, &LKFKKCheckEntbindTotfalsch, 0, "ENTBINDUNGEN TOTGEB."}
}};
#endif

const SATZART K03Satzart2017 = {"K03", 0, 23, 23, (const int *) &k01_ident, "KA-Statistik (Ressourcen und Inanspruchnahme)", &LKFKKCheckK03Auslastung, {
    {GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
    {GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
    {K03_SYST_BETTEN_SUM,		TYP_NUM,	14,  6, &LKFKKCheckSystBettenInsgfehlt, 0, "SYST. BETTEN INSG."},
    {K03_SYST_BETTEN_SOND,		TYP_NUM,	20,  6, &LKFKKCheckSystBettenSondfalsch, 0, "SYST. BETTEN SONDERKLASSE"},
    {K03_TATS_BETTEN_INSG,		TYP_NUM,	26,  6, &LKFKKCheckTatsBettenInsgfehlt, 0, "TATS. BETTEN INSG."},
    {K03_TATS_BETTEN_SOND,		TYP_NUM,	32,  6, &LKFKKCheckTatsBettenSondfalsch, 0, "TATS. BETTEN SONDERKLASSE"},
    {K03_BELAGSTAGE_SOND,		TYP_NUM,	38,  6, &LKFKKCheckBelagSonderklasseFehlt, 0, "BELAGSTAGE SONDERKLASSE"},
    {K03_AUFNAHMEN_SOND,		TYP_NUM,	44,  6, &LKFKKCheckSondAufnahmenfalsch, 0, "AUFNAHMEN SONDERKLASSE"},
    {K03_VORJAHR_SOND,			TYP_NUM,	50,  6, &LKFKKCheckSondVorjahrfalsch, 0, "VORJAHR SONDERKLASSE"},
    {K03_ENTLASSUNGEN_SOND,		TYP_NUM,	56,  6, &LKFKKCheckSondEntlassungenfalsch, 0, "ENTLASSUNGEN SONDERKLASSE"},
    {K03_VERSTORBENE_SOND,		TYP_NUM,	62,  6, &LKFKKCheckSondVerstorbenefalsch, 0, "VERSTORBENE SONDERKLASSE"},
    {K03_AUFNAHME_BEGLEIT,		TYP_NUM,	68,  6, &LKFKKCheckBegleitAufnahmenfalsch, 0, "AUFNAHME BEGLEITPERSONEN"},
    {K03_BELAGSTAGE_BEGLEIT,	TYP_NUM,	74,  6, &LKFKKCheckBegleitBelagstagefalsch, 0, "BELAGSTAGE BEGLEITPERSONEN"},
    {K03_AMBULANTE_PAT,			TYP_NUM,	80,  6, &LKFKKCheckAmbPatfalsch, 0, "AMBULANTE PATIENTEN"},
    {K03_AMBPLAETZE,            TYP_NUM,    86,  6, &LKFKKCheckAmbBetreuung, 0, "AMBULANTE BETREUUNGSPLAETZE"},
    {K03_OP_TISCHE,				TYP_NUM,	92,	 6, &LKFKKCheckOPTischefalsch, 0, "OP-TISCHE"},
    {K03_ENTBINDUNGSPLAETZE,	TYP_NUM,	98,  6, &LKFKKCheckEntbindPlaetzefalsch, 0, "ENTBINDUNGSPLAETZE"},
    {K03_POSTOP_UEB_PLAETZE,	TYP_NUM,   104,  6, &LKFKKCheckPostOPUebPlaetzefalsch, 0, "POSTOP. UEBERWACHUNGSPLAETZE"},
    {K03_DIALYSEPLAETZE,		TYP_NUM,   110,  6, &LKFKKCheckDialysePlaetzefalsch, 0, "DIALYSEPLAETZE"},
    {K03_OBDUK_ANSTPERS,		TYP_NUM,   116,  6, &LKFKKCheckObdukAnstfalsch, 0, "OBDUKTIONEN ANSTALTSPERS."},
    {K03_OBDUK_FREMDPERS,		TYP_NUM,   122,  6, &LKFKKCheckObdukFremdfalsch, 0, "OBDUKTIONEN FREMDPERS."},
    {K03_ENTBIND_LEBEND,		TYP_NUM,   128,  6, &LKFKKCheckEntbindLebendfalsch, 0, "ENTBINDUNGEN LEBENDGEB."},
    {K03_ENTBIND_TOT,			TYP_NUM,   134,  6, &LKFKKCheckEntbindTotfalsch, 0, "ENTBINDUNGEN TOTGEB."}
}};


/*********************************************************************************************
** Satzart K04                                                                              **
*********************************************************************************************/

const LKF_SATZART_ERRORCHECK_STRINGLIST 
stringlist_PersGruppen = {36, {"111", "112", "113", "114", "115", "116", "117", "118", "119",
							   "121", "122", "123", "124", "125", "126", "127", "128", "129",
							   "131", "132", "133", "134", "135", "136", "137", "138", "139",
							   "Z01", "Z02", "Z03", "Z04", "Z05", "Z06", "Z07", "Z08", "Z09"}};

static int k04_perskalkanggross (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	double fKalkPers;
	char sPersGruppenIndex[4];
	const SATZART_FELD *pFeldPersGruppenIndex;
	if (Satzart_GetValueFloat (ds, len, pFeld, &fKalkPers, pCheckContext->pContext->modelljahr)) return 0;
	pFeldPersGruppenIndex = pCheckContext->pKKContext->ppKKSatzarten[3]->ppRef[K04_PERSONALGRUPPENINDEX];
	Satzart_GetValueString (ds, len, pFeldPersGruppenIndex, sPersGruppenIndex, 4);

	if (sPersGruppenIndex[0] == 'Z')
	{
		char cGrp;
		const char *sCurDs;
		unsigned int lCurLen;
		double fVollzeitSum, fVollzeit;
		unsigned int i;

		cGrp = sPersGruppenIndex[2]; 
		fVollzeitSum = 0;
        
        if (pCheckContext->pContext->modelljahr >= 2017) {
            const LKF_EXPANDED_LINE **ppK = pCheckContext->pKKContext->pppExpandedLines[3];
            for (i = 0; i < pCheckContext->pKKContext->pSatzartCount[3]; i++)
            {
                Satzart_GetValueStringExp (ppK[i], pFeldPersGruppenIndex, sPersGruppenIndex, 4);
                if (Satzart_GetValueFloatExp (ppK[i], pFeld, &fVollzeit, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 0;
                
                if (sPersGruppenIndex[0] != 'Z' && sPersGruppenIndex[2] == cGrp) fVollzeitSum += fVollzeit;
            }
        }
        else {
            for (i = 0; i < pCheckContext->pKKContext->pSatzartCount[3]; i++)
            {
                sCurDs = pCheckContext->pKKContext->pppSatzartRecords[3][i];
                lCurLen = pCheckContext->pKKContext->ppSatzartRecordLen[3][i];
                
                Satzart_GetValueString (sCurDs, lCurLen, pFeldPersGruppenIndex, sPersGruppenIndex, 4);
                if (Satzart_GetValueFloat (sCurDs, lCurLen, pFeld, &fVollzeit, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 0;
                
                if (sPersGruppenIndex[0] != 'Z' && sPersGruppenIndex[2] == cGrp) fVollzeitSum += fVollzeit;
            }
        }
        
	
		if (fVollzeitSum < fKalkPers)
		{
			sprintf (pCheckContext->sErrorAdditionalInfo, "%8.2f/%8.2f", fKalkPers, fVollzeitSum);
			return 1;
		}
	}
	return 0;
}

static int k04_perskeinekosten (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sPersGruppenIndex[4];
	int lPersGruppenIndex, lKosten, lMlv;
	unsigned int i;
	double fPersonal;
	const SATZART_FELD *pFeldPersGruppenIndex, *pFeld12Kosten, *pFeld12Mlv;
	const char *sK12;
	unsigned int lK12Len, lK12Count;
    
	if (Satzart_GetValueFloat (ds, len, pFeld, &fPersonal, pCheckContext->pContext->modelljahr) || fPersonal <= 0.1) return 0;
	pFeldPersGruppenIndex = pCheckContext->pKKContext->ppKKSatzarten[3]->ppRef[K04_PERSONALGRUPPENINDEX];
	Satzart_GetValueString (ds, len, pFeldPersGruppenIndex, sPersGruppenIndex, 4);
	lPersGruppenIndex = atoi (sPersGruppenIndex);
	if (lPersGruppenIndex < 111 || lPersGruppenIndex >139) return 0;

	pFeld12Kosten = pCheckContext->pKKContext->ppKKSatzarten[11]->ppRef[K12_KOSTEN];
	pFeld12Mlv = pCheckContext->pKKContext->ppKKSatzarten[11]->ppRef[K12_MLVNUMMER];
	
	lK12Count = pCheckContext->pKKContext->pSatzartCount[11];
    
    if (pCheckContext->pContext->modelljahr >= 2017) {
        
        const LKF_EXPANDED_LINE **ppK = pCheckContext->pKKContext->pppExpandedLines[11];
        
        for (i = 0; i < lK12Count; i++)
        {
            if (!Satzart_GetValueIntExp (ppK[i], pFeld12Mlv, &lMlv)) {
                if (lMlv == lPersGruppenIndex && (Satzart_GetValueIntExp (ppK[i], pFeld12Kosten, &lKosten) || lKosten)) return 0;
            }
        }
    
    }
    else {
        for (i = 0; i < lK12Count; i++)
        {
            sK12 = pCheckContext->pKKContext->pppSatzartRecords[11][i];
            lK12Len = pCheckContext->pKKContext->ppSatzartRecordLen[11][i];
            if (!Satzart_GetValueInt (sK12, lK12Len, pFeld12Mlv, &lMlv)) {
                if (lMlv == lPersGruppenIndex && (Satzart_GetValueInt (sK12, lK12Len, pFeld12Kosten, &lKosten) || lKosten)) return 0;
            }
        }
    }
    
	sprintf (pCheckContext->sErrorAdditionalInfo, "%3d: %9.2f", lPersGruppenIndex, fPersonal);
	return 1;
}

const LKF_SATZART_ERRORCHECK	
	LKFKKCheckPersKeineKosten =             {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k04_perskeinekosten, &LKFKKErrorPersKeineKosten, 0, 0},
	LKFKKCheckPersKalkAngGross2005 =		{LKF_CHECKFUNC_FUNCTION, k04_perskalkanggross, &LKFKKErrorPersKalkAngGross, 0, &LKFKKCheckPersKeineKosten},
	LKFKKCheckPersGruppenIndexfalsch =		{LKF_CHECKFUNC_STRINGLIST, &stringlist_PersGruppen, &LKFKKErrorPersGruppenIndexfalsch, 0, 0},
	LKFKKCheckPersGruppenIndexfehlt =		{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorPersGruppenIndexfehlt, 0, &LKFKKCheckPersGruppenIndexfalsch},
	LKFKKCheckVollzeitAqufalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorVollzeitAqufalsch, 0, &LKFKKCheckPersKalkAngGross2005},
	LKFKKCheckVollzeitAqufehlt =			{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorVollzeitAqufehlt, 0, &LKFKKCheckVollzeitAqufalsch};

const int k04_ident[] = {0,1,2,-1};

const SATZART K04Satzart = {"K04", 0, 4, 4, (const int *) &k04_ident, "KA-Statistik (Personal-Vollzeitaequivalente nach Funktionsgruppen und Dienstverhaeltnis", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K04_PERSONALGRUPPENINDEX,	TYP_ALPHA,  14,  3, &LKFKKCheckPersGruppenIndexfehlt, 0, "PERSONALGRUPPENINDEX"},
	{K04_VOLLZEITAEQUIVALENTE,	TYP_FLOAT,    17,  9, &LKFKKCheckVollzeitAqufehlt, 0, "VOLLZEITAEQUIVALENTE"}
}};

/*********************************************************************************************
** Satzart K05                                                                              **
*******************************************************************<**************************/

const LKF_SATZART_ERRORCHECK_STRINGLIST 
	stringlist_FachHaupt = {31, {"11", "12", "21", "22", "23", "24", "25", "26", "27", "31",
								 "32", "33", "41", "42", "43", "45", "48", "51", "61", "62",
								 "63", "64", "71", "72", "75", "78", "81", "82", "83", "91",
								 "99"}},
	stringlist_FachHaupt2010 = {30, {"11", "12", "21", "22", "23", "24", "25", "26", "27", "31",
								 "32", "33", "41", "42", "43", "45", "48", "51", "62",
								 "63", "64", "71", "72", "75", "78", "81", "82", "83", "91",
								 "99"}}, /* V14.0 */
	stringlist_FachHaupt2012 = {33, {"11", "12", "21", "22", "23", "24", "25", "26", "27", "28", "29", "31",
								 "32", "33", "41", "42", "43", "45", "48", "51", "62",
								 "63", "64", "71", "72", "73", "75", "78", "81", "82", "83", "91",
								 "99"}}, /* V17.0 */
    stringlist_FachHaupt2015 = {34, {"00", "11", "12", "21", "22", "23", "24", "25", "26", "27", "28", "29", "31",
                                 "32", "33", "41", "42", "43", "45", "48", "51", "62",
                                 "63", "64", "71", "72", "73", "75", "78", "81", "82", "83", "91",
                                 "99"}}, /* V20.0 */

    stringlist_FachHaupt2017 = {38, {"00", "11", "12", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31",
    "32", "33", "41", "42", "43", "45", "48", "51", "62",
    "63", "64", "71", "72", "73", "75", "78", "81", "82", "83", "84", "85", "90", "91",
    "99"}}; /* V21.0 */

static int k05_fachhaupt_kopfzahl (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{   /* V20.0 */
    
    static int indices[] = {K05_FACHAERZTE_KOPF, K05_AERZTE_ALLGMED_KOPF, K05_FACHAERZTE_AUSB_KOPF, 0};
    const SATZART_INFO *pSatzartInfo;
    char sFachHauptBereich[4];
    int kopfzahl, i;
    
    Satzart_GetValueString(ds, len, pFeld, sFachHauptBereich, 3);
    if (memcmp (sFachHauptBereich, "00", 2)) return 0;
    pSatzartInfo = pCheckContext->pKKContext->ppKKSatzarten[4];

    for (i = 0; indices[i]; i++) {
        if (Satzart_GetValueInt(ds, len, pSatzartInfo->ppRef[indices[i]], &kopfzahl) != LKF_FIELD_ERROR) {
            if (kopfzahl) return 1;
        }
    }
    
    return 0;
}

static int k05_fachhaupt_vollzeit (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{  /* V20.0 */
    
    static int indices[] = {K05_FACHAERZTE_VZEQ, K05_AERZTE_ALLG_VZEQ, K05_FACHAERZTE_AUSB_VZEQ, 0};

    const SATZART_INFO *pSatzartInfo;
    char sFachHauptBereich[4];
    double vollzeitAequivalente;
    int i;
    
    Satzart_GetValueString(ds, len, pFeld, sFachHauptBereich, 3);
    if (memcmp (sFachHauptBereich, "00", 2)) return 0;
    pSatzartInfo = pCheckContext->pKKContext->ppKKSatzarten[4];

    for (i = 0; indices[i]; i++) {
        if (Satzart_GetValueFloat (ds, len, pSatzartInfo->ppRef[indices[i]], &vollzeitAequivalente, pCheckContext->pContext->modelljahr) != LKF_FIELD_ERROR) {
            if (vollzeitAequivalente != 0) return 1;
        }
    }
    
    return 0;
}

const LKF_SATZART_ERRORCHECK
	LKFKKCheckFacharztAquFalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorFacharztAquFalsch, 0, 0},
	LKFKKCheckAllgArztAquFalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorAllgArztAquFalsch, 0, 0},
	LKFKKCheckFachArztAusbAquFalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorFachArztAusbAquFalsch, 0, 0},
	LKFKKCheckAllgArztAusbAquFalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorAllgArztAusbAquFalsch, 0, 0},
    LKFKKCheck00Kopfzahl =                  {LKF_CHECKFUNC_FUNCTION, k05_fachhaupt_kopfzahl, &LKFKKErrorBasisAusbKopfzahl, 0, 0},
    LKFKKCheck00Vollzeit =                  {LKF_CHECKFUNC_FUNCTION, k05_fachhaupt_vollzeit, &LKFKKErrorBasisAusbVollzeit, &LKFKKCheck00Kopfzahl, &LKFKKCheck00Kopfzahl},
    LKFKKCheckFachhauptfalsch2017 =			{LKF_CHECKFUNC_STRINGLIST, &stringlist_FachHaupt2017, &LKFKKErrorFachhauptfalsch, &LKFKKCheck00Vollzeit, &LKFKKCheck00Vollzeit},
    LKFKKCheckFachhauptfalsch2015 =			{LKF_CHECKFUNC_STRINGLIST, &stringlist_FachHaupt2015, &LKFKKErrorFachhauptfalsch, &LKFKKCheck00Vollzeit, &LKFKKCheck00Vollzeit, 2017, &LKFKKCheckFachhauptfalsch2017},
	LKFKKCheckFachhauptfalsch2012 =			{LKF_CHECKFUNC_STRINGLIST, &stringlist_FachHaupt2012, &LKFKKErrorFachhauptfalsch, 0, 0, 2015, &LKFKKCheckFachhauptfalsch2015},
	LKFKKCheckFachhauptfalsch2010 =			{LKF_CHECKFUNC_STRINGLIST, &stringlist_FachHaupt2010, &LKFKKErrorFachhauptfalsch, 0, 0, 2012, &LKFKKCheckFachhauptfalsch2012},
	LKFKKCheckFachhauptfalsch =				{LKF_CHECKFUNC_STRINGLIST, &stringlist_FachHaupt, &LKFKKErrorFachhauptfalsch, 0, 0, 2010, &LKFKKCheckFachhauptfalsch2010},
	LKFKKCheckFachhauptfehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorFachhauptfehlt, 0, &LKFKKCheckFachhauptfalsch},
	LKFKKCheckFacharztKopffalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorFacharztKopffalsch, 0, 0},
	LKFKKCheckAllgarztKopffalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorAllgarztKopffalsch, 0, 0},
	LKFKKCheckFacharztAusbKopffalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorFacharztAusbKopffalsch, 0, 0},
	LKFKKCheckAllgarztAusbKopffalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorAllgarztAusbKopffalsch, 0, 0};

const SATZART K05Satzart = {"K05", 0, 11, 11, (const int *) &k04_ident, "KA-Statistik (Personal des arztlichen Diensts)", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K05_FACHHAUPTBEREICHSIND,	TYP_ALPHA,	14,  2, &LKFKKCheckFachhauptfehlt, 0, "FACHHAUPTBEREICHSINDEX"},
	{K05_FACHAERZTE_KOPF,		TYP_NUM,	16,  6, &LKFKKCheckFacharztKopffalsch, 0, "FACHAERZTE, KOPFZAHL"},
	{K05_AERZTE_ALLGMED_KOPF,	TYP_NUM,	22,  6, &LKFKKCheckAllgarztKopffalsch, 0, "AERZTE ALLGEMEINMEDIZIN"},
	{K05_FACHAERZTE_AUSB_KOPF,	TYP_NUM,	28,  6, &LKFKKCheckFacharztAusbKopffalsch, 0, "FACHAERZTE IN AUSB."},
	{K05_AERZTE_ALLG_AUSB_KOPF,	TYP_NUM,	34,  6, &LKFKKCheckAllgarztAusbKopffalsch, 0, "AERZTE ALLG.MED. IN AUSB."},
	{K05_FACHAERZTE_VZEQ,		TYP_FLOAT,	40,  9, &LKFKKCheckFacharztAquFalsch, 0, "FACHAERZTE VOLLAEQU."},
	{K05_AERZTE_ALLG_VZEQ,		TYP_FLOAT,	49,	 9, &LKFKKCheckAllgArztAquFalsch, 0, "AERZTE ALLG.MED VOLLAEQU."},
	{K05_FACHAERZTE_AUSB_VZEQ,  TYP_FLOAT,	58,  9, &LKFKKCheckFachArztAusbAquFalsch, 0, "FACHAERZTE IN AUSB. VOLLAEQU."},
	{K05_AERZTE_ALLG_AUSB_VZEQ, TYP_FLOAT,	67,  9, &LKFKKCheckAllgArztAusbAquFalsch, 0, "AERZTE ALLG.MED. IN AUSB. VOLLAEQU."}
}};

/*********************************************************************************************
** Satzart K06                                                                              **
*********************************************************************************************/

const LKF_SATZART_ERRORCHECK_STRINGLIST 
	stringlist_Fachrichtungsindex = {30, {"00", "01", "02", "03", "04", "05", "06", "07", "08", "09",
										  "11", "12", "13", "14", "15", "16", "19", "20", "24", "29",
										  "30", "42", "44", "45", "47", "49", "50", "51", "91", "98"}};
const LKF_SATZART_ERRORCHECK
	LKFKKCheckFachrichtungsindexfalsch =	{LKF_CHECKFUNC_STRINGLIST, &stringlist_Fachrichtungsindex, &LKFKKErrorFachrichtungsindexfalsch, 0, 0},
	LKFKKCheckFachrichtungsindexfehlt =		{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorFachrichtungsindexfehlt, 0, &LKFKKCheckFachrichtungsindexfalsch},
	LKFKKCheckKonsisliarfalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorKonsisliarfalsch, 0, 0};

const SATZART K06Satzart = {"K06", 0, 4, 4, (const int *) &k04_ident, "KA-Statistik (Konsiliaraerztlicher Dienst)", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K06_FACHRICHTUNGSINDEX,	TYP_ALPHA,  14,  2, &LKFKKCheckFachrichtungsindexfehlt, 0, "FACHRICHTUNGSINDEX"},
	{K06_KONSILIARAERZTE_KOPF,	TYP_NUM,	16,  6, &LKFKKCheckKonsisliarfalsch, 0, "KONSILIARAERZTE - KOPFZAHL"}
}};

/*********************************************************************************************
** Satzart K07                                                                              **
*********************************************************************************************/

const LKF_SATZART_ERRORCHECK_STRINGLIST 
	stringlist_NichtAerztlGesBer =  {23, {"30", "41", "42", "43", "44", "51", "52", "53", "54", "55",
										  "56", "57", "58", "59", "61", "62", "63", "64", "65", "66",
										  "67", "68", "69"}},
    stringlist_NichtAerztlGesBer2014 =  {25, {"30", "41", "42", "43", "44", "51", "52", "53", "54", "55",
                                          "56", "57", "58", "59", "61", "62", "63", "64", "65", "66",
                                          "67", "68", "69", "6A", "6B"}},
    stringlist_NichtAerztlGesBer2017 =  {26, {"30", "41", "42", "43", "44", "51", "52", "53", "54", "55",
                                          "56", "57", "58", "59", "61", "62", "63", "64", "65", "66",
                                          "67", "68", "69", "6A", "6B", "6C"}},
    stringlist_NichtAerztlGesBer2024 =  {27, {"30", "41", "42", "43", "44", "4A", "51", "52", "53", "54", "55",
                                      "56", "57", "58", "59", "61", "62", "63", "64", "65", "66",
                                      "67", "68", "69", "6A", "6B", "6C"}};



;

static int k07_check_auslpers (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nEUAusl, nNichtEUAusl, nPersM, nPersW;
	const SATZART_INFO *pSatzartInfo;
	pSatzartInfo = pCheckContext->pKKContext->ppKKSatzarten[6];
	
	if (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[K07_EU_AUSL_INSG], &nEUAusl) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[K07_NEU_AUSL_INSG], &nNichtEUAusl) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[K07_PERSONAL_MAENNLICH], &nPersM) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[K07_PERSONAL_WEIBLICH], &nPersW) == LKF_FIELD_ERROR) return 0;

	nEUAusl += nNichtEUAusl;
	nPersM += nPersW;

	if (nEUAusl > nPersM)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", nEUAusl, nPersM);
		return 1;
	}
	return 0;
}

static int k07_check_hebamme (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nAnzahl;
	char sIndex[4];
	
	Satzart_GetValueInt (ds, len, pFeld, &nAnzahl);
	if (!nAnzahl) return 0;

	Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppKKSatzarten[6]->ppRef[K07_NICHTAERZTL_GESBERUF], sIndex, 4);
	if (!memcmp (sIndex, "30", 2))
		return 1;
	else
		return 0;
}

static int k07_check_hebamme_vz (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	double dVal;
	char sIndex[4];
	
	if (Satzart_GetValueFloat (ds, len, pFeld, &dVal, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR)
		return 0;
	if (dVal < DOUBLE_0_VALUE && dVal > -DOUBLE_0_VALUE) return 0; /* Wert = 0 */

	Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppKKSatzarten[6]->ppRef[K07_NICHTAERZTL_GESBERUF], sIndex, 4);
	if (!memcmp (sIndex, "30", 2))
		return 1;
	else
		return 0;
}

static int k07_check_kopfvzeq (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nPersM, nPersW, nPers;
	double dVzeqM, dVzeqW, dVzeq;
	const SATZART_INFO *pSatzartInfo;
	const SATZART_FELD *pFeldKopfM, *pFeldKopfW, *pFeldVzeqM, *pFeldVzeqW;
	unsigned int nCount, i;
    const LKF_EXPANDED_LINE **ppK;

	nCount = pCheckContext->pKKContext->pSatzartCount[6];

	if (!nCount)
		return 0;

	pSatzartInfo = pCheckContext->pKKContext->ppKKSatzarten[6];
	pFeldKopfM = pSatzartInfo->ppRef[K07_PERSONAL_MAENNLICH];
	pFeldKopfW = pSatzartInfo->ppRef[K07_PERSONAL_WEIBLICH];
	pFeldVzeqM = pSatzartInfo->ppRef[K07_MAENNL_VZEQ];
	pFeldVzeqW = pSatzartInfo->ppRef[K07_WEIBL_VZEQ];
		
	nPers = 0;
	dVzeq = 0;

    ppK = (pCheckContext->pContext->modelljahr >= 2017) ? pCheckContext->pKKContext->pppExpandedLines[6] : 0;
    
	for (i = 0; i < nCount; i++)
	{
        ds = ppK ? (const char *) ppK[i] : pCheckContext->pKKContext->pppSatzartRecords[6][i];
        len = ppK ? LKF_LEN_FOR_EXPANDEDLINE : pCheckContext->pKKContext->ppSatzartRecordLen[6][i];

		if (Satzart_GetValueFloat (ds, len, pFeldVzeqM, &dVzeqM, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) continue;
		if (Satzart_GetValueFloat (ds, len, pFeldVzeqW, &dVzeqW, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) continue;
		if (Satzart_GetValueInt (ds, len, pFeldKopfM, &nPersM) == LKF_FIELD_ERROR) continue;
		if (Satzart_GetValueInt (ds, len, pFeldKopfW, &nPersW) == LKF_FIELD_ERROR) continue;
		dVzeq += dVzeqM + dVzeqW;
		nPers += nPersM + nPersW;
	}
	return (dVzeq == (double) nPers) ? 1 : 0;
}

const LKF_SATZART_ERRORCHECK
	LKFKKCheckPersMaennAquHebamme =			{LKF_CHECKFUNC_FUNCTION, k07_check_hebamme_vz, &LKFKKErrorHebammenVZFalsch, 0, 0},
	LKFKKCheckPersMaennAquFalsch2007 =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorPersMaennAquFalsch, 0, &LKFKKCheckPersMaennAquHebamme},
	LKFKKCheckPersWeibAquFalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorPersWeibAquFalsch, 0, 0},
	LKFKKCheckEUAuslAquFalsch =				{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorEUAuslAquFalsch, 0, 0},
	LKFKKCheckNEUAuslAquFalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorNEUAuslAquFalsch, 0, 0},
    LKFKKCheckIndexNarztBerufefalsch_2024 =    {LKF_CHECKFUNC_STRINGLIST, &stringlist_NichtAerztlGesBer2024, &LKFKKErrorIndexNarztBerufefalsch, 0, 0},
    LKFKKCheckIndexNarztBerufefalsch_2017 =	{LKF_CHECKFUNC_STRINGLIST, &stringlist_NichtAerztlGesBer2017, &LKFKKErrorIndexNarztBerufefalsch, 0, 0, 2024,
        &LKFKKCheckIndexNarztBerufefalsch_2024},
	LKFKKCheckIndexNarztBerufefalsch_2014 =	{LKF_CHECKFUNC_STRINGLIST, &stringlist_NichtAerztlGesBer2014, &LKFKKErrorIndexNarztBerufefalsch, 0, 0, 2017, &LKFKKCheckIndexNarztBerufefalsch_2017},
    LKFKKCheckIndexNarztBerufefalsch =		{LKF_CHECKFUNC_STRINGLIST, &stringlist_NichtAerztlGesBer, &LKFKKErrorIndexNarztBerufefalsch, 0, 0, 2014, &LKFKKCheckIndexNarztBerufefalsch_2014},
	LKFKKCheckIndexNarztBerufefehlt =		{LKF_CHECKFUNC_EXISTS, 0, &LKFKKErrorIndexNarztBerufefehlt, 0, &LKFKKCheckIndexNarztBerufefalsch},
    LKFKKCheckMaennlicheHebamme2017 =		{LKF_CHECKFUNC_FUNCTION, k07_check_hebamme, &LKFKKErrorMaennlicheHebamme2017, 0, 0},
    LKFKKCheckMaennlicheHebamme =			{LKF_CHECKFUNC_FUNCTION, k07_check_hebamme, &LKFKKErrorMaennlicheHebamme, 0, 0, 2017, &LKFKKCheckMaennlicheHebamme2017},
	LKFKKCheckMPersKopfzahlfalsch2006 =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorMPersKopfzahlfalsch, 0, &LKFKKCheckMaennlicheHebamme },
	LKFKKCheckWPersKopfzahlfalsch =			{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorWPersKopfzahlfalsch, 0, 0},
	LKFKKCheckEUAuslKopfzahlfalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorEUAuslKopfzahlfalsch, 0, 0},
	LKFKKCheckNEUAuslKopfzahlfalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorNEUAuslKopfzahlfalsch, 0, 0},
	LKFKKCheckPersonalAuslGross =			{LKF_CHECKFUNC_FUNCTION, k07_check_auslpers, &LKFKKErrorPersonalAuslGross, 0, 0};

const SATZART K07Satzart = {"K07", 0, 11, 11, (const int *) &k04_ident, "KA-Statistik (Personal der nicht-aerztlichen Gesundheitsberufe)", &LKFKKCheckPersonalAuslGross, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K07_NICHTAERZTL_GESBERUF,	TYP_ALPHA,	14,  2, &LKFKKCheckIndexNarztBerufefehlt, 0, "INDEX NICHT-AERZTL. GES.BERUFE"},
	{K07_PERSONAL_MAENNLICH,	TYP_NUM,	16,  6, &LKFKKCheckMPersKopfzahlfalsch2006, 0, "PERSONAL MAENNLICH KOPFZAHL"},
	{K07_PERSONAL_WEIBLICH,		TYP_NUM,	22,  6, &LKFKKCheckWPersKopfzahlfalsch, 0, "PERSONAL WEIBLICH KOPFZAHL"},
	{K07_EU_AUSL_INSG,			TYP_NUM,	28,  6, &LKFKKCheckEUAuslKopfzahlfalsch, 0, "EU-AUSLAENDER INSGESAMT"},
	{K07_NEU_AUSL_INSG,			TYP_NUM,    34,  6, &LKFKKCheckNEUAuslKopfzahlfalsch, 0, "NICHT-EU-AUSLAENDER INSGESAMT"},
	{K07_MAENNL_VZEQ,			TYP_FLOAT,	40,  9, &LKFKKCheckPersMaennAquFalsch2007, 0, "PERSONAL MAENNLICH - VOLLZEITAEQUIVALENTE"},
	{K07_WEIBL_VZEQ,			TYP_FLOAT,	49,  9, &LKFKKCheckPersWeibAquFalsch, 0, "PERSONAL WEIBLICH - VOLLZEITAEQUIVALENTE"},
	{K07_EU_AUSL_VZEQ,			TYP_FLOAT,	58,  9, &LKFKKCheckEUAuslAquFalsch, 0, "EU-AUSLAENDER/INNEN VOLLZEITAEQUIVALENTE"},
	{K07_NEU_AUSL_VZEQ,			TYP_FLOAT,	67,  9, &LKFKKCheckNEUAuslAquFalsch, 0, "NICHT-EU-AUSLAENDER/INNEN VOLLZEITAEQU."}
}};

/*********************************************************************************************
** Satzart K08 (/K09/K10)                                                                   **
*********************************************************************************************/

static int check_abtfc_hk2005 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sAbtFC[10];
	Satzart_GetValueString (ds, len, pFeld, sAbtFC, 10); 
	if (lkf_IsBettHK (pCheckContext->pContext, sAbtFC))
		return 0;
	else 
		return 1;
}


static int check_k08_mehrfach (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbt = pCheckContext->pKKContext->pAktAbteilung;
	
	if (!pKKAbt) return 0;
	else if (pKKAbt->pK08) return 1;
	else 
	{
		pKKAbt->pK08 = ds;
		pKKAbt->nK08Len = len;
		return 0;
	}
}

static int check_k09_mehrfach (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbt = pCheckContext->pKKContext->pAktAbteilung;
	
	if (!pKKAbt) return 0; /* V9.2a */
	else if (pKKAbt->pK09) return 1;
	else 
	{
		pKKAbt->pK09 = ds;
		pKKAbt->nK09Len = len;
		return 0;
	}
}

static int check_k10_mehrfach (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbt = pCheckContext->pKKContext->pAktAbteilung;
	
	if (!pKKAbt) return 0; /* V9.2a */
	else if (pKKAbt->pK10) return 1;
	else 
	{
		pKKAbt->pK10 = ds;
		pKKAbt->nK10Len = len;
		return 0;
	}
}

static int k08_endkosten_bettHK (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nKost;
	if (Satzart_GetValueInt (ds, len, pFeld, &nKost)) return 0;
	if (nKost < 0) return 1;
	return 0;
}

static int k09_endkosten_nbetthk (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nKost;
	if (Satzart_GetValueInt (ds, len, pFeld, &nKost)) return 0;
	if (nKost < -50) return 1;
	return 0;
}

#define K08_MLV_ANZAHL 9
static int aMLVs[K08_MLV_ANZAHL] = {K08_MLV1_1_VZEQ, K08_MLV1_2_VZEQ, K08_MLV1_3_VZEQ, K08_MLV1_4_VZEQ, K08_MLV1_5_VZEQ, K08_MLV1_6_VZEQ, K08_MLV1_7_VZEQ, K08_MLV1_8_VZEQ, K08_MLV1_9_VZEQ};

static int k08_personal_ohne_kosten (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int i;
	int koagr01;
	double mlv_gesamt, mlv_current;
	LKF_KK_CONTEXT *pKKContext;

	pKKContext = pCheckContext->pKKContext;

	if (Satzart_GetValueInt (ds, len, pKKContext->ppKKSatzarten[pKKContext->nCurrentCheckSatzart]->ppRef[K08_KOAGR01], &koagr01) == LKF_FIELD_ERROR) return 0;

	if (pKKContext->nCurrentCheckSatzart == 9)
	{ /* Satzart 10 */
		if (Satzart_GetValueFloat (ds, len, pKKContext->ppKKSatzarten[9]->ppRef[K10_PERS_INSG_VZEQ], &mlv_gesamt, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 0;
	}
	else
	{ /* Satzarten 8 und 9 */
		mlv_gesamt = 0;
		for (i = 0; i < K08_MLV_ANZAHL; i++)
		{
			if (Satzart_GetValueFloat (ds, len, pKKContext->ppKKSatzarten[pKKContext->nCurrentCheckSatzart]->ppRef[aMLVs[i]], &mlv_current, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 0;
			mlv_gesamt += mlv_current;
		}
	}

	if (koagr01 == 0 && mlv_gesamt > 0.1) 
	{
		Satzart_GetValueString (ds, len, pKKContext->ppKKSatzarten[pKKContext->nCurrentCheckSatzart]->ppRef[GEN_ABTFC], pCheckContext->sErrorAdditionalInfo, 10);
		sprintf (pCheckContext->sErrorAdditionalInfo + 8, ": %9.2f", mlv_gesamt);
		return 1;
	}
	else if (koagr01 > 1000 && mlv_gesamt == 0)
	{
		char sAdditionalInfo[48];
		Satzart_GetValueString (ds, len, pKKContext->ppKKSatzarten[pKKContext->nCurrentCheckSatzart]->ppRef[GEN_ABTFC], sAdditionalInfo, 10);
		sprintf (sAdditionalInfo + 8, ": %9d", koagr01);
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, ds, len, pKKContext->ppKKSatzarten[pKKContext->nCurrentCheckSatzart], pFeld, &LKFKKErrorPersonalKostenOhnePers, sAdditionalInfo);
	}
	return 0;
}

#define ENDKOSTEN_PLUS		13
#define ENDKOSTEN_MINUS		 2

static int k08_endkosten_falsch_berechnet (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int i;
	int nSum, nCur, nEndKosten;
	static int aPlus[ENDKOSTEN_PLUS] = {K08_KOAGR01, K08_KOAGR02, K08_KOAGR03, K08_KOAGR04, K08_KOAGR05, K08_KOAGR06, K08_KOAGR07, K08_KOAGR08, K08_KOAGR11, K08_KOAGR12, K08_KOAGR13, K08_KOAGR14, K08_UNTER_UEBERDECKUNG};
	static int aMinus[ENDKOSTEN_MINUS] = {K08_KOSTENMINDERUNGEN, K08_SUM_ABG_INNERBETR_LST};

	const SATZART_INFO *pSatzartInfo = pCheckContext->pKKContext->ppKKSatzarten[pCheckContext->pKKContext->nCurrentCheckSatzart];

	nSum = 0;
	for (i = 0; i < ENDKOSTEN_PLUS; i++)
	{
		if (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[aPlus[i]], &nCur) == LKF_FIELD_ERROR) return 0;
		nSum += nCur;
	}

	for (i = 0; i < ENDKOSTEN_MINUS; i++)
	{
		if (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[aMinus[i]], &nCur) == LKF_FIELD_ERROR) return 0;
		nSum -= nCur;
	}

	if (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[K08_ENDKOSTEN], &nEndKosten) == LKF_FIELD_ERROR) return 0;

	if (nEndKosten > nSum + 100 || nSum > nEndKosten + 100)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", nEndKosten, nSum);
		return 1;
	}
	return 0;
}

static int k08_abweichung_unterueber (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nSummeAbgLst, nUnterUeber;
	const SATZART_INFO *pSatzartInfo = pCheckContext->pKKContext->ppKKSatzarten[pCheckContext->pKKContext->nCurrentCheckSatzart];
	
	if (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[K08_SUM_ABG_INNERBETR_LST], &nSummeAbgLst) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[K08_UNTER_UEBERDECKUNG], &nUnterUeber) == LKF_FIELD_ERROR) return 0;
	
	if (-nUnterUeber*10 > nSummeAbgLst || nUnterUeber*10 > nSummeAbgLst)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", nUnterUeber, nSummeAbgLst);
		return 1;
	}
	return 0; 
}

static int check_kostenstelle_ohne_kosten (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int i;
	int nCur;
	const SATZART_INFO *pSatzartInfo = pCheckContext->pKKContext->ppKKSatzarten[pCheckContext->pKKContext->nCurrentCheckSatzart];
	static int aKost[15] = {K08_KOAGR01, K08_KOAGR02, K08_KOAGR03, K08_KOAGR04, K08_KOAGR05,
						    K08_KOAGR06, K08_KOAGR07, K08_KOAGR08, K08_KOAGR11, K08_KOAGR12,
						    K08_KOAGR13, K08_KOAGR14, K08_KOSTENMINDERUNGEN, K08_SUM_ABG_INNERBETR_LST, K08_UNTER_UEBERDECKUNG};

	if (pCheckContext->pKKContext->nCurrentCheckSatzart == 7 && (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[K08_TATS_BETTEN], &nCur) || !nCur)) return 0;

	for (i = 0; i < 15; i++)
	{
		if (Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[aKost[i]], &nCur) == LKF_FIELD_ERROR) return 0;
		if (nCur != 0) return 0;
	}

	Satzart_GetValueString (ds, len, pSatzartInfo->ppRef[GEN_ABTFC], pCheckContext->sErrorAdditionalInfo, 10);
	return 1;
}

static int check_abtfc_nbetthk (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sAbtFC[10];
	Satzart_GetValueString (ds, len, pFeld, sAbtFC, 10); 
	if (IsNBettHK (pCheckContext->pContext, sAbtFC))
		return 0;
	else 
		return 1;
}

static int k09_check_freqnopat (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int ambpat, ambpat_freq;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K09_AMBULANTE_PATIENTEN], &ambpat) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K09_FREQ_AMB_PAT], &ambpat_freq) == LKF_FIELD_ERROR) return 0;
	if (!ambpat && ambpat_freq) return 1;
	else return 0;
}

static int k09_check_ambpat_freq (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int ambpat, ambpat_freq;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K09_AMBULANTE_PATIENTEN], &ambpat) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K09_FREQ_AMB_PAT], &ambpat_freq) == LKF_FIELD_ERROR) return 0;
	if (ambpat > ambpat_freq) return 1;
	else return 0;
}

static int k09_check_ambpat_endkost (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int ambpat, endkost;

	if (Satzart_GetValueInt (ds, len, pFeld, &ambpat)) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K08_ENDKOSTEN], &endkost) == LKF_FIELD_ERROR) return 0;
	
	if (endkost < 50  && endkost > -50)
		endkost = 0;
	
	if (ambpat > 0 && !endkost) return 1;
	return 0;
}

static int k09_check_ambpat_umlage (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int ambpat, ambpatkh, summeabgleist;

	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K09_FREQ_STAT_PAT], &ambpat) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K09_FREQ_STAT_PAT_ANDKH], &ambpatkh) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K08_SUM_ABG_INNERBETR_LST], &summeabgleist) == LKF_FIELD_ERROR) return 0;
	
	if (summeabgleist < 50 && summeabgleist > -50)
		summeabgleist = 0; /* V11.0 */
	
	if (summeabgleist == 0 && (ambpat + ambpatkh) > 0) return 1;
	else return 0;
}

static int check_abtfc_hilfskost (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sAbtFC[10];
	Satzart_GetValueString (ds, len, pFeld, sAbtFC, 10); 
	if (IsNebenHK (pCheckContext->pContext, sAbtFC) || IsHilfsHK (pCheckContext->pContext, sAbtFC))
		return 0;
	else 
		return 1;
}

static int k10_check_hilfskost (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nKost;
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbt = pCheckContext->pKKContext->pAktAbteilung;
	if (pKKAbt && IsHilfsHK (pCheckContext->pContext, pKKAbt->sAbtFC))
	{
		if (Satzart_GetValueInt (ds, len, pFeld, &nKost)) return 0;
		if (nKost > 1000 || nKost < -1000) return 1;	
	}
	return 0;
}

static int k08_check_nurTBettOhneSBett (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int lTatsBetten, lSystBetten;

	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[7]->ppRef[K08_SYST_BETTEN], &lSystBetten) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[7]->ppRef[K08_TATS_BETTEN], &lTatsBetten) == LKF_FIELD_ERROR) return 0;
	if (lTatsBetten && !lSystBetten) return 1;
	else return 0;
}

static int k08_check_nurSBett (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* nicht nur tats. Betten, alle Felder m\xc3\xbc""ssen leer sein */
	int lSystBetten;
	int lValue;
	double fValue;
    int i, limit;
	const static int aCheckFieldsInt[] = { K08_TATS_BETTEN, K08_NETTOGRUNDRISSFLAECHE, K08_KOAGR01, K08_KOAGR02, K08_KOAGR03, K08_KOAGR04, 
										   K08_KOAGR05, K08_KOAGR06, K08_KOAGR07, K08_KOAGR08, K08_KOAGR11, K08_KOAGR12, K08_KOAGR13, K08_KOAGR14, 
										   K08_KOSTENMINDERUNGEN, K08_SUM_ABG_INNERBETR_LST, K08_UNTER_UEBERDECKUNG, K08_ENDKOSTEN};
	const static int aCheckFieldsDouble[] = {K08_MLV1_1_VZEQ, K08_MLV1_2_VZEQ, K08_MLV1_3_VZEQ, K08_MLV1_4_VZEQ, K08_MLV1_5_VZEQ,
											 K08_MLV1_6_VZEQ, K08_MLV1_7_VZEQ, K08_MLV1_8_VZEQ, K08_MLV1_9_VZEQ};


	const SATZART_INFO *pK08 = pCheckContext->pKKContext->ppKKSatzarten[7];

	if (Satzart_GetValueInt (ds, len, pK08->ppRef[K08_SYST_BETTEN], &lSystBetten) == LKF_FIELD_ERROR) return 0;
	else if (lSystBetten == 0) return 0;

    limit = sizeof (aCheckFieldsInt) / sizeof (int);
	for (i = 0; i < limit; i++)
	{
		if (Satzart_GetValueInt (ds, len, pK08->ppRef[aCheckFieldsInt[i]], &lValue) == LKF_FIELD_ERROR || lValue)
			return 0;
	}
    
    limit = sizeof (aCheckFieldsDouble) / sizeof (int);

	for (i = 0; i < limit; i++)
	{
		if (Satzart_GetValueFloat (ds, len, pK08->ppRef[aCheckFieldsDouble[i]], &fValue, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR || fValue != 0.0)
			return 0;
	}

	pCheckContext->lCheckFlags |= CHECKFLAG_SKIP_LINE;
	return 1;
}

static int k08_check_int_ohne_arzt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{

	LKF_KK_CONTEXT_ABTEILUNG *pKKAbt;
	pKKAbt = pCheckContext->pKKContext->pAktAbteilung;
	
	if (pKKAbt && pKKAbt->sAbtFC[1] == '2')
	{
		double fArzt;
		if (Satzart_GetValueFloat (ds, len, pCheckContext->pKKContext->ppKKSatzarten[7]->ppRef[K08_MLV1_1_VZEQ], &fArzt, pCheckContext->pContext->modelljahr)) return 0;
		if (fArzt <= 0) return 1;
	}
	return 0;
}

static int k09_check_op_ohne_arzt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbt = pCheckContext->pKKContext->pAktAbteilung;

	if (pKKAbt && pKKAbt->sAbtFC[4] == '9' && pKKAbt->sAbtFC[5] == '5')
	{
		double fArzt;
		if (Satzart_GetValueFloat (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K08_MLV1_1_VZEQ], &fArzt, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 0;
		if (fArzt == 0) return 1;
	}
	return 0;
}

static int k09_check_labor_ohne_arzt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbt = pCheckContext->pKKContext->pAktAbteilung;

	if (pKKAbt && (!memcmp (pKKAbt->sAbtFC + 2, "82", 2) || !memcmp (pKKAbt->sAbtFC + 2, "83", 2) || !memcmp (pKKAbt->sAbtFC + 4, "79", 2)))
	{
		double fPers;
		if (Satzart_GetValueFloat (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K08_MLV1_5_VZEQ], &fPers, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 0;
		if (fPers == 0) return 1;		
	}

	return 0;
}

static int k10_check_nebenkost_endk_neg (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nKost;
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbt = pCheckContext->pKKContext->pAktAbteilung;
	if (pKKAbt && IsNebenHK (pCheckContext->pContext, pKKAbt->sAbtFC))
	{
		if (Satzart_GetValueInt (ds, len, pFeld, &nKost)) return 0;
		if (nKost <= 0) return 1;	
	}
	return 0;
}

static int aNumDatK08[2] = {K08_TATS_BETTEN, K08_NETTOGRUNDRISSFLAECHE};
static int aNumDatK09[4] = {K09_AMBULANTE_PATIENTEN, K09_FREQ_AMB_PAT, K09_FREQ_STAT_PAT, K08_NETTOGRUNDRISSFLAECHE};
static int aDezDat[9] = {K08_MLV1_1_VZEQ, K08_MLV1_2_VZEQ, K08_MLV1_3_VZEQ, K08_MLV1_4_VZEQ, K08_MLV1_5_VZEQ,
						K08_MLV1_6_VZEQ, K08_MLV1_7_VZEQ, K08_MLV1_8_VZEQ, K08_MLV1_9_VZEQ};
static int aNumKost[15] = {K08_KOAGR01, K08_KOAGR02, K08_KOAGR03, K08_KOAGR04, K08_KOAGR05,
						   K08_KOAGR06, K08_KOAGR07, K08_KOAGR08, K08_KOAGR11, K08_KOAGR12,
						   K08_KOAGR13, K08_KOAGR14, K08_KOSTENMINDERUNGEN, K08_SUM_ABG_INNERBETR_LST, K08_UNTER_UEBERDECKUNG};

static int k08_check_kostenstellevollst (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int i;
	int nCur;
	double fCur;
	int hasdat, haskost;
	const SATZART_INFO *pSatzart = pCheckContext->pKKContext->ppKKSatzarten[7];

	hasdat = haskost = 0;

	for (i = 0; !hasdat && i < 2; i++)
	{
		if (Satzart_GetValueInt (ds, len, pSatzart->ppRef[aNumDatK08[i]], &nCur) == LKF_FIELD_ERROR) return 0;
		else if (nCur != 0) hasdat = 1;
	}

	for (i = 0; !hasdat && i < 9; i++)
	{
		if (Satzart_GetValueFloat (ds, len, pSatzart->ppRef[aDezDat[i]], &fCur, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 0;
		else if (fCur != 0) hasdat = 1;
	}

	for (i = 0; !haskost && i < 15; i++)
	{
		if (Satzart_GetValueInt (ds, len, pSatzart->ppRef[aNumKost[i]], &nCur) == LKF_FIELD_ERROR) return 0;
		else if (nCur != 0) haskost = 1;
	}

	if ((!hasdat && haskost) || (hasdat && !haskost)) 
	{
		Satzart_GetValueString (ds, len, pSatzart->ppRef[GEN_ABTFC], pCheckContext->sErrorAdditionalInfo, 10);	
		return 1;
	}
	else return 0;
}

static int k09_check_kostenstellevollst (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int i;
	int nCur;
	double fCur;
	int hasdat, haskost;
	const SATZART_INFO *pSatzart = pCheckContext->pKKContext->ppKKSatzarten[8];

	hasdat = haskost = 0;

	for (i = 0; !hasdat && i < 4; i++)
	{
		if (Satzart_GetValueInt (ds, len, pSatzart->ppRef[aNumDatK09[i]], &nCur) == LKF_FIELD_ERROR) return 0;
		else if (nCur != 0) hasdat = 1;
	}

	for (i = 0; !hasdat && i < 9; i++)
	{
		if (Satzart_GetValueFloat (ds, len, pSatzart->ppRef[aDezDat[i]], &fCur, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 0;
		else if (fCur != 0) hasdat = 1;
	}

	for (i = 0; !haskost && i < 15; i++)
	{
		if (Satzart_GetValueInt (ds, len, pSatzart->ppRef[aNumKost[i]], &nCur) == LKF_FIELD_ERROR) return 0;
		else if (nCur != 0) haskost = 1;
	}

	if ((!hasdat && haskost) || (hasdat && !haskost)) 
	{
		Satzart_GetValueString (ds, len, pSatzart->ppRef[GEN_ABTFC], pCheckContext->sErrorAdditionalInfo, 10);
		return 1;
	}
	else return 0;
}

static int check_verbleib_unplaus (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sAbtFC[10];
	int nTatsBetten;

	if (!pCheckContext->pKKContext->lMBDSStatOk) k03_mbdsstat (pCheckContext,0);
	Satzart_GetValueInt (ds, len, pFeld, &nTatsBetten);
	Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppKKSatzarten[7]->ppRef[GEN_ABTFC], sAbtFC, 10);

	if (pCheckContext->pKKContext->pAktAbteilung)
	{
		if (pCheckContext->pKKContext->pAktAbteilung->nVerbleibPat * 20 > nTatsBetten * 23)
		{
			sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", pCheckContext->pKKContext->pAktAbteilung->nVerbleibPat, nTatsBetten);		
			return 1; /* WK1W: Verbleibende \xc3\xbc""bersteigen die gemeldeteten tats. Betten um mehr als 15 % */
		}
	}
	return 0;
}

static int check_tbett_warn (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nTatsBetten, nAnzahlTage;
	Satzart_GetValueInt (ds, len, pFeld, &nTatsBetten);

	if (pCheckContext->pKKContext->pAktAbteilung)
	{
		nAnzahlTage = (pCheckContext->pContext->cmb_jahr % 4) ? 365 : 366;
		if (pCheckContext->pKKContext->pAktAbteilung->nBelagstage * 2 / nAnzahlTage > nTatsBetten * 23)	
			return 1; /* WK1X: Durchschnittsbelag \xc3\xbc""bersteigt die gemeldeteten tats. Betten um mehr als 15 % */
	}
	return 0;
}

static int check_tbett_err (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nTatsBetten, nAnzahlTage;
	Satzart_GetValueInt (ds, len, pFeld, &nTatsBetten);

	if (pCheckContext->pKKContext->pAktAbteilung)
	{
		nAnzahlTage = (pCheckContext->pContext->cmb_jahr % 4) ? 365 : 366;
		if (pCheckContext->pKKContext->pAktAbteilung->nBelagstage / nAnzahlTage > nTatsBetten * 13)	
			return 1; /* EK6X: Durchschnittsbelag \xc3\xbc""bersteigt die gemeldeteten tats. Betten um mehr als 30 % */
	}
	return 0;
}

static int check_medtechnfehlt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sAbtFC[10];
	double dVal;

	if (!Satzart_IsEmpty (ds, len, pFeld))
	{
		if (Satzart_GetValueFloat (ds, len, pFeld, &dVal, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 0;
		if (dVal != 0) return 0;
	}

	Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[GEN_ABTFC], sAbtFC, 10);
	if (!memcmp (sAbtFC + 2, "72", 2) || !memcmp (sAbtFC + 2, "75", 2) ||
		!memcmp (sAbtFC + 2, "78", 2) || !memcmp (sAbtFC + 2, "82", 2))
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%8.8s", sAbtFC);
		return 1;
	}
	else return 0;
}

static int k10_check202511 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	static int aIntFields[] = {K08_NETTOGRUNDRISSFLAECHE, K08_KOAGR01, K08_KOAGR02, K08_KOAGR03, K08_KOAGR04, K08_KOAGR05, K08_KOAGR06, K08_KOAGR07, K08_KOAGR08, K08_KOAGR11, K08_KOAGR12, K08_KOAGR13, K08_KOAGR14, K08_SUM_ABG_INNERBETR_LST, K08_UNTER_UEBERDECKUNG};
	int nIntValue;
	double dValue;
	unsigned int i, nCount;
	char sAbtFC[10];

	if (pCheckContext->pContext->modelljahr < 2008) return 0;

	pFeld = pCheckContext->pKKContext->ppKKSatzarten[9]->ppRef[GEN_ABTFC];
	Satzart_GetValueString (ds, len, pFeld, sAbtFC, 10);
	if (memcmp (sAbtFC, "202511", 6)) return 0;

	pFeld = pCheckContext->pKKContext->ppKKSatzarten[9]->ppRef[K10_PERS_INSG_VZEQ];

	if (pFeld && !Satzart_GetValueFloat (ds, len, pFeld, &dValue, pCheckContext->pContext->modelljahr) && dValue != 0)
		return 1; 

	nCount = (unsigned int) (sizeof(aIntFields)/sizeof(int));

	for (i = 0; i < nCount; i++)
	{
		pFeld = pCheckContext->pKKContext->ppKKSatzarten[9]->ppRef[aIntFields[i]];
		if (pFeld && !Satzart_GetValueInt (ds, len, pFeld, &nIntValue) && nIntValue)
			return 1;
	} 

	return 0;
}

static int k08_check_auslastung (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    
    int lNum;
    int dayCount;
    double auslastung;
    LKF_KK_CONTEXT *pKKContext;
    const SATZART_INFO *pSatzart;
    pKKContext = pCheckContext->pKKContext;
    
    if (!pKKContext->pAktAbteilung || !pKKContext->pAktAbteilung->pK08) {
        return 0;
    }
    
    pSatzart = pCheckContext->pKKContext->ppKKSatzarten[7];
    dayCount = (pCheckContext->pContext->cmb_jahr % 4) ? 365 : 366;
    if (Satzart_GetValueInt (ds, len, pSatzart->ppRef[K08_TATS_BETTEN], &lNum) == LKF_FIELD_ERROR) return 0;
    if (lNum == 0) {
        return 0;
    }
    
    auslastung = pKKContext->pAktAbteilung->nBelagstage;
    auslastung /= lNum * dayCount;
    
    if (auslastung > 1.0) {
        sprintf (pCheckContext->sErrorAdditionalInfo, "%.2f%%", auslastung * 100);
        return 1;
    }
    
    return 0;
}


const LKF_SATZART_ERRORCHECK
	LKFKKCheckTBETTunplausWarn =		{LKF_CHECKFUNC_FUNCTION, check_tbett_warn, &LKFErrorTBETTunplausWarn, 0, 0},
	LKFKKCheckTBETTunplausErr =			{LKF_CHECKFUNC_FUNCTION, check_tbett_err, &LKFErrorTBETTunplausErr, 0, &LKFKKCheckTBETTunplausWarn},
	LKFKKCheckVerbleibUnplaus =			{LKF_CHECKFUNC_FUNCTION, check_verbleib_unplaus, &LKFErrorVerbleibUnplaus, &LKFKKCheckTBETTunplausErr, &LKFKKCheckTBETTunplausErr},
	LKFKKCheckUnterUeberdeckungFalsch = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorUnterUeberdeckungFalsch, 0, 0},
    LKFKKCheckK08Auslastung2025 =           {LKF_CHECKFUNC_FUNCTION, &k08_check_auslastung, &LKFKKErrorAuslastungK08, 0, 0}, /* V2026.0 */
    LKFKKCheckEndkostenFalschBerechnet2025 ={LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k08_endkosten_falsch_berechnet, &LKFKKErrorEndkostenFalschBerechnet, &LKFKKCheckK08Auslastung2025, &LKFKKCheckK08Auslastung2025},
    LKFKKCheckEndkostenFalschBerechnet ={LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k08_endkosten_falsch_berechnet, &LKFKKErrorEndkostenFalschBerechnet, 0, 0, 2025, &LKFKKCheckEndkostenFalschBerechnet2025 },
    LKFKKCheckAbweichungUnterUeberdeckung2017 = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k08_abweichung_unterueber, &LKFKKErrorAbweichungUnterUeberdeckung2017, &LKFKKCheckEndkostenFalschBerechnet, &LKFKKCheckEndkostenFalschBerechnet}, /* V21.0 blank weg ab 2017 */
    LKFKKCheckAbweichungUnterUeberdeckung = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k08_abweichung_unterueber, &LKFKKErrorAbweichungUnterUeberdeckung, &LKFKKCheckEndkostenFalschBerechnet, &LKFKKCheckEndkostenFalschBerechnet, 2017, &LKFKKCheckAbweichungUnterUeberdeckung2017},
	LKFKKCheckKostenstelleOhneKosten =	{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_kostenstelle_ohne_kosten, &LKFKKErrorKostenstelleOhneKosten, &LKFKKCheckAbweichungUnterUeberdeckung, &LKFKKCheckAbweichungUnterUeberdeckung},
	LKFKKCheckK08_Kostenstelleunvollst =	{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k08_check_kostenstellevollst, &LKFKKErrorK08_Kostenstelleunvollst, &LKFKKCheckKostenstelleOhneKosten, &LKFKKCheckKostenstelleOhneKosten},
	LKFKKCheckK09_Kostenstelleunvollst =	{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k09_check_kostenstellevollst, &LKFKKErrorK09_Kostenstelleunvollst, &LKFKKCheckKostenstelleOhneKosten, &LKFKKCheckKostenstelleOhneKosten},
	LKFKKCheckK08Mehrfach =				{LKF_CHECKFUNC_FUNCTION, check_k08_mehrfach, &LKFKKErrorFunktionscodemehrfach, 0, 0},
	LKFKKCheckK09Mehrfach =				{LKF_CHECKFUNC_FUNCTION, check_k09_mehrfach, &LKFKKErrorFunktionscodemehrfach, 0, 0},
	LKFKKCheckK10Mehrfach =				{LKF_CHECKFUNC_FUNCTION, check_k10_mehrfach, &LKFKKErrorFunktionscodemehrfach, 0, 0},
	LKFKKCheckPersonalOhneKostenK08 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k08_personal_ohne_kosten, &LKFKKErrorPersonalOhneKosten, &LKFKKCheckK08_Kostenstelleunvollst, &LKFKKCheckK08_Kostenstelleunvollst},
	LKFKKCheckPersonalOhneKostenK09 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k08_personal_ohne_kosten, &LKFKKErrorPersonalOhneKosten, &LKFKKCheckK09_Kostenstelleunvollst, &LKFKKCheckK09_Kostenstelleunvollst},
	LKFKKCheckFLAFFalsch2009 =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k10_check202511, &LKFKKErrorFLAFFalsch, &LKFKKCheckKostenstelleOhneKosten, &LKFKKCheckKostenstelleOhneKosten},
    LKFKKCheckPersonalOhneKostenK10_2008 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k08_personal_ohne_kosten, &LKFKKErrorPersonalOhneKosten, &LKFKKCheckFLAFFalsch2009, &LKFKKCheckFLAFFalsch2009},
	LKFKKCheckABTFCHKFalsch2005 =		{LKF_CHECKFUNC_FUNCTION, check_abtfc_hk2005, &LKFKKErrorABTFCHKFalsch, 0, &LKFKKCheckK08Mehrfach},
	LKFKKCheckNurSBETT2005 =			{LKF_CHECKFUNC_FUNCTION, k08_check_nurSBett, &LKFKKErrorNurSBETT, 0, 0},
	LKFKKCheckK08SystBettenFalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorK08SystBettenFalsch, 0, &LKFKKCheckNurSBETT2005},
	LKFKKCheckK08SystBettenFehlt =		{LKF_CHECKFUNC_EXISTS_NOT0, 0, &LKFKKErrorK08SystBettenFehlt, 0, &LKFKKCheckK08SystBettenFalsch},
	LKFKKCheckTBETTENohneSBETTEN2005 =	{LKF_CHECKFUNC_FUNCTION, k08_check_nurTBettOhneSBett, &LKFKKErrorTBETTENohneSBETTEN, &LKFKKCheckVerbleibUnplaus, &LKFKKCheckVerbleibUnplaus}, /* V9.2 */
	LKFKKCheckK08TatsBettenFalsch =		{LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorK08TatsBettenFalsch, 0, &LKFKKCheckTBETTENohneSBETTEN2005},
	LKFKKCheckK08TatsBettenFehlt =		{LKF_CHECKFUNC_EXISTS_NOT0, 0, &LKFKKErrorK08TatsBettenFehlt, 0, &LKFKKCheckK08TatsBettenFalsch},
	LKFKKCheckK08NettogrundrissFalsch = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK08NettogrundrissFalsch, 0, 0},
	LKFKKCheckK08NettogrundrissFehlt =	{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK08NettogrundrissFehlt, 0, &LKFKKCheckK08NettogrundrissFalsch},
	LKFKKCheckIntOhneArztPers =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k08_check_int_ohne_arzt, &LKFKKErrorIntOhneArztPers, 0, 0},
	LKFKKCheckK08ArztAquFalsch2005 =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK08ArztAquFalsch, 0, &LKFKKCheckIntOhneArztPers},
	LKFKKCheckArztAquFehlt =			{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorArztAquFehlt, 0, &LKFKKCheckK08ArztAquFalsch2005},
	LKFKKCheckLaborOhneMedTechn =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k09_check_labor_ohne_arzt, &LKFKKErrorLaborOhneMedTechn, 0, 0},
	LKFKKCheckOPOhneArztPers =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k09_check_op_ohne_arzt, &LKFKKErrorOPOhneArztPers, &LKFKKCheckLaborOhneMedTechn, &LKFKKCheckLaborOhneMedTechn},
	LKFKKCheckK09ArztAquFalsch2005 =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK08ArztAquFalsch, 0, &LKFKKCheckOPOhneArztPers},
	LKFKKCheckApoChemAquFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorApoChemAquFalsch, 0, 0},
	LKFKKCheckHebammenAquFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorHebammenAquFalsch, 0, 0},
	LKFKKCheckGehoberDienstAquFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorGehoberDienstAquFalsch, 0, 0},
	LKFKKCheckGehDienstAquFehlt =		{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorGehDienstAquFehlt, 0, &LKFKKCheckGehoberDienstAquFalsch},
	LKFKKCheckMedTechnDienstAquFalsch = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorMedTechnDienstAquFalsch, 0, 0},
	LKFKKCheckMedTechnDienstAquFehlt =  {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_medtechnfehlt, &LKFKKErrorMedTechnDienstAquFehlt, 0, &LKFKKCheckMedTechnDienstAquFalsch},
	LKFKKCheckPflegeAquFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorPflegeAquFalsch, 0, 0},
	LKFKKCheckVerwKanzleiAquFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorVerwKanzleiAquFalsch, 0, 0},
	LKFKKCheckBetriebspersAquFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorBetriebspersAquFalsch, 0, 0},
	LKFKKCheckSonstPersAquFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorSonstPersAquFalsch, 0, 0},
	LKFKKCheckPersonalKostenFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorPersonalKostenFalsch, 0, 0},
	LKFKKCheckKostMedGueterFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostMedGueterFalsch, 0, 0},
	LKFKKCheckKostNichtMedGueterFalsch ={LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostNichtMedGueterFalsch, 0, 0},
	LKFKKCheckKostenMedFremdLStFalsch = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostenMedFremdLStFalsch, 0, 0},
	LKFKKCheckKostenNichtMedFremdLStFalsch = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostenNichtMedFremdLStFalsch, 0, 0},
	LKFKKCheckEnergieKostenFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorEnergieKostenFalsch, 0, 0},
	LKFKKCheckAbgabenFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorAbgabenFalsch, 0, 0},
	LKFKKCheckKalkAnlageKostenFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKalkAnlageKostenFalsch, 0, 0},
	LKFKKCheckKostMedEntsorgungFalsch = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostMedEntsorgungFalsch, 0, 0},
	LKFKKCheckKostNMedEntsorgungFalsch ={LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostNMedEntsorgungFalsch, 0, 0},
	LKFKKCheckKostVerwaltungFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostVerwaltungFalsch, 0, 0},
	LKFKKCheckKostSekundaerFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostSekundaerFalsch, 0, 0},
	LKFKKCheckKostenminderungFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostenminderungFalsch, 0, 0},
	LKFKKCheckSummeLeistungenFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorSummeLeistungenFalsch, 0, 0},
	LKFKKCheckHilfsKostmitEndkosten =	{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k10_check_hilfskost, &LKFKKErrorHilfsKostmitEndkosten, 0, 0},
	LKFKKCheckEndkostenFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorEndkostenFalsch, 0, 0},
	LKFKKCheckEndkostenFalschK10 =      {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorEndkostenFalsch, 0, &LKFKKCheckHilfsKostmitEndkosten},	
	LKFKKCheckK09_AbtFCFalsch =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_abtfc_nbetthk, &LKFKKErrorK09_AbtFCFalsch, 0, &LKFKKCheckK09Mehrfach},
	LKFFreqKeinePat =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k09_check_freqnopat, &LKFErrorFreqKeinePat, 0, 0}, /* V10.2 */
	LKFKKCheckFreqAmbPatFalsch2006 =    {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorFreqAmbPatFalsch, 0, &LKFFreqKeinePat},
	LKFKKCheckFreqStatPatAndKAFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorFreqStatPatAndKAFalsch, 0, 0},
	LKFKKCheckFreqStatPatOhneUmlage =	{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k09_check_ambpat_umlage, &LKFKKErrorFreqStatPatOhneUmlage, 0, 0},
	LKFKKCheckFreqStatPatFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorFreqStatPatFalsch, 0, &LKFKKCheckFreqStatPatOhneUmlage},
	LKFKKCheckAmbPat_Freq =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k09_check_ambpat_freq, &LKFKKErrorAmbPat_Freq, 0, 0},
	LKFKKCheckAmbPatOhneEndkosten =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k09_check_ambpat_endkost, &LKFKKErrorAmbPatOhneEndkosten, 0, &LKFKKCheckAmbPat_Freq},
	LKFKKCheckAmbPatFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorAmbPatFalsch, 0, &LKFKKCheckAmbPatOhneEndkosten},
	LKFKKCheckK10_AbtFCFalsch =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_abtfc_hilfskost, &LKFKKErrorK10_AbtFCFalsch, 0, &LKFKKCheckK10Mehrfach},
	LKFKKCheckPersInsgAquFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorPersInsgAquFalsch, 0, 0};


const SATZART K08Satzart = {"K08", 0, 31, 31, (const int *) &k04_ident, "Kostenstellen-Statistik und Kostenstellennachweis (Bettenf. HK)", &LKFKKCheckPersonalOhneKostenK08, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{GEN_ABTFC,					TYP_NUM,	14,  8, &LKFKKCheckABTFCHKFalsch2005, 0, "ABTFC"},
	{K08_SYST_BETTEN,			TYP_NUM,	22,  6, &LKFKKCheckK08SystBettenFehlt, 0, "SYSTEMISIERTE BETTEN"},
	{K08_TATS_BETTEN,			TYP_NUM,	28,  6, &LKFKKCheckK08TatsBettenFehlt, 0, "TATSAECHLICH AUFG. BETTEN"},
	{K08_NETTOGRUNDRISSFLAECHE,	TYP_NUM,	34,  6, &LKFKKCheckK08NettogrundrissFehlt, 0, "NETTOGRUNDRISSFLAECHE"},
	{K08_MLV1_1_VZEQ,			TYP_FLOAT,	40,  9, &LKFKKCheckArztAquFehlt, 0, "ARZTE/INNEN VOLLZEITAEQU. (MLV 1-1)"},
	{K08_MLV1_2_VZEQ,			TYP_FLOAT,	49,  9, &LKFKKCheckApoChemAquFalsch, 0, "APOTH./CHEM./PHYS. VOLLZ.AEQU. (MLV 1-2)"},
	{K08_MLV1_3_VZEQ,			TYP_FLOAT,	58,  9, &LKFKKCheckHebammenAquFalsch, 0, "HEBAMMEN VOLLZEITAEQU. (MLV 1-3)"},
	{K08_MLV1_4_VZEQ,			TYP_FLOAT,	67,  9, &LKFKKCheckGehDienstAquFehlt, 0, "GEHOB.DIENST PFLEGE VOLLZEITAEQU. (MLV 1-4)"},
	{K08_MLV1_5_VZEQ,			TYP_FLOAT,	76,  9, &LKFKKCheckMedTechnDienstAquFalsch, 0, "GEHOB.MED-TECHN. DIENSTE/FACHD./MASS VOLLZ.AEQU (MLV 1-5)"},
	{K08_MLV1_6_VZEQ,			TYP_FLOAT,	85,	 9, &LKFKKCheckPflegeAquFalsch, 0, "PFLEGEHILFE UND SANI-HILFSD. VOLLZ.AEQU (MLV 1-6)"},
	{K08_MLV1_7_VZEQ,			TYP_FLOAT,	94,	 9, &LKFKKCheckVerwKanzleiAquFalsch, 0, "VERW./KANZLEIPERS. VOLLZEITAEQU. (MLV 1-7)"},
	{K08_MLV1_8_VZEQ,			TYP_FLOAT, 103,  9, &LKFKKCheckBetriebspersAquFalsch, 0, "BETRIEBSPERSONAL VOLLZEITAEQU. (MLV 1-8)"},
	{K08_MLV1_9_VZEQ,			TYP_FLOAT, 112,  9, &LKFKKCheckSonstPersAquFalsch, 0, "SONST. PERSONAL VOLLZEITAEQU. (MLV 1-9)"},
	{K08_KOAGR01,				TYP_NUM_NEG1000,   121, 10, &LKFKKCheckPersonalKostenFalsch, 0, "PERSONALKOSTEN (KOAGR01)"},
	{K08_KOAGR02,				TYP_NUM_NEG1000,   131, 10, &LKFKKCheckKostMedGueterFalsch, 0, "KOSTEN MED.GEBR/VERBR.GUETER (KOAGR02)"},
	{K08_KOAGR03,				TYP_NUM_NEG1000,   141, 10, &LKFKKCheckKostNichtMedGueterFalsch, 0, "KOSTEN NICHTMED.GEBR/VERBR.GUETER (KOAGR03)"},
	{K08_KOAGR04,				TYP_NUM_NEG1000,   151, 10, &LKFKKCheckKostenMedFremdLStFalsch, 0, "KOSTEN MED. FREMDLEISTUNGEN (KOAGR04)"},
	{K08_KOAGR05,				TYP_NUM_NEG1000,   161, 10, &LKFKKCheckKostenNichtMedFremdLStFalsch, 0, "KOSTEN NICHTMED. FREMDLEISTUNGEN (KOAGR05)"},
	{K08_KOAGR06,				TYP_NUM_NEG1000,   171, 10, &LKFKKCheckEnergieKostenFalsch, 0, "ENERGIEKOSTEN (KOAGR06)"},
	{K08_KOAGR07,				TYP_NUM_NEG1000,   181, 10, &LKFKKCheckAbgabenFalsch, 0, "ABGABEN/BEITRAEGE/GEBUEHREN SONST. (KOAGR07)"},
	{K08_KOAGR08,				TYP_NUM_NEG1000,   191, 10, &LKFKKCheckKalkAnlageKostenFalsch, 0, "KALK. ANLAGEKAPITALKOSTEN (KOAGR08)"},
	{K08_KOAGR11,				TYP_NUM_NEG1000,   201, 10, &LKFKKCheckKostMedEntsorgungFalsch, 0, "KOSTEN VORW.MED.BED. VER-/ENTSORGUNG (KOAGR11)"},
	{K08_KOAGR12,				TYP_NUM_NEG1000,   211, 10, &LKFKKCheckKostNMedEntsorgungFalsch, 0, "KOSTEN VORW.NMED.BED. VER-/ENTSORGUNG (KOAGR12)"},
	{K08_KOAGR13,				TYP_NUM_NEG1000,   221, 10, &LKFKKCheckKostVerwaltungFalsch, 0, "KOSTEN VERWALTUNG (KOAGR13)"},
	{K08_KOAGR14,				TYP_NUM_NEG1000,   231, 10, &LKFKKCheckKostSekundaerFalsch, 0, "ANDERE SEKUNDAERKOSTEN (KOAGR14)"},
	{K08_KOSTENMINDERUNGEN,		TYP_NUM_NEG,   241, 10, &LKFKKCheckKostenminderungFalsch, 0, "KOSTENMINDERUNGEN"},
	{K08_SUM_ABG_INNERBETR_LST,	TYP_NUM_NEG,   251, 10, &LKFKKCheckSummeLeistungenFalsch, 0, "SUMME ABG. INNERBETR. LEISTUNGEN"},
	{K08_UNTER_UEBERDECKUNG,	TYP_NUM_NEG, 261, 10, &LKFKKCheckUnterUeberdeckungFalsch, 0, "UNTER- ODER UEBERDECKUNG"},
	{K08_ENDKOSTEN,				TYP_NUM_NEG, 271, 10, &LKFKKCheckEndkostenFalsch, 0, "ENDKOSTEN DER KOSTENSTELLE"}
}};


/*********************************************************************************************
** Satzart K09                                                                              **
*********************************************************************************************/

static int Is_AmbPatCheckAbt (LKF_CHECK_CONTEXT *pCheckContext)
{
	const char *sAbtFC = pCheckContext->pKKContext->pAktAbteilung->sAbtFC;

	if (sAbtFC[0] == '1')
	{
		if ((sAbtFC[2] == '8' && strchr ("123", sAbtFC[3])) ||
			!memcmp (sAbtFC + 2, "7112", 4) || !memcmp (sAbtFC + 4, "79", 2))
		{
			if (pCheckContext->bKKTraceDetail)
				lkf_trace_kk_detail (pCheckContext, "Kein Check fuer diesen ABTFC -> ok");
			return 0;
		}
	}
	return 1;
}

static int check_k09_endk_ambpat (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nEndKosten, nAmbPat;

	Satzart_GetValueInt (ds, len, pFeld, &nEndKosten);
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K09_AMBULANTE_PATIENTEN], &nAmbPat) == LKF_FIELD_ERROR) return 0;
	if ((nEndKosten > 100 || nEndKosten < -100) && !nAmbPat) return 1;
	else return 0;
}

static int check_k09_umlage_ohnestatfreq (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sTraceLine[512];
	int nUmlage, nStatPat, nStatPatAndKH;
    const char *sAbtFC;

	if (!Is_AmbPatCheckAbt (pCheckContext))
		return 0;

    /* Zusaetzliche Ausnahmen
  	    1-1179 Mikrobiologisch-serologische Laboruntersuchung (Interne)
		1-1279 Mikrobiologisch-serologische Laboruntersuchung (Pulmologie)
		1-2179 Mikrobiologisch-serologische Laboruntersuchung (Chirurgie)
		1-2479 Mikrobiologisch-serologische Laboruntersuchung (Mund-, Kiefer- und Gesichtschirurgie)
		1-2579 Mikrobiologisch-serologische Laboruntersuchung (Neurochirurgie)
		1-3279 Mikrobiologisch-serologische Laboruntersuchung (Gyn\xc3\xa4""kologie)
		1-5179 Mikrobiologisch-serologische Laboruntersuchung (Kinderheilkunde)
		1-7179 Mikrobiologisch-serologische Laboruntersuchung (An\xc3\xa4""sthesie)
		1-9179 Mikrobiologisch-serologische Laboruntersuchung (interdisziplin\xc3\xa4""r)
		1-4116 Hornhautbank (Augenheilkunde)
		1-2316 Knochenbank (Orthop\xc3\xa4""die) */

    sAbtFC = pCheckContext->pKKContext->pAktAbteilung->sAbtFC;
    
    if (sAbtFC[0] == '1')
    {
        switch (sAbtFC[2])
        {
            case '1':
                if (!memcmp (sAbtFC+2, "1179", 4) ||
                    !memcmp (sAbtFC+2, "1279", 4))
                    return 0;
                break;
            case '2':
                if (!memcmp (sAbtFC+2, "2179", 4) ||
                    !memcmp (sAbtFC+2, "2479", 4) ||
                    !memcmp (sAbtFC+2, "2579", 4) ||
                    !memcmp (sAbtFC+2, "2316", 4))
                    return 0;
                break;
            case '3':
                if (!memcmp (sAbtFC+2, "3279", 4))
                    return 0;
                break;
            case '4':
                if (!memcmp (sAbtFC+2, "4116", 4))
                    return 0;
                break;
            case '5':
                if (!memcmp (sAbtFC+2, "5179", 4))
                    return 0;
                break;
            case '7':
                if (!memcmp (sAbtFC+2, "7179", 4))
                    return 0;
                break;
            case '9':
                if (!memcmp (sAbtFC+2, "9179", 4))
                    return 0;
                break;
            default:
                break;
                
        }
    }

	Satzart_GetValueInt (ds, len, pFeld, &nUmlage);
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K09_FREQ_STAT_PAT], &nStatPat) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[8]->ppRef[K09_FREQ_STAT_PAT_ANDKH], &nStatPatAndKH) == LKF_FIELD_ERROR) return 0;

	if (nUmlage > -100 && nUmlage < 100) nUmlage = 0;


	if (nUmlage && !nStatPat && !nStatPatAndKH) 
	{
		if (pCheckContext->bKKTraceDetail)
		{
			sprintf (sTraceLine, "Umlage=%d, aber keine stat. Pat (inkl. stat. Pat and. KH) -> Fehler", nUmlage);
			lkf_trace_kk_detail (pCheckContext, sTraceLine);
		}
		return 1;
	}
	if (pCheckContext->bKKTraceDetail)
	{
			sprintf (sTraceLine, "Umlage=%d, StatPat=%d, StatPatAndKH=%d -> ok", nUmlage, nStatPat, nStatPatAndKH);
			lkf_trace_kk_detail (pCheckContext, sTraceLine);
	}
	return 0;
}

const LKF_SATZART_ERRORCHECK
	LKFKKCheckEndKostenOhneAmbPat =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_k09_endk_ambpat, &LKFErrorEndKostenOhneAmbPat, 0, 0},
	LKFKKCheckUmlageOhneStatFrequenz =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_k09_umlage_ohnestatfreq, &LKFErrorUmlageOhneStatFrequenz, 0, 0},
	LKFKKCheckSummeLeistungenFalschK09_2006 =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorSummeLeistungenFalsch, 0, &LKFKKCheckUmlageOhneStatFrequenz},
	LKFKKCheckEndkostenK09Falsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorEndkostenFalsch, 0, &LKFKKCheckEndKostenOhneAmbPat},
    LKFKKCheckK09AmbBetreuung =                {LKF_CHECKFUNC_FORMAT, 0, &LKFKKErrorK09AmbBetreuungFalsch, 0, 0}; /* V21.0 */

#ifdef SUPPORT_PRE2017
const SATZART K09Satzart = {"K09", 0,  33, 33,(const int *) &k04_ident, "Kostenstellen-Statistik und Kostenstellennachweis (nicht-bettenf. HK)", &LKFKKCheckPersonalOhneKostenK09, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{GEN_ABTFC,					TYP_NUM,	14,  8, &LKFKKCheckK09_AbtFCFalsch, 0, "ABTFC"},
	{K09_AMBULANTE_PATIENTEN,	TYP_NUM,	22,  6, &LKFKKCheckAmbPatFalsch, 0, "AMBULANTE PATIENTEN/INNEN"},
	{K09_FREQ_AMB_PAT,			TYP_NUM,	28,  8, &LKFKKCheckFreqAmbPatFalsch2006, 0, "FREQUENZEN AMB. PAT"},
	{K09_FREQ_STAT_PAT,			TYP_NUM,	36,  8, &LKFKKCheckFreqStatPatFalsch, 0, "FREQUENZEN STAT. PAT"},
	{K09_FREQ_STAT_PAT_ANDKH,	TYP_NUM,	44,  8, &LKFKKCheckFreqStatPatAndKAFalsch, 0, "FREQUENZEN STAT. PAT. AND. KH"},
	{K08_NETTOGRUNDRISSFLAECHE,	TYP_NUM,	52,  6, &LKFKKCheckK08NettogrundrissFehlt, 0, "NETTOGRUNDRISSFLAECHE"},
	{K08_MLV1_1_VZEQ,			TYP_FLOAT,	58,  9, &LKFKKCheckK09ArztAquFalsch2005, 0, "ARZTE/INNEN VOLLZEITAEQU. (MLV 1-1)"},
	{K08_MLV1_2_VZEQ,			TYP_FLOAT,	67,  9, &LKFKKCheckApoChemAquFalsch, 0, "APOTH./CHEM./PHYS. VOLLZ.AEQU. (MLV 1-2)"},
	{K08_MLV1_3_VZEQ,			TYP_FLOAT,	76,  9, &LKFKKCheckHebammenAquFalsch, 0, "HEBAMMEN VOLLZEITAEQU. (MLV 1-3)"},
	{K08_MLV1_4_VZEQ,			TYP_FLOAT,	85,  9, &LKFKKCheckGehoberDienstAquFalsch, 0, "GEHOB.DIENST PFLEGE VOLLZEITAEQU. (MLV 1-4)"},
	{K08_MLV1_5_VZEQ,			TYP_FLOAT,	94,  9, &LKFKKCheckMedTechnDienstAquFehlt /* V9.1 */, 0, "GEHOB.MED-TECHN. DIENSTE/FACHD./MASS VOLLZ.AEQU (MLV 1-5)"},
	{K08_MLV1_6_VZEQ,			TYP_FLOAT,   103,	 9, &LKFKKCheckPflegeAquFalsch, 0, "PFLEGEHILFE UND SANI-HILFSD. VOLLZ.AEQU (MLV 1-6)"},
	{K08_MLV1_7_VZEQ,			TYP_FLOAT,   112,	 9, &LKFKKCheckVerwKanzleiAquFalsch, 0, "VERW./KANZLEIPERS. VOLLZEITAEQU. (MLV 1-7)"},
	{K08_MLV1_8_VZEQ,			TYP_FLOAT,   121,  9, &LKFKKCheckBetriebspersAquFalsch, 0, "BETRIEBSPERSONAL VOLLZEITAEQU. (MLV 1-8)"},
	{K08_MLV1_9_VZEQ,			TYP_FLOAT,   130,  9, &LKFKKCheckSonstPersAquFalsch, 0, "SONST. PERSONAL VOLLZEITAEQU. (MLV 1-9)"},
	{K08_KOAGR01,				TYP_NUM_NEG1000,   139, 10, &LKFKKCheckPersonalKostenFalsch, 0, "PERSONALKOSTEN (KOAGR01)"},
	{K08_KOAGR02,				TYP_NUM_NEG1000,   149, 10, &LKFKKCheckKostMedGueterFalsch, 0, "KOSTEN MED.GEBR/VERBR.GUETER (KOAGR02)"},
	{K08_KOAGR03,				TYP_NUM_NEG1000,   159, 10, &LKFKKCheckKostNichtMedGueterFalsch, 0, "KOSTEN NICHTMED.GEBR/VERBR.GUETER (KOAGR03)"},
	{K08_KOAGR04,				TYP_NUM_NEG1000,   169, 10, &LKFKKCheckKostenMedFremdLStFalsch, 0, "KOSTEN MED. FREMDLEISTUNGEN (KOAGR04)"},
	{K08_KOAGR05,				TYP_NUM_NEG1000,   179, 10, &LKFKKCheckKostenNichtMedFremdLStFalsch, 0, "KOSTEN NICHTMED. FREMDLEISTUNGEN (KOAGR05)"},
	{K08_KOAGR06,				TYP_NUM_NEG1000,   189, 10, &LKFKKCheckEnergieKostenFalsch, 0, "ENERGIEKOSTEN (KOAGR06)"},
	{K08_KOAGR07,				TYP_NUM_NEG1000,   199, 10, &LKFKKCheckAbgabenFalsch, 0, "ABGABEN/BEITRAEGE/GEBUEHREN SONST. (KOAGR07)"},
	{K08_KOAGR08,				TYP_NUM_NEG1000,   209, 10, &LKFKKCheckKalkAnlageKostenFalsch, 0, "KALK. ANLAGEKAPITALKOSTEN (KOAGR08)"},
	{K08_KOAGR11,				TYP_NUM_NEG1000,   219, 10, &LKFKKCheckKostMedEntsorgungFalsch, 0, "KOSTEN VORW.MED.BED. VER-/ENTSORGUNG (KOAGR11)"},
	{K08_KOAGR12,				TYP_NUM_NEG1000,   229, 10, &LKFKKCheckKostNMedEntsorgungFalsch, 0, "KOSTEN VORW.NMED.BED. VER-/ENTSORGUNG (KOAGR12)"},
	{K08_KOAGR13,				TYP_NUM_NEG1000,   239, 10, &LKFKKCheckKostVerwaltungFalsch, 0, "KOSTEN VERWALTUNG (KOAGR13)"},
	{K08_KOAGR14,				TYP_NUM_NEG1000,   249, 10, &LKFKKCheckKostSekundaerFalsch, 0, "ANDERE SEKUNDAERKOSTEN (KOAGR14)"},
	{K08_KOSTENMINDERUNGEN,		TYP_NUM_NEG,   259, 10, &LKFKKCheckKostenminderungFalsch, 0, "KOSTENMINDERUNGEN"},
	{K08_SUM_ABG_INNERBETR_LST,	TYP_NUM_NEG,   269, 10, &LKFKKCheckSummeLeistungenFalschK09_2006, 0, "SUMME ABG. INNERBETR. LEISTUNGEN"},
	{K08_UNTER_UEBERDECKUNG,	TYP_NUM_NEG,   279, 10, &LKFKKCheckUnterUeberdeckungFalsch, 0, "UNTER- ODER UEBERDECKUNG"},
	{K08_ENDKOSTEN,				TYP_NUM_NEG,   289, 10, &LKFKKCheckEndkostenK09Falsch, 0, "ENDKOSTEN DER KOSTENSTELLE"}
}};
#endif

const SATZART K09Satzart2017 = {"K09", 0,  34, 34, (const int *) &k04_ident, "Kostenstellen-Statistik und Kostenstellennachweis (nicht-bettenf. HK)", &LKFKKCheckPersonalOhneKostenK09, {
    {GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
    {GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
    {GEN_ABTFC,					TYP_NUM,	14,  8, &LKFKKCheckK09_AbtFCFalsch, 0, "ABTFC"},
    {K09_AMBPLAETZE,            TYP_NUM,    22,  6, &LKFKKCheckK09AmbBetreuung, 0, "AMBULANTE BETREUUNGSPLAETZE"},
    {K09_AMBULANTE_PATIENTEN,	TYP_NUM,	28,  6, &LKFKKCheckAmbPatFalsch, 0, "AMBULANTE PATIENTEN/INNEN"},
    {K09_FREQ_AMB_PAT,			TYP_NUM,	34,  8, &LKFKKCheckFreqAmbPatFalsch2006, 0, "FREQUENZEN AMB. PAT"},
    {K09_FREQ_STAT_PAT,			TYP_NUM,	42,  8, &LKFKKCheckFreqStatPatFalsch, 0, "FREQUENZEN STAT. PAT"},
    {K09_FREQ_STAT_PAT_ANDKH,	TYP_NUM,	50,  8, &LKFKKCheckFreqStatPatAndKAFalsch, 0, "FREQUENZEN STAT. PAT. AND. KH"},
    {K08_NETTOGRUNDRISSFLAECHE,	TYP_NUM,	58,  6, &LKFKKCheckK08NettogrundrissFehlt, 0, "NETTOGRUNDRISSFLAECHE"},
    {K08_MLV1_1_VZEQ,			TYP_FLOAT,	64,  9, &LKFKKCheckK09ArztAquFalsch2005, 0, "ARZTE/INNEN VOLLZEITAEQU. (MLV 1-1)"},
    {K08_MLV1_2_VZEQ,			TYP_FLOAT,	73,  9, &LKFKKCheckApoChemAquFalsch, 0, "APOTH./CHEM./PHYS. VOLLZ.AEQU. (MLV 1-2)"},
    {K08_MLV1_3_VZEQ,			TYP_FLOAT,	82,  9, &LKFKKCheckHebammenAquFalsch, 0, "HEBAMMEN VOLLZEITAEQU. (MLV 1-3)"},
    {K08_MLV1_4_VZEQ,			TYP_FLOAT,	91,  9, &LKFKKCheckGehoberDienstAquFalsch, 0, "GEHOB.DIENST PFLEGE VOLLZEITAEQU. (MLV 1-4)"},
    {K08_MLV1_5_VZEQ,			TYP_FLOAT,	100,  9, &LKFKKCheckMedTechnDienstAquFehlt /* V9.1 */, 0, "GEHOB.MED-TECHN. DIENSTE/FACHD./MASS VOLLZ.AEQU (MLV 1-5)"},
    {K08_MLV1_6_VZEQ,			TYP_FLOAT,   109,	 9, &LKFKKCheckPflegeAquFalsch, 0, "PFLEGEHILFE UND SANI-HILFSD. VOLLZ.AEQU (MLV 1-6)"},
    {K08_MLV1_7_VZEQ,			TYP_FLOAT,   118,	 9, &LKFKKCheckVerwKanzleiAquFalsch, 0, "VERW./KANZLEIPERS. VOLLZEITAEQU. (MLV 1-7)"},
    {K08_MLV1_8_VZEQ,			TYP_FLOAT,   127,  9, &LKFKKCheckBetriebspersAquFalsch, 0, "BETRIEBSPERSONAL VOLLZEITAEQU. (MLV 1-8)"},
    {K08_MLV1_9_VZEQ,			TYP_FLOAT,   136,  9, &LKFKKCheckSonstPersAquFalsch, 0, "SONST. PERSONAL VOLLZEITAEQU. (MLV 1-9)"},
    {K08_KOAGR01,				TYP_NUM_NEG1000,   145, 10, &LKFKKCheckPersonalKostenFalsch, 0, "PERSONALKOSTEN (KOAGR01)"},
    {K08_KOAGR02,				TYP_NUM_NEG1000,   155, 10, &LKFKKCheckKostMedGueterFalsch, 0, "KOSTEN MED.GEBR/VERBR.GUETER (KOAGR02)"},
    {K08_KOAGR03,				TYP_NUM_NEG1000,   165, 10, &LKFKKCheckKostNichtMedGueterFalsch, 0, "KOSTEN NICHTMED.GEBR/VERBR.GUETER (KOAGR03)"},
    {K08_KOAGR04,				TYP_NUM_NEG1000,   175, 10, &LKFKKCheckKostenMedFremdLStFalsch, 0, "KOSTEN MED. FREMDLEISTUNGEN (KOAGR04)"},
    {K08_KOAGR05,				TYP_NUM_NEG1000,   185, 10, &LKFKKCheckKostenNichtMedFremdLStFalsch, 0, "KOSTEN NICHTMED. FREMDLEISTUNGEN (KOAGR05)"},
    {K08_KOAGR06,				TYP_NUM_NEG1000,   195, 10, &LKFKKCheckEnergieKostenFalsch, 0, "ENERGIEKOSTEN (KOAGR06)"},
    {K08_KOAGR07,				TYP_NUM_NEG1000,   205, 10, &LKFKKCheckAbgabenFalsch, 0, "ABGABEN/BEITRAEGE/GEBUEHREN SONST. (KOAGR07)"},
    {K08_KOAGR08,				TYP_NUM_NEG1000,   215, 10, &LKFKKCheckKalkAnlageKostenFalsch, 0, "KALK. ANLAGEKAPITALKOSTEN (KOAGR08)"},
    {K08_KOAGR11,				TYP_NUM_NEG1000,   225, 10, &LKFKKCheckKostMedEntsorgungFalsch, 0, "KOSTEN VORW.MED.BED. VER-/ENTSORGUNG (KOAGR11)"},
    {K08_KOAGR12,				TYP_NUM_NEG1000,   235, 10, &LKFKKCheckKostNMedEntsorgungFalsch, 0, "KOSTEN VORW.NMED.BED. VER-/ENTSORGUNG (KOAGR12)"},
    {K08_KOAGR13,				TYP_NUM_NEG1000,   245, 10, &LKFKKCheckKostVerwaltungFalsch, 0, "KOSTEN VERWALTUNG (KOAGR13)"},
    {K08_KOAGR14,				TYP_NUM_NEG1000,   255, 10, &LKFKKCheckKostSekundaerFalsch, 0, "ANDERE SEKUNDAERKOSTEN (KOAGR14)"},
    {K08_KOSTENMINDERUNGEN,		TYP_NUM_NEG,   265, 10, &LKFKKCheckKostenminderungFalsch, 0, "KOSTENMINDERUNGEN"},
    {K08_SUM_ABG_INNERBETR_LST,	TYP_NUM_NEG,   275, 10, &LKFKKCheckSummeLeistungenFalschK09_2006, 0, "SUMME ABG. INNERBETR. LEISTUNGEN"},
    {K08_UNTER_UEBERDECKUNG,	TYP_NUM_NEG,   285, 10, &LKFKKCheckUnterUeberdeckungFalsch, 0, "UNTER- ODER UEBERDECKUNG"},
    {K08_ENDKOSTEN,				TYP_NUM_NEG,   295, 10, &LKFKKCheckEndkostenK09Falsch, 0, "ENDKOSTEN DER KOSTENSTELLE"}
}};


/*********************************************************************************************
** Satzart K10                                                                              **
*********************************************************************************************/

const SATZART K10Satzart = {"K10", 0,  21, 21,(const int *) &k04_ident, "Kostenstellen-Statistik und Kostenstellennachweis (Neben- und Hilfskostenstellen)", &LKFKKCheckPersonalOhneKostenK10_2008, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{GEN_ABTFC,					TYP_NUM,	14,  8, &LKFKKCheckK10_AbtFCFalsch, 0, "ABTFC"},
	{K08_NETTOGRUNDRISSFLAECHE,	TYP_NUM,	22,  6, &LKFKKCheckK08NettogrundrissFalsch, 0, "NETTOGRUNDRISSFLAECHE"},
	{K10_PERS_INSG_VZEQ,		TYP_FLOAT,	28,  9, &LKFKKCheckPersInsgAquFalsch, 0, "PERSONAL INSG. VOLLZEITEQUIVALENT"},
	{K08_KOAGR01,				TYP_NUM_NEG1000,    37, 10, &LKFKKCheckPersonalKostenFalsch, 0, "PERSONALKOSTEN (KOAGR01)"},
	{K08_KOAGR02,				TYP_NUM_NEG1000,    47, 10, &LKFKKCheckKostMedGueterFalsch, 0, "KOSTEN MED.GEBR/VERBR.GUETER (KOAGR02)"},
	{K08_KOAGR03,				TYP_NUM_NEG1000,    57, 10, &LKFKKCheckKostNichtMedGueterFalsch, 0, "KOSTEN NICHTMED.GEBR/VERBR.GUETER (KOAGR03)"},
	{K08_KOAGR04,				TYP_NUM_NEG1000,    67, 10, &LKFKKCheckKostenMedFremdLStFalsch, 0, "KOSTEN MED. FREMDLEISTUNGEN (KOAGR04)"},
	{K08_KOAGR05,				TYP_NUM_NEG1000,    77, 10, &LKFKKCheckKostenNichtMedFremdLStFalsch, 0, "KOSTEN NICHTMED. FREMDLEISTUNGEN (KOAGR05)"},
	{K08_KOAGR06,				TYP_NUM_NEG1000,    87, 10, &LKFKKCheckEnergieKostenFalsch, 0, "ENERGIEKOSTEN (KOAGR06)"},
	{K08_KOAGR07,				TYP_NUM_NEG1000,    97, 10, &LKFKKCheckAbgabenFalsch, 0, "ABGABEN/BEITRAEGE/GEBUEHREN SONST. (KOAGR07)"},
	{K08_KOAGR08,				TYP_NUM_NEG1000,   107, 10, &LKFKKCheckKalkAnlageKostenFalsch, 0, "KALK. ANLAGEKAPITALKOSTEN (KOAGR08)"},
	{K08_KOAGR11,				TYP_NUM_NEG1000,   117, 10, &LKFKKCheckKostMedEntsorgungFalsch, 0, "KOSTEN VORW.MED.BED. VER-/ENTSORGUNG (KOAGR11)"},
	{K08_KOAGR12,				TYP_NUM_NEG1000,   127, 10, &LKFKKCheckKostNMedEntsorgungFalsch, 0, "KOSTEN VORW.NMED.BED. VER-/ENTSORGUNG (KOAGR12)"},
	{K08_KOAGR13,				TYP_NUM_NEG1000,   137, 10, &LKFKKCheckKostVerwaltungFalsch, 0, "KOSTEN VERWALTUNG (KOAGR13)"},
	{K08_KOAGR14,				TYP_NUM_NEG1000,   147, 10, &LKFKKCheckKostSekundaerFalsch, 0, "ANDERE SEKUNDAERKOSTEN (KOAGR14)"},
	{K08_KOSTENMINDERUNGEN,		TYP_NUM_NEG,   157, 10, &LKFKKCheckKostenminderungFalsch, 0, "KOSTENMINDERUNGEN"},
	{K08_SUM_ABG_INNERBETR_LST,	TYP_NUM_NEG,   167, 10, &LKFKKCheckSummeLeistungenFalsch, 0, "SUMME ABG. INNERBETR. LEISTUNGEN"},
	{K08_UNTER_UEBERDECKUNG,	TYP_NUM_NEG,   177, 10, &LKFKKCheckUnterUeberdeckungFalsch, 0, "UNTER- ODER UEBERDECKUNG"},
	{K08_ENDKOSTEN,				TYP_NUM_NEG,   187, 10, &LKFKKCheckEndkostenFalschK10, 0, "ENDKOSTEN DER KOSTENSTELLE"}
}};

/*********************************************************************************************
** Satzart K11                                                                              **
*********************************************************************************************/

static int k11_check_sum_koagr (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext, unsigned int nType)
{
    int fmt;
	int nFeldWert, nFeldSum, nCount, i, nAdd;
	char sBlattNummer[6];
	const SATZART_INFO *pSatzart12;
	const SATZART_FELD *pKosten12, *pBlatt12;
	nFeldSum = 0;
	if (Satzart_GetValueInt (ds, len, pFeld, &nFeldWert)) return 0;

	nFeldSum = 0;
	pSatzart12 = pCheckContext->pKKContext->ppKKSatzarten[11];
	pKosten12 = pSatzart12->ppRef[K12_KOSTEN];
	pBlatt12 = pSatzart12->ppRef[K12_BLATTNUMMER];

	nCount = (int) pCheckContext->pKKContext->pSatzartCount[11]; /* Anzahl Satzart-12-Records */

    fmt = (pCheckContext->pContext->modelljahr >= 2017);
    
	for (i = 0; i < nCount; i++)
	{
        if (fmt) {
            ds = (const char *) pCheckContext->pKKContext->pppExpandedLines[11][i];
            len = LKF_LEN_FOR_EXPANDEDLINE;
        } else {
            ds = pCheckContext->pKKContext->pppSatzartRecords[11][i];
            len = pCheckContext->pKKContext->ppSatzartRecordLen[11][i];
        }
        Satzart_GetValueString (ds, len, pBlatt12, sBlattNummer, 6);
        nAdd = 0;
		switch (nType)
		{
			case 1:
				if (!memcmp (sBlattNummer, "01", 2)) nAdd = 1;
				break;
			case 2:
				if (!memcmp (sBlattNummer, "02", 2)) nAdd = 1;
				break;
			case 3:
				if (!memcmp (sBlattNummer, "03", 2)) nAdd = 1;
				break;
			case 4:
				if (!memcmp (sBlattNummer, "04", 2)) nAdd = 1;
				break;
			case 5:
				if (!memcmp (sBlattNummer, "05", 2)) nAdd = 1;
				break;
			case 6:
				if (!memcmp (sBlattNummer, "06", 2)) nAdd = 1;
				break;
			case 7:
				if (!memcmp (sBlattNummer, "07", 2)) nAdd = 1;
				break;
			case 8:
				if (!memcmp (sBlattNummer, "08", 2)) nAdd = 1;
				break;
			case 99:
				if (sBlattNummer[0] == '0' && sBlattNummer[1] >= '1' && sBlattNummer[1] <= '8') nAdd = 1; /* V9.4 BUGFIX [1] statt [8] */
				break;
			default:
				nAdd = 0; break;
		}

		if (nAdd) 
		{
            if (Satzart_GetValueInt (ds, len, pKosten12, &nAdd) == LKF_FIELD_ERROR) return 0;
			nFeldSum += nAdd;
		}
	}

	if (nFeldWert > nFeldSum + 500 || nFeldSum > nFeldWert + 500) 
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", nFeldWert, nFeldSum);	
		return 1;
	}
	else return 0;
}

static int k11_check_sum_koagr01 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_sum_koagr (ds, len, pFeld, pCheck, pCheckContext, 1);
}

static int k11_check_sum_koagr02 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_sum_koagr (ds, len, pFeld, pCheck, pCheckContext, 2);
}

static int k11_check_sum_koagr03 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_sum_koagr (ds, len, pFeld, pCheck, pCheckContext, 3);
}

static int k11_check_sum_koagr04 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_sum_koagr (ds, len, pFeld, pCheck, pCheckContext, 4);
}

static int k11_check_sum_koagr05 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_sum_koagr (ds, len, pFeld, pCheck, pCheckContext, 5);
}

static int k11_check_sum_koagr06 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_sum_koagr (ds, len, pFeld, pCheck, pCheckContext, 6);
}

static int k11_check_sum_koagr07 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_sum_koagr (ds, len, pFeld, pCheck, pCheckContext, 7);
}

static int k11_check_sum_koagr08 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_sum_koagr (ds, len, pFeld, pCheck, pCheckContext, 8);
}

static int k11_check_sum_primkost (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_sum_koagr (ds, len, pFeld, pCheck, pCheckContext, 99);
}

static int k11_check_sum_kostmind (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nFeldWert, nSumK13, nCur;
	unsigned int count, i;
	LKF_KK_CONTEXT *pKKContext;
    const LKF_EXPANDED_LINE **ppK;
	if (Satzart_GetValueInt (ds, len, pFeld, &nFeldWert)) return 0;

	pKKContext = pCheckContext->pKKContext;

	count = pKKContext->pSatzartCount[12];
	pFeld = pKKContext->ppKKSatzarten[12]->ppRef[K13_KOSTENMINDERUNGEN];

	nSumK13 = 0;
    
    if (pCheckContext->pContext->modelljahr >= 2017) {
        ppK = pCheckContext->pKKContext->pppExpandedLines[12];
        for (i = 0; i < count; i++)
        {
            if (Satzart_GetValueIntExp (ppK[i], pFeld, &nCur) == LKF_FIELD_ERROR) return 0;
            nSumK13 += nCur;
        }
    }
    else {
        for (i = 0; i < count; i++)
        {
            if (Satzart_GetValueInt (pKKContext->pppSatzartRecords[12][i], pKKContext->ppSatzartRecordLen[12][i], pFeld, &nCur) == LKF_FIELD_ERROR) return 0;
            nSumK13 += nCur;
        }
    }

	if (nSumK13 > nFeldWert + 500 || nFeldWert > nSumK13 + 500)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", nFeldWert, nSumK13);
		return 1;
	}
	return 0;
}

static int k11_check_koagr_double (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext, unsigned int nK08Feld)
{
	LKF_KK_CONTEXT *pKKContext;
	const SATZART_FELD *pK08Feld;
	unsigned int i, nSatzart;
	double v, s, curval;
	Satzart_GetValueFloat (ds, len, pFeld, &v, pCheckContext->pContext->modelljahr);

	s = 0;
	pKKContext = pCheckContext->pKKContext;

	for (nSatzart = 7; nSatzart < 10; nSatzart++)
	{

		pK08Feld = pKKContext->ppKKSatzarten[nSatzart]->ppRef[nK08Feld];

        if (pCheckContext->pContext->modelljahr >= 2017) {
            const LKF_EXPANDED_LINE **ppKK = pKKContext->pppExpandedLines[nSatzart];
            for (i = 0; i < pKKContext->pSatzartCount[nSatzart]; i++)
            {
                if (Satzart_GetValueFloatExp (ppKK[i], pK08Feld, &curval, pCheckContext->pContext->modelljahr)) return 0;
                s += curval;
            }
        }
        else {
            for (i = 0; i < pKKContext->pSatzartCount[nSatzart]; i++)
            {
                if (Satzart_GetValueFloat (pKKContext->pppSatzartRecords[nSatzart][i], pKKContext->ppSatzartRecordLen[nSatzart][i], pK08Feld, &curval, pCheckContext->pContext->modelljahr)) return 0;
                s += curval;
            }
        }
	}

	if (v > s + 500 || s > v + 500) 
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", (int) v, (int) s);	
		return 1;
	}
	else return 0;
}

static int k11_check_koagr01 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_koagr_double (ds, len, pFeld, pCheck, pCheckContext, K08_KOAGR01);
}

static int k11_check_koagr02 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_koagr_double (ds, len, pFeld, pCheck, pCheckContext, K08_KOAGR02);
}

static int k11_check_koagr03 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_koagr_double (ds, len, pFeld, pCheck, pCheckContext, K08_KOAGR03);
}

static int k11_check_koagr04 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_koagr_double (ds, len, pFeld, pCheck, pCheckContext, K08_KOAGR04);
}

static int k11_check_koagr05 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_koagr_double (ds, len, pFeld, pCheck, pCheckContext, K08_KOAGR05);
}

static int k11_check_koagr06 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_koagr_double (ds, len, pFeld, pCheck, pCheckContext, K08_KOAGR06);
}

static int k11_check_koagr07 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_koagr_double (ds, len, pFeld, pCheck, pCheckContext, K08_KOAGR07);
}

static int k11_check_koagr08 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_koagr_double (ds, len, pFeld, pCheck, pCheckContext, K08_KOAGR08);
}

static int k11_check_kostminddiff (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_koagr_double (ds, len, pFeld, pCheck, pCheckContext, K08_KOSTENMINDERUNGEN);
}

static int k11_check_endkost_diff (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return k11_check_koagr_double (ds, len, pFeld, pCheck, pCheckContext, K08_ENDKOSTEN);
}

static int k11_check_primkost_double (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	LKF_KK_CONTEXT *pKKContext;
	const SATZART_FELD *pK08Feld[8];
    const LKF_EXPANDED_LINE **ppK;
	int aFeldIndices[8] = {K08_KOAGR01, K08_KOAGR02, K08_KOAGR03, K08_KOAGR04, K08_KOAGR05, K08_KOAGR06, K08_KOAGR07, K08_KOAGR08}; 
	unsigned int j, i, nSatzart;
	double v, s, curval;
	Satzart_GetValueFloat (ds, len, pFeld, &v, pCheckContext->pContext->modelljahr);

	s = 0;
	pKKContext = pCheckContext->pKKContext;

	for (nSatzart = 7; nSatzart < 10; nSatzart++)
	{

		for	(j = 0; j < 8; j++) pK08Feld[j] = pKKContext->ppKKSatzarten[nSatzart]->ppRef[aFeldIndices[j]];

        ppK = (pCheckContext->pContext->modelljahr >= 2017) ? pKKContext->pppExpandedLines[nSatzart] : 0;
        
		for (i = 0; i < pKKContext->pSatzartCount[nSatzart]; i++)
		{
			for (j = 0; j < 8; j++) {
                
                if (ppK) {
                    if (Satzart_GetValueFloatExp(ppK[i], pK08Feld[j], &curval, pCheckContext->pContext->modelljahr)) {
                        return 0;
                    }
                }
                else if (Satzart_GetValueFloat (pKKContext->pppSatzartRecords[nSatzart][i], pKKContext->ppSatzartRecordLen[nSatzart][i], pK08Feld[j], &curval, pCheckContext->pContext->modelljahr))
				{
					return 0;
				}
				s += curval;
			}
		}
	}

	if (v > s + 500 || s > v + 500) 
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d/%d", (int) v, (int) s);	
		return 1;
	}
	else return 0;
}

static int k11_check_unter_ueber (LKF_CHECK_CONTEXT *pCheckContext, LKF_KK_CONTEXT *pKKContext)
{
	if (pKKContext->lHasUnterUeber < 0)
	{
		unsigned int i, count;
		unsigned int nSatzart;
		int nVal;
		const SATZART_FELD *pFeld;

		pKKContext->lHasUnterUeber = 0;

		for (nSatzart = 7; pKKContext->lHasUnterUeber != 1 && nSatzart < 10; nSatzart++)
		{
			pFeld = pKKContext->ppKKSatzarten[nSatzart]->ppRef[K08_UNTER_UEBERDECKUNG];
			count = pKKContext->pSatzartCount[nSatzart];

            if (pCheckContext->pContext->modelljahr >= 2017) {
                const LKF_EXPANDED_LINE **ppK = pKKContext->pppExpandedLines[nSatzart];
                for (i = 0; pKKContext->lHasUnterUeber != 1 && i < count; i++)
                {
                    if (Satzart_GetValueIntExp (ppK[i], pFeld, &nVal) == LKF_FIELD_ERROR) pKKContext->lHasUnterUeber = 2;
                    else if (nVal) pKKContext->lHasUnterUeber = 1;
                }
            }
            else {
                for (i = 0; pKKContext->lHasUnterUeber != 1 && i < count; i++)
                {
                    if (Satzart_GetValueInt (pKKContext->pppSatzartRecords[nSatzart][i], pKKContext->ppSatzartRecordLen[nSatzart][i], pFeld, &nVal) == LKF_FIELD_ERROR) pKKContext->lHasUnterUeber = 2;
                    else if (nVal) pKKContext->lHasUnterUeber = 1;
                }
            }
		}
	}
	return pKKContext->lHasUnterUeber;
}

static int k11_check_exists_unterueber (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* EK48, EK49, EK6V */
	if (k11_check_unter_ueber (pCheckContext, pCheckContext->pKKContext) != 1) return 0;
	if (Satzart_IsEmpty (ds, len, pFeld)) return 1;
	else return 0;
}


static int k11_check_patkost_endkost (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nStatPat, nAmbPat, nNebenHK, nEndKosten;

	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[10]->ppRef[K11_ENDK_STAT_PATVERS], &nStatPat)) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[10]->ppRef[K11_ENDK_AMB_PATVERS], &nAmbPat)) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[10]->ppRef[K11_ENDK_NEBENKOSTENST], &nNebenHK)) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[10]->ppRef[K08_ENDKOSTEN], &nEndKosten)) return 0;

	if (k11_check_unter_ueber (pCheckContext, pCheckContext->pKKContext) != 1) return 0;

	if (nStatPat + nAmbPat + nNebenHK + 500 < nEndKosten ||
		nStatPat + nAmbPat + nNebenHK > nEndKosten + 500) 
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%d", nEndKosten);	
		return 1;
	}
	return 0;
}


static int k11_check_kalkabschr (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	LKF_KK_CONTEXT *pKKContext;
	int nKalkAbschr, nKalkAbschrRW0, nKalkAbschrWeg;

	pKKContext = pCheckContext->pKKContext;

	if (Satzart_GetValueInt (ds, len, pKKContext->ppKKSatzarten[10]->ppRef[K11_KALK_ABSCHREIBUNGEN], &nKalkAbschr) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pKKContext->ppKKSatzarten[10]->ppRef[K11_KALK_ABSCHR_RESTW0], &nKalkAbschrRW0) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pKKContext->ppKKSatzarten[10]->ppRef[K11_KALK_ABSCHR_AUSG_ANL], &nKalkAbschrWeg) == LKF_FIELD_ERROR) return 0;

	if (nKalkAbschrRW0 + nKalkAbschrWeg > nKalkAbschr) return 1;
	else return 0;
}


const LKF_SATZART_ERRORCHECK
	LKFKKCheckKOAGR01SummenblattDiff =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_sum_koagr01, &LKFKKErrorKOAGR01SummenblattDiff, 0, 0},
	LKFKKCheckKOAGR02SummenblattDiff =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_sum_koagr02, &LKFKKErrorKOAGR02SummenblattDiff, 0, 0},
	LKFKKCheckKOAGR03SummenblattDiff =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_sum_koagr03, &LKFKKErrorKOAGR03SummenblattDiff, 0, 0},
	LKFKKCheckKOAGR04SummenblattDiff =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_sum_koagr04, &LKFKKErrorKOAGR04SummenblattDiff, 0, 0},
	LKFKKCheckKOAGR05SummenblattDiff =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_sum_koagr05, &LKFKKErrorKOAGR05SummenblattDiff, 0, 0},
	LKFKKCheckKOAGR06SummenblattDiff =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_sum_koagr06, &LKFKKErrorKOAGR06SummenblattDiff, 0, 0},
	LKFKKCheckKOAGR07SummenblattDiff =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_sum_koagr07, &LKFKKErrorKOAGR07SummenblattDiff, 0, 0},
	LKFKKCheckKOAGR08SummenblattDiff =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_sum_koagr08, &LKFKKErrorKOAGR08SummenblattDiff, 0, 0},
	LKFKKCheckPrimKostSummenblattPrimDetDiff = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_sum_primkost, &LKFKKErrorPrimKostSummenblattPrimDetDiff, 0, 0},
	LKFKKCheckKostenmindSummenblattKostDetDiff = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_sum_kostmind, &LKFKKErrorKostenmindSummenblattKostDetDiff, 0, 0},
	LKFKKCheckKOAGR01KostDiff =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_koagr01, &LKFKKErrorKOAGR01KostDiff, &LKFKKCheckKOAGR01SummenblattDiff, &LKFKKCheckKOAGR01SummenblattDiff},
	LKFKKCheckKOAGR02KostDiff =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_koagr02, &LKFKKErrorKOAGR02KostDiff, &LKFKKCheckKOAGR02SummenblattDiff, &LKFKKCheckKOAGR02SummenblattDiff},
	LKFKKCheckKOAGR03KostDiff =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_koagr03, &LKFKKErrorKOAGR03KostDiff, &LKFKKCheckKOAGR03SummenblattDiff, &LKFKKCheckKOAGR03SummenblattDiff},
	LKFKKCheckKOAGR04KostDiff =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_koagr04, &LKFKKErrorKOAGR04KostDiff, &LKFKKCheckKOAGR04SummenblattDiff, &LKFKKCheckKOAGR04SummenblattDiff},
	LKFKKCheckKOAGR05KostDiff =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_koagr05, &LKFKKErrorKOAGR05KostDiff, &LKFKKCheckKOAGR05SummenblattDiff, &LKFKKCheckKOAGR05SummenblattDiff},
	LKFKKCheckKOAGR06KostDiff =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_koagr06, &LKFKKErrorKOAGR06KostDiff, &LKFKKCheckKOAGR06SummenblattDiff, &LKFKKCheckKOAGR06SummenblattDiff},
	LKFKKCheckKOAGR07KostDiff =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_koagr07, &LKFKKErrorKOAGR07KostDiff, &LKFKKCheckKOAGR07SummenblattDiff, &LKFKKCheckKOAGR07SummenblattDiff},
	LKFKKCheckKOAGR08KostDiff =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_koagr08, &LKFKKErrorKOAGR08KostDiff, &LKFKKCheckKOAGR08SummenblattDiff, &LKFKKCheckKOAGR08SummenblattDiff},
	LKFKKCheckKostenmindDiff =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_kostminddiff, &LKFKKErrorKostenmindDiff, &LKFKKCheckKostenmindSummenblattKostDetDiff, &LKFKKCheckKostenmindSummenblattKostDetDiff},
	LKFKKCheckEndkostenDiff =					{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_endkost_diff, &LKFKKErrorEndkostenDiff, 0, 0},
	LKFKKCheckPrimaerkostenFalsch =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_primkost_double, &LKFKKErrorPrimaerkostenFalsch, &LKFKKCheckPrimKostSummenblattPrimDetDiff, &LKFKKCheckPrimKostSummenblattPrimDetDiff},
	LKFKKCheckK11_KOAGR01_Falsch =				{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorPersonalKostenFalsch, 0, &LKFKKCheckKOAGR01KostDiff},
	LKFKKCheckK11_KOAGR02_Falsch =				{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostMedGueterFalsch, 0, &LKFKKCheckKOAGR02KostDiff},
	LKFKKCheckK11_KOAGR03_Falsch =				{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostNichtMedGueterFalsch, 0, &LKFKKCheckKOAGR03KostDiff},
	LKFKKCheckK11_KOAGR04_Falsch =				{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostenMedFremdLStFalsch, 0, &LKFKKCheckKOAGR04KostDiff},
	LKFKKCheckK11_KOAGR05_Falsch =				{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostenNichtMedFremdLStFalsch, 0, &LKFKKCheckKOAGR05KostDiff},
	LKFKKCheckK11_KOAGR06_Falsch =				{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorEnergieKostenFalsch, 0, &LKFKKCheckKOAGR06KostDiff},
	LKFKKCheckK11_KOAGR07_Falsch =				{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorAbgabenFalsch, 0, &LKFKKCheckKOAGR07KostDiff},
	LKFKKCheckK11_KOAGR08_Falsch =				{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKalkAnlageKostenFalsch, 0, &LKFKKCheckKOAGR08KostDiff},
	LKFKKCheckPersonalKostenFehlt =				{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorPersonalKostenFehlt, 0, &LKFKKCheckK11_KOAGR01_Falsch},
	LKFKKCheckK11_KostMedVerbrauchFehlt =		{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_KostMedVerbrauchFehlt, 0, &LKFKKCheckK11_KOAGR02_Falsch},
	LKFKKCheckK11_KostNichtMedVerbrauchFehlt =	{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_KostNichtMedVerbrauchFehlt, 0, &LKFKKCheckK11_KOAGR03_Falsch},
	LKFKKCheckK11_KostMedFremdleistungenFehlt = {LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_KostMedFremdleistungenFehlt, 0, &LKFKKCheckK11_KOAGR04_Falsch},
	LKFKKCheckK11_KostNMedFremdleistungenFehlt ={LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_KostNMedFremdleistungenFehlt, 0, &LKFKKCheckK11_KOAGR05_Falsch},
	LKFKKCheckK11_EnergiekostenFehlt =			{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_EnergiekostenFehlt, 0, &LKFKKCheckK11_KOAGR06_Falsch},
	LKFKKCheckK11_AbgabenFehlt =				{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_AbgabenFehlt, 0, &LKFKKCheckK11_KOAGR07_Falsch},
	LKFKKCheckK11_KalkAnlagekapitalkostenFehlt ={LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_KalkAnlagekapitalkostenFehlt, 0, &LKFKKCheckK11_KOAGR08_Falsch},
	LKFKKCheckK11_SummePrimaerkostenFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_SummePrimaerkostenFalsch, 0, &LKFKKCheckPrimaerkostenFalsch},
	LKFKKCheckK11_SummePrimaerkostenFehlt =		{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_SummePrimaerkostenFehlt, 0, &LKFKKCheckK11_SummePrimaerkostenFalsch},
	LKFKKCheckK11_KostenmindFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_KostenmindFalsch, 0, &LKFKKCheckKostenmindDiff},
	LKFKKCheckK11_KostenmindFehlt =				{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_KostenmindFehlt, 0, &LKFKKCheckK11_KostenmindFalsch},
	LKFKKCheckK11_EndkostenKAFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_EndkostenKAFalsch, 0, &LKFKKCheckEndkostenDiff},
	LKFKKCheckK11_EndkostenKAFehlt =			{LKF_CHECKFUNC_EXISTS_NOT0 | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_EndkostenKAFehlt, 0, &LKFKKCheckK11_EndkostenKAFalsch},
	LKFKKCheckK11_SummeKalkAbschlFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_SummeKalkAbschlFalsch, 0, 0},
	LKFKKCheckK11_EndkostenAmbPatFehlt =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, &k11_check_exists_unterueber, &LKFKKErrorK11_EndkostenAmbPatFehlt, 0, 0},
	LKFKKCheckK11_EndkostenAmbPatUng =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_EndkostenAmbPatUng, 0, &LKFKKCheckK11_EndkostenAmbPatFehlt},
	LKFKKCheckK11_EndkostenStatPatFehlt =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, &k11_check_exists_unterueber, &LKFKKErrorK11_EndkostenStatPatFehlt, 0, 0},
	LKFKKCheckK11_EndkostenStatPatUng =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_EndkostenStatPatUng, 0, &LKFKKCheckK11_EndkostenStatPatFehlt},
	LKFKKCheckK11_PatKost_EndKost =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_patkost_endkost, &LKFErrorSummeKostenKrankenanstalt, 0, 0},
	LKFKKCheckK11_EndkostenNebenHKFehlt =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_exists_unterueber, &LKFKKErrorK11_EndkostenNebenHKFehlt, 0, &LKFKKCheckK11_PatKost_EndKost},
	LKFKKCheckK11_EndkostenNebenHKUng =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_EndkostenNebenHKUng, 0, &LKFKKCheckK11_EndkostenNebenHKFehlt},
	LKFKKCheckK11_KalkAbschrAnlageRest0Falsch2007 = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_KalkAbschrAnlageRest0Falsch2007, 0, 0},
	LKFKKCheckK11_KalkAbschrFalsch2007 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k11_check_kalkabschr, &LKFKKErrorK11_KalkAbschrFalsch2007, 0, 0},
	LKFKKCheckK11_KalkAbschrAusgeschAnlagenFalsch2007 = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_KalkAbschrAusgeschAnlagenFalsch2007, 0, &LKFKKCheckK11_KalkAbschrFalsch2007},
	LKFKKCheckK11_SummeKalkZinsenFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_SummeKalkZinsenFalsch, 0, 0},
	LKFKKCheckK11_SummeKalkMietenFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK11_SummeKalkMietenFalsch, 0, 0};

int k11_ident[] = {0,1,-1};

const SATZART K11Satzart = {"K11", 0,  21, 21, (const int *) &k11_ident, "Sammel-Kostennachweis Summenblatt", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K08_KOAGR01,				TYP_NUM,    14, 10, &LKFKKCheckPersonalKostenFehlt, 0, "PERSONALKOSTEN (KOAGR01)"},
	{K08_KOAGR02,				TYP_NUM,    24, 10, &LKFKKCheckK11_KostMedVerbrauchFehlt, 0, "KOSTEN MED.GEBR/VERBR.GUETER (KOAGR02)"},
	{K08_KOAGR03,				TYP_NUM,    34, 10, &LKFKKCheckK11_KostNichtMedVerbrauchFehlt, 0, "KOSTEN NICHTMED.GEBR/VERBR.GUETER (KOAGR03)"},
	{K08_KOAGR04,				TYP_NUM,    44, 10, &LKFKKCheckK11_KostMedFremdleistungenFehlt, 0, "KOSTEN MED. FREMDLEISTUNGEN (KOAGR04)"},
	{K08_KOAGR05,				TYP_NUM,    54, 10, &LKFKKCheckK11_KostNMedFremdleistungenFehlt, 0, "KOSTEN NICHTMED. FREMDLEISTUNGEN (KOAGR05)"},
	{K08_KOAGR06,				TYP_NUM,    64, 10, &LKFKKCheckK11_EnergiekostenFehlt, 0, "ENERGIEKOSTEN (KOAGR06)"},
	{K08_KOAGR07,				TYP_NUM,    74, 10, &LKFKKCheckK11_AbgabenFehlt, 0, "ABGABEN/BEITRAEGE/GEBUEHREN SONST. (KOAGR07)"},
	{K08_KOAGR08,				TYP_NUM,    84, 10, &LKFKKCheckK11_KalkAnlagekapitalkostenFehlt, 0, "KALK. ANLAGEKAPITALKOSTEN (KOAGR08)"},
	{K11_SUM_PRIMAERKOSTEN,		TYP_NUM,	94, 10, &LKFKKCheckK11_SummePrimaerkostenFehlt, 0, "SUMME PRIMAERKOSTEN"},
	{K08_KOSTENMINDERUNGEN,		TYP_NUM,   104, 10, &LKFKKCheckK11_KostenmindFehlt, 0, "KOSTENMINDERUNGEN"},
	{K08_ENDKOSTEN,				TYP_NUM,   114, 10, &LKFKKCheckK11_EndkostenKAFehlt, 0, "ENDKOSTEN DER KRANKENANSTALT"},
	{K11_KALK_ABSCHREIBUNGEN,	TYP_NUM,   124, 10, &LKFKKCheckK11_SummeKalkAbschlFalsch, 0, "SUMME KALK. ABSCHREIBUNGEN"},
	{K11_KALK_ABSCHR_RESTW0,	TYP_NUM,   134, 10, &LKFKKCheckK11_KalkAbschrAnlageRest0Falsch2007, 0, "SUMME KALK. ABSCHR. MIT RESTWERT 0"},
	{K11_KALK_ABSCHR_AUSG_ANL,	TYP_NUM,   144, 10, &LKFKKCheckK11_KalkAbschrAusgeschAnlagenFalsch2007, 0, "SUMME KALK. ABSCHR. AUSGESCH. ANLAGEN"},
	{K11_KALK_ZINSEN,			TYP_NUM,   154, 10, &LKFKKCheckK11_SummeKalkZinsenFalsch, 0, "SUMME KALK. ZINSEN"},
	{K11_KALK_MIETEN,			TYP_NUM,   164, 10, &LKFKKCheckK11_SummeKalkMietenFalsch, 0, "SUMME KALK. MIETEN"},
	{K11_ENDK_STAT_PATVERS,		TYP_NUM_NEG,   174, 10, &LKFKKCheckK11_EndkostenStatPatUng, 0, "ENDK. STAT. PATIENTENVERSORGUNG"},
	{K11_ENDK_AMB_PATVERS,		TYP_NUM_NEG,   184, 10, &LKFKKCheckK11_EndkostenAmbPatUng, 0, "ENDK. AMB. PATIENTENVERSORGUNG"},
	{K11_ENDK_NEBENKOSTENST,	TYP_NUM_NEG,   194, 10, &LKFKKCheckK11_EndkostenNebenHKUng, 0, "ENDK. NEBENKOSTENSTELLEN"}
}};

/*********************************************************************************************
** Satzart K12                                                                              **
*********************************************************************************************/

const LKF_SATZART_ERRORCHECK_STRINGLIST 
stringlist_K12BlattNummer = {12, {"01/11", "01/12", "01/13", "02", "03", "04", "05", "06", "07", "08/3", 
						  	      "08/5", "08/9"}};

typedef struct
{
	const char *sBlattNummer;
	unsigned int *ppMlvNummern;
} LKF_K12_BLATTNUMMERN;

static unsigned int	K12_Blatt01_11[] = {111, 112, 113, 114, 115, 116, 117, 118, 119, 0},
					K12_Blatt01_12[] = {121, 122, 123, 124, 125, 126, 127, 128, 129, 0},
					K12_Blatt01_13[] = {131, 132, 133, 134, 135, 136, 137, 138, 139, 0},
					K12_Blatt02[] =	   { 21,  22,  23,  24,  25,  26,  27,  28,  29, 30 , 31, 32, 33, 34, 35, 36, 37, 38, 39, 0},
					K12_Blatt03[] =	   { 41,  44,  45,  46,  47,  48,  49,  51,  52, 53, 54, 55, 56, 57, 58, 59, 0},
					K12_Blatt04[] =    { 61,  62,  63,  64,  69,   0},
					K12_Blatt05[] =	   { 72,  73,  74,  75,  76,  77,  78,  79,   0},
					K12_Blatt06[] =    { 71,   0},
                    K12_Blatt07[] =    { 81,  82,  83,  84,  85,  86,  87,  88,  89, 0}, /* V22.5: caused memory overflow */
					K12_Blatt08_3[] =  { 31,  32,  33,  34,  35,  36,  37,  38,  39, 0},
					K12_Blatt08_5[] =  { 51,  52,  53,  54,  55,  56,  57,  58,  59, 0},
					K12_Blatt08_9[] =  { 91,  92,  93,  94,  95,  96,  97,  98,  99, 0};

static LKF_K12_BLATTNUMMERN K12_Blatt[] = {
	{"01/11", K12_Blatt01_11}, {"01/12", K12_Blatt01_12}, {"01/13", K12_Blatt01_13},
	{"02", K12_Blatt02}, {"03", K12_Blatt03}, {"04", K12_Blatt04}, {"05", K12_Blatt05},
	{"06", K12_Blatt06}, {"07", K12_Blatt07}, {"08/3", K12_Blatt08_3}, {"08/5", K12_Blatt08_5},
	{"08/9", K12_Blatt08_9}, {0, 0}};

static int check_blattmlvkomb (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int i, j;
	char sBlattNummer[6];
	int mlv_nummer;
	Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppKKSatzarten[11]->ppRef[K12_BLATTNUMMER], sBlattNummer, 6);
	Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[11]->ppRef[K12_MLVNUMMER], &mlv_nummer);

	i = 0;
	while (K12_Blatt[i].sBlattNummer)
	{
		if (!strcmp (K12_Blatt[i].sBlattNummer, sBlattNummer))
		{
			j = 0;
			while (K12_Blatt[i].ppMlvNummern[j])
			{
				if (K12_Blatt[i].ppMlvNummern[j++] == (unsigned int) mlv_nummer) return 0;
			}
			return 1;
		}
		++i;
	}
	return 0;
}

static int check_mlvnummer (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int i, j;
	int mlv_nummer;
	Satzart_GetValueInt (ds, len, pFeld, &mlv_nummer);
	
	i = 0;
	while (K12_Blatt[i].sBlattNummer)
	{
		j = 0;
		while (K12_Blatt[i].ppMlvNummern[j])
		{
			if (K12_Blatt[i].ppMlvNummern[j++] == (unsigned int) mlv_nummer) return 0;
		}
		++i;
	}
	return 1;
}

static int k12_check_kostenohnepers (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sPersGruppenIndex[4];
    int lPersGruppenIndex;
	int lMlv, lKosten;
	unsigned int i, lK04Count, lK04Len;
	const char *sK04;
	const SATZART_FELD *pK04PersGruppe, *pK04Personal;
	double fPersonal;

	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[11]->ppRef[K12_MLVNUMMER], &lMlv)) return 0;
	if (lMlv < 111 || lMlv > 139) return 0;
	if (Satzart_GetValueInt (ds, len, pFeld, &lKosten) || lKosten <= 1000) return 0;

	lK04Count = pCheckContext->pKKContext->pSatzartCount[3];
	pK04PersGruppe = pCheckContext->pKKContext->ppKKSatzarten[3]->ppRef[K04_PERSONALGRUPPENINDEX];
	pK04Personal = pCheckContext->pKKContext->ppKKSatzarten[3]->ppRef[K04_VOLLZEITAEQUIVALENTE];
	
    if (pCheckContext->pContext->modelljahr >= 2017) {
        const LKF_EXPANDED_LINE **ppK = pCheckContext->pKKContext->pppExpandedLines[3];
        for (i = 0; i < lK04Count; i++)
        {
            Satzart_GetValueStringExp (ppK[i], pK04PersGruppe, sPersGruppenIndex, 4);
            lPersGruppenIndex = atoi (sPersGruppenIndex);
            if (lPersGruppenIndex == lMlv)
            {
                if (Satzart_GetValueFloatExp (ppK[i], pK04Personal, &fPersonal, pCheckContext->pContext->modelljahr) || fPersonal != 0) return 0;
            }
        }
    }
    else {
        for (i = 0; i < lK04Count; i++)
        {
            sK04 = pCheckContext->pKKContext->pppSatzartRecords[3][i];
            lK04Len = pCheckContext->pKKContext->ppSatzartRecordLen[3][i];
            
            Satzart_GetValueString (sK04, lK04Len, pK04PersGruppe, sPersGruppenIndex, 4);
            lPersGruppenIndex = atoi (sPersGruppenIndex);
            if (lPersGruppenIndex == lMlv)
            {
                if (Satzart_GetValueFloat (sK04, lK04Len, pK04Personal, &fPersonal, pCheckContext->pContext->modelljahr) || fPersonal != 0) return 0;
            }
        }
        
    }
    

	sprintf (pCheckContext->sErrorAdditionalInfo, "%3d: %d", lMlv, lKosten);
	return 1;
}

static int k12_check_kostenzeile (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nErgebnis, nAufwandFiBu, nNeutralerAufwand, nKalkKosten, nKosten;

	if (Satzart_GetValueInt (ds, len, pFeld, &nKosten) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[11]->ppRef[K12_NEUTRALER_AUFWAND], &nNeutralerAufwand) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[11]->ppRef[K12_KALK_KOSTEN], &nKalkKosten) == LKF_FIELD_ERROR) return 0;
	if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[11]->ppRef[K12_AUFWAND_FINANZBUCHF], &nAufwandFiBu) == LKF_FIELD_ERROR) return 0;

	nErgebnis = nAufwandFiBu - nNeutralerAufwand + nKalkKosten - nKosten;

	if (nErgebnis > 100 || nErgebnis < -100)
	{
		char sMlvNummer[4];
		Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppKKSatzarten[11]->ppRef[K12_MLVNUMMER], sMlvNummer, 4);
		sprintf (pCheckContext->sErrorAdditionalInfo, "MLV%3.3s", sMlvNummer);
		return 1;
	}
	return 0;
}


const LKF_SATZART_ERRORCHECK
	LKFKKCheckAufwandFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorAufwandFalsch, 0, 0},
	LKFKKCheckNeutralerAufwandFalsch =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorNeutralerAufwandFalsch, 0, 0},
	LKFKKCheckKalkKostenFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKalkKostenFalsch, 0, 0},
	LKFKKCheckBlattnummerFalsch = {LKF_CHECKFUNC_STRINGLIST | LKF_CHECK_NURFONDSKA, &stringlist_K12BlattNummer, &LKFKKErrorBlattnummerFalsch, 0, 0},
	LKFKKCheckBlattnummerFehlt =  {LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorBlattnummerFehlt, 0, &LKFKKCheckBlattnummerFalsch},
	LKFKKCheckKombMLVBlattFalsch ={LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_blattmlvkomb, &LKFKKErrorKombMLVBlattFalsch, 0, 0},
	LKFKKCheckMLVNummerFalsch =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_mlvnummer, &LKFKKErrorMLVNummerFalsch, 0, &LKFKKCheckKombMLVBlattFalsch},
	LKFKKCheckMLVNummerFehlt =    {LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorMLVNummerFehlt, 0, &LKFKKCheckMLVNummerFalsch},

	LKFKKCheckK12_KostenUngleichZeile = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k12_check_kostenzeile, &LKFKKErrorK12_KostenUngleichZeile, 0, 0},
	LKFKKCheckK12_KostenOhnePersonal2008 = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k12_check_kostenohnepers, &LKFKKErrorK12_KostenOhnePersonal, &LKFKKCheckK12_KostenUngleichZeile, &LKFKKCheckK12_KostenUngleichZeile},
	LKFKKCheckK12_KostenFalsch =  {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK12_KostenFalsch, 0, &LKFKKCheckK12_KostenOhnePersonal2008};

int k12_ident[] = {0,1,2,-1};

const SATZART K12Satzart = {"K12", 0,  8, 8, (const int *) &k12_ident, "Sammel-Kostennachweis Detailblaetter", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K12_BLATTNUMMER,			TYP_ALPHA,  14,  5, &LKFKKCheckBlattnummerFehlt, 0, "BLATTNUMMER"},
	{K12_MLVNUMMER,				TYP_NUM,	19,  3, &LKFKKCheckMLVNummerFehlt, 0, "MLV-NUMMER"},
	{K12_AUFWAND_FINANZBUCHF,	TYP_NUM,    22, 10, &LKFKKCheckAufwandFalsch, 0, "AUFWAND GEM. FINANZBUCHFUEHRUNG"},
	{K12_NEUTRALER_AUFWAND,		TYP_NUM,    32, 10, &LKFKKCheckNeutralerAufwandFalsch, 0, "NEUTRALER AUFWAND"},
	{K12_KALK_KOSTEN,			TYP_NUM,	42, 10, &LKFKKCheckKalkKostenFalsch, 0, "KALK. KOSTEN"},
	{K12_KOSTEN,				TYP_NUM,	52, 10, &LKFKKCheckK12_KostenFalsch, 0, "KOSTEN"}
}};

/*********************************************************************************************
** Satzart K13                                                                              **
*********************************************************************************************/

const LKF_SATZART_ERRORCHECK_STRINGLIST 
	stringlist_indexkostmind_2008 = {8, {"A", "B", "C", "D", "E", "F", "G", "H"}};


static int k13_klinischermehraufwand (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	static const char *sUniKHs[] = {"K612", "K706", "K901", 0};
	static const char *sUniKHs2018[] = {"K470", "K612", "K706", "K901", 0}; /* V2019.0 */
    char sIndexKost[2];
	int lKost;
	Satzart_GetValueString (ds, len, pFeld, sIndexKost, 2);
	if (*sIndexKost == 'B')
	{
		unsigned int i = 0;

		if (Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppKKSatzarten[12]->ppRef[K13_KOSTENMINDERUNGEN], &lKost) || !lKost) return 0;

        
        if (pCheckContext->pContext->modelljahr >= 2018) {
            while (sUniKHs2018[i])
            {
                if (!memcmp (pCheckContext->pContext->KANR, sUniKHs2018[i++], 4)) return 0;
            }
        }
        else {
            while (sUniKHs[i])
            {
                if (!memcmp (pCheckContext->pContext->KANR, sUniKHs[i++], 4)) return 0;
            }
        }
        
		return 1;
	}
	else return 0;
}

const LKF_SATZART_ERRORCHECK
	LKFKKCheckKlinischerMehraufwandNurUni = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k13_klinischermehraufwand, &LKFKKErrorKlinischerMehraufwandNurUni, 0, 0},
	LKFKKCheckIndexKostMindFalsch2008 =		{LKF_CHECKFUNC_STRINGLIST | LKF_CHECK_NURFONDSKA, &stringlist_indexkostmind_2008, &LKFKKErrorIndexKostMindFalsch, 0, &LKFKKCheckKlinischerMehraufwandNurUni},
	LKFKKCheckIndexKostMindFehlt =			{LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorIndexKostMindFehlt, 0, &LKFKKCheckIndexKostMindFalsch2008},
	LKFKKCheckKostMindFalsch =				{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKostMindFalsch, 0, 0};

const SATZART K13Satzart = {"K13", 0,  4, 4, (const int *) &k12_ident, "Kalk. Anhang - Kostenminderungen", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K13_INDEX_KOSTENMIN_ART,	TYP_ALPHA,  14,  2, &LKFKKCheckIndexKostMindFehlt, 0, "INDEX KOSTENMINDERUNGSART"},
	{K13_KOSTENMINDERUNGEN,		TYP_NUM,	16, 10, &LKFKKCheckKostMindFalsch, 0, "KOSTENMINDERUNGEN"}
}};

/*********************************************************************************************
** Satzart K14                                                                              **
*********************************************************************************************/

const LKF_SATZART_ERRORCHECK_STRINGLIST 
	stringlist_anlagenindex = {8, {"A", "B", "C", "D", "E", "F", "G", "H"}};

static int checkfunc_buchwert_zeile (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    int modelljahr;
	int nErgebnis;
    double nAnschaffKosten, nZugaenge, nAbgaenge, nKumAbschr, nUmbuchungen, nBuchwertEnde;
    
    modelljahr = pCheckContext->pContext->modelljahr;
    
    if (Satzart_GetValueFloat (ds, len, pFeld, &nBuchwertEnde, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 0;
    if (Satzart_GetValueFloat (ds, len, pCheckContext->pKKContext->ppKKSatzarten[13]->ppRef[K14_ANSCHAFF_HERSTKOSTEN], &nAnschaffKosten, modelljahr) == LKF_FIELD_ERROR) return 0;
    if (Satzart_GetValueFloat (ds, len, pCheckContext->pKKContext->ppKKSatzarten[13]->ppRef[K14_ZUGAENGE], &nZugaenge, modelljahr) == LKF_FIELD_ERROR) return 0;
    if (Satzart_GetValueFloat (ds, len, pCheckContext->pKKContext->ppKKSatzarten[13]->ppRef[K14_ABGAENGE], &nAbgaenge, modelljahr) == LKF_FIELD_ERROR) return 0;
    if (Satzart_GetValueFloat (ds, len, pCheckContext->pKKContext->ppKKSatzarten[13]->ppRef[K14_UMBUCHUNGEN], &nUmbuchungen, modelljahr) == LKF_FIELD_ERROR) return 0;
    if (Satzart_GetValueFloat (ds, len, pCheckContext->pKKContext->ppKKSatzarten[13]->ppRef[K14_KUM_ABSCHREIBUNGEN], &nKumAbschr, modelljahr) == LKF_FIELD_ERROR) return 0;
    
    nErgebnis = (int) (nAnschaffKosten + nZugaenge - nAbgaenge - nKumAbschr + nUmbuchungen - nBuchwertEnde);

	if (nErgebnis > 100 || nErgebnis < -100)
	{
		char sAnlagenIndex[4];
		Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppKKSatzarten[13]->ppRef[K14_ANLAGENINDEX], sAnlagenIndex, 4);
		sprintf (pCheckContext->sErrorAdditionalInfo, "%s: %d", sAnlagenIndex, nErgebnis);
		return 1;
	}
	else
		return 0;


}


const LKF_SATZART_ERRORCHECK
	LKFKKCheckBuchwertUngleichZeile =	{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, checkfunc_buchwert_zeile, &LKFKKErrorK14_BuchwertUngleichZeile, 0, 0},
	LKFKKCheckAnlagenindexFalsch2008 =		{LKF_CHECKFUNC_STRINGLIST | LKF_CHECK_NURFONDSKA, &stringlist_anlagenindex, &LKFKKErrorAnlagenindexFalsch2008, 0, 0},
	LKFKKCheckAnschaffKostenFalsch2008 =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorAnschaffKostenFalsch2008, 0, 0},
	LKFKKCheckZugaengeFalsch2008 =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorZugaengeFalsch2008, 0, 0},
	LKFKKCheckAbgaengeFalsch2008 =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorAbgaengeFalsch2008, 0, 0},
	LKFKKCheckUmbuchungenFalsch2008 =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorUmbuchungenFalsch2008, 0, 0},
	LKFKKCheckKumAbschrFalsch2008 =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorKumAbschrFalsch2008, 0, 0},
	LKFKKCheckBuchwerteVorjahrFalsch2008 =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorBuchwerteVorjahrFalsch2008, 0, 0},
    LKFKKCheckAbschrLfdFalsch2008 =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorAbschrLfdFalsch2008, 0, 0},
    LKFKKCheckBuchwerteEndeFalsch2008 =	{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorBuchwerteEndeFalsch2008, 0, &LKFKKCheckBuchwertUngleichZeile};

const SATZART K14Satzart = {"K14", 0,  11, 11, (const int *) &k12_ident, "Kalk. Anhang - Kalk. Anlagenspiegel", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K14_ANLAGENINDEX,			TYP_ALPHA,  14,  2, &LKFKKCheckAnlagenindexFalsch2008, 0, "ANLAGENINDEX"},
	{K14_ANSCHAFF_HERSTKOSTEN,	TYP_NUM,	16,	10, &LKFKKCheckAnschaffKostenFalsch2008, 0, "ANSCHAFFUNGS/HERSTELLUNGSKOSTEN"},
	{K14_ZUGAENGE,				TYP_NUM,	26, 10, &LKFKKCheckZugaengeFalsch2008, 0, "ZUGAENGE"},
	{K14_ABGAENGE,				TYP_NUM,	36, 10, &LKFKKCheckAbgaengeFalsch2008, 0, "ABGAENGE"},
	{K14_UMBUCHUNGEN,			TYP_NUM_NEG,	46, 10, &LKFKKCheckUmbuchungenFalsch2008, 0, "UMBUCHUNGEN"},
	{K14_KUM_ABSCHREIBUNGEN,	TYP_NUM,	56, 10, &LKFKKCheckKumAbschrFalsch2008, 0, "KUM.ABSCHREIBUNGEN"},
	{K14_BUCHW_ENDE_JAHR,		TYP_NUM,	66, 10, &LKFKKCheckBuchwerteEndeFalsch2008, 0, "BUCHWERT ENDE DES BERICHTSJAHRS"},
	{K14_BUCHW_VORJAHR,			TYP_NUM,	76, 10, &LKFKKCheckBuchwerteVorjahrFalsch2008, 0, "BUCHWERT VORJAHR"},
	{K14_ABSCHR_LFD_JAHR,		TYP_NUM,	86, 10, &LKFKKCheckAbschrLfdFalsch2008, 0, "ABSCHREIBUNGEN LFD. BERICHTSJAHR"}
}};

/*********************************************************************************************
** Satzart K15                                                                              **
*********************************************************************************************/


static int check_k15unvollst (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V17.0 */

	const SATZART_FELD *pKosten = pCheckContext->pKKContext->ppKKSatzarten[14]->ppRef[K15_KOSTEN];
	const SATZART_FELD *pBezugsGr = pCheckContext->pKKContext->ppKKSatzarten[14]->ppRef[K15_BEZUGSGROESSE];

	int kosten, gr;
	if (!Satzart_GetValueInt (ds, len, pKosten, &kosten) &&
		!Satzart_GetValueInt (ds, len, pBezugsGr, &gr) &&
		((kosten == 0 && gr != 0) || (kosten != 0 && gr == 0))) return 1;
	return 0;

	return 1;
}

const LKF_SATZART_ERRORCHECK_STRINGLIST 
	stringlist_kostbereichkz = {4, {"K1", "K2", "K3", "K9"}};

const LKF_SATZART_ERRORCHECK
	LKFKKCheckKostBereichKZIndexFalsch = {LKF_CHECKFUNC_STRINGLIST | LKF_CHECK_NURFONDSKA, &stringlist_kostbereichkz, &LKFKKErrorKostBereichKZIndexFalsch, 0, 0},
	LKFKKCheckK15_KostenFalsch =		 {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK15_KostenFalsch, 0, 0},
	LKFKKCheckK15_KostenFehlen =          {LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK15Kostenfehlen, 0, &LKFKKCheckK15_KostenFalsch},
	LKFKKCheckK15_BezugsgroesseFalsch =  {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK15_BezugsgroesseFalsch, 0, 0},
	LKFKKCheckK15_KennzahlenUnvollst = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_k15unvollst, &LKFKKErrorKennzahlunvollst, 0, 0}, /* V17.0 */
	LKFKKCheckK15_BezugsgroesseFehlt =   {LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK15Bezugsgroessefehlt, 0, &LKFKKCheckK15_BezugsgroesseFalsch};

const SATZART K15Satzart = {"K15", 0,  5, 5, (const int *) &k12_ident, "Kalk. Anhang - Allg. Kostenbereiche", &LKFKKCheckK15_KennzahlenUnvollst /* V17.0 */, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K15_KENNZAHLENINDEX,		TYP_ALPHA,  14,  2, &LKFKKCheckKostBereichKZIndexFalsch, 0, "KOSTENBEREICH - KENNZAHLENINDEX"},
	{K15_KOSTEN,				TYP_NUM,	16, 10, &LKFKKCheckK15_KostenFehlen, 0, "KOSTEN"},
	{K15_BEZUGSGROESSE,		TYP_NUM,	26, 10, &LKFKKCheckK15_BezugsgroesseFehlt, 0, "BEZUGSGROESSE"}
}};

/*********************************************************************************************
** Satzart K16                                                                              **
*********************************************************************************************/

const LKF_SATZART_ERRORCHECK_STRINGLIST 
	stringlist_kostenindex = {8, {"10", "20", "30", "31", "32", "33", "34", "35"}};

const LKF_SATZART_ERRORCHECK
	LKFKKCheckK16_KostenIndexFalsch =		{LKF_CHECKFUNC_STRINGLIST | LKF_CHECK_NURFONDSKA, &stringlist_kostenindex, &LKFKKErrorK16_KostenIndexFalsch, 0, 0},
	LKFKKCheckK16_KostenFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFKKErrorK16_KostenFalsch, 0, 0};

const SATZART K16Satzart = {"K16", 0,  4, 4, (const int *) &k12_ident, "Kalk. Anhang - Ausgewaehlte Kosten", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFKKCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{K16_KOSTENINDEX,			TYP_ALPHA,  14,  2, &LKFKKCheckK16_KostenIndexFalsch, 0, "KOSTENINDEX"},
	{K16_KOSTEN,				TYP_NUM,	16, 10, &LKFKKCheckK16_KostenFalsch, 0, "KOSTEN"}
}};

/*********************************************************************************************
** Generelle Checks                                                                         **
*********************************************************************************************/

static int k05_check_fachhaupt_k05 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sPersGrp[4];
	unsigned int count, i, j;
	int nK05Kopf, nK05KopfAlle, nCur;
	double fK05Aqui, fK04Aqui, fCur, fK05AquiAlle;
	LKF_KK_CONTEXT *pKKContext;
	const SATZART_FELD *pKopf, *pAqui, *pPersGrp, *pKopfAlle[3], *pAquiAlle[3];
	int ok_aqui04, ok_aqui05, ok_kopf, ok_kopfalle, ok_aqui05alle;
	
	int bNichtFonds = (pCheckContext->pContext->flags & LKFCONTEXT_NICHTFONDSKA);
	char sAddInfo[48];
    const LKF_EXPANDED_LINE **ppK;
	
	fK05Aqui = fK04Aqui = 0;
	fK05AquiAlle = 0;
	nK05Kopf = nK05KopfAlle = 0;
	ok_aqui04 = ok_aqui05 = 1;
	ok_kopf = ok_kopfalle = ok_aqui05alle = 1;

	pKKContext = pCheckContext->pKKContext;
	pAqui = pKKContext->ppKKSatzarten[3]->ppRef[K04_VOLLZEITAEQUIVALENTE];
	pPersGrp = pKKContext->ppKKSatzarten[3]->ppRef[K04_PERSONALGRUPPENINDEX];
	
	count = pKKContext->pSatzartCount[3];
    
    if (pCheckContext->pContext->modelljahr >= 2017) {

        ppK = pKKContext->pppExpandedLines[3];
        
        for (i = 0; i < count; i++)
        {
            Satzart_GetValueStringExp (ppK[i], pPersGrp, sPersGrp, 4);
            
            if (sPersGrp[2] == '1' && strchr ("123", sPersGrp[1]))
            {
                if (Satzart_GetValueFloatExp (ppK[i], pAqui, &fCur, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) ok_aqui04 = 0;
                else fK04Aqui += fCur;
            }
        }
    }
    else {
        for (i = 0; i < count; i++)
        {
            ds = pKKContext->pppSatzartRecords[3][i];
            len = pKKContext->ppSatzartRecordLen[3][i];
            
            Satzart_GetValueString (ds, len, pPersGrp, sPersGrp, 4);
            
            if (sPersGrp[2] == '1' && strchr ("123", sPersGrp[1]))
            {
                if (Satzart_GetValueFloat (ds, len, pAqui, &fCur, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) ok_aqui04 = 0;
                else fK04Aqui += fCur;
            }
        }
    }
    
	count = pKKContext->pSatzartCount[4];
	pAqui = pKKContext->ppKKSatzarten[4]->ppRef[K05_FACHAERZTE_VZEQ];
	pKopf = pKKContext->ppKKSatzarten[4]->ppRef[K05_FACHAERZTE_KOPF];
	pKopfAlle[0] = pKKContext->ppKKSatzarten[4]->ppRef[K05_FACHAERZTE_AUSB_KOPF];
	pKopfAlle[1] = pKKContext->ppKKSatzarten[4]->ppRef[K05_AERZTE_ALLGMED_KOPF];
	pKopfAlle[2] = pKKContext->ppKKSatzarten[4]->ppRef[K05_AERZTE_ALLG_AUSB_KOPF];

	pAquiAlle[0] = pKKContext->ppKKSatzarten[4]->ppRef[K05_AERZTE_ALLG_VZEQ];
	pAquiAlle[1] = pKKContext->ppKKSatzarten[4]->ppRef[K05_FACHAERZTE_AUSB_VZEQ];
	pAquiAlle[2] = pKKContext->ppKKSatzarten[4]->ppRef[K05_AERZTE_ALLG_AUSB_VZEQ];

    if (pCheckContext->pContext->modelljahr >= 2017) {

        ppK = pKKContext->pppExpandedLines[4];
        
        for (i = 0; i < count; i++)
        {
            
            if (Satzart_GetValueIntExp (ppK[i], pKopf, &nCur) == LKF_FIELD_ERROR) ok_kopf = 0;
            else nK05Kopf += nCur;
            
            for (j = 0; ok_kopf && ok_kopfalle && j < 3; j++)
            {
                if (Satzart_GetValueIntExp (ppK[i], pKopfAlle[j], &nCur) == LKF_FIELD_ERROR) ok_kopfalle = 0;
                else nK05KopfAlle += nCur;
                
                if (Satzart_GetValueFloatExp (ppK[i], pAquiAlle[j], &fCur, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) ok_aqui05alle = 0;
                else fK05AquiAlle += fCur;
            }
            
            if (Satzart_GetValueFloatExp (ppK[i], pAqui, &fCur, pCheckContext->pContext->modelljahr)) ok_aqui05 = 0;
            else fK05Aqui += fCur;
        }
    }
    else {
        for (i = 0; i < count; i++)
        {
            ds = pKKContext->pppSatzartRecords[4][i];
            len = pKKContext->ppSatzartRecordLen[4][i];
            
            if (Satzart_GetValueInt (ds, len, pKopf, &nCur) == LKF_FIELD_ERROR) ok_kopf = 0;
            else nK05Kopf += nCur;
            
            for (j = 0; ok_kopf && ok_kopfalle && j < 3; j++)
            {
                if (Satzart_GetValueInt (ds, len, pKopfAlle[j], &nCur) == LKF_FIELD_ERROR) ok_kopfalle = 0;
                else nK05KopfAlle += nCur;
                
                if (Satzart_GetValueFloat (ds, len, pAquiAlle[j], &fCur, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) ok_aqui05alle = 0;
                else fK05AquiAlle += fCur;
            }
            
            if (Satzart_GetValueFloat (ds, len, pAqui, &fCur, pCheckContext->pContext->modelljahr)) ok_aqui05 = 0;
            else fK05Aqui += fCur;
        }
    }
    
    
	if (ok_aqui05) fK05AquiAlle += fK05Aqui;
	else ok_aqui05alle = 0;

	if (ok_kopf && ok_kopfalle && ok_aqui04 && fK04Aqui * 3 > 4 * (nK05Kopf + nK05KopfAlle))
	{
		sprintf (sAddInfo, "%5d/%8.2f", nK05Kopf + nK05KopfAlle /* V9.4 */, fK04Aqui);
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorArztFachK04DienstKopf, sAddInfo);
	}

	if (ok_aqui05alle && ok_aqui04)
	{
		sprintf (sAddInfo, "%8.2f/%8.2f", fK04Aqui, fK05AquiAlle); 
		if (fK05AquiAlle * 4 < fK04Aqui * 3)
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorK04K05VZEQunter, sAddInfo);
		else if (fK05AquiAlle > fK04Aqui + 0.1) /* V13.3 - Einbau Toleranz */
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorK04K05VZEQueber, sAddInfo);
	}


	if (bNichtFonds)
		return 0;
	if (pCheckContext->pContext->period_type != 'J' || !count) return 0;
	else if (!lkf_IsFondsKA (pCheckContext)) return 0;
	else if (ok_kopf && nK05Kopf == 0) return 1;
	else return 0;
}

static int k04_persvollzeit_gesamt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* EK1L, EK1M */
	char sPersGruppenIndex[4];
	double fK04Gesamt, fGesamt, fCurrent;
	unsigned int i, j, lCount, lSatzart, lFeldMax;
	unsigned int lRecLen;
	int lMlvIndex;
	const char *sRec;
	const SATZART_FELD *pK04PersGrp, *ppFelder[K08_MLV_ANZAHL];
	LKF_KK_CONTEXT *pKKContext;

	double fK04Mlv[K08_MLV_ANZAHL];
	double fGesamtMlv[K08_MLV_ANZAHL];
	int ok_gesamt, ok_mlv[K08_MLV_ANZAHL];

	char sAddInfo[48];

	pKKContext = pCheckContext->pKKContext;
		
	ok_gesamt = 1;
	for (i = 0; i < K08_MLV_ANZAHL; i++)
	{
		ok_mlv[i] = 1;
		fGesamtMlv[i] = fK04Mlv[i] = 0;
	}

	/* Check K04-Gesamt */
	lCount = pKKContext->pSatzartCount[3];
	pFeld = pKKContext->ppKKSatzarten[3]->ppRef[K04_VOLLZEITAEQUIVALENTE];
	pK04PersGrp = pKKContext->ppKKSatzarten[3]->ppRef[K04_PERSONALGRUPPENINDEX];
	fK04Gesamt = fGesamt = 0;
	
    if (pCheckContext->pContext->modelljahr >= 2017) {
        const LKF_EXPANDED_LINE **ppK = pKKContext->pppExpandedLines[3];
        for (i = 0; i < lCount; i++)
        {
            Satzart_GetValueStringExp (ppK[i], pK04PersGrp, sPersGruppenIndex, 4);
            if (sPersGruppenIndex[0] == '1' && sPersGruppenIndex[2] >= '1' && sPersGruppenIndex[2] <= '9')
                lMlvIndex = sPersGruppenIndex[2] - '1';
            else lMlvIndex = -1;
            
            if (Satzart_GetValueFloatExp (ppK[i], pFeld, &fCurrent, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR)
            {
                if (lMlvIndex >= 0)
                {
                    ok_mlv[lMlvIndex] = 0;
                    ok_gesamt = 0;
                }
            }
            else
            {
                if (lMlvIndex >= 0)
                {
                    fK04Mlv[lMlvIndex] += fCurrent;
                    fK04Gesamt += fCurrent;
                }
            }
        }
        
        for (lSatzart = 7; lSatzart < 10; lSatzart++)
        {
            if (lSatzart < 9) {
                for (i = 0; i < K08_MLV_ANZAHL; i++)
                {
                    ppFelder[i] = pKKContext->ppKKSatzarten[lSatzart]->ppRef[aMLVs[i]];
                }
            }
            else ppFelder[0] = pKKContext->ppKKSatzarten[lSatzart]->ppRef[K10_PERS_INSG_VZEQ];
         
            ppK = pKKContext->pppExpandedLines[lSatzart];
            
            lCount = pKKContext->pSatzartCount[lSatzart];
            for (i = 0; i < lCount; i++)
            {
                lFeldMax = (lSatzart < 9) ? K08_MLV_ANZAHL : 1;
                for (j = 0; j < lFeldMax; j++)
                {
                    if (Satzart_GetValueFloatExp (ppK[i], ppFelder[j], &fCurrent, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) {
                        ok_gesamt = 0;
                        if (lSatzart < 9) ok_mlv[j] = 0;
                    }
                    else
                    {
                        fGesamt += fCurrent;
                        if (lSatzart < 9) fGesamtMlv[j] += fCurrent;
                    }
                }
            }
        }
    }
    else {
        for (i = 0; i < lCount; i++)
        {
            sRec = pKKContext->pppSatzartRecords[3][i];
            lRecLen = pKKContext->ppSatzartRecordLen[3][i];
            Satzart_GetValueString (sRec, lRecLen, pK04PersGrp, sPersGruppenIndex, 4);
            if (sPersGruppenIndex[0] == '1' && sPersGruppenIndex[2] >= '1' && sPersGruppenIndex[2] <= '9')
                lMlvIndex = sPersGruppenIndex[2] - '1';
            else lMlvIndex = -1;
            
            if (Satzart_GetValueFloat (sRec, lRecLen, pFeld, &fCurrent, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR)
            {
                if (lMlvIndex >= 0)
                {
                    ok_mlv[lMlvIndex] = 0;
                    ok_gesamt = 0;
                }
            }
            else
            {
                if (lMlvIndex >= 0)
                {
                    fK04Mlv[lMlvIndex] += fCurrent;
                    fK04Gesamt += fCurrent;
                }
            }
        }
        
        for (lSatzart = 7; lSatzart < 10; lSatzart++)
        {
            if (lSatzart < 9) {
                for (i = 0; i < K08_MLV_ANZAHL; i++)
                {
                    ppFelder[i] = pKKContext->ppKKSatzarten[lSatzart]->ppRef[aMLVs[i]];
                }
            }
            else ppFelder[0] = pKKContext->ppKKSatzarten[lSatzart]->ppRef[K10_PERS_INSG_VZEQ];
            
            lCount = pKKContext->pSatzartCount[lSatzart];
            for (i = 0; i < lCount; i++)
            {
                sRec = pKKContext->pppSatzartRecords[lSatzart][i];
                lRecLen = pKKContext->ppSatzartRecordLen[lSatzart][i];
                lFeldMax = (lSatzart < 9) ? K08_MLV_ANZAHL : 1;
                for (j = 0; j < lFeldMax; j++)
                {
                    if (Satzart_GetValueFloat (sRec, lRecLen, ppFelder[j], &fCurrent, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) {
                        ok_gesamt = 0;
                        if (lSatzart < 9) ok_mlv[j] = 0;
                    }
                    else
                    {
                        fGesamt += fCurrent;
                        if (lSatzart < 9) fGesamtMlv[j] += fCurrent;
                    }
                }
            }
        }
    }
    
    for (i = 0; i < K08_MLV_ANZAHL; i++)
    {
        if (ok_mlv[i] && fK04Mlv[i] < fGesamtMlv[i]- 0.01) 
		{
			sprintf (sAddInfo, "1.%1d:%9.2f/%9.2f", i+1, fK04Mlv[i], fGesamtMlv[i]); 
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorPersVollzeit2, sAddInfo);
		}
	}

	if (ok_gesamt && (fK04Gesamt > fGesamt + 0.5 || fGesamt > fK04Gesamt + 0.5))
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%9.2f/%9.2f", fK04Gesamt, fGesamt);
		return 1;
	}
	else return 0;
}

static int check_gesamtumlagefehlerhaft (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sErrorInfo[48];
	char sAbtFC[10];
	int nKOAGR[4], nILV[4], nCurrent;
	double nKOAGRGesamt, nILVGesamt;
	int ok[4], okgesamt, okcur;
	unsigned int i, count, nSatzart, nFeld;
	const SATZART_FELD *pKOAGR[4], *pILV, *pAbtFC;
    const LKF_EXPANDED_LINE **ppK;
	LKF_KK_CONTEXT *pKKContext;
	const SATZART_INFO *pSatzart;
	static const LKF_SATZART_ERRORDEF *pKOAGRError[4] = {&LKFKKErrorGesamtumlageKOAGR11unplaus, &LKFKKErrorGesamtumlageKOAGR12unplaus, &LKFKKErrorGesamtumlageKOAGR13unplaus, &LKFKKErrorGesamtumlageKOAGR14unplaus};

	pKKContext = pCheckContext->pKKContext;

	for (i = 0; i < 4; i++)
	{
		ok[i] = 1;
		nKOAGR[i] = nILV[i] = 0;
	}
	okgesamt = 1;
	nILVGesamt = 0;
	nKOAGRGesamt = 0;
	
	for (nSatzart = 7; nSatzart < 10; nSatzart++)
	{
		pSatzart = pKKContext->ppKKSatzarten[nSatzart];
	
		pKOAGR[0] = pSatzart->ppRef[K08_KOAGR11];
		pKOAGR[1] = pSatzart->ppRef[K08_KOAGR12];
		pKOAGR[2] = pSatzart->ppRef[K08_KOAGR13];
		pKOAGR[3] = pSatzart->ppRef[K08_KOAGR14];
		pILV = pSatzart->ppRef[K08_SUM_ABG_INNERBETR_LST];
		pAbtFC = pSatzart->ppRef[GEN_ABTFC];
	
		count = pKKContext->pSatzartCount[nSatzart];

        if (pCheckContext->pContext->modelljahr >= 2017) {
            ppK = pKKContext->pppExpandedLines[nSatzart];
            for (i = 0; i < count; i++)
            {
                for (nFeld = 0; nFeld < 4; nFeld++)
                {
                    if (Satzart_GetValueIntExp (ppK[i], pKOAGR[nFeld], &nCurrent) == LKF_FIELD_ERROR) {
                        ok[nFeld] = 0;
                        okgesamt = 0;
                    }
                    else
                    {
                        nKOAGR[nFeld] += nCurrent;
                        nKOAGRGesamt += nCurrent;
                    }
                }
                
                Satzart_GetValueStringExp (ppK[i], pAbtFC, sAbtFC, 10);
                okcur = Satzart_GetValueIntExp (ppK[i], pILV, &nCurrent);
                if (okcur == LKF_FIELD_ERROR) okgesamt = 0;
                else
                {
                    nILVGesamt += nCurrent;
                }
                if (sAbtFC[0] == '3')
                {
                    if (sAbtFC[1] == '1')
                    {
                        if (okcur == LKF_FIELD_ERROR) ok[0] = 0;
                        else nILV[0] += nCurrent;
                    }
                    else if (sAbtFC[1] == '2')
                    {
                        if (okcur == LKF_FIELD_ERROR) ok[1] = 0;
                        else nILV[1] += nCurrent;
                    }
                    else if (sAbtFC[1] == '3')
                    {
                        if (okcur == LKF_FIELD_ERROR) ok[2] = 0;
                        else nILV[2] += nCurrent;
                    }
                }
                else if (sAbtFC[0] == '1' || sAbtFC[0] == '2')
                {
                    if (okcur == LKF_FIELD_ERROR) ok[3] = 0;
                    else nILV[3] += nCurrent;
                }		
            }
        }
        else {
            for (i = 0; i < count; i++)
            {
                ds = pKKContext->pppSatzartRecords[nSatzart][i];
                len = pKKContext->ppSatzartRecordLen[nSatzart][i];
                
                
                
                for (nFeld = 0; nFeld < 4; nFeld++)
                {
                    if (Satzart_GetValueInt (ds, len, pKOAGR[nFeld], &nCurrent) == LKF_FIELD_ERROR) {
                        ok[nFeld] = 0;
                        okgesamt = 0;
                    }
                    else
                    {
                        nKOAGR[nFeld] += nCurrent;
                        nKOAGRGesamt += nCurrent;
                    }
                }
                
                Satzart_GetValueString (ds, len, pAbtFC, sAbtFC, 10);
                okcur = Satzart_GetValueInt (ds, len, pILV, &nCurrent);
                if (okcur == LKF_FIELD_ERROR) okgesamt = 0;
                else
                {
                    nILVGesamt += nCurrent;
                }
                if (sAbtFC[0] == '3')
                {
                    if (sAbtFC[1] == '1')
                    {
                        if (okcur == LKF_FIELD_ERROR) ok[0] = 0;
                        else nILV[0] += nCurrent;
                    }
                    else if (sAbtFC[1] == '2')
                    {
                        if (okcur == LKF_FIELD_ERROR) ok[1] = 0;
                        else nILV[1] += nCurrent;
                    }
                    else if (sAbtFC[1] == '3')
                    {
                        if (okcur == LKF_FIELD_ERROR) ok[2] = 0;
                        else nILV[2] += nCurrent;
                    }
                }
                else if (sAbtFC[0] == '1' || sAbtFC[0] == '2')
                {
                    if (okcur == LKF_FIELD_ERROR) ok[3] = 0;
                    else nILV[3] += nCurrent;
                }		
            }
        }
    }
    
	for (i = 0; i < 4; i++)
	{
		if (ok[i] && ((nKOAGR[i] - nILV[i]) > 1000 || (nILV[i] - nKOAGR[i]) > 1000))
		{
			sprintf (sErrorInfo, "%d/%d", nKOAGR[i], nILV[i]);
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, pKOAGRError[i], sErrorInfo);
		}
	}

	if (okgesamt && (nKOAGRGesamt - nILVGesamt > 1000 || nILVGesamt - nKOAGRGesamt > 1000)) {
		sprintf (sErrorInfo, "%9.2f/%9.2f", nKOAGRGesamt, nILVGesamt);
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorGesamtumlageFehlerhaft, sErrorInfo);
	}
	
	return 0;
}

static int check_kombabtfc_satzart (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return 0; /* OK? deaktiviert: EK66 Kombination Funktionscode und gemeldete Satzart ung\xc3\xbc""ltig */
}

#define LKF_CHECK_VORST		14

static int check_penskost_unvollst (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sAdditionalInfo[48];
	unsigned int i, j, count;
	char sAbtFC[10], sArt[4];
	const SATZART_INFO *pK10;
	const SATZART_FELD *pFeldMlv, *pFeldKosten, *pFeldAbtFC, *pFeldMind, *pFeldArt;
	int nMlv, nKosten;
	int nPensK12, nVorstK12;
	int nPensK10, nVorstK10;

	int nVorstMind10, nVorstMind13;
	int nFlafMind10, nFlafMind13;
	LKF_KK_CONTEXT *pKKContext;

	int nVorstNO, nPensNO, nMed3NO, nNMed3NO;
    const LKF_EXPANDED_LINE **ppK;

	static unsigned int aCheckKost[LKF_CHECK_VORST] = 
		{K08_KOAGR01, K08_KOAGR02, K08_KOAGR03, K08_KOAGR04, K08_KOAGR05,
		 K08_KOAGR06, K08_KOAGR08, K08_KOAGR11, K08_KOAGR12, K08_KOAGR13, K08_KOAGR14,
		 K08_KOSTENMINDERUNGEN, K08_SUM_ABG_INNERBETR_LST, K08_UNTER_UEBERDECKUNG};

    pKKContext = pCheckContext->pKKContext;

	pFeldMlv = pKKContext->ppKKSatzarten[11]->ppRef[K12_MLVNUMMER];
	pFeldKosten = pKKContext->ppKKSatzarten[11]->ppRef[K12_KOSTEN];
	count = pKKContext->pSatzartCount[11];
	nPensK12 = nVorstK12 = 0;

    if (pCheckContext->pContext->modelljahr >= 2017) {
        ppK = pKKContext->pppExpandedLines[11];
        for (i = 0; i < count; i++)
        {
            if (!Satzart_GetValueIntExp (ppK[i], pFeldMlv, &nMlv) && !Satzart_GetValueIntExp (ppK[i], pFeldKosten, &nKosten))
            {
                if (nMlv == 86) nPensK12 += nKosten;
                else if (nMlv == 87) nVorstK12 += nKosten;
            }
        }
    }
    else {
        for (i = 0; i < count; i++)
        {
            ds = pKKContext->pppSatzartRecords[11][i];
            len = pKKContext->ppSatzartRecordLen[11][i];
            if (!Satzart_GetValueInt (ds, len, pFeldMlv, &nMlv) && !Satzart_GetValueInt (ds, len, pFeldKosten, &nKosten))
            {
                if (nMlv == 86) nPensK12 += nKosten;
                else if (nMlv == 87) nVorstK12 += nKosten;
            }
        }
    }
    

	pK10 = pKKContext->ppKKSatzarten[9];
	pFeldAbtFC = pK10->ppRef[GEN_ABTFC];
	pFeldKosten = pK10->ppRef[K08_KOAGR07];
	pFeldMind = pK10->ppRef[K08_KOSTENMINDERUNGEN];
	count = pKKContext->pSatzartCount[9];

	nVorstNO = nPensNO = nMed3NO = nNMed3NO = 0;
	nVorstMind10 = nPensK10 = nVorstK10 = 0;
	nFlafMind10 = nFlafMind13 = 0;

    ppK = (pCheckContext->pContext->modelljahr >= 2017) ? pKKContext->pppExpandedLines[9] : 0;
    
	for (i = 0; i < count; i++)
	{
        ds = ppK ? (const char *) ppK[i] : pKKContext->pppSatzartRecords[9][i];
        len = ppK ? LKF_LEN_FOR_EXPANDEDLINE : pKKContext->ppSatzartRecordLen[9][i];
		
		Satzart_GetValueString (ds, len, pFeldAbtFC, sAbtFC, 10);
		if (!memcmp (sAbtFC, "202111", 6))
		{
			if (!Satzart_GetValueInt (ds, len, pFeldKosten, &nKosten)) nPensK10 += nKosten;
			nPensNO = 0;
			for (j = 0; !nPensNO && j < LKF_CHECK_VORST; j++)
			{
				if (!Satzart_GetValueInt (ds, len, pK10->ppRef[aCheckKost[j]], &nKosten) && nKosten > 0) nPensNO = 1;
			}
			if (nPensNO)
			{
				Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorKostenstellePensNichtOK, sAbtFC);
			}
		}
		else if (!memcmp (sAbtFC, "202211", 6))
		{
			if (!Satzart_GetValueInt (ds, len, pFeldKosten, &nKosten)) nVorstK10 += nKosten;
			if (!Satzart_GetValueInt (ds, len, pFeldMind, &nKosten)) nVorstMind10 += nKosten;

			nVorstNO = 0;
			for (j = 0; !nVorstNO && j < LKF_CHECK_VORST; j++)
			{
				if (!Satzart_GetValueInt (ds, len, pK10->ppRef[aCheckKost[j]], &nKosten) && nKosten > 0) 
				{
					if (aCheckKost[j] != K08_KOSTENMINDERUNGEN) nVorstNO = 1;
				}
			}
			if (nVorstNO) 
			{
				sprintf (sAdditionalInfo, "%8.8s", sAbtFC);
				Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorKostVorsteuerNichtOK, sAdditionalInfo);
			}
		}
		else if (!memcmp (sAbtFC, "202511", 6))
		{
			if (!Satzart_GetValueInt (ds, len, pFeldMind, &nKosten)) nFlafMind10 += nKosten;
		}
	}

	nVorstMind13 = 0;
	count = pKKContext->pSatzartCount[12];
	pFeldArt = pKKContext->ppKKSatzarten[12]->ppRef[K13_INDEX_KOSTENMIN_ART];
	pFeldKosten = pKKContext->ppKKSatzarten[12]->ppRef[K13_KOSTENMINDERUNGEN];

    
    if (pCheckContext->pContext->modelljahr >= 2017) {
        ppK = pKKContext->pppExpandedLines[12];
        for (i = 0; i < count; i++)
        {
            Satzart_GetValueStringExp (ppK[i], pFeldArt, sArt, 4);
            if (sArt[0] == 'A')
            {
                if (!Satzart_GetValueIntExp (ppK[i], pFeldKosten, &nKosten)) nVorstMind13 += nKosten;
            }
            else if (sArt[0] == 'H')
            {
                if (!Satzart_GetValueIntExp (ppK[i], pFeldKosten, &nKosten)) nFlafMind13 += nKosten;
            }
        }
    }
    else {
        for (i = 0; i < count; i++)
        {
            ds = pKKContext->pppSatzartRecords[12][i];
            len = pKKContext->ppSatzartRecordLen[12][i];
            
            Satzart_GetValueString (ds, len, pFeldArt, sArt, 4);
            if (sArt[0] == 'A')
            {
                if (!Satzart_GetValueInt (ds, len, pFeldKosten, &nKosten)) nVorstMind13 += nKosten;
            }
            else if (sArt[0] == 'H')
            {
                if (!Satzart_GetValueInt (ds, len, pFeldKosten, &nKosten)) nFlafMind13 += nKosten;
            }
        }
    }
    

	if (nPensK10 > 0 && nPensK12 == 0)
	{
		sprintf (sAdditionalInfo, "%d/%d", nPensK10, nPensK12);
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorPensionskostenUnvollst, sAdditionalInfo);
	}

	if (nVorstK10 > 0 && nVorstK12 == 0)
	{
		sprintf (sAdditionalInfo, "%d/%d", nVorstK10, nVorstK12);
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorVorsteuerUnvollst, sAdditionalInfo);
	}

	if ((nPensK10 == 0 && nPensK12 > 0) || (nVorstK10 == 0 && nVorstK12 > 0))
	{
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorMLVAbhaengigkeit, 0);
	}
	
	if (nVorstMind13 != nVorstMind10)
	{
		sprintf (sAdditionalInfo, "%d/%d", nVorstMind13, nVorstMind10);
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorKostMindVorsteuerFalsch, sAdditionalInfo);
	}
	if (nFlafMind13 != nFlafMind10)
	{

		if (!(pCheckContext->pContext->flags & LKFCONTEXT_NICHTFONDSKA))
		{
			sprintf (sAdditionalInfo, "%d/%d", nFlafMind13, nFlafMind10);
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorKostMindFLAFFalsch, sAdditionalInfo);
		}
	}
	return 0; 
}

static int check_mlv (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	const LKF_SATZART_ERRORDEF *pErrors[K08_MLV_ANZAHL] = {&LKFKKErrorAquMLV11unplaus, &LKFKKErrorAquMLV12unplaus, &LKFKKErrorAquMLV13unplaus, 
														&LKFKKErrorAquMLV14unplaus, &LKFKKErrorAquMLV15unplaus, &LKFKKErrorAquMLV16unplaus, 
														&LKFKKErrorAquMLV17unplaus, &LKFKKErrorAquMLV18unplaus, &LKFKKErrorAquMLV19unplaus};
	char sPersGruppenIndex[4];
    const LKF_EXPANDED_LINE **ppK;

	int mlv_ok[K08_MLV_ANZAHL];

	double mlv_current, mlv_gesamt[K08_MLV_ANZAHL], mlv_k04_gesamt[K08_MLV_ANZAHL];
	unsigned int i, nSatzart, nMlv;

	LKF_KK_CONTEXT *pKKContext;
	pKKContext = pCheckContext->pKKContext;

	for (i = 0; i < K08_MLV_ANZAHL; i++)
	{
		mlv_ok[i] = 1;
		mlv_gesamt[i] = 0;
		mlv_k04_gesamt[i] = 0;
	}

	for (nSatzart = 7; nSatzart < 9; nSatzart++)
	{
        
        if (pCheckContext->pContext->modelljahr >= 2017) {
            ppK = pKKContext->pppExpandedLines[nSatzart];
            for (i = 0; i < pKKContext->pSatzartCount[nSatzart]; i++)
            {
                for (nMlv = 0; nMlv < K08_MLV_ANZAHL; nMlv++)
                {
                    if (mlv_ok[nMlv])
                    {
                        if (Satzart_GetValueFloatExp (ppK[i], pKKContext->ppKKSatzarten[nSatzart]->ppRef[aMLVs[nMlv]], &mlv_current, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR)
                        {
                            mlv_ok[nMlv] = 0;
                        }
                        else 
                        {
                            mlv_gesamt[nMlv] += mlv_current;
                        }
                    }
                }
            }
        } else {
            for (i = 0; i < pKKContext->pSatzartCount[nSatzart]; i++)
            {
                ds = pKKContext->pppSatzartRecords[nSatzart][i];
                len = pKKContext->ppSatzartRecordLen[nSatzart][i];
                
                for (nMlv = 0; nMlv < K08_MLV_ANZAHL; nMlv++)
                {
                    if (mlv_ok[nMlv])
                    {
                        if (Satzart_GetValueFloat (ds, len, pKKContext->ppKKSatzarten[nSatzart]->ppRef[aMLVs[nMlv]], &mlv_current, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR)
                        {
                            mlv_ok[nMlv] = 0;
                        }
                        else 
                        {
                            mlv_gesamt[nMlv] += mlv_current;
                        }
                    }
                }
            }
        }
	}

    if (pCheckContext->pContext->modelljahr >= 2017) {
        
        ppK = pKKContext->pppExpandedLines[3];
        for (i = 0; i < pKKContext->pSatzartCount[3]; i++)
        {
            Satzart_GetValueStringExp (ppK[i], pKKContext->ppKKSatzarten[3]->ppRef[K04_PERSONALGRUPPENINDEX], sPersGruppenIndex, 4);
            
            if (sPersGruppenIndex[2]>='1' && sPersGruppenIndex[2]<='9')
            {
                if (!memcmp (sPersGruppenIndex, "Z0", 2) || (sPersGruppenIndex[0] == '1' && strchr ("123", sPersGruppenIndex[1])))
                {
                    nMlv = (unsigned int) (sPersGruppenIndex[2] - '1');
                    if (mlv_ok[nMlv])
                    {
                        if (Satzart_GetValueFloatExp (ppK[i], pKKContext->ppKKSatzarten[3]->ppRef[K04_VOLLZEITAEQUIVALENTE], &mlv_current, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR)
                            mlv_ok[nMlv] = 0;
                        else mlv_k04_gesamt[nMlv] += mlv_current;
                    }
                }
            }
        }
        
    }
    else {
        for (i = 0; i < pKKContext->pSatzartCount[3]; i++)
        {
            ds = pKKContext->pppSatzartRecords[3][i];
            len = pKKContext->ppSatzartRecordLen[3][i];
            Satzart_GetValueString (ds, len, pKKContext->ppKKSatzarten[3]->ppRef[K04_PERSONALGRUPPENINDEX], sPersGruppenIndex, 4);
            
            if (sPersGruppenIndex[2]>='1' && sPersGruppenIndex[2]<='9')
            {
                if (!memcmp (sPersGruppenIndex, "Z0", 2) || (sPersGruppenIndex[0] == '1' && strchr ("123", sPersGruppenIndex[1])))
                {
                    nMlv = (unsigned int) (sPersGruppenIndex[2] - '1');
                    if (mlv_ok[nMlv])
                    {
                        if (Satzart_GetValueFloat (ds, len, pKKContext->ppKKSatzarten[3]->ppRef[K04_VOLLZEITAEQUIVALENTE], &mlv_current, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR)
                            mlv_ok[nMlv] = 0;
                        else mlv_k04_gesamt[nMlv] += mlv_current;
                    }
                }
            }
        }
    }
    
    for (nMlv = 0; nMlv < K08_MLV_ANZAHL; nMlv++)
	{
		if (mlv_ok[nMlv])
		{
			if (mlv_gesamt[nMlv] > mlv_k04_gesamt[nMlv] + 0.01) {
				char sErrorBuf[128];
				sprintf (sErrorBuf, "%9.2f/%9.2f", mlv_gesamt[nMlv], mlv_k04_gesamt[nMlv]);
				Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, pErrors[nMlv], sErrorBuf);
			}
		}
	}

	return 0;
}

static int check_abtfcdlb_ohne_stat (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	/* OK? DLB-Daten */
	char sErrorInfo[10];
	unsigned int i;
	LKF_KK_CONTEXT *pKKContext;
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbteilung;
    int modelljahr;
    
    modelljahr = pCheckContext->pContext->modelljahr;

	pKKContext = pCheckContext->pKKContext;

	if (!HasKAS (pKKContext)) return 0;

	if (!pKKContext->lMBDSStatOk) k03_mbdsstat (pCheckContext,0);

	for (i = 0; i < pKKContext->nAbtCount; i++)
	{
		pKKAbteilung = pKKContext->pKKAbteilung + i;
		if (pKKAbteilung->nHasM02Toleranz /* V9.4 */ && !pKKAbteilung->pK08) 
		{
			if (modelljahr >= 2010 && !memcmp (pKKAbteilung->sAbtFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
				continue;
            
            if (modelljahr >= 2017 && pKKAbteilung->pK09) {
                continue; /* V22.3: FIX ambulante Abteilungen */
            }
            
            if (modelljahr >= 2018 && (pCheckContext->pContext->flags & LKFCONTEXT_NICHTFONDSKA) && IsNBettHK(pCheckContext->pContext, pKKAbteilung->sAbtFC))
                continue; /* V2019.0 */
            


			sprintf (sErrorInfo, "%8.8s", pKKAbteilung->sAbtFC);
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorAbtFCDLBOhneStat, sErrorInfo);
		}
		else if (pKKAbteilung->nHasM02Jahr && !pKKAbteilung->pK08)
		{ /* Fehler EK75 wenn EK6T nicht geliefert wird, aber M02-Daten und keine K08-Daten */
			if (modelljahr >= 2010 && !memcmp (pKKAbteilung->sAbtFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
				continue;

            if (modelljahr >= 2017 && pKKAbteilung->pK09) {
                continue; /* V22.3: FIX ambulante Abteilungen */
            }
            
            if (modelljahr >= 2018 && !pKKAbteilung->nHasM02Toleranz)
                continue; /* V2019.0: Toleranz 15.1 fuer EK75 */

			sprintf (sErrorInfo, "%8.8s", pKKAbteilung->sAbtFC);
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorBelagstageDifferenz, sErrorInfo);

		}
		else if (!pKKAbteilung->nHasM02 && pKKAbteilung->pK08)
		{
			sprintf (sErrorInfo, "%8.8s", pKKAbteilung->sAbtFC);
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorAbtFCStatohneDLB, sErrorInfo);
		}
	}

	return 0;
}

static int check_abtfcstat_ohne_dlb (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return 0; /* wird in check_abtfcdlb_ohne_stat gecheckt und geliefert */
}

static int check_kostenstelle_ohne_daten (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int i;
	LKF_KK_CONTEXT *pKKContext;
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbteilung;
	char sAdditionalInfo[24];
/* ok? mu\xc3\x9f"" M02-Daten haben */	

	if (pCheckContext->pContext->period_type != 'J') return 0; /* nur bei Jahres-Check */

	pKKContext = pCheckContext->pKKContext;
    if (!pKKContext->lMBDSStatOk) {
        int ret = k03_mbdsstat (pCheckContext,0);
        if (ret == LKF_OUTOFMEMORY_ERROR) return ret;
    }

	for (i = 0; i < pKKContext->nAbtCount; i++)
	{
		pKKAbteilung = pKKContext->pKKAbteilung + i;
		if (pKKAbteilung->pK01 && !pKKAbteilung->pK08 && !pKKAbteilung->pK09 && !pKKAbteilung->pK10 && !pKKAbteilung->pG01 && !pKKAbteilung->nHasM02)
		{
			if (pKKAbteilung->sAbtFC[0] == '9' && pCheckContext->pContext->modelljahr >= 2012)
				continue; /* V17.0 - keine Warning bei 9er-Abteilungen */
			sprintf (sAdditionalInfo, "%8.8s", pKKAbteilung->sAbtFC);
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, pKKAbteilung->pK01, pKKAbteilung->nK01Len, pKKContext->ppKKSatzarten[0], 0, pCheck->pErrorDef, sAdditionalInfo);
		}
	}
	return 0;
}

static int k07_check_summe (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{

	int nCur;
	unsigned int count, i;
	const SATZART_FELD *pFeldW, *pFeldM;
	LKF_KK_CONTEXT *pKKContext;

	pKKContext = pCheckContext->pKKContext;

	if (!HasKAS (pKKContext)) return 0;

	pFeldW = pKKContext->ppKKSatzarten[6]->ppRef[K07_PERSONAL_WEIBLICH];
	pFeldM = pKKContext->ppKKSatzarten[6]->ppRef[K07_PERSONAL_MAENNLICH];

	count = pKKContext->pSatzartCount[6];
    
    if (pCheckContext->pContext->modelljahr >= 2017) {
        const LKF_EXPANDED_LINE **ppK = pKKContext->pppExpandedLines[6];
        for (i = 0; i < count; i++)
        {
            
            if (Satzart_GetValueIntExp (ppK[i], pFeldW, &nCur) == LKF_FIELD_ERROR || nCur) return 0;
            if (Satzart_GetValueIntExp (ppK[i], pFeldM, &nCur) == LKF_FIELD_ERROR || nCur) return 0;
        }
    }
    else {
        for (i = 0; i < count; i++)
        {
            ds = pKKContext->pppSatzartRecords[6][i];
            len = pKKContext->ppSatzartRecordLen[6][i];
            
            if (Satzart_GetValueInt (ds, len, pFeldW, &nCur) == LKF_FIELD_ERROR || nCur) return 0;
            if (Satzart_GetValueInt (ds, len, pFeldM, &nCur) == LKF_FIELD_ERROR || nCur) return 0;
        }
    }
    
	return 1;
}

static int k07_check_gesberufe (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sIndex[4];
	double fK04Gesamt[4], fCurrent;
	int nK07Gesamt[4], nCurrent;
	int ok[4];
	const SATZART_INFO *pK04Satzart, *pK07Satzart;
	const SATZART_FELD *pFeldIndex, *pFeldWert, *pFeldWert2;
	LKF_KK_CONTEXT *pKKContext;
	unsigned int i, count, nIndex;
	char sAdditionalInfo[48];
    const LKF_EXPANDED_LINE **ppK;

	for (i = 0; i < 4; i++)
	{
		ok[i] = 1;
		fK04Gesamt[i] = 0;
		nK07Gesamt[i] = 0; 
	}

	pKKContext = pCheckContext->pKKContext;
	pK04Satzart = pKKContext->ppKKSatzarten[3];
	pK07Satzart = pKKContext->ppKKSatzarten[6];

	count = pKKContext->pSatzartCount[3];

	pFeldIndex = pK04Satzart->ppRef[K04_PERSONALGRUPPENINDEX];
	pFeldWert = pK04Satzart->ppRef[K04_VOLLZEITAEQUIVALENTE];
	
    if (pCheckContext->pContext->modelljahr >= 2017) {
        
        ppK = pKKContext->pppExpandedLines[3];
        for (i = 0; i < count; i++)
        {
            Satzart_GetValueStringExp (ppK[i], pFeldIndex, sIndex, 4);
            
            if (sIndex[0] == '1' && strchr ("123", sIndex[1]) && strchr ("3456", sIndex[2]))
            {
                nIndex = (unsigned int) (sIndex[2] - '3');
                if (Satzart_GetValueFloatExp (ppK[i], pFeldWert, &fCurrent, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) ok[nIndex] = 0;
                else fK04Gesamt[nIndex] += fCurrent;
            }
        }
    }
    else {
        for (i = 0; i < count; i++)
        {
            ds = pKKContext->pppSatzartRecords[3][i];
            len = pKKContext->ppSatzartRecordLen[3][i];
            
            Satzart_GetValueString (ds, len, pFeldIndex, sIndex, 4);
            
            if (sIndex[0] == '1' && strchr ("123", sIndex[1]) && strchr ("3456", sIndex[2]))
            {
                nIndex = (unsigned int) (sIndex[2] - '3');
                if (Satzart_GetValueFloat (ds, len, pFeldWert, &fCurrent, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) ok[nIndex] = 0;
                else fK04Gesamt[nIndex] += fCurrent;
            }
        }
    }

	count = pKKContext->pSatzartCount[6];
	pFeldIndex = pK07Satzart->ppRef[K07_NICHTAERZTL_GESBERUF];
	pFeldWert = pK07Satzart->ppRef[K07_PERSONAL_MAENNLICH];
	pFeldWert2 = pK07Satzart->ppRef[K07_PERSONAL_WEIBLICH];

    if (pCheckContext->pContext->modelljahr >= 2017) {

        ppK = pKKContext->pppExpandedLines[6];
        
        for (i = 0; i < count; i++)
        {
            Satzart_GetValueStringExp (ppK[i], pFeldIndex, sIndex, 4);
            nIndex = 9;
            switch (sIndex[0])
            {
                case '3':
                    if (sIndex[1] == '0') nIndex = 0;
                    break;
                case '4':
                    if (pCheckContext->pContext->modelljahr >= 2024) {
                        if (strchr ("1234A", sIndex[1])) nIndex = 1;
                    }
                    else {
                        if (strchr ("1234", sIndex[1])) nIndex = 1;
                    }
                    
                    break;
                case '5':
                    if (sIndex[1] >= '0' && sIndex[1] <= '9') nIndex = 2;
                    break;
                case '6':
                    if (sIndex[1] >= '0' && sIndex[1] <= '9') nIndex = 3;
                    else if (pCheckContext->pContext->modelljahr >= 2014) {
                        /* V18.0 */
                        if (sIndex[1] >= 'A' && sIndex[1]<='B') nIndex = 3;
                        else if (sIndex[1] == 'C' && pCheckContext->pContext->modelljahr >= 2020) {
                            nIndex = 3; /* V2020.3 */
                        }
                    }
                    break;
                default:
                    break;
            }
            
            if (nIndex < 9)
            {
                if (Satzart_GetValueIntExp (ppK[i], pFeldWert, &nCurrent) == LKF_FIELD_ERROR) ok[nIndex] = 0;
                else nK07Gesamt[nIndex] += nCurrent;
                if (Satzart_GetValueIntExp (ppK[i], pFeldWert2, &nCurrent) == LKF_FIELD_ERROR) ok[nIndex] = 0;
                else nK07Gesamt[nIndex] += nCurrent;
            }
        }
        
    }
    else {
        for (i = 0; i < count; i++)
        {
            ds = pKKContext->pppSatzartRecords[6][i];
            len = pKKContext->ppSatzartRecordLen[6][i];
            
            Satzart_GetValueString (ds, len, pFeldIndex, sIndex, 4);
            nIndex = 9;
            switch (sIndex[0])
            {
                case '3':
                    if (sIndex[1] == '0') nIndex = 0;
                    break;
                case '4':
                    if (strchr ("1234", sIndex[1])) nIndex = 1;
                    break;
                case '5':
                    if (sIndex[1] >= '0' && sIndex[1] <= '9') nIndex = 2;
                    break;
                case '6':
                    if (sIndex[1] >= '0' && sIndex[1] <= '9') nIndex = 3;
                    else if (pCheckContext->pContext->modelljahr >= 2014) {
                        /* V18.0 */
                        if (sIndex[1] >= 'A' && sIndex[1]<='B') nIndex = 3;
                    }
                    break;
                default:
                    break;
            }
            
            if (nIndex < 9)
            {
                if (Satzart_GetValueInt (ds, len, pFeldWert, &nCurrent) == LKF_FIELD_ERROR) ok[nIndex] = 0;
                else nK07Gesamt[nIndex] += nCurrent;
                if (Satzart_GetValueInt (ds, len, pFeldWert2, &nCurrent) == LKF_FIELD_ERROR) ok[nIndex] = 0;
                else nK07Gesamt[nIndex] += nCurrent;
            }
        }
        
    }
    
    
    for (i = 0; i < 4; i++)
	{
		if (ok[i] && nK07Gesamt[i] * 4 < 3 * fK04Gesamt[i]) /* V9.4: Toleranz 75% */
		{
			sprintf (sAdditionalInfo, "%d: %d/%8.2f", i+3, nK07Gesamt[i], fK04Gesamt[i]);
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFKKErrorNArztVergleich, sAdditionalInfo);
		}
	}
	return 0;
}

static int k05_check_keinFacharzt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* WK10 */
	const char *sAbtFC;
	char sFachHauptIndex[4];
	unsigned int i, j, count;
	int nKopfZahl;
	LKF_KK_CONTEXT *pKKContext;
	const SATZART_FELD *pFachHaupt, *pFachKopf;

	pKKContext = pCheckContext->pKKContext;
	if (!HasKAS (pKKContext)) return 0;

	pFachHaupt = pKKContext->ppKKSatzarten[4]->ppRef[K05_FACHHAUPTBEREICHSIND];
	pFachKopf  = pKKContext->ppKKSatzarten[4]->ppRef[K05_FACHAERZTE_KOPF];

	count = pKKContext->pSatzartCount[4];
	for (i = 0; i < pKKContext->nAbtCount; i++)
	{
		sAbtFC = pKKContext->pKKAbteilung[i].sAbtFC;
		if (pKKContext->pKKAbteilung[i].pK01 && sAbtFC[0] == '1') {
			nKopfZahl = 0;

			if (sAbtFC[2] != '9' || (sAbtFC[3] != '1' && sAbtFC[3] != '9'))
			{

                if (pCheckContext->pContext->modelljahr >= 2017) {
                    
                    const LKF_EXPANDED_LINE **ppK = pKKContext->pppExpandedLines[4];
                    
                    for (j = 0; !nKopfZahl && j < count; j++)
                    {
                        Satzart_GetValueStringExp (ppK[j], pFachHaupt, sFachHauptIndex, 4);
                        
                        if (!memcmp (sFachHauptIndex, pKKContext->pKKAbteilung[i].sAbtFC + 2, 2))
                        {
                            if (Satzart_GetValueIntExp (ppK[j], pFachKopf, &nKopfZahl) == LKF_FIELD_ERROR || nKopfZahl) nKopfZahl = 1;
                        }
                    }
                    
                }
                else {
                    for (j = 0; !nKopfZahl && j < count; j++)
                    {
                        ds = pKKContext->pppSatzartRecords[4][j];
                        len = pKKContext->ppSatzartRecordLen[4][j];
                        
                        Satzart_GetValueString (ds, len, pFachHaupt, sFachHauptIndex, 4);
                        
                        if (!memcmp (sFachHauptIndex, pKKContext->pKKAbteilung[i].sAbtFC + 2, 2))
                        {
                            if (Satzart_GetValueInt (ds, len, pFachKopf, &nKopfZahl) == LKF_FIELD_ERROR || nKopfZahl) nKopfZahl = 1;
                        }
                    }
                    
                }
			}
		}
	}


	return 0;
}

static int check_aerztliches_personal (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* EK76 \xc3\x84""rztliches Personal fehlt */
	int lVal;
	unsigned int count, i;
	LKF_KK_CONTEXT *pKKContext;
	const SATZART_FELD *pFeld1, *pFeld2;
    const LKF_EXPANDED_LINE **ppK;


	if (pCheckContext->pContext->isKTR)
		return 0;

	if (pCheckContext->pContext->period_type != 'J')
		return 0;

	pKKContext = pCheckContext->pKKContext;
	count = pKKContext->pSatzartCount[3];

	if (count > 0)
	{
		double dVal;
		char sPersGrpIndex[4];
		pFeld1 = pKKContext->ppKKSatzarten[3]->ppRef[K04_PERSONALGRUPPENINDEX];
		pFeld2 = pKKContext->ppKKSatzarten[3]->ppRef[K04_VOLLZEITAEQUIVALENTE];

        ppK = (pCheckContext->pContext->modelljahr >= 2017) ? pKKContext->pppExpandedLines[3] : 0;
        
		for (i = 0; i < count; i++)
		{
            ds = ppK ? (const char *) ppK[i] : pKKContext->pppSatzartRecords[3][i];
            len = ppK ? LKF_LEN_FOR_EXPANDEDLINE : pKKContext->ppSatzartRecordLen[3][i];
			Satzart_GetValueString (ds, len, pFeld1, sPersGrpIndex, 4);
			if (sPersGrpIndex[2] != '1')
				continue;

			if (Satzart_GetValueFloat (ds, len, pFeld2, &dVal, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR || dVal > DOUBLE_0_VALUE)
                return 0;

		}
	}

	count = pKKContext->pSatzartCount[4];

	if (count > 0)
	{
		pFeld1 = pKKContext->ppKKSatzarten[4]->ppRef[K05_FACHAERZTE_KOPF];
		pFeld2 = pKKContext->ppKKSatzarten[4]->ppRef[K05_AERZTE_ALLGMED_KOPF];

        ppK = (pCheckContext->pContext->modelljahr >= 2017) ? pKKContext->pppExpandedLines[4] : 0;

		for (i = 0; i < count; i++)
		{
            ds = ppK ? (const char *) ppK[i] : pKKContext->pppSatzartRecords[4][i];
            len = ppK ? LKF_LEN_FOR_EXPANDEDLINE : pKKContext->ppSatzartRecordLen[4][i];

			if (Satzart_GetValueInt (ds, len, pFeld1, &lVal) == LKF_FIELD_ERROR || lVal > 0)
                return 0;
			if (Satzart_GetValueInt (ds, len, pFeld2, &lVal) == LKF_FIELD_ERROR || lVal > 0)
                return 0;
		}
	}

	count = pKKContext->pSatzartCount[5];

	if (count > 0)
	{
		pFeld2 = pKKContext->ppKKSatzarten[5]->ppRef[K06_KONSILIARAERZTE_KOPF];

        ppK = (pCheckContext->pContext->modelljahr >= 2017) ? pKKContext->pppExpandedLines[5] : 0;

		for (i = 0; i < count; i++)
		{
            ds = ppK ? (const char *) ppK[i] : pKKContext->pppSatzartRecords[5][i];
            len = ppK ? LKF_LEN_FOR_EXPANDEDLINE : pKKContext->ppSatzartRecordLen[5][i];

			if (Satzart_GetValueInt (ds, len, pFeld2, &lVal) == LKF_FIELD_ERROR || lVal > 0)
				return 0;
		}
	}
	
	return 1;
}



/* Modell 2026: Antiinfektiva - A-Satzarten */

#define A01_STAAT           11
#define A01_PZN             12
#define A01_HANDELSNAME     13
#define A01_PCK_ANZ         14
#define A01_PE_M            15
#define A01_PE              16
#define A01_ATC             17

const LKF_SATZART_ERRORCHECK_STRINGLIST
stringlist_A01_einheit = {3, {"ml", "St\xc3\xbc""ck", "St\xfc""ck"}},
stringlist_A01_monat = {12, {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"}};

static int check_a01_abtfc (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    LKF_KK_CONTEXT_ABTEILUNG *pKKAbt;
    char sAbtFC[10];
    Satzart_GetValueString (ds, len, pFeld, sAbtFC, 10);
    pKKAbt = lkf_check_kk_abteilung (pCheckContext->pKKContext, sAbtFC, 1);
    if (!pKKAbt) {
        return 1;
    }
    pKKAbt->pA01 = ds;
    pKKAbt->nA01Len = len;
    if (!pKKAbt->pK01) {
        return 1;
    }
    return 0;
}

static int check_a01staat (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    char sStaat[8];
    if (!pCheckContext->pContext || !pCheckContext->pContext->pStamm2001) {
        return 1;
    }
    
    Satzart_GetValueString (ds, len, pFeld, sStaat, 6);
    if (StaatInArray(pCheckContext->pContext, sStaat)) {
        return 0;
    }
    
    return 1;
}

static int check_a01_atc (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    char sATC[12];
    if (!pCheckContext->pContext || !pCheckContext->pContext->pStamm2001) {
        return 1;
    }
    
    Satzart_GetValueString (ds, len, pFeld, sATC, 10);
    if (FindATC(pCheckContext->pContext->pStamm2001, sATC)) {
        return 0;
    }
    
    return 1;
}

const LKF_SATZART_ERRORDEF
LKFA01ErrorJahrfehlt =        {  1, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Berichtsjahr fehlt"},
LKFA01ErrorJahrfalsch  =        {  2, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Berichtsjahr - ung\xc3\xbc""ltige Jahresangabe"},
LKFA01ErrorMonatFalsch  =        {  3, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Berichtsmonat - Ung\xc3\xbc""ltige Monatsangabe"},
LKFA01ErrorAbtFCK01Fehlt  =        {  4, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Funktionscode nicht in Satzart K01 enthalten"},
LKFA01ErrorStaatFehlt  =        {  5, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Bezugsland fehlt"},
LKFA01ErrorStaatFalsch  =        {  6, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Bezugsland ung\xc3\xbc""ltig"},
LKFA01ErrorPZNFehlt  =        {  7, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Pharmazentralnummer fehlt"},
LKFA01ErrorHandelsNameFehlt  =        { 8, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Handelsname fehlt"},
LKFA01ErrorPackfehlt  =        {  9, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Anzahl abgerufener Packungen fehlt"},
LKFA01ErrorPackfalsch  =        { 10, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Anzahl abgerufener Packungen ung\xc3\xbc""ltig"},
LKFA01ErrorPackMengefehlt  =        {  11, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Menge je Packungseinheit fehlt"},
LKFA01ErrorPackMengefalsch  =        { 12, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Menge je Packungseinheit ung\xc3\xbc""ltig"},
LKFA01ErrorEinheitfalsch  =        {  13, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "Packungseinheit ung\xc3\xbc""ltig"},
LKFA01ErrorATCfalsch  =        {  14, LKF_FAC_A, LKF_SEV_ERROR, 0, 0, "ATC-Code ung\xc3\xbc""ltig"}
;

const LKF_SATZART_ERRORCHECK
LKFA01CheckJahrfalsch =            {LKF_CHECKFUNC_FUNCTION, kaskore_berichtsjahr, &LKFA01ErrorJahrfalsch, 0, 0},
LKFA01CheckJahr =                {LKF_CHECKFUNC_EXISTS, 0, &LKFA01ErrorJahrfehlt, 0, &LKFA01CheckJahrfalsch},
LKFA01CheckMonat = {LKF_CHECKFUNC_STRINGLIST, &stringlist_A01_monat, &LKFA01ErrorMonatFalsch, 0, 0},
LKFA01CheckAbtFC = {LKF_CHECKFUNC_FUNCTION, &check_a01_abtfc, &LKFA01ErrorAbtFCK01Fehlt, 0, 0},
LKFA01CheckEinheit = {LKF_CHECKFUNC_STRINGLIST, &stringlist_A01_einheit, &LKFA01ErrorEinheitfalsch, 0, 0},
LKFA01CheckStaatGueltig = {LKF_CHECKFUNC_FUNCTION, &check_a01staat, &LKFA01ErrorStaatFalsch, 0, 0},
LKFA01CheckStaat =                {LKF_CHECKFUNC_EXISTS, 0, &LKFA01ErrorStaatFehlt, 0, &LKFA01CheckStaatGueltig},
LKFA01CheckPZN = {LKF_CHECKFUNC_EXISTS, 0, &LKFA01ErrorPZNFehlt, 0, 0},
LKFA01CheckHandelsname =                {LKF_CHECKFUNC_EXISTS, 0, &LKFA01ErrorHandelsNameFehlt, 0, 0},
LKFA01CheckPackFormat =    {LKF_CHECKFUNC_FORMAT, 0, &LKFA01ErrorPackfalsch, 0, 0},
LKFA01CheckPack =            {LKF_CHECKFUNC_EXISTS_NOT0, 0, &LKFA01ErrorPackfehlt, 0, &LKFA01CheckPackFormat},
LKFA01CheckPackMengeFormat =    {LKF_CHECKFUNC_FORMAT, 0, &LKFA01ErrorPackMengefalsch, 0, 0},
LKFA01CheckATCfalsch = {LKF_CHECKFUNC_FUNCTION, &check_a01_atc, &LKFA01ErrorATCfalsch, 0, 0},
LKFA01CheckPackMenge =            {LKF_CHECKFUNC_EXISTS_NOT0, 0, &LKFA01ErrorPackMengefehlt, 0, &LKFA01CheckPackMengeFormat};


const int a01_ident[] = {0,1,2,3,4,5,6,-1};

const SATZART A01Satzart = {"A01", 0, 11, 11, (const int *) &a01_ident, "Antiinfektiva Abrufe",0, {
    {GEN_JAHR,                    TYP_NUM,        4,   4, &LKFA01CheckJahr, 0, "JAHR"},
    {GEN_MONAT,                   TYP_NUM,        4,   2, &LKFA01CheckMonat, 0, "MONAT"},
    {GEN_KANR,                    TYP_ALPHA,      6,   6, 0, 0, "KANR"},
    {GEN_ABTFC,                   TYP_ALPHA,     12,   8, &LKFA01CheckAbtFC, 0, "ABTFC"},
    {A01_STAAT,                   TYP_ALPHA,     20,   2, &LKFA01CheckStaat, 0, "BEZUGSSTAAT"},
    {A01_PZN,                     TYP_ALPHA,     22,  10, &LKFA01CheckPZN, 0, "PZN"},
    {A01_HANDELSNAME,             TYP_ALPHA,     32, 100, &LKFA01CheckHandelsname, 0, "HANDELSNAME"},
    {A01_PCK_ANZ,                 TYP_FLOAT_NEG,132,  10, &LKFA01CheckPack, 0, "ABG.PACKUNGEN"},
    {A01_PE_M,                    TYP_NUM,      142,  10, &LKFA01CheckPackMenge, 0, "MENGE/PACKUNG"},
    {A01_PE,                      TYP_ALPHA,    152,  10, &LKFA01CheckEinheit, 0, "EINHEIT"},
    {A01_ATC,                     TYP_ALPHA,    162,  10, &LKFA01CheckATCfalsch, 0, "ATC"}
}};
    



const SATZART M02StaticSatzart = {"M02", 0, 0, 0, 0, "M02 - Verlegungsdaten", 0, {{0}}};
const SATZART_INFO M02SatzartInfo = {&M02StaticSatzart, {0}, {0}};
const SATZART X02StaticSatzart = {"X02", 0, 0, 0, 0, "X02 - Verlegungsdaten", 0, {{0}}};
const SATZART_INFO X02SatzartInfo = {&X02StaticSatzart, {0}, {0}};

static void GenKKAbtError (LKF_CHECK_CONTEXT *pCheckContext, const LKF_SATZART_ERRORDEF *pErrorDef, LKF_KK_CONTEXT_ABTEILUNG *pKKAbteilung)
{
	if (pKKAbteilung->pK01)
	{
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, pKKAbteilung->pK01, pKKAbteilung->nK01Len,
							 pCheckContext->pKKContext->ppKKSatzarten[0], 0, pErrorDef, pKKAbteilung->sAbtFC);
	}

	if (pKKAbteilung->pK08)
	{
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, pKKAbteilung->pK08, pKKAbteilung->nK08Len,
							 pCheckContext->pKKContext->ppKKSatzarten[7], 0, pErrorDef, pKKAbteilung->sAbtFC);
	}

	if (pKKAbteilung->pK09)
	{
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, pKKAbteilung->pK09, pKKAbteilung->nK09Len,
							 pCheckContext->pKKContext->ppKKSatzarten[8], 0, pErrorDef, pKKAbteilung->sAbtFC);
	}

	if (pKKAbteilung->pK10)
	{
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, pKKAbteilung->pK10, pKKAbteilung->nK10Len,
							 pCheckContext->pKKContext->ppKKSatzarten[9], 0, pErrorDef, pKKAbteilung->sAbtFC);
	}

	if (pKKAbteilung->pG01)
	{
		Satzart_ReportError (pCheckContext->pContext, pCheckContext, pKKAbteilung->pG01, pKKAbteilung->nG01Len,
							 pCheckContext->pKKContext->ppGGSatzarten[0], 0, pErrorDef, pKKAbteilung->sAbtFC);
	}
    
    if (pKKAbteilung->pA01)
    {
        Satzart_ReportError (pCheckContext->pContext, pCheckContext, pKKAbteilung->pA01, pKKAbteilung->nA01Len,
                             pCheckContext->pKKContext->ppASatzarten[0], 0, pErrorDef, pKKAbteilung->sAbtFC);
    }
    

	if (pKKAbteilung->nHasM02Toleranz)
	{
        if (pCheckContext->pContext->modelljahr >= 2017) {
            Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0,
                                 &X02SatzartInfo, 0, pErrorDef, pKKAbteilung->sAbtFC); /* V21.2: M02->X02 */
        }
        else {
            Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0,
                                 &M02SatzartInfo, 0, pErrorDef, pKKAbteilung->sAbtFC);
        }

	}
}

static int general_checks (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	static int aMustKNFonds[5] = {2,3,4,7,8}; 
	static int aMustKSatzarten2008[14] = {2,3,4,5,7,8,9,10,11,12,13,14,15,16};
	unsigned int i, j;
	int nFound;
	char sAddInfo[48];
	char sGGArt[4], sGGLeist[4];
	int nG01Num, nG02Num, nVal;
	const SATZART_FELD *pG01Pos, *pG02Pos, *pG01Art, *pG02Freq, *pG02Amb, *pG02Stat, *pG02LstIndex;
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbteilung;
	const char *ds2;
	unsigned int len2;
	int aSLeistDaten[6];
    int modelljahr;
    
    const LKF_EXPANDED_LINE **ppG01, **ppG02;

    modelljahr = pCheckContext->pContext->modelljahr;
    
	if (pCheckContext->pContext->period_type == 'J' && pCheckContext->pKKContext->pSatzartCount[0] > 0)
	{
		if (pCheckContext->pContext->Count_M[0] == 0 && pCheckContext->pContext->Count_X[0] == 0)
		{
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorSatzartFehlt,
                                 modelljahr >= 2017 ? "X01" : "M01");
		}
		if (lkf_IsFondsKA (pCheckContext))
		{
			int *pMustSatzarten;
			unsigned int nSatzartenCount;

            pMustSatzarten = aMustKSatzarten2008;
            nSatzartenCount = 14;

			for (i = 0; i < nSatzartenCount; i++)
			{
				if (pCheckContext->pContext->Count_K[pMustSatzarten[i]-1] == 0)
				{
					sprintf (sAddInfo, "K%02d", pMustSatzarten[i]);
					Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorSatzartFehlt, sAddInfo);
				}
			}
		}
		else
		{
			for (i = 0; i < 5; i++)
			{
				if (pCheckContext->pContext->Count_K[aMustKNFonds[i]-1] == 0)
				{
					sprintf (sAddInfo, "K%02d", aMustKNFonds[i]);
					Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorSatzartFehlt, sAddInfo);
				}
			}
		}
	}

	if (!pCheckContext->pKKContext->lMBDSStatOk) k03_mbdsstat (pCheckContext,0);

	for (i = 0; i < pCheckContext->pKKContext->nAbtCount; i++)
	{
		pKKAbteilung = pCheckContext->pKKContext->pKKAbteilung + i;

		if (modelljahr >= 2012 && pKKAbteilung->sAbtFC[0] == '9') continue; /* V17.0 */
			
		if (!memcmp (pKKAbteilung->sAbtFC, "        ", 8) || pKKAbteilung->sAbtFC[0] == 0)
		{
			GenKKAbtError (pCheckContext, &LKFErrorFCfehlt, pKKAbteilung);
		}
		else if (modelljahr >= 2010 && !memcmp (pKKAbteilung->sAbtFC, UNTERBRECHUNG_ABTFC, UNTERBRECHUNG_LEN))
			continue;
		else if (!FunkInArray (pCheckContext->pContext->pStamm2001, pKKAbteilung->sAbtFC))
		{
				GenKKAbtError (pCheckContext, &LKFErrorFCfalsch, pKKAbteilung);
		}
		else if (!pKKAbteilung->pK01 && (pKKAbteilung->pK08 || pKKAbteilung->pK09 || pKKAbteilung->pK10 || (pKKAbteilung->nHasM02Toleranz || (pKKAbteilung->nHasM02Jahr && modelljahr >= 2024 /* V2025.0 */)) || pKKAbteilung->pG01))
		{
//            char dat[10];
//            printf("%8.8s: %8.8s\n", pKKAbteilung->sAbtFC, lkf_int2dat(pKKAbteilung->lLatestEntDat, dat));
            
			GenKKAbtError (pCheckContext, &LKFErrorFCnichtimKostPlan, pKKAbteilung);
			sprintf (sAddInfo, "%8.8s", pCheckContext->pKKContext->pKKAbteilung[i].sAbtFC);
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorK01fehlt, sAddInfo);
		}
		else if (pKKAbteilung->nHasM02Toleranz && !pKKAbteilung->pK08)
		{
            
            if (modelljahr >= 2018 && (pCheckContext->pContext->flags & LKFCONTEXT_NICHTFONDSKA) && IsNBettHK(pCheckContext->pContext, pKKAbteilung->sAbtFC))
                continue; /* V2019.0 */
            
			if (pCheckContext->pContext->period_type == 'J' && pCheckContext->pKKContext->pSatzartCount[0] > 0)
			{
				sprintf (sAddInfo, "%8.8s", pKKAbteilung->sAbtFC);
                if (modelljahr >= 2017) {
                    if (!pKKAbteilung->pK09) {
                        Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorK08fehlt2017, sAddInfo);
                    }
                }
                else
                    Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorK08fehlt, sAddInfo);
            }
		}
	}

	pG01Pos  = pCheckContext->pKKContext->ppGGSatzarten[0]->ppRef[G01_POSNR];
	pG01Art  = pCheckContext->pKKContext->ppGGSatzarten[0]->ppRef[G01_ART];
	pG02Pos  = pCheckContext->pKKContext->ppGGSatzarten[1]->ppRef[G02_POSNR];
	
	pG02Amb  = pCheckContext->pKKContext->ppGGSatzarten[1]->ppRef[G02_AMB_FREQUENZEN];
	pG02Stat = pCheckContext->pKKContext->ppGGSatzarten[1]->ppRef[G02_STAT_FREQUENZEN];
	pG02Freq = pCheckContext->pKKContext->ppGGSatzarten[1]->ppRef[G02_AVG_DAUER_FREQ_MIN];
	pG02LstIndex  = pCheckContext->pKKContext->ppGGSatzarten[1]->ppRef[G02_LSTINDEX];

    if (modelljahr >= 2017) {
        ppG01 = pCheckContext->pKKContext->pppGGExpandedLines[0];
        ppG02 = pCheckContext->pKKContext->pppGGExpandedLines[1];
    }
    else {
        ppG01 = ppG02 = 0;
    }
    
	for (i = 0; i < pCheckContext->pKKContext->pGGSatzartCount[1]; i++)
	{
        ds = ppG02 ? (const char *) ppG02[i] : pCheckContext->pKKContext->pppGGSatzartRecords[1][i];
        len = ppG02 ? LKF_LEN_FOR_EXPANDEDLINE : pCheckContext->pKKContext->ppGGSatzartRecordLen[1][i];
		nFound = 0;

		if (!Satzart_GetValueInt (ds, len, pG02Pos, &nG02Num))
		{
            if (ppG01) {
                for (j = 0; !nFound && j < pCheckContext->pKKContext->pGGSatzartCount[0]; j++)
                {
                    if (!Satzart_GetValueIntExp (ppG01[j], pG01Pos, &nG01Num) && nG01Num == nG02Num) nFound = 1;
                }
            }
            else {
                for (j = 0; !nFound && j < pCheckContext->pKKContext->pGGSatzartCount[0]; j++)
                {
                    if (!Satzart_GetValueInt (pCheckContext->pKKContext->pppGGSatzartRecords[0][j], pCheckContext->pKKContext->ppGGSatzartRecordLen[0][j], pG01Pos, &nG01Num) && nG01Num == nG02Num) nFound = 1;
                }
            }
            

			if (!nFound)
			{
				Satzart_ReportError (pCheckContext->pContext, pCheckContext, ds, len, pCheckContext->pKKContext->ppGGSatzarten[1], pG02Pos, &LKFErrorG01fehlt, 0);
			}

		}
	}

	for (i = 0; i < pCheckContext->pKKContext->pGGSatzartCount[0]; i++)
	{
        ds = ppG01 ? (const char *) ppG01[i] : pCheckContext->pKKContext->pppGGSatzartRecords[0][i];
        len = ppG01 ? LKF_LEN_FOR_EXPANDEDLINE : pCheckContext->pKKContext->ppGGSatzartRecordLen[0][i];
		nFound = 0;

		Satzart_GetValueString (ds, len, pG01Art, sGGArt, 4);
		sGGArt[3] = 0;
		if (!Satzart_GetValueInt (ds, len, pG01Pos, &nG01Num))
		{

			for (j = 0; j < 6; j++) aSLeistDaten[j] = 0;

			for (j = 0; j < pCheckContext->pKKContext->pGGSatzartCount[1]; j++)
			{
                ds2 = ppG02 ? (const char *) ppG02[j]: pCheckContext->pKKContext->pppGGSatzartRecords[1][j];
                len2 = ppG02 ? LKF_LEN_FOR_EXPANDEDLINE : pCheckContext->pKKContext->ppGGSatzartRecordLen[1][j];

				if (!Satzart_GetValueInt (ds2, len2, pG02Pos, &nG02Num) && nG01Num == nG02Num) 
				{
					if (!nFound)
					{
						Satzart_GetValueInt (ds2, len2, pG02Amb, &nVal); 
						if (nVal > 0) nFound = 1;
						else
						{
							Satzart_GetValueInt (ds2, len2, pG02Stat, &nVal); 
							if (nVal > 0) nFound = 1;
						}
					}

					Satzart_GetValueString (ds2, len2, pG02LstIndex, sGGLeist, 4);
 
					/* alle Leistungen au\xc3\x9f""er S51-S53, S57-S59 */
					nVal = atoi (sGGLeist + 1);

					if (sGGLeist[0] == 'S' && nVal >= 51 && nVal <= 56)
						aSLeistDaten[nVal - 51] = 1;

				}
			}

			if (!nFound)
			{
				sprintf (sAddInfo, "%3.3s", sGGArt);
				Satzart_ReportError (pCheckContext->pContext, pCheckContext, ds, len, pCheckContext->pKKContext->ppGGSatzarten[0], pG01Pos, &LKFGGErrorPosNichtVorhanden, sAddInfo);
			}

			if (sGGArt[0] == 'S')
			{
				nVal = atoi (sGGArt + 1);
				if (nVal >= 1 && nVal <= 49)
				{
					int nCount = 0;

                    if (pCheckContext->pContext->modelljahr >= 2018 || aSLeistDaten[0] || aSLeistDaten[1] || aSLeistDaten[2]) nCount++;
                    if (aSLeistDaten[3] || aSLeistDaten[4] || aSLeistDaten[5]) nCount++;

					if (nCount < 2)
					{
						sprintf (sAddInfo, "%3.3s", sGGArt);
						Satzart_ReportError (pCheckContext->pContext, pCheckContext, ds, len,pCheckContext->pKKContext->ppGGSatzarten[0] /* V9.4, V10.1: G02 */, 0, &LKFGGErrorStrahlentherapie, sAddInfo);
					}
				}
			}
		}
	}

	if (pCheckContext->pContext->period_type == 'J' && !pCheckContext->pContext->isKTR /* V14.2 */)
	{
		if (pCheckContext->pKKContext->lVerbleib == 0)
			Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorKeineVPatienten, 0);
	}

	return 0;
}

static int check_k04k07 (const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext, char cK04PersGruppe, const char *sK07IndexMin, const char *sK07IndexMax)
{
	char sIndex[6];
	const char *ds;
	unsigned int len;
	unsigned int nCount, i;
	double dCur, dK04, dK07;
	LKF_KK_CONTEXT *pKKContext;
	const SATZART_FELD *pK04Index, *pK04VZEQ;
	const SATZART_FELD *pK07Index, *pK07M, *pK07W;
    const LKF_EXPANDED_LINE **ppK;
    
    int modelljahr;

	pKKContext = pCheckContext->pKKContext;
	pK04VZEQ = pKKContext->ppKKSatzarten[3]->ppRef[K04_VOLLZEITAEQUIVALENTE];
	pK04Index = pKKContext->ppKKSatzarten[3]->ppRef[K04_PERSONALGRUPPENINDEX];
	
	pK07Index = pKKContext->ppKKSatzarten[6]->ppRef[K07_NICHTAERZTL_GESBERUF];
	pK07M = pKKContext->ppKKSatzarten[6]->ppRef[K07_MAENNL_VZEQ];
	pK07W = pKKContext->ppKKSatzarten[6]->ppRef[K07_WEIBL_VZEQ];

    modelljahr = pCheckContext->pContext->modelljahr;
    
	dK04 = 0;
	dK07 = 0;

	nCount = pKKContext->pSatzartCount[3];
    
    ppK = (pCheckContext->pContext->modelljahr >= 2017) ? pKKContext->pppExpandedLines[3]: 0;
    
	for (i = 0; i < nCount; i++)
	{
        ds =  ppK ? (const char *) ppK[i] : pKKContext->pppSatzartRecords[3][i];
        len = ppK ? LKF_LEN_FOR_EXPANDEDLINE : pKKContext->ppSatzartRecordLen[3][i];
	
		Satzart_GetValueString (ds, len, pK04Index, sIndex, 4);

		if (sIndex[0] == 'Z' || sIndex[2] != cK04PersGruppe)
			continue;

		if (Satzart_GetValueFloat (ds, len, pK04VZEQ, &dCur, modelljahr) == LKF_FIELD_ERROR)
			return 0;
		dK04 += dCur;
	}
	nCount = pKKContext->pSatzartCount[6];
    ppK = (pCheckContext->pContext->modelljahr >= 2017) ? pKKContext->pppExpandedLines[6]: 0;

	for (i = 0; i < nCount; i++)
	{
        len = ppK ? LKF_LEN_FOR_EXPANDEDLINE : pKKContext->ppSatzartRecordLen[6][i];
        ds = ppK ? (const char *) ppK[i] : pKKContext->pppSatzartRecords[6][i];

		Satzart_GetValueString (ds, len, pK07Index, sIndex, 3);

		if (memcmp (sIndex, sK07IndexMin, 2) < 0 || memcmp (sIndex, sK07IndexMax, 2) > 0)
			continue;

		if (Satzart_GetValueFloat (ds, len, pK07M, &dCur, modelljahr) == LKF_FIELD_ERROR)
			return 0;
		dK07 += dCur;
		if (Satzart_GetValueFloat (ds, len, pK07W, &dCur, modelljahr) == LKF_FIELD_ERROR)
			return 0;
		dK07 += dCur;
	}

	if (dK04+0.1 < dK07 || dK07+0.1 < dK04)
	{
		sprintf (pCheckContext->sErrorAdditionalInfo, "%8.2f/%8.2f", dK04, dK07);
		return 1;
	}
	return 0;
}

static int check_k04k07_hebamme (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return check_k04k07 (pCheck, pCheckContext, '3', "30", "30");
}

static int check_k04k07_gehdienst (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    if (pCheckContext->pContext->modelljahr >= 2024)
    { /* V2024.1 */
        return check_k04k07 (pCheck, pCheckContext, '4', "41", "4A");
    }
    else {
        return check_k04k07 (pCheck, pCheckContext, '4', "41", "44");
    }
}

static int check_k04k07_gehmedtechn (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return check_k04k07 (pCheck, pCheckContext, '5', "51", "59");
}

static int check_k04k07_pflege (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    if (pCheckContext->pContext->modelljahr >= 2017)
    {
        /* V22.0 */
        return check_k04k07 (pCheck, pCheckContext, '6', "61", "6C");
    }
    
    if (pCheckContext->pContext->modelljahr >= 2014) {
        /* V18.0 */
        return check_k04k07 (pCheck, pCheckContext, '6', "61", "6B");
    }
	return check_k04k07 (pCheck, pCheckContext, '6', "61", "69");
}

const LKF_SATZART_ERRORCHECK
	LKFKKCheckFachhauptohneAerztPers2007 =  {LKF_CHECKFUNC_FUNCTION, k05_check_fachhaupt_k05, &LKFKKErrorFachhauptohneAerztPers, 0, 0}, /* V12.0 */
	LKFKKCheckPersVollzeitGesamt =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k04_persvollzeit_gesamt, &LKFKKErrorPersVollzeit1, 0, 0},
	LKFKKCheckKostenstelleimPlanOhneDaten = {LKF_CHECKFUNC_FUNCTION, check_kostenstelle_ohne_daten, &LKFKKErrorKostenstelleimPlanOhneDaten, 0, 0},
	LKFKKCheckGesamtumlageFehlerhaft2005 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_gesamtumlagefehlerhaft, &LKFKKErrorGesamtumlageFehlerhaft, 0, 0},
	LKFKKCheckGesamtumlageFehlerhaft =		{LKF_CHECKFUNC_FUNCTION, check_gesamtumlagefehlerhaft, &LKFKKErrorGesamtumlageFehlerhaft, 0, 0, 2005, &LKFKKCheckGesamtumlageFehlerhaft2005 /* V10.1 */},
/*	LKFKKCheckKombAbtFCSatzart =			{LKF_CHECKFUNC_FUNCTION, check_kombabtfc_satzart, &LKFKKErrorKombAbtFCSatzart, 0, 0}, */
	LKFKKCheckAquMLVunplaus2005 =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_mlv, 0, 0, 0},
	LKFKKCheckAbtFCDLBOhneStat =			{LKF_CHECKFUNC_FUNCTION, check_abtfcdlb_ohne_stat, &LKFKKErrorAbtFCDLBOhneStat, 0, 0},
	LKFKKCheckAbtFCStatohneDLB =			{LKF_CHECKFUNC_FUNCTION, check_abtfcstat_ohne_dlb, &LKFKKErrorAbtFCStatohneDLB, 0, 0},
	LKFKKCheckNArztOhnePers =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, k07_check_summe, &LKFKKErrorNArztOhnePers, 0, 0},
	LKFKKCheckNArztVergleich =				{LKF_CHECKFUNC_FUNCTION, k07_check_gesberufe, &LKFKKErrorNArztVergleich, 0, 0},
	LKFKKCheckKeinFacharzt =				{LKF_CHECKFUNC_FUNCTION, k05_check_keinFacharzt, 0 /* V9.4 &LKFKKErrorKeinFacharzt */, 0, 0},
	LKFKKCheckGeneralChecks =				{LKF_CHECKFUNC_FUNCTION, general_checks, &LKFErrorG01fehlt, 0, 0},
	LKFKKCheckPensKost2005 =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_penskost_unvollst, 0, 0, 0},
	LKFKKCheckPensKost =					{LKF_CHECKFUNC_FUNCTION, check_penskost_unvollst, 0, 0, 0, 2005, &LKFKKCheckPensKost2005},
	LKFKKCheckKeinAerztlichesPersonal =     {LKF_CHECKFUNC_FUNCTION, check_aerztliches_personal, &LKFKKErrorKeinAerztlichesPersonal, 0, 0},
	LKFKKCheckK04K07Hebamme =				{LKF_CHECKFUNC_FUNCTION, check_k04k07_hebamme, &LKFErrorK04K07Hebamme, 0, 0},
	LKFKKCheckK04K07GehDienst =				{LKF_CHECKFUNC_FUNCTION, check_k04k07_gehdienst, &LKFErrorK04K07GehDienst, 0, 0},
	LKFKKCheckK04K07GehMedTechn =			{LKF_CHECKFUNC_FUNCTION, check_k04k07_gehmedtechn, &LKFErrorK04K07GehMedTechn, 0, 0},
	LKFKKCheckK04K07Pflege =				{LKF_CHECKFUNC_FUNCTION, check_k04k07_pflege, &LKFErrorK04K07Pflege, 0, 0},
	LKFKKCheckPersonalKopfVZEQ =			{LKF_CHECKFUNC_FUNCTION, k07_check_kopfvzeq, &LKFKKErrorKopfVZEQ, 0, 0};

const LKF_SATZART_ERRORCHECK *GenKKChecks2008[] = {&LKFKKCheckKostenstelleimPlanOhneDaten, &LKFKKCheckGesamtumlageFehlerhaft,
			&LKFKKCheckAquMLVunplaus2005,
			&LKFKKCheckAbtFCDLBOhneStat, &LKFKKCheckAbtFCStatohneDLB, 
			&LKFKKCheckPersVollzeitGesamt, &LKFKKCheckNArztOhnePers, &LKFKKCheckNArztVergleich, &LKFKKCheckKeinFacharzt, 
			&LKFKKCheckFachhauptohneAerztPers2007, &LKFKKCheckGeneralChecks, &LKFKKCheckPensKost, &LKFKKCheckKeinAerztlichesPersonal /* V12.1 */,
			&LKFKKCheckK04K07Hebamme, &LKFKKCheckK04K07GehDienst, &LKFKKCheckK04K07GehMedTechn, &LKFKKCheckK04K07Pflege, &LKFKKCheckPersonalKopfVZEQ, 0};

const LKF_SATZART_ERRORDEF *GenKKErrors[] = {&LKFKKErrorPersonalKostenOhnePers, &LKFKKErrorAquMLV11unplaus, &LKFKKErrorAquMLV12unplaus, &LKFKKErrorAquMLV13unplaus, 
														&LKFKKErrorAquMLV14unplaus, &LKFKKErrorAquMLV15unplaus, &LKFKKErrorAquMLV16unplaus, 
														&LKFKKErrorAquMLV17unplaus, &LKFKKErrorAquMLV18unplaus, &LKFKKErrorAquMLV19unplaus, &LKFKKErrorPersVollzeit2, 
														&LKFKKErrorArztFachK04DienstKopf,
														&LKFKKErrorPensionskostenUnvollst, &LKFKKErrorKostenstellePensNichtOK, &LKFKKErrorVorsteuerUnvollst, &LKFKKErrorKostVorsteuerNichtOK, &LKFKKErrorKostMindVorsteuerFalsch, &LKFKKErrorMLVAbhaengigkeit,
														&LKFKKErrorGesamtumlageKOAGR11unplaus, &LKFKKErrorGesamtumlageKOAGR12unplaus, &LKFKKErrorGesamtumlageKOAGR13unplaus, &LKFKKErrorGesamtumlageKOAGR14unplaus, &LKFKKErrorNegKosten1000, 
														&LKFKKErrorAquMLV11unplaus, &LKFKKErrorAquMLV12unplaus, &LKFKKErrorAquMLV13unplaus, 
														&LKFKKErrorAquMLV14unplaus, &LKFKKErrorAquMLV15unplaus, &LKFKKErrorAquMLV16unplaus, 
														&LKFKKErrorAquMLV17unplaus, &LKFKKErrorAquMLV18unplaus, &LKFKKErrorAquMLV19unplaus,
																	 &LKFGGErrorPosNichtVorhanden, &LKFGGErrorStrahlentherapie, &LKFErrorKeineVPatienten, &LKFErrorBelagstageDifferenz, &LKFKKErrorKeinAerztlichesPersonal,
														&LKFErrorK04K05VZEQunter, &LKFErrorK04K05VZEQueber, &LKFKKErrorKostMindFLAFFalsch, &LKFKKErrorFuncLeistBereich /* V17.0 */, &LKFErrorSPEZAbt /* V2019.0 */, 0};

const LKF_SATZART_ERRORDEF *GenKKErrors2024[] = {&LKFKKErrorPersonalKostenOhnePers, &LKFKKErrorAquMLV11unplaus, &LKFKKErrorAquMLV12unplaus, &LKFKKErrorAquMLV13unplaus,
                                                        &LKFKKErrorAquMLV14unplaus, &LKFKKErrorAquMLV15unplaus, &LKFKKErrorAquMLV16unplaus,
                                                        &LKFKKErrorAquMLV17unplaus, &LKFKKErrorAquMLV18unplaus, &LKFKKErrorAquMLV19unplaus, &LKFKKErrorPersVollzeit2,
                                                        &LKFKKErrorArztFachK04DienstKopf,
                                                        &LKFKKErrorPensionskostenUnvollst, &LKFKKErrorKostenstellePensNichtOK, &LKFKKErrorVorsteuerUnvollst, &LKFKKErrorKostVorsteuerNichtOK, &LKFKKErrorKostMindVorsteuerFalsch, &LKFKKErrorMLVAbhaengigkeit,
                                                        &LKFKKErrorGesamtumlageKOAGR11unplaus, &LKFKKErrorGesamtumlageKOAGR12unplaus, &LKFKKErrorGesamtumlageKOAGR13unplaus, &LKFKKErrorGesamtumlageKOAGR14unplaus, &LKFKKErrorNegKosten1000,
                                                        &LKFKKErrorAquMLV11unplaus, &LKFKKErrorAquMLV12unplaus, &LKFKKErrorAquMLV13unplaus,
                                                        &LKFKKErrorAquMLV14unplaus, &LKFKKErrorAquMLV15unplaus, &LKFKKErrorAquMLV16unplaus,
                                                        &LKFKKErrorAquMLV17unplaus, &LKFKKErrorAquMLV18unplaus, &LKFKKErrorAquMLV19unplaus,
                                                                     &LKFGGErrorPosNichtVorhanden, &LKFGGErrorStrahlentherapie, &LKFErrorKeineVPatienten, &LKFErrorBelagstageDifferenz, &LKFKKErrorKeinAerztlichesPersonal,
                                                        &LKFErrorK04K05VZEQunter, &LKFErrorK04K05VZEQueber, &LKFKKErrorKostMindFLAFFalsch, &LKFKKErrorFuncLeistBereich, &LKFErrorSPEZAbt2024, 0};

/*********************************************************************************************
** Grossger\xc3\xa4""te-Satzarten                                                                    **
*********************************************************************************************/

const LKF_SATZART_ERRORDEF
	LKFGGErrorBerichtsjahrfehlt =		{  1, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Berichtsjahr fehlt"},
	LKFGGErrorBerichtsjahrfalsch  =		{  2, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Berichtsjahr - ung\xc3\xbc""ltige Jahresangabe"},
	LKFGGErrorPosFehlt =				{  3, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Gro\xc3\x9f""ger\xc3\xa4""t - Positionsnummer fehlt"},
	LKFGGErrorArtFehlt =				{  4, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Gro\xc3\x9f""ger\xc3\xa4""t - Art (Ger\xc3\xa4""teindex) fehlt"},
	LKFGGErrorNichtBettHK =				{  5, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Nur Funktionscode f\xc3\xbc""r nicht-bettenf\xc3\xbc""hrende Kostenstellen zul\xc3\xa4""ssig"},
	LKFGGErrorPosFalsch =				{  6, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Gro\xc3\x9f""ger\xc3\xa4""t - Positionsnummer ung\xc3\xbc""ltig"},
	LKFGGErrorArtFalsch =				{  7, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Gro\xc3\x9f""ger\xc3\xa4""t - Art (Ger\xc3\xa4""teindex) ung\xc3\xbc""ltig"},
	LKFGGErrorLeistIndexFehlt =			{  9, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Gro\xc3\x9f""ger\xc3\xa4""t - Leistungsindex fehlt"},
	LKFGGErrorLeistIndexFalsch =		{ 10, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Gro\xc3\x9f""ger\xc3\xa4""t - Leistungsindex ung\xc3\xbc""ltig"},
	LKFGGErrorAmbFalsch =				{ 11, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Ambulante Frequenzen/Patienten/Felder ung\xc3\xbc""ltig"},
	LKFGGErrorStatFalsch =				{ 12, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Station\xc3\xa4""re Frequenzen/Patienten/Felder ung\xc3\xbc""ltig"},
	LKFGGErrorAvgDauerFreqMinFalsch =	{ 13, LKF_FAC_GG, LKF_SEV_ERROR, 0, 0, "Durchschnittliche Dauer je Frequenz in Minuten ung\xc3\xbc""ltig"},
	LKFGGErrorTypeFehlt =				{101, LKF_FAC_GG, LKF_SEV_WARNING, 0, 0, "Gro\xc3\x9f""ger\xc3\xa4""t - Type fehlt"},
	LKFGGErrorAnschaffKostenFehlt =		{102, LKF_FAC_GG, LKF_SEV_WARNING, 0, 0, "Anschaffungskosten fehlen"},
	LKFGGErrorAnschaffKostenFalsch =	{103, LKF_FAC_GG, LKF_SEV_WARNING, 0, 0, "Anschaffungskosten ung\xc3\xbc""ltig"};

static int gg_checkart (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sGGArt[4];
	Satzart_GetValueString (ds, len, pFeld, sGGArt, 4);
	if (!FindGGArt (pCheckContext->pContext, sGGArt)) return 1;
	return 0;
}

static int gg_checkleistungsindex (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sGGLeist[4];
	Satzart_GetValueString (ds, len, pFeld, sGGLeist, 4);
	if (!FindGGLeist (pCheckContext->pContext, sGGLeist)) return 1;
	return 0;
}

static int gg_checkNichtBettHK (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	LKF_KK_CONTEXT_ABTEILUNG *pKKAbt;
	char sAbtFC[10];
	Satzart_GetValueString (ds, len, pFeld, sAbtFC, 10);
	pKKAbt = lkf_check_kk_abteilung (pCheckContext->pKKContext, sAbtFC, 1);
	pKKAbt->nG01Len = len;
	pKKAbt->pG01 = ds;

		return IsNBettHK (pCheckContext->pContext, sAbtFC) ? 0 : 1;
}

static int gg_check_dauer (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sGGLeist[6];
	int lNum;
	int nVal;

	if (Satzart_GetValueInt (ds, len, pFeld, &lNum) != LKF_FIELD_ERROR && lNum == 0)
	{
		Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppGGSatzarten[1]->ppRef[G02_LSTINDEX], sGGLeist, 4);

		nVal = atoi (sGGLeist + 1);

		if (sGGLeist[0] != 'S' || nVal < 51 || nVal > 59 || (nVal > 53 && nVal < 57))
		{
			if ((Satzart_GetValueInt (ds, len, pCheckContext->pKKContext->ppGGSatzarten[1]->ppRef[G02_AMB_FREQUENZEN], &lNum) != LKF_FIELD_ERROR && lNum != 0) ||
			    (Satzart_GetValueInt(ds, len, pCheckContext->pKKContext->ppGGSatzarten[1]->ppRef[G02_STAT_FREQUENZEN], &lNum) != LKF_FIELD_ERROR && lNum != 0))
			{
				char sPosBuf[6];
				Satzart_GetValueString (ds, len, pCheckContext->pKKContext->ppGGSatzarten[1]->ppRef[G02_POSNR], sPosBuf, 6);
				sprintf (pCheckContext->sErrorAdditionalInfo, "%4.4s: %3.3s", sPosBuf, sGGLeist);
				return 1;
			}
		}
	}
	return 0;
}


const LKF_SATZART_ERRORCHECK
	LKFGGCheckBerichtsjahrfalsch =		{LKF_CHECKFUNC_FUNCTION, kaskore_berichtsjahr, &LKFGGErrorBerichtsjahrfalsch, 0, 0},
	LKFGGCheckBerichtsjahr =			{LKF_CHECKFUNC_EXISTS, 0, &LKFGGErrorBerichtsjahrfehlt, 0, &LKFGGCheckBerichtsjahrfalsch},
	LKFGGCheckPosFalsch =				{LKF_CHECKFUNC_FORMAT, 0, &LKFGGErrorPosFalsch, 0, 0},
	LKFGGCheckPosFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFGGErrorPosFehlt, 0, &LKFGGCheckPosFalsch},
	LKFGGCheckArtFalsch =				{LKF_CHECKFUNC_FUNCTION, gg_checkart, &LKFGGErrorArtFalsch, 0, 0},
	LKFGGCheckArtFehlt =				{LKF_CHECKFUNC_EXISTS, 0, &LKFGGErrorArtFehlt, 0, &LKFGGCheckArtFalsch},
	LKFGGCheckLeistIndexFalsch =		{LKF_CHECKFUNC_FUNCTION, gg_checkleistungsindex, &LKFGGErrorLeistIndexFalsch, 0, 0},
	LKFGGCheckLeistIndexFehlt =			{LKF_CHECKFUNC_EXISTS, 0, &LKFGGErrorLeistIndexFehlt, 0, &LKFGGCheckLeistIndexFalsch},
	LKFGGCheckNichtBettHK =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, gg_checkNichtBettHK, &LKFGGErrorNichtBettHK, 0, 0},
	LKFGGCheckAmb =						{LKF_CHECKFUNC_FORMAT, 0, &LKFGGErrorAmbFalsch, 0, 0},
	LKFGGCheckStat =					{LKF_CHECKFUNC_FORMAT, 0, &LKFGGErrorStatFalsch, 0, 0},
	LKFGGCheckType =					{LKF_CHECKFUNC_EXISTS, 0, &LKFGGErrorTypeFehlt, 0, 0},
	LKFGGCheckAnschaffKostenFalsch =	{LKF_CHECKFUNC_FORMAT, 0, &LKFGGErrorAnschaffKostenFalsch, 0, 0},
	LKFGGCheckAnschaffKostenFehlt =		{LKF_CHECKFUNC_EXISTS_NOT0, 0, &LKFGGErrorAnschaffKostenFehlt, 0, &LKFGGCheckAnschaffKostenFalsch},
	LKFGGCheckAvgDauerFreqMinFalsch =   {LKF_CHECKFUNC_FORMAT, 0, &LKFGGErrorAvgDauerFreqMinFalsch, 0, 0},
	LKFGGCheckAvgDauerFreqFehlt =		{LKF_CHECKFUNC_FUNCTION, gg_check_dauer, &LKFGGErrorAvgDauerFreqFehlt, 0, &LKFGGCheckAvgDauerFreqMinFalsch};

	int g01_ident[] = {0,1,2,3,-1};

const SATZART G01Satzart = {"G01", 0,  11, 11, (const int *) &g01_ident, "Grossgeraetebasisdaten", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFGGCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{GEN_ABTFC,					TYP_NUM,    14,  8, &LKFGGCheckNichtBettHK, 0, "ABTFC"},
	{G01_POSNR,					TYP_NUM,	22,  4, &LKFGGCheckPosFehlt, 0, "GROSSGERAET - POSITIONSNUMMER"},
	{G01_ART,					TYP_ALPHA,	26,  3, &LKFGGCheckArtFehlt, 0, "GROSSGERAET - ART"},
	{G01_TYPE,					TYP_ALPHA,	29,100, &LKFGGCheckType, 0, "GROSSGERAET - TYPE"},
	{G01_HERSTELLER,			TYP_ALPHA, 129,100, 0, 0, "HERSTELLER"},
	{G01_BAUJAHR,				TYP_NUM,   229,  4, 0, 0, "BAUJAHR"},
	{G01_ANSCHAFFKOSTEN,		TYP_NUM,   233, 10, &LKFGGCheckAnschaffKostenFehlt, 0, "ANSCHAFFUNGSKOSTEN"},
	{G01_BETRIEBSZEITEN,		TYP_ALPHA, 243,200, 0, 0, "BETRIEBSZEITEN"},
	{G01_KOMMENTAR,				TYP_ALPHA, 443,200, 0, 0, "KOMMENTAR"}
}};

const SATZART G02Satzart = {"G02", 0,  7, 7, (const int *) &g01_ident, "Grossgeraeteleistungsdaten", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFGGCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{G02_POSNR,					TYP_NUM,    14,  4, &LKFGGCheckPosFehlt, 0, "GROSSGERAET - POSITIONSNUMMER"},
	{G02_LSTINDEX,				TYP_ALPHA,	18,  3, &LKFGGCheckLeistIndexFehlt, 0, "GROSSGERAET - LEISTUNGSINDEX"},
	{G02_AMB_FREQUENZEN,		TYP_NUM,	21, 10, &LKFGGCheckAmb, 0, "AMB.FREQUENZEN/PATIENTEN/FELDER"},
	{G02_STAT_FREQUENZEN,		TYP_NUM,	31, 10, &LKFGGCheckStat, 0, "STAT.FREQUENZEN/PATIENTEN/FELDER"},
	{G02_AVG_DAUER_FREQ_MIN,	TYP_NUM,	41,  4, &LKFGGCheckAvgDauerFreqFehlt, 0, "DURCHSCH.DAUER JE FREQ. IN MIN."}
}};

#define LKF_SATZART_DEFS_MINIMUM 2009
#define LKF_SATZART_DEFS_MAXIMUM 2058

static LKF_SATZART_DEFS *ppSatzarten[LKF_SATZART_DEFS_MAXIMUM - LKF_SATZART_DEFS_MINIMUM + 1] = {
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};

extern const SATZART B01Satzart, B02Satzart, B03Satzart, B04Satzart, B05Satzart, B06Satzart;
extern const SATZART X01Satzart, X02Satzart, X03Satzart, X04Satzart, X05Satzart, X06Satzart, X07Satzart;
extern const SATZART O02Satzart; /* V2021.3 */

static void Free_SatzartDef (LKF_SATZART_DEFS *pDef)
{
    if (pDef) {
        if (pDef->ppSatzarten) LKF_FREE (0, "Free_SatzartDef", (void *)pDef->ppSatzarten);
        if (pDef->pL01Internal) LKF_FREE (0, "Free_SatzartDef", (void *)pDef->pL01Internal);
        if (pDef->pSatzartInfo) LKF_FREE (0, "Free_SatzartDef", (void*)pDef->pSatzartInfo);
        if (pDef->ppI) LKF_FREE(0, "Free_SatzartDef", (void*)pDef->ppI);
        if (pDef->ppK) LKF_FREE(0, "Free_SatzartDef", (void*)pDef->ppK);
        if (pDef->ppG) LKF_FREE(0, "Free_SatzartDef", (void*)pDef->ppG);
        if (pDef->ppL) LKF_FREE(0, "Free_SatzartDef", (void*)pDef->ppL);
        if (pDef->ppS) LKF_FREE(0, "Free_SatzartDef", (void*)pDef->ppS);
        if (pDef->ppB) LKF_FREE(0, "Free_SatzartDef", (void*)pDef->ppB);
        if (pDef->ppO) LKF_FREE(0, "Free_SatzartDef", (void*)pDef->ppO);
        if (pDef->ppX) LKF_FREE(0, "Free_SatzartDef", (void*)pDef->ppX);
        LKF_FREE (0, "Free_SatzartDef", pDef);
    }
}

static LKF_SATZART_DEFS *Init_SatzartDef (int jahr)
{
	LKF_SATZART_DEFS *pDef;
	int offset;

	pDef = (LKF_SATZART_DEFS *) LKF_MALLOC (0, "Init_SatzartDef", sizeof (LKF_SATZART_DEFS));
    if (!pDef) return 0;
	pDef->jahr = jahr;
	
    if (jahr >= SATZART_A_MODEL)
        pDef->nCount = 41;
    else if (jahr >= SATZART_O_MODEL)
        pDef->nCount = 40;
    else if (jahr >= 2017)
        pDef->nCount = 39;
	else if (jahr >= 2012)
		pDef->nCount = 33;
	else if (jahr >= 2011)
		pDef->nCount = 35;
	else
		pDef->nCount = 33;
	pDef->ppSatzarten = (const SATZART **) LKF_CALLOC (0, "Init_SatzartDef.satzarten", sizeof(const SATZART *), pDef->nCount);

	pDef->ppI = (const SATZART_INFO **) LKF_CALLOC (0, "Init_SatzartDef.i", sizeof(const SATZART_INFO *),  MAX_I_SATZART_NUM2011 + 1);
    if (!pDef->ppI) { Free_SatzartDef(pDef); return 0; }

    pDef->ppK = (const SATZART_INFO **) LKF_CALLOC (0, "Init_SatzartDef.k", sizeof(const SATZART_INFO *),  MAX_K_SATZART_NUM + 1);
    if (!pDef->ppK) { Free_SatzartDef(pDef); return 0; }
    
    pDef->ppG = (const SATZART_INFO **) LKF_CALLOC (0, "Init_SatzartDef.g", sizeof(const SATZART_INFO *),  MAX_G_SATZART_NUM + 1);
    if (!pDef->ppG) { Free_SatzartDef(pDef); return 0; }

    pDef->ppL = (const SATZART_INFO **) LKF_CALLOC (0, "Init_SatzartDef.l", sizeof(const SATZART_INFO *),  MAX_L_SATZART_NUM + 1);
    if (!pDef->ppL) { Free_SatzartDef(pDef); return 0; }

    pDef->ppS = (const SATZART_INFO **) LKF_CALLOC (0, "Init_SatzartDef.s", sizeof(const SATZART_INFO *),  MAX_S_SATZART_NUM + 1);
    if (!pDef->ppS) { Free_SatzartDef(pDef); return 0; }

    pDef->ppB = (const SATZART_INFO **) LKF_CALLOC (0, "Init_SatzartDef.b", sizeof(const SATZART_INFO *),  MAX_B_SATZART_NUM + 1);
    if (!pDef->ppB) { Free_SatzartDef(pDef); return 0; }
    
    if (jahr >= SATZART_O_MODEL) {
        pDef->ppO = (const SATZART_INFO **) LKF_CALLOC (0, "Init_SatzartDef.o", sizeof(const SATZART_INFO *),  MAX_O_SATZART_NUM + 1);
        if (!pDef->ppO) { Free_SatzartDef(pDef); return 0; }

    }
    else {
        pDef->ppO = 0;
    }
    
    if (jahr >= SATZART_A_MODEL) {
        pDef->ppA = (const SATZART_INFO **) LKF_CALLOC (0, "Init_SatzartDef.a", sizeof(const SATZART_INFO *),  MAX_A_SATZART_NUM + 1);
        if (!pDef->ppA) { Free_SatzartDef(pDef); return 0; }

    }
    else {
        pDef->ppA = 0;
    }
    
    if (jahr < 2017) {
        pDef->ppX = 0;
    } else {
        pDef->ppX = (const SATZART_INFO **) LKF_CALLOC(0, "Init_SatzartDef.x", sizeof(const SATZART_INFO *), MAX_X_SATZART_NUM + 1);
        if (!pDef->ppX) { Free_SatzartDef(pDef); return 0; }

    }

	pDef->ppSatzarten[ 0] = &Int01;
	pDef->ppSatzarten[ 1] = &Int02;
	pDef->ppSatzarten[ 2] = &Int03;

    if (jahr >= 2017) {
        pDef->ppSatzarten[0] = &Int11_2017;
        pDef->ppSatzarten[1] = &Int12_2017;
        offset = -1;
    }
    else if (jahr >= 2012)
	{
		pDef->ppSatzarten[0] = &Int11;
		pDef->ppSatzarten[1] = &Int12;
		pDef->ppSatzarten[2] = &IntAbt_NFonds;
		offset = 0;
	}
	else if (jahr >= 2011)
	{
		pDef->ppSatzarten[3] = &Int11;
		pDef->ppSatzarten[4] = &Int12;
		offset = 2;
	}
	else
		offset = 0;

	pDef->ppSatzarten[ 3+offset] = &IntAbt;
	pDef->ppSatzarten[ 4+offset] = &L01Satzart;
	pDef->ppSatzarten[ 5+offset] = &L02Satzart;
	pDef->ppSatzarten[ 6+offset] = &L03Satzart;
	pDef->ppSatzarten[ 7+offset] = &L04Satzart;
    if (jahr >= 2025) {
        pDef->ppSatzarten[ 8+offset] = &SumSatz2025;
    }
    else if (jahr >= 2017)
		pDef->ppSatzarten[ 8+offset] = &SumSatz2017;
    else if (jahr >= 2012)
		pDef->ppSatzarten[ 8+offset] = &SumSatz2012;
	else
		pDef->ppSatzarten[ 8+offset] = &SumSatz;
    pDef->ppSatzarten[ 9+offset] = (jahr >= 2017) ? &K01Satzart2017 : &K01Satzart;
	pDef->ppSatzarten[10+offset] = &K02Satzart;
	pDef->ppSatzarten[12+offset] = &K04Satzart;
	pDef->ppSatzarten[13+offset] = &K05Satzart;
	pDef->ppSatzarten[14+offset] = &K06Satzart;
	pDef->ppSatzarten[15+offset] = &K07Satzart;
	pDef->ppSatzarten[16+offset] = &K08Satzart;
	pDef->ppSatzarten[18+offset] = &K10Satzart;
	pDef->ppSatzarten[19+offset] = &K11Satzart;
	pDef->ppSatzarten[20+offset] = &K12Satzart;
	pDef->ppSatzarten[21+offset] = &K13Satzart;
	pDef->ppSatzarten[22+offset] = &K14Satzart;
	pDef->ppSatzarten[23+offset] = &K15Satzart;
	pDef->ppSatzarten[24+offset] = &K16Satzart;
	pDef->ppSatzarten[25+offset] = &G01Satzart;
	pDef->ppSatzarten[26+offset] = &G02Satzart;
	pDef->ppSatzarten[27+offset] = &B01Satzart;
	pDef->ppSatzarten[28+offset] = &B02Satzart;
	pDef->ppSatzarten[29+offset] = &B03Satzart;
	pDef->ppSatzarten[30+offset] = &B04Satzart;
	pDef->ppSatzarten[31+offset] = &B05Satzart;
	pDef->ppSatzarten[32+offset] = &B06Satzart;
    

    if (jahr >= 2017) {
        pDef->ppSatzarten[11+offset] = &K03Satzart2017;
        pDef->ppSatzarten[17+offset] = &K09Satzart2017;
    }
#if SUPPORT_PRE2017
    else {
        pDef->ppSatzarten[11+offset] = &K03Satzart;
        pDef->ppSatzarten[17+offset] = &K09Satzart;
    }
#endif
    if (jahr >= 2017) {
        pDef->ppSatzarten[33+offset] = &X01Satzart;
        pDef->ppSatzarten[34+offset] = &X02Satzart;
        pDef->ppSatzarten[35+offset] = &X03Satzart;
        pDef->ppSatzarten[36+offset] = &X04Satzart;
        pDef->ppSatzarten[37+offset] = &X05Satzart;
        pDef->ppSatzarten[38+offset] = &X06Satzart;
        pDef->ppSatzarten[39+offset] = &X07Satzart;
    
    
        if (jahr >= SATZART_O_MODEL) {
            pDef->ppSatzarten[40+offset] = &O02Satzart;
        }
        
        if (jahr >= SATZART_A_MODEL) {
            pDef->ppSatzarten[41+offset] = &A01Satzart;
        }
    }
    
	pDef->pSatzartInfo = (SATZART_INFO *) LKF_CALLOC (0, "Init_SatzartDef.satzartInfo", sizeof(SATZART_INFO), pDef->nCount);
    if (!pDef->pSatzartInfo) return 0;
	
    if (jahr >= 2013)
	{
		pDef->pL01Internal = LKF_MALLOC(0, "Init_SatzartDef.satzartInfo", sizeof (SATZART_INFO));
        if (pDef->pL01Internal) {
            Satzart_ComputeReference (jahr, &L01SatzartInternal, pDef->pL01Internal);
        }
	}
	else
		pDef->pL01Internal = 0;

	return pDef;
}

void Satzart_ComputeReference (int jahr, const SATZART *pSatzart, SATZART_INFO *pSatzartInfo) 
{
	unsigned int j;
    int index, maxIndex;
	const SATZART_FELD *pSatzartFeld;

	pSatzartInfo->pSatzart = pSatzart;
	for (j = 0; j < MAX_FELDINDEX; j++) pSatzartInfo->ppRef[j] = 0;
	pSatzartInfo->nLength = 0;
    maxIndex = 0;
    
	if (pSatzart) {
		for (j = 0; j < pSatzart->nCount; j++) {
			pSatzartFeld = lkf_getSatzartFeld (jahr, pSatzart->Felder + j);
			
			if (pSatzartFeld) index = pSatzartFeld->nFieldNum;
			else index = -1;

			if (index < 0 || index >= MAX_FELDINDEX) {
				/* Error goes here */
			}
			else {
				pSatzartInfo->ppRef[index] = pSatzartFeld;
                pSatzartInfo->feldIndex[index] = j;
                if (index > maxIndex) maxIndex = index;
			}
		}
		pSatzartInfo->nLength = pSatzart->Felder[pSatzart->nCount-1].nPos + pSatzart->Felder[pSatzart->nCount-1].nLen;
        pSatzartInfo->nMaxIndex = maxIndex; /* V21.0 */
        pSatzartInfo->pCompatibility = 0; /* V21.0 */
    }
}

static void Satzart_ComputeReferences (LKF_SATZART_DEFS *pDef)
{
	unsigned int i, j;
    int index, maxIndex;
	const SATZART *pSatzart;
	const SATZART_FELD *pSatzartFeld;
	SATZART_INFO *pSatzartInfo;
	char prefix[4];

	for (i = 0; i < pDef->nCount; i++) {
	
		pSatzart = pDef->ppSatzarten[i];
		pSatzartInfo = pDef->pSatzartInfo + i;	
		pSatzartInfo->pSatzart = pSatzart;
		for (j = 0; j < MAX_FELDINDEX; j++) pSatzartInfo->ppRef[j] = 0;
		pSatzartInfo->nLength = 0;

		if (pSatzart) {
            maxIndex = 0;
            for (j = 0; j < pSatzart->nCount; j++) {
				pSatzartFeld = lkf_getSatzartFeld (pDef->jahr, pSatzart->Felder + j);
				
				if (pSatzartFeld) index = pSatzartFeld->nFieldNum;
				else index = -1;

				if (index < 0 || index >= MAX_FELDINDEX) {
					/* Error goes here */
				}
				else {
                    if (index > maxIndex) maxIndex = index;
					pSatzartInfo->ppRef[index] = pSatzartFeld;
                    pSatzartInfo->feldIndex[index] = j;
                }
			}
			pSatzartInfo->nLength = pSatzart->Felder[pSatzart->nCount-1].nPos + pSatzart->Felder[pSatzart->nCount-1].nLen;
            pSatzartInfo->nMaxIndex = maxIndex; /* V21.0 */
            pSatzartInfo->pCompatibility = 0; /* V21.0 */
		}
	}

	strcpy (prefix, "I00");
	for (i = 1; i <= MAX_I_SATZART_NUM2011; i++)
	{
		if (i >= 10)
		{ 
			prefix[1] = '1';
			prefix[2] = (char) ((i-10) + '0');
		}
		else
			prefix[2] = (char) (i + '0');
		pDef->ppI[i] = Satzart_GetSatzart (pDef, prefix);
	}

	prefix[0] = 'K';
	for (i = 1; i <= MAX_K_SATZART_NUM; i++)
	{
		sprintf (prefix + 1, "%02d", i);
		pDef->ppK[i] = Satzart_GetSatzart (pDef, prefix);
	}

	prefix[0] = 'G';
	prefix[1] = '0';
	for (i = 1; i <= MAX_G_SATZART_NUM; i++)
	{
		prefix[2] = (char) (i + '0');
		pDef->ppG[i] = Satzart_GetSatzart (pDef, prefix);
	}

	prefix[0] = 'L';
	for (i = 1; i <= MAX_L_SATZART_NUM; i++)
	{
		prefix[2] = (char) (i + '0');
		pDef->ppL[i] = Satzart_GetSatzart (pDef, prefix);
	}


	prefix[0] = 'S';
	for (i = 1; i <= MAX_S_SATZART_NUM; i++)
	{
        if (i > 9) sprintf (prefix + 1, "%02d", i);
		else prefix[2] = (char) (i + '0');
		pDef->ppS[i] = Satzart_GetSatzart (pDef, prefix);
	}

	prefix[0] = 'B';
    prefix[1] = '0';
    if (pDef->ppB)
	{
		for (i = 1; i <= MAX_B_SATZART_NUM; i++)
		{
			prefix[2] = (char) (i + '0');
			pDef->ppB[i] = Satzart_GetSatzart (pDef, prefix);
		}
	}
    
    prefix[0] = 'A';
    if (pDef->ppA)
    {
        for (i = 1; i <= MAX_A_SATZART_NUM; i++)
        {
            prefix[2] = (char) (i + '0');
            pDef->ppA[i] = Satzart_GetSatzart (pDef, prefix);
        }
    }
    
    if (pDef->ppX) {
        prefix[0] = 'X';
        for (i = 1; i <= MAX_X_SATZART_NUM; i++) {
            prefix[2] = (char) (i + '0');
            pDef->ppX[i] = Satzart_GetSatzart (pDef, prefix);
        }
    }
    
    if (pDef->ppO) {
        prefix[0] = 'O';
        for (i = 1; i <= MAX_O_SATZART_NUM; i++) {
            prefix[2] = (char) (i + '0');
            pDef->ppO[i] = Satzart_GetSatzart (pDef, prefix);
        }
    }
    
    if (pDef->jahr == 2017) {
        
        SATZART_INFO *pSatzartInfo2 = (SATZART_INFO *) LKF_CALLOC(0, "Satzart_ComputeReferences", sizeof(SATZART_INFO), 4);
        if (!pSatzartInfo2) {
            return;
        }
        unsigned int bufCount = 0;
        
        
        for (i = 0; i < pDef->nCount; i++) {
            
            const char *sprefix = pDef->ppSatzarten[i]->sPrefix;
            if (!strcmp (sprefix, "I11")) {
                pDef->pSatzartInfo[i].pCompatibility = pSatzartInfo2 + bufCount;
                Satzart_ComputeReference(2017, &Int11, pSatzartInfo2 + bufCount++);
            }
            else if (!strcmp (sprefix, "I12")) {
                pDef->pSatzartInfo[i].pCompatibility = pSatzartInfo2 + bufCount;
                Satzart_ComputeReference(2017, &Int12, pSatzartInfo2 + bufCount++);
            }
#if SUPPORT_PRE2017
            else if (!strcmp(sprefix, "K03")) {
                pDef->pSatzartInfo[i].pCompatibility = pSatzartInfo2 + bufCount;
                Satzart_ComputeReference(2017, &K03Satzart, pSatzartInfo2 + bufCount++);
            }
            else if (!strcmp (sprefix, "K09")) {
                pDef->pSatzartInfo[i].pCompatibility = pSatzartInfo2 + bufCount;
                Satzart_ComputeReference(2017, &K09Satzart, pSatzartInfo2 + bufCount++);
            }
#endif
        }
        
    }
}

/* Exportierte Routinen f\xc3\xbc""r Satzart-Definitions-Handling */

const LKF_SATZART_DEFS *SatzartDef_Init (int year)
{ /* V2025.0 - refactor */
    int arrayIndex;
    
    if (year < LKF_SATZART_DEFS_MINIMUM || year > LKF_SATZART_DEFS_MAXIMUM) {
        return 0;
    }
    
    arrayIndex = year - LKF_SATZART_DEFS_MINIMUM;
    
    
    if (!ppSatzarten[arrayIndex]) {
        if (!ppSatzarten[arrayIndex]) {
            LKF_SATZART_DEFS *pDefs = Init_SatzartDef(year);
            Satzart_ComputeReferences (pDefs);
            ppSatzarten[arrayIndex] = pDefs;
        }
    }
    
    return ppSatzarten[arrayIndex];
}

_SCORING_EXPORT void lkf_unloadSatzart (void)
{ /* V2025.0 - refactor */
    int arrayIndex;
    int satzartenCount;
    
    satzartenCount = (LKF_SATZART_DEFS_MAXIMUM) - (LKF_SATZART_DEFS_MINIMUM) + 1;
    
    for (arrayIndex = 0; arrayIndex < satzartenCount; arrayIndex++) {
        Free_SatzartDef(ppSatzarten[arrayIndex]);
    }
    memset (ppSatzarten, 0, sizeof(LKF_SATZART_DEFS *) * satzartenCount);
}

const SATZART_INFO *Satzart_GetSatzart (const LKF_SATZART_DEFS *pDef, const char *buf)
{

	unsigned int i;
	for (i = 0; i < pDef->nCount; i++) {
		if (!strncmp (pDef->ppSatzarten[i]->sPrefix, buf, 3)) return pDef->pSatzartInfo + i;
	}
	return 0;
}

static double aNachkomma[] = {1, 10, 100, 1000, 10000, 10000};

int Satzart_GetValueFloatExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld, double *pVal, int modell)
{
    const char *fieldbuf, *fv;
    unsigned int nNachkomma = 0, nNachkommaStellen = 0;
    unsigned int nMinus;
    unsigned int vorkommaDigits;
    double nVorkomma = 0;
    
    fieldbuf = expLine->fieldsById[pFeld->nFieldNum];
    if (pVal) *pVal = 0;
    
    nMinus = 0;
       
    while (*fieldbuf == ' ') ++fieldbuf;
    if (!*fieldbuf) return LKF_FIELD_EMPTY;

    if (*fieldbuf == '-')
    {
        if (nMinus || (pFeld->nType != TYP_NUM_NEG && pFeld->nType != TYP_NUM_NEG1000 && pFeld->nType != TYP_FLOAT_NEG))
            return LKF_FIELD_ERROR;
        nMinus = 1;
        ++fieldbuf;

        if (*fieldbuf == ' ' && expLine->pContext && expLine->pContext->modelljahr >= 2018) {
            return LKF_FIELD_ERROR; /* V2019.0 */
        }
        while (*fieldbuf == ' ') ++fieldbuf;
    }
    
    fv = fieldbuf;
    vorkommaDigits = 0;
    
    while (*fv >= '0' && *fv <= '9') {
        ++fv;
        ++vorkommaDigits;
    }
    if (fv == fieldbuf) return LKF_FIELD_ERROR; /* keine Vorkomma-Stelle */
    
    
    if (*fv == '.' && modell >= 2023) {
        return LKF_FIELD_ERROR;
    }
    
    if (pVal) {
        
        if (vorkommaDigits < 20 && (*fv == '.' || *fv == ','))
        { /* 22.4 */
            char buf[20];
            memcpy (buf, fieldbuf, vorkommaDigits);
            buf[vorkommaDigits] = 0;
            nVorkomma = atof(buf); /* V22.3 */
        }
        else {
            nVorkomma = atof(fieldbuf); /* V22.3 */
        }
    }
    else {
        nVorkomma = atof(fieldbuf);
    }
    
    if (*fv == '.' || *fv == ',') {
        fieldbuf = ++fv;
        while (*fv >= '0' && *fv <= '9') ++fv;
        if (fv == fieldbuf) return LKF_FIELD_ERROR; /* keine Nachkomma-Stelle */
        nNachkommaStellen = (unsigned int) (fv - fieldbuf);
        if (nNachkommaStellen > 2) return LKF_FIELD_ERROR; /* maximal 2 Nachkommastellen */
        while (*fv == ' ') ++fv;
        if (*fv) return LKF_FIELD_ERROR; /* ungueltiger Ausdruck */
        nNachkomma = (unsigned int) atoi (fieldbuf);
        if (pVal) {
            *pVal = (double) nNachkomma / aNachkomma[nNachkommaStellen];
        }
    }
    
    if (nMinus && pFeld->nType == TYP_FLOAT_NEG && nNachkomma == 0 && nVorkomma == 0)
        return LKF_FIELD_ERROR;
    
    if (pVal) {
        *pVal += nVorkomma;
        if (nMinus) {
            *pVal = -*pVal;
        }
    }
    return 0;
}

int Satzart_GetValueFloat (const char *buf, unsigned int buflen, const SATZART_FELD *pFeld, double *pVal, int modell)
{
    char intbuf[30];
	unsigned int nLen, nPos, nSavePos;
	unsigned int nNachkomma = 0, nNachkommaStellen = 0;
	unsigned int nMinus;
	double nVorkomma = 0;
    
    if (buflen == LKF_LEN_FOR_EXPANDEDLINE)
        return Satzart_GetValueFloatExp((const LKF_EXPANDED_LINE *) buf, pFeld, pVal, modell);
    
	if (pVal) *pVal = 0;

	nMinus = 0;

	if (buflen + 1 >= pFeld->nPos)
	{
		nLen = pFeld->nLen;
		if (buflen + 1 < pFeld->nPos + nLen) nLen = buflen - pFeld->nPos + 1;
		nPos = pFeld->nPos - 1;

		while (nLen > 0 && (buf[nPos] == ' ' || buf[nPos] == '-')) 
		{

			if (buf[nPos] == '-')
			{
				if (nMinus || (pFeld->nType != TYP_NUM_NEG && pFeld->nType != TYP_NUM_NEG1000 && pFeld->nType != TYP_FLOAT_NEG))
					return LKF_FIELD_ERROR;
				nMinus = 1;
			}

			++nPos;
			--nLen;
		}

		if (nLen == 0) return LKF_FIELD_EMPTY;
		nSavePos = nPos;
		while (nLen > 0 && buf[nPos] >= '0' && buf[nPos] <= '9')
		{
			++nPos;
			--nLen;
		}

		if (nPos == nSavePos) return LKF_FIELD_ERROR; /* keine Vorkomma-Stelle */

		if (nPos - nSavePos < 30)
		{
			if (pVal)
			{
				memcpy (intbuf, buf + nSavePos, nPos - nSavePos);
				intbuf[nPos - nSavePos] = 0;
				nVorkomma = atof (intbuf);
			}
		}
		else return LKF_FIELD_ERROR;
		
        if (buf[nPos] == '.' && modell >= 2023) {
            return LKF_FIELD_ERROR;
        }
        
		if (nLen > 0 && (buf[nPos] == ',' || buf[nPos] == '.'))
		{
			--nLen;
			nSavePos = ++nPos;

			while (nLen > 0 && buf[nPos] >= '0' && buf[nPos] <= '9')
			{
				++nPos;
				--nLen;
			}

			if (nPos == nSavePos) return LKF_FIELD_ERROR; /* keine Nachkomma-Stelle, aber Komma */

			if (nPos - nSavePos < 3) /* nur zwei Nachkommastellen zul\xc3\xa4""ssig */
			{
				if (pVal) 
				{
					nNachkommaStellen = nPos - nSavePos;
					memcpy (intbuf, buf + nSavePos, nNachkommaStellen);
					intbuf[nNachkommaStellen] = 0;
					nNachkomma = (unsigned int) atoi (intbuf);
				}
			}
			else return LKF_FIELD_ERROR;
			

			while (nLen > 0 && buf[nPos] == ' ')
			{
				++nPos;
				--nLen;
			}

			if (nLen > 0 && buf[nPos]) return LKF_FIELD_ERROR; /* ungueltiger Ausdruck */
		
			if (pVal) 
			{
				*pVal = (double) nNachkomma;
				while (nNachkommaStellen > 5) {
					*pVal /= aNachkomma[5];
					nNachkommaStellen -= 5;
				}
				*pVal /= aNachkomma[nNachkommaStellen];
				*pVal += nVorkomma;
				if (nMinus)
					*pVal = -*pVal;
			}
			return 0;
		
		}
		else 
		{
			while (nLen > 0 && buf[nPos] == ' ') 
			{
				++nPos;
				--nLen;
			}

			if (nLen > 0 && buf[nPos]) return LKF_FIELD_ERROR; /* ung\xc3\xbc""ltiger Ausdruck */
			if (pVal) *pVal = (double) nVorkomma;
            if (nMinus) {
                *pVal = -*pVal;
            }
			return 0;
		}
	}
	else return LKF_FIELD_EMPTY;
}

int Satzart_GetValueIntExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld, int *pVal)
{
    const char *fieldValue, *fv;
    int nMinus = 0;
    
    if (pVal) *pVal = 0;
    fieldValue = expLine->fieldsById[pFeld->nFieldNum];
    
    if (!fieldValue) {
        return LKF_FIELD_EMPTY;
    }
    
    while (*fieldValue == ' ') ++fieldValue;
    
    if (pFeld->nType == TYP_NUM_NEG || pFeld->nType == TYP_NUM_NEG1000)
    {
        if (*fieldValue == '-')
        {
            nMinus = 1;
            ++fieldValue;
        }
        if (*fieldValue == ' ' && expLine->pContext && expLine->pContext->modelljahr >= 2018) {
            return LKF_FIELD_ERROR; /* V2019.0 */
        }
        while (*fieldValue == ' ') ++fieldValue;
    }
    
    if (!*fieldValue) return LKF_FIELD_EMPTY;
    
    fv = fieldValue;
    
    while (*fv) {
        if (*fv < '0' || *fv > '9') {
            while (*fv == ' ') ++fv;
            if (*fv) return LKF_FIELD_ERROR;
        }
        ++fv;
    }
    
    if (pVal) {
        if (nMinus)
            *pVal = - atoi (fieldValue);
        else
            *pVal = atoi (fieldValue);
    }
    
    return 0;
}

int Satzart_GetValueInt (const char *buf, unsigned int buflen, const SATZART_FELD *pFeld, int *pVal)
{
	char intbuf[MAX_INTBUFLEN];
	unsigned int nLen, nPos, i;
	int nMinus;
    
    if (buflen == LKF_LEN_FOR_EXPANDEDLINE)
        return Satzart_GetValueIntExp((const LKF_EXPANDED_LINE *) buf, pFeld, pVal);
    
	if (pVal) *pVal = 0;

	if (buflen + 1 >= pFeld->nPos) {
		nLen = pFeld->nLen;
		if (buflen + 1 < pFeld->nPos + nLen) nLen = buflen - pFeld->nPos + 1;
		nPos = pFeld->nPos - 1;
		while (nLen > 0 && buf[nPos] == ' ') 
		{ 
			++nPos; 
			--nLen; 
		}

		if (pFeld->nType == TYP_NUM_NEG || pFeld->nType == TYP_NUM_NEG1000) 
		{
			if (nLen > 0 && buf[nPos] == '-')
			{
				nMinus = 1;
				++nPos;
				--nLen;

				while (nLen > 0 && buf[nPos] == ' ')
				{
					++nPos;
					--nLen;
				}
			}
			else nMinus = 0;
		}
		else nMinus = 0;
		if (nLen > 0 && buf[nPos] >= '0' && buf[nPos] <= '9') {
			memcpy (intbuf, buf + nPos, nLen);
			intbuf[nLen] = 0;

			/* Format-Check */
			while (intbuf[nLen-1] == ' ') nLen--;
			
			for (i = 0; i < nLen; i++)
			{
				if (intbuf[i] < '0' || intbuf[i] > '9') return LKF_FIELD_ERROR; 
			}

			if (pVal) {
				if (nMinus)
					*pVal = - atoi (intbuf);
				else
				    *pVal = atoi (intbuf);
			}
			return 0;
		}
		else if (nLen == 0) return LKF_FIELD_EMPTY;
		else return LKF_FIELD_ERROR;
	}
	else return LKF_FIELD_EMPTY;
}

int Satzart_GetValueDouble (const char *buf, unsigned int buflen, const SATZART_FELD *pFeld, unsigned int nachkommastellen, double *pVal)
{ /* entspricht Util_Get_DoubleValue */
	double factor[] = {0, 0.1, 0.01, 0.001, 0.0001, 0.00001};
	double value;
	unsigned int nLen;
	char intbuf[MAX_INTBUFLEN];

	if (pVal) *pVal = 0;

	if (buflen + 1 >= pFeld->nPos) {
		nLen = pFeld->nLen;
		if (buflen + 1 < pFeld->nPos + nLen) nLen = buflen - pFeld->nPos + 1;
		memcpy (intbuf, buf + pFeld->nPos - 1, nLen);
		intbuf[nLen] = 0;
		value = (double) atoi (intbuf);
		while (nachkommastellen > 5) 
		{
			value *= factor[5];
			nachkommastellen -= 5;
		}
		value *= factor[nachkommastellen];
		if (pVal) *pVal = value;
		return 0;
	}
	else return LKF_FIELD_EMPTY;
}

unsigned int Satzart_GetValueStringExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld, char *value, unsigned int maxlen) {
    const char *l = expLine->fieldsById[pFeld->nFieldNum];
    unsigned int sl = (unsigned int) strlen (l);
    
    if (maxlen <= sl) {
        memcpy (value, l, maxlen);
        return maxlen;
    }
    strcpy (value, l);
    return sl;
}

unsigned int Satzart_GetValueString (const char *buf, unsigned int buflen, const SATZART_FELD *pFeld, char *value, unsigned int maxlen)
{
	unsigned int l;
	const char *valuepos;
	unsigned int nLen;
	
    if (buflen == LKF_LEN_FOR_EXPANDEDLINE) {
        return Satzart_GetValueStringExp((LKF_EXPANDED_LINE *) buf, pFeld, value, maxlen);
    }
    
	if (buflen + 1 >= pFeld->nPos) {
		valuepos = buf + pFeld->nPos - 1;
		nLen = pFeld->nLen;
		if (buflen + 1 < pFeld->nPos + nLen) nLen = buflen - pFeld->nPos + 1;
		for (l = nLen; l && (valuepos[l-1] && valuepos[l-1]==' '); l--) ;

		if (l <= maxlen) {
			if (l) memcpy (value, valuepos, l);
			if (l < maxlen) value[l] = 0;
		}
	}
	else {
		if (maxlen > 0) value[0] = 0;
		l = 0;
	}
	return l;
}

unsigned int Satzart_GetValueString2017 (const char *buf, unsigned int buflen, const SATZART_FELD *pFeld, unsigned int indexOfField, char *value, unsigned int maxlen)
{ /* V21.1 */
	const char *valuepos;
	unsigned int nLen;
	unsigned int nCurrentFieldNum;
    if (buflen == LKF_LEN_FOR_EXPANDEDLINE) {
        return Satzart_GetValueStringExp((LKF_EXPANDED_LINE *) buf, pFeld, value, maxlen);
    }

	nCurrentFieldNum = 0;
	valuepos = strchr (buf, '|');
	if (valuepos) valuepos++;

	while (valuepos && nCurrentFieldNum < indexOfField) 
	{
		const char *nextTrenn = strchr (valuepos, '|');
		if (nextTrenn) {
			nCurrentFieldNum++;
			valuepos = nextTrenn + 1;
		}
		else {
			valuepos = 0;
		}
	}
    
	if (valuepos) {	
		const char *endPos = strchr(valuepos, '|');
		if (endPos) {
			nLen = (unsigned int) (endPos - valuepos);
		}
		else {
			nLen = (unsigned int) strlen(valuepos);
			while (nLen > 0 && (valuepos[nLen-1] == 10 || valuepos[nLen-1] == 13)) --nLen;
		}

		if (nLen < maxlen) {
			memcpy (value, valuepos, nLen);
			value[nLen] = 0;
		}
		else {
			memcpy (value, valuepos, maxlen - 1);
			value[maxlen-1] = 0;
		}
	}
	else 
	{
		value[0] = 0;
		nLen = 0;
	}

	return nLen;
}


int Satzart_GetValueDate (const char *ds, unsigned int buflen, const SATZART_FELD *pFeld)
{
    
    if (buflen == LKF_LEN_FOR_EXPANDEDLINE)
        return Satzart_GetValueDateExp((const LKF_EXPANDED_LINE *) ds, pFeld);
    
	if (buflen < pFeld->nPos + 7) return 0;
	else return (int) lkf_dat2int (ds + pFeld->nPos - 1);
}

int Satzart_GetValueDateExp (const LKF_EXPANDED_LINE *pExtLine, const SATZART_FELD *pFeld)
{
    const char *t = pExtLine->fieldsById[pFeld->nFieldNum];
    if (!t || !*t) return 0;
    return (int) lkf_dat2int (t);
}


const char *Satzart_GetValueDateFormat (const char *ds, unsigned int buflen, const SATZART_FELD *pFeld, char *value, unsigned int maxlen)
{
	if (buflen < pFeld->nPos + 7) return 0;
	else if (maxlen < 12) return 0;
	else return FormatDate8 (ds + pFeld->nPos - 1, value);
}

const char *Satzart_GetValueDateFormatExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld, char *value, unsigned int maxlen)
{
    const char *buf = expLine->fieldsById[pFeld->nFieldNum];
    if (!buf || !*buf || strlen(buf) != 8)
        return 0;
    return FormatDate8 (buf, value);
}


int Satzart_IsEmptyExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld) {
    const char *buf = expLine->fieldsById[pFeld->nFieldNum];
    while (*buf == ' ') ++buf;
    if (!*buf) return 1;
    return 0;
}

int Satzart_IsEmpty (const char *buf, unsigned int len, const SATZART_FELD *pFeld)
{
	const char *field;
	unsigned int i;

	if (len == LKF_LEN_FOR_EXPANDEDLINE)
		return Satzart_IsEmptyExp ((const LKF_EXPANDED_LINE *) buf, pFeld); /* V21.2 */

	if (len < (unsigned int) pFeld->nPos) return 1;

	field = buf + pFeld->nPos - 1;
	
	i = 0;

	while (i < pFeld->nLen && field[i] != 0) {
		if (field[i] != ' ') return 0;
		++i;
	}
	return 1;
}

int Satzart_IsNumeric (const char *buf, const SATZART_FELD *pFeld, int flags)
{
	unsigned int i, firstdigit;
	const char *field = buf + pFeld->nPos - 1;

	i = 0;

	/* Accept Leading blanks */
	while (i < pFeld->nLen && field[i] == ' ') ++i;

	/* Negative Numbers */
	if (flags & 1) {
		if (i < pFeld->nLen && field[i] == '-') ++i;
		while (i < pFeld->nLen && field[i] == ' ') ++i;
	}

	firstdigit = i;

	/* Check Digits */
	while (i < pFeld->nLen && field[i] >= '0' && field[i] <= '9') ++i;
	if (firstdigit == i) return 0; 

	while (i < pFeld->nLen && (field[i] == ' ' || !field[i])) 
	{
		if (!field[i]) return 1;
		++i;
	}

	if (i < pFeld->nLen) return 0;
	return 1;
}

int Satzart_IsSatzart (const char *buf, const SATZART *pSatzart)
{
	if (strncmp (buf, pSatzart->sPrefix, strlen (pSatzart->sPrefix))) return 0;
	else return 1;
}

unsigned int Satzart_GetLines (LKF_LINE_BUFFER *pLineBuffer, const SATZART *pSatzart, const char **ppLines, unsigned int max_lines)
{
	unsigned int i, linecount = 0;
	const char *buf;

	if (!pLineBuffer) return 0;

	for (i = 0; i < pLineBuffer->lLineCount; i++) {
		buf = pLineBuffer->pBuf + pLineBuffer->plOffsets[i];
		if (Satzart_IsSatzart (buf, pSatzart)) {
			if (linecount < max_lines) ppLines[linecount] = buf;
			++linecount;
		}
	}

	return linecount;
}

unsigned int Satzart_GetLinesAllocExp (LKF_EXPANDED_LINES *pExpandedLines, const SATZART *pSatzart, const LKF_EXPANDED_LINE ***pppLines) {
    unsigned int i, len, count = 0;
    LKF_EXPANDED_LINE **lines;
 
    if (!pExpandedLines) {
        *pppLines = 0;
        return 0;
    }
    
    len = pExpandedLines->lineCount;
    lines = (LKF_EXPANDED_LINE **) LKF_CALLOC(pExpandedLines->pContext, "Satzart_GetLinesAllocExp.lines", pExpandedLines->lineCount, sizeof (LKF_EXPANDED_LINE *));
    
	if (!lines) {
		return LKF_OUTOFMEMORY_UINTERROR;
	}
    for (i = 0; i < len; i++) {
        const SATZART_INFO *pSatzartInfo = pExpandedLines->lines[i]->pSatzartInfo;
        if (pSatzartInfo && !strcmp (pSatzartInfo->pSatzart->sPrefix, pSatzart->sPrefix)) {
            lines[count++] = pExpandedLines->lines[i];
        }
    }
	if (count > 0) {
		*pppLines = (const LKF_EXPANDED_LINE **)LKF_CALLOC(pExpandedLines->pContext, "Satzart_GetLinesAllocExp.pl", sizeof(LKF_EXPANDED_LINE *), count);
		if (!*pppLines) {
			LKF_FREE(pExpandedLines->pContext, "Satzart_GetLinesAllocExp.lines", lines);
			return LKF_OUTOFMEMORY_UINTERROR;
		}
		memcpy((void *)*pppLines, lines, sizeof(LKF_EXPANDED_LINE *) * count);
	}
	else {
		*pppLines = 0;
	}
    LKF_FREE (pExpandedLines->pContext, "Satzart_GetLinesAllocExp.lines", lines);
    return count;
}

unsigned int Satzart_GetLinesAlloc (LKF_LINE_BUFFER *pLineBuffer, const SATZART *pSatzart, const char ***pppLines)
{
	unsigned int count = Satzart_GetLines (pLineBuffer, pSatzart, 0, 0);
	if (count > 0) {
		*pppLines = (const char **) LKF_CALLOC (0, "Satzart_GetLinesAlloc", sizeof (const char *), count);
		if (!*pppLines) {
			return LKF_OUTOFMEMORY_UINTERROR;
		}
		return Satzart_GetLines (pLineBuffer, pSatzart, *pppLines, count);
	}
	else {
		*pppLines = 0;
		return 0;
	}
}

unsigned int Satzart_GetExpandedLines (LKF_EXPANDED_LINES *pExpandedLines, const char *prefix, LKF_EXPANDED_LINE ***pppLines) {
    
    unsigned int i, count;
    LKF_EXPANDED_LINE **ppLines;
    
    if (!pExpandedLines) {
        *pppLines = 0;
        return 0;
    }
    
    ppLines = (LKF_EXPANDED_LINE **) LKF_CALLOC(pExpandedLines->pContext, "Satzart_GetExpandedLines", pExpandedLines->lineCount, sizeof (LKF_EXPANDED_LINE *));
    if (!ppLines) {
		*pppLines = 0;
        return LKF_OUTOFMEMORY_UINTERROR;
    }
    
    count = 0;
    for (i = 0; i < pExpandedLines->lineCount; i++)
    {
        LKF_EXPANDED_LINE *pLine = pExpandedLines->lines[i];
        if (!strcmp (pLine->fields[0], prefix)) {
            ppLines[count++] = pLine;
        }
    }
    
    if (count == 0) {
        LKF_FREE (pExpandedLines->pContext, "Satzart_GetExpandedLines", ppLines);
        *pppLines = 0;
    }
    else if (count == pExpandedLines->lineCount) {
        *pppLines = ppLines;
    }
    else {
        *pppLines = (LKF_EXPANDED_LINE **) LKF_CALLOC(pExpandedLines->pContext, "Satzart_GetExpandedLines", count, sizeof (LKF_EXPANDED_LINE *));
        if (!*pppLines) {
            LKF_FREE (pExpandedLines->pContext, "Satzart_GetExpandedLines", ppLines);
            return LKF_OUTOFMEMORY_UINTERROR;
        }
        memcpy (*pppLines, ppLines, sizeof(LKF_EXPANDED_LINE *) * count);
        LKF_FREE (pExpandedLines->pContext, "Satzart_GetExpandedLines", ppLines);
    }
    
    
    return count;
}

void Satzart_GetLinesFree  (LKF_CONTEXT *pContext, const char **ppLines)
{
	if (ppLines) LKF_FREE (pContext, "Satzart_GetLinesFree", (void *)ppLines);
}

static void Satzart_GetAdditionalErrorInfo (LKF_CONTEXT *pContext, const char *pLine, const SATZART_INFO *pSatzartInfo, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORDEF *pErrorDef, char *sInfo, int bDisplay)
{

	sInfo[0] = 0;
	
	if (pSatzartInfo && pLine && 
		(!memcmp (pSatzartInfo->pSatzart->sPrefix, "I02", 3) || !memcmp (pSatzartInfo->pSatzart->sPrefix, "I12", 3))) /* V16.0 */
	{
		char sAbtPos[4];
		char sErhebDat[14];
		unsigned int linelen;
		linelen = (unsigned int) strlen (pLine);
		Satzart_GetValueString (pLine, linelen, pSatzartInfo->ppRef[GEN_ABTPOS], sAbtPos, 3);
		if (bDisplay)
		{
			Satzart_GetValueDateFormat (pLine, linelen, pSatzartInfo->ppRef[GEN_ERHEBDAT], sErhebDat, 12);
			sprintf (sInfo, "%2.2s:%10.10s", sAbtPos, sErhebDat);
		}	
		else
		{ /* V10.0 */
			Satzart_GetValueString (pLine, linelen, pSatzartInfo->ppRef[GEN_ERHEBDAT], sErhebDat, 12);
			sprintf (sInfo, "%2.2s%8.8s", sAbtPos, sErhebDat); 
		}
	}
	else if (pSatzartInfo && pLine && !memcmp (pSatzartInfo->pSatzart->sPrefix, "I11", 3)
		&& (pErrorDef == &LKFErrorKeinGrund || pErrorDef == &LKFErrorKeinAufnahmeTyp || pErrorDef == &LKFErrorKeinChirurgStatus || pErrorDef == &LKFErrorZutransNichtErhoben))
	{ /* V18.2 */
		char sAbtPos[4];
		char sErhebDat[14];
		unsigned int linelen;
		linelen = (unsigned int) strlen (pLine);
		Satzart_GetValueString (pLine, linelen, pSatzartInfo->ppRef[GEN_ABTPOS], sAbtPos, 3);
		if (bDisplay)
		{
			Satzart_GetValueDateFormat (pLine, linelen, pSatzartInfo->ppRef[GEN_ERHEBDAT], sErhebDat, 12);
			sprintf (sInfo, "%2.2s:%10.10s", sAbtPos, sErhebDat);
		}	
		else
		{
			Satzart_GetValueString (pLine, linelen, pSatzartInfo->ppRef[GEN_ERHEBDAT], sErhebDat, 12);
			sprintf (sInfo, "%2.2s%8.8s", sAbtPos, sErhebDat); 
		}

	}
	else if (pErrorDef) {

		if (pErrorDef->nFacility == LKF_FAC_KAS_KORE && (pErrorDef->nSeverity & LKF_SEV_ERROR))
		{
			switch (pErrorDef->nCode)
			{
				case 48: /* K04 - Vollzeit\xc3\xa4""quivalente -> Index */
					if (pLine) Satzart_GetValueString (pLine, (unsigned int) strlen (pLine), pSatzartInfo->ppRef[K04_PERSONALGRUPPENINDEX], sInfo, LKF_ERRORFELD_LAENGE);
					break;
				default:
					
					break;
			}
		}
	}
}

static void Satzart_GetAdditionalErrorInfoExp (LKF_CONTEXT *pContext, const LKF_EXPANDED_LINE *expLine, const SATZART_INFO *pSatzartInfo, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORDEF *pErrorDef, char *sInfo)
{
    sInfo[0] = 0;
        
    if (pSatzartInfo && expLine && !memcmp (pSatzartInfo->pSatzart->sPrefix, "I12", 3))
    {
        char sAbtPos[5];
        char sFormattedAbtPos[5];
        char sErhebDat[14];
        Satzart_GetValueStringExp (expLine, pSatzartInfo->ppRef[GEN_ABTPOS], sAbtPos, 4);
        Satzart_GetValueDateFormatExp (expLine, pSatzartInfo->ppRef[GEN_ERHEBDAT], sErhebDat, 12);
        sprintf (sInfo, "%3.3s:%10.10s", lkf_format_abtpos_string (sAbtPos, sFormattedAbtPos), sErhebDat);
    }
    else if (pSatzartInfo && expLine && !memcmp (pSatzartInfo->pSatzart->sPrefix, "I11", 3))
    { /* V18.2 */
        char sAbtPos[5];
        char sFormattedAbtPos[5];
        char sErhebDat[14];
        Satzart_GetValueStringExp (expLine, pSatzartInfo->ppRef[GEN_ABTPOS], sAbtPos, 4);
        Satzart_GetValueDateFormatExp (expLine, pSatzartInfo->ppRef[GEN_ERHEBDAT], sErhebDat, 12);
        sprintf (sInfo, "%3.3s:%10.10s", lkf_format_abtpos_string (sAbtPos, sFormattedAbtPos), sErhebDat);
        
    }
    else if (pErrorDef) {
        
        if (pErrorDef->nFacility == LKF_FAC_KAS_KORE && (pErrorDef->nSeverity & LKF_SEV_ERROR))
        {
            switch (pErrorDef->nCode)
            {
                case 48: /* K04 - Vollzeitaequivalente -> Index */
                    if (expLine) Satzart_GetValueStringExp (expLine, pSatzartInfo->ppRef[K04_PERSONALGRUPPENINDEX], sInfo, LKF_ERRORFELD_LAENGE);
                    break;
                default:
                    
                    break;
            }
        }
    }
}


static int IsAcceptable (LKF_CONTEXT *pContext, LKF_AUFENTHALT *pAufenthalt, const LKF_SATZART_ERRORDEF *pErrorDef)
{
	if (pContext->modelljahr >= 2006 && pAufenthalt && (pErrorDef->nSeverity & LKF_SEV_ACCEPTABLE)) return 1;
	else return 0;
}

int Satzart_ReportError (LKF_CONTEXT *pContext, LKF_CHECK_CONTEXT *pCheckContext, const char *pLine, unsigned int buflen, const SATZART_INFO *pSatzartInfo, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORDEF *pErrorDef, const char *sInfo)
{
    LKF_SATZART_ERROR *pError;
    unsigned int nSev;
    int errorindex;
    
    if (buflen == LKF_LEN_FOR_EXPANDEDLINE) {
        Satzart_ReportErrorExp(pContext, pCheckContext, (const LKF_EXPANDED_LINE *) pLine, pSatzartInfo, pFeld, pErrorDef, sInfo);
        return 0;
    }
    
    if (!lkf_getErrorRelevance (pErrorDef, pContext))
        return 0;
    
    if (pCheckContext && pCheckContext->pAufenthalt && IsAcceptable (pContext, pCheckContext->pAufenthalt, pErrorDef))
    {
        char sAkwarnInfo[24];
        if (sInfo && *sInfo)
            memcpy (sAkwarnInfo, sInfo, 10);
        else
            Satzart_GetAdditionalErrorInfo (pContext, pLine, pSatzartInfo, pFeld, pErrorDef, sAkwarnInfo, 0);
        
        sAkwarnInfo[10] = 0;
        
        if (pErrorDef->nSeverity & LKF_SEV_ERROR)
        {
            if (checkAcceptedError (pCheckContext->pAufenthalt, pErrorDef, sAkwarnInfo, 0))
            {
                ++pCheckContext->pAufenthalt->akerr_count;
                return 0;
            }
        }
        else if (checkAcceptedWarning (pCheckContext->pAufenthalt, pErrorDef, sAkwarnInfo, 0))
        {
            ++pCheckContext->pAufenthalt->akwarn_count; /* V10.1 */
            return 0;
        }
    }
    
    
    if (!pContext->pSatzartErrors) {
        pContext->pSatzartErrors = Satzart_AllocErrorStructure(pContext);
        if (!pContext->pSatzartErrors) return LKF_OUTOFMEMORY_ERROR;
    }
    errorindex = (int) Satzart_GetNextFreeErrorIndex (pContext, pContext->pSatzartErrors);
    if (errorindex == LKF_OUTOFMEMORY_UINTERROR) return LKF_OUTOFMEMORY_ERROR;
    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 = pFeld;
    pError->pSatzartInfo = pSatzartInfo;
    pError->nAddInfo = 0;
    pError->nAufNextErrorIndex = -1;
    pError->nErrorLfdNr = (unsigned int) errorindex;
    pError->nAbtIndex = pCheckContext ? pCheckContext->nAbtIndex : -1;
    pError->mainErrorIndex = -1;
    if (pCheckContext && pCheckContext->sBerichtsTyp[0])
    {
        pError->sTyp[0] = pCheckContext->sBerichtsTyp[0];
        pError->sTyp[1] = 0;
    }
    else
        pError->sTyp[0] = 0;
    
    if (sInfo && *sInfo)
    {
        strncpy (pError->sErrorFeld, sInfo, sizeof(pError->sErrorFeld));
        pError->sErrorFeld[sizeof(pError->sErrorFeld)-1] = 0;
    }
    else
    {
        Satzart_GetAdditionalErrorInfo (pContext, pLine, pSatzartInfo, pFeld, pErrorDef, pError->sErrorFeld, 1); /* V9.1 */
    }
    
    if (pCheckContext && pCheckContext->pAufenthalt) {
        LKF_AUFENTHALT *pAufenthalt = pCheckContext->pAufenthalt;
        if (pAufenthalt->nSatzartNextError >= 0) {
            LKF_SATZART_ERROR *pPrevious = Satzart_GetSatzartError (pContext->pSatzartErrors, pAufenthalt->nSatzartNextError);
            pPrevious->nAufNextErrorIndex = errorindex;
        }
        else pAufenthalt->nSatzartFirstError = errorindex;
        pAufenthalt->nSatzartNextError = errorindex;
        pError->pAufenthalt = pAufenthalt;
        
        if (pCheckContext->pContext->flags & LKFCONTEXT_AUFPLAUS_IERRORS)
        {
            PlausReportIntensivError (pAufenthalt, pError->pErrorDef->nSeverity != LKF_SEV_ERROR, errorindex);
        } else if (pContext->modelljahr >= 2015) {
            /* V19.2 */
            if (pError->pErrorDef->nSeverity & LKF_SEV_ERROR) ++pAufenthalt->plaus_err; /* V21.2: == ersetzt durch & */
            else ++pAufenthalt->plaus_warn;
        }
    }
    else pError->pAufenthalt = 0;
    
    nSev = lkf_getSeverity (pContext, pErrorDef);
    
    if (pCheckContext && pCheckContext->nWorstSeverity < nSev)
        pCheckContext->nWorstSeverity = nSev;
    pError->pLine = pLine;
    pError->pExpLine = 0;
    
    if (pCheckContext && pCheckContext->nTraceFacility == LKF_FAC_KAS_KORE)
    {
        if (pCheckContext->bKKTraceInfo)
            lkf_trace_kk_info (pCheckContext, 0);
    }
    else if (pCheckContext && pCheckContext->nTraceFacility == LKF_FAC_INTSCOR)
    {
        if (LKF_IS_TRACE_INFO (pCheckContext->pContext->nTraceAufenthaltIntScor))
            lkf_trace_int_info (pCheckContext, 0);
    }
    
    return lkf_context_count_error (pContext, pError);
}


void Satzart_ReportErrorExp (LKF_CONTEXT *pContext, LKF_CHECK_CONTEXT *pCheckContext, const LKF_EXPANDED_LINE *pLine, const SATZART_INFO *pSatzartInfo, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORDEF *pErrorDef, const char *sInfo)
{
	LKF_SATZART_ERROR *pError;
	unsigned int nSev;
	int errorindex;
	
	if (!lkf_getErrorRelevance (pErrorDef, pContext))
		return;

	if (pCheckContext && pCheckContext->pAufenthalt && IsAcceptable (pContext, pCheckContext->pAufenthalt, pErrorDef))
	{
		char sAkwarnInfo[24];
		if (sInfo && *sInfo)
			memcpy (sAkwarnInfo, sInfo, 20);
		else
			Satzart_GetAdditionalErrorInfoExp (pContext, pLine, pSatzartInfo, pFeld, pErrorDef, sAkwarnInfo);

		sAkwarnInfo[20] = 0;

		if (pErrorDef->nSeverity & LKF_SEV_ERROR)
		{
			if (checkAcceptedError (pCheckContext->pAufenthalt, pErrorDef, sAkwarnInfo, 0))
			{
				++pCheckContext->pAufenthalt->akerr_count;
				return;
			}
		}
		else if (checkAcceptedWarning (pCheckContext->pAufenthalt, pErrorDef, sAkwarnInfo, 0))
		{
			++pCheckContext->pAufenthalt->akwarn_count; /* V10.1 */
			return;
		}
	}

	if (!pContext->pSatzartErrors) pContext->pSatzartErrors = Satzart_AllocErrorStructure(pContext);
	errorindex = (int) Satzart_GetNextFreeErrorIndex (pContext, pContext->pSatzartErrors);
    if (errorindex == LKF_OUTOFMEMORY_UINTERROR) return;
    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 = Satzart_GetSatzartError (pContext->pSatzartErrors, errorindex);
	pError->pErrorDef = pErrorDef;
	pError->pFeld = pFeld;
	pError->pSatzartInfo = pSatzartInfo;
	pError->nAddInfo = 0;
	pError->nAufNextErrorIndex = -1;
	pError->nErrorLfdNr = (unsigned int) errorindex;
	pError->nAbtIndex = pCheckContext ? pCheckContext->nAbtIndex : -1;
    pError->mainErrorIndex = -1;
    
	if (pCheckContext && pCheckContext->sBerichtsTyp[0])
	{
		pError->sTyp[0] = pCheckContext->sBerichtsTyp[0];
		pError->sTyp[1] = 0;
	}
	else
		pError->sTyp[0] = 0;

	if (sInfo && *sInfo)
	{
		strncpy (pError->sErrorFeld, sInfo, sizeof(pError->sErrorFeld));
		pError->sErrorFeld[sizeof(pError->sErrorFeld)-1] = 0;
	}
	else 
	{
		Satzart_GetAdditionalErrorInfoExp (pContext, pLine, pSatzartInfo, pFeld, pErrorDef, pError->sErrorFeld);
	}

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

		if (pCheckContext->pContext->flags & LKFCONTEXT_AUFPLAUS_IERRORS)
		{
			PlausReportIntensivError (pAufenthalt, pError->pErrorDef->nSeverity != LKF_SEV_ERROR, errorindex);
		} else if (pContext->modelljahr >= 2015) {
			/* V19.2 */
			if (pError->pErrorDef->nSeverity & LKF_SEV_ERROR) ++pAufenthalt->plaus_err; /* V21.2: == ersetzt durch & */
			else ++pAufenthalt->plaus_warn;
		}
	}
	else pError->pAufenthalt = 0;

    pError->pLine = 0;
    pError->pExpLine = pLine;
    
	nSev = lkf_getSeverity (pContext, pErrorDef);

	if (pCheckContext && pCheckContext->nWorstSeverity < nSev)
		pCheckContext->nWorstSeverity = nSev;

	if (pCheckContext && pCheckContext->nTraceFacility == LKF_FAC_KAS_KORE)
	{
		if (pCheckContext->bKKTraceInfo)
			lkf_trace_kk_info (pCheckContext, 0);
	}
	else if (pCheckContext && pCheckContext->nTraceFacility == LKF_FAC_INTSCOR)
	{
		if (LKF_IS_TRACE_INFO (pCheckContext->pContext->nTraceAufenthaltIntScor))
			lkf_trace_int_info (pCheckContext, 0);
	}
    lkf_context_count_error(pContext, pError);
}

static int Satzart_ErrorCheckFloat (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	switch (pCheck->nFunction & 255)
	{
		case LKF_CHECKFUNC_FORMAT:
			if (Satzart_GetValueFloat (ds, len, pFeld, 0, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 1;
			else return 0;
		case LKF_CHECKFUNC_EXISTS_NOT0:
			{
				int nRet;
				double dVal;
				nRet = Satzart_GetValueFloat (ds, len, pFeld, &dVal, pCheckContext->pContext->modelljahr);
				if (nRet == LKF_FIELD_EMPTY || (!nRet && dVal < DOUBLE_0_VALUE && dVal > -DOUBLE_0_VALUE)) return 1;
				if (Satzart_IsEmpty (ds, len, pFeld)) return 1;
				return 0;
			}
		default:
			return 1;
	}
}

static int Satzart_ErrorCheckFloatExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    switch (pCheck->nFunction & 255)
    {
        case LKF_CHECKFUNC_FORMAT:
            if (Satzart_GetValueFloatExp (expLine, pFeld, 0, pCheckContext->pContext->modelljahr) == LKF_FIELD_ERROR) return 1;
            else if (pFeld->nType == TYP_FLOAT_P2) {
                unsigned long len;
                const char *fieldbuf = expLine->fieldsById[pFeld->nFieldNum];
                len = (unsigned long) strlen(fieldbuf);
                if (len < 3 || fieldbuf[len - 3] != ',') {
                    return 1;
                }
                return 0;
            }
            else return 0;
        case LKF_CHECKFUNC_EXISTS_NOT0:
        {
            int nRet;
            double dVal;
            nRet = Satzart_GetValueFloatExp (expLine, pFeld, &dVal, pCheckContext->pContext->modelljahr);
            if (nRet == LKF_FIELD_EMPTY || (!nRet && dVal < DOUBLE_0_VALUE && dVal > -DOUBLE_0_VALUE)) return 1;
            if (Satzart_IsEmptyExp (expLine, pFeld)) return 1;
            return 0;
        }
        default:
            return 1;
    }
}


static int Satzart_ErrorCheckInt (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	const LKF_SATZART_ERRORCHECK_INTRANGE *pErrorCheckIntRange;
	int v;
	switch (pCheck->nFunction & 255) {
		case LKF_CHECKFUNC_INTRANGE:

			if (pCheckContext->pContext->modelljahr >= 2013)
			{
				if (Satzart_GetValueInt (ds, len, pFeld, &v)) return 1;
			}
			else if (Satzart_GetValueInt (ds, len, pFeld, &v) == LKF_FIELD_ERROR) return 1;
			pErrorCheckIntRange = (const LKF_SATZART_ERRORCHECK_INTRANGE *) pCheck->pCheckInfo;
			if (!pErrorCheckIntRange) return 1;
			else if (v < pErrorCheckIntRange->nMin || v > pErrorCheckIntRange->nMax) return 1;
			else return 0;
		case LKF_CHECKFUNC_BOOL01:
			if (Satzart_GetValueInt (ds, len, pFeld, &v) == LKF_FIELD_ERROR) return 1;
			if (v != 0 && v != 1) return 1;
			else return 0;
		case LKF_CHECKFUNC_FORMAT:
			if (Satzart_GetValueInt (ds, len, pFeld, &v) == LKF_FIELD_ERROR) return 1;
			else return 0;
		default:
			return 1;
	}
}

static int Satzart_ErrorCheckIntExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    const LKF_SATZART_ERRORCHECK_INTRANGE *pErrorCheckIntRange;
    int v;
    switch (pCheck->nFunction & 255) {
        case LKF_CHECKFUNC_INTRANGE:
            if (Satzart_GetValueIntExp (expLine, pFeld, &v)) return 1;
            pErrorCheckIntRange = (const LKF_SATZART_ERRORCHECK_INTRANGE *) pCheck->pCheckInfo;
            if (!pErrorCheckIntRange) return 1;
            else if (v < pErrorCheckIntRange->nMin || v > pErrorCheckIntRange->nMax) return 1;
            else return 0;
        case LKF_CHECKFUNC_BOOL01:
            if (Satzart_GetValueIntExp (expLine, pFeld, &v) == LKF_FIELD_ERROR) return 1;
            if (v != 0 && v != 1) return 1;
            else return 0;
        case LKF_CHECKFUNC_FORMAT:
            if (Satzart_GetValueIntExp (expLine, pFeld, &v) == LKF_FIELD_ERROR) return 1;
            else return 0;
        default:
            return 1;
    }
}


static int Satzart_ErrorCheckText (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return 0;
}

static int Satzart_ErrorCheckTextExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    return 0;
}

static int Satzart_ErrorCheckDate (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	if (!Satzart_GetValueDate (ds, len, pFeld)) return 1;
	else return 0;
}

static int Satzart_ErrorCheckDateExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    if (!Satzart_GetValueDateExp (expLine, pFeld)) return 1;
    else return 0;
}

static int Satzart_ErrorCheckTime (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{

	int v, stunde, minute;
	if (Satzart_GetValueInt (ds, len, pFeld, &v) == LKF_FIELD_ERROR) return 1;
	
	stunde = v / 100;
	minute = v % 100;

	if (stunde >= 0 && stunde < 24 && minute >= 0 && minute < 60) return 0;
	else return 1;
}

static int Satzart_ErrorCheckTimeExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    
    int v, stunde, minute;
    if (Satzart_GetValueIntExp (expLine, pFeld, &v) == LKF_FIELD_ERROR) return 1;
    
    stunde = v / 100;
    minute = v % 100;
    
    if (stunde >= 0 && stunde < 24 && minute >= 0 && minute < 60) return 0;
    else return 1;
}

int Satzart_ErrorCheckField (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	LKF_SATZART_ERRORCHECK_STRINGLIST *pStringList;
	LKF_SATZART_ERRORCHECK_FUNCTION func;
	int nVal, nRet;
	char sFieldVal[20];
	unsigned int i;

	if ((pCheck->nFunction & LKF_CHECK_NURFONDSKA) && !lkf_IsFondsKA (pCheckContext))
		return 0;

	if ((pCheck->nFunction & LKF_CHECK_BYPASS_EMPTY) && Satzart_IsEmpty (ds, len, pFeld)) 
		return 0;

	switch (pCheck->nFunction & 255) {
		case LKF_CHECKFUNC_NONE:
			return 0;
		case LKF_CHECKFUNC_EXISTS:
			if (Satzart_IsEmpty (ds, len, pFeld)) return 1;
			return 0;
		case LKF_CHECKFUNC_EXISTS_NOT0: /* V9.2 */
			if (pCheckContext->pContext->modelljahr > 2006 && pFeld->nType == TYP_FLOAT)
			{
				return Satzart_ErrorCheckFloat (ds, len, pFeld, pCheck, pCheckContext);
			}
			else
			{	
				nRet = Satzart_GetValueInt (ds, len, pFeld, &nVal);
				if (nRet == LKF_FIELD_EMPTY || (!nRet && !nVal)) return 1;
				if (Satzart_IsEmpty (ds, len, pFeld)) return 1;
				return 0;
			}
		case LKF_CHECKFUNC_FUNCTION:
			func = (LKF_SATZART_ERRORCHECK_FUNCTION) pCheck->pCheckInfo;
			return func (ds, len, pFeld, pCheck, pCheckContext); 
		
		case LKF_CHECKFUNC_STRINGLIST:
			pStringList = (LKF_SATZART_ERRORCHECK_STRINGLIST *) pCheck->pCheckInfo;
			
			if (pStringList)
			{
				Satzart_GetValueString (ds, len, pFeld, sFieldVal, 20);
				for (i = 0; i < pStringList->nStringCount; i++)
				{
					if (!strcmp (sFieldVal, pStringList->psValues[i])) return 0;
				}
				return 1;
			}
			return 0;
		default:
			switch (pFeld->nType) {
                case TYP_FLOAT:
                case TYP_FLOAT_NEG:
					return Satzart_ErrorCheckFloat (ds, len, pFeld, pCheck, pCheckContext);
                case TYP_FLOAT_P2:
                    return Satzart_ErrorCheckFloat (ds, len, pFeld, pCheck, pCheckContext);
				case TYP_NUM:
				case TYP_NUM_NEG:
				case TYP_NUM_NEG1000:
					return Satzart_ErrorCheckInt (ds, len, pFeld, pCheck, pCheckContext);			
                case TYP_ALPHA:
                case TYP_ALPHA_TRUNC:
					return Satzart_ErrorCheckText (ds, len, pFeld, pCheck, pCheckContext);			
				case TYP_DAT:
					return Satzart_ErrorCheckDate (ds, len, pFeld, pCheck, pCheckContext);			
				case TYP_ZEIT:
					return Satzart_ErrorCheckTime (ds, len, pFeld, pCheck, pCheckContext);			
				default:
					return 1;
			}
	}
	return 0;
}

int Satzart_ErrorCheckFieldExp (const LKF_EXPANDED_LINE *expLine, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    LKF_SATZART_ERRORCHECK_STRINGLIST *pStringList;
    LKF_SATZART_ERRORCHECK_FUNCTION func;
    int nVal, nRet;
    char sFieldVal[20];
    unsigned int i;
    
    if ((pCheck->nFunction & LKF_CHECK_NURFONDSKA) && !lkf_IsFondsKA (pCheckContext))
        return 0;
    
    if ((pCheck->nFunction & LKF_CHECK_BYPASS_EMPTY) && Satzart_IsEmptyExp (expLine, pFeld))
        return 0;
    
    switch (pCheck->nFunction & 255) {
        case LKF_CHECKFUNC_NONE:
            return 0;
        case LKF_CHECKFUNC_EXISTS:
            if (Satzart_IsEmptyExp (expLine, pFeld)) return 1;
            return 0;
        case LKF_CHECKFUNC_EXISTS_NOT0: /* V9.2 */
            if (pFeld->nType == TYP_FLOAT)
            {
                return Satzart_ErrorCheckFloatExp (expLine, pFeld, pCheck, pCheckContext);
            }
            else
            {
                nRet = Satzart_GetValueIntExp (expLine, pFeld, &nVal);
                if (nRet == LKF_FIELD_EMPTY || (!nRet && !nVal)) return 1;
                if (Satzart_IsEmptyExp (expLine, pFeld)) return 1;
                return 0;
            }
        case LKF_CHECKFUNC_FUNCTION:
            func = (LKF_SATZART_ERRORCHECK_FUNCTION) pCheck->pCheckInfo;
            return func ((const char *) expLine, LKF_LEN_FOR_EXPANDEDLINE, pFeld, pCheck, pCheckContext);
            
        case LKF_CHECKFUNC_STRINGLIST:
            pStringList = (LKF_SATZART_ERRORCHECK_STRINGLIST *) pCheck->pCheckInfo;
            
            if (pStringList)
            {
                Satzart_GetValueStringExp (expLine, pFeld, sFieldVal, 20);
                for (i = 0; i < pStringList->nStringCount; i++)
                {
                    if (!strcmp (sFieldVal, pStringList->psValues[i])) return 0;
                }
                return 1;
            }
            return 0;
        default:
            switch (pFeld->nType) {
                case TYP_FLOAT:
                case TYP_FLOAT_NEG:
                    return Satzart_ErrorCheckFloatExp (expLine, pFeld, pCheck, pCheckContext);
                case TYP_FLOAT_P2:
                    return Satzart_ErrorCheckFloatExp (expLine, pFeld, pCheck, pCheckContext);
                case TYP_NUM:
                case TYP_NUM_NEG:
                case TYP_NUM_NEG1000:
                    return Satzart_ErrorCheckIntExp (expLine, pFeld, pCheck, pCheckContext);
                case TYP_ALPHA:
                case TYP_ALPHA_TRUNC:
                    return Satzart_ErrorCheckTextExp (expLine, pFeld, pCheck, pCheckContext);
                case TYP_DAT:
                    return Satzart_ErrorCheckDateExp (expLine, pFeld, pCheck, pCheckContext);
                case TYP_ZEIT:
                    return Satzart_ErrorCheckTimeExp (expLine, pFeld, pCheck, pCheckContext);
                default:
                    return 1;
            }
    }
    return 0;
}


const LKF_SATZART_ERRORCHECK *lkf_getModelDependentCheck (const LKF_SATZART_ERRORCHECK *pCheck, const LKF_CONTEXT *pContext)
{

	if (!pCheck || !pContext) return pCheck;
	while (pCheck && pCheck->nModellJahr && pCheck->nModellJahr <= (unsigned int) pContext->modelljahr)
		pCheck = pCheck->pAlternateCheck;

	if (pCheck && pCheck->pErrorDef) 
	{ /* V17.0 */
		const LKF_SATZART_ERROR_PROPERTIES *pProperties = lkf_getErrorProperties (pCheck->pErrorDef, pContext);
		if (pProperties && pProperties->nNichtFonds == 0 && pProperties->nFonds == 0) 
		{
			if (pCheck->pNextSuc) return lkf_getModelDependentCheck (pCheck->pNextSuc, pContext);
			else return 0;
		}
	}
    if (pCheck->nFunction != LKF_CHECKFUNC_NONE) /* V2026.0 */ {
        return pCheck;
    }
    return 0;
}

unsigned int Satzart_Check (LKF_CONTEXT *pContext, const char *ds, const SATZART_INFO *pSatzartInfo, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nVal;
	unsigned int nErrorCount;
	unsigned int i;
	unsigned int len;
	const SATZART *pSatzart;
	const SATZART_FELD *pFeld;
	const LKF_SATZART_ERRORCHECK *pCheck;

	int nTraceDetails;


	pSatzart = pSatzartInfo->pSatzart;
	nErrorCount = 0;

	lkf_trace_SetFacility (pContext, pSatzart->sPrefix);

	if (lkf_isTraceInput (pContext, 0) && ds)
		lkf_addTraceInputLine (pContext, ds);
	
	nTraceDetails = lkf_isTraceDetail (pContext, 0);
	
	len = (unsigned int) strlen (ds);
	while (len > 0 && ds[len-1] == ' ') --len;
	
	pCheckContext->sErrorAdditionalInfo[0] = 0;
	pCheckContext->lCheckFlags = 0;

	pCheckContext->bKKTraceDetail = lkf_isTraceDetail (pContext, LKF_FAC_KAS_KORE);
	pCheckContext->bKKTraceInfo =   lkf_isTraceInfo (pContext, LKF_FAC_KAS_KORE);


	for (i = 0; i < pSatzart->nCount && !pCheckContext->lCheckFlags; i++)
	{
		pFeld = lkf_getSatzartFeld (pContext->modelljahr, pSatzart->Felder + i);
		if (!pFeld) continue;
		pCheck = pFeld->pCheckInfo;
		while (pCheck) 
		{
			pCheck = lkf_getModelDependentCheck (pCheck, pContext);


			pCheckContext->pCurrentCheck = pCheck;
			if (pCheck)
			{
				if (Satzart_ErrorCheckField (ds, len, pFeld, pCheck, pCheckContext)) {

					Satzart_ReportError (pContext, pCheckContext, ds, len,pSatzartInfo, pFeld, pCheck->pErrorDef, pCheckContext->sErrorAdditionalInfo);
					pCheckContext->sErrorAdditionalInfo[0] = 0;
					pCheck = pCheck->pNextErr;
				}
				else pCheck = pCheck->pNextSuc;

				if (pCheckContext->lCheckFlags & CHECKFLAG_SKIP_LINE) pCheck = 0;
			}
		}

		pCheckContext->pCurrentCheck = 0;
		if (!(pCheckContext->lCheckFlags & CHECKFLAG_SKIP_LINE))
		{
			if (pFeld->nType == TYP_NUM_NEG1000)
			{
				if (!Satzart_GetValueInt (ds, len, pFeld, &nVal) && nVal < -1000)
					Satzart_ReportError (pContext, pCheckContext, ds, len, pSatzartInfo, pFeld, &LKFKKErrorNegKosten1000, 0);
			}
		}
	}

	if (!(pCheckContext->lCheckFlags & CHECKFLAG_SKIP_LINE))
	{
		pCheck = pSatzart->pCheck;
		pCheckContext->sErrorAdditionalInfo[0] = 0;
		while (pCheck)
		{
			pCheck = lkf_getModelDependentCheck (pCheck, pContext);

			if (pCheck)
			{
				if (Satzart_ErrorCheckField (ds, len, 0, pCheck, pCheckContext)) {
					Satzart_ReportError (pContext, pCheckContext, ds, len, pSatzartInfo, 0, pCheck->pErrorDef, pCheckContext->sErrorAdditionalInfo);
					pCheckContext->sErrorAdditionalInfo[0] = 0;
					pCheck = pCheck->pNextErr;
				}
				else pCheck = pCheck->pNextSuc;
			}
		}
	}
	return nErrorCount;
}

unsigned int Satzart_CheckExp (LKF_CONTEXT *pContext, const LKF_EXPANDED_LINE *expLine, const SATZART_INFO *pSatzartInfo, LKF_CHECK_CONTEXT *pCheckContext)
{
    int nVal;
    unsigned int nErrorCount;
    unsigned int i;
    const SATZART *pSatzart;
    const SATZART_FELD *pFeld;
    const LKF_SATZART_ERRORCHECK *pCheck;
    
    int nTraceDetails;
    
    
    pSatzart = pSatzartInfo->pSatzart;
    nErrorCount = 0;
    
    lkf_trace_SetFacility (pContext, pSatzart->sPrefix);
    
    if (lkf_isTraceInput (pContext, 0) && expLine) {
        char line[2048];
        lkf_write_expLine(line, expLine);
        lkf_addTraceInputLine (pContext, line);
    }
    
    nTraceDetails = lkf_isTraceDetail (pContext, 0);
    pCheckContext->sErrorAdditionalInfo[0] = 0;
    pCheckContext->lCheckFlags = 0;
    
    pCheckContext->bKKTraceDetail = lkf_isTraceDetail (pContext, LKF_FAC_KAS_KORE);
    pCheckContext->bKKTraceInfo =   lkf_isTraceInfo (pContext, LKF_FAC_KAS_KORE);
    
    
    for (i = 0; i < pSatzart->nCount && !pCheckContext->lCheckFlags; i++)
    {
        pFeld = lkf_getSatzartFeld (pContext->modelljahr, pSatzart->Felder + i);
        if (!pFeld) continue;
        pCheck = pFeld->pCheckInfo;
        while (pCheck)
        {
            pCheck = lkf_getModelDependentCheck (pCheck, pContext);
            
            
            pCheckContext->pCurrentCheck = pCheck;
            if (pCheck)
            {
                
                if (!strcmp (pFeld->sFeldName, "SPEZIELLE ORGANISATIONSFORM")) {
                    pCheck = pCheck;
                }
                
                if (Satzart_ErrorCheckFieldExp (expLine, pFeld, pCheck, pCheckContext)) {
                    
                    Satzart_ReportErrorExp (pContext, pCheckContext, expLine, pSatzartInfo, pFeld, pCheck->pErrorDef, pCheckContext->sErrorAdditionalInfo);
                    pCheckContext->sErrorAdditionalInfo[0] = 0;
                    pCheck = pCheck->pNextErr;
                }
                else pCheck = pCheck->pNextSuc;
                
                if (pCheckContext->lCheckFlags & CHECKFLAG_SKIP_LINE) pCheck = 0;
            }
        }
        
        pCheckContext->pCurrentCheck = 0;
        if (!(pCheckContext->lCheckFlags & CHECKFLAG_SKIP_LINE))
        {
            if (pFeld->nType == TYP_NUM_NEG1000)
            {
                if (!Satzart_GetValueIntExp (expLine, pFeld, &nVal) && nVal < -1000)
                    Satzart_ReportErrorExp (pContext, pCheckContext, expLine, pSatzartInfo, pFeld, &LKFKKErrorNegKosten1000, 0);
            }
        }
    }
    
    if (!(pCheckContext->lCheckFlags & CHECKFLAG_SKIP_LINE))
    {
        pCheck = pSatzart->pCheck;
        pCheckContext->sErrorAdditionalInfo[0] = 0;
        while (pCheck)
        {
            pCheck = lkf_getModelDependentCheck (pCheck, pContext);
            
            if (pCheck)
            {
                if (Satzart_ErrorCheckFieldExp (expLine, 0, pCheck, pCheckContext)) {
                    Satzart_ReportErrorExp (pContext, pCheckContext, expLine, pSatzartInfo, 0, pCheck->pErrorDef, pCheckContext->sErrorAdditionalInfo);
                    pCheckContext->sErrorAdditionalInfo[0] = 0;
                    pCheck = pCheck->pNextErr;
                }
                else pCheck = pCheck->pNextSuc;
            }
        }
    }
    return nErrorCount;
}


void lkf_Satzart_Counter_Clear (LKF_CONTEXT *pContext)
{
    unsigned int i;
    for (i = 0; i < MAX_X_SATZART_NUM; i++) pContext->Count_X[i] = 0;
	for (i = 0; i < MAX_M_SATZART_NUM; i++) pContext->Count_M[i] = 0;
	for (i = 0; i < MAX_I_SATZART_NUM2011; i++) pContext->Count_I[i] = 0;
	for (i = 0; i < MAX_L_SATZART_NUM; i++) pContext->Count_L[i] = 0;
	for (i = 0; i < MAX_K_SATZART_NUM; i++) pContext->Count_K[i] = 0;
	for (i = 0; i < MAX_G_SATZART_NUM; i++) pContext->Count_G[i] = 0;
	for (i = 0; i < MAX_S_SATZART_NUM; i++) pContext->Count_S[i] = 0;
	for (i = 0; i < MAX_B_SATZART_NUM; i++) pContext->Count_B[i] = 0;

}

_SCORING_EXPORT const LKF_SATZART_DEFS *lkf_Satzart_getDefinition (unsigned int modell_jahr)
{
	return SatzartDef_Init ((int) modell_jahr);
}

_SCORING_EXPORT unsigned int lkf_Satzart_getCount (const LKF_SATZART_DEFS *pSatzartDefs)
{
	if (pSatzartDefs) return pSatzartDefs->nCount;
	else return 0;
}

_SCORING_EXPORT unsigned int lkf_Satzart_getSatzartFieldCount (const LKF_SATZART_DEFS *pSatzartDefs, unsigned int satzart_nr)
{
	if (pSatzartDefs && pSatzartDefs->nCount > satzart_nr) return pSatzartDefs->ppSatzarten[satzart_nr]->nCount;
	else return 0;
}

_SCORING_EXPORT unsigned int lkf_Satzart_getSatzartFieldTextId (const LKF_SATZART_DEFS *pSatzartDefs, unsigned int satzart_nr, unsigned int field_nr, char *buf, unsigned int buflen)
{
	char internal_buf[1024];
	unsigned int l;
	if (pSatzartDefs && pSatzartDefs->nCount > satzart_nr) 
	{
		const SATZART *pSatzart = pSatzartDefs->ppSatzarten[satzart_nr];
		if (pSatzart->nCount > field_nr) {
			const SATZART_FELD *pFeld = lkf_getSatzartFeld (pSatzartDefs->jahr, pSatzart->Felder + field_nr);
			if (pFeld)
				sprintf (internal_buf, "%3s;%03d;", pSatzart->sPrefix, pFeld->nFieldNum);
			else
				internal_buf[0] = 0;
		}
		else if (field_nr == (1<<16))
		{
			sprintf (internal_buf, "%s;   ;", pSatzart->sPrefix);
		}
		else internal_buf[0] = 0;
	}
	else if (pSatzartDefs && (satzart_nr == (1<<16) || satzart_nr == (1<<17)))
	{
		sprintf (internal_buf, "   ;   ;");
	}
	else internal_buf[0] = 0;

	l = (unsigned int) strlen (internal_buf);
	if (l < buflen) strncpy (buf, internal_buf, buflen); 
	return l;


}

static const char *lkf_fieldtype_to_num (int modell, int nType, char *sBuf)
{
	switch (nType)
	{
		case TYP_NUM:
			strcpy (sBuf, "Num");
			break;
		case TYP_NUM_NEG:
			strcpy (sBuf, "NumNeg");
			break;
		case TYP_NUM_NEG1000:
			strcpy (sBuf, "Num-1000");
			break;
        case TYP_ALPHA:
			strcpy (sBuf, "Text");
			break;
        case TYP_FLOAT_P2:
            strcpy (sBuf, "DezPos2");
            break;
        case TYP_ALPHA_TRUNC:
            if (modell >= 2024) {
                strcpy (sBuf, "Text/TR");
            }
            else {
                strcpy (sBuf, "Text");
            }
            break;
		case TYP_DAT:
			strcpy (sBuf, "Datum");
			break;
		case TYP_ZEIT:
			strcpy (sBuf, "Zeit");
			break;
		case TYP_FLOAT:
			strcpy (sBuf, "NumDez");
			break;
        case TYP_FLOAT_NEG:
            strcpy (sBuf, "NumDezN");
            break;
		default:
			sprintf (sBuf, "Typ%02d", nType);
			break;
	}
	return sBuf;
}

_SCORING_EXPORT unsigned int lkf_Satzart_getSatzartFieldInfo (const LKF_SATZART_DEFS *pSatzartDefs, unsigned int satzart_nr, unsigned int field_nr, char *buf, unsigned int buflen)
{
	char sTypeBuf[20];
	if (pSatzartDefs && pSatzartDefs->nCount > satzart_nr) 
	{
		const SATZART *pSatzart = pSatzartDefs->ppSatzarten[satzart_nr];
		if (pSatzart->nCount > field_nr) {
			unsigned int l;
			char internal_buf[1024];
			const SATZART_FELD *pFeld = lkf_getSatzartFeld (pSatzartDefs->jahr, pSatzart->Felder + field_nr);
			if (!pFeld) return 0;
			sprintf (internal_buf, "F;%3.3s;%03d;%-8.8s;%03d;%03d;%8X;%s", pSatzart->sPrefix, pFeld->nFieldNum, lkf_fieldtype_to_num(pSatzartDefs->jahr, pFeld->nType, sTypeBuf), pFeld->nPos, pFeld->nLen, pFeld->nScoreInfo, pFeld->sFeldName); /* V16.0: nach 3 Stellen abschneiden */
			l = (unsigned int) strlen (internal_buf);
			if (l < buflen) strncpy (buf, internal_buf, buflen); 
			return l;
		}
		else return 0;
	}
	else return 0;
}

_SCORING_EXPORT unsigned int lkf_Satzart_getSatzartDef (const LKF_SATZART_DEFS *pSatzartDefs, unsigned int satzart_nr, char *buf, unsigned int buflen)
{
	char internal_buf[1024];
	if (pSatzartDefs && pSatzartDefs->nCount > satzart_nr) 
	{
		const SATZART *pSatzart = pSatzartDefs->ppSatzarten[satzart_nr];
		unsigned int l;
		sprintf (internal_buf, "S;%3.3s;%03d;%s", pSatzart->sPrefix, pSatzart->nStarts, pSatzart->sTitle);
		l = (unsigned int) strlen (internal_buf);
		if (l < buflen) strncpy (buf, internal_buf, buflen); 
		return l;
	}
	else return 0;
}

_SCORING_EXPORT unsigned int lkf_Satzart_getSatzartKeyInfo (const LKF_SATZART_DEFS *pSatzartDefs, unsigned int satzart_nr, char *buf, unsigned int buflen)
{
	char internal_buf[1024];

	if (pSatzartDefs && pSatzartDefs->nCount > satzart_nr) 
	{
		const SATZART *pSatzart = pSatzartDefs->ppSatzarten[satzart_nr];
		const int *pKey = pSatzart->nErrorIdentFields;
		sprintf (internal_buf, "K;%3.3s;", pSatzart->sPrefix);
		if (pKey) {
			unsigned int i, l;
			char b[8];		
			for (i = 0; pKey[i] >= 0; i++) {
				sprintf (b, ";%d", pKey[i]);
				strcat (internal_buf, b);
			}		
			l = (unsigned int) strlen (internal_buf);
			if (l < buflen) strncpy (buf, internal_buf, buflen); 
			return l;
		}
		else return 0;
	}
	else return 0;
}

/*************************************************************************************
** Erzeugung der Error-Information zu den Satzarten                                 **
*************************************************************************************/

_SCORING_EXPORT const void *lkf_Satzart_getSatzartFieldCheck (const LKF_CONTEXT *pContext, const LKF_SATZART_DEFS *pSatzartDefs, unsigned int satzart_nr, unsigned int field_nr)
{
	if (pSatzartDefs && pSatzartDefs->nCount > satzart_nr) 
	{
		const SATZART *pSatzart = pSatzartDefs->ppSatzarten[satzart_nr];
		if (pSatzart->nCount > field_nr) {
			const SATZART_FELD *pFeld = lkf_getSatzartFeld (pSatzartDefs->jahr, pSatzart->Felder + field_nr);
			if (pFeld && pFeld->pCheckInfo) 
				return (const void *) lkf_getModelDependentCheck (pFeld->pCheckInfo, pContext); /* V10.2 */
			else
				return 0;
		}
		else if (field_nr == (1<<16)) {
			return (const void *) lkf_getModelDependentCheck(pSatzart->pCheck, pContext);
		}
	}
	else if (pSatzartDefs && satzart_nr == (1<<16))
	{
        const LKF_SATZART_ERRORCHECK **pGeneralChecks = lkf_get_facility_general_checks (pContext, LKF_FAC_KAS_KORE);
        if (pGeneralChecks) {
            return lkf_getModelDependentCheck(pGeneralChecks[field_nr], pContext);
        }
        return 0;
	}
	else if (pSatzartDefs && satzart_nr == (1<<17))
	{
        const LKF_SATZART_ERRORCHECK **pGeneralChecks = lkf_get_facility_general_checks (pContext, LKF_FAC_BERICHT);
        if (pGeneralChecks) {
            return lkf_getModelDependentCheck(pGeneralChecks[field_nr], pContext);
        }
        return 0;
	}
	return 0;
}

_SCORING_EXPORT const void *lkf_Satzart_getNextCheck (const LKF_CONTEXT *pContext, const void *pErrorCheck, int onsuccess)
{
	const LKF_SATZART_ERRORCHECK *pCheck = pErrorCheck;


	if (pCheck) {
		if (onsuccess) pCheck = pCheck->pNextSuc;
		else pCheck = pCheck->pNextErr;

		if (pCheck) pCheck = lkf_getModelDependentCheck (pCheck, pContext); /* V10.2 */
		return pCheck;
	}
	else return 0;
}

static const char *lkf_Satzart_getTypeDependentInfo (const LKF_SATZART_ERRORCHECK *pCheck, char *buf)
{
	char prefix[48];
	const LKF_SATZART_ERRORCHECK_STRINGLIST *pStringList;
	const LKF_SATZART_ERRORCHECK_INTRANGE *pIntRange;
	switch (pCheck->nFunction & 255) {
		default:
		case LKF_CHECKFUNC_NONE:
			strcpy (buf, "Kein Check");
			break;
		case LKF_CHECKFUNC_BOOL01:
			strcpy (buf, "BOOL(0/1)");
			break;
		case LKF_CHECKFUNC_EXISTS:
			strcpy (buf, "LEER");
			break;
		case LKF_CHECKFUNC_EXISTS_NOT0:
			strcpy (buf, "LEER/0");
			break;
		case LKF_CHECKFUNC_FUNCTION:
			strcpy (buf, "FUNCTION");
			break;
		case LKF_CHECKFUNC_FORMAT:
			strcpy (buf, "FORMAT");
			break;
		case LKF_CHECKFUNC_STRINGLIST:
			pStringList = (const LKF_SATZART_ERRORCHECK_STRINGLIST *) pCheck->pCheckInfo;
			if (pStringList) {
				sprintf (buf, "STRINGLIST[%d]", pStringList->nStringCount);
			}
			else
				strcpy (buf, "STRINGLIST");
			break;
		case LKF_CHECKFUNC_INTRANGE:
			pIntRange = (const LKF_SATZART_ERRORCHECK_INTRANGE *) pCheck->pCheckInfo;
			if (pIntRange)
				sprintf (buf, "INTRANGE: %d - %d", pIntRange->nMin, pIntRange->nMax);
			else 
				strcpy (buf, "INTRANGE ???");
			break;
	}

	prefix[0] = 0;

	if (pCheck->nFunction & LKF_CHECK_NURFONDSKA)
		strcpy (prefix, "*/");

	if (pCheck->nFunction & LKF_CHECK_BYPASS_EMPTY)
		strcat (prefix, "BE/");
	
	if (prefix[0])
	{
		strcat (prefix, buf);
		strcpy (buf, prefix);
	}

	return buf;
}

_SCORING_EXPORT unsigned int lkf_Satzart_getCheckInfo (const LKF_CONTEXT *pContext, const void *pErrorCheck, const char *sFieldId, const char *sErrorPrefix, char *buf, unsigned int buflen)
{
	const LKF_SATZART_ERRORCHECK *pCheck;
	char internal_buf[1024], internal_fieldid[48];
	char internal_func_buf[512];
    char internal_error_buf[256];
	unsigned int l;
	char sErrorIdent[6];
	strncpy (internal_fieldid, sFieldId, 48);
	internal_fieldid[47] = 0;

	pCheck = lkf_getModelDependentCheck ((const LKF_SATZART_ERRORCHECK *) pErrorCheck, pContext); /* V10.1 */
	if (!pCheck) return 0;

	sprintf (internal_buf, "C;%s                         ; %-16.16s;%-30.30s;%4.4s;%s", sFieldId, sErrorPrefix,
		lkf_Satzart_getTypeDependentInfo (pCheck, internal_func_buf),
		pCheck->pErrorDef ? lkf_getErrorIdent (pContext, pCheck->pErrorDef, 6, sErrorIdent) : "", 
		pCheck->pErrorDef ? lkf_context_formatted_text (pContext, pCheck->pErrorDef->sText, internal_error_buf) : "");
			 

	l = (unsigned int) strlen (internal_buf);
	if (l < buflen) strncpy (buf, internal_buf, buflen); 
	return l;

}

const LKF_SATZART_ERRORDEF *lkf_importcheck_kanr (LKF_CONTEXT *pContext, const char *ka, int bTraegerOk /* V14.2 */)
{
	int isKTR = 0; /* V14.2 */
	if (IsEmpty (ka, 4))
	{
		if (!(pContext->flags & LKFCONTEXT_ALLOWQUICKSCORE)) return &LKFErrorKAfehlt;
		else return 0;
	}
	else if (pContext->KANR[0])
	{
		if (memcmp (pContext->KANR, ka, 4))
		{
			if (!KAInArray (pContext->pStamm2001, ka))
			{
				if (bTraegerOk && KTRInArray (pContext->pStamm2001, ka))
					isKTR = 1;
				else
					return &LKFErrorKAfalsch; 
			}
			else return &LKFErrorKAmultibel;
		}
		else return 0;
	}
	else if (!KAInArray (pContext->pStamm2001, ka)) 
	{
		if (bTraegerOk && KTRInArray (pContext->pStamm2001, ka))
			isKTR = 1;
		else
			return &LKFErrorKAfalsch;
	}
	
	memcpy (pContext->KANR, ka, 4);
	pContext->KANR[4] = 0;
	pContext->isKTR = (unsigned int) isKTR;
	return 0;
}

static const LKF_SATZART_ERRORDEF **lkf_getGeneralErrorInfo (const LKF_CONTEXT *pContext)
{
    if (pContext->modelljahr >= 2017) {
        return ppGeneralErrors2017;
    }
	return ppGeneralErrors;
}

int lkf_create_general_errorinfo (LKF_SATZART_ERRORINFO_LIST *pList, LKF_CONTEXT *pContext, unsigned int nSev)
{
	unsigned int i;
	LKF_SATZART_ERRORINFO *pErrorInfo;
	const LKF_SATZART_ERRORDEF **generalErrors = lkf_getGeneralErrorInfo (pContext);

	i = 0;

	while (generalErrors[i])
	{
		if (lkf_getSeverity (pContext, generalErrors[i]) & nSev)
		{
			unsigned int nNextInfo = lkf_getNextFreeErrorInfo (pList);
            if (nNextInfo == LKF_OUTOFMEMORY_UINTERROR) return LKF_OUTOFMEMORY_ERROR;
			pErrorInfo = pList->pErrors + nNextInfo; /* V11.1 */
			pErrorInfo->nAlloc = pErrorInfo->nCount = 0;
			pErrorInfo->pUsage = 0;
			pErrorInfo->pError = generalErrors[i];
			pErrorInfo->nOccurrences = 1;
			pErrorInfo->pContext = pContext;
			pErrorInfo->nFonds = 1;
			pErrorInfo->nNichtFonds = 1;
			lkf_getErrorIdent (pContext, generalErrors[i], 6, pErrorInfo->sErrorCode);
		}
		++i;
	}
    return 0;
}


const LKF_SATZART_ERRORDEF **lkf_get_general_errors (const LKF_CONTEXT *pContext, unsigned int nFacility)
{
    switch (nFacility) {
        case LKF_FAC_KAS_KORE:
            if (pContext->modelljahr >= 2024) {
                return GenKKErrors2024;
            }
            return GenKKErrors;
        default:
            return 0;
    }
}


const LKF_SATZART_ERRORCHECK **lkf_get_facility_general_checks (const LKF_CONTEXT *pContext, unsigned int facility)
{
    
    switch (facility) {
        case LKF_FAC_BERICHT:
            return lkf_get_bericht_general_checks(pContext);
        case LKF_FAC_KAS_KORE:
            return GenKKChecks2008;
        default:
            return 0;
    }
}


unsigned int lkf_getSeverity (const LKF_CONTEXT *pContext, const LKF_SATZART_ERRORDEF *pErrorDef)
{ /* V9.0: Liefert die Error-Severity zur\xc3\xbc""ck */
	if (!pErrorDef) return 0;
	else if (!pContext) return pErrorDef->nSeverity & 255;
	else if (pContext->modelljahr == 2004)
	{
		if (pErrorDef->nFacility == LKF_FAC_INTSCOR && (pErrorDef->nSeverity & LKF_SEV_ERROR))
			return LKF_SEV_WARNING; /* V9.0: Intensiv-Errors sind Warnings im Modelljahr 2004 */
		else if (pErrorDef->nFacility == LKF_FAC_MBDS && (pErrorDef->nSeverity & LKF_SEV_ERROR) && pErrorDef->nOldCode >= 66 && pErrorDef->nOldCode <= 88)
			return LKF_SEV_WARNING; /* V9.0: MBDS-Errors f\xc3\xbc""r Intensiv-M02 sind Warnings im Modelljahr 2004 */
	}
	return pErrorDef->nSeverity & 255;
}


/*****************************************************************************************************
** L01-Check                                                                                        **
*****************************************************************************************************/

static int ABTFC_Bereich_Check (LKF_CONTEXT *pContext, const SPEZ_LIST_STRING *pSpezListString) 
{ /* V17.0 */
	return ABTFC_SpezList_Match (pContext, pSpezListString); 
}

void lkf_checkL01 (LKF_CHECK_CONTEXT *pCheckContext) 
{ /* V17.0 - Check auf Error EK84 (Funktionscode in Kombination mit speziellem Leistungsbereich ungueltig) */
	unsigned int j, count;
	const char *spezBuf;
	char infoBuf[20];
	const SATZART_INFO *pL01SatzartInfo = 0;
	LKF_CONTEXT *pContext = pCheckContext->pContext;

	/* Check der gemeldeten L01-Datens\xc3\xa4""tze */
	if (pContext->Count_L[0]) 
	{
		count = pContext->Count_L[0];
		for (j = 0; j < count; j++) 
		{
			spezBuf = pContext->spez_list[j];
			if (!ABTFC_Bereich_Check (pContext, (const SPEZ_LIST_STRING *) (pContext->spez_list + j))) 
			{
				if (!pL01SatzartInfo) pL01SatzartInfo = lkf_GetSatzartL01Internal (pContext);
				sprintf (infoBuf, "%c-%2.2s/%8.8s", spezBuf[0], spezBuf+27, spezBuf + 9);
				Satzart_ReportError (pContext, pCheckContext, spezBuf, 0, pL01SatzartInfo, 0, &LKFKKErrorFuncLeistBereich, infoBuf);
			}
		}
	}

	/* Check der SPEZLIST.dat */
	if (pContext->pStamm2001) 
	{
		count = pContext->pStamm2001->spez_gesamt;

		for (j = 0; j < count; j++) 
		{
			spezBuf = pContext->pStamm2001->spez_list[j];
			if (memcmp (spezBuf + 5, pContext->KANR, 4)) continue;
			
			if (!ABTFC_Bereich_Check (pContext, (const SPEZ_LIST_STRING *) (pContext->pStamm2001->spez_list + j)))
			{
				if (!pL01SatzartInfo) pL01SatzartInfo = lkf_GetSatzartL01Internal (pContext);
				sprintf (infoBuf, "%c-%2.2s/%8.8s", spezBuf[0], spezBuf+27, spezBuf + 9);
				Satzart_ReportError (pContext, pCheckContext, spezBuf, 0, pL01SatzartInfo, 0, &LKFKKErrorFuncLeistBereich, infoBuf);
			}
		}
	}
}

/*****************************************************************************************************
** Kommentare zu den Check-Funktionen                                                               **
*****************************************************************************************************/#

const LKF_SATZART_ERRORCHECK_COMMENT Comments[] = {

{intcheck_erhebdat_zeitraum, "Fehler, wenn Meldungsdatum vor Abteilungsaufnahmedatum oder nach Abteilungsentlassungsdatum"},
{intcheck_erhebdat_doppelt, "Fehler, wenn zwei Datens\xc3\xa4""tze der Abteilung am gleichen Tag gemeldet wurden"},
{intcheck_si_einheit, "SI-Einheit mu\xc3\x9f"" 1 oder 2 sein"},
{intcheck_gesamtbilirubin, "Wert zw. 0 und 2000 (SI<>2) bzw. 0 und 34200 oder leer"},
{intcheck_sauerstoffpart, "Wert zw. 0 und 700 (SI<>2) bzw. zw. 0 und 933 oder leer"},
{intcheck_harnstoff, "Wert zw. 0 und 642 (SI<>2) bzw. zw. 0 und 999 oder leer (bis Modell 2004: 0/500 bzw. 0/830)"},
{intcheck_harnstoff_n, "Wert zw. 0 und 300 (SI<>2) bzw. zw. 0 und 830 oder leer"},
{intcheck_syst_art_blutdruck, "Wert zw. 0 und 500 (SI<>2) bzw. zw. 0 und 667 oder leer"},
{intcheck_komb_med, "Fehler, wenn sowohl Medikation einfach als auch Medikation mehrfach gesetzt ist"},
{intcheck_komb_atemunt, "Fehler, wenn sowohl Atemunterst\xc3\xbc""tzung als auch mechanische Beatmung gesetzt ist"},
{intcheck_komb_med_vaso, "Fehler, wenn sowohl med.vaso.einmalig und mehrfach gesetzt ist"},
{intcheck_komb_intervention, "Fehler, wenn sowohl Intervention einfach als auch Intervention mehrfach gesetzt ist"},
{intcheck_metabol, "Fehler, wenn Satz f\xc3\xbc""r den Abteilungsaufnahmetag und metabolisch gesetzt ist und Serum Bikarbonat zwischen 22 und 28 ist"},
{int_check_fio2, "Fehler, wenn FIO2 nicht leer und nicht zwischen 1 und 100"},
{int_check_fio2_2011, "Fehler, wenn FIO2 nicht leer und nicht zwischen 10 und 100"},
{intcheck_komb_saps_gcs, "Fehler, wenn SAPS-Aufnahmeart = 2 und GCS-Summe kleiner gleich 8"},
{intcheck_komb_chirurg_gcs, "Fehler, wenn Chirurgischer Status = 1 und GCS-Summe kleiner gleich 8"}, /* V15.1 */
{intcheck_komb_sapsfio2_mechvent, "Fehler, wenn Satz f\xc3\xbc""r den Abteilungsaufnahmetag und Mechanische Ventilation gesetzt ist und FIO2 kleiner 21 ist"},
{intcheck_komb_sapsfio2_atmung, "Fehler, wenn Satz f\xc3\xbc""r den Abteilungsaufnahmetag und Atmungsmodus <> 0 ist und FIO2 kleiner 21 ist"},
{kaskore_berichtsjahr, "Jahr mu\xc3\x9f"" mit Abrechnungsjahr \xc3\xbc""bereinstimmen"},
{kaskore_checkfunc, "Fehler, wenn Abteilungs-FC nicht in Stammdaten-Datei FUNK.dat zu finden (erste 6 Zeichen)"},
{kaskore_checkfunc_mehrfach, "Fehler, wenn mehr als ein K01-Satz f\xc3\xbc""r den Abt-FC gemeldet wurde"},
{kaskore_spezorghk, "Fehler, wenn Feld nicht leer ist und die Abteilung keine Hauptkostenstelle ist"},
{k01_check_intkost_mehrfach, "Fehler, wenn f\xc3\xbc""r mehr als eine Abteilung die gleiche interne Kostenstelle gemeldet wurde"},
{kaskore_leitungsformat, "Fehler, wenn nicht 3 durch '/' getrennte Werte (Nachname, Vorname, Titel), das erste Feld darf keine Kleinbuchstaben enthalten"},
{check_plz, "Fehler, wenn die Postleitzahl nicht im Postleitzahlenverzeichnis enthalten ist"},
{kaskore_systbetten_k08, "Fehler, wenn die gemeldet Anzahl syst. Betten nicht mit der Summe syst. Betten aller K08-S\xc3\xa4""tze \xc3\xbc""bereinstimmt"},
{check_ambbetten,"Fehler, wenn die gemeldet Anzahl ambulanter Betreuungspl\xc3\xa4""tze nicht mit der Summe aller K09-S\xc3\xa4""tze \xc3\xbc""bereinstimmt"},
{kaskore_systbetten_sond, "Nur f\xc3\xbc""r Fonds-KH: Fehler, wenn die Anzahl syst. Betten Sonderklasse gr\xc3\xb6""\xc3\x9f""er der Anzahl syst. Betten gesamt ist"},
{check_gesamtumlagefehlerhaft, "Liefert Fehler EK5G, wenn die Gesamtsumme KOAGR11 (K08-K10) nicht mit der Summe abg. Innerbetr. Leistungen AbtFC = 31* \xc3\xbc""bereinstimmt (Toleranz 1000);\n EK5H f\xc3\xbc""r KOAGR12 verglichen mit AbtFC=32; EK5K f\xc3\xbc""r KOAGR13 verglichen mit AbtFC=33*;\n EK5L f\xc3\xbc""r KOAGR14 verglichen mit AbtFC=1*/2*;\nEK65, wenn die Summe aller abg. innerbetr. Leistungen nicht mit der Summe KOAGR11-KOAGR14 \xc3\xbc""bereinstimmt"},
{kaskore_tatsbetten_sond, "Nur f\xc3\xbc""r Fonds-KH: Fehler, wenn die Anzahl tats. Betten Sonderklasse gr\xc3\xb6""\xc3\x9f""er der Anzahl tats. Betten insgesamt ist"},
{k03_belagsondgross, "Fehler, wenn die Belagstage Sonderklasse gr\xc3\xb6""\xc3\x9f""er der Belagstage der gemeldeten MBDS-Daten ist"},
{k03_aufsondgross, "Fehler, wenn die Anzahl Aufnahmen der Sonderklasse gr\xc3\xb6""\xc3\x9f""er als die gemeldeten Aufnahmen im Berichtsjahr aufgrund der MBDS-Daten ist"},
{k03_entlsondgross, "Fehler, wenn die Anzahl Entlassungen der Sonderklasse gr\xc3\xb6""\xc3\x9f""er als die gemeldeten Entlassungen im Berichtsjahr aufgrund der MBDS-Daten ist"},
{k03_verstsondgross, "Fehler, wenn die Anzahl Verstorbener der Sonderklasse gr\xc3\xb6""\xc3\x9f""er als die gemeldeten Entlassungen mit Entlassungsart 'S' im Berichtsjahr aufgrund der MBDS-Daten ist"},
{k03_ambpatungleich, "Fehler, wenn die Anzahl ambulanter Patienten ungleich der Anzahl ambulanter Patienten aus allen K09-S\xc3\xa4""tzen ist"},
{kaskore_tatsbetten_k08, "Fehler, wenn die gemeldete Anzahl tats. Betten nicht mit der Summe tats. Betten aller K08-S\xc3\xa4""tze \xc3\xbc""bereinstimmt"},
{k03_check_sklbettensys, "Fehler, wenn der Wert f\xc3\xbc""r systemisierte Betten Sonderklasse ein Viertel der syst. Betten insgesamt \xc3\xbc""bersteigt"},
{k03_check_tats_verbleib, "Fehler, wenn die Anzahl vom Vorjahr verbleibender Sonderklasse gr\xc3\xb6""\xc3\x9f""er der Anzahl syst. Betten Sonderklasse ist"},
{k03_check_sklbettentats, "Fehler, wenn der Wert f\xc3\xbc""r tats. Betten Sonderklasse ein Viertel der tats. Betten insgesamt \xc3\xbc""bersteigt"},
{k03_check_begleitbelagstage, "Fehler, wenn die Aufnahmen von Begleitpersonen gr\xc3\xb6""\xc3\x9f""er der Belagstage der Begleitpersonen ist"},
{k04_perskalkanggross, "Fehler, wenn f\xc3\xbc""r kalk. Personal (1. Stelle Personalgruppenindex = 'Z') die Vollzeit\xc3\xa4""quivalente gr\xc3\xb6""\xc3\x9f""er sind als die Summe der Vollzeit\xc3\xa4""quivalente aller K04-Records mit Nicht-Kalkulatorischem Personal und gleicher 3. Stelle bei Personalgruppenindex"},
{k04_perskeinekosten, "Nur f\xc3\xbc""r Personalgruppenindex 111 bis 139: Fehler, wenn es zum Satz keinen K12-Satz mit entsprechender Mlv-Nummer und mit gemeldeten Kosten gibt "},
{k07_check_auslpers, "Fehler, wenn die Anzahl Ausl\xc3\xa4""nder (EU+Nicht-EU) gr\xc3\xb6""\xc3\x9f""er als die Gesamtzahl (m\xc3\xa4""nnlich + weiblich) ist"},
{check_abtfc_hk2005, "Fehler, wenn der Funktionscode keine bettenf\xc3\xbc""hrende Hauptkostenstelle (erste Stelle = 1, zweite Stelle in '123459', 3./4. Stelle ungleich 78,81,82,83) ist"},
{check_k08_mehrfach, "Fehler, wenn es f\xc3\xbc""r einen Funktionscode mehr als einen K08-Satz gibt"},
{check_k09_mehrfach, "Fehler, wenn es f\xc3\xbc""r einen Funktionscode mehr als einen K09-Satz gibt"},
{check_k10_mehrfach, "Fehler, wenn es f\xc3\xbc""r einen Funktionscode mehr als einen K10-Satz gibt"},
{k08_endkosten_bettHK, "Fehler, wenn kleiner 0"},
{k09_endkosten_nbetthk, "Fehler, wenn kleiner -50"},
{k08_personal_ohne_kosten, "Fehler, wenn KOAGR01 0 ist und die Summe der neun MLV-Werte > 0.1; wenn KOAGR01 > 1000 und die Summe MLV 0 ist, wird Fehler EK3B (Personalkosten aber kein Personal) geliefert"},
{k08_endkosten_falsch_berechnet, "Fehler, wenn Endkosten ungleich KOAGR01-KOAGR14 und Unter-\xc3\x9c""berdeckung MINUS Kostenminderungen und abgeg. Betr. Leistungen"},
{k08_abweichung_unterueber, "Fehler, wenn Unter-\xc3\x9c""berdeckung (Absolutbetrag) gr\xc3\xb6""\xc3\x9f""er 10 % der abgeg. Innerbetr. Leistungen ist"},
{check_kostenstelle_ohne_kosten, "Fehler, wenn alle Kostenfelder (KOAGR01-KOAGR14, Kostenmind, abgeb. Lst., \xc3\x9c""ber-Unterdeckung) 0 sind; bei K08 nur, wenn tats. Betten gemeldet wurden"},
{check_abtfc_nbetthk, "Fehler, wenn der Funktionscode keine nicht-bettenf\xc3\xbc""hrende Hauptkostenstelle (erste Stelle = 1, zweite Stelle in '678') ist"},
{k09_check_ambpat_freq, "Fehler, wenn die Anzahl ambulanter Patienten gr\xc3\xb6""\xc3\x9f""er den Frequenzen ambulanter Patienten ist"},
{k09_check_ambpat_endkost, "Fehler, wenn ambulante Patienten gemeldet wurden, aber Endkosten 0 sind (ab Modell 2006: -50<Endkosten<50)"},
{k09_check_ambpat_umlage, "Fehler, wenn Frequenzen stat. Patienten (inkl. anderer KHs) gr\xc3\xb6""\xc3\x9f""er 0 ist, aber die Summe abgeg. innerbetrieblicher Leistungen 0 ist (ab Modell 2006: -50<Wert<50)"},
{check_abtfc_hilfskost, "Fehler, wenn keine Neben- ('2xxxxxxx') oder Hilfskostenstelle ('3xxxxxxx')"},
{k10_check_hilfskost, "Fehler, wenn f\xc3\xbc""r eine Hilfskostenstelle ('3xxxxxxx') und Endkosten < -1000 oder > 1000"},
{k08_check_nurTBettOhneSBett, "Fehler, wenn tats\xc3\xa4""chlich aufgestellte, aber keine systemisierten Betten gemeldet wurden"},
{k08_check_nurSBett, "Fehler, wenn nur systemisierte Betten und keine weiteren Felder gemeldet wurden - in diesem Fall werden alle weiteren Checks f\xc3\xbc""r den K08-Satz deaktiviert"},
{k08_check_int_ohne_arzt, "Wenn Intensiv-Abteilung (2. Stelle des FC = 2), dann m\xc3\xbc""ssen die MLV1-1-Vollzeit\xc3\xa4""quivalente gr\xc3\xb6""\xc3\x9f""er 0 sein, sonst Fehler"},
{k09_check_op_ohne_arzt, "Wenn 5./6. Stelle des FC=95, m\xc3\xbc""ssen MLV1-Vollzeit\xc3\xa4""quivalente ungleich 0 sein, sonst Fehler"},
{k09_check_labor_ohne_arzt, "Wenn 3./4. Stelle des FC=82 oder 83, oder die 5./6. Stelle = 79, m\xc3\xbc""ssen MLV5-Vollzeit\xc3\xa4""quivalente ungleich 0 sein, sonst Fehler"},
{k10_check_nebenkost_endk_neg, "Fehler, wenn Nebenkostenstelle ('2xxxxxxx') und Kosten kleiner 0"},
{k08_check_kostenstellevollst, "Fehler, wenn entweder Patientendaten (tats. Betten, Nettogrundri\xc3\x9f"", Vollzeit\xc3\xa4""quivalente) aber keine Kosten (KOAGR01 - KOAGR14, Kostenmind., Abgrenzungen, Unter-\xc3\x9c""berdeckung); oder umgekehrt gemeldet wurden"},
{k09_check_kostenstellevollst, "Fehler, wenn entweder Patientendaten (amb. Pat, Frequenzen, stat. Pat oder Nettogrundri\xc3\x9f"", Vollzeit\xc3\xa4""quivalente) aber keine Kosten (KOAGR01 - KOAGR14, Kostenmind., Abgrenzungen, Unter-\xc3\x9c""berdeckung); oder umgekehrt gemeldet wurden"},
{k11_check_sum_koagr01, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der Kosten aller K12-S\xc3\xa4""tze mit Blattnummer beginnend mit '01' ist (Fehler bei abs. Differenz > 500)"},
{k11_check_sum_koagr02, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der Kosten aller K12-S\xc3\xa4""tze mit Blattnummer beginnend mit '02' ist (Fehler bei abs. Differenz > 500)"},
{k11_check_sum_koagr03, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der Kosten aller K12-S\xc3\xa4""tze mit Blattnummer beginnend mit '03' ist (Fehler bei abs. Differenz > 500)"},
{k11_check_sum_koagr04, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der Kosten aller K12-S\xc3\xa4""tze mit Blattnummer beginnend mit '04' ist (Fehler bei abs. Differenz > 500)"},
{k11_check_sum_koagr05, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der Kosten aller K12-S\xc3\xa4""tze mit Blattnummer beginnend mit '05' ist (Fehler bei abs. Differenz > 500)"},
{k11_check_sum_koagr06, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der Kosten aller K12-S\xc3\xa4""tze mit Blattnummer beginnend mit '06' ist (Fehler bei abs. Differenz > 500)"},
{k11_check_sum_koagr07, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der Kosten aller K12-S\xc3\xa4""tze mit Blattnummer beginnend mit '07' ist (Fehler bei abs. Differenz > 500)"},
{k11_check_sum_koagr08, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der Kosten aller K12-S\xc3\xa4""tze mit Blattnummer beginnend mit '08' ist (Fehler bei abs. Differenz > 500)"},
{k11_check_sum_primkost, "\xc3\x9c""berpr\xc3\xbc""fung, ob die Prim\xc3\xa4""rkosten mit der Summe der Kosten aller K12-S\xc3\xa4""tze mit Blattnummern 01 - 08 \xc3\xbc""bereinstimmen (Fehler bei abs. Differenz > 100)"},
{k11_check_sum_kostmind, "\xc3\x9c""berpr\xc3\xbc""fung, ob die Kostenminderungen mit der Summe der Kostenminderungen aller K13-S\xc3\xa4""tze \xc3\xbc""bereinstimmen (Fehler bei abs. Differenz > 100)"},
{k11_check_koagr01, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der KOAGR01-Felder aus allen K08-, K09- und K10-S\xc3\xa4""tzen ist (Fehler bei abs. Differenz > 500)"},
{k11_check_koagr02, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der KOAGR02-Felder aus allen K08-, K09- und K10-S\xc3\xa4""tzen ist (Fehler bei abs. Differenz > 500)"},
{k11_check_koagr03, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der KOAGR03-Felder aus allen K08-, K09- und K10-S\xc3\xa4""tzen ist (Fehler bei abs. Differenz > 500)"},
{k11_check_koagr04, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der KOAGR04-Felder aus allen K08-, K09- und K10-S\xc3\xa4""tzen ist (Fehler bei abs. Differenz > 500)"},
{k11_check_koagr05, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der KOAGR05-Felder aus allen K08-, K09- und K10-S\xc3\xa4""tzen ist (Fehler bei abs. Differenz > 500)"},
{k11_check_koagr06, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der KOAGR06-Felder aus allen K08-, K09- und K10-S\xc3\xa4""tzen ist (Fehler bei abs. Differenz > 500)"},
{k11_check_koagr07, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der KOAGR07-Felder aus allen K08-, K09- und K10-S\xc3\xa4""tzen ist (Fehler bei abs. Differenz > 500)"},
{k11_check_koagr08, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der KOAGR08-Felder aus allen K08-, K09- und K10-S\xc3\xa4""tzen ist (Fehler bei abs. Differenz > 500)"},
{k11_check_kostminddiff, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der Kostenminderung-Felder aus allen K08-, K09- und K10-S\xc3\xa4""tzen ist (Fehler bei abs. Differenz > 500)"},
{k11_check_endkost_diff, "\xc3\x9c""berpr\xc3\xbc""fung, ob der Feldwert gleich der Summe der Endkosten-Felder aus allen K08-, K09- und K10-S\xc3\xa4""tzen ist (Fehler bei abs. Differenz > 500)"},
{k11_check_primkost_double, "Fehler, wenn die Prim\xc3\xa4""rkosten um mehr als 500 von der Summe KOAGR01-KOAGR08 aus allen K08-, K09- und K10-S\xc3\xa4""tzen abweichen"},
{k11_check_kalkabschr, "Fehler, wenn die kalk. Abschr. Restwert 0 + kalk. Abschr. Ausgesch. Anlagen gr\xc3\xb6""\xc3\x9f""er der Summe der kalk. Abschreibungen ist"},
{check_blattmlvkomb, "\xc3\x9c""berpr\xc3\xbc""fung, ob die Kombination zwischen Blattnummer und MLV-Nummer entsprechend Anhang H g\xc3\xbc""ltig ist"},
{check_mlvnummer, "\xc3\x9c""berpr\xc3\xbc""fung, ob die MLV-Nummer g\xc3\xbc""ltig ist (entsprechend Anhang H)"},
{k12_check_kostenohnepers, "Wenn MLV 111 bis 139 und Kosten gr\xc3\xb6""\xc3\x9f""er 1000: Wenn es keinen K04-Satz mit entsprechendem Personalgruppenindex und gemeldeten Vollzeit\xc3\xa4""quivalenten gibt, wird der Fehler geliefert"},
{k13_klinischermehraufwand, "Fehler, wenn K13 mit Minimierungsart = 'B' (und Wert ungleich 0) f\xc3\xbc""r andere KA als K612, K701 und K901 gemeldet wurde"},
{k05_check_fachhaupt_k05, "Fehler, wenn die Kopfzahl \xc3\xbc""ber alle Fachhauptbereiche 0 ist; wenn die Summe der Kopfzahlen kleiner als die 75 % der VZEQ aller MLV-1-K04-S\xc3\xa4""tze ist, wird Warning WK1Z geliefert. Ab 2008 werden die VZEQ dieser K04-S\xc3\xa4""tze mit den VZEQ der K05-S\xc3\xa4""tze verglichen, wenn K05 unter 75% der K04, wird EK7H, wenn diese \xc3\xbc""ber 100% liegen, EK7K geliefert"},
{k04_persvollzeit_gesamt, "Es werden die Vollzeit\xc3\xa4""quivalente der K04-S\xc3\xa4""tze entsprechend des Personalgruppenindizes (1x1-1x9) aufsummiert und mit den Vollzeit\xc3\xa4""quivalenten aus den K08-, K09 und K10-S\xc3\xa4""tzen verglichen. Ein Fehler wird geliefert, wenn die Gesamtsummen nicht \xc3\xbc""bereinstimmen. Au\xc3\x9f""erdem werden die Summen aus K08 und K09 pro Gruppe (1-9) mit den K04-Daten verglichen, und wenn die K04-Summe kleiner ist, wird Fehler EK1N geliefert "},
{check_kombabtfc_satzart, "nicht aktiv - es wird kein Fehler geliefert"},
{check_penskost_unvollst, "EK67 (Pensionskosten unvollst\xc3\xa4""ndig), wenn Pensionskosten in K10 (AbtFC=202111), aber nicht in K12 (MLV=86) - oder umgekehrt - geliefert werden, \nEK68 (Kost.Pens. nicht ordnungsgem\xc3\xa4""\xc3\x9f""), wenn in K10 mit AbtFC=202111 andere Kosten als KOAGR07 und Endkosten ungleich 0 sind,\nEK69 (Vorsteuer unvollst.) , wenn Vorsteuer in K10 (AbtFC=202211), aber nicht in K12 (MLV=87) - oder umgekehrt - geliefert werden, \nEK6A (Kost.Vorst. nicht ordnungsgem\xc3\xa4""\xc3\x9f""), wenn in K10 mit AbtFC=202211 andere Kosten als KOAGR07, Kostenminderungen und Endkosten ungleich 0 sind, \nEK6B (Kostmind.Vorst.fehlerhaft), wenn Vorsteuer-Minderungen aus K10 (Kostenminderungen aus AbtFC=202211) ungleich der Vorsteuer-Minderung aus K13 (Summe der Kostenminderungen der S\xc3\xa4""tze mit Index 'A') ist,\nEK6C (Kost. med.leist Dritte nicht ok) wenn in K10 kein Satz mit AbtFC=2018* existiert mit einem Feld aus KOAGR1-KOAGR8, KOAGR11-KOAGR13 ungleich 0,\nEK6D (Kost n.med. Leistungen Dritte nicht ok) wenn in K10 kein Satz mit AbtFC=2019* existiert mit einem Feld aus KOAGR1-KOAGR8 und KOAGR14 ungleich 0,\nEK7W (Kostmind. FLAF fehlerhaft), wenn FLAF-Minderungen aus K10 (Kostenminderungen aus AbtFC=202511) ungleich der Vorsteuer-Minderung aus K13 (Summe der Kostenminderungen der S\xc3\xa4""tze mit Index 'H') ist (ab Modell 2008)"},
{check_mlv, "Es werden die die MLV-Werte (1-9) aller K08- und K09-S\xc3\xa4""tze aufsummiert, und es werden die Vollzeit\xc3\xa4""quivalente aller K04-S\xc3\xa4""tze pro Mlv-Gruppe (letzte Stelle des Personalgruppenindex) aufsummiert. Pro MLV-Wert wird der entsprechende Fehler (EK6E-EK6P) geliefert, wenn die Mlv-Werte der K08- und K09-S\xc3\xa4""tze gr\xc3\xb6""\xc3\x9f""er sind. "},
{check_abtfcdlb_ohne_stat, "wenn ein K02 gemeldet: pro Abteilung wird Fehler EK6T oder EK75 (ab 2007, wenn EK6T wegen Toleranz nicht geliefert wird) geliefert, wenn M02-Daten, aber keine K08-Daten gemeldet wurden; und umgekehrt Fehler EK6U, wenn zu einer in K08 gemeldeten Abteilung kein einziger M02-Satz existiert "},
{check_abtfcstat_ohne_dlb, "nicht aktiv - es wird kein Fehler geliefert"},
{check_kostenstelle_ohne_daten, "Fehler, wenn zu einem Funktionscode ein K01-Satz gemeldet wurde, aber weder K08/K09/K10 noch zumindest ein G01-Satz und der Funktionscode auch in den MBDS-Daten nicht vorkommt"},
{k07_check_summe, "Fehler, wenn in keinem K07-Satz Personal m\xc3\xa4""nnlich oder Personal weiblich gemeldet wurde"},
{k07_check_gesberufe, "Es werden die Vollzeit\xc3\xa4""quivalente der K04-S\xc3\xa4""tze nach Personalgruppenindex (1x3, 1x4, 1x5 und 1x6) mit den Kopfzahlen (m\xc3\xa4""nnlich plus weiblich) aus K07 entsprechend Index (30 f\xc3\xbc""r 1x3, 41-44 f\xc3\xbc""r 1x4, 5* f\xc3\xbc""r 1x5, 6* f\xc3\xbc""r 1x6) verglichen. Pro Personalgruppenindex (3-6) wird ein Fehler geliefert, wenn die Kopfzahlen aus K07 kleiner 75% der Vollzeit\xc3\xa4""auivalenten der K04-S\xc3\xa4""tze sind"},
{k05_check_keinFacharzt, "Wenn ein K02 gemeldet: pro Hauptkostenstelle (FC=1xxxxxxx) wird \xc3\xbc""berpr\xc3\xbc""ft, ob es zumindest einen zugeh\xc3\xb6""rigen K05-Satz (Fachhauptbereichsindex =3./4.Stelle des FC) und zumindest einem Facharzt gibt, sonst Fehler (nicht f\xc3\xbc""r AbtFC=xx91xx oder xx99xx)"},
{general_checks, "Fehler FAT7, wenn kein M01-Satz (nur Jahresmeldung), kein S01-Satzgeliefert wurde, und Error FATK (G01 fehlt), wenn zu einem G02-Satz der zugeh\xc3\xb6""rige G01-Satz fehlt"},
{gg_checkart, "Fehler, wenn die Art nicht in der Stammdaten-Datei GGART.txt eingetragen ist"},
{gg_checkleistungsindex, "Fehler, wenn der Leistungsindex nicht in der Stammdaten-Datei GGLEIST.txt eingetragen ist"},
{gg_checkNichtBettHK, "Fehler, wenn die Abteilung keine nicht-bettenf\xc3\xbc""hrende Hauptkostenstelle ist (ABTFC=16*, 17* oder 18*)"},
{k11_check_exists_unterueber, "Fehler, zumindest bei einer Kostenstelle Unter- oder \xc3\x9c""berdeckung ungleich 0 angegeben ist, aber dieses Feld nicht bef\xc3\xbc""llt ist"},
{check_angaben_sonderklasse, "Fehler, wenn kein Wert oder 0, aber eine der Sonderklasse-Daten Belag, Aufnahmen oder tats\xc3\xa4""chliche Betten ungleich 0 ist"},
{gg_check_dauer, "Fehler, wenn keine Dauer angegeben ist, aber amb. oder stat. Frequenzen"},
{k11_check_patkost_endkost, "Fehler, wenn die Summe aus Endkosten der Nebenkostenstellen und der station\xc3\xa4""ren und ambulanten Patientenversorgung von den Endkosten der Krankenanstalt um mehr als 500 Euro abweicht. Die \xc3\x9c""berpr\xc3\xbc""fung findet nur statt, wenn die vier Felder ausgef\xc3\xbc""llt sind"},
{check_tbett_err, "Fehler, wenn die durchschnittliche t\xc3\xa4""gl. Belagsdauer um mehr als 30% \xc3\xbc""ber der Anzahl tats\xc3\xa4""chlicher Betten liegt"},
{check_tbett_warn, "Fehler, wenn die durchschnittliche t\xc3\xa4""gl. Belagsdauer um mehr als 15% \xc3\xbc""ber der Anzahl tats\xc3\xa4""chlicher Betten liegt"},
{check_verbleib_unplaus, "Fehler, wenn die Anzahl am Jahresende Verbleibender die Anzahl tats. Betten um mehr als 15% \xc3\xbc""bersteigt"},
{check_k09_endk_ambpat, "Fehler, wenn Endkosten gemeldet wurden, aber keine ambulanten Patienten"},
{check_k09_umlage_ohnestatfreq, "Fehler, wenn Summe abg. innerbetr. Leistungen gemeldet wurde, aber keine Frequenzen an stat. Patienten (inkl. anderer KHs)"},
{check_medtechnfehlt, "Fehler, wenn der Wert leer oder 0 ist, aber nur bei 3./4. Stelle AbtFC = 72,75,78,82"},
{k09_check_freqnopat, "Fehler, wenn Frequenzen ambulanter Patienten, aber keine Anzahl Patienten gemeldet wurde"},
{k07_check_hebamme, "Fehler, wenn Wert ungleich 0 und Index = 30 (Hebamme)"}, /* V11.0 */
{k07_check_hebamme_vz, "Fehler, wenn Wert ungleich 0 und Index = 30 (Hebamme)"}, /* V12.0 */
{checkfunc_buchwert_zeile, "Fehler, wenn Anschaffungskosten + Zug\xc3\xa4""nge - Abg\xc3\xa4""nge + Umbuchungen - kumulierte Abschreibungen ungleich Buchwert am Ende des Berichtsjahres, Toleranz +/-100"}, /* V12.0 */
{k12_check_kostenzeile, "Fehler, wenn Aufwand gem\xc3\xa4""\xc3\x9f"" Finanzbuchf\xc3\xbc""hrung - neutraler Aufwand + Kalkulatorische Kosten ungleich Kosten, Toleranz +/-100"}, /* V12.0 */
{check_aerztliches_personal, "Fehler, wenn kein \xc3\xa4""rztliches Personal in K04 (111,121,131,Z01), K05 (Kopfzahl exkl. Ausbildung) und K06 gemeldet wurde"}, /* V12.1 */
{k01_check_standort_falsch, "Fehler, wenn ein ung\xc3\xbc""ltiger Standort angegeben ist"}, /* V13.0 */
{k01_check_standort_fehlt, "Fehler, wenn die KA Standorte hat und in K01 kein Standort angegeben ist"},/* V13.0 */
{check_k04k07_hebamme, "Fehler, wenn die Hebammen-Vollzeit\xc3\xa4""quivalente in K04 nicht mit K07 \xc3\xbc""bereinstimmen"}, /* V13.1 */
{check_k04k07_gehdienst, "Fehler, wenn die Geh. Ges-/Krankenpfl.-Vollzeit\xc3\xa4""quivalente in K04 nicht mit K07 \xc3\xbc""bereinstimmen"}, /* V13.1 */
{check_k04k07_gehmedtechn, "Fehler, wenn die Med.-Techn.-Vollzeit\xc3\xa4""quivalente in K04 nicht mit K07 \xc3\xbc""bereinstimmen"}, /* V13.1 */
{check_k04k07_pflege, "Fehler, wenn die Pflege-Vollzeitquivalente in K04 nicht mit K07 \xc3\xbc""bereinstimmen"},
{k07_check_kopfvzeq, "Fehler, wenn die Kopfzahlen mit den Vollzeit\xc3\xa4""quivalenten exakt \xc3\xbc""bereinstimmen"}, /* V13.1 */
{k10_check202511, "Fehler, wenn bei AbtFC=202511xx ein anderes Kostenfeld ausser Kostenminderungen und Endkosten ungleich 0 ist"},
{intcheck_01, "Fehler, wenn nicht alle Stellen entweder 0 oder 1 sind"}, /* V15.1 */
{intcheck_leuko, "Fehler, wenn nicht nicht im Bereich 0,0 - 999,0"}, /* V15.1 */
{intcheck_gesamtbilirubin_2011, "Fehler, wenn nicht im Bereich 0,0 - 200,0"}, /* V15.1 */
{intcheck_blutbild_ph, "Fehler, wenn nicht nicht im Bereich 6,00 - 8,00"}, /* V15.1 */
{intcheck_kreatinin, "Fehler, wenn nicht nicht im Bereich 0,0 - 50,0"}, /* V15.1 */
{intcheck_pao2_2011, "Fehler, wenn nicht im Bereich 0,0 - 900,0"}, /* V15.1 */
{intcheck_koerpertemp, "Fehler, wenn nicht nicht im Bereich 0,0 - 45,0"}, /* V15.1 */
{intcheck_kombination_atmungsmodus, "Fehler, wenn ung\xc3\xbc""ltige Kombination Atmungsmodus und Atemwegszugang"}, /* V15.2 */
{k01_check_spezorg_fehlt, "Fehler, wenn leer bei Hauptkostenstelle (2012 nur bei Jahresmeldung)"},
{k01_spezorgfunkhk, "Fehler, wenn AbtFC nicht zur Spez/Org pa\xc3\x9f""t"},
{k01_check19, "Fehler, wenn AbtFC mit 19 beginnt"},
{check_k15unvollst, "Fehler, wenn entweder Kosten oder Bezugsgr\xc3\xb6""\xc3\x9f""e 0 ist"}, /* V17.0 */
{k01_virtKSTCheck, "Fehler, wenn virt. Kostenstelle von keiner Kostenstelle referenziert wird"},
{intcheck_aufgrund, "Warnung, wenn kein Aufnahmegrund ungleich Blank/0 ist"}, /* V18.1 */
{k05_fachhaupt_kopfzahl, "Fehler, wenn Fachhauptbereichsindex=00 und andere Kopfzahl als Allgemeinmed. in Ausbildung gesetzt"}, /* V20.0 */
{k05_fachhaupt_vollzeit, "Fehler, wenn Fachhauptbereichsindex=00 und andere Vollzeit\xc3\xa4""quivalente als Allgemeinmed. in Ausbildung gesetzt"},
{k03_check_auslastung, "Fehler, wenn Belagstage > tats.Betten * Anzahl Tage"}, /* V2026.0 */
{k08_check_auslastung, "Nur K08: Fehler, wenn Belagstage > tats.Betten * Anzahl Tage auf der Abteilung"},  /* V2026.0 */
{check_a01staat, "Fehler, wenn der eingetrage Staat nicht in den Stammdaten verf\xc3\xbc""gbar ist"},
{check_a01_atc, "Fehler, wenn der eingetrage ATC-Code nicht in den Stammdaten verf\xc3\xbc""gbar ist"},
{check_a01_abtfc, "Fehler, wenn es zum eingetragenen AbtFC keinen K01-Satz gibt"}
}; /* V20.0 */

const char *lkf_getErrorFunctionComment (const LKF_CONTEXT *pContext, const void *pPtr)
{ /* V9.0a */
	unsigned int i, count;
	count = sizeof (Comments) / sizeof (const LKF_SATZART_ERRORCHECK_COMMENT);
	for (i = 0; i < count; i++)
	{
		if (Comments[i].pTarget == pPtr) return Comments[i].sComment;
	}
	return lkf_getErrorBerichtFunctionComment (pContext, pPtr); /* V14.2 */
}

_SCORING_EXPORT unsigned int lkf_Satzart_getCheckDetails (const LKF_CONTEXT *pContext, const void *pErrorCheck, char *buf, unsigned int buflen)
{ /* V9.0a */
	char sBuf[2048];
	const LKF_SATZART_ERRORCHECK *pCheck;
    char utf8buf[2048];
	const char *pDetails = 0;
	if (pErrorCheck)
	{
		/* V10.1 */
		pCheck = lkf_getModelDependentCheck ((const LKF_SATZART_ERRORCHECK *) pErrorCheck, pContext);
		if (!pCheck)
		{
			if (buflen) buf[0] = 0;
			return 0;
		}

		if ((pCheck->nFunction&255) == LKF_CHECKFUNC_FUNCTION)
		{
			pDetails = lkf_getErrorFunctionComment (pContext, pCheck->pCheckInfo);
            if (pDetails) {
                pDetails = lkf_context_formatted_text(pContext, pDetails, utf8buf);
            }
		}
		else if ((pCheck->nFunction&255) == LKF_CHECKFUNC_STRINGLIST)
		{
            unsigned int i;
            int nPos = 0;
			const LKF_SATZART_ERRORCHECK_STRINGLIST *pStringList;
			pStringList = (const LKF_SATZART_ERRORCHECK_STRINGLIST *) pCheck->pCheckInfo;
			for (i = 0; i < pStringList->nStringCount; i++)
			{
				if (!i) nPos = sprintf (sBuf, "Strings: '%s'", pStringList->psValues[0]);
				else nPos += sprintf (sBuf + nPos, ", '%s'", pStringList->psValues[i]);
			}
			pDetails = sBuf;
		}
	}
	
	if (pDetails)
	{
		unsigned int nLen;
		strncpy (buf, pDetails, buflen);
		nLen = (unsigned int) strlen (pDetails);
		if (buflen <= nLen) buf[buflen-1] = 0;
		return nLen;
	}
	else if (buflen) buf[0] = 0;
	return 0;

}

const LKF_SATZART_ERROR_PROPERTIES *lkf_getErrorProperties (const LKF_SATZART_ERRORDEF *pErrorDef, const LKF_CONTEXT *pContext)
{ /* V10.1 */
	static const LKF_SATZART_ERROR_PROPERTIES DefaultProperties = {1,1,0,0};
	const LKF_SATZART_ERROR_PROPERTIES *pProperties = pErrorDef ? pErrorDef->pProperties : 0;

	if (!pProperties)
		return &DefaultProperties;

	while (pProperties && pContext && (pProperties->nAlternateModelljahr && pProperties->nAlternateModelljahr >= (unsigned int) pContext->modelljahr)) 
		pProperties = pProperties->pAlternateProperties;
	return pProperties ? pProperties : &DefaultProperties;
}

int lkf_getErrorRelevance (const LKF_SATZART_ERRORDEF *pErrorDef, const LKF_CONTEXT *pContext)
{ /* V10.1 */
	const LKF_SATZART_ERROR_PROPERTIES *pProperties;

	if (pContext->flags & LKFCONTEXT_DISABLE_SOME_CHECKS)
	{
		if (pErrorDef == &LKFErrorKeineVPatienten || pErrorDef == &LKFKKErrorKeinAerztlichesPersonal /* V12.1 */)
			return 0;
	}

	pProperties = lkf_getErrorProperties (pErrorDef, pContext);
	if (pContext->flags & LKFCONTEXT_NICHTFONDSKA)
	{
		return pProperties->nNichtFonds;
	}
	else
	{
		return pProperties->nFonds;
	}
}




/* 

static const LKF_SATZART_ERRORDEF *ppIgnoreKKErrors[] = {&LKFKKErrorSystBettenInsgSonderkl, &LKFKKErrorTatsBettenInsgSonderkl, &LKFKKErrorArztFachK04DienstKopf, &LKFKKErrorPersVollzeit2, &LKFKKErrorPersonalKostenOhnePers, 0};
static const LKF_SATZART_ERRORDEF *ppIgnoreKKErrors2005[] = {&LKFKKErrorGesamtumlageKOAGR11unplaus, &LKFKKErrorGesamtumlageKOAGR12unplaus, &LKFKKErrorGesamtumlageKOAGR13unplaus, &LKFKKErrorGesamtumlageKOAGR14unplaus, 
															 &LKFKKErrorGesamtumlageFehlerhaft, 0};

static unsigned int GetErrorCount (const LKF_SATZART_ERRORDEF **ppErrors)
{
	unsigned int i = 0;
	while (ppErrors[i]) i++;
	return i;
}

static void CopyErrors (const LKF_SATZART_ERRORDEF **ppDestination, const LKF_SATZART_ERRORDEF **ppSource, unsigned int nCount)
{
	unsigned int i;
	for (i = 0; i < nCount; i++)
	{
		ppDestination[i] = ppSource[i];
	}
}

const LKF_SATZART_ERRORDEF **lkf_getIgnoreNFondsErrors (const LKF_CONTEXT *pContext)
{
	const LKF_SATZART_ERRORDEF **ppErrors;
	const LKF_SATZART_ERRORDEF ***pppIgnoreErrors;
	int *pIgnoreErrorCount;
	int i, nCount, nSum;

	if (pContext->modelljahr < 2005)
	{
		nCount = 2;
		pppIgnoreErrors = (LKF_SATZART_ERRORDEF ***) LKF_CALLOC (sizeof (const LKF_SATZART_ERRORDEF **), nCount);
		pppIgnoreErrors[0] = lkf_getIgnorePlausNFondsErrors (pContext);
		pppIgnoreErrors[1] = ppIgnoreKKErrors;
	}
	else
	{
		nCount = 3;
		pppIgnoreErrors = (LKF_SATZART_ERRORDEF ***) LKF_CALLOC (sizeof (const LKF_SATZART_ERRORDEF **), nCount);
		pppIgnoreErrors[0] = lkf_getIgnorePlausNFondsErrors (pContext);
		pppIgnoreErrors[1] = ppIgnoreKKErrors;
		pppIgnoreErrors[2] = ppIgnoreKKErrors2005;
	}
	
	pIgnoreErrorCount = (unsigned int *) LKF_CALLOC (sizeof (unsigned int), nCount);

	nSum = 0;
	for (i = 0; i < nCount; i++)
	{
		pIgnoreErrorCount[i] = GetErrorCount (pppIgnoreErrors[i]);
		nSum += pIgnoreErrorCount[i];
	}

	ppErrors =(const LKF_SATZART_ERRORDEF **) LKF_CALLOC (sizeof(LKF_SATZART_ERRORDEF *), nSum + 1);
	ppErrors[nSum] = 0;
	nSum = 0;
	for (i = 0; i < nCount; i++)
	{
		CopyErrors (ppErrors + nSum, pppIgnoreErrors[i], pIgnoreErrorCount[i]);
		nSum += pIgnoreErrorCount[i];
	}
	LKF_FREE ((void *) pppIgnoreErrors);
	LKF_FREE ((void *) pIgnoreErrorCount);
	return ppErrors;
}
*/
