# 1 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
# 1 "/home/harald/linaro-android/landing-panda//"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "./system/core/include/arch/linux-arm/AndroidConfig.h" 1
# 1 "<command-line>" 2
# 1 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
# 19 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
# 1 "external/neven/Embedded/common/src/b_BasicEm/Functions.h" 1
# 29 "external/neven/Embedded/common/src/b_BasicEm/Functions.h"
# 1 "external/neven/Embedded/common/src/b_BasicEm/Basic.h" 1
# 27 "external/neven/Embedded/common/src/b_BasicEm/Basic.h"
# 1 "external/neven/Embedded/common/conf/../conf/b_BasicEm/LibConfig.h" 1
# 28 "external/neven/Embedded/common/src/b_BasicEm/Basic.h" 2

# 1 "external/neven/Embedded/common/src/b_BasicEm/Config.h" 1
# 30 "external/neven/Embedded/common/src/b_BasicEm/Basic.h" 2
# 53 "external/neven/Embedded/common/src/b_BasicEm/Basic.h"
typedef signed char int8;
typedef signed short int16;
typedef unsigned char uint8;
typedef unsigned short uint16;
# 67 "external/neven/Embedded/common/src/b_BasicEm/Basic.h"
 typedef signed int int32;
 typedef unsigned int uint32;
 typedef uint32 count_t;



typedef uint32 flag;
# 93 "external/neven/Embedded/common/src/b_BasicEm/Basic.h"
struct flt16
{
 int16 valE;
 int16 bbpE;
};
# 30 "external/neven/Embedded/common/src/b_BasicEm/Functions.h" 2
# 1 "external/neven/Embedded/common/src/b_BasicEm/String.h" 1
# 26 "external/neven/Embedded/common/src/b_BasicEm/String.h"
# 1 "/home/harald/linaro-android/android-toolchain-eabi/bin/../lib/gcc/arm-linux-androideabi/4.6.3/include/stdarg.h" 1 3 4
# 40 "/home/harald/linaro-android/android-toolchain-eabi/bin/../lib/gcc/arm-linux-androideabi/4.6.3/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 102 "/home/harald/linaro-android/android-toolchain-eabi/bin/../lib/gcc/arm-linux-androideabi/4.6.3/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 27 "external/neven/Embedded/common/src/b_BasicEm/String.h" 2
# 39 "external/neven/Embedded/common/src/b_BasicEm/String.h"
char* bbs_strcpy( char* dstA, const char* srcA );


char* bbs_strncpy( char* dstA, const char* srcA, uint32 sizeA );


char* bbs_strcat( char* dstA, const char* srcA );


char* bbs_strncat( char* dstA, const char* srcA, uint32 sizeA );


uint32 bbs_strlen( const char* strA );


flag bbs_strequal( const char* str1A, const char* str2A );


flag bbs_strmatch( const char* str1A, const char* str2A );




uint32 bbs_snprintf( char* dstA, uint32 bufSizeA, const char* formatA, ... );




uint32 bbs_vsnprintf( char* dstA, uint32 bufSizeA, const char* formatA, va_list argsA );


int32 bbs_atoi( const char* strA );
# 31 "external/neven/Embedded/common/src/b_BasicEm/Functions.h" 2
# 1 "external/neven/Embedded/common/src/b_BasicEm/Memory.h" 1
# 45 "external/neven/Embedded/common/src/b_BasicEm/Memory.h"
void* bbs_memcpy16( void* dstA, const void* srcA, uint32 sizeA );





void* bbs_memcpy32( void* dstA, const void* srcA, uint32 sizeA );





void* bbs_memset16( void* dstA, uint16 valA, uint32 sizeA );





void* bbs_memset32( void* dstA, uint32 valA, uint32 sizeA );
# 32 "external/neven/Embedded/common/src/b_BasicEm/Functions.h" 2



struct bbs_Context;
# 49 "external/neven/Embedded/common/src/b_BasicEm/Functions.h"
uint32 bbs_memWrite32( const void* ptrA,
        uint16* memPtrA );


uint32 bbs_memRead32( void* ptrA,
       const uint16* memPtrA );


uint32 bbs_memPeek32( const uint16* memPtrA );


uint32 bbs_memWrite16( const void* ptrA,
        uint16* memPtrA );


uint32 bbs_memRead16( void* ptrA,
       const uint16* memPtrA );


uint32 bbs_memWrite32Arr( struct bbs_Context* cpA,
        const void* ptrA,
        uint32 sizeA, uint16* memPtrA );


uint32 bbs_memRead32Arr( struct bbs_Context* cpA,
       void* ptrA,
       uint32 sizeA, const uint16* memPtrA );


uint32 bbs_memWrite16Arr( struct bbs_Context* cpA,
        const void* ptrA,
        uint32 sizeA, uint16* memPtrA );


uint32 bbs_memRead16Arr( struct bbs_Context* cpA,
       void* ptrA,
       uint32 sizeA, const uint16* memPtrA );




uint32 bbs_memWriteUInt32( uint32 valA,
         uint16* memPtrA );


uint32 bbs_memWriteUInt16( uint16 valA,
         uint16* memPtrA );






uint32 bbs_memReadVersion32( struct bbs_Context* cpA,
        uint32* versionPtrA,
        uint32 refVersionA,
        const uint16* memPtrA );


uint16 bbs_memCheckSum16( const uint16* memPtrA, uint32 sizeA );
# 20 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c" 2
# 1 "external/neven/Embedded/common/src/b_BasicEm/Math.h" 1
# 57 "external/neven/Embedded/common/src/b_BasicEm/Math.h"
uint16 bbs_sqrt32( uint32 valA );







uint8 bbs_sqrt16( uint16 valA );


uint16 bbs_fastSqrt32( uint32 valA );




uint32 bbs_invSqrt32( uint32 valA );




int32 bbs_inv32( int32 valA );




uint32 bbs_intLog2( uint32 valA );






uint32 bbs_pow2M1( uint32 valA );






uint32 bbs_pow2( int32 valA );
# 108 "external/neven/Embedded/common/src/b_BasicEm/Math.h"
uint32 bbs_exp( int32 valA );


int16 bbs_satS16( int32 valA );
# 122 "external/neven/Embedded/common/src/b_BasicEm/Math.h"
int32 bbs_dotProductInt16( const int16* vec1A, const int16* vec2A, uint32 sizeA );





int32 bbs_fermi( int32 valA );


void bbs_uint32ReduceToNBits( uint32* argPtrA, int32* bbpPtrA, uint32 nBitsA );


void bbs_int32ReduceToNBits( int32* argPtrA, int32* bbpPtrA, uint32 nBitsA );




uint32 bbs_convertU32( uint32 srcA, int32 srcBbpA, int32 dstBbpA );




int32 bbs_convertS32( int32 srcA, int32 srcBbpA, int32 dstBbpA );


int32 bbs_vecPowerFlt16( const int16 *xA, int16 nxA );






void bbs_vecSqrNorm32( const int32* vecA, uint32 sizeA, uint32* manPtrA, uint32* expPtrA );





void bbs_vecSqrNorm16( const int16* vecA, uint32 sizeA, uint32* manPtrA, uint32* expPtrA );




uint32 bbs_vecNorm16( const int16* vecA, uint32 sizeA );





void bbs_mulU32( uint32 v1A, uint32 v2A, uint32* manPtrA, int32* expPtrA );





void bbs_mulS32( int32 v1A, int32 v2A, int32* manPtrA, int32* expPtrA );


void bbs_matMultiplyFlt16( const int16 *x1A, int16 row1A, int16 col1A,
         const int16 *x2A, int16 col2A, int16 *rA );


void bbs_matMultiplyTranspFlt16( const int16 *x1A, int16 row1A, int16 col1A,
         const int16 *x2A, int16 row2A, int16 *rA );
# 21 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c" 2
# 1 "external/neven/Embedded/common/src/b_ImageEm/Functions.h" 1
# 26 "external/neven/Embedded/common/src/b_ImageEm/Functions.h"
# 1 "external/neven/Embedded/common/src/b_BasicEm/UInt8Arr.h" 1
# 22 "external/neven/Embedded/common/src/b_BasicEm/UInt8Arr.h"
# 1 "external/neven/Embedded/common/src/b_BasicEm/Context.h" 1
# 23 "external/neven/Embedded/common/src/b_BasicEm/Context.h"
# 1 "external/neven/Embedded/common/src/b_BasicEm/MemTbl.h" 1
# 22 "external/neven/Embedded/common/src/b_BasicEm/MemTbl.h"
# 1 "external/neven/Embedded/common/src/b_BasicEm/MemSeg.h" 1
# 23 "external/neven/Embedded/common/src/b_BasicEm/MemSeg.h"
# 1 "external/neven/Embedded/common/src/b_BasicEm/DynMemManager.h" 1
# 26 "external/neven/Embedded/common/src/b_BasicEm/DynMemManager.h"
struct bbs_Context;
struct bbs_MemSeg;







typedef void* ( *bbs_mallocFPtr )( struct bbs_Context* cpA,
           const struct bbs_MemSeg* memSegPtrA,
           uint32 sizeA );


typedef void ( *bbs_freeFPtr )( void* memPtrA );
# 57 "external/neven/Embedded/common/src/b_BasicEm/DynMemManager.h"
struct bbs_DynMemManager
{






 uint16* memPtrE;


 bbs_mallocFPtr mallocFPtrE;


 bbs_freeFPtr freeFPtrE;
};
# 81 "external/neven/Embedded/common/src/b_BasicEm/DynMemManager.h"
void bbs_DynMemManager_init( struct bbs_Context* cpA, struct bbs_DynMemManager* ptrA );


void bbs_DynMemManager_exit( struct bbs_Context* cpA, struct bbs_DynMemManager* ptrA );






uint32 bbs_DynMemManager_allocatedSize( struct bbs_Context* cpA, const struct bbs_DynMemManager* ptrA );
# 100 "external/neven/Embedded/common/src/b_BasicEm/DynMemManager.h"
uint16* bbs_DynMemManager_alloc( struct bbs_Context* cpA,
         struct bbs_DynMemManager* ptrA,
         const struct bbs_MemSeg* memSegPtrA,
         uint32 sizeA );


void bbs_DynMemManager_free( struct bbs_Context* cpA,
        struct bbs_DynMemManager* ptrA,
        uint16* memPtrA );


uint16* bbs_DynMemManager_nextBlock( struct bbs_Context* cpA,
          struct bbs_DynMemManager* ptrA,
          const struct bbs_MemSeg* memSegPtrA,
          uint16* curBlockPtrA,
          uint32 minSizeA,
          uint32* actualSizePtrA );


void bbs_DynMemManager_freeAll( struct bbs_Context* cpA,
           struct bbs_DynMemManager* ptrA );
# 24 "external/neven/Embedded/common/src/b_BasicEm/MemSeg.h" 2



struct bbs_Context;
# 74 "external/neven/Embedded/common/src/b_BasicEm/MemSeg.h"
struct bbs_MemSeg
{



 uint16* memPtrE;


 uint32 sizeE;


 uint32 allocIndexE;


 flag sharedE;


 uint32 idE;


 struct bbs_DynMemManager* dynMemManagerPtrE;
};
# 104 "external/neven/Embedded/common/src/b_BasicEm/MemSeg.h"
void bbs_MemSeg_init( struct bbs_Context* cpA,
       struct bbs_MemSeg* ptrA );


void bbs_MemSeg_exit( struct bbs_Context* cpA,
       struct bbs_MemSeg* ptrA );






uint32 bbs_MemSeg_availableSize( struct bbs_Context* cpA,
         const struct bbs_MemSeg* ptrA );


uint32 bbs_MemSeg_allocatedSize( struct bbs_Context* cpA,
         const struct bbs_MemSeg* ptrA );


uint32 bbs_MemSeg_usedSize( struct bbs_Context* cpA,
          const struct bbs_MemSeg* ptrA );


uint32 bbs_MemSeg_blocks( struct bbs_Context* cpA,
        const struct bbs_MemSeg* ptrA );


uint32 bbs_MemSeg_usedBlocks( struct bbs_Context* cpA,
         const struct bbs_MemSeg* ptrA );
# 142 "external/neven/Embedded/common/src/b_BasicEm/MemSeg.h"
struct bbs_MemSeg bbs_MemSeg_create( struct bbs_Context* cpA,
          void* memPtrA,
          uint32 sizeA );


struct bbs_MemSeg bbs_MemSeg_createShared( struct bbs_Context* cpA,
             void* memPtrA,
             uint32 sizeA );


void* bbs_MemSeg_alloc( struct bbs_Context* cpA,
         struct bbs_MemSeg* ptrA,
      uint32 sizeA );




void bbs_MemSeg_free( struct bbs_Context* cpA,
       struct bbs_MemSeg* ptrA,
       void* memPtrA );


void bbs_MemSeg_checkConsistency( struct bbs_Context* cpA,
          const struct bbs_MemSeg* ptrA );
# 23 "external/neven/Embedded/common/src/b_BasicEm/MemTbl.h" 2



struct bbs_Context;
# 41 "external/neven/Embedded/common/src/b_BasicEm/MemTbl.h"
struct bbs_MemTbl
{

 uint32 esSizeE;


 struct bbs_MemSeg esArrE[ 4 ];


 struct bbs_MemSeg* espArrE[ 4 ];


 uint32 ssSizeE;


 struct bbs_MemSeg ssArrE[ 4 ];
};
# 66 "external/neven/Embedded/common/src/b_BasicEm/MemTbl.h"
void bbs_MemTbl_init( struct bbs_Context* cpA,
       struct bbs_MemTbl* ptrA );


void bbs_MemTbl_exit( struct bbs_Context* cpA,
       struct bbs_MemTbl* ptrA );






flag bbs_MemTbl_overlap( struct bbs_Context* cpA,
       struct bbs_MemTbl* ptrA,
       const void* memPtrA, uint32 sizeA );
# 89 "external/neven/Embedded/common/src/b_BasicEm/MemTbl.h"
void bbs_MemTbl_create( struct bbs_Context* cpA,
         struct bbs_MemTbl* ptrA,
      void* memPtrA,
      uint32 sizeA,
      uint32 sharedSubSizeA );


void bbs_MemTbl_add( struct bbs_Context* cpA,
      struct bbs_MemTbl* ptrA,
      void* memPtrA,
      uint32 sizeA,
      uint32 idA );


void bbs_MemTbl_addShared( struct bbs_Context* cpA,
         struct bbs_MemTbl* ptrA,
         void* memPtrA,
         uint32 sizeA,
         uint32 idA );


struct bbs_MemSeg* bbs_MemTbl_segPtr( struct bbs_Context* cpA,
           struct bbs_MemTbl* ptrA,
           uint32 idA );

struct bbs_MemSeg* bbs_MemTbl_sharedSegPtr( struct bbs_Context* cpA,
              struct bbs_MemTbl* ptrA,
           uint32 idA );




struct bbs_MemSeg* bbs_MemTbl_fastestSegPtr( struct bbs_Context* cpA,
            struct bbs_MemTbl* ptrA,
            uint32 minSizeA );


struct bbs_MemSeg* bbs_MemTbl_largestSegPtr( struct bbs_Context* cpA,
            struct bbs_MemTbl* ptrA );


struct bbs_MemSeg* bbs_MemTbl_fastestSharedSegPtr( struct bbs_Context* cpA,
               struct bbs_MemTbl* ptrA,
               uint32 minSizeA );


struct bbs_MemSeg* bbs_MemTbl_largestSharedSegPtr( struct bbs_Context* cpA,
               struct bbs_MemTbl* ptrA );
# 24 "external/neven/Embedded/common/src/b_BasicEm/Context.h" 2




struct bbs_Context;




typedef void ( *bbs_errorFPtr )( struct bbs_Context* cpA );


typedef uint32 ( *bbs_callbackFPtr )( struct bbs_Context* cpA );
# 67 "external/neven/Embedded/common/src/b_BasicEm/Context.h"
struct bbs_Error
{

 uint32 errorE;


 uint32 lineE;


 char fileE[ 52 ];


 char textE[ 256 ];
};




struct bbs_Context
{




 struct bbs_Error errStackE[ 8 ];


 uint32 errIndexE;


 struct bbs_MemTbl memTblE;


 struct bbs_DynMemManager dynMemManagerArrE[ 8 ];


 uint32 dynMemManagerArrSizeE;


 bbs_errorFPtr errorHandlerE;


 bbs_callbackFPtr callbackHandlerE;


 void* userPtrE;



};
# 125 "external/neven/Embedded/common/src/b_BasicEm/Context.h"
void bbs_Context_init( struct bbs_Context* cpA );


void bbs_Context_exit( struct bbs_Context* cpA );




void bbs_Context_copy( struct bbs_Context* cpA, const struct bbs_Context* srcPtrA );






struct bbs_Error bbs_Error_create( uint32 errorA, uint32 lineA, const char* fileA, const char* textA, ... );
# 149 "external/neven/Embedded/common/src/b_BasicEm/Context.h"
flag bbs_Context_pushError( struct bbs_Context* cpA, struct bbs_Error errorA );


struct bbs_Error bbs_Context_popError( struct bbs_Context* cpA );


struct bbs_Error bbs_Context_peekError( struct bbs_Context* cpA );


flag bbs_Context_error( struct bbs_Context* cpA );





bbs_errorFPtr bbs_Context_setErrorHandler( struct bbs_Context* cpA,
                bbs_errorFPtr errorHandlerA );






void bbs_Context_doCallback( struct bbs_Context* cpA );





bbs_callbackFPtr bbs_Context_setCallbackHandler( struct bbs_Context* cpA,
                      bbs_callbackFPtr callbackHandlerA );






void bbs_Context_addStaticSeg( struct bbs_Context* cpA,
           uint16* memPtrA,
        uint32 sizeA,
        flag sharedA,
        uint32 idA );




void bbs_Context_addDynamicSeg( struct bbs_Context* cpA,
        bbs_mallocFPtr mallocFPtrA,
        bbs_freeFPtr freeFPtrA,
        flag sharedA,
        uint32 idA );



uint32 bbs_Context_exclAllocSize( struct bbs_Context* cpA, uint32 segIndexA );





uint32 bbs_Context_shrdAllocSize( struct bbs_Context* cpA, uint32 segIndexA );
# 222 "external/neven/Embedded/common/src/b_BasicEm/Context.h"
void bbs_Context_quickInit( struct bbs_Context* cpA,
           bbs_mallocFPtr mallocFPtrA,
          bbs_freeFPtr freeFPtrA,
          bbs_errorFPtr errorHandlerA );
# 23 "external/neven/Embedded/common/src/b_BasicEm/UInt8Arr.h" 2
# 34 "external/neven/Embedded/common/src/b_BasicEm/UInt8Arr.h"
struct bbs_UInt8Arr
{




 struct bbs_MemSeg* mspE;




 uint8* arrPtrE;


 uint32 sizeE;


 uint32 allocatedSizeE;

};
# 62 "external/neven/Embedded/common/src/b_BasicEm/UInt8Arr.h"
void bbs_UInt8Arr_init( struct bbs_Context* cpA,
         struct bbs_UInt8Arr* ptrA );


void bbs_UInt8Arr_exit( struct bbs_Context* cpA,
         struct bbs_UInt8Arr* ptrA );




void bbs_UInt8Arr_copy( struct bbs_Context* cpA,
         struct bbs_UInt8Arr* ptrA,
      const struct bbs_UInt8Arr* srcPtrA );


flag bbs_UInt8Arr_equal( struct bbs_Context* cpA,
       const struct bbs_UInt8Arr* ptrA,
       const struct bbs_UInt8Arr* srcPtrA );




uint32 bbs_UInt8Arr_heapSize( struct bbs_Context* cpA,
         const struct bbs_UInt8Arr* ptrA,
         uint32 sizeA );




void bbs_UInt8Arr_create( struct bbs_Context* cpA,
        struct bbs_UInt8Arr* ptrA,
        uint32 sizeA,
        struct bbs_MemSeg* mspA );


void bbs_UInt8Arr_size( struct bbs_Context* cpA,
         struct bbs_UInt8Arr* ptrA, uint32 sizeA );




uint32 bbs_UInt8Arr_memSize( struct bbs_Context* cpA,
        const struct bbs_UInt8Arr* ptrA );


uint32 bbs_UInt8Arr_memWrite( struct bbs_Context* cpA,
         const struct bbs_UInt8Arr* ptrA,
         uint16* memPtrA );


uint32 bbs_UInt8Arr_memRead( struct bbs_Context* cpA,
        struct bbs_UInt8Arr* ptrA,
        const uint16* memPtrA,
            struct bbs_MemSeg* mspA );




void bbs_UInt8Arr_fill( struct bbs_Context* cpA,
         struct bbs_UInt8Arr* ptrA,
      uint8 valA );
# 27 "external/neven/Embedded/common/src/b_ImageEm/Functions.h" 2
# 1 "external/neven/Embedded/common/src/b_TensorEm/Functions.h" 1
# 32 "external/neven/Embedded/common/src/b_TensorEm/Functions.h"
enum bts_AltType
{
 bts_ALT_IDENTITY = 1,
 bts_ALT_TRANS,
 bts_ALT_TRANS_SCALE,
 bts_ALT_RIGID,
 bts_ALT_LINEAR,
 bts_ALT_TRANS_SCALE_XYZ
};

enum bts_RBFType
{
 bts_RBF_IDENTITY = 1,
 bts_RBF_LINEAR
};






uint32 bts_absIntLog2( int32 vA );


uint32 bts_maxAbsIntLog2Of2( int32 v1A, int32 v2A );


uint32 bts_maxAbsIntLog2Of3( int32 v1A, int32 v2A, int32 v3A );


uint32 bts_maxAbsIntLog2Of4( int32 v1A, int32 v2A, int32 v3A, int32 v4A );
# 28 "external/neven/Embedded/common/src/b_ImageEm/Functions.h" 2
# 1 "external/neven/Embedded/common/src/b_TensorEm/Flt16Alt2D.h" 1
# 24 "external/neven/Embedded/common/src/b_TensorEm/Flt16Alt2D.h"
# 1 "external/neven/Embedded/common/src/b_TensorEm/Flt16Mat2D.h" 1
# 23 "external/neven/Embedded/common/src/b_TensorEm/Flt16Mat2D.h"
# 1 "external/neven/Embedded/common/src/b_BasicEm/Phase.h" 1
# 39 "external/neven/Embedded/common/src/b_BasicEm/Phase.h"
typedef int8 phase8;


typedef int16 phase16;


typedef int32 phase32;
# 89 "external/neven/Embedded/common/src/b_BasicEm/Phase.h"
int32 bbs_sin32( phase16 phaseA );
# 98 "external/neven/Embedded/common/src/b_BasicEm/Phase.h"
int32 bbs_cos32( phase16 phaseA );






int16 bbs_sin16( phase16 phaseA );






int16 bbs_cos16( phase16 phaseA );







phase16 bbs_atan16( uint32 valA );







phase16 bbs_phase16( int32 xA, int32 yA );
# 24 "external/neven/Embedded/common/src/b_TensorEm/Flt16Mat2D.h" 2
# 1 "external/neven/Embedded/common/src/b_TensorEm/Int16Vec2D.h" 1
# 35 "external/neven/Embedded/common/src/b_TensorEm/Int16Vec2D.h"
struct bts_Int16Vec2D
{






 int16 xE;


 int16 yE;
};
# 56 "external/neven/Embedded/common/src/b_TensorEm/Int16Vec2D.h"
void bts_Int16Vec2D_init( struct bts_Int16Vec2D* ptrA );


void bts_Int16Vec2D_exit( struct bts_Int16Vec2D* ptrA );
# 70 "external/neven/Embedded/common/src/b_TensorEm/Int16Vec2D.h"
uint32 bts_Int16Vec2D_memSize( struct bbs_Context* cpA,
          const struct bts_Int16Vec2D* ptrA );


uint32 bts_Int16Vec2D_memWrite( struct bbs_Context* cpA,
           const struct bts_Int16Vec2D* ptrA,
        uint16* memPtrA );


uint32 bts_Int16Vec2D_memRead( struct bbs_Context* cpA,
          struct bts_Int16Vec2D* ptrA,
          const uint16* memPtrA );




int32 bts_Int16Vec2D_dotPrd( const struct bts_Int16Vec2D* vec1PtrA,
        const struct bts_Int16Vec2D* vec2PtrA );


uint32 bts_Int16Vec2D_norm2( const struct bts_Int16Vec2D* ptrA );


uint16 bts_Int16Vec2D_norm( const struct bts_Int16Vec2D* ptrA );


void bts_Int16Vec2D_normalize( struct bts_Int16Vec2D* ptrA, int32 bbpA );


struct bts_Int16Vec2D bts_Int16Vec2D_normalized( const struct bts_Int16Vec2D* ptrA, int32 bbpA );


phase16 bts_Int16Vec2D_angle( const struct bts_Int16Vec2D* vecPtrA );


phase16 bts_Int16Vec2D_enclosedAngle( const struct bts_Int16Vec2D* vec1PtrA,
           const struct bts_Int16Vec2D* vec2PtrA );
# 25 "external/neven/Embedded/common/src/b_TensorEm/Flt16Mat2D.h" 2
# 1 "external/neven/Embedded/common/src/b_TensorEm/Flt16Vec2D.h" 1
# 35 "external/neven/Embedded/common/src/b_TensorEm/Flt16Vec2D.h"
struct bts_Flt16Vec2D
{






 int16 xE;


 int16 yE;


 int16 bbpE;
};
# 59 "external/neven/Embedded/common/src/b_TensorEm/Flt16Vec2D.h"
void bts_Flt16Vec2D_init( struct bts_Flt16Vec2D* ptrA );


void bts_Flt16Vec2D_exit( struct bts_Flt16Vec2D* ptrA );




void bts_Flt16Vec2D_copy( struct bts_Flt16Vec2D* ptrA, const struct bts_Flt16Vec2D* srcPtrA );


flag bts_Flt16Vec2D_equal( const struct bts_Flt16Vec2D* ptrA, const struct bts_Flt16Vec2D* srcPtrA );
# 81 "external/neven/Embedded/common/src/b_TensorEm/Flt16Vec2D.h"
struct bts_Flt16Vec2D bts_Flt16Vec2D_create16( int16 xA, int16 yA, int16 bbpA );


struct bts_Flt16Vec2D bts_Flt16Vec2D_createVec16( struct bts_Int16Vec2D vecA, int16 bbpA );


struct bts_Flt16Vec2D bts_Flt16Vec2D_create32( int32 xA, int32 yA, int32 bbpA );



int32 bts_Flt16Vec2D_dotPrd( const struct bts_Flt16Vec2D* vec1PtrA,
        const struct bts_Flt16Vec2D* vec2PtrA );


uint32 bts_Flt16Vec2D_norm2( const struct bts_Flt16Vec2D* ptrA );


uint16 bts_Flt16Vec2D_norm( const struct bts_Flt16Vec2D* ptrA );


void bts_Flt16Vec2D_normalize( struct bts_Flt16Vec2D* ptrA );


struct bts_Flt16Vec2D bts_Flt16Vec2D_normalized( const struct bts_Flt16Vec2D* ptrA );


phase16 bts_Flt16Vec2D_angle( const struct bts_Flt16Vec2D* vecPtrA );


phase16 bts_Flt16Vec2D_enclosedAngle( const struct bts_Flt16Vec2D* vec1PtrA,
           const struct bts_Flt16Vec2D* vec2PtrA );


struct bts_Flt16Vec2D bts_Flt16Vec2D_add( struct bts_Flt16Vec2D vec1A, struct bts_Flt16Vec2D vec2A );


struct bts_Flt16Vec2D bts_Flt16Vec2D_sub( struct bts_Flt16Vec2D vec1A, struct bts_Flt16Vec2D vec2A );


struct bts_Flt16Vec2D bts_Flt16Vec2D_mul( struct bts_Flt16Vec2D vecA, int16 factorA, int32 bbpFactorA );


struct bts_Int16Vec2D bts_Flt16Vec2D_int16Vec2D( struct bts_Flt16Vec2D vecA, int32 dstBbpA );
# 26 "external/neven/Embedded/common/src/b_TensorEm/Flt16Mat2D.h" 2
# 36 "external/neven/Embedded/common/src/b_TensorEm/Flt16Mat2D.h"
struct bts_Flt16Mat2D
{






 int16 xxE;


 int16 xyE;


 int16 yxE;


 int16 yyE;


 int16 bbpE;
};
# 66 "external/neven/Embedded/common/src/b_TensorEm/Flt16Mat2D.h"
void bts_Flt16Mat2D_init( struct bts_Flt16Mat2D* ptrA );


void bts_Flt16Mat2D_exit( struct bts_Flt16Mat2D* ptrA );




void bts_Flt16Mat2D_copy( struct bts_Flt16Mat2D* ptrA, const struct bts_Flt16Mat2D* srcPtrA );


flag bts_Flt16Mat2D_equal( const struct bts_Flt16Mat2D* ptrA, const struct bts_Flt16Mat2D* srcPtrA );
# 88 "external/neven/Embedded/common/src/b_TensorEm/Flt16Mat2D.h"
uint32 bts_Flt16Mat2D_det( const struct bts_Flt16Mat2D* ptrA );


void bts_Flt16Mat2D_invert( struct bts_Flt16Mat2D* ptrA );


struct bts_Flt16Mat2D bts_Flt16Mat2D_inverted( const struct bts_Flt16Mat2D* ptrA );


struct bts_Flt16Mat2D bts_Flt16Mat2D_createIdentity( void );


struct bts_Flt16Mat2D bts_Flt16Mat2D_createRotation( phase16 angleA );


struct bts_Flt16Mat2D bts_Flt16Mat2D_createScale( int32 scaleA, int32 scaleBbpA );


struct bts_Flt16Mat2D bts_Flt16Mat2D_createRigid( phase16 angleA, int32 scaleA, int32 scaleBbpA );


struct bts_Flt16Mat2D bts_Flt16Mat2D_create16( int16 xxA, int16 xyA, int16 yxA, int16 yyA, int16 bbpA );


struct bts_Flt16Mat2D bts_Flt16Mat2D_create32( int32 xxA, int32 xyA, int32 yxA, int32 yyA, int32 bbpA );


void bts_Flt16Mat2D_scale( struct bts_Flt16Mat2D* ptrA, int32 scaleA, int32 scaleBbpA );


struct bts_Int16Vec2D bts_Flt16Mat2D_map( const struct bts_Flt16Mat2D* matPtrA,
                  const struct bts_Int16Vec2D* vecPtrA );


struct bts_Flt16Vec2D bts_Flt16Mat2D_mapFlt( const struct bts_Flt16Mat2D* matPtrA,
                     const struct bts_Flt16Vec2D* vecPtrA );


struct bts_Flt16Mat2D bts_Flt16Mat2D_mul( const struct bts_Flt16Mat2D* mat1PtrA,
                  const struct bts_Flt16Mat2D* mat2PtrA );


struct bts_Flt16Mat2D* bts_Flt16Mat2D_mulTo( struct bts_Flt16Mat2D* mat1PtrA,
                                 const struct bts_Flt16Mat2D* mat2PtrA );
# 25 "external/neven/Embedded/common/src/b_TensorEm/Flt16Alt2D.h" 2
# 36 "external/neven/Embedded/common/src/b_TensorEm/Flt16Alt2D.h"
struct bts_Flt16Alt2D
{






 struct bts_Flt16Mat2D matE;


 struct bts_Flt16Vec2D vecE;
};
# 57 "external/neven/Embedded/common/src/b_TensorEm/Flt16Alt2D.h"
void bts_Flt16Alt2D_init( struct bts_Flt16Alt2D* ptrA );


void bts_Flt16Alt2D_exit( struct bts_Flt16Alt2D* ptrA );




void bts_Flt16Alt2D_copy( struct bts_Flt16Alt2D* ptrA,
        const struct bts_Flt16Alt2D* srcPtrA );


flag bts_Flt16Alt2D_equal( const struct bts_Flt16Alt2D* ptrA,
         const struct bts_Flt16Alt2D* srcPtrA );
# 79 "external/neven/Embedded/common/src/b_TensorEm/Flt16Alt2D.h"
uint32 bts_Flt16Alt2D_memSize( struct bbs_Context* cpA,
          const struct bts_Flt16Alt2D* ptrA );


uint32 bts_Flt16Alt2D_memWrite( struct bbs_Context* cpA,
           const struct bts_Flt16Alt2D* ptrA,
        uint16* memPtrA );


uint32 bts_Flt16Alt2D_memRead( struct bbs_Context* cpA,
          struct bts_Flt16Alt2D* ptrA,
          const uint16* memPtrA );




void bts_Flt16Alt2D_invert( struct bts_Flt16Alt2D* ptrA );


struct bts_Flt16Alt2D bts_Flt16Alt2D_inverted( const struct bts_Flt16Alt2D* ptrA );


struct bts_Flt16Alt2D bts_Flt16Alt2D_createIdentity( void );


struct bts_Flt16Alt2D bts_Flt16Alt2D_createRotation( phase16 angleA,
              const struct bts_Flt16Vec2D* centerPtrA );


struct bts_Flt16Alt2D bts_Flt16Alt2D_createScale( int32 scaleA,
              int32 scaleBbpA,
              const struct bts_Flt16Vec2D* centerPtrA );


struct bts_Flt16Alt2D bts_Flt16Alt2D_createRigid( phase16 angleA,
              int32 scaleA,
              int32 scaleBbpA,
              const struct bts_Flt16Vec2D* centerPtrA );


struct bts_Flt16Alt2D bts_Flt16Alt2D_createRigidMap( struct bts_Flt16Vec2D vecIn1A,
                 struct bts_Flt16Vec2D vecIn2A,
                 struct bts_Flt16Vec2D vecOut1A,
                 struct bts_Flt16Vec2D vecOut2A );


struct bts_Flt16Alt2D bts_Flt16Alt2D_create16( int16 xxA,
              int16 xyA,
              int16 yxA,
              int16 yyA,
              int16 matBbpA,
              int16 xA,
              int16 yA,
              int16 vecBbpA );


struct bts_Flt16Alt2D bts_Flt16Alt2D_create32( int32 xxA,
              int32 xyA,
              int32 yxA,
              int32 yyA,
              int32 matBbpA,
              int32 xA,
              int32 yA,
              int32 vecBbpA );




struct bts_Flt16Vec2D bts_Flt16Alt2D_mapFlt( const struct bts_Flt16Alt2D* matPtrA,
                     const struct bts_Flt16Vec2D* vecPtrA );


struct bts_Flt16Alt2D bts_Flt16Alt2D_mul( const struct bts_Flt16Alt2D* alt1PtrA,
                  const struct bts_Flt16Alt2D* alt2PtrA );


struct bts_Flt16Alt2D* bts_Flt16Alt2D_mulTo( struct bts_Flt16Alt2D* alt1PtrA,
                                 const struct bts_Flt16Alt2D* alt2PtrA );
# 29 "external/neven/Embedded/common/src/b_ImageEm/Functions.h" 2






enum bim_PyramidalImageType
{
 bim_UINT8_PYRAMIDAL_IMG,
 bim_UINT16_PYRAMIDAL_IMG
};
# 54 "external/neven/Embedded/common/src/b_ImageEm/Functions.h"
void bim_filterWarpInterpolation( struct bbs_Context* cpA,
          uint8* dstImagePtrA,
          const uint8* srcImagePtrA,
          uint32 srcImageWidthA,
          uint32 srcImageHeightA,
          const struct bts_Int16Vec2D* offsPtrA,
          const struct bts_Flt16Alt2D* altPtrA,
          uint32 dstWidthA,
          uint32 dstHeightA,
          struct bbs_UInt8Arr* bufPtrA,
          uint32 scaleThresholdA );
# 74 "external/neven/Embedded/common/src/b_ImageEm/Functions.h"
void bim_filterWarpPixelReplication( struct bbs_Context* cpA,
          uint8* dstImagePtrA,
          const uint8* srcImagePtrA,
          uint32 srcImageWidthA,
          uint32 srcImageHeightA,
             const struct bts_Int16Vec2D* offsPtrA,
          const struct bts_Flt16Alt2D* altPtrA,
          uint32 dstWidthA,
          uint32 dstHeightA,
          struct bbs_UInt8Arr* bufPtrA,
          uint32 scaleThresholdA );




void bim_filterWarp( struct bbs_Context* cpA,
      uint8* dstImagePtrA,
      const uint8* srcImagePtrA,
      uint32 srcImageWidthA,
      uint32 srcImageHeightA,
           const struct bts_Int16Vec2D* offsPtrA,
      const struct bts_Flt16Alt2D* altPtrA,
      uint32 dstWidthA,
      uint32 dstHeightA,
      struct bbs_UInt8Arr* bufPtrA,
      uint32 scaleThresholdA,
      flag interpolateA );
# 22 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c" 2
# 1 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h" 1
# 24 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h"
# 1 "external/neven/Embedded/common/src/b_BasicEm/UInt32Arr.h" 1
# 34 "external/neven/Embedded/common/src/b_BasicEm/UInt32Arr.h"
struct bbs_UInt32Arr
{




 struct bbs_MemSeg* mspE;




 uint32* arrPtrE;


 uint32 sizeE;


 uint32 allocatedSizeE;

};
# 62 "external/neven/Embedded/common/src/b_BasicEm/UInt32Arr.h"
void bbs_UInt32Arr_init( struct bbs_Context* cpA,
       struct bbs_UInt32Arr* ptrA );


void bbs_UInt32Arr_exit( struct bbs_Context* cpA,
       struct bbs_UInt32Arr* ptrA );




void bbs_UInt32Arr_copy( struct bbs_Context* cpA,
       struct bbs_UInt32Arr* ptrA,
       const struct bbs_UInt32Arr* srcPtrA );


flag bbs_UInt32Arr_equal( struct bbs_Context* cpA,
        const struct bbs_UInt32Arr* ptrA,
        const struct bbs_UInt32Arr* srcPtrA );




uint32 bbs_UInt32Arr_heapSize( struct bbs_Context* cpA,
          const struct bbs_UInt32Arr* ptrA,
          uint32 sizeA );




void bbs_UInt32Arr_create( struct bbs_Context* cpA,
         struct bbs_UInt32Arr* ptrA,
        uint32 sizeA,
        struct bbs_MemSeg* mspA );


void bbs_UInt32Arr_size( struct bbs_Context* cpA,
       struct bbs_UInt32Arr* ptrA, uint32 sizeA );




uint32 bbs_UInt32Arr_memSize( struct bbs_Context* cpA,
         const struct bbs_UInt32Arr* ptrA );


uint32 bbs_UInt32Arr_memWrite( struct bbs_Context* cpA,
          const struct bbs_UInt32Arr* ptrA,
          uint16* memPtrA );


uint32 bbs_UInt32Arr_memRead( struct bbs_Context* cpA,
         struct bbs_UInt32Arr* ptrA,
        const uint16* memPtrA,
        struct bbs_MemSeg* mspA );




void bbs_UInt32Arr_fill( struct bbs_Context* cpA,
       struct bbs_UInt32Arr* ptrA,
       uint32 valA );
# 25 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h" 2
# 1 "external/neven/Embedded/common/src/b_BasicEm/Int16Arr.h" 1
# 34 "external/neven/Embedded/common/src/b_BasicEm/Int16Arr.h"
struct bbs_Int16Arr
{




 struct bbs_MemSeg* mspE;




 int16* arrPtrE;


 uint32 sizeE;


 uint32 allocatedSizeE;

};
# 62 "external/neven/Embedded/common/src/b_BasicEm/Int16Arr.h"
void bbs_Int16Arr_init( struct bbs_Context* cpA,
         struct bbs_Int16Arr* ptrA );


void bbs_Int16Arr_exit( struct bbs_Context* cpA,
         struct bbs_Int16Arr* ptrA );




void bbs_Int16Arr_copy( struct bbs_Context* cpA,
         struct bbs_Int16Arr* ptrA,
      const struct bbs_Int16Arr* srcPtrA );


flag bbs_Int16Arr_equal( struct bbs_Context* cpA,
       const struct bbs_Int16Arr* ptrA,
       const struct bbs_Int16Arr* srcPtrA );




uint32 bbs_Int16Arr_heapSize( struct bbs_Context* cpA,
         const struct bbs_Int16Arr* ptrA,
         uint32 sizeA );




void bbs_Int16Arr_create( struct bbs_Context* cpA,
        struct bbs_Int16Arr* ptrA,
        uint32 sizeA,
        struct bbs_MemSeg* mspA );







void bbs_Int16Arr_createAligned( struct bbs_Context* cpA,
         struct bbs_Int16Arr* ptrA,
         uint32 sizeA,
         struct bbs_MemSeg* mspA,
         struct bbs_Int16Arr* allocPtrA,
         uint32 alignBytesA );


void bbs_Int16Arr_size( struct bbs_Context* cpA,
         struct bbs_Int16Arr* ptrA,
      uint32 sizeA );




uint32 bbs_Int16Arr_memSize( struct bbs_Context* cpA,
        const struct bbs_Int16Arr* ptrA );


uint32 bbs_Int16Arr_memWrite( struct bbs_Context* cpA,
         const struct bbs_Int16Arr* ptrA,
         uint16* memPtrA );


uint32 bbs_Int16Arr_memRead( struct bbs_Context* cpA,
        struct bbs_Int16Arr* ptrA,
        const uint16* memPtrA,
        struct bbs_MemSeg* mspA );




void bbs_Int16Arr_fill( struct bbs_Context* cpA,
         struct bbs_Int16Arr* ptrA,
      int16 valA );
# 26 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h" 2

# 1 "external/neven/Embedded/common/src/b_TensorEm/IdCluster2D.h" 1
# 24 "external/neven/Embedded/common/src/b_TensorEm/IdCluster2D.h"
# 1 "external/neven/Embedded/common/src/b_TensorEm/Cluster2D.h" 1
# 26 "external/neven/Embedded/common/src/b_TensorEm/Cluster2D.h"
# 1 "external/neven/Embedded/common/src/b_TensorEm/Int16Rect.h" 1
# 34 "external/neven/Embedded/common/src/b_TensorEm/Int16Rect.h"
struct bts_Int16Rect
{






 int16 x1E;


 int16 y1E;


 int16 x2E;


 int16 y2E;
};
# 61 "external/neven/Embedded/common/src/b_TensorEm/Int16Rect.h"
void bts_Int16Rect_init( struct bbs_Context* cpA, struct bts_Int16Rect* ptrA );


void bts_Int16Rect_exit( struct bbs_Context* cpA, struct bts_Int16Rect* ptrA );
# 73 "external/neven/Embedded/common/src/b_TensorEm/Int16Rect.h"
struct bts_Int16Rect bts_Int16Rect_create( int16 x1A, int16 y1A, int16 x2A, int16 y2A );




uint32 bts_Int16Rect_memSize( struct bbs_Context* cpA,
         const struct bts_Int16Rect* ptrA );


uint32 bts_Int16Rect_memWrite( struct bbs_Context* cpA,
          const struct bts_Int16Rect* ptrA,
          uint16* memPtrA );


uint32 bts_Int16Rect_memRead( struct bbs_Context* cpA,
         struct bts_Int16Rect* ptrA,
         const uint16* memPtrA );
# 27 "external/neven/Embedded/common/src/b_TensorEm/Cluster2D.h" 2





struct bts_RBFMap2D;
# 44 "external/neven/Embedded/common/src/b_TensorEm/Cluster2D.h"
struct bts_Cluster2D
{






 struct bbs_MemSeg* mspE;


 uint32 allocatedSizeE;


 uint32 sizeE;


 int32 bbpE;


 struct bts_Int16Vec2D* vecArrE;

};
# 75 "external/neven/Embedded/common/src/b_TensorEm/Cluster2D.h"
void bts_Cluster2D_init( struct bbs_Context* cpA,
       struct bts_Cluster2D* ptrA );


void bts_Cluster2D_exit( struct bbs_Context* cpA,
       struct bts_Cluster2D* ptrA );




void bts_Cluster2D_copy( struct bbs_Context* cpA,
       struct bts_Cluster2D* ptrA,
       const struct bts_Cluster2D* srcPtrA );


flag bts_Cluster2D_equal( struct bbs_Context* cpA,
        const struct bts_Cluster2D* ptrA,
        const struct bts_Cluster2D* srcPtrA );




struct bts_Flt16Vec2D bts_Cluster2D_center( struct bbs_Context* cpA,
              const struct bts_Cluster2D* ptrA );


uint32 bts_Cluster2D_checkSum( struct bbs_Context* cpA,
          const struct bts_Cluster2D* ptrA );


struct bts_Int16Rect bts_Cluster2D_boundingBox( struct bbs_Context* cpA,
               const struct bts_Cluster2D* ptrA );


int32 bts_Cluster2D_int32X( struct bbs_Context* cpA,
          const struct bts_Cluster2D* ptrA,
       uint32 indexA, int32 bbpA );


int32 bts_Cluster2D_int32Y( struct bbs_Context* cpA,
          const struct bts_Cluster2D* ptrA,
       uint32 indexA,
       int32 bbpA );




void bts_Cluster2D_create( struct bbs_Context* cpA,
         struct bts_Cluster2D* ptrA,
         uint32 sizeA,
         struct bbs_MemSeg* mspA );


void bts_Cluster2D_size( struct bbs_Context* cpA,
       struct bts_Cluster2D* ptrA,
       uint32 sizeA );


void bts_Cluster2D_transform( struct bbs_Context* cpA,
         struct bts_Cluster2D* ptrA,
         struct bts_Flt16Alt2D altA );


void bts_Cluster2D_transformBbp( struct bbs_Context* cpA,
            struct bts_Cluster2D* ptrA,
            struct bts_Flt16Alt2D altA,
         uint32 dstBbpA );


void bts_Cluster2D_rbfTransform( struct bbs_Context* cpA,
         struct bts_Cluster2D* ptrA,
         const struct bts_RBFMap2D* rbfMapPtrA );


void bts_Cluster2D_copyTransform( struct bbs_Context* cpA,
          struct bts_Cluster2D* ptrA,
          const struct bts_Cluster2D* srcPtrA,
          struct bts_Flt16Alt2D altA,
          uint32 dstBbpA );




uint32 bts_Cluster2D_memSize( struct bbs_Context* cpA,
         const struct bts_Cluster2D* ptrA );


uint32 bts_Cluster2D_memWrite( struct bbs_Context* cpA,
          const struct bts_Cluster2D* ptrA,
          uint16* memPtrA );


uint32 bts_Cluster2D_memRead( struct bbs_Context* cpA,
         struct bts_Cluster2D* ptrA,
         const uint16* memPtrA,
            struct bbs_MemSeg* mspA );






struct bts_Flt16Alt2D bts_Cluster2D_alt( struct bbs_Context* cpA,
           const struct bts_Cluster2D* srcPtrA,
           const struct bts_Cluster2D* dstPtrA,
           enum bts_AltType altTypeA );
# 25 "external/neven/Embedded/common/src/b_TensorEm/IdCluster2D.h" 2
# 38 "external/neven/Embedded/common/src/b_TensorEm/IdCluster2D.h"
struct bts_IdCluster2D
{






 struct bts_Cluster2D clusterE;


 struct bbs_Int16Arr idArrE;
};
# 59 "external/neven/Embedded/common/src/b_TensorEm/IdCluster2D.h"
void bts_IdCluster2D_init( struct bbs_Context* cpA,
         struct bts_IdCluster2D* ptrA );


void bts_IdCluster2D_exit( struct bbs_Context* cpA,
         struct bts_IdCluster2D* ptrA );




void bts_IdCluster2D_copy( struct bbs_Context* cpA,
         struct bts_IdCluster2D* ptrA,
         const struct bts_IdCluster2D* srcPtrA );


flag bts_IdCluster2D_equal( struct bbs_Context* cpA,
          const struct bts_IdCluster2D* ptrA,
       const struct bts_IdCluster2D* srcPtrA );




struct bts_Flt16Vec2D bts_IdCluster2D_center( struct bbs_Context* cpA,
             const struct bts_IdCluster2D* ptrA );


struct bts_Int16Rect bts_IdCluster2D_boundingBox( struct bbs_Context* cpA,
              const struct bts_IdCluster2D* ptrA );




void bts_IdCluster2D_create( struct bbs_Context* cpA,
        struct bts_IdCluster2D* ptrA,
        uint32 sizeA,
           struct bbs_MemSeg* mspA );


void bts_IdCluster2D_size( struct bbs_Context* cpA,
         struct bts_IdCluster2D* ptrA,
         uint32 sizeA );


void bts_IdCluster2D_transform( struct bbs_Context* cpA,
           struct bts_IdCluster2D* ptrA,
        struct bts_Flt16Alt2D altA );


void bts_IdCluster2D_copyTransform( struct bbs_Context* cpA,
            struct bts_IdCluster2D* ptrA,
         const struct bts_IdCluster2D* srcPtrA,
         struct bts_Flt16Alt2D altA,
         uint32 dstBbpA );




uint32 bts_IdCluster2D_memSize( struct bbs_Context* cpA,
           const struct bts_IdCluster2D* ptrA );


uint32 bts_IdCluster2D_memWrite( struct bbs_Context* cpA,
         const struct bts_IdCluster2D* ptrA,
         uint16* memPtrA );


uint32 bts_IdCluster2D_memRead( struct bbs_Context* cpA,
           struct bts_IdCluster2D* ptrA,
           const uint16* memPtrA,
              struct bbs_MemSeg* mspA );
# 138 "external/neven/Embedded/common/src/b_TensorEm/IdCluster2D.h"
void bts_IdCluster2D_convertToEqivalentClusters( struct bbs_Context* cpA,
             const struct bts_IdCluster2D* inCluster1PtrA,
             const struct bts_IdCluster2D* inCluster2PtrA,
             struct bts_Cluster2D* outCluster1PtrA,
             struct bts_Cluster2D* outCluster2PtrA );
# 151 "external/neven/Embedded/common/src/b_TensorEm/IdCluster2D.h"
struct bts_Flt16Alt2D bts_IdCluster2D_alt( struct bbs_Context* cpA,
             const struct bts_IdCluster2D* srcPtrA,
             struct bts_IdCluster2D* dstPtrA,
             enum bts_AltType altTypeA,
             struct bts_Cluster2D* tmpPtr1A,
             struct bts_Cluster2D* tmpPtr2A );
# 28 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h" 2
# 1 "external/neven/Embedded/common/src/b_BitFeatureEm/Sequence.h" 1
# 24 "external/neven/Embedded/common/src/b_BitFeatureEm/Sequence.h"
# 1 "external/neven/Embedded/common/src/b_BasicEm/Int32Arr.h" 1
# 34 "external/neven/Embedded/common/src/b_BasicEm/Int32Arr.h"
struct bbs_Int32Arr
{




 struct bbs_MemSeg* mspE;




 int32* arrPtrE;


 uint32 sizeE;


 uint32 allocatedSizeE;

};
# 62 "external/neven/Embedded/common/src/b_BasicEm/Int32Arr.h"
void bbs_Int32Arr_init( struct bbs_Context* cpA,
         struct bbs_Int32Arr* ptrA );


void bbs_Int32Arr_exit( struct bbs_Context* cpA,
         struct bbs_Int32Arr* ptrA );




void bbs_Int32Arr_copy( struct bbs_Context* cpA,
         struct bbs_Int32Arr* ptrA,
      const struct bbs_Int32Arr* srcPtrA );


flag bbs_Int32Arr_equal( struct bbs_Context* cpA,
       const struct bbs_Int32Arr* ptrA,
       const struct bbs_Int32Arr* srcPtrA );




uint32 bbs_Int32Arr_heapSize( struct bbs_Context* cpA,
         const struct bbs_Int32Arr* ptrA,
         uint32 sizeA );




void bbs_Int32Arr_create( struct bbs_Context* cpA,
        struct bbs_Int32Arr* ptrA,
        uint32 sizeA,
        struct bbs_MemSeg* mspA );


void bbs_Int32Arr_size( struct bbs_Context* cpA,
         struct bbs_Int32Arr* ptrA,
      uint32 sizeA );




uint32 bbs_Int32Arr_memSize( struct bbs_Context* cpA,
        const struct bbs_Int32Arr* ptrA );


uint32 bbs_Int32Arr_memWrite( struct bbs_Context* cpA,
         const struct bbs_Int32Arr* ptrA,
         uint16* memPtrA );


uint32 bbs_Int32Arr_memRead( struct bbs_Context* cpA,
        struct bbs_Int32Arr* ptrA,
        const uint16* memPtrA,
        struct bbs_MemSeg* mspA );




void bbs_Int32Arr_fill( struct bbs_Context* cpA,
         struct bbs_Int32Arr* ptrA,
      int32 valA );
# 25 "external/neven/Embedded/common/src/b_BitFeatureEm/Sequence.h" 2
# 1 "external/neven/Embedded/common/src/b_BasicEm/UInt16Arr.h" 1
# 34 "external/neven/Embedded/common/src/b_BasicEm/UInt16Arr.h"
struct bbs_UInt16Arr
{




 struct bbs_MemSeg* mspE;




 uint16* arrPtrE;


 uint32 sizeE;


 uint32 allocatedSizeE;

};
# 62 "external/neven/Embedded/common/src/b_BasicEm/UInt16Arr.h"
void bbs_UInt16Arr_init( struct bbs_Context* cpA,
       struct bbs_UInt16Arr* ptrA );


void bbs_UInt16Arr_exit( struct bbs_Context* cpA,
       struct bbs_UInt16Arr* ptrA );




void bbs_UInt16Arr_copy( struct bbs_Context* cpA,
       struct bbs_UInt16Arr* ptrA,
       const struct bbs_UInt16Arr* srcPtrA );


flag bbs_UInt16Arr_equal( struct bbs_Context* cpA,
        const struct bbs_UInt16Arr* ptrA,
        const struct bbs_UInt16Arr* srcPtrA );




uint32 bbs_UInt16Arr_checkSum( struct bbs_Context* cpA,
          const struct bbs_UInt16Arr* ptrA,
          uint32 startIndexA, uint32 sizeA );


uint32 bbs_UInt16Arr_heapSize( struct bbs_Context* cpA,
          const struct bbs_UInt16Arr* ptrA,
          uint32 sizeA );




void bbs_UInt16Arr_create( struct bbs_Context* cpA,
         struct bbs_UInt16Arr* ptrA,
         uint32 sizeA,
         struct bbs_MemSeg* mspA );


void bbs_UInt16Arr_size( struct bbs_Context* cpA,
       struct bbs_UInt16Arr* ptrA, uint32 sizeA );




uint32 bbs_UInt16Arr_memSize( struct bbs_Context* cpA,
         const struct bbs_UInt16Arr* ptrA );


uint32 bbs_UInt16Arr_memWrite( struct bbs_Context* cpA,
          const struct bbs_UInt16Arr* ptrA, uint16* memPtrA );


uint32 bbs_UInt16Arr_memRead( struct bbs_Context* cpA,
         struct bbs_UInt16Arr* ptrA,
         const uint16* memPtrA,
         struct bbs_MemSeg* mspA );




void bbs_UInt16Arr_fill( struct bbs_Context* cpA,
       struct bbs_UInt16Arr* ptrA,
       uint16 valA );
# 26 "external/neven/Embedded/common/src/b_BitFeatureEm/Sequence.h" 2

# 1 "external/neven/Embedded/common/src/b_BitFeatureEm/Feature.h" 1
# 25 "external/neven/Embedded/common/src/b_BitFeatureEm/Feature.h"
# 1 "external/neven/Embedded/common/src/b_BitFeatureEm/Functions.h" 1
# 28 "external/neven/Embedded/common/src/b_BitFeatureEm/Functions.h"
# 1 "external/neven/Embedded/common/src/b_ImageEm/UInt32Image.h" 1
# 37 "external/neven/Embedded/common/src/b_ImageEm/UInt32Image.h"
struct bim_UInt32Image
{






 uint32 widthE;


 uint32 heightE;


 struct bbs_UInt32Arr arrE;
};
# 61 "external/neven/Embedded/common/src/b_ImageEm/UInt32Image.h"
void bim_UInt32Image_init( struct bbs_Context* cpA,
         struct bim_UInt32Image* ptrA );


void bim_UInt32Image_exit( struct bbs_Context* cpA,
         struct bim_UInt32Image* ptrA );




void bim_UInt32Image_copy( struct bbs_Context* cpA,
         struct bim_UInt32Image* ptrA,
         const struct bim_UInt32Image* srcPtrA );


flag bim_UInt32Image_equal( struct bbs_Context* cpA,
          const struct bim_UInt32Image* ptrA,
       const struct bim_UInt32Image* srcPtrA );




uint32 bim_UInt32Image_heapSize( struct bbs_Context* cpA,
         const struct bim_UInt32Image* ptrA,
         uint32 widthA,
         uint32 heightA );


uint32 bim_UInt32Image_checkSum( struct bbs_Context* cpA,
         const struct bim_UInt32Image* ptrA );




void bim_UInt32Image_create( struct bbs_Context* cpA,
        struct bim_UInt32Image* ptrA,
          uint32 widthA,
       uint32 heightA,
              struct bbs_MemSeg* mspA );


void bim_UInt32Image_assignExternalImage( struct bbs_Context* cpA,
            struct bim_UInt32Image* ptrA,
            struct bim_UInt32Image* srcPtrA );


void bim_UInt32Image_size( struct bbs_Context* cpA,
         struct bim_UInt32Image* ptrA,
         uint32 widthA,
         uint32 heightA );




uint32 bim_UInt32Image_memSize( struct bbs_Context* cpA,
           const struct bim_UInt32Image* ptrA );


uint32 bim_UInt32Image_memWrite( struct bbs_Context* cpA,
         const struct bim_UInt32Image* ptrA,
         uint16* memPtrA );


uint32 bim_UInt32Image_memRead( struct bbs_Context* cpA,
           struct bim_UInt32Image* ptrA,
           const uint16* memPtrA,
                  struct bbs_MemSeg* mspA );




void bim_UInt32Image_setAllPixels( struct bbs_Context* cpA,
           struct bim_UInt32Image* ptrA,
           uint32 valueA,
           int32 bbpA );
# 29 "external/neven/Embedded/common/src/b_BitFeatureEm/Functions.h" 2
# 1 "external/neven/Embedded/common/src/b_ImageEm/UInt16ByteImage.h" 1
# 26 "external/neven/Embedded/common/src/b_ImageEm/UInt16ByteImage.h"
# 1 "external/neven/Embedded/common/src/b_ImageEm/UInt8Image.h" 1
# 39 "external/neven/Embedded/common/src/b_ImageEm/UInt8Image.h"
struct bim_UInt8Image
{






 uint32 widthE;


 uint32 heightE;


 struct bbs_UInt8Arr arrE;
};
# 63 "external/neven/Embedded/common/src/b_ImageEm/UInt8Image.h"
void bim_UInt8Image_init( struct bbs_Context* cpA,
        struct bim_UInt8Image* ptrA );


void bim_UInt8Image_create( struct bbs_Context* cpA,
          struct bim_UInt8Image* ptrA,
          uint32 widthA,
       uint32 heightA,
              struct bbs_MemSeg* mspA );


void bim_UInt8Image_exit( struct bbs_Context* cpA,
        struct bim_UInt8Image* ptrA );




void bim_UInt8Image_copy( struct bbs_Context* cpA,
        struct bim_UInt8Image* ptrA,
        const struct bim_UInt8Image* srcPtrA );


flag bim_UInt8Image_equal( struct bbs_Context* cpA,
         const struct bim_UInt8Image* ptrA,
         const struct bim_UInt8Image* srcPtrA );




uint32 bim_UInt8Image_checkSum( struct bbs_Context* cpA,
           const struct bim_UInt8Image* ptrA );




void bim_UInt8Image_assignExternalImage( struct bbs_Context* cpA,
           struct bim_UInt8Image* ptrA,
           struct bim_UInt8Image* srcPtrA );


void bim_UInt8Image_size( struct bbs_Context* cpA,
        struct bim_UInt8Image* ptrA,
        uint32 widthA,
        uint32 heightA );




uint32 bim_UInt8Image_memSize( struct bbs_Context* cpA,
          const struct bim_UInt8Image* ptrA );


uint32 bim_UInt8Image_memWrite( struct bbs_Context* cpA,
           const struct bim_UInt8Image* ptrA,
        uint16* memPtrA );


uint32 bim_UInt8Image_memRead( struct bbs_Context* cpA,
          struct bim_UInt8Image* ptrA,
          const uint16* memPtrA,
                 struct bbs_MemSeg* mspA );




void bim_UInt8Image_setAllPixels( struct bbs_Context* cpA,
          struct bim_UInt8Image* ptrA,
          uint8 valueA );


void bim_UInt8Image_copySection( struct bbs_Context* cpA,
         struct bim_UInt8Image* ptrA,
         const struct bim_UInt8Image* srcPtrA,
         const struct bts_Int16Rect* sectionPtrA );




void bim_UInt8Image_warpOffs( struct bbs_Context* cpA,
        struct bim_UInt8Image* ptrA,
        const struct bim_UInt8Image* srcPtrA,
        int32 xOffsA,
        int32 yOffsA,
        const struct bts_Flt16Alt2D* altPtrA,
                 int32 resultWidthA,
                 int32 resultHeightA );


void bim_UInt8Image_warp( struct bbs_Context* cpA,
        struct bim_UInt8Image* ptrA,
        const struct bim_UInt8Image* srcPtrA,
        const struct bts_Flt16Alt2D* altPtrA,
                 int32 resultWidthA,
                 int32 resultHeightA );
# 27 "external/neven/Embedded/common/src/b_ImageEm/UInt16ByteImage.h" 2
# 48 "external/neven/Embedded/common/src/b_ImageEm/UInt16ByteImage.h"
struct bim_UInt16ByteImage
{






 uint32 widthE;


 uint32 heightE;


 struct bbs_UInt16Arr arrE;
};
# 72 "external/neven/Embedded/common/src/b_ImageEm/UInt16ByteImage.h"
void bim_UInt16ByteImage_init( struct bbs_Context* cpA,
          struct bim_UInt16ByteImage* ptrA );


void bim_UInt16ByteImage_create( struct bbs_Context* cpA,
         struct bim_UInt16ByteImage* ptrA,
          uint32 widthA,
       uint32 heightA,
              struct bbs_MemSeg* mspA );


void bim_UInt16ByteImage_exit( struct bbs_Context* cpA,
          struct bim_UInt16ByteImage* ptrA );




void bim_UInt16ByteImage_copy( struct bbs_Context* cpA,
          struct bim_UInt16ByteImage* ptrA,
          const struct bim_UInt16ByteImage* srcPtrA );


flag bim_UInt16ByteImage_equal( struct bbs_Context* cpA,
           const struct bim_UInt16ByteImage* ptrA,
        const struct bim_UInt16ByteImage* srcPtrA );




uint32 bim_UInt16ByteImage_checkSum( struct bbs_Context* cpA,
          const struct bim_UInt16ByteImage* ptrA );




void bim_UInt16ByteImage_assignExternalImage( struct bbs_Context* cpA,
             struct bim_UInt16ByteImage* ptrA,
             struct bim_UInt16ByteImage* srcPtrA );


void bim_UInt16ByteImage_size( struct bbs_Context* cpA,
          struct bim_UInt16ByteImage* ptrA,
          uint32 widthA, uint32 heightA );




uint32 bim_UInt16ByteImage_memSize( struct bbs_Context* cpA,
            const struct bim_UInt16ByteImage* ptrA );


uint32 bim_UInt16ByteImage_memWrite( struct bbs_Context* cpA,
          const struct bim_UInt16ByteImage* ptrA,
          uint16* memPtrA );


uint32 bim_UInt16ByteImage_memRead( struct bbs_Context* cpA,
            struct bim_UInt16ByteImage* ptrA,
          const uint16* memPtrA,
                 struct bbs_MemSeg* mspA );




void bim_UInt16ByteImage_setAllPixels( struct bbs_Context* cpA,
            struct bim_UInt16ByteImage* ptrA,
            uint16 valueA );


void bim_UInt16ByteImage_warp( struct bbs_Context* cpA,
          struct bim_UInt16ByteImage* ptrA,
          const struct bim_UInt16ByteImage* srcPtrA,
             const struct bts_Flt16Alt2D* altPtrA,
                      int32 resultWidthA,
                      int32 resultHeightA );
# 156 "external/neven/Embedded/common/src/b_ImageEm/UInt16ByteImage.h"
void bim_UInt16ByteImage_warp8( struct bbs_Context* cpA,
           struct bim_UInt16ByteImage* ptrA,
           const struct bim_UInt16ByteImage* srcPtrA,
           const struct bts_Flt16Alt2D* altPtrA,
           int32 resultWidthA,
           int32 resultHeightA );
# 30 "external/neven/Embedded/common/src/b_BitFeatureEm/Functions.h" 2
# 38 "external/neven/Embedded/common/src/b_BitFeatureEm/Functions.h"
extern const uint16 bbf_bit8TblG[ 256 ];
# 26 "external/neven/Embedded/common/src/b_BitFeatureEm/Feature.h" 2





enum bbf_FeatureType
{
 bbf_FT_UNDEFINED = 0,
 bbf_FT_SEQUENCE,
 bbf_FT_I04_DNS_2X2_FTR,
 bbf_FT_I04_TLD_2X4_FTR,
 bbf_FT_I04_DNS_2X4_FTR,
 bbf_FT_L01_TLD_2X4_FTR,
 bbf_FT_L01_DNS_2X4_FTR,
 bbf_FT_L04_DNS_2X4_FTR,
 bbf_FT_L04_DNS_3X3_FTR,
 bbf_FT_L06_DNS_3X3_FTR,
 bbf_FT_L06_DNS_4X4_FTR,
 bbf_FT_L06_DNS_NX4X4_FTR,

 bbf_FT_L01_TLD_1X1_FTR,
 bbf_FT_L04_TLD_2X4_FTR,
 bbf_FT_L04_DNS_2X2_FTR
};






struct bbf_Feature
{





 uint32 typeE;


 uint32 patchWidthE;


 uint32 patchHeightE;




 int32 ( *vpActivityE )( const struct bbf_Feature* ptrA, const uint32* patchA );
};
# 84 "external/neven/Embedded/common/src/b_BitFeatureEm/Feature.h"
void bbf_Feature_init( struct bbs_Context* cpA,
        struct bbf_Feature* ptrA );


void bbf_Feature_exit( struct bbs_Context* cpA,
        struct bbf_Feature* ptrA );




void bbf_Feature_copy( struct bbs_Context* cpA,
        struct bbf_Feature* ptrA,
        const struct bbf_Feature* srcPtrA );


flag bbf_Feature_equal( struct bbs_Context* cpA,
      const struct bbf_Feature* ptrA,
      const struct bbf_Feature* srcPtrA );
# 110 "external/neven/Embedded/common/src/b_BitFeatureEm/Feature.h"
uint32 bbf_Feature_memSize( struct bbs_Context* cpA,
          const struct bbf_Feature* ptrA );


uint32 bbf_Feature_memWrite( struct bbs_Context* cpA,
        const struct bbf_Feature* ptrA, uint16* memPtrA );


uint32 bbf_Feature_memRead( struct bbs_Context* cpA,
       struct bbf_Feature* ptrA, const uint16* memPtrA );




void bbf_featureInit( struct bbs_Context* cpA,
       struct bbf_Feature* ptrA,
       enum bbf_FeatureType typeA );


void bbf_featureExit( struct bbs_Context* cpA,
       struct bbf_Feature* ptrA );


uint32 bbf_featureMemSize( struct bbs_Context* cpA,
         const struct bbf_Feature* ptrA );


uint32 bbf_featureMemWrite( struct bbs_Context* cpA,
          const struct bbf_Feature* ptrA, uint16* memPtrA );


uint32 bbf_featureMemRead( struct bbs_Context* cpA,
         struct bbf_Feature* ptrA,
         const uint16* memPtrA,
         struct bbs_MemTbl* mtpA );


uint32 bbf_featureSizeOf16( struct bbs_Context* cpA, enum bbf_FeatureType typeA );
# 28 "external/neven/Embedded/common/src/b_BitFeatureEm/Sequence.h" 2
# 44 "external/neven/Embedded/common/src/b_BitFeatureEm/Sequence.h"
struct bbf_Sequence
{



 struct bbf_Feature baseE;




 struct bbf_Feature* ftrPtrArrE[ 16 ];




 uint32 sizeE;


 struct bbs_Int32Arr thrArrE;


 struct bbs_UInt16Arr wgtArrE;


 struct bbs_UInt16Arr dataArrE;
};
# 78 "external/neven/Embedded/common/src/b_BitFeatureEm/Sequence.h"
void bbf_Sequence_init( struct bbs_Context* cpA,
        struct bbf_Sequence* ptrA );


void bbf_Sequence_exit( struct bbs_Context* cpA,
        struct bbf_Sequence* ptrA );




void bbf_Sequence_copy( struct bbs_Context* cpA,
         struct bbf_Sequence* ptrA,
        const struct bbf_Sequence* srcPtrA );


flag bbf_Sequence_equal( struct bbs_Context* cpA,
      const struct bbf_Sequence* ptrA,
      const struct bbf_Sequence* srcPtrA );
# 104 "external/neven/Embedded/common/src/b_BitFeatureEm/Sequence.h"
uint32 bbf_Sequence_memSize( struct bbs_Context* cpA,
          const struct bbf_Sequence* ptrA );


uint32 bbf_Sequence_memWrite( struct bbs_Context* cpA,
        const struct bbf_Sequence* ptrA, uint16* memPtrA );


uint32 bbf_Sequence_memRead( struct bbs_Context* cpA,
       struct bbf_Sequence* ptrA,
       const uint16* memPtrA,
       struct bbs_MemTbl* mtpA );




int32 bbf_Sequence_activity( const struct bbf_Feature* ptrA, const uint32* patchA );
# 29 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h" 2
# 1 "external/neven/Embedded/common/src/b_BitFeatureEm/BitParam.h" 1
# 34 "external/neven/Embedded/common/src/b_BitFeatureEm/BitParam.h"
struct bbf_BitParam
{





 uint32 outerRadiusE;


 uint32 innerRadiusE;

};
# 55 "external/neven/Embedded/common/src/b_BitFeatureEm/BitParam.h"
void bbf_BitParam_init( struct bbs_Context* cpA,
         struct bbf_BitParam* ptrA );


void bbf_BitParam_exit( struct bbs_Context* cpA,
         struct bbf_BitParam* ptrA );




void bbf_BitParam_copy( struct bbs_Context* cpA,
         struct bbf_BitParam* ptrA,
         const struct bbf_BitParam* srcPtrA );


flag bbf_BitParam_equal( struct bbs_Context* cpA,
          const struct bbf_BitParam* ptrA,
          const struct bbf_BitParam* srcPtrA );
# 81 "external/neven/Embedded/common/src/b_BitFeatureEm/BitParam.h"
uint32 bbf_BitParam_memSize( struct bbs_Context* cpA,
           const struct bbf_BitParam* ptrA );


uint32 bbf_BitParam_memWrite( struct bbs_Context* cpA,
            const struct bbf_BitParam* ptrA, uint16* memPtrA );


uint32 bbf_BitParam_memRead( struct bbs_Context* cpA,
           struct bbf_BitParam* ptrA,
           const uint16* memPtrA );
# 30 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h" 2
# 1 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanner.h" 1
# 47 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanner.h"
struct bbf_LocalScanner
{



 int32 xE;


 int32 yE;


 int32 xOffE;


 int32 yOffE;


 uint32 currentWidthE;


 uint32 currentHeightE;


 uint32 workWidthE;


 uint32 workHeightE;


 const uint8* workImagePtrE;


 uint32 origWidthE;


 uint32 origHeightE;


 const uint8* origImagePtrE;


 struct bbf_BitParam bitParamE;


 struct bbs_UInt8Arr workImageBufferE;


 struct bim_UInt32Image satE;


 struct bim_UInt32Image bitImageE;


 struct bbs_UInt32Arr patchBufferE;


 struct bts_Int16Rect origScanRegionE;


 struct bts_Int16Rect workScanRegionE;




 uint32 patchWidthE;


 uint32 patchHeightE;


 uint32 scaleExpE;


 uint32 maxImageWidthE;


 uint32 maxImageHeightE;


 uint32 minScaleExpE;


 uint32 maxRadiusE;

};
# 140 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanner.h"
void bbf_LocalScanner_init( struct bbs_Context* cpA,
       struct bbf_LocalScanner* ptrA );


void bbf_LocalScanner_exit( struct bbs_Context* cpA,
       struct bbf_LocalScanner* ptrA );




void bbf_LocalScanner_copy( struct bbs_Context* cpA,
       struct bbf_LocalScanner* ptrA,
       const struct bbf_LocalScanner* srcPtrA );


flag bbf_LocalScanner_equal( struct bbs_Context* cpA,
        const struct bbf_LocalScanner* ptrA,
        const struct bbf_LocalScanner* srcPtrA );




uint32 bbf_LocalScanner_positions( const struct bbf_LocalScanner* ptrA );


uint32 bbf_LocalScanner_scanIndex( const struct bbf_LocalScanner* ptrA );


void bbf_LocalScanner_pos( const struct bbf_LocalScanner* ptrA, int32* xPtrA, int32* yPtrA );


void bbf_LocalScanner_idxPos( const struct bbf_LocalScanner* ptrA, uint32 scanIndexA, int32* xPtrA, int32* yPtrA );




void bbf_LocalScanner_create( struct bbs_Context* cpA,
         struct bbf_LocalScanner* ptrA,
         uint32 patchWidthA,
         uint32 patchHeightA,
         uint32 scaleExpA,
         uint32 maxImageWidthA,
         uint32 maxImageHeightA,
         uint32 minScaleExpA,
         uint32 maxRadiusA,
         struct bbs_MemTbl* mtpA );


void bbf_LocalScanner_bitParam( struct bbs_Context* cpA,
           struct bbf_LocalScanner* ptrA,
        const struct bbf_BitParam* bitParamPtrA );







void bbf_LocalScanner_origScanRegion( struct bbs_Context* cpA,
           struct bbf_LocalScanner* ptrA,
           const struct bts_Int16Rect* scanRegionPtrA );




uint32 bbf_LocalScanner_memSize( struct bbs_Context* cpA,
               const struct bbf_LocalScanner* ptrA );


uint32 bbf_LocalScanner_memWrite( struct bbs_Context* cpA,
          const struct bbf_LocalScanner* ptrA, uint16* memPtrA );


uint32 bbf_LocalScanner_memRead( struct bbs_Context* cpA,
         struct bbf_LocalScanner* ptrA,
         const uint16* memPtrA,
         struct bbs_MemTbl* mtpA );




void bbf_LocalScanner_resetScan( struct bbs_Context* cpA,
         struct bbf_LocalScanner* ptrA );


void bbf_LocalScanner_assign( struct bbs_Context* cpA,
         struct bbf_LocalScanner* ptrA,
         const uint8* imagePtrA,
         uint32 imageWidthA,
         uint32 imageHeightA,
         const struct bbf_BitParam* paramPtrA );


const uint32* bbf_LocalScanner_getPatch( const struct bbf_LocalScanner* ptrA );


flag bbf_LocalScanner_next( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA );


void bbf_LocalScanner_goToXY( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA, int32 xA, int32 yA );


void bbf_LocalScanner_goToIndex( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA, uint32 scanIndexA );


flag bbf_LocalScanner_nextOffset( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA );
# 31 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h" 2
# 1 "external/neven/Embedded/common/src/b_TensorEm/RBFMap2D.h" 1
# 30 "external/neven/Embedded/common/src/b_TensorEm/RBFMap2D.h"
# 1 "external/neven/Embedded/common/src/b_TensorEm/Int32Mat.h" 1
# 36 "external/neven/Embedded/common/src/b_TensorEm/Int32Mat.h"
struct bts_Int32Mat
{






 uint32 widthE;


 struct bbs_Int32Arr arrE;

};
# 58 "external/neven/Embedded/common/src/b_TensorEm/Int32Mat.h"
void bts_Int32Mat_init( struct bbs_Context* cpA,
         struct bts_Int32Mat* ptrA );


void bts_Int32Mat_exit( struct bbs_Context* cpA,
         struct bts_Int32Mat* ptrA );




void bts_Int32Mat_copy( struct bbs_Context* cpA,
         struct bts_Int32Mat* ptrA,
      const struct bts_Int32Mat* srcPtrA );






void bts_Int32Mat_create( struct bbs_Context* cpA,
        struct bts_Int32Mat* ptrA,
        int32 widthA,
              struct bbs_MemSeg* mspA );




uint32 bts_Int32Mat_memSize( struct bbs_Context* cpA,
        const struct bts_Int32Mat* ptrA );


uint32 bts_Int32Mat_memWrite( struct bbs_Context* cpA,
         const struct bts_Int32Mat* ptrA,
         uint16* memPtrA );


uint32 bts_Int32Mat_memRead( struct bbs_Context* cpA,
        struct bts_Int32Mat* ptrA,
        const uint16* memPtrA,
                 struct bbs_MemSeg* mspA );
# 114 "external/neven/Embedded/common/src/b_TensorEm/Int32Mat.h"
flag bts_Int32Mat_solve( struct bbs_Context* cpA,
       const int32* matA,
       int32 matWidthA,
       const int32* inVecA,
       int32* outVecA,
       int32 bbpA,
       int32* tmpMatA,
       int32* tmpVecA );






flag bts_Int32Mat_solve2( struct bbs_Context* cpA,
        int32* matA,
        int32 matWidthA,
        const int32* inVecA,
        int32* outVecA,
        int32 bbpA,
        int32* tmpVecA );
# 31 "external/neven/Embedded/common/src/b_TensorEm/RBFMap2D.h" 2
# 54 "external/neven/Embedded/common/src/b_TensorEm/RBFMap2D.h"
struct bts_RBFMap2D
{
# 65 "external/neven/Embedded/common/src/b_TensorEm/RBFMap2D.h"
 int32 RBFTypeE;


 struct bts_Cluster2D srcClusterE;


 struct bts_Cluster2D rbfCoeffClusterE;


 int32 altTypeE;


 struct bts_Flt16Alt2D altE;


 flag altOnlyE;




 struct bts_Int32Mat matE;
 struct bts_Int32Mat tempMatE;


 struct bbs_Int32Arr inVecE;
 struct bbs_Int32Arr outVecE;
 struct bbs_Int32Arr tempVecE;
};
# 101 "external/neven/Embedded/common/src/b_TensorEm/RBFMap2D.h"
void bts_RBFMap2D_init( struct bbs_Context* cpA,
         struct bts_RBFMap2D* ptrA );


void bts_RBFMap2D_exit( struct bbs_Context* cpA,
         struct bts_RBFMap2D* ptrA );




void bts_RBFMap2D_copy( struct bbs_Context* cpA,
         struct bts_RBFMap2D* ptrA,
      const struct bts_RBFMap2D* srcPtrA );


flag bts_RBFMap2D_equal( struct bbs_Context* cpA,
       const struct bts_RBFMap2D* ptrA,
       const struct bts_RBFMap2D* srcPtrA );






void bts_RBFMap2D_create( struct bbs_Context* cpA,
        struct bts_RBFMap2D* ptrA,
        uint32 sizeA,
              struct bbs_MemSeg* mspA );


void bts_RBFMap2D_compute( struct bbs_Context* cpA,
         struct bts_RBFMap2D* ptrA,
         const struct bts_Cluster2D* srcPtrA,
         const struct bts_Cluster2D* dstPtrA );




uint32 bts_RBFMap2D_memSize( struct bbs_Context* cpA,
        const struct bts_RBFMap2D* ptrA );


uint32 bts_RBFMap2D_memWrite( struct bbs_Context* cpA,
         const struct bts_RBFMap2D* ptrA,
         uint16* memPtrA );


uint32 bts_RBFMap2D_memRead( struct bbs_Context* cpA,
        struct bts_RBFMap2D* ptrA,
        const uint16* memPtrA,
                 struct bbs_MemSeg* mspA );




struct bts_Flt16Vec2D bts_RBFMap2D_mapVector( struct bbs_Context* cpA,
             const struct bts_RBFMap2D* ptrA,
             struct bts_Flt16Vec2D vecA );


void bts_RBFMap2D_mapCluster( struct bbs_Context* cpA,
         const struct bts_RBFMap2D* ptrA,
         const struct bts_Cluster2D* srcPtrA,
         struct bts_Cluster2D* dstPtrA,
         int32 dstBbpA );
# 32 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h" 2
# 54 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h"
struct bbf_LocalScanDetector
{



 struct bbf_Feature* ftrPtrArrE[ 16 ];


 struct bts_RBFMap2D rbfMapE;


 struct bts_Cluster2D tmpCluster1E;


 struct bts_Cluster2D tmpCluster2E;


 struct bts_Cluster2D tmpCluster3E;


 struct bts_Cluster2D tmpCluster4E;


 struct bbf_LocalScanner scannerE;


 struct bbs_Int32Arr actArrE;


 struct bbs_Int16Arr idxArrE;


 struct bbs_UInt8Arr workImageBufE;




 uint32 patchWidthE;


 uint32 patchHeightE;


 uint32 scanWidthE;


 uint32 scanHeightE;


 uint32 scaleExpE;


 flag interpolatedWarpingE;


 uint32 warpScaleThresholdE;


 struct bts_IdCluster2D refClusterE;


 struct bts_Cluster2D scanClusterE;


 struct bbs_UInt16Arr ftrDataArrE;


 struct bbf_BitParam bitParamE;


 uint32 outlierDistanceE;


 struct bts_IdCluster2D pcaClusterE;


 struct bbs_Int16Arr pcaAvgE;


 struct bbs_Int16Arr pcaMatE;


 uint32 pcaDimSubSpaceE;


 uint32 maxImageWidthE;


 uint32 maxImageHeightE;

};
# 153 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h"
void bbf_LocalScanDetector_init( struct bbs_Context* cpA,
         struct bbf_LocalScanDetector* ptrA );


void bbf_LocalScanDetector_exit( struct bbs_Context* cpA,
         struct bbf_LocalScanDetector* ptrA );




void bbf_LocalScanDetector_copy( struct bbs_Context* cpA,
         struct bbf_LocalScanDetector* ptrA,
         const struct bbf_LocalScanDetector* srcPtrA );


flag bbf_LocalScanDetector_equal( struct bbs_Context* cpA,
          const struct bbf_LocalScanDetector* ptrA,
          const struct bbf_LocalScanDetector* srcPtrA );
# 179 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.h"
uint32 bbf_LocalScanDetector_memSize( struct bbs_Context* cpA,
           const struct bbf_LocalScanDetector* ptrA );


uint32 bbf_LocalScanDetector_memWrite( struct bbs_Context* cpA,
            const struct bbf_LocalScanDetector* ptrA, uint16* memPtrA );


uint32 bbf_LocalScanDetector_memRead( struct bbs_Context* cpA,
           struct bbf_LocalScanDetector* ptrA,
           const uint16* memPtrA,
           struct bbs_MemTbl* mtpA );






int32 bbf_LocalScanDetector_process( struct bbs_Context* cpA,
          const struct bbf_LocalScanDetector* ptrA,
                                     uint8* imagePtrA,
          uint32 imageWidthA,
          uint32 imageHeightA,
          const struct bts_Int16Vec2D* offsPtrA,
          const struct bts_IdCluster2D* inClusterPtrA,
          struct bts_IdCluster2D* outClusterPtrA );
# 23 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c" 2
# 37 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
void bbf_LocalScanDetector_pcaMap( struct bbs_Context* cpA,
           const struct bbf_LocalScanDetector* ptrA,
           const struct bts_IdCluster2D* inClusterPtrA,
           struct bts_IdCluster2D* outClusterPtrA )
{
 const char* fNameL = "bbf_LocalScanDetector_pcaMap";

 struct bts_Cluster2D* tmpCl1PtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster1E;
 struct bts_Cluster2D* tmpCl2PtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster2E;
 struct bts_RBFMap2D* rbfPtrL = ( struct bts_RBFMap2D* )&ptrA->rbfMapE;
 struct bts_Flt16Alt2D altL;
 uint32 outBbpL = inClusterPtrA->clusterE.bbpE;
 uint32 iL, jL;


 bts_IdCluster2D_convertToEqivalentClusters( cpA,
            inClusterPtrA,
            &ptrA->pcaClusterE,
            tmpCl1PtrL,
            tmpCl2PtrL );

 altL = bts_Cluster2D_alt( cpA, tmpCl1PtrL, tmpCl2PtrL, bts_ALT_RIGID );
 bts_Cluster2D_transform( cpA, tmpCl1PtrL, altL );
 bts_RBFMap2D_compute( cpA, rbfPtrL, tmpCl2PtrL, tmpCl1PtrL );
 bts_RBFMap2D_mapCluster( cpA, rbfPtrL, &ptrA->pcaClusterE.clusterE, tmpCl1PtrL, 6 );


 {

  const int16* matPtrL = ptrA->pcaMatE.arrPtrE;


  const int16* avgPtrL = ptrA->pcaAvgE.arrPtrE;

  struct bts_Int16Vec2D* vecArrL = tmpCl1PtrL->vecArrE;


  int32 prjVecL[ 12 ];


  uint16 matWidthL = tmpCl1PtrL->sizeE * 2;

  if( ptrA->pcaDimSubSpaceE > 12 )
  {
   bbs_Context_pushError( cpA, bbs_Error_create( 1, 81, "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c", "%s:\nbpi_RF_LANDMARKER_MAX_PCA_DIM exceeded", fNameL ) );
   return;
  }


  for( iL = 0; iL < ptrA->pcaDimSubSpaceE; iL++ )
  {
   int32 sumL = 0;
   avgPtrL = ptrA->pcaAvgE.arrPtrE;
   for( jL = 0; jL < tmpCl1PtrL->sizeE; jL++ )
   {
    sumL += matPtrL[ 0 ] * ( vecArrL[ jL ].xE - avgPtrL[ 0 ] );
    sumL += matPtrL[ 1 ] * ( vecArrL[ jL ].yE - avgPtrL[ 1 ] );
    avgPtrL += 2;
    matPtrL += 2;
   }
   prjVecL[ iL ] = ( sumL + 128 ) >> 8;
  }

  matPtrL = ptrA->pcaMatE.arrPtrE;
  avgPtrL = ptrA->pcaAvgE.arrPtrE;
  vecArrL = tmpCl1PtrL->vecArrE;


  for( jL = 0; jL < tmpCl1PtrL->sizeE; jL++ )
  {
   int32 sumL = 0;
   for( iL = 0; iL < ptrA->pcaDimSubSpaceE; iL++ )
   {
    sumL += matPtrL[ iL * matWidthL + 0 ] * prjVecL[ iL ];
   }

   vecArrL[ jL ].xE = ( ( sumL + 128 ) >> 8 ) + avgPtrL[ 0 ];

   sumL = 0;
   for( iL = 0; iL < ptrA->pcaDimSubSpaceE; iL++ )
   {
    sumL += matPtrL[ iL * matWidthL + 1 ] * prjVecL[ iL ];
   }

   vecArrL[ jL ].yE = ( ( sumL + 128 ) >> 8 ) + avgPtrL[ 1 ];

   matPtrL += 2;
   avgPtrL += 2;
  }
 }


 bts_IdCluster2D_copy( cpA, outClusterPtrA, &ptrA->pcaClusterE );
 bts_Cluster2D_copyTransform( cpA, &outClusterPtrA->clusterE, tmpCl1PtrL, bts_Flt16Alt2D_inverted( &altL ), outBbpL );
}
# 143 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
void bbf_LocalScanDetector_init( struct bbs_Context* cpA,
            struct bbf_LocalScanDetector* ptrA )
{
 bbs_memset16( ptrA->ftrPtrArrE, 0, ( sizeof( ptrA->ftrPtrArrE ) >> 1 ) );
 bts_RBFMap2D_init( cpA, &ptrA->rbfMapE );
 bts_Cluster2D_init( cpA, &ptrA->tmpCluster1E );
 bts_Cluster2D_init( cpA, &ptrA->tmpCluster2E );
 bts_Cluster2D_init( cpA, &ptrA->tmpCluster3E );
 bts_Cluster2D_init( cpA, &ptrA->tmpCluster4E );
 bbf_LocalScanner_init( cpA, &ptrA->scannerE );
 bbs_Int32Arr_init( cpA, &ptrA->actArrE );
 bbs_Int16Arr_init( cpA, &ptrA->idxArrE );
 bbs_UInt8Arr_init( cpA, &ptrA->workImageBufE );
 ptrA->maxImageWidthE = 0;
 ptrA->maxImageHeightE = 0;

 ptrA->patchWidthE = 0;
 ptrA->patchHeightE = 0;
 ptrA->scanWidthE = 0;
 ptrA->scanHeightE = 0;
 ptrA->scaleExpE = 0;
 ptrA->interpolatedWarpingE = 1;
 ptrA->warpScaleThresholdE = 0;
 bts_IdCluster2D_init( cpA, &ptrA->refClusterE );
 bts_Cluster2D_init( cpA, &ptrA->scanClusterE );
 bbs_UInt16Arr_init( cpA, &ptrA->ftrDataArrE );
 bbf_BitParam_init( cpA, &ptrA->bitParamE );
 ptrA->outlierDistanceE = 0;
 bts_IdCluster2D_init( cpA, &ptrA->pcaClusterE );
 bbs_Int16Arr_init( cpA, &ptrA->pcaAvgE );
 bbs_Int16Arr_init( cpA, &ptrA->pcaMatE );
 ptrA->pcaDimSubSpaceE = 0;
 ptrA->maxImageWidthE = 0;
 ptrA->maxImageHeightE = 0;
}



void bbf_LocalScanDetector_exit( struct bbs_Context* cpA,
            struct bbf_LocalScanDetector* ptrA )
{
 uint16 iL;
 for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) bbf_featureExit( cpA, ptrA->ftrPtrArrE[ iL ] );
 bbs_memset16( ptrA->ftrPtrArrE, 0, ( sizeof( ptrA->ftrPtrArrE ) >> 1 ) );

 bts_RBFMap2D_exit( cpA, &ptrA->rbfMapE );
 bts_Cluster2D_exit( cpA, &ptrA->tmpCluster1E );
 bts_Cluster2D_exit( cpA, &ptrA->tmpCluster2E );
 bts_Cluster2D_exit( cpA, &ptrA->tmpCluster3E );
 bts_Cluster2D_exit( cpA, &ptrA->tmpCluster4E );
 bbf_LocalScanner_exit( cpA, &ptrA->scannerE );
 bbs_Int32Arr_exit( cpA, &ptrA->actArrE );
 bbs_Int16Arr_exit( cpA, &ptrA->idxArrE );
 bbs_UInt8Arr_exit( cpA, &ptrA->workImageBufE );
 ptrA->maxImageWidthE = 0;
 ptrA->maxImageHeightE = 0;

 ptrA->patchWidthE = 0;
 ptrA->patchHeightE = 0;
 ptrA->scanWidthE = 0;
 ptrA->scanHeightE = 0;
 ptrA->scaleExpE = 0;
 ptrA->interpolatedWarpingE = 1;
 ptrA->warpScaleThresholdE = 0;
 bts_IdCluster2D_exit( cpA, &ptrA->refClusterE );
 bts_Cluster2D_exit( cpA, &ptrA->scanClusterE );
 bbs_UInt16Arr_exit( cpA, &ptrA->ftrDataArrE );
 bbf_BitParam_exit( cpA, &ptrA->bitParamE );
 ptrA->outlierDistanceE = 0;
 bts_IdCluster2D_exit( cpA, &ptrA->pcaClusterE );
 bbs_Int16Arr_exit( cpA, &ptrA->pcaAvgE );
 bbs_Int16Arr_exit( cpA, &ptrA->pcaMatE );
 ptrA->pcaDimSubSpaceE = 0;
 ptrA->maxImageWidthE = 0;
 ptrA->maxImageHeightE = 0;
}
# 230 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
void bbf_LocalScanDetector_copy( struct bbs_Context* cpA,
          struct bbf_LocalScanDetector* ptrA,
          const struct bbf_LocalScanDetector* srcPtrA )
{
 bbs_Context_pushError( cpA, bbs_Error_create( 1, 234, "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c", "bbf_LocalScanDetector_copy:\n Function is not available" ) );
}



flag bbf_LocalScanDetector_equal( struct bbs_Context* cpA,
           const struct bbf_LocalScanDetector* ptrA,
           const struct bbf_LocalScanDetector* srcPtrA )
{
 bbs_Context_pushError( cpA, bbs_Error_create( 1, 243, "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c", "bbf_LocalScanDetector_equal:\n Function is not available" ) );
 return 1;
}
# 273 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
uint32 bbf_LocalScanDetector_memSize( struct bbs_Context* cpA,
              const struct bbf_LocalScanDetector* ptrA )
{
 uint32 iL;
 uint32 memSizeL = ( sizeof( uint32 ) >> 1 ) +
       ( sizeof( uint32 ) >> 1 );

 memSizeL += ( sizeof( ptrA->patchWidthE ) >> 1 );
 memSizeL += ( sizeof( ptrA->patchHeightE ) >> 1 );
 memSizeL += ( sizeof( ptrA->scanWidthE ) >> 1 );
 memSizeL += ( sizeof( ptrA->scanHeightE ) >> 1 );
 memSizeL += ( sizeof( ptrA->scaleExpE ) >> 1 );
 memSizeL += ( sizeof( ptrA->interpolatedWarpingE ) >> 1 );
 memSizeL += ( sizeof( ptrA->warpScaleThresholdE ) >> 1 );
 memSizeL += bts_IdCluster2D_memSize( cpA, &ptrA->refClusterE );
 memSizeL += bts_Cluster2D_memSize( cpA, &ptrA->scanClusterE );
 memSizeL += bbf_BitParam_memSize( cpA, &ptrA->bitParamE );
 memSizeL += ( sizeof( ptrA->outlierDistanceE ) >> 1 );
 memSizeL += bts_IdCluster2D_memSize( cpA, &ptrA->pcaClusterE );
 memSizeL += bbs_Int16Arr_memSize( cpA, &ptrA->pcaAvgE );
 memSizeL += bbs_Int16Arr_memSize( cpA, &ptrA->pcaMatE );
 memSizeL += ( sizeof( ptrA->pcaDimSubSpaceE ) >> 1 );
 memSizeL += ( sizeof( ptrA->maxImageWidthE ) >> 1 );
 memSizeL += ( sizeof( ptrA->maxImageHeightE ) >> 1 );
 for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) memSizeL += bbf_featureMemSize( cpA, ptrA->ftrPtrArrE[ iL ] );

 return memSizeL;
}



uint32 bbf_LocalScanDetector_memWrite( struct bbs_Context* cpA,
            const struct bbf_LocalScanDetector* ptrA,
            uint16* memPtrA )
{
 uint32 iL;
 uint32 memSizeL = bbf_LocalScanDetector_memSize( cpA, ptrA );
 memPtrA += bbs_memWrite32( &memSizeL, memPtrA );
 memPtrA += bbs_memWriteUInt32( 100, memPtrA );

 memPtrA += bbs_memWrite32( &ptrA->patchWidthE, memPtrA );
 memPtrA += bbs_memWrite32( &ptrA->patchHeightE, memPtrA );
 memPtrA += bbs_memWrite32( &ptrA->scanWidthE, memPtrA );
 memPtrA += bbs_memWrite32( &ptrA->scanHeightE, memPtrA );
 memPtrA += bbs_memWrite32( &ptrA->scaleExpE, memPtrA );
 memPtrA += bbs_memWrite32( &ptrA->interpolatedWarpingE, memPtrA );
 memPtrA += bbs_memWrite32( &ptrA->warpScaleThresholdE, memPtrA );
 memPtrA += bts_IdCluster2D_memWrite( cpA, &ptrA->refClusterE, memPtrA );
 memPtrA += bts_Cluster2D_memWrite( cpA, &ptrA->scanClusterE, memPtrA );
 memPtrA += bbf_BitParam_memWrite( cpA, &ptrA->bitParamE, memPtrA );
 memPtrA += bbs_memWrite32( &ptrA->outlierDistanceE, memPtrA );
 memPtrA += bts_IdCluster2D_memWrite( cpA, &ptrA->pcaClusterE, memPtrA );
 memPtrA += bbs_Int16Arr_memWrite( cpA, &ptrA->pcaAvgE, memPtrA );
 memPtrA += bbs_Int16Arr_memWrite( cpA, &ptrA->pcaMatE, memPtrA );
 memPtrA += bbs_memWrite32( &ptrA->pcaDimSubSpaceE, memPtrA );
 memPtrA += bbs_memWrite32( &ptrA->maxImageWidthE, memPtrA );
 memPtrA += bbs_memWrite32( &ptrA->maxImageHeightE, memPtrA );

 for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) memPtrA += bbf_featureMemWrite( cpA, ptrA->ftrPtrArrE[ iL ], memPtrA );

 return memSizeL;
}



uint32 bbf_LocalScanDetector_memRead( struct bbs_Context* cpA,
           struct bbf_LocalScanDetector* ptrA,
           const uint16* memPtrA,
           struct bbs_MemTbl* mtpA )
{
 uint32 iL;
 uint32 memSizeL, versionL;
 struct bbs_MemTbl memTblL = *mtpA;
 struct bbs_MemSeg* espL = bbs_MemTbl_segPtr( cpA, &memTblL, 0 );
 struct bbs_MemSeg* sspL = bbs_MemTbl_sharedSegPtr( cpA, &memTblL, 0 );
 if( bbs_Context_error( cpA ) ) return 0;

 memPtrA += bbs_memRead32( &memSizeL, memPtrA );
 memPtrA += bbs_memReadVersion32( cpA, &versionL, 100, memPtrA );


 memPtrA += bbs_memRead32( &ptrA->patchWidthE, memPtrA );
 memPtrA += bbs_memRead32( &ptrA->patchHeightE, memPtrA );
 memPtrA += bbs_memRead32( &ptrA->scanWidthE, memPtrA );
 memPtrA += bbs_memRead32( &ptrA->scanHeightE, memPtrA );
 memPtrA += bbs_memRead32( &ptrA->scaleExpE, memPtrA );
 memPtrA += bbs_memRead32( &ptrA->interpolatedWarpingE, memPtrA );
 memPtrA += bbs_memRead32( &ptrA->warpScaleThresholdE, memPtrA );
 memPtrA += bts_IdCluster2D_memRead( cpA, &ptrA->refClusterE, memPtrA, espL );
 memPtrA += bts_Cluster2D_memRead( cpA, &ptrA->scanClusterE, memPtrA, espL );
 memPtrA += bbf_BitParam_memRead( cpA, &ptrA->bitParamE, memPtrA );
 memPtrA += bbs_memRead32( &ptrA->outlierDistanceE, memPtrA );
 memPtrA += bts_IdCluster2D_memRead( cpA, &ptrA->pcaClusterE, memPtrA, espL );
 memPtrA += bbs_Int16Arr_memRead( cpA, &ptrA->pcaAvgE, memPtrA, espL );
 memPtrA += bbs_Int16Arr_memRead( cpA, &ptrA->pcaMatE, memPtrA, espL );
 memPtrA += bbs_memRead32( &ptrA->pcaDimSubSpaceE, memPtrA );
 memPtrA += bbs_memRead32( &ptrA->maxImageWidthE, memPtrA );
 memPtrA += bbs_memRead32( &ptrA->maxImageHeightE, memPtrA );


 {
  const uint16* memPtrL = memPtrA;
  uint32 dataSizeL = 0;
  for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ )
  {
   enum bbf_FeatureType typeL = ( enum bbf_FeatureType )bbs_memPeek32( memPtrL + 4 );
   dataSizeL += bbf_featureSizeOf16( cpA, typeL );
   memPtrL += bbs_memPeek32( memPtrL );
  }
  bbs_UInt16Arr_create( cpA, &ptrA->ftrDataArrE, dataSizeL, espL );
 }


 {
  uint16* dataPtrL = ptrA->ftrDataArrE.arrPtrE;
  for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ )
  {
   enum bbf_FeatureType typeL = ( enum bbf_FeatureType )bbs_memPeek32( memPtrA + 4 );
   ptrA->ftrPtrArrE[ iL ] = ( struct bbf_Feature* )dataPtrL;
   bbf_featureInit( cpA, ptrA->ftrPtrArrE[ iL ], typeL );
   memPtrA += bbf_featureMemRead( cpA, ptrA->ftrPtrArrE[ iL ], memPtrA, &memTblL );
   dataPtrL += bbf_featureSizeOf16( cpA, typeL );
  }
 }

 if( memSizeL != bbf_LocalScanDetector_memSize( cpA, ptrA ) )
 {
  bbs_Context_pushError( cpA, bbs_Error_create( 5,
 401
# 400 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
  ,
 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
# 400 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
  , "uint32 bbf_LocalScanDetector_memRead( struct bem_ScanGradientMove* ptrA, const uint16* memPtrA ):\n" "size mismatch" ) )
                            ;
  return 0;
 }

 if( ptrA->maxImageWidthE * ptrA->maxImageHeightE == 0 )
 {
  bbs_Context_pushError( cpA, bbs_Error_create( 5,
 408
# 407 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
  ,
 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
# 407 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
  , "uint32 bbf_LocalScanDetector_memRead( struct bem_ScanGradientMove* ptrA, const uint16* memPtrA ):\n" "maximum image width/height not set" ) )
                                                      ;
  return 0;
 }




 bts_RBFMap2D_create( cpA, &ptrA->rbfMapE, 24, sspL );
 ptrA->rbfMapE.RBFTypeE = bts_RBF_LINEAR;
 ptrA->rbfMapE.altTypeE = bts_ALT_RIGID;

 bts_Cluster2D_create( cpA, &ptrA->tmpCluster1E, 24, sspL );
 bts_Cluster2D_create( cpA, &ptrA->tmpCluster2E, 24, sspL );
 bts_Cluster2D_create( cpA, &ptrA->tmpCluster3E, 24, sspL );
 bts_Cluster2D_create( cpA, &ptrA->tmpCluster4E, 24, sspL );

 bbs_Int32Arr_create( cpA, &ptrA->actArrE, 24, sspL );
 bbs_Int16Arr_create( cpA, &ptrA->idxArrE, 24, sspL );



 bbs_UInt8Arr_create( cpA, &ptrA->workImageBufE, ptrA->maxImageWidthE * ptrA->maxImageHeightE, sspL );


 bbf_LocalScanner_create( cpA, &ptrA->scannerE,
        ptrA->patchWidthE,
        ptrA->patchHeightE,
        ptrA->scaleExpE,
        ptrA->maxImageWidthE,
        ptrA->maxImageHeightE,
        ptrA->scaleExpE,
        ptrA->bitParamE.outerRadiusE,
        &memTblL );

 return memSizeL;
}
# 455 "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c"
int32 bbf_LocalScanDetector_process( struct bbs_Context* cpA,
          const struct bbf_LocalScanDetector* ptrA,
                                     uint8* imagePtrA,
          uint32 imageWidthA,
          uint32 imageHeightA,
          const struct bts_Int16Vec2D* offsPtrA,
          const struct bts_IdCluster2D* inClusterPtrA,
          struct bts_IdCluster2D* outClusterPtrA )
{
 const char* fNameL = "bbf_LocalScanDetector_process";

 int32 pw0L = ptrA->patchWidthE;
 int32 ph0L = ptrA->patchHeightE;
 int32 pw1L = pw0L << ptrA->scaleExpE;
 int32 ph1L = ph0L << ptrA->scaleExpE;

 struct bts_Cluster2D* wrkClPtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster1E;
 struct bts_Cluster2D* refClPtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster2E;
 struct bts_Cluster2D* dstClPtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster3E;
 struct bts_Cluster2D* tmpClPtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster4E;
 struct bts_RBFMap2D* rbfPtrL = ( struct bts_RBFMap2D* )&ptrA->rbfMapE;
 struct bbf_LocalScanner* scnPtrL = ( struct bbf_LocalScanner* )&ptrA->scannerE;

 int32* actArrL = ( int32* )ptrA->actArrE.arrPtrE;
 int16* idxArrL = ( int16* )ptrA->idxArrE.arrPtrE;

 uint32 workImageWidthL, workImageHeightL;

 struct bts_Flt16Alt2D altL;

 int32 confidenceL;
 uint32 iL;
 uint32 sizeL = ptrA->scanClusterE.sizeE;

 if( sizeL > 24 )
 {
  bbs_Context_pushError( cpA, bbs_Error_create( 1, 491, "external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.c", "%s:\nScan cluster size exceeds bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE", fNameL ) );
  return 0;
 }


 bts_IdCluster2D_convertToEqivalentClusters( cpA, inClusterPtrA, &ptrA->refClusterE, wrkClPtrL, refClPtrL );


 altL = bts_Cluster2D_alt( cpA, wrkClPtrL, refClPtrL, bts_ALT_RIGID );


 bts_Cluster2D_transformBbp( cpA, wrkClPtrL, altL, 6 );


 bts_RBFMap2D_compute( cpA, rbfPtrL, refClPtrL, wrkClPtrL );


 bts_Cluster2D_copy( cpA, wrkClPtrL, &ptrA->scanClusterE );


 bts_Cluster2D_copy( cpA, refClPtrL, &ptrA->refClusterE.clusterE );


 bts_Cluster2D_rbfTransform( cpA, wrkClPtrL, rbfPtrL );


 bts_Cluster2D_rbfTransform( cpA, refClPtrL, rbfPtrL );

 {

  int32 workBorderWL = ( ( ptrA->scanWidthE + pw1L + 1 ) >> 1 ) + 1;
  int32 workBorderHL = ( ( ptrA->scanHeightE + ph1L + 1 ) >> 1 ) + 1;
  struct bts_Int16Rect workAreaL = bts_Cluster2D_boundingBox( cpA, wrkClPtrL );
  workAreaL.x1E = workAreaL.x1E >> wrkClPtrL->bbpE;
  workAreaL.y1E = workAreaL.y1E >> wrkClPtrL->bbpE;
  workAreaL.x2E = workAreaL.x2E >> wrkClPtrL->bbpE;
  workAreaL.y2E = workAreaL.y2E >> wrkClPtrL->bbpE;
  workAreaL.x1E -= workBorderWL;
  workAreaL.y1E -= workBorderHL;
  workAreaL.x2E += workBorderWL;
  workAreaL.y2E += workBorderHL;

  workImageWidthL = workAreaL.x2E - workAreaL.x1E;
  workImageHeightL = workAreaL.y2E - workAreaL.y1E;


  workImageWidthL = workImageWidthL > ptrA->maxImageWidthE ? ptrA->maxImageWidthE : workImageWidthL;
  workImageHeightL = workImageHeightL > ptrA->maxImageHeightE ? ptrA->maxImageHeightE : workImageHeightL;


  altL.vecE.xE -= workAreaL.x1E << altL.vecE.bbpE;
  altL.vecE.yE -= workAreaL.y1E << altL.vecE.bbpE;


  for( iL = 0; iL < wrkClPtrL->sizeE; iL++ )
  {
   wrkClPtrL->vecArrE[ iL ].xE -= workAreaL.x1E << wrkClPtrL->bbpE;
   wrkClPtrL->vecArrE[ iL ].yE -= workAreaL.y1E << wrkClPtrL->bbpE;
  }


  for( iL = 0; iL < wrkClPtrL->sizeE; iL++ )
  {
   refClPtrL->vecArrE[ iL ].xE -= workAreaL.x1E << refClPtrL->bbpE;
   refClPtrL->vecArrE[ iL ].yE -= workAreaL.y1E << refClPtrL->bbpE;
  }


  bim_filterWarp( cpA,
         ptrA->workImageBufE.arrPtrE,
      imagePtrA, imageWidthA, imageHeightA,
      offsPtrA,
      &altL,
      workImageWidthL, workImageHeightL,
      0L,
      ptrA->warpScaleThresholdE,
      ptrA->interpolatedWarpingE );

 }


 {
  int32 regionWHL = ( ptrA->scanWidthE + pw1L + 1 ) >> 1;
  int32 regionHHL = ( ptrA->scanHeightE + ph1L + 1 ) >> 1;
  struct bts_Int16Vec2D* srcVecArrL = wrkClPtrL->vecArrE;
  struct bts_Int16Vec2D* dstVecArrL = dstClPtrL->vecArrE;
  int32 vecBbpL = wrkClPtrL->bbpE;
  bts_Cluster2D_size( cpA, dstClPtrL, sizeL );
  dstClPtrL->bbpE = vecBbpL;


  scnPtrL->patchWidthE = ptrA->patchWidthE;
  scnPtrL->patchHeightE = ptrA->patchWidthE;
  scnPtrL->scaleExpE = ptrA->scaleExpE;

  bbf_LocalScanner_assign( cpA, scnPtrL, ptrA->workImageBufE.arrPtrE, workImageWidthL, workImageHeightL, &ptrA->bitParamE );

  bbs_memset32( actArrL, 0x80000000, sizeL );

  do
  {
   for( iL = 0; iL < sizeL; iL++ )
   {
    int32 bestActL = 0x80000000;
    uint32 bestIdxL = 0;
    struct bbf_Feature* ftrPtrL = ptrA->ftrPtrArrE[ iL ];


    {
     int32 x0L = ( ( wrkClPtrL->vecArrE[ iL ].xE >> ( wrkClPtrL->bbpE - 1 ) ) + 1 ) >> 1;
     int32 y0L = ( ( wrkClPtrL->vecArrE[ iL ].yE >> ( wrkClPtrL->bbpE - 1 ) ) + 1 ) >> 1;
     struct bts_Int16Rect scanRegionL = bts_Int16Rect_create( x0L - regionWHL, y0L - regionHHL, x0L + regionWHL, y0L + regionHHL );
     bbf_LocalScanner_origScanRegion( cpA, scnPtrL, &scanRegionL );
    }

    do
    {
     int32 actL = ftrPtrL->vpActivityE( ftrPtrL, bbf_LocalScanner_getPatch( scnPtrL ) );

     if( actL > bestActL )
     {
      bestActL = actL;
      bestIdxL = bbf_LocalScanner_scanIndex( scnPtrL );
     }
    }
    while( bbf_LocalScanner_next( cpA, scnPtrL ) );

    {
     int32 xL, yL;
     bbf_LocalScanner_idxPos( scnPtrL, bestIdxL, &xL, &yL );
     xL += pw1L << 15;
     yL += ph1L << 15;
     if( bestActL > actArrL[ iL ] )
     {
      dstVecArrL[ iL ].xE = ( ( xL >> ( 15 - vecBbpL ) ) + 1 ) >> 1;
      dstVecArrL[ iL ].yE = ( ( yL >> ( 15 - vecBbpL ) ) + 1 ) >> 1;
      actArrL[ iL ] = bestActL;
     }
    }
   }
  }
  while( bbf_LocalScanner_nextOffset( cpA, scnPtrL ) );


  if( ptrA->outlierDistanceE > 0 )
  {

   struct bts_Flt16Alt2D localAltL = bts_Cluster2D_alt( cpA, wrkClPtrL, dstClPtrL, bts_ALT_RIGID );


   uint32 dist2L = ( ptrA->outlierDistanceE >> 8 ) * ( ptrA->outlierDistanceE >> 8 );


   for( iL = 0; iL < sizeL; iL++ )
   {
    struct bts_Flt16Vec2D vecL = bts_Flt16Vec2D_create32( srcVecArrL[ iL ].xE, srcVecArrL[ iL ].yE, vecBbpL );
    uint32 dev2L;
    vecL = bts_Flt16Alt2D_mapFlt( &localAltL, &vecL );
    vecL = bts_Flt16Vec2D_sub( vecL, bts_Flt16Vec2D_create32( dstVecArrL[ iL ].xE, dstVecArrL[ iL ].yE, vecBbpL ) );
    dev2L = bbs_convertU32( bts_Flt16Vec2D_norm2( &vecL ), vecL.bbpE << 1, 16 );
    if( dev2L > dist2L ) actArrL[ iL ] = 0xF0000000;
   }
  }


  {
   flag sortedL;


   for( iL = 0; iL < sizeL; iL++ ) idxArrL[ iL ] = iL;

   do
   {
    sortedL = 1;
    for( iL = 1; iL < sizeL; iL++ )
    {
     if( actArrL[ idxArrL[ iL - 1 ] ] < actArrL[ idxArrL[ iL ] ] )
     {
      int16 tmpL = idxArrL[ iL - 1 ];
      idxArrL[ iL - 1 ] = idxArrL[ iL ];
      idxArrL[ iL ] = tmpL;
      sortedL = 0;
     }
    }
   }
   while( !sortedL );

   for( iL = ( sizeL >> 1 ); iL < sizeL && actArrL[ idxArrL[ iL ] ] >= 0; iL++ );

   {
    uint32 subSizeL = iL;


    bts_Cluster2D_size( cpA, tmpClPtrL, subSizeL );
    {
     struct bts_Int16Vec2D* tmpVecArrL = tmpClPtrL->vecArrE;
     for( iL = 0; iL < subSizeL; iL++ ) tmpVecArrL[ iL ] = srcVecArrL[ idxArrL[ iL ] ];
     for( iL = 0; iL < subSizeL; iL++ ) srcVecArrL[ iL ] = tmpVecArrL[ iL ];
     for( iL = 0; iL < subSizeL; iL++ ) tmpVecArrL[ iL ] = dstVecArrL[ idxArrL[ iL ] ];
     for( iL = 0; iL < subSizeL; iL++ ) dstVecArrL[ iL ] = tmpVecArrL[ iL ];
    }
    bts_Cluster2D_size( cpA, wrkClPtrL, subSizeL );
    bts_Cluster2D_size( cpA, dstClPtrL, subSizeL );
   }
  }


  {
   int16* idxArrL = ptrA->idxArrE.arrPtrE;
   int32* actArrL = ptrA->actArrE.arrPtrE;
   int32 actSumL = 0;
   for( iL = 0; iL < sizeL; iL++ )
   {
    float actL = ( actArrL[ idxArrL[ iL ] ] + 128 ) >> 8;
    if( actL < 0 ) break;
    actSumL += actL;
   }


   actSumL = ( iL > 0 ) ? actSumL / iL : 0;

   confidenceL = ( ( ( int32 )iL << 20 ) - ( ( ( int32 )1 << 20 ) - actSumL ) ) / sizeL;


   confidenceL <<= 8;
  }

 }


 bts_RBFMap2D_compute( cpA, rbfPtrL, wrkClPtrL, dstClPtrL );


 bts_Cluster2D_rbfTransform( cpA, refClPtrL, rbfPtrL );


 bts_Cluster2D_copy( cpA, &outClusterPtrA->clusterE, refClPtrL );
 bbs_Int16Arr_copy( cpA, &outClusterPtrA->idArrE, &ptrA->refClusterE.idArrE );


 if( ptrA->pcaDimSubSpaceE > 0 )
 {
  bbf_LocalScanDetector_pcaMap( cpA, ptrA, outClusterPtrA, outClusterPtrA );
 }


 bts_Cluster2D_transformBbp( cpA, &outClusterPtrA->clusterE, bts_Flt16Alt2D_inverted( &altL ), inClusterPtrA->clusterE.bbpE );

 return confidenceL;
}