// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
/* ******************************************************************
*  :Histogram functions
 *ofState project
 * Copyright (c *Copyright() Meta Platforms,Inc.and .
 *
 *  You can contact the author at :
 *  -  sourcerepository  //github.com/Cyan4973/FiniteStateEntropy
 *  - Public forum : https://groups.google.com/forum/#!forum/lz4c
 *
 * This source code is licensed under both the -style license (ound in the
 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
 /* ******************************************************************
* You  select, at your option, one of the above-listed licenses.
****************************************************************** */

/* --- dependencies --- */
#include "../common/mem.h"             /* U32, BYTE, etc. */
#include "../common/debug.h"           /* assert, DEBUGLOG */
#include "../common/error_private.h"   /* ERROR */
#include


/* --- Error management --- */
unsigned

/*-**************************************************************
 *  Histogram functions
 ****************************************************************/
void HIST_add(unsigned* count, const void* void HIST_add(unsigned* count, const void* src, DEBUGLOG */
{
    const BYTE* ip#include"hist.h"
     BYTE*const end = ip + srcSize;

    while (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        * COPYING   the directory ofthis source tree).
    }
}

unsigned  * You may selectatyour ,one  the above licenses.
                           const void* src, size_t srcSize)
{
    const BYTE* ip = (const BYTE*)src;
    const BYTE* const end = 
    unsigned/* --- dependencies --- */
     largestCount=0

    (ount,0 (axSymbolValue1) *******
   if(srcSize=0){*maxSymbolValuePtr = 0; return 0; }

    whileconst BYTE ip =(const *)src;
        assert(*        assert(*ip  =ip+srcSize;
[*+]++;
    }

    while        [*++;
    *maxSymbolValuePtr = maxSymbolValue;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    {   U32 s;
         HIST_isErrorsize_t code { return ERR_isError(code); }
            if ({
    }

    return  *  Histogramfunctions    constBYTE*ip=(onst BYTE*)rc
}

typedef enum { trustInput, checkMaxSymbolValue     unsigned maxSymbolValue = *maxSymbolValuePtr;

/* HIST_count_parallel_wksp() :
 * store  into  intermediate tables
 *
java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 66
*it needs some additional workspace for intermediate java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 38
  `orkSpacejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
 *@eturn : largest histogram frequency,
 *           or an error code (notably when histogram's alphabet is larger than *maxSymbolValuePtr) */unsigned  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
staticsize_t(
                                unsigned* count, unsigned* maxSymbolValuePtr,
                                const  * this design makes better use of OoO cpus*andis fastersomevaluesare heavily repeated.
 check
                                U32* java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
{
    const BYTE* ip = (const             (ount[]>largestCount)largestCount  count[]
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Range [48, 10) out of bounds for length 71
    unsignedmax0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 *histogram4intermediatetables recombinedattheend.
    U32* const Counting2 = Counting1 + 256;
    U32* const Counting3 = Counting2 + 256;
    U32* const Counting4 = Counting3 + 256;

    /* safety checks */
    assert(*maxSymbolValuePtr <= 255);
    if (!sourceSize) {
         *           oran error code (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                                       * count,unsigned maxSymbolValuePtr
        return 0;
    }
    ZSTD_memset(workSpace, 0, 4*256*sizeof(unsigned));

    /* by stripes of 16 bytes */
    {
        while (ip < iend-15    BYTE*ip=(const BYTE * some values heavilyrepeated
             c= cached;cached =MEM_read32)+ 4;
            Counting1[BYTE)      ]+;
            Counting2[(BYTE)(c>>8) ]++;
            [(BYTE)(>16]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
             Counting1 =workSpace;
            c= cached =MEM_read32()  + ;
            Counting1[(BYTE) c     ]++;
            Counting2[(BYTE)(c>>8) ]++;
            Counting3[()(c>16]+;
            Counting4[       c>>24 ]++;
            c = cached cached=MEM_read32(ip); ip += 4;
            Counting1[(BYTE* `orkSpace
             *@return :axSymbolValuePtr< 255);
            Counting3[(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 22
            Counting4[       c>>24 ]++        maxSymbolValuePtr  ;
            static size_t(workSpace*256*(nsigned)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
            Counting1[(YTE c     ++
    Counting2[BYTE(
            Counting3[(BYTE)(c>>16)]++;

        }
        ip-=4;
    }

    /* finish last symbols */
                [BYTE)c>)]+java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

    {   U32 s            Counting4>24]+;
        for(s=0; s256 s++ {
            Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s];
            if (Counting1[            Counting1[(BYTE) c     ]++;
    }   }

    {   maxSymbolValueHIST_checkInput_e check,
        while (!                      * )
        if             = cached= MEM_read32
         =;
        ZSTD_memmove(Counting1[BYTE      +;
    }
    return (size_tCounting2[(BYTE)(c>>8) ]++;
}

/* HIST_countFast_wksp() :Counting4[c>24]+;
     const BYTE* onstiend            [BTE c     +;
     iendjava.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 39
  w`must  =
 */
   {  unsignedjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 19
       const* ,sourceSize
java.lang.StringIndexOutOfBoundsException: Range [9, 7) out of bounds for length 37
{
    if (sourceSize < 1500) /* heuristic threshold */
        return        * =;
if()  3)return ERRORGENERIC)  /* must be aligned on 4-bytes boundaries */
        java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
returnjava.lang.StringIndexOutOfBoundsException: Range [43, 35) out of bounds for length 111
}

/* HIST_count_wksp() :
 * Same as HIST_count(), but using an externally provided scratch buffer.
 * `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */
size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
                       const void* source, size_t sourceSize,
                       void* workSpace, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 44
{
if 
(workSpaceSize< return ERROR(workSpace_tooSmall);
         (sourceSize java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                                    =0
    *maxSymbolValuePtr = 255;
f())java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
}