static bool logic_imm_decode_wmask(uint64_t *result, unsigned int immn,

                                   unsigned int imms, unsigned int immr)

{

    uint64_t mask;

    unsigned e, levels, s, r;

    int len;



    assert(immn < 2 && imms < 64 && immr < 64);



    /* The bit patterns we create here are 64 bit patterns which

     * are vectors of identical elements of size e = 2, 4, 8, 16, 32 or

     * 64 bits each. Each element contains the same value: a run

     * of between 1 and e-1 non-zero bits, rotated within the

     * element by between 0 and e-1 bits.

     *

     * The element size and run length are encoded into immn (1 bit)

     * and imms (6 bits) as follows:

     * 64 bit elements: immn = 1, imms = <length of run - 1>

     * 32 bit elements: immn = 0, imms = 0 : <length of run - 1>

     * 16 bit elements: immn = 0, imms = 10 : <length of run - 1>

     *  8 bit elements: immn = 0, imms = 110 : <length of run - 1>

     *  4 bit elements: immn = 0, imms = 1110 : <length of run - 1>

     *  2 bit elements: immn = 0, imms = 11110 : <length of run - 1>

     * Notice that immn = 0, imms = 11111x is the only combination

     * not covered by one of the above options; this is reserved.

     * Further, <length of run - 1> all-ones is a reserved pattern.

     *

     * In all cases the rotation is by immr % e (and immr is 6 bits).

     */



    /* First determine the element size */

    len = 31 - clz32((immn << 6) | (~imms & 0x3f));

    if (len < 1) {

        /* This is the immn == 0, imms == 0x11111x case */

        return false;

    }

    e = 1 << len;



    levels = e - 1;

    s = imms & levels;

    r = immr & levels;



    if (s == levels) {

        /* <length of run - 1> mustn't be all-ones. */

        return false;

    }



    /* Create the value of one element: s+1 set bits rotated

     * by r within the element (which is e bits wide)...

     */

    mask = bitmask64(s + 1);

    mask = (mask >> r) | (mask << (e - r));

    /* ...then replicate the element over the whole 64 bit value */

    mask = bitfield_replicate(mask, e);

    *result = mask;

    return true;

}

static bool logic_imm_decode_wmask(uint64_t *result, unsigned int immn,

                                   unsigned int imms, unsigned int immr)

{

    uint64_t mask;

    unsigned e, levels, s, r;

    int len;



    assert(immn < 2 && imms < 64 && immr < 64);



    









































    

    len = 31 - clz32((immn << 6) | (~imms & 0x3f));

    if (len < 1) {

        

        return false;

    }

    e = 1 << len;



    levels = e - 1;

    s = imms & levels;

    r = immr & levels;



    if (s == levels) {

        

        return false;

    }



    





    mask = bitmask64(s + 1);

    mask = (mask >> r) | (mask << (e - r));

    

    mask = bitfield_replicate(mask, e);

    *result = mask;

    return true;

}

    mask = (mask >> r) | (mask << (e - r));
static bool FUNC_0(uint64_t *result, unsigned int immn,

                                   unsigned int imms, unsigned int immr)

{

    uint64_t mask;

    unsigned VAR_0, VAR_1, VAR_2, VAR_3;

    int VAR_4;



    assert(immn < 2 && imms < 64 && immr < 64);



    









































    

    VAR_4 = 31 - clz32((immn << 6) | (~imms & 0x3f));

    if (VAR_4 < 1) {

        

        return false;

    }

    VAR_0 = 1 << VAR_4;



    VAR_1 = VAR_0 - 1;

    VAR_2 = imms & VAR_1;

    VAR_3 = immr & VAR_1;



    if (VAR_2 == VAR_1) {

        

        return false;

    }



    





    mask = bitmask64(VAR_2 + 1);

    mask = (mask >> VAR_3) | (mask << (VAR_0 - VAR_3));

    

    mask = bitfield_replicate(mask, VAR_0);

    *result = mask;

    return true;

}

static bool FUNC_0(uint64_t *result, unsigned int immn,
unsigned int imms, unsigned int immr)
{ uint64_t mask; unsigned VAR_0, VAR_1, VAR_2, VAR_3; int VAR_4; assert(immn < 2 && imms < 64 && immr < 64); VAR_4 = 31 - clz32((immn << 6) | (~imms & 0x3f)); if (VAR_4 < 1) { return false; } VAR_0 = 1 << VAR_4; VAR_1 = VAR_0 - 1; VAR_2 = imms & VAR_1; VAR_3 = immr & VAR_1; if (VAR_2 == VAR_1) { return false; } mask = bitmask64(VAR_2 + 1); mask = (mask >> VAR_3) | (mask << (VAR_0 - VAR_3)); mask = bitfield_replicate(mask, VAR_0); *result = mask; return true; }