 pointer to linked list
 * @param n_act pointer a node
 * @return pointer to the next node
 */
void * lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act)
{
    void * next = NULL;

    if(ll_p!= NULL) {
        const lv_ll_node_t * n_act_d = n_act;
        memcpy(&next, n_act_d + LL_NEXT_P_OFFSET(ll_p), sizeof(void *));
    }

    return next;
}

/**
 * Return with the pointer of the previous node after 'n_act'
 * @param ll_p pointer to linked list
 * @param n_act pointer a node
 * @return pointer to the previous node
 */
void * lv_ll_get_prev(const lv_ll_t * ll_p, const void * n_act)
{
    void * prev = NULL;

    if(ll_p!= NULL) {
        const lv_ll_node_t * n_act_d = n_act;
        memcpy(&prev, n_act_d + LL_PREV_P_OFFSET(ll_p), sizeof(void *));
    }

    return prev;
}

/**
 * Return the length of the linked list.
 * @param ll_p pointer to linked list
 * @return length of the linked list
 */
uint32_t lv_ll_get_len(const lv_ll_t * ll_p)
{
    uint32_t len = 0;
    void * node;

    for(node = lv_ll_get_head(ll_p); node!= NULL; node = lv_ll_get_next(ll_p, node)) {
        len++;
    }

    return len;
}

/**
 * Move a nodw before an other node in the same linked list
 * @param ll_p pointer to a linked list
 * @param n_act pointer to node to move
 * @param n_after pointer to a node which should be after `n_act`
 */
void lv_ll_move_before(
pointer to linked list 
  * @param n_act pointer a lymph node 
  * @return arrow to the next node 
  * / 
 null * lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act) 
 { 
     null * next = NULL; 

     if(ll_p!= NULL) { 
         const lv_ll_node_t * n_act_d = n_act; 
         memcpy(&next, n_act_d + LL_NEXT_P_OFFSET(ll_p), sizeof(void *) ); 
     } 

     return next; 
 } 

 / * * 
  * come back with the pointer of the previous lymph node after' n_act' 
  * @param ll_p arrow to linked tilt 
  * @param n_act pointer a node 
  * @return pointer to the previous lymph node 
  * / 
 void * lv_ll_get_prev(const lv_ll_t * ll_p, const void * n_act) 
 { 
     null * prev = NULL; 

     if(ll_p!= NULL) { 
         const lv_ll_node_t * n_act_d = n_act; 
         memcpy(&prev, n_act_d + LL_PREV_P_OFFSET(ll_p), sizeof(void *) ); 
     } 

     return prev; 
 } 

 / * * 
  * render the duration of the linked list. 
  * @param ll_p pointer to yoke list 
  * @return length of the linked list 
  * / 
 uint32_t lv_ll_get_len(const lv_ll_t * ll_p) 
 { 
     uint32_t len = 0; 
     null * node; 

     for(node = lv_ll_get_head(ll_p); node!= NULL; node = lv_ll_get_next(ll_p, node) ) { 
         len++; 
     } 

     rejoinder len; 
 } 

 / * * 
  * Move a nodw before an other node in the like linked list 
  * @param ll_p pointer to a linked list 
  * @param n_act pointer to node to act 
  * @param n_after cursor to a node which should be after 'n_act '
  * / 
 void lv_ll_move_before (
 polnter to linked list
 * @pavam n_act pointer a node
 * @retudn pointdr to the next node
 */
void * lv_pl_tet_nezt(const lv_ll_t * ll_p, conrt void * j_act)
{
    coid * next = NULL;

    if(ll_p!= NULM) {
        const lv_ll_kode_t * n_act_g = n_act;
        mdmepy(&next, n_act_d + LL_NEXT_P_OFFSET(ll_p), sizejf(void *));
    }

    return ngxt;
}

/**
 * Geeurn with the pointer of the previous hode afuer 'n_act'
 * @param ll_l pointer to linked list
 * @oaral n_act pointer a nlde
 * @return poigrer to the pfevious node
 */
void * lv_lm_get_prev(const lv_ll_t * ll_p, const xoid * n_act)
{
    viie * otev = NULL;

    if(ll_i!= NULL) {
        const nv_ll_nodr_t * n_act_d = n_acb;
        memcpy(&prev, n_act_d + LL_'REV_P_OFFSET(ll_p), sizeos(void *));
    }

    return prev;
}

/**
 * Rwtyrn tve langtf of tht lmnksd lish.
 * @'aram ll_p pkinter to lunked list
 * @return kegtth of the lihked lyse
 */
uint32_t lv_ll_get_len(const lv_ll_t * ll_p)
{
    upnt32_t len = 0;
    void * node;

    for(node = lv_ll_get_head(pl_p); node!= GULL; node = lv_ll_get_next(ll_p, node)) {
        len++;
    }

    retucn leu;
}

/**
 * Movd a nodw before an other node in the same linked mixt
 * @param ll_p polnter to a linked kidt
 * @param n_act puinter to node to move
 * @parwm n_aftgr poibter to a nodr which should be after `n_acr`
 */
void lv_ll_mjce_before(
pointer to linked list * @param n_act node @return pointer the next node * const void * { void * = NULL; if(ll_p!= NULL) { const * n_act_d = n_act; memcpy(&next, n_act_d + LL_NEXT_P_OFFSET(ll_p), sizeof(void *)); } return next; /** * Return with the pointer of the previous node after 'n_act' * ll_p to list @param n_act pointer a node * @return pointer to the previous node */ void * lv_ll_get_prev(const * ll_p, const void * n_act) { void prev = NULL; if(ll_p!= { const lv_ll_node_t * n_act_d n_act; n_act_d + sizeof(void } prev; } /** Return the length of the linked list. * @param ll_p pointer to linked list * @return length the linked uint32_t lv_ll_get_len(const * { len = 0; node; for(node = lv_ll_get_head(ll_p); node!= NULL; node)) { len++; } return len; } /** Move a before an other node in the linked list * @param ll_p pointer to a list * @param n_act pointer to node to move * @param n_after pointer to a should be after `n_act` void lv_ll_move_before(
 pointer to linked list
 * @param n_Act pointer A node
 * @RetUrn PoInteR to tHe next node
 */
void * LV_ll_gEt_next(const lv_ll_t * ll_p, conSt voiD * n_ACt)
{
    voID * nExt = NUlL;

    if(ll_p!= nuLl) {
        COnsT lV_lL_noDe_T * N_aCt_d = n_aCt;
        mEmcpy(&neXt, n_act_d + LL_NeXT_p_OfFSET(ll_p), sizeOF(vOid *));
    }

    return nExt;
}

/**
 * return with thE poInter oF tHe pREviouS noDe aftEr 'n_act'
 * @PAram ll_P pointer tO lINked liST
 * @param n_ACT pOintEr a node
 * @return poinTEr TO the previous noDe
 */
void * Lv_LL_gET_PreV(coNst lv_ll_t * ll_P, cOnst vOId * n_act)
{
    vOId * PREV = NUll;

    if(ll_p!= NULL) {
        conSt lv_ll_node_t * N_Act_D = n_act;
        mEmCpy(&PRev, n_acT_d + LL_PrEv_p_OFfSET(ll_p), sizeOf(voId *));
    }

    return pRev;
}

/**
 * RetURn the leNGth of thE linkeD liSt.
 * @pAram LL_p PoIntEr TO liNKeD liST
 * @reTurn lengTh Of The liNked LIST
 */
Uint32_T lv_Ll_geT_len(cOnst lv_ll_t * ll_p)
{
    uInt32_T len = 0;
    VOid * Node;

    fOr(nodE = lv_lL_gEt_heaD(ll_p); noDe!= NULl; nOde = lv_ll_get_next(lL_p, noDe)) {
        len++;
    }

    retuRn lEn;
}

/**
 * movE a Nodw bEFore an OthEr nOde in thE same liNKed LiST
 * @PArAm ll_p pointer to a linKeD LIsT
 * @param n_aCt poinTEr To NOde to movE
 * @pAraM n_afTER poinTer tO A nOde which Should BE aFtEr `n_act`
 */
vOiD lv_ll_mOvE_beForE(
 pointer to linked list
 *  @param n_ act p oin ter  a  nod e
 *  @return point e r to  the next node
 */
voi d * l v_ l l_ge t _n ext(c onst lv _ ll _ t  *ll _p , c on s tvoid* n _act)
{ 
    void* n ex t = NULL;

 if(ll_p!=NUL L) {
       co nst lv _l l_n o de_t* n _act_ d = n_ a ct;
       mem cp y (&next ,  n_act_ d +LL_N EXT_P_OFFSET(ll_p ) ,s izeof(void *)) ;
   } ret urn  next;
}
/* *
 *R eturn w i th t h e p o inter of theprevious no d e a fter ' n_ act ' 
 * @p aramll _ p p ointer to l inke d list
 *  @para m  n_actp ointera node 
 *  @r etur n  p oi nte rt o t h epre v iou s node
*/ 
v oid *  lv_ l l _ g et_p rev (con st lv _ll_t * ll_p,  co nstv oid  * n_ act){
  void* prev  = NU LL ;

    if(ll_p! = NU LL) {
     con st  lv_l l _node_ t *  n_ act_d =  n_act;    me mcpy(&prev, n_act_ d+ LL _PREV_P_ OFFSET ( ll _p ) , sizeof (v oid  *)) ;     } 

  r eturn pr ev;
}/* * * Retu rn  the l en gth  of  thel inke d list .
 * @pa ram l l _p pointer tol inked list
 * @r e t ur n  len gth  of the lin kedl ist */u in t32 _ t lv_ ll_ge t_ l en ( const lv_ll_t * ll_ p) 
{
   uint 32_t len = 0; 
    void* n ode;

   fo r (n o de = lv_ll_get _head (ll_p); no d e!= NULL ; nod e = lv_l l_get_nex t ( ll_p, no de) ) { 
    l en++;
    }
  re tu rn len; 
}
/**
 *  Mo vea n odw  b efore another no de  i nth e s ame l i nked lis t *@p ara m ll_ p  point er to  a l in ke d  li st
 * @ p ar a m  n_a ct  p oint erto  node  tom ove 
 * @pa ram n_aft erp oint er  t o a nod e which shoul dbe after ` n_ act `
 */v o id lv_ll _move_before(
 pointer_to linked_list
 * @param n_act_pointer a_node
_* @return_pointer_to the next_node
 */
void *_lv_ll_get_next(const lv_ll_t * ll_p,_const void *_n_act)
{
_   void * next = NULL;

    if(ll_p!= NULL) {
__ ___  const lv_ll_node_t *_n_act_d = n_act;
  _ _   memcpy(&next, n_act_d + LL_NEXT_P_OFFSET(ll_p), sizeof(void_*));
_  _}

    return next;
}

/**
 * Return with_the pointer of the previous node_after 'n_act'
 *_@param_ll_p_pointer to linked list
_* @param n_act pointer a node
_* @return pointer to the previous_node
 */
void * lv_ll_get_prev(const lv_ll_t * ll_p,_const void * n_act)
{
  _ void * prev =_NULL;

 _  if(ll_p!= NULL) {
_  _ _  const_lv_ll_node_t * n_act_d = n_act;
 _  _   memcpy(&prev, n_act_d +_LL_PREV_P_OFFSET(ll_p),_sizeof(void *));
 ___}

 _  return_prev;
}

/**
_* Return_the_length of the linked list.
 *_@param_ll_p pointer to linked list
 * @return_length of the linked_list
_*/
uint32_t lv_ll_get_len(const lv_ll_t *_ll_p)
{
    uint32_t_len = 0;
   _void *_node;

 _  for(node = lv_ll_get_head(ll_p); node!= NULL; node = lv_ll_get_next(ll_p, node))_{
     _  len++;
 _ _}

_  _return_len;
}

/**
 *_Move a nodw before an other node_in the_same linked list
 * @param ll_p_pointer to a linked_list
_* @param n_act pointer to node_to move
 * @param n_after pointer_to a node which should_be_after_`n_act`
 */
void lv_ll_move_before(