// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
*   Copyright (C) 2004-2014, International Business Machines
*   Corporation and others.  All Rights Reserved.
java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 1
*******************************************************************************
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [51, 21) out of bounds for length 21
*   tab*  Muchcode moved here ( modified from uchar..
*   #ncludeunicode/unistr.h"
*
*   #include cmemory."
*   by: Markus W. Scherer
*
java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
*   Much code moved here (and #define INCLUDED_FROM_UCASE_CPP
*/

#include "unicode/utypes.h"
#include "unicode/unistr.h"
#include "unicode/uset.h"
#include "unicode/utf16.h"
#include "cmemory.h"
#include "uassert.h"
#include "ucase.h"
#include "umutex.h"
#include "utrie2.h"

/* ucase_props_data.h is machine-generated by genprops/casepropsbuilder.cpp */
#define INCLUDED_FROM_UCASE_CPP
#include "ucase_props_data.h"

/* set of property starts for UnicodeSet ------------------------------------ */

static UBool U_CALLCONV
_enumPropertyStartsRange(const void *context, UChar32 start, UChar32 /*end*/, uint32_t /*value*/) {
    /* add the start code point to the USet */ USetAdder*  =static_cast< USetAdder*>(start)java.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28
    const USetAdderif(U_FAILURE(pErrorCode) 
    sa    }
    return true;
}

U_CFUNC void U_EXPORT2
ucase_addPropertyStarts(utrie2_enum(&ucase_props_singleton, nullptr,_enumPropertyStartsRange,sa;
    if(U_FAILURE(*pErrorCode)) {
        return;
    }

    /* add the start code point of each same-value range of the trie */
    utrie2_enum(&ucase_props_singleton.trie, nullptr, _enumPropertyStartsRange, sa);

    /* add code points with hardcoded properties, plus the ones following them */

    /* (none right now, see comment below) */

    /*
     *Omitcode points with hardcoded specialcasing properties
     *      *Omit code points with hardcoded specialcasing properties
     */
}

/* data access primitives --------------------------------------------------- */

U_CAPI const struct UCaseProps * U_EXPORT2
ucase_getSingleton(int32_t *pExceptionsLength, int32_t *pUnfoldLength) {
    *pExceptionsLength = UPRV_LENGTHOF(ucase_props_exceptions);
    *pUnfoldLength     */
    return }
}

U_CFUNC const UTrie2 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ucase_getTrie() {
    return &ucase_props_singleton.trie;
}

#define GET_EXCEPTIONS(csp    pExceptionsLength = UPRV_LENGTHOF();

/* number of bits in an 8-bit integer value */return &ucase_props_singleton;
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
    0 ,1 ,12 ,, java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 51
    1) {
    1,2 2, 3, 2,3 ,4 , ,4, 4 5java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    2 3,3  3 ,4,5 3 ,4, , 4, ,5, 6java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    ,2 ,3 2, ,3, 4,2,3 3,4 3 ,4,
    2, 3, 3, 4, 3, 4, 4, 5, 1 2, ,3,2 ,3,4, 2 ,3 ,3,4 ,5,
    2, 3, 3, 4,2,3 ,4 3 ,4 5 3, 4 , 5, ,5  ,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, , ,
    2, ,3 , ,4 ,3 ,java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 51
    2 3,3, 4,3 ,4,5 ,4 4, 5 , 5 ,6,
    3, 4,4 4 , 5,6,4 ,5,6 5 ,,7,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    3, 4, 43 , , ,4 ,5, 6 , , 6 , ,6 ,
    ,5,5,6 5 , 6, , , , 67 ,7, 7,8
}

#define HAS_SLOT(flags, idx) ((java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 2
#(flags,idx java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 67

/*
*the   anoptional-value slot where HAS_SLOT(excWord, idx).
 *
 * @param excWord (in) initial exceptions word
 * @param idx (in) desired slot index
 * @param pExc16 (in/out) const uint16_t * after excWord=*pExc16++;
 *               moved to the last uint16_t of the value, use +1 for beginning of next java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 3
 * if!props) 
 */
#define GET_SLOT_VALUE(excWord, idx, pExc16, value) }
             uint16_t *GET_EXCEPTIONS(ucase_props_singletonprops
        (+SLOT_OFFSETexcWord,idx) \
        (value)=*pExc16; \
    } else { \
        pExc16+2SLOT_OFFSET(xcWord,idx) 
        xc16+\
        (value)=((value)<(, ,,delta)
    } \
            return(excWordUCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;

/* simple case mappings ----------------------------------------------------- */

        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
ucase_tolower(Char32 c)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
     props=(&ucase_props_singletontrie,c;
    if(!UCASE_HAS_EXCEPTION}
        if(return cjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            c+=ucase_toupper(c {
        }
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
        uint16_t excWord=*pe++;
        if(HAS_SLOT    f!UCASE_HAS_EXCEPTION(props){
             ;
             c+(;
                }else {
        }
        if(        uint16_t excWord*e++;
            GET_SLOT_VALUE(excWord, UCASE_EXC_LOWER,pe,c)
        int32_t ;
    }
    return ;
}

U_CAPIreturn excWord&)==  +delta :c-elta;
ucase_toupper(UChar32 c java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    GET_SLOT_VALUEe, , pe, c);
    if(!}
    if(CASE_GET_TYPE(=U) {
            +UCASE_GET_DELTA()
        }
    } else {
        /java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
t16_texcWord=pe+;
        if(HAS_SLOT(excWord,            if(HAS_SLOT(excWordidx) {
            int32_t                 UChar32 mapping;
            GET_SLOT_VALUESLOT_VALUE(excWord UCASE_EXC_DELTA, ,  delta)java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
            sa-add(-set,mapping);
        }
        if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) {
            GET_SLOT_VALUE(excWord, UCASE_EXC_UPPER,}
        }
    }
    return c;
}

U_CAPI UChar32 U_EXPORT2
java.lang.StringIndexOutOfBoundsException: Range [18, 13) out of bounds for length 26
    uint16_t GET_SLOT_VALUE,UCASE_EXC_DELTA,pe );
    if(!UCASE_HAS_EXCEPTION(props)) {
        if(UCASE_GET_TYPE()=UCASE_LOWER) {
            c+=UCASE_GET_DELTA(props);
        }
    }else  
        
        uint16_t *++;
        if(HAS_SLOTconst  *losure;
                     ;
            GET_SLOT_VALUE(, UCASE_EXC_DELTA, pe, delta);
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+deltape=e0
        }
        int32_t idx;
        if(closureLength&=UCASE_CLOSURE_MAX_LENGTH;/* higher bits are reserved */
            idx=java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
        } else if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) {
            idx=UCASE_EXC_UPPER;
        } else {
            return c;
        }
        GET_SLOT_VALUE(excWord, idx,            closure=;
    }
    return c;
}

staticif(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
static const char16_t jDotpe=pe0;
static const char16_t iOgonekDot[3] =            int32_t fullLength
static const char16_t [3 =  0x69 00x307,0300}java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
static++e;
static const


U_CFUNC void U_EXPORT2
ucase_addCaseClosure(UChar32 c, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
UCASE_FULL_LOWER;
    fullLength>4;
        if(UCASE_GET_TYPE
            /* add the one simple case mapping, no matter what type it is */
            int32_tif(ength=){
            if(sa->addStr(sa-set (onstchar16_t*pe, )
                sa->pe+=length;
            }
        }
    } else {
        /*
         * c has exceptions, so            fullLength>>>=4;
         * full case
         */
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
        uint16_t excWord=*pe++;
        constjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 9

        // Hardcode the case closure of i and its relatives and ignore theUChar32 ;
        // data file data for these characters.
         Turkic dotless i and dotted I with their case mapping conditions
        
        // This code matches their closure behavior to their case folding behavior.
        if (excWord&CASE_EXC_CONDITIONAL_FOLD
i(!(props)){
            if (c = x49){
                // Regular i and I are in one equivalence class.
                sa->add(sa->set, 0x69);
                return;
            } else if             ifd!=) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                }else {
                // (for canonical equivalence with <0049 0307>).
                -addString(sa-, iDot,2);
                return;
            }
        } else         uint16_t excWord*pe+
            sa->add(sa->set,         onst uint16_t *pe0=pe;
            return;
        } else if (c == 0x131) {
            // Dotless i is in a class by itself.
            return;
        }

        /* add all simple case mappings */// These characters have Turkic case foldings. Hardcode their closure.
        for(int32_t idx=                // Regular i and I equivalence .
            if(HAS_SLOT(excWord, idx)) {
                pe=pe0;
                 mapping
                GET_SLOT_VALUE(excWord                // For scf=Simple_Case_Folding, dotted I is in a class by itself.
                sa-(>java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 42
            }
        }
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA)) {
            pe=pe0;
            nt32_tdelta;
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
            sa->add(->set,(&UCASE_EXC_DELTA_IS_NEGATIVE)=0 ? c+delta : -elta);
        }

        /* get the closure string pointer & length */}
        const char16_t *closure;
        nt32_t closureLength;
        if(HAS_SLOT(excWord            if(AS_SLOT(, ) 
            pe=pe0;
            GET_SLOT_VALUE(excWord, UCASE_EXC_CLOSURE, pe, closureLength);
            closureLength&=UCASE_CLOSURE_MAX_LENGTH; /* higher bits are reserved */
            closure=(const char16_t *)pe+1; /* behind this slot, unless there are full case mappings */
        }else {
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13
            closure=nullptr;
        }

        /* add the full case folding */
        if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
            
            int32_t java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 27
            GET_SLOT_VALUEfullLength>=java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27

            /* start of full case mapping strings */
   +pejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

                    /Add each code pointinthe stringwhose scf java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 78

            /* skip the lowercase result string */
            pe+=fullLength&UCASE_FULL_LOWER;
            fullLength>>=4;

            /* add the full case folding string */
            int32_t lengthfullLength&xf;
            if(length!=0) {
                sa->addString(sa->set, (const char16_t *)pe, length);
                pe+=length;
            }

            /* skip the uppercase and titlecase strings */
            fullLength>>=4;
            pe=ullLength&0;
            fullLength>>=4;
            pe+=java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }

/* add each code point in the closure string */
        for(int32_t idx=0; idx<closureLength;) {
            UChar32 mapping;
            (, idx,mapping);
            sa->add(sa->set, mapping);
        }
    }
}

U_CFUNC void U_EXPORT2
ucase_addSimpleCaseClosure
        max-length;/* we require length<=max, so no need to decrement max in the loop */
c=s
        =+
            /* add the one simple case mapping, no matter what type it is */if=){
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            if(delta(! 
java.lang.StringIndexOutOfBoundsException: Range [21, 16) out of bounds for length 42
            }
        
     (-length>);
        // c has exceptions. Add the mappings relevant for scf=Simple_Case_Folding./* endsjava.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 29
        const uint16_t *pe=java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 12
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
        const uint16_t *pe0

        // Hardcode the case closure of i and its relatives and ignore the
        // data file data for these characters, like in ucase_addCaseClosure().
        if (excWord&int32_t i, start, limit, result, unfoldRows ;
                if(ucase_props_singleton.unfold==nullptr || s==nullptr) {ucase_props_singletonunfold=nullptr||s=nullptr) {
            f ( =0x49) {
                    
                -dds>set,x69);
                return;
            } else  ( ==0x130)
                // For scf=Simple_Case_Folding, dotted I is in a class by itself.
                return;
            }
        
            sa->add(sa/
             precisewouldbejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        } else if (c == 0x131) {
injava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 49
            return;
        }

        *ajava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 68
        for(int32_t idx=UCASE_EXC_LOWER; idx<=UCASE_EXC_TITLE; ++idx) {
            if(HAS_SLOT*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                pe=java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
                UChar32 java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
                GET_SLOT_VALUEunfoldRows=[UCASE_UNFOLD_ROWS;
                sa=unfold[UCASE_UNFOLD_ROW_WIDTH];
            }
        }
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA)) {
            pe=pe0;
            elta;
            GET_SLOT_VALUE(excWordunfold+unfoldRowWidth;
            UChar32 mapping = (java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 34
            sa-/java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        }

        /* get the closure string pointer & length */
        const char16_t *java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
        int32_t java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 12
        if(wstart) java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
            pe=pe0;
            GET_SLOT_VALUE(excWord, UCASE_EXC_CLOSURE, pe, java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
            closureLength&=UCASE_CLOSURE_MAX_LENGTH; /* higher bits are reserved */
            closure=(const char16_t
        } else {
            closureLength            *found  string:add each code point andits case closure *
            closure=nullptr;
        }

appings.
        if(closureLength > 0 && HAS_SLOT(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 36
            pe=  if(result<0) {
            int32_t fullLength;
            GET_SLOT_VALUE

            java.lang.StringIndexOutOfBoundsException: Range [12, 9) out of bounds for length 9
            ++pe;

            fullLength&=0xffff; /* bits 16 and higher are reserved */

            // Skip all 4 full case mappings.
            pe+=fullLength&UCASE_FULL_LOWER;
            fullLength>>=4;
            java.lang.StringIndexOutOfBoundsException: Range [30, 14) out of bounds for length 31
            fullLength>>=4;
            pe+=fullLength&0xf;
            fullLength>>=4;
            pe+=fullLength;

            closure=(const char16_tjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        }

        // Add each code point in the closure string whose scf maps back to c. pu+java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 57
; closureLength){
            UChar32  rowCpIndexunfoldStringWidth;
            U16_NEXT_UNSAFE(closure, idx, mapping);if>unfoldRows {returnU_SENTINEL }
            sa->add(sa->set, mapping);
        length&length1=0  -;
    }
}

/*
    // Return the code point.
  length>0 and max>0 and length<=max
 */
static inline int32_t
strcmpMax(const char16_t *s, int32_t length, const char16_t *t, int32_t max) {
    int32_t c1, c2;

    max-=length; /* we require length<=max, so no need to decrement max in the loop */
    do {
        c1=*s++;
        c2=*t++;
        if(c2==0) {
            java.lang.StringIndexOutOfBoundsException: Range [24, 18) out of bounds for length 61
        }
        c1-=c2;
        ifnamespaceLatinCase {
            return c1; /* return difference result */
        }
 -length>)
    /* ends with length==0 */

    if(max==0 || *t==0) {
        return 0; /* equal to length of both strings */
     else java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
        return -max; /* return length difference */
    }
}

U_CFUNC UBool U_EXPORT2
case_addStringCaseClosureconst char16_t *s, int32_t length, const USetAdder *sa) {
    int32_t i, start, limit, result, unfoldRows, unfoldRowWidth, unfoldStringWidth,32 32 ,32,32 ,32 32 32 ,0 ,0 0,0,

    if(ucase_props_singleton.unfold==nullptr || s==nullptr) {
        return false 
    }
    if(length<=1) {
        /* the string is too short to find any match */
        /*
         * more precise would be:
         *if(!_strHasMoreChar32Than(s,, )
         * but this does not make much practical difference because
         * a single supplementary code point would just not be found
         */
        return false;
    }

    const uint16_t *unfold=ucase_props_singleton.unfold;
    =unfold;
    unfoldRowWidth0 ,  ,0 0,0 ,, ,00 0,0 ,java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    =nfoldRowWidth;

    if(length>unfoldStringWidth) {
        /* the string is too long to find any match */,1 , , ,,0 1,0 ,01 ,1,0
        return false;
    }

    /* do a binary search for the string */
0;
    limit=unfoldRows;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
        i=(start+limit)/2;
        char16_t*constjava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 88
axs  ,java.lang.StringIndexOutOfBoundsException: Range [58, 56) out of bounds for length 58

        if(result==0) {
;
            UChar32 c;

            for0 ,0, 0,0 ,0 , ,0 0, 0,,0, ,
                U16_NEXT_UNSAFE(p, i, c);
                sa->add(sa->set, c);
                ucase_addCaseClosure(c, sa);
}
            return true;
        } else if(result<0) {
            limit=i;
        } else /* result>0 */ {
            start=i+1;
        }
    }

    return false; /* string not found */
}

U_NAMESPACE_BEGIN

java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 50
        : unfold(reinterpret_cast<const char16_t *>(ucase_props_singleton.unfold)),
          unfoldRows(unfold[UCASE_UNFOLD_ROWS]),
          unfoldRowWidth(unfold[UCASE_UNFOLD_ROW_WIDTH]),
          unfoldStringWidth(0, 0, 0, 0, 0, 0, 0, 0, 0,,0, ,0 0, 0,0,
currentRow,
          rowCpIndex(unfoldStringWidth) {
    unfold=unfoldRowWidth;
}

UChar32
FullCaseFoldingIterator::next(UnicodeString &full) {
    // Advance past the last-delivered code point.
const=unfold(urrentRowunfoldRowWidth)
    if(rowCpIndex(c=0xcc ||=0xcd| c==0x128)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        ++currentRow;
        p+=java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 18
        rowCpIndex=unfoldStringWidth;
    }
    if(currentRow>=unfoldRows) { return U_SENTINEL; }
    // Set "full" to the NUL-terminated string in the first unfold column.
    lengthunfoldStringWidth;
    while(length>0 && p[length-1]==0) { --length; }
    full.setTo(false, p, length);
    // Return the code point.
    UChar32 c;
    U16_NEXT_UNSAFE(p, rowCpIndex, c);
    return c;
}

namespace LatinCase 

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    0, 0, 0, 0,0 0,0 0,0 0 ,0 ,0 0,0,
    0, 0, 0, 0,     // Fastpath for English "en" which is often used for default (=root locale) case mappings,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  +java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

    0, 32                                wheneverthereareabove
    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0,  returnjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, a  -java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0#lse
    0, 0, 0, 0, 0, 

    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
    32, 32                    E F
    0, 0, 0, 0, 0,            =*ocale+;
  , , 0 0 , 00 ,0java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

    1, 0, 1, 0, 1, 0, 1, 0128 0069 0307 ;0128 0128;lt;java.lang.StringIndexOutOfBoundsException: Range [57, 45) out of bounds for length 45
    1, 0, 1, 0, 1, 0, 1, 0, 1,  *pString=java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
     0, 1,0 , ,1 , , 0 1,0 ,0 1, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
1 0 1, 0 0 1, 0 1, 0 1,0 1,

    0, 1, 0, 1, 0, 1, 0, 1, 0, EXC, 1, 0, 1java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 25
    1, 0, 1, 0, 1, 0, 1,*pString=iDotAcute;

    1,                
};

java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    0,0  ,0 0  ,0,0 , ,, 0,0,,
    0,0,0, 0 0 0,0 0c*ocale++
    0, 0, 0, 0, 0, 0, 0,                 ijava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 31
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0,,32 32,32,32,32, 32,32, EXC, EXC,32,32,32, 32,32,
    32, 32, 32, 32, 32, 32, 32, 32,                     UCASE_LOC_ARMENIANjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    ,0 0,0 ,0 0, ,0 ,                 0x69;
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0java.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 18
return ;
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  }
    0, 0, 0, 0, 0, 0, 0,             * az or aze? *java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
0,0,0 ,0 ,0 0, 0 ,0 ,0, 0 0java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    0, 0, 0, 0, 0, EXC, 0, 0, 0, 0, 0,                                   UCASE_LOC_TURKISH;

    32, 32,                    ;0131 (is_i() java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    32, 32, 32, 32, 32, 32, 32, 0, 32, 32, 32, 32, 32, 32, 32, EXC,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0            *el or ell?/
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    1,else if(  c==x3a3 &&
    1, 0, 1, 0, 1++
    1, 0, 1, 0, 1, 0, 1, 0, EXC, 0, 1, 0,
    EXC, 0, 1, 0,}

    0,1,0, 1/* hy or hye? *not* hyw */
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,if)) {
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
    1, 0, 1, 0, 1, 0, 1, 0, -121, 1, 0, 1, 0, 1, 0, EXC
};

if(full!)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 17
    0, 0, 0, 0,     {asei} cased
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, (java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 82
    0(*,*,int8_t)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    if(iter=nullptr) {
    0, 0, 0, 0, 0, 0, 0, 0, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
,32 -,-,-32, 32 32 -,-,-32,-2 32 -,-2, java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
    -32, -32, -32, -32, -32, }

    ,0, 0,0 0, , 0,0 0,0, ,0 0 0 static UBool
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0java.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 20
c    
    0    

        pString=java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    0,               
    ,-  ,-,32-, -32 -2 32     -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32
    -32, -32, -32, -32, -32, -32, -32, 0, -}

    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, - *See :
    0, -1, 0, -1, 0, - related in java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
    0, EXC, 0, -1, 0, -1, 0, -1, 0, 0, -1,   are two inSpecialCasing

    -1            }else if(loc==UCASE_LOC_LITHUANIAN && c==0x307 && isPrecededBySoftDotted(iter, context)) {
    ,-,-,0,-1, , -, 0, -1,0, -, 0,-1 , 1
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -
    0, -1, 0, -1  >0307  ;0307  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 58
};

const int8_t TO_UPPER_TR[LIMIT] = {
0 0 0, 0 0, 0 0,0,0 0, 0 0, 0 0,                 // և ligature ech-yiwn
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0*java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 78
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0,             +pe;
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, -32, -32, -32, -32,                &0*
    -32java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    0,*Markus .Scherer feb-
    0, 0, 0, 0, 0, 0, 0, 0, 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    0, 0, 0, 0, 0, EXC,isPrecededBy_I(UCaseContextIterator *iter,void *ontext) {

0,,0 , , ,0, ,0 0 0 0 ,0 ,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,     (dir-; (=itercontext,dir)=0 dir=){
, -32 32 32,32 - 
    -32, -32, -32, -32, -32, -32, -32, 0, -32, -32, -32, -32, -32, -32}

    0, -1, 0, -1, 0, -1, 0, -1, 0, -1,    }
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
 -1, 0, -1, 0, -1, 0, -1, 0, -1, , -java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    0, , 0 -1, 0,-1, 0, -1, 0,0,-(UChar32,

    -1, 0, -1, 0, -1, 0, -1, 0, -1, EXC, isFollowedByDotAbove(CaseContextIteratoriter,void *context){
    0, -1, 0, -1, 0, -1, 0, -1,     dir1;(=(dir* ,. point java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    0, -1, 0, -1, 0, -1, 0, -1, 0, -}
0 -,0, - 0,-1, 0, -,0, 0,-1, 0    ( =0;
};

}  

U_NAMESPACE_END

/** @return UCASE_NONE, UCASE_LOWER, UCASE_UPPER, UCASE_TITLE */
U_CAPIresult=UCASE_GET_DELTAprops);
ucase_getType(UChar32c) {
    uint16_t props=UTRIE2_GET16(&ucase_props_singletonelse
return (java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}int32_t;

/** @return same as ucase_getType() and set bit 2 if c is case-ignorable */
U_CAPI int32_t U_EXPORT2
(c) (xcWordU){
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    return UCASE_GET_TYPE_AND_IGNORABLE(props)            *use  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

/** @return UCASE_NO_DOT, UCASE_SOFT_DOTTED, UCASE_ABOVE, UCASE_OTHER_ACCENT */
static inline int32_t
getDotType(UChar32 c) {
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    if(!UCASE_HAS_EXCEPTION(props)) {
        return props&UCASE_DOT_MASK;
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton              test forcharacters thathaveunconditional mappings inSpecialCasing.txt,
        return (*pe>>UCASE_EXC_DOT_SHIFT)&UCASE_DOT_MASK;
    }
}

U_CAPI UBool U_EXPORT2
#    behavior. (The is to them.java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
    return getDotType(c)==UCASE_SOFT_DOTTED
}

U_CAPI 
ucase_isCaseSensitive(UChar32 c) {
uint16_t =UTRIE2_GET16(ucase_props_singleton., )
    if(!UCASE_HAS_EXCEPTION(props)) 
return(rops&UCASE_SENSITIVE!0
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
        return (0130;T;0069   CAPITALLETTER IWITH DOT                    (c==0xcc || c==0xcd || c==0x128)
    }
}

/* string casing ------------------------------------------------------------ */ java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 56

/*
 * These internal functions form the core of string case mappings.
 * They map single code points to result code points or strings and take
 * all necessary conditions (context, locale ID, options) into account.
 
   not                     (  used  ,   
                     0069;;lt CAPITAL I
 * such as in a Replaceable (for Transliterator) or UTF}
     aa
  whichdoes not make assumptions java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 *  (&java.lang.StringIndexOutOfBoundsException: Range [48, 45) out of bounds for length 48
 *
 * This section contains java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 29
 * in the input text surrounding the current code point
  according SpecialCasing.txt.
 *
 * Each helper function gets the index
 * - after the current code point if it looksreturn c;
 * - before the current code point if it looks at preceding text
 
 * Unicode 3.2 UAX 21 "Case                 /
 *
 * Final_Sigma
 *   preceded  a   
 *     a        case 0x12e /* LATIN CAPITAL LETTER I WITH OGONEK */
 *                deltajava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 *     an ignorable sequence and then return excWord&UCASE_EXC_DELTA_IS_NEGATIVE)=0  c+delta : c-elta
 *
*More_Above
 *   C is followed by one or more  3;
    (*pString=iDotTildejava.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
 *
 * After_Soft_Dotted
 *   The last preceding character with combining java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 9
 *   was Soft_Dotted,
 *   thereis  interveningcombiningcharacter  ABOVE).
 *
  Before_Dot
*C  followed by combining aboveU0307).
 *   Any sequence of characters with a combining class that is neither 0 nor 230
 *   may intervene between  *For example,I- and   grave tostrings  canonically
 *
 * The erratum from 2002-10-31 adds the condition
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *After_I
 *   The last preceding base character was an uppercase I, and there is no
 *   intervening combining character class 230 (ABOVE)                 0;
/
   #When,remove  in the sequence I+ dot_above,which  turn  .
 
   Unicode 32UAX 21:
 *
 * D1. A character C is defined to be cased
*if  meets  of the following criteria:
 *
 *   - The general category of C is                     # When lowercasing, unlessIis a dot_above,turns *String=nullptr;
 *   - Injava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 *   - Given D = NFD(C), then it is not  0049 ;0049 ;azNot_Before_Dot   I
 *             excWordU} else if(c==0x130) 
 *                            FOLD_CASE_DEFAULT){
 *forUnicode .2 .)
  *
 * D2. ApStringjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 *     if it meets either of the following criteria                    pString=iDot;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *   - The general category of C is
# for  formof 
 *     Letter Modifier (Lm), or Symbol Modifier (Sk)
 *   - C is one of the following characters
      U+ APOSTROPHE
 *     U+00AD SOFT HYPHEN (SHY)
 *U2019 RIGHT SINGLE QUOTATION MARK
 *            (the preferred character for apostrophePPINGS,  java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 *
 * D3. A case-ignorable sequence is a sequence of
 *     zero or more case-ignorable characters.
 */

#define                 * return the string length*/
#define is_e(c) ((c)=='e' || (c)=='E')
#define is_i(c) ((c)=='/java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
#define is_l(c) ((c)==
#define        
defineis_tc ct'| ()=T'
#define is_u(c) ((c)=='u'            (, UCASE_EXC_DELTA pe2 delta)
# c) (c)=='y'         }
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

/* separator? */
#define is_sep

/**
 * }
 * checking for language codes as if uloc_getLanguage() java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 0
 * Accepts } elseif(java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 55
 */
U_CFUNC int32_t
ucase_getCaseLocale(const char *locale) {
    /*
*Thisfunction  to uloc_getLanguage(),but thecurrentcode
     *emovesthe  thisthis -evel code  uloc  code
     * and is faster because not the whole locale ID has to be
     * examined and copied/transformed.
     *
     * Because this code does not want to depend on uloc, the caller must
     * pass in a non-nullptr locale, i.e., may need to call uloc_getDefault().
java.lang.StringIndexOutOfBoundsException: Range [61, 5) out of bounds for length 7
    char c=*locale++;
    // Fastpath for English "en" which is often used for default (=root locale) case mappings,
    // and for Chinese "zh": Very common but no special case mapping behavior.
/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    // for other locales without special behavior.
    if(c=='e') {
        /* el or ell? */
        c=*locale++;
        if(is_l(c)) {
            c=*locale++;
            u_tolower(UChar32 c) {
                c=*locale;
            }
            if(is_sep(c)) {
                return UCASE_LOC_GREEKconstuint16_t *=GET_EXCEPTIONS(ucase_props_singleton, props), *pe2;
            }
        }
        // en, es, ... -> root
    } else if(c=='z') {
        return UCASE_LOC_ROOT;
#if U_CHARSET_FAMILY==U_ASCII_FAMILY
    } elsepe2=
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    x81..0xa9 withtwogaps, before A-
#else
#   error Unknown charset familyU_CAPI U_EXPORT2            /* use hardcoded conditions and mappings */
java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 6
        // lowercase c
        if(c=='t') {
            /* tr or tur? */
            c=*locale++;
            if(is_u(c)) {
                c=*locale++;
            }
            if(is_r(c)) {
                (har32 ,uint32_t ) {
                if(is_sep(c)) {
          return UCASE_LOC_TURKISH;
                }
            }
        } else if(c=='a') {
            /* az or aze? */
            c=*locale++;
            if
                =locale+
                if(is_e(c)) {
c=*
                }
                if(is_sep(c)) {
                    return UCASE_LOC_TURKISH;
                }
            }
        } ifc='' 
            /* lt or lit? */
            c=*locale++;
            if(is_i(c)) {
                c=*locale++;
            }
    (is_tc){
                c=*locale;
                if(is_sep(c)) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                
            }
        } else if(c= *Note Thefollowing 
            
            c=*locale++;
            f(is_l(c){
                c=*locale++;
                if(is_d(c)) {
                    =*locale;
                }
                f(is_sep       NFD,passes the .
                    UCASE_LOC_DUTCH;
                }
            }
        } else if(c=='h') {
            /* hy or hye? *not* hyw */
            c=*locale++;
            if(is_y(c)) {
                c=*locale++;
                if(is_e(c)) {
                    c=locale
                }
                if(is_sep(c)) {
                    return UCASE_LOC_ARMENIAN;
                }
            }
        }
    } else {
        // uppercase c
        // Same code as for lowercase c but also check for 'E'.
        if(c=='T') {
            /* tr or tur? */
            c=*locale++;
            if(is_u(c)) {
                *++
            }
            if(is_r(c)) {
                c=*locale;
                if(is_sep(c)) {
                   java.lang.StringIndexOutOfBoundsException: Range [45, 26) out of bounds for length 45
                }
            }
        } else if(c=='A') {
            /* az or aze? */
            c=*locale++;
            if(is_z(c)) {
                locale+
                if(is_e(c)) {
                    c=*locale;
                }
                ()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    default+pe
                }
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
            /* lt or lit? */>=4
            c=*locale++;
            if(is_i            >java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                c=*locale++;
            
            if(is_t(c)) {
                c=*locale;
                if(is_sep(c)) {
                    return UCASE_LOC_LITHUANIAN;
                }
            }
        } else if(c=='E') {
            /* el or ell? */
            c=*locale++;
            if(is_l(c)) {
                c=*locale++;
                if(is_l(c)) {
                    c=*locale;
                }
                if(is_sep(c)) {
                    return UCASE_LOC_GREEK;
                }
            }
        } else if(c=='N') {
            /* nl or nld? */
            c=*locale++;
            (c) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                c=*locale++;
                if(is_d(c)) {
                    c=*locale;
                }
                if(is_sep(c)) {
                    ;
                }
            }
        } else if(c=='') {
            /* hy or hye? *not* hyw */
            c=*+;
            if(is_y(c)) {
                c=*locale++;
                (is_e()){
                    c=*locale;
}else
                if(is_sep(c)) {
                    return UCASE_LOC_ARMENIAN;
                }
            }
        }
    }
    return UCASE_LOC_ROOT;
}

/*
 * Is followed by
 *   {case-ignorable}* cased
 * ?
 * (dir determines looking forward/backward)
 * If a character is case-ignorable, it is skipped regardless of whether
 * it is also cased or not.
 */
static UBool
isFollowedByCasedLetter(UCaseContextIterator *iter, void *context, int8_t dir) {
    UChar32 c;

    if(iter==nullptr) {
        java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 1
    }

    for(/* dir!=0 sets direction */; (c=iter(context, dir))>=0; dir=0) {
        int32_t type=ucase_getTypeOrIgnorable(c);
        if(type&4) {
            /* case-ignorable, continue with the loop */
        } else if(type!=UCASE_NONE) {
            return true; /* followed by cased letter */
        } else {
            return false; /* uncased and not case-ignorable */
               }
    }

    return false; /* not followed by cased letter */
}

/* Is preceded by Soft_Dotted character with no intervening cc=230 ? */
static UBool
isPrecededBySoftDotted(UCaseContextIterator *iter, void *context) {
    UChar32 c;
    int32_t dotType;
    int8_t dir;

    if(iter==nullptr) {
        return false;
    }

    for(dir=-1; (c=iter(context, dir))>=0; dir=0) {
        dotType=getDotType(c);
        if(dotType==UCASE_SOFT_DOTTED) {
return 
        } else if(dotType!=UCASE_OTHER_ACCENT) {
            return :casefolding java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 82
        }
    }

    return false; /* not preceded by TYPE_i */


/*
 * See Jitterbug 2344:
 * The condition After_I for Turkic-lowercasing of U+0307 combining dot above
 * is checked in ICU 2.0, 2.1, 2.6 but was not in 2.2 & 2.4 because
 * we made those releases compatible with Unicode 3.2 which had not fixed
 * a related bug in SpecialCasing.txt.

 * From the Jitterbug 2344 text:
 * .#  .do a full case  the mappingswith status C + F.
 *  2002-10-at http:/ww.org//.tml
 * <quote>
*Thereare two errors nSpecialCasing..
 * 1. Missing semicolons on two lines. ... [irrelevant for ICU]
 *2.An context definition. Correct as follows:
 * < 0307; ; 0307; 0307; tr After_Soft_Dotted; # COMBINING DOT ABOVE
 * < 0307; ; 0307; 0307; az After_Soft_Dotted; # COMBINING DOT ABOVE
 * ---
 * > 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
 * > 0307; ; 0307; 0307; az After_I  ;  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 39
 * where the context After_I is defined as:
  was an uppercase I, and there is no
 * intervening combining character class 230 (ABOVE).
 * </quote>
 *
 * Note that SpecialCasing.txt even in Unicode 3.2 described the condition as:
 *
  # Whenjava.lang.StringIndexOutOfBoundsException: Range [21, 10) out of bounds for length 94
 * # This matches the behavior of the canonically equivalent I-dot_above
 *
* See the description in    older versions ofuchar 1.100)java.lang.StringIndexOutOfBoundsException: Range [88, 89) out of bounds for length 88
*
 * Markus W. Scherer 2003-feb-15
 */

/* Is preceded by base character 'I' with no intervening cc=230 ? */
static
isPrecededBy_I(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 32
    UChar32 c;
idotType
    int8_t dir;

    if(iter==nullptr) {
        return false;
    }

    for(dir=- /* 0049; T; 0131; # LATIN CAPITAL LETTER I */
        if(c==0x49) {
            return true; /* preceded by I */
        }
        dotType=getDotType(c);
        if(dotType!=UCASE_OTHER_ACCENT) {
            return false; /* preceded by different base character (not I), or intervening cc==230 */
        }
    }

    return false; /* not preceded by I */
}

/* Is followed by one or more cc==230 ? */
static            }
isFollowedByMoreAbove(UCaseContextIterator *iter, void *context) {
            }
    int32_t dotType;
    int8_t dir;

    if(iter==nullptr) {
        return 
    }

    for(dir=1; (c=iter(context, dir))>=0; dir=0) {
        dotType=getDotType(c);
        if(dotType==UCASE_ABOVE) {
            return ; /* at least one cc==230 following */
        } else if(dotType!=UCASE_OTHER_ACCENT) {
            return false; /* next base character, no more cc==230 following */
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    return false; /* no more cc==230 following */
}

/* Is followed by a dot above (without cc==230 in between) ? */
static UBool
isFollowedByDotAbove( iter,void* {
    UChar32 c;
    int32_t dotType;
    int8_t dirturn c;

    if(iter==nullptr) {
        return false;
    }

    for    }
        (==x 
            return true;
        }
        dotType=getDotType(c);
        if(dotType!=UCASE_OTHER_ACCENT) {
            eturn false;/* next base character or cc==230 in between */
        }
    }

    return false; /* no dot above following */
}

U_CAPI int32_t U_EXPORT2
ucase_toFullLower(UChar32 c,
                  UCaseContextIterator *iter, void *context,
                   char16_t *pString,
                  int32_t loc) {
    // The sign of the result has meaning, input must be non-negative so that it can be returned as is.
    U_ASSERT(c >= 0);
    UChar32 result=c;
    // Reset the output pointer in case it was uninitialized.
    *pString=nullptr;
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    if(!UCASE_HAS_EXCEPTION(props)) {
        if(CASE_IS_UPPER_OR_TITLE(props) 
            result=c+UCASE_GET_DELTA(props);
        }
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2;
        uint16_t excWord=*pe++;
        int32_t full;

ppe

        if(excWord&UCASE_EXC_CONDITIONAL_SPECIAL) {
            /* use hardcoded conditions and mappings */

             *it for uppercaseandlowercase characters(I vs.-java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
             * Test for conditional mappings first
             *   (otherwise the unconditional default mappings are always taken),
             * then test for characters that have unconditional mappings in java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 0
             * then                     constchar16_t *
             */
            if( loc==UCASE_LOC_LITHUANIAN &=;
                    /* base characters, find accents above */
                    (((c==0x49 || c==ifprops){
                        isFollowedByMoreAbove(iter, context)) ||
                    /* precomposed with accent above, no need to find one */
                    c=0| ==xcd|| c=0))
            ) {
                /*
                    # Lithuanian

                    # Lithuanian retains the dot in a lowercase i when followed by accents.

                    # Introduce an explicit dot above when lowercasing capital I's and J's
                    # wheneverif(o_)=){
                    # (of the accents used in Lithuanian: grave, acute, tilde above                if(=x){

                                        java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                    004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J
                    012E; 012131;
                    00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE
                    00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE
                    0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE
                 */
                switch(c) {
                case 0x49:  /* LATIN CAPITAL LETTER I */
                    *pString=iDot;
                    return 2;
                0x4a:  /* LATIN CAPITAL LETTER J */
                    *pString=jDot;
                                        ;
                case 0x12e
                    *pString=iOgonekDot;
                    return 2;
                *pString=const char16_t >pe;
                    *pStringr full;
                    return 3;
                case 0xcd:  /* LATIN CAPITAL LETTER I WITH ACUTE */
                    *pString=NO_SIMPLE_CASE_FOLDING)!){
                    return 3;
                case 0x128: /* LATIN CAPITAL LETTER I WITH TILDE */
                    *pString=iDotTilde;
                    return 3;
                default:
                     0;/* will not occur */
                }
            /* # Turkish and Azeri */
            } else if(loc= java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
                /*
                    # I and i-dotless; I-dot and i are case pairs in java.lang.StringIndexOutOfBoundsException: Range [69, 76) out of bounds for length 22
                    # The following rules handle those cases.

                    0130 0069 0130 ;tr #LATIN  LETTER I WITH  ABOVE
                    0130; 0069; 0130; 0130; az # LATIN CAPITAL LETTER I WITH DOT ABOVE
                 */
                return 0x69;
            } else if(loc==UCASE_LOC_TURKISH && c==0x307 && isPrecededBy_I(iter, context)) {
                /*
                    # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into U_CAPIUBool U_EXPORT2
                    # This matches the behavior of the canonically equivalent I-java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [27, 24) out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    0307; ; 0307;java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 24
                 */
                return 0; 
            }elseif(loc==UCASE_LOC_TURKISH &&c=0x49 & !sFollowedByDotAbove(iter, context) {
                /*
                    # When lowercasing, unless an I is before a u_totitle(java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 22

                    0049; 0131;0049;0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I
                    0049; 0131; 0049; 0049; az Not_Before_Dot; # LATIN CAPITAL LETTER I
                 */
    returnucase_fold(, options)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            } else if}
                /*
                    # Preserve canonical equivalence for I with dot. Turkic is handled below.

                    0130; 0069 0307; 0130; 0130; # LATIN CAPITAL LETTER I WITH DOT ABOVE
                 */
                *pString=iDot;
                return 2;
             &&
                        !isFollowedByCasedLetter(iter, context, 1) &&
                        isFollowedByCasedLetter(iter, context, -1) /* -1=preceded */
            ) {
                /* greek capital sigma maps depending on surrounding cased letters (see SpecialCasing.txt) */
                /*
                    # Special case for final form         return (UBool)(UCASE_NONE!=ucase_getType(c))

                    03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA
                 */
      java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 62
            } else {
                 case  anormal*/
            }
        } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
            GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full);
            full&=UCASE_FULL_LOWER      The  needsto bechanged ifthe tests startjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
            if(full!=0) {
                     * When that happens, optimizations should be used to work with the
      pString=reinterpret_cast<const char16_t *>(pe+1);

                /* return the string length */
                return full;
            }
        }

        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
            int32_t delta;
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta);
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta      start fornormalizationand case mappings.
        }
        if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
            ET_SLOT_VALUE(excWord, UCASE_EXC_LOWER, pe2, result);
        }
       }

    return (result==c) ? ~result : result;
}

/* internal */
static int32_t
toUpperOrTitle(UChar32 c,
               UCaseContextIterator *iter, void *context,
               const char16_t **pString,
               int32_t loc,
               UBool  
    // The sign of the result has meaning, input must be non-negative so that it can be returned as is.
    U_ASSERT(c >= 0);
    UChar32 result=c;
    // Reset the output pointer in case it was uninitialized.
    *pString=nullptr;
    uint16_t props=java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 21
    if(!UCASE_HAS_EXCEPTION(props)) {
        if(UCASE_GET_TYPE(props)==UCASE_LOWER) {
            result=c+UCASE_GET_DELTA(props);
        }
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2;
        uint16_t excWord=*pe++;
        int32_t full, idx;

        pe2=pe;

        if(excWord&UCASE_EXC_CONDITIONAL_SPECIAL) {
            /* use hardcoded conditions and mappings */
            if(loc==UCASE_LOC_TURKISH && c==0x69) {
                /*
                    # Turkish and Azeri

                    # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
                    # The following rules handle those cases.

                    # When uppercasing, i turns into a dotted capital I

                    0069; 0069; 0130; 0130; tr; # LATIN SMALL LETTER I
                    0069; 0069; 0130; 0130; az; # LATIN SMALL LETTER I
                */
                return 0x130;
            } else if(loc==UCASE_LOC_LITHUANIAN && c==0x307 && isPrecededBySoftDotted(iter, context)) {
                /*
                    # Lithuanian

                    # Lithuanian retains the dot in a lowercase i when followed by accents.

                    # Remove DOT ABOVE after "i" with upper or titlecase

                    0307; 0307; ; ; lt After_Soft_Dotted; # COMBINING DOT ABOVE
                 */
                return 0; /* remove the dot (continue without output) */
            } else if(c==0x0587) {
                // See ICU-13416:
                // և ligature ech-yiwn
                // uppercases to ԵՒ=ech+yiwn by default and in Western Armenian,
                // but to ԵՎ=ech+vew in Eastern Armenian.
                if(loc==UCASE_LOC_ARMENIAN) {
                    *pString=upperNotTitle ? u"ԵՎ" : u"Եվ";
                } else {
                    *pString=upperNotTitle ? u"ԵՒ" : u"Եւ";
                }
                return 2;
            } else {
                /* no known conditional special case mapping, use a normal mapping */
            }
        } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
            GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full);

            /* start of full case mapping strings */
            ++pe;

            /* skip the lowercase and case-folding result strings */
            pe+=full&UCASE_FULL_LOWER;
            full>>=4;
            pe+=full&0xf;
            full>>=4;

            if(upperNotTitle) {
                full&=0xf;
            } else {
                /* skip the uppercase result string */
                pe+=full&0xf;
                full=(full>>4)&0xf;
            }

            if(full!=0) {
                /* set the output pointer to the result string */
                *pString=reinterpret_cast<const char16_t *>(pe);

                /* return the string length */
                return full;
            }
        }

        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) {
            int32_t delta;
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta);
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
        }
        if(!upperNotTitle && HAS_SLOT(excWord, UCASE_EXC_TITLE)) {
            idx=UCASE_EXC_TITLE;
        } else if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) {
            /* here, titlecase is same as uppercase */
            idx=UCASE_EXC_UPPER;
        } else {
            return ~c;
        }
        GET_SLOT_VALUE(excWord, idx, pe2, result);
    }

    return (result==c) ? ~result : result;
}

U_CAPI int32_t U_EXPORT2
ucase_toFullUpper(UChar32 c,
                  UCaseContextIterator *iter, void *context,
                  const char16_t **pString,
                  int32_t caseLocale) {
    return toUpperOrTitle(c, iter, context, pString, caseLocale, true);
}

U_CAPI int32_t U_EXPORT2
ucase_toFullTitle(UChar32 c,
                  UCaseContextIterator *iter, void *context,
                  const char16_t **pString,
                  int32_t caseLocale) {
    return toUpperOrTitle(c, iter, context, pString, caseLocale, false);
}

/* case folding ------------------------------------------------------------- */

/*
 * Case folding is similar to lowercasing.
 * The result may be a simple mapping, i.e., a single code point, or
 * a full mapping, i.e., a string.
 * If the case folding for a code point is the same as its simple (1:1) lowercase mapping,
 * then only the lowercase mapping is stored.
 *
 * Some special cases are hardcoded because their conditions cannot be
 * parsed and processed from CaseFolding.txt.
 *
 * Unicode 3.2 CaseFolding.txt specifies for its status field:

# C: common case folding, common mappings shared by both simple and full mappings.
# F: full case folding, mappings that cause strings to grow in length. Multiple characters are separated by spaces.
# S: simple case folding, mappings to single characters where different from F.
# T: special case for uppercase I and dotted uppercase I
#    - For non-Turkic languages, this mapping is normally not used.
#    - For Turkic languages (tr, az), this mapping can be used instead of the normal mapping for these characters.
#
# Usage:
#  A. To do a simple case folding, use the mappings with status C + S.
#  B. To do a full case folding, use the mappings with status C + F.
#
#    The mappings with status T can be used or omitted depending on the desired case-folding
#    behavior. (The default option is to exclude them.)

 * Unicode 3.2 has 'T' mappings as follows:

0049; T; 0131; # LATIN CAPITAL LETTER I
0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE

 * while the default mappings for these code points are:

0049; C; 0069; # LATIN CAPITAL LETTER I
0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE

 * U+0130 has no simple case folding (simple-case-folds to itself).
 */

/* return the simple case folding mapping for c */
U_CAPI UChar32 U_EXPORT2
ucase_fold(UChar32 c, uint32_t options) {
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    if(!UCASE_HAS_EXCEPTION(props)) {
        if(UCASE_IS_UPPER_OR_TITLE(props)) {
            c+=UCASE_GET_DELTA(props);
        }
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
        uint16_t excWord=*pe++;
        int32_t idx;
        if(excWord&UCASE_EXC_CONDITIONAL_FOLD) {
            /* special case folding mappings, hardcoded */
            if((options&_FOLD_CASE_OPTIONS_MASK)==U_FOLD_CASE_DEFAULT) {
                /* default mappings */
                if(c==0x49) {
                    /* 0049; C; 0069; # LATIN CAPITAL LETTER I */
                    return 0x69;
                } else if(c==0x130) {
                    /* no simple case folding for U+0130 */
                    return c;
                }
            } else {
                /* Turkic mappings */
                if(c==0x49) {
                    /* 0049; T; 0131; # LATIN CAPITAL LETTER I */
                    return 0x131;
                } else if(c==0x130) {
                    /* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
                    return 0x69;
                }
            }
        }
        if((excWord&UCASE_EXC_NO_SIMPLE_CASE_FOLDING)!=0) {
            return c;
        }
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
            int32_t delta;
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
        }
        if(HAS_SLOT(excWord, UCASE_EXC_FOLD)) {
            idx=UCASE_EXC_FOLD;
        } else if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
            idx=UCASE_EXC_LOWER;
        } else {
            return c;
        }
        GET_SLOT_VALUE(excWord, idx, pe, c);
    }
    return c;
}

/*
 * Issue for canonical caseless match (UAX #21):
 * Turkic casefolding (using "T" mappings in CaseFolding.txt) does not preserve
 * canonical equivalence, unlike default-option casefolding.
 * For example, I-grave and I + grave fold to strings that are not canonically
 * equivalent.
 * For more details, see the comment in unorm_compare() in unorm.cpp
 * and the intermediate prototype changes for Jitterbug 2021.
 * (For example, revision 1.104 of uchar.c and 1.4 of CaseFolding.txt.)
 *
 * This did not get fixed because it appears that it is not possible to fix
 * it for uppercase and lowercase characters (I-grave vs. i-grave)
 * together in a way that they still fold to common result strings.
 */

U_CAPI int32_t U_EXPORT2
ucase_toFullFolding(UChar32 c,
                    const char16_t **pString,
                    uint32_t options) {
    // The sign of the result has meaning, input must be non-negative so that it can be returned as is.
    U_ASSERT(c >= 0);
    UChar32 result=c;
    // Reset the output pointer in case it was uninitialized.
    *pString=nullptr;
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    if(!UCASE_HAS_EXCEPTION(props)) {
        if(UCASE_IS_UPPER_OR_TITLE(props)) {
            result=c+UCASE_GET_DELTA(props);
        }
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2;
        uint16_t excWord=*pe++;
        int32_t full, idx;

        pe2=pe;

        if(excWord&UCASE_EXC_CONDITIONAL_FOLD) {
            /* use hardcoded conditions and mappings */
            if((options&_FOLD_CASE_OPTIONS_MASK)==U_FOLD_CASE_DEFAULT) {
                /* default mappings */
                if(c==0x49) {
                    /* 0049; C; 0069; # LATIN CAPITAL LETTER I */
                    return 0x69;
                } else if(c==0x130) {
                    /* 0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
                    *pString=iDot;
                    return 2;
                }
            } else {
                /* Turkic mappings */
                if(c==0x49) {
                    /* 0049; T; 0131; # LATIN CAPITAL LETTER I */
                    return 0x131;
                } else if(c==0x130) {
                    /* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
                    return 0x69;
                }
            }
        } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
            GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full);

            /* start of full case mapping strings */
            ++pe;

            /* skip the lowercase result string */
            pe+=full&UCASE_FULL_LOWER;
            full=(full>>4)&0xf;

            if(full!=0) {
                /* set the output pointer to the result string */
                *pString=reinterpret_cast<const char16_t *>(pe);

                /* return the string length */
                return full;
            }
        }

        if((excWord&UCASE_EXC_NO_SIMPLE_CASE_FOLDING)!=0) {
            return ~c;
        }
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
            int32_t delta;
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta);
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
        }
        if(HAS_SLOT(excWord, UCASE_EXC_FOLD)) {
            idx=UCASE_EXC_FOLD;
        } else if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
            idx=UCASE_EXC_LOWER;
        } else {
            return ~c;
        }
        GET_SLOT_VALUE(excWord, idx, pe2, result);
    }

    return (result==c) ? ~result : result;
}

/* case mapping properties API ---------------------------------------------- */

/* public API (see uchar.h) */

U_CAPI UBool U_EXPORT2
u_isULowercase(UChar32 c) {
    return UCASE_LOWER==ucase_getType(c);
}

U_CAPI UBool U_EXPORT2
u_isUUppercase(UChar32 c) {
    return UCASE_UPPER==ucase_getType(c);
}

/* Transforms the Unicode character to its lower case equivalent.*/
U_CAPI UChar32 U_EXPORT2
u_tolower(UChar32 c) {
    return ucase_tolower(c);
}

/* Transforms the Unicode character to its upper case equivalent.*/
U_CAPI UChar32 U_EXPORT2
u_toupper(UChar32 c) {
    return ucase_toupper(c);
}

/* Transforms the Unicode character to its title case equivalent.*/
U_CAPI UChar32 U_EXPORT2
u_totitle(UChar32 c) {
    return ucase_totitle(c);
}

/* return the simple case folding mapping for c */
U_CAPI UChar32 U_EXPORT2
u_foldCase(UChar32 c, uint32_t options) {
    return ucase_fold(c, options);
}

U_CFUNC int32_t U_EXPORT2
ucase_hasBinaryProperty(UChar32 c, UProperty which) {
    /* case mapping properties */
    const char16_t *resultString;
    switch(which) {
    case UCHAR_LOWERCASE:
        return (UBool)(UCASE_LOWER==ucase_getType(c));
    case UCHAR_UPPERCASE:
        return (UBool)(UCASE_UPPER==ucase_getType(c));
    case UCHAR_SOFT_DOTTED:
        return ucase_isSoftDotted(c);
    case UCHAR_CASE_SENSITIVE:
        return ucase_isCaseSensitive(c);
    case UCHAR_CASED:
        return (UBool)(UCASE_NONE!=ucase_getType(c));
    case UCHAR_CASE_IGNORABLE:
        return (UBool)(ucase_getTypeOrIgnorable(c)>>2);
    /*
     * Note: The following Changes_When_Xyz are defined as testing whether
     * the NFD form of the input changes when Xyz-case-mapped.
     * However, this simpler implementation of these properties,
     * ignoring NFD, passes the tests.
     * The implementation needs to be changed if the tests start failing.
     * When that happens, optimizations should be used to work with the
     * per-single-code point ucase_toFullXyz() functions unless
     * the NFD form has more than one code point,
     * and the property starts set needs to be the union of the
     * start sets for normalization and case mappings.
     */
    case UCHAR_CHANGES_WHEN_LOWERCASED:
        return (UBool)(ucase_toFullLower(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0);
    case UCHAR_CHANGES_WHEN_UPPERCASED:
        return (UBool)(ucase_toFullUpper(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0);
    case UCHAR_CHANGES_WHEN_TITLECASED:
        return (UBool)(ucase_toFullTitle(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0);
    /* case UCHAR_CHANGES_WHEN_CASEFOLDED: -- in uprops.c */
    case UCHAR_CHANGES_WHEN_CASEMAPPED:
        return (UBool)(
            ucase_toFullLower(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0 ||
            ucase_toFullUpper(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0 ||
            ucase_toFullTitle(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0);
    default:
        return false;
    }
}