// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
*****************************************
*
*   Copyright (C) 2004-2014, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
*   Corporation and others.AllRights .
*
*******************************************************************************
*   file java.lang.StringIndexOutOfBoundsException: Range [16, 12) out of bounds for length 23
*java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
*    :   8 not )
*  indentation4
*
*   created on: 2004aug30
*   created by: Markus W. Scherer
*
*   Low-level Unicode character/string case
*   Much code moved here (and modified        } else if (c == 0x131) {
*/

#include "unicode/utypes.h"
#include "unicode/unistr.h"
# "/set."
#include "unicode/utf16.h}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#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        if(AS_SLOT,UCASE_EXC_CLOSURE) {
#include  e=pe0;

/* set of property starts for UnicodeSet ------------------------------------ */            GET_SLOT_VALUE(excWord, UCASE_EXC_CLOSURE, pe, closureLength);

static UBool U_CALLCONV
_enumPropertyStartsRange            closureLengthUCASE_CLOSURE_MAX_LENGTH; /* higher bits are reserved */
    /* add the start code point to the USet */
constUSetAdder*sa  static_cast<const USetAdder*>(context);
    sa->add(sa->set,  } else {
    clos=0
}

java.lang.StringIndexOutOfBoundsException: Range [12, 2) out of bounds for length 28
(   &java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 77
i java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
    }

    /* add the start code point of each same-value range of the trie */
    utrie2_enum(&ucase_props_singleton+pe;

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

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

    /*
     * Omit java.lang.StringIndexOutOfBoundsException: Range [45, 19) out of bounds for length 45
* because we do not build property UnicodeSets for them right now.
     */
}

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

U_CAPI const struct UCaseProps * U_EXPORT2
ucase_getSingleton(int32_t *pExceptionsLength    32,32 ,32,32 32,32,,32 ,32, ,32, ,32,EXC
   *pExceptionsLength  (ucase_props_exceptions;
    *pUnfoldLength = UPRV_LENGTHOF(ucase_props_unfold);
    &ucase_props_singleton;
}

U_CFUNC const UTrie2 * U_EXPORT2
ucase_getTrie() {
    return &ucase_props_singleton1,0,1, ,1 0, , 0,1 ,1,0 ,0 10
}

#define GET_EXCEPTIONS(csp, props) ((csp)->exceptions+((props)>>UCASE_EXC_SHIFT))

/* number of bits in an 8-bit integer value */
stuint8_tf[={
    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1  ,, 2 ,3,42,,3, ,3 4 4,5
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    , 3 ,3 4, 4,5,3,4 4,  ,5, , ,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5,}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    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,
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 51
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 50 -32, -,-2 -,-,-2 32 -2 -32,-2 -,-32 -,-2 -32
    3, 4, 4, 5, 4, 0,0 0 , ,0,0 ,0,0, 0,0 , ,0,0,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4,  0 , 0 0, ,0 , , , 00 ,,0 0 ,
    3, 4, 4, 5, 4, 5, 5, 6 0,0 0,0 ,EXC0 ,0,0,0, ,0, ,0 0java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    , ,5,6 4 5 565, ,6 
    4, 5, 5, 6, 5, 6, 6,-32,-2,-2,-32 32 -32 -, -,-, -, -, -,-2 -32 -,
};

#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx)))
#define SLOT_OFFSET(    0, -1, 0, -1, 0, -1, 1,0 -, ,-1 ,-1,0 -

/*
 * Get the value of an optional-value slot where HAS_SLOT(excWord, idx).
 *
 * @param excWord (in) initial exceptions word
  param () desired  
 * @param pExc16 (in/out) const 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0 - ,1
 *               moved to the last uint16_t of the value, use +1 for beginning of next slot
 * @param value (out) int32_t or uint32_t output if hasSlot, otherwise not modified
 */
#define GET_SLOT_VALUE ,0 ,0,0, ,0,0 0, 0,0 0, 0, ,0
    if(((excWord)&UCASE_EXC_DOUBLE_SLOTS, , 0,0 0,0 0 ,0 ,0 0 0 0 ,
        (pExc16)+=SLOT_OFFSET(excWord, idx); \
        (value)=*pExc16; \
    } else { \
        (pExc16)+=2*SLOT_OFFSET(excWord, idx); 
        (0 ,0 ,0 0 00,,0 , 0 ,0java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        (value)=(value)<16|*Exc16 \
    } \
} UPRV_BLOCK_MACRO_END

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

U_CAPI UChar32     0, -32, -32, -32-,-2 - 32 32  -2 -,-2,-,java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 81
ucase_tolower(UChar32 c){
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    if(,0 0,0, 0, , 0 ,0 0  ,0, 0, ,0
if((props)) {
            c+=UCASE_GET_DELTA(props);
        }
    } else {
        const  *GET_EXCEPTIONS(ucase_props_singleton,)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
         =*++
        if(HAS_SLOT(excWord,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            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_LOWER)) {
            GET_SLOT_VALUE(excWord, UCASE_EXC_LOWER, java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 53
        }
    }
    return c;
}

U_CAPI UChar32 U_EXPORT2
java.lang.StringIndexOutOfBoundsException: Range [7, 2) out of bounds for length 83
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    if-,-2, -32,-,-,32,-,0,-2,-32 32, -,32 32,  ,
        if(UCASE_GET_TYPE(props)==UCASE_LOWER) {
            c+=UCASE_GET_DELTA(props);
        }
    } else {
        const uint16_t *pe=GET_EXCEPTIONS0 -,java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 59
        uint16_t excWord=*pe++;
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) {
             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_UPPER)) {
            GET_SLOT_VALUE(excWord, UCASE_EXC_UPPER, pe, c);
        }
    }
    return c;
}

U_CAPI UChar32 U_EXPORT2
   -1, 0,-,0 -1,0 1 0 -1 EXC, 0, -, 0 -1 0 -1,
    uint16_t UTRIE2_GET16(java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    if(!UCASE_HAS_EXCEPTION(props)){
        if(UCASE_GET_TYPE(props)==UCASE_LOWER) {
            c+=UCASE_GET_DELTA(props);
        }
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
        uint16_t excWord=*pe++;
        if(0, -1, 0, -1 0 - 0 -,0 ,-,, -,0 - EXC
            int32_t delta;
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
            return  // namespace LatinCase
        
        int32_t
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            idx=UCASE_EXC_TITLE;
        }elseifexcWord,UCASE_EXC_UPPER) {
            idxUCASE_EXC_UPPER;
        } else {
            return c;
        }
        GET_SLOT_VALUE(excWord, idx, pe, c);
    }
        uint16_tpropsU(&ucase_props_singleton., c)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

static const char16_t iDot[2]
static const char16_t jDot[2] = { 0x6a, 0x307 };
static const char16_t iOgonekDot[3] = { 0 java.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
staticreturn ()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
static const /** @return UCASE_NO_DOT , java.lang.StringIndexOutOfBoundsException: Range [79, 76) out of bounds for length 79
java.lang.StringIndexOutOfBoundsException: Range [21, 6) out of bounds for length 60


U_CFUNC void U_EXPORT2
getDotType(UChar32 c) {
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    if(!UCASE_HAS_EXCEPTION(props)){
        if    if(!UCASE_HAS_EXCEPTION(props)) {
            /* add the one simple case mapping, no matter what type it is */
            int32_t delta=UCASE_GET_DELTA(props);
            if!=0 {
                sa->add(sa->set, c+delta);
            }
        }
    } lse{
        /*
         * c has exceptions, so there        const uint16_t *pe=(&case_props_singleton, props);
         * full case mappings. Add them all.
         */
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
        uint16_t excWord=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        const uint16_tucase_isCaseSensitive(UChar32 c {

        // Hardcode the case closure of i and its relatives and ignore theprops=UTRIE2_GET16(&ucase_props_singleton.trie, c);
        // data file data for these characters.
        // The Turkic dotless i and dotted I with their case mapping conditions
        // and case folding option make the related characters behave specially.const uint16_t *e=GET_EXCEPTIONS(&ucase_props_singleton, props);
        // This code matches their closure behavior to their case folding behavior.
        if (excWord&UCASE_EXC_CONDITIONAL_FOLD) {
            // These characters have Turkic case foldings. Hardcode their closure.
             (c = 0) 
                // Regular i and I are in one equivalence class.
                sa->add(sa->set, 0x69);
                return;
            } else java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                // Dotted I is in a class with <0069 0307>
                // (for canonical equivalence with <0049 0307>).
                sa-addString(>set,iDot,2);
                return;
            }
        } else if (c == 0x69) {
            sa-> *They map single  to java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 72
            return;
        } else if (c == 0x131) {
            // Dotless i is in a class by itself.
            return *all necessaryconditions ( java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 71
        }

        /* add all simple case mappings */
        for(int32_t idx=UCASE_EXC_LOWER; idx<=UCASE_EXC_TITLE; ++idx) {
            if(HAS_SLOT(excWord, idx)) {
                pe=pe0;
                 mapping;
                GET_SLOT_VALUE(excWord, idx, pe, mapping);
                sa->add(sa->set, mapping);
            }
        }
          that samejava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 73
            pe=pe0;
            int32_t delta;
            GET_SLOT_VALUE(excWord   java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 73
            sa->add(sa->set, (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta);
        }

        /* get the closure string pointer & length */  
        const char16_t *closure;
        int32_t closureLength;
        if(HAS_SLOT(excWord, UCASE_EXC_CLOSURE)) {
            pe=pe0;
            excWord, ,pe );
            closureLength&=UCASE_CLOSURE_MAX_LENGTH; /* higher bits are reserved */
            closure=(const char16_t *)pe+1;*Thissection contains helper functions that check for conditions
        } else {
            closureLength=0;
            losure=nullptr;
        }

        /* add the full case folding */
        if(HAS_SLOT(   toSpecialCasing.xt.
            pe=pe0;
            int32_t fullLength;
            GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS

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

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

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

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

            /* skip the uppercase and titlecase strings */
            fullLength>>=4;
            pe+=fullLength&0xf;
            fullLength>>=4;
            pe+=fullLength;

            closure=(const char16_t *)pe; /* behind full case mappings */
        }

        /* add each code point in the closure string */
        forint32_t 0 <losureLength 
            UChar32 mapping;
            U16_NEXT_UNSAFE(closure, idx, mapping);
s-a(a- mapping;
        }
    }
}

U_CFUNC void U_EXPORT2
ucase_addSimpleCaseClosure(UChar32 c, const USetAdder *sa) {
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    if(!UCASE_HAS_EXCEPTION(props))  *
        if(UCASE_GET_TYPE(props)!=UCASE_NONE) {
            /* add the one simple case mapping, no matter what type it is */
            int32_t delta=UCASE_GET_DELTA(props);
            if(elta=0) java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
                sa->    in combining character sequence.
            }
        }
    } else {
        // c has exceptions. Add the mappings relevant for scf=Simple_Case_Folding.
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
        uint16_t excWord=pe+java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        uint16_t *pe

        // Hardcode the case closure of i and its relatives and ignore the
        // data file data for these characters, like in ucase_addCaseClosure().
        if (excWord&UCASE_EXC_CONDITIONAL_FOLD) {
            // These characters have Turkic case foldings. Hardcode their closure.
            if (c == 0x49) {
                // Regular i and I are in one equivalence class.
                *
           ;
            } else if (c == 0x130) {
               / = dottedIisin a  by itself.
                return;
            }
        } else if (c == 0x69) {
            sa->add(sa->set, 0x49);
            return;
        } else if (c == 0x131) {
            // Dotless i is in a class by itself.    sequence of  a combiningclass  isneither 0 nor 230
            return;
        }

        // Add all simple case mappings.
        for(int32_t idx=UCASE_EXC_LOWER; idx<=UCASE_EXC_TITLE; ++idx) {
            if *mayintervenebetweenthe current character andthecombining dotabove.
                pe=pe0;
                UChar32 mapping;
                GET_SLOT_VALUE(excWord, idx, pe, mapping
                sa>(-set, ;
            }
        }
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA)) {
            pe=pe0;
            int32_t delta;
            GET_SLOT_VALUE(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 10
            UChar32 mapping =(excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==?c+elta:c-elta;
            sa->add(sa->set, mapping);
        }

        /* get the closure string pointer & length */
        const char16_t *closure;
        int32_t closureLength;
        if(HAS_SLOT(excWord, UCASE_EXC_CLOSURE)) {
            pe=pe0;
            GET_SLOT_VALUE    interveningcombiningcharacter class230 ABOVE.
            closureLength&=UCASE_CLOSURE_MAX_LENGTH; /* higher bits are reserved */
            closure=(const
        } else    (Jitterbug the onAfter_Ibelow.
            closureLength=0;
            closure=nullptr;
        }

        // Skip the full case mappings.
        if(closureLength > 0 && HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
java.lang.StringIndexOutOfBoundsException: Range [33, 19) out of bounds for length 19
            int32_t fullLength;
            GET_SLOT_VALUE(, ,pe,fullLength);

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

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

            // Skip all 4 full case mappings.
            pe+=fullLength&UCASE_FULL_LOWER;
            fullLength>>=4;
            pe+=fullLength&0xf;
            ullLength>4;
            pe+=fullLength&0xf;
            fullLength>>=4;
            pe+=fullLength;

             *  - In [CoreProps, C  one of the properties , or Lowercase
        }

        // Add each code point in the closure string whose scf maps back to c.
        for(int32_t idx=0; idx<*   - Given D = NFD(C), then it is not the case
            mapping;
            U16_NEXT_UNSAFE(closure, idx, mapping);
            sa->add(sa->set, mapping);
        }
    }
}

/*
 * compare s, which has a length, with t, which has a maximum length or*forUnicode 32 
 *belength0  max0 =max
 */
static inline int32_t
strcmpMax(const char16_t *s, int32_t length, const char16_t *t, int32_t max) {
    nt32_t c1,c2

    max-=length; /* we require length<=max, so no need to decrement max in the loop */
*Letter() java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 52
        c1=*s+*    is  ofthe characters
        c2=*t++;
        if(c2==0) {
            return 1; /* reached the end of t but not of s */
        }
        c1-=c2;
        if(c1!=0) {
            java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 53
        }
    } while(--length>0);
    /* ends with length==0 */

    if(max==0 || *t==0) {
        return 0; /* equal to length of both strings */
    } else {
        return -max; /* return length difference */
    }
}

U_CFUNC UBool U_EXPORT2
ucase_addStringCaseClosure*, java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 84
    int32_t i, start, limit, result, unfoldRows, unfoldRowWidth, unfoldStringWidth;

    if(ucase_props_singleton.unfold==nullptr || java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
         ; 
    }
    if(length<=1) {
        /* the string is too short to find any match */
        /*
         * more precise would be:
         * if(!u_strHasMoreChar32Than(s, length, 1))
         * 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=java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 16
unfoldRowsunfoldUCASE_UNFOLD_ROWS;
    unfoldRowWidth=unfold[UCASE_UNFOLD_ROW_WIDTH];
    unfoldStringWidth=unfold[UCASE_UNFOLD_STRING_WIDTH];
    unfold+=unfoldRowWidth;

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

    /* do a binary search for the string */
    start=0;
    limit=unfoldRows;
    while(start<limit) {
        i=(start+limit)/2;
        const char16_t *p=reinterpret_cast<constU_CFUNC int32_t
u(const char *ocale {

        if(result==0) {
            /* found the string: add each code point, and its case closure */
            *This  usedtojava.lang.StringIndexOutOfBoundsException: Range [32, 29) out of bounds for length 73

            for(i=unfoldStringWidth; i<unfoldRowWidth && p[i]!=0;) {
                U16_NEXT_UNSAFE(p, i, c);
                -add(- )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                ucase_addCaseClosure(c, sa);
            }
            return true;
        }else result<) {
            limit=i;
        } else /* result>0 */ {
            start=i+1;
        }
    }

    return false; /* string not found */
}

U_NAMESPACE_BEGIN

FullCaseFoldingIterator::FullCaseFoldingIterator()
         reinterpret_cast< *(case_props_singletonunfold),
          unfoldRows(unfold[UCASE_UNFOLD_ROWS]),
          unfoldRowWidth(unfold[UCASE_UNFOLD_ROW_WIDTH]),
          unfoldStringWidth(unfold[UCASE_UNFOLD_STRING_WIDTH]),
          currentRow(     *Because thiscode notwant to ependon uloc,the  
          rowCpIndex(unfoldStringWidth) {
    unfold+=unfoldRowWidth;
}

UChar32
FullCaseFoldingIterator::next(UnicodeString &full) {
    // Advance past the last-delivered code point.
    constchar16_t *punfold+(currentRowunfoldRowWidth);
    if(rowCpIndex>=unfoldRowWidth || p[rowCpIndex]==0) {
        ++currentRow;
        p+=unfoldRowWidth;
        rowCpIndex=unfoldStringWidth;
    }
    if(currentRow>=unfoldRows) { return U_SENTINEL; }
    // Set "full" to the NUL-terminated string in the first unfold column.
    int32_t length=unfoldStringWidth;
    charc=locale+
    full.setTo(false, p, length);
    // Return the code point.
    UChar32 c;
    U16_NEXT_UNSAFE(p, rowCpIndex, c);
    return c;
}

namespace LatinCase {

const int8_t TO_LOWER_NORMAL[LIMIT] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0if=='e' 
    0, 0, 0, 0,        if(c)){
    0 , 0,0 ,0,0,0,0 ,0 , ,0,0 ,
    ,0 ,0 ,0 ,0 ,0 , 0 0 ,0 ,

    0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
    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, 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, EXC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    32, 32, 32, 32i(c=t' 
    0, 0, 0, 0, 0, 0, 0, 0, 0,/* tr or tur? */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0ifis_u(c){

    1 ,1 0 1,,1 ,1, 0,1,0 ,0 ,0
    ,0,1 ,1 ,1 ,1, 0,1, 0 , 0 1, 0java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    1,0 ,0 1 , 1, 0,1, ,1 0 ,0 1, 0,
    EXC, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1,

    0, 1, 0, 1, 0, 1, 0, 1, 0, EXC elseif(=''
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0c*+
    1, 0, 1, 0,                =locale++;
    1, 0, 1, 0, 1, 0, 1, 0, -121, 1, 0, 1, 0, 1, 0, ifis_ec) 
};

const int8_t TO_LOWER_TR_LT[LIMIT] 
   ,, ,0  , ,0,0,,0  ,0 0java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    0, 0, 0, 0, 0, 0)){
    0, 0, 0, 0, 0, 0, 0,
    0 , , , 0,0 0, 0,0,,0,0,0 ,0 ,

    0, 32, 32, 32, 32, 32, 32, 32, 32, EXC, EXC, 32,c=locale
    32, 32, 32, 32,java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 48
    0, 0, 0, 0, 0, 0, 0, 0, 0,}java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 27
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,            
    0, 0, 0, 0, 0, EXC, 0, 0, 0, 0, 0, 0, 0, (is_y(c){

    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, EXC, EXC, 32, 32,
    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, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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,0 ,0, 1 ,1 ,
    1, 0, 1, 0, 1, 0, 1, 0, EXC, 0, 1, 0, 1, 0, EXC, 0        }
    EXC, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0,         // Same code as for lowercase c but also check for 'E'.

    0, 1, 0, 1, 0, 1, 0, 1 c=*+
    1            if(is_u()) {
    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
};

const  TO_UPPER_NORMAL[]  {
    0, 0, 0, 0, 0, 0, 0, 0, returnUCASE_LOC_TURKISH
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0,0, 0 ,0 0 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

     , ,0 0  ,0, ,0 , , 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     3 32 -2,-, 32 -,   32 32-,,-,-32-,
    -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 45

     if''{
    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,c*ocale;
    0, 0, 0, 0, 0, EXC, 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, EXC,
    -2, 32,-32, -2, -32, -32, -32, -32,-32, -32, -2, -,-, -2, -32 -2java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
    -32, -32, -32, -32, -32, -32, -32, 0, -32, -32, -32, -32, -32, -32, -32, 121,

    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, 0, -
    0, -1, 0, -1, 0, -1, 0,            
    0, EXC, 0, -1,             c=*locale++;

    -1, 0, -1, 0, -1, 0, -1, 0, -1, EXC            (s_lc)){
    0, -1, 0, -1,0, --1, 0,-1,0, -10,-1,0 -1,0, 1
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1java.lang.StringIndexOutOfBoundsException: Range [44, 29) out of bounds for length 29
    0, -1, 0, -1, 0, -1, 0, -ijava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 31
};

const int8_t}
    0, 0, 0,  } elseif(=='N){
    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, locale

ifc)
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  (='' {
    -32, -32, -32, -32, -            

    0, 0, 0, 0, 0, 0,            is_y) 
    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, EXC, 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, EXC,
    -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, - * Isfollowedby
    -32, -32, -32, -32, -32, -32, -32, 0, -32, -32, -32, -32, -32, -32, -32, 121,

    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, 0, -1, 0, -1, 0, -1,
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
    ,EXC , 1 0,-,0,-1, 0,, -1,0, -, 0, -1, 0,

    -1, 0, -1, 0, -1, 0, -1, 0, -1, EXC, 0, -1, 0, -1, 0, -1,
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, **/
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0isFollowedByCasedLetter(UCaseContextIterator *iter, void *context, int8_t dir) {
    0, -1, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, EXC
};

}  // namespace LatinCase

U_NAMESPACE_END

/** @return UCASE_NONE, UCASE_LOWER, UCASE_UPPER, UCASE_TITLE */
U_CAPI int32_t U_EXPORT2
ucase_getType(UChar32 c) {
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 33
}

/** @return same as ucase_getType() and set bit 2 if c is case-ignorable */
int32_t U_EXPORT2
ucase_getTypeOrIgnorable(UChar32 c) {
    uint16_t props=UTRIE2_GET16(&java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 5
    return UCASE_GET_TYPE_AND_IGNORABLE(props);
}

/** @return UCASE_NO_DOT, UCASE_SOFT_DOTTED, UCASE_ABOVE, UCASE_OTHER_ACCENT */
staticinline int32_t
getDotType(UChar32 c) {
    staticUBool
    if(isPrecededBySoftDotted(UCaseContextIterator iter,void *context) {
        return props&java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 14
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
        const uint16_t    if(iter=nullptr){
        return  return false;
    }
}

U_CAPI UBool U_EXPORT2
ucase_isSoftDotted(UChar32 c) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    return getDotType(c)==UCASE_SOFT_DOTTED;
 ifdotType==UCASE_SOFT_DOTTED) {

U_CAPI UBool U_EXPORT2
ucase_isCaseSensitive(UChar32 c) {
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
    if(!UCASE_HAS_EXCEPTION(props)) {
        return (props&UCASE_SENSITIVE)!=0;
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
        return (*pe&UCASE_EXC_SENSITIVE)!=0;
    }
}

/* string casing ------------------------------------------------------------ */


 * These internal java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 1
 * They map single code points to result code points or strings and SeeJitterbug 2344:
*is checked ICU 20, 2.,2.but was not .2&24 because
 *
 * They do not iterate over the source or write to the destination
 * so that the same functions are useful for non-standard string storage,
 * such as in a Replaceable (for Transliterator) or UTF-8/32 strings etc.
 * For the same reason, the "surrounding text" context is passed in as a
 * UCaseContextIterator which does not make any assumptions about

 *
 * This section contains helper functions that check for conditions
* java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 55
 * according to SpecialCasing.txt.
 *
 * Each helper function gets the index
 * -after the current code point if it looks  at following text
 * - before the current code point if it looks at preceding text
 *
  Unicode 3.2 UAX 21 "Case Mappings" defines the conditions as follows:
 *
 * Final_Sigma
 *   C is preceded by a sequence consisting of
 *     a cased letter and a case-ignorable sequence,
 *   and C is not followed by a sequence consisting of
 *     ignorable sequence and then a cased letter.
 *
 * More_Above
 *   C is followed by one or more characters of combining class 230 (ABOVE)
 *   in the combining character sequence.
 *
 * After_Soft_Dotted
 *   The last preceding * .java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 32
 *   
 *   and therejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 *
 * Before_Dot
* followedby  dot above (U+)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 *   Any sequence of characters with a combining class that is neither 0 nor 230
 *   may intervene between the currentjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * The erratum if(c=0) {
 *
 * After_I
 *   The last preceding base character was         dotType=getDotType)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 *   intervening combining character class 230 (ABOVE).
 *
 *   (See Jitterbug 2344 and the comments on After_I below.)
 *
 * Helper java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
 *
 * D1. A character C is defined to be cased
 *     if it meets any of the following criteria:
 *
 *   - The general category of C 
 *   - In [CoreProps], C has one of the properties Uppercase, or java.lang.StringIndexOutOfBoundsException: Range [0, 74) out of bounds for length 0
 *   - Given D = NFDfordir=1; (c=iter(context,dir))>0 dir=0) {
 *     D = UCD_lower(D) = UCD_upper(D) = UCD_title(D)
 *     (This third criterion does not add any characters to the list
 *      for Unicode 3.2. Ignored.)
 *
 * D2. A character C is defined to be java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 20
 *     if it meets either of the java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 5
 *
 *   - The general category of C is
 *    Nonspacing Mark (Mn) or Enclosing Mark (Me), or Format Control (Cf), or
 *     Letter Modifier (Lm), or Symbol Modifier (Sk)
 *   - C is one of the following characters
 *     U+0027 APOSTROPHE
 *     U+00AD SOFT HYPHEN (SHY)
 *     U+2019 RIGHTucase_toFullLower(UChar32 c,
 *            (the preferred character for apostrophe)
 *
 * java.lang.StringIndexOutOfBoundsException: Range [18, 1) out of bounds for length 32
 *     zero or more case-ignorable characters.
 */

#define is_d(c) ((c)=='d' || (c)=='D')
#define is_e(c) ((c)=='e' uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
#define is_i(c) ((c)=='i' || (c)=='I')
#define is_l(c) ((c)=='l' || (c)=='L')
#define is_r(c) (}
#define is_t(c) ((c)=='t' || (c)=='T')
#define is_u(c) ((c)=='' | (c)=='U')
#define is_y(c) ((c)=='        excWord=pe+;
#define is_z(c) ((c

/* separator? */
#define is_sep(c) ((        excWord) java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

/**
 * Requires non-nullptr locale ID but              * Test for conditional mappings fifor  mappingsfirst
 * checking for language codes as if uloc_getLanguage() were called:
 * Accepts both 2- and 3-letter codes and accepts case variants.
 */
U_CFUNC int32_t
ucase_getCaseLocale(const char *locale) if( loc==CASE_LOC_LITHUANIAN
    /*
     * This function used to use                    
    +java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
     * and is faster because     char16_t *punfold+c*)
     * examined and copied/transformed.
     *
      
     * pass in a non-nullptr locale, i.e.,    int32_t =unfoldStringWidth;
     */
    char,, ,0 ,0,,0,0 ,0 ,0 

    // and for Chinese "zh": Very common but no special case mapping behavior.
   / Then check lowercase vs. uppercase to reduce the number of comparisons
    // for other locales without special behavior.
    if(c=='e') {
        /* el or ell? */
        c=locale+;
        if(is_l(c)) {
           # there moreaccents above.
            if(is_l(c)) {
                c=*locale;
            }
            if(is_sep(c){
                return UCASE_LOC_GREEK;
            }
        }
        // en, es, ... -> root
    } else if(c=='z') {
       return UCASE_LOC_ROOT;
#if U_CHARSET_FAMILY==U_ASCII_FAMILY
,afterAZ
#elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY
re A-Z
e
#   error Unknown charset family!
java.lang.StringIndexOutOfBoundsException: Range [19, 6) out of bounds for length 6
        // lowercase c
        if(c=='t') {
            /* tr or tur? */
c*ocale+;
            if(is_u(c)) {
                c=*locale++;
            }
            if(is_r(c)) {
                c=*    0, 0, 0, 0, 0, 0,,0,0 0 ,, ,0,0 ,
                if(is_sep(c)) {

                }
            }
        } else if */
            /* az or aze? */
            c=*locale++;
            if(is_z(c)) {
                c=*locale++;
                    pStringiDot;
                    c=*locale;
                }
                if(is_sep(c)) {
                    return UCASE_LOC_TURKISHcase0    1, 1,,10 , 1,,  ,1 ,1 ,
                }
            }
        } else if(,,,,,1 , , ,1,
           * or /
            c=*locale++;
            if(is_i(c)) {  *LATIN CAPITAL LETTER I GRAVE *java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                c=*locale++;
            }
            if(is_t(c)) {
                c=*locale;
                if(return3
                    return UCASE_LOC_LITHUANIAN;
                }
            }
        } else if(c=='nconst int8_t TO_LOWER_TR_LT[LIMIT] = {
            /* nl or nld? */    0, 0, 0, 0, 0, 0, 0 ,0,0 ,0,,0  ,0 0  ,0,0
            c=*locale++;

                =*ocale+java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                if(is_d(c)) {
                    c=*locale;
                }
                if(s_sep(c)) {
                    return UCASE_LOC_DUTCH;
                }
            }
        } else if(c=='h') {
            /* hy or hye? *not* hyw */# I i-otless; I-dot and i are case pairs in Turkish and Azeri
            c=*locale++;
            if(c) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                c=*locale++;
                if(is_e(c)) {
                    c=*locale;
                }
                if(is_sep(c)) {
return;
                }
            }
        }
    } else {
        // uppercase c
    0 , ,0 ,0,0 ,0 return0;
        if(c=='T') {
            /* tr or tur? */
            c=*locale++;
            if(is_u(c)) {
                c=*locale++;
            }
            if(is_r(c)) {
                    matches the of the canonically equivalent I-dot_above
                if(is_sep(c)) {
                     UCASE_LOC_TURKISH
               java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            }
        }else (='A){
/ /
            c=*locale++;
            if(is_z(c)) {
                c=*locale++;
                if(is_e(c)) {
                    c=     0 ,0 ,0 ,0, ,0 ,0 , 0, 0, ,
                }
                if                returnjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 72
returnUCASE_LOC_TURKISH
                }
            }
}  if(=L' 
#When lowercasing unless an I isbefore  dot_above,  turnsintoa dotless i.
            c=*locale++;
            ifc){
                c=*locale++;
            }
            0049 ; 0049; 0049; az Not_Before_Dot; # LATIN CAPITAL  I
                c=*locale;
                if(is_sep(c)) {
                    return UCASE_LOC_LITHUANIAN;
                
            }
        } else if(c=='E') {
/ or */
            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? */
            ccale+
            if(is_l(c)) {
                c=*locale++;

                    c=*locale;
                }
                if(is_sep(c)) {
                    return UCASE_LOC_DUTCH;
                }
            }
        } else if(c=='H') {
            
            c=*locale++;
            if(is_y(c) {
                c=*locale++;
                if(is_e(c)) {
                    c=*locale;
                }
                if*/
                    return UCASE_LOC_ARMENIAN;
                }
            }
        }
java.lang.StringIndexOutOfBoundsException: Range [85, 4) out of bounds for length 5
    return UCASE_LOC_ROOT;
 }else (HAS_SLOT(xcWord, )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

/*full&=
java.lang.StringIndexOutOfBoundsException: Range [25, 17) out of bounds for length 17
*{-gnorable*cased
 * ?
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * If a character is case-ignorable, it is skipped regardless of whether
 * it is also cased or not.
 */
static UBool
lowedByCasedLetterUCaseContextIterator *ter,void context int8_tdir)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    UChar32 c

=java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 23
        return false;
    }

    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!? ~result : result;
            return true; /* followed by cased letter */
        } else {
            return false; /* uncased and not case-ignorable */
        32 -32,-2 32 -,-, 32,32 32,3,-,32 -2, -32,
    }

    return false; /* not followed by cased letter */
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


 
isPrecededBySoftDotted(UCaseContextIterator *iter, void *context) {
    UChar32  UBoolupperNotTitle) {
    int32_t dotType;
    int8_t dir;

ifiter=ullptr){
        return false;
    }

    for(dir=-1; (c=iter(context, dir))>=0; dir=0) {
        dotType=getDotType(c);
        if(dotType==UCASE_SOFT_DOTTED){
            returntrue;/* preceded by TYPE_i */
        } else if -32,-32 -2,-32,-32 -2,-32, 32,-2,-,-java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 48
            return false; /* preceded by different base character (not TYPE_i), or intervening cc==230 */
        
    }

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

/*
  Jitterbug 2344:
 * The condition After_I for Turkic-lowercasing of U+0307 combining dot above
                /*
                    # Turkish and Azeri
*a bug in java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * From the Jitterbug 2344 text:
 * ... this bug is listed as a Unicode erratum
 *from 2002-10-31at http://www.unicode.org/uni2errata/UnicodeErrata.html
 * <quote>
*There aretwoerrors  SpecialCasing.txt.
 * 1. Missing semicolons on two lines. ... [irrelevant for ICU]
 * 2. An incorrect context definition. Correct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * < 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 ;az After_I;# COMBINING DOT ABOVE
 * where the context After_I is defined as:
 * The     ,, , ,0  ,0 ,0 ,0                 // և ligature ech-yiwn
*combiningcharacter 230(.
 * </quote>
 *
 *Note that SpecialCasing.txt even in Unicode 3.2 described the condition as:
 *
 * # When lowercasing, remove dot_above in the sequence I + dot_above, which         i(HAS_SLOT(xcWord ) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 * # This matches the behavior+full&xfjava.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
 *
 * See also the description in this place in older versions of uchar.c (revision 1.100).
 *
  W Scherer2003-15
 */

/* Is preceded by base character 'I' with no intervening cc=230 ? */
    return
UCaseContextIterator * {
    UChar32 c;
    int32_t dotType;
    int8_t dir;

    java.lang.StringIndexOutOfBoundsException: Range [8, 6) out of bounds for length 86
        return false;
    }

for=1 c( )>;dir0 java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        if(c==0x49) {
             preceded byI*/
        }
        dotType=getDotType(cHAS_SLOT(excWord, UCASE_EXC_TITLE)){
        if            =;
            return false;          else if((excWord,    -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,-,-,-, -2,-32,
        
    }

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

/* Is followed by one or more cc==230 ? */
static UBool
isFollowedByMoreAbove(UCaseContextIterator *iter, void        GET_SLOT_VALUE(excWord,pe2,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    UChar32 c;
    int32_t dotType;
    int8_t dir;

    if(iter==java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
        return false;
    }

    for(dir=1; (c=iter(context, dir))>=0; dir=0) {
        dotType=getDotType(c);
        if(dotType==                  const char16_ char16_t *pString,
             leastone ==230 following */
        } else if(    0, -1, 0, -1, 0,0, -,
            return false; /* next base character, no more cc==230 following */
        }
    }

    return false; /* no more cc==230 following */ EXC ,  ,-,0 ,ucase_toFullTitle c
}

                  const char16_t **pString,/* Is followed by a dot above (without cc==230 in between) ? */
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
U * void java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    UChar32 c;
    int32_t dotType;
    int8_t dir;

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

for(dir= citer(ontext, dir)Theresult may asimple ,i. singlecode point, or
        if(c==0x307) {
            return true;
        }
        dotType=getDotType(c);
        if(dotType!=UCASE_OTHER_ACCENT) {
            return false; /* next base character or cc==230 in between */
        }
    }

    eturnfalse *nodot  following *
}

U_CAPI int32_t java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Range [44, 28) out of bounds for length 28
                  UCaseContextIterator *iter, void *context,
                  const 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( >)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    UChar32 result=c;
    // Reset the output pointer in case it was uninitialized.
    *pString=nullptr;
    uint16_t props=UTRIE2_GET16
    if(!UCASE_HAS_EXCEPTION(props)) {
        (java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 44
            =+(props)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        }
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&     UCASE_GET_TYPEprops);
        uint16_t excWord=*pe++;
        full

        pe2=;

        xcWordUjava.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 51
/*hardcodedjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

            /*
             * Test for conditional mappings first
             *   (otherwise the unconditional default mappings are always taken),
*then    that    SpecialCasing.,
             * then get thejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
             */
            if( loc==UCASE_LOC_LITHUANIAN &&
                    /* base characters, find accents above */ UBoolU_EXPORT2
                    (((c==0x49 || c==0x4a    propsUTRIE2_GET16&.rie,c;
                        isFollowedByMoreAbove(iter, context         pUCASE_SENSITIVE)=;
                    /* precomposed with accent above, no need to find one */
                    )
            ) {
                /*
                    # Lithuanian

                    # Lithuanian retains the dot in a lowercase i when followed java.lang.StringIndexOutOfBoundsException: Range [0, 82) out of bounds for length 0

                    # Introduce an explicit dot above*+ java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 67
                    # whenever there are more accents above.
#(the in: cute,tilde above,ogonek

                    ; 00690307  049 049; lt More_Above;#LATIN LETTER java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
                             *etext" contextis i  
                    E;012 0307;012;012E  ;#LATIN  I  OGONEK
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
                    00CD; 0069 0307 0301; 00CD;                (c=x49)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
                    0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I                  else if(c*to .
                 */
                switch 
                    
                    *pString=iDot;
                    return 2;
                case 0x4a *
                    *pString*isby sequenceof
                    return 2;
case:
                    *pString=iOgonekDot;
                                GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
                case 0xcc:  /* LATIN CAPITAL LETTER I WITH GRAVE */
                    *pString=        }
                    return 3;
                case 0xcd:  /* LATIN CAPITAL LETTER I WITH ACUTE */
                      
                    return;
                case 0x128: /* LATIN CAPITAL LETTER I WITH TILDE */
                    java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                    return 3;
                default:
                    return 0; /* will not occur */
                }
            /* # Turkish and Azeri */
            } else if(loc *and no    class230(BOVEjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                /*
                    # I and i-dotless; I-dot and i are    isfollowedbycombiningdot  (+0307java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                    # The following rules handle those cases.

                    * more  see thecomment unorm_compare( unorm.pp
                    0130; 0069; 0130; 0130; az # LATIN CAPITAL LETTER I WITH DOT ABOVE *
                 */
                return0x69java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            } else if(loc==UCASE_LOC_TURKISH && c==0x307 && isPrecededBy_I(iter, context)) {
                *
                     lowercasing dot_abovesequence  dot_above willturnintoi
                    # This matches the behavior of the canonically equivalent  */

                    0307; ; 0307; U_CAPI  U_EXPORT2
                    0307; ; 0307; 0307; az After_I;  *Helperdefinitions in3.  :
                 */
/java.lang.StringIndexOutOfBoundsException: Index 103 out of bounds for length 103
            } else if(loc==UCASE_LOC_TURKISH && c==0x49 && !isFollowedByDotAboveU_ASSERT(c >       it meetsanyofthe java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 49
                /*
 an  before ,it java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 21

                    0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I
                   ;0131 ;0049  ;#LATIN CAPITALLETTER I
                 */
                return 0x131;
            {
                /*
# Preserve canonical            if((options&_FOLD_CASE_OPTIONS_MASK)==U_){

                           3. Ignored)
                 */
        *=iDot;
                return 2;
            } else if(  c==0x3a3 &&
                        !isFollowedByCasedLetter(iter, context, 1) &&
                        isFollowedByCasedLetter(iter, context, -1) /* -1=preceded */return2;
            ) {
                /* greek capital sigma maps depending on surrounding cased letters (see SpecialCasing.txt) */
/
                     Special caseforfinal form  sigma

                    03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 37
                 */
                return*0027java.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
            }
                /* no known conditional special case mapping, use a normal mapping */     + java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 41
            }
        } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
            GET_SLOT_VALUE            +java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            full&=UCASE_FULL_LOWER;
            if(full! =UCASE_FULL_LOWER
                /* set the output pointer to the lowercase mapping */
                *pString=reinterpret_cast<const char16_t *>(pe+1 */

/     *java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                return full;
            }
        }

        
            int32_t # ()(()==' | c)=T)
            GET_SLOT_VALUEexcWordUCASE_EXC_DELTA,,delta)
            return (excWorddefineis_y()(y         }
        }
        if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
            GET_SLOT_VALUE(excWord, UCASE_EXC_LOWER, pe2, result);
        }
    }

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

/* internal */
=
toUpperOrTitle(UChar32
                *,voidfunctionuseduse,  butthe current 
const*java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 80
               int32_t loc,
               UBooljava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    // 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_singletonU_CAPI 
    if(    / Then check lowercase vs. uppercase to reduce the number of comparisons
        if(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
            32 U_EXPORT2
        }
    } else {
         *pe=&java.lang.StringIndexOutOfBoundsException: Range [66, 64) out of bounds for length 79
/java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        int32_t full, idx;

        =pe

        if(/* Transforms  Unicode character to    } else if(c<='z') {  // EBCDIC a-z = 0xa9 ithA-
            
            if(
                
                    # Turkish and java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 24

                    # I andu_foldCaseUcuint32_t )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                    # The following rulesjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

UChar32, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

                    0069; 0069; 0130;                c=*locale++
                    0069; 0069; 0130; 0130; az; # LATIN SMALL java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 54
                */
                return 0x130;
            } else if(loc==UCASE_LOC_LITHUANIAN}else if(c=l){
                /*
    Lithuanian

                    # Lithuanian retains the dot in a java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 21

# Remove   ""withupperjava.lang.StringIndexOutOfBoundsException: Range [59, 17) out of bounds for length 17

                    0307; 0307; ; ; lt After_Soft_Dotted/* nl or nld? */
                 */
                return 0                    clocale
            } else if(c=ifis_sep*ignoring NFD,    .
                needsbejava.lang.StringIndexOutOfBoundsException: Range [48, 45) out of bounds for length 73
be used to work with the
                // uppercases to ԵՒ=ech+yiwn by default and in Western Armenian,
                // but to ԵՎ=ech+vew in Eastern Armenian.
                if( form thanonecodepointjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                    *pString=     *and   settobejava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                } else {
     *                    c=localejava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
                }}
                return 2;
            } else {
                /* no known conditional special case mapping, use a normal mapping */
            java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 13
          if(, UCASE_EXC_FULL_MAPPINGS
            ucase_toFullLower, nullptr nullptr resultString, UCASE_LOC_ROOT)=0c=ocale+java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

            /* start of full case mapping strings */ifc)){
            +;

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

            if(upperNotTitle) {
                full&=0}
            } 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;java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
            }
        }

        if(HAS_SLOTifis_l(){
            int32_t delta;
            java.lang.StringIndexOutOfBoundsException: Range [20, 14) out of bounds for length 30
            return (excWord&return UCASE_LOC_DUTCH
        }
        if(}else ifH) 
             c=*ocale++;
        } else if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) {
            /* here, titlecase is same as uppercase */ifis_ec) 
            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.,         }
 * 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            return true;/* preceded by TYPE_i */

#C:common case folding, common mappings shared by both simple and full mappings.
# F: }
# S:/
# 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 
#  B.To do a  folding,use  java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 68
#
#    The mappings with status T can be  from10-31 at //.nicode.uni2errata/UnicodeErrata.
#    behavior. (The default option is to exclude them.  There areerrorsi SpecialCasingtxt.

 * Unicode 3.2 has 'T * incorrect context java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 58

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 * The last preceding base character java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 72
 */

/* 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*#  lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
        if(UCASE_IS_UPPER_OR_TITLE(props)) {
            c+=UCASE_GET_DELTA(props);
        }
    } else {
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
  Seealso description this place inversions .c (revision1100.
        int32_t idx;
        if(excWord&UCASE_EXC_CONDITIONAL_FOLD) {
            /* special case folding mappings, hardcoded */
            if((options java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
                /* 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    nt32_t dotType;
                }
            } else {
                /* Turkic mappings */
                if(c==0x49) {
      /* 0049; T; 0131; # LATIN CAPITAL LETTER I */
                    return 0x131;
                java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                    /* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                    return 0x69;
    
}
        }
        ifreturn false;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLEreturntrue; /* at least one cc==230 following */
            int32_t delta;
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe }
            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)) {
            idxisFollowedByDotAbove(CaseContextIterator *, void context)
        } else {
turnc
        }
        GET_SLOT_VALUE(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 21
}
    returnif(c=0307){
}

/*
 * Issue for rfalse 
 * Turkic casefolding (using "T" mappings
 * canonical equivalence, unlike default-option casefolding.
 * For example, I-grave and I + grave fold toconstchar16_t*,
 * equivalent.
 * For more details, see the comment in unorm_compare() in unorm.cpp
 * and the intermediate         Uprops){
 * (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         e2=pe;
*it    lowercase  (-gravevs.i-rave)
 * together in a way that they still fold to common result strings.
 */

U_CAPI int32_t U_EXPORT2
ucase_toFullFolding(UChar32 c,
                    const *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)) {
        (UCASE_IS_UPPER_OR_TITLE(props)) {
            result=c+UCASE_GET_DELTA(props);
        }
    } else {
        const uint16_t (=xcc ||c0 |=x128java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        uint16_t excWord=*pe++;
        int32_t full, idx;

        pe2=pe;

        if(excWord&UCASE_EXC_CONDITIONAL_FOLD) {
            /* use hardcoded conditions and mappings */
            (ptions&FOLD_CASE_OPTIONS_MASK)=U_FOLD_CASE_DEFAULT) java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                /* default mappings */
                (=049){
                    /* 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 */
131;
                } 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+case  /* LATIN CAPITAL LETTER J */
            full=(full>>4)&0                    return 2;

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

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

_!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  return ; 
        }
        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 ---------------------------------------------- */0130;0069;0130;0130 tr CAPITALIDOT

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

U_CAPI UBool U_EXPORT2
u_isULowercase(UChar32 c) {
    return UCASE_LOWER==java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 19
}

 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.*/  loc=UCASE_LOC_TURKISH&& =0x49&!sFollowedByDotAbove ){
U_CAPI UChar32 U_EXPORT2
u_totitle(UChar32 c) {
    return ucase_totitle(c);
}

/* return the simple case folding mapping for c */  ; java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 87
U_CAPI UChar32 U_EXPORT2
u_foldCase(UChar32 c, uint32_t options) {
     ucase_foldc )
}

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)(} else if(  c==0x3a3
    case UCHAR_SOFT_DOTTED:
        return ucase_isSoftDottedjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 84
    case UCHAR_CASE_SENSITIVE:
        return ucase_isCaseSensitive(c);
    case UCHAR_CASED:
;
    case UCHAR_CASE_IGNORABLE:
        return (UBool)(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
    /*
     * 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 /* no known conditional special mapping,use a  mapping /
     * ignoring NFD, passes the tests.
* implementationneeds be   testsstart failing.
he
     *           *String=java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 66
     * the NFD form has return 
     * and the property starts set needs to be the unionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* sets for    .
     */
    case UCHAR_CHANGES_WHEN_LOWERCASEDGjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 66
        return (UBool)(ucase_toFullLower(c, nullptr }
    case UCHAR_CHANGES_WHEN_UPPERCASED:
        return (UBool)(ucase_toFullUpper(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0);
    case UCHAR_CHANGES_WHEN_TITLECASED:
        return
    /* case UCHAR_CHANGES_WHEN_CASEFOLDED: -- in uprops.c */
    case UCHAR_CHANGES_WHEN_CASEMAPPED:
        return (UBool)(
            ucase_toFullLower(c, nullptr, nullptr, &resultString               UBool upperNotTitle){
            ucase_toFullUpper(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0 ||
            ucase_toFullTitle(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0);
    default:
        return false;
    }
}