/****************************************************************************
** Leistungsorientierte Krankenanstaltenfinanzierung (LKF)                 **
** Scoring-C-Sourcen V2026.1                                               **
** (C) 2026 BMASGPK                                                        **
*****************************************************************************
** bericht5.c - Routinen zur Verwendung des Scoring-Contexts               **
**                                                                         **
**	    Alex.Holzer@chello.at                                             **
**       Bernhard.Pesec@dothealth.at                                       **
***************************************************************************/

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

#define DOUBLE_0_VALUE 0.000001 /* V12.0 */

const LKF_SATZART_ERRORDEF
	LKFBErrorBerichtsjahrfehlt =		{  1, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Berichtsjahr fehlt"},
	LKFBErrorBerichtsjahrfalsch  =		{  2, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Berichtsjahr - ung\xc3\xbc""ltige Jahresangabe"},
	LKFBErrorBerichtstypFalsch =		{  3, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Berichtstyp falsch"},
	LKFBErrorBerechTypFalsch =			{  4, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Berechnungstyp falsch"},
	LKFBErrorZuordArtFalsch =			{  5, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Zuordnungsart falsch"},
	LKFBErrorVKSIndexFalsch =			{  6, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "VKS-Index falsch"},
	LKFBErrorWertFehlt =				{  7, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Wert Berichtsjahr fehlt"},
	LKFBErrorWertFalsch =				{  8, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Wert Berichtsjahr falsch"},
	LKFBErrorVorjahrWertFehlt =			{  9, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Wert Vorjahr fehlt"},
	LKFBErrorVorjahrWertFalsch =		{ 10, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Wert Vorjahr falsch"},
	LKFBErrorEVRIndexFalsch =			{ 11, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "EVR-Index falsch"},
	LKFBErrorQVAIndexFalsch =			{ 12, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "QVA-Index falsch"},
	LKFBErrorErloesIndexFalsch =		{ 13, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Erl\xc3\xb6""s-Index falsch"},
	LKFBErrorFTIndexFalsch =			{ 14, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0,	"Finanztr\xc3\xa4""ger-Index falsch"},
	LKFBErrorZuschussArtFalsch =		{ 15, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0,	"Zuschuss-Art falsch"},
	LKFBErrorLGFWertFehlt =			    { 16, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0,	"Wert LGF fehlt"}, 
	LKFBErrorLGFWertFalsch =			{ 17, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0,	"Wert LGF falsch"},
	LKFBErrorZuschussFehlt =			{ 18, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0,	"Zuschuss fehlt"}, 
	LKFBErrorZuschussFalsch =			{ 19, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0,	"Zuschuss falsch"},
	LKFBErrorNegWertVKSIndex =			{ 20, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Negativer Wert f\xc3\xbc""r diesen VKS-Index ung\xc3\xbc""ltig"},
	LKFBErrorNegWertEVRIndex =			{ 21, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Negativer Wert f\xc3\xbc""r diesen EVR-Index ung\xc3\xbc""ltig"},
	LKFBErrorNegWertQVAIndex =			{ 22, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Negativer Wert f\xc3\xbc""r diesen QVA-Index ung\xc3\xbc""ltig"},
	LKFBErrorE01U17 =					{ 23, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Umsatzerl\xc3\xb6""se QVA (E01) ungleich Umsatzerl\xc3\xb6""se ES (U17)"},
	LKFBErrorE02U08 =					{ 24, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Station\xc3\xa4""re Erl\xc3\xb6""se QVA (E02) ungleich Station\xc3\xa4""re Erl\xc3\xb6""se ES (U08)"},
	LKFBErrorE03U12 =					{ 25, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Ambulante Erl\xc3\xb6""se QVA (E03) ungleich Ambulante Erl\xc3\xb6""se ES (U12)"},
	LKFBErrorE04U16 =					{ 26, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Sonstige Umsatzerl\xc3\xb6""se QVA (E04) ungleich Sonstige Umsatzerl\xc3\xb6""se ES (U16)"},
	LKFBErrorE05U18 =					{ 27, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Ersatz f\xc3\xbc""r klinischen Mehraufwand QVA (E05) ungleich Ersatz f\xc3\xbc""r klinischen Mehraufwand ES (U18)"},
	LKFBErrorE11Z01 =					{ 28, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Zusch\xc3\xbc""sse zum Betriebsabgang QVA (E11) ungleich Zusch\xc3\xbc""sse zum Betriebsabgang ZS (Z01)"},
	LKFBErrorE12Z02 =					{ 29, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Sonstige Betriebszusch\xc3\xbc""sse QVA (E12) ungleich Sonstige Betriebszusch\xc3\xbc""sse ZS (Z02)"},
	LKFBErrorE19Z04 =					{ 30, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Investitionszusch\xc3\xbc""sse QVA (E19) ungleich Investitionszusch\xc3\xbc""sse ZS (Z04)"},
	LKFBErrorE28Z05 =					{ 31, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Zins- und Annuit\xc3\xa4""tenzusch\xc3\xbc""sse QVA (E28) ungleich Zins- und Annuit\xc3\xa4""tenzusch\xc3\xbc""sse ZS (Z05)"},
	LKFBErrorE06U19 =					{ 32, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Sonstige betriebliche Ertr\xc3\xa4""ge QVA (E06) ungleich Sonstige betriebliche Ertr\xc3\xa4""ge ES (U19)"},    /* V15.2 */
	LKFBErrorV13V18 =					{ 33, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Sonstige Forderungen VKS: Summe der davon-Eintr\xc3\xa4""ge (V14 bis V18) gr\xc3\xb6""sser Gesamtwert (V13)"},  /* V15.2 */
	LKFBErrorK09K13 =					{ 34, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Sonstige Verbindlichkeiten langfristig  VKS: Summe der davon-Eintr\xc3\xa4""ge (K10 bis K13) gr\xc3\xb6""sser Gesamtwert (K09)"},  /* V15.2 */
	LKFBErrorE01E04 =					{ 35, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Teilangaben der Umsatzerl\xc3\xb6""se QVA (E02-E04) ungleich Umsatzerl\xc3\xb6""se Gesamt QVA (E01)"}, /* V15.2 */
    LKFBErrorE01E042025 =                    { 35, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Teilangaben der Umsatzerl\xc3\xb6""se QVA (E02, E03, E04, E41) ungleich Umsatzerl\xc3\xb6""se Gesamt QVA (E01)"}, /* V15.2 */
LKFBErrorR01K16 =					{ 36, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Eigenmittel i.w.S. + Mezzaninkapital EVR (R01) ungleich Eigenmittel i.w.S. + Mezzaninkapital VKS (K16)"}, /* V15.2 */
	LKFBErrorU01 =						{ 37, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "LKF-Geb\xc3\xbc""hreners\xc3\xa4""tze ES (U01): davon-Eintrag gr\xc3\xb6""sser Gesamtwert"}, /* V15.2 */
	LKFBErrorU02 =						{ 38, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "LKF-Geb\xc3\xbc""hren ES (U02): davon-Eintrag gr\xc3\xb6""sser Gesamtwert"}, /* V15.2 */
	LKFBErrorU07 =						{ 39, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Sonstige Erl\xc3\xb6""se akutstation\xc3\xa4""rer Bereich ES (U07): davon-Eintrag gr\xc3\xb6""sser Gesamtwert"}, /* V15.2 */
	LKFBErrorU09 =						{ 40, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Leistungsbezogene Verg\xc3\xbc""tung ES (U09): davon-Eintrag gr\xc3\xb6""sser Gesamtwert"}, /* V15.2 */
	LKFBErrorU10 =						{ 41, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Zeitraumbezogene Verg\xc3\xbc""tung ES (U10): davon-Eintrag gr\xc3\xb6""sser Gesamtwert"}, /* V15.2 */
	LKFBErrorU19 =						{ 42, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Sonstige betriebliche Ertr\xc3\xa4""ge ES (U19): davon-Eintrag gr\xc3\xb6""sser Gesamtwert"}, /* V15.2 */
    LKFBErrorU22 =                        { 43, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Vorhaltekosten ES (U22): davon-Eintrag gr\xc3\xb6""sser Gesamtwert"},
    LKFBErrorE41U22 = { 44, LKF_FAC_BERICHT, LKF_SEV_ERROR, 0, 0, "Vorhaltekosten QVA (E41) ungleich Vorhaltekosten ES (U22)"},
	LKFErrorB02fehlt =					{821, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlender Datensatz B02"},
	LKFErrorB04fehlt =					{822, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlender Datensatz B04"},
	LKFErrorB05fehlt =					{823, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlender Datensatz B05"},
	LKFErrorB06fehlt =					{824, LKF_FAC_ALL,	   LKF_SEV_FATAL, 0, 0, "Fehlender Datensatz B06"};

static int bericht_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 check_vksindex (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	int nIndex;
	char vksindex[4];
	Satzart_GetValueString (ds, len, pFeld, vksindex, 3);

	pCheckContext->cBerichtsIndexTyp = ' ';
	pCheckContext->nBerichtsIndex = 0;

	if (vksindex[1] < '0' || vksindex[1] > '9' || vksindex[2] < '0' || vksindex[2] > '9')
		return 1;
	nIndex = (vksindex[1]-'0')*10 + (vksindex[2]-'0');

	switch (vksindex[0])
	{
		case 'K':
			if (nIndex < 1 || nIndex > 18)
				return 1;
			break;
		case 'V':
			if (nIndex < 1 || nIndex > 22)
				return 1;
			break;
		default:
			return 1;
	}
	pCheckContext->cBerichtsIndexTyp = vksindex[0];
	pCheckContext->nBerichtsIndex = (unsigned int) nIndex;
	
	if (pCheckContext->pAktBericht)
	{
		double dValue;
		const SATZART_INFO *pSatzartInfo = pCheckContext->pKKContext->ppBSatzarten[1];

		if (vksindex[0] == 'K')
			pCheckContext->pAktBericht->kok[nIndex] = 1;
		else if (vksindex[0] == 'V')
			pCheckContext->pAktBericht->vok[nIndex] = 1;
		
		if (!Satzart_GetValueFloat (ds, len, pSatzartInfo->ppRef[B02_WERT], &dValue, pCheckContext->pContext->modelljahr))
		{
			if (vksindex[0] == 'K')
			{
				pCheckContext->pAktBericht->kok[nIndex] = 2;
				pCheckContext->pAktBericht->kv[nIndex] = dValue;	
			}
			else if (vksindex[0] == 'V')
			{
				pCheckContext->pAktBericht->vok[nIndex] = 2;
				pCheckContext->pAktBericht->vv[nIndex] = dValue;	
			}
		}
	}
	return 0;
}

static int check_evrindex (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int nIndex;
	char evrindex[4];
	Satzart_GetValueString (ds, len, pFeld, evrindex, 3);

	pCheckContext->cBerichtsIndexTyp = ' ';
	pCheckContext->nBerichtsIndex = 0;

	if (evrindex[0] != 'R' || evrindex[1] < '0' || evrindex[1] > '9' || evrindex[2] < '0' || evrindex[2] > '9')
		return 1;
	nIndex = (unsigned int) ((evrindex[1]-'0')*10 + (evrindex[2]-'0'));

	if (nIndex < 1 || nIndex > 12)
		return 1;

	pCheckContext->cBerichtsIndexTyp = evrindex[0];
	pCheckContext->nBerichtsIndex = nIndex;

	if (pCheckContext->pAktBericht && nIndex == 1)
	{
		const SATZART_INFO *pSatzartInfo = pCheckContext->pKKContext->ppBSatzarten[2];
		if (!Satzart_GetValueFloat (ds, len, pSatzartInfo->ppRef[B02_WERT], &pCheckContext->pAktBericht->r01v, pCheckContext->pContext->modelljahr))
			pCheckContext->pAktBericht->r01ok = 2;
		else
			pCheckContext->pAktBericht->r01ok = 1;
	}

	return 0;
}

static int check_qvaindex (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int nIndex;
	char qvaindex[4];
	Satzart_GetValueString (ds, len, pFeld, qvaindex, 3);

	pCheckContext->cBerichtsIndexTyp = ' ';
	pCheckContext->nBerichtsIndex = 0;

	if (qvaindex[1] < '0' || qvaindex[1] > '9' || qvaindex[2] < '0' || qvaindex[2] > '9')
		return 1;
	nIndex = (unsigned int) ((qvaindex[1]-'0')*10 + (qvaindex[2]-'0'));

	switch (qvaindex[0])
	{
		case 'E':
            
			if (nIndex < 1 || nIndex > 31)
            {
                if (pCheckContext->pContext->modelljahr < 2025 || nIndex != 41) {
                    return 1;
                }
            }
			break;
		case 'A':
			if (nIndex < 1 || nIndex > 26)
				return 1;
			break;
		case 'S':
			if (nIndex != 1)
				return 1;
			break;
		default:
			return 1;
	}
	pCheckContext->cBerichtsIndexTyp = qvaindex[0];
	pCheckContext->nBerichtsIndex = nIndex;

	if (pCheckContext->pAktBericht && qvaindex[0] == 'E')
		pCheckContext->pAktBericht->eok[nIndex] = 1;

	return 0;
}

static int check_erloesindex (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int nIndex;
	char erloesindex[4];
	Satzart_GetValueString (ds, len, pFeld, erloesindex, 3);

	pCheckContext->cBerichtsIndexTyp = ' ';
	pCheckContext->nBerichtsIndex = 0;

	if (erloesindex[0] != 'U' || erloesindex[1] < '0' || erloesindex[1] > '9' || erloesindex[2] < '0' || erloesindex[2] > '9')
		return 1;
	nIndex = (unsigned int) ((erloesindex[1]-'0')*10 + (erloesindex[2]-'0'));
    
	if (nIndex < 1 || nIndex > 22 /* V2025.1 */ )
		return 1;
    
    if (pCheckContext->pContext->modelljahr < 2025 && nIndex > 21)
        return 1;
    
    if (pCheckContext->pContext->modelljahr < 2018 && nIndex > 19)
        return 1; /* V2019.0 */

	pCheckContext->cBerichtsIndexTyp = erloesindex[0];
	pCheckContext->nBerichtsIndex = nIndex;

	if (pCheckContext->pAktBericht)
	{
		double dValue;
		const SATZART_INFO *pSatzartInfo = pCheckContext->pKKContext->ppBSatzarten[4];

		pCheckContext->pAktBericht->uok[nIndex] = 1;
		if (!Satzart_GetValueFloat (ds, len, pSatzartInfo->ppRef[B05_WERT_GESAMT], &dValue, pCheckContext->pContext->modelljahr))
		{
			pCheckContext->pAktBericht->uok[nIndex] = 2;
			pCheckContext->pAktBericht->uv[nIndex] = dValue;	
		}

		pCheckContext->pAktBericht->ulgfok[nIndex] = 1;
		if (!Satzart_GetValueFloat (ds, len, pSatzartInfo->ppRef[B05_WERT_LGF], &dValue, pCheckContext->pContext->modelljahr))
		{
			pCheckContext->pAktBericht->ulgfok[nIndex] = 2;
			pCheckContext->pAktBericht->ulgfv[nIndex] = dValue;	
		}


	}
	return 0;
}

static int check_zuschussart (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int nIndex;
	char zuschussindex[4];
	
	Satzart_GetValueString (ds, len, pFeld, zuschussindex, 3);

	pCheckContext->cBerichtsIndexTyp = ' ';
	pCheckContext->nBerichtsIndex = 0;

	if (zuschussindex[0] != 'Z' || zuschussindex[1] < '0' || zuschussindex[1] > '9' || zuschussindex[2] < '0' || zuschussindex[2] > '9')
		return 1;
	nIndex = (unsigned int) ((zuschussindex[1]-'0')*10 + (zuschussindex[2]-'0'));

	if (nIndex < 1 || nIndex > 5)
		return 1;

	pCheckContext->cBerichtsIndexTyp = zuschussindex[0];
	pCheckContext->nBerichtsIndex = nIndex;


	if (pCheckContext->pAktBericht)
	{
		const SATZART_INFO *pSatzartInfo = pCheckContext->pKKContext->ppBSatzarten[5];
		double dValue;

		Satzart_GetValueString (ds, len, pSatzartInfo->ppRef[B06_FINANZIERUNGSINDEX], zuschussindex, 3);
		if (memcmp (zuschussindex, "LF", 2) &&
			memcmp (zuschussindex, "LD", 2) &&
			memcmp (zuschussindex, "GM", 2) &&
			memcmp (zuschussindex, "RT", 2) &&
			memcmp (zuschussindex, "SO", 2))
			return 0;
		
		if (!Satzart_GetValueFloat (ds, len, pSatzartInfo->ppRef[B06_ZUSCHUSS], &dValue, pCheckContext->pContext->modelljahr))
		{
			pCheckContext->pAktBericht->zv[nIndex] += dValue;
			if (pCheckContext->pAktBericht->zok[nIndex] != 1)
				pCheckContext->pAktBericht->zok[nIndex] = 2;
		}
		else
			pCheckContext->pAktBericht->zok[nIndex] = 1;
	}
	return 0;
}

static int check_b02wertneg (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	double dValue = 0;
	if (!pCheckContext->nBerichtsIndex)
		return 0;
	if (pCheckContext->cBerichtsIndexTyp == 'K' && pCheckContext->nBerichtsIndex == 16)
		return 0;
	Satzart_GetValueFloat (ds, len, pFeld, &dValue, pCheckContext->pContext->modelljahr);
	if (dValue < -DOUBLE_0_VALUE)
		return 1;

	return 0;
}

static int check_b03wertneg(const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	double dValue = 0;
	if (!pCheckContext->nBerichtsIndex)
		return 0;
	if (pCheckContext->cBerichtsIndexTyp == 'R' && (pCheckContext->nBerichtsIndex ==  1 || pCheckContext->nBerichtsIndex ==  2 || pCheckContext->nBerichtsIndex ==  3
											     || pCheckContext->nBerichtsIndex ==  6 || pCheckContext->nBerichtsIndex ==  8 || pCheckContext->nBerichtsIndex == 11))
		return 0;
	Satzart_GetValueFloat (ds, len, pFeld, &dValue, pCheckContext->pContext->modelljahr);
	if (dValue < -DOUBLE_0_VALUE)
		return 1;
	return 0;
}

static int check_b04wertneg (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	double dValue = 0;
	if (!pCheckContext->nBerichtsIndex)
		return 0;
	if (pCheckContext->cBerichtsIndexTyp == 'E' && (pCheckContext->nBerichtsIndex == 10 || pCheckContext->nBerichtsIndex == 17 || pCheckContext->nBerichtsIndex == 24))
		return 0;
	if (pCheckContext->cBerichtsIndexTyp == 'A' && pCheckContext->nBerichtsIndex == 7)
		return 0;
	Satzart_GetValueFloat (ds, len, pFeld, &dValue, pCheckContext->pContext->modelljahr);
	if (pCheckContext->cBerichtsIndexTyp == 'E' && pCheckContext->pAktBericht && pFeld && pFeld->nFieldNum == B02_WERT)
	{
		pCheckContext->pAktBericht->eok[pCheckContext->nBerichtsIndex] = 2;
		pCheckContext->pAktBericht->ev[pCheckContext->nBerichtsIndex] = dValue;
	}
	if (dValue < -DOUBLE_0_VALUE)
		return 1;
	return 0;
}

static LKF_BERICHT_DATEN *GetTypBericht (LKF_CHECK_CONTEXT *pCheckContext, char cBerichtsTyp, int bAlloc)
{
	int nIndex = -1;
	switch (cBerichtsTyp)
	{
		case 'K':
			nIndex = 0;
			break;
		case 'G':
			nIndex = 1;
			break;
		case 'A':
			nIndex = 2;
			break;
		case 'T':
			nIndex = 3;
			break;
		default:
			break;
	}

	if (nIndex<0)
		return 0;
	if (nIndex >= 0 && pCheckContext->pKKContext->pBericht[nIndex])
		return pCheckContext->pKKContext->pBericht[nIndex];
	if (!bAlloc)
		return 0;
	pCheckContext->pKKContext->pBericht[nIndex] = LKF_MALLOC (pCheckContext->pContext, "GetTypBericht", sizeof (LKF_BERICHT_DATEN));
    if (!pCheckContext->pKKContext->pBericht[nIndex]) {
        return 0;
    }
	memset (pCheckContext->pKKContext->pBericht[nIndex], 0, sizeof(LKF_BERICHT_DATEN));
	pCheckContext->pKKContext->pBericht[nIndex]->cBerichtsTyp = cBerichtsTyp;

	return pCheckContext->pKKContext->pBericht[nIndex];
}

static int check_berichtstyp (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sTyp[2];
	Satzart_GetValueString (ds, len, pFeld, sTyp, 1);
	pCheckContext->sBerichtsTyp[0] = sTyp[0];
	pCheckContext->sBerichtsTyp[1] = 0;
	pCheckContext->pAktBericht = GetTypBericht (pCheckContext, pCheckContext->sBerichtsTyp[0], 1);

	if (pCheckContext->pContext->isKTR)
	{
		if (sTyp[0] != 'G' && sTyp[0] != 'A' && sTyp[0] != 'T')
			return 1;
	}
	else if (sTyp[0] != 'K')
		return 1;
	return 0;
}

static int check_zuordart (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	char sArt[2];
	Satzart_GetValueString (ds, len, pFeld, sArt, 1);

	if (sArt[0] != 'D' && sArt[0] != 'G')
	{
		if (pCheckContext->pContext->isKTR || (sArt[0] && sArt[0] != ' '))
			return 1;
	}
	return 0;
}



const LKF_SATZART_ERRORCHECK_STRINGLIST 
	stringlist_Berichtstyp = {4, {"K", "G", "A", "T"}},
	stringlist_BerechTyp = {3, {"E", "K", "S"}},
/*	stringlist_ZuordArt = {2, {"D", "G"}}, */
	stringlist_FTIndex = {5, {"LF", "LD", "GM", "RT", "SO"}};

const LKF_SATZART_ERRORCHECK	
	LKFBCheckBerichtsjahrfalsch =	 {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, bericht_berichtsjahr, &LKFBErrorBerichtsjahrfalsch, 0, 0},
	LKFBCheckBerichtsjahr =			 {LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorBerichtsjahrfehlt, 0, &LKFBCheckBerichtsjahrfalsch},
/*  LKFBCheckBerichtstyp =			 {LKF_CHECKFUNC_STRINGLIST, &stringlist_Berichtstyp, &LKFBErrorBerichtstypFalsch, 0, 0}, */
	LKFBCheckBerichtstyp =			 {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_berichtstyp, &LKFBErrorBerichtstypFalsch, 0, 0},
	LKFBCheckBerechTypFalsch =		 {LKF_CHECKFUNC_STRINGLIST | LKF_CHECK_NURFONDSKA, &stringlist_BerechTyp, &LKFBErrorBerechTypFalsch, 0, 0},
	LKFBCheckZuordArtFalsch =		 {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_zuordart, &LKFBErrorZuordArtFalsch, 0, 0};

/**************************************************************************************************
** Satzart B01                                                                                   **
**************************************************************************************************/

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

const SATZART B01Satzart = {"B01", 0, 5, 5, (const int *) &b01_ident, "Basisinformation", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFBCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{B01_BERICHTSTYP,			TYP_ALPHA,	14,  1, &LKFBCheckBerichtstyp, 0, "BERICHTSTYP"},
	{B01_BERECH_TYP,			TYP_ALPHA,  15,  1, &LKFBCheckBerechTypFalsch, 0, "BERECHNUNGSTYP"},
	{B01_ZUORD_ART,				TYP_ALPHA,  16,  1, &LKFBCheckZuordArtFalsch, 0, "ZUORDNUNGSART"}
}};

/**************************************************************************************************
** Satzart B02                                                                                   **
**************************************************************************************************/

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

const LKF_SATZART_ERRORCHECK
	LKFBCheckVKSIndexFalsch =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_vksindex, &LKFBErrorVKSIndexFalsch, 0, 0},
	LKFBCheckB02WertNeg =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_b02wertneg, &LKFBErrorNegWertVKSIndex, 0, 0},
	LKFBCheckB02WertFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorWertFalsch, 0, &LKFBCheckB02WertNeg},
	LKFBCheckB02WertFehlt =			{LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorWertFehlt, 0, &LKFBCheckB02WertFalsch},
	LKFBCheckB02VorjahrWertFalsch = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorVorjahrWertFalsch, 0, &LKFBCheckB02WertNeg},
	LKFBCheckB02VorjahrWertFehlt =  {LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorVorjahrWertFehlt, 0, &LKFBCheckB02VorjahrWertFalsch};

const SATZART_FELD B02WertVorjahrMuss = {B02_WERT_VORJAHR,	TYP_NUM_NEG, 28, 10, &LKFBCheckB02VorjahrWertFehlt, 0, "WERT VORJAHR"};

const SATZART B02Satzart = {"B02", 0, 6, 6, (const int *) &b02_ident, "Verm\xc3\xb6""gens- und Kapitalstruktur (VKS)", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFBCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{B01_BERICHTSTYP,			TYP_ALPHA,	14,  1, &LKFBCheckBerichtstyp, 0, "BERICHTSTYP"},
	{B02_VKSINDEX,				TYP_ALPHA,	15,  3, &LKFBCheckVKSIndexFalsch, 0, "VKS-INDEX"},
	{B02_WERT,					TYP_NUM_NEG,	18, 10, &LKFBCheckB02WertFehlt, 0, "WERT BERICHTSJAHR"},
	{B02_WERT_VORJAHR,			TYP_NUM_NEG,    28, 10, &LKFBCheckB02VorjahrWertFalsch, 0, "WERT VORJAHR", 2010, &B02WertVorjahrMuss}
}};

/**************************************************************************************************
** Satzart B03                                                                                   **
**************************************************************************************************/

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

const LKF_SATZART_ERRORCHECK
	LKFBCheckEVRIndexFalsch =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_evrindex, &LKFBErrorEVRIndexFalsch, 0, 0},
	LKFBCheckB03WertNeg =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_b03wertneg, &LKFBErrorNegWertEVRIndex, 0, 0},
	LKFBCheckB03WertFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorWertFalsch, 0, &LKFBCheckB03WertNeg},
	LKFBCheckB03WertFehlt =			{LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorWertFehlt, 0, &LKFBCheckB03WertFalsch},
	LKFBCheckB03VorjahrWertFalsch = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorVorjahrWertFalsch, 0, &LKFBCheckB03WertNeg},
	LKFBCheckB03VorjahrWertFehlt =  {LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorVorjahrWertFehlt, 0, &LKFBCheckB03VorjahrWertFalsch};


const SATZART_FELD B03WertVorjahrMuss = {B02_WERT_VORJAHR,	TYP_NUM_NEG, 28, 10, &LKFBCheckB03VorjahrWertFehlt, 0, "WERT VORJAHR"};

const SATZART B03Satzart = {"B03", 0, 6, 6, (const int *) &b03_ident, "Eigenmittelverteilungsrechnung (EVR)", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFBCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{B01_BERICHTSTYP,			TYP_ALPHA,	14,  1, &LKFBCheckBerichtstyp, 0, "BERICHTSTYP"},
	{B03_EVRINDEX,				TYP_ALPHA,  15,  3, &LKFBCheckEVRIndexFalsch, 0, "EVR-INDEX"},
	{B02_WERT,					TYP_NUM_NEG,	18, 10, &LKFBCheckB03WertFehlt, 0, "WERT BERICHTSJAHR"},
	{B02_WERT_VORJAHR,			TYP_NUM_NEG,    28, 10, &LKFBCheckB03VorjahrWertFalsch, 0, "WERT VORJAHR", 2010, &B03WertVorjahrMuss}
}};

/**************************************************************************************************
** Satzart B04                                                                                   **
**************************************************************************************************/

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

const LKF_SATZART_ERRORCHECK
	LKFBCheckQVAIndexFalsch =			{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_qvaindex, &LKFBErrorQVAIndexFalsch, 0, 0},
	LKFBCheckB04WertNeg =				{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_b04wertneg, &LKFBErrorNegWertQVAIndex, 0, 0},
	LKFBCheckB04WertFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorWertFalsch, 0, &LKFBCheckB04WertNeg},
	LKFBCheckB04WertFehlt =				{LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorWertFehlt, 0, &LKFBCheckB04WertFalsch},
	LKFBCheckB04VorjahrWertFalsch =		{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorVorjahrWertFalsch, 0, &LKFBCheckB04WertNeg},
	LKFBCheckB04VorjahrWertFehlt =		{LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorVorjahrWertFehlt, 0, &LKFBCheckB04VorjahrWertFalsch};

const SATZART_FELD B04WertVorjahrMuss = {B02_WERT_VORJAHR,	TYP_NUM_NEG, 28, 10, &LKFBCheckB04VorjahrWertFehlt, 0, "WERT VORJAHR"};

const SATZART B04Satzart = {"B04", 0, 6, 6, (const int *) &b04_ident, "Quellen- und Verwendungsanalyse (QVA)", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFBCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{B01_BERICHTSTYP,			TYP_ALPHA,	14,  1, &LKFBCheckBerichtstyp, 0, "BERICHTSTYP"},
	{B04_QVAINDEX,				TYP_ALPHA,  15,  3, &LKFBCheckQVAIndexFalsch, 0, "QVA-INDEX"},
	{B02_WERT,					TYP_NUM_NEG,	18, 10, &LKFBCheckB04WertFehlt, 0, "WERT BERICHTSJAHR"},
	{B02_WERT_VORJAHR,			TYP_NUM_NEG,    28, 10, &LKFBCheckB04VorjahrWertFalsch, 0, "WERT VORJAHR", 2010, &B04WertVorjahrMuss}
}};

/**************************************************************************************************
** Satzart B05                                                                                   **
**************************************************************************************************/


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

const LKF_SATZART_ERRORCHECK
	LKFBCheckErloesIndexFalsch =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_erloesindex, &LKFBErrorErloesIndexFalsch, 0, 0},
	LKFBCheckLGFWertFalsch = {LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorLGFWertFalsch, 0, 0},
	LKFBCheckLGFWertFehlt =  {LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorLGFWertFehlt, 0, &LKFBCheckLGFWertFalsch},
	LKFBCheckB05WertFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorWertFalsch, 0, 0},
	LKFBCheckB05WertFehlt =				{LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorWertFehlt, 0, &LKFBCheckB05WertFalsch};

const SATZART B05Satzart = {"B05", 0, 6, 6, (const int *) &b05_ident, "Erl\xc3\xb6""sstruktur (ES)", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFBCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{B01_BERICHTSTYP,			TYP_ALPHA,	14,  1, &LKFBCheckBerichtstyp, 0, "BERICHTSTYP"},
	{B05_ERLOESINDEX,			TYP_ALPHA,  15,  3, &LKFBCheckErloesIndexFalsch, 0, "ERLOES-INDEX"},
	{B05_WERT_GESAMT,			TYP_NUM,	18, 10, &LKFBCheckB05WertFehlt, 0, "WERT GESAMT"},
	{B05_WERT_LGF,				TYP_NUM,    28, 10, &LKFBCheckLGFWertFehlt, 0, "WERT LGF"}
}};

/**************************************************************************************************
** Satzart B06                                                                                   **
**************************************************************************************************/

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

const LKF_SATZART_ERRORCHECK
	LKFBCheckFTIndexFalsch =			{LKF_CHECKFUNC_STRINGLIST | LKF_CHECK_NURFONDSKA, &stringlist_FTIndex, &LKFBErrorFTIndexFalsch, 0, 0},
	LKFBCheckZuschussArtFalsch =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_zuschussart, &LKFBErrorZuschussArtFalsch, 0, 0},
	LKFBCheckZuschussFalsch =			{LKF_CHECKFUNC_FORMAT | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorZuschussFalsch, 0, 0},
	LKFBCheckZuschussFehlt =			{LKF_CHECKFUNC_EXISTS | LKF_CHECK_NURFONDSKA, 0, &LKFBErrorZuschussFehlt, 0, &LKFBCheckZuschussFalsch};

const SATZART B06Satzart = {"B06", 0, 6, 6, (const int *) &b06_ident, "Zuschussstruktur (ZS)", 0, {
	{GEN_JAHR,					TYP_NUM,	 4,  4, &LKFBCheckBerichtsjahr, 0, "JAHR"},
	{GEN_KANR,					TYP_ALPHA,	 8,  6, 0, 0, "KANR"},
	{B01_BERICHTSTYP,			TYP_ALPHA,	14,  1, &LKFBCheckBerichtstyp, 0, "BERICHTSTYP"},
	{B06_FINANZIERUNGSINDEX,	TYP_ALPHA,  15,  2, &LKFBCheckFTIndexFalsch, 0, "FINANZIERUNGSTR\xc3\x84""GERINDEX"},
	{B06_ZUSCHUSSARTINDEX,		TYP_ALPHA,	17,  3, &LKFBCheckZuschussArtFalsch, 0, "ZUSCHUSSARTINDEX"},
	{B06_ZUSCHUSS,				TYP_NUM,    20, 10, &LKFBCheckZuschussFehlt, 0, "ZUSCHUSS"}
}};

/********************************************************************************************* 
** Felduebergreifende Berichts-Checks                                                       **
*********************************************************************************************/

static int check_b02_exists (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	if (pCheckContext->pContext->period_type != 'J' || pCheckContext->pContext->isKTR || pCheckContext->pKKContext->pBSatzartCount[1] || !pCheckContext->pKKContext->pBSatzartCount[0])
		return 0;
	return 1;
}

static int check_b04_exists (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	if (pCheckContext->pContext->period_type != 'J' || pCheckContext->pContext->isKTR || pCheckContext->pKKContext->pBSatzartCount[3] || !pCheckContext->pKKContext->pBSatzartCount[0])
		return 0;
	return 1;
}

static int check_b05_exists (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	if (pCheckContext->pContext->period_type != 'J' || pCheckContext->pContext->isKTR || pCheckContext->pKKContext->pBSatzartCount[4] || !pCheckContext->pKKContext->pBSatzartCount[0])
		return 0;
	return 1;
}

static int check_b06_exists (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	if (pCheckContext->pContext->period_type != 'J' || pCheckContext->pContext->isKTR || pCheckContext->pKKContext->pBSatzartCount[5] || !pCheckContext->pKKContext->pBSatzartCount[0])
		return 0;
	return 1;
}

static double absdiff (double d1, double d2)
{
	if (d1 > d2)
		return d1 - d2;
	if (d2 > d1)
		return d2 - d1;
	return 0;
}

static int check_eu (LKF_CHECK_CONTEXT *pCheckContext, unsigned int nEIndex, unsigned int nUIndex, unsigned int nUIndexCount, unsigned int *pUIndices, const LKF_SATZART_ERRORDEF *pError /* V14.3 */)
{
	unsigned int i, j;
	LKF_BERICHT_DATEN *pBericht;
	int uok;
    double uval = 0;

	for (i = 0; i < MAX_BERICHT_TYP; i++)
	{
		pBericht = pCheckContext->pKKContext->pBericht[i];
		if (pBericht)
		{
			if (pUIndices)
			{
				uok = 0;
				for (j = 0; uok != 1 && j < nUIndexCount; j++)
				{
					if (pBericht->uok[pUIndices[j]] == 1)
						uok = 1;
				}
				if (pBericht->eok[nEIndex] != 1 && uok != 1)
				{
					uval = 0.0;
					for (j = 0; j < nUIndexCount; j++)
					{
						uval += pBericht->uv[pUIndices[j]];
					}
				}
			}
			else
			{
				uok = pBericht->uok[nUIndex];
				uval = pBericht->uv[nUIndex];
			}
			
			if (pBericht->eok[nEIndex] != 1 && uok != 1)
			{
				if (pBericht->ev[nEIndex]+50 < uval ||
					uval+50 < pBericht->ev[nEIndex])
				{
					/* V14.3 */
					pCheckContext->sBerichtsTyp[0] = pBericht->cBerichtsTyp;
					sprintf (pCheckContext->sErrorAdditionalInfo, "%10.0f", absdiff (pBericht->ev[nEIndex], uval));
					Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, pError, pCheckContext->sErrorAdditionalInfo);
				}
			}
		}
	}
	return 0;
}

static int check_ez (LKF_CHECK_CONTEXT *pCheckContext, unsigned int nEIndex, unsigned int nZIndex, const LKF_SATZART_ERRORDEF *pError /* V14.3 */)
{
	unsigned int i;
	LKF_BERICHT_DATEN *pBericht;

	for (i = 0; i < MAX_BERICHT_TYP; i++)
	{
		pBericht = pCheckContext->pKKContext->pBericht[i];
		if (pBericht)
		{
			if (pBericht->eok[nEIndex] != 1 && pBericht->zok[nZIndex] != 1)
			{
				if (pBericht->ev[nEIndex]+50 < pBericht->zv[nZIndex] ||
					pBericht->zv[nZIndex]+50 < pBericht->ev[nEIndex])
				{
					/* V14.3 */
					pCheckContext->sBerichtsTyp[0] = pBericht->cBerichtsTyp;
					sprintf (pCheckContext->sErrorAdditionalInfo, "%10.0f", absdiff (pBericht->ev[nEIndex], pBericht->zv[nZIndex]));
					Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, pError, pCheckContext->sErrorAdditionalInfo);
				}
			}
		}
	}
	return 0;
}

static int check_e01u17 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	static unsigned int addval[] = {1,2,3,4,5,6,7,9,10,11,13,14,15};
    static unsigned int addval2018[] = {1,2,3,4,5,6,7,9,10,11,13,14,15,20,21}; /* V2019.2 */
    static unsigned int addval2025[] = {1,2,3,4,5,6,7,9,10,11,13,14,15,20,21,22}; /* V2019.2 */
    
    if (pCheckContext->pContext->modelljahr >= 2025) { /* V2025.1 */
        return check_eu (pCheckContext, 1, 17, sizeof(addval2025)/sizeof(unsigned int), addval2025, &LKFBErrorE01U17);
    }
    else if (pCheckContext->pContext->modelljahr >= 2018) {
        return check_eu (pCheckContext, 1, 17, sizeof(addval2018)/sizeof(unsigned int), addval2018, &LKFBErrorE01U17);
    }
    else {
        return check_eu (pCheckContext, 1, 17, sizeof(addval)/sizeof(unsigned int), addval, &LKFBErrorE01U17);
    }
}

static int check_e02u08 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	static unsigned int addval[] = {1,2,3,4,5,6,7};
	return check_eu (pCheckContext, 2, 8, sizeof(addval)/sizeof(unsigned int), addval, &LKFBErrorE02U08);
}

static int check_e03u12 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	static unsigned int addval[] = {9,10,11};
    static unsigned int addval2018[] = {9,10,11,20,21}; /* V2019.2 */
    
    if (pCheckContext->pContext->modelljahr >= 2018) {
        return check_eu (pCheckContext, 3, 12, sizeof(addval2018)/sizeof(unsigned int), addval2018, &LKFBErrorE03U12);
    }
    else {
        return check_eu (pCheckContext, 3, 12, sizeof(addval)/sizeof(unsigned int), addval, &LKFBErrorE03U12);
    }
}

static int check_e41u22 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
    return check_eu (pCheckContext, 41, 22, 0, 0, &LKFBErrorE41U22);
}

static int check_e04u16 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	static unsigned int addval[] = {13,14,15};
	return check_eu (pCheckContext, 4, 16, sizeof(addval)/sizeof(unsigned int), addval, &LKFBErrorE04U16);
}

static int check_e05u18 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return check_eu (pCheckContext, 5, 18, 0, 0, &LKFBErrorE05U18);
}

static int check_e06u19 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
	return check_eu (pCheckContext, 6, 19, 0, 0, &LKFBErrorE06U19);
}

static int check_v13v18 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
	unsigned int i, j;
	int ok;
	LKF_BERICHT_DATEN *pBericht;
	double dSum, dGesamt;

	for (i = 0; i < MAX_BERICHT_TYP; i++)
	{
		ok = 1;
		pBericht = pCheckContext->pKKContext->pBericht[i];
		if (pBericht)
		{
			ok = 1;
			dSum = 0;
			dGesamt = 0;

			for (j = 13; j < 19; j++)
			{
				if (pBericht->vok[j] == 1)
				{
					ok = 0;
					break;
				}
				else if (pBericht->vok[j] == 2)
				{
					if (j == 13)
						dGesamt = pBericht->vv[13];
					else
						dSum += pBericht->vv[j];
				}
				if (!ok)
					continue;
			}
			if (dSum - 0.00001 > dGesamt)
			{
				pCheckContext->sBerichtsTyp[0] = pBericht->cBerichtsTyp;
				sprintf (pCheckContext->sErrorAdditionalInfo, "%10.0f", dSum - dGesamt);
				Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFBErrorV13V18, pCheckContext->sErrorAdditionalInfo);
			}
		}
	}
	return 0;
}

static int check_k09k13 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
	unsigned int i, j;
	int ok;
	LKF_BERICHT_DATEN *pBericht;
	double dSum, dGesamt;

	for (i = 0; i < MAX_BERICHT_TYP; i++)
	{
		ok = 1;
		pBericht = pCheckContext->pKKContext->pBericht[i];
		if (pBericht)
		{
			ok = 1;
			dSum = 0;
			dGesamt = 0;

			for (j = 9; j < 14; j++)
			{
				if (pBericht->kok[j] == 1)
				{
					ok = 0;
					break;
				}
				else if (pBericht->kok[j] == 2)
				{
					if (j == 9)
						dGesamt = pBericht->kv[9];
					else
						dSum += pBericht->kv[j];
				}
				if (!ok)
					continue;
			}
			if (dSum - 0.00001 > dGesamt)
			{
				pCheckContext->sBerichtsTyp[0] = pBericht->cBerichtsTyp;
				sprintf (pCheckContext->sErrorAdditionalInfo, "%10.0f", dSum - dGesamt);
				Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFBErrorK09K13, pCheckContext->sErrorAdditionalInfo);
			}
		}
	}
	return 0;
}


static int check_e11z01 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return check_ez (pCheckContext, 11, 1, &LKFBErrorE11Z01);
}

static int check_e12z02 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return check_ez (pCheckContext, 12, 2, &LKFBErrorE12Z02);
}

static int check_e19z04 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return check_ez (pCheckContext, 19, 4, &LKFBErrorE19Z04);
}

static int check_e28z05 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	return check_ez (pCheckContext, 28, 5, &LKFBErrorE28Z05);
}

static int check_e01e04 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
	unsigned int i, j;
	LKF_BERICHT_DATEN *pBericht;
	double dSum, dGesamt;
	int ok;


	for (i = 0; i < MAX_BERICHT_TYP; i++)
	{
		dSum = 0;
		dGesamt = 0;
		pBericht = pCheckContext->pKKContext->pBericht[i];
		if (pBericht)
		{
			ok = 1;
			for (j = 1; j < 5; j++)
			{
				if (pBericht->eok[j] == 1)
				{
					ok = 0;
					break;
				}
				else if (pBericht->eok[j] == 2)
				{
					if (j == 1)
						dGesamt = pBericht->ev[1];
					else
						dSum += pBericht->ev[j];
				}
				if (!ok)
					continue;
			}
            
            if (ok && pCheckContext->pContext->modelljahr >= 2025) {
                /* V2025 - E41 mitberuecksichtigen */
                if (pBericht->eok[41] == 1)
                {
                    ok = 0;
                }
                else if (pBericht->eok[41] == 2)
                {
                    dSum += pBericht->ev[41];
                }
            }
            
            
			if (dSum+50 < dGesamt || dGesamt+50<dSum)
			{
                const LKF_SATZART_ERRORDEF *pEB13 = (pCheckContext->pContext->modelljahr >= 2025) ? &LKFBErrorE01E042025 : &LKFBErrorE01E04;
				pCheckContext->sBerichtsTyp[0] = pBericht->cBerichtsTyp;
				sprintf (pCheckContext->sErrorAdditionalInfo, "%10.0f", absdiff (dSum,dGesamt));
				Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, pEB13, pCheckContext->sErrorAdditionalInfo);
			}
		}
	}
	return 0;
}

static int check_r01k16 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{
	unsigned int i, j;
	LKF_BERICHT_DATEN *pBericht;

	for (i = 0; i < MAX_BERICHT_TYP; i++)
	{
		pBericht = pCheckContext->pKKContext->pBericht[i];
		if (pBericht)
		{
			int kok = pBericht->kok[16];
			double kv = pBericht->kv[16];

			if (pCheckContext->pContext->modelljahr >= 2011)
			{ /* V16.1 */
				const static unsigned int kind[] = {1,2,3,5,6,7,8,9};
				const static unsigned int vind[] = {1,2,3,4,5,6,7,8,10,11,13,19,20};
				unsigned int count;
				kv = 0;
				kok = 2;
				count = sizeof(kind)/sizeof(unsigned int);
				for (j = 0; kok != 1 && j < count; j++)
				{
					kok = pBericht->kok[kind[j]];
					if (kok == 2) kv -= pBericht->kv[kind[j]];
				}
				if (kok != 1) {
					count = sizeof(vind)/sizeof(unsigned int);
					for (j = 0; kok != 1 && j < count; j++)
					{
						kok = pBericht->vok[vind[j]];
						if (kok == 2) kv += pBericht->vv[vind[j]];
					}
				}
				if (kok != 1) kok = 2;
			}

			if (pBericht->r01ok == 2 && kok == 2) /* check nur, wenn beide ausgefuellt */
			{
				if (pBericht->r01v + 50 < kv || kv + 50 < pBericht->r01v)
				{
					pCheckContext->sBerichtsTyp[0] = pBericht->cBerichtsTyp;
					sprintf (pCheckContext->sErrorAdditionalInfo, "%10.0f", absdiff (pBericht->r01v, kv));
					Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, &LKFBErrorR01K16, pCheckContext->sErrorAdditionalInfo);
				}
			}
		}
	}
	return 0;
}

static int check_u (LKF_CHECK_CONTEXT *pCheckContext, unsigned int index, const LKF_SATZART_ERRORDEF *pError)
{
	unsigned int i;
	LKF_BERICHT_DATEN *pBericht;

	for (i = 0; i < MAX_BERICHT_TYP; i++)
	{
		pBericht = pCheckContext->pKKContext->pBericht[i];
		if (pBericht)
		{
			if (pBericht->uok[index] == 2 && pBericht->ulgfok[index] == 2)
			{
				if (pBericht->ulgfv[index] - 0.00001 > pBericht->uv[index])
				{
					pCheckContext->sBerichtsTyp[0] = pBericht->cBerichtsTyp;
					sprintf (pCheckContext->sErrorAdditionalInfo, "%10.0f", pBericht->ulgfv[index] - pBericht->uv[index]);
					Satzart_ReportError (pCheckContext->pContext, pCheckContext, 0, 0, 0, 0, pError, pCheckContext->sErrorAdditionalInfo);
				}
			}
		}
	}

	return 0;
}

static int check_u01 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
	return check_u (pCheckContext, 1, &LKFBErrorU01);
}

static int check_u02 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
	return check_u (pCheckContext, 2, &LKFBErrorU02);
}

static int check_u07 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
	return check_u (pCheckContext, 7, &LKFBErrorU07);
}

static int check_u09 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
	return check_u (pCheckContext, 9, &LKFBErrorU09);
}

static int check_u10 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
	return check_u (pCheckContext, 10, &LKFBErrorU10);

}

static int check_u19 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
	return check_u (pCheckContext, 19, &LKFBErrorU19);
}

static int check_u22 (const char *ds, unsigned int len, const SATZART_FELD *pFeld, const LKF_SATZART_ERRORCHECK *pCheck, LKF_CHECK_CONTEXT *pCheckContext)
{ /* V15.2 */
    return check_u (pCheckContext, 22, &LKFBErrorU22);
}


const LKF_SATZART_ERRORCHECK	
	LKFBCheckB02fehlt =	{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_b02_exists, &LKFErrorB02fehlt},
	LKFBCheckB04fehlt = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_b04_exists, &LKFErrorB04fehlt},
	LKFBCheckB05fehlt = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_b05_exists, &LKFErrorB05fehlt},
	LKFBCheckB06fehlt = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_b06_exists, &LKFErrorB06fehlt},
	LKFBCheckE01U17 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e01u17,     &LKFBErrorE01U17},
	LKFBCheckE02U08 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e02u08,     &LKFBErrorE02U08},
	LKFBCheckE03U12 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e03u12,     &LKFBErrorE03U12},
    LKFBCheckE41U22 = {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e41u22,     &LKFBErrorE41U22},
    LKFBCheckE04U16 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e04u16,     &LKFBErrorE04U16},
	LKFBCheckE05U18 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e05u18,     &LKFBErrorE05U18},
	LKFBCheckE11Z01 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e11z01,     &LKFBErrorE11Z01},
	LKFBCheckE12Z02 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e12z02,     &LKFBErrorE12Z02},
	LKFBCheckE19Z04 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e19z04,     &LKFBErrorE19Z04},
	LKFBCheckE28Z05 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e28z05,     &LKFBErrorE28Z05},
	LKFBCheckE06U19 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e06u19,     &LKFBErrorE06U19}, /* V15.2 */
	LKFBCheckV13V18 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_v13v18,     &LKFBErrorV13V18}, /* V15.2 */
	LKFBCheckK09K13 =   {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_k09k13,     &LKFBErrorK09K13}, /* V15.2 */
    LKFBCheckE01E042025 =    {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e01e04, &LKFBErrorE01E042025}, /* V15.2 */

    LKFBCheckE01E04 =	{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_e01e04,     &LKFBErrorE01E04, 0, 0, 2025, &LKFBCheckE01E042025}, /* V15.2 */
	LKFBCheckR01K16 =	{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_r01k16,     &LKFBErrorR01K16}, /* V15.2 */
	LKFBCheckU01 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_u01,	      &LKFBErrorU01}, /* V15.2 */
	LKFBCheckU02 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_u02,	      &LKFBErrorU02}, /* V15.2 */
	LKFBCheckU07 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_u07,	      &LKFBErrorU07}, /* V15.2 */
	LKFBCheckU09 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_u09,		  &LKFBErrorU09}, /* V15.2 */
	LKFBCheckU10 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_u10,	      &LKFBErrorU10}, /* V15.2 */
    LKFBCheckU19 =		{LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_u19,	      &LKFBErrorU19}, /* V15.2 */
    LKFBCheckU22 =      {LKF_CHECKFUNC_FUNCTION | LKF_CHECK_NURFONDSKA, check_u22,        &LKFBErrorU22}; /* V2025.1 V */

const LKF_SATZART_ERRORCHECK *GenBerichtChecks[] = {&LKFBCheckB02fehlt, &LKFBCheckB04fehlt, &LKFBCheckB05fehlt, &LKFBCheckB06fehlt, 
													&LKFBCheckE01U17, &LKFBCheckE02U08, &LKFBCheckE03U12, &LKFBCheckE04U16, &LKFBCheckE05U18,
													&LKFBCheckE11Z01, &LKFBCheckE12Z02, &LKFBCheckE19Z04, &LKFBCheckE28Z05, 
													&LKFBCheckE06U19, &LKFBCheckV13V18, &LKFBCheckK09K13, &LKFBCheckE01E04, &LKFBCheckR01K16, /* V15.2 */ 
													&LKFBCheckU01, &LKFBCheckU02, &LKFBCheckU07, &LKFBCheckU09, &LKFBCheckU10, &LKFBCheckU19, /* V15.2 */									
													0};

const LKF_SATZART_ERRORCHECK *GenBerichtChecks2025[] = {&LKFBCheckB02fehlt, &LKFBCheckB04fehlt, &LKFBCheckB05fehlt, &LKFBCheckB06fehlt,
                                                    &LKFBCheckE01U17, &LKFBCheckE02U08, &LKFBCheckE03U12, &LKFBCheckE04U16, &LKFBCheckE05U18, &LKFBCheckE41U22,
                                                    &LKFBCheckE11Z01, &LKFBCheckE12Z02, &LKFBCheckE19Z04, &LKFBCheckE28Z05,
                                                    &LKFBCheckE06U19, &LKFBCheckV13V18, &LKFBCheckK09K13, &LKFBCheckE01E04, &LKFBCheckR01K16, /* V15.2 */
                                                    &LKFBCheckU01, &LKFBCheckU02, &LKFBCheckU07, &LKFBCheckU09, &LKFBCheckU10, &LKFBCheckU19, /* V15.2 */ &LKFBCheckU22, /* V2025.1 */
                                                    0};

/*********************************************************************************************
** Alle Satzart BERICHTS-Satzarten                                                          **
*********************************************************************************************/

const LKF_SATZART_ERRORCHECK_COMMENT BerichtComments[] = {
	{bericht_berichtsjahr, "Jahr mu\xc3\x9f"" mit Abrechnungsjahr \xc3\xbc""bereinstimmen"},
	{check_vksindex, "VKS-Index K01-K18 / V01-V22"},
	{check_evrindex, "EVR-Index R01-R12"},
	{check_qvaindex, "QVA-Index E01-E32|E41 / A01-A26 / S01"},
    {check_erloesindex, "Erl\xc3\xb6""sindex U01-U22 (<2025: -U21, <2019: -U19)"},
	{check_zuschussart, "Zuschussart Z01-Z05"},
	{check_b02wertneg, "Wenn Wert negativ, m\xc3\xbc""ssen f\xc3\xbc""r den VKS-Index negative Werte erlaubt sein"},
	{check_b03wertneg, "Wenn Wert negativ, m\xc3\xbc""ssen f\xc3\xbc""r den EVR-Index negative Werte erlaubt sein"},
	{check_b04wertneg, "Wenn Wert negativ, m\xc3\xbc""ssen f\xc3\xbc""r den QVA-Index negative Werte erlaubt sein"},
	{check_berichtstyp, "Berichtstyp mu\xc3\x9f"" f\xc3\xbc""r Krankenanstalten 'K' und f\xc3\xbc""r Tr\xc3\xa4""ger 'G', 'A' oder 'T'"},
	{check_zuordart, "Zuordnungsart 'D' und 'G' (f\xc3\xbc""r Krankenanstalten kann das Feld leer bleiben)"},
	{check_b02_exists, "Zumindest ein B02-Satz mu\xc3\x9f"" gemeldet werden (nur f\xc3\xbc""r Krankenanstalten)"},
	{check_b04_exists, "Zumindest ein B02-Satz mu\xc3\x9f"" gemeldet werden (nur f\xc3\xbc""r Krankenanstalten)"},
	{check_b05_exists, "Zumindest ein B02-Satz mu\xc3\x9f"" gemeldet werden (nur f\xc3\xbc""r Krankenanstalten)"},
	{check_b06_exists, "Zumindest ein B02-Satz mu\xc3\x9f"" gemeldet werden (nur f\xc3\xbc""r Krankenanstalten)"},
	{check_e01u17, "Wert von QVA-Index E01 mu\xc3\x9f"" mit Wert von Erl\xc3\xb6""sindex U17 \xc3\xbc""bereinstimmen (Toleranz 50)"},
	{check_e02u08, "Wert von QVA-Index E02 mu\xc3\x9f"" mit Wert von Erl\xc3\xb6""sindex U08 \xc3\xbc""bereinstimmen (Toleranz 50)"},
	{check_e03u12, "Wert von QVA-Index E03 mu\xc3\x9f"" mit Wert von Erl\xc3\xb6""sindex U12 \xc3\xbc""bereinstimmen (Toleranz 50)"},
    {check_e04u16, "Wert von QVA-Index E04 mu\xc3\x9f"" mit Wert von Erl\xc3\xb6""sindex U16 \xc3\xbc""bereinstimmen (Toleranz 50)"},
	{check_e05u18, "Wert von QVA-Index E05 mu\xc3\x9f"" mit Wert von Erl\xc3\xb6""sindex U18 \xc3\xbc""bereinstimmen (Toleranz 50)"},
	{check_e11z01, "Wert von QVA-Index E11 mu\xc3\x9f"" mit Zuschu\xc3\x9f""art Z01 (LF, LD, GM, RT, SO) \xc3\xbc""bereinstimmen (Toleranz 50)"},
	{check_e12z02, "Wert von QVA-Index E12 mu\xc3\x9f"" mit Zuschu\xc3\x9f""art Z02 (LF, LD, GM, RT, SO) \xc3\xbc""bereinstimmen (Toleranz 50)"},
	{check_e19z04, "Wert von QVA-Index E19 mu\xc3\x9f"" mit Zuschu\xc3\x9f""art Z04 (LF, LD, GM, RT, SO) \xc3\xbc""bereinstimmen (Toleranz 50)"},
	{check_e28z05, "Wert von QVA-Index E28 mu\xc3\x9f"" mit Zuschu\xc3\x9f""art Z05 (LF, LD, GM, RT, SO) \xc3\xbc""bereinstimmen (Toleranz 50)"},
	{check_e06u19, "Wert von QVA-Index E05 mu\xc3\x9f"" mit Wert von Erl\xc3\xb6""sindex U18 \xc3\xbc""bereinstimmen (Toleranz 50)"},
    {check_e41u22, "Wert von QVA-Index E41 mu\xc3\x9f"" mit Wert von Erl\xc3\xb6""sindex U22 \xc3\xbc""bereinstimmen (Toleranz 50)"},
	{check_v13v18, "VKS-Summe V14 - V18 mu\xc3\x9f"" kleiner-gleich V13 sein"},
	{check_k09k13, "VKS-Summe K10 - K13 mu\xc3\x9f"" kleiner-gleich K09 sein"},
	{check_e01e04, "QVA-Umsatzerl\xc3\xb6""se E1 mu\xc3\x9f"" gleich Summe E02+E03+E04+E41 sein"},
	{check_r01k16, "EVR-Index R01 mu\xc3\x9f"" gleich VKS-Index K16 sein"},
	{check_u01, "Erl\xc3\xb6""se U01: davon LGF mu\xc3\x9f"" kleiner-gleich Gesamt sein"},
	{check_u02, "Erl\xc3\xb6""se U02: davon LGF mu\xc3\x9f"" kleiner-gleich Gesamt sein"},
	{check_u07, "Erl\xc3\xb6""se U07: davon LGF mu\xc3\x9f"" kleiner-gleich Gesamt sein"},
	{check_u09, "Erl\xc3\xb6""se U09: davon LGF mu\xc3\x9f"" kleiner-gleich Gesamt sein"},
	{check_u10, "Erl\xc3\xb6""se U10: davon LGF mu\xc3\x9f"" kleiner-gleich Gesamt sein"},
	{check_u19, "Erl\xc3\xb6""se U19: davon LGF mu\xc3\x9f"" kleiner-gleich Gesamt sein"},
    {check_u22, "Erl\xc3\xb6""se U22: davon LGF mu\xc3\x9f"" kleiner-gleich Gesamt sein"}
};

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

const LKF_SATZART_ERRORCHECK **lkf_get_bericht_general_checks (const LKF_CONTEXT *pContext) {
    if (pContext->modelljahr >= 2025) {
        return GenBerichtChecks2025;
    }
    return GenBerichtChecks;
}
