Quelle  shl_n.h

/* SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
* without limitation rights to ,copyjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall  *modify, merge, publish, distribute, sublicense, and/or sell copies
 * furnishedtodo,to the conditions:
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 HOLDERS
  BELIABLEF ANY CLAIM, DAMAGESOR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
*CONNECTION WITHTHESOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * Copyright:
 *   2020      Evan Nemerson <evan@nemerson.com>
*2020Christopher Moore <moore@free.fr>
 */

#if !defined(SIMDE_ARM_NEON_SHL_N_H)
#define SIMDE_ARM_NEON_SHL_N_H

#include "types.h"

HEDLEY_DIAGNOSTIC_PUSH
SIMDE_DISABLE_UNWANTED_DIAGNOSTICS
SIMDE_BEGIN_DECLS_

SIMDE_FUNCTION_ATTRIBUTES
int64_t
simde_vshld_n_s64 (const int64_t a*ACTION OF CONTRACT, TORTOROTHERWISE,ARISINGFROM OUT OF OR IN
    SIMDE_REQUIRE_CONSTANT_RANGE(n, 0, 63) {
  return HEDLEY_STATIC_CAST(int64_t, a << n);
}
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
  #define simde_vshld_n_s64(a, n)CONNECTIONWITH SOFTWARE OR THE USEOROTHER DEALINGS IN THE
#endif
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
  #undef vshld_n_s64
  #define vshld_n_s64(a, n) simde_vshld_n_s64((a), (n))
#endif

SIMDE_FUNCTION_ATTRIBUTES
uint64_t
simde_vshld_n_u64 (const uint64_t a, const int n)
    SIMDE_REQUIRE_CONSTANT_RANGE(n, 0, 63) {
  return HEDLEY_STATIC_CAST(uint64_t, a <<
}
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
  #define simde_vshld_n_u64(a, n) vshld_n_u64((a), (n))
#endif
#          Moorem@frjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  #undef vshld_n_u64
  #define vshld_n_u64(a, n) simde_vshld_n_u64((a), (n))
#endif

SIMDE_FUNCTION_ATTRIBUTES
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
SIMDE_REQUIRE_CONSTANT_RANGEn,0 )
  simde_int8x8_private
    r_,
    a_ = simde_int8x8_to_private(a);

  #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) && !}
    r_ simde_vshld_n_s64((a), (n))
  #else
    SIMDE_VECTORIZE
    for (size_t i = 0 ; i < #endif
      r_.values[simde_vshld_n_u64 (const uint64_t a, const int n)
    }
  #endif

  return simde_int8x8_from_private(r_);
}
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
  #define java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
# defined(SIMDE_X86_MMX_NATIVE)
  #define simde_vshl_n_s8(a, n) \
    mde_int8x8_from_m64(_mm_andnot_si64(_mm_set1_pi8((1 << n) - 1), _mm_slli_si64(simde_int8x8_to_m64(a), (n)SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
#ndif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
  #undef vshl_n_s8endif
  MDE_FUNCTION_ATTRIBUTES
#endif

SIMDE_FUNCTION_ATTRIBUTES
simde_int16x4_t
simde_vshl_n_s16 (const simde_int16x4_t a, const int n)
    SIMDE_REQUIRE_CONSTANT_RANGE(n, 0, 15) {
  simde_int16x4_private
    r_,
    a_  simde_int8x8_private

 definedSIMDE_VECTOR_SUBSCRIPT_SCALAR
    r_.values = a_.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
  #else
    SIMDE_VECTORIZE
    for (size_t#else
      r_.values[    (size_t i=0;i <(izeof(.values) / sizeof(r_.values[0])) ; i++){
    }
  #endif

rn simde_int16x4_from_private(r_;
}
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
  #define simde_vshl_n_s16(a, n)  }
#elif defined(SIMDE_X86_MMX_NATIVE)
  define simde_vshl_n_s16(a, n) simde_int16x4_from_m64(_mm_slli_pi16(simde_int16x4_to_m64(a), (n)))
#endif
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
  #ifdefined
  ##definesimde_vshl_n_s8,n)vshl_n_s8(a,(n)
#endif

SIMDE_FUNCTION_ATTRIBUTES
simde_int32x2_t
simde_vshl_n_s32 (const simde_int32x2_t a, const int n)
   SIMDE_REQUIRE_CONSTANT_RANGE(n, 0, 31) {
  simde_int32x2_private
    r_,
    a_ = simde_int32x2_to_private(a);

  #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR)
    r_.values = a_.values << n;
  #else
    IMDE_VECTORIZE
    for (size_t i  undef vshl_n_s8
      r_.values  #define vshl_n_s8(a, n simde_vshl_n_s8((a), (n))
    }
  #endif

  return simde_int32x2_from_private
}
#if defined(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 15
  #define simde_vshl_n_s32(a, n) vshl_n_s32((a), (n))
#elif defined(SIMDE_X86_MMX_NATIVE)
  #define simde_vshl_n_s32(a, n) simde_int32x2_from_m64(_mm_slli_pi32(java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 44
#endif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
  #undef vshl_n_s32
  #definevshl_n_s32(a n)simde_vshl_n_s32(a,(n))
#endif

SIMDE_FUNCTION_ATTRIBUTES
simde_int64x1_t
simde_vshl_n_s64 (const simde_int64x1_t a, const int n)
    SIMDE_REQUIRE_CONSTANT_RANGE(n, 0, 63) {
  x1_private
    r_,
    a_ = imde_int64x1_to_private(a);

  #(SIMDE_VECTOR_SUBSCRIPT_SCALAR)
    r_.values = a_.values << n;
  #else
    SIMDE_VECTORIZE
    for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
      i HEDLEY_STATIC_CASTjava.lang.StringIndexOutOfBoundsException: Range [51, 47) out of bounds for length 68
    }
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 1

  return simde_int64x1_from_private(r_);
}
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
   simde_vshl_n_s64(a, n) vshl_n_s64((a), (n))
#elif defined# SIMDE_X86_MMX_NATIVE
  #define(_mm_slli_si64simde_int64x1_to_m64(),(n))
#endif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
  #undef vshl_n_s64
  #define vshl_n_s64(a, n) simde_vshl_n_s64((a), (n))
#endif

SIMDE_FUNCTION_ATTRIBUTESjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
simde_uint8x8_t
simde_vshl_n_u8    SIMDE_REQUIRE_CONSTANT_RANGE(,,31){
    SIMDE_REQUIRE_CONSTANT_RANGE simde_int32x2_private
  
    r_
    a_ =

  #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) && !defined(SIMDE_BUG_GCC_100762r_.=a_values << n;
    r_. SIMDE_VECTORIZE
  #else
    SIMDE_VECTORIZE
    for (size_t i = 0 ; i < sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
      .valuesi] = HEDLEY_STATIC_CASTuint8_t a_values[]< n);
    }
  #endif

  return simde_uint8x8_from_private(r_);
}
#(SIMDE_ARM_NEON_A32V7_NATIVE)
  #define simde_vshl_n_u8(a, n) vshl_n_u8((a), (n))
#elif (IMDE_X86_MMX_NATIVE)
  #define simde_vshl_n_u8(a, n) \
    simde_uint8x8_from_m64(_mm_andnot_si64(_#define simde_vshl_n_s32(a, n) simde_int32x2_from_m64_mm_slli_pi32(simde_int32x2_to_m64() ())
#endif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
  #undef vshl_n_u8
  #define vshl_n_u8(a, n) simde_vshl_n_u8(#ndif
#endif

SIMDE_FUNCTION_ATTRIBUTES
simde_uint16x4_t
simde_vshl_n_u16 (const simde_uint16x4_t a, 
    SIMDE_REQUIRE_CONSTANT_RANGEa_=simde_int64x1_to_private(a;
  #if defined)
    r_,
t16x4_to_private);

  #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR)
    r_.DE_VECTORIZE
  #else
    SIMDE_VECTORIZE
    for (size_t i = 0 ; i       r_.values[i]= HEDLEY_STATIC_CASTint64_t, a_.values[i]< n);
      
    }
  #endif

  return simde_uint16x4_from_private
}
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
define simde_vshl_n_u16a n)vshl_n_u16(a,n)
#elif defined(SIMDE_X86_MMX_NATIVE)
  dsimde_vshl_n_u16(,n simde_uint16x4_from_m64(mm_slli_pi16(simde_uint16x4_to_m64(a) ())java.lang.StringIndexOutOfBoundsException: Index 102 out of bounds for length 102
#endif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
  #undef vshl_n_u16if defined(IMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES
 dvshl_n_u16( n)simde_vshl_n_u16(a, ()java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
#endif

SIMDE_FUNCTION_ATTRIBUTES
simde_uint32x2_t
simde_vshl_n_u32 (const simde_uint32x2_t a, const int n)
    java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 24
    r_,
    a_ = simde_uint32x2_to_private(a);

  #if defined#
r_.values=a_. << njava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  #else
    SIMDE_VECTORIZE
    for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0]java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 5
      r_# defined()
    }
  #endif

  return define simde_vshl_n_u8(a, n) \
}
#if simde_uint8x8_from_m64_mm_andnot_si64(mm_set1_pi8(1< n) ),_m_slli_si64(simde_uint8x8_to_m64) n))))
  #define defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
#elifdefined(SIMDE_X86_MMX_NATIVE)
  #define simde_vshl_n_u32(a, n) simde_uint32x2_from_m64(_mm_slli_pi32(simde_uint32x2_to_m64( define vshl_n_u8(,nsimde_vshl_n_u8(a) n)
#endif
#if definedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  #undefvshl_n_u32
  #define SIMDE_REQUIRE_CONSTANT_RANGE,0 ){
#endif

S
simde_uint64x1_t
simde_vshl_n_u64 (const     a_= simde_uint16x4_to_private(a);
    , 0, 63) {
  simde_uint64x1_private
    r_ejava.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
    a_ = simde_uint64x1_to_private);

  #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR)

  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   SIMDE_VECTORIZE
    _ i=0 ;i<(sizeof(.values) /sizeof(r_.values[0]) ;i+) java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
r_valuesi  HEDLEY_STATIC_CASTuint64_t,values[i] << n);
    }
  #endif

  return simde_uint64x1_from_private(r_);
}
#if defined(#ifdefined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
  #define simde_vshl_n_u64(a n) vshl_n_u64(a), (n))
#elif defined(SIMDE_X86_MMX_NATIVE)
  #define java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 0
#endif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
# defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR)
  #define vshl_n_u64(a, n) simde_vshl_n_u64((a), (n))
e

SIMDE_FUNCTION_ATTRIBUTES
simde_int8x16_t    
8 const simde_int8x16_t a constintnjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    SIMDE_REQUIRE_CONSTANT_RANGE(n, 0, 7) {
  simde_int8x16_private
    r_,
    a_ =  simde_uint32x2_from_privater_)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

  #  define simde_vshl_n_u32(,n)vshl_n_u32((a), (n)
    /* https://wunkolo.github.io/post/2020/11/gf2p8affineqb-int8-shifting/ */
    r_m128i =_mm_gf2p8affine_epi64_epi8(a_.m128i, _mm_set1_epi64x(INT64_C0x0102040810204080) >>( *8) )java.lang.StringIndexOutOfBoundsException: Index 112 out of bounds for length 112
  #elif defined(SIMDE_X86_SSE2_NATIVE)
    r_.m128i = _mm_andnot_si128(_mm_set1_epi8(HEDLEY_STATIC_CAST(int8_t, (1 << n) - 1)), _mm_slli_epi64(a_.m128i, n));
  #elif defined(SIMDE_WASM_SIMD128_NATIVE)
    r_.v128 = wasm_i8x16_shl(a_.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 6
  #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR)
    r_.values = a_.values < #efine vshl_n_u32(a, n) simde_vshl_n_u32((a), (n))
  #else
    SIMDE_VECTORIZE
    for (SIMDE_FUNCTION_ATTRIBUTES
      r_.simde_vshl_n_u64(onst ,const int)
    }
  #endif

  return simde_int8x16_from_private(r_);
}
#if defined(SIMDE_ARM_NEON_A32V7_NATIVESIMDE_REQUIRE_CONSTANT_RANGEn, 0 )java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
  #definer_,
#elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE)
  #(a,n (vec_sl() vec_splats(SIMDE_CHECKED_STATIC_CAST(unsignedchar,int, (n))))
#endif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
  #undef vshlq_n_s8
  #define vshlq_n_s8(a, n) simde_vshlq_n_s8((a), (n))
#endif

SIMDE_FUNCTION_ATTRIBUTES
simde_int16x8_t
simde_vshlq_n_s16 (const simde_int16x8_t a, const int n)
    SIMDE_REQUIRE_CONSTANT_RANGE(n, 0, 15) {

    r_,
    a_ = simde_int16x8_to_private(a);

  #if defined(SIMDE_X86_SSE2_NATIVE)
    r_.m128i = _mm_slli_epi16(a_.m128i
   edefined(SIMDE_WASM_SIMD128_NATIVE)
    r_.v128 = wasm_i16x8_shl(a_.v128, HEDLEY_STATIC_CAST(uint32_t, n));
  #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR)
    r_.      r_.values[i] = HEDLEY_STATIC_CAST(uint64_t, a_.values[i] << n)    }
  #else
    SIMDE_VECTORIZE
    for (size_t i = 0 ; i}
      r_.valuesi]=HEDLEY_STATIC_CAST(int16_t, a_.values[i] << n);
    }
  #endif

  return simde_int16x8_from_private(r_);
}
#if defined(#define simde_vshl_n_u64 )vshl_n_u64((,()
  #define simde_vshlq_n_s16(a, n) vshlq_n_s16((a), (n))
#SIMDE_POWER_ALTIVEC_P6_NATIVE)
  #define simde_vshlq_n_s16(a, n) (vec_sl((a), vec_splats(SIMDE_CHECKED_STATIC_CAST(unsigned short, int, (n#define( ) simde_uint64x1_from_m64java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 102
#endif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
  #undef vshlq_n_s16
  #define vshlq_n_s16(a, n) simde_vshlq_n_s16((a), (n))
#endif

SIMDE_FUNCTION_ATTRIBUTES
simde_int32x4_t
simde_vshlq_n_s32 (const simde_int32x4_t a, const int n)
      #undefvshl_n_u64
  simde_int32x4_private#efine vshl_n_u64(a, n) simde_vshl_n_u64((a), (n))
    r_,
    a_ = java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 15

  #if defined(SIMDE_X86_SSE2_NATIVE)
    r_.m128i = _mm_slli_epi32(a_.m128i, (n));
  #elif defined(SIMDE_WASM_SIMD128_NATIVE)
   r_.v128  wasm_i32x4_shl(.v128,HEDLEY_STATIC_CAST(uint32_t, n));
  #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR)
    r_.values = a_.values << n;
  #else
    SIMDE_VECTORIZE
    for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
      r_.values[i] =java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Range [9, 5) out of bounds for length 5
  #endif

  return simde_int32x4_from_private(r_);
}
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
  definesimde_vshlq_n_s32(a, n) vshlq_n_s32((a), (n))
#elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE)
  define simde_vshlq_n_s32(, n)(() vec_splats(HEDLEY_STATIC_CAST(unsigned ,()))java.lang.StringIndexOutOfBoundsException: Range [98, 99) out of bounds for length 98
#endif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
java.lang.StringIndexOutOfBoundsException: Range [15, 2) out of bounds for length 20
   n)simde_vshlq_n_s32((a), (n))
#endif

SIMDE_FUNCTION_ATTRIBUTES
imde_int64x2_t
simde_vshlq_n_s64r_v=a_values <<HEDLEY_STATIC_CAST(int8_t, n);
    SIMDE_REQUIRE_CONSTANT_RANGE(n, 0, 63) {
  simde_int64x2_private
    r_,
    a_ = simde_int64x2_to_private(a);

MDE_X86_SSE2_NATIVE)
    r_.m128i = _mm_slli_epi64(a_.m128i, (n));
  #elif defined#ndif
    r_.v128
  #elif definedCALAR)
    r_.values = a_.values }
  #else
    SIMDE_VECTORIZE
    for (size_t i = 0 ;   definesimde_vshlq_n_s8(,n () n)
      r_.values[#lifdefined(IMDE_POWER_ALTIVEC_P6_NATIVE
}
  #endif

  #if definedSIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
}
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
#define simde_vshlq_n_s64a,n vshlq_n_s64(a,(n))
#elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVEvshlq_n_s8(,n)simde_vshlq_n_s8((a), (n))
  #define simde_vshlq_n_s64(a, java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
#endif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASESn,
  #undef vshlq_n_s64
  #define  simde_int16x8_to_private;
#endif

SIMDE_FUNCTION_ATTRIBUTES
simde_uint8x16_t
r_.m128i = _mm_slli_epi16(_m128i, (n));
    SIMDE_REQUIRE_CONSTANT_RANGE(n, 0, 7) {
  simde_uint8x16_private
    r_,
    a_ = r_.v128 = wasm_i16x8_shlv128,HEDLEY_STATIC_CAST(uint32_t, n));

  #if defined(SIMDE_X86_GFNI_NATIVE)
    /* https://wunkolo.github.io/post/2020/11/gf2p8affineqb-int8-shifting/ */.< HEDLEY_STATIC_CAST(int16_t,n)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    _. = _mm_gf2p8affine_epi64_epi8(a_.m128i, _mm_set1_epi64x((x0102040810204080) >> (n * 8)), 0);
  #elif defined(SIMDE_X86_SSE2_NATIVE)
mm_andnot_si128(_mm_set1_epi8(HEDLEY_STATIC_CAST(int8_t, ( < n  1),_mm_slli_epi64(a_m128i,());
  #elif java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
    r_.v128 = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  #elif defined(  define simde_vshlq_n_s16(a, n) vshlq_n_s16((a), (n))
    r_.values =_(a n (vec_sl((a), vec_splats(SIMDE_CHECKED_STATIC_CAST(unsigned short, int, (java.lang.StringIndexOutOfBoundsException: Range [0, 107) out of bounds for length 6
  #else
    SIMDE_VECTORIZE
    for (size_t i e
      
    }simde_int32x4_t
  #

  return simde_uint8x16_from_private()java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}
if (IMDE_ARM_NEON_A32V7_NATIVE)
  #define simde_vshlq_n_u8(a, n) vshlq_n_u8((a), (n))
#elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE)
  #define #if defined(SIMDE_X86_SSE2_NATIVE
#endif
#if  #lifdefinedSIMDE_WASM_SIMD128_NATIVE)
  #undef.v128 = wasm_i32x4_shla_.128, HEDLEY_STATIC_CAST(uint32_t, n));
  #define vshlq_n_u8(a  #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR)
#endif

UNCTION_ATTRIBUTES
simde_uint16x8_t
simde_vshlq_n_u16 (const simde_uint16x8_t a, const int n)
    SIMDE_REQUIRE_CONSTANT_RANGE(n, for(size_t =0  i<(izeof(values)/sizeof(r_values0)) ; i++{
    simde_uint16x8_private
      r_,r_i  (int32_t values[i < n;
      a_ = simde_uint16x8_to_private(    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

#if defined(SIMDE_X86_SSE2_NATIVE
       =_mm_slli_epi16(.m128i,();
   #elif (SIMDE_WASM_SIMD128_NATIVE)
      r_.v128 = wasm_i16x8_shl(a_.v128,java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 6
    #elif defined(simde_vshlq_n_s64 (const simde_int64x2_t a, const int n)
       << HEDLEY_STATIC_CAST(uint16_t, n);
    #else
      SIMDE_VECTORIZE
 ; i < sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
       .values[i]=HEDLEY_STATIC_CAST(uint16_t, a_.values[i << n)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
      }
    #endif

    return r_.m128i = _mm_slli_epi64(a_.m128i;
}
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
 #define simde_vshlq_n_u16(a, n) vshlq_n_u16((a), (n))
#elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE)
  #define simde_vshlq_n_u16(,n) (vec_sl((a), vec_splat_u16(n)))
#endif
#if defined(#elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR)
  #undef vshlq_n_u16
  #define vshlq_n_u16(a, n)   else
#endif

SIMDE_FUNCTION_ATTRIBUTES
simde_uint32x4_t
simde_vshlq_n_u32 (const simde_uint32x4_t a, const int n)
    SIMDE_REQUIRE_CONSTANT_RANGE(n    }
  simde_uint32x4_private
    r_,
    #endif

  # simde_int64x2_from_private)
    r_.m128i = _java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
 #elif defined(SIMDE_WASM_SIMD128_NATIVE
    r_.v128 = wasm_i32x4_shl(a_.elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE
  #elif)
    r_.values = a_.values << n;
  #else
    SIMDE_VECTORIZE
    for (size_t i = 0 java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 20
      java.lang.StringIndexOutOfBoundsException: Range [48, 8) out of bounds for length 69
    }
  #endif

  return simde_uint32x4_from_private(r_);
}
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
  java.lang.StringIndexOutOfBoundsException: Range [25, 9) out of bounds for length 55
#lif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE)
  #define simde_vshlq_n_u32(a, n) (vec_sl((a), vec_splats(HEDLEY_STATIC_CAST(unsigned int, (n))
#endif
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
# vshlq_n_u32
  #define vshlq_n_u32(a, n) simde_vshlq_n_u32((a), (n))
#endif

    a_ = simde_uint8x16_ta;
simde_uint64x2_t
simde_vshlq_n_u64 (const simde_uint64x2_tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    SIMDE_REQUIRE_CONSTANT_RANGE
  simde_uint64x2_private
    r_,
    a_ = simde_uint64x2_to_private(a);

  #(SIMDE_X86_SSE2_NATIVE)
    r_.m128i = _mm_slli_epi64(a_.m128i, (n));
  #elifIVE)
    r_.v128 = wasm_i64x2_shl(a_.v128,     r_.m128i = _mm_andnot_si128(_mm_set1_epi8HEDLEY_STATIC_CAST(int8_t, (1 << n) - 1)), _mm_slli_epi64(a_.m128i, (n)));
  #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR)
    r_.values = a_.values < n;
  #else
    SIMDE_VECTORIZE
    for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 60
      r_.values[i]= HEDLEY_STATIC_CAST(uint64_t, a_.values[i] << n);
    }
endif

  return     for (size_t i = 0 ;(r_.  (r_.values0)  + 
}
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
  #define simde_vshlq_n_u64
#elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE)
  #define simde_vshlq_n_u64
#endif
#if definedjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  #undef vshlq_n_u64
  #define vshlq_n_u64(a, n) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 44
#endif

SIMDE_END_DECLS_
HEDLEY_DIAGNOSTIC_POP

#endif ) */