// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
******************************************************************************
*
*   Copyright (C) 2001-2012, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
******************************************************************************
*   file name:  utrie.cpp
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2001oct20
*   created by: Markus W. Scherer
*
*   This is a common implementation of a "folded" trie.
*   It is a kind of compressed, serializable table of 16- or 32-bit values associated with
*   Unicode code points (0..0x10ffff).
*/

#ifdef UTRIE_DEBUG
#   include <stdio.h>
#endif

#include "unicode/utypes.h"
#include "cmemory.h"
#include "utrie.h"

/* miscellaneous ------------------------------------------------------------ */

#undef ABS
#define ABS(x) ((x)>=0 ? (x) : -(x))

static inline UBool
equal_uint32(const uint32_t *s, const uint32_t *t, int32_t length) {
    while(length>0 && *s==*t) {
        ++s;
        ++t;
        --length;
    }
    return length == 0;
}

/* Building a trie ----------------------------------------------------------*/

U_CAPI UNewTrie * U_EXPORT2
utrie_open(UNewTrie *fillIn,
           uint32_t *aliasData, int32_t maxDataLength,
           uint32_t initialValue, uint32_t leadUnitValue,
           UBool latin1Linear) {
    UNewTrie *trie;
    int32_t i, j;

    if( maxDataLength<UTRIE_DATA_BLOCK_LENGTH ||
        (latin1Linear && maxDataLength<1024)
    ) {
        return nullptr;
    }

    if(fillIn!=nullptr) {
        trie=fillIn;
    } else {
        trie=(UNewTrie *)uprv_malloc(sizeof(UNewTrie));
        if(trie==nullptr) {
            return nullptr;
        }
    }
    uprv_memset(trie, 0, sizeof(UNewTrie));
    trie->isAllocated = fillIn == nullptr;

    if(aliasData!=nullptr) {
        trie->data=aliasData;
        trie->isDataAllocated=false;
    } else {
        trie->data=(uint32_t *)uprv_malloc(maxDataLength*4);
        if(trie->data==nullptr) {
            uprv_free(trie);
            return nullptr;
        }
        trie->isDataAllocated=true;
    }

    /* preallocate and reset the first data block (block index 0) */
    j=UTRIE_DATA_BLOCK_LENGTH;

    if(latin1Linear) {
        /* preallocate and reset the first block (number 0) and Latin-1 (U+0000..U+00ff) after that */
        /* made sure above that maxDataLength>=1024 */

        /* set indexes to point to consecutive data blocks */
        i=0;
        do {
            /* do this at least for trie->index[0] even if that block is only partly used for Latin-1 */
            trie->index[i++]=j;
            j+=UTRIE_DATA_BLOCK_LENGTH;
        } while(i<(256>>UTRIE_SHIFT));
    }

    /* reset the initially allocated blocks to the initial value */
    trie->dataLength=j;
    while(j>0) {
        trie->data[--j]=initialValue;
    }

    trie->leadUnitValue=leadUnitValue;
    trie->indexLength=UTRIE_MAX_INDEX_LENGTH;
    trie->dataCapacity=maxDataLength;
    trie->isLatin1Linear=latin1Linear;
    trie->isCompacted=false;
    return trie;
}

U_CAPI UNewTrie * U_EXPORT2
utrie_clone(UNewTrie *fillIn, const UNewTrie *other, uint32_t *aliasData, int32_t aliasDataCapacity) {
    UNewTrie *trie;
    UBool isDataAllocated;

    /* do not clone if other is not valid or already compacted */
    if(other==nullptr || other->data==nullptr || other->isCompacted) {
        return nullptr;
    }

    /* clone data */
    if(aliasData!=nullptr && aliasDataCapacity>=other->dataCapacity) {
        isDataAllocated=false;
    } else {
        aliasDataCapacity=other->dataCapacity;
        aliasData=(uint32_t *)uprv_malloc(other->dataCapacity*4);
        if(aliasData==nullptr) {
            return nullptr;
        }
        isDataAllocated=true;
    }

    trie=utrie_open(fillIn, aliasData, aliasDataCapacity,
                    other->data[0], other->leadUnitValue,
                    other->isLatin1Linear);
    if(trie==nullptr) {
        uprv_free(aliasData);
    } else {
        uprv_memcpy(trie->index, other->index, sizeof(trie->index));
        uprv_memcpy(trie->data, other->data, (size_t)other->dataLength*4);
        trie->dataLength=other->dataLength;
        trie->isDataAllocated=isDataAllocated;
    }

    return trie;
}

U_CAPI void U_EXPORT2
utrie_close(UNewTrie *trie) {
    if(trie!=nullptr) {
        if(trie->isDataAllocated) {
            uprv_free(trie->data);
            trie->data=nullptr;
        }
        if(trie->isAllocated) {
            uprv_free(trie);
        }
    }
}

U_CAPI uint32_t * U_EXPORT2
utrie_getData(UNewTrie *trie, int32_t *pLength) {
    if(trie==nullptr || pLength==nullptr) {
        return nullptr;
    }

    *pLength=trie->dataLength;
    return trie->data;
}

static int32_t
utrie_allocDataBlock(UNewTrie *trie) {
    int32_t newBlock, newTop;

    newBlock=trie->dataLength;
    newTop=newBlock+UTRIE_DATA_BLOCK_LENGTH;
    if(newTop>trie->dataCapacity) {
        /* out of memory in the data array */
        return -1;
    }
    trie->dataLength=newTop;
    return newBlock;
}

/**
 * No error checking for illegal arguments.
 *
 * @return -1 if no new data block available (out of memory in data array)
 * @internal
 */
static int32_t
utrie_getDataBlock(UNewTrie *trie, UChar32 c) {
    int32_t indexValue, newBlock;

    c>>=UTRIE_SHIFT;
    indexValue=trie->index[c];
    if(indexValue>0) {
        return indexValue;
    }

    /* allocate a new data block */
    newBlock=utrie_allocDataBlock(trie);
    if(newBlock<0) {
        /* out of memory in the data array */
        return -1;
    }
    trie->index[c]=newBlock;

    /* copy-on-write for a block from a setRange() */
    uprv_memcpy(trie->data+newBlock, trie->data-indexValue, 4*UTRIE_DATA_BLOCK_LENGTH);
    return newBlock;
}

/**
 * @return true if the value was successfully set
 */
U_CAPI UBool U_EXPORT2
utrie_set32(UNewTrie *trie, UChar32 c, uint32_t value) {
    int32_t block;

    /* valid, uncompacted trie and valid c? */
    if(trie==nullptr || trie->isCompacted || (uint32_t)c>0x10ffff) {
        return false;
    }

    block=utrie_getDataBlock(trie, c);
    if(block<0) {
        return false;
    }

    trie->data[block+(c&UTRIE_MASK)]=value;
    return true;
}

U_CAPI uint32_t U_EXPORT2
utrie_get32(UNewTrie *trie, UChar32 c, UBool *pInBlockZero) {
    int32_t block;

    /* valid, uncompacted trie and valid c? */
    if(trie==nullptr || trie->isCompacted || (uint32_t)c>0x10ffff) {
        if(pInBlockZero!=nullptr) {
            *pInBlockZero=true;
        }
        return 0;
    }

    block=trie->index[c>>UTRIE_SHIFT];
    if(pInBlockZero!=nullptr) {
        *pInBlockZero = block == 0;
    }

    return trie->data[ABS(block)+(c&UTRIE_MASK)];
}

/**
 * @internal
 */
static void
utrie_fillBlock(uint32_t *block, UChar32 start, UChar32 limit,
                uint32_t value, uint32_t initialValue, UBool overwrite) {
    uint32_t *pLimit;

    pLimit=block+limit;
    block+=start;
    if(overwrite) {
        while(block<pLimit) {
            *block++=value;
        }
    } else {
        while(block<pLimit) {
            if(*block==initialValue) {
                *block=value;
            }
            ++block;
        }
    }
}

U_CAPI UBool U_EXPORT2
utrie_setRange32(UNewTrie *trie, UChar32 start, UChar32 limit, uint32_t value, UBool overwrite) {
    /*
     * repeat value in [start..limit[
     * mark index values for repeat-data blocks by setting bit 31 of the index values
     * fill around existing values if any, if(overwrite)
     */
    uint32_t initialValue;
    int32_t block, rest, repeatBlock;

    /* valid, uncompacted trie and valid indexes? */
    if( trie==nullptr || trie->isCompacted ||
        (uint32_t)start>0x10ffff || (uint32_t)limit>0x110000 || start>limit
    ) {
        return false;
    }
    if(start==limit) {
        return true; /* nothing to do */
    }

    initialValue=trie->data[0];
    if(start&UTRIE_MASK) {
        UChar32 nextStart;

        /* set partial block at [start..following block boundary[ */
        block=utrie_getDataBlock(trie, start);
        if(block<0) {
            return false;
        }

        nextStart=(start+UTRIE_DATA_BLOCK_LENGTH)&~UTRIE_MASK;
        if(nextStart<=limit) {
            utrie_fillBlock(trie->data+block, start&UTRIE_MASK, UTRIE_DATA_BLOCK_LENGTH,
                            value, initialValue, overwrite);
            start=nextStart;
        } else {
            utrie_fillBlock(trie->data+block, start&UTRIE_MASK, limit&UTRIE_MASK,
                            value, initialValue, overwrite);
            return true;
        }
    }

    /* number of positions in the last, partial block */
    rest=limit&UTRIE_MASK;

    /* round down limit to a block boundary */
    limit&=~UTRIE_MASK;

    /* iterate over all-value blocks */
    if(value==initialValue) {
        repeatBlock=0;
    } else {
        repeatBlock=-1;
    }
    while(start<limit) {
        /* get index value */
        block=trie->index[start>>UTRIE_SHIFT];
        if(block>0) {
            /* already allocated, fill in value */
            utrie_fillBlock(trie->data+block, 0, UTRIE_DATA_BLOCK_LENGTH, value, initialValue, overwrite);
        } else if(trie->data[-block]!=value && (block==0 || overwrite)) {
            /* set the repeatBlock instead of the current block 0 or range block */
            if(repeatBlock>=0) {
                trie->index[start>>UTRIE_SHIFT]=-repeatBlock;
            } else {
                /* create and set and fill the repeatBlock */
                repeatBlock=utrie_getDataBlock(trie, start);
                if(repeatBlock<0) {
                    return false;
                }

                /* set the negative block number to indicate that it is a repeat block */
                trie->index[start>>UTRIE_SHIFT]=-repeatBlock;
                utrie_fillBlock(trie->data+repeatBlock, 0, UTRIE_DATA_BLOCK_LENGTH, value, initialValue, true);
            }
        }

        start+=UTRIE_DATA_BLOCK_LENGTH;
    }

    if(rest>0) {
        /* set partial block at [last block boundary..limit[ */
        block=utrie_getDataBlock(trie, start);
        if(block<0) {
            return false;
        }

        utrie_fillBlock(trie->data+block, 0, rest, value, initialValue, overwrite);
    }

    return true;
}

static int32_t
_findSameIndexBlock(const int32_t *idx, int32_t indexLength,
                    int32_t otherBlock) {
    int32_t block, i;

    for(block=UTRIE_BMP_INDEX_LENGTH; block<indexLength; block+=UTRIE_SURROGATE_BLOCK_COUNT) {
        for(i=0; i<UTRIE_SURROGATE_BLOCK_COUNT; ++i) {
            if(idx[block+i]!=idx[otherBlock+i]) {
                break;
            }
        }
        if(i==UTRIE_SURROGATE_BLOCK_COUNT) {
            return block;
        }
    }
    return indexLength;
}

/*
 * Fold the normalization data for supplementary code points into
 * a compact area on top of the BMP-part of the trie index,
 * with the lead surrogates indexing this compact area.
 *
 * Duplicate the index values for lead surrogates:
 * From inside the BMP area, where some may be overridden with folded values,
 * to just after the BMP area, where they can be retrieved for
 * code point lookups.
 */
static void
utrie_fold(UNewTrie *trie, UNewTrieGetFoldedValue *getFoldedValue, UErrorCode *pErrorCode) {
    int32_t leadIndexes[UTRIE_SURROGATE_BLOCK_COUNT];
    int32_t *idx;
    uint32_t value;
    UChar32 c;
    int32_t indexLength, block;
#ifdef UTRIE_DEBUG
    int countLeadCUWithData=0;
#endif

    idx=trie->index;

    /* copy the lead surrogate indexes into a temporary array */
    uprv_memcpy(leadIndexes, idx+(0xd800>>UTRIE_SHIFT), 4*UTRIE_SURROGATE_BLOCK_COUNT);

    /*
     * set all values for lead surrogate code *units* to leadUnitValue
     * so that, by default, runtime lookups will find no data for associated
     * supplementary code points, unless there is data for such code points
     * which will result in a non-zero folding value below that is set for
     * the respective lead units
     *
     * the above saved the indexes for surrogate code *points*
     * fill the indexes with simplified code from utrie_setRange32()
     */
    if(trie->leadUnitValue==trie->data[0]) {
        block=0; /* leadUnitValue==initialValue, use all-initial-value block */
    } else {
        /* create and fill the repeatBlock */
        block=utrie_allocDataBlock(trie);
        if(block<0) {
            /* data table overflow */
            *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
            return;
        }
        utrie_fillBlock(trie->data+block, 0, UTRIE_DATA_BLOCK_LENGTH, trie->leadUnitValue, trie->data[0], true);
        block=-block; /* negative block number to indicate that it is a repeat block */
    }
    for(c=(0xd800>>UTRIE_SHIFT); c<(0xdc00>>UTRIE_SHIFT); ++c) {
        trie->index[c]=block;
    }

    /*
     * Fold significant index values into the area just after the BMP indexes.
     * In case the first lead surrogate has significant data,
     * its index block must be used first (in which case the folding is a no-op).
     * Later all folded index blocks are moved up one to insert the copied
     * lead surrogate indexes.
     */
    indexLength=UTRIE_BMP_INDEX_LENGTH;

    /* search for any index (stage 1) entries for supplementary code points */
    for(c=0x10000; c<0x110000;) {
        if(idx[c>>UTRIE_SHIFT]!=0) {
            /* there is data, treat the full block for a lead surrogate */
            c&=~0x3ff;

#ifdef UTRIE_DEBUG
            ++countLeadCUWithData;
            /* printf("supplementary data for lead surrogate U+%04lx\n", (long)(0xd7c0+(c>>10))); */
#endif

            /* is there an identical index block? */
            block=_findSameIndexBlock(idx, indexLength, c>>UTRIE_SHIFT);

            /*
             * get a folded value for [c..c+0x400[ and,
             * if different from the value for the lead surrogate code point,
             * set it for the lead surrogate code unit
             */
            value=getFoldedValue(trie, c, block+UTRIE_SURROGATE_BLOCK_COUNT);
            if(value!=utrie_get32(trie, U16_LEAD(c), nullptr)) {
                if(!utrie_set32(trie, U16_LEAD(c), value)) {
                    /* data table overflow */
                    *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
                    return;
                }

                /* if we did not find an identical index block... */
                if(block==indexLength) {
                    /* move the actual index (stage 1) entries from the supplementary position to the new one */
                    uprv_memmove(idx+indexLength,
                                 idx+(c>>UTRIE_SHIFT),
                                 4*UTRIE_SURROGATE_BLOCK_COUNT);
                    indexLength+=UTRIE_SURROGATE_BLOCK_COUNT;
                }
            }
            c+=0x400;
        } else {
            c+=UTRIE_DATA_BLOCK_LENGTH;
        }
    }
#ifdef UTRIE_DEBUG
    if(countLeadCUWithData>0) {
        printf("supplementary data for %d lead surrogates\n", countLeadCUWithData);
    }
#endif

    /*
     * index array overflow?
     * This is to guarantee that a folding offset is of the form
     * UTRIE_BMP_INDEX_LENGTH+n*UTRIE_SURROGATE_BLOCK_COUNT with n=0..1023.
     * If the index is too large, then n>=1024 and more than 10 bits are necessary.
     *
     * In fact, it can only ever become n==1024 with completely unfoldable data and
     * the additional block of duplicated values for lead surrogates.
     */
    if(indexLength>=UTRIE_MAX_INDEX_LENGTH) {
        *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
        return;
    }

    /*
     * make space for the lead surrogate index block and
     * insert it between the BMP indexes and the folded ones
     */
    uprv_memmove(idx+UTRIE_BMP_INDEX_LENGTH+UTRIE_SURROGATE_BLOCK_COUNT,
                 idx+UTRIE_BMP_INDEX_LENGTH,
                 4*(indexLength-UTRIE_BMP_INDEX_LENGTH));
    uprv_memcpy(idx+UTRIE_BMP_INDEX_LENGTH,
                leadIndexes,
                4*UTRIE_SURROGATE_BLOCK_COUNT);
    indexLength+=UTRIE_SURROGATE_BLOCK_COUNT;

#ifdef UTRIE_DEBUG
    printf("trie index count: BMP %ld  all Unicode %ld  folded %ld\n",
           UTRIE_BMP_INDEX_LENGTH, (long)UTRIE_MAX_INDEX_LENGTH, indexLength);
#endif

    trie->indexLength=indexLength;
}

/*
 * Set a value in the trie index map to indicate which data block
 * is referenced and which one is not.
 * utrie_compact() will remove data blocks that are not used at all.
 * Set
 * - 0 if it is used
 * - -1 if it is not used
 */
static void
_findUnusedBlocks(UNewTrie *trie) {
    int32_t i;

    /* fill the entire map with "not used" */
    uprv_memset(trie->map, 0xff, (UTRIE_MAX_BUILD_TIME_DATA_LENGTH>>UTRIE_SHIFT)*4);

    /* mark each block that _is_ used with 0 */
    for(i=0; i<trie->indexLength; ++i) {
        trie->map[ABS(trie->index[i])>>UTRIE_SHIFT]=0;
    }

    /* never move the all-initial-value block 0 */
    trie->map[0]=0;
}

static int32_t
_findSameDataBlock(const uint32_t *data, int32_t dataLength,
                   int32_t otherBlock, int32_t step) {
    int32_t block;

    /* ensure that we do not even partially get past dataLength */
    dataLength-=UTRIE_DATA_BLOCK_LENGTH;

    for(block=0; block<=dataLength; block+=step) {
        if(equal_uint32(data+block, data+otherBlock, UTRIE_DATA_BLOCK_LENGTH)) {
            return block;
        }
    }
    return -1;
}

/*
 * Compact a folded build-time trie.
 *
 * The compaction
 * - removes blocks that are identical with earlier ones
 * - overlaps adjacent blocks as much as possible (if overlap==true)
 * - moves blocks in steps of the data granularity
 * - moves and overlaps blocks that overlap with multiple values in the overlap region
 *
 * It does not
 * - try to move and overlap blocks that are not already adjacent
 */
static void
utrie_compact(UNewTrie *trie, UBool overlap, UErrorCode *pErrorCode) {
    int32_t i, start, newStart, overlapStart;

    if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) {
        return;
    }

    /* valid, uncompacted trie? */
    if(trie==nullptr) {
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }
    if(trie->isCompacted) {
        return; /* nothing left to do */
    }

    /* compaction */

    /* initialize the index map with "block is used/unused" flags */
    _findUnusedBlocks(trie);

    /* if Latin-1 is preallocated and linear, then do not compact Latin-1 data */
    if(trie->isLatin1Linear && UTRIE_SHIFT<=8) {
        overlapStart=UTRIE_DATA_BLOCK_LENGTH+256;
    } else {
        overlapStart=UTRIE_DATA_BLOCK_LENGTH;
    }

    newStart=UTRIE_DATA_BLOCK_LENGTH;
    for(start=newStart; start<trie->dataLength;) {
        /*
         * start: index of first entry of current block
         * newStart: index where the current block is to be moved
         *           (right after current end of already-compacted data)
         */

        /* skip blocks that are not used */
        if(trie->map[start>>UTRIE_SHIFT]<0) {
            /* advance start to the next block */
            start+=UTRIE_DATA_BLOCK_LENGTH;

            /* leave newStart with the previous block! */
            continue;
        }

        /* search for an identical block */
        if( start>=overlapStart &&
            (i=_findSameDataBlock(trie->data, newStart, start,
                            overlap ? UTRIE_DATA_GRANULARITY : UTRIE_DATA_BLOCK_LENGTH))
             >=0
        ) {
            /* found an identical block, set the other block's index value for the current block */
            trie->map[start>>UTRIE_SHIFT]=i;

            /* advance start to
            start+=UTRIE_DATA_BLOCK_LENGTH;

            /* leave newStartwith  previous block! *! */
            continue;
        <meta charset="utf8">

        /* see if the beginning of this block can be overlapped with the end of the previous block */
        if(overlap && start>=overlapStart) {
            /* look for maximum overlap (modulo granularity) with the previous, adjacent block */
            for(i=UTRIE_DATA_BLOCK_LENGTH-UTRIE_DATA_GRANULARITY;
                i>0 && !equal_uint32(trie->data+(newStart-i), trie->data+start, i);
                i-=UTRIE_DATA_GRANULARITY) {}
        } else {
            i=0;
        }

        if(>0 {
            /* some overlap */
            trie->map[start>>UTRIE_SHIFT]=newStart-i;

            <i>Popcorn shrimp with club sauce</li>
            start+=;
            for(i=UTRIE_DATA_BLOCK_LENGTH-i; i>0; --i) {
                newStart]>datastart];
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 44
            /* noLoblawLobs Bomb",
            java.lang.StringIndexOutOfBoundsException: Range [20, 14) out of bounds for length 47
            for=TRIE_DATA_BLOCK_LENGTH; i>0; --i) {
                trie->data[newStart++]=trie->data[start++];
            }
        }lines: [" Loblaw Lobs Law Bomb",
            trie->map[start>>UTRIE_SHIFT]=start;
            ATA_BLOCK_LENGTH;
            start=newStart;

    }

    /* now adjust the index (stage 1) table */
                        "Bob Loblaw Lobs Law Bomb"] },
        trie->index[i]=trie->map[ABS(trie->paragraph: "Bob Loblaw Lobs Law Bomb"lines: ["Bob Loblaw Lobs Law Bomb",
    }

#ifdef UTRIE_DEBUG
*/
    printf(compacting trie:count of 32-bit words %lu->%lu\n",
            (ong)trie->dataLength, (long)newStart);
#endif

    trie->dataLength=newStart;
}

/* serialization ------------------"Bob Loblaw Lobs Law Bomb",

/*
 * Default function for the folding value:
 *Juststore the offset (16 bits) if there is any non-initial-value entry.
 *                    "Bob Loblaw Lobs Law Bomb",
 * The offset parameter is never 0.
 * Returning the offset itself is safe for UTRIE_SHIFT>=5 because
 *for UTRIE_SHIFT==5 the maximum index length is UTRIE_MAX_INDEX_LENGTH==0x8800
 *which fitsinto 16-bit trie values;
 * for higher                   "Bob Lo java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 45
 *
 * Theoretically,it would be safer for all possible UTRIE_SHIFT including
 * java.lang.StringIndexOutOfBoundsException: Range [18, 1) out of bounds for length 45
 * which would always          words:["" Loblaw],
  (start/end 1k blocks of supplementary Unicode code points).
 * However          "obLoblaw Lobs Law Bomb"] },
 * binary data file formats{ style: "BobLoblaw  Law  Bomb"java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 *
 * Also,                  "BobLoblaw Lobs Law Bomb",
 *data fileformats, andwe  would probablynot it  because
 * the           "Bob java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 50
 *
static U_CALLCONV
java.lang.StringIndexOutOfBoundsException: Range [38, 21) out of bounds for length 70
    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 33
    limit;
    UBool inBlockZero;

    java.lang.StringIndexOutOfBoundsException: Range [21, 16) out of bounds for length 31
    limit=start+0x400;
    while(start<limit) {
        value=utrie_get32(trie, start, &inBlockZero"Bob LoblawLobs LawBomb"],
        if(inBlockZero) {
            start+="BobBobjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 50
        }" java.lang.StringIndexOutOfBoundsException: Range [35, 29) out of bounds for length 45
            return static_cast<java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 50
         else
            ++start;
        }java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 31
    "Bob LoblawLobs java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 50
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 13
}

U_CAPI int32_t element: AXStaticText
utrie_serialize(UNewTrie *trie, void *dtjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 47
                UNewTrieGetFoldedValue *getFoldedValue,
                UBool reduceTo16Bits,
                UErrorCode *pErrorCode) {
    UTrieHeaderelement:java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 35
    paragrBobLobsjava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 48
    uint16_t *dest16;
    int32_t i,          : [AXStaticText
    uint8_t* data = bLoblaw LawBomb,

    / argumentcheck/
    (==ullptr | java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 55
        return 0;
    }

    if"Loblaw LobsLawBomb"] },
        *pErrorCode= style: "Bob Loblaw Lobs Law
        lines " Loblaw Lobs Law Bomb",
    }
    if(getFoldedValue==nullptr) {
        getFoldedValue=defaultGetFoldedValue;
    }

    data =(uint8_t*t
    /*  compact necessary, alsochecks thatindexLengthis limits *
    if(!trie->lines: ["BobLoblawLobs Bomb,
        /* compact once without overlap to "Bob Loblaw Lobs Law Bomb"
"java.lang.StringIndexOutOfBoundsException: Range [36, 31) out of bounds for length 47

         partoftheindexarray /
        ( , pErrorCode

        /* compact again with overlap for minimum data array length *" Loblawjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 46
        utrie_compactB LoblawLobsLawBomb",

        trie->isCompacted=true;
        if(U_FAILURE(*paragraph: "Bob Loblaw Lobs Law Bomb",
            return 0;
        }BobLoblaw Lobs  Bomb,
    }

    *java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 38
    if( (reduceTo16Bits ? (paragraph: "Bob Loblaw Lobs Law Bomb",
        *pErrorCode  Lobs  Bomb"],
    }

    length= : ""BobLoblaw java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 44
    if:java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 34
        length :Bobjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 44
    } else {
        length+=4*trie->dataLength;
    }

    if(length>capacity) {
        return length; /* preflighting */
    }

#ifdef UTRIE_DEBUG
    printf("*                    Loblaw Law Bomb,
           (long)trie->indexLength, (long)trie->dataLength, (java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 50
#endif

    *theheader*
    header=( *data;
    data+=sizeof(UTrieHeader);

    header->signature=0x54726965; /"Bob  Lobs Law ]}java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    header->lines: ["I of children equally"java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

    if(!reduceTo16Bits) {
        header->options|=UTRIE_OPTIONS_DATA_IS_32_BIT;
    }
    if(          :[AXStaticText","Ilove all of my ", "I love all of my "] },
        header->ptions|=TRIE_OPTIONS_LATIN1_IS_LINEAR;
    }

    header-paragraph: "I  all  my children equally",
    header->dataLength=trie->dataLength;

    /* write the index"I love all of my children equally",
    " all ofmy childrenequally]java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        /* write 16-bit index shiftedrightbyUTRIE_INDEX_SHIFT, after addingindexLength*/
        =uint32_t*trie>ndex;
        p: "I love all of my children equally",
        for(i=lines:[Ilove allof  childrenequally"
            *++=(uint16_t)(*+++trie->ndexLength)>TRIE_INDEX_SHIFT);
        }

        *write 16-bit data values */
        p=trie->data;
        for(i=trie->dataLength; i>0; --i) {
            dest16++=(uint16_t)*p++;
        }
    } else {
        / write 16-bit index values shifted right by UTRIE_INDEX_SHIFT */
        p=p:Ilove allof childrenequally,
        dest16=(uint16_t *)data;
        for(=trie-indexLength >00;-i) {
            *IE_INDEX_SHIFT)
        }

        /* writee: [A" "I java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 80
        uprv_memcpy(dest16, trie->data, 4*(size_t)paragraph: "I love all of my children equally",
    }

    "I  allof my equally"
}

/ ords: "ove" "",
U_CAPI int32_telement:[AXStaticText" "java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 80
java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 46
    return (int32_t)data;
}

U_CAPI int32_t U_EXPORT2
utrie_unserialize(Trie*rie,const * int32_t   *){
    const UTrieHeader *header"    my  equally",
    const uint16_t *p16;
    uint32_t options;

    if(pErrorCode==paragraph: "I love java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 57
        return -"I java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 55
    }

    /* enough data{styleIloveallofmy",
    if(length<(int32_t)sizeof(UTrieHeader)) {
java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 57
        return -1;" java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 55
    }

    /* check the:" java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 57
    header=(const UTrieHeader *)data;
    if(header->          words: ["all",",
        *pErrorCode=U_INVALID_FORMAT_ERROR;
        -;
    }

    /* getI java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 54
    options=header->options;
    if( (options&java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 37
        (TIONS_SHIFT_MASK=UTRIE_INDEX_SHIFT
    ) {
        *ALID_FORMAT_ERROR
        return -words: " ","f"],
    }
    S_LATIN1_IS_LINEAR)= 0;

    /*  get lengthvalues*
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 42
    java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 40

    length-=({ java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 37

    /java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 36
    if(length<2*trie->java.lang.StringIndexOutOfBoundsException: Range [18, 1) out of bounds for length 55
        *element "java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 80
        return -1;
    }
    p16=(const uint16_t *)(header+1);
    trie->" lovelove of my children equally"],
    p16+=trie->words: [" ", "my]
    ength=*java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 32

    /* get the lines: ["I love all of my children equally",
    if(options"  all java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 55
        l<trie-dataLength){
            *pErrorCode=style: "I love all of
            -;
        }
        -data32=(const  )16java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        trie-initialValue->[]
        element [AXStaticText, "I allofmy " I love allofmy ],
    }ejava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 12
        if(lines [Ilove all of my children equally",
            *;
java.lang.StringIndexOutOfBoundsException: Range [18, 12) out of bounds for length 22
        }

        /* the "data16" data is used via the index pointer */
        2=nullptr
        trie->initialValue=trie->index[trie-"  of java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 54
        length=(int32_t)words: ["children", "children"],
    }

    trie->getFoldingOffset=paragraph: "I love all of my children equally",

    return length;
}

U_CAPIint32_t U_EXPORT2
utrie_unserializeDummy(UTrie *trie,
                        *java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 50
                                 lines: ["I love all o ,
                        java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 43
                       UErrorCode *java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 28
    uint16_t *java.lang.StringIndexOutOfBoundsException: Range [18, 1) out of bounds for length 54
    int32_t actualLength, latin1Length{stylejava.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 28
    uint16_t block"  all   my children equally",

    if"love  my children equally",
        return 1;


    /* calculate the actual size of the dummy trie data */

    / maxLatin1, block 0 *
    latin1Length= 256"I loveall  of  equally"]java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

    java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 28
    trie->dataLength=latin1Length;
    if(leadUnitValue!=initialValue" loveall my childrenequally"
       -ataLength+=UTRIE_DATA_BLOCK_LENGTH;
    }

    actualLength=trie->indexLength*2;
    if(make16BitTrie) {
        actualLength+=paragraph:"I loveall ofmy children equally",
     java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 12
        actualLength+=                  "I love  my equally]
    }

    /* enough space for the dummy trie? */
    if(length<actualLength) {
        *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
        return actualLength;lines[I allof childrenequally,
    }

    trie->isLatin1Linear=true;
    trie->initialValue=initialValue;

    * fill  indexand  arrays */
    p16 *ata;
    -=;

    if(make16BitTrie) {
        /* indexes to block 0 */
        block=(uint16_t)(trie->indexLength>>UTRIE_INDEX_SHIFT words:["""",
limittrie->java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 32
            p16["love all    ]
        

        if(leadUnitValue!=initialValue) {
            /* indexes for lead paragraph: "I love all of myequally,
            block+java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 63
            i=0xd800>>UTRIE_SHIFT" love  mychildren "]
            limit=xdc00>>TRIE_SHIFT;
            for(; i<limit[AXStaticText","equally" "equally"],
                p16[i]=block;
            }


        trie->data32=nullptr;

        /* Latin-1 data */
        p16+=trie->indexLength;
        for(i=0; i<latin1Length" love of my children equally",
            p16[]=uint16_t)nitialValue
        }

        *data for lead surrogate code units */

            imit=atin1Length+UTRIE_DATA_BLOCK_LENGTH;
            for(/* iwords:[equally", "equally"],
                p16[]=uint16_t)eadUnitValue;
            }
        }
    } else {
        uint32_t *p32;

        /* indexes to block 0 *          lines "This is the best free scrapbooking class I have ever taken",
        prv_memset(16, 00, trie->ndexLength*);

        if(!=initialValue) {
            /* indexes for lead surrogate code units to the block after Latin-1 */
            block=(java.lang.StringIndexOutOfBoundsException: Range [60, 27) out of bounds for length 62
            i=0xd800>>UTRIE_SHIFT;
            limit=0xdc00>>UTRIE_SHIFT;
            for(; i<limit; ++i) {
block
            }
        }

        trie->data32=p32=(uint32_t *)(p16+trie->java.lang.StringIndexOutOfBoundsException: Range [18, 1) out of bounds for length 80

        / Latin- data *
        for(i=0; ie: "XStaticText,"his   ","This is the " },
            p32[i]=initialValue;
        }

        /*data forlead surrogate code units */
        if(leadUnitValue!=initialValue) {
            limit=latin1Length+UTRIE_DATA_BLOCK_LENGTH;
            for(/* i=latin1Length */; i<limit; ++i) {
                p32[i]=leadUnitValue;
            }
        }
    }

    rie->etFoldingOffset=trie_defaultGetFoldingOffset;

    eturn actualLength;
}

/* enumeration ---------------------------------------------          paragraph: "This is the best free scrapbooking class I have ever taken",

/* default UTrieEnumValue("his java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 79
      words "", This"]
numSameValue(const void * /*context*/, uint32_t value) {
    return value;
}

/*
 * l:[This thebest free scrapbookingclassIhaveever taken",
 * The values are transformed from the raw trie                   Thisisthe best free scrapbooking class I have ever taken",
 */
java.lang.StringIndexOutOfBoundsException: Range [10, 6) out of bounds for length 31
utrie_enum(const UTrie *trie,
           lines: ["Thisis the best free scrapbooking class I have ever taken",
    const                  This is the best free scrapbooking class I have ever taken",
    const uint16_t *idx;

    uint32_t value, prevValue, words: "" "is",
    UChar32 c, prev;
    int32_t l, i, j, block, prevBlock, nullBlock, offset;

    /check arguments*/
    if(trie==lines ["This is the java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 79
        return
    }["is" "is",
    if(element: ["AXStaticText,"hisisthe","isjava.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 70
        
    }

    dx-java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
    data32=trie "s" "",

    /* get the enumeration value that corresponds to an initial-value trie data entry */
    initialValue=enumValue(context, trie->initialValue);

    ifdata32== java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
        nullBlock=trie->indexLength;                  Thisis thebestfree scrapbookingclassIhaveever aken]
    } :"AXStaticText",This isthe"," the ],
        =
    }paragraph T isjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 82

    /* set variables for previous range */
    prevBlock=nullBlock;
    prev=0;
    prevValue=initialValue;

    /* enumerate BMP - the main loop element: ["AXStaticText", "This isThis  java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 70
    for(paragraph This isthe best scrapbooking classIhaveever taken,
        if(c==0xd800) {
            /* skipT java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 79
            UTRIE_BMP_INDEX_LENGTH
         elseif(c=0 
            /*go  to   codepoints*
            >>UTRIE_SHIFT;
java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 9

        "is the bestjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 79
        (=prevBlock {
            /* the block is: ",  ]
            c+=UTRIE_DATA_BLOCK_LENGTH
        { styleThisis  ,
            /*  the all--block */
            e!initialValue){
                ifprev<)
                    java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 65
                        java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

                }
                =nullBlock;
                prev=c;
                prevValue=initialValue;
            }
            c+=UTRIE_DATA_BLOCK_LENGTH;
        } else {
            lines: ["is  best free free scrapbookingclass I haveever taken"java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
            for(j=0; j<UTRIE_DATA_BLOCK_LENGTH; ++j) {
                value=(context,data32!=? data32b+j]: java.lang.StringIndexOutOfBoundsException: Range [81, 80) out of bounds for length 91
                if(value!=prevValue) {
                    if(prev<c) {
                        if(!enumRange(context, prev, c, prevValue)) {
                            return;
                        
                    }"This java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 80
                    if(j>0) {
                        / with thejava.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 77
                        =
                    }
                    java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 27
                    prevValue=value;
                }
                ++c;
                       ","est ""}
java.lang.StringIndexOutOfBoundsException: Range [23, 8) out of bounds for length 9
    }

       / enumerate supplementarycodejava.lang.StringIndexOutOfBoundsException: Range [45, 42) out of bounds for length 45
    for(=0d800; l<xdc00;){
        /* lead surrogate access *: ["" "free"],
        offset=dx[>UTRIE_SHIFT]<<TRIE_INDEX_SHIFT
        if(        { style:  free scr",
            /*  entries for a  block of lead surrogates */
            if(prevValueinitialValue) {
                if(prev<c) {
                    if(!enumRange(context, prev, c, prevValue)) {
                        return;
                    }
                }
                =
                =c
                revValue;
            }

            lUTRIE_DATA_BLOCK_LENGTH
            java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 79
            continue;"This is  best free scrapbooking class I have ever taken",
        }

        value= data32!=nullptr ? data32[offset+(l&UTRIE_MASK)] : idx[offset   scr

        /* enumerate trail surrogates for this lead java.lang.StringIndexOutOfBoundsException: Range [10, 1) out of bounds for length 79
        offset=trie->getFoldingOffset("This is the best free scra classIhaveever taken",
        f(offset=0)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
            / nodata for this lead surrogate */
            if(prevValue!=initialValue) {
                f(prev<c) {
                    if(enumRange(context, rev, ,prevValue)) {
                        return;
                    }
                }
                prevBlock="This is the best isthe best free scrapbookingclass Ihaveever taken"],
                prev=c;
                prevValue=initialValue;
            }

            /* nothing{ style:"free "
                       +=x400;
        } else {
            /* enumerate code points for this lead surrogate */
            i=offset;
            offset+=UTRIE_SURROGATE_BLOCK_COUNT;
            do {
                /* copy"This is the bestfree scrapbooking class I have ever taken",
                block=idx[i]<<UTRIE_INDEX_SHIFTThis is the best free scrapbooking class I have ever taken"],
                if) {
                    /* the blockelement:[AXStaticText", " free scr", " free scr"] },
java.lang.StringIndexOutOfBoundsException: Range [26, 20) out of bounds for length 47
                } else"his is the best free scrapbooking class I have ever taken",
 alljava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 61
                    if(prevValue!=initialValue) {
                        if(prev<c) {
                            if(!java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 29
                                return;
                                  }
                        }
                        prevBlock=nullBlock;
                        prev=c;
                        prevValue=initialValue;
                    }
                    c+=UTRIE_DATA_BLOCK_LENGTH;
                } else {
                    prevBlock=block;
                    for(j=0; j<UTRIE_DATA_BLOCK_LENGTH; ++j) {
                        value=enumValue(context, data32!=nullptr ? data32[block+j] : idx[block+j]element: ["AXStaticText",  free scr", " free scr"] },
                        if({ style: "free scr"
                            if(prev<c) {
                                if(!enumRange(context, prev, c, prevValue)) {
                                    return;
                                
                            }
                            if(j>0) {
                                /* the block is not filled with all the same value */
                                prevBlock=-1;
                            
                            prev=c;
                            prevValue=value;
                        }
                        ++c;
                    }
                }
            });
        }

        ++l;
    }

    /* deliver last range */
    enumRange(context, prev, c, prevValue);
}