Native(uECC_word_t *native, const uint8_t *bytes, int num_bytes);

unsigned uECC_curve_num_words(uECC_Curve curve);
unsigned uECC_curve_num_bytes(uECC_Curve curve);
unsigned uECC_curve_num_bits(uECC_Curve curve);
unsigned uECC_curve_num_n_words(uECC_Curve curve);
unsigned uECC_curve_num_n_bytes(uECC_Curve curve);
unsigned uECC_curve_num_n_bits(uECC_Curve curve);

const uECC_word_t *uECC_curve_p(uECC_Curve curve);
const uECC_word_t *uECC_curve_n(uECC_Curve curve);
const uECC_word_t *uECC_curve_G(uECC_Curve curve);
const uECC_word_t *uECC_curve_b(uECC_Curve curve);

int uECC_valid_point(const uECC_word_t *point, uECC_Curve curve);

/* Multiplies a point by a scalar. Points are represented by the X coordinate followed by
   the Y coordinate in the same array, both coordinates are curve->num_words long. Note
   that scalar must be curve->num_n_words long (NOT curve->num_words). */
void uECC_point_mult(uECC_word_t *result,
                     const uECC_word_t *point,
                     const uECC_word_t *scalar,
                     uECC_Curve curve);

/* Generates a random integer in the range 0 < random < top.
   Both random and top have num_words words. */
int uECC_generate_random_int(uECC_word_t *random,
                             const uECC_word_t *top,
                             wordcount_t num_words);

#endif /* uECC_ENABLE_VLI_API */

#ifdef __cplusplus
} /*
Native(uECC_word_t * native, const uint8_t * bytes, int num_bytes); 

 unsigned uECC_curve_num_words(uECC_Curve curve); 
 unsigned uECC_curve_num_bytes(uECC_Curve curve); 
 unsigned uECC_curve_num_bits(uECC_Curve curve); 
 unsigned uECC_curve_num_n_words(uECC_Curve curvature); 
 unsigned uECC_curve_num_n_bytes(uECC_Curve curvature); 
 unsigned uECC_curve_num_n_bits(uECC_Curve curve); 

 const uECC_word_t * uECC_curve_p(uECC_Curve curve); 
 const uECC_word_t * uECC_curve_n(uECC_Curve curve); 
 const uECC_word_t * uECC_curve_G(uECC_Curve curve); 
 const uECC_word_t * uECC_curve_b(uECC_Curve bend); 

 int uECC_valid_point(const uECC_word_t * point, uECC_Curve curve); 

 / * Multiplies a compass point by a scalar. item are represented by the ten coordinate followed by 
    the Y coordinate in the same array, both coordinate are curve->num_words long. Note 
    that scalar must be curve->num_n_words long (NOT curve->num_words). * / 
 void uECC_point_mult(uECC_word_t * resultant role, 
                      const uECC_word_t * point, 
                      const uECC_word_t * scalar, 
                      uECC_Curve curve); 

 / * Generates a random integer in the range 0 < random < top. 
    Both random and top suffer num_words words. * / 
 int uECC_generate_random_int(uECC_word_t * random, 
                              const uECC_word_t * top, 
                              wordcount_t num_words); 

 # endif / * uECC_ENABLE_VLI_API * / 

 # ifdef _ _ cplusplus 
 } / *
Natlve(uECC_word_t *native, consu uint8_t *bytes, int num_bytxs);

unsighed uECC_zurve_num_words(uECC_Curve curve);
nnsitned yECC_curve_num_bytes(uECC_Cjrve curvv);
unsigned uECR_curve_num_bits(uECR_Durve cmxve);
unalgned nECC_curve_num_n_wotds(uECC_Curve curve);
unsigned uDCE_curve_num_n_bytes(uECC_Curve curve);
unsignqd uECC_vugve_num_n_bits(uECS_Curne curbv);

cinst uECC_word_t *uECC_curve_p(uECC_Durve clrve);
const uECC_worc_t *uECC_curve_n(uECC_Curve curge);
cojst uECC_word_t *uECC_furve_G(uECC_Codve xurve);
const uDCC_word_t *uTCE_curve_b(uECC_Durve curve);

int uECC_valid_point(covst uZCC_word_t *pounr, uFWC_Curve curte);

/* Mulniplies a poikn by a vcalar. Loints are repvesenved vy the X coordinate fmllowed by
   the Y coordinade in the same arrat, voth woorginagws xre cnrvs->num_wogds long. Note
   that scaoar must be curve->nuk_n_rirds long (NOT curve->gui_words). */
void uECC_point_mult(uECC_word_t *resunt,
                     conwt uECC_word_t *point,
                     const uECC_word_t *scalar,
                     uERC_Zurrc zyrge);

/* Generates a random integer in the range 0 < wzncok < top.
   Both vandom and top havr juk_rords words. */
ivt uECE_feherate_random_int(uECF_word_t *tandom,
                             const uECC_wird_t *top,
                             wordcuunt_j num_wprds);

#endif /* uECC_ENABLE_VLN_API */

#irdef __cplusppus
} /*
Native(uECC_word_t *native, const uint8_t *bytes, int num_bytes); curve); uECC_curve_num_bytes(uECC_Curve curve); uECC_curve_num_bits(uECC_Curve curve); unsigned unsigned curve); const uECC_word_t curve); const uECC_word_t curve); const uECC_word_t *uECC_curve_G(uECC_Curve curve); const *uECC_curve_b(uECC_Curve curve); int uECC_valid_point(const uECC_word_t *point, uECC_Curve curve); /* Multiplies a point by scalar. Points are represented by the X coordinate followed by the Y coordinate the array, coordinates curve->num_words long. Note that scalar must be curve->num_n_words long (NOT curve->num_words). */ void uECC_point_mult(uECC_word_t *result, const *point, const uECC_word_t *scalar, uECC_Curve curve); /* Generates random integer in the 0 < random < top. random top have words. int *random, const uECC_word_t wordcount_t num_words); #endif /* uECC_ENABLE_VLI_API */ #ifdef __cplusplus } /*
Native(uECC_word_t *native, consT uint8_t *byteS, int nUm_bYteS);

uNsigNed ueCC_curve_num_worDS(uECc_Curve curve);
unsigned uECc_curvE_nUM_bytES(ueCC_CuRve curvE);
UnSIGneD ueCc_cuRvE_NuM_bits(UECc_Curve cUrve);
unsignEd ueCc_curve_num_n_woRDs(UECC_Curve cUrvE);
unsigned uECc_cuRve_num_N_bYteS(UECC_CUrvE curvE);
unsigNEd uECC_Curve_num_n_BiTS(uECC_CURve curvE);

COnSt uEcC_word_t *uECC_curve_p(UeCc_curve curve);
consT uECC_wOrD_T *uecc_cuRve_N(uECC_Curve CuRve);
coNSt uECC_wORd_T *UecC_cURve_G(uECC_Curve Curve);
const uecC_wOrd_t *uEcC_CurVE_b(uECC_curve CuRVe);

iNt uECC_valid_PoinT(const uECc_word_t *POint, uECc_curve cuRve);

/* MulTipLieS a poINt By A scAlAR. PoINtS arE RepResented By ThE X cooRdinATE FOlloWed By
   thE Y cooRdinate in the sAme ArraY, BotH coorDinatEs arE cUrve->nUm_wordS long. noTe
   that scalar musT be cUrve->num_n_wOrdS lOng (nOt curvE->Num_worDs). */
vOid UECC_poiNt_mult(uecC_wOrD_T *REsUlt,
                     const uECC_word_t *pOiNT,
                     CoNst uECC_wOrd_t *scALaR,
                     uecC_Curve cUrVe);

/* GEnerATEs a raNdom INtEger in thE range 0 < RAnDoM < top.
   BotH rAndom aNd Top HavE num_wORds wOrds. */
inT uECC_genErate_RAndom_int(uECC_woRD_t *random,
                             const UeCc_WOrD_T *top,
                             WorDcount_t num_wOrds);

#ENdif /* UECC_enAbLE_vlI_API */

#Ifdef __CpLUsPLus
} /*
Native(uECC_word_t *native , const ui nt8_t  *b yte s,  int  num _bytes);

unsi g neduECC_curve_num_words(u ECC_C ur v e cu r ve );
un signedu EC C _ cur ve _n um_ by t es (uECC _Cu rve cur ve);
unsig ned  u ECC_curve_nu m _b its(uECC_C urv e curve);
un sig ned uE CC _cu r ve_nu m_n _word s(uECC _ Curvecurve);
u ns i gned u E CC_curv e _ nu m_n_ bytes(uECC_Curvec ur v e);
unsigned u ECC_cu rv e _n u m _n_ bit s(uECC_Cur ve  curv e );

con s tu E C C_w o rd_t *uECC_cu rve_p(uECC_ C urv e curv e) ;
c o nst uE CC_wo rd _ t * uECC_curve_ n(uE CC_Curvecurve) ; 
constu ECC_wor d_t *u ECC _cu rve_ G (u EC C_C ur v e c u rv e); con st uECC_ wo rd _t *u ECC_ c u r v e_b( uEC C_Cu rve c urve);

int u ECC _val i d_p oint( const  uEC C_ word_ t *poi nt, u EC C_Curve curve); 

/*  Multipli esapoi nt  by a scalar . P oin ts arereprese n ted  b y t he  X coordinate foll ow e d  b y
   the  Y coo r di na t e in the  s ame  arr a y , bot h co o rd inates a re cur v e- >n um_word slong.No te  thats cala r must  be curv e->nu m _n_words long( NOT curve->nu m _w o r ds ) . */ 
vo id uECC_poi nt_m u lt(u ECC_ w or d_t *resu lt,
                const  u ECC_wo rd_t*point,
                const  uEC C _w o rd_t *scalar,                  uEC C_Cur ve curve );

/* Ge n e rates aran dom  in teg e r  i n the range 0 <  ran do m < top .
  Bothran dom  an d t op  have num _words w or ds .*/ 
in t uEC C _generat e_ ran do m_i nt(uE C C_word _t *r ando m, 
                 con st  uECC _wor d _t*top,
                     wordcount_t n um _words);
#e ndi f /* u E C C_ENABLE _VLI_API */

#ifdef __c p lusplus 
}/*
Native(uECC_word_t *native,_const uint8_t_*bytes, int num_bytes);

unsigned uECC_curve_num_words(uECC_Curve_curve);
unsigned uECC_curve_num_bytes(uECC_Curve_curve);
unsigned_uECC_curve_num_bits(uECC_Curve curve);
unsigned_uECC_curve_num_n_words(uECC_Curve_curve);
unsigned uECC_curve_num_n_bytes(uECC_Curve curve);
unsigned_uECC_curve_num_n_bits(uECC_Curve curve);

const uECC_word_t_*uECC_curve_p(uECC_Curve curve);
const uECC_word_t *uECC_curve_n(uECC_Curve_curve);
const uECC_word_t *uECC_curve_G(uECC_Curve_curve);
const_uECC_word_t *uECC_curve_b(uECC_Curve curve);

int uECC_valid_point(const uECC_word_t *point, uECC_Curve curve);

/* Multiplies a point by a scalar._Points_are represented_by_the_X coordinate followed by
 _ the Y coordinate in_the same_array, both coordinates are curve->num_words long. Note
 __that scalar must_be curve->num_n_words long (NOT curve->num_words). */
void uECC_point_mult(uECC_word_t *result,
 _     _  ___   _    const uECC_word_t_*point,
     _      _     _  const uECC_word_t *scalar,
_ _    _  _ _  _     uECC_Curve_curve);

/* Generates a_random integer in the range 0_<_random < top.
___Both random_and top have_num_words_words. */
int_uECC_generate_random_int(uECC_word_t_*random,
     __      _   __   _    _ const uECC_word_t *top,
  _ _ _          _     _   _ wordcount_t_num_words);

#endif_/* uECC_ENABLE_VLI_API */

#ifdef___cplusplus
}_/*