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

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

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


/*********************************************************************************
** Intensiv-Scoring, Strukturaufbau                                             **
*********************************************************************************/

static LKF_INT_SCORING_ABT *lkf_int_alloc_scoring_abt (LKF_AUFENTHALT *pAufenthalt, LKF_AUFENTHALT_ABT *pAbt, const LKF_INT_AUFENTHALT *pIntAufenthalt)
{
    LKF_CONTEXT *pContext;
    LKF_INT_SCORING_ABT *pIntAbt;
    
    pContext = pAufenthalt->pScoringContext;
    pIntAbt = (LKF_INT_SCORING_ABT *) LKF_MALLOC (pContext, "lkf_int_alloc_scoring_abt", sizeof (LKF_INT_SCORING_ABT));
    if (!pIntAbt) return 0;
	pIntAbt->pAufenthalt = pAufenthalt;
	pIntAbt->pAbt = pAbt;

    if (pAufenthalt->pScoringContext && pAufenthalt->pScoringContext->isBM) {
        pIntAbt->nAlter = (unsigned int) atoi (pAbt->ALTERSGRUPPE);
    } else {
        pIntAbt->nAlter = (unsigned int) Util_Alter_Abteilung(pAufenthalt, pAbt->ABTDAT);
    }

    pIntAbt->nInt11Count = 0;
    pIntAbt->nInt12Count = 0;

    pIntAbt->ppInt11Records = 0;
    pIntAbt->ppInt12Records = 0;
    pIntAbt->ppInt11 = 0;
    pIntAbt->ppInt12 = 0;

#ifdef SUPPORT_PRE2017
	pIntAbt->nInt01Count = 0;
	pIntAbt->nInt02Count = 0;
	pIntAbt->nInt03Count = 0;


	if (pIntAufenthalt->int01_count) pIntAbt->ppInt01Records = (const char **) LKF_CALLOC (sizeof (const char *), pIntAufenthalt->int01_count);
	else pIntAbt->ppInt01Records = 0;	

	if (pIntAufenthalt->int02_count) pIntAbt->ppInt02Records = (const char **) LKF_CALLOC (sizeof (const char *), pIntAufenthalt->int02_count);
	else pIntAbt->ppInt02Records = 0;

	if (pIntAufenthalt->int03_count) pIntAbt->ppInt03Records = (const char **) LKF_CALLOC (sizeof (const char *), pIntAufenthalt->int03_count);
	else pIntAbt->ppInt03Records = 0;

    if (pAufenthalt->pScoringContext->modelljahr >= 2017)
    {
        if (pIntAufenthalt->int11_count)
            pIntAbt->ppInt11 = (LKF_EXPANDED_LINE **) LKF_CALLOC (sizeof (LKF_EXPANDED_LINE *), pIntAufenthalt->int11_count);
        if (pIntAufenthalt->int12_count)
            pIntAbt->ppInt12 = (LKF_EXPANDED_LINE **) LKF_CALLOC (sizeof (LKF_EXPANDED_LINE *), pIntAufenthalt->int12_count);
    }
    else
    {
        if (pIntAufenthalt->int11_count)
            pIntAbt->ppInt11Records = (const char **) LKF_CALLOC (sizeof (const char *), pIntAufenthalt->int11_count);
        if (pIntAufenthalt->int12_count) pIntAbt->ppInt12Records = (const char **) LKF_CALLOC (sizeof (const char *), pIntAufenthalt->int12_count);
    }

#else
    if (pIntAufenthalt->int11_count) {
        pIntAbt->ppInt11 = (LKF_EXPANDED_LINE **) LKF_CALLOC (pContext, "lkf_int_alloc_scoring_abt.int11", pIntAufenthalt->int11_count, sizeof (LKF_EXPANDED_LINE *));
        if (!pIntAbt->ppInt11) {
            LKF_FREE(pContext, "lkf_int_alloc_scoring_abt", pIntAbt);
            return 0;
        }
    }
    if (pIntAufenthalt->int12_count) {
        pIntAbt->ppInt12 = (LKF_EXPANDED_LINE **) LKF_CALLOC (pContext, "lkf_int_alloc_scoring_abt.int12", pIntAufenthalt->int12_count, sizeof (LKF_EXPANDED_LINE *));
        if (!pIntAbt->ppInt12) {
            if (pIntAbt->ppInt11) LKF_FREE (pContext, "lkf_int_alloc_scoring_abt.int11", pIntAbt->ppInt11);
            LKF_FREE(pContext, "lkf_int_alloc_scoring_abt", pIntAbt);
            return 0;
        }
    }
#endif
        

	pIntAbt->pInt01Results = 0;
	pIntAbt->pInt02Results = 0;
	pIntAbt->pInt03Results = 0;

	pIntAbt->nInt01ResultCount = 0;
	pIntAbt->nInt02ResultCount = 0;
	pIntAbt->nInt03ResultCount = 0;


	return pIntAbt;
}

#ifdef SUPPORT_PRE2017
static int sort_intsatz (const void *s1, const void *s2)
{
	return memcmp (*((const char **) s1) + 22, *((const char **) s2) + 22, 8);
}


static void lkf_sort_scoring_abt (LKF_INT_SCORING *pIntScoring, LKF_INT_SCORING_ABT *pIntAbt)
{

	if (pIntAbt->nInt02Count && pIntAbt->ppInt02Records)
	{
		qsort ((void *)pIntAbt->ppInt02Records, pIntAbt->nInt02Count, sizeof (const char *), sort_intsatz);
	}

	if (pIntAbt->nInt12Count && pIntAbt->ppInt12Records)
		qsort ((void *)pIntAbt->ppInt12Records, pIntAbt->nInt12Count, sizeof (const char *), sort_intsatz);
}
#endif
static int sort_intsatz_2018 (const void *s1, const void *s2)
{
    
    const LKF_EXPANDED_LINE **l1 = (const LKF_EXPANDED_LINE **) s1;
    const LKF_EXPANDED_LINE **l2 = (const LKF_EXPANDED_LINE **) s2;
    
    return memcmp ((*l1)->fieldsById[GEN_ERHEBDAT], (*l2)->fieldsById[GEN_ERHEBDAT], 8);
}

static void lkf_sort_scoring_abt_2018 (LKF_INT_SCORING *pIntScoring, LKF_INT_SCORING_ABT *pIntAbt)
{
    if (pIntAbt->nInt11Count && pIntAbt->ppInt11)
        qsort ((void *)pIntAbt->ppInt11, pIntAbt->nInt11Count, sizeof (const char *), sort_intsatz_2018);
    if (pIntAbt->nInt12Count && pIntAbt->ppInt12)
        qsort ((void *)pIntAbt->ppInt12, pIntAbt->nInt12Count, sizeof (const char *), sort_intsatz_2018);
    
}

static LKF_INT_SCORING_ABT *lkf_add_scoring_abt_2017 (LKF_INT_SCORING *pIntScoring, LKF_INT_SCORING_ABT *pSource)
{
    LKF_INT_SCORING_ABT *pDest;
    LKF_CONTEXT *pContext;
    
    pContext = pIntScoring->pContext;
    
    if (pIntScoring->nAbtAlloc == pIntScoring->nAbtCount) {
        pDest = pIntScoring->pAbt;
        pIntScoring->nAbtAlloc += ABTCOUNT_EXTEND;
        pIntScoring->pAbt = (LKF_INT_SCORING_ABT *) LKF_CALLOC (pContext, "lkf_add_scoring_abt_2017", pIntScoring->nAbtAlloc, sizeof (LKF_INT_SCORING_ABT));
		if (pIntScoring->pAbt == 0) {
			pIntScoring->nAbtAlloc = 0;
            if (pDest) LKF_FREE (pContext, "lkf_add_scoring_abt_2017", pDest);
			return 0;
		}
        if (pDest) {
            memcpy (pIntScoring->pAbt, pDest, sizeof (LKF_INT_SCORING_ABT) * pIntScoring->nAbtCount);
            LKF_FREE (pContext, "lkf_add_scoring_abt_2017", pDest);
        }
    }
    
    pDest = pIntScoring->pAbt + pIntScoring->nAbtCount++;
    
    memcpy (pDest, pSource, sizeof (LKF_INT_SCORING_ABT));

#ifdef SUPPORT_PRE2017
    if (pDest->nInt01Count) {
        pDest->ppInt01Records = (const char **) LKF_MALLOC (sizeof (const char *) * pDest->nInt01Count);
        memcpy ((void *) pDest->ppInt01Records, pSource->ppInt01Records, sizeof (const char *) * pDest->nInt01Count);
    }
    else pDest->ppInt01Records = 0;
    
    if (pDest->nInt02Count) {
        pDest->ppInt02Records = (const char **) LKF_MALLOC (sizeof (const char *) * pDest->nInt02Count);
        memcpy ((void *) pDest->ppInt02Records, pSource->ppInt02Records, sizeof (const char *) * pDest->nInt02Count);
    }
    else pDest->ppInt02Records = 0;
    
    if (pDest->nInt03Count) {
        pDest->ppInt03Records = (const char **) LKF_MALLOC (sizeof (const char *) * pDest->nInt03Count);
        memcpy ((void *) pDest->ppInt03Records, pSource->ppInt03Records, sizeof (const char *) * pDest->nInt03Count);
    }
    else pDest->ppInt03Records = 0;
#endif
    
    if (pDest->nInt11Count) {
        pDest->ppInt11 = (LKF_EXPANDED_LINE **) LKF_MALLOC (pContext, "lkf_add_scoring_abt_2017.i11", sizeof (LKF_EXPANDED_LINE *) * pDest->nInt11Count);
        if (pDest->ppInt11 == 0) {
            pDest->ppInt12 = 0;
			pDest->nInt11Count = pDest->nInt12Count = 0;
            return 0;
        }
        memcpy ((void *) pDest->ppInt11, pSource->ppInt11, sizeof (const char *) * pDest->nInt11Count);
    }
    else pDest->ppInt11 = 0;
    
    if (pDest->nInt12Count) {
        pDest->ppInt12 = (LKF_EXPANDED_LINE **) LKF_MALLOC (pContext, "lkf_add_scoring_abt_2017.i12", sizeof (LKF_EXPANDED_LINE *) * pDest->nInt12Count);
		if (pDest->ppInt12 == 0) {
			pDest->nInt12Count = 0;
			return 0;
		}
        memcpy ((void *) pDest->ppInt12, pSource->ppInt12, sizeof (const char *) * pDest->nInt12Count);
    }
    else pDest->ppInt12 = 0;
    
    pDest->ppInt11Records = 0;
    pDest->ppInt12Records = 0;
    
    return pDest;
}

#ifdef SUPPORT_PRE2017
static LKF_INT_SCORING_ABT *lkf_add_scoring_abt (LKF_INT_SCORING *pIntScoring, LKF_INT_SCORING_ABT *pSource)
{
	LKF_INT_SCORING_ABT *pDest;
    LKF_CONTEXT *pContext;
    
    pContext = pIntScoring->pContext;
	
	if (pIntScoring->nAbtAlloc == pIntScoring->nAbtCount) {
		pDest = pIntScoring->pAbt;
		pIntScoring->nAbtAlloc += ABTCOUNT_EXTEND;
		pIntScoring->pAbt = (LKF_INT_SCORING_ABT *) LKF_CALLOC (pContext, "lkf_add_scoring_abt", pIntScoring->nAbtAlloc, sizeof (LKF_INT_SCORING_ABT));
        if (!pIntScoring->pAbt) {
            if (pDest) LKF_FREE(pContext, "lkf_add_scoring_abt", pDest);
            return 0;
        }
		if (pDest) {
			memcpy (pIntScoring->pAbt, pDest, sizeof (LKF_INT_SCORING_ABT) * pIntScoring->nAbtCount);
			LKF_FREE (pContext, "lkf_add_scoring_abt", pDest);
		}
	}

	pDest = pIntScoring->pAbt + pIntScoring->nAbtCount++;

	memcpy (pDest, pSource, sizeof (LKF_INT_SCORING_ABT));


	if (pDest->nInt01Count) {
		pDest->ppInt01Records = (const char **) LKF_MALLOC (sizeof (const char *) * pDest->nInt01Count);
		memcpy ((void *) pDest->ppInt01Records, pSource->ppInt01Records, sizeof (const char *) * pDest->nInt01Count);
	}
	else pDest->ppInt01Records = 0;

	if (pDest->nInt02Count) {
		pDest->ppInt02Records = (const char **) LKF_MALLOC (sizeof (const char *) * pDest->nInt02Count);
		memcpy ((void *) pDest->ppInt02Records, pSource->ppInt02Records, sizeof (const char *) * pDest->nInt02Count);
	}
	else pDest->ppInt02Records = 0;

	if (pDest->nInt03Count) {
		pDest->ppInt03Records = (const char **) LKF_MALLOC (sizeof (const char *) * pDest->nInt03Count);
		memcpy ((void *) pDest->ppInt03Records, pSource->ppInt03Records, sizeof (const char *) * pDest->nInt03Count);
	}
	else pDest->ppInt03Records = 0;
    
	if (pDest->nInt11Count) {
		pDest->ppInt11Records = (const char **) LKF_MALLOC (pContext, "lkf_add_scoring_abt.i11", sizeof (const char *) * pDest->nInt11Count);
        if (pDest->ppInt11Records) {
            memcpy ((void *) pDest->ppInt11Records, pSource->ppInt11Records, sizeof (const char *) * pDest->nInt11Count);
        }
	}
	else pDest->ppInt11Records = 0;

	if (pDest->nInt12Count) {
		pDest->ppInt12Records = (const char **) LKF_MALLOC (pContext, "lkf_add_scoring_abt.i12", sizeof (const char *) * pDest->nInt12Count);
        if (pDest->ppInt12Records) {
            memcpy ((void *) pDest->ppInt12Records, pSource->ppInt12Records, sizeof (const char *) * pDest->nInt12Count);
        }
	}
	else pDest->ppInt12Records = 0;

    pDest->ppInt11 = 0;
    pDest->ppInt12 = 0;

    
	return pDest;
}
#endif

static void lkf_int_free_scoring_abt (LKF_CONTEXT *pContext, LKF_INT_SCORING_ABT *pAbt, int delete_this)
{
	if (pAbt) {
#ifdef SUPPORT_PRE2017
		if (pAbt->ppInt01Records) LKF_FREE ((void *) pAbt->ppInt01Records);
		if (pAbt->ppInt02Records) LKF_FREE ((void *) pAbt->ppInt02Records);
		if (pAbt->ppInt03Records) LKF_FREE ((void *) pAbt->ppInt03Records);
#endif
		if (pAbt->ppInt11Records) LKF_FREE (pContext, "lkf_int_free_scoring_abt.i11r", (void *) pAbt->ppInt11Records);
		if (pAbt->ppInt12Records) LKF_FREE (pContext, "lkf_int_free_scoring_abt.i11r", (void *) pAbt->ppInt12Records);

        if (pAbt->ppInt11) LKF_FREE (pContext, "lkf_int_free_scoring_abt.i11", (void *) pAbt->ppInt11);
        if (pAbt->ppInt12) LKF_FREE (pContext, "lkf_int_free_scoring_abt.i12", (void *) pAbt->ppInt12);
        
		if (pAbt->pInt01Results) LKF_FREE (pContext, "lkf_int_free_scoring_abt.r1", pAbt->pInt01Results);
		if (pAbt->pInt03Results) LKF_FREE (pContext, "lkf_int_free_scoring_abt.r3", pAbt->pInt03Results);
		if (pAbt->pInt02Results) LKF_FREE (pContext, "lkf_int_free_scoring_abt.r2", pAbt->pInt02Results);

		if (delete_this) LKF_FREE (pContext, "lkf_int_free_scoring_abt", pAbt);
	}
}


static unsigned int lkf_getMonat (const char *datum, const char *jahr)
{
	if (!memcmp (datum, jahr, 4)) 
	{
		if (datum[4] == '0') {
			if (datum[5] >= '1' && datum[5] <= '9') return (unsigned int ) (datum[5] - '0');
		}
		else if (datum[4] == '1') {
			if (datum[5] >= '0' && datum[5] <= '2') return (unsigned int) (10 + (datum[5] - '0'));
		}
	}
	return 0;
}

static int cmp_LKF_INT_SCORING_ABT (const void *a1, const void *a2)
{
	int c;
	const LKF_INT_SCORING_ABT *pAbt1 = (LKF_INT_SCORING_ABT *) a1;
	const LKF_INT_SCORING_ABT *pAbt2 = (LKF_INT_SCORING_ABT *) a2;

	c = memcmp (pAbt1->pAufenthalt->KANR, pAbt2->pAufenthalt->KANR, 4);
	if (!c) c = memcmp (pAbt1->pAbt->ABTFC, pAbt2->pAbt->ABTFC, 8);
	if (!c) c = memcmp (pAbt1->pAbt->ABTDAT, pAbt2->pAbt->ABTDAT, 8);
	if (!c) c = memcmp (pAbt1->pAufenthalt->UCASE_PATID, pAbt2->pAufenthalt->UCASE_PATID, 10);
	return c;
}

int lkf_int_alloc_structure_aufenthalt_2017 (LKF_CONTEXT *pContext, LKF_AUFENTHALT *pAufenthalt, LKF_INT_SCORING *pIntScoring) {
    LKF_INT_AUFENTHALT *pIntAufenthalt;
    LKF_INT_SCORING_ABT **ppIntAbtData;
    const SATZART_FELD *pAbtPosFeld;
    unsigned int j, satzart;
    LKF_EXPANDED_LINE **ppCurExpandedLines = 0;
    unsigned int cur_count;
    
    char lastpos[6], actpos[6];
    int actindex, lastindex;
    
    if (pAufenthalt->pIntAufenthalt) lkf_int_free_aufenthalt (pAufenthalt->pScoringContext, pAufenthalt->pIntAufenthalt);
    pIntAufenthalt = (LKF_INT_AUFENTHALT *) LKF_MALLOC (pContext, "lkf_int_alloc_structure_aufenthalt_2017", sizeof (LKF_INT_AUFENTHALT));
	if (pIntAufenthalt == 0) {
		pAufenthalt->pIntAufenthalt = 0;
		return LKF_OUTOFMEMORY_ERROR;
	}
    pAufenthalt->pIntAufenthalt = pIntAufenthalt;
    
#ifdef SUPPORT_PRE2017
    pIntAufenthalt->int01_count = 0;
    pIntAufenthalt->int02_count = 0;
    pIntAufenthalt->int03_count = 0;
    pIntAufenthalt->ppInt01Records = 0;
    pIntAufenthalt->ppInt02Records = 0;
    pIntAufenthalt->ppInt03Records = 0;
#endif
    pIntAufenthalt->ppInt11Records = 0;
    pIntAufenthalt->ppInt12Records = 0;

	pIntAufenthalt->ppAbt = 0;
    pIntAufenthalt->int11_count = Satzart_GetExpandedLines (pAufenthalt->pIntensiv, "I11", &(pIntAufenthalt->ppInt11));
    if (pIntAufenthalt->int11_count == LKF_OUTOFMEMORY_UINTERROR) {
        pIntAufenthalt->int11_count = 0;
        return LKF_OUTOFMEMORY_ERROR;
    }
    pIntAufenthalt->int12_count = Satzart_GetExpandedLines (pAufenthalt->pIntensiv, "I12", &(pIntAufenthalt->ppInt12));
    if (pIntAufenthalt->int12_count == LKF_OUTOFMEMORY_UINTERROR) {
        pIntAufenthalt->int12_count = 0;
        return LKF_OUTOFMEMORY_ERROR;
    }
    
    
    if (pIntAufenthalt->int11_count || pIntAufenthalt->int12_count) {
        
        ppIntAbtData = (LKF_INT_SCORING_ABT **) LKF_CALLOC (pContext, "lkf_int_alloc_structure_aufenthalt_2017.abt", pAufenthalt->abt_anz, sizeof (LKF_INT_SCORING_ABT *));
		if (ppIntAbtData == 0) {
			LKF_FREE(pContext, "lkf_int_alloc_structure_aufenthalt_2017", pIntAufenthalt);
			pAufenthalt->pIntAufenthalt = 0;
			return LKF_OUTOFMEMORY_ERROR;
		}
        pIntAufenthalt->ppAbt = ppIntAbtData;
        pIntAufenthalt->abt_count = pAufenthalt->abt_anz;
        
        lastindex = -1;
        memset (lastpos, 0, LKF_AUFENTHALT_ABTPOS_LEN_2017);
        
        for (satzart = 0; satzart < 2; satzart++)
        {
            cur_count = 0;
            ppCurExpandedLines = 0;
            pAbtPosFeld = 0;
            
            switch (satzart)
            {
                case 0:
                    cur_count = pIntAufenthalt->int11_count;
                    pAbtPosFeld = pIntScoring->pInt11->ppRef[GEN_ABTPOS];
                    ppCurExpandedLines = pIntAufenthalt->ppInt11;
                    break;
                case 1:
                    cur_count = pIntAufenthalt->int12_count;
                    pAbtPosFeld = pIntScoring->pInt11->ppRef[GEN_ABTPOS];
                    ppCurExpandedLines = pIntAufenthalt->ppInt12;
                    break;
                default:
                    break;
            }
            
            for (j = 0; j < cur_count; j++)
            {
                Satzart_GetValueStringExp (ppCurExpandedLines[j], pAbtPosFeld, actpos, LKF_AUFENTHALT_ABTPOS_LEN_2017 + 1); /* V2019.4 */
                if (memcmp (actpos, lastpos, LKF_AUFENTHALT_ABTPOS_LEN_2017))
                {
                    actindex = lkf_auf_getidfrompos_2017 (pAufenthalt, actpos);
                    if (actindex >= 0)
                    {
                        memcpy (lastpos, actpos, LKF_AUFENTHALT_ABTPOS_LEN_2017);
                        lastindex = actindex;
                    }
                    else {
                        /* sollte FATG beim Import liefern (ab 2021.2) */
                    }
                }
                else actindex = lastindex;
                
                if (actindex >= 0)
                {
                    if (!ppIntAbtData[actindex])
                    {
                        ppIntAbtData[actindex] = lkf_int_alloc_scoring_abt (pAufenthalt, pAufenthalt->abt + actindex, pIntAufenthalt);
                        if (!ppIntAbtData[actindex] && *pContext->outOfMemory) {
                            return LKF_OUTOFMEMORY_ERROR;
                        }
                    }
                    switch (satzart)
                    {
                        case 0:
                            ppIntAbtData[actindex]->ppInt11[ppIntAbtData[actindex]->nInt11Count++] = ppCurExpandedLines[j];
                            break;
                        case 1:
                            ppIntAbtData[actindex]->ppInt12[ppIntAbtData[actindex]->nInt12Count++] = ppCurExpandedLines[j];
                            break;
                        default:
                            break;
                    }
                }
                else 
                {
                    /* Error-Handling */ 
                }
            }
        }
        
        for (j = 0; j < pAufenthalt->abt_anz; j++) 
        {
            if (ppIntAbtData[j]) 
            {
                lkf_sort_scoring_abt_2018 (pIntScoring, ppIntAbtData[j]);
				if (!lkf_add_scoring_abt_2017(pIntScoring, ppIntAbtData[j])) {
					return LKF_OUTOFMEMORY_ERROR;
				}
            }
        }
    }
    else 
    {
        pIntAufenthalt->abt_count = 0;
        pIntAufenthalt->ppAbt = 0;
    }
	return 0;
}

int lkf_int_alloc_structure_2017 (LKF_CONTEXT *pContext)
{
    LKF_INT_SCORING *pIntScoring;
    LKF_INT_SCORING_ABT *pAbt;
    const LKF_SATZART_DEFS *pSatzartDefs;
    unsigned int i;
    int ret;
    char sAbrJahr[5];
    
    sprintf (sAbrJahr, "%4d", pContext->cmb_jahr);
    
    /* Satzart-Definitionen laden */
    pSatzartDefs = SatzartDef_Init (pContext->modelljahr);
    if (!pSatzartDefs) return 1;
    
    /* Struktur anlegen */
    pIntScoring = (LKF_INT_SCORING *) LKF_MALLOC (pContext, "lkf_int_alloc_structure_2017", sizeof(LKF_INT_SCORING));
	if (pIntScoring == 0) return LKF_OUTOFMEMORY_ERROR;
	
    pContext->pIntScoring = pIntScoring;
    pIntScoring->pContext = pContext;
    

    pIntScoring->pInt01 = 0;
    pIntScoring->pInt02 = 0;
    pIntScoring->pInt03 = 0;
    pIntScoring->pInt11 = Satzart_GetSatzart (pSatzartDefs, "I11");
    pIntScoring->pInt12 = Satzart_GetSatzart (pSatzartDefs, "I12");
    pIntScoring->pM02 = 0;

    pIntScoring->nAbtAlloc = ABTCOUNT_INITIAL;
    pIntScoring->nAbtCount = 0;
    pIntScoring->pAbt = (LKF_INT_SCORING_ABT *) LKF_CALLOC (pContext, "lkf_int_alloc_structure_2017.abt", sizeof(LKF_INT_SCORING_ABT), pIntScoring->nAbtAlloc);
	if (pIntScoring->pAbt == 0) {
		LKF_FREE(pContext, "lkf_int_alloc_structure_2017", pIntScoring);
		pContext->pIntScoring = 0;
		return LKF_OUTOFMEMORY_ERROR;
	}
    pIntScoring->pIntAbt = 0;       /* V14.0 */
    pIntScoring->nIntAbtCount = 0;  /* V14.0 */
    
    for (i = 0; i < pContext->patient_anz; i++) {
        ret = lkf_int_alloc_structure_aufenthalt_2017 (pContext, pContext->ppAufenthalt[i], pIntScoring);
        if (ret == LKF_OUTOFMEMORY_ERROR) return ret;
    }
    /* Berechnung von Feldern innerhalb der Abteilungssätze */
    for (i = 0; i < pIntScoring->nAbtCount; i++)
    {
        pAbt = pIntScoring->pAbt + i;
        
        pAbt->nStartDatum = (int) lkf_dat2int (pAbt->pAbt->ABTDAT);
        pAbt->nEndDatum = (int) lkf_dat2int (pAbt->pAbt->ENTDAT);
        
        if (pAbt->nEndDatum)
        {
            pAbt->nMonat = lkf_getMonat (pAbt->pAbt->ENTDAT, sAbrJahr);
        }
        else pAbt->nMonat = 0;
        
        if (pAbt->nStartDatum > 0 && pAbt->nStartDatum == pAbt->nEndDatum)
        {
            /* Berechnung des Aufenthalts in Stunden */
            char vonzeit[5], biszeit[5];
            sprintf(vonzeit, "%4.4s", pAbt->pAbt->ABTZEIT);
            sprintf(biszeit, "%4.4s", pAbt->pAbt->ENTZEIT);
            pAbt->nStunden = (unsigned int) ((atoi(biszeit) - atoi(vonzeit)) / 100);
        }
        else pAbt->nStunden = 99;
    }
    
    /* Default-Werte für Int-Scoring-Parameter */
    pIntScoring->bCompleteTiss = 0;
    pIntScoring->nMindestStd = 0;
    sprintf (pIntScoring->dStartDatum, "%4.4d0101", pContext->cmb_jahr);
    sprintf (pIntScoring->dEndDatum, "%4.4d1231", pContext->cmb_jahr);
    pContext->pIntScoring = pIntScoring;
	return 0;
}

#ifdef SUPPORT_PRE2017
void lkf_int_alloc_structure_aufenthalt (LKF_CONTEXT *pContext, LKF_AUFENTHALT *pAufenthalt, LKF_INT_SCORING *pIntScoring)
{
    LKF_INT_AUFENTHALT *pIntAufenthalt;
	LKF_INT_SCORING_ABT **ppIntAbtData;
	const SATZART_FELD *pAbtPosFeld;
	unsigned int j, satzart;
    const char **ppCurRecords;
	unsigned int cur_count;

	char lastpos[2], actpos[2];
	int actindex, lastindex;

	if (pAufenthalt->pIntAufenthalt) lkf_int_free_aufenthalt (pAufenthalt->pScoringContext, pAufenthalt->pIntAufenthalt);
	pIntAufenthalt = (LKF_INT_AUFENTHALT *) LKF_MALLOC (sizeof (LKF_INT_AUFENTHALT));
	pAufenthalt->pIntAufenthalt = pIntAufenthalt;

	/* Daten der verschiedenen Typen ermitteln */

    if (pContext->modelljahr < 2012)
	{
		pIntAufenthalt->int01_count = Satzart_GetLinesAlloc (pAufenthalt->pLineBuffer, pIntScoring->pInt01->pSatzart, &(pIntAufenthalt->ppInt01Records));
		pIntAufenthalt->int02_count = Satzart_GetLinesAlloc (pAufenthalt->pLineBuffer, pIntScoring->pInt02->pSatzart, &(pIntAufenthalt->ppInt02Records));
		pIntAufenthalt->int03_count = Satzart_GetLinesAlloc (pAufenthalt->pLineBuffer, pIntScoring->pInt03->pSatzart, &(pIntAufenthalt->ppInt03Records));
	}
	else
	{ /* V16.0 */
		pIntAufenthalt->int01_count = 0;
		pIntAufenthalt->int02_count = 0;
		pIntAufenthalt->int03_count = 0;
		pIntAufenthalt->ppInt01Records = 0;
		pIntAufenthalt->ppInt02Records = 0;
		pIntAufenthalt->ppInt03Records = 0;
	}
    
    if (pContext->modelljahr >= 2011)
	{
		pIntAufenthalt->int11_count = Satzart_GetLinesAlloc (pAufenthalt->pLineBuffer, pIntScoring->pInt11->pSatzart, &(pIntAufenthalt->ppInt11Records));
		pIntAufenthalt->int12_count = Satzart_GetLinesAlloc (pAufenthalt->pLineBuffer, pIntScoring->pInt12->pSatzart, &(pIntAufenthalt->ppInt12Records));
	}
	else
	{
		pIntAufenthalt->int11_count = 0;
		pIntAufenthalt->int12_count = 0;
		pIntAufenthalt->ppInt11Records = 0; /* V15.2 */
		pIntAufenthalt->ppInt12Records = 0; /* V15.2 */
	}
    
    pIntAufenthalt->ppInt11 = 0;
    pIntAufenthalt->ppInt12 = 0;
	pIntAufenthalt->ppAbt = 0;

	if (pIntAufenthalt->int01_count || pIntAufenthalt->int02_count || pIntAufenthalt->int03_count
									|| pIntAufenthalt->int11_count || pIntAufenthalt->int12_count) 

    {

		ppIntAbtData = (LKF_INT_SCORING_ABT **) LKF_CALLOC (sizeof (LKF_INT_SCORING_ABT *), pAufenthalt->abt_anz);
		pIntAufenthalt->ppAbt = ppIntAbtData;
		pIntAufenthalt->abt_count = pAufenthalt->abt_anz;
		
		lastindex = -1;
		memset (lastpos, 0, LKF_AUFENTHALT_ABTPOS_LEN);
		
		for (satzart = 0; satzart < 5; satzart++) 
		{
			cur_count = 0;
			ppCurRecords = 0;
			pAbtPosFeld = 0;

			switch (satzart) 
			{
				case 0:
					if (pContext->modelljahr < 2012)
					{
						cur_count = pIntAufenthalt->int01_count;
						ppCurRecords = pIntAufenthalt->ppInt01Records;
						pAbtPosFeld = pIntScoring->pInt01->ppRef[GEN_ABTPOS];
					}
					break;
				case 1:
					if (pContext->modelljahr < 2012)
					{
						cur_count = pIntAufenthalt->int02_count;
						ppCurRecords = pIntAufenthalt->ppInt02Records;
						pAbtPosFeld = pIntScoring->pInt02->ppRef[GEN_ABTPOS];
					}
					break;
				case 2:
					if (pContext->modelljahr < 2012)
					{
						cur_count = pIntAufenthalt->int03_count;
						ppCurRecords = pIntAufenthalt->ppInt03Records;
						pAbtPosFeld = pIntScoring->pInt03->ppRef[GEN_ABTPOS];
					}
					break;
				case 3:
                    if (pContext->modelljahr >= 2011)
					{
                        cur_count = pIntAufenthalt->int11_count;
                        pAbtPosFeld = pIntScoring->pInt11->ppRef[GEN_ABTPOS];
						ppCurRecords = pIntAufenthalt->ppInt11Records;
					}
					break;
				case 4:
                    if (pContext->modelljahr >= 2011)
					{
                        cur_count = pIntAufenthalt->int12_count;
                        pAbtPosFeld = pIntScoring->pInt11->ppRef[GEN_ABTPOS];
						ppCurRecords = pIntAufenthalt->ppInt12Records;
					}
					break;
                default:
                    break;
			}

			for (j = 0; j < cur_count; j++) 
			{
				Satzart_GetValueString (ppCurRecords[j], (unsigned int) strlen(ppCurRecords[j]), pAbtPosFeld, actpos, LKF_AUFENTHALT_ABTPOS_LEN);
				if (memcmp (actpos, lastpos, LKF_AUFENTHALT_ABTPOS_LEN)) 
				{
					actindex = lkf_auf_getidfrompos (pAufenthalt, actpos);
					if (actindex >= 0) 
					{
						memcpy (lastpos, actpos, LKF_AUFENTHALT_ABTPOS_LEN);
						lastindex = actindex;
					}
				}
				else actindex = lastindex;

				if (actindex >= 0) 
				{
					if (!ppIntAbtData[actindex]) 
					{
						ppIntAbtData[actindex] = lkf_int_alloc_scoring_abt (pAufenthalt, pAufenthalt->abt + actindex, pIntAufenthalt);
					}
					switch (satzart) 
					{
						case 0:
							ppIntAbtData[actindex]->ppInt01Records[ppIntAbtData[actindex]->nInt01Count++] = ppCurRecords[j];
							break;						
						case 1:
							ppIntAbtData[actindex]->ppInt02Records[ppIntAbtData[actindex]->nInt02Count++] = ppCurRecords[j];
							break;
						case 2:
							ppIntAbtData[actindex]->ppInt03Records[ppIntAbtData[actindex]->nInt03Count++] = ppCurRecords[j];
							break;
						case 3:
							if (pContext->modelljahr >= 2011)
								ppIntAbtData[actindex]->ppInt11Records[ppIntAbtData[actindex]->nInt11Count++] = ppCurRecords[j];
							break;
						case 4:
							if (pContext->modelljahr >= 2011)
								ppIntAbtData[actindex]->ppInt12Records[ppIntAbtData[actindex]->nInt12Count++] = ppCurRecords[j];
							break;
                        default:
                            break;
					}
				}
				else 
				{
					/* Error-Handling */ 
				}
			}
		}

		for (j = 0; j < pAufenthalt->abt_anz; j++) 
		{
			if (ppIntAbtData[j]) 
			{
				lkf_sort_scoring_abt (pIntScoring, ppIntAbtData[j]);
				lkf_add_scoring_abt (pIntScoring, ppIntAbtData[j]);
			}
		}
	}
	else 
	{
		pIntAufenthalt->abt_count = 0;
		pIntAufenthalt->ppAbt = 0;
	}
}

void lkf_int_alloc_structure (LKF_CONTEXT *pContext)
{
	LKF_INT_SCORING *pIntScoring;
	LKF_INT_SCORING_ABT *pAbt;
	const LKF_SATZART_DEFS *pSatzartDefs;
	const SATZART_FELD *pDatFeld, *pVonZeitFeld, *pBisZeitFeld;
	unsigned int i;
	unsigned int line_len; 
	char sAbrJahr[5];

	sprintf (sAbrJahr, "%4d", pContext->cmb_jahr);

	/* Satzart-Definitionen laden */
	pSatzartDefs = SatzartDef_Init (pContext->modelljahr);
	if (!pSatzartDefs) return;

	/* Struktur anlegen */
	pIntScoring = (LKF_INT_SCORING *) LKF_MALLOC (sizeof(LKF_INT_SCORING));
	pContext->pIntScoring = pIntScoring;
	pIntScoring->pContext = pContext;

	if (pContext->modelljahr < 2012)
	{
		pIntScoring->pInt01 = Satzart_GetSatzart (pSatzartDefs, "I01");
		pIntScoring->pInt02 = Satzart_GetSatzart (pSatzartDefs, "I02");
		pIntScoring->pInt03 = Satzart_GetSatzart (pSatzartDefs, "I03");
	}
	else
	{
		pIntScoring->pInt01 = 0; /* V16.0 */
		pIntScoring->pInt02 = 0; /* V16.0 */
		pIntScoring->pInt03 = 0; /* V16.0 */
	}
	if (pContext->modelljahr >= 2011)
	{ /* V15.1 */
		pIntScoring->pInt11 = Satzart_GetSatzart (pSatzartDefs, "I11");
		pIntScoring->pInt12 = Satzart_GetSatzart (pSatzartDefs, "I12");
	}
	else
	{
		pIntScoring->pInt11 = 0;
		pIntScoring->pInt12 = 0;
	}

	if (pContext->flags  & LKFCONTEXT_NICHTFONDSKA)
		pIntScoring->pM02 = Satzart_GetSatzart (pSatzartDefs, "M02NF");
	else
		pIntScoring->pM02 = Satzart_GetSatzart (pSatzartDefs, "M02");
	pIntScoring->nAbtAlloc = ABTCOUNT_INITIAL;
	pIntScoring->nAbtCount = 0;
	pIntScoring->pAbt = (LKF_INT_SCORING_ABT *) LKF_CALLOC (sizeof(LKF_INT_SCORING_ABT), pIntScoring->nAbtAlloc); 

	pIntScoring->pIntAbt = 0;       /* V14.0 */
	pIntScoring->nIntAbtCount = 0;  /* V14.0 */

	/* Aufbau der Strukturen pro Aufenthalt V9.2 - eigene Funktion */
	
    for (i = 0; i < pContext->patient_anz; i++)
        lkf_int_alloc_structure_aufenthalt (pContext, pContext->ppAufenthalt[i], pIntScoring);
    pDatFeld =     pIntScoring->pM02->ppRef[M02_ABGANGSDATUM];
    pVonZeitFeld = pIntScoring->pM02->ppRef[M02_ZUGANGSUHRZEIT];
    pBisZeitFeld = pIntScoring->pM02->ppRef[M02_ABGANGSUHRZEIT];

	/* Berechnung von Feldern innerhalb der Abteilungssätze */
	for (i = 0; i < pIntScoring->nAbtCount; i++)
	{
		pAbt = pIntScoring->pAbt + i;
		line_len = (unsigned int) strlen (pAbt->pAbt->ABT_INTSATZ);
		Satzart_GetValueString (pAbt->pAbt->ABT_INTSATZ, line_len, pDatFeld, pAbt->DISDATE, 8);

		pAbt->nStartDatum = (int) lkf_dat2int (pAbt->pAbt->ABTDAT);
		pAbt->nEndDatum = (int) lkf_dat2int (pAbt->DISDATE);

		if (pAbt->nEndDatum) 
		{
			pAbt->nMonat = lkf_getMonat (pAbt->DISDATE, sAbrJahr); 
		}
		else pAbt->nMonat = 0;
		
		if (pAbt->nStartDatum > 0 && pAbt->nStartDatum == pAbt->nEndDatum) 
		{
			/* Berechnung des Aufenthalts in Stunden */
			int vonzeit, biszeit;
			Satzart_GetValueInt (pAbt->pAbt->ABT_INTSATZ, line_len, pVonZeitFeld, &vonzeit);
			Satzart_GetValueInt (pAbt->pAbt->ABT_INTSATZ, line_len, pBisZeitFeld, &biszeit);
			pAbt->nStunden = (unsigned int) ((biszeit - vonzeit) / 100);
		}
		else pAbt->nStunden = 99;
	}

	/* Default-Werte für Int-Scoring-Parameter */
	pIntScoring->bCompleteTiss = 0;
	pIntScoring->nMindestStd = 0;
	sprintf (pIntScoring->dStartDatum, "%4.4d0101", pContext->cmb_jahr);
	sprintf (pIntScoring->dEndDatum, "%4.4d1231", pContext->cmb_jahr);
	pContext->pIntScoring = pIntScoring;
}
#endif

int lkf_int_analyse (LKF_CONTEXT *pContext)
{
	LKF_INT_SCORING *pIntScoring;
	LKF_INTABT *pIntAbt;
	LKF_AUFENTHALT *pAufenthalt;
	char ABTFC[8];
	char KANR[4];
	unsigned int i, j = 0, k;

	memset (ABTFC, 0, 8);

	pIntScoring = pContext->pIntScoring;
	pIntScoring->nIntAbtCount = 0;

	if (pIntScoring->nAbtCount) 
	{
		/* Sortierung der pAbt-Saetze */	
		qsort (pIntScoring->pAbt, pIntScoring->nAbtCount, sizeof (LKF_INT_SCORING_ABT), cmp_LKF_INT_SCORING_ABT);
		
		/* Feststellung der Anzahl der Intensivabteilungen */
		for (i = 0; i < pIntScoring->nAbtCount; i++)
		{
			if (!i || memcmp (pIntScoring->pAbt[i].pAbt->ABTFC, ABTFC, 8) || memcmp (pIntScoring->pAbt[i].pAufenthalt->KANR, KANR, 4)) 
			{
				pIntScoring->nIntAbtCount++;
				memcpy (ABTFC, pIntScoring->pAbt[i].pAbt->ABTFC, 8);
			}
		}

		/* Aufbau der Abteilungsspezifischen Informationen */
		pIntScoring->pIntAbt = LKF_CALLOC (pContext, "lkf_int_analyse", pIntScoring->nIntAbtCount, sizeof (LKF_INTABT));
        if (!pIntScoring->pIntAbt) {
            return LKF_OUTOFMEMORY_ERROR;
        }
        
		for (i = 0; i< pIntScoring->nAbtCount; i++)
		{
			if (!i || memcmp (pIntScoring->pAbt[i].pAbt->ABTFC, ABTFC, 8)) 
			{
				if (!i) j = 0;
				else ++j;
				pIntAbt = pIntScoring->pIntAbt + j;
				memcpy (ABTFC, pIntScoring->pAbt[i].pAbt->ABTFC, 8);
				memcpy (pIntAbt->ABTFC, ABTFC, 8);
				pIntAbt->nAufCount = 1;
				pIntAbt->nEinstufung = 99999;
				pIntAbt->nTatsBetten = 1;
				pIntAbt->nMindestStd = pIntScoring->nMindestStd;
				pIntAbt->bCompleteTiss = (int) pIntScoring->bCompleteTiss;
				pIntAbt->nTissTagefMW = 0;
				memcpy (pIntAbt->sErhebDatVon, "        ", 8);
				memcpy (pIntAbt->sErhebDatBis, "        ", 8);

				for (k = 0; k < 12; k++) 
				{
					pIntAbt->Monate[k].nError = 0;
					pIntAbt->Monate[k].nInt = 0;
					pIntAbt->Monate[k].nNeo = 0;
					pIntAbt->Monate[k].nPed = 0;
				}
			}
			else 
			{
				pIntAbt = pIntScoring->pIntAbt + j;			
				pIntAbt->nAufCount++;
			}
			pIntScoring->pAbt[i].nIntAbtIndex = j;

			pAufenthalt = pIntScoring->pAbt[i].pAufenthalt;

			if (pIntScoring->pAbt[i].nMonat) 
			{
				if (pAufenthalt->FLAG > '3') pIntAbt->Monate[pIntScoring->pAbt[i].nMonat - 1].nError++;
				else pIntAbt->Monate[pIntScoring->pAbt[i].nMonat - 1].nInt++;
			}
		}
	}
    return 0;
}

_SCORING_EXPORT int lkf_setIntAbtData (LKF_CONTEXT *pContext, const char *sAbtFC, unsigned int lTatsBetten)
{
	LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
	if (pIntScoring) 
	{
		unsigned int i;
		for (i = 0; i < pIntScoring->nIntAbtCount; i++) 
		{
			if (!memcmp (pIntScoring->pIntAbt[i].ABTFC, sAbtFC, 8))
			{
				pIntScoring->pIntAbt[i].nTatsBetten = lTatsBetten;
				return 1;
			}
		}
	}
	return 0;
}


_SCORING_EXPORT int lkf_setIntAbtDataIndex (LKF_CONTEXT *pContext, unsigned int lIndex, unsigned int lTatsBetten)
{
	LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
	if (pIntScoring && lIndex < pIntScoring->nIntAbtCount)
		pIntScoring->pIntAbt[lIndex].nTatsBetten = lTatsBetten;
	return 0;
}

_SCORING_EXPORT int lkf_getIntAbtCounter (LKF_CONTEXT *pContext, unsigned int lIndex, char *sAbtFC, unsigned int *plAufCount, unsigned int *plTISSCountSum, unsigned int *plTISSCountOk, unsigned int *plTISSCountDouble)
{
	LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
	if (sAbtFC) *sAbtFC = 0;
	if (plAufCount) *plAufCount = 0;
	if (plTISSCountSum) *plTISSCountSum = 0;
	if (plTISSCountDouble) *plTISSCountDouble = 0;
	if (plTISSCountOk) *plTISSCountOk = 0;

	if (pIntScoring && lIndex < pIntScoring->nIntAbtCount) 
	{
		unsigned int i;
		unsigned int tiss_sum, tiss_all, tiss_double;
		LKF_INTABT *pIntAbt;
		LKF_INT_SCORING_ABT *pAbt;
		LKF_AUFENTHALT *pLastAufenthalt;
		LKF_INT_SCORING_ABT *pLastAbt;
		tiss_sum = tiss_all = tiss_double = 0;
		pAbt = 0;
		pLastAbt = 0;
		pLastAufenthalt = 0;
		pIntAbt = pIntScoring->pIntAbt + lIndex;

		if (sAbtFC) sprintf (sAbtFC, "%8.8s", pIntAbt->ABTFC);
		if (plAufCount) *plAufCount = pIntAbt->nAufCount;
	
		for (i = 0; i < pIntScoring->nAbtCount; i++) 
		{
			pAbt = pIntScoring->pAbt + i;

#ifdef SUPPORT_PRE2017
			if (pAbt->pAufenthalt->FLAG < '4')
			{
				tiss_sum += pAbt->nInt02Count + pAbt->nInt12Count;
				if (pLastAufenthalt == pAbt->pAufenthalt && pLastAbt->nIntAbtIndex == pAbt->nIntAbtIndex &&
					pLastAbt->nEndDatum == pAbt->nStartDatum) tiss_double++;
			}
			tiss_all += pAbt->nInt02Count + pAbt->nInt12Count;
#else
            if (pAbt->pAufenthalt->FLAG < '4')
            {
                tiss_sum += pAbt->nInt12Count;
                if (pLastAufenthalt == pAbt->pAufenthalt && pLastAbt->nIntAbtIndex == pAbt->nIntAbtIndex &&
                    pLastAbt->nEndDatum == pAbt->nStartDatum) tiss_double++;
            }
            tiss_all += pAbt->nInt12Count;
#endif
		}

		if (plTISSCountSum) *plTISSCountSum = tiss_all;
		if (plTISSCountDouble) *plTISSCountDouble = tiss_double;
		if (plTISSCountOk) *plTISSCountOk = tiss_sum;
		if (plAufCount) *plAufCount = pIntScoring->nAbtCount;
	}
	return 0;
}


void lkf_int_free_aufenthalt (LKF_CONTEXT *pContext, LKF_INT_AUFENTHALT *pIntAufenthalt)
{
	unsigned int i;
    
    
#ifdef SUPPORT_PRE2017
	if (pIntAufenthalt->ppInt01Records)
	{
		Satzart_GetLinesFree (pContext, pIntAufenthalt->ppInt01Records);
		pIntAufenthalt->ppInt01Records = 0;
	}
	if (pIntAufenthalt->ppInt02Records) 
	{
		Satzart_GetLinesFree (pContext, pIntAufenthalt->ppInt02Records);
		pIntAufenthalt->ppInt02Records = 0;
	}
	if (pIntAufenthalt->ppInt03Records) 
	{
		Satzart_GetLinesFree (pContext, pIntAufenthalt->ppInt03Records);
		pIntAufenthalt->ppInt03Records = 0;
	}
#endif
	if (pIntAufenthalt->ppInt11Records)
	{
		Satzart_GetLinesFree (pContext, pIntAufenthalt->ppInt11Records);
		pIntAufenthalt->ppInt11Records = 0;
	}
	if (pIntAufenthalt->ppInt12Records)
	{
		Satzart_GetLinesFree (pContext, pIntAufenthalt->ppInt12Records);
		pIntAufenthalt->ppInt12Records = 0;
	}
    
    if (pIntAufenthalt->ppInt11) {
        LKF_FREE (pContext, "lkf_int_free_aufenthalt", pIntAufenthalt->ppInt11);
        pIntAufenthalt->ppInt11 = 0;
    }
    
    if (pIntAufenthalt->ppInt12) {
        LKF_FREE (pContext, "lkf_int_free_aufenthalt", pIntAufenthalt->ppInt12);
        pIntAufenthalt->ppInt12 = 0;
        
    }
    
	if (pIntAufenthalt->ppAbt) 
	{
		for (i = 0; i < pIntAufenthalt->abt_count; i++) 
			if (pIntAufenthalt->ppAbt[i]) lkf_int_free_scoring_abt (pContext, pIntAufenthalt->ppAbt[i], 1);
		LKF_FREE (pContext, "lkf_int_free_aufenthalt", pIntAufenthalt->ppAbt);
		pIntAufenthalt->ppAbt = 0;
	}
	LKF_FREE (pContext, "lkf_int_free_aufenthalt", pIntAufenthalt); /* V18.2 */
}

void lkf_int_free_structure (LKF_CONTEXT *pContext)
{
	if (pContext && pContext->pIntScoring) 
	{
		LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
		unsigned int i;
		if (pIntScoring->pAbt) {
			for (i = 0; i < pIntScoring->nAbtCount; i++) 
				lkf_int_free_scoring_abt (pContext, pIntScoring->pAbt + i, 0);
			LKF_FREE (pContext, "lkf_int_free_structure.abti", pIntScoring->pAbt);
		}

		if (pIntScoring->pIntAbt) LKF_FREE (pContext, "lkf_int_free_structure.abt", pIntScoring->pIntAbt); /* V18.2 */

		LKF_FREE (pContext, "lkf_int_free_structure", pIntScoring);
		pContext->pIntScoring = 0;
	}
}

/*********************************************************************************
** Intensiv-Scoring, Plausibilitäts-Check                                       **
*********************************************************************************/

extern const LKF_SATZART_ERRORDEF LKFErrorTISS28unvollst, 
								  LKFErrorTISSAunvollst, 
								  LKFErrorSAPSII,
								  LKFErrorSAPS3,
								  LKFErrorIntMix;

const LKF_SATZART_ERRORDEF **lkf_GetGeneralIntScoringErrors (int modelljahr)
{
	static const LKF_SATZART_ERRORDEF *ppIntScoringErrors2010[] = {&LKFErrorTISS28unvollst, &LKFErrorSAPSII, 0};
	static const LKF_SATZART_ERRORDEF *ppIntScoringErrors2011[] = {&LKFErrorTISS28unvollst, &LKFErrorSAPSII, &LKFErrorSAPS3, &LKFErrorTISSAunvollst, &LKFErrorIntMix, 0};
	static const LKF_SATZART_ERRORDEF *ppIntScoringErrors[] = {&LKFErrorTISSAunvollst, &LKFErrorSAPS3, 0};
	if (modelljahr < 2011)
		return ppIntScoringErrors2010;
	else if (modelljahr < 2012)
		return ppIntScoringErrors2011;
	else
		return ppIntScoringErrors;
}

unsigned int lkf_int_check (LKF_CONTEXT *pContext, LKF_AUFENTHALT *pAufenthalt)
{
	char sAdditionalInfo[20];
	unsigned int l01Dat;
	unsigned int nErrorCount;
	unsigned int i, j;
	LKF_INT_SCORING_ABT *pAbt;
	const SATZART_FELD *pFeld;
	LKF_CHECK_CONTEXT *pCheckContext;
	LKF_INT_AUFENTHALT *pIntAufenthalt = pAufenthalt->pIntAufenthalt;
	LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
	char sTraceLine[1024];

	if (!pIntAufenthalt || !pIntScoring) return 0;	
	
	pIntScoring->bTraceInfo = lkf_isTraceInfo (pContext, LKF_FAC_INTSCOR);
	pIntScoring->bTraceDetail = lkf_isTraceDetail (pContext, LKF_FAC_INTSCOR);
	pIntScoring->bTraceInput = lkf_isTraceInput (pContext, LKF_FAC_INTSCOR);

	pCheckContext = lkf_get_contextcheckcontext (pContext);
	pCheckContext->nTraceFacility = LKF_FAC_INTSCOR;
	pCheckContext->nWorstSeverity = 0;
	nErrorCount = 0;
	for (i = 0; i < pIntAufenthalt->abt_count; i++) 
	{
		if (pIntAufenthalt->ppAbt) pAbt = pIntAufenthalt->ppAbt[i];
		else pAbt = 0;

		if (pAbt) 
		{
            
            const char *abtENTDAT;
            
			int i01_aufnahmetag = 0;
			pCheckContext->pContext = pContext;
			pCheckContext->pAufenthalt = pAufenthalt;
			pCheckContext->lAbtAufDat = (unsigned int) lkf_dat2int (pAufenthalt->abt[i].ABTDAT);
            
            
            if (pCheckContext->pContext->modelljahr >= 2017) {
                abtENTDAT = pAufenthalt->abt[i].ENTDAT;
                pCheckContext->cSAPSAufnahmeart = 0;
            }
            else if (pCheckContext->pContext->flags & LKFCONTEXT_NICHTFONDSKA) {
                abtENTDAT = pAufenthalt->abt[i].ABT_INTSATZ + 4;
                pCheckContext->cSAPSAufnahmeart = 0;
            }
            else
            {
                abtENTDAT = pAufenthalt->abt[i].ABT_INTSATZ + 26;
                pCheckContext->cSAPSAufnahmeart = pAufenthalt->abt[i].ABT_INTSATZ[5];
            }
            pCheckContext->lAbtEntDat = (unsigned int) lkf_dat2int (abtENTDAT);
            pCheckContext->nAbtIndex = (int) i;
			pCheckContext->fio2 = -1;

			if (pIntScoring->bTraceInfo)
			{
				sprintf (sTraceLine, "Check Intensiv-Abteilung: AUFDAT=%8.8s, ENTDAT=%8.8s, SAPS-Aufnahme=%c", pAufenthalt->abt[i].ABTDAT, abtENTDAT, pCheckContext->cSAPSAufnahmeart);
				lkf_addTraceAufenthaltAbteilungLine (pContext, pAufenthalt, pAufenthalt->abt[i].ABTFC, sTraceLine, LKF_FAC_INTSCOR, LKF_TRACE_INFO);
			}
        
			if (pContext->modelljahr >= 2017 || (pAbt->nInt12Count && pContext->modelljahr >= 2011))
			{ /* V15.1 */
				if (pCheckContext->lAbtAufDat && pCheckContext->lAbtEntDat && pAbt->nInt12Count < (pCheckContext->lAbtEntDat - pCheckContext->lAbtAufDat + 1)) 
				{
                    if (pContext->modelljahr >= 2017) {
                        Satzart_ReportError (pContext, pCheckContext, 0, 0, pIntScoring->pInt12, 0, &LKFErrorTISSAunvollst, 0);
                    }
                    else {
                        sprintf (sAdditionalInfo, "%2.2s: %8.8s", pAbt->pAbt->ABTPOS, pAbt->pAbt->ABTFC);
                        Satzart_ReportError (pContext, pCheckContext, 0, 0, pIntScoring->pInt12, 0, &LKFErrorTISSAunvollst, sAdditionalInfo);
                    }
				}
			}
#ifdef SUPPORT_PRE2017
			else if (pCheckContext->lAbtAufDat && pCheckContext->lAbtEntDat && pAbt->nInt02Count < (pCheckContext->lAbtEntDat - pCheckContext->lAbtAufDat + 1))
			{
				sprintf (sAdditionalInfo, "%2.2s: %8.8s", pAbt->pAbt->ABTPOS, pAbt->pAbt->ABTFC);
				Satzart_ReportError (pContext, pCheckContext, 0, 0, pIntScoring->pInt02, 0, &LKFErrorTISS28unvollst, sAdditionalInfo);
			}
#endif
			/* V9.2: Serum-Bikarbonat-Ermittlung für Aufnahmetag umgestellt */
			
            if (pAbt->nInt11Count && pContext->modelljahr >= 2017) {
                pCheckContext->lSerumBikarbonat = -1;
                pFeld = pIntScoring->pInt11->ppRef[GEN_ERHEBDAT];
                
                for (j = 0; !i01_aufnahmetag && j < pAbt->nInt11Count; j++)
                {
                    l01Dat = (unsigned int) Satzart_GetValueDateExp (pAbt->ppInt11[j], pFeld);
                    if (l01Dat && l01Dat == pCheckContext->lAbtAufDat) {
                        i01_aufnahmetag = 1;
                    }
                }
                
                if (!i01_aufnahmetag)
                {
                    Satzart_ReportErrorExp (pContext, pCheckContext, pAbt->ppInt11[0], pIntScoring->pInt11, pFeld, &LKFErrorSAPS3, 0);
                }
                
            }
            else if (pAbt->nInt11Count && pContext->modelljahr >= 2011)
			{
						
				pCheckContext->lSerumBikarbonat = -1;
				pFeld = pIntScoring->pInt11->ppRef[GEN_ERHEBDAT];

				for (j = 0; !i01_aufnahmetag && j < pAbt->nInt11Count; j++)
				{
					l01Dat = (unsigned int) Satzart_GetValueDate (pAbt->ppInt11Records[j], (unsigned int) strlen (pAbt->ppInt11Records[j]), pFeld);
					if (l01Dat && l01Dat == pCheckContext->lAbtAufDat) {
						i01_aufnahmetag = 1;
					}
				}

				if (!i01_aufnahmetag) 
				{
					sprintf (sAdditionalInfo, "%2.2s: %8.8s", pAbt->pAbt->ABTPOS, pAbt->pAbt->ABTFC);
					Satzart_ReportError (pContext, pCheckContext, pAbt->ppInt11Records[0], 0, pIntScoring->pInt11, pFeld, &LKFErrorSAPS3, sAdditionalInfo); /* V15.2 */
				}
			}
#ifdef SUPPORT_PRE2017
			else if (pAbt->nInt01Count)
			{
				pCheckContext->lSerumBikarbonat = -1;
				pFeld = pIntScoring->pInt01->ppRef[GEN_ERHEBDAT];

				for (j = 0; !i01_aufnahmetag && j < pAbt->nInt01Count; j++)
				{
					l01Dat = (unsigned int) Satzart_GetValueDate (pAbt->ppInt01Records[j], (unsigned int) strlen (pAbt->ppInt01Records[j]), pFeld);
					if (l01Dat && l01Dat == pCheckContext->lAbtAufDat) {
						i01_aufnahmetag = 1;
						Satzart_GetValueInt (pAbt->ppInt01Records[0], (unsigned int) strlen (pAbt->ppInt01Records[0]), pIntScoring->pInt01->ppRef[I01_SERUM_BIKARBONAT], &pCheckContext->lSerumBikarbonat);
					}
				}

				if (!i01_aufnahmetag) 
				{
					sprintf (sAdditionalInfo, "%2.2s: %8.8s", pAbt->pAbt->ABTPOS, pAbt->pAbt->ABTFC);
					Satzart_ReportError (pContext, pCheckContext, pAbt->ppInt01Records[0], 0, pIntScoring->pInt01, pFeld, &LKFErrorSAPSII, sAdditionalInfo);
				}
			}
            if (pContext->modelljahr >= 2011)
            { /* 15.1 */
                if ((pAbt->nInt01Count > 0 || pAbt->nInt02Count > 0 || pAbt->nInt03Count > 0) && (pAbt->nInt11Count > 0 || pAbt->nInt12Count > 0))
                {
                    Satzart_ReportError (pContext, pCheckContext, 0, 0, 0, 0, &LKFErrorIntMix, 0);
                }
            }
            pCheckContext->lLetzteMeldung = 0;
            for (j = 0; j < pAbt->nInt01Count; j++) {
                nErrorCount += Satzart_Check (pContext, pAbt->ppInt01Records[j], pIntScoring->pInt01, pCheckContext);
            }

            pCheckContext->lLetzteMeldung = 0;
            for (j = 0; j < pAbt->nInt02Count; j++) {
                nErrorCount += Satzart_Check (pContext, pAbt->ppInt02Records[j], pIntScoring->pInt02, pCheckContext);
            }

            pCheckContext->lLetzteMeldung = 0;
            for (j = 0; j < pAbt->nInt03Count; j++) {
                nErrorCount += Satzart_Check (pContext, pAbt->ppInt03Records[j], pIntScoring->pInt03, pCheckContext);
            }
#endif

            if (pContext->modelljahr >= 2017) {
                pCheckContext->lLetzteMeldung = 0;
                for (j = 0; j < pAbt->nInt11Count; j++) {
                    nErrorCount += Satzart_CheckExp (pContext, pAbt->ppInt11[j], pIntScoring->pInt11, pCheckContext);
                }
                
                pCheckContext->lLetzteMeldung = 0;
                for (j = 0; j < pAbt->nInt12Count; j++) {
                    nErrorCount += Satzart_CheckExp (pContext, pAbt->ppInt12[j], pIntScoring->pInt12, pCheckContext);
                }
            
            }
			else if (pContext->modelljahr >= 2011)
			{ /* 15.1 */
				pCheckContext->lLetzteMeldung = 0;
				for (j = 0; j < pAbt->nInt11Count; j++) {
					nErrorCount += Satzart_Check (pContext, pAbt->ppInt11Records[j], pIntScoring->pInt11, pCheckContext);
				}

				pCheckContext->lLetzteMeldung = 0;
				for (j = 0; j < pAbt->nInt12Count; j++) {
					nErrorCount += Satzart_Check (pContext, pAbt->ppInt12Records[j], pIntScoring->pInt12, pCheckContext);
				}
			}


		}
	}
	pCheckContext->nAbtIndex = -1;
	return pCheckContext->nWorstSeverity;
}


/*********************************************************************************
** Intensiv-Scoring                                                             **
*********************************************************************************/


#ifdef SUPPORT_PRE2017
static int IntScore_GetBiggerValue (const char *buf, unsigned int buflen, const SATZART_FELD *pFeld1, const SATZART_FELD *pFeld2)
{
	int wert1, wert2;
	int score1;
	Satzart_GetValueInt (buf, buflen, pFeld1, &wert1);
	score1 = (wert1 == 1) ? pFeld1->nScoreInfo : 0;
	if (score1 > 0 && pFeld1->nScoreInfo >= pFeld2->nScoreInfo) return score1;

	Satzart_GetValueInt (buf, buflen, pFeld2, &wert2);
	return (wert2 == 1) ? pFeld2->nScoreInfo : score1;
}

static int IntScore_GetValue (const char *buf, unsigned int buflen, const SATZART_FELD *pFeld)
{
	int val;
	Satzart_GetValueInt (buf, buflen, pFeld, &val);
	return (val == 1) ? pFeld->nScoreInfo : 0;
}
#endif

static int IntScore_DoScore (const LKF_INT_SCORING_ABT *pIntAbt)
{
    LKF_AUFENTHALT *pAufenthalt = pIntAbt->pAufenthalt;
	if ((pAufenthalt->pScoringContext && (pAufenthalt->pScoringContext->compatibility & LKF_COMPATIBILITY_IGNOREERRORSFORINTSCOR)) ||
		((pAufenthalt->FLAG >= '0' && pAufenthalt->FLAG <= '3') || !pAufenthalt->plaus_err))
		return 1;
	else
		return 0;
}

_SCORING_EXPORT const char *ConvertI12toI02 (const LKF_CONTEXT *pContext, char *dest, const char *source)
{ /* V15.1: Konvertierung von I12 auf I02 */
	return 0; /* V15.2 deaktiviert */
}

static int IntScore_TISS28 (LKF_INT_SCORING *pIntScoring, LKF_INT_SCORING_ABT *pIntAbt, unsigned int lineindex)
{
#ifdef SUPPORT_PRE2017
    int score = 0;
	const char *ds;
	unsigned int buflen;
	const SATZART_INFO *pSatzartInfo;
#endif
	/* char int12[256]; */
	
	if (pIntAbt->nInt12Count)
	{
		pIntAbt->pInt02Results[lineindex].ignoreduplicate = 0;
		pIntAbt->pInt02Results[lineindex].t28_score = 0;
		pIntAbt->pInt02Results[lineindex].errorstatus = 0;
		return 0;
	}
#ifdef SUPPORT_PRE2017
	else
		ds = pIntAbt->ppInt02Records[lineindex];

	pSatzartInfo = pIntScoring->pInt02;
	pIntAbt->pInt02Results[lineindex].ignoreduplicate = 0;

	if (!IntScore_DoScore (pIntAbt))
	{
		pIntAbt->pInt02Results[lineindex].t28_score = 0;
		pIntAbt->pInt02Results[lineindex].errorstatus = 1;
		return 0;
	}
	else pIntAbt->pInt02Results[lineindex].errorstatus = 0;
 

	buflen = (unsigned int) strlen (ds);
	/* TISS-28: Mechanische Beatmung / Atemunterstützung */
	score += IntScore_GetBiggerValue (ds, buflen, pSatzartInfo->ppRef[I02_BEATMUNG_MECH], pSatzartInfo->ppRef[I02_ATEMUNTERSTUETZUNG]);

	/* TISS-28: Einmalige vasokative Medikation / Mehrfache vasoaktive Medikation */
	score += IntScore_GetBiggerValue (ds, buflen, pSatzartInfo->ppRef[I02_MEDIKATION_VAS_MEHRFACH], pSatzartInfo->ppRef[I02_MEDIKATION_VAS_EINMALIG]);

	/* TISS-28: Einmalige Medikation / Mehrfache Medikationen */
	score += IntScore_GetBiggerValue (ds, buflen, pSatzartInfo->ppRef[I02_MEDIKATION_MEHRFACH], pSatzartInfo->ppRef[I02_MEDIKATION_EINMALIG]);

	/* TISS-28: Einmalige Intervention / Mehrfache Interventionen */
	score += IntScore_GetBiggerValue (ds, buflen, pSatzartInfo->ppRef[I02_INTERVENTION_MEHRFACH], pSatzartInfo->ppRef[I02_INTERVENTION_EINFACH]);

	/* TISS-28: Enterale Ernährung */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_ERNAEHRUNG_ENTERAL]);

	/* TISS-28: Parenterale Ernährung */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_ERNAEHRUNG_PARENTERAL]);

	/* TISS-28: Nierenersatztherapie */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_NIERENERSATZTHERAPIE]);

	/* TISS-28: Behandlung metabolischer Entgleisungen */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_METABOL_ENTGLEISUNGEN]);

	/* TISS-28: Aktive Diurese */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_DIURESE_AKTIV]);

	/* TISS-28: Massiver Flüssigkeitsersatz */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_FLUESSIGERSATZ_MASSIV]);

	/* TISS-28: Standard-Monitoring */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_STANDARD_MONITORING]);

	/* TISS-28: Arterieller Katheter */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_KATHETER_ARTERIELL]);

	/* TISS-28: Atemtherapie */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_ATEMTHERAPIE]);

	/* TISS-28: Diagnostik und Therapie außerhalb der IBS */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_DIAGTHER_AUSS_IBS]);

	/* TISS-28: Drainagenpflege */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_DRAINAGENPFLEGE]);

	/* TISS-28: Harnbilanzierung */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_HARNBILANZIERUNG]);

	/* TISS-28: Häufiger Verbandswechsel */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_VERBANDSWECHSEL_HAEUFIG]);

	/* TISS-28: Hirndruckmessung */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_HIRNDRUCKMESSUNG]);

	/* TISS-28: Pulmonaliskatheter */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_PULMONALISKATHETER]);

	/* TISS-28: Routine Verbandswechsel */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_ROUTINEVERBANDSWECHSEL]);

	/* TISS-28: Tubus/Stomapflege */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_TUBUSPFLEGE]);

	/* TISS-28: Zentralvenöser Katheter */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_KATHETER_ZENTRALVENOES]);

	/* TISS-28: Kardiopulmonale Reanimation */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_REANIMATION_KARDIO]);

	/* TISS-28: Labor */
	score += IntScore_GetValue (ds, buflen, pSatzartInfo->ppRef[I02_LABOR]);

	pIntAbt->pInt02Results[lineindex].t28_score = score;
#endif
	return 0;
}

typedef struct 
{
	int LowerLimit;
	unsigned int Punkte;
} LKF_INT_LIMIT_PUNKTE;
/*
typedef struct
{
	unsigned int Anzahl;
	SAPS_PUNKTE_SINGLE
	const int *Limits;
	const unsigned int *Punkte;
} SAPS_PUNKTE;
*/

#ifdef SUPPORT_PRE2017
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_Alter[] =			{{0,  0}, { 40,  7}, { 60, 12}, { 70, 15}, { 75, 16}, { 80, 18}};
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_Herzfrequenz[] =	{{0, 11}, { 40,  2}, { 70,  0}, {120,  4}, {160,  7}};
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_SAP[] =			{{0, 13}, { 70,  5}, {100,  0}, {200,  2}};
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_Harn24h[] =		{{0, 11}, {500,  4}, {1000, 0}};  
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_SerumHarnstoffN[]= {{0,  0}, { 28,  6}, { 84, 10}};
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_Leokozyten[] =     {{0, 12}, {  1,  0}, { 20,  3}};
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_SerumKalium[] =	{{0,  3}, {  3,  0}, {  5,  3}};
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_SerumNatrium[] =   {{0,  5}, {125,  0}, {145,  1}};
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_SerumBikarbonat[]= {{0,  6}, { 15,  3}, { 20,  0}};
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_SerumBilirubin[] = {{0,  0}, {  4,  4}, {  6,  9}};
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_GCS[] =			{{0,  0}, {  3, 26}, {  6, 13}, {  9,  7}, { 11,  5}, { 14,  0}};
static const LKF_INT_LIMIT_PUNKTE SAPSPunkte_OxygenIndex[] =	{{0, 11}, {100,  9}, {200,  6}};
#define LIMIT_PUNKTE_ANZAHL(strucLKF_INT_LIMIT_PUNKTE) (sizeof(strucLKF_INT_LIMIT_PUNKTE)/sizeof(const LKF_INT_LIMIT_PUNKTE))



static unsigned int IntScore_GetLimitPunkte (int value, const LKF_INT_LIMIT_PUNKTE *pLimits, unsigned int count, unsigned int defaultwert)
{
	unsigned int i;
	for (i = count; i > 0; i--) 
	{
		if (pLimits[i-1].LowerLimit <= value) return pLimits[i-1].Punkte;
	}
	return defaultwert;
}

#endif

static int IntScore_SAPS3 (LKF_INT_SCORING *pIntScoring, LKF_INT_SCORING_ABT *pIntAbt, unsigned int lineindex)
{ /* V15.2: SAPS3-Berechnung */
    int score, scorePart;
	const char *ds;
	unsigned int buflen;
	char buf[40];
	const SATZART_INFO *pSatzartInfo = pIntScoring->pInt11;
	unsigned int bd;
	int aufgr, v, gcs, neuro, cancer, fv;
    int modelljahr;
	double dv, pao2;
    INT01_SCORING_RESULT *pResult;
    
    modelljahr = pIntScoring->pContext->modelljahr;
    pResult = pIntAbt->pInt01Results + lineindex;

    memset (pResult, 0, sizeof(INT01_SCORING_RESULT));
    
    if (modelljahr >= 2017) {
        ds = (const char *) pIntAbt->ppInt11[lineindex];
        buflen = LKF_LEN_FOR_EXPANDEDLINE;
    }
    else {
        ds = pIntAbt->ppInt11Records[lineindex];
        buflen = (unsigned int) strlen (ds);
    }
    
	
	/* Alter */
	if (pIntAbt->nAlter >= 80) score = 18;
	else if (pIntAbt->nAlter >= 75) score = 15;
	else if (pIntAbt->nAlter >= 70) score = 13;

	else if (pIntAbt->nAlter >= 60) score = 9;
	else if (pIntAbt->nAlter >= 40) score = 5;
	else score = 0;
    
    pResult->scoreParts[LKF_INT11_SCORE_ALTER] = score;
    
    
	/* Koexistierende Erkrankungen */
	cancer = 0;
    scorePart = 0;
	Satzart_GetValueString (ds, buflen, pSatzartInfo->ppRef[I11_KOEXIST_ERKRANKUNGEN], buf, 40);
	if (buf[ 0] == '1') scorePart +=  6; /* Hämatolog. Erkrankung */
	if (buf[ 2] == '1') scorePart +=  8; /* AIDS */
	if (buf[ 3] == '1') scorePart += 11; /* Metastas. Malignom */
	if (buf[ 5] == '1') scorePart +=  8; /* Leberzirrhose */
	if (buf[ 8] == '1') scorePart +=  6; /* Herzinsuff. NYHA IV */
	if (buf[13] == '1' || /* Immumsuppression, andere */ 
		buf[16] == '1' || /* Steroide Behandlung */
		buf[17] == '1' || /* Bestrahlung */
		buf[18] == '1')
	{
		scorePart +=  3;
	}
    
    score += scorePart;
    pResult->scoreParts[LKF_INT11_COEXIST] = scorePart;

	/* ??? - Belagsdauer vor Aufnahme auf ICU */
	bd = pIntAbt->pAbt->lAbtDat;
	bd -= (unsigned int) pIntAbt->pAufenthalt->lAufDat;
    if (bd >= 28) {
        pResult->scoreParts[LKF_INT11_PREBELAG] = 7;
        score += 7;
    }
    else if (bd >= 14) {
        pResult->scoreParts[LKF_INT11_PREBELAG] = 6;
        score += 6;
    }
	/* Zutransferierung */
	Satzart_GetValueString (ds, buflen, pSatzartInfo->ppRef[I11_ZUTRANSFERIERUNG], buf, 2);
	switch (buf[0])
	{
		case '2':
            score += 5;
            pResult->scoreParts[LKF_INT11_ZUTRANS] = 5;
            break;
		case '4': case '6': case '3':
            score += 7;
            pResult->scoreParts[LKF_INT11_ZUTRANS] = 7;
            break;
		case '1': case '7':
            pResult->scoreParts[LKF_INT11_ZUTRANS] = 8;
            score += 8; break;
		default:
			break;
	}

	/* Therapeut. Massnahmen */
	Satzart_GetValueString (ds, buflen, pSatzartInfo->ppRef[I11_THERAPEUTISCHE_MASSN], buf, 4);
    if (buf[1] == '1') {
        pResult->scoreParts[LKF_INT11_THERAP_MASSNAHME] = 3;
        score += 3;
    }
    
	/* Au­fnahmetyp */
	Satzart_GetValueString (ds, buflen, pSatzartInfo->ppRef[I11_AUFNAHMETYP], buf, 2);
    if (buf[0] == '2') {
        pResult->scoreParts[LKF_INT11_AUFNAHMETYP] = 3;
        score += 3;
    }
	/* Aufnahmegründe */
	score += 16;
    pResult->scoreParts[LKF_INT11_AUFNAHMEGRUND] = 16;
    
	neuro = 0;
	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I11_AUFN_NEUROLOGISCH], &aufgr) != LKF_FIELD_ERROR)
	{
		switch (aufgr)
		{
		case 1:
			pResult->scoreParts[LKF_INT11_NEURO] = 4; break;
		case 2:
			neuro = 1;		
			pResult->scoreParts[LKF_INT11_NEURO] = -4; break;
		case 3:
			pResult->scoreParts[LKF_INT11_NEURO] = 7; break;
		case 4:
			pResult->scoreParts[LKF_INT11_NEURO] = 10; break;
		default:
			break;
		}
        score += pResult->scoreParts[LKF_INT11_NEURO];
	}


	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I11_AUFN_KARDIOVASKULAER], &aufgr) != LKF_FIELD_ERROR)
	{
		switch (aufgr)
		{
			case 2: case 3: 
                score += 3;
                pResult->scoreParts[LKF_INT11_KARDIOVASKULAER] = 3;
                break;
			case 4: case 6: case 7: 
				score += 5;
                pResult->scoreParts[LKF_INT11_KARDIOVASKULAER] = 5;
                break;
			case 10:
                if (!neuro) {
                    score -= 5;
                    pResult->scoreParts[LKF_INT11_KARDIOVASKULAER] = -5;
                }
                break;
			default:
				break;
		}
	}

	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I11_AUFN_GASTROINTESTINAL], &aufgr) != LKF_FIELD_ERROR)
	{
		switch (aufgr)
		{
		case 2: case 4:
			score += 3;
            pResult->scoreParts[LKF_INT11_GASTROINTESTINAL] = 3;
            break;
		case 3:
			score += 9;
            pResult->scoreParts[LKF_INT11_GASTROINTESTINAL] = 9;
            break;
		default:
			break;
		}
	}

    if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I11_AUFN_LEBER], &aufgr) != LKF_FIELD_ERROR && aufgr == 1) {
        score += 6;
        pResult->scoreParts[LKF_INT11_LEBER] = 6;
    }

    /* Chirurgischer Status */
	Satzart_GetValueString (ds, buflen, pSatzartInfo->ppRef[I11_CHIRURG_STATUS], buf, 2);
    if (buf[0] == '3') {
        pResult->scoreParts[LKF_INT11_CHIRURG_STATUS] = 5;
        score += 5;
    }
    else if (buf[0] == '2') {
        pResult->scoreParts[LKF_INT11_CHIRURG_STATUS] = 6;
        score += 6;
    }
	/* Chirurgischer Eingriff */
    
	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I11_CHIRURGIE_EINGRIFF], &v) != LKF_FIELD_ERROR)
	{
		switch (v)
		{
			case 34: case 36: case 37: case 40: case 41:
				score -= 11;
                pResult->scoreParts[LKF_INT11_CHIRURG_EINGRIFF] = -11;
                break;
			case 30: case 31: case 32: case 33:
				score -= 8;
                pResult->scoreParts[LKF_INT11_CHIRURG_EINGRIFF] = -8;
                break;
			case 17:
				score -= 6;
                pResult->scoreParts[LKF_INT11_CHIRURG_EINGRIFF] = -6;
                break;
			case 21:
				score += 5;
                pResult->scoreParts[LKF_INT11_CHIRURG_EINGRIFF] = 5;
                break;
			default:
				break;
		}
	}

	/* Akute Infektion bei Aufnahme */
    scorePart = 0;
	Satzart_GetValueString (ds, buflen, pSatzartInfo->ppRef[I11_AKUTEINF_AUFNAHME], buf, 3);
	if (buf[0] == '1') scorePart += 4;
	if (buf[1] == '1') scorePart += 5;
    score += scorePart;
    pResult->scoreParts[LKF_INT11_AKUT_AUFNAHME] = scorePart;

	/* GCS Gesamt - Berechnung */
	v = 0;
	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_COMASCALE_MOTORISCH], &gcs) == LKF_FIELD_ERROR) gcs = -1;
	v =  (gcs > 0) ? gcs : 6;
	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_COMASCALE_VERBAL], &gcs) == LKF_FIELD_ERROR) gcs = -1;
	v += (gcs > 0) ? gcs : 5;
	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_COMASCALE_VISUELL], &gcs) == LKF_FIELD_ERROR) gcs = -1;
	v += (gcs > 0) ? gcs : 4;
    pResult->scoreParts[LKF_INT11_GCS_POINTS] = v;

    if (v < 13)
	{
        if (v >= 7) {
            score += 2;
            pResult->scoreParts[LKF_INT11_GCS_SCORE] = 2;
        }
        else if (v == 6) {
            score += 7;
            pResult->scoreParts[LKF_INT11_GCS_SCORE] = 7;
        }
        else if (v == 5) {
            score += 10;
            pResult->scoreParts[LKF_INT11_GCS_SCORE] = 10;
        }
        else if (v >= 3) {
            score += 15;
            pResult->scoreParts[LKF_INT11_GCS_SCORE] = 15;
        }
	}

	/* Serum: Bilirubin */
	if (Satzart_GetValueFloat (ds, buflen, pSatzartInfo->ppRef[I01_SERUM_GESAMT_BILIRUBIN], &dv, modelljahr) != LKF_FIELD_ERROR)
	{
        if (dv > 5.9999) {
            score += 5;
            pResult->scoreParts[LKF_INT11_BILIRUBIN] = 5;
        }
        else if (dv > 1.9999) {
            score += 4;
            pResult->scoreParts[LKF_INT11_BILIRUBIN] = 4;
        }
	}

	/* Körpertemperatur */

	fv = Satzart_GetValueFloat (ds, buflen, pSatzartInfo->ppRef[I01_KOERPERTEMP], &dv, modelljahr);
    if (fv != LKF_FIELD_ERROR && fv != LKF_FIELD_EMPTY && dv < 34.9999) {
		score += 7;
        pResult->scoreParts[LKF_INT11_KOERPERTEMP] = 7;
    }
    
	/* Serum: Kreatinin */
	if (Satzart_GetValueFloat (ds, buflen, pSatzartInfo->ppRef[I11_SERUM_KREATININ], &dv, modelljahr) != LKF_FIELD_ERROR)
	{
        scorePart = 0;
		if (dv > 3.4999) scorePart = 8;
		else if (dv > 1.9999) scorePart = 7;
		else if (dv > 1.1999) scorePart = 2;
        score += scorePart;
        pResult->scoreParts[LKF_INT11_SERUM_KREATININ] = scorePart;
    }
    

	
	/* Herzfrequenz */
	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_HERZFREQUENZ], &v) != LKF_FIELD_ERROR)
	{
        if (v >= 160) {
            score += 7;
            pResult->scoreParts[LKF_INT11_HERZFREQUENZ] = 7;
        }
        else if (v >= 120) {
            score += 5;
            pResult->scoreParts[LKF_INT11_HERZFREQUENZ] = 5;
        }
	}
	
	/* Blutbild: Leokozyten */
	if (Satzart_GetValueFloat (ds, buflen, pSatzartInfo->ppRef[I01_BLUTBILD_LEUKOZYTEN], &dv, modelljahr) != LKF_FIELD_ERROR && dv > 14.9999)
    {
        score += 2;
        pResult->scoreParts[LKF_INT11_BLUTBILD_LEUKOZYTEN] = 2;
    }
	/* Blutbild: ph-Wert */
	fv = Satzart_GetValueFloat (ds, buflen, pSatzartInfo->ppRef[I11_BLUTBILD_PH], &dv, modelljahr);
    if (fv != LKF_FIELD_ERROR && fv != LKF_FIELD_EMPTY && dv < 7.25001) {
		score += 3;
        pResult->scoreParts[LKF_INT11_BLUTBILD_PH] = 3;
    }
    
	/* Blutbild: Thrombozyten */
	fv = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I11_BLUTBILD_THROMBO], &v);
	if (fv != LKF_FIELD_ERROR && fv != LKF_FIELD_EMPTY)
	{
        scorePart = 0;
		if (v < 20) scorePart = 13;
		else if (v < 50) scorePart = 8;
		else if (v < 100) scorePart = 5;
        score += scorePart;
        pResult->scoreParts[LKF_INT11_BLUTBILD_THROMBO] = scorePart;
	}
	
	/* Systolischer Blutdruck */
	fv = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SYSTOL_ARTER_BLUTDRUCK], &v);
	if (fv != LKF_FIELD_ERROR && fv != LKF_FIELD_EMPTY)
	{
        scorePart = 0;
        if (v < 40) scorePart = 11;
		else if (v < 70) scorePart = 8;
		else if (v < 120) scorePart = 3;
        score += scorePart;
        pResult->scoreParts[LKF_INT11_SYSTOL_ARTER_BLUTDRUCK] = scorePart;
    }
	
	/* Oxygenierung */
	fv = Satzart_GetValueFloat (ds, buflen, pSatzartInfo->ppRef[I01_SAUERSTOFFPART], &pao2, modelljahr);
	if (fv != LKF_FIELD_ERROR && fv != LKF_FIELD_EMPTY)
	{
        scorePart = 0;
		Satzart_GetValueString (ds, buflen, pSatzartInfo->ppRef[I11_MECHANISCHE_BEATMUNG], buf, 2);
		if (buf[0] == '1')
		{
			fv = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SAUERSTOFFKONZ_INSP], &v);
			if (fv != LKF_FIELD_ERROR && v)
			{
				if (pao2/v < 0.9999) scorePart = 11;
				else scorePart = 7;
			}
		}
		else if (pao2 < 60)
			scorePart = 5;
        score += scorePart;
        pResult->scoreParts[LKF_INT11_SAUERSTOFF] = scorePart;
	}

	pIntAbt->pInt01Results[lineindex].score = score;
	return 0;
}

static void IntScore_I11 (LKF_INT_SCORING *pIntScoring, LKF_INT_SCORING_ABT *pIntAbt) {
    
	unsigned int i;
    LKF_CONTEXT *pContext;
    
    pContext = pIntScoring->pContext;
    
    if (pIntAbt->pInt01Results) {
        LKF_FREE (pContext, "IntScore_I11", pIntAbt->pInt01Results);
    }
    
    pIntAbt->pInt01Results = (INT01_SCORING_RESULT *) LKF_CALLOC (pContext, "IntScore_I11", pIntAbt->nInt11Count, sizeof (INT01_SCORING_RESULT));
    for (i = 0; i < pIntAbt->nInt11Count; i++) {
        IntScore_SAPS3 (pIntScoring, pIntAbt, i);
    }
}

static int IntScore_SAPSII (LKF_INT_SCORING *pIntScoring, LKF_INT_SCORING_ABT *pIntAbt, unsigned int lineindex)
{
#ifdef SUPPORT_PRE2017
	unsigned int buflen, m02_len, oxygen_index;
	unsigned int saps2_age, saps2_sap, saps2_temp, saps2_comorbidity, saps2_gcs_total, saps2_oxygen_index, saps2_oxygen, saps2_bun, saps2_wbc, 
				 saps2_urine_vol24, saps2_potassium, saps2_sodium, saps2_hco3, saps2_bilirubine, saps2_adm_type;

	char comorbidity[24], intaufart[4];
	int val, saps2_sind, gcs, fio2, art_po2;
	unsigned int saps2_hr;
	int ret;
	const char *m02, *ds;
	const SATZART_INFO *pSatzartInfo = pIntScoring->pInt01;
	const SATZART_INFO *pSatzartInfoM02 = pIntScoring->pM02;
#endif
	if (!IntScore_DoScore (pIntAbt))
	{
		pIntAbt->pInt01Results[lineindex].oxygen_index = 0;
		pIntAbt->pInt01Results[lineindex].score = 0;
		pIntAbt->pInt01Results[lineindex].errorstatus = 1;
		return 0;
	}
	else pIntAbt->pInt01Results[lineindex].errorstatus = 0;

	if (pIntAbt->nInt11Count > 0)
		return IntScore_SAPS3 (pIntScoring, pIntAbt, lineindex); /* V15.2 */
#ifdef SUPPORT_PRE2017
    else
		ds = pIntAbt->ppInt01Records[lineindex];

	buflen = (unsigned int) strlen (ds);

	/* Altersberechnung */
	saps2_age = IntScore_GetLimitPunkte ((int) pIntAbt->nAlter, SAPSPunkte_Alter, LIMIT_PUNKTE_ANZAHL (SAPSPunkte_Alter), 0);
	
	/* Herzfrequenz */
	ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_HERZFREQUENZ], &val);
	if (!ret)
		saps2_hr = IntScore_GetLimitPunkte (val, SAPSPunkte_Herzfrequenz, LIMIT_PUNKTE_ANZAHL (SAPSPunkte_Herzfrequenz), 0);
	else
		saps2_hr = 0;
	/* SI-Indikator */
	Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SI_INDIKATOR], &saps2_sind);

	/* Systolischer arterieller Blutdruck */
	saps2_sap = 0;
	ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SYSTOL_ARTER_BLUTDRUCK], &val);
	if (ret == 0)
	{
		if (val >= 0 && saps2_sind == 2) val = (int) (val * 0.1 / 0.1333); 
		saps2_sap = IntScore_GetLimitPunkte (val, SAPSPunkte_SAP, LIMIT_PUNKTE_ANZAHL(SAPSPunkte_SAP), 0);
	}

	/* Körpertemperatur */
	Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_KOERPERTEMP], &val);
	if (val >= 0) val = (int) (val * 0.1);
	saps2_temp = (val >= 39) ? 3 : 0; 
	
	/* Oxygenierungsindex - Berechnung */
	ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SAUERSTOFFKONZ_INSP], &fio2);
	oxygen_index = 0;
	saps2_oxygen_index = 0;
	if (!ret)
	{
		ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SAUERSTOFFPART], &art_po2);
		if (!ret)
		{
			if (fio2 <= 0 || art_po2 < 0) 
			{	
				oxygen_index = 0;	
				saps2_oxygen_index = 0;	
			}
			else {
				if (saps2_sind == '2') art_po2 = (int) ((art_po2 * 0.1 / 0.1333) + 0.49999);
				oxygen_index = (unsigned int) (art_po2 * 100 / fio2);
				if (oxygen_index > 1000) oxygen_index = 1000;
				saps2_oxygen_index = IntScore_GetLimitPunkte ((int) oxygen_index, SAPSPunkte_OxygenIndex, LIMIT_PUNKTE_ANZAHL(SAPSPunkte_OxygenIndex), 0);
			}
		}
	}
	pIntAbt->pInt01Results[lineindex].oxygen_index = (int) oxygen_index;
	/* Harnvolumen 24h */

	ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_HARN_VOLUMEN24H], &val);
	if (!ret)
		saps2_urine_vol24 = IntScore_GetLimitPunkte (val, SAPSPunkte_Harn24h, LIMIT_PUNKTE_ANZAHL(SAPSPunkte_Harn24h), 0);
	else
		saps2_urine_vol24 = 0;
	/* Serum - Harnstoff-N */
	ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SERUM_HARNSTOFF_N], &val);
	if (!ret)
	{
		if (val >= 0 && saps2_sind == 2) val = (int) (val * 0.1 / 0.166);
		saps2_bun = IntScore_GetLimitPunkte (val, SAPSPunkte_SerumHarnstoffN, LIMIT_PUNKTE_ANZAHL(SAPSPunkte_SerumHarnstoffN), 0);
	}
	else
		saps2_bun = 0;
	/* Blutbild: Leukozyten */
	ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_BLUTBILD_LEUKOZYTEN], &val);
	if (!ret)
	{
		if (val >= 0) val = (int) (val * 0.1);
		saps2_wbc = IntScore_GetLimitPunkte (val, SAPSPunkte_Leokozyten, LIMIT_PUNKTE_ANZAHL (SAPSPunkte_Leokozyten), 0);
	}
	else
		saps2_wbc = 0;

	/* Serum: Kalium */
	ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SERUM_KALIUM], &val);
	if (!ret)
	{
		if (val >= 0) val = (int) (val * 0.1);
		saps2_potassium = IntScore_GetLimitPunkte (val, SAPSPunkte_SerumKalium, LIMIT_PUNKTE_ANZAHL (SAPSPunkte_SerumKalium), 0); 
	}
	else
		saps2_potassium = 0;

	/* Serum: Natrium */
	ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SERUM_NATRIUM], &val);
	if (!ret)
		saps2_sodium = IntScore_GetLimitPunkte (val, SAPSPunkte_SerumNatrium, LIMIT_PUNKTE_ANZAHL (SAPSPunkte_SerumNatrium), 0); 
	else
		saps2_sodium = 0;

	/* Serum: Bikarbonat */
	ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SERUM_BIKARBONAT], &val);
	if (!ret)
	{
		if (val >= 0) val = (int) (val * 0.1);
		saps2_hco3 = IntScore_GetLimitPunkte (val, SAPSPunkte_SerumBikarbonat, LIMIT_PUNKTE_ANZAHL (SAPSPunkte_SerumBikarbonat), 0); 
	}
	else
		saps2_hco3 = 0;

	/* Serum: Gesamt-Bilirubin */
	ret = Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_SERUM_GESAMT_BILIRUBIN], &val);
	if (!ret)
	{
		if (val >= 0) {
			if (saps2_sind == 2) val = (int) (val * 0.1 / 17.1);
			else val = (int) (val * 0.1);
		}
		saps2_bilirubine = IntScore_GetLimitPunkte (val, SAPSPunkte_SerumBilirubin, LIMIT_PUNKTE_ANZAHL (SAPSPunkte_SerumBilirubin), 0); 
	}
	else
		saps2_bilirubine = 0;

	/* GCS Gesamt - Berechnung */
	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_COMASCALE_MOTORISCH], &gcs) == LKF_FIELD_ERROR) gcs = -1;
	val =  (gcs > 0) ? gcs : 6; /* V9.3: gcs 0 bedeutet Wert 6 */
	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_COMASCALE_VERBAL], &gcs) == LKF_FIELD_ERROR) gcs = -1;
	val += (gcs > 0) ? gcs : 5; /* V9.3: gcs 0 bedeutet Wert 5 */
	if (Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_COMASCALE_VISUELL], &gcs) == LKF_FIELD_ERROR) gcs = -1;
	val += (gcs > 0) ? gcs : 4; /* V9.3: gcs 0 bedeutet Wert 4 */

	saps2_gcs_total = IntScore_GetLimitPunkte (val, SAPSPunkte_GCS, LIMIT_PUNKTE_ANZAHL (SAPSPunkte_GCS), 0);  

	m02 = pIntAbt->pAbt->ABT_INTSATZ;
	m02_len = (unsigned int) strlen (m02);

	/* Coexistierende Erkrankungen */
	Satzart_GetValueString (m02, m02_len, pSatzartInfoM02->ppRef[M02_COEXIST_ERKRANKUNGEN], comorbidity, sizeof (comorbidity));
	if (comorbidity[1] == '1') /* AIDS */
		saps2_comorbidity = 17;
	else if (comorbidity[0] == '1') /* hämatologische Erkrankungen */
		saps2_comorbidity = 10;
	else if (comorbidity[2] == '1') /* Metastatisches Malignom */
		saps2_comorbidity = 9;
	else saps2_comorbidity = 0;


	/* Aufnahmetyp SAPSII */
	if (pIntScoring->cAufArtSaps != 0)
		intaufart[0] = pIntScoring->cAufArtSaps;
	else
		Satzart_GetValueString (m02, m02_len, pSatzartInfoM02->ppRef[M02_AUFART_SAPSII], intaufart, sizeof (intaufart));
	
	switch (intaufart[0]) {
		case '1':
			saps2_adm_type = 6;
			break;
		default:	
		case '2':
			saps2_adm_type = 0;
			break;
		case '3':
			saps2_adm_type = 8;
			break;
	} 

	/* SAPSII Oxygen Index */
	Satzart_GetValueInt (ds, buflen, pSatzartInfo->ppRef[I01_ATMUNGSMODUS], &val);
	saps2_oxygen = (val > 1) ? 1 : 0;

	/* Score-Berechnung */
	pIntAbt->pInt01Results[lineindex].score = (int) (saps2_age + saps2_comorbidity + saps2_adm_type + saps2_hr + saps2_sap + saps2_temp + saps2_oxygen_index * saps2_oxygen + saps2_urine_vol24 + saps2_bun + saps2_wbc + saps2_potassium + saps2_sodium + saps2_hco3 + saps2_bilirubine + saps2_gcs_total);
#endif
	return 0;
}

#ifdef SUPPORT_PRE2017
static int IntScore_Triss (LKF_INT_SCORING *pIntScoring, LKF_INT_SCORING_ABT *pIntAbt, unsigned int lineindex)
{
#define GCS_WEIGHT		0.9368
#define SAP_WEIGHT		0.7326
#define RESPRATE_WEIGHT	0.2908

	INT03_SCORING_RESULT *pResult;
	int si_einheit, val;
	int triss_age, adm_gcs_total, triss_adm_sap, triss_adm_resprate;
	int triss_ais, wert_anzahl, minval, wert6;
	int ais[6];
	unsigned int i;
	unsigned int len;
	int feldnummer;
	double calc_double, triss_ts;
	int calc_long;

	const char *ds = pIntAbt->ppInt03Records[lineindex];
	const SATZART_INFO *pSatzartInfo = pIntScoring->pInt03;
	const SATZART_INFO *pI01SatzartInfo = pIntScoring->pInt01;
	const char *pInt01Satz;
	unsigned int nInt01Len;

	pResult = pIntAbt->pInt03Results + lineindex;

	if (!pIntAbt->ppInt01Records || !pIntAbt->nInt01Count)
	{
		pResult->errorstatus = 0;
		pResult->triss_gcs_total = 0;
		pResult->triss_iss = 0;
		return 0;
	}
	else 
	{
		pInt01Satz = pIntAbt->ppInt01Records[0];
		nInt01Len = pInt01Satz ? (unsigned int) strlen (pInt01Satz) : 0;
	}

	if (!IntScore_DoScore (pIntAbt))
	{
		pResult->triss_gcs_total = 0;
		pResult->triss_iss = 0;
		pResult->errorstatus = 1;
		return 0;
	}
	else pResult->errorstatus = 0;


	triss_age = (pIntAbt->nAlter < 55) ? 1 : 0;

	/* Glasgow Coma Scale Gesamt - Berechnung */
	adm_gcs_total = 0;

	len = (unsigned int) strlen (ds);

	if (Satzart_IsEmpty (ds, len, pSatzartInfo->ppRef[I03_COMASCALE_AUF_MOTREAK])) 
		 adm_gcs_total += 6;
	else 
	{
		Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[I03_COMASCALE_AUF_MOTREAK], &val);	
		adm_gcs_total += val; 
	}
	if (Satzart_IsEmpty (ds, len, pSatzartInfo->ppRef[I03_COMASCALE_AUF_VERBREAK]))
		 adm_gcs_total += 5;
	else
	{
		Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[I03_COMASCALE_AUF_VERBREAK], &val);
		adm_gcs_total += val;
	}
	if (Satzart_IsEmpty (ds, len, pSatzartInfo->ppRef[I03_COMASCALE_AUF_VISREAK]))
		 adm_gcs_total += 4;
	else 
	{
		Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[I03_COMASCALE_AUF_VISREAK], &val);
		adm_gcs_total += val; 
	}
	if (adm_gcs_total >= 13) pResult->triss_gcs_total = 4;
	else if (adm_gcs_total >= 9) pResult->triss_gcs_total = 3;
	else if (adm_gcs_total >= 6) pResult->triss_gcs_total = 2;
	else if (adm_gcs_total >= 4) pResult->triss_gcs_total = 1;
	else pResult->triss_gcs_total = 0;

	/* SI-Einheit aus Satzart I01 */ 
	if (!Satzart_IsEmpty (pInt01Satz, nInt01Len, pI01SatzartInfo->ppRef[I01_SI_INDIKATOR]))
		 Satzart_GetValueInt (pInt01Satz, nInt01Len, pI01SatzartInfo->ppRef[I01_SI_INDIKATOR], &si_einheit);
	else si_einheit = 0;
	/* Systolischer arterieller Blutdruck bei der Aufnahme */
	triss_adm_sap = 4;
	if (!Satzart_IsEmpty (ds, len, pSatzartInfo->ppRef[I03_SYST_BLUTDRUCK_AUFNAHME])) 
	{
		if (si_einheit == 2) {
			Satzart_GetValueDouble (ds, len, pSatzartInfo->ppRef[I03_SYST_BLUTDRUCK_AUFNAHME],1,&calc_double);
			calc_long = (int) (calc_double / 0.1333);
		}
		else Satzart_GetValueInt (ds, len, pSatzartInfo->ppRef[I03_SYST_BLUTDRUCK_AUFNAHME], &calc_long);
	
		if (calc_long >= 90) triss_adm_sap = 4;
		else if (calc_long >= 76) triss_adm_sap = 3;
		else if (calc_long >= 50) triss_adm_sap = 2;
		else if (calc_long >= 1) triss_adm_sap = 1;
		else triss_adm_sap = 0;
	}
	/* Atemfrequenz bei der Aufnahme */

	triss_adm_resprate = 4;
	if (!Satzart_IsEmpty (ds, len, pSatzartInfo->ppRef[I03_ATEMFREQUENZ_AUFNAHME])) {
		Satzart_GetValueInt(ds, len, pSatzartInfo->ppRef[I03_ATEMFREQUENZ_AUFNAHME], &calc_long);

		if (calc_long >= 30) triss_adm_resprate = 3;
		else if (calc_long >= 10) triss_adm_resprate = 4;
		else if (calc_long >= 6) triss_adm_resprate = 2;
		else if (calc_long >= 1) triss_adm_resprate = 1;
		else triss_adm_resprate = 0;
	}

	/* TRISS-Score - Zwischenberechnung */
	triss_ts = pResult->triss_gcs_total * GCS_WEIGHT + triss_adm_sap * SAP_WEIGHT + triss_adm_resprate * RESPRATE_WEIGHT;

	wert6 = 0;

	for (i = 0; i < 6; i++) {
	
		switch (i) {
			case 0: /* Abbreviated Injury Scale AIS: Hals/Kopf */
				feldnummer = I03_AIS_HALS_KOPF;
				break;
			case 1: /* Abbreviated Injury Scale AIS: Gesicht */
				feldnummer = I03_AIS_GESICHT;
				break;
			case 2: /* Abbreviated Injury Scale AIS: Thorax */
				feldnummer = I03_AIS_THORAX;
				break;
			case 3: /* Abbreviated Injury Scale AIS: Abdomen */
				feldnummer = I03_AIS_ABDOMEN;
				break;
			case 4: /* Abbreviated Injury Scale AIS: Extremitäten */
				feldnummer = I03_AIS_EXTREMITAETEN;
				break;
			case 5: /* Abbreviated Injury Scale AIS: Extern */
				feldnummer = I03_AIS_EXTERN;
				break;
            default:
                feldnummer = 0;
                break;
		}
	
		if (Satzart_IsEmpty (ds, len, pSatzartInfo->ppRef[feldnummer])) ais[i] = 0;
		else {
			Satzart_GetValueInt (ds,  len, pSatzartInfo->ppRef[feldnummer], ais+i);
			if (ais[i] == 6) wert6 = 1;
			ais[i] *= ais[i];	
		}
	}

	/* TRISS-AIS-Score - Zwischenberechnung */

	do {
		minval = 99;
		wert_anzahl = 0;
		for (i = 0; i < 6; i++) {
			if (ais[i]) {
				if (minval == 99 || ais[i] < ais[minval]) minval = (int) i;
				++wert_anzahl;
			}
		}
		if (wert_anzahl > 3) {
			ais[minval] = 0;
			--wert_anzahl;
		}
	} while (wert_anzahl > 3);

	triss_ais = 0;
	for (i = 0; i < 6; i++) triss_ais += ais[i];
	
	/* TRISS-ISS-Score - Zwischenberechnung */
	if (wert6) pResult->triss_iss = 75;
	else pResult->triss_iss = triss_ais;

	return 0;
}
#endif

/*
static int IncludeThisRecord (const LKF_INT_SCORING *pIntScoring, const LKF_INT_SCORING_ABT *pIntAbt)
{
	if (pIntScoring->nStartDatum && pIntAbt->nEndDatum < pIntScoring->nStartDatum) return 0;
	if (pIntAbt->nStartDatum > pIntScoring->nEndDatum) return 0;
	if (pIntAbt->nStunden < pIntScoring->nMindestStd) return 0;
	return 1;
}*/

_SCORING_EXPORT int lkf_int_scoring (LKF_CONTEXT *pContext)
{
	unsigned int tiss_sum, tiss_count;
	unsigned int nZeitraum;
	int nStartDate, nEndDate;
	int nCurDate, nNextDate, nPrevDate;
	unsigned int i, j, k;
	unsigned int nextabt;
	LKF_INT_SCORING_ABT *pIntAbt;
	LKF_INTABT *pAbteilung;
	LKF_INT_SCORING *pIntScoring;
	const SATZART_FELD *pDatFeld, *pDatFeldI12;

	pIntScoring = pContext->pIntScoring;
	if (!pIntScoring) return 1; /* V9.1 */

	for (i = 0; i < pIntScoring->nAbtCount; i++) {

		pIntAbt = pIntScoring->pAbt + i;

#ifdef SUPPORT_PRE2017
		if ((pIntAbt->nInt01Count || pIntAbt->nInt02Count || pIntAbt->nInt03Count) &&
			(pIntAbt->nInt11Count || pIntAbt->nInt12Count)) 
		{
			/* V16.1: bei EI22 Abteilung ignorieren */
			pIntAbt->nInt01ResultCount = 0;
			pIntAbt->nInt02ResultCount = 0;
			pIntAbt->nInt03ResultCount = 0;
			continue;
		}
        
        if (pIntAbt->nInt01Count || pIntAbt->nInt11Count)
        {
            pIntAbt->nInt01ResultCount = pIntAbt->nInt01Count;
            if (!pIntAbt->nInt01ResultCount)
                pIntAbt->nInt01ResultCount = pIntAbt->nInt11Count;

            pIntAbt->pInt01Results = (INT01_SCORING_RESULT *) LKF_CALLOC (sizeof (INT01_SCORING_RESULT), pIntAbt->nInt01ResultCount);
            for (j = 0; j < pIntAbt->nInt01ResultCount; j++)
            {
                IntScore_SAPSII (pIntScoring, pIntAbt, j);
            }
        }
        
        if (pIntAbt->nInt02Count || pIntAbt->nInt12Count)
        {
            pIntAbt->nInt02ResultCount = pIntAbt->nInt02Count;
            if (!pIntAbt->nInt02ResultCount) pIntAbt->nInt02ResultCount = pIntAbt->nInt12Count; /* V15.1 */
            pIntAbt->pInt02Results = (INT02_SCORING_RESULT *) LKF_CALLOC (sizeof (INT02_SCORING_RESULT), pIntAbt->nInt02ResultCount);
            for (j = 0; j < pIntAbt->nInt02ResultCount; j++)
            {
                IntScore_TISS28 (pIntScoring, pIntAbt, j);
            }
        }
        
        if (pIntAbt->nInt03Count)
        {
            pIntAbt->nInt03ResultCount = pIntAbt->nInt03Count;
            pIntAbt->pInt03Results = (INT03_SCORING_RESULT *) LKF_CALLOC (sizeof (INT03_SCORING_RESULT), pIntAbt->nInt03ResultCount);
            for (j = 0; j < pIntAbt->nInt03ResultCount; j++)
            {
                IntScore_Triss (pIntScoring, pIntAbt, j);
            }
        }

#else
        if (pIntAbt->nInt11Count)
        {
            pIntAbt->nInt01ResultCount = pIntAbt->nInt11Count;
            pIntAbt->pInt01Results = (INT01_SCORING_RESULT *) LKF_CALLOC (pContext, "lkf_int_scoring.r1", pIntAbt->nInt01ResultCount, sizeof (INT01_SCORING_RESULT));
            if (pIntAbt->pInt01Results) {
                for (j = 0; j < pIntAbt->nInt01ResultCount; j++)
                {
                    IntScore_SAPSII (pIntScoring, pIntAbt, j);
                }
            }
			else {
				pIntAbt->nInt01ResultCount = 0;
				return LKF_OUTOFMEMORY_ERROR;
			}
        }
        
        if (pIntAbt->nInt12Count)
        {
            pIntAbt->nInt02ResultCount = pIntAbt->nInt12Count; /* V15.1 */
            pIntAbt->pInt02Results = (INT02_SCORING_RESULT *) LKF_CALLOC (pContext, "lkf_int_scoring.r2", pIntAbt->nInt02ResultCount, sizeof (INT02_SCORING_RESULT));
            if (pIntAbt->pInt02Results) {
                for (j = 0; j < pIntAbt->nInt02ResultCount; j++)
                {
                    IntScore_TISS28 (pIntScoring, pIntAbt, j);
                }
			}
			else {
				pIntAbt->nInt02ResultCount = 0;
				return LKF_OUTOFMEMORY_ERROR;
			}
        }

#endif


	}

	j = 0;

	pIntScoring->nStartDatum = (int) lkf_dat2int (pIntScoring->dStartDatum);
	if (!pIntScoring->nStartDatum) 
	{
		sprintf (pIntScoring->dStartDatum, "%4.4d0101", pContext->cmb_jahr);
		pIntScoring->nStartDatum = (int) lkf_dat2int (pIntScoring->dStartDatum);
	}
	
	pIntScoring->nEndDatum = (int) lkf_dat2int (pIntScoring->dEndDatum);
	if (!pIntScoring->nEndDatum)
	{
		sprintf (pIntScoring->dEndDatum, "%4.4d1231", pContext->cmb_jahr);
		pIntScoring->nEndDatum = (int) lkf_dat2int (pIntScoring->dEndDatum);
	}

	/* Pflegetage Gesamt unter Beruecksichtigung von Zeitraum und Mindeststunden für 0-Tagespatienten */
	if (pIntScoring->pInt02)
		pDatFeld = pIntScoring->pInt02->ppRef[GEN_ERHEBDAT];
	else
		pDatFeld = 0; /* V16.0: gibts ab 2012 nicht mehr */

	if (pIntScoring->pContext->modelljahr >= 2011)
		pDatFeldI12 = pIntScoring->pInt12->ppRef[GEN_ERHEBDAT];
	else
		pDatFeldI12 = 0;

	for (i = 0; i < pIntScoring->nIntAbtCount; i++) 
	{
		pAbteilung = pIntScoring->pIntAbt + i;
	
		memcpy (pAbteilung->sErhebDatVon, pIntScoring->dStartDatum, 8);
		memcpy (pAbteilung->sErhebDatBis, pIntScoring->dEndDatum, 8);

		pAbteilung->bCompleteTiss = (int) pIntScoring->bCompleteTiss;
		pAbteilung->nMindestStd = pIntScoring->nMindestStd;

		pAbteilung->sKommentar [0] = 0;
		nextabt = j + pAbteilung->nAufCount;

		for (; j < nextabt; j++) {
			pIntAbt = pIntScoring->pAbt + j;

			nStartDate = (pIntAbt->nStartDatum < pIntScoring->nStartDatum) ? pIntScoring->nStartDatum : pIntAbt->nStartDatum;
			nEndDate = (pIntAbt->nEndDatum < pIntScoring->nEndDatum || !pIntScoring->nEndDatum) ? pIntAbt->nEndDatum : pIntScoring->nEndDatum;
			pAbteilung->nCountPeriode += (unsigned int) (nEndDate - nStartDate + 1);
			
			if (pIntAbt->nAlter < 16) pAbteilung->nCountKleiner16 += (unsigned int) (nEndDate - nStartDate + 1);

            nNextDate = nStartDate;
            nPrevDate = 0;
            
            for (k = 0; nNextDate <= nEndDate; k++)
            {
                if (k < pIntAbt->nInt02ResultCount)
                {
                    if (pIntAbt->pInt02Results[k].errorstatus || pIntAbt->pInt02Results[k].ignoreduplicate)
                        continue;
#ifdef SUPPORT_PRE2017
                    if (pIntAbt->nInt12Count) {
                        
                        if (pContext->modelljahr >= 2017) {
                            nCurDate = Satzart_GetValueDateExp (pIntAbt->ppInt12[k], pDatFeldI12);
                        }
                        else {
                            nCurDate = Satzart_GetValueDate (pIntAbt->ppInt12Records[k], (unsigned int) strlen (pIntAbt->ppInt12Records[k]), pDatFeldI12);
                        }
                    }
                    else
                        nCurDate = Satzart_GetValueDate (pIntAbt->ppInt02Records[k], (unsigned int) strlen (pIntAbt->ppInt02Records[k]), pDatFeld);
#else
                    nCurDate = Satzart_GetValueDateExp (pIntAbt->ppInt12[k], pDatFeldI12);
#endif
                }
                else nCurDate = 0;
                
                /* Fehlende TISS28-Meldung am Aufnahmetag - wird ergänzt durch Meldung des Folgetags */
                if (nNextDate == nStartDate && nCurDate == nStartDate + 1)
                {
                    if (pIntAbt->pInt02Results[k].t28_score >= 16) {
                        pAbteilung->nTISS28FScore += (unsigned int) pIntAbt->pInt02Results[k].t28_score;
                        pAbteilung->nTISS28FCount++;
                    }
                    pAbteilung->nTissTageFehlend++;
                    nNextDate++;
                }
                
                if (nCurDate >= nNextDate || nCurDate == 0) {
                    if (nCurDate == nNextDate && nNextDate <= nEndDate)
                    {
                        if (pIntAbt->pInt02Results[k].t28_score >= 16) {
                            pAbteilung->nTISS28Score += (unsigned int) pIntAbt->pInt02Results[k].t28_score;
                            pAbteilung->nTISS28Count++;
                        }
                        pAbteilung->nTissTageGesamt++;
                    }
                    
                    /* Fehlende TISS28-Meldung am Entlassungstag */
                    else if (nNextDate == nEndDate && nPrevDate == nEndDate - 1 && (nCurDate > nEndDate || k >= pIntAbt->nInt02ResultCount))
                    {
                        if (pIntAbt->pInt02Results[k-1].t28_score >= 16) {
                            pAbteilung->nTISS28FScore += (unsigned int) pIntAbt->pInt02Results[k-1].t28_score;
                            pAbteilung->nTISS28FCount++;
                        }
                        pAbteilung->nTissTageFehlend++;
                    }
                    else if (nNextDate < nCurDate && nNextDate <= nEndDate) 
                    {
                        pAbteilung->nTissTageFehlend++;
                    }
                    ++nNextDate;
                    
                    nPrevDate = nCurDate;
                }
            }
		}

		if (pAbteilung->bCompleteTiss) {
			tiss_count = pAbteilung->nTISS28Count + pAbteilung->nTISS28FCount;
			tiss_sum = pAbteilung->nTISS28Score + pAbteilung->nTISS28FScore;
		}
		else {
			tiss_count = pAbteilung->nTISS28Count;
			tiss_sum = pAbteilung->nTISS28Score;
		}
			
		if (tiss_count) pAbteilung->fTissMw = ((double)tiss_sum) / tiss_count;
		else pAbteilung->fTissMw = 0;
		pAbteilung->nTissTagefMW = tiss_count;

		if (pAbteilung->fTissMw >= 32) pAbteilung->nEinstufung = 3;
		else if (pAbteilung->fTissMw >= 27) pAbteilung->nEinstufung = 2;
		else if (pAbteilung->fTissMw >= 22) pAbteilung->nEinstufung = 1;
		else pAbteilung->nEinstufung = 0;

		/* Korrekturfaktor berechnen */
		nZeitraum = (unsigned int) (pIntScoring->nEndDatum - pIntScoring->nStartDatum);
		if (nZeitraum < 90)
			strcpy (pAbteilung->sKommentar, "* Zeitraum ist <90 Tage *");

		if (((double)pAbteilung->nTissTageGesamt) / (nZeitraum * pAbteilung->nTatsBetten) < 0.35)
		{
			strcat (pAbteilung->sKommentar, "* Auslastung <35% *");
		}

		pAbteilung->fKorrFaktor = ((double) tiss_count) / nZeitraum / 0.7 / pAbteilung->nTatsBetten;
		if (pAbteilung->fKorrFaktor > 1.2) pAbteilung->fKorrFaktor = 1.2;

	}

	return 0;

}


/**********************************************************************************************************************
** Routinen zur Ausgabe des Intensiv-Scoring-Ergebnisses                                                             **
**********************************************************************************************************************/

_SCORING_EXPORT unsigned int lkf_int_getAbtAnz (LKF_CONTEXT *pContext)
{
	if (pContext->pIntScoring) return pContext->pIntScoring->nIntAbtCount;
	else return 0;
}

_SCORING_EXPORT void lkf_int_getAbtHeadline (LKF_CONTEXT *pContext, char *buf, unsigned int buflen)
{
	char s[512];
	sprintf (s, "KANR ; KA                   ; ABTFC    ; ABT                                  ; Einstufung; Korrfaktor; TISS-MW; TISS-Tage gem.; TISS-Tage feh.; TISS-Ersatzscore; TISS-Tage für MW; 0-Tage-Mindeststd.; ERHEBDAT von; ERHEBDAT bis; tats.Betten; Kommentar");
	strncpy (buf, s, buflen);
	buf[buflen-1] = 0;
}

_SCORING_EXPORT void lkf_int_getAbtData (LKF_CONTEXT *pContext, unsigned int i, char *buf, unsigned int buflen)
{
	char s[512];
	char katext[32]; /* V14.2:  30->32 */
	char abttext[60];
	char erhebdat_von[12];
	char erhebdat_bis[12];
	LKF_INT_SCORING *pIntScoring;
	LKF_INTABT *pIntAbt;
	pIntScoring = pContext->pIntScoring;
	pIntAbt = pIntScoring->pIntAbt + i;
	lkf_KA_to_Name (pContext, pContext->KANR, katext);
	lkf_ABTFC_to_Name (pContext, pIntAbt->ABTFC, abttext);

	FormatDate8 (pIntAbt->sErhebDatVon, erhebdat_von);
	FormatDate8 (pIntAbt->sErhebDatBis, erhebdat_bis);

	sprintf (s, "%4.4s ; %20.20s ; %8.8s ; %36.36s ;  0%1d       ; %10.2f; %7.1f;         %5d ;         %5d ;            %-4.4s ;           %5d ;                %2d ;  %s ;  %s ;      %5d ; %s", 
		pContext->KANR, katext, pIntAbt->ABTFC, abttext, 
		/* V9.3: Einstufund deaktiviert #205: pIntAbt->nEinstufung, pIntAbt->fKorrFaktor, pIntAbt->fTissMw, */
		0, 0.0, 0.0, 
		pIntAbt->nTissTageGesamt, pIntAbt->nTissTageFehlend,
		(pIntAbt->bCompleteTiss) ? "ja" : "nein", 
		pIntAbt->nTissTagefMW, pIntAbt->nMindestStd, erhebdat_von, erhebdat_bis, pIntAbt->nTatsBetten, 
		pIntAbt->sKommentar);
	strncpy (buf, s, buflen);
	buf[buflen-1] = 0;
}

_SCORING_EXPORT unsigned int lkf_int_getAbtEinstufungField (LKF_CONTEXT *pContext, unsigned int lIntAbt, unsigned int lFieldNr, char *sBuf, unsigned int lBufLen)
{
	LKF_INT_SCORING *pIntScoring;
	LKF_INTABT *pIntAbt;
	char internalbuf[64];

	pIntScoring = pContext->pIntScoring;

	if (lIntAbt < pIntScoring->nIntAbtCount) {

		pIntAbt = pIntScoring->pIntAbt + lIntAbt;


		switch (lFieldNr)
		{
/* V9.3/#205: Einstufung deaktiviert 
		case LKF_INTSCORFIELD_ABTFC:
				memcpy (internalbuf, pIntAbt->ABTFC, 8);
				internalbuf[8] = 0;
				break;

			case LKF_INTSCORFIELD_EINSTUFUNG: 
				sprintf (internalbuf, "%02d", pIntAbt->nEinstufung);
				break;

			case LKF_INTSCORFIELD_KORRFAKTOR:
				sprintf (internalbuf, "%10.2f", pIntAbt->fKorrFaktor);
				break;

			case LKF_INTSCORFIELD_TISSMW:
				sprintf (internalbuf, "%7.1f", pIntAbt->fTissMw);
				break;
*/
			default:
				internalbuf[0] = 0;
		}
	}
	else internalbuf[0] = 0;

	strncpy (sBuf, internalbuf, lBufLen);
	return (unsigned int) strlen (internalbuf);
}


/**********************************************************************************************************************
** Routinen zur Ausgabe des Intensiv-Scoring-Analyse                                                                 **
**********************************************************************************************************************/

_SCORING_EXPORT const char *lkf_int_getAnalyseHeadline (const LKF_CONTEXT *pContext, char *buf, unsigned int buflen)
{
	strncpy (buf, "KANR ; KA                   ; ABTFC    ; ABTEILUNG                            ; Jahr ; Monat;   INT;   NEO;  PAED; ERROR", buflen);
	buf[buflen-1] = 0;
	return buf;
}

_SCORING_EXPORT const char *lkf_int_getAnalyseData (const LKF_CONTEXT *pContext, unsigned int lIntAbt, unsigned int lMonat, char *buf, unsigned int buflen)
{
	char localbuf[1024];
	LKF_INTABT *pIntAbt;
	char sMonatBuf[4];
	char katext[32]; /* V14.2:  30->32 */
	char abttext[60];
	unsigned int lInt, lNeo, lPed, lError;

	if (pContext->pIntScoring && pContext->pIntScoring->nIntAbtCount > lIntAbt) {
		pIntAbt = pContext->pIntScoring->pIntAbt + lIntAbt;

		if (lMonat > 0 && lMonat < 13) 
		{
			sprintf (sMonatBuf, "%02d", lMonat);
			--lMonat;
			lInt = pIntAbt->Monate[lMonat].nInt;
			lNeo = pIntAbt->Monate[lMonat].nNeo;
			lPed = pIntAbt->Monate[lMonat].nPed;
			lError = pIntAbt->Monate[lMonat].nError;
		}
		else 
		{
			strcpy (sMonatBuf, "  ");
			lInt = lNeo = lPed = lError = 0;
			for (lMonat = 0; lMonat < 12; lMonat++)
			{
				lInt += pIntAbt->Monate[lMonat].nInt;
				lNeo += pIntAbt->Monate[lMonat].nNeo;
				lPed += pIntAbt->Monate[lMonat].nPed;
				lError += pIntAbt->Monate[lMonat].nError;
			}
		}

		lkf_KA_to_Name (pContext, pContext->KANR, katext);
		lkf_ABTFC_to_Name (pContext, pIntAbt->ABTFC, abttext);
		sprintf (localbuf, "%4.4s ; %20.20s ; %8.8s ; %36.36s ; %4d ;    %s; %5d; %5d; %5d; %5d",
			pContext->KANR, katext, pIntAbt->ABTFC, abttext, pContext->cmb_jahr, sMonatBuf, lInt, lNeo, lPed, lError);
		
		strncpy (buf, localbuf, buflen);
		buf[buflen-1] = 0;
		
		if (lInt + lNeo + lPed + lError > 0) return buf;
		else return 0;
	}
	else 
	{
		if (buflen > 0) buf[0] = 0;
		return 0;
	}
}

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltCount (const LKF_CONTEXT *pContext)
{
	LKF_INT_SCORING *pIntScoring;
	pIntScoring = pContext->pIntScoring;

	if (pIntScoring) return pIntScoring->nAbtCount;
	else return 0;
}

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltTISSCount (const LKF_CONTEXT *pContext, unsigned int lIntAuf)
{
	LKF_INT_SCORING *pIntScoring;
	pIntScoring = pContext->pIntScoring;
	if (!pIntScoring) return 0;

	if (lIntAuf < pIntScoring->nAbtCount)
	{
		return pIntScoring->pAbt[lIntAuf].nInt02ResultCount;
	}
	else return 0;
}

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltSAPSCount (const LKF_CONTEXT *pContext, unsigned int lIntAuf)
{
	LKF_INT_SCORING *pIntScoring;
	pIntScoring = pContext->pIntScoring;
	if (!pIntScoring) return 0;

	if (lIntAuf < pIntScoring->nAbtCount) 
		return pIntScoring->pAbt[lIntAuf].nInt01ResultCount;
	else return 0;
}

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltTRISSCount (const LKF_CONTEXT *pContext, unsigned int lIntAuf)
{
#ifdef SUPPORT_PRE2017
	LKF_INT_SCORING *pIntScoring;
	pIntScoring = pContext->pIntScoring;
	if (!pIntScoring) return 0;

	if (lIntAuf < pIntScoring->nAbtCount) return pIntScoring->pAbt[lIntAuf].nInt03Count;
	else return 0;
#else
    return 0;
#endif
}

_SCORING_EXPORT LKF_AUFENTHALT *lkf_int_getAufenthalt (const LKF_CONTEXT *pContext, unsigned int lIntAuf)
{ /* V13.0 */
	LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
	if (lIntAuf < pIntScoring->nAbtCount) return pIntScoring->pAbt[lIntAuf].pAufenthalt;
	else return 0;
}

/************************************************************************************************************
** lkf_int_getIntAufenthaltDetailsHeadline:                                                                **
**           Retourniert die Überschriftszeile für die Intensiv-Scoring-Details.                           **
************************************************************************************************************/

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltDetailsHeadline (const LKF_CONTEXT *pContext, char *sBuf, unsigned int lBufLen)
{
	static const char *headline = "FLAG ; KANR ; ABTFC    ; AUFENTHALT ; ABTPOS ; ERHEBDAT   ; TISS-SCORE";
    static const char *headline2017 = "FLAG ; KANR ; ABTFC    ; AUFENTHALT   ; ABTPOS ; ERHEBDAT   ; TISS-SCORE";
    LKF_INT_SCORING *pIntScoring;
	pIntScoring = pContext->pIntScoring;
    if (pContext && pContext->modelljahr >= 2017)
        strncpy (sBuf, headline2017, lBufLen);
    else
        strncpy (sBuf, headline, lBufLen);
	sBuf[lBufLen - 1] = 0;
	return (unsigned int) strlen (headline);
}

/************************************************************************************************************
** lkf_int_getIntAufenthaltDetails:                                                                        **
**           Retourniert eine Zeile über Details eines Intensiv-Scoring-Aufenthalts.                       **
************************************************************************************************************/

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltDetails (const LKF_CONTEXT *pContext, unsigned int lIntAuf, char *sBuf, unsigned int lBufLen)
{
	LKF_INT_SCORING *pIntScoring;
	pIntScoring = pContext->pIntScoring;

	if (pIntScoring && pIntScoring->nAbtCount > lIntAuf) {
		LKF_INT_SCORING_ABT *pAbt;
		unsigned int lIntSatzLen;
		char localbuf[1024];
		char von_zeit[6], bis_zeit[6];
		char von_datum[12], bis_datum[12];

		pAbt = pIntScoring->pAbt + lIntAuf;

        if (pContext->modelljahr >= 2017) {

            memcpy (von_zeit, pAbt->pAufenthalt->AUFZEIT, 4);
            memcpy (bis_zeit, pAbt->pAufenthalt->ENTZEIT, 4);
            von_zeit[4] = 0;
            bis_zeit[4] = 0;
            
            sprintf (localbuf, "%c    ; %4.4s ; %8.8s ; %12.12s ;    %3.3s ; von %10.10s, %2.2s:%2.2sh bis %10.10s, %2.2s:%2.2sh",
                     pAbt->pAufenthalt->FLAG,
                     pAbt->pAufenthalt->KANR, pAbt->pAbt->ABTFC, pAbt->pAufenthalt->PATID,
                     pAbt->pAbt->ABTPOS, FormatDate8(pAbt->pAbt->ABTDAT, von_datum), von_zeit, von_zeit + 2, FormatDate8(pAbt->DISDATE, bis_datum), bis_zeit, bis_zeit + 2);
            
        }
        else {
            lIntSatzLen = (unsigned int ) strlen (pAbt->pAbt->ABT_INTSATZ);
            Satzart_GetValueString (pAbt->pAbt->ABT_INTSATZ, lIntSatzLen, pIntScoring->pM02->ppRef[M02_ZUGANGSUHRZEIT], von_zeit, 6);
            Satzart_GetValueString (pAbt->pAbt->ABT_INTSATZ, lIntSatzLen, pIntScoring->pM02->ppRef[M02_ABGANGSUHRZEIT], bis_zeit, 6);
            
            sprintf (localbuf, "%c    ; %4.4s ; %8.8s ; %10.10s ;     %2.2s ; von %10.10s, %2.2s:%2.2sh bis %10.10s, %2.2s:%2.2sh",
                     pAbt->pAufenthalt->FLAG,
                     pAbt->pAufenthalt->KANR, pAbt->pAbt->ABTFC, pAbt->pAufenthalt->PATID,
                     pAbt->pAbt->ABTPOS, FormatDate8(pAbt->pAbt->ABTDAT, von_datum), von_zeit, von_zeit + 2, FormatDate8(pAbt->DISDATE, bis_datum), bis_zeit, bis_zeit + 2);
        }
        

		strncpy (sBuf, localbuf, lBufLen);
		sBuf[lBufLen-1] = 0;
		return (unsigned int) strlen (localbuf);
	}
	else {
		if (lBufLen) sBuf[0] = 0;
		return 0;
	}
}

/************************************************************************************************************
** lkf_int_getIntAufenthaltTISSDetails:                                                                    **
**           Retourniert eine Zeile über TISS-Details (Key und TISS28-Score).                              **
************************************************************************************************************/
_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltTRISSDetails (const LKF_CONTEXT *pContext, unsigned int lIntAuf, unsigned int lTRISSNr, char *sBuf, unsigned int lBufLen)
{
#ifdef SUPPORT_PRE2017
	LKF_INT_SCORING *pIntScoring;
	pIntScoring = pContext->pIntScoring;

	if (pIntScoring && pIntScoring->nAbtCount > lIntAuf && pIntScoring->pAbt[lIntAuf].nInt03Count > lTRISSNr && pIntScoring->pAbt[lIntAuf].pInt03Results) {
		LKF_INT_SCORING_ABT *pAbt;
		const char *sTrissSatz;
		char localbuf[1024];
		char erhebdatbuf[12];
		pAbt = pIntScoring->pAbt + lIntAuf;
		sTrissSatz = pAbt->ppInt03Records[lTRISSNr];
		erhebdatbuf[0] = 0;

		sprintf (localbuf, "I%03d ; %4.4s ; %8.8s ; %10.10s ;     %2.2s ; %10.10s ; %10d",
				 lTRISSNr + 1, pAbt->pAufenthalt->KANR, pAbt->pAbt->ABTFC, pAbt->pAufenthalt->PATID,
				 pAbt->pAbt->ABTPOS, erhebdatbuf, pAbt->pInt03Results[lTRISSNr].triss_iss);

		strncpy (sBuf, localbuf, lBufLen);
		sBuf[lBufLen-1] = 0;
		return (unsigned int) strlen (localbuf);

	}
	else {
		if (lBufLen) sBuf[0] = 0;
		return 0;
	}
#else
    if (lBufLen) sBuf[0] = 0;
    return 0;
#endif
}

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltSAPSDetails (const LKF_CONTEXT *pContext, unsigned int lIntAuf, unsigned int lSAPS, char *sBuf, unsigned int lBufLen)
{
    LKF_INT_SCORING *pIntScoring;
    pIntScoring = pContext->pIntScoring;
    
    if (pIntScoring && pIntScoring->nAbtCount > lIntAuf) {
        return lkf_int_getIntAufenthaltDetailsInternal (pContext, pIntScoring->pAbt, lSAPS, sBuf, lBufLen);
    }
    return 0;
}

_SCORING_EXPORT unsigned int lkf_int_getAufIsIntAbt (LKF_AUFENTHALT *pAufenthalt, unsigned int lIntAuf) {
    return pAufenthalt->pIntAufenthalt && pAufenthalt->pIntAufenthalt->abt_count > lIntAuf && pAufenthalt->pIntAufenthalt->ppAbt[lIntAuf];
}

_SCORING_EXPORT unsigned int lkf_int_getAufIntAbtSAPSCount (LKF_AUFENTHALT *pAufenthalt, unsigned int lIntAuf) {
    if (pAufenthalt->pIntAufenthalt && pAufenthalt->pIntAufenthalt->abt_count > lIntAuf && pAufenthalt->pIntAufenthalt->ppAbt[lIntAuf]) {
        return pAufenthalt->pIntAufenthalt->ppAbt[lIntAuf]->nInt11Count;
    }
    return 0;
}

_SCORING_EXPORT unsigned int lkf_int_getAufIntAbtDetails (LKF_AUFENTHALT *pAufenthalt, unsigned int lIntAuf, unsigned int lSAPS, char *sBuf, unsigned int lBufLen) {
    if (pAufenthalt->pIntAufenthalt && pAufenthalt->pIntAufenthalt->abt_count > lIntAuf && pAufenthalt->pIntAufenthalt->ppAbt[lIntAuf]) {
        lkf_int_getIntAufenthaltDetailsInternal (pAufenthalt->pScoringContext, pAufenthalt->pIntAufenthalt->ppAbt[lIntAuf], lSAPS, sBuf, lBufLen);
    }
    return 0;
}

unsigned int lkf_int_getIntAufenthaltDetailsInternal (const LKF_CONTEXT *pContext, LKF_INT_SCORING_ABT *pAbt, unsigned int lSAPS, char *sBuf, unsigned int lBufLen)
{
	LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
#ifdef SUPPORT_PRE2017
	if ((pAbt->nInt01Count > lSAPS || pAbt->nInt11Count > lSAPS) && pAbt->pInt01Results) {
		const char *sSapsSatz;
		char localbuf[1024];
		char erhebdatbuf[12];
		if (pAbt->nInt11Count)
		{
            if (pContext->modelljahr >= 2017) {
                if (!Satzart_GetValueDateFormatExp(pAbt->ppInt11[lSAPS], pIntScoring->pInt11->ppRef[GEN_ERHEBDAT], erhebdatbuf, 12))
                    erhebdatbuf[0] = 0;
            }
            else
            {
                sSapsSatz = pAbt->ppInt11Records[lSAPS];
                if (!Satzart_GetValueDateFormat (sSapsSatz, (unsigned int) strlen (sSapsSatz), pIntScoring->pInt11->ppRef[GEN_ERHEBDAT], erhebdatbuf, 12))
                    erhebdatbuf[0] = 0;
            }
		}
		else
		{
			sSapsSatz = pAbt->ppInt01Records[lSAPS];
			if (!Satzart_GetValueDateFormat (sSapsSatz, (unsigned int) strlen (sSapsSatz), pIntScoring->pInt01->ppRef[GEN_ERHEBDAT], erhebdatbuf, 12))
				erhebdatbuf[0] = 0;
		}
        if (pContext->modelljahr >= 2017) {
            sprintf (localbuf, "S%03d ; %4.4s ; %8.8s ; %12.12s ;    %3.3s ; %10.10s ; %10d",
                     lSAPS + 1, pAbt->pAufenthalt->KANR, pAbt->pAbt->ABTFC, pAbt->pAufenthalt->PATID,
                     pAbt->pAbt->ABTPOS, erhebdatbuf, pAbt->pInt01Results[lSAPS].score);
            
        }
        else {
            sprintf (localbuf, "S%03d ; %4.4s ; %8.8s ; %10.10s ;     %2.2s ; %10.10s ; %10d",
                     lSAPS + 1, pAbt->pAufenthalt->KANR, pAbt->pAbt->ABTFC, pAbt->pAufenthalt->PATID,
                     pAbt->pAbt->ABTPOS, erhebdatbuf, pAbt->pInt01Results[lSAPS].score);
        }

		strncpy (sBuf, localbuf, lBufLen);
		sBuf[lBufLen-1] = 0;
		return (unsigned int) strlen (localbuf);

	}
	else {
		if (lBufLen) sBuf[0] = 0;
		return 0;
	}
#else
    if (pAbt->nInt11Count > lSAPS && pAbt->pInt01Results) {
        char localbuf[1024];
        char erhebdatbuf[12];
        if (!Satzart_GetValueDateFormatExp(pAbt->ppInt11[lSAPS], pIntScoring->pInt11->ppRef[GEN_ERHEBDAT], erhebdatbuf, 12))
            erhebdatbuf[0] = 0;
         
        sprintf (localbuf, "S%03d ; %4.4s ; %8.8s ; %12.12s ;    %3.3s ; %10.10s ; %10d",
                     lSAPS + 1, pAbt->pAufenthalt->KANR, pAbt->pAbt->ABTFC, pAbt->pAufenthalt->PATID,
                     pAbt->pAbt->ABTPOS, erhebdatbuf, pAbt->pInt01Results[lSAPS].score);
        strncpy (sBuf, localbuf, lBufLen);
        sBuf[lBufLen-1] = 0;
        return (unsigned int) strlen (localbuf);
    }
    else {
        if (lBufLen) sBuf[0] = 0;
        return 0;
    }
#endif
}

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltField (const LKF_CONTEXT *pContext, unsigned int lIntAuf, unsigned int lFieldNr, char *sBuf, unsigned int lBufLen)
{
	char internalbuf[66];
	LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;

	if (pIntScoring && pIntScoring->nAbtCount > lIntAuf) {
		switch (lFieldNr) 
		{
			case LKF_INTSCORFIELD_PATID:
                if (pContext->modelljahr >= 2017)
                {
                    memcpy (internalbuf, pIntScoring->pAbt[lIntAuf].pAufenthalt->PATID, 12);
                    internalbuf[12] = 0;
                }
                else
                {
                    memcpy (internalbuf, pIntScoring->pAbt[lIntAuf].pAufenthalt->PATID, 10);
                    internalbuf[10] = 0;
                }
				break;
            case LKF_INTSCORFIELD_AUFDAT:
                memcpy (internalbuf, pIntScoring->pAbt[lIntAuf].pAufenthalt->AUFDAT, 8);
                internalbuf[8] = 0;
                break;
			case LKF_INTSCORFIELD_ABTPOS:
                if (pContext->modelljahr >= 2017)
                {
                    memcpy (internalbuf, pIntScoring->pAbt[lIntAuf].pAbt->ABTPOS, 3);
                    internalbuf[3] = 0;
                }
                else {
                    memcpy (internalbuf, pIntScoring->pAbt[lIntAuf].pAbt->ABTPOS, 2);
                    internalbuf[2] = 0;
                }
				break;
			case LKF_INTSCORFIELD_ABTFC:
				memcpy (internalbuf, pIntScoring->pAbt[lIntAuf].pAbt->ABTFC, 8);
				internalbuf[8] = 0;
				break;
            case LKF_INTSCORFIELD_AUFID64:
                memcpy (internalbuf, pIntScoring->pAbt[lIntAuf].pAufenthalt->UCASE_PATID,  64);
                internalbuf[64] = 0;
                break;
			default:
				internalbuf[0] = 0;
				break;
		}
	}
	else internalbuf[0] = 0;

	strncpy (sBuf, internalbuf, lBufLen);
	return (unsigned int) strlen (internalbuf);

}

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltTISSField (const LKF_CONTEXT *pContext, unsigned int lIntAuf, unsigned int lTISSNr, unsigned int lFieldNr, char *sBuf, unsigned int lBufLen)
{
	char internalbuf[256], date[10];
	
#ifdef SUPPORT_PRE2017
    const char *ds;
    unsigned int nLen;
    LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
	if (pIntScoring && pIntScoring->nAbtCount > lIntAuf && (pIntScoring->pAbt[lIntAuf].nInt02Count > lTISSNr || pIntScoring->pAbt[lIntAuf].nInt12Count > lTISSNr)  && pIntScoring->pAbt[lIntAuf].pInt02Results) {
		switch (lFieldNr) 
		{
            case LKF_INTSCORFIELD_AUFID64:
			case LKF_INTSCORFIELD_PATID:
			case LKF_INTSCORFIELD_ABTPOS:
			case LKF_INTSCORFIELD_ABTFC:
				return lkf_int_getIntAufenthaltField (pContext, lIntAuf, lFieldNr, sBuf, lBufLen);
			case LKF_INTSCORFIELD_ERHEBDAT:
				if (pIntScoring->pAbt[lIntAuf].nInt12Count)
				{
                    if (pContext->modelljahr >= 2017) {
                        Satzart_GetValueStringExp(pIntScoring->pAbt[lIntAuf].ppInt12[lTISSNr], pIntScoring->pInt12->ppRef[GEN_ERHEBDAT], date, 10);
                    }
                    else {
                        ds = pIntScoring->pAbt[lIntAuf].ppInt12Records[lTISSNr];
                        Satzart_GetValueString (ds, (unsigned int) strlen (ds), pIntScoring->pInt12->ppRef[GEN_ERHEBDAT], date, 10);
                    }
				}
				else
				{
					ds = pIntScoring->pAbt[lIntAuf].ppInt02Records[lTISSNr];
					Satzart_GetValueString (ds, (unsigned int) strlen (ds), pIntScoring->pInt02->ppRef[GEN_ERHEBDAT], date, 10);
				}
				FormatDate8 (date, internalbuf);
				break;
			case LKF_INTSCORFIELD_SCORE:
				sprintf (internalbuf, "%d", pIntScoring->pAbt[lIntAuf].pInt02Results[lTISSNr].t28_score);
				break;
			case LKF_INTSCORFIELD_LINEID:
				if (pIntScoring->pAbt[lIntAuf].nInt12Count)
				{
                    if (pContext->modelljahr >= 2017) {
                        Satzart_GetValueStringExp (pIntScoring->pAbt[lIntAuf].ppInt12[lTISSNr], pIntScoring->pInt12->ppRef[GEN_LINEID], internalbuf, 24);
                    }
                    else {
                        ds = pIntScoring->pAbt[lIntAuf].ppInt12Records[lTISSNr];
                        Satzart_GetValueString (ds, (unsigned int) strlen (ds), pIntScoring->pInt12->ppRef[GEN_LINEID], internalbuf, 24);
                    }
				}
				else
				{
					ds = pIntScoring->pAbt[lIntAuf].ppInt02Records[lTISSNr];
					Satzart_GetValueString (ds, (unsigned int) strlen (ds), pIntScoring->pInt02->ppRef[GEN_LINEID], internalbuf, 24);
				}
				break;
			case LKF_INTSCORFIELD_LINE:
                
                if (pContext-> modelljahr >= 2017) {
                    lkf_write_expLine(internalbuf, pIntScoring->pAbt[lIntAuf].ppInt12[lTISSNr]);
                }
                else {
                    if (pIntScoring->pAbt[lIntAuf].nInt12Count)
                        ds = pIntScoring->pAbt[lIntAuf].ppInt12Records[lTISSNr];
                    else
                        ds = pIntScoring->pAbt[lIntAuf].ppInt02Records[lTISSNr];
                    strncpy (internalbuf, ds, 255);
                }
                internalbuf[255] = 0;
				break;
			case LKF_INTSCORFIELD_ADDINFO1:
			default:
				internalbuf[0] = 0;
				break;
		}
	}
	else *internalbuf = 0;
#else
    unsigned int nLen;
    LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
    if (pIntScoring && pIntScoring->nAbtCount > lIntAuf && pIntScoring->pAbt[lIntAuf].nInt12Count > lTISSNr  && pIntScoring->pAbt[lIntAuf].pInt02Results) {
        switch (lFieldNr)
        {
            case LKF_INTSCORFIELD_AUFID64:
            case LKF_INTSCORFIELD_PATID:
            case LKF_INTSCORFIELD_ABTPOS:
            case LKF_INTSCORFIELD_ABTFC:
                return lkf_int_getIntAufenthaltField (pContext, lIntAuf, lFieldNr, sBuf, lBufLen);
            case LKF_INTSCORFIELD_ERHEBDAT:
                Satzart_GetValueStringExp(pIntScoring->pAbt[lIntAuf].ppInt12[lTISSNr], pIntScoring->pInt12->ppRef[GEN_ERHEBDAT], date, 10);
                FormatDate8 (date, internalbuf);
                break;
            case LKF_INTSCORFIELD_SCORE:
                sprintf (internalbuf, "%d", pIntScoring->pAbt[lIntAuf].pInt02Results[lTISSNr].t28_score);
                break;
            case LKF_INTSCORFIELD_LINEID:
                Satzart_GetValueStringExp (pIntScoring->pAbt[lIntAuf].ppInt12[lTISSNr], pIntScoring->pInt12->ppRef[GEN_LINEID], internalbuf, 24);
                break;
            case LKF_INTSCORFIELD_LINE:
                lkf_write_expLine(internalbuf, pIntScoring->pAbt[lIntAuf].ppInt12[lTISSNr]);
                internalbuf[255] = 0;
                break;
            case LKF_INTSCORFIELD_ADDINFO1:
            default:
                internalbuf[0] = 0;
                break;
        }
    }
    else *internalbuf = 0;
#endif
	strncpy (sBuf, internalbuf, lBufLen);
	nLen = (unsigned int) strlen (internalbuf);
	if (nLen >= lBufLen) sBuf[lBufLen-1] = 0;
	return nLen;
}

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltTRISSField (const LKF_CONTEXT *pContext, unsigned int lIntAuf, unsigned int lTRISSNr, unsigned int lFieldNr, char *sBuf, unsigned int lBufLen)
{
	unsigned int nLen;
	char internalbuf[256]; /* V16.0: 48 -> 256 */
#ifdef SUPPORT_PRE2017
    const char *ds;
	LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
	if (pIntScoring && pIntScoring->nAbtCount > lIntAuf && pIntScoring->pAbt[lIntAuf].nInt03Count > lTRISSNr && pIntScoring->pAbt[lIntAuf].pInt03Results) {
		switch (lFieldNr) 
		{
            case LKF_INTSCORFIELD_AUFID64:
			case LKF_INTSCORFIELD_PATID:
			case LKF_INTSCORFIELD_ABTPOS:
			case LKF_INTSCORFIELD_ABTFC:
				return lkf_int_getIntAufenthaltField (pContext, lIntAuf, lFieldNr, sBuf, lBufLen);
			case LKF_INTSCORFIELD_SCORE:
				sprintf (internalbuf, "%d", pIntScoring->pAbt[lIntAuf].pInt03Results[lTRISSNr].triss_iss);
				break;
			case LKF_INTSCORFIELD_LINEID:
				ds = pIntScoring->pAbt[lIntAuf].ppInt03Records[lTRISSNr];
				Satzart_GetValueString (ds, (unsigned int) strlen (ds), pIntScoring->pInt03->ppRef[GEN_LINEID], internalbuf, 24);
				break;
			case LKF_INTSCORFIELD_LINE:
				ds = pIntScoring->pAbt[lIntAuf].ppInt03Records[lTRISSNr];
				strncpy (internalbuf, ds, 255);
				internalbuf[255] = 0;
				break;
			case LKF_INTSCORFIELD_ADDINFO1:
			case LKF_INTSCORFIELD_ERHEBDAT:
			default:
				internalbuf[0] = 0;
				break;
		}
	}
	else *internalbuf = 0;
#else
    *internalbuf = 0;
#endif
	strncpy (sBuf, internalbuf, lBufLen);
	nLen = (unsigned int) strlen (internalbuf);
	if (nLen >= lBufLen) sBuf[lBufLen-1] = 0;
	return nLen;
}

_SCORING_EXPORT int lkf_int_getAufSAPSScore (LKF_AUFENTHALT *pAufenthalt, unsigned int lIntAuf, unsigned int lSAPS, unsigned int lFieldNr) {
    if (pAufenthalt->pIntAufenthalt && pAufenthalt->pIntAufenthalt->ppAbt && pAufenthalt->pIntAufenthalt->abt_count > lIntAuf) {
        LKF_INT_SCORING_ABT *pAbt = pAufenthalt->pIntAufenthalt->ppAbt[lIntAuf];
        if (pAbt == 0)
            return 0;
        return lkf_int_getAufSAPSScoreInternal (pAufenthalt->pScoringContext, pAbt, lSAPS, lFieldNr);
    }
    return 0;
}

_SCORING_EXPORT int lkf_int_getIntAufenthaltSAPSScore (const LKF_CONTEXT *pContext, unsigned int lIntAuf, unsigned int lSAPS, unsigned int lFieldNr) {
    if (pContext->pIntScoring && pContext->pIntScoring->nAbtCount > lIntAuf) {
        return lkf_int_getAufSAPSScoreInternal (pContext, pContext->pIntScoring->pAbt + lIntAuf, lSAPS, lFieldNr);
    }
    return 0;
}

int lkf_int_getAufSAPSScoreInternal (const LKF_CONTEXT *pContext, LKF_INT_SCORING_ABT *pAbt, unsigned int lSAPS, unsigned int lFieldNr) {
    
    if (!pAbt->pInt01Results) {
        IntScore_I11(pContext->pIntScoring, pAbt);
    }
    
    if (pAbt->pInt01Results && pAbt->nInt11Count >= lSAPS) {
        INT01_SCORING_RESULT *pResult = pAbt->pInt01Results + lSAPS;
        
        if (lFieldNr == 0)
            return pResult->score;
        else if (lFieldNr <= LKF_INT11_MAX_SCORE_FIELDNR) {
            return pResult->scoreParts[lFieldNr];
        }
        return 0;
    }
    return 0;
}


_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltSAPSField (const LKF_CONTEXT *pContext, unsigned int lIntAuf, unsigned int lSAPS, unsigned int lFieldNr, char *sBuf, unsigned int lBufLen)
{
	unsigned int nLen;
	char internalbuf[256], date[10];
	

#ifdef SUPPORT_PRE2017
    const char *ds;
    LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
    if (pIntScoring && pIntScoring->nAbtCount > lIntAuf && pIntScoring->pAbt[lIntAuf].nInt01ResultCount > lSAPS && pIntScoring->pAbt[lIntAuf].pInt01Results) {
		switch (lFieldNr)
		{
            case LKF_INTSCORFIELD_AUFID64:
			case LKF_INTSCORFIELD_PATID:
			case LKF_INTSCORFIELD_ABTPOS:
			case LKF_INTSCORFIELD_ABTFC:
            case LKF_INTSCORFIELD_AUFDAT:
				return lkf_int_getIntAufenthaltField (pContext, lIntAuf, lFieldNr, sBuf, lBufLen);
			case LKF_INTSCORFIELD_ERHEBDAT:
				if (pIntScoring->pAbt[lIntAuf].nInt11Count > 0)
				{
                    if (pContext->modelljahr >= 2017) {
                        Satzart_GetValueStringExp(pIntScoring->pAbt[lIntAuf].ppInt11[lSAPS], pIntScoring->pInt11->ppRef[GEN_ERHEBDAT], date, 10);
                    }
                    else {
                        ds = pIntScoring->pAbt[lIntAuf].ppInt11Records[lSAPS];
                        Satzart_GetValueString (ds, (unsigned int) strlen (ds), pIntScoring->pInt11->ppRef[GEN_ERHEBDAT], date, 10);
                    }
				}
				else
				{
					ds = pIntScoring->pAbt[lIntAuf].ppInt01Records[lSAPS];
					Satzart_GetValueString (ds, (unsigned int) strlen (ds), pIntScoring->pInt01->ppRef[GEN_ERHEBDAT], date, 10);
				}
				FormatDate8 (date, internalbuf);
				break;
			case LKF_INTSCORFIELD_SCORE:
				sprintf (internalbuf, "%d", pIntScoring->pAbt[lIntAuf].pInt01Results[lSAPS].score);
				break;
			case LKF_INTSCORFIELD_ADDINFO1:
				sprintf (internalbuf, "%d", pIntScoring->pAbt[lIntAuf].pInt01Results[lSAPS].oxygen_index);
				break;
			case LKF_INTSCORFIELD_LINEID:
				if (pIntScoring->pAbt[lIntAuf].nInt11Count > 0)
				{
                    if (pContext->modelljahr >= 2017) {
                        Satzart_GetValueStringExp (pIntScoring->pAbt[lIntAuf].ppInt11[lSAPS], pIntScoring->pInt11->ppRef[GEN_LINEID], internalbuf, 24);
                    }
                    else
                    {
                        ds = pIntScoring->pAbt[lIntAuf].ppInt11Records[lSAPS];
                        Satzart_GetValueString (ds, (unsigned int) strlen (ds), pIntScoring->pInt11->ppRef[GEN_LINEID], internalbuf, 24);
                    }
				}
				else
				{
					ds = pIntScoring->pAbt[lIntAuf].ppInt01Records[lSAPS];
					Satzart_GetValueString (ds, (unsigned int) strlen (ds), pIntScoring->pInt01->ppRef[GEN_LINEID], internalbuf, 24);
				}
				break;

			case LKF_INTSCORFIELD_LINE:
                if (pContext->modelljahr >= 2017) {
                    lkf_write_expLine(internalbuf, pIntScoring->pAbt[lIntAuf].ppInt11[lSAPS]);
                }
                else
                {
                    if (pIntScoring->pAbt[lIntAuf].nInt11Count > 0)
                        ds = pIntScoring->pAbt[lIntAuf].ppInt11Records[lSAPS];
                    else
                        ds = pIntScoring->pAbt[lIntAuf].ppInt01Records[lSAPS];
                    strncpy (internalbuf, ds, 255);
                }
				internalbuf[255] = 0;
				break;

			default:
				internalbuf[0] = 0;
				break;
		}
	}
	else *internalbuf = 0;
#else
    LKF_INT_SCORING *pIntScoring = pContext->pIntScoring;
    if (pIntScoring && pIntScoring->nAbtCount > lIntAuf && pIntScoring->pAbt[lIntAuf].nInt01ResultCount > lSAPS && pIntScoring->pAbt[lIntAuf].pInt01Results) {
        switch (lFieldNr)
        {
            case LKF_INTSCORFIELD_AUFID64:
            case LKF_INTSCORFIELD_PATID:
            case LKF_INTSCORFIELD_ABTPOS:
            case LKF_INTSCORFIELD_ABTFC:
            case LKF_INTSCORFIELD_AUFDAT:
                return lkf_int_getIntAufenthaltField (pContext, lIntAuf, lFieldNr, sBuf, lBufLen);
            case LKF_INTSCORFIELD_ERHEBDAT:
                Satzart_GetValueStringExp(pIntScoring->pAbt[lIntAuf].ppInt11[lSAPS], pIntScoring->pInt11->ppRef[GEN_ERHEBDAT], date, 10);
                FormatDate8 (date, internalbuf);
                break;
            case LKF_INTSCORFIELD_SCORE:
                sprintf (internalbuf, "%d", pIntScoring->pAbt[lIntAuf].pInt01Results[lSAPS].score);
                break;
            case LKF_INTSCORFIELD_ADDINFO1:
                sprintf (internalbuf, "%d", pIntScoring->pAbt[lIntAuf].pInt01Results[lSAPS].oxygen_index);
                break;
            case LKF_INTSCORFIELD_LINEID:
                Satzart_GetValueStringExp (pIntScoring->pAbt[lIntAuf].ppInt11[lSAPS], pIntScoring->pInt11->ppRef[GEN_LINEID], internalbuf, 24);
                break;

            case LKF_INTSCORFIELD_LINE:
                lkf_write_expLine(internalbuf, pIntScoring->pAbt[lIntAuf].ppInt11[lSAPS]);
                internalbuf[255] = 0;
                break;

            default:
                internalbuf[0] = 0;
                break;
        }
    }
    else *internalbuf = 0;
#endif
	strncpy (sBuf, internalbuf, lBufLen);
	nLen = (unsigned int) strlen (internalbuf);
	if (nLen >= lBufLen) sBuf[lBufLen-1] = 0;
	return nLen;
}

_SCORING_EXPORT unsigned int lkf_int_getIntAufenthaltTISSDetails (const LKF_CONTEXT *pContext, unsigned int lIntAuf, unsigned int lTISSNr, char *sBuf, unsigned int lBufLen)
{
	LKF_INT_SCORING *pIntScoring;
	pIntScoring = pContext->pIntScoring;
#ifdef SUPPORT_PRE2017
	if (pIntScoring && pIntScoring->nAbtCount > lIntAuf && (pIntScoring->pAbt[lIntAuf].nInt02Count > lTISSNr || pIntScoring->pAbt[lIntAuf].nInt12Count > lTISSNr) && pIntScoring->pAbt[lIntAuf].pInt02Results) {
		LKF_INT_SCORING_ABT *pAbt;
		const char *sTissSatz;
		char localbuf[1024];
		char erhebdatbuf[12];
		pAbt = pIntScoring->pAbt + lIntAuf;

		if (pAbt->nInt12Count > 0)
		{
            if (pContext->modelljahr >= 2017) {
                if (!Satzart_GetValueDateFormatExp(pAbt->ppInt12[lTISSNr], pIntScoring->pInt12->ppRef[GEN_ERHEBDAT], erhebdatbuf, 12))
                    erhebdatbuf[0] = 0;

            }
            else {
                sTissSatz = pAbt->ppInt12Records[lTISSNr];
                if (!Satzart_GetValueDateFormat (sTissSatz, (unsigned int) strlen (sTissSatz), pIntScoring->pInt12->ppRef[GEN_ERHEBDAT], erhebdatbuf, 12))
                    erhebdatbuf[0] = 0;
            }
		}
		else
		{
			sTissSatz = pAbt->ppInt02Records[lTISSNr];
			if (!Satzart_GetValueDateFormat (sTissSatz, (unsigned int) strlen (sTissSatz), pIntScoring->pInt02->ppRef[GEN_ERHEBDAT], erhebdatbuf, 12))
				erhebdatbuf[0] = 0;
		}
        
        if (pContext->modelljahr >= 2017) {
            sprintf (localbuf, "T%03d ; %4.4s ; %8.8s ; %12.12s ;     %2.2s ; %10.10s ; %10d",
                     lTISSNr + 1, pAbt->pAufenthalt->KANR, pAbt->pAbt->ABTFC, pAbt->pAufenthalt->PATID,
                     pAbt->pAbt->ABTPOS, erhebdatbuf, pAbt->pInt02Results[lTISSNr].t28_score);
        }
        else
        {
            sprintf (localbuf, "T%03d ; %4.4s ; %8.8s ; %10.10s ;     %2.2s ; %10.10s ; %10d",
                     lTISSNr + 1, pAbt->pAufenthalt->KANR, pAbt->pAbt->ABTFC, pAbt->pAufenthalt->PATID,
                     pAbt->pAbt->ABTPOS, erhebdatbuf, pAbt->pInt02Results[lTISSNr].t28_score);
        }
		strncpy (sBuf, localbuf, lBufLen);
		sBuf[lBufLen-1] = 0;
		return (unsigned int) strlen (localbuf);

	}
	else {
		if (lBufLen) sBuf[0] = 0;
		return 0;
	}
#else
    if (pIntScoring && pIntScoring->nAbtCount > lIntAuf && pIntScoring->pAbt[lIntAuf].nInt12Count > lTISSNr && pIntScoring->pAbt[lIntAuf].pInt02Results) {
        LKF_INT_SCORING_ABT *pAbt;
        char localbuf[1024];
        char erhebdatbuf[12];
        pAbt = pIntScoring->pAbt + lIntAuf;

        if (!Satzart_GetValueDateFormatExp(pAbt->ppInt12[lTISSNr], pIntScoring->pInt12->ppRef[GEN_ERHEBDAT], erhebdatbuf, 12))
            erhebdatbuf[0] = 0;
        sprintf (localbuf, "T%03d ; %4.4s ; %8.8s ; %12.12s ;     %2.2s ; %10.10s ; %10d",
                     lTISSNr + 1, pAbt->pAufenthalt->KANR, pAbt->pAbt->ABTFC, pAbt->pAufenthalt->PATID,
                     pAbt->pAbt->ABTPOS, erhebdatbuf, pAbt->pInt02Results[lTISSNr].t28_score);
        strncpy (sBuf, localbuf, lBufLen);
        sBuf[lBufLen-1] = 0;
        return (unsigned int) strlen (localbuf);

    }
    else {
        if (lBufLen) sBuf[0] = 0;
        return 0;
    }
#endif
}

_SCORING_EXPORT unsigned int lkf_int_setintcontextparameters (LKF_CONTEXT *pContext, const char *sVonDatum, const char *sBisDatum, unsigned int flags, unsigned int mindeststd)
{
	if (pContext && pContext->pIntScoring) 
	{
		
		if (strlen (sVonDatum) == 4) 
			sprintf (pContext->pIntScoring->dStartDatum, "%4.4d%s", pContext->cmb_jahr, sVonDatum);
		else 
			sprintf (pContext->pIntScoring->dStartDatum, "%-8.8s", sVonDatum);

		if (strlen (sBisDatum) == 4) 
			sprintf (pContext->pIntScoring->dEndDatum, "%4.4d%s", pContext->cmb_jahr, sBisDatum);
		else 
			sprintf (pContext->pIntScoring->dEndDatum, "%-8.8s", sBisDatum);

		pContext->pIntScoring->bCompleteTiss = (flags & 1) ? 1 : 0;
		pContext->pIntScoring->nMindestStd = mindeststd;

		if (!lkf_dat2int(pContext->pIntScoring->dEndDatum) || !lkf_dat2int (pContext->pIntScoring->dStartDatum)) {
			pContext->pIntScoring->dEndDatum[0] = pContext->pIntScoring->dStartDatum[0] = 0;
			if (*sVonDatum || *sBisDatum) return 1;
		}
	}
	else 
	{
		return 2;
	}
	return 0;
}

_SCORING_EXPORT int lkf_auf_getIntLineWithIdent (LKF_AUFENTHALT *pAufenthalt, const char *ident, char *l) {
    unsigned int lineIndex;
    if (memcmp (ident, "INX:", 4)) {
        return LKFCERROR_INVALIDID;
    }
    if (!pAufenthalt->pIntensiv) {
        return LKFCERROR_NULLREF;
    }
    lineIndex = (unsigned int) atoi (ident + 8);
    if (lineIndex >= pAufenthalt->pIntensiv->lineCount) {
        return LKFCERROR_OUTOFBOUNDS;
    }
    
    lkf_write_expLine(l, pAufenthalt->pIntensiv->lines[lineIndex]);
    return LKFCERROR_OK;
}

_SCORING_EXPORT int lkf_auf_replaceIntLine (LKF_AUFENTHALT *pAufenthalt, const char *line, const char *ident)
{ /* V2024.0 */
    unsigned int indexToReplace;
    LKF_EXPANDED_LINE *pIntLine;
    LKF_EXPANDED_LINE_INFO info;
    LKF_CONTEXT *pContext;
    
    pContext = pAufenthalt->pScoringContext;
    if (!pContext) {
        return LKFCERROR_NOCONTEXT;
    }
    
    indexToReplace = (unsigned int) atoi (ident + 8);
    memset (&info, 0, sizeof (LKF_EXPANDED_LINE_INFO));
    info.replaceIdent = ident; /* V2024.0 */
    pIntLine = lkf_create_expandLine(pContext, line, 0, &info, "lkf_auf_replaceIntLine");
    if (!pIntLine) {
        return LKFCERROR_INVALIDFORMAT;
    }
    return lkf_replace_expandLine(pAufenthalt->pIntensiv, pIntLine, indexToReplace);
}

_SCORING_EXPORT int lkf_auf_deleteIntLine (LKF_AUFENTHALT *pAufenthalt, const char *ident)
{ /* V2024.0 */
    unsigned int indexToReplace;
    indexToReplace = (unsigned int) atoi (ident + 8);
    return lkf_delete_expandLine(pAufenthalt->pIntensiv, indexToReplace);
}

