From 47ad7f1f301a18d2cd4093eabccc8ac3e8abbd63 Mon Sep 17 00:00:00 2001 From: jlsantiago Date: Mon, 6 Nov 2023 22:03:24 +0100 Subject: [PATCH 01/18] MacOS Intel Build --- .github/workflows/compile.yml | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/.github/workflows/compile.yml b/.github/workflows/compile.yml index 26de28b54..c8ef49f78 100644 --- a/.github/workflows/compile.yml +++ b/.github/workflows/compile.yml @@ -145,8 +145,10 @@ jobs: fail-fast: true matrix: include: - - build: 'metal' + - build: 'arm64' defines: '-DCMAKE_OSX_ARCHITECTURES=arm64' + - build: 'x86_64' + defines: '-DCMAKE_OSX_ARCHITECTURES=x86_64' runs-on: macos-latest steps: - uses: actions/checkout@v3 @@ -210,9 +212,13 @@ jobs: - name: Rearrange MacOS files if: ${{ github.event.inputs.macos }} run: | - mkdir deps/macos-metal - cp artifacts/llama-bin-macos-metal.dylib/libllama.dylib deps/macos-metal/libllama.dylib - cp artifacts/ggml-metal.metal/ggml-metal.metal deps/macos-metal/ggml-metal.metal + mkdir deps/macos-arm64 + mkdir deps/macos-x86_64 + + cp artifacts/llama-bin-macos-arm64.dylib/libllama.dylib deps/macos-arm64/libllama.dylib + cp artifacts/ggml-metal.metal/ggml-metal.metal deps/macos-arm64/ggml-metal.metal + cp artifacts/llama-bin-macos-x86_64.dylib/libllama.dylib deps/macos-x86_64/libllama.dylib + cp artifacts/ggml-metal.metal/ggml-metal.metal deps/macos-x86_64/ggml-metal.metal - name: Rearrange CUDA files if: ${{ github.event.inputs.cublas }} From d1244332ed68450f782810c1f85fa9b11ab5be76 Mon Sep 17 00:00:00 2001 From: SignalRT Date: Mon, 6 Nov 2023 23:03:50 +0100 Subject: [PATCH 02/18] MacOS Runtime detection and clasification Create different paths to different MacOS platforms. Dynamically load the right library --- LLama/LLamaSharp.Runtime.targets | 18 +- LLama/Native/NativeApi.cs | 4 +- .../{ => macos-arm64}/ggml-metal.metal | 0 .../runtimes/{ => macos-arm64}/libllama.dylib | Bin LLama/runtimes/macos-x86_64/ggml-metal.metal | 2823 +++++++++++++++++ LLama/runtimes/macos-x86_64/libllama.dylib | Bin 0 -> 981616 bytes 6 files changed, 2839 insertions(+), 6 deletions(-) rename LLama/runtimes/{ => macos-arm64}/ggml-metal.metal (100%) rename LLama/runtimes/{ => macos-arm64}/libllama.dylib (100%) create mode 100644 LLama/runtimes/macos-x86_64/ggml-metal.metal create mode 100644 LLama/runtimes/macos-x86_64/libllama.dylib diff --git a/LLama/LLamaSharp.Runtime.targets b/LLama/LLamaSharp.Runtime.targets index 8910f1551..3b2acc30e 100644 --- a/LLama/LLamaSharp.Runtime.targets +++ b/LLama/LLamaSharp.Runtime.targets @@ -27,13 +27,21 @@ PreserveNewest libllama-cuda12.so - + PreserveNewest - libllama.dylib + runtimes/macos-arm64/libllama.dylib - + PreserveNewest - ggml-metal.metal - + runtimes/macos-arm64/ggml-metal.metal + + + PreserveNewest + runtimes/macos-x86_64/libllama.dylib + + + PreserveNewest + runtimes/macos-x86_64/ggml-metal.metal + \ No newline at end of file diff --git a/LLama/Native/NativeApi.cs b/LLama/Native/NativeApi.cs index e3b182bd4..119a36fb8 100644 --- a/LLama/Native/NativeApi.cs +++ b/LLama/Native/NativeApi.cs @@ -79,7 +79,9 @@ private static IntPtr TryLoadLibrary() if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { - return IntPtr.Zero; + return TryLoad("runtimes/macos-arm64/libllama.dylib", System.Runtime.Intrinsics.Arm.ArmBase.Arm64.IsSupported) + ?? TryLoad("runtimes/macos-x86_64/libllama.dylib") + ?? IntPtr.Zero; } #endif diff --git a/LLama/runtimes/ggml-metal.metal b/LLama/runtimes/macos-arm64/ggml-metal.metal similarity index 100% rename from LLama/runtimes/ggml-metal.metal rename to LLama/runtimes/macos-arm64/ggml-metal.metal diff --git a/LLama/runtimes/libllama.dylib b/LLama/runtimes/macos-arm64/libllama.dylib similarity index 100% rename from LLama/runtimes/libllama.dylib rename to LLama/runtimes/macos-arm64/libllama.dylib diff --git a/LLama/runtimes/macos-x86_64/ggml-metal.metal b/LLama/runtimes/macos-x86_64/ggml-metal.metal new file mode 100644 index 000000000..7c35f23a7 --- /dev/null +++ b/LLama/runtimes/macos-x86_64/ggml-metal.metal @@ -0,0 +1,2823 @@ +#include + +using namespace metal; + +#define MAX(x, y) ((x) > (y) ? (x) : (y)) + +#define QK4_0 32 +#define QR4_0 2 +typedef struct { + half d; // delta + uint8_t qs[QK4_0 / 2]; // nibbles / quants +} block_q4_0; + +#define QK4_1 32 +typedef struct { + half d; // delta + half m; // min + uint8_t qs[QK4_1 / 2]; // nibbles / quants +} block_q4_1; + +#define QK5_0 32 +typedef struct { + half d; // delta + uint8_t qh[4]; // 5-th bit of quants + uint8_t qs[QK5_0 / 2]; // nibbles / quants +} block_q5_0; + +#define QK5_1 32 +typedef struct { + half d; // delta + half m; // min + uint8_t qh[4]; // 5-th bit of quants + uint8_t qs[QK5_1 / 2]; // nibbles / quants +} block_q5_1; + +#define QK8_0 32 +typedef struct { + half d; // delta + int8_t qs[QK8_0]; // quants +} block_q8_0; + +// general-purpose kernel for addition of two tensors +// pros: works for non-contiguous tensors, supports broadcast across dims 1, 2 and 3 +// cons: not very efficient +kernel void kernel_add( + device const char * src0, + device const char * src1, + device char * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant int64_t & nb00, + constant int64_t & nb01, + constant int64_t & nb02, + constant int64_t & nb03, + constant int64_t & ne10, + constant int64_t & ne11, + constant int64_t & ne12, + constant int64_t & ne13, + constant int64_t & nb10, + constant int64_t & nb11, + constant int64_t & nb12, + constant int64_t & nb13, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant int64_t & nb0, + constant int64_t & nb1, + constant int64_t & nb2, + constant int64_t & nb3, + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + const int64_t i03 = tgpig.z; + const int64_t i02 = tgpig.y; + const int64_t i01 = tgpig.x; + + const int64_t i13 = i03 % ne13; + const int64_t i12 = i02 % ne12; + const int64_t i11 = i01 % ne11; + + device const char * src0_ptr = src0 + i03*nb03 + i02*nb02 + i01*nb01 + tpitg.x*nb00; + device const char * src1_ptr = src1 + i13*nb13 + i12*nb12 + i11*nb11 + tpitg.x*nb10; + device char * dst_ptr = dst + i03*nb3 + i02*nb2 + i01*nb1 + tpitg.x*nb0; + + for (int i0 = tpitg.x; i0 < ne0; i0 += ntg.x) { + ((device float *)dst_ptr)[0] = ((device float *)src0_ptr)[0] + ((device float *)src1_ptr)[0]; + + src0_ptr += ntg.x*nb00; + src1_ptr += ntg.x*nb10; + dst_ptr += ntg.x*nb0; + } +} + +// assumption: src1 is a row +// broadcast src1 into src0 +kernel void kernel_add_row( + device const float4 * src0, + device const float4 * src1, + device float4 * dst, + constant int64_t & nb [[buffer(27)]], + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = src0[tpig] + src1[tpig % nb]; +} + +kernel void kernel_mul( + device const float4 * src0, + device const float4 * src1, + device float4 * dst, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = src0[tpig] * src1[tpig]; +} + +// assumption: src1 is a row +// broadcast src1 into src0 +kernel void kernel_mul_row( + device const float4 * src0, + device const float4 * src1, + device float4 * dst, + constant int64_t & nb, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = src0[tpig] * src1[tpig % nb]; +} + +kernel void kernel_scale( + device const float * src0, + device float * dst, + constant float & scale, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = src0[tpig] * scale; +} + +kernel void kernel_scale_4( + device const float4 * src0, + device float4 * dst, + constant float & scale, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = src0[tpig] * scale; +} + +kernel void kernel_silu( + device const float4 * src0, + device float4 * dst, + uint tpig[[thread_position_in_grid]]) { + device const float4 & x = src0[tpig]; + dst[tpig] = x / (1.0f + exp(-x)); +} + +kernel void kernel_relu( + device const float * src0, + device float * dst, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = max(0.0f, src0[tpig]); +} + +kernel void kernel_sqr( + device const float * src0, + device float * dst, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = src0[tpig] * src0[tpig]; +} + +constant float GELU_COEF_A = 0.044715f; +constant float SQRT_2_OVER_PI = 0.79788456080286535587989211986876f; + +kernel void kernel_gelu( + device const float4 * src0, + device float4 * dst, + uint tpig[[thread_position_in_grid]]) { + device const float4 & x = src0[tpig]; + + // BEWARE !!! + // Simply using "tanh" instead of "precise::tanh" will sometimes results in NaNs! + // This was observed with Falcon 7B and 40B models + // + dst[tpig] = 0.5f*x*(1.0f + precise::tanh(SQRT_2_OVER_PI*x*(1.0f + GELU_COEF_A*x*x))); +} + +kernel void kernel_soft_max( + device const float * src0, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + threadgroup float * buf [[threadgroup(0)]], + uint tgpig[[threadgroup_position_in_grid]], + uint tpitg[[thread_position_in_threadgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]], + uint tiisg[[thread_index_in_simdgroup]], + uint ntg[[threads_per_threadgroup]]) { + const int64_t i03 = (tgpig) / (ne02*ne01); + const int64_t i02 = (tgpig - i03*ne02*ne01) / ne01; + const int64_t i01 = (tgpig - i03*ne02*ne01 - i02*ne01); + + device const float * psrc0 = src0 + i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + device float * pdst = dst + i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + + // parallel max + float lmax = tpitg < ne00 ? psrc0[tpitg] : -INFINITY; + + for (int i00 = tpitg + ntg; i00 < ne00; i00 += ntg) { + lmax = MAX(lmax, psrc0[i00]); + } + + float max = simd_max(lmax); + if (tiisg == 0) { + buf[sgitg] = max; + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + // broadcast, simd group number is ntg / 32 + for (uint i = ntg / 32 / 2; i > 0; i /= 2) { + if (tpitg < i) { + buf[tpitg] = MAX(buf[tpitg], buf[tpitg + i]); + } + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + max = buf[0]; + + // parallel sum + float lsum = 0.0f; + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + const float exp_psrc0 = exp(psrc0[i00] - max); + lsum += exp_psrc0; + // Remember the result of exp here. exp is expensive, so we really do not + // wish to compute it twice. + pdst[i00] = exp_psrc0; + } + + float sum = simd_sum(lsum); + if (tiisg == 0) { + buf[sgitg] = sum; + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + // broadcast, simd group number is ntg / 32 + for (uint i = ntg / 32 / 2; i > 0; i /= 2) { + if (tpitg < i) { + buf[tpitg] += buf[tpitg + i]; + } + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + sum = buf[0]; + + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + pdst[i00] /= sum; + } +} + +kernel void kernel_soft_max_4( + device const float * src0, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + threadgroup float * buf [[threadgroup(0)]], + uint tgpig[[threadgroup_position_in_grid]], + uint tpitg[[thread_position_in_threadgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]], + uint tiisg[[thread_index_in_simdgroup]], + uint ntg[[threads_per_threadgroup]]) { + const int64_t i03 = (tgpig) / (ne02*ne01); + const int64_t i02 = (tgpig - i03*ne02*ne01) / ne01; + const int64_t i01 = (tgpig - i03*ne02*ne01 - i02*ne01); + + device const float4 * psrc4 = (device const float4 *)(src0 + i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00); + device float4 * pdst4 = (device float4 *)(dst + i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00); + + // parallel max + float4 lmax4 = tpitg < ne00/4 ? psrc4[tpitg] : -INFINITY; + + for (int i00 = tpitg + ntg; i00 < ne00/4; i00 += ntg) { + lmax4 = fmax(lmax4, psrc4[i00]); + } + + const float lmax = MAX(MAX(lmax4[0], lmax4[1]), MAX(lmax4[2], lmax4[3])); + float max = simd_max(lmax); + if (tiisg == 0) { + buf[sgitg] = max; + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + // broadcast, simd group number is ntg / 32 + for (uint i = ntg / 32 / 2; i > 0; i /= 2) { + if (tpitg < i) { + buf[tpitg] = MAX(buf[tpitg], buf[tpitg + i]); + } + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + max = buf[0]; + + // parallel sum + float4 lsum4 = 0.0f; + for (int i00 = tpitg; i00 < ne00/4; i00 += ntg) { + const float4 exp_psrc4 = exp(psrc4[i00] - max); + lsum4 += exp_psrc4; + pdst4[i00] = exp_psrc4; + } + + const float lsum = lsum4[0] + lsum4[1] + lsum4[2] + lsum4[3]; + float sum = simd_sum(lsum); + if (tiisg == 0) { + buf[sgitg] = sum; + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + // broadcast, simd group number is ntg / 32 + for (uint i = ntg / 32 / 2; i > 0; i /= 2) { + if (tpitg < i) { + buf[tpitg] += buf[tpitg + i]; + } + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + sum = buf[0]; + + for (int i00 = tpitg; i00 < ne00/4; i00 += ntg) { + pdst4[i00] /= sum; + } +} + +kernel void kernel_diag_mask_inf( + device const float * src0, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int & n_past, + uint3 tpig[[thread_position_in_grid]]) { + const int64_t i02 = tpig[2]; + const int64_t i01 = tpig[1]; + const int64_t i00 = tpig[0]; + + if (i00 > n_past + i01) { + dst[i02*ne01*ne00 + i01*ne00 + i00] = -INFINITY; + } else { + dst[i02*ne01*ne00 + i01*ne00 + i00] = src0[i02*ne01*ne00 + i01*ne00 + i00]; + } +} + +kernel void kernel_diag_mask_inf_8( + device const float4 * src0, + device float4 * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int & n_past, + uint3 tpig[[thread_position_in_grid]]) { + + const int64_t i = 2*tpig[0]; + + dst[i+0] = src0[i+0]; + dst[i+1] = src0[i+1]; + int64_t i4 = 4*i; + const int64_t i02 = i4/(ne00*ne01); i4 -= i02*ne00*ne01; + const int64_t i01 = i4/(ne00); i4 -= i01*ne00; + const int64_t i00 = i4; + for (int k = 3; k >= 0; --k) { + if (i00 + 4 + k <= n_past + i01) { + break; + } + dst[i+1][k] = -INFINITY; + if (i00 + k > n_past + i01) { + dst[i][k] = -INFINITY; + } + } +} + +kernel void kernel_norm( + device const void * src0, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant float & eps, + threadgroup float * sum [[threadgroup(0)]], + uint tgpig[[threadgroup_position_in_grid]], + uint tpitg[[thread_position_in_threadgroup]], + uint ntg[[threads_per_threadgroup]]) { + device const float * x = (device const float *) ((device const char *) src0 + tgpig*nb01); + // MEAN + // parallel sum + sum[tpitg] = 0.0f; + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + sum[tpitg] += x[i00]; + } + // reduce + threadgroup_barrier(mem_flags::mem_threadgroup); + for (uint i = ntg/2; i > 0; i /= 2) { + if (tpitg < i) { + sum[tpitg] += sum[tpitg + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + } + const float mean = sum[0] / ne00; + + // recenter and VARIANCE + threadgroup_barrier(mem_flags::mem_threadgroup); + device float * y = dst + tgpig*ne00; + sum[tpitg] = 0.0f; + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + y[i00] = x[i00] - mean; + sum[tpitg] += y[i00] * y[i00]; + } + + // reduce + threadgroup_barrier(mem_flags::mem_threadgroup); + for (uint i = ntg/2; i > 0; i /= 2) { + if (tpitg < i) { + sum[tpitg] += sum[tpitg + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + } + const float variance = sum[0] / ne00; + + const float scale = 1.0f/sqrt(variance + eps); + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + y[i00] = y[i00] * scale; + } +} + +kernel void kernel_rms_norm( + device const void * src0, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant float & eps, + threadgroup float * sum [[threadgroup(0)]], + uint tgpig[[threadgroup_position_in_grid]], + uint tpitg[[thread_position_in_threadgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]], + uint tiisg[[thread_index_in_simdgroup]], + uint ntg[[threads_per_threadgroup]]) { + device const float4 * x = (device const float4 *) ((device const char *) src0 + tgpig*nb01); + device const float * x_scalar = (device const float *) x; + + float4 sumf = 0; + float all_sum = 0; + + // parallel sum + for (int i00 = tpitg; i00 < ne00/4; i00 += ntg) { + sumf += x[i00] * x[i00]; + } + all_sum = sumf[0] + sumf[1] + sumf[2] + sumf[3]; + all_sum = simd_sum(all_sum); + if (tiisg == 0) { + sum[sgitg] = all_sum; + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + // broadcast, simd group number is ntg / 32 + for (uint i = ntg / 32 / 2; i > 0; i /= 2) { + if (tpitg < i) { + sum[tpitg] += sum[tpitg + i]; + } + } + if (tpitg == 0) { + for (int i = 4 * (ne00 / 4); i < ne00; i++) { + sum[0] += x_scalar[i]; + } + sum[0] /= ne00; + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + const float mean = sum[0]; + const float scale = 1.0f/sqrt(mean + eps); + + device float4 * y = (device float4 *) (dst + tgpig*ne00); + device float * y_scalar = (device float *) y; + for (int i00 = tpitg; i00 < ne00/4; i00 += ntg) { + y[i00] = x[i00] * scale; + } + if (tpitg == 0) { + for (int i00 = 4 * (ne00 / 4); i00 < ne00; i00++) { + y_scalar[i00] = x_scalar[i00] * scale; + } + } +} + +// function for calculate inner product between half a q4_0 block and 16 floats (yl), sumy is SUM(yl[i]) +// il indicates where the q4 quants begin (0 or QK4_0/4) +// we assume that the yl's have been multiplied with the appropriate scale factor +// that corresponds to the missing bit shifts (1, 1/16, 1/256, 1/4096) +inline float block_q_n_dot_y(device const block_q4_0 * qb_curr, float sumy, thread float * yl, int il) { + float d = qb_curr->d; + + float2 acc = 0.f; + + device const uint16_t * qs = ((device const uint16_t *)qb_curr + 1 + il/2); + + for (int i = 0; i < 8; i+=2) { + acc[0] += yl[i + 0] * (qs[i / 2] & 0x000F) + + yl[i + 1] * (qs[i / 2] & 0x0F00); + acc[1] += yl[i + 8] * (qs[i / 2] & 0x00F0) + + yl[i + 9] * (qs[i / 2] & 0xF000); + } + return d * (sumy * -8.f + acc[0] + acc[1]); +} + +// function for calculate inner product between half a q4_1 block and 16 floats (yl), sumy is SUM(yl[i]) +// il indicates where the q4 quants begin (0 or QK4_0/4) +// we assume that the yl's have been multiplied with the appropriate scale factor +// that corresponds to the missing bit shifts (1, 1/16, 1/256, 1/4096) +inline float block_q_n_dot_y(device const block_q4_1 * qb_curr, float sumy, thread float * yl, int il) { + float d = qb_curr->d; + float m = qb_curr->m; + + float2 acc = 0.f; + + device const uint16_t * qs = ((device const uint16_t *)qb_curr + 2 + il/2); + + for (int i = 0; i < 8; i+=2) { + acc[0] += yl[i + 0] * (qs[i / 2] & 0x000F) + + yl[i + 1] * (qs[i / 2] & 0x0F00); + acc[1] += yl[i + 8] * (qs[i / 2] & 0x00F0) + + yl[i + 9] * (qs[i / 2] & 0xF000); + } + return d * (acc[0] + acc[1]) + sumy * m; +} + +// function for calculate inner product between half a q5_0 block and 16 floats (yl), sumy is SUM(yl[i]) +// il indicates where the q5 quants begin (0 or QK5_0/4) +// we assume that the yl's have been multiplied with the appropriate scale factor +// that corresponds to the missing bit shifts (1, 1/16, 1/256, 1/4096) +inline float block_q_n_dot_y(device const block_q5_0 * qb_curr, float sumy, thread float * yl, int il) { + float d = qb_curr->d; + + float2 acc = 0.f; + + device const uint16_t * qs = ((device const uint16_t *)qb_curr + 3 + il/2); + const uint32_t qh = *((device const uint32_t *)qb_curr->qh); + + for (int i = 0; i < 8; i+=2) { + acc[0] += yl[i + 0] * ((qs[i / 2] & 0x000F) | ((qh >> (i+0+il ) << 4 ) & 0x00010)) + + yl[i + 1] * ((qs[i / 2] & 0x0F00) | ((qh >> (i+1+il ) << 12) & 0x01000)); + acc[1] += yl[i + 8] * ((qs[i / 2] & 0x00F0) | ((qh >> (i+0+il+QK5_0/2) << 8 ) & 0x00100)) + + yl[i + 9] * ((qs[i / 2] & 0xF000) | ((qh >> (i+1+il+QK5_0/2) << 16) & 0x10000)); + } + return d * (sumy * -16.f + acc[0] + acc[1]); +} + +// function for calculate inner product between half a q5_1 block and 16 floats (yl), sumy is SUM(yl[i]) +// il indicates where the q5 quants begin (0 or QK5_1/4) +// we assume that the yl's have been multiplied with the appropriate scale factor +// that corresponds to the missing bit shifts (1, 1/16, 1/256, 1/4096) +inline float block_q_n_dot_y(device const block_q5_1 * qb_curr, float sumy, thread float * yl, int il) { + float d = qb_curr->d; + float m = qb_curr->m; + + float2 acc = 0.f; + + device const uint16_t * qs = ((device const uint16_t *)qb_curr + 4 + il/2); + const uint32_t qh = *((device const uint32_t *)qb_curr->qh); + + for (int i = 0; i < 8; i+=2) { + acc[0] += yl[i + 0] * ((qs[i / 2] & 0x000F) | ((qh >> (i+0+il ) << 4 ) & 0x00010)) + + yl[i + 1] * ((qs[i / 2] & 0x0F00) | ((qh >> (i+1+il ) << 12) & 0x01000)); + acc[1] += yl[i + 8] * ((qs[i / 2] & 0x00F0) | ((qh >> (i+0+il+QK5_0/2) << 8 ) & 0x00100)) + + yl[i + 9] * ((qs[i / 2] & 0xF000) | ((qh >> (i+1+il+QK5_0/2) << 16) & 0x10000)); + } + return d * (acc[0] + acc[1]) + sumy * m; +} + +// putting them in the kernel cause a significant performance penalty +#define N_DST 4 // each SIMD group works on 4 rows +#define N_SIMDGROUP 2 // number of SIMD groups in a thread group +#define N_SIMDWIDTH 32 // assuming SIMD group size is 32 +//Note: This is a template, but strictly speaking it only applies to +// quantizations where the block size is 32. It also does not +// giard against the number of rows not being divisible by +// N_DST, so this is another explicit assumption of the implementation. +template +void mul_vec_q_n_f32(device const void * src0, device const float * src1, device float * dst, + int64_t ne00, int64_t ne01, int64_t ne02, int64_t ne10, int64_t ne12, int64_t ne0, int64_t ne1, uint gqa, + uint3 tgpig, uint tiisg, uint sgitg) { + const int nb = ne00/QK4_0; + + const int r0 = tgpig.x; + const int r1 = tgpig.y; + const int im = tgpig.z; + + const int first_row = (r0 * nsg + sgitg) * nr; + + const uint offset0 = first_row * nb + im/gqa*(nb*ne0); + + device const block_q_type * x = (device const block_q_type *) src0 + offset0; + device const float * y = (device const float *) src1 + r1*ne10 + im*ne00*ne1; + + float yl[16]; // src1 vector cache + float sumf[nr] = {0.f}; + + const int ix = (tiisg/2); + const int il = (tiisg%2)*8; + + device const float * yb = y + ix * QK4_0 + il; + + // each thread in a SIMD group deals with half a block. + for (int ib = ix; ib < nb; ib += nw/2) { + float sumy = 0; + for (int i = 0; i < 8; i += 2) { + sumy += yb[i] + yb[i+1]; + yl[i+0] = yb[i+ 0]; + yl[i+1] = yb[i+ 1]/256.f; + + sumy += yb[i+16] + yb[i+17]; + yl[i+8] = yb[i+16]/16.f; + yl[i+9] = yb[i+17]/4096.f; + } + + for (int row = 0; row < nr; row++) { + sumf[row] += block_q_n_dot_y(x+ib+row*nb, sumy, yl, il); + } + + yb += QK4_0 * 16; + } + + for (int row = 0; row < nr; ++row) { + const float tot = simd_sum(sumf[row]); + if (tiisg == 0 && first_row + row < ne01) { + dst[im*ne0*ne1 + r1*ne0 + first_row + row] = tot; + } + } +} + +kernel void kernel_mul_mv_q4_0_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + mul_vec_q_n_f32(src0,src1,dst,ne00,ne01,ne02,ne10,ne12,ne0,ne1,gqa,tgpig,tiisg,sgitg); +} + +kernel void kernel_mul_mv_q4_1_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + mul_vec_q_n_f32(src0,src1,dst,ne00,ne01,ne02,ne10,ne12,ne0,ne1,gqa,tgpig,tiisg,sgitg); +} + +kernel void kernel_mul_mv_q5_0_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + mul_vec_q_n_f32(src0,src1,dst,ne00,ne01,ne02,ne10,ne12,ne0,ne1,gqa,tgpig,tiisg,sgitg); +} + +kernel void kernel_mul_mv_q5_1_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + mul_vec_q_n_f32(src0,src1,dst,ne00,ne01,ne02,ne10,ne12,ne0,ne1,gqa,tgpig,tiisg,sgitg); +} + + +#define NB_Q8_0 8 + +kernel void kernel_mul_mv_q8_0_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + const int nr = N_DST; + const int nsg = N_SIMDGROUP; + const int nw = N_SIMDWIDTH; + + const int nb = ne00/QK8_0; + const int r0 = tgpig.x; + const int r1 = tgpig.y; + const int im = tgpig.z; + const int first_row = (r0 * nsg + sgitg) * nr; + const uint offset0 = first_row * nb + im/gqa*(nb*ne0); + device const block_q8_0 * x = (device const block_q8_0 *) src0 + offset0; + device const float * y = (device const float *) src1 + r1*ne10 + im*ne00*ne1; + + float yl[NB_Q8_0]; + float sumf[nr]={0.f}; + + const int ix = tiisg/4; + const int il = tiisg%4; + + device const float * yb = y + ix * QK8_0 + NB_Q8_0*il; + + // each thread in a SIMD group deals with NB_Q8_0 quants at a time + for (int ib = ix; ib < nb; ib += nw/4) { + for (int i = 0; i < NB_Q8_0; ++i) { + yl[i] = yb[i]; + } + + for (int row = 0; row < nr; row++) { + device const int8_t * qs = x[ib+row*nb].qs + NB_Q8_0*il; + float sumq = 0.f; + for (int iq = 0; iq < NB_Q8_0; ++iq) { + sumq += qs[iq] * yl[iq]; + } + sumf[row] += sumq*x[ib+row*nb].d; + } + + yb += NB_Q8_0 * nw; + } + + for (int row = 0; row < nr; ++row) { + const float tot = simd_sum(sumf[row]); + if (tiisg == 0 && first_row + row < ne01) { + dst[r1*ne0 + im*ne0*ne1 + first_row + row] = tot; + } + } +} + +#define N_F32_F32 4 + +kernel void kernel_mul_mv_f32_f32( + device const char * src0, + device const char * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant int64_t & ne10, + constant int64_t & ne11, + constant int64_t & ne12, + constant uint64_t & nb10, + constant uint64_t & nb11, + constant uint64_t & nb12, + constant int64_t & ne0, + constant int64_t & ne1, + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]]) { + + const int64_t r0 = tgpig.x; + const int64_t rb = tgpig.y*N_F32_F32; + const int64_t im = tgpig.z; + + device const float * x = (device const float *) (src0 + r0*nb01 + im/(ne12/ne02)*nb02); + + if (ne00 < 128) { + for (int row = 0; row < N_F32_F32; ++row) { + int r1 = rb + row; + if (r1 >= ne11) { + break; + } + + device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); + + float sumf = 0; + for (int i = tiisg; i < ne00; i += 32) { + sumf += (float) x[i] * (float) y[i]; + } + + float all_sum = simd_sum(sumf); + if (tiisg == 0) { + dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; + } + } + } else { + device const float4 * x4 = (device const float4 *)x; + for (int row = 0; row < N_F32_F32; ++row) { + int r1 = rb + row; + if (r1 >= ne11) { + break; + } + + device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); + device const float4 * y4 = (device const float4 *) y; + + float sumf = 0; + for (int i = tiisg; i < ne00/4; i += 32) { + for (int k = 0; k < 4; ++k) sumf += (float) x4[i][k] * y4[i][k]; + } + + float all_sum = simd_sum(sumf); + if (tiisg == 0) { + for (int i = 4*(ne00/4); i < ne00; ++i) all_sum += (float) x[i] * y[i]; + dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; + } + } + } +} + +kernel void kernel_mul_mv_f16_f32_1row( + device const char * src0, + device const char * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant int64_t & ne10, + constant int64_t & ne11, + constant int64_t & ne12, + constant uint64_t & nb10, + constant uint64_t & nb11, + constant uint64_t & nb12, + constant int64_t & ne0, + constant int64_t & ne1, + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]]) { + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + const int64_t im = tgpig.z; + + device const half * x = (device const half *) (src0 + r0*nb01 + im/(ne12/ne02)*nb02); + device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); + + float sumf = 0; + if (ne00 < 128) { + for (int i = tiisg; i < ne00; i += 32) { + sumf += (float) x[i] * (float) y[i]; + } + float all_sum = simd_sum(sumf); + if (tiisg == 0) { + dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; + } + } else { + device const half4 * x4 = (device const half4 *) x; + device const float4 * y4 = (device const float4 *) y; + for (int i = tiisg; i < ne00/4; i += 32) { + for (int k = 0; k < 4; ++k) sumf += (float)x4[i][k] * y4[i][k]; + } + float all_sum = simd_sum(sumf); + if (tiisg == 0) { + for (int i = 4*(ne00/4); i < ne00; ++i) all_sum += (float) x[i] * y[i]; + dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; + } + } + +} + +#define N_F16_F32 4 + +kernel void kernel_mul_mv_f16_f32( + device const char * src0, + device const char * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant int64_t & ne10, + constant int64_t & ne11, + constant int64_t & ne12, + constant uint64_t & nb10, + constant uint64_t & nb11, + constant uint64_t & nb12, + constant int64_t & ne0, + constant int64_t & ne1, + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]]) { + + const int64_t r0 = tgpig.x; + const int64_t rb = tgpig.y*N_F16_F32; + const int64_t im = tgpig.z; + + device const half * x = (device const half *) (src0 + r0*nb01 + im/(ne12/ne02)*nb02); + + if (ne00 < 128) { + for (int row = 0; row < N_F16_F32; ++row) { + int r1 = rb + row; + if (r1 >= ne11) { + break; + } + + device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); + + float sumf = 0; + for (int i = tiisg; i < ne00; i += 32) { + sumf += (float) x[i] * (float) y[i]; + } + + float all_sum = simd_sum(sumf); + if (tiisg == 0) { + dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; + } + } + } else { + device const half4 * x4 = (device const half4 *)x; + for (int row = 0; row < N_F16_F32; ++row) { + int r1 = rb + row; + if (r1 >= ne11) { + break; + } + + device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); + device const float4 * y4 = (device const float4 *) y; + + float sumf = 0; + for (int i = tiisg; i < ne00/4; i += 32) { + for (int k = 0; k < 4; ++k) sumf += (float) x4[i][k] * y4[i][k]; + } + + float all_sum = simd_sum(sumf); + if (tiisg == 0) { + for (int i = 4*(ne00/4); i < ne00; ++i) all_sum += (float) x[i] * y[i]; + dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; + } + } + } +} + +// Assumes row size (ne00) is a multiple of 4 +kernel void kernel_mul_mv_f16_f32_l4( + device const char * src0, + device const char * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant int64_t & ne10, + constant int64_t & ne11, + constant int64_t & ne12, + constant uint64_t & nb10, + constant uint64_t & nb11, + constant uint64_t & nb12, + constant int64_t & ne0, + constant int64_t & ne1, + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]]) { + + const int nrows = ne11; + const int64_t r0 = tgpig.x; + const int64_t im = tgpig.z; + + device const half4 * x4 = (device const half4 *) (src0 + r0*nb01 + im/(ne12/ne02)*nb02); + + for (int r1 = 0; r1 < nrows; ++r1) { + device const float4 * y4 = (device const float4 *) (src1 + r1*nb11 + im*nb12); + + float sumf = 0; + for (int i = tiisg; i < ne00/4; i += 32) { + for (int k = 0; k < 4; ++k) sumf += (float) x4[i][k] * y4[i][k]; + } + + float all_sum = simd_sum(sumf); + if (tiisg == 0) { + dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; + } + } +} + +kernel void kernel_alibi_f32( + device const float * src0, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + constant float & m0, + constant float & m1, + constant int & n_heads_log2_floor, + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + const int64_t i03 = tgpig[2]; + const int64_t i02 = tgpig[1]; + const int64_t i01 = tgpig[0]; + + const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + + const int64_t i3 = n / (ne2*ne1*ne0); + const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); + const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; + const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); + + device float * dst_data = (device float *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + float m_k; + if (i2 < n_heads_log2_floor) { + m_k = pow(m0, i2 + 1); + } else { + m_k = pow(m1, 2 * (i2 - n_heads_log2_floor) + 1); + } + for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { + device const float * src = (device float *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); + dst_data[i00] = src[0] + m_k * (i00 - ne00 + 1); + } +} + +static float rope_yarn_ramp(const float low, const float high, const int i0) { + const float y = (i0 / 2 - low) / max(0.001f, high - low); + return 1.0f - min(1.0f, max(0.0f, y)); +} + +// YaRN algorithm based on LlamaYaRNScaledRotaryEmbedding.py from https://github.com/jquesnelle/yarn +// MIT licensed. Copyright (c) 2023 Jeffrey Quesnelle and Bowen Peng. +static void rope_yarn( + float theta_extrap, float freq_scale, float corr_dims[2], int64_t i0, float ext_factor, float mscale, + thread float * cos_theta, thread float * sin_theta +) { + // Get n-d rotational scaling corrected for extrapolation + float theta_interp = freq_scale * theta_extrap; + float theta = theta_interp; + if (ext_factor != 0.0f) { + float ramp_mix = rope_yarn_ramp(corr_dims[0], corr_dims[1], i0) * ext_factor; + theta = theta_interp * (1 - ramp_mix) + theta_extrap * ramp_mix; + + // Get n-d magnitude scaling corrected for interpolation + mscale *= 1.0f + 0.1f * log(1.0f / freq_scale); + } + *cos_theta = cos(theta) * mscale; + *sin_theta = sin(theta) * mscale; +} + +// Apparently solving `n_rot = 2pi * x * base^((2 * max_pos_emb) / n_dims)` for x, we get +// `corr_fac(n_rot) = n_dims * log(max_pos_emb / (n_rot * 2pi)) / (2 * log(base))` +static float rope_yarn_corr_factor(int n_dims, int n_orig_ctx, float n_rot, float base) { + return n_dims * log(n_orig_ctx / (n_rot * 2 * M_PI_F)) / (2 * log(base)); +} + +static void rope_yarn_corr_dims( + int n_dims, int n_orig_ctx, float freq_base, float beta_fast, float beta_slow, float dims[2] +) { + // start and end correction dims + dims[0] = max(0.0f, floor(rope_yarn_corr_factor(n_dims, n_orig_ctx, beta_fast, freq_base))); + dims[1] = min(n_dims - 1.0f, ceil(rope_yarn_corr_factor(n_dims, n_orig_ctx, beta_slow, freq_base))); +} + +typedef void (rope_t)( + device const void * src0, + device const int32_t * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + constant int & n_past, + constant int & n_dims, + constant int & mode, + constant int & n_orig_ctx, + constant float & freq_base, + constant float & freq_scale, + constant float & ext_factor, + constant float & attn_factor, + constant float & beta_fast, + constant float & beta_slow, + uint tiitg[[thread_index_in_threadgroup]], + uint3 tptg[[threads_per_threadgroup]], + uint3 tgpig[[threadgroup_position_in_grid]]); + +template +kernel void kernel_rope( + device const void * src0, + device const int32_t * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + constant int & n_past, + constant int & n_dims, + constant int & mode, + constant int & n_orig_ctx, + constant float & freq_base, + constant float & freq_scale, + constant float & ext_factor, + constant float & attn_factor, + constant float & beta_fast, + constant float & beta_slow, + uint tiitg[[thread_index_in_threadgroup]], + uint3 tptg[[threads_per_threadgroup]], + uint3 tgpig[[threadgroup_position_in_grid]]) { + const int64_t i3 = tgpig[2]; + const int64_t i2 = tgpig[1]; + const int64_t i1 = tgpig[0]; + + const bool is_neox = mode & 2; + + float corr_dims[2]; + rope_yarn_corr_dims(n_dims, n_orig_ctx, freq_base, beta_fast, beta_slow, corr_dims); + + device const int32_t * pos = src1; + + const int64_t p = pos[i2]; + + const float theta_0 = (float)p; + const float inv_ndims = -1.f/n_dims; + + if (!is_neox) { + for (int64_t i0 = 2*tiitg; i0 < ne0; i0 += 2*tptg.x) { + + const float theta = theta_0 * pow(freq_base, inv_ndims*i0); + float cos_theta, sin_theta; + rope_yarn(theta, freq_scale, corr_dims, i0, ext_factor, attn_factor, &cos_theta, &sin_theta); + + device const T * const src = (device T *)((device char *) src0 + i3*nb03 + i2*nb02 + i1*nb01 + i0*nb00); + device T * dst_data = (device T *)((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + + const T x0 = src[0]; + const T x1 = src[1]; + + dst_data[0] = x0*cos_theta - x1*sin_theta; + dst_data[1] = x0*sin_theta + x1*cos_theta; + } + } else { + for (int64_t ib = 0; ib < ne0/n_dims; ++ib) { + for (int64_t ic = 2*tiitg; ic < n_dims; ic += 2*tptg.x) { + + // simplified from `(ib * n_dims + ic) * inv_ndims` + const float cur_rot = inv_ndims*ic - ib; + + const float theta = theta_0 * pow(freq_base, cur_rot); + float cos_theta, sin_theta; + rope_yarn(theta, freq_scale, corr_dims, cur_rot, ext_factor, attn_factor, &cos_theta, &sin_theta); + + const int64_t i0 = ib*n_dims + ic/2; + + device const T * const src = (device T *)((device char *) src0 + i3*nb03 + i2*nb02 + i1*nb01 + i0*nb00); + device T * dst_data = (device T *)((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + + const float x0 = src[0]; + const float x1 = src[n_dims/2]; + + dst_data[0] = x0*cos_theta - x1*sin_theta; + dst_data[n_dims/2] = x0*sin_theta + x1*cos_theta; + } + } + } +} + +template [[host_name("kernel_rope_f32")]] kernel rope_t kernel_rope; +template [[host_name("kernel_rope_f16")]] kernel rope_t kernel_rope; + +kernel void kernel_cpy_f16_f16( + device const half * src0, + device half * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + const int64_t i03 = tgpig[2]; + const int64_t i02 = tgpig[1]; + const int64_t i01 = tgpig[0]; + + const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + + const int64_t i3 = n / (ne2*ne1*ne0); + const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); + const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; + const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); + + device half * dst_data = (device half *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + + for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { + device const half * src = (device half *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); + dst_data[i00] = src[0]; + } +} + +kernel void kernel_cpy_f32_f16( + device const float * src0, + device half * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + const int64_t i03 = tgpig[2]; + const int64_t i02 = tgpig[1]; + const int64_t i01 = tgpig[0]; + + const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + + const int64_t i3 = n / (ne2*ne1*ne0); + const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); + const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; + const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); + + device half * dst_data = (device half *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + + for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { + device const float * src = (device float *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); + + dst_data[i00] = src[0]; + } +} + +kernel void kernel_cpy_f32_f32( + device const float * src0, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + const int64_t i03 = tgpig[2]; + const int64_t i02 = tgpig[1]; + const int64_t i01 = tgpig[0]; + + const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + + const int64_t i3 = n / (ne2*ne1*ne0); + const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); + const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; + const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); + + device float * dst_data = (device float *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + + for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { + device const float * src = (device float *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); + + dst_data[i00] = src[0]; + } +} + +kernel void kernel_concat( + device const char * src0, + device const char * src1, + device char * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne10, + constant int64_t & ne11, + constant int64_t & ne12, + constant int64_t & ne13, + constant uint64_t & nb10, + constant uint64_t & nb11, + constant uint64_t & nb12, + constant uint64_t & nb13, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + + const int64_t i03 = tgpig.z; + const int64_t i02 = tgpig.y; + const int64_t i01 = tgpig.x; + + const int64_t i13 = i03 % ne13; + const int64_t i12 = i02 % ne12; + const int64_t i11 = i01 % ne11; + + device const char * src0_ptr = src0 + i03 * nb03 + i02 * nb02 + i01 * nb01 + tpitg.x*nb00; + device const char * src1_ptr = src1 + i13*nb13 + i12*nb12 + i11*nb11 + tpitg.x*nb10; + device char * dst_ptr = dst + i03*nb3 + i02*nb2 + i01*nb1 + tpitg.x*nb0; + + for (int i0 = tpitg.x; i0 < ne0; i0 += ntg.x) { + if (i02 < ne02) { + ((device float *)dst_ptr)[0] = ((device float *)src0_ptr)[0]; + src0_ptr += ntg.x*nb00; + } else { + ((device float *)dst_ptr)[0] = ((device float *)src1_ptr)[0]; + src1_ptr += ntg.x*nb10; + } + dst_ptr += ntg.x*nb0; + } +} + +//============================================ k-quants ====================================================== + +#ifndef QK_K +#define QK_K 256 +#else +static_assert(QK_K == 256 || QK_K == 64, "QK_K must be 256 or 64"); +#endif + +#if QK_K == 256 +#define K_SCALE_SIZE 12 +#else +#define K_SCALE_SIZE 4 +#endif + +typedef struct { + uint8_t scales[QK_K/16]; // scales and mins, quantized with 4 bits + uint8_t qs[QK_K/4]; // quants + half d; // super-block scale for quantized scales + half dmin; // super-block scale for quantized mins +} block_q2_K; +// 84 bytes / block + +typedef struct { + uint8_t hmask[QK_K/8]; // quants - high bit + uint8_t qs[QK_K/4]; // quants - low 2 bits +#if QK_K == 64 + uint8_t scales[2]; +#else + uint8_t scales[K_SCALE_SIZE]; // scales, quantized with 6 bits +#endif + half d; // super-block scale +} block_q3_K; + +#if QK_K == 64 +typedef struct { + half d[2]; // super-block scales/mins + uint8_t scales[2]; + uint8_t qs[QK_K/2]; // 4-bit quants +} block_q4_K; +#else +typedef struct { + half d; // super-block scale for quantized scales + half dmin; // super-block scale for quantized mins + uint8_t scales[K_SCALE_SIZE]; // scales and mins, quantized with 6 bits + uint8_t qs[QK_K/2]; // 4--bit quants +} block_q4_K; +#endif + +#if QK_K == 64 +typedef struct { + half d; // super-block scales/mins + int8_t scales[QK_K/16]; // 8-bit block scales + uint8_t qh[QK_K/8]; // quants, high bit + uint8_t qs[QK_K/2]; // quants, low 4 bits +} block_q5_K; +#else +typedef struct { + half d; // super-block scale for quantized scales + half dmin; // super-block scale for quantized mins + uint8_t scales[3*QK_K/64]; // scales and mins, quantized with 6 bits + uint8_t qh[QK_K/8]; // quants, high bit + uint8_t qs[QK_K/2]; // quants, low 4 bits +} block_q5_K; +// 176 bytes / block +#endif + +typedef struct { + uint8_t ql[QK_K/2]; // quants, lower 4 bits + uint8_t qh[QK_K/4]; // quants, upper 2 bits + int8_t scales[QK_K/16]; // scales, quantized with 8 bits + half d; // super-block scale +} block_q6_K; +// 210 bytes / block + +static inline uchar4 get_scale_min_k4(int j, device const uint8_t * q) { + uchar4 r; + if (j < 4) { + r[0] = q[j+0] & 63; + r[2] = q[j+1] & 63; + r[1] = q[j+4] & 63; + r[3] = q[j+5] & 63; + } else { + r[0] = (q[j+4] & 0xF) | ((q[j-4] >> 6) << 4); + r[2] = (q[j+5] & 0xF) | ((q[j-3] >> 6) << 4); + r[1] = (q[j+4] >> 4) | ((q[j-0] >> 6) << 4); + r[3] = (q[j+5] >> 4) | ((q[j+1] >> 6) << 4); + } + return r; +} + +//====================================== dot products ========================= + +kernel void kernel_mul_mv_q2_K_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + + const int nb = ne00/QK_K; + const int r0 = tgpig.x; + const int r1 = tgpig.y; + const int r2 = tgpig.z; + + const int first_row = (r0 * N_SIMDGROUP + sgitg) * N_DST; + const int ib_row = first_row * nb; + const uint offset0 = r2/gqa*(nb*ne0); + device const block_q2_K * x = (device const block_q2_K *) src0 + ib_row + offset0; + device const float * y = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; + float yl[32]; + float sumf[N_DST]={0.f}, all_sum; + + const int step = sizeof(block_q2_K) * nb; + +#if QK_K == 256 + const int ix = tiisg/8; // 0...3 + const int it = tiisg%8; // 0...7 + const int im = it/4; // 0 or 1 + const int ir = it%4; // 0...3 + const int is = (8*ir)/16;// 0 or 1 + + device const float * y4 = y + ix * QK_K + 128 * im + 8 * ir; + + for (int ib = ix; ib < nb; ib += 4) { + + float4 sumy = {0.f, 0.f, 0.f, 0.f}; + for (int i = 0; i < 8; ++i) { + yl[i+ 0] = y4[i+ 0]; sumy[0] += yl[i+ 0]; + yl[i+ 8] = y4[i+32]; sumy[1] += yl[i+ 8]; + yl[i+16] = y4[i+64]; sumy[2] += yl[i+16]; + yl[i+24] = y4[i+96]; sumy[3] += yl[i+24]; + } + + device const uint8_t * sc = (device const uint8_t *)x[ib].scales + 8*im + is; + device const uint16_t * qs = (device const uint16_t *)x[ib].qs + 16 * im + 4 * ir; + device const half * dh = &x[ib].d; + + for (int row = 0; row < N_DST; row++) { + + float4 acc1 = {0.f, 0.f, 0.f, 0.f}; + float4 acc2 = {0.f, 0.f, 0.f, 0.f}; + for (int i = 0; i < 8; i += 2) { + acc1[0] += yl[i+ 0] * (qs[i/2] & 0x0003); + acc2[0] += yl[i+ 1] * (qs[i/2] & 0x0300); + acc1[1] += yl[i+ 8] * (qs[i/2] & 0x000c); + acc2[1] += yl[i+ 9] * (qs[i/2] & 0x0c00); + acc1[2] += yl[i+16] * (qs[i/2] & 0x0030); + acc2[2] += yl[i+17] * (qs[i/2] & 0x3000); + acc1[3] += yl[i+24] * (qs[i/2] & 0x00c0); + acc2[3] += yl[i+25] * (qs[i/2] & 0xc000); + } + float dall = dh[0]; + float dmin = dh[1] * 1.f/16.f; + sumf[row] += dall * ((acc1[0] + 1.f/256.f * acc2[0]) * (sc[0] & 0xF) * 1.f/ 1.f + + (acc1[1] + 1.f/256.f * acc2[1]) * (sc[2] & 0xF) * 1.f/ 4.f + + (acc1[2] + 1.f/256.f * acc2[2]) * (sc[4] & 0xF) * 1.f/16.f + + (acc1[3] + 1.f/256.f * acc2[3]) * (sc[6] & 0xF) * 1.f/64.f) - + dmin * (sumy[0] * (sc[0] & 0xF0) + sumy[1] * (sc[2] & 0xF0) + sumy[2] * (sc[4] & 0xF0) + sumy[3] * (sc[6] & 0xF0)); + + qs += step/2; + sc += step; + dh += step/2; + } + + y4 += 4 * QK_K; + } +#else + const int ix = tiisg/2; // 0...15 + const int it = tiisg%2; // 0...1 + + device const float * y4 = y + ix * QK_K + 8 * it; + + for (int ib = ix; ib < nb; ib += 16) { + + float4 sumy = {0.f, 0.f, 0.f, 0.f}; + for (int i = 0; i < 8; ++i) { + yl[i+ 0] = y4[i+ 0]; sumy[0] += yl[i+ 0]; + yl[i+ 8] = y4[i+16]; sumy[1] += yl[i+ 8]; + yl[i+16] = y4[i+32]; sumy[2] += yl[i+16]; + yl[i+24] = y4[i+48]; sumy[3] += yl[i+24]; + } + + device const uint8_t * sc = (device const uint8_t *)x[ib].scales; + device const uint16_t * qs = (device const uint16_t *)x[ib].qs + 4 * it; + device const half * dh = &x[ib].d; + + for (int row = 0; row < N_DST; row++) { + + float4 acc1 = {0.f, 0.f, 0.f, 0.f}; + float4 acc2 = {0.f, 0.f, 0.f, 0.f}; + for (int i = 0; i < 8; i += 2) { + acc1[0] += yl[i+ 0] * (qs[i/2] & 0x0003); + acc2[0] += yl[i+ 1] * (qs[i/2] & 0x0300); + acc1[1] += yl[i+ 8] * (qs[i/2] & 0x000c); + acc2[1] += yl[i+ 9] * (qs[i/2] & 0x0c00); + acc1[2] += yl[i+16] * (qs[i/2] & 0x0030); + acc2[2] += yl[i+17] * (qs[i/2] & 0x3000); + acc1[3] += yl[i+24] * (qs[i/2] & 0x00c0); + acc2[3] += yl[i+25] * (qs[i/2] & 0xc000); + } + + float dall = dh[0]; + float dmin = dh[1]; + sumf[row] += dall * ((acc1[0] + 1.f/256.f * acc2[0]) * (sc[0] & 0xF) * 1.f/ 1.f + + (acc1[1] + 1.f/256.f * acc2[1]) * (sc[1] & 0xF) * 1.f/ 4.f + + (acc1[2] + 1.f/256.f * acc2[2]) * (sc[2] & 0xF) * 1.f/16.f + + (acc1[3] + 1.f/256.f * acc2[3]) * (sc[3] & 0xF) * 1.f/64.f) - + dmin * (sumy[0] * (sc[0] >> 4) + sumy[1] * (sc[1] >> 4) + sumy[2] * (sc[2] >> 4) + sumy[3] * (sc[3] >> 4)); + + qs += step/2; + sc += step; + dh += step/2; + } + + y4 += 16 * QK_K; + } +#endif + + for (int row = 0; row < N_DST; ++row) { + all_sum = simd_sum(sumf[row]); + if (tiisg == 0) { + dst[r1*ne0 + r2*ne0*ne1 + first_row + row] = all_sum; + } + } +} + +#if QK_K == 256 +kernel void kernel_mul_mv_q3_K_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + + const int nb = ne00/QK_K; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + const int64_t r2 = tgpig.z; + + const int first_row = (r0 * N_SIMDGROUP + sgitg) * 2; + const uint offset0 = r2/gqa*(nb*ne0); + device const block_q3_K * x = (device const block_q3_K *) src0 + first_row*nb + offset0; + device const float * yy = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; + + float yl[32]; + + //const uint16_t kmask1 = 0x3030; + //const uint16_t kmask2 = 0x0f0f; + + const int tid = tiisg/4; + const int ix = tiisg%4; + const int ip = tid/4; // 0 or 1 + const int il = 2*((tid%4)/2); // 0 or 2 + const int ir = tid%2; + const int n = 8; + const int l0 = n*ir; + + // One would think that the Metal compiler would figure out that ip and il can only have + // 4 possible states, and optimize accordingly. Well, no. It needs help, and we do it + // with these two tales. + // + // Possible masks for the high bit + const ushort4 mm[4] = {{0x0001, 0x0100, 0x0002, 0x0200}, // ip = 0, il = 0 + {0x0004, 0x0400, 0x0008, 0x0800}, // ip = 0, il = 2 + {0x0010, 0x1000, 0x0020, 0x2000}, // ip = 1, il = 0 + {0x0040, 0x4000, 0x0080, 0x8000}}; // ip = 1, il = 2 + + // Possible masks for the low 2 bits + const int4 qm[2] = {{0x0003, 0x0300, 0x000c, 0x0c00}, {0x0030, 0x3000, 0x00c0, 0xc000}}; + + const ushort4 hm = mm[2*ip + il/2]; + + const int shift = 2*il; + const float v1 = il == 0 ? 4.f : 64.f; + const float v2 = 4.f * v1; + + const uint16_t s_shift1 = 4*ip; + const uint16_t s_shift2 = s_shift1 + il; + + const int q_offset = 32*ip + l0; + const int y_offset = 128*ip + 32*il + l0; + + const int step = sizeof(block_q3_K) * nb / 2; + + device const float * y1 = yy + ix*QK_K + y_offset; + + uint32_t scales32, aux32; + thread uint16_t * scales16 = (thread uint16_t *)&scales32; + thread const int8_t * scales = (thread const int8_t *)&scales32; + + float sumf1[2] = {0.f}; + float sumf2[2] = {0.f}; + for (int i = ix; i < nb; i += 4) { + + for (int l = 0; l < 8; ++l) { + yl[l+ 0] = y1[l+ 0]; + yl[l+ 8] = y1[l+16]; + yl[l+16] = y1[l+32]; + yl[l+24] = y1[l+48]; + } + + device const uint16_t * q = (device const uint16_t *)(x[i].qs + q_offset); + device const uint16_t * h = (device const uint16_t *)(x[i].hmask + l0); + device const uint16_t * a = (device const uint16_t *)(x[i].scales); + device const half * dh = &x[i].d; + + for (int row = 0; row < 2; ++row) { + + const float d_all = (float)dh[0]; + + scales16[0] = a[4]; + scales16[1] = a[5]; + aux32 = ((scales32 >> s_shift2) << 4) & 0x30303030; + scales16[0] = a[il+0]; + scales16[1] = a[il+1]; + scales32 = ((scales32 >> s_shift1) & 0x0f0f0f0f) | aux32; + + float s1 = 0, s2 = 0, s3 = 0, s4 = 0, s5 = 0, s6 = 0; + for (int l = 0; l < n; l += 2) { + const int32_t qs = q[l/2]; + s1 += yl[l+0] * (qs & qm[il/2][0]); + s2 += yl[l+1] * (qs & qm[il/2][1]); + s3 += ((h[l/2] & hm[0]) ? 0.f : yl[l+0]) + ((h[l/2] & hm[1]) ? 0.f : yl[l+1]); + s4 += yl[l+16] * (qs & qm[il/2][2]); + s5 += yl[l+17] * (qs & qm[il/2][3]); + s6 += ((h[l/2] & hm[2]) ? 0.f : yl[l+16]) + ((h[l/2] & hm[3]) ? 0.f : yl[l+17]); + } + float d1 = d_all * (s1 + 1.f/256.f * s2 - s3*v1); + float d2 = d_all * (s4 + 1.f/256.f * s5 - s6*v2); + sumf1[row] += d1 * (scales[0] - 32); + sumf2[row] += d2 * (scales[2] - 32); + + s1 = s2 = s3 = s4 = s5 = s6 = 0; + for (int l = 0; l < n; l += 2) { + const int32_t qs = q[l/2+8]; + s1 += yl[l+8] * (qs & qm[il/2][0]); + s2 += yl[l+9] * (qs & qm[il/2][1]); + s3 += ((h[l/2+8] & hm[0]) ? 0.f : yl[l+8]) + ((h[l/2+8] & hm[1]) ? 0.f : yl[l+9]); + s4 += yl[l+24] * (qs & qm[il/2][2]); + s5 += yl[l+25] * (qs & qm[il/2][3]); + s6 += ((h[l/2+8] & hm[2]) ? 0.f : yl[l+24]) + ((h[l/2+8] & hm[3]) ? 0.f : yl[l+25]); + } + d1 = d_all * (s1 + 1.f/256.f * s2 - s3*v1); + d2 = d_all * (s4 + 1.f/256.f * s5 - s6*v2); + sumf1[row] += d1 * (scales[1] - 32); + sumf2[row] += d2 * (scales[3] - 32); + + q += step; + h += step; + a += step; + dh += step; + + } + + y1 += 4 * QK_K; + + } + + for (int row = 0; row < 2; ++row) { + const float sumf = (sumf1[row] + 0.25f * sumf2[row]) / (1 << shift); + sumf1[row] = simd_sum(sumf); + } + if (tiisg == 0) { + for (int row = 0; row < 2; ++row) { + dst[r1*ne0 + r2*ne0*ne1 + first_row + row] = sumf1[row]; + } + } +} +#else +kernel void kernel_mul_mv_q3_K_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + + const int nb = ne00/QK_K; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + const int64_t r2 = tgpig.z; + + const int row = 2 * r0 + sgitg; + const uint offset0 = r2/gqa*(nb*ne0); + device const block_q3_K * x = (device const block_q3_K *) src0 + row*nb + offset0; + device const float * yy = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; + const int ix = tiisg/4; + const int il = 4 * (tiisg%4);// 0, 4, 8, 12 + const int im = il/8; // 0, 0, 1, 1 + const int in = il%8; // 0, 4, 0, 4 + + float2 sum = {0.f, 0.f}; + + for (int i = ix; i < nb; i += 8) { + + const float d_all = (float)(x[i].d); + + device const uint16_t * q = (device const uint16_t *)(x[i].qs + il); + device const uint16_t * h = (device const uint16_t *)(x[i].hmask + in); + device const uint16_t * s = (device const uint16_t *)(x[i].scales); + device const float * y = yy + i * QK_K + il; + + const float d1 = d_all * ((int32_t)(s[0] & 0x000F) - 8); + const float d2 = d_all * ((int32_t)(s[0] & 0x00F0) - 128) * 1.f/64.f; + const float d3 = d_all * ((int32_t)(s[0] & 0x0F00) - 2048) * 1.f/4096.f; + const float d4 = d_all * ((int32_t)(s[0] & 0xF000) - 32768) * 1.f/262144.f; + + for (int l = 0; l < 4; l += 2) { + const uint16_t hm = h[l/2] >> im; + sum[0] += y[l+ 0] * d1 * ((int32_t)(q[l/2] & 0x0003) - ((hm & 0x0001) ? 0 : 4)) + + y[l+16] * d2 * ((int32_t)(q[l/2] & 0x000c) - ((hm & 0x0004) ? 0 : 16)) + + y[l+32] * d3 * ((int32_t)(q[l/2] & 0x0030) - ((hm & 0x0010) ? 0 : 64)) + + y[l+48] * d4 * ((int32_t)(q[l/2] & 0x00c0) - ((hm & 0x0040) ? 0 : 256)); + sum[1] += y[l+ 1] * d1 * ((int32_t)(q[l/2] & 0x0300) - ((hm & 0x0100) ? 0 : 1024)) + + y[l+17] * d2 * ((int32_t)(q[l/2] & 0x0c00) - ((hm & 0x0400) ? 0 : 4096)) + + y[l+33] * d3 * ((int32_t)(q[l/2] & 0x3000) - ((hm & 0x1000) ? 0 : 16384)) + + y[l+49] * d4 * ((int32_t)(q[l/2] & 0xc000) - ((hm & 0x4000) ? 0 : 65536)); + } + + } + const float sumf = sum[0] + sum[1] * 1.f/256.f; + + const float tot = simd_sum(sumf); + if (tiisg == 0) { + dst[r1*ne0 + r2*ne0*ne1 + row] = tot; + } + +} +#endif + +#if QK_K == 256 +kernel void kernel_mul_mv_q4_K_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01 [[buffer(4)]], + constant int64_t & ne02 [[buffer(5)]], + constant int64_t & ne10 [[buffer(9)]], + constant int64_t & ne12 [[buffer(11)]], + constant int64_t & ne0 [[buffer(15)]], + constant int64_t & ne1 [[buffer(16)]], + constant uint & gqa [[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + + const uint16_t kmask1 = 0x3f3f; + const uint16_t kmask2 = 0x0f0f; + const uint16_t kmask3 = 0xc0c0; + + const int ix = tiisg/8; // 0...3 + const int it = tiisg%8; // 0...7 + const int im = it/4; // 0 or 1 + const int ir = it%4; // 0...3 + + const int nb = ne00/QK_K; + const int r0 = tgpig.x; + const int r1 = tgpig.y; + const int r2 = tgpig.z; + //const int first_row = (r0 * N_SIMDGROUP + sgitg) * N_DST; + const int first_row = r0 * N_DST; + const int ib_row = first_row * nb; + const uint offset0 = r2/gqa*(nb*ne0); + device const block_q4_K * x = (device const block_q4_K *) src0 + ib_row + offset0; + device const float * y = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; + float yl[16]; + float yh[16]; + float sumf[N_DST]={0.f}, all_sum; + + const int step = sizeof(block_q4_K) * nb / 2; + + device const float * y4 = y + ix * QK_K + 64 * im + 8 * ir; + + uint16_t sc16[4]; + thread const uint8_t * sc8 = (thread const uint8_t *)sc16; + + for (int ib = ix; ib < nb; ib += 4) { + + float4 sumy = {0.f, 0.f, 0.f, 0.f}; + for (int i = 0; i < 8; ++i) { + yl[i+0] = y4[i+ 0]; sumy[0] += yl[i+0]; + yl[i+8] = y4[i+ 32]; sumy[1] += yl[i+8]; + yh[i+0] = y4[i+128]; sumy[2] += yh[i+0]; + yh[i+8] = y4[i+160]; sumy[3] += yh[i+8]; + } + + device const uint16_t * sc = (device const uint16_t *)x[ib].scales + im; + device const uint16_t * q1 = (device const uint16_t *)x[ib].qs + 16 * im + 4 * ir; + device const half * dh = &x[ib].d; + + for (int row = 0; row < N_DST; row++) { + + sc16[0] = sc[0] & kmask1; + sc16[1] = sc[2] & kmask1; + sc16[2] = ((sc[4] >> 0) & kmask2) | ((sc[0] & kmask3) >> 2); + sc16[3] = ((sc[4] >> 4) & kmask2) | ((sc[2] & kmask3) >> 2); + + device const uint16_t * q2 = q1 + 32; + + float4 acc1 = {0.f, 0.f, 0.f, 0.f}; + float4 acc2 = {0.f, 0.f, 0.f, 0.f}; + for (int i = 0; i < 8; i += 2) { + acc1[0] += yl[i+0] * (q1[i/2] & 0x000F); + acc1[1] += yl[i+1] * (q1[i/2] & 0x0F00); + acc1[2] += yl[i+8] * (q1[i/2] & 0x00F0); + acc1[3] += yl[i+9] * (q1[i/2] & 0xF000); + acc2[0] += yh[i+0] * (q2[i/2] & 0x000F); + acc2[1] += yh[i+1] * (q2[i/2] & 0x0F00); + acc2[2] += yh[i+8] * (q2[i/2] & 0x00F0); + acc2[3] += yh[i+9] * (q2[i/2] & 0xF000); + } + + float dall = dh[0]; + float dmin = dh[1]; + sumf[row] += dall * ((acc1[0] + 1.f/256.f * acc1[1]) * sc8[0] + + (acc1[2] + 1.f/256.f * acc1[3]) * sc8[1] * 1.f/16.f + + (acc2[0] + 1.f/256.f * acc2[1]) * sc8[4] + + (acc2[2] + 1.f/256.f * acc2[3]) * sc8[5] * 1.f/16.f) - + dmin * (sumy[0] * sc8[2] + sumy[1] * sc8[3] + sumy[2] * sc8[6] + sumy[3] * sc8[7]); + + q1 += step; + sc += step; + dh += step; + } + + y4 += 4 * QK_K; + } + + for (int row = 0; row < N_DST; ++row) { + all_sum = simd_sum(sumf[row]); + if (tiisg == 0) { + dst[r1*ne0 + r2*ne0*ne1 + first_row + row] = all_sum; + } + } +} +#else +kernel void kernel_mul_mv_q4_K_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + + const int ix = tiisg/4; // 0...7 + const int it = tiisg%4; // 0...3 + + const int nb = ne00/QK_K; + const int r0 = tgpig.x; + const int r1 = tgpig.y; + const int r2 = tgpig.z; + const int first_row = (r0 * N_SIMDGROUP + sgitg) * N_DST; + const int ib_row = first_row * nb; + const uint offset0 = r2/gqa*(nb*ne0); + device const block_q4_K * x = (device const block_q4_K *) src0 + ib_row + offset0; + device const float * y = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; + float yl[8]; + float yh[8]; + float sumf[N_DST]={0.f}, all_sum; + + const int step = sizeof(block_q4_K) * nb / 2; + + device const float * y4 = y + ix * QK_K + 8 * it; + + uint16_t sc16[4]; + + for (int ib = ix; ib < nb; ib += 8) { + + float2 sumy = {0.f, 0.f}; + for (int i = 0; i < 8; ++i) { + yl[i] = y4[i+ 0]; sumy[0] += yl[i]; + yh[i] = y4[i+32]; sumy[1] += yh[i]; + } + + device const uint16_t * sc = (device const uint16_t *)x[ib].scales; + device const uint16_t * qs = (device const uint16_t *)x[ib].qs + 4 * it; + device const half * dh = x[ib].d; + + for (int row = 0; row < N_DST; row++) { + + sc16[0] = sc[0] & 0x000f; + sc16[1] = sc[0] & 0x0f00; + sc16[2] = sc[0] & 0x00f0; + sc16[3] = sc[0] & 0xf000; + + float2 acc1 = {0.f, 0.f}; + float2 acc2 = {0.f, 0.f}; + for (int i = 0; i < 8; i += 2) { + acc1[0] += yl[i+0] * (qs[i/2] & 0x000F); + acc1[1] += yl[i+1] * (qs[i/2] & 0x0F00); + acc2[0] += yh[i+0] * (qs[i/2] & 0x00F0); + acc2[1] += yh[i+1] * (qs[i/2] & 0xF000); + } + + float dall = dh[0]; + float dmin = dh[1]; + sumf[row] += dall * ((acc1[0] + 1.f/256.f * acc1[1]) * sc16[0] + + (acc2[0] + 1.f/256.f * acc2[1]) * sc16[1] * 1.f/4096.f) - + dmin * 1.f/16.f * (sumy[0] * sc16[2] + sumy[1] * sc16[3] * 1.f/256.f); + + qs += step; + sc += step; + dh += step; + } + + y4 += 8 * QK_K; + } + + for (int row = 0; row < N_DST; ++row) { + all_sum = simd_sum(sumf[row]); + if (tiisg == 0) { + dst[r1*ne0+ r2*ne0*ne1 + first_row + row] = all_sum; + } + } +} +#endif + +kernel void kernel_mul_mv_q5_K_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + + const int nb = ne00/QK_K; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + const int r2 = tgpig.z; + + const int first_row = (r0 * N_SIMDGROUP + sgitg) * 2; + const uint offset0 = r2/gqa*(nb*ne0); + device const block_q5_K * x = (device const block_q5_K *) src0 + first_row*nb + offset0; + device const float * yy = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; + + float sumf[2]={0.f}; + + const int step = sizeof(block_q5_K) * nb; + +#if QK_K == 256 +# + float yl[16], yh[16]; + + const uint16_t kmask1 = 0x3f3f; + const uint16_t kmask2 = 0x0f0f; + const uint16_t kmask3 = 0xc0c0; + + const int tid = tiisg/4; + const int ix = tiisg%4; + const int im = tid/4; + const int ir = tid%4; + const int n = 8; + + const int l0 = n*ir; + const int q_offset = 32*im + l0; + const int y_offset = 64*im + l0; + + const uint8_t hm1 = 1u << (2*im); + const uint8_t hm2 = hm1 << 1; + const uint8_t hm3 = hm1 << 4; + const uint8_t hm4 = hm2 << 4; + + uint16_t sc16[4]; + thread const uint8_t * sc8 = (thread const uint8_t *)sc16; + + device const float * y1 = yy + ix*QK_K + y_offset; + + for (int i = ix; i < nb; i += 4) { + + device const uint8_t * q1 = x[i].qs + q_offset; + device const uint8_t * qh = x[i].qh + l0; + device const half * dh = &x[i].d; + device const uint16_t * a = (device const uint16_t *)x[i].scales + im; + + device const float * y2 = y1 + 128; + float4 sumy = {0.f, 0.f, 0.f, 0.f}; + for (int l = 0; l < 8; ++l) { + yl[l+0] = y1[l+ 0]; sumy[0] += yl[l+0]; + yl[l+8] = y1[l+32]; sumy[1] += yl[l+8]; + yh[l+0] = y2[l+ 0]; sumy[2] += yh[l+0]; + yh[l+8] = y2[l+32]; sumy[3] += yh[l+8]; + } + + for (int row = 0; row < 2; ++row) { + + device const uint8_t * q2 = q1 + 64; + + sc16[0] = a[0] & kmask1; + sc16[1] = a[2] & kmask1; + sc16[2] = ((a[4] >> 0) & kmask2) | ((a[0] & kmask3) >> 2); + sc16[3] = ((a[4] >> 4) & kmask2) | ((a[2] & kmask3) >> 2); + + float4 acc1 = {0.f}; + float4 acc2 = {0.f}; + for (int l = 0; l < n; ++l) { + uint8_t h = qh[l]; + acc1[0] += yl[l+0] * (q1[l] & 0x0F); + acc1[1] += yl[l+8] * (q1[l] & 0xF0); + acc1[2] += yh[l+0] * (q2[l] & 0x0F); + acc1[3] += yh[l+8] * (q2[l] & 0xF0); + acc2[0] += h & hm1 ? yl[l+0] : 0.f; + acc2[1] += h & hm2 ? yl[l+8] : 0.f; + acc2[2] += h & hm3 ? yh[l+0] : 0.f; + acc2[3] += h & hm4 ? yh[l+8] : 0.f; + } + const float dall = dh[0]; + const float dmin = dh[1]; + sumf[row] += dall * (sc8[0] * (acc1[0] + 16.f*acc2[0]) + + sc8[1] * (acc1[1]/16.f + 16.f*acc2[1]) + + sc8[4] * (acc1[2] + 16.f*acc2[2]) + + sc8[5] * (acc1[3]/16.f + 16.f*acc2[3])) - + dmin * (sumy[0] * sc8[2] + sumy[1] * sc8[3] + sumy[2] * sc8[6] + sumy[3] * sc8[7]); + + q1 += step; + qh += step; + dh += step/2; + a += step/2; + + } + + y1 += 4 * QK_K; + + } +#else + float yl[8], yh[8]; + + const int il = 4 * (tiisg/8); // 0, 4, 8, 12 + const int ix = tiisg%8; + const int im = il/8; // 0, 0, 1, 1 + const int in = il%8; // 0, 4, 0, 4 + + device const float * y = yy + ix*QK_K + il; + + for (int i = ix; i < nb; i += 8) { + + for (int l = 0; l < 4; ++l) { + yl[l+0] = y[l+ 0]; + yl[l+4] = y[l+16]; + yh[l+0] = y[l+32]; + yh[l+4] = y[l+48]; + } + + device const half * dh = &x[i].d; + device const uint8_t * q = x[i].qs + il; + device const uint8_t * h = x[i].qh + in; + device const int8_t * s = x[i].scales; + + for (int row = 0; row < 2; ++row) { + + const float d = dh[0]; + + float2 acc = {0.f, 0.f}; + for (int l = 0; l < 4; ++l) { + const uint8_t hl = h[l] >> im; + acc[0] += yl[l+0] * s[0] * ((int16_t)(q[l+ 0] & 0x0F) - (hl & 0x01 ? 0 : 16)) + + yl[l+4] * s[1] * ((int16_t)(q[l+16] & 0x0F) - (hl & 0x04 ? 0 : 16)); + acc[1] += yh[l+0] * s[2] * ((int16_t)(q[l+ 0] & 0xF0) - (hl & 0x10 ? 0 : 256)) + + yh[l+4] * s[3] * ((int16_t)(q[l+16] & 0xF0) - (hl & 0x40 ? 0 : 256)); + } + sumf[row] += d * (acc[0] + 1.f/16.f * acc[1]); + + q += step; + h += step; + s += step; + dh += step/2; + + } + + y += 8 * QK_K; + } +#endif + + for (int row = 0; row < 2; ++row) { + const float tot = simd_sum(sumf[row]); + if (tiisg == 0) { + dst[r1*ne0 + r2*ne0*ne1 + first_row + row] = tot; + } + } + +} + +kernel void kernel_mul_mv_q6_K_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01[[buffer(4)]], + constant int64_t & ne02[[buffer(5)]], + constant int64_t & ne10[[buffer(9)]], + constant int64_t & ne12[[buffer(11)]], + constant int64_t & ne0[[buffer(15)]], + constant int64_t & ne1[[buffer(16)]], + constant uint & gqa[[buffer(17)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiisg[[thread_index_in_simdgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + + const uint8_t kmask1 = 0x03; + const uint8_t kmask2 = 0x0C; + const uint8_t kmask3 = 0x30; + const uint8_t kmask4 = 0xC0; + + const int nb = ne00/QK_K; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + const int r2 = tgpig.z; + + const int row = 2 * r0 + sgitg; + const uint offset0 = r2/gqa*(nb*ne0); + device const block_q6_K * x = (device const block_q6_K *) src0 + row * nb + offset0; + device const float * yy = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; + + float sumf = 0; + +#if QK_K == 256 + const int tid = tiisg/2; + const int ix = tiisg%2; + const int ip = tid/8; // 0 or 1 + const int il = tid%8; + const int n = 4; + const int l0 = n*il; + const int is = 8*ip + l0/16; + + const int y_offset = 128*ip + l0; + const int q_offset_l = 64*ip + l0; + const int q_offset_h = 32*ip + l0; + + for (int i = ix; i < nb; i += 2) { + + device const uint8_t * q1 = x[i].ql + q_offset_l; + device const uint8_t * q2 = q1 + 32; + device const uint8_t * qh = x[i].qh + q_offset_h; + device const int8_t * sc = x[i].scales + is; + + device const float * y = yy + i * QK_K + y_offset; + + const float dall = x[i].d; + + float4 sums = {0.f, 0.f, 0.f, 0.f}; + for (int l = 0; l < n; ++l) { + sums[0] += y[l+ 0] * ((int8_t)((q1[l] & 0xF) | ((qh[l] & kmask1) << 4)) - 32); + sums[1] += y[l+32] * ((int8_t)((q2[l] & 0xF) | ((qh[l] & kmask2) << 2)) - 32); + sums[2] += y[l+64] * ((int8_t)((q1[l] >> 4) | ((qh[l] & kmask3) << 0)) - 32); + sums[3] += y[l+96] * ((int8_t)((q2[l] >> 4) | ((qh[l] & kmask4) >> 2)) - 32); + } + + sumf += dall * (sums[0] * sc[0] + sums[1] * sc[2] + sums[2] * sc[4] + sums[3] * sc[6]); + + } + +#else + const int ix = tiisg/4; + const int il = 4*(tiisg%4); + + for (int i = ix; i < nb; i += 8) { + device const float * y = yy + i * QK_K + il; + device const uint8_t * ql = x[i].ql + il; + device const uint8_t * qh = x[i].qh + il; + device const int8_t * s = x[i].scales; + + const float d = x[i].d; + + float4 sums = {0.f, 0.f, 0.f, 0.f}; + for (int l = 0; l < 4; ++l) { + sums[0] += y[l+ 0] * ((int8_t)((ql[l+ 0] & 0xF) | ((qh[l] & kmask1) << 4)) - 32); + sums[1] += y[l+16] * ((int8_t)((ql[l+16] & 0xF) | ((qh[l] & kmask2) << 2)) - 32); + sums[2] += y[l+32] * ((int8_t)((ql[l+ 0] >> 4) | ((qh[l] & kmask3) >> 0)) - 32); + sums[3] += y[l+48] * ((int8_t)((ql[l+16] >> 4) | ((qh[l] & kmask4) >> 2)) - 32); + } + sumf += d * (sums[0] * s[0] + sums[1] * s[1] + sums[2] * s[2] + sums[3] * s[3]); + } + +#endif + + const float tot = simd_sum(sumf); + if (tiisg == 0) { + dst[r1*ne0 + r2*ne0*ne1 + row] = tot; + } +} + +//============================= templates and their specializations ============================= + +// NOTE: this is not dequantizing - we are simply fitting the template +template +void dequantize_f32(device const float4x4 * src, short il, thread type4x4 & reg) { + float4x4 temp = *(((device float4x4 *)src)); + for (int i = 0; i < 16; i++){ + reg[i/4][i%4] = temp[i/4][i%4]; + } +} + +template +void dequantize_f16(device const half4x4 * src, short il, thread type4x4 & reg) { + half4x4 temp = *(((device half4x4 *)src)); + for (int i = 0; i < 16; i++){ + reg[i/4][i%4] = temp[i/4][i%4]; + } +} + +template +void dequantize_q4_0(device const block_q4_0 *xb, short il, thread type4x4 & reg) { + device const uint16_t * qs = ((device const uint16_t *)xb + 1); + const float d1 = il ? (xb->d / 16.h) : xb->d; + const float d2 = d1 / 256.f; + const float md = -8.h * xb->d; + const ushort mask0 = il ? 0x00F0 : 0x000F; + const ushort mask1 = mask0 << 8; + + for (int i=0;i<8;i++) { + reg[i/2][2*(i%2)+0] = d1 * (qs[i] & mask0) + md; + reg[i/2][2*(i%2)+1] = d2 * (qs[i] & mask1) + md; + } +} + +template +void dequantize_q4_1(device const block_q4_1 *xb, short il, thread type4x4 & reg) { + device const uint16_t * qs = ((device const uint16_t *)xb + 2); + const float d1 = il ? (xb->d / 16.h) : xb->d; + const float d2 = d1 / 256.f; + const float m = xb->m; + const ushort mask0 = il ? 0x00F0 : 0x000F; + const ushort mask1 = mask0 << 8; + + for (int i=0;i<8;i++) { + reg[i/2][2*(i%2)+0] = ((qs[i] & mask0) * d1) + m; + reg[i/2][2*(i%2)+1] = ((qs[i] & mask1) * d2) + m; + } +} + +template +void dequantize_q5_0(device const block_q5_0 *xb, short il, thread type4x4 & reg) { + device const uint16_t * qs = ((device const uint16_t *)xb + 3); + const float d = xb->d; + const float md = -16.h * xb->d; + const ushort mask = il ? 0x00F0 : 0x000F; + + const uint32_t qh = *((device const uint32_t *)xb->qh); + + const int x_mv = il ? 4 : 0; + + const int gh_mv = il ? 12 : 0; + const int gh_bk = il ? 0 : 4; + + for (int i = 0; i < 8; i++) { + // extract the 5-th bits for x0 and x1 + const uint8_t xh_0 = ((qh >> (gh_mv + 2*i )) << gh_bk) & 0x10; + const uint8_t xh_1 = ((qh >> (gh_mv + 2*i+1)) << gh_bk) & 0x10; + + // combine the 4-bits from qs with the 5th bit + const int32_t x0 = ((((qs[i] ) & mask) >> x_mv) | xh_0); + const int32_t x1 = ((((qs[i] >> 8) & mask) >> x_mv) | xh_1); + + reg[i/2][2*(i%2)+0] = d * x0 + md; + reg[i/2][2*(i%2)+1] = d * x1 + md; + } +} + +template +void dequantize_q5_1(device const block_q5_1 *xb, short il, thread type4x4 & reg) { + device const uint16_t * qs = ((device const uint16_t *)xb + 4); + const float d = xb->d; + const float m = xb->m; + const ushort mask = il ? 0x00F0 : 0x000F; + + const uint32_t qh = *((device const uint32_t *)xb->qh); + + const int x_mv = il ? 4 : 0; + + const int gh_mv = il ? 12 : 0; + const int gh_bk = il ? 0 : 4; + + for (int i = 0; i < 8; i++) { + // extract the 5-th bits for x0 and x1 + const uint8_t xh_0 = ((qh >> (gh_mv + 2*i )) << gh_bk) & 0x10; + const uint8_t xh_1 = ((qh >> (gh_mv + 2*i+1)) << gh_bk) & 0x10; + + // combine the 4-bits from qs with the 5th bit + const int32_t x0 = ((((qs[i] ) & mask) >> x_mv) | xh_0); + const int32_t x1 = ((((qs[i] >> 8) & mask) >> x_mv) | xh_1); + + reg[i/2][2*(i%2)+0] = d * x0 + m; + reg[i/2][2*(i%2)+1] = d * x1 + m; + } +} + +template +void dequantize_q8_0(device const block_q8_0 *xb, short il, thread type4x4 & reg) { + device const int8_t * qs = ((device const int8_t *)xb->qs); + const half d = xb->d; + + for (int i=0;i<16;i++) { + reg[i/4][i%4] = (qs[i + 16*il] * d); + } +} + +template +void dequantize_q2_K(device const block_q2_K *xb, short il, thread type4x4 & reg) { + const half d = xb->d; + const half min = xb->dmin; + device const uint8_t * q = (device const uint8_t *)xb->qs; + half dl, ml; + uint8_t sc = xb->scales[il]; + +#if QK_K == 256 + q = q + 32*(il/8) + 16*(il&1); + il = (il/2)%4; +#endif + half coef = il>1 ? (il>2 ? 1/64.h : 1/16.h) : (il>0 ? 1/4.h : 1.h); + uchar mask = il>1 ? (il>2 ? 192 : 48) : (il>0 ? 12 : 3); + dl = d * (sc & 0xF) * coef, ml = min * (sc >> 4); + for (int i = 0; i < 16; ++i) { + reg[i/4][i%4] = dl * (q[i] & mask) - ml; + } +} + +template +void dequantize_q3_K(device const block_q3_K *xb, short il, thread type4x4 & reg) { + const half d_all = xb->d; + device const uint8_t * q = (device const uint8_t *)xb->qs; + device const uint8_t * h = (device const uint8_t *)xb->hmask; + device const int8_t * scales = (device const int8_t *)xb->scales; + +#if QK_K == 256 + q = q + 32 * (il/8) + 16 * (il&1); + h = h + 16 * (il&1); + uint8_t m = 1 << (il/2); + uint16_t kmask1 = (il/4)>1 ? ((il/4)>2 ? 192 : 48) : \ + ((il/4)>0 ? 12 : 3); + uint16_t kmask2 = il/8 ? 0xF0 : 0x0F; + uint16_t scale_2 = scales[il%8], scale_1 = scales[8 + il%4]; + int16_t dl_int = (il/4)&1 ? (scale_2&kmask2) | ((scale_1&kmask1) << 2) + : (scale_2&kmask2) | ((scale_1&kmask1) << 4); + half dl = il<8 ? d_all * (dl_int - 32.h) : d_all * (dl_int / 16.h - 32.h); + const half ml = 4.h * dl; + + il = (il/2) & 3; + const half coef = il>1 ? (il>2 ? 1/64.h : 1/16.h) : (il>0 ? 1/4.h : 1.h); + const uint8_t mask = il>1 ? (il>2 ? 192 : 48) : (il>0 ? 12 : 3); + dl *= coef; + + for (int i = 0; i < 16; ++i) { + reg[i/4][i%4] = dl * (q[i] & mask) - (h[i] & m ? 0 : ml); + } +#else + float kcoef = il&1 ? 1.f/16.f : 1.f; + uint16_t kmask = il&1 ? 0xF0 : 0x0F; + float dl = d_all * ((scales[il/2] & kmask) * kcoef - 8); + float coef = il>1 ? (il>2 ? 1/64.h : 1/16.h) : (il>0 ? 1/4.h : 1.h); + uint8_t mask = il>1 ? (il>2 ? 192 : 48) : (il>0 ? 12 : 3); + uint8_t m = 1<<(il*2); + for (int i = 0; i < 16; ++i) { + reg[i/4][i%4] = coef * dl * ((q[i] & mask) - ((h[i%8] & (m * (1 + i/8))) ? 0 : 4.f/coef)); + } +#endif +} + +static inline uchar2 get_scale_min_k4_just2(int j, int k, device const uchar * q) { + return j < 4 ? uchar2{uchar(q[j+0+k] & 63), uchar(q[j+4+k] & 63)} + : uchar2{uchar((q[j+4+k] & 0xF) | ((q[j-4+k] & 0xc0) >> 2)), uchar((q[j+4+k] >> 4) | ((q[j-0+k] & 0xc0) >> 2))}; +} + +template +void dequantize_q4_K(device const block_q4_K *xb, short il, thread type4x4 & reg) { + device const uchar * q = xb->qs; + +#if QK_K == 256 + short is = (il/4) * 2; + q = q + (il/4) * 32 + 16 * (il&1); + il = il & 3; + const uchar2 sc = get_scale_min_k4_just2(is, il/2, xb->scales); + const half d = il < 2 ? xb->d : xb->d / 16.h; + const half min = xb->dmin; + const half dl = d * sc[0]; + const half ml = min * sc[1]; +#else + q = q + 16 * (il&1); + device const uint8_t * s = xb->scales; + device const half2 * dh = (device const half2 *)xb->d; + const float2 d = (float2)dh[0]; + const float dl = il<2 ? d[0] * (s[0]&0xF) : d[0] * (s[1]&0xF)/16.h; + const float ml = il<2 ? d[1] * (s[0]>>4) : d[1] * (s[1]>>4); +#endif + const ushort mask = il<2 ? 0x0F : 0xF0; + for (int i = 0; i < 16; ++i) { + reg[i/4][i%4] = dl * (q[i] & mask) - ml; + } +} + +template +void dequantize_q5_K(device const block_q5_K *xb, short il, thread type4x4 & reg) { + device const uint8_t * q = xb->qs; + device const uint8_t * qh = xb->qh; + +#if QK_K == 256 + short is = (il/4) * 2; + q = q + 32 * (il/4) + 16 * (il&1); + qh = qh + 16 * (il&1); + uint8_t ul = 1 << (il/2); + il = il & 3; + const uchar2 sc = get_scale_min_k4_just2(is, il/2, xb->scales); + const half d = il < 2 ? xb->d : xb->d / 16.h; + const half min = xb->dmin; + const half dl = d * sc[0]; + const half ml = min * sc[1]; + + const ushort mask = il<2 ? 0x0F : 0xF0; + const half qh_val = il<2 ? 16.h : 256.h; + for (int i = 0; i < 16; ++i) { + reg[i/4][i%4] = dl * ((q[i] & mask) + (qh[i] & ul ? qh_val : 0)) - ml; + } +#else + q = q + 16 * (il&1); + device const int8_t * s = xb->scales; + const float dl = xb->d * s[il]; + uint8_t m = 1<<(il*2); + const float coef = il<2 ? 1.f : 1.f/16.f; + const ushort mask = il<2 ? 0x0F : 0xF0; + for (int i = 0; i < 16; ++i) { + reg[i/4][i%4] = coef * dl * ((q[i] & mask) - (qh[i%8] & (m*(1+i/8)) ? 0.f : 16.f/coef)); + } +#endif +} + +template +void dequantize_q6_K(device const block_q6_K *xb, short il, thread type4x4 & reg) { + const half d_all = xb->d; + device const uint8_t * ql = (device const uint8_t *)xb->ql; + device const uint8_t * qh = (device const uint8_t *)xb->qh; + device const int8_t * scales = (device const int8_t *)xb->scales; + +#if QK_K == 256 + ql = ql + 64*(il/8) + 32*((il/2)&1) + 16*(il&1); + qh = qh + 32*(il/8) + 16*(il&1); + half sc = scales[(il%2) + 2 * ((il/2))]; + il = (il/2) & 3; +#else + ql = ql + 16 * (il&1); + half sc = scales[il]; +#endif + const uint16_t kmask1 = il>1 ? (il>2 ? 192 : 48) : (il>0 ? 12 : 3); + const uint16_t kmask2 = il>1 ? 0xF0 : 0x0F; + const half coef = il>1 ? 1.f/16.h : 1.h; + const half ml = d_all * sc * 32.h; + const half dl = d_all * sc * coef; + for (int i = 0; i < 16; ++i) { + const half q = il&1 ? ((ql[i] & kmask2) | ((qh[i] & kmask1) << 2)) + : ((ql[i] & kmask2) | ((qh[i] & kmask1) << 4)); + reg[i/4][i%4] = dl * q - ml; + } +} + +template +kernel void kernel_get_rows( + device const void * src0, + device const int * src1, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant uint64_t & nb1, + uint tgpig[[threadgroup_position_in_grid]], + uint tiitg[[thread_index_in_threadgroup]], + uint tptg[[threads_per_threadgroup]]) { + const int i = tgpig; + const int r = ((device int32_t *) src1)[i]; + + for (int ind = tiitg; ind < ne00/16; ind += tptg) { + float4x4 temp; + dequantize_func( + ((device const block_q *) ((device char *) src0 + r*nb01)) + ind/nl, ind%nl, temp); + *(((device float4x4 *) ((device char *) dst + i*nb1)) + ind) = temp; + } +} + +#define BLOCK_SIZE_M 64 // 8 simdgroup matrices from matrix A +#define BLOCK_SIZE_N 32 // 4 simdgroup matrices from matrix B +#define BLOCK_SIZE_K 32 +#define THREAD_MAT_M 4 // each thread take 4 simdgroup matrices from matrix A +#define THREAD_MAT_N 2 // each thread take 2 simdgroup matrices from matrix B +#define THREAD_PER_BLOCK 128 +#define THREAD_PER_ROW 2 // 2 thread for each row in matrix A to load numbers +#define THREAD_PER_COL 4 // 4 thread for each row in matrix B to load numbers +#define SG_MAT_SIZE 64 // simdgroup matrix is of shape 8x8 +#define SG_MAT_ROW 8 + +// each block_q contains 16*nl weights +template +kernel void kernel_mul_mm(device const uchar * src0, + device const uchar * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne02, + constant int64_t & nb01, + constant int64_t & nb02, + constant int64_t & ne12, + constant int64_t & nb10, + constant int64_t & nb11, + constant int64_t & nb12, + constant int64_t & ne0, + constant int64_t & ne1, + constant uint & gqa, + threadgroup uchar * shared_memory [[threadgroup(0)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint tiitg[[thread_index_in_threadgroup]], + uint sgitg[[simdgroup_index_in_threadgroup]]) { + + threadgroup half * sa = (threadgroup half *)(shared_memory); + threadgroup float * sb = (threadgroup float *)(shared_memory + 4096); + + const uint r0 = tgpig.y; + const uint r1 = tgpig.x; + const uint im = tgpig.z; + + // if this block is of 64x32 shape or smaller + short n_rows = (ne0 - r0 * BLOCK_SIZE_M < BLOCK_SIZE_M) ? (ne0 - r0 * BLOCK_SIZE_M) : BLOCK_SIZE_M; + short n_cols = (ne1 - r1 * BLOCK_SIZE_N < BLOCK_SIZE_N) ? (ne1 - r1 * BLOCK_SIZE_N) : BLOCK_SIZE_N; + + // a thread shouldn't load data outside of the matrix + short thread_row = ((short)tiitg/THREAD_PER_ROW) < n_rows ? ((short)tiitg/THREAD_PER_ROW) : n_rows - 1; + short thread_col = ((short)tiitg/THREAD_PER_COL) < n_cols ? ((short)tiitg/THREAD_PER_COL) : n_cols - 1; + + simdgroup_half8x8 ma[4]; + simdgroup_float8x8 mb[2]; + simdgroup_float8x8 c_res[8]; + for (int i = 0; i < 8; i++){ + c_res[i] = make_filled_simdgroup_matrix(0.f); + } + + short il = (tiitg % THREAD_PER_ROW); + + uint offset0 = im/gqa*nb02; + ushort offset1 = il/nl; + + device const block_q * x = (device const block_q *)(src0 + (r0 * BLOCK_SIZE_M + thread_row) * nb01 + offset0) + offset1; + device const float * y = (device const float *)(src1 + + nb12 * im + + nb11 * (r1 * BLOCK_SIZE_N + thread_col) + + nb10 * (BLOCK_SIZE_K / THREAD_PER_COL * (tiitg % THREAD_PER_COL))); + + for (int loop_k = 0; loop_k < ne00; loop_k += BLOCK_SIZE_K) { + // load data and store to threadgroup memory + half4x4 temp_a; + dequantize_func(x, il, temp_a); + threadgroup_barrier(mem_flags::mem_threadgroup); + + #pragma unroll(16) + for (int i = 0; i < 16; i++) { + *(sa + SG_MAT_SIZE * ((tiitg / THREAD_PER_ROW / 8) \ + + (tiitg % THREAD_PER_ROW) * 16 + (i / 8) * 8) \ + + (tiitg / THREAD_PER_ROW) % 8 + (i & 7) * 8) = temp_a[i/4][i%4]; + } + + *(threadgroup float2x4 *)(sb + (tiitg % THREAD_PER_COL) * 8 * 32 + 8 * (tiitg / THREAD_PER_COL)) = *((device float2x4 *)y); + + il = (il + 2 < nl) ? il + 2 : il % 2; + x = (il < 2) ? x + (2+nl-1)/nl : x; + y += BLOCK_SIZE_K; + + threadgroup_barrier(mem_flags::mem_threadgroup); + + // load matrices from threadgroup memory and conduct outer products + threadgroup half * lsma = (sa + THREAD_MAT_M * SG_MAT_SIZE * (sgitg % 2)); + threadgroup float * lsmb = (sb + THREAD_MAT_N * SG_MAT_SIZE * (sgitg / 2)); + + #pragma unroll(4) + for (int ik = 0; ik < BLOCK_SIZE_K / 8; ik++) { + #pragma unroll(4) + for (int i = 0; i < 4; i++) { + simdgroup_load(ma[i],lsma + SG_MAT_SIZE * i); + } + simdgroup_barrier(mem_flags::mem_none); + #pragma unroll(2) + for (int i = 0; i < 2; i++) { + simdgroup_load(mb[i],lsmb + SG_MAT_SIZE * i); + } + + lsma += BLOCK_SIZE_M / SG_MAT_ROW * SG_MAT_SIZE; + lsmb += BLOCK_SIZE_N / SG_MAT_ROW * SG_MAT_SIZE; + + #pragma unroll(8) + for (int i = 0; i < 8; i++){ + simdgroup_multiply_accumulate(c_res[i], mb[i/4], ma[i%4], c_res[i]); + } + } + } + + if ((r0 + 1) * BLOCK_SIZE_M <= ne0 && (r1 + 1) * BLOCK_SIZE_N <= ne1) { + device float * C = dst + (BLOCK_SIZE_M * r0 + 32 * (sgitg & 1)) \ + + (BLOCK_SIZE_N * r1 + 16 * (sgitg >> 1)) * ne0 + im*ne1*ne0; + for (int i = 0; i < 8; i++) { + simdgroup_store(c_res[i], C + 8 * (i%4) + 8 * ne0 * (i/4), ne0); + } + } else { + // block is smaller than 64x32, we should avoid writing data outside of the matrix + threadgroup_barrier(mem_flags::mem_threadgroup); + threadgroup float * temp_str = ((threadgroup float *)shared_memory) \ + + 32 * (sgitg&1) + (16 * (sgitg>>1)) * BLOCK_SIZE_M; + for (int i = 0; i < 8; i++) { + simdgroup_store(c_res[i], temp_str + 8 * (i%4) + 8 * BLOCK_SIZE_M * (i/4), BLOCK_SIZE_M); + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + device float * C = dst + (BLOCK_SIZE_M * r0) + (BLOCK_SIZE_N * r1) * ne0 + im*ne1*ne0; + if (sgitg == 0) { + for (int i = 0; i < n_rows; i++) { + for (int j = tiitg; j < n_cols; j += BLOCK_SIZE_N) { + *(C + i + j * ne0) = *(temp_str + i + j * BLOCK_SIZE_M); + } + } + } + } +} + +#if QK_K == 256 +#define QK_NL 16 +#else +#define QK_NL 4 +#endif + +typedef void (get_rows_t)(device const void *, device const int *, device float *, constant int64_t &, \ + constant uint64_t &, constant uint64_t &, uint, uint, uint); + +template [[host_name("kernel_get_rows_f32")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_f16")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_q4_0")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_q4_1")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_q5_0")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_q5_1")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_q8_0")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_q2_K")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_q3_K")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_q4_K")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_q5_K")]] kernel get_rows_t kernel_get_rows; +template [[host_name("kernel_get_rows_q6_K")]] kernel get_rows_t kernel_get_rows; + +typedef void (mat_mm_t)( + device const uchar * src0, + device const uchar * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne02, + constant int64_t & nb01, + constant int64_t & nb02, + constant int64_t & ne12, + constant int64_t & nb10, + constant int64_t & nb11, + constant int64_t & nb12, + constant int64_t & ne0, + constant int64_t & ne1, + constant uint & gqa, + threadgroup uchar *, uint3, uint, uint); + +template [[host_name("kernel_mul_mm_f32_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_f16_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_q4_0_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_q4_1_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_q5_0_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_q5_1_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_q8_0_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_q2_K_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_q3_K_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_q4_K_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_q5_K_f32")]] kernel mat_mm_t kernel_mul_mm; +template [[host_name("kernel_mul_mm_q6_K_f32")]] kernel mat_mm_t kernel_mul_mm; diff --git a/LLama/runtimes/macos-x86_64/libllama.dylib b/LLama/runtimes/macos-x86_64/libllama.dylib new file mode 100644 index 0000000000000000000000000000000000000000..f3e412128d79225a2fae5e1115e0f085d26788b3 GIT binary patch literal 981616 zcmeFadw5jU)jvLyOdvq;OcXR~grE@#P$de=C`txq;2f9{T0ua$DMIzFD3TdKD-xWE zD9Ra*g>VtVHNVeipEHw5(DwVj|NWjP zd7jLivoC9}z4qE`uf5jVdp4i`*ZIyin?2oTvvtD%rT8D;&1Net$;Ok-b~*lYkU3+< z1n=YtBB||1N!EA1XCRgTU98+0GXk?01zL-?hga!0^R^E|rT)#BG3(Jsid#F}9$uaWZ_r(4Exwap-}g6T#*b&snlXFPtl9GdGXnSB z-yYuheI|Z?7+^x+dn$hI;R3(n!2E|E`LUJJ9^UaRb6l%tnFSK>2{`Rx&zSM({r@#< z#;k|$D=vQIzPYp8!+U+63D0Q(NWA|Ccynh59wfL6#^ZepUVm$R6Yt*-FZjs9haPzV z!#w9v6l#y3UTorb)+D2i@9q1TfX#2ti=AMo88bZY3GNvq$K83CIXe>bp@^mM*Y2I@ z@}FZ(T3}osZRL{hhu4r`4#2azjN0a$eOWx29~bgnTl}_^n*H3_-7L@d1W%`cNj?JJ zoK!|>-``a)n(&G;%_@9P#V-lSdPwDyhaV~qw1=nv%7kZuv+=zhyaWpgh!(tu=HBZCHk2V0^bL(+$wJaymtLe zi+^;<&aJDYx*+vxFSqQ{jPqzKd>Rz7k@4{3>H+fBRWY@I4hClD`Yy z1NQ~)v+!+;-%bnOcncoi+rhJP%&!?UlAyj5UcdDweuJ!9eE;|G?k{d#EiN42nHIcL z_ar#4?fPSpHHjnV+1$C0K9WdiPrsR0^%Pmol-ZR!&)UPIJdyD~V}?(;bF9~+n9{^% zD`F1+5?pIe+2>eWi#az-Pr(Jr{{CW2U9=zeUP@=cRgMlm_7Ff-$VD$zia2e_vqs^>Y%bH{3mYe(^(?yf?U0@&V}r_$|Lhj|bZS4g67$1|I=41KM}NA9+J- zz6F0Wz7zO6(r-l9|1JLh*@62W{w~n&8$=eMeFxsQUn2EC!yWrj;NO5ou7GaBPw<_f zdwvga1mFjY=acLBKWo5%>kBQ;BOQn0KhaN{?Yaxfn?rW}h$OS3JnKD}T2Ijb=l^be zM?N}#b}Nm)yEkpiSnagMZ$DDo_J&lGSEe8!nf&1iH%VqReUWA$N4MO{&iw@uc1>vgwxv&rgSxpY^sNzv|5>cu5$EZgN? z_w;G;KO&zGz)0Y8*Lc)I>Ae@woiY%_sfA`096j!}Z8qq9Q0XqLA*%k9iBhULw(W{9KvO29wRu@O5@IEx`Q@vXh*GXyFrGSHG z&XM-|G+c})tJOZuyJbwh<4dObOHVx210?mSbw2f|U#-)9pr&7Kk~MGDn21A{Ls93L zNYqW4KMk!DFU-AuGKe*@_xYuRJe9*y9R zr~1ess;n*E0$R!HXFj!B&m%!mN>O*R0x^_B^`KX7Gw9W5(W?{ag|Pv>dVe>)nk{<$ z?N+nl6q|3%vmZPKbceZFV_wZ|1_2!HfN+{|c1& z)WiB3S2tU{7&V!KX?9ru15(!U`W*d_c&csg=dGx1&gQ^W%Bt*SLJ1Oza*$Gvlzwu3 z5pNH&$xCZE>p#7v8@>zfo_$RW_YtNyp`4NA0Ef%aDEeb^rQ^VgfZ*;)}6>p`o04SgeH>Q(r( z>wVgsOuy@^fTUtg-zuJmdBeA>)R2;=4i%U6QsqZk25uLJ&q!#?$l z96OWFQM^+s+XM*#YUuZ1Xk;~psa%Oxc8V#jdZR>JRze4wWp%Txe&|yV`P9?88~vBn zPa$sn_Or%-1pktkq^wl=CiBfHLR1eJQmrMf=zz)Dw(uUzl*`-UvJs9MOtMvp%8CQ$P zGCp3WzrZi2NLj$g41Ec{q;9%Av#ZVMWH^j811w!lM1``2savJH0Gn!6^^M&iq;1R? zOQnyK{I2oP<9ynZ98RQ>iZ&{b608Tf#26^`F2OLMs*qooUnsvCZ=(FFRL&z!d>&FveKl1+<)8=V zN-`Ds=)I!W$SQQJ6Z#9ULIDg_=lCO!2l+K$evYDf z^3ikX4VQx93b!fm{`D{BpOG)}$XC!tF&&|MFayej-K;erODKY}YjbhA;;NRy%K+3{ zxWTw;PC20{p_ttVEu^4Hjy0z%(wplQSFCvT*oZ^%X^uLd%Tt#b_^fb4;V$DUblA>B zS(^ZjwqU&+I}L3tmI)bA{C7p0Xd9#TIIY+le78AH2e&C&5A-mQk9D@kdfC2lj5heZ ztoAq$^o`Ym|Iu!oyz5gNF%~(gTnbui!}7^cPM`WUWlGC5Fk(8jQ1yTwEi@T#%%Ify zM%IJAubv5=ZwYoSY|)Fwu+^!5r$$o+`rF>&9eD|PtR9UW>{WR5p>4C(&JP1a48tyU zf_7G3dg>)e%fPjAWS(99BzCx0;U^D$!b0{P_Kl(SyVV{V)R#2$JvH6O2I4#9&6ntPv$#q!CZElT#?C@OpXj* zrmy;Sy3JkZ$#>ehIA)67Ml*Wi*YfjgVox|d`HtGt+1~B7r>92su^3UHJk0hS5A1Vz+=Etn_C$u7#A75pk^t0`Idvt2n6)m1lHUSs4PWS z-^#2#I2kkOjH9@7;fDBP^g)RPNWqaU@9@S(`Q$#S91Pf0xB)w)`7^@Xg7;!^mP7l_ z)_n1J&U)^h2FmJ2=(DGt^6r{1AL}FQPVsd-k6)RCYMZ7vpi9hr{4!a$i?8Ep{K~`( zhzdjNthOChB^%QI_FPhZc@>#_gq`%JjHCbgR3((m1Fs^(H_1XBkrI-^r|C zOXP!NDx^q1FpN(PR$`O)2FMG=phuAs@t;@JkCd&4WOWN^ZUlxldrYPh837%Bo1(6lp8Et~{jMEP8e=1aFP1}fQ2To< zfFyhwi!a_|X+BqcaSkZudD&4DTXg+sr!0*=qC`e#`J~a!DD)#zeH;KgJc~t*>x})T;yNKM{~=e` zNY>409LVG~MTcz-W+#rLOE+g`z9SgqJJeQe-bzDZulFUdEbaq?@ z%7V-!EXZuUE0)qo)-pF_u2gCW;x-#sc+@LWm_HQF@>5AT51o%R#h{ukxwRs;q-fAT zL_==1hz%*KtxY@T5P;m+;DX)%+oSas#D9;YDXXW*O5m9``vo@iBWpai!onpj`>`00 zZEkHurs~Fcq{*sXaqW?o-zmmp@RjCdbYL>}Scdt4cXKkng~lc<69e)i=Yl^fq@4PZ z@v2`vZCtKm)@6?bmt>EHzOf!X-6(~7SUtt`PxKUxvZrX&>gfoxr)lkbicX$(PRd2a zjlx7CjSj9t3V86eb2{PeT=;U~HfBpNucvaQbw&<3@s!cKl?F(=+v@(OKFFPAcd?i1 zF>OJn`WTwNNmdIL*A8j(-Jce~K^bH3pbo?c6mCfJr>h}Q1T?XnIxZEG3B(1|*!-`2u2b_HWp%7I1=iogDbUzD1)N+j zgpEUNYDKx=PUEXoj9b?a3ty@fU@j>X5@M|A#Quk9&_Z0u6G*hQ z`M1d0C7`)?ckSsZ7~0VK9wN`^k=PGVxQaQ~5Ez7((iZ%S{m@(caeB)CV?Wx`TiA0$ z-z*}$jdjUrN!a!X*;RXToNX zG?PK(V$-%8_eWzhSON1DjkrD-$z%E*Qt2L~-x(Ra7WCqdL+^2&*hgR=yb4TSf+dvu z$8xcIIH9K@*9Xh5U)`H%Cuy5NJLdy;!B|FX+?|nu7RbYTtS`5&*q3;@A`@Jcb__f0 z7zel|c?0=W^?aJBO8AO>k5aHFc!^N>V64Vo(o71>S7PVWAh}k_nz;@rq4Q~qH1eZj zN8vW(R!nI*^!0f;vM8@`o6uKA>(I+aLutu&yojOY(^Sm0Y|o1hj3jir`W)G{Blz)& zm_5)FQ|3n~K0X&p~7^d5_4Jce5rN-!pw%`Aw zU%tOXW=)Mj5@$Q!k|U$+P;6mjs*_#ogN>rkj=~ehJ+dk~To`4SGvt2UZc~4Gaza*^ zpA*8wW5U!h@tE*HcqYEGMOL<%m2GBaBMZ7DP^=3=2|XIPmMU<@NiZJv@4&*D^;T`u zga+c1^_CF!uA{*Ne%D!Z*Fv_$Zq1snkUKU&b8t6)jC1Sng!9as9HGc#XR&LOL+78A zp5|^yjvWFwK$GLX`#_@->G3}M(oh&}6*)lK*&|&0&GfB&ni|fl-9Ptu{bs{F}q)FP(qD@GaHmh5kzpk96OxB{kVEQ^flPHc_!F+Tl{aNN$9{?`Q+Zh zZ5BP*fvlJK>3d0Z%J-7!l<%dPOkDm_2`ZUS70IV)@~JWTWCKQKxxD04QSu3f9V@pa z`Bag7iYA{L@g#>1mH>H&R5}B4M}|IiEA}fdfyOiC*w^St>*zrqoXz$*E5v71d^X}U z%PC+$2sHX#u>iMx;UxcvosG#qv7#xz4pVP6%7nf z)Du4KX6}w#yy^jW=m42F9d1gxg^Gu8bl~KPA4H?pY9(AZa0GD)L@JU~{7LcWVXjv~ z`_C$o=>x6GsiWx;XnHX@og<+jWDBnnUdCdD$@Xv2KSsZyHzbn%4Yfz7Voqj@8s07X zYBQe}2WQ*NkzAfo;>GVRLH!g3=3h_%HVUj`)r0)5Z=}*`=oYu%)3MIZW&eD3-5(kJ z4E?)G>_FPM$gm}ayIT7MdjhbdP<8Y&8^~_o07Vgyg-!&cL3Nhm+8f*`YJCqy-D{}< z3Yk6jYFa@G1U*E;jaEV)(8RQXDqXk>D?8SA=*XBx5ssU2Qwn~R@|~erIDG0_>O4O6 z2#eBDjgAAGO;TtqgaCH-vet<@uA`ss2X6v9YaFJ6{LK?e*(Q;H0}9F@0ckZ`lLt)O zqNtz4BatRN5(%^YaACIJ4&{hW*R819)XwTU)1OUqWH9(=As z1Jc)DMfIl+%cdwmlaS-TY3;|J;i=1L3{Bp>4%K5k=ze3TK{eKef3O% zu^<7Q`s7}@G#dB;WVb#E;86qQ!wy>|lse-YZ{dkH?JQYopySAFr8BfG(jk?UPp|$? zH!H;6qNEE3{*0Kk>d5Dz_n zWj$Q=OY7m*i_?w zYKd=C9=|4RD&p7FO*4_b3I8ACe-Hi-FnRf=5_FzVFKw!@o?h7$wVwX4sS!`uG3C{+ z-5#Z)8hmk;JupIGzh@R0{M>fYm7brPFWZ=N)pqkGflJK91z*GkU%&;%q9EM%)1q*% zs7+WZkMkw5zfoZ*jAG+cXQ#^4Bu7k%sd{0Znphze_VZkUeh+Jrzu*AE5z=LCwG+dE zI>JQ{OU!9!gt8o=1Bz=iY}C*=w5&~v2JcOl0!791ENq`L6iKXxpVQ*G(*T2D*j?$>pm)r7Xe@991`D)Rd$gm=P_2uR) z(ac_?Q}#u2?}f7Y3j5+#J+Hv1;f26(yy7c34eTodZR%_oA91(RY6>aDcES84(8p!2!7dij{tZ*-yiiui#AJ zE=3!P_y#K&%_^9xlGeWd^2s{A2R>8^WcyN6?P+18M2r4J4pB{2Kpqq+Ybg+^m0-MuRMf{a zeQ6C9j8v@%)4usiPWx4MsdOD2obj{xkRt+sK6fb;BzhSUF9rDmFXI3Yy^MN3zf8^P z&wr-o1R>R6Tm;`v0-Ku*nCPpGT#=MSr@;7$NHAGS4lQo51+TKI1p8z3EWCprip=XT z6}@YKr*f74{AI0Og%b@i5sO7iqDtT&hSavP_Y-}ez=D9cr)R3KDb>DCYfcW89V`#9 z;PGBwv zmT=dZ`S-zFF^$4E)M$DuMUpB_{SBx?J z6#r<;X0)0N=FS~%A>8Rd8&rmBpkB<7^(9`li?r%g) zV+pyC?07&pA^!o-hv^XFj==z{2d{V{r?zp@F1&vjyyywq6aN|PBx!G>JUJqtW*a!R z@i`$sSAP(g$nbX06zj{`0(iUYJ^4lWCBNam$dmbbtphx#oDm}G9xia}0W4&Lv9HJ-TWPT4RY;cW&^Ru6DelixtN2mHRS*oh`!^zBGpwQdw zSEw4AuRsKQ^knFR{QmYCoIuRqYp(ch?@A`cI&qP5z}eBV6;USaNcU#?Bi2 zOH6gS&q*w)%^*`?HzMc^$y&c%^PPb!W$j{ydq7l;f#dr~;Go>+Q`vPYaKNafr*gtC zX$4+i+^P29^iK>&?ZGLZXk&WRzT5xP+ApS{@BQ|H_|MOQfUVs*X@8u13aq^eoc{|l z%eWTn3~-LN$Jq(J&hB?@mcpN+v#>)i89NJ|gL3Zra3TB<4RV*ASSj)X^YC1_O+JZ` z)g4%vo2bnK-=S@{&qX%ZIA`D7N_cbr1H4hlrzLlb)GaBm#QYlX(faylo%JF98MtGK*%FwbL`JnJ zrFB6+T>Sn%=gg3)E@QOZIPty02)4G({&-xooKo0}eX^`wi4uW{Ts&X`4}2x}iNWU? z_}my_6#3P2hyq>+J43Ut3&J)q;@$BK1>ocfMg7?5=2069x4BQAaH}74w*y-)n$$Ua zN^b+Fugd{-bk#}1ReRK#&ibMrB$!WKlqu7^%Jx~U2tMbieNleRzSI4q=+xtbeF!a~ zZR|*BA8cc>ntez6Z>T*wd8^TzZiKDzP$QBXM0uLbP-oGmn%L3)I|vZ-SnK5Zi3<}>otWGg3 zZC#^X(bPb!@Ypm@&A9y%Y#{Is+xzL^a-UD+E}LanGortm-D@FlFx^}1P-!Bgq1)64 zXDKA(w+rS$f!IPr`JG$SY;il<6@&DT9m6ad`t-=D0}VcaTb_4Al6*J|A>! zxQ}DLE=S~8JTJIT5MSM5e4saXr)pQr-utw92y*;(VYw7~C6&UZQCJ@LebGN^^lVE* zB$0+D<)#-Q6rp{GeHWV@j+!0b0@9Oa^RGLmNL3$&PT3bCWCwni-WbLfSz6l=Ix_sk zry>qU{%50+$qnw^#E`q~5jwDwo<1achA=)j!4mA7t@J^-Ut)xU{f#l?KWwg({C9OL z|9#S0GH|sOv8`Ti%xz`LloG)`a^y~@tljOD)k|b`x^s*QF3{2`v2Ftc0tGSn!3?=i zgK;$}eN`)^16>nCWxx^%hKEejpho5*0CZFiR~N{!ogyfwHKvzyAKKhg=r`waW)?S_ zVKRN&`HZ!)isM8R#LL1`0oM?;yK{PQIDK37jMG7Qmk%NbVzUqJk=TP_lxbIo;~Ehg zu7)7&kw>K!UMvN5-cPVi@($8U&H}Dl8lcdF5v`4Fv5m=04*fI}NX`|T3@Mz3JvYp6 zVrQYQ?T6|xMDVNu9M&ZOi3!6K2D37yP_>XD=`aR7Fha{kkipu?C=M=%5o8BCbK9$I zJ=m*c@h8A~+A67(Tf!3}1lt~XJI?6TIpxoa_f>Y52wpu5QJT*py=3ha)I}K6V!X(a z)qFGk``DOJ1Gfd{VAo26Qpp`QE-=DYBx~ab0gpjQ*8kp_Q)wD}Qo*Rtb*vc5L%&ky zATB!{<%{qrt0O^8GX`B9$>^6n?6s=mVNAosep*W(QSYe&SxQE^MCqhjZI zKZ+}{uQSL&MQ8-u-V7Xe=%?6)C5m0C`R$@?M?Y*J*_kowgnsCaI7-6j9GDKlAqWgS z!$2)5`~ql+y=X=1f?%s{c8+WWN!*RHb{9-AKWxIw*haa2Bx5^3!MmD~*bMciQI6cz z2vv?AjSZk|CBhou3S`8)w+f~y>?J-6<`{RRf-eFyp*MR1{SdE#7M^J2ii!B~Cv<&g zSH@qa0w8i+k{~qp>TYC1E@AxO;m{^GV;sxyjsU~D;sU?g*RPI(vvfKXmO8jom^W=z za)9oJ<3E0n7^TG}O2K)*dQuoVK1kRFeA1iemB={Q1zLChTcu^4A;W#DFg1b^Rwj<) zV7H9GMOk_icB)((R3XGPe=5IYnG`ZG2SrRX!poqxFD!&q~+>8HO zwuGS`7YUrpL9G%&3_5(FL4uN>=qEEFhDh2}3JvB?dML<*99USyRL2<^PJE-2nDhTq zA`=i;X-+2*AQ{Ke8~v|c$Q7@W{m>7wx@0v>JCW{@2EQ9zis4j2#)>n?$P5XKKEYl0zMO~FD=ir&b9!GIDp zMe|B+-UCz_|9dR38S%ehqeTh+TcqoaoymXtnVVoJxDpnGO1<(m7!#a&oGGU1;QA3F zKzZ5Vu0o%qLIuQvk8`fma9mnS;scj!J5kfwt7`yC)b|(@u?X;KyD`?d0+G#^a#7HP zY~mc~s?TKm=}1k8#4Kb}qUocM!(n0d6$ZjQa0bMDTLwv8MygyRikL`*e=5d;lTe)C z=wV#nN(9k=^ZZ8p{sU!keuEL4Rr*%EvM2Xuq?#bac?xYAR}(sfz9Zhxt(t4r`NRna z^90Uw07tC^W-DJLsq?WVOsoc3`{^K$I(xfE{TjP~cW6Y`f7jh^gQ9Z3TdfH-cafg1 z6Qpf~2y2Ed7}JXDVd!l3IwvyVyF07*7eq(6`Jzn4UISy7p3hcce4{B*oraFh22l>{ z-=a?lSb%hnlUvY&`{ZtS=xmqy#Ud^^+8nqWm{t({dlvZJ9L@$*BzW15xa@kr{Qwln z3Y1)>zl$8v68T<*%h@l;h*qO)F@$Uk+A1x$-RR>}<39VoP;;hF@}4qWq2^{J2f9Kp z1w=s-#&Kzj26=fhh4&BbirR}o>0~4xdJ^YH>>$<1I>#ND%rvjo z3?)~l2K7fBZG!sA8*h$Evl*D`85fbw`nV`#YPh@_J zTUz6#Gs+&02JQ@%y4Sq2)y(RR;Spb;=*^k=8W2yKM4Airdid5`=<#)MHC_8eK31kiTwq5BiL-Q-G#jq4Zup z6vTY$hr&`%+q|n;T6P{tqBpIMI-l#Gu*B0Dii40<=Ajx;rc!aWNXvGibkaR{4HyV! zaA*q9Mb-g4|6m!q$|iTSdDQ%su=#+tm9)XbLx4H3QBUWvYLrb^eKs18>qI411E4!2 zSyhOiT}eWkgR)o*iXS_Mi8wn7-1Xnt$?#Xb+NQFiev0~)sSeO&|DlY;&)}mlnu3z_ z{6lEic#eFK9OL*%6iYJC^VL|SahReN#nzG--O{7TCL72gQv>5WLswz2+$OUkm=KOv zp4bRR{c3%DKC&X~>HX@1xdT0JR=@tMb(1#zFs<0EOx z)>Ambfel@Q&$Si9v>7B06i}2Yu2a&oJ6TxWj1h{k6@95qu)3ciqKm5x_)Ma(Kb5)b z9V?j+U&l(C=`hw$OiZ^EDs&$9g|uR*?wt5Cv?tgPzQ$$*F>jE!!Uep+y$&ebD4%^UL?4fY zyBKUn?EPv@lGEO45qbdm!=f*jr1ng*KX4J;Y<_iON2x7!9KB!-vzMa_mdY z^~u<7v^OP|9pn97l2@G(oDz^@G5k1w1H&1`#IDoWW6-D`1!-W5$! zs=jpYd*kzAu(?>dZ6apBIQWMXRB#A~f5m}-E1PXDLn}OMg9R>AE`VzY%I|v#)fsB= zPS7}t0fEclOxpZ~&^W6we&^jEj6xK2M0T%rE~5=1E= zf>SvuIlOYnu+P6nAOQv6sG{Vri7m?Rq|}e%3T=Za159f;z}jGwi_Gl+m%BDZ)w2eW z95?fSFyn^kCvArRDelOeSFjvE|M^G-Dg|a0-b=suT&Ulj5qlwk51glv&s@V|x`Pg2TV|hf;%wE*x!EZ zFR1mYMnZP`prb5v00Tw|Y(3w8LyK60YQHq{ICnM(UFH0h!Y={~G;1BgZlr6#RVOX` z7y+`FX~NU0kHg4_*j~XMFj6^1aYmCkUcuCV>Qcc~kmU#UThL9gP?W5M3k}{0HClFkOd7X0-(Mgc{z%RO%oUg}rB#(vIz2YyaMduu>c})O74nN z5kgOVxb7nKrSLfN(3KcpY&=_OBj#hx(nU_kTeZ#8MLx;_vFk+(1;q1Gy!N<mHwe zC_>(m14Cwpx5BQcx5-VM(0HYy{=+xx6l_1x-P7jZq(tr( zY|#l}{%cLHI3nPK{#`A8*l6;@deFQM{6HhT6#fkcoE(jE*#Kn^ic@$vIr*qxJ&Vw{ zR5sv#4L!ET|JNL-slRrljQ^<%#{buVn;d_U-DdoMZH@o#;GfK0Yo0a!sFxgnR%v%uV*LNuZu~_Ht>bSs_?_e5Ca>N2H(xmZI8{=E z@&7Wo454PkRP-b;Fu9))+>YK(kLiE1>T`N!JAQ5Qz~12J*zT2XfCQjX4%LOJM0)P0 zLY|tT`9QF*9q_FHd zT_pXio~OlrhS2KIq@Up=?Q!X6)rBXD!qBZ5Zc-F)of%kFumf>LIn_#J z(PRV;mLp`>nFUrr6!a^#-%QU6bmfn$5=Rfm)rg~qLv}LZ>Ypit{eK6WlWAv6_A1a`%6Q;2 z276Oe5cU9Cu?4zAok3Ydm|RKxpvk;;jOrftThw1h|rz?E!J~jWL{SUc(PVzwpnJj8PBLa z*gwX4+x1m_>A&}u@x03+eN1&r3!Lau_zNKC*Jk6mR!xgMYZuoq_XqS6LPas|Pmce= z{+nrNsrmimeLRDXJ8ORbSf8vxkn+>HYIw0YT^iMMK?Wh)G2gHvbjK^>Rij|&KK@D+ zo`S;t{N=Sxli|L?$tl;~z<(*BZ|w6Qz}5mLrnE(u*6ce7Zy3a7Iam0{pE3Fg|8EvORDlp3MMmzd zAH*O6&B#nvJ30kTWn(4d;feKTc`rIJNrdul*H;`zVT2(3idiB|**UQi0RdQcr~51P z1tNRk77^)g68?uZur20ZOK&%Bdok_Gme1QX3+XgAsnvROzBpJ#szU)sWYM-j0ngRo zzf6vOk%p79KT6nFTsh!IoGgUSay)nxK>@(2C{r&LU6}-gp-OCF_i#>gigyz+#anh~ z{Y5m=dR$Dn&{Ct}^}F)O(e3zg={IFSQ7~d5lv$pxQqSlzKq0!Ewo~&+)qyA_Z#%b_ zI9>(sFT!t0V8|&-WD#=;E&2exS=N3P$2|3qj!*&JiLE6q0pQ+B{8xRDDcBRrEFupf z24&#s_0wwZ6AIBiZE`BVlmT7-3Vz_VwZ?96Y zIT64pLKcA~{}9QHyHzfu_ejN=*K?LDH5o=rB^z7TgHVg%yP!@hg_i?Qvd?nt7N~+K zu8*Z<2Iej_>^G2S)Bn{ZG;E(HYCvycF(Bt%&hep=-SX6xl!@v`*o@;?n!Xt%;Ylj9 z1{@l%TS1DVv!E<)PYLwpl`Exy&B#qZuNi=_G%ia~u3MJ;*;tQ67O=b<@oiM2ad&`` ziEw{2-VirtC5EsZ`=bgXt*Cqa1&5??03&C*bP(zZwE2g4?s{q2wdf*ly1H4v2q<90 z%IS0A)&shn6dsCt7!>G9=Z6&&u{dnbaI78Tl)p`7yx_S^!rZ}2-NTn$cpA(vj@Hw?< zrdg%PtTNuLA`+*ro`(|QrV?}&56hb>%!iknqUOUZO^tW}OXXq3O$&xjthWblGQrtQ zaQ|-@z-`okBhY~Xn9;&Qa4&*jV%MiZ@PQXDr^V%5NMBx_ zj`0@iVARP1BM7Vga3pvT46?L_lfHFPhPH!_OQq?67%#+!wZK+lK1P8^r9KHa z)ERwKll2}~zj0`m|oyP?SZBmF7Gj+ln!-yWQYF!Y(mTLS zbl=>41q?$;eTwIwc;}0VyWMpa@rEn!5)pOFOT?~+{;Kr?2?Cet?<2c43N^v$i3kz% zG<0MHB80LOPQK%4F!ctpa+`yRBgkeiA!9gDx#f(XW*i2viA(0}(z2dt3|ek8^xErM`y%-3f9$;1(^eF22@JsDh9jY2M>?sW1czdA za)%aYW(4-21XdrG2=4K?9&<=9tv5dA!vda{{t!=D(u?bj_2ziu_?+}obkG*5lrb~V zbq3)p(Zl5NLO4TVi(4h^{AO%}DqQ*G;d`aBm)Rl6oeesnyb3 zDxd4?fY-d2ZZEuayp-MJ_l>hhXwL(!^;m=s>un?VwnuF-<@DH@9r^ z#8)5>omhplEz+_W>Od(v2jDh+=K*vWjy)r-FnXstuo0>+oW>x*Q`m&<ZoPd zN;cJfj;O|T1a;I}gI5k_gWa}te{izZPH-kU&ghQC%FVHs@dDYEcEW;|I^d~mp zJT5m>CodKH#uf;3ih8iJ2us-KRh#tzy{SBjbSw#&EDd@lrjTCEIs>5d*hBN6+=W63 z6;Du&&MD|W#7GN*C?^6VMfbs_J;9~CuFu5J!!d9YSD5~1c#R+n;RzE4RHhRBBMwU2L)k)^GY8)6!e3a%I($@lF`hB#{l1_& z_g(Z|`b{%vEp0Ru`e}uUG?4)4obZj8g9w(I`4A87HcZU?Y=xv+MGUQ zybS$%wCxTp>0y(eo68kNTZk2NbY8u8JAvRbC|tQ9h0h_Yb;6fCo@>KV@K6kkek^z- zKCDeH?lX+snaAA@j<|d9ZCu$}Rmc~_JzJFn`A|nj@Wh0IPT>BZ{rHS6+$XJ>k~{RC z-1#3HJFs6bc_J4Mt{qrFKqam{2+Jwlrmuj3tM;tZ48X*;2!Z8167O!=;n&7-?a%WS zK*ErQ2sF;{Yoo^_Kq1YHBbG*N!QCJy3?L}BU`j+Ds6^buun&WM!Rg))J-28#@X*U9 zH!|TY6V6I&E-!c) zJcYO;Z?p`xntDArqX7;tDLfWju4uy*t&3ZmwYn=XR&FjFUsR^V10o; zLH`W~k=p^BSRn-{4e+)%~^r;J&7eGz@I)a0n;1)Ka}62JE2JiqH}Dg0aHv>RWp zS-3g#4&HbPU&Na{lu>Xrkfk5k2m64TE+b5j&hi4i*r}X^eVZ{v`urOpa(Rj1GK3jH z@MEM;=%0gUv2kE?fgZ#a@Pie`zT|wwatggH-RO&reo7yt(vj$6oL4~A#7;d@2i<;3 z6lGDQANYKbqAtwAC_OrEC_a~r9>mXad03f>sMa-r@gY|b<}f=ND5AE5$zbY3u(r9u z1Tn$>N5LH3{|mE-_iLaC_!YYau=D9`C0XcSntwZP*--u4-M5YFAuay{R!Rd$I?c(3 zmIC9&q`{0C%^7ofDn&61lk=qyTKo6&1;=-((<4@`NiL|vow*41ZP73PfsnA{K?_VC zaYKzhv6nf2m?&5#Ie)OIQpTh%s_^TA->?f6ORp(Aj_xsK)svs6y1cFX^VMdHdppbZ zqw@gGRyVqjy}mP3FC;0z>nuZ1F6sWsOWa*RSW9MzH(2 z?DA&3%kN|^w%NMk9|dxND9caAw_IQHAins=Bo0VjNdr^(x(E;aUTS@>w7!4KZ=kaU z-@+n_)xW-^32*$XFWn8R9-m+u$+HD7l_MerLH9XwB;!jQ6Jq>5qzT2}MdZ&=bCVR> z3nh)N|4{Q~#W{#^%r7flMe|@}?Vs^QRjSaqoo0_vwKEayn75n8%zErAt5Aj^kJ$N$ zTIy?+tSqDxuXyc>kr`R%xDFzAnp0YHS05}>Ls=)Xn&tK7==HNB^RU0!QZ}lem8tI_ zvQ|Ol=zVX;yH;Alii}Buhes=NSZe}JVdg6SZZGs+|HY?v+X-*EJD-yenbS?XXizUh~A|1>=>;euVL^x9_y}LE}r5L(q z{%`4x$lc>i(1$WU67bz3-K#eqsF)zy$tQ+Bv9AL?u2Z~TU(fN=`v41|AO7ZIMp=sU z`W7s;0bsYr5xgpSv0$8X1Q90ReS9h?M;lN(J~2VP2T;!n?D83}itY(_5p6ILae=56 znjabRFK7DH*<7+C33DsPCZLu8^JY(huBO5uU>^tkoKAg zOwz9u^oRY+yTuo&s6Y)bVmY)bKFM0iDt_^rX8Mo+oZ2Xx_#!2tnhmFr~~il$b5Hak$C|^5ri;MaUOxVY-0*>%|YUfJ)#9Z#ixR zfiu^;(&(Dl|82z~O0dkPo*Xd1dO!CUydk);0N)K(RNZF1H1YNL17D zbU83l3jQI+jFF$;<$vOjz0m(8g`WX%;cPkvPj1rLRI-C)s~f52{t+AEr*MhINz8KS z)u;8xK~Y3){Wttc2)-cJrqR$u9z!j5pc-OS#U7|XAW zB6D1dSR$*vCFRDeiTxS&^MGWXG5Y*tpv5?k)nqT2UdUFk@R4Jru!0_766D|oBD-Ag zvjY@{GJUi7iI@Euz_{u1QfEu~vW zDxHPVhn<&FF@%$LbLs>`JLc4visRSM)|K)?Q;QQw#Dp!E zZ(F=l3O@$WxHTB1Jq1+y=L_s&j+A+Lei zQkVfgBee}_qFbACe??UahKl4Y$9l;9}q>o30PuLEYtS_x_=hz=8+;SaTCD> z&zfBDYz6xQ@eQj$@eSlgIpTkTP5Udvf`K(eeo(9~fA}$eTtod71O6o>sT;qwV=`|B zM}(sJ2{aPtc}ebU=Hf*NdabeyO~7s=g}2jGkU@jKUM4C+)d*X+<^8 zeT;IhvIldeH4PLUaOKReNp;51pAYv5c819LOPPS}L7cKbGRJ8KjMsY`h#RE%b(Z|b zK03#Pz&6*;h1bT1gYQ~#750=ZI*wbI1*B(SN`o-NnV+w5|AG1`B2M*twtz(D@FN+= z>E!wt`iv0&M*R-tNo#`TMU1N1yNX4i_fW~ZM=V=I?(LMtc=Eu_Z1UNn znbF3KXftkKX-8jKyP2h&Lr3K;Ikxx;8AtN*&U?ddpZpLGaD9XATzr5NY=cq$lrrxm%E*II;61azz?1?jlLZE&z-qHVx0C`4lLhEE zdDAR#5I4sq2z+<4z%Uf}vsqw6N`WEC0!1kBd$Yi*lmb1H1w1J5s##!JN`YfyeZiQy zhvH(E$Jox#%u@FyN~tjr`a@9;9(nk(eT*zY!LV6yXrf@HUH?N$vGG>1C(L5mDa972 z6nnrbHqR_}5bP%U4`_F%6noGrHpeVhol@)utC%Ls!0LXp!0!?Tfc!-$K*2_7>la&h z{|hL2msxUAO3D44A{cmfbAr|4XtUT46UBho+LU6Gtzx&E#rmfd`?*z2lc%D&Tg(Do z5(R)*&?<1EXeKx@qiQ;*T6Yf%n(W)ltn=}GtxVxg0JVuZ+tr%0SJa_WV$Qz#69O92 z0+K_lyqr=yJy9E%Pnf%1y%E||LdUysBN`dPy9@#4hbd6jVx}glBzKs1Z$vQ1zGMAM zWz4MFGgC5JaOnuJc+;$(ov07`E#^$eWe+F_!|x-}+Ee#uOxeUJfT+^o!>S4+E$!sR{Tjy#ZN9Wnc+l{lM4jZQyj$ycgUKYhqlIc#&DfPXRpdQ$-Yt-BaYYSsS-fRCC0kAw3QQg5aSP#AOm z_cXl41o-DT#HNigg`OvQd8@x5Kr8qjTrcy+P74i zgMCHGPxEYnTnuy1DFR?2z7l1;*@#2C!+~LPzKG0Ko6pP(v6ez|f!$ z;^U#nrg|VWVMa60NWu=E@y7=20{#dc26LCQp`IHv;MHm=?Spsy(VFiuJg)h(*w~~{ z?rNam4sn}46{pXjWkRVwuRrxyu_vl89f(E%k=D285PgmUz%!!}DcEIj6H&Oqql&G) zM_tYBzR}CHuV@igrT<4fcyMqp@|9&#LJK%L{MlcUcBCmBK4C|?JOi5y!~)Q0ojWq( z`GKuW?Av^i*SKw?7wmfDR@kd}b}q$m{o`8hWouyP!J&r_X|?8V53z_P&}Lx`<@vTr z=qgM~1Czdv)&kTK1%p3+zcFL4<@o3A*Y26nj!hiakl}JF(Za0hV5| z$&M{uEpFy7?&nnp@)r|fo|#S41@mFiWRo;1y%YbCIAFhobrSX@{KlmDQ;8SGF@MGF z7z3SYAcQ#yQDE&ZX2z})<|N*nDutg0SjF{;wCo6~!JM>~ebozVNVPiP^lKREaJ4|g zQ#f*K-fZxNejR8E+sp_4NIp&;5#^v|q~i~%S|K`LR4467ZTljX#wn02Q_?{^8&~o^ zl-9PEykt})_xEk=Nf7|W4{3T#qmdN;2uLUFfNTZ#mOJsqJ|GCQG|GnROSj;QNy5{I zxk{pbkcR|)S4{9%i$@bYij%dlAH0Mdc=x#5iHI#6_l_||ZPI(Kr@4R)nX{X1>8Fqg z?ymsf^Ih1b*to!lHq#`W*3Bk?ZAIHB1d1jwVyVC03XJbbVC;zrh+y^SiFai2Dj>)l zeF@*q15x54nJ?ssm|gm>|G^25J$OH{eJr#Z4Bl#WBRI<1XiDK(bi zj8Cf|Tt%eQ3%I%g3&Zd5g-EAfcf-Yh1acnIHXB&$uM;2Mg{e;`us84|E&0NleCo>8sau z<#8KX8*=5_#IEN9tAP_ToW$X#L^sx?;odsN)}tF2C%dr`_bZ?qyYPi>Oqz&pd}MZG z3~K9NMFE1|K%haA>+=X@ubIF#NS}cOvuBT?ENyy`A@2}x*ywu#GoTe-BhdQCTSTix zf1EI10SL3&t!6dB3p@#40RU(3B37bB+?oWMo?3%mzr|h?3qn~3<051rz+Y>Ef5ZZR z1;N9&XMx`Z9DtSQ*}34mX%!yOWz+9T>{`1bd2p}XkYHILnMOSZQfhZNBXtlBv<)m(L`i>FF&OkWO`>#lhGtM<$iF9!RV*HPIVz7L@u1?0& z?R;8-C$m<<3f0*g-XDAf_cn8$UQaUOeLBY*7EX{L{veyE8;6!Gc3^y^NlIb3W<>^+@s3aHVNo)E z9@txjO*DcSoR*-A2OLf5`W$L9sc&NReoCviAmbS0hi2XQYe_H^GcSn7gg_2#!%bNi z#~Vn)_mYK-%guTTNR~tQ8q~u$#dn~fkr96}S>9?oP%1d)?0XD2v~Z|1{$Y$a?lj?% zF^r3hX~td2ci~}Tl;29d2K5q1oh*aRq>%hTieafdxvfZ}}m2 ze>eIqbsfQ5n7dOz4E;uwp)ptJ`ckPA2Mywv;R9ohU?yCclFioIZv{5JOS0np!#ijJ z6Y|i6wg&8?cJZT2zgZ+W_M{sjFzSkV5bCgjF2a{j710qsHByE*c&dx2bd=*6-@=oE z?-iBi`>R~L@&4Kt^ZSiP^LurZ`E9OZTE_E#qpSgDQ0DQw2FQd~lLy+tKjB2fIedHv zh6>vt{3C&jK1xTiid&DBcofBOnh(?+Br1z?AC#aDJ(62NnNahRC6`024LOPyBf|aV zQBSt?{P-{~O&f(PZ6mX&IqAOzp+HTvUkQ2%<>s_r4gl&-+%b$z0bm?C!fS}AowoE` zf%+uyG!j_L_@L74&~4r=!HcnvA~jR?QTi(=mTIsqf|;`=kjo$>9!NQ(pR9>;h2)b{s|cf=0$D%|nV4)J@(k-^z88Siqdf#u0xJnkz;#@p4C z{Keyw51kahczo3UQK)XWTOGU{et(|XPBY$C>cjct=>x={yDpqhd~G$=k2{v>Akv+5 zt%mbwB9RKV`GzZiL{Z#2jAWd<#hJM5<@xha$PH-a7BsW)O1zm*zZFj`2?`*MPdo9% zR-5r{6~oUH*xZPc#4kMLJMfUjhfF*;`H%%z&QW=U=*iD@KRaqL0!i}+y0tqUr5l1M zKW>m)&B{mIqVw(?aVEI=`mMptCps}@(gb|ss&ky)LpFbNvNdb6nbiXg4T9l23%{^B zm9Cr>SW(z8qE<)s7={(@7f9fBU%$t<)c}q}yv|};FGK-JVQ%S_NGW@XNl^jG@$GP` z7(>#FEQ5kjm>7=L6WTD5VH}-lvptKV!svi9FvJ}{lPG|@+J#Z~Xi5RZ@;FgwGYYA% z?)KHkwxLg~QZp>)!F0HoA!Se?pk>^6;VHC{O+{HVWp>FT(Y4 zvL8Q0E)&RjoK5w)P6meJUIRE|()S8f9%^6Ap0d`kQak?Yo!vjU4ccgH6Fz z*g!)@L1am9;*2qWXfcpK9(Q8VYwVa|;jxAAkq5QZ`<_LI0c zIgp?9k42_8D%yf31m)`3BJ0D@B#zPY0P=pn3S2!}@O?-p{l$1XaH+ZS8CJGXZ&}UdsoJgf za^tLNydS|?c)*0RSHA@L2{gIAGq2>A06_?9`U#u=jzTz~yhzcOTj?fS!3_=W zsVmj-2_Y@M&4|)d&QdZKVj&S!`ZG|7jm#6Y_`n1VFFZ{)J8V28=)s-xAm2PIF=iz` z$i$hLeFuLC2iC7(o?^m-NZ7}OXRU;pdJzt#b4Zx0-^3UD&ZO0Q7Wzo5_fPPhw0h&% zuCx1wGsroE8xQagpnn<0C9G#}d?nl?w>0D4WL(P}D0FKx2D+s;bMtWsD>CGAw2z{9 z;45MN%R*7)^hfPDFNbCYzxG!CN=zk13+J!GH_kgUJ{&&p;vf69*Yhio<}dgb$LU`M zRc!jx|HI+H=FWjYsWU#i0V~W?xVsHX0;xr9q!@!Cu5Wwagsi?IpeU-@0v!1qN1iV_ zsb2?ha>VN_S#*mnFwCtj985$g)i{#a!QqrxjK(GWbVBh(2t9*RR-u1+InD%Mv;ZeB z9hC&ja{33lpfGM^yGY-*OC0Rvuas)<=i``{O<(s?7hrW#pM-DLVIuvE-I7a#adqMm z>cC0;m!hZ1f>Kz5Nx-kZmEVM#>+(p90ri;zmbsib^4+-I+kp$%Mm7{QDE}XE?;jsk zasB^iNg`3f4GKyv)TmJj{sIL}1T}#T?8-*5Ma6ePQT%~#t)lD#R(^zTqO6xyYSGdb z+O$=RRx7s91{F;pB=JWTlqzbKpjPj?R>2<-en>vg*Ua6`CQ3j3JidQ?d62#L&YYP! zbLPyMGiT1sI1`G8IQO*!7r&%FZrL$W#m=IHSaQQ|e4W4UV;Qogwt$Ocfy9NhkT(oT zeR(i8LL4Li&`;D^-a?S7v&5d8uE=>D<#6tGnojO?J8nHV=Q#zs{cf{0EMkx|{Ol)K zbP$^AEvq&cC>Ly(MWVLqlg*9)pyJ}jcX)Q?#u2-_aO1>t42%7=tdkobp=#-(+{Z*7 z%GFrzp8qo|cHX$pVyD0i{mm$E>91GQ@sEB|oK|B}n`$gkHDIO!Af74`ZEWZNM^jcS zc$D$qGuBi(!1WK#!lk_Hc8-2wXK2{Dy&xs~_#Dtq?o~EUy>vDA-=9keG)s<<$c80N zm^r&W6ZS8{AYZ2UJ_Mqo*W*09((6!Ej;!8$F(uL^uPW`N*X>f{A(3e-7L$NrOva$f zc@^#?NQJh|?N1g!EY&ID62r@ZmVeeT3wLrS+!8}Ibs-Up%J%m_4>q9DQwefG18iP9 zyHh};pNwrq=jtwK>JOV_>$Bf`_uw4&a{Vmf$JmRz>az)QL4tew z?78IiE&8l;mwJfy2z*n&9b_7u8~OI4USIhT=sIMmb+lV(jOWD8?(7W(jM~l3mA}ks zuKX2$%lKQ)->>=m4ZE>qV$FFDV+7~FJ}zO?`~E+WQ=FC0DlS6_GWD8Rh?dMsOVzLV zF5Vx(9KDCp` zpu*`Hx97Ii?2H^1h}T}Dz>^V2+J-93y(-iB>!N(~PmXb_>6(w3?^4`J=E_ z5Y&O8`lI*N`zjZ*Cz}H;+7I#Hb+@ui^!`wfsd)>6zSfR5rh{q_H{Ony@|5(~-tTbc zF-PCnxaBACg-3+_x)(D~>a6tF0!%?ESir`OzL>A0(_atu=8Lh%#*H1>1F3-rqwY=Y zi1c=6YH;@|U0H)yoDOQOaQwB;&*Mhxi@E$J)|ShLxZD}NhrY^TZ&!1S-rW!=wr!uj zv-Hc56M2KpN^{;|Z^X0P0rACNgO1OoUlor-TP8~1MOoh*d6LJ@>*(JkX9shl1Uv2; z3v_*Ojar0u7`CY^IOq3njJgiYoftmI8n%NxjIL1;--4`Z3b*V~watQg0}+-qY#4R)rv)yCA@n9W%+m)V$&Hs-0Um~(B+8iJ5xby+dT zD~4snP}x3QvS}4;jy*fZ4@%+s!LtZ)QutddPBdE|t8=3kG)dfK2{?ehs1uOPxPKgK z3VDVHX53{Uv&QXhtg9zKigmU55v;4j-8DQ&_Dm*O#3rk?$vSwfxf91D==dd|?!EkQ zW(oYPvr2?+)M8pB&3E}9$PMHz(g>EV?%f1kxA=H;vWg=AvUNd!)egL3HWAJJDv91r0_Dh@{IW4c^UiFp zY&fi?vN3w|jW@ScHr;&7teczh1VxxNI=L}9#2qqgh;fKp`#T!nIi(S~U|r`L+}j?O znXkbYVNAMqV;X)YyD3f`3O{ljX)wWUf-x$qrLo9CoNHarIk$wC z4wDld9@~Go|E@h?$i~G)?}^z`v^n>%meIbeZn~+cWprNAm^0649$k==)cLgwKJ36A zfN5ZhROR0rkw3gbYY%*$N6C1{6b9qt`N(I)N9WD7Q}`V`ObkOhb9{i6nVy#_YQVSF@T@DxHIK&aGuBkZ6^)ZQPy}AwV!79KgAZC>eD!ydTTdd7iW!vy z{9VQ0JpO*+{Wb7>hrd1i9R)iLroQy zZ4p}`w(QuliW@(a$t!T1SgBP{EKSC){ki+{@8yUR7*78~R!qti_aHpit+)osLKTPC z3){H6m3FHsOz0w-IZT8F{m~Aqhaj!CkAHeQ0ryU!$}1N>qLq?i^~40T)@43CnK2{LZ!ZsHPO;0wPjNDm`!hi6X{DTG z6^uzH?gB!T$=kmX`?t6=M#!P2`}p+%v#L+Dl{$z~p@`Y;x^{>!T6G5 ztq(dnHL9j~3x&W4$m{dYQsiDN;m;7Jf5Ak4EGHH8KG0`!QX{+%3eRB|fz3ZP#0x!4ApN}$tgbn!L%olK_~12z4R!^C zxT#7ZRj6&4-`m}32vSq5fMDX8Vl&#r-{nw=wne_2>Su~)Gq&VJ#@lu3BQZXqTDyH; zL!(ZtDy}Ay{T&RMB)IYe?5)nS;-v(JFoDTSaXUWac+vT+UGO19S1OQw-^bH`FcvK- zZdF8m=f-cWQvy*M&ckKeQBz#XQ~ylhLO!V8QiYj-i+M9I!Su_m>6dAG5t?_c)Qem+FyH1E1^-KtH?n4FX?md83pV%^ZU zn|MImeurOijJkjgdy4oRch%h{;)@}j5otDeml79yrg)M7{rB{S8o0pd;K>G+Bin+G z`>NqdMr)SK(XhoA7-3WR6G_sAEgCYl>T;UpVnt@$)>j2X$2H!t4Q{oPxXTM?DGbjNFE3 zB(c(Tnaw8tVDUy}C;5$?^*#5nUmN*-f_j975&BBEbGuEgUSgWs(;&I}H1 z4LTR~3_jI~-zF{^jU3LJjKyyc_#HNXRqD)e*=Lc{!XPU7i<1p^t#Ss=+0YaNp`j&*>%_5eC0LF9z?QEbYkn;gJ+KKDVm)o zn&~L|l4jL(?#eU*T?(J1!oRP=xlZ(cHeVYe`R{KiYGt=s5R;ym+Q)j5ef!o-j#4JQ z`RVKi^oan8CBFhA9y6Il^DE2#9yx(N*J0Nc{^wk8Mjp_SuD1IyDcQUgovWHs-I`y@ z)X5Qh`{$QW(NDR4iqzF6BGUP=LTonzseuF%BO7_@AH7s!KPNKEzwo-#iJQ928wW;8 zMK)rknEW|Paf>o+AWY9z^IT-|F=Znqm2VE?&maEy=ou7RQ(VA@c`4G1im#?Dfh|^< z{4;@dUf{~?K+R_aS;SNS(&A*^_-t#8*`IC&ggTc5guR>kfd%>SE3?pM*EtLk;fXGN zkGLPZr_MYl#Xv6>KhGqmwFbg3Dc6 zI?uj)VF|Cp=W^tmPO|$@68SGnAze$%*xIN>OKdT}=p!BMpX;vy(ukvUsTgE`S^Uxm{NHI}c-cvZ~fa?_eBckd@Yu*`3is+nh}%Q>lRn}zNB`;_!_awaG*c&;BgYJ4;I%` zoH#XmyaPkQx*O)HCCr%j)S(*lPzfkb1Ky(tXU4t~HJ%y!t}f{u`$l?WUnv=dX_zve z8v8EQe9fGtkXG{iwR4C|UC}ut;@I6~JUr?FqyDMESUWOcguf( z0H|ZN5~C?DG*9YGW!#m|Yq7`N@LIOPAKRu1iXMtvV&WL#k-ka)oe!EgD@n|eT5stD zMRO~&HYG2-dobm&qQ7Rlx|`1Ujy3wjiDGW&`m)MD>O)-eGbdZm#~Z#4g7|Ar7$EdN za);gz9a$Lm{gc&7Ev9lIF@1W!mYz$fRFD-f)j$G6HBjqGrs?EMmQXv~50;2bTT{o* zIHt-+G7E+~rtd|iRhsm96mXm>7>?KH5SrHC(j$m=7vH{xy9!|%=~Hq`SkqGt&iYqX z|7UHQWu~)ol{j5PMq-RNwN;T2mI@%%3IwJ z_54=&K^E|F4{+@P0a=|>zFM#uiLtq z14o`QCAjb0ryb+y|9~^UJzkoE={6KyZd$u9%c`$KorC6nFLk~8BO9kxw)!Y%!KP#9 zjAQ6Z_0)LBW^|p96FIAT&d`oX^fMm&r$t>JUtb^H#$(?N(YJW)y*Bz9k3F-ZF9m%s zlWb4wAf=}`2F4PuRe#;v`c55p2NS_P!LnB>{7Z1~UsNoPjNM+?!@mS0_#!iFtiJu= zoF{!z6sGpx(LojUnwg4QRkzHEJQyo`4#&r0;bL=|&i##nqA!YG)Wl#4V0Vu?WamZ{ zCjVbwtZj|-tN!t!Ig!%?^l;6AlV{*Ug8obEsB|ZnCjLO-rz<>jpjk#B{3S0V_RfGQ zEQkHPxKr#M?TJ0Hy~JJxPl>%@sq$_@ZPZUQLTx-i8KzP~dUnt}Q9O;3UqYK2p{6dW z!xaMb?%C9ifp9wy7NKg2ckpsuOL^Y3NK1}%bmDdqWC&(>5C&D6r_lTeTx3$Zi@7b* z|JOxcXXeZVREc$L|IyyYB?b*{g=Aobi7R%t_#(G!pcKpNw(?nQ-Y3vsBch2);&Jzf zGz5$(#E5#si^>6Qx16Y&x2>DE<}0F;QMGmQjbyZ;1Pj z9tQJ8algHo1+Z3be2add{$Yx#9e_yBRI9dxFKSYA7S9TEJ+6Ft{WXnXsu8`8va4tJ z&sif=Nj=XfiVa*X;5 zGK;3K&DUH`C-ry%HCne#er6^vZT4a~4T?_I|lJt`608Qa|x9upz_ckSh$2QnaI!}B@y(n3-$-ihjpk=F!X63&}N0bDoHU@8Ky_BoFby8#F z$LH%>S>Gm(V=rmt90OWIo!zvAKhT(5sU)$zet#l>UTf}(S#RdQn$JNv_fPj25=F2d zF$LCqE;`*#fwSjxdzjDVGoSO<%qAO4qxXX)xYO+IJ@+xM(0F5_VrNDC6&>Gl*YA|S z#~Wd1dVjMjd=Kk@&cq^Z`Wd!fOWFv2+e3$IU5L@OnFoTObyx12g%rsC3tolmVl6w_ zEt&6+{r*@a&{TY}dLQ%;j&K;cpn}XkT9<2AVj<|$%E zd{IBnH}O}}pE8}>KIz`Mh+!qOUTo#1(J`r0pln3+#<258qZr7F+@N~Y6!$0RjO-js zV8&JE$52?VGC$$j)m5gAgMiYmGU);EtkVz02I*e13C0R(dp~8=LnM{qQob`nyFp&$ zjlEX6a+Nt;b(Hw8o?Sp^dhi%YmsQ1PhDS_)i4)JkjbP=0`{hiQ<(Zoj=YD)8jxSjW z>QqXp`H}ogAT@odS`q$ir7prl1_p)8elwI)Rj_nO3vM+;c(AyErxf9p%JGuUAwc?` zZrfD_>f-c#vMLg+{|Sr_s!1++D*&xTHkV-TqT*JqR9ok^g z4^G`4x2GLTQYMbKbwYw{?Tt~mjB&g*=zp04*xD`6P;$FukXU$ zqKBRIP6vSt6UE!JRPhX9{zI*%OvX74CQ@>IqqkNi!n)q5or94Lvw)?)<^_Hc@EXNt z`(yd4YJ7Jm2Vty1Cl3_22U{w{AY?>9tf^fy$1*p{VRX+J!l>TjR<&n?dD1R|hvh^M zwarF_vub&3m_`#;l0$}vktO2c08|#Wv&xUHr>L!B;79Ic#fjz3Pr@*(QZqd?)TUAW zwMQ^2r)ckPrPC=)sRt;iOBNg1L_lXrzRpvV;MjZZT$`|qsV*qI%*}*2RLmL^N?ern zc{V`KjLxIEReBLdAH>&jrzfsrJ zIJa=Z8x49)dZUfylmV~vGvW0%2A$bwkv)>5LG)x!vqUMuvB zzo>3U&Mv9B2(6X}Nbd=jyyd_13FRnmG?3gh`7(1he=I?;_UrG1!EHaTFX`vlzOR7zZlV}ka9x2(Xxks5eG<{x>`D{ z>^L6*+4w1rSJoaEDBB+JU%1_<_4lxm!q|qlgNpviPAv7tydx}g$XTsqCt9A6=G)Aa zh*!yqH%0)yjcUaA!~$B?PCEIT!k3}GO5l4M-y+CHLx{(Ur+e|P7msqoD8xx|h=x|e zBxlr3d&<)jJF9_;6ujn2YsF)_GZJ zJe(`RIX$N16!}V3;zICm3zls0*R&Y%BgtcgKD6=2)HlNMZE1RS_Fyaj$8;0_%@Y6Y zpNO`pc~tLC@!z#YR14E0W!%R#*|hZ{LokUHHBo0#X1qm+q~-mZYRUWet-KeFrBl|H zfqk-4k~1TrKkFi){db+o6jB#icZzBMUB_t7nGw~WW<>RSGx~NB)jRw@`BItxN3r}m zq_Sd}qQ5DYJFBGoYmv{JtBri#EGb(!VY6gz;iS#~Q9f^OGlJQ`_PNHSN4jVcvFj+bFF9IwSL2% zd5es6+OXs57dGse^pZd~`8K2`KF=vzFX}Hn?4*umTGqpTc0IcWx!M6?Cn1M4n@HtQ zRSWnVU&PPE@(o{Ywlw43;>#Z_o+#?=-fYF9d6C@*$Z1m;ehZY_qT*=^`uAqcc)Tbb z<|_rgxw*k4QSgQx-p6zUqht#e{IAW+jQF?3EmhF-9%OZPvc;KXD-`^X%?v&!NTt;) zX#aewkSc@$_I=AwDU-01d zCdk}4y9f1N45ko|7JII+LE3+5=*$YhN}o9GGL9d&fFd(D&wd-AJ2V4jD0%>>Lo-mO zB@O`fFAgcSB^pv60P496lxeU7K>Z>ErItDn_A@e2rlk*%S5*eewB-SyPRc+TjyM36 zF9Ri3I1pZMH;57+(@2Ju4v^RC43y!M13=wtpgt!r!*U0Jx*-E)IP3sWqcc#3R}TO+ z5U6yYefl7+)QF#Y5}FYhkN(MQdBW~fO5bHAVwG79kP#SbFG1?o)AVF6oYq~;H?nd& zEG#=75BK8R^JPprU@lg+s9dGeTFJen&_vDTiZ#V9Pk-wE=ypxTmwDl%j|s-w+A{0D zWm`0+YVk5M6q8#wdFdUxWb;Z-ZQTLNuw#96TN*!q&HL|J8mNZugTyB{5fZB@)_STh zZ3Xk!?)-$Yli~u&!G4p z9Ym&TWMx6i8eIKzpGY1;+M#b})&~9ew!Kf$Nq)j*ZQQq*;w5cl{Rtlx&&iZZo5}DQ zZ$#(a!pkB4nz=+KZxFcB>F|Qb`l0W#MP~V%9g9m3XtOnCV7O(_ zPUlOTD77#7_{UN__8vZGZra3M&ZKJHXQKC2K)5?*8+u13`~Ma!+_3xR#tpk~={=Z6 zz^kr+NkaZ<<~`NGD07r7h1s+|eC}UT#gHa)j7OHpk+wz;QU_|}@<NZ9)E;a}}C4 zQ(u2o zm>0(wzO;N9^@mVzP~IG)125^_>Z2OKhhZr))Rc zg^t&Qji0j6@o|ywbFOYL*+`C&lRYHU)JxMV{DP@Wpq2P7lzx~co9$6Qq}+<8`?bS~6GvI^A73&Z~1) zFSXjt>eDZpESnHB=O%*&0`yN>xaR4S{2EO(+MO^%qe)H1ZE0tX@m0$A*DhBIT$i>R zYXEz!$_HsusLV7|t|ofJ*O*;Z3NI{7o0maLimPo1Yax2sKYvp36d97Z5)MNWx4`Y6 zpI4k-A9$)z`LxgKz&RdUAi4%eDrF<&`9E~?qx$4F(Dth1Uat>ta^JmGS5tbfCbxTN$v4bhLJXz-H`N)KU4s)R z>HW%6W^$4~`QUf`nC~R|)%W$B!dMqN_iyY8-OJL86p{_?ee(x+nH7H{v!8U$>{grE zjaiv(|Em=u6P4HgTl5z!V)_!KZ8ziQ`1R(-ruXNTHTsx?Ftki>{Zuc~{MV!K`|qif z=ARgTrp>ueI%lhM{fx|;w!JkN?}TM$mZXndcHUa=2h>mQyfz1~tV$=Oev`daqd7za zt-p@e^`P#_f;u}5#qQs(P}8!Y`WUE>2ao1{ysl8AvY=9{t-d?Ds5{hvET|1>s6pMK zb{^5$I=@Ln4e1WGF$?PUG*oGKs7JG)evpPL?+#Uy1$Al~D%c(BiY%y}X()C+ccnyW z7Sy&?9wj)~yDQY;Sx`@>p{8_)`h>%!jqXi5-k*k=)*Y%j3+fgF_4(k@)4M~}WkH3~ zP_w&3{WuHic%Wd$<~@g4Bv?5vBnSyK9`??e$66ulJ-h}Gjgr3=zE;fWbR0N_6JL3WWh9 zpI7&Yo2^7MHg1GV?;wT^EzY_}c`-j@I^0B1a*(*M4zONR#JHy zdE5ep{J{&+^vd1&Cqi^$l=3~8Q+kpMy^noM`M4vUTGV+#us0~g$v@Gctj)~teyO(T z_Zbg1GoM1MuekzmM7ZP%>h12ni3!m#5}92%D&;qX$Tt^msiQ)yFf8~T%fN}@b72*O zDuvmVh>26ZV@a{Mn!v5@z#Dan1Uxi6renFCelJboK|9P=K`&A#yWOYk8>M{LmU6zo zdnun^{f$!o_P^;;2HH}t^GZ2frCggS6hb`@)+4BJ0Om-5cj(GoKNdYjkLA_Norfv>i8yDry=?Vu$F`fu;E07+WhiZ8z_1FuZF~Mjm3R8><4|;=zJknj z4RD^xPbgL0^^9<9;A?YC8P2n$_CFI^X2YD`KBAl1n$=$-QKle24s#&*(?{jR{U& zp}6CT)AI$vEVnT#!*H?uOyrCqIVCe(@^K50yw|4ED&8cO^b7kfS{o(l4r)dlKdQ!! zHD@HEIXl&>k|=kn((1$-bIlNFXwj{viU4v>mV1SrPUeORsgs0hkuWu9`xuIgZXU&R zh;d({=rphI$3$D~BXdNPpc?izofq1iycPUXQ&U&*p0;DBF5^Q|Wjb-vT*nH7Bb4ae zR4H-7A1UZ#?~IyT0`aTsi9Lq6)KGrRzU)-*)S;<^6?Ahan@CoA8^bWv!9%qX{z4|k~2l93s~ zUMJV|f`K&c^D`qD&h0n^9G7KZvg6k?O2K0CXUbirr0MBy5rzbsLF`2jT{DQ)F^;H6 zGl=E#p?){wTENpo?=mlK8vmMdEejF5LMYGkV!g`vYfmROc{V@SEk2^Tqa*uoHAe%a z|Ng$AqvLD-w(}>Lhk2&|{=&Qd8oa;vdHQjp|BT~1-r?_c{@VFF7>{R#=~=O(qvJ^a z=3|u$0ju|`z31yZJ4gKM7LRv7r-JU^`0=ODkKm|HXZ{fPR<#Z5mRuQ(_>1lFMPa?I z?m7`9YuE3w+tpD0%6Vk%`fYlYUBAl#t%ovM*|>2fC!6=D>e=GnA@XF*Ip%)k&ijUA zAGFoC<@<8n;YwA~#H3R_T24Y+$d}oH9c@EeB)2|0j0O`YiGP7&-b-Qx_wNoNB+>6x z9^T5q4m;}@C^Xw2u>Nx8WF2-+t@xp~A6;9n9@~ysl^5w01Tx!?_WzG^?%aMf-UM3> z&%86soG7(Wb*9gnFt#F@XL>8re)r^SsLi+UL)w6+$72RQQ#>-_`w$CR!OZk2SxDTo zM7;F8GJ}NOCZJE|?9+K@yU_-Lrcpr|Wp=Nq{K%jR33yRw>%oRPt9Y0e49B64+v5?K z*W5Tu{Y@Fz3>N3(!39ln+!wDV->evQ2^;eyF{sfBzz4P$0x28r6o_o$;@xr>l!>{8 z7^&R~X==P}a09Bi(rx&BFq?l_O{)U~lzV1`Fu(xC*r{RI*5u=Y&Y8uC6gf(~fXh)MZ6C)YD7)pe38ap0qUgmzH%_0B28&DFHib zE}IJvyezrNny@K0tlA4xi>xFz?5x~K5EsdcpT)5X4V5+fYnyqoCxVc?T(L4?nDk1w z%JcwjuBmyM`2x*2i(13v|L)nH$xHtL2_}-A>t1C%OeEJ5;tR74WEy@e-o9La>{sOF zIqIve#rr?yX%>W^Brf?BKUw`X=-__TGaN4qVj!Fic0N{Qi^6QCQbqhV=g_@5aP-Jf z;tJo+b-sw7!#N8>&ZPyZLyf!%Zu*$1j~GP7NfSGVK@cw(En>)Mp^|IHK>ja6{`!}= zD9AVK&`@GRaYy*rk5fbOPyD#5>|eJH;xNVV!ELP27ex-?edw#9U0p>Me8+?&|RUCX9a<1TdnNr4^Xy0TL(VvAXBnskYS+?C@`!6y}m-<+`)F+Zd$kh z(Gxf?Bi-?EoteoYsf>M8L*|JE9MYDY#D^Q5WF%=89N6AZABc{fEvs^o*b zS^8)3%MCPw)=<@1vias|RHHQCRKb90zUiYb;x(tg_Do{_1D8B2F1e2dj0}G~*2y22 zQ-U0jzR?iIV5DZtqNPX2GvRL0vBA=DBkiZQxa}k(mn4=3B2IhU#$s#(cap4ajqNyp z=bQE9l@oleEmfcq=iDDsW9!Kab^Sm2HFe1DO#u zoF(jfr-fZoJMz==t|I=A^!ghOq6WOc>4hMA-d{Uzk4#n80X7u(OD#4t3mkX!ydd7o z4RK4cI&g^rEiXtjTQom-Y-{RNb>Bf*lH`zd_e~w{b-K z`piHT;9>L)l#ToAXicM!B;RKjgI(vSgLd{!V@dKe__fCm8cD7CmAno55a^`YSc62=b=cl7Go8a$!1+`&;&9)k7F~@QD z=5ko~+#<5v7V-yP3Hp5Oi?0|lId2a4`7E;-!yV;>sr^xQ1a`|F{CZ>qgvmGh$UM z1$yX;%SG>|)J(DIHxZ%wWnat~81}s{9ZCo$f3K7{b=B!v_Qh?)>`mUohi;}i>Vm|8 z)3v2`68UDbWNWXNz?c$DW%i~fv*I-_F>+Xy?<4Y8qLWC3{v%-3NZzs^5w63O`qFHw zsX@_0MVv0mP_W!;y&|xlwoC-LBwdp;iOD zW3h1$F)bGvYb{0#$Pu=5=Q|u&9{&`p#-PlZJTERoy>TX&SH-A$_W8=#6l9F{;QCjdBb%A zfkHSY!i?8O^|x-#?n31Xj|ZpL7;rR4&f;7@=j}|jH!4qR*QU()7o57JSXg=pt5>?C zlndu%C>-yH?fzIb%k8nfM_I4bMBaC4MVG|t_Ufb}iLkT!Lv!9S>i8-cTFx_|a+ z+|Gw;r9jj2%89ExYzn3b`aVQ^PLy?XdEQkmIj7xp%WcGbN&x#OmzliHPR{uRNFcVE z=Q6Y249fX)ew?%jm4oDr!cgo(wrcEh&jANdx(SU?>}6abye(NU>UP5Dlxk5CLMxF2 zXwi!78u@Dn)2owb@MG!Eu1IZU*(3}odG1AayAv&>Da53G&@$2Q(Y-oY%+2{#S|~#x z)syMmKY>h>%U|KxV8#KgiYDw!fpSenWyZglt=u`j|8RpSM+I@>4O5Q6HG6QMB?+;r*ok9VeB5oo# zC2;>%hBvfE#6u~A_EVqW7|p{N_5HQi^RWgf`8}u=Q3Cw6ClV-T73+(=`|63%UI74G zLE??>Ygp7V$4LcE48H?{y9-)mV^0rFpSn?@g5WP?#wB(*mLsvm4zcy<81J`brkh1{ zN;AjINx!sFnh9x8v9L-xG3vkO2{%`R#)f@^n4=oVL9nEK;ZSUo$)IJ$MdqcCR_^zi zmHT~MPEf>qUNPNI^5f<2!=KJyC7Vo--sAq25LKbhqn_Hry`8ChIL>xJJBA_S(u9T8 z60EX=-0H3cznL`pbjmm_0;NMq0W2G3t2c_-o$fmrT_i zj0@zkyjT~=A!;KHkU#{T*+I9gET5C?{0k5Fm`*t%I?MYTvDpT=x7q_T+(2kgdO_jt zmH#Xpe~6^5m1m7;>`VfgAtN>zZDHj_MyE6NF~!+oGMMl-4IH`^me1X%|D7e*1`69p$cuTc zXQ*pGEq@FBC)(qVfGRA3=$`$Em25^9exmZDru=lq9Q3fqJj=PX_Dmm9JWTBUUTyJoIwzmmGszs!PMEXYsU)SNUu0aT|WPuyQ#XvBio zx&F*VGWlz^`*rD-4e$fq@*38TVZ^6?mg(;=(<3@N(W2sXC*o)$2-zi%*jFZxBAds| z&OGimy~M7BG8JOLYG0j)9f?!FEjzmRfs`al4j71}hGOJtk@n~UB~1r2P8{VXJCDX7 zDnTV$8}{?WiaU@gXQoYupb$tq4pLkGl?!KUz-A6e7&_=gMG=ewBgJJT4++c5dB!iu zjrULz!F1ZTm6@H{{FYT{QA}M_BZ1NKZU2(_c_lSt`V}n~3i{AL(PIVg=6H@r6p*-} zBfim`=D$04M#<3UQ?nqG`-5@J-I%;m^M)$tyo#M;3Vo3eL(aS+x0I;V+iafQr=3NZ zFO^+O-pe-o^mjlvud2MxfWqzp{Y^lukx9i1(N!pLk)ws5m*ERuEb3=NNAyG0!qkvp zh_Z!JvGq}Xy{*WN_8a=?c?eM#h zPj@m=$(3G+k$gX5piz6Sq*Sec=DR;6#Jz3~!6&1yk*aCi+k?61=!*Ou_sOT=0|tRT zpL)BwymwD^V z%#q{~pq!^DJ=D=t|16$A^}yBgvM$u_R21NK9=M+RXTh)bkP&~nmza-%E6>+zTE<<< ztT8dUl)IE&Z=!6Zo%=sQ(Dl}tO#~|96$(RwX@SoDNFPrAlyc=~9FDZ^=dX=Zd;kk= zqKnT_=j_9rzqHkDCb@PdYc1ta)TOX<=FZXZ~_$bvuQ8}PFY zyl`_V-o5c|tfoKL+jB&ug|0h6!PNvSq#RPYqmISp23tgGX2EI6o|J1*w)8nJLmwZ&sUwJEKAZe4V99C=%hb&MppwW_ ziAb*%F#sx@*s5O7Y44%4`po*Pi3z3<3ib+^ka!&bp=3T=^UC6Wt!$@kF9Fa_qO0!GNCc@KthI^q`ZifC%UTl!;-61B{%4`){ z^EVT_)xBYn71(|cAcNIrAp}*X2+eN@?6%Qr4h|PdSK=QYc%28Xr~X-i{iFd$aiKxo z2hGR84sOW$Zv^%uqbRDIz{~g-lo4zd{3dt3;KhWcjwZcVQ@M1k~sYo!Pji zj#Qv0)e>j?=AYkK-%bBz(xObh1wQW<6Qo8GN_}r9bP`Os8vK4fsRr7O;NPF~35K1@i;` zQP0aHhW9KRhftp9HgM-yAqq;oa&sVFwJ~+_=oaoy5YA3{fm5})tg*r$cqv}BIp9=n z48@v!@y1ZuOa9mu~92c82yg&0(c>+L? zl8y5=XgRTNI zzFPY{Ot7h9LA&9Cr}bOOp+ww>B>oC;Ra>PvViM5tFW3$mzhtx6A`rjir9gc0#?F#orson9jYWt-+K4V1k(_h;ewwJXOZ z@-MAnma9>IXBvgB zsTl;90CTFV;kVH(d8bjqjx=k#hn6zBaQEoAmcVId0(DV*&S_~k2&Z!Mh_U5#<0f)a z7bf>mS(85o(lp&Hn(kkr#((8sL`Ojo71BRWqu=g~EY(qh@g4NnS7{g9{oqLNzNv6o zJ6FJgMcKpw{(Eo8MrRH=9}pdmwGUqC%qf9OIwAp1GAUsRsgPrxJJ%Oj%VwUbxgTm_ zOGVk01Ll7+w>PJYL-( zd}3A;&!&kFy1)q!PPgu17bNlqXIhu2IfIcF&7t_~?zzKF>z-y>w>7yY-8m!q@zyw( z8FuZO%ul+@<3XYLp30%m*S=ce4{oyZxE>Ve`$sj#D_?RhDsQQj8jw@*w0^~|vUsaI zvdQp8gm0LeR>NG$7{6p=>Tq+u68-PZP#K4~v;bM<+(sjQtwzi=9{sPF=4_(>Z41V? zcTyMphN{iV{mWYDfC!(wc9HaBj;xA2qz+g|2Ru#vZ$#BgbAJZcpH|U4s?;|sG13<= z9qS96mKX3f`r|XHLW>zHGJF_=QqCpZ8CKaqeZ$Tr^;sNwjW{x|SXHca{-+$a43uqw zEn8sAWC@wskN|r*E8`c4tl!>ay!+mqyOtgz(R=R-^Z0o+`37_Es@GRZV=(vL2E8Tn z4hiO;lH=nh&Q228@$-`+W??>^B#C4}ATWoGa`j22^ivW>UAM1ZoJvm2X)5ZTJ~Q5q zuP?KRNdzse>Y;=z5#6nVcs@%)Px%hk_j ztAXoQD(U4y9zvRvfX@p$_m|pSgsI>{B8IcJoKJTk2zE__>yoop2)I5Wk1-*!TKGRz zAbQ8Qb}*7EOu2FLpi!I^HZZ`snO2o8=gv@()Z3|*Z{J4;2^MuBf4N{y!*b!~mmNE6 z`*(b4yr!JBgLrfAq@v6e++IAb+H2ZK*l#vTJj>d zLHA&S5gG3-yVn}hx75}F2^GzZXW^$TLQ2ngm z+}i}_+^LQeI{D6eg9le;$8F}e!LynstGVts#Z!SJsDMq_Spi)0h6J41jV5!Lg%+8J-OH_vk0F7#EAn2@HpyKa&twYEUtEnIy|YV>?9oh9Oro`UJh8R8^_xmkwg;+nNVJ~$2C zU2AN(wM8nK3CX)RuoPo-lM>T`K|!5IC?L1P@yBQL6&dSa*c+1zHg(R-SF$IEQ&QZd zpfIyb+VpzOZta4?uMEWUX(SIjCKql#r#dP)9IvC}foiQKNcl9-z28HZGcLnUtq1hieHG zi;XD;x3c#r!Zw2I79?|-;Bd;?1}@#2W~)vf+(Xb#Vn~>knBJr|V5FrW_hqiGG8^%{ zz)z8nMMS$B-XtO|Oq<=m4%V`O0Yd5kq#C$&U4ecoAUk}dB_hp|GXV2+uYgNgvnOEVu-ljOu-)#4c8)d9m=rWzuy*vr-JuG{Z zvrAtLKE=4KfB2Yf%zVrzic3ddjWF8XFMR~N3KH_A*WKkqg8{2*CdJ6lCAD7Q!~xt#^}Le z#|)xWZJOG+WKS2_sc~t!VRdg1EP1Olo@ON;Db18&tJ~LL?wvT$laJV12`OaKF*KgM z5FekS5}ef&d8CRv^%aT`e=$t?94iXT*85}fT}qReC472`0cw0dzrx8o#*UBN`F>1) z>baQYA?F~^k&9(+Q`Zih`VTVWkXFI$fZI`6=2LCCk&sMOrtJ1{v12I#~__hB^| z?cdy_?F5PkSTU1T01kA@oTFzob2_Fov7Ikx&Cma0{Lur&h2gTI$iq@t$=~T!98O#X zX)Bme7eqfxB^c4q(y5>*RJz&taIQ6$+Lbk>a{CU2m26vbp9^+*4y!Ot=PuLNk$kD4 z+GgCQ1h*wi>?`o5!DYfegdpxnFC~3) zw>Vy7h~*bW?^6@S*NSnHa;+jdt%RKg+;pMy_34lYFU? zKbFpY;CUzhms(I-p>*=kRFeOo4BZY6QUE$mgM`Kgm{Eo{E67uZh8eJ3?mthJKB1a= zgkX85us+Cx&nL!%w@kWkWL1mmc^Ih`eoR?fx!x=cFIGY=c zJhRJj`S#uD#AaUMZOT|o&{6u?e3 z$Qq?I?5rt}g6^U2)GsyYR$E1x?F;QaBq?fjWL?ntMIo@^#FPD%1hF_Nldif>={WI= z1R4xEyncWe8BWwGQwi>-B^=7?j4V#|opCrbyWb$+4aMRMOmb9WEKPE$d>#zPIRl=} zNJ@oLQ~rfdt#rD({Q=$^$oiKKd)wdO?MY<0lcY#I<*Zi4LQ@Zd-zMtKnK#9~_G+V%&Q>;_8frCC>7hcp*{IXfNOJ_^ zIX)YO)oP@%so&H{?>||i;g~7TkkC|2fA{w%snLcWpRPCOA)#$ln|Am3+YJT<$~~=r zEj1b!BlB5T8dXpuhcgCsF{4u19FwF_-9qs#?%T6XKGh~?qnW3#ZX%yguP~7kE$lm+ z5_S@*F}l~^js9jPE~sE^Ajnd|pqN2d-S1v|k;5zORSLzQ z=M9B3J1^6R!||jt$srT;4h@jbYFlxusO{2rfP|TxOM$@(_^%>);t0-GY>)ezU~FV7 zkzSvM!R`Kqz7vcRXZo0wxN#ay(o$ftRpM55QQ|sK-|X#PQsS(<=&H*lXIx`+xzka! zX-$I(H$xmir3*b{v^#83>?qhK4QaeOTC{{QDd>-_gsHf_%PT1yUn#9B`Ab5z69B{8 zu+zC-SbqH%k%FFQs&CQqRJrL!l`9STP?>8*cxEC>@I4Zs3C`nY3r|lr4rBhoor2Id zR4~3UOQmC8Vs$y3eN5#d?1tf1<3UPh0)mcatkw!(%_6y0LCdIlqPM&7a--&nY20Pk zsF|44nEvW%dS0dD<3|SKv&+MY@*r271aX!e&(egwY$G4p7LJ?Q7#k?$RK*DZ@a2o{ zTX)KP&%}^%Dm?RoP#pF}zP06ZX?M76SLFE4K{1%PvMuP$+RieC>z;p{F?i@4mya@p zpH8!IbEU~p3oJD(Ct}8YSUy^b_JZWkTa>T(P$@imdJg4iBtNrCQz8_>#e^y zxiBe{(+KAVt~X0G*l)v$8!@(yPTOzi;?*(;4DvAl`a)&+_WlOGN@{a{C^4Wf;}0g< zcS14XqFX$%X-)QToM;+ba*3wN7zT}vsc_4@TafdfX?kT zbSM_+E7PvAHl!QPu@%okug2`=bc(X5;IHigwr0t}Yl&dVn{@w$VsmRW3Odi4vCw&- zn%V_(tyQI@C7AncgT|sn-Z|Dj$r<3YZb79PKTzYj)pD=VX37Ok(tolPU8G34xVHIv z?h7A6k`qi4`JTMd$JiS9Ix3@;rNbV8UeCL9XCfTPRXwVwavb5q@Gg*H2^%*^}Wi+>M!7*J{8}R5~&*(%KDqx(EmuN9rr09NZIY?C# z=FTTTy8TJV>9hzH*KK`b!6!yHX5fy3K<|FJ@Sc(T7PL;T21nop2wdA5iY9T%5MLrSbw3U?i-RQjL& zpfdijvNI-Kiixi+AhsotThOD>ETpH~H>7c9L9^1TMgvLCjh0B zOjgfxpQL1&cD#D*Q6)j>r6LpDJxgN#Ow2de=Or#T_4Qh4`5u5bIn!lkvCa4aoAEiF8DsIJ{1ADkewWd{p#jDn_ccUZ zDE>Va%4+OJ_h}K_+`P7d>~-I?Q>)2A$Vo`bhR^^Mo?C0w{gTE|ZbDL)O_PU&7PM#? zh~wsG9!CYk7LPwa?^TfN8LBV?H@FSgg2)w~5wo(I^&qi_RF%m0{0o)6m}vs-nl_~F zcfZe9D%ZGq8oXtc>JREh1OCuGm7`oT#;3!81&Ip(1I@`Nj5k64wMU8ZB)+(dKr)Z*^+iWYpSq7E**-P@dNkuqvkq*2h2_VM07IiD zcj4khPVO~)EA6ubNsAtTDK00S^Lw*iHsJ?&rwl|#%ZB&gF`HF@Hkcw4ESJM?G4YB3*i}6D<@vHlGjz}*pRQXUX$>0E|jpyU* z+mUl_z1k0ZS-_bqPYZv|mn030n9sG12eZ{Sn79O$V=R5KvTkSt*Dm_}_c!2Uve60L zRS>US5p*swL_>~Z0-tn)UOhRRGZlB z>6o@3HJ?>=PQ@t{Rqs>`1G-eS*!>yTUd*p86d_x%M0FSwhJrK&AZUD6&=eaqy)&p& zG}B89gRy!2b2uY2Hg6DIJ(nX{W?*wkw$KcabyJfe>pyvTXBP77HrmhlUtUVNt*bs*wrR#>)?{&N+x4pM4rN<- zVs4=`Yoz~)9l5hg^1tUPos1!Pn1rKRz{3%Q!r|HP#u^)X?g zW@J5Z>xjN%tjU4+?%1~N-1#waOsRe^92rd9x;+^GoMW;9UFT!Eh7XQxYw6k0<ko4L{ny!NfO>ik4dd0V=*6(7?(ms2YOgD(03R(Ld_opuq-* z)yN*g-&X2Z_46WM8#jDqQukF6ft74jQusj7x67c%wJ6=2-t7kuiEkJ^7+S@^oH zZ|iF^dYv|;SI=^1^o`3HNWu8?V0zBo^C)gTcjqR!-{f9f~shESJ? zk10x1BR*zOSh^wZKLKY{xpNpEp)&{BTF?atuQOfnd>&a{@CTFVe9uz9u=D+(5ilbd z<*~gcDmntrZLoU~CxPfnwxLz{?`s^o)7*9c7VyOe{$h$uyI>{MGSAS*#|x8gPtc=BrfF1{^7FrNJU~m845x^boBvrbk6K# zaKzk|lv?52&z)o#2qtd~#Al53?dM}?N1&{^-2bzdn&&c2l-?OX%rq|)Ikt-3RelnoNGwqG{T7?hJ zG|2|Z1#gryV2zw_FLG`=1NqMB7?&)KjK$~c3@xFh24okAW>Ljj_9t43!=di)6=jnL z%umUo?ph|SRTyNRmqQ(Hp3&P<{aBAIc4>BZ^!DXk5DT1%!6jh{WcbplYT$z8 zg^0en7zC?ep<73Wor{A>AKbgxW2^=v^5R^ScS%EV#3d^u%%QVDWuFO@jT$+#sAZIK zZcQC!*)KUselQ+miqo7PEx2jy?i@LMt1BiTVP=OvAtY6%&9vpuR@mt5l)H z(_Yly6*a|+noSh)qbL}ky!5u?-CIx4zV67;?o#s-?c-Ffi0#g+*YphMzj)OOghn0i zIC;)Q9CYfnFTo818(W`SQMT2dk#NZhfA|H;4ZMJ_8zl4pemhrIa0SC5{?RX(!QQDa zQa$Jh$FOQLa;Iu5`+*6TxwkC$;GEh6RHGjtWZu1e~&K=7vIV59WL9!?$nnv-V5LA z%7D^P7s1|k$x2zlqK6}`oJ&@wCir8IkZsuag{e>6xD_Nhc34*@^s6~i<17OmTdeW2 zPnPl{_1+(hzs`_xlv_qVQs<4S$GSF5Humr$=$E(4RRm-Z zG$(R$^O({cXH2*Fo4kM;!<|8vdIooV^hGP(|mSL{W~LvzeMnB^bf{9#x=lmS zxksTv=YcvsN?tI-mInFPXHL+Z@~7+#OZ~9=SxlhELBGEJ@oz>FwIjL~QG0HrgSYxd+ z;M(Eto{6Q)nY)xT<5H~j&Rsf_U4>?1kcEu0bYEGJg$RzOWZ4auxBXZy=C=Bxr?~HN zSW56@GaWG%@-3()kJy66{QA%ds@F{9Ehk!)I@SH_H(+NIr>68RSj1Zv`1jnnfJM)f z7fcaUe8Dsx%{nwH$44K;{L&G*fW!+~6N(;56LOaFre)ySZQ z8e>z01m#5{X@akm@gT7ZLtlx56Qse;r&c9Wtts8ovpSiGXu zZVO0uQYBi%yGMrTDZG32j+V-JG2&3LmER3!s^z^5HPa+xi5o8l!fS1KnqIAhi(c-J z6iyzy4mqH`T(j{1zwHyhjG7aumfAUyFzT3=`-U^TJdiqE{hxUWjr2`kD8^TFhteo!&%BBmmBdy z2BAo8>~S$m5FAbF1`MkF1^t`)yrmx4jt{f znXfa0%=*=YAA~ina^_+slp*msco5eQtT6g|(tdeyzqemSHtv4Ds+@U)B!&i8Iww}5 zNgSO%zYU+6t?mpUH0FfL{u$-Gy$<(ko52ue&^v9)OojsF30&#=R*OAI?4gb3(j&YEk?8JHj{C?2S*f+rr30CEPBNQPlF9=N!o z#%o1aSH8sq?}RJyj(Ffr5RW&GD*+Y4A^HB*{ob4RCI^Y@PbSkn?^Rb-S65e8S65GG z>6;_5&v?fV%3(|-=@$Q0`wI6RJtH}k(4_?DbZE-U#hdd_j}VhE?c?0g&B?yP?`siY zU*I>RyuBEkKd5bq9P*sLN8-6@YqNvXI6lNVPuZs1XFQjr0@H?bu7stN=S9|Fq4{Na z195ckHjV^^-8pO35fQedt^^{&SVp(6A~*||v#;V{o1FAt79?fv`6m33Fkig4%lYCf zJlID05`3PlP57;Qi`T5v65@!>JTswAgho)Tg>`MG4~;&ce-BQ$Ga)b`n84p8{wDFa6MrT8isT_x`JYE{ zT-Fm~7nr|FM*qF-tPQK7(J64f#6TBrtMP`;t?>n_eHBKc4-rzSP_}@nKd_FhCOFo< zV8mPUgy1K<#E1VSR8jJTm&Cz)=}T8I6cX0RcvvGEYQh?-J72nn>g1xA3V_9zWiOTK zFZaGwuD`5&sYZS2T(qV@e_6JsOnL4~xE#v<$KuR!5TG z4$lRo%2Lt>Dul`VU^1RX)_HiYc^*TPlcjPlSjJagY2oZ7++aCXGN+8k&345AJWCil zIjg;)k#dTrS~WbelmUHm=I)L0`KS3l{4e&juFom+ym(QvF!mJq$(Fd_NlxM!r$z2p z{xg5@`XuG-57>|9ec}(^hK+R*{=)A)i*EvDj(e+Kkenc3S4Q+#Z(saIiMLDJ zvrJM^5Dxnp;K|C~*B&q4v@g8%>pVrN>i0byzcG3U>Cy*cf5|?igxINz`P%afME8(+ z)P_C(weXKXwboPVzj%taQ1+jaUq*zYG>HCTlVhD!s>S+he|(MN5TWu*Bw2;(tYJA- zc>_7`I`B()46lozMMf6+OyM<3<2Mcx=cfHUt9xW@v=7w_`iGf=wE&*q#wma-SW9)> zp;3y)?q?*q^nl$DTO%|y256fRYy?b~V1C#mG-}Y9l8dd2jlx+uW7mdQo zc#$}ftlZU#xdfF>VXOT|8Ad_{&dSxsyN64hZF_O-3O+|dxiVk;1cvKlO5L3 z`M4Oy9z;2|&&!t7TRGLy{)U(0F-_l<|C=}MSMvY2pK)^J636fJiPt_;5{IxY2gv-1 zk;`=pd)rUPZ@4}w%6#aNzG?LTLhg+z+}~j#5sK&%b}^GA2atpcFsvlHnp8j!#_2(} zoWC;2^x%q)6;JUW2N>e-@FA44h>^`J6wtC+F=P%k$t)FQV(B|6GFA+}C|RE36oGr3 zz*Qh2jd(XmQ}4H)9#3(lWUhOk4<~on^Ue%Tgw`A!G_#ZZ!)CMBbPS!I88}*^Wc-2I zNx8vk_?FOZ0TdZ2urZe2AvmO;FF0`k9$;BB`2w}Z;)AlpLRFeubV?lOb8FB_11;_4#Q#2_TV~&+o}GWHcz}>U|h@KvdnL`w#oDEON%w(#+rmG4iw6 zEkAz!d~Waz1&MpskfH@h(MG~AkfIBaqH#l6R3JsTxyy~A2Rgt(%nX!_(VYUbZ!$rg zqU}j5ijN_U7qybs^zqP zzsRXTLQYo#pO=M6VTlQ`
Be;}thv2rSTJ)4x%jSe~W6fFjvC9A&(XiHX?f`Cg_ zpNW;#c?xw~R^>{D1R3@XWK~I4a9WuuEuNxxRq~@f#xb-Jev^WhS7~A4Ly_myhDh<3 z#HcOWASR{5DvxRlWe;H^eY#I1O7aEep=5QgH--}m{xyDyaL^DB=k_t|{2r~oekNZ# z85Mo_lW4rcA5X`~G2wZ%qxK=NIb;#MkeAgBZj{5<$&VMy$3*!U&j;0(1Pr2Ulmv{G z2FX^%FGF?5rST-cDv3Q!Aj;a02Sh56E@6!ERNfbs%)CRrEi?aCa-w9$_zypXMFoY`icH$qx)hChBmygVAl{;0jY+2} z;FC-gV4982iKgP@4Al7+E*H9S`P#zeY=uj2pv33(0fy*U<76r$+{Usg(vFW@S$WnQ z-K3JhRF-@5tK;&Il?h9Hi{RFQz3?RCw>s(JJ;s7Pf*Bz{DYktk{jYxAFa8a#85*W? z{h9sGFOjdJ64Nl=Xay`G*obW*vF$Sh?-G6{ib^fUB!h(TFm0zqa#Z}3n7+<)$0(i) zUU&=lr+JDV=GWrQp5m$MUBsT-L~0U)6WaAG+}F-iw3qM;w#Yq2pYoi%P~3qBy=?4+ z2+oJ$Ab%nxZOSQcSD91s?R|^lrdH;Zp__6ZWf@u*S`FIh-<)#!i$kD*JB$!@VkLb686Hbv9%{z^z@O*Y)%1WYnMYhN&gs+Ufkd$Z#VgKZo$a=J}n~WRq6gC*2 z9+bYRBvN8Vuk64uOeG=?Ca)4X!C6rtcf)K73znt+G@>Us?Fw@%_P6ndvf^Evd!8jv zfdmI8a?@~hvF*RNjqk&Q%-o!Dsf|wMMBMv5S-V7|%=M8mX~_cK;@GirKN-{E9C|S) zFnlHF1XNq3i|we~D8Crj(mCgZ20zb9g_VLRQG@j1X+EdiNolMwD7x+U%M)xORFLY80eJ!u(&#~*78O(?FdgI3)@o`HNJM%bEzl5eR2oD;Ad?+DVcHIVS&l|T88mxxBG50so zDI#p~d8--6N=IDzJ0t5+8I%9u8;i1+O}3kJZesAXj&YTVkMJpXre(fyJbxpHNwfr; z!wd6Hr*F%%1G{A|odi1G(1?q8R`vGUk!|9#O9t%DDUZ*?lZUJHH&BSMAEBfb-B6iR z4LFgH@;BCjn6c$o6oZr=k?sP|6Ap0KG!M>if%~U`J4=I`Z-M(NLx}yS16)e; z;QrWY63eA`^~MfW8qwbZ7gFG!bbxz{2Ad)F-xj!40{$xjDhIeZ&4at# z0>|Zw^~SjxT&V?a$Js*cQx0&aG!HJ>0>?F$^+p>FF4F>6rocVz0QVJ7G(&7ft;xH8 z3AiXnZSCzM&D@C3S$zF(Vy~FIP%pfi%99XI>hC?=W=IS{}uV&R*x# zs}I&2h5U^2eOuM;F;-CIsFzF!;itGvf^8Ph9foMBioKi$tnl2PBTcK>w_F9Qz06t( zL~D(ccA#OwmJ65Vc@$KbQ|j`i3>yfqoJ^P5!6_^Adq+;BjcX~IE9%IF=FiM3@`Ul0 zf>od?FEw7F$bx%3Z{XZ1<$eZpWt5gv;CXR!fw=xUY1?7JX?wnm+<S#o$uL)<@np?rB!~n{{J7l{C-ZJ* z$#Jj3iZ~UvEC!gvx`*5M6tf3Bm>jVYwES9^#aJMfIkqU>Oi{XjZ=^%a z`ML|v=fd6%+xDM)yAFWZzj6OXiN}!6Xyg9Q?TzlowI%8Kuafk`ZIP3!H*DLxpnSu&?I)MZuT}9I_jX+;MfC&sD{eozYU9qXZ*SP1 zpTeu(&hLKs^FwImkBcfc{?R!rIWu^B380G0RcxAPTty&j0Cf_vfng)X!4xIngW@?= zfw6eEKD#9IvdLH>j(ii&{Wtb__X}l9gfby3OB&qYIj7pl>}Ap=#07@LxhuPVs*;`J?GRBi%~g?{Zt%z5`EEmAY(o> zL&a4me=QZ|np~ul$o$Ix|yf%i{Kw~(pQk0qaSF3Y2jx>Pb<9Sf+M{(bE zV85}eCt*2(Le+0#I3DP%_+P0QriQBQx$CZv=9jegvnMT09C(7*$7D^Ha|)pmhfxHN zPeIVQG)zFut^0|c3$Y3bY$ZrD{U;gn-PZCm6$5u0XYq`7ZRJ**el2($Km&!nGV+)PYC+!_Bqj?BiM$zCD`aMjAGL)`tQ#)(H|at;n3(0vC(HeIltC8 zlIHacI1$YwGoTTts#ZaV_)fxpskbSePfV#%{o^4ieHEk(W3Q9aQo%FS?F7MFb<}de zw4|fH%Qq=KFZx33DNUpK7)p;)RZUQO&v8)t0~?-)=+h5D$~eMB=|2U}P`8nSx1#i4 zfN2S(`|?amuZ_OYdP>ix`4~!1RaH$;`cy9{J@EY@Dg6EK0Y0 z*D^}`$Qz<&?v1|CdP;9lNQuzd!$fWu-i!~E_R{xsp%G_ z|J~j)N{7oELg~}d7g|s0B89Yz(wkIO6O=~CC}5mLi-({z4Isupe|J)PQ1A?OtGv~s zv~3jeYHKEFZ0a~q-VjR5zqMJ@dP@JUkakg8q^g>rG+rp3K#PZ<^lX3_U;XB!w5t#n z>SkaF>2caUig>e>UMp`1rJrv5A1HlRA?>2{AF8SeN{=SrfpI-89)i+|05RIQC_PyS z3w3K}Q~H-E;>}XJ;AWH3pKJaHO4lo-U6ig?RZUQO8VL@J0$Mx-r8fY?==ZC$PcwwD zP`AEXD1WZdP{rP&6(u<=nw4Ty|G#_Il^-@($^yvd6UNC<7Qd63LqP&`a>h2su zn}+O8oX?N(d1raahokZ{kY_|9ds#@lt$2gG>0`BscvTfy_`E}Lt?`T$6VH~n^Eq;x zc&6j+(1;95#ydPByC8?{vO^FOJ@Qy(VpsmCg=1*QA1YJAh;bhZYr0)H9(Q0KFR}*P z&o9O@zK5&G?GYyS1$HYB7{MkK!rk!tsTv3`lDm__WM7F3Z+1TTu~h$T)yRWYQWKVs zr>ts`ntw^ndaFhrd{}DA<)gr=mIozjBm57mMjo6gHGh|n3$1E-@FJv}MjkAXnn(DEaH3B;Ca(`Krfhae z-j(4(`E``_t3Ps$_0#Cc4Uzs<{ou$sRy}*+q>weC^^BZp)gK)hroPt1=XX`|d#sY* zJ`6wOdGZG-f$jc<9v5;u9jo5MR1tywLJ92t&v}f;i{){%g;yeLJYUkS! z|CRVaekEA^OX zGM}DkKfS?v8Y4=)WQmpL)8Z2|pT5F=`aYfx-XqP@?3N1Slfhwb`wT`x{P>XZ2kK|nuV*NYpE`ZMkN4!T|tr~V4Nekc71y~+nA z6#dbg91JidsNH^wUDxZUVb^-|Y0aIB5)^0=f^ey(&%gv`tXjH+p*tUY#Om;1_ zp4JCWBymi5GVj^(m*W3gTP=gN?dSoM*DHS-K5ca6E^buudU6P?PQ3GQ^kHDgXP%C( zY%a3jEbnXiL-^R+cbzsT9+4gKc<-Y9Y9FWvM<>4#=Qmk7$^3+PbDYgsw!es&q?Oqp&7S|&rBj?IWb+CqhiOneJ;s&%Gn$g@>LvYD?a+O zJtb`FuoC-J_VP)&m6Ie10y&#r!(WoLotZ1|5DG|m9(y3<4&7&jKrJ`^U~V8kiG6kA zXm3agZxvpxHSvNCjz0Z_YFrbiEq52^9g-j=UF1hA^d6E*cxif zkwr384DR4f|CHS6yS%SV)c+-Na+x@-T7vzECoCh9JbjaA372~!Q3<~@g84fYC4?QQJp00c1Y)Oi$_dTfWOAXs5JlZ8Um7vha;lZYJvoFW)aT_&0Ia9v zOhJrZxC5{xr;{jpaiuL~cc@1_I9eK*Y$LTBDRFA~m>FtGt0@tVm0s<^RVGO6-g(BSGJcD#~GKSe&0PUGB4r7>6#3J&?5JYi&X>R+Xd zK4TvbAnk(b7QQ0Z#wo4_qW*K#*6mm0>K@JS-e6+t+dv==U1UP}%^mwCMxq-Z>;#VBHnz<8E(F{F}59 zmr=AkuTSCdeeFnFw=eKb{?NiXNr`#i@+)#9zvh3NJ~F{`@A}9W{GFMAru;B{WGBx( z>mzSD0mc>XZR@$Wd;s~V2SIIauxDy+a02+NKug5|4pvJ@oTqRHkaGjaxmjf|)Swe6@Qek~!ez)|GW^EfbuG6fqB1c78z{5%D zpU?V$AK&4qm!h=j0)k<~{RK&V6xx@@%rU>pS5fcKw|;Kq@P*DH{>xU*q=H!T7bx`y zCYO;F1??s25;&Qp4)}{E-o$}Xj;g;$I9S;Ga#Ryn5f1i~FZ~nGlJ6mqS>nGiTPxtJ ztJR?6inN7eLY?YF^N~}BbeTD;#{{zXiz-|tU(lDRmNdB>1NBwDpu3!>KpF6l=z~EF z8To>)SPl4T0^T3b5v+vu<3jWHrx3j?Qg3#sS27DT28d5X^X)M{{y^RqNzYju9x9== z!6SWXpD+!nIcTk84kGUbF>xDPmOJs^qq+siT;yMmWD2f!D)cu5rj?E@Sr_L7|9m}R31Obi>4JJuQ44Y&K zYBt#{I#IFcblw2>=xlu^2#SV=CN6E_A~q44!TS|=l#rN8=@BOH{r%o!pmh~NGwcTRV3$5Z@`44G|wFz5@*|B$0?ORhq}4lH-)vmsye`{X!! zzg=$Nm;7D>-;!AVM20tTGrKg-}i(cIR)I)S4W4G=BEGVDN@VS!tK}rl}uI= zaYKwrXX#oFE)ldD|9N;0P?Vlthn|i~Gd2*17VO_t=VMmfZ;9hjmSXMnM(?B@eS z9!v_xWp>O??V9(!f7p!Ve7cEI^r_rHB$k{l9_R@@iip%)!X_~5s#AOT(l??s4A4mfQ4rP6c&TC%GJXS!vNBLH z4(%aBCO4F~)f_KGsLpVYmzD46@e<{rI!nhfpg0njh(1w);hx1}fekE|`E`(-ijDpR zCMD`|&*G0oWu@=UOZErS5Eoj?Em3D`FgA0wGR3tVleGzgMr&%MAKS}rj& zVn=1&O=2CLQjJ965~1Y{abbh}F`wCO{N){aMjbuknSSzPAg9cqj(u^X*ptDllF(db zm_Mr`X?niS4Rqo-L0&3Tx|;SkAh}l|xs{kHl^pw#aS-(Qg0qsCDG%fZFJzj@Vi~ky zI+s%o^Q9f|2lP6`nbYnIe`tn7xse&uvqW4*(RmQ(n97bcov3`~@rkRMD$CJBYthtI zu8A?a_MwMriKO-{DFhT!7}a{2Z;6m|+gZ;`fcqIbtDF_Y*N7|$X81w}<*b%3$*hTp z)06&ELcSIu=bs4qw}wahSmsdH8r(cN6P347>6myUH+1#aQ6ay|E#xm%DIs5FF|C+h zkPw41G0+o@73yd1VA03ZxG-1+9LVvsW9Zn(V3$5I&!?quKFx6D>odj!N7fH2XqvNW z6189qqmrfyq$!Rv%r7z0RE>(<*6pWA#i9*j7(3(Of{EARWYHN`jvvprP`5$+A;ZcA z7m+Vz%h4*v=Mi2uhVv2riT7!#+W0GWk@BkA zflUx#J1WhCBE}=~`aSZx4m3Av=vVD4lXk>m86gghua)xkMp;$7F5j*+rt)g!6613D z!+F2Nhu*MAxj?smjcz?SDN4$xG;G|;N8|*fkGx1u9F8e;l&=y9SYX7-*F>WOe`Jld zDf~6a$=}z_zc1*&rd0@gJw+c-r96o8+_MxS1Ni2ALMp=_Hhgor)W2-i%PLL|q;O8s zRd09Xb>R>{L{4x)&pSUd$6YZpa-CEZ&M%8o!8m0`$|eyJ>x2!*zd}kDjVt#`rZgow z`MskE=ch4POl0zhh~~L&0{}#{-ruMoiJd5-wZ&_uxp`65TQ7+#obPh1=0ScC2z`Oz zSWg;5+-0Y~g`+!oANP9$csVaj3Y^1j*`vGqC1rkSA#uH<$D`4z%%vTL%F$QA6|F)K zbRL~T6xQf|DuY51)#}WxHLV`T4C*Nqu3Hl%dD1dKPmT!GgOSqQS>u_#4e!gAMT<$` z-LuU-=b_-Uu8=&a05}ix>h~1Y){n+UprAQ^V`UeoRALQ&8oWW|0g>Z*gj#ZGueZV&<|+PB zl~HDwCrQRf>B~>ni!^*L&ZYPYb)U#~PtiYlPCA9D*Qw32r8aqN4W5@VHOw2e-oQw9 zb~XtJ|_@^`kN#UhZiJ?29^CY&M^hCE#xR4gIL#{QlYS;vI}MHAnSj9 zd|5q_xs*HWO0s%pVh*MRvQqFv_4WlWOA61R-+jTOylEd{3?|~!!j7rZz3?}Fvd<2+ z_oZ#2(@8d$h|SB{n-4H$_S&XQTduNaqO22_+tI8WJWEdDZ9F|*Zb&y$kOT}EPLYvq zG}I|Yu1)vFS8^3)ij9AQ;GdA<6E^^NNTehSkqxMr02LEbAY%e#Oh`%b#^X{g@0}a$ z!;#!1oM@h+yXar>zh&ZiOCBRa;G;{XBLugK5R60!Mw&u!@qvf;*dvSr7VE+-{$ugA;@wH!9dk#h$jBG?RkK>n8xN<{Xd8P=K<+| z8;vsQ(Y(MA0V|y5BgrY*M{LL3|7O~DB9F^ivAJyAaR0Cm|Z*=AJ&7OR4-E{PM zyeC7yBa!CNpZ%&Q+Yo@9oIUgaNhuPBdV}M}j|)r~`16>+r2~K4@W`Cb*#i%ZDoGfK zyM@#Nzz<&5J2!2;4+)S(1epf4Y9ho$6RQo|x3o8|m<&p_s|o_FLkXOQ!T z{Ld^W_D0r9bG}oOq`4e2Rs_a*y}_9%-vR!>B+MUga>;nK*JaLR>#qGF%OBTI#5(X> z!GfN2jU+?FZvFwY27Y zaEATp2K?+idR3CAc$6g2CKak@*>Jwe#d!xM)kx@uc#(2{{C+2cWF+7=vTbH{Syvrh ziGxlqxvXJ1weZXEE;eF)L58h(=;Xkh$}=QN)f@b)N&p>h6Fe_D5E82nXNlNiN*5gH ztdBxOorh+=_R8XUJOeZ0(C7tLA}f7X;y|+Uy)btnQl;}pdH<~3 z?02>mLsKSRZ2Q$K@EKwkCJRbI?*MOb(JE=~ltpEV-CP|VP7H)n11C<9NDW5+gR7X%Ig{Z_QqY8m#bWwtPJvh z;Fk^?_jL~S;g8?fd19$FkQr%1%s^>bn zGNq!P49z)Jok(*5tWrD-TKzX%xk(d2W(k}YY44M~1z~NYvKQPzPk2h6$3-a4IZ-*c zzb4ZuF7=!;Q;zr}QZ+7gYMDRq?0CNBl7g;c2cByjvH85U%eeY=3@dWY1RfO0W5H5F zT9yQ)S`PA*j7$i|2UuT+6pJt*f`icsKYEJml_1b?FuyEvx~BI~?+T*4uMgAaru{C7 znIXp)%4Vgl1d%3jS>dX9ABUazx<0ID;$c>*vnMTbS8QNb+RLouDGGxH8&1qzo+U5w z3X5zpu;Yw5uPR=E+{nP-$HX;t1U5gzRa|zr!YItJS8+l;hN|Lx?t^;p>7?v(H>O%( ziGwq*kFfSQ0jHTDsin336Oa@y^0H%Rj8B$`Xv5iudvElO~t@3OFEyPfOWQkBBATo33#EYUFc=@|cF4%Or5mZ2p0DHnx| zF`?V*l^a?B$OVS6n5G&~CWPo66L7~sN@mK(RA^v+EX_*DEE#nm*fujTs!l7w*$mcO z7_2+JY3Q}RSU1WmV)X3HD(gh?20F&Q*#R4CFMJDKR^cf=9L3;S+FqPK$aRW3-h<$m z;*fHxKkQlYBH^%;-PgkX%sC&?Wn!@9hHg?_)|EK}!%093197g9xJGrG=f%eQZItRa znQ5fs{Hdzv#yNU!K^>{dn(MmNbX}P-XsznHGU>Y2(XR8nX!hM`yX)FB0MP54$^OM; z5-Kh?P(yz7XwUiRCvwo2=Ort?1>x@aB;#h7X(=1k0rAleKvQa$llaC*Vs)T|4QA-t zyq=kX!HCNSmNZux;Y~0s%F|LN`5JHVXkXgL99M55*U0@C17rYe>>$1Jie`z^5-zM} z0}kj)x8QNQh1cve^}Sw_1s)1?;%f9uR$%aRn17NNhfys$^;;uZb8s~axR=O_^PDId zZbz%Z&23=FvroQRNYfhu>t7UhD;FDP90p!ggN&giOM~d?YQ|8?qv}v2BCT_orDCOY z<`GC1la?izb^Q}NqCxT(%$cVIQcNE;GvQ-{Qp!DC z5u#*-ZcC7pjpCWkh+N}<@9gU+^&AIlhWgnE9=G4%rJG!ic$JDJ3O=l3t7H)3^Ys*Z zRl`w+_lq+8^B1BFhtaI5f~FNPfJQkQhn^jkGV=+oC?*ln@l|fxZ`{Ak@ZACpzR)NZ zLI+S8Gt>}1iWQ7KfR8|jHZgoz)nuvB+s+#t%itY{s_s12UfTLYbL%`WjuoXF9INib zK$bAN)4YMX2vq)R(Ys9g%j4)dV>(6w$sXjp4B;}7O2D0u_?=(d*eGT|F^ai5-Sqx$ zlb-C4322e2MplC%{EQmp+FmHhI)I^&Wol4+05f>|S%cS8e2O?T9fS0TCK6Xk%pK`g z8lU`0f1xIS8KikLtjS-pme`a3{548}$>?OpBxK|}@zCbL2uT8}hv+oLB&nOoCg$L^ z*aEAyEg((<8KyI2m=cYsrs6F|Pk@H=Wg0FwfiC;0U_q!7RfSx4&Wp?K-mcTlH+CDEgWXR;pe(5Nb zQJd+9qp*5QT5`e$*oKwJ4t;HzWsfO;&Hg-27smQ)uJ}K-US}C>-ZjHM!Ja6D@Rh9g zOn=Sy&o%VdNd9JZ=a~vqWT}ZgeoZo4GFFawlEdHT3!dRi!#~H0h^29;({bA8a+arf zFS2QyuV?$xeq)M|1pmGd52($ek=tzJm%u4;xu80~V^~+^Wy?YrgV(dD!!Y3@LW8X%k^_J08PzFwb43ZdyB1 za6b5@(-$KC1(7c!|KCmWdy@8&>6MX6m94ZV_mieqd;Hb@tG>vQU0MlKK^d&|lnhPe z+pA_kKsR)8lAvqUR!0U!r>Ci<{y_iAQ7k&j7qXuvndhqUX?WAOdWuNbz*d)pkC3REwSRW-)D^yp z?|b_?eCP$vsY`JgA)tz|0z>s zT9u>(Vh;GlmRU}s-ovoCF(uW;Yto@M0ch{InM$X%f>j?66$jyVwUBKTu| z^9GWFxhn!=4k*JSFot=5Uy8O9Q8}GdxD-_<&FjWOkVJm8(Q_tQ|0ks=PYab}!7e!? zfnQkSK8rm1Py<{EU!5Bo^9Sy>df$iP?4UR?XpvM2t^`T+2E7<8gHZe=Q@tAUzZT#t5=D*3?T+YVp=O@o3QgD4I z8{EwQ%MP>?vr5=E&cSM@yptp`DLZi4Zz9o(jVt7hI$w~bb*(pzq~&!m@OFCHw}&a= zC!+7x;XmWVcfxtJb;sFWZlZ%#-VeEuZnyxR@Umvfo9YfvZbfV3ihro}hsI&VvZDMTa%!}> zsioP0_7E^yNIoYC*=M;-)=!c@R(kGO%0!2tT=VER?X2c-6(2^OP%ae(s## zYeNP0`eJE4D|x1j_D+$*qb=b4WF##F!?DT}rk|{u^><(3cjAl|X9wF00RQ5o$WbD% z^eE5j{`D-mOpI{iUISZ$Gm-+gz!IWl2Kdt7@+`}epCk-dvbU;mqn?Ys@ox!Q{`Bzt zmjvnrg%%zCl)Iy!2`9?il4kHLu|yJ$DW8gcVO+)^bVY>D#JUi#69|!Fmn%u))Y6TS zB5_qijV@1XLt*8rhVh=x{WsFY60f)HT~UTOWCQPWQD|;pgWBlVp0vUWUQQM> z&$35(66=|z(l)trPz7Ibk5wpv46qy85N|V|EW&X7XiSLy8AE3tBijV9ECc_?oa9`o zt(bXi_!0pVcsJ$;&ypd7>SHow+o(XG!jsf#R(} zLBJ2pyW>k$z-zasSRwER&~vNZuVDeTm6{yvBjOqe+r-j2(%R2qd#YzlN}I;%>quqc2zj^c zMeVOI{Mqb(Ii;g-13(hRpN^d-sRwB|yL}3u%u3KCEM z7`_^|j}7(g&!YtE5657u&+CU~prRZ#Kh&uBr=uH0f*hNCswZ@v?u)k46-jhORtdN@ z*%{{f1Ebp$P1;u}-oSox-}};b=c16v&1&xA5;djc{kg;QJGTB_rmJ<-l@rOqa-c3D(6Dd&Q2A_rp4Wy1~t58>8V^vo@5_Lwpk+`bK`##tIr>}A}Pk|m37pyzssJ-k488Cy4F+H z_(7MSGm-IJWgh z?jLMG+*lxXTX%0T6Jb2w ziv{ElT$k)k|1AGR8K2`Cu1qd_Oh_T->zll<{h?cE*twsd!LJezC4Jc&;HW%yNVyae zXzENwOms!HQO$u#of*-4YbiL@lw$uR$j{+}GiKW^T~Yt0Aej~D+zVdX6tkh2XrG|AYSB&;2QGvA9> z%&Qtj0uzlF9$_E{7Yq=2ycTc3P+9ShV5CRRg*@Xvem2vPt#_v(o5wHi{JD&1A}jJF zKYPvYj2fMvz1BEi9^6jL16UppHL@v!k0^G9PZIdBK+;SQRXtq08NxkyFlyYPUj?6b zR5p&!&t-y-?V^A`A{Ap5QzQt0VMPGQ8O9F`Q0YP0X8MBfyR(L>+(&c0##4aUoz+_x z2N?gLNSm@%9=?O`j;Yt?zZqYG?=rDF61HL6zEeL-KW@e}^bCo$P9DS+bNjEFnZxNy z@2T9I>{$tgbsh8Mg7`@$zw{ZQ%7!aBkvF2RH_&HB%s)jn6`tShtD`N-XkcB3(}zlKvI za{JrtzM6`U0Ig&n;i$43{DY@7ZNnW6{{9bXFlTMS6<4sKVm2qCUB(|PEE;2)%eI;u zq?^0iYOcMfc)i`+FG?0Cu3b9jit?Ja1>5!{Rg{dm!qM_v)v}N}Adq>f-F6RYdr?zu zS8<-iNvZ)Z7ODSdx821i^-@QJhnb{SW=x37=sC)6kqB+_oi^3t1y+k`n%bFGi=481 z%5E`3$tW2c_jS&g;Ar!{`y~baicXa|_uqKkO;bog|KQ)IZ_0UCMoGC+Yu%;wyZ$b` zE*G^{VW~CdkROfD=9%=Ks#~uE8%wP%w_E>@v@V^8O6$2oR2o@2bb8)yAm9&1OL|S=$gP zTQr>C*_a>Qk5mdhh*BLOiBEflPrycZPSAF4`VO+d3Z8?N`IhUxIawP7)#Y5jM;^mI z0Tcm_L-YR5#!0d&d;FrOgPEAhN%^(v2Crxfr4~NVVE%y5IsF76`S1hlNLrtlKmf@A zIkr4ZQrMq3@U2pwnczwLYuAqXtn?+|uPXoN$jwoJoMa!Wwh(?Y_QFK$;PWiByJ~+| z6yL%qzMi5POj?3-6qK?ze8Cv}$MRg}($T%eo6N9CZC|jhPK}D;?L9@mNGOaY6vv2A z%p+jCQK48r$5Ndi@|+fot#eJmKrDZ-r-`Q!7erD8;5mdM?(eLIB?4q$vieE<8Tr@G zxz=u9qPmR(_cqafmf8O7e!A_e9Bn^nYuM8oZ@cI|!L%mmVgLQmWeT|J|H$n0~j)CZ2p2pDE7KR%7U(dFBd5w+IUQkj~ z3B8=&#p?U@@LzPeD4+2TRJ&WKW@HqW|4>+WhG$84*>VaU{s~$qiVv?=%HiU;aDw{T z)JziPYwWqZ3G~jg(VJ$Ycd-LK$%~-HBh`VP-+|todo?EuXJ@2(im{U7D&zQw3!`D9 zLqTD2Yg1UPon^s&VxClc+(Zi2^!5~AOVgF&riu$+ z<-|g<=7OfMcyOl0nk^D!qAb*x!OUXKdo~t@O3=0ZI9c=g-452UbF_i2t-`uqp5m|h zBCH8!3?2~&7*Ej))QpJ3j`bAn;A{9*dBVl5f0s7Ft>5!4JWFgmJ3H{a)5h~lcxZK@ zlUoCwc+!RaXuPnl9|0VKh3Z1&IxgJDDrQ_wF^Zq!;}K2aH_^r~)5h;scx&SK`lX@(^Vf5FVww6=2~HOZb_s^N>p0Vk{bIFKqgKCEIbHme^B z?=>2ZQFt<*$StK1WmIv4ivG@5K&vDGa^0s|P9-@^y7hNLcj1O>T?d#%O(0!y5@93X z#j6x~Stk16$e{z@8a8q`2fYh-b_^UAc}$)t@Ltg#C)>8$WtGk*=#cx57B4}!r}@Lt z!JAIx@Lo?;GLDSykYqehqhSN`wWnb+MLZ1(s|1X>RX{k7cZAP4R(b2V+cAoiV}Oc1 zh7qzH1LL>?0LQ@J3$ll?W#JVX*I z)tv!u#;TyD7m8`=MR7sU5}EB)OWaI3nx4()FsP zdgCZ*=}Nn$EnpN&!u=*}O~U;GI7-5m3b43ms$dGe(Agy6bs&X1*nowHShvnzxcOFB zFQmkh@E11;bwP`S%XCXmE)r(d8|O<)52MI5v${4y!l&f4iVD)Fg)R~vR)B?sL=AYH z0=&oA2W{a|Helgl3<=K=mFf_riDok#ThfAbqqGziq#-s555Ogu^<9A`p;TJ>3I(A_ zI9Ijg9t%ghNI23>!dFYJu`p5tmJDGsNX`_%g*IT}VGIf3n_VQ_eO!znJ+;_H!gSS= z2-0V82@;MsNq7&?;qG=zcc_-!B#bvfTM!c-6mn723)mJlaMEX%W?8(-Utt4 zNa*7x;e%c=B>b?*MZ$9dOOU$hmM&8*)fFtzk>&xm((QYz$3Z+%0`sVhKQ|ZfU96 z(izecGGVr~2aIB9GN!p`x+}J&RRu1ZZnaz50^6Xex7pIWfDWhFErlAkw7}g`-`JMU za<|mpZfTls>Bae)dsj+J|Hg#X+&i&hOI_V9z1}m1dmk@!(e&UFi+gQ#OMbJZI#38_ z+bz9JQFE`HsiZoa)3{IH=;Ge_x}^eJ16*&nR3PK=bi1YdVH@20cAlo`4r%ENrbkWF zISpINaJLlhp=gS>6z6W~t=lb{{-Rr&ZMKvuE!|?b^gS5G(DdmIE}9m`wshYDi+hTu z%k7pn!Zv6+!ffdkK!@AeEzQ*};oim%J~%i|R+lryP*|=TC=a}?X5TYy@a4j?I2-&_ z4gR^gnq`*=_$M*QG|PH6B;;^6Auk>i!?O40y9l|j*kaiMD1eY0v!$J&5FTN-^dE|_ zOc{=1s#HTmo(Ws)wmdiB5jNn*G~l1-XcATk;P0@kGzk|q0=S0@a1S@&?}{vp$7sO! zn1Ig~z(E_Z@GutRb=@^LG{)=ZxmXdj0q=wdu;Q;K;2$6*Jje$8B*j?3*SP>+=LS5; z2E0N8-gcX2MMwaD&Z0)MVq7DDlU;z5-GDzYv{-Sr23%qS9xQ+hY{0*RKrF^Dp|&s& zkY=$nUz+P;MS%_Y2Y3K0{$c|D5=h~`HsF;ZE2vprG1NpCTZyk z-O^LDgjw~*L}}>}Ry$g5j%wIadv{B#kJ6oOtLVzxTr`#1E$xOFXgb?$DFU(KGwqh1 zp%_EcgHv7H8x`BqWOqw_?3R}4mOkN@8KG&BwDcZ}FHO_PhAo}$Zt1ITF*N-;+eOoB z1s3;C&@J6ywsf?#bd}xGXJ8aV(_2$qG)<3fDd2ADJi8@zw^6WLyxG#TfDZ3vg{o<~ zsbNc(yIV?%ZRt37OU6Qrrg3x-{q*;I&AlvX=}x<)goZ8sezl9Hhq}ga?}b?|?k%ue z`VL}f=`^#Y&mlH^lHJljD8{OmOHJ5XwOlHIm3_$Y*<+lf0E>MX)PO(cf*JXtKmfnX zf?G2yQvsI6Q@J%z2f0c3^2itxc9E3CF;HJ!U@_}>-O}}{CDwm{j!eX^W`g&&M zEbHs35n^oh1II_${?K2KiX3Zw?HK7|epTB+rA9kpV$p6-Q8q&}EIvi+(V7SmW*WdJ zk*~s6M;rGPZQ{AG{Y1aC^kCX>R%STE1glM^)lqHqC32*m&%59?MAEdl1+TN#9{x(|PB<0PN zBh$hv+x+)@56jt}@R#!OynH+-ABvk#$hR{2ctAexlaIUPwrEUuV+e;8O0s^KXPGFHM8T^xQ}zHO9`a`|{wK3;Q+z<$VngXE-*SrI@w3xtRAo%wd_Nsm?$5&13mvj6?nzJN|f1 zMU~fk_k8I+e!VaFyn0tG&9q%J`}#r}w72b<#@%brLTxyN1}1jo0RF%BhsqRSE9& zGH)oieBfqd@V_n7X2LAtTh1zpRWGcN(;#a(I6Yh729o`9=tlA$hbHoN?kaRr0pSce zEYdbVsXL>$&?mWn2@~xg2Lz4XGbLK2L`RFPFn&};TZMi`(cB6l6!?(1z9K?s6h8~P z_%Y&)C**Y-T|v%)ZWE~XHBrrIfa+K`s>9u=p4LiKF@NHWFP^bDyD#5~YRfr0`=6S# z;~Sv65{M4YhE&n!>;j4+EMBDNTKdlyTA4Zt7$VO4@4cy42uvdSEA}OLUw$mu{}tm= z^74D0dz(X3p2EA>-y>eYoA$oUC>bv?tKLo3Av+0y+Ws$#?6!ZB>_tyBB~VY~xyZgx z6>YMYP;9k84Hk5jKuwU>TPaYVKCV%1C{X)mxKNF#qK)cT6kCI;5~#q_7H6N5*KJf= zE>L|IKhysl*#jPHN}whH z(J_v4RMGCGGo(GeS?doDJtVHLV6(>=+gC9s1usnx44tggK7Z!Ky$xJtrgJO|ven!=S zYMYQFMvYA$m#K66u1jQvDan>#Y>1FCS`3>g%Vu zP_0!(8`W(TU8puM_4lH(HImQEi>*ZR3=_$QQh%`<$+2!EhsPp$2!5*hDU6!c-QU55 zYRjd5$%9Qv{l9K>@pPps+B^+Ww4{F0pE7tp>EV?6b1;g-pHkHlso#aB)?{}9jc5`OqU4l5fb1twb`zL~>{YB(GLj*(;KXZX`#=B6$dYDlPIWnp*So z$UlMV@_#g?MP9zn)%8!SqRr0-D7K8B3dwOck~hhVt>kCz{Tj)JTBNHR$wW7jyRVHw z@(}z~TI4aN06m=6%j-6(Egw#qCb|vh&M822%$*mgqRrFM6fG_C=ax;I20FD!2kiB5 zB~>laBF~_yHQDc8^XJGOv!W?2auX08WM8g|HreB)z1CWcf1s(g)F10Yw`IoI!<=P3R982;iEeavPx)U3 zYRM5!fm(|N94?`%B?5H`lZqyLE@=E2viEXCM0%-r12uXq5FG+_geuy-RDX5rdP!-h zXVBSNpx%|&?Otk`K#em|Z75LFf#yKxmQ}=3qHdLeU zUFAaZ4OO&}e2!wPrT$VT7Tx{xku&jN50r?r$zpSfh%zC_GNF<>(R{ zWTQLWmWLY!MpN=YszM=Pwdvn=pd7hNP|hAKu3v|bw~HI!wr+fXyP`Gtws+vWj7eO} z?`s01NqmFL#XsIO+JjBBg(3&qmjKkE7W}Gcvw1|T&=w)Eq~a6APotgqKcPLpRC61j zwiE5gFL$B6TorA!Z>QLD=^#GTM!T1d_BesjB)6NCj`!}=_?Elz{p~UrzTc~&jqj%v zTaIsM2fjC9KC8M?6KCn#CP8e)r?G37_ z#N60A){XoTCi0%5`}Qh*UTy5Zgph+0N{5=XPV5iv!D6+|rf;Dmt&`W>_RD--&t~=h z(3BEuHak|I|0NBdZ_!3QpS><~pr>fdX)>Rk-V(AF` z=Ck*M!mXnI4d=667rXj-yDHlK{4vFrqbo-xbwAe`H)5UWeqJdsYz@$`pBtSYY|OhV z%(MG*`r4^zhq=){)s6PCtwKAhXzPp@nD{l?-(S=m+Ob-|#`o%_YB=>TcjFrbnnMfB zQ$?H2)1<8yXaOx1QAJy4BnrOD${FIqw?$I1HlT5>apSsmk_*>rRkU%fpxAO;qZ+Hu zxQMA<^EMzb8i>RpG?vZccoXdyjn&VMc6T@0hqVgrsK%-@9%ZW6Xm7r-F|?Ix2#BI> zbbheW9#f(;7MH6lL3V4b8vrfxk$nZ4yDL0PQ&_s&DK}b8r4@DT>7dnue4BK?P#E{ZeSMIlKH>|PPR2CnPgwp_IIx( zN?-M9sINu>%rTHoS4CSmQ>CdE3?z+i)c&qBUSsywz5Me;C%UovDt6%8DBp0q8ccm+ z?C-mQ=D@d56>WU;q^%a?8@0ddj7~Pb!<)so3H#ed`}tyx_G-5d_;P{^?RQntM*DS& zEk`?Qf7clku{JcDiv>ml9S|K%jZOqfh?8|^l3w0}LfHE26$ zvmg__M*CHP(E#m3%w{&)r<-WU%w`t@)FByTRng}5@K&MioXtLF^3-T2G>Ud~05;F< zd5eVG34KgvyJxcp$GecfLltG(vhDA=R5fXTD{s-$CouUCJZah9+K&)Q7;oC%zU!26 zO-X!6IcT+Y1&9u&+YeWH`6ir>_}rA*9nfBFmZil=C_G!Zml~) zInMrXZiv~oz*z-KR);WToL21=AUQhy0#&p-eYCXWR0mFHDESf^Ou+`Ts75iR^(a2D zP@|aSMseLZ7m90C(MIuciexw_-~u_XIKjP*E@m~Rog6ygEHD+qAt9jB?2*lCtC4bs zWQ36V{A4kU^1By*d0U_GE%+6+Jv78>{YQ|jHu_NHl7*6UltWx4aWG?ST8hVuOyZhj zKjgN$Q?KJRCLXvU$!?C70?E;-i&W9(*mP;z)sZ%eS*=HL(|nC$iW|lM`duh~ zqlz|)A5e6m*lf3UaCGZ67#CXE{9Rx)(2-GP)97q(4;PP#_7!fl&v2vN*Nt{ctI&4N z_N$q!HQF^}n?pNxwzu)UoCB9436tFT-VQW}B+ODpo6XlsTTV%6md(zoD9*-rK%@9h zLfa7|+>|TGMtjvZG_O|j*eJ7=R&m>QbXGX+L70-|Y% zabnq+|1w8oF3TGeb7mx&2TYGpM>hcnd_s@RNZ(l=p)gh9Pg~#->fEzAkI>5Xe^h@t9A#s2+I@`OQjrKSPpk%d72x` zUa?pQWe}+GbjpldP8f8{VE46(NV)=9Bbc>a-sNW5B6WdFe!!>7v@~SNWE#mAECW*%%T-Q@{;o2BGohV+-9In}Uue=)5ax;exBo>c))%qe;#-X&*;!(D=sK$6eg`wsqtC+h1ew zZH%Q(G?z06YnE=5S8X&cmRgokqmz!;M6ujGq;3Y1qt~xcMVqDP#-i9POPw=$n8{e< z+P(F-uDo8eGsf6hpYFo-c~!J=eS)H^`x|4Y6U9+BiZkWa*0FQ%bsEJOW23hl#m;UN z+r*;SEIXYB{6CnFwS>Ms)QPJ#_AN8hQd&)o{gEcxG0TnX0P2u}i&fF)>{w~?P}8Lo z+nefV0<*_h?VrZZhAzNCsaimNEPP;8d7GSn?IE<_ax_5yv^{bOCWU5O za7bfpvpTs^wjD85dbTlt-5`KDcy^*H+A`TynmW|5aoQsi}<+X=dA|R z>~x~|B6G7w@rMDeM)A78X?DigBc(uc^!OrGwAndb+Hv-Hv+Q)v@P`SmYV7~jg{vi@ z);x45d*nY?XtZPOkpI_Kq8MY3oZ&{X zuN%dbSQMM(taFB6%_OZkThrf(tHoJMP!DB~OuAfiHpU)V2vCPW+@gv$Xa6QmIt8LJ z&N{JeBiJexFvx|ir2;HDXmnzI;W9z7347$z(_DyFs-nvtd7dg|kC1G#KtdKip_{>e zfcOpCsx)I8w(Y&CTrzu!1W9JE&HQy|_8KtLmD%g2DmW18)|Wq4X0L~)AFMCrCLMq9 zS+8sz-jTu4NnfbAS|S~E5+NdBB3DIYUa~?7XJnQnq~?a^rN(msah|?_SnWJ=k+5+L zyvo{?aHe1@{V5mQruYgs^v(@D@flG4L3JIY#LEb6*~8{0ctUTtAr)Bgh1t?-aIV*{ zuWZcby34P-N=CFjk`Zn5Ba(Mbn_i?sTmP^W*XITm*xcajHN2ghet<_N(e8{3gl+w# z=L+j;J%xu0VO*nGSa-B%@tHipoxXAxwYPA4tvosIRF!vC-K*>^d?((=J)pUPywoI< zHQ{c;AMQI1s?7xC_TKbr&yuI1$CvhjKd_hEpA)%xncIjf z{hpC^_GQJ~MqJ_dWbKn1UXS*rZ}BWy#yfJ}Ol~8tIEAEtZS+OM&?EErxX`J+1hlI;0@=qyzK}XOZd@Smcm!K+ zyY&X`&dh}=Tp%kq9Gfrs;y)O)t+v`j8QzO8dk4e8Q+HQvh1TAl>(xpn-`ZO0pHyrFYzynzq> z>AUi=P8w?<@U%4N3w+`YELJTBUJ)_yr|-dir!-RBhPoWu0DPjbVNSpq;av!lb4Ws?v&zM{j4F+F4|xKz;V3{fnCNqSUHhv zyusH+ml>TgdbtnVNSE4kjq@f__ut7$rpi7Wz#<@_A$!*IjboOaXFQ@e!QU$RY>70! zrLW|;#j`nN#BnP5?Cr<$haU#Xq%vj){!{0fEe8}d=6A2e+*Ptk;qRC@TZ-(DeakFnkcUh!Y$ znOm(Ifp@)ty2(*f^f#$FU)NZ`i(kTM4DXVUGU% zip!;D4-R=7yL}i=;b$B*#Vh5RkDN72rKZBFk*Q-nh42fGn&MSbW5bbW9+sNB9M2Sm zq-LS6v60-)+9KRbBWYK@FO?mn*$nV=()7IivV#w2<-=0>g?x0@k85f-OHBt014X~o z?9sea&lK%r5)MD(s3~44&wS*pSt>OZj+&wk^43hNMyUNi3gO3`H4jUTq_|VOmR>HB zni5A%(OjvS=B&9+YA$iq6pxdd^K^~Ppl2}^!Ui8sHms1!kL2Sp@N@pMKq_C3dHg!5 zd|W=h#Ku!t3XfJw%|}i?E|r=JM@`WNUI@>0)D%yZXC8FcOpuzOqo(K%dCTlj9k(=> zpTpCvXM~T}NzEnyPu{!7M^z+Y!x>2+LE?lJFe*sUum-P01rtHcKmuoAMxubQYS0z$ z%8D=}xN?b`WMw#x;%!BDU0E-?tkD31pllgTfXcl`6Ls;*@1dX_w)*se;(vP5^3RNjXM z5xybY=5>G8xxra-5=+K8N-8I?l{uh_YbAIbIp3;7uAR%0zK)WrY?kzNlvKJ|;&PV! z#PRsf8hc9UHkNExB{tVQ9Z@(Fe{8bvWJ$H7VdblA_)J2>bXFVYY*@sS>CT3Cvf(WW z4cAZwcXl+a9L8!#Staap5lhZd4aso1A$oyfoGdp)2h$_HO`up1GER{t&M51nwEw=h z55rW%3q2_BFA&+6)>sns*W~zmRbq2t5UbsRKX$`uEO{=WS~nJswyF`@ql6YpsP;`N z3iF)Rrmz}c%w@wrmY_x^H2fDEeuqC&jquNB!+y?&pR!KZgod!YaWS^D;o(e_?8YA( z)&P-_dC<{NrAG_fRY}m!wa4GBj&?TPKi7b4~+3*Y0h>V2I%Q+VgYN_RL**8|(G4T4HFc#t_zc zs|3PYIf`|DqWy3xzS-S8mlgXuDpq|0dp(k=O6(Dt&caufC9hP;L4w-lFjuOcV4ZcU z#BRuY{3CZd8`iPmYtDweZa?zpgobG>EOIuS%Z9&qHsmWVBiAG}d>>|Hq?5DZXg2gX z8}hpPNWX-J53%q={IQwSgALQ24SC&uWH(v)1r{l*V%1kHF)Y54-Jfv{yN|^+&Wdlb zWSO(#Ypi%3i|=<XsPjpsvvtk`9MzP2MwK=@ONs+(O+*fZna#wC=l@0hKB~+0iJdV_=606Z! z(Oc~nVwC+o)*^UC8~hur#h$ZSFC0lRcg*Z#F7U5 ziE+zaxt9(9?hwtY=UMG#RZTU#oF(@qH00H-k;%@6Q(5f}N5jgSxkC12@o>j#SLJ1i z-&s*s<-N2PdO0iRuwt&WVm2YZ%ZfiZ)|;yREIFhEK{59`t~Y;U@q5mSAF|{lXT^F} zoWbI!oE4vC$v>SHpJ2t&RtYuQ-K-2<%@&b;|&W3K(h#c!|_zoNHQB1QjoQw?)jvR&1& z8)mR@xwByhmUMD9jMDyiF`;1-3q#I^@3Mq%=(1Q;`6^5B0%8ZNVd}B4)T+ilKERSk ztP(N@FRD(73{oXFsS{avoK=ktC$Qv7tAvBni6w~*`?7GeQ;GFv$tjM8mC|svs$*l^ zh2N29oej6MWT#a^Qa@zLd{tsMe2s;-TGdGEi!6D?Dq+J%STbIf*bRTr!gH-^Y#3n4 z46B3~ZD*6=!Ncp`hDwW2w8jZ;|TR7Z{8k+n(}T8yfiiwsCLlV8UZ zF#@Z0QTHkLoxJ4GUG*tTHmjzr9rz?NSN*a8RX)!ud`pjwUEcY_SNli_hbqiEJjaL< zyWvz8o^Dm+7~jg0DOL#^j%5j7f#hsh$ih8N&YsJX^Hnva2u@_l=c3)s!v+?Xt3t)9I+m=mO4#t9_!0e`lg)EO!|JhPh_$SDMY3yj0Z@+Z!d_K%)#LFgMjL%w3fx86ZDpN-|6q8d zC?)ZII5RL(p+{yOW+Z37rl-y9Ovf%ZN+nHN1J>}Al!g(oZ7?yzBl1?YjIUkQ(scv^ zdP^J8q<%yWUOaw>tGOdy0n;2v_3G2J5P>@SS#J8Prl1BrzyC~g0b~^$Xko1sZ&@kF zR})qdoZm&IMBr)e#23jB%A72|<_e7-VNE#H+199ozSKg)G_xnsApeecN*%z z;F8h#AifSumGAelc-Y`#eOPKqRqgC+eBoQNO7g#oMGWS%T5)K*F&3>515x-28IKxz zj|8CDg9a!9ud4(Iw-|@;-K0o!4a@dataJ(Z!j&^$(}xXaF9NB4GC~iNY&`>StEp%? zYPwrn0N#wvB!5$vM>}cZv`d6hskv~vyPpBi!rk{hZ3gfBq3`o+t)8#H>@ZkYRTE>I zd{|Q<%TWWPh~Ve7r`;{4r<(B6D3(w>Y%; z8C2Hv88`z!1K;qbqLKsTbsefIjuc?jZe*pprh;X?pJ7TyzdTOpO zbO^6NVsSKE#ium=Xm99qt!lNq@)A_iLhlt0>p3SfD-%PJuIZ!F@hBMa>%kO>zO17l zR1D8SkPBcRHNk4(Cj@4<>*srQH;@RtK6vU4t??9&=sCxjmFW#%mG0F?3qS+c&j`F* zP)8SDcm@s6aaX)c8gzk%@Csg1M0_MXES-t|O6c7p@cFtlC%tz$={=v|tD>k9xd(sj zd~~z>zEITaQ`H%m!OQZ1$XM-`nNNhC(D0s~hT%CVPT^EoSvR9=M{j6imOm5(g)*?5 zhj``EjpjIe!KCQKnCznnU6ZZLz>Vf>PDZZO0tBoBq&jym*NBnNfVr zUUo5isp;oNJ2)u0#X*TylFO+EVH+~{o3pt=&gO5wleKj2qvK0i5ruYP_U{wR!l zixVDwcuq)36EKICa@rUNhjBX8dv#xK_B&koz?vrZ3!%Vp_dEWUk%BZeSf%zn?VD@r5tE7`1UXCmIYi8w_v1L7uAF#jM%0{hIw%O^yqR*uzhWnn%QP zX^^OS#or(Th%;X_w`wj(^M#)c;e+$AY6+g0@m<9J2d6Yk4cxj=#VUbL;N${)(L$-Y zl6e4q_5dP8=zd>(=t`+<^dYoPh}3LG>ZONUi*->vCNy{D)p9x2Qi3ub>;e;TGzy&J zTud1~Xgo$c_+zXg742kRMt)A8_P)i^XI$SYVW8O7cQt2i#SIFhwI5;*Y1| zuzT9kHEVF_u-N_d?y091W5LeGTOZM-ZGV+6U5bxouyVo5I&@^vC5Kz1$9gB#<1Jms zjYV%$?+%GVMq)uD@apoz6Dle2>a#R}sYZKaz;_)|s%mGrS%$UdPx#3yo(dqIeVs2n z;4i2Jf%y6fh|i`N51{|hV6&07y94`e{yGl7uuPQ$itr!P2i*;A^oO>3g~&gZA`gTw zkQ0(TgUV87E`b`X27Ttbq7|-iSJI9G?m~t8Cg677B_{etLd0R}2(7R&Fsb6MoRmNx z{jQ$IUicib5au`tPz*W&xJ^YL=sI5uA=IBirN1xwn&evy%hC$71OMQt%I~8Qy2s+_ zL2-I;cl18wD+s#qQj%-Dhjk9}Caew9Zkem)z;0RTQg+Lrk|y{(I68N)q;2Dfh-=}c zlnkTL2W#;vm8j(HEb`-6wZj8OBOVFSy;(k%HlYb3_!wyyz`X{cH^pg((U{J`K~Veb z6e90F<1lCM4kH&p5e+|EVAnTS5riwy1-f-B@xPvtky5!Sm=?VZYJ>GZLjhhec}DcK zXc6BLiDGk31WrUFnGb(polJQJWlz2WQw+j5#=HudjCPQ6WouQ`7U3EbtpUscJDkY` zb3hpt!I=OGUQPj3nqI&cydgIQWwcVC?!-C`#-OJUJLcg0MEkJ?u)U!lyrIKd=#kw7 z6biTC120!h!FU2R}Y`z9F*bn5#~GL^NAw$`7H0(!S5HZR-cQf zs85_h*VDGOl336L%d`eTwUqwsR;UE;t}B5-T2cc^CV%m@7XKD%Iv#~eVBz6Ws07BB zzdFAaH!Os<8AHGTPWL(PidO+8w4ykC3yjb2j8ieBcs(;Zj<;GFeeny;<|A(hKiM!1 z4GT9Y3G;+Lt2lJrw5)LIiJrL~{o&uasx}4tM)SSlD|798trt4|@AxP{hggNN*g?2-h$!CWw8-c;;tod)LSpc;X zzMr&q|0_Ox;k1_@&q#UWd9;DtW&(w=2#_I@f0j{|_uKZDuUm{a)9_wVJB5bhs}&x0 zKRi4;ctY8V`C7&D?0Qc&)M~v}*y4V;D7*eBS75uQUz}BbXLd^PGnuJ6ChNO_W3{S} z0+Y&rpPdqDj9y{ce>l&9;*L`MidLBKu6&yVr(Xhd>KrX}J03R&kehU|n)IQe@`($X z3e$_+kJM|SZo9QmXDxII%7f0Q+f`qb4H7hv&{gi3M*CDvP?tiMh-yj}5?u;AYT?o>kO7J4 z0tp8jI+r1d>fQRG77TzuPjE}h&jjH?Wx#Ovu0%)B6?FbgnN*jJkr$92*7Sh}UYv>< zISq2M-}sc@LtC!!Oe~Ac#8|C}4Hooe{Cup~m8W4QhG*3nUqV~Cmjr7#IoIwgYOZ(r z+$Go5Vk6tAh0EU1+$FHwE*yZsi02(dY9KUc_Qwx@;dk!Ja}U|Q#a6Js^zJJ*A! z(I0@y@)Z^Y9`#lCAHGwKE7ya_U0{c!y+zLlAQJS9M*ka$Gqk+9&K2zHE8G_7 z9xaPC@ap6HqcAvVIUF&l<9Qu2utD3c zRjkZ&O#c{=#PQcatT*&yLrEhC)!bxv(i%okV?sg9g1QVg;-y|=WI$$X%_Y??UwHB> zP;hdCR;}?E_SvBouul4U_1QEwYIe{%X{cyP51wxp1>v@&Z3Ww9tBYQdYUSmqH8vha z7HtK=nuB1q+HS%#sN$yLdBJLAht?KD<-G@N9`x1gF8&;9Ebu3)u~`fFMprRibX={& zRX4bR{5Hk{o2}ti>Byt(Jm;JW`Whw;{_zT_d4p;8V7-2J$lKDxB6xo z5fl*iG{8=rkEM94uopR>darK^U?FhBS&vb`RQnviquo(o(?J6E$9R7%S0b2K#f8&y zxSv%UcwL!zLU&k4V3tUmj(_EaJ2R~OA4j}{s|FEg=b-RTl1Lb;07;;w;OYfMl z2tM#=v+Qppf)D%g9JL>x232P7$Ip_>^!_c_N{FmPkgWo;Rj$Zj{LsR^jstv9ZxL5D z39^f~AveL5w5$kCjSXN5%+%u0lpM?7lLvoK0iHoNyP~@jvb-TUR`j$L=PLsaGb&RH zrTq&(Wy6cTAXb|TU%+qUDqgx&k@gRK$7+4phk-MBQOV7%U%xiD0F1bipup^^{WJ%{ zy(SP=XtQ6JPE~P+kxC&Eq#EZ4m8(2@C)nUZD0kx}dESN+p;UeWLK!yaxP~_^h49th z9J|)E?+239f!sBI3rct5r?I$2DE%7WVRe&CGO_Y4p>lG87!=!mp`BQspKB&LEtoLr zjtOI}4~g>|`fV?aE%%ZhJ{TO$%UyxaSSX+$$D~I)YHN3rhA`xGEOK!;)%^PGbnM}@ zP+4^#cdyr7vqq~p;F^AtKYT;0@09DByn4rxdg@jR+0Y1G$?}$XO)tS9uJjeQOvP); zVQ__(`!Wt{bvttqI)xIZ-)aHAd_e<+Qy||^}8O#AUne^VfH66P(5NtOJ%mUPO8fbx&5-GXNK}m3& zd&wwR6tOjlN_I>(bDkG-33@Dlb=>^Ka&&Z8&jn*MQ-Y6J3sN+~6dDJC&s!W>MjP0e z`V(wHrtZ!FtAo|X)jy`EGz_E12?GKzTLW5i^&Os#H)p$MoVW6egQwL(DDEt#+^sc= zLkB9paA_HJE5F!t+Uiw%Cahgq_xr4ib5`y7%}1+R&RTv)e$)p}YilDFTT!i1+OIk| zfiPygy|Ql4Y3t(~Oz(v!foy;1YY~txFacJ(t0e1W0S6W)NkwZ1_k*?G@aR@=)f)FB zb?J5PC3PdisWVm`oLGlr4xMW|1I-zYu(ehlyfUpjrYL{6;KjxlX?@mf8EasUYVKhz zo_7Ed?hM&sg-5h%RSm&jm?3=Udb+>x@Es>(ox+-JoQ%}O$mI|@qsJk>)4blQF@3YU zf_94+uU3X&*1G31thDlrZKu^r48tJ^J;-T&Rt<%rAMk2AB?z)lMPms>7p+f=2qC<- zt?dv03J(9%@xxyPp|!{VDaZJOJQ;sa+?=br_ec0G_9AK>KRlqE!-GMYSe%>FmYWTS z(}kP0iknRsQx3?~Q$;~gKlFl2=%}f^Aup|(due0E_ZKy9tN{@z+Q(a?>D(8tJpd*a z*5lN}ZgAQChd)uZg|-V*y%+~C#-W?H&#IUN1ka2-4ha6jpQaw?3mLu)45pD2n2PVF zKKXa7a$u^a!`kkkg^rKBiB^`xlgpg{Hj@v41?EgY77w$daTZpJvOfcJ)JO$uBdbxr zm>4nLJs}6i;C(dw&{nN{#e>z*U zKHABgsb2jUE!4BlTY>!syc^Km8xqVoZuEy`xdO*f#Ed7wQMG}`*8D;Ip!MIgg>$>X z_}4>+r-~L=;0B0fRVqdZZ-n1CxPN`grWr-zhNt;ALCwf9G2JM zuz6RyU6q^e9NxU5$X!{8N#DF8$6a+l=R(-y!jj7)K^4r`n|Ea=S7<|S?cj2E)mhXI zJOmYLiH_2+shQU^y>inGx6J7ffUn?&ZiN8-3d1Hqx!B=Qj7u9dKHXix;KIC~S)otM zx7C&(1Wd+=-AlTqS8VHDx2b~q)objI3fzdW-N(Vvv28{rP zRSK}n6$8vz^U!(SQY^UFB!fHDjkMT`trulrLezDLd&INC=(d@XWZbwJK0c7uG9E$58 z91F+DV5?2gC;K>~dC(^PUTjA&w`+hUdWU*iV?W)gtEbeN(FyA5)Se?J{@*ybKr7s zXdk@}zVMuMsB-wbJNltspo8fx^@b7%cA_WCCZO2p^#g}#BSwmL0lG7+ zKlTAxskzv<46`>0skz<;JVgUBAE4uhX{?4=5bBL8;MRc$BvDE1F&NX0IzrN=c#8eP zH0*wQbD>ka2`sEGi9ex(-Vn&YGu^ml7ySmqvs|x2mv8~ecI*Z9?832gW2b7&_au;O(O#m;aO*xwj94lM&Y zKK%xml>Vkgu3(NYe3L7B64&}iYu#1kcXWa;d;@6b^T1Z0eiNd4FtxtL-rd**X~3Xm zRJ-oXiqHjJ?eZ7ycmILDKk*%W5JG<0uc@OxTYCUu*hRIo`s}0FAzULYG`2`vEWd95||iuxILF z1J}C@zaS2t6+Ipr0Ywcip!!17@5nRGQIC$zUkym^2kUU0um(HER`;;FIs*{m2B0nf zv7v^yk*KlAtdfyYZng}V&q_Mpxf^_6BLee>h?KE>4&l*rx{udka^&?-_#DoE$u1 zde!%s#HZ2<@4?fZ{_uIdWuhE5F2NHV8uf;*%uSE%1;f=bRIh8Lx9;mSuWJ?Sj|!)r zisiXc#`Cbzi){+`x+^(hG<{qnH}jT%ci3(os@=V+C2JH8e9q|V%iRj$9)=U2!*-)O z>JP(-&*EGh`CPeG3*$j(g|BdTa1{kd(~pO%78XPwcwO;v6CBAKg6BXA1DAu~cy32# z?QWxg;2p;>1wQnJr)+I5Qs+Hq>^8=rX7o#LU40=)kH1k1X#jsC+_am5e~$;dg7e?N zp|uoaNKdD8(aM)G7Jp0Ipq#x)*pDB~nO>$<9L#dxLkB0mWw`&K$u9BA9xZs|*Ri3s z+Q*HsCbaxI?VX#>EQqG>-13Cxe)&T!v_`A@?rfIlA5aC90u(gjSG|_MA@T$EZ2(#1 zzUQ|D4%ap20%o?a$8K+Ua93~5srm0cdS&CYE4=QPTeJ>CAbJ;vyPfZ?TMoCxVXdzI zL~n;V&?(p;*A;56?=@G07qh%>MIWDQt=ILQw?px9TYawm{tkiTTD;*d9Z?T0S7>!B z(6abAgHHdt`a&Px%jv?m+CG}=kmlN}x!%)UE3`L87tKF=(9K^w4th8GU7P*xmv?(z z@RRO=qu^{`{vMFkt+q2-E+m<}|FBEl*gXHVc;-mgvW_1oV zX7<<(QhfbLO?U0B@z?#ev|+t>wJ)Efo}sy#G}i{LAJ|uSvUKwRx%#Gq+wUS+pw)e= zxcxmKqQJrJ<&hA~HSaQuDDPW#TYYAa4L-fN$8Mi~Z4XFM5F!hq(#K{sVd|!O!#$BQ z0y|bO&N8%ojs*1QW`%2omX8h9%bUERjo!M*+1~t(V9|TjZJHkFQLDK=(ZW5?_ko*r zD^B;ie(<~2`9oh~e7bpEd%Z417FErynhR?|8L=MQ;&UDLh0hz}M`PD+pR1O$$<^d_ z{phW$KOKO&VSs#S?tU3NQnnumq8l~WenfIwwTf+MFs{}kzAwtRKlGu`wL^2Q!L)9= zSRZ>qqtCTot80MD#4`~_M;mRRfy{^ywu2mX@tOIC)`vwd_d(HK+ zw{F$xK3CLNIIA|$b)?>H2&ly_x1lJK0qyC{Um2T@APv5_ZIoJ+d-K<+f~}NVU;b8f z8~dnt`B=+;S9`<3jTsdp^!nEt6#yXwb40)MRgq64@c$>Dat#-4jv1UG zC4qBz%|JSRB;hWv0)C73jx}fS>w7K#uon7WQNYPi7Y*C-odo^13&D>c8Kd$+xoC(( z)EO7Lt42b@jSLU|i3-v9VJCKTNQdzv`$L70KS7B<1osPf%*COWimlkjL)TXv=rAoW ze|2=aRBuSlWqZ}+X##K}66^mtXC9TN5PH!9RSFhfU@ZL2mVxwN$8r3Gc?jAD z9%u;ctlDT#Cq*c3wrc$wwfy?;(uptIcgo}@Z{g>GEzxu0>eHKYV$7T3u3RTpK+L0p zHqR6P$cn*6iV8BorUomZ78b%SyvSYoB07&a*lZZN2jJv`tQR#mAd3;ckZgAqw|uaq za7u}b5Zq=W2&^u(jzOq2J9>=eujax7qYUoNtK_j8X@xn_uC{!MlM?1uezUS4fcMIQ zT`%Z)e(-D>W?JF*!Cji(AMOF}ih#H|_&~JV$k2I)B(+2%o5jzxpUIJ=zoYa`Plcxj zK7~%!FJGuX-0n44*-@`-QDl+0;${fR?uYAC90sJp--n(_7Yh%%tGw)DcnZ8gvvV*w z)#z)~AIEQL6Z({uw8BGy{*fTGNvy_v_YxaP@MFwK#<5ggOdC`cgS@0Mh@7b@InlKF z(rF!0xzNW(4NgMQjq@=&4(c1ddMEl*UWmBS(CM=({M=pnG1Nfh6m*M7&ye#&32p^vKrJtOa!GWe%b}@?SjFBBkaBBqV9`NJskBuiBvqkiy zcZZ>ttradup7WWp4%5F@xEw~gj(bMdklYXO87WgxBIEIir8Y8}pV<3EhVx6s$^wUu zGa7%z+~i7*ccOi@tH1+iap>^8v`M(Jpb~CZ$*|LVorj;Wc5% zYS9M8eqxvoMj-UO>Gok8Or#Rb=A1tZ*GaHsq^PPQd<6X^*1 z_tF+Z^K;DRr&-O@RrBaFn7>m$N4Q1H_>|$6;A)|`DY_b7tj;sx#d@Ckkl_o*f_~%W zuT@-P7nmyXwI92t9g7DIY5njwC8hi#&$2%3Texg}v={hai(p$8EcKFVTIwa}XoJgB z(K;tE0N%1{T*$MkWxDYjM2?H+&RP#F^*zBQY_{v=SnI0h6j$I4ODd+< z4|z5XCAGiYIg%u_UWIs%TV7LKQg<64E|Dd2EhIF3ogG3b}#IL5;9G;yRT98Uws^El}#{df-S z!UT%-V?CSvl72k5&EysG_>lvIU*OdN*@-xwCt1IQSFfqIvZ1PL`v1F^stA7&5BK!ic{s|mo zEF9`Qt^>!MUy9>W3&(TBQLJ!02OQsJoBhDPHl9}}{!$#@ZZZ3T^CzvwR{TOgo(B%y z!ol;`ar5JKlJ!e?HP6EF0&&b#I9>pbQ!O07PQ)=LDGtvvM)pJ-<|qo_G<2$&057F z*K}N^cOOq>`1%}(o`&nge1(UnBR<)pWze$D31s3s*9qhst&L{DbcXhC#%4iJ8%%(D zY9rRGK+sIqoLq6}sA=?PwMH)~E|`<$u9WWS7ty9JMbH6}vKBbS3U?!l&n1N$^PB)8 zRf3@@+EKt`MQTK%OK*Y*+@`7KU9IL3t

&*a3zu3RkNHcif_IZko-Pg*{AhdJ?=c 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%0Dk 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

$|s;euhwLB$dlH8LImN_>Jj&y7<8R7F7 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∾mCqu^-Uhf(p#bhnMDL#is6-GNl&fYe|S45A$Y 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 wkF0h$=xCSb- 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�kpnu@E!Omgq_udQtaOTJV!R!h% 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 P=8ly$3^*7L%)kE+a=G+- literal 0 HcmV?d00001 From 2efc4e111a732358b3d45082f0d111661f746eab Mon Sep 17 00:00:00 2001 From: jlsantiago Date: Mon, 6 Nov 2023 23:10:34 +0100 Subject: [PATCH 03/18] Include MacOS Intel test --- .github/workflows/main.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 1c08e6e57..42ad4a500 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -17,9 +17,9 @@ jobs: - build: linux-release os: ubuntu-latest config: release - # - build: macos-release - # os: macos-latest - # config: release + - build: macos-release + os: macos-latest + config: release - build: windows-release os: windows-2019 config: release From cfe03cd2657ccc7099babade710b819fa5e6efef Mon Sep 17 00:00:00 2001 From: jlsantiago Date: Mon, 6 Nov 2023 23:12:01 +0100 Subject: [PATCH 04/18] Change to execute test --- .github/workflows/main.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 42ad4a500..f8f4f7a27 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -1,9 +1,9 @@ name: CI on: push: - branches: [master] + branches: [RuntimeDetection] pull_request: - branches: [master] + branches: [RuntimeDetection] jobs: build: From d0856fbbf198a80343787c49de0a1a8053213304 Mon Sep 17 00:00:00 2001 From: jlsantiago Date: Mon, 6 Nov 2023 23:17:58 +0100 Subject: [PATCH 05/18] Include MacOS Build --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index f8f4f7a27..4711de353 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -12,7 +12,7 @@ jobs: strategy: fail-fast: false matrix: - build: [linux-release, windows-release] + build: [linux-release, windows-release, macos-release] include: - build: linux-release os: ubuntu-latest From e9415131805997731023a0f13c23782b81d4315e Mon Sep 17 00:00:00 2001 From: jlsantiago Date: Mon, 6 Nov 2023 23:31:10 +0100 Subject: [PATCH 06/18] Disable metal con x86_64 --- .github/workflows/compile.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/compile.yml b/.github/workflows/compile.yml index c8ef49f78..75f096a80 100644 --- a/.github/workflows/compile.yml +++ b/.github/workflows/compile.yml @@ -148,7 +148,7 @@ jobs: - build: 'arm64' defines: '-DCMAKE_OSX_ARCHITECTURES=arm64' - build: 'x86_64' - defines: '-DCMAKE_OSX_ARCHITECTURES=x86_64' + defines: '-DLLAMA_METAL=OFF -DCMAKE_OSX_ARCHITECTURES=x86_64' runs-on: macos-latest steps: - uses: actions/checkout@v3 From b67198c6ef14a9e8f158f55e1cd88f88788f1468 Mon Sep 17 00:00:00 2001 From: SignalRT Date: Mon, 6 Nov 2023 23:56:12 +0100 Subject: [PATCH 07/18] MacOS Intel Disable METAL --- LLama/LLamaSharp.Runtime.targets | 4 - LLama/runtimes/macos-x86_64/ggml-metal.metal | 2823 ------------------ LLama/runtimes/macos-x86_64/libllama.dylib | Bin 981616 -> 925024 bytes 3 files changed, 2827 deletions(-) delete mode 100644 LLama/runtimes/macos-x86_64/ggml-metal.metal diff --git a/LLama/LLamaSharp.Runtime.targets b/LLama/LLamaSharp.Runtime.targets index 3b2acc30e..bc9a69110 100644 --- a/LLama/LLamaSharp.Runtime.targets +++ b/LLama/LLamaSharp.Runtime.targets @@ -39,9 +39,5 @@ PreserveNewest runtimes/macos-x86_64/libllama.dylib - - PreserveNewest - runtimes/macos-x86_64/ggml-metal.metal - \ No newline at end of file diff --git a/LLama/runtimes/macos-x86_64/ggml-metal.metal b/LLama/runtimes/macos-x86_64/ggml-metal.metal deleted file mode 100644 index 7c35f23a7..000000000 --- a/LLama/runtimes/macos-x86_64/ggml-metal.metal +++ /dev/null @@ -1,2823 +0,0 @@ -#include - -using namespace metal; - -#define MAX(x, y) ((x) > (y) ? (x) : (y)) - -#define QK4_0 32 -#define QR4_0 2 -typedef struct { - half d; // delta - uint8_t qs[QK4_0 / 2]; // nibbles / quants -} block_q4_0; - -#define QK4_1 32 -typedef struct { - half d; // delta - half m; // min - uint8_t qs[QK4_1 / 2]; // nibbles / quants -} block_q4_1; - -#define QK5_0 32 -typedef struct { - half d; // delta - uint8_t qh[4]; // 5-th bit of quants - uint8_t qs[QK5_0 / 2]; // nibbles / quants -} block_q5_0; - -#define QK5_1 32 -typedef struct { - half d; // delta - half m; // min - uint8_t qh[4]; // 5-th bit of quants - uint8_t qs[QK5_1 / 2]; // nibbles / quants -} block_q5_1; - -#define QK8_0 32 -typedef struct { - half d; // delta - int8_t qs[QK8_0]; // quants -} block_q8_0; - -// general-purpose kernel for addition of two tensors -// pros: works for non-contiguous tensors, supports broadcast across dims 1, 2 and 3 -// cons: not very efficient -kernel void kernel_add( - device const char * src0, - device const char * src1, - device char * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant int64_t & ne03, - constant int64_t & nb00, - constant int64_t & nb01, - constant int64_t & nb02, - constant int64_t & nb03, - constant int64_t & ne10, - constant int64_t & ne11, - constant int64_t & ne12, - constant int64_t & ne13, - constant int64_t & nb10, - constant int64_t & nb11, - constant int64_t & nb12, - constant int64_t & nb13, - constant int64_t & ne0, - constant int64_t & ne1, - constant int64_t & ne2, - constant int64_t & ne3, - constant int64_t & nb0, - constant int64_t & nb1, - constant int64_t & nb2, - constant int64_t & nb3, - uint3 tgpig[[threadgroup_position_in_grid]], - uint3 tpitg[[thread_position_in_threadgroup]], - uint3 ntg[[threads_per_threadgroup]]) { - const int64_t i03 = tgpig.z; - const int64_t i02 = tgpig.y; - const int64_t i01 = tgpig.x; - - const int64_t i13 = i03 % ne13; - const int64_t i12 = i02 % ne12; - const int64_t i11 = i01 % ne11; - - device const char * src0_ptr = src0 + i03*nb03 + i02*nb02 + i01*nb01 + tpitg.x*nb00; - device const char * src1_ptr = src1 + i13*nb13 + i12*nb12 + i11*nb11 + tpitg.x*nb10; - device char * dst_ptr = dst + i03*nb3 + i02*nb2 + i01*nb1 + tpitg.x*nb0; - - for (int i0 = tpitg.x; i0 < ne0; i0 += ntg.x) { - ((device float *)dst_ptr)[0] = ((device float *)src0_ptr)[0] + ((device float *)src1_ptr)[0]; - - src0_ptr += ntg.x*nb00; - src1_ptr += ntg.x*nb10; - dst_ptr += ntg.x*nb0; - } -} - -// assumption: src1 is a row -// broadcast src1 into src0 -kernel void kernel_add_row( - device const float4 * src0, - device const float4 * src1, - device float4 * dst, - constant int64_t & nb [[buffer(27)]], - uint tpig[[thread_position_in_grid]]) { - dst[tpig] = src0[tpig] + src1[tpig % nb]; -} - -kernel void kernel_mul( - device const float4 * src0, - device const float4 * src1, - device float4 * dst, - uint tpig[[thread_position_in_grid]]) { - dst[tpig] = src0[tpig] * src1[tpig]; -} - -// assumption: src1 is a row -// broadcast src1 into src0 -kernel void kernel_mul_row( - device const float4 * src0, - device const float4 * src1, - device float4 * dst, - constant int64_t & nb, - uint tpig[[thread_position_in_grid]]) { - dst[tpig] = src0[tpig] * src1[tpig % nb]; -} - -kernel void kernel_scale( - device const float * src0, - device float * dst, - constant float & scale, - uint tpig[[thread_position_in_grid]]) { - dst[tpig] = src0[tpig] * scale; -} - -kernel void kernel_scale_4( - device const float4 * src0, - device float4 * dst, - constant float & scale, - uint tpig[[thread_position_in_grid]]) { - dst[tpig] = src0[tpig] * scale; -} - -kernel void kernel_silu( - device const float4 * src0, - device float4 * dst, - uint tpig[[thread_position_in_grid]]) { - device const float4 & x = src0[tpig]; - dst[tpig] = x / (1.0f + exp(-x)); -} - -kernel void kernel_relu( - device const float * src0, - device float * dst, - uint tpig[[thread_position_in_grid]]) { - dst[tpig] = max(0.0f, src0[tpig]); -} - -kernel void kernel_sqr( - device const float * src0, - device float * dst, - uint tpig[[thread_position_in_grid]]) { - dst[tpig] = src0[tpig] * src0[tpig]; -} - -constant float GELU_COEF_A = 0.044715f; -constant float SQRT_2_OVER_PI = 0.79788456080286535587989211986876f; - -kernel void kernel_gelu( - device const float4 * src0, - device float4 * dst, - uint tpig[[thread_position_in_grid]]) { - device const float4 & x = src0[tpig]; - - // BEWARE !!! - // Simply using "tanh" instead of "precise::tanh" will sometimes results in NaNs! - // This was observed with Falcon 7B and 40B models - // - dst[tpig] = 0.5f*x*(1.0f + precise::tanh(SQRT_2_OVER_PI*x*(1.0f + GELU_COEF_A*x*x))); -} - -kernel void kernel_soft_max( - device const float * src0, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - threadgroup float * buf [[threadgroup(0)]], - uint tgpig[[threadgroup_position_in_grid]], - uint tpitg[[thread_position_in_threadgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]], - uint tiisg[[thread_index_in_simdgroup]], - uint ntg[[threads_per_threadgroup]]) { - const int64_t i03 = (tgpig) / (ne02*ne01); - const int64_t i02 = (tgpig - i03*ne02*ne01) / ne01; - const int64_t i01 = (tgpig - i03*ne02*ne01 - i02*ne01); - - device const float * psrc0 = src0 + i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; - device float * pdst = dst + i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; - - // parallel max - float lmax = tpitg < ne00 ? psrc0[tpitg] : -INFINITY; - - for (int i00 = tpitg + ntg; i00 < ne00; i00 += ntg) { - lmax = MAX(lmax, psrc0[i00]); - } - - float max = simd_max(lmax); - if (tiisg == 0) { - buf[sgitg] = max; - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - // broadcast, simd group number is ntg / 32 - for (uint i = ntg / 32 / 2; i > 0; i /= 2) { - if (tpitg < i) { - buf[tpitg] = MAX(buf[tpitg], buf[tpitg + i]); - } - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - max = buf[0]; - - // parallel sum - float lsum = 0.0f; - for (int i00 = tpitg; i00 < ne00; i00 += ntg) { - const float exp_psrc0 = exp(psrc0[i00] - max); - lsum += exp_psrc0; - // Remember the result of exp here. exp is expensive, so we really do not - // wish to compute it twice. - pdst[i00] = exp_psrc0; - } - - float sum = simd_sum(lsum); - if (tiisg == 0) { - buf[sgitg] = sum; - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - // broadcast, simd group number is ntg / 32 - for (uint i = ntg / 32 / 2; i > 0; i /= 2) { - if (tpitg < i) { - buf[tpitg] += buf[tpitg + i]; - } - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - sum = buf[0]; - - for (int i00 = tpitg; i00 < ne00; i00 += ntg) { - pdst[i00] /= sum; - } -} - -kernel void kernel_soft_max_4( - device const float * src0, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - threadgroup float * buf [[threadgroup(0)]], - uint tgpig[[threadgroup_position_in_grid]], - uint tpitg[[thread_position_in_threadgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]], - uint tiisg[[thread_index_in_simdgroup]], - uint ntg[[threads_per_threadgroup]]) { - const int64_t i03 = (tgpig) / (ne02*ne01); - const int64_t i02 = (tgpig - i03*ne02*ne01) / ne01; - const int64_t i01 = (tgpig - i03*ne02*ne01 - i02*ne01); - - device const float4 * psrc4 = (device const float4 *)(src0 + i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00); - device float4 * pdst4 = (device float4 *)(dst + i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00); - - // parallel max - float4 lmax4 = tpitg < ne00/4 ? psrc4[tpitg] : -INFINITY; - - for (int i00 = tpitg + ntg; i00 < ne00/4; i00 += ntg) { - lmax4 = fmax(lmax4, psrc4[i00]); - } - - const float lmax = MAX(MAX(lmax4[0], lmax4[1]), MAX(lmax4[2], lmax4[3])); - float max = simd_max(lmax); - if (tiisg == 0) { - buf[sgitg] = max; - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - // broadcast, simd group number is ntg / 32 - for (uint i = ntg / 32 / 2; i > 0; i /= 2) { - if (tpitg < i) { - buf[tpitg] = MAX(buf[tpitg], buf[tpitg + i]); - } - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - max = buf[0]; - - // parallel sum - float4 lsum4 = 0.0f; - for (int i00 = tpitg; i00 < ne00/4; i00 += ntg) { - const float4 exp_psrc4 = exp(psrc4[i00] - max); - lsum4 += exp_psrc4; - pdst4[i00] = exp_psrc4; - } - - const float lsum = lsum4[0] + lsum4[1] + lsum4[2] + lsum4[3]; - float sum = simd_sum(lsum); - if (tiisg == 0) { - buf[sgitg] = sum; - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - // broadcast, simd group number is ntg / 32 - for (uint i = ntg / 32 / 2; i > 0; i /= 2) { - if (tpitg < i) { - buf[tpitg] += buf[tpitg + i]; - } - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - sum = buf[0]; - - for (int i00 = tpitg; i00 < ne00/4; i00 += ntg) { - pdst4[i00] /= sum; - } -} - -kernel void kernel_diag_mask_inf( - device const float * src0, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int & n_past, - uint3 tpig[[thread_position_in_grid]]) { - const int64_t i02 = tpig[2]; - const int64_t i01 = tpig[1]; - const int64_t i00 = tpig[0]; - - if (i00 > n_past + i01) { - dst[i02*ne01*ne00 + i01*ne00 + i00] = -INFINITY; - } else { - dst[i02*ne01*ne00 + i01*ne00 + i00] = src0[i02*ne01*ne00 + i01*ne00 + i00]; - } -} - -kernel void kernel_diag_mask_inf_8( - device const float4 * src0, - device float4 * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int & n_past, - uint3 tpig[[thread_position_in_grid]]) { - - const int64_t i = 2*tpig[0]; - - dst[i+0] = src0[i+0]; - dst[i+1] = src0[i+1]; - int64_t i4 = 4*i; - const int64_t i02 = i4/(ne00*ne01); i4 -= i02*ne00*ne01; - const int64_t i01 = i4/(ne00); i4 -= i01*ne00; - const int64_t i00 = i4; - for (int k = 3; k >= 0; --k) { - if (i00 + 4 + k <= n_past + i01) { - break; - } - dst[i+1][k] = -INFINITY; - if (i00 + k > n_past + i01) { - dst[i][k] = -INFINITY; - } - } -} - -kernel void kernel_norm( - device const void * src0, - device float * dst, - constant int64_t & ne00, - constant uint64_t & nb01, - constant float & eps, - threadgroup float * sum [[threadgroup(0)]], - uint tgpig[[threadgroup_position_in_grid]], - uint tpitg[[thread_position_in_threadgroup]], - uint ntg[[threads_per_threadgroup]]) { - device const float * x = (device const float *) ((device const char *) src0 + tgpig*nb01); - // MEAN - // parallel sum - sum[tpitg] = 0.0f; - for (int i00 = tpitg; i00 < ne00; i00 += ntg) { - sum[tpitg] += x[i00]; - } - // reduce - threadgroup_barrier(mem_flags::mem_threadgroup); - for (uint i = ntg/2; i > 0; i /= 2) { - if (tpitg < i) { - sum[tpitg] += sum[tpitg + i]; - } - threadgroup_barrier(mem_flags::mem_threadgroup); - } - const float mean = sum[0] / ne00; - - // recenter and VARIANCE - threadgroup_barrier(mem_flags::mem_threadgroup); - device float * y = dst + tgpig*ne00; - sum[tpitg] = 0.0f; - for (int i00 = tpitg; i00 < ne00; i00 += ntg) { - y[i00] = x[i00] - mean; - sum[tpitg] += y[i00] * y[i00]; - } - - // reduce - threadgroup_barrier(mem_flags::mem_threadgroup); - for (uint i = ntg/2; i > 0; i /= 2) { - if (tpitg < i) { - sum[tpitg] += sum[tpitg + i]; - } - threadgroup_barrier(mem_flags::mem_threadgroup); - } - const float variance = sum[0] / ne00; - - const float scale = 1.0f/sqrt(variance + eps); - for (int i00 = tpitg; i00 < ne00; i00 += ntg) { - y[i00] = y[i00] * scale; - } -} - -kernel void kernel_rms_norm( - device const void * src0, - device float * dst, - constant int64_t & ne00, - constant uint64_t & nb01, - constant float & eps, - threadgroup float * sum [[threadgroup(0)]], - uint tgpig[[threadgroup_position_in_grid]], - uint tpitg[[thread_position_in_threadgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]], - uint tiisg[[thread_index_in_simdgroup]], - uint ntg[[threads_per_threadgroup]]) { - device const float4 * x = (device const float4 *) ((device const char *) src0 + tgpig*nb01); - device const float * x_scalar = (device const float *) x; - - float4 sumf = 0; - float all_sum = 0; - - // parallel sum - for (int i00 = tpitg; i00 < ne00/4; i00 += ntg) { - sumf += x[i00] * x[i00]; - } - all_sum = sumf[0] + sumf[1] + sumf[2] + sumf[3]; - all_sum = simd_sum(all_sum); - if (tiisg == 0) { - sum[sgitg] = all_sum; - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - // broadcast, simd group number is ntg / 32 - for (uint i = ntg / 32 / 2; i > 0; i /= 2) { - if (tpitg < i) { - sum[tpitg] += sum[tpitg + i]; - } - } - if (tpitg == 0) { - for (int i = 4 * (ne00 / 4); i < ne00; i++) { - sum[0] += x_scalar[i]; - } - sum[0] /= ne00; - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - const float mean = sum[0]; - const float scale = 1.0f/sqrt(mean + eps); - - device float4 * y = (device float4 *) (dst + tgpig*ne00); - device float * y_scalar = (device float *) y; - for (int i00 = tpitg; i00 < ne00/4; i00 += ntg) { - y[i00] = x[i00] * scale; - } - if (tpitg == 0) { - for (int i00 = 4 * (ne00 / 4); i00 < ne00; i00++) { - y_scalar[i00] = x_scalar[i00] * scale; - } - } -} - -// function for calculate inner product between half a q4_0 block and 16 floats (yl), sumy is SUM(yl[i]) -// il indicates where the q4 quants begin (0 or QK4_0/4) -// we assume that the yl's have been multiplied with the appropriate scale factor -// that corresponds to the missing bit shifts (1, 1/16, 1/256, 1/4096) -inline float block_q_n_dot_y(device const block_q4_0 * qb_curr, float sumy, thread float * yl, int il) { - float d = qb_curr->d; - - float2 acc = 0.f; - - device const uint16_t * qs = ((device const uint16_t *)qb_curr + 1 + il/2); - - for (int i = 0; i < 8; i+=2) { - acc[0] += yl[i + 0] * (qs[i / 2] & 0x000F) - + yl[i + 1] * (qs[i / 2] & 0x0F00); - acc[1] += yl[i + 8] * (qs[i / 2] & 0x00F0) - + yl[i + 9] * (qs[i / 2] & 0xF000); - } - return d * (sumy * -8.f + acc[0] + acc[1]); -} - -// function for calculate inner product between half a q4_1 block and 16 floats (yl), sumy is SUM(yl[i]) -// il indicates where the q4 quants begin (0 or QK4_0/4) -// we assume that the yl's have been multiplied with the appropriate scale factor -// that corresponds to the missing bit shifts (1, 1/16, 1/256, 1/4096) -inline float block_q_n_dot_y(device const block_q4_1 * qb_curr, float sumy, thread float * yl, int il) { - float d = qb_curr->d; - float m = qb_curr->m; - - float2 acc = 0.f; - - device const uint16_t * qs = ((device const uint16_t *)qb_curr + 2 + il/2); - - for (int i = 0; i < 8; i+=2) { - acc[0] += yl[i + 0] * (qs[i / 2] & 0x000F) - + yl[i + 1] * (qs[i / 2] & 0x0F00); - acc[1] += yl[i + 8] * (qs[i / 2] & 0x00F0) - + yl[i + 9] * (qs[i / 2] & 0xF000); - } - return d * (acc[0] + acc[1]) + sumy * m; -} - -// function for calculate inner product between half a q5_0 block and 16 floats (yl), sumy is SUM(yl[i]) -// il indicates where the q5 quants begin (0 or QK5_0/4) -// we assume that the yl's have been multiplied with the appropriate scale factor -// that corresponds to the missing bit shifts (1, 1/16, 1/256, 1/4096) -inline float block_q_n_dot_y(device const block_q5_0 * qb_curr, float sumy, thread float * yl, int il) { - float d = qb_curr->d; - - float2 acc = 0.f; - - device const uint16_t * qs = ((device const uint16_t *)qb_curr + 3 + il/2); - const uint32_t qh = *((device const uint32_t *)qb_curr->qh); - - for (int i = 0; i < 8; i+=2) { - acc[0] += yl[i + 0] * ((qs[i / 2] & 0x000F) | ((qh >> (i+0+il ) << 4 ) & 0x00010)) - + yl[i + 1] * ((qs[i / 2] & 0x0F00) | ((qh >> (i+1+il ) << 12) & 0x01000)); - acc[1] += yl[i + 8] * ((qs[i / 2] & 0x00F0) | ((qh >> (i+0+il+QK5_0/2) << 8 ) & 0x00100)) - + yl[i + 9] * ((qs[i / 2] & 0xF000) | ((qh >> (i+1+il+QK5_0/2) << 16) & 0x10000)); - } - return d * (sumy * -16.f + acc[0] + acc[1]); -} - -// function for calculate inner product between half a q5_1 block and 16 floats (yl), sumy is SUM(yl[i]) -// il indicates where the q5 quants begin (0 or QK5_1/4) -// we assume that the yl's have been multiplied with the appropriate scale factor -// that corresponds to the missing bit shifts (1, 1/16, 1/256, 1/4096) -inline float block_q_n_dot_y(device const block_q5_1 * qb_curr, float sumy, thread float * yl, int il) { - float d = qb_curr->d; - float m = qb_curr->m; - - float2 acc = 0.f; - - device const uint16_t * qs = ((device const uint16_t *)qb_curr + 4 + il/2); - const uint32_t qh = *((device const uint32_t *)qb_curr->qh); - - for (int i = 0; i < 8; i+=2) { - acc[0] += yl[i + 0] * ((qs[i / 2] & 0x000F) | ((qh >> (i+0+il ) << 4 ) & 0x00010)) - + yl[i + 1] * ((qs[i / 2] & 0x0F00) | ((qh >> (i+1+il ) << 12) & 0x01000)); - acc[1] += yl[i + 8] * ((qs[i / 2] & 0x00F0) | ((qh >> (i+0+il+QK5_0/2) << 8 ) & 0x00100)) - + yl[i + 9] * ((qs[i / 2] & 0xF000) | ((qh >> (i+1+il+QK5_0/2) << 16) & 0x10000)); - } - return d * (acc[0] + acc[1]) + sumy * m; -} - -// putting them in the kernel cause a significant performance penalty -#define N_DST 4 // each SIMD group works on 4 rows -#define N_SIMDGROUP 2 // number of SIMD groups in a thread group -#define N_SIMDWIDTH 32 // assuming SIMD group size is 32 -//Note: This is a template, but strictly speaking it only applies to -// quantizations where the block size is 32. It also does not -// giard against the number of rows not being divisible by -// N_DST, so this is another explicit assumption of the implementation. -template -void mul_vec_q_n_f32(device const void * src0, device const float * src1, device float * dst, - int64_t ne00, int64_t ne01, int64_t ne02, int64_t ne10, int64_t ne12, int64_t ne0, int64_t ne1, uint gqa, - uint3 tgpig, uint tiisg, uint sgitg) { - const int nb = ne00/QK4_0; - - const int r0 = tgpig.x; - const int r1 = tgpig.y; - const int im = tgpig.z; - - const int first_row = (r0 * nsg + sgitg) * nr; - - const uint offset0 = first_row * nb + im/gqa*(nb*ne0); - - device const block_q_type * x = (device const block_q_type *) src0 + offset0; - device const float * y = (device const float *) src1 + r1*ne10 + im*ne00*ne1; - - float yl[16]; // src1 vector cache - float sumf[nr] = {0.f}; - - const int ix = (tiisg/2); - const int il = (tiisg%2)*8; - - device const float * yb = y + ix * QK4_0 + il; - - // each thread in a SIMD group deals with half a block. - for (int ib = ix; ib < nb; ib += nw/2) { - float sumy = 0; - for (int i = 0; i < 8; i += 2) { - sumy += yb[i] + yb[i+1]; - yl[i+0] = yb[i+ 0]; - yl[i+1] = yb[i+ 1]/256.f; - - sumy += yb[i+16] + yb[i+17]; - yl[i+8] = yb[i+16]/16.f; - yl[i+9] = yb[i+17]/4096.f; - } - - for (int row = 0; row < nr; row++) { - sumf[row] += block_q_n_dot_y(x+ib+row*nb, sumy, yl, il); - } - - yb += QK4_0 * 16; - } - - for (int row = 0; row < nr; ++row) { - const float tot = simd_sum(sumf[row]); - if (tiisg == 0 && first_row + row < ne01) { - dst[im*ne0*ne1 + r1*ne0 + first_row + row] = tot; - } - } -} - -kernel void kernel_mul_mv_q4_0_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - mul_vec_q_n_f32(src0,src1,dst,ne00,ne01,ne02,ne10,ne12,ne0,ne1,gqa,tgpig,tiisg,sgitg); -} - -kernel void kernel_mul_mv_q4_1_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - mul_vec_q_n_f32(src0,src1,dst,ne00,ne01,ne02,ne10,ne12,ne0,ne1,gqa,tgpig,tiisg,sgitg); -} - -kernel void kernel_mul_mv_q5_0_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - mul_vec_q_n_f32(src0,src1,dst,ne00,ne01,ne02,ne10,ne12,ne0,ne1,gqa,tgpig,tiisg,sgitg); -} - -kernel void kernel_mul_mv_q5_1_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - mul_vec_q_n_f32(src0,src1,dst,ne00,ne01,ne02,ne10,ne12,ne0,ne1,gqa,tgpig,tiisg,sgitg); -} - - -#define NB_Q8_0 8 - -kernel void kernel_mul_mv_q8_0_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - const int nr = N_DST; - const int nsg = N_SIMDGROUP; - const int nw = N_SIMDWIDTH; - - const int nb = ne00/QK8_0; - const int r0 = tgpig.x; - const int r1 = tgpig.y; - const int im = tgpig.z; - const int first_row = (r0 * nsg + sgitg) * nr; - const uint offset0 = first_row * nb + im/gqa*(nb*ne0); - device const block_q8_0 * x = (device const block_q8_0 *) src0 + offset0; - device const float * y = (device const float *) src1 + r1*ne10 + im*ne00*ne1; - - float yl[NB_Q8_0]; - float sumf[nr]={0.f}; - - const int ix = tiisg/4; - const int il = tiisg%4; - - device const float * yb = y + ix * QK8_0 + NB_Q8_0*il; - - // each thread in a SIMD group deals with NB_Q8_0 quants at a time - for (int ib = ix; ib < nb; ib += nw/4) { - for (int i = 0; i < NB_Q8_0; ++i) { - yl[i] = yb[i]; - } - - for (int row = 0; row < nr; row++) { - device const int8_t * qs = x[ib+row*nb].qs + NB_Q8_0*il; - float sumq = 0.f; - for (int iq = 0; iq < NB_Q8_0; ++iq) { - sumq += qs[iq] * yl[iq]; - } - sumf[row] += sumq*x[ib+row*nb].d; - } - - yb += NB_Q8_0 * nw; - } - - for (int row = 0; row < nr; ++row) { - const float tot = simd_sum(sumf[row]); - if (tiisg == 0 && first_row + row < ne01) { - dst[r1*ne0 + im*ne0*ne1 + first_row + row] = tot; - } - } -} - -#define N_F32_F32 4 - -kernel void kernel_mul_mv_f32_f32( - device const char * src0, - device const char * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant int64_t & ne10, - constant int64_t & ne11, - constant int64_t & ne12, - constant uint64_t & nb10, - constant uint64_t & nb11, - constant uint64_t & nb12, - constant int64_t & ne0, - constant int64_t & ne1, - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]]) { - - const int64_t r0 = tgpig.x; - const int64_t rb = tgpig.y*N_F32_F32; - const int64_t im = tgpig.z; - - device const float * x = (device const float *) (src0 + r0*nb01 + im/(ne12/ne02)*nb02); - - if (ne00 < 128) { - for (int row = 0; row < N_F32_F32; ++row) { - int r1 = rb + row; - if (r1 >= ne11) { - break; - } - - device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); - - float sumf = 0; - for (int i = tiisg; i < ne00; i += 32) { - sumf += (float) x[i] * (float) y[i]; - } - - float all_sum = simd_sum(sumf); - if (tiisg == 0) { - dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; - } - } - } else { - device const float4 * x4 = (device const float4 *)x; - for (int row = 0; row < N_F32_F32; ++row) { - int r1 = rb + row; - if (r1 >= ne11) { - break; - } - - device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); - device const float4 * y4 = (device const float4 *) y; - - float sumf = 0; - for (int i = tiisg; i < ne00/4; i += 32) { - for (int k = 0; k < 4; ++k) sumf += (float) x4[i][k] * y4[i][k]; - } - - float all_sum = simd_sum(sumf); - if (tiisg == 0) { - for (int i = 4*(ne00/4); i < ne00; ++i) all_sum += (float) x[i] * y[i]; - dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; - } - } - } -} - -kernel void kernel_mul_mv_f16_f32_1row( - device const char * src0, - device const char * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant int64_t & ne10, - constant int64_t & ne11, - constant int64_t & ne12, - constant uint64_t & nb10, - constant uint64_t & nb11, - constant uint64_t & nb12, - constant int64_t & ne0, - constant int64_t & ne1, - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]]) { - - const int64_t r0 = tgpig.x; - const int64_t r1 = tgpig.y; - const int64_t im = tgpig.z; - - device const half * x = (device const half *) (src0 + r0*nb01 + im/(ne12/ne02)*nb02); - device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); - - float sumf = 0; - if (ne00 < 128) { - for (int i = tiisg; i < ne00; i += 32) { - sumf += (float) x[i] * (float) y[i]; - } - float all_sum = simd_sum(sumf); - if (tiisg == 0) { - dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; - } - } else { - device const half4 * x4 = (device const half4 *) x; - device const float4 * y4 = (device const float4 *) y; - for (int i = tiisg; i < ne00/4; i += 32) { - for (int k = 0; k < 4; ++k) sumf += (float)x4[i][k] * y4[i][k]; - } - float all_sum = simd_sum(sumf); - if (tiisg == 0) { - for (int i = 4*(ne00/4); i < ne00; ++i) all_sum += (float) x[i] * y[i]; - dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; - } - } - -} - -#define N_F16_F32 4 - -kernel void kernel_mul_mv_f16_f32( - device const char * src0, - device const char * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant int64_t & ne10, - constant int64_t & ne11, - constant int64_t & ne12, - constant uint64_t & nb10, - constant uint64_t & nb11, - constant uint64_t & nb12, - constant int64_t & ne0, - constant int64_t & ne1, - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]]) { - - const int64_t r0 = tgpig.x; - const int64_t rb = tgpig.y*N_F16_F32; - const int64_t im = tgpig.z; - - device const half * x = (device const half *) (src0 + r0*nb01 + im/(ne12/ne02)*nb02); - - if (ne00 < 128) { - for (int row = 0; row < N_F16_F32; ++row) { - int r1 = rb + row; - if (r1 >= ne11) { - break; - } - - device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); - - float sumf = 0; - for (int i = tiisg; i < ne00; i += 32) { - sumf += (float) x[i] * (float) y[i]; - } - - float all_sum = simd_sum(sumf); - if (tiisg == 0) { - dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; - } - } - } else { - device const half4 * x4 = (device const half4 *)x; - for (int row = 0; row < N_F16_F32; ++row) { - int r1 = rb + row; - if (r1 >= ne11) { - break; - } - - device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); - device const float4 * y4 = (device const float4 *) y; - - float sumf = 0; - for (int i = tiisg; i < ne00/4; i += 32) { - for (int k = 0; k < 4; ++k) sumf += (float) x4[i][k] * y4[i][k]; - } - - float all_sum = simd_sum(sumf); - if (tiisg == 0) { - for (int i = 4*(ne00/4); i < ne00; ++i) all_sum += (float) x[i] * y[i]; - dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; - } - } - } -} - -// Assumes row size (ne00) is a multiple of 4 -kernel void kernel_mul_mv_f16_f32_l4( - device const char * src0, - device const char * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant int64_t & ne10, - constant int64_t & ne11, - constant int64_t & ne12, - constant uint64_t & nb10, - constant uint64_t & nb11, - constant uint64_t & nb12, - constant int64_t & ne0, - constant int64_t & ne1, - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]]) { - - const int nrows = ne11; - const int64_t r0 = tgpig.x; - const int64_t im = tgpig.z; - - device const half4 * x4 = (device const half4 *) (src0 + r0*nb01 + im/(ne12/ne02)*nb02); - - for (int r1 = 0; r1 < nrows; ++r1) { - device const float4 * y4 = (device const float4 *) (src1 + r1*nb11 + im*nb12); - - float sumf = 0; - for (int i = tiisg; i < ne00/4; i += 32) { - for (int k = 0; k < 4; ++k) sumf += (float) x4[i][k] * y4[i][k]; - } - - float all_sum = simd_sum(sumf); - if (tiisg == 0) { - dst[im*ne1*ne0 + r1*ne0 + r0] = all_sum; - } - } -} - -kernel void kernel_alibi_f32( - device const float * src0, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant int64_t & ne03, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant uint64_t & nb03, - constant int64_t & ne0, - constant int64_t & ne1, - constant int64_t & ne2, - constant int64_t & ne3, - constant uint64_t & nb0, - constant uint64_t & nb1, - constant uint64_t & nb2, - constant uint64_t & nb3, - constant float & m0, - constant float & m1, - constant int & n_heads_log2_floor, - uint3 tgpig[[threadgroup_position_in_grid]], - uint3 tpitg[[thread_position_in_threadgroup]], - uint3 ntg[[threads_per_threadgroup]]) { - const int64_t i03 = tgpig[2]; - const int64_t i02 = tgpig[1]; - const int64_t i01 = tgpig[0]; - - const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; - - const int64_t i3 = n / (ne2*ne1*ne0); - const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); - const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; - const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); - - device float * dst_data = (device float *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); - float m_k; - if (i2 < n_heads_log2_floor) { - m_k = pow(m0, i2 + 1); - } else { - m_k = pow(m1, 2 * (i2 - n_heads_log2_floor) + 1); - } - for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { - device const float * src = (device float *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); - dst_data[i00] = src[0] + m_k * (i00 - ne00 + 1); - } -} - -static float rope_yarn_ramp(const float low, const float high, const int i0) { - const float y = (i0 / 2 - low) / max(0.001f, high - low); - return 1.0f - min(1.0f, max(0.0f, y)); -} - -// YaRN algorithm based on LlamaYaRNScaledRotaryEmbedding.py from https://github.com/jquesnelle/yarn -// MIT licensed. Copyright (c) 2023 Jeffrey Quesnelle and Bowen Peng. -static void rope_yarn( - float theta_extrap, float freq_scale, float corr_dims[2], int64_t i0, float ext_factor, float mscale, - thread float * cos_theta, thread float * sin_theta -) { - // Get n-d rotational scaling corrected for extrapolation - float theta_interp = freq_scale * theta_extrap; - float theta = theta_interp; - if (ext_factor != 0.0f) { - float ramp_mix = rope_yarn_ramp(corr_dims[0], corr_dims[1], i0) * ext_factor; - theta = theta_interp * (1 - ramp_mix) + theta_extrap * ramp_mix; - - // Get n-d magnitude scaling corrected for interpolation - mscale *= 1.0f + 0.1f * log(1.0f / freq_scale); - } - *cos_theta = cos(theta) * mscale; - *sin_theta = sin(theta) * mscale; -} - -// Apparently solving `n_rot = 2pi * x * base^((2 * max_pos_emb) / n_dims)` for x, we get -// `corr_fac(n_rot) = n_dims * log(max_pos_emb / (n_rot * 2pi)) / (2 * log(base))` -static float rope_yarn_corr_factor(int n_dims, int n_orig_ctx, float n_rot, float base) { - return n_dims * log(n_orig_ctx / (n_rot * 2 * M_PI_F)) / (2 * log(base)); -} - -static void rope_yarn_corr_dims( - int n_dims, int n_orig_ctx, float freq_base, float beta_fast, float beta_slow, float dims[2] -) { - // start and end correction dims - dims[0] = max(0.0f, floor(rope_yarn_corr_factor(n_dims, n_orig_ctx, beta_fast, freq_base))); - dims[1] = min(n_dims - 1.0f, ceil(rope_yarn_corr_factor(n_dims, n_orig_ctx, beta_slow, freq_base))); -} - -typedef void (rope_t)( - device const void * src0, - device const int32_t * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant int64_t & ne03, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant uint64_t & nb03, - constant int64_t & ne0, - constant int64_t & ne1, - constant int64_t & ne2, - constant int64_t & ne3, - constant uint64_t & nb0, - constant uint64_t & nb1, - constant uint64_t & nb2, - constant uint64_t & nb3, - constant int & n_past, - constant int & n_dims, - constant int & mode, - constant int & n_orig_ctx, - constant float & freq_base, - constant float & freq_scale, - constant float & ext_factor, - constant float & attn_factor, - constant float & beta_fast, - constant float & beta_slow, - uint tiitg[[thread_index_in_threadgroup]], - uint3 tptg[[threads_per_threadgroup]], - uint3 tgpig[[threadgroup_position_in_grid]]); - -template -kernel void kernel_rope( - device const void * src0, - device const int32_t * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant int64_t & ne03, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant uint64_t & nb03, - constant int64_t & ne0, - constant int64_t & ne1, - constant int64_t & ne2, - constant int64_t & ne3, - constant uint64_t & nb0, - constant uint64_t & nb1, - constant uint64_t & nb2, - constant uint64_t & nb3, - constant int & n_past, - constant int & n_dims, - constant int & mode, - constant int & n_orig_ctx, - constant float & freq_base, - constant float & freq_scale, - constant float & ext_factor, - constant float & attn_factor, - constant float & beta_fast, - constant float & beta_slow, - uint tiitg[[thread_index_in_threadgroup]], - uint3 tptg[[threads_per_threadgroup]], - uint3 tgpig[[threadgroup_position_in_grid]]) { - const int64_t i3 = tgpig[2]; - const int64_t i2 = tgpig[1]; - const int64_t i1 = tgpig[0]; - - const bool is_neox = mode & 2; - - float corr_dims[2]; - rope_yarn_corr_dims(n_dims, n_orig_ctx, freq_base, beta_fast, beta_slow, corr_dims); - - device const int32_t * pos = src1; - - const int64_t p = pos[i2]; - - const float theta_0 = (float)p; - const float inv_ndims = -1.f/n_dims; - - if (!is_neox) { - for (int64_t i0 = 2*tiitg; i0 < ne0; i0 += 2*tptg.x) { - - const float theta = theta_0 * pow(freq_base, inv_ndims*i0); - float cos_theta, sin_theta; - rope_yarn(theta, freq_scale, corr_dims, i0, ext_factor, attn_factor, &cos_theta, &sin_theta); - - device const T * const src = (device T *)((device char *) src0 + i3*nb03 + i2*nb02 + i1*nb01 + i0*nb00); - device T * dst_data = (device T *)((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); - - const T x0 = src[0]; - const T x1 = src[1]; - - dst_data[0] = x0*cos_theta - x1*sin_theta; - dst_data[1] = x0*sin_theta + x1*cos_theta; - } - } else { - for (int64_t ib = 0; ib < ne0/n_dims; ++ib) { - for (int64_t ic = 2*tiitg; ic < n_dims; ic += 2*tptg.x) { - - // simplified from `(ib * n_dims + ic) * inv_ndims` - const float cur_rot = inv_ndims*ic - ib; - - const float theta = theta_0 * pow(freq_base, cur_rot); - float cos_theta, sin_theta; - rope_yarn(theta, freq_scale, corr_dims, cur_rot, ext_factor, attn_factor, &cos_theta, &sin_theta); - - const int64_t i0 = ib*n_dims + ic/2; - - device const T * const src = (device T *)((device char *) src0 + i3*nb03 + i2*nb02 + i1*nb01 + i0*nb00); - device T * dst_data = (device T *)((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); - - const float x0 = src[0]; - const float x1 = src[n_dims/2]; - - dst_data[0] = x0*cos_theta - x1*sin_theta; - dst_data[n_dims/2] = x0*sin_theta + x1*cos_theta; - } - } - } -} - -template [[host_name("kernel_rope_f32")]] kernel rope_t kernel_rope; -template [[host_name("kernel_rope_f16")]] kernel rope_t kernel_rope; - -kernel void kernel_cpy_f16_f16( - device const half * src0, - device half * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant int64_t & ne03, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant uint64_t & nb03, - constant int64_t & ne0, - constant int64_t & ne1, - constant int64_t & ne2, - constant int64_t & ne3, - constant uint64_t & nb0, - constant uint64_t & nb1, - constant uint64_t & nb2, - constant uint64_t & nb3, - uint3 tgpig[[threadgroup_position_in_grid]], - uint3 tpitg[[thread_position_in_threadgroup]], - uint3 ntg[[threads_per_threadgroup]]) { - const int64_t i03 = tgpig[2]; - const int64_t i02 = tgpig[1]; - const int64_t i01 = tgpig[0]; - - const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; - - const int64_t i3 = n / (ne2*ne1*ne0); - const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); - const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; - const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); - - device half * dst_data = (device half *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); - - for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { - device const half * src = (device half *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); - dst_data[i00] = src[0]; - } -} - -kernel void kernel_cpy_f32_f16( - device const float * src0, - device half * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant int64_t & ne03, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant uint64_t & nb03, - constant int64_t & ne0, - constant int64_t & ne1, - constant int64_t & ne2, - constant int64_t & ne3, - constant uint64_t & nb0, - constant uint64_t & nb1, - constant uint64_t & nb2, - constant uint64_t & nb3, - uint3 tgpig[[threadgroup_position_in_grid]], - uint3 tpitg[[thread_position_in_threadgroup]], - uint3 ntg[[threads_per_threadgroup]]) { - const int64_t i03 = tgpig[2]; - const int64_t i02 = tgpig[1]; - const int64_t i01 = tgpig[0]; - - const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; - - const int64_t i3 = n / (ne2*ne1*ne0); - const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); - const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; - const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); - - device half * dst_data = (device half *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); - - for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { - device const float * src = (device float *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); - - dst_data[i00] = src[0]; - } -} - -kernel void kernel_cpy_f32_f32( - device const float * src0, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant int64_t & ne03, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant uint64_t & nb03, - constant int64_t & ne0, - constant int64_t & ne1, - constant int64_t & ne2, - constant int64_t & ne3, - constant uint64_t & nb0, - constant uint64_t & nb1, - constant uint64_t & nb2, - constant uint64_t & nb3, - uint3 tgpig[[threadgroup_position_in_grid]], - uint3 tpitg[[thread_position_in_threadgroup]], - uint3 ntg[[threads_per_threadgroup]]) { - const int64_t i03 = tgpig[2]; - const int64_t i02 = tgpig[1]; - const int64_t i01 = tgpig[0]; - - const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; - - const int64_t i3 = n / (ne2*ne1*ne0); - const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); - const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; - const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); - - device float * dst_data = (device float *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); - - for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { - device const float * src = (device float *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); - - dst_data[i00] = src[0]; - } -} - -kernel void kernel_concat( - device const char * src0, - device const char * src1, - device char * dst, - constant int64_t & ne00, - constant int64_t & ne01, - constant int64_t & ne02, - constant int64_t & ne03, - constant uint64_t & nb00, - constant uint64_t & nb01, - constant uint64_t & nb02, - constant uint64_t & nb03, - constant int64_t & ne10, - constant int64_t & ne11, - constant int64_t & ne12, - constant int64_t & ne13, - constant uint64_t & nb10, - constant uint64_t & nb11, - constant uint64_t & nb12, - constant uint64_t & nb13, - constant int64_t & ne0, - constant int64_t & ne1, - constant int64_t & ne2, - constant int64_t & ne3, - constant uint64_t & nb0, - constant uint64_t & nb1, - constant uint64_t & nb2, - constant uint64_t & nb3, - uint3 tgpig[[threadgroup_position_in_grid]], - uint3 tpitg[[thread_position_in_threadgroup]], - uint3 ntg[[threads_per_threadgroup]]) { - - const int64_t i03 = tgpig.z; - const int64_t i02 = tgpig.y; - const int64_t i01 = tgpig.x; - - const int64_t i13 = i03 % ne13; - const int64_t i12 = i02 % ne12; - const int64_t i11 = i01 % ne11; - - device const char * src0_ptr = src0 + i03 * nb03 + i02 * nb02 + i01 * nb01 + tpitg.x*nb00; - device const char * src1_ptr = src1 + i13*nb13 + i12*nb12 + i11*nb11 + tpitg.x*nb10; - device char * dst_ptr = dst + i03*nb3 + i02*nb2 + i01*nb1 + tpitg.x*nb0; - - for (int i0 = tpitg.x; i0 < ne0; i0 += ntg.x) { - if (i02 < ne02) { - ((device float *)dst_ptr)[0] = ((device float *)src0_ptr)[0]; - src0_ptr += ntg.x*nb00; - } else { - ((device float *)dst_ptr)[0] = ((device float *)src1_ptr)[0]; - src1_ptr += ntg.x*nb10; - } - dst_ptr += ntg.x*nb0; - } -} - -//============================================ k-quants ====================================================== - -#ifndef QK_K -#define QK_K 256 -#else -static_assert(QK_K == 256 || QK_K == 64, "QK_K must be 256 or 64"); -#endif - -#if QK_K == 256 -#define K_SCALE_SIZE 12 -#else -#define K_SCALE_SIZE 4 -#endif - -typedef struct { - uint8_t scales[QK_K/16]; // scales and mins, quantized with 4 bits - uint8_t qs[QK_K/4]; // quants - half d; // super-block scale for quantized scales - half dmin; // super-block scale for quantized mins -} block_q2_K; -// 84 bytes / block - -typedef struct { - uint8_t hmask[QK_K/8]; // quants - high bit - uint8_t qs[QK_K/4]; // quants - low 2 bits -#if QK_K == 64 - uint8_t scales[2]; -#else - uint8_t scales[K_SCALE_SIZE]; // scales, quantized with 6 bits -#endif - half d; // super-block scale -} block_q3_K; - -#if QK_K == 64 -typedef struct { - half d[2]; // super-block scales/mins - uint8_t scales[2]; - uint8_t qs[QK_K/2]; // 4-bit quants -} block_q4_K; -#else -typedef struct { - half d; // super-block scale for quantized scales - half dmin; // super-block scale for quantized mins - uint8_t scales[K_SCALE_SIZE]; // scales and mins, quantized with 6 bits - uint8_t qs[QK_K/2]; // 4--bit quants -} block_q4_K; -#endif - -#if QK_K == 64 -typedef struct { - half d; // super-block scales/mins - int8_t scales[QK_K/16]; // 8-bit block scales - uint8_t qh[QK_K/8]; // quants, high bit - uint8_t qs[QK_K/2]; // quants, low 4 bits -} block_q5_K; -#else -typedef struct { - half d; // super-block scale for quantized scales - half dmin; // super-block scale for quantized mins - uint8_t scales[3*QK_K/64]; // scales and mins, quantized with 6 bits - uint8_t qh[QK_K/8]; // quants, high bit - uint8_t qs[QK_K/2]; // quants, low 4 bits -} block_q5_K; -// 176 bytes / block -#endif - -typedef struct { - uint8_t ql[QK_K/2]; // quants, lower 4 bits - uint8_t qh[QK_K/4]; // quants, upper 2 bits - int8_t scales[QK_K/16]; // scales, quantized with 8 bits - half d; // super-block scale -} block_q6_K; -// 210 bytes / block - -static inline uchar4 get_scale_min_k4(int j, device const uint8_t * q) { - uchar4 r; - if (j < 4) { - r[0] = q[j+0] & 63; - r[2] = q[j+1] & 63; - r[1] = q[j+4] & 63; - r[3] = q[j+5] & 63; - } else { - r[0] = (q[j+4] & 0xF) | ((q[j-4] >> 6) << 4); - r[2] = (q[j+5] & 0xF) | ((q[j-3] >> 6) << 4); - r[1] = (q[j+4] >> 4) | ((q[j-0] >> 6) << 4); - r[3] = (q[j+5] >> 4) | ((q[j+1] >> 6) << 4); - } - return r; -} - -//====================================== dot products ========================= - -kernel void kernel_mul_mv_q2_K_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - - const int nb = ne00/QK_K; - const int r0 = tgpig.x; - const int r1 = tgpig.y; - const int r2 = tgpig.z; - - const int first_row = (r0 * N_SIMDGROUP + sgitg) * N_DST; - const int ib_row = first_row * nb; - const uint offset0 = r2/gqa*(nb*ne0); - device const block_q2_K * x = (device const block_q2_K *) src0 + ib_row + offset0; - device const float * y = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; - float yl[32]; - float sumf[N_DST]={0.f}, all_sum; - - const int step = sizeof(block_q2_K) * nb; - -#if QK_K == 256 - const int ix = tiisg/8; // 0...3 - const int it = tiisg%8; // 0...7 - const int im = it/4; // 0 or 1 - const int ir = it%4; // 0...3 - const int is = (8*ir)/16;// 0 or 1 - - device const float * y4 = y + ix * QK_K + 128 * im + 8 * ir; - - for (int ib = ix; ib < nb; ib += 4) { - - float4 sumy = {0.f, 0.f, 0.f, 0.f}; - for (int i = 0; i < 8; ++i) { - yl[i+ 0] = y4[i+ 0]; sumy[0] += yl[i+ 0]; - yl[i+ 8] = y4[i+32]; sumy[1] += yl[i+ 8]; - yl[i+16] = y4[i+64]; sumy[2] += yl[i+16]; - yl[i+24] = y4[i+96]; sumy[3] += yl[i+24]; - } - - device const uint8_t * sc = (device const uint8_t *)x[ib].scales + 8*im + is; - device const uint16_t * qs = (device const uint16_t *)x[ib].qs + 16 * im + 4 * ir; - device const half * dh = &x[ib].d; - - for (int row = 0; row < N_DST; row++) { - - float4 acc1 = {0.f, 0.f, 0.f, 0.f}; - float4 acc2 = {0.f, 0.f, 0.f, 0.f}; - for (int i = 0; i < 8; i += 2) { - acc1[0] += yl[i+ 0] * (qs[i/2] & 0x0003); - acc2[0] += yl[i+ 1] * (qs[i/2] & 0x0300); - acc1[1] += yl[i+ 8] * (qs[i/2] & 0x000c); - acc2[1] += yl[i+ 9] * (qs[i/2] & 0x0c00); - acc1[2] += yl[i+16] * (qs[i/2] & 0x0030); - acc2[2] += yl[i+17] * (qs[i/2] & 0x3000); - acc1[3] += yl[i+24] * (qs[i/2] & 0x00c0); - acc2[3] += yl[i+25] * (qs[i/2] & 0xc000); - } - float dall = dh[0]; - float dmin = dh[1] * 1.f/16.f; - sumf[row] += dall * ((acc1[0] + 1.f/256.f * acc2[0]) * (sc[0] & 0xF) * 1.f/ 1.f + - (acc1[1] + 1.f/256.f * acc2[1]) * (sc[2] & 0xF) * 1.f/ 4.f + - (acc1[2] + 1.f/256.f * acc2[2]) * (sc[4] & 0xF) * 1.f/16.f + - (acc1[3] + 1.f/256.f * acc2[3]) * (sc[6] & 0xF) * 1.f/64.f) - - dmin * (sumy[0] * (sc[0] & 0xF0) + sumy[1] * (sc[2] & 0xF0) + sumy[2] * (sc[4] & 0xF0) + sumy[3] * (sc[6] & 0xF0)); - - qs += step/2; - sc += step; - dh += step/2; - } - - y4 += 4 * QK_K; - } -#else - const int ix = tiisg/2; // 0...15 - const int it = tiisg%2; // 0...1 - - device const float * y4 = y + ix * QK_K + 8 * it; - - for (int ib = ix; ib < nb; ib += 16) { - - float4 sumy = {0.f, 0.f, 0.f, 0.f}; - for (int i = 0; i < 8; ++i) { - yl[i+ 0] = y4[i+ 0]; sumy[0] += yl[i+ 0]; - yl[i+ 8] = y4[i+16]; sumy[1] += yl[i+ 8]; - yl[i+16] = y4[i+32]; sumy[2] += yl[i+16]; - yl[i+24] = y4[i+48]; sumy[3] += yl[i+24]; - } - - device const uint8_t * sc = (device const uint8_t *)x[ib].scales; - device const uint16_t * qs = (device const uint16_t *)x[ib].qs + 4 * it; - device const half * dh = &x[ib].d; - - for (int row = 0; row < N_DST; row++) { - - float4 acc1 = {0.f, 0.f, 0.f, 0.f}; - float4 acc2 = {0.f, 0.f, 0.f, 0.f}; - for (int i = 0; i < 8; i += 2) { - acc1[0] += yl[i+ 0] * (qs[i/2] & 0x0003); - acc2[0] += yl[i+ 1] * (qs[i/2] & 0x0300); - acc1[1] += yl[i+ 8] * (qs[i/2] & 0x000c); - acc2[1] += yl[i+ 9] * (qs[i/2] & 0x0c00); - acc1[2] += yl[i+16] * (qs[i/2] & 0x0030); - acc2[2] += yl[i+17] * (qs[i/2] & 0x3000); - acc1[3] += yl[i+24] * (qs[i/2] & 0x00c0); - acc2[3] += yl[i+25] * (qs[i/2] & 0xc000); - } - - float dall = dh[0]; - float dmin = dh[1]; - sumf[row] += dall * ((acc1[0] + 1.f/256.f * acc2[0]) * (sc[0] & 0xF) * 1.f/ 1.f + - (acc1[1] + 1.f/256.f * acc2[1]) * (sc[1] & 0xF) * 1.f/ 4.f + - (acc1[2] + 1.f/256.f * acc2[2]) * (sc[2] & 0xF) * 1.f/16.f + - (acc1[3] + 1.f/256.f * acc2[3]) * (sc[3] & 0xF) * 1.f/64.f) - - dmin * (sumy[0] * (sc[0] >> 4) + sumy[1] * (sc[1] >> 4) + sumy[2] * (sc[2] >> 4) + sumy[3] * (sc[3] >> 4)); - - qs += step/2; - sc += step; - dh += step/2; - } - - y4 += 16 * QK_K; - } -#endif - - for (int row = 0; row < N_DST; ++row) { - all_sum = simd_sum(sumf[row]); - if (tiisg == 0) { - dst[r1*ne0 + r2*ne0*ne1 + first_row + row] = all_sum; - } - } -} - -#if QK_K == 256 -kernel void kernel_mul_mv_q3_K_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - - const int nb = ne00/QK_K; - - const int64_t r0 = tgpig.x; - const int64_t r1 = tgpig.y; - const int64_t r2 = tgpig.z; - - const int first_row = (r0 * N_SIMDGROUP + sgitg) * 2; - const uint offset0 = r2/gqa*(nb*ne0); - device const block_q3_K * x = (device const block_q3_K *) src0 + first_row*nb + offset0; - device const float * yy = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; - - float yl[32]; - - //const uint16_t kmask1 = 0x3030; - //const uint16_t kmask2 = 0x0f0f; - - const int tid = tiisg/4; - const int ix = tiisg%4; - const int ip = tid/4; // 0 or 1 - const int il = 2*((tid%4)/2); // 0 or 2 - const int ir = tid%2; - const int n = 8; - const int l0 = n*ir; - - // One would think that the Metal compiler would figure out that ip and il can only have - // 4 possible states, and optimize accordingly. Well, no. It needs help, and we do it - // with these two tales. - // - // Possible masks for the high bit - const ushort4 mm[4] = {{0x0001, 0x0100, 0x0002, 0x0200}, // ip = 0, il = 0 - {0x0004, 0x0400, 0x0008, 0x0800}, // ip = 0, il = 2 - {0x0010, 0x1000, 0x0020, 0x2000}, // ip = 1, il = 0 - {0x0040, 0x4000, 0x0080, 0x8000}}; // ip = 1, il = 2 - - // Possible masks for the low 2 bits - const int4 qm[2] = {{0x0003, 0x0300, 0x000c, 0x0c00}, {0x0030, 0x3000, 0x00c0, 0xc000}}; - - const ushort4 hm = mm[2*ip + il/2]; - - const int shift = 2*il; - const float v1 = il == 0 ? 4.f : 64.f; - const float v2 = 4.f * v1; - - const uint16_t s_shift1 = 4*ip; - const uint16_t s_shift2 = s_shift1 + il; - - const int q_offset = 32*ip + l0; - const int y_offset = 128*ip + 32*il + l0; - - const int step = sizeof(block_q3_K) * nb / 2; - - device const float * y1 = yy + ix*QK_K + y_offset; - - uint32_t scales32, aux32; - thread uint16_t * scales16 = (thread uint16_t *)&scales32; - thread const int8_t * scales = (thread const int8_t *)&scales32; - - float sumf1[2] = {0.f}; - float sumf2[2] = {0.f}; - for (int i = ix; i < nb; i += 4) { - - for (int l = 0; l < 8; ++l) { - yl[l+ 0] = y1[l+ 0]; - yl[l+ 8] = y1[l+16]; - yl[l+16] = y1[l+32]; - yl[l+24] = y1[l+48]; - } - - device const uint16_t * q = (device const uint16_t *)(x[i].qs + q_offset); - device const uint16_t * h = (device const uint16_t *)(x[i].hmask + l0); - device const uint16_t * a = (device const uint16_t *)(x[i].scales); - device const half * dh = &x[i].d; - - for (int row = 0; row < 2; ++row) { - - const float d_all = (float)dh[0]; - - scales16[0] = a[4]; - scales16[1] = a[5]; - aux32 = ((scales32 >> s_shift2) << 4) & 0x30303030; - scales16[0] = a[il+0]; - scales16[1] = a[il+1]; - scales32 = ((scales32 >> s_shift1) & 0x0f0f0f0f) | aux32; - - float s1 = 0, s2 = 0, s3 = 0, s4 = 0, s5 = 0, s6 = 0; - for (int l = 0; l < n; l += 2) { - const int32_t qs = q[l/2]; - s1 += yl[l+0] * (qs & qm[il/2][0]); - s2 += yl[l+1] * (qs & qm[il/2][1]); - s3 += ((h[l/2] & hm[0]) ? 0.f : yl[l+0]) + ((h[l/2] & hm[1]) ? 0.f : yl[l+1]); - s4 += yl[l+16] * (qs & qm[il/2][2]); - s5 += yl[l+17] * (qs & qm[il/2][3]); - s6 += ((h[l/2] & hm[2]) ? 0.f : yl[l+16]) + ((h[l/2] & hm[3]) ? 0.f : yl[l+17]); - } - float d1 = d_all * (s1 + 1.f/256.f * s2 - s3*v1); - float d2 = d_all * (s4 + 1.f/256.f * s5 - s6*v2); - sumf1[row] += d1 * (scales[0] - 32); - sumf2[row] += d2 * (scales[2] - 32); - - s1 = s2 = s3 = s4 = s5 = s6 = 0; - for (int l = 0; l < n; l += 2) { - const int32_t qs = q[l/2+8]; - s1 += yl[l+8] * (qs & qm[il/2][0]); - s2 += yl[l+9] * (qs & qm[il/2][1]); - s3 += ((h[l/2+8] & hm[0]) ? 0.f : yl[l+8]) + ((h[l/2+8] & hm[1]) ? 0.f : yl[l+9]); - s4 += yl[l+24] * (qs & qm[il/2][2]); - s5 += yl[l+25] * (qs & qm[il/2][3]); - s6 += ((h[l/2+8] & hm[2]) ? 0.f : yl[l+24]) + ((h[l/2+8] & hm[3]) ? 0.f : yl[l+25]); - } - d1 = d_all * (s1 + 1.f/256.f * s2 - s3*v1); - d2 = d_all * (s4 + 1.f/256.f * s5 - s6*v2); - sumf1[row] += d1 * (scales[1] - 32); - sumf2[row] += d2 * (scales[3] - 32); - - q += step; - h += step; - a += step; - dh += step; - - } - - y1 += 4 * QK_K; - - } - - for (int row = 0; row < 2; ++row) { - const float sumf = (sumf1[row] + 0.25f * sumf2[row]) / (1 << shift); - sumf1[row] = simd_sum(sumf); - } - if (tiisg == 0) { - for (int row = 0; row < 2; ++row) { - dst[r1*ne0 + r2*ne0*ne1 + first_row + row] = sumf1[row]; - } - } -} -#else -kernel void kernel_mul_mv_q3_K_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - - const int nb = ne00/QK_K; - - const int64_t r0 = tgpig.x; - const int64_t r1 = tgpig.y; - const int64_t r2 = tgpig.z; - - const int row = 2 * r0 + sgitg; - const uint offset0 = r2/gqa*(nb*ne0); - device const block_q3_K * x = (device const block_q3_K *) src0 + row*nb + offset0; - device const float * yy = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; - const int ix = tiisg/4; - const int il = 4 * (tiisg%4);// 0, 4, 8, 12 - const int im = il/8; // 0, 0, 1, 1 - const int in = il%8; // 0, 4, 0, 4 - - float2 sum = {0.f, 0.f}; - - for (int i = ix; i < nb; i += 8) { - - const float d_all = (float)(x[i].d); - - device const uint16_t * q = (device const uint16_t *)(x[i].qs + il); - device const uint16_t * h = (device const uint16_t *)(x[i].hmask + in); - device const uint16_t * s = (device const uint16_t *)(x[i].scales); - device const float * y = yy + i * QK_K + il; - - const float d1 = d_all * ((int32_t)(s[0] & 0x000F) - 8); - const float d2 = d_all * ((int32_t)(s[0] & 0x00F0) - 128) * 1.f/64.f; - const float d3 = d_all * ((int32_t)(s[0] & 0x0F00) - 2048) * 1.f/4096.f; - const float d4 = d_all * ((int32_t)(s[0] & 0xF000) - 32768) * 1.f/262144.f; - - for (int l = 0; l < 4; l += 2) { - const uint16_t hm = h[l/2] >> im; - sum[0] += y[l+ 0] * d1 * ((int32_t)(q[l/2] & 0x0003) - ((hm & 0x0001) ? 0 : 4)) - + y[l+16] * d2 * ((int32_t)(q[l/2] & 0x000c) - ((hm & 0x0004) ? 0 : 16)) - + y[l+32] * d3 * ((int32_t)(q[l/2] & 0x0030) - ((hm & 0x0010) ? 0 : 64)) - + y[l+48] * d4 * ((int32_t)(q[l/2] & 0x00c0) - ((hm & 0x0040) ? 0 : 256)); - sum[1] += y[l+ 1] * d1 * ((int32_t)(q[l/2] & 0x0300) - ((hm & 0x0100) ? 0 : 1024)) - + y[l+17] * d2 * ((int32_t)(q[l/2] & 0x0c00) - ((hm & 0x0400) ? 0 : 4096)) - + y[l+33] * d3 * ((int32_t)(q[l/2] & 0x3000) - ((hm & 0x1000) ? 0 : 16384)) - + y[l+49] * d4 * ((int32_t)(q[l/2] & 0xc000) - ((hm & 0x4000) ? 0 : 65536)); - } - - } - const float sumf = sum[0] + sum[1] * 1.f/256.f; - - const float tot = simd_sum(sumf); - if (tiisg == 0) { - dst[r1*ne0 + r2*ne0*ne1 + row] = tot; - } - -} -#endif - -#if QK_K == 256 -kernel void kernel_mul_mv_q4_K_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01 [[buffer(4)]], - constant int64_t & ne02 [[buffer(5)]], - constant int64_t & ne10 [[buffer(9)]], - constant int64_t & ne12 [[buffer(11)]], - constant int64_t & ne0 [[buffer(15)]], - constant int64_t & ne1 [[buffer(16)]], - constant uint & gqa [[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - - const uint16_t kmask1 = 0x3f3f; - const uint16_t kmask2 = 0x0f0f; - const uint16_t kmask3 = 0xc0c0; - - const int ix = tiisg/8; // 0...3 - const int it = tiisg%8; // 0...7 - const int im = it/4; // 0 or 1 - const int ir = it%4; // 0...3 - - const int nb = ne00/QK_K; - const int r0 = tgpig.x; - const int r1 = tgpig.y; - const int r2 = tgpig.z; - //const int first_row = (r0 * N_SIMDGROUP + sgitg) * N_DST; - const int first_row = r0 * N_DST; - const int ib_row = first_row * nb; - const uint offset0 = r2/gqa*(nb*ne0); - device const block_q4_K * x = (device const block_q4_K *) src0 + ib_row + offset0; - device const float * y = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; - float yl[16]; - float yh[16]; - float sumf[N_DST]={0.f}, all_sum; - - const int step = sizeof(block_q4_K) * nb / 2; - - device const float * y4 = y + ix * QK_K + 64 * im + 8 * ir; - - uint16_t sc16[4]; - thread const uint8_t * sc8 = (thread const uint8_t *)sc16; - - for (int ib = ix; ib < nb; ib += 4) { - - float4 sumy = {0.f, 0.f, 0.f, 0.f}; - for (int i = 0; i < 8; ++i) { - yl[i+0] = y4[i+ 0]; sumy[0] += yl[i+0]; - yl[i+8] = y4[i+ 32]; sumy[1] += yl[i+8]; - yh[i+0] = y4[i+128]; sumy[2] += yh[i+0]; - yh[i+8] = y4[i+160]; sumy[3] += yh[i+8]; - } - - device const uint16_t * sc = (device const uint16_t *)x[ib].scales + im; - device const uint16_t * q1 = (device const uint16_t *)x[ib].qs + 16 * im + 4 * ir; - device const half * dh = &x[ib].d; - - for (int row = 0; row < N_DST; row++) { - - sc16[0] = sc[0] & kmask1; - sc16[1] = sc[2] & kmask1; - sc16[2] = ((sc[4] >> 0) & kmask2) | ((sc[0] & kmask3) >> 2); - sc16[3] = ((sc[4] >> 4) & kmask2) | ((sc[2] & kmask3) >> 2); - - device const uint16_t * q2 = q1 + 32; - - float4 acc1 = {0.f, 0.f, 0.f, 0.f}; - float4 acc2 = {0.f, 0.f, 0.f, 0.f}; - for (int i = 0; i < 8; i += 2) { - acc1[0] += yl[i+0] * (q1[i/2] & 0x000F); - acc1[1] += yl[i+1] * (q1[i/2] & 0x0F00); - acc1[2] += yl[i+8] * (q1[i/2] & 0x00F0); - acc1[3] += yl[i+9] * (q1[i/2] & 0xF000); - acc2[0] += yh[i+0] * (q2[i/2] & 0x000F); - acc2[1] += yh[i+1] * (q2[i/2] & 0x0F00); - acc2[2] += yh[i+8] * (q2[i/2] & 0x00F0); - acc2[3] += yh[i+9] * (q2[i/2] & 0xF000); - } - - float dall = dh[0]; - float dmin = dh[1]; - sumf[row] += dall * ((acc1[0] + 1.f/256.f * acc1[1]) * sc8[0] + - (acc1[2] + 1.f/256.f * acc1[3]) * sc8[1] * 1.f/16.f + - (acc2[0] + 1.f/256.f * acc2[1]) * sc8[4] + - (acc2[2] + 1.f/256.f * acc2[3]) * sc8[5] * 1.f/16.f) - - dmin * (sumy[0] * sc8[2] + sumy[1] * sc8[3] + sumy[2] * sc8[6] + sumy[3] * sc8[7]); - - q1 += step; - sc += step; - dh += step; - } - - y4 += 4 * QK_K; - } - - for (int row = 0; row < N_DST; ++row) { - all_sum = simd_sum(sumf[row]); - if (tiisg == 0) { - dst[r1*ne0 + r2*ne0*ne1 + first_row + row] = all_sum; - } - } -} -#else -kernel void kernel_mul_mv_q4_K_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - - const int ix = tiisg/4; // 0...7 - const int it = tiisg%4; // 0...3 - - const int nb = ne00/QK_K; - const int r0 = tgpig.x; - const int r1 = tgpig.y; - const int r2 = tgpig.z; - const int first_row = (r0 * N_SIMDGROUP + sgitg) * N_DST; - const int ib_row = first_row * nb; - const uint offset0 = r2/gqa*(nb*ne0); - device const block_q4_K * x = (device const block_q4_K *) src0 + ib_row + offset0; - device const float * y = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; - float yl[8]; - float yh[8]; - float sumf[N_DST]={0.f}, all_sum; - - const int step = sizeof(block_q4_K) * nb / 2; - - device const float * y4 = y + ix * QK_K + 8 * it; - - uint16_t sc16[4]; - - for (int ib = ix; ib < nb; ib += 8) { - - float2 sumy = {0.f, 0.f}; - for (int i = 0; i < 8; ++i) { - yl[i] = y4[i+ 0]; sumy[0] += yl[i]; - yh[i] = y4[i+32]; sumy[1] += yh[i]; - } - - device const uint16_t * sc = (device const uint16_t *)x[ib].scales; - device const uint16_t * qs = (device const uint16_t *)x[ib].qs + 4 * it; - device const half * dh = x[ib].d; - - for (int row = 0; row < N_DST; row++) { - - sc16[0] = sc[0] & 0x000f; - sc16[1] = sc[0] & 0x0f00; - sc16[2] = sc[0] & 0x00f0; - sc16[3] = sc[0] & 0xf000; - - float2 acc1 = {0.f, 0.f}; - float2 acc2 = {0.f, 0.f}; - for (int i = 0; i < 8; i += 2) { - acc1[0] += yl[i+0] * (qs[i/2] & 0x000F); - acc1[1] += yl[i+1] * (qs[i/2] & 0x0F00); - acc2[0] += yh[i+0] * (qs[i/2] & 0x00F0); - acc2[1] += yh[i+1] * (qs[i/2] & 0xF000); - } - - float dall = dh[0]; - float dmin = dh[1]; - sumf[row] += dall * ((acc1[0] + 1.f/256.f * acc1[1]) * sc16[0] + - (acc2[0] + 1.f/256.f * acc2[1]) * sc16[1] * 1.f/4096.f) - - dmin * 1.f/16.f * (sumy[0] * sc16[2] + sumy[1] * sc16[3] * 1.f/256.f); - - qs += step; - sc += step; - dh += step; - } - - y4 += 8 * QK_K; - } - - for (int row = 0; row < N_DST; ++row) { - all_sum = simd_sum(sumf[row]); - if (tiisg == 0) { - dst[r1*ne0+ r2*ne0*ne1 + first_row + row] = all_sum; - } - } -} -#endif - -kernel void kernel_mul_mv_q5_K_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - - const int nb = ne00/QK_K; - - const int64_t r0 = tgpig.x; - const int64_t r1 = tgpig.y; - const int r2 = tgpig.z; - - const int first_row = (r0 * N_SIMDGROUP + sgitg) * 2; - const uint offset0 = r2/gqa*(nb*ne0); - device const block_q5_K * x = (device const block_q5_K *) src0 + first_row*nb + offset0; - device const float * yy = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; - - float sumf[2]={0.f}; - - const int step = sizeof(block_q5_K) * nb; - -#if QK_K == 256 -# - float yl[16], yh[16]; - - const uint16_t kmask1 = 0x3f3f; - const uint16_t kmask2 = 0x0f0f; - const uint16_t kmask3 = 0xc0c0; - - const int tid = tiisg/4; - const int ix = tiisg%4; - const int im = tid/4; - const int ir = tid%4; - const int n = 8; - - const int l0 = n*ir; - const int q_offset = 32*im + l0; - const int y_offset = 64*im + l0; - - const uint8_t hm1 = 1u << (2*im); - const uint8_t hm2 = hm1 << 1; - const uint8_t hm3 = hm1 << 4; - const uint8_t hm4 = hm2 << 4; - - uint16_t sc16[4]; - thread const uint8_t * sc8 = (thread const uint8_t *)sc16; - - device const float * y1 = yy + ix*QK_K + y_offset; - - for (int i = ix; i < nb; i += 4) { - - device const uint8_t * q1 = x[i].qs + q_offset; - device const uint8_t * qh = x[i].qh + l0; - device const half * dh = &x[i].d; - device const uint16_t * a = (device const uint16_t *)x[i].scales + im; - - device const float * y2 = y1 + 128; - float4 sumy = {0.f, 0.f, 0.f, 0.f}; - for (int l = 0; l < 8; ++l) { - yl[l+0] = y1[l+ 0]; sumy[0] += yl[l+0]; - yl[l+8] = y1[l+32]; sumy[1] += yl[l+8]; - yh[l+0] = y2[l+ 0]; sumy[2] += yh[l+0]; - yh[l+8] = y2[l+32]; sumy[3] += yh[l+8]; - } - - for (int row = 0; row < 2; ++row) { - - device const uint8_t * q2 = q1 + 64; - - sc16[0] = a[0] & kmask1; - sc16[1] = a[2] & kmask1; - sc16[2] = ((a[4] >> 0) & kmask2) | ((a[0] & kmask3) >> 2); - sc16[3] = ((a[4] >> 4) & kmask2) | ((a[2] & kmask3) >> 2); - - float4 acc1 = {0.f}; - float4 acc2 = {0.f}; - for (int l = 0; l < n; ++l) { - uint8_t h = qh[l]; - acc1[0] += yl[l+0] * (q1[l] & 0x0F); - acc1[1] += yl[l+8] * (q1[l] & 0xF0); - acc1[2] += yh[l+0] * (q2[l] & 0x0F); - acc1[3] += yh[l+8] * (q2[l] & 0xF0); - acc2[0] += h & hm1 ? yl[l+0] : 0.f; - acc2[1] += h & hm2 ? yl[l+8] : 0.f; - acc2[2] += h & hm3 ? yh[l+0] : 0.f; - acc2[3] += h & hm4 ? yh[l+8] : 0.f; - } - const float dall = dh[0]; - const float dmin = dh[1]; - sumf[row] += dall * (sc8[0] * (acc1[0] + 16.f*acc2[0]) + - sc8[1] * (acc1[1]/16.f + 16.f*acc2[1]) + - sc8[4] * (acc1[2] + 16.f*acc2[2]) + - sc8[5] * (acc1[3]/16.f + 16.f*acc2[3])) - - dmin * (sumy[0] * sc8[2] + sumy[1] * sc8[3] + sumy[2] * sc8[6] + sumy[3] * sc8[7]); - - q1 += step; - qh += step; - dh += step/2; - a += step/2; - - } - - y1 += 4 * QK_K; - - } -#else - float yl[8], yh[8]; - - const int il = 4 * (tiisg/8); // 0, 4, 8, 12 - const int ix = tiisg%8; - const int im = il/8; // 0, 0, 1, 1 - const int in = il%8; // 0, 4, 0, 4 - - device const float * y = yy + ix*QK_K + il; - - for (int i = ix; i < nb; i += 8) { - - for (int l = 0; l < 4; ++l) { - yl[l+0] = y[l+ 0]; - yl[l+4] = y[l+16]; - yh[l+0] = y[l+32]; - yh[l+4] = y[l+48]; - } - - device const half * dh = &x[i].d; - device const uint8_t * q = x[i].qs + il; - device const uint8_t * h = x[i].qh + in; - device const int8_t * s = x[i].scales; - - for (int row = 0; row < 2; ++row) { - - const float d = dh[0]; - - float2 acc = {0.f, 0.f}; - for (int l = 0; l < 4; ++l) { - const uint8_t hl = h[l] >> im; - acc[0] += yl[l+0] * s[0] * ((int16_t)(q[l+ 0] & 0x0F) - (hl & 0x01 ? 0 : 16)) - + yl[l+4] * s[1] * ((int16_t)(q[l+16] & 0x0F) - (hl & 0x04 ? 0 : 16)); - acc[1] += yh[l+0] * s[2] * ((int16_t)(q[l+ 0] & 0xF0) - (hl & 0x10 ? 0 : 256)) - + yh[l+4] * s[3] * ((int16_t)(q[l+16] & 0xF0) - (hl & 0x40 ? 0 : 256)); - } - sumf[row] += d * (acc[0] + 1.f/16.f * acc[1]); - - q += step; - h += step; - s += step; - dh += step/2; - - } - - y += 8 * QK_K; - } -#endif - - for (int row = 0; row < 2; ++row) { - const float tot = simd_sum(sumf[row]); - if (tiisg == 0) { - dst[r1*ne0 + r2*ne0*ne1 + first_row + row] = tot; - } - } - -} - -kernel void kernel_mul_mv_q6_K_f32( - device const void * src0, - device const float * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne01[[buffer(4)]], - constant int64_t & ne02[[buffer(5)]], - constant int64_t & ne10[[buffer(9)]], - constant int64_t & ne12[[buffer(11)]], - constant int64_t & ne0[[buffer(15)]], - constant int64_t & ne1[[buffer(16)]], - constant uint & gqa[[buffer(17)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiisg[[thread_index_in_simdgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - - const uint8_t kmask1 = 0x03; - const uint8_t kmask2 = 0x0C; - const uint8_t kmask3 = 0x30; - const uint8_t kmask4 = 0xC0; - - const int nb = ne00/QK_K; - - const int64_t r0 = tgpig.x; - const int64_t r1 = tgpig.y; - const int r2 = tgpig.z; - - const int row = 2 * r0 + sgitg; - const uint offset0 = r2/gqa*(nb*ne0); - device const block_q6_K * x = (device const block_q6_K *) src0 + row * nb + offset0; - device const float * yy = (device const float *) src1 + r1*ne10 + r2*ne00*ne1; - - float sumf = 0; - -#if QK_K == 256 - const int tid = tiisg/2; - const int ix = tiisg%2; - const int ip = tid/8; // 0 or 1 - const int il = tid%8; - const int n = 4; - const int l0 = n*il; - const int is = 8*ip + l0/16; - - const int y_offset = 128*ip + l0; - const int q_offset_l = 64*ip + l0; - const int q_offset_h = 32*ip + l0; - - for (int i = ix; i < nb; i += 2) { - - device const uint8_t * q1 = x[i].ql + q_offset_l; - device const uint8_t * q2 = q1 + 32; - device const uint8_t * qh = x[i].qh + q_offset_h; - device const int8_t * sc = x[i].scales + is; - - device const float * y = yy + i * QK_K + y_offset; - - const float dall = x[i].d; - - float4 sums = {0.f, 0.f, 0.f, 0.f}; - for (int l = 0; l < n; ++l) { - sums[0] += y[l+ 0] * ((int8_t)((q1[l] & 0xF) | ((qh[l] & kmask1) << 4)) - 32); - sums[1] += y[l+32] * ((int8_t)((q2[l] & 0xF) | ((qh[l] & kmask2) << 2)) - 32); - sums[2] += y[l+64] * ((int8_t)((q1[l] >> 4) | ((qh[l] & kmask3) << 0)) - 32); - sums[3] += y[l+96] * ((int8_t)((q2[l] >> 4) | ((qh[l] & kmask4) >> 2)) - 32); - } - - sumf += dall * (sums[0] * sc[0] + sums[1] * sc[2] + sums[2] * sc[4] + sums[3] * sc[6]); - - } - -#else - const int ix = tiisg/4; - const int il = 4*(tiisg%4); - - for (int i = ix; i < nb; i += 8) { - device const float * y = yy + i * QK_K + il; - device const uint8_t * ql = x[i].ql + il; - device const uint8_t * qh = x[i].qh + il; - device const int8_t * s = x[i].scales; - - const float d = x[i].d; - - float4 sums = {0.f, 0.f, 0.f, 0.f}; - for (int l = 0; l < 4; ++l) { - sums[0] += y[l+ 0] * ((int8_t)((ql[l+ 0] & 0xF) | ((qh[l] & kmask1) << 4)) - 32); - sums[1] += y[l+16] * ((int8_t)((ql[l+16] & 0xF) | ((qh[l] & kmask2) << 2)) - 32); - sums[2] += y[l+32] * ((int8_t)((ql[l+ 0] >> 4) | ((qh[l] & kmask3) >> 0)) - 32); - sums[3] += y[l+48] * ((int8_t)((ql[l+16] >> 4) | ((qh[l] & kmask4) >> 2)) - 32); - } - sumf += d * (sums[0] * s[0] + sums[1] * s[1] + sums[2] * s[2] + sums[3] * s[3]); - } - -#endif - - const float tot = simd_sum(sumf); - if (tiisg == 0) { - dst[r1*ne0 + r2*ne0*ne1 + row] = tot; - } -} - -//============================= templates and their specializations ============================= - -// NOTE: this is not dequantizing - we are simply fitting the template -template -void dequantize_f32(device const float4x4 * src, short il, thread type4x4 & reg) { - float4x4 temp = *(((device float4x4 *)src)); - for (int i = 0; i < 16; i++){ - reg[i/4][i%4] = temp[i/4][i%4]; - } -} - -template -void dequantize_f16(device const half4x4 * src, short il, thread type4x4 & reg) { - half4x4 temp = *(((device half4x4 *)src)); - for (int i = 0; i < 16; i++){ - reg[i/4][i%4] = temp[i/4][i%4]; - } -} - -template -void dequantize_q4_0(device const block_q4_0 *xb, short il, thread type4x4 & reg) { - device const uint16_t * qs = ((device const uint16_t *)xb + 1); - const float d1 = il ? (xb->d / 16.h) : xb->d; - const float d2 = d1 / 256.f; - const float md = -8.h * xb->d; - const ushort mask0 = il ? 0x00F0 : 0x000F; - const ushort mask1 = mask0 << 8; - - for (int i=0;i<8;i++) { - reg[i/2][2*(i%2)+0] = d1 * (qs[i] & mask0) + md; - reg[i/2][2*(i%2)+1] = d2 * (qs[i] & mask1) + md; - } -} - -template -void dequantize_q4_1(device const block_q4_1 *xb, short il, thread type4x4 & reg) { - device const uint16_t * qs = ((device const uint16_t *)xb + 2); - const float d1 = il ? (xb->d / 16.h) : xb->d; - const float d2 = d1 / 256.f; - const float m = xb->m; - const ushort mask0 = il ? 0x00F0 : 0x000F; - const ushort mask1 = mask0 << 8; - - for (int i=0;i<8;i++) { - reg[i/2][2*(i%2)+0] = ((qs[i] & mask0) * d1) + m; - reg[i/2][2*(i%2)+1] = ((qs[i] & mask1) * d2) + m; - } -} - -template -void dequantize_q5_0(device const block_q5_0 *xb, short il, thread type4x4 & reg) { - device const uint16_t * qs = ((device const uint16_t *)xb + 3); - const float d = xb->d; - const float md = -16.h * xb->d; - const ushort mask = il ? 0x00F0 : 0x000F; - - const uint32_t qh = *((device const uint32_t *)xb->qh); - - const int x_mv = il ? 4 : 0; - - const int gh_mv = il ? 12 : 0; - const int gh_bk = il ? 0 : 4; - - for (int i = 0; i < 8; i++) { - // extract the 5-th bits for x0 and x1 - const uint8_t xh_0 = ((qh >> (gh_mv + 2*i )) << gh_bk) & 0x10; - const uint8_t xh_1 = ((qh >> (gh_mv + 2*i+1)) << gh_bk) & 0x10; - - // combine the 4-bits from qs with the 5th bit - const int32_t x0 = ((((qs[i] ) & mask) >> x_mv) | xh_0); - const int32_t x1 = ((((qs[i] >> 8) & mask) >> x_mv) | xh_1); - - reg[i/2][2*(i%2)+0] = d * x0 + md; - reg[i/2][2*(i%2)+1] = d * x1 + md; - } -} - -template -void dequantize_q5_1(device const block_q5_1 *xb, short il, thread type4x4 & reg) { - device const uint16_t * qs = ((device const uint16_t *)xb + 4); - const float d = xb->d; - const float m = xb->m; - const ushort mask = il ? 0x00F0 : 0x000F; - - const uint32_t qh = *((device const uint32_t *)xb->qh); - - const int x_mv = il ? 4 : 0; - - const int gh_mv = il ? 12 : 0; - const int gh_bk = il ? 0 : 4; - - for (int i = 0; i < 8; i++) { - // extract the 5-th bits for x0 and x1 - const uint8_t xh_0 = ((qh >> (gh_mv + 2*i )) << gh_bk) & 0x10; - const uint8_t xh_1 = ((qh >> (gh_mv + 2*i+1)) << gh_bk) & 0x10; - - // combine the 4-bits from qs with the 5th bit - const int32_t x0 = ((((qs[i] ) & mask) >> x_mv) | xh_0); - const int32_t x1 = ((((qs[i] >> 8) & mask) >> x_mv) | xh_1); - - reg[i/2][2*(i%2)+0] = d * x0 + m; - reg[i/2][2*(i%2)+1] = d * x1 + m; - } -} - -template -void dequantize_q8_0(device const block_q8_0 *xb, short il, thread type4x4 & reg) { - device const int8_t * qs = ((device const int8_t *)xb->qs); - const half d = xb->d; - - for (int i=0;i<16;i++) { - reg[i/4][i%4] = (qs[i + 16*il] * d); - } -} - -template -void dequantize_q2_K(device const block_q2_K *xb, short il, thread type4x4 & reg) { - const half d = xb->d; - const half min = xb->dmin; - device const uint8_t * q = (device const uint8_t *)xb->qs; - half dl, ml; - uint8_t sc = xb->scales[il]; - -#if QK_K == 256 - q = q + 32*(il/8) + 16*(il&1); - il = (il/2)%4; -#endif - half coef = il>1 ? (il>2 ? 1/64.h : 1/16.h) : (il>0 ? 1/4.h : 1.h); - uchar mask = il>1 ? (il>2 ? 192 : 48) : (il>0 ? 12 : 3); - dl = d * (sc & 0xF) * coef, ml = min * (sc >> 4); - for (int i = 0; i < 16; ++i) { - reg[i/4][i%4] = dl * (q[i] & mask) - ml; - } -} - -template -void dequantize_q3_K(device const block_q3_K *xb, short il, thread type4x4 & reg) { - const half d_all = xb->d; - device const uint8_t * q = (device const uint8_t *)xb->qs; - device const uint8_t * h = (device const uint8_t *)xb->hmask; - device const int8_t * scales = (device const int8_t *)xb->scales; - -#if QK_K == 256 - q = q + 32 * (il/8) + 16 * (il&1); - h = h + 16 * (il&1); - uint8_t m = 1 << (il/2); - uint16_t kmask1 = (il/4)>1 ? ((il/4)>2 ? 192 : 48) : \ - ((il/4)>0 ? 12 : 3); - uint16_t kmask2 = il/8 ? 0xF0 : 0x0F; - uint16_t scale_2 = scales[il%8], scale_1 = scales[8 + il%4]; - int16_t dl_int = (il/4)&1 ? (scale_2&kmask2) | ((scale_1&kmask1) << 2) - : (scale_2&kmask2) | ((scale_1&kmask1) << 4); - half dl = il<8 ? d_all * (dl_int - 32.h) : d_all * (dl_int / 16.h - 32.h); - const half ml = 4.h * dl; - - il = (il/2) & 3; - const half coef = il>1 ? (il>2 ? 1/64.h : 1/16.h) : (il>0 ? 1/4.h : 1.h); - const uint8_t mask = il>1 ? (il>2 ? 192 : 48) : (il>0 ? 12 : 3); - dl *= coef; - - for (int i = 0; i < 16; ++i) { - reg[i/4][i%4] = dl * (q[i] & mask) - (h[i] & m ? 0 : ml); - } -#else - float kcoef = il&1 ? 1.f/16.f : 1.f; - uint16_t kmask = il&1 ? 0xF0 : 0x0F; - float dl = d_all * ((scales[il/2] & kmask) * kcoef - 8); - float coef = il>1 ? (il>2 ? 1/64.h : 1/16.h) : (il>0 ? 1/4.h : 1.h); - uint8_t mask = il>1 ? (il>2 ? 192 : 48) : (il>0 ? 12 : 3); - uint8_t m = 1<<(il*2); - for (int i = 0; i < 16; ++i) { - reg[i/4][i%4] = coef * dl * ((q[i] & mask) - ((h[i%8] & (m * (1 + i/8))) ? 0 : 4.f/coef)); - } -#endif -} - -static inline uchar2 get_scale_min_k4_just2(int j, int k, device const uchar * q) { - return j < 4 ? uchar2{uchar(q[j+0+k] & 63), uchar(q[j+4+k] & 63)} - : uchar2{uchar((q[j+4+k] & 0xF) | ((q[j-4+k] & 0xc0) >> 2)), uchar((q[j+4+k] >> 4) | ((q[j-0+k] & 0xc0) >> 2))}; -} - -template -void dequantize_q4_K(device const block_q4_K *xb, short il, thread type4x4 & reg) { - device const uchar * q = xb->qs; - -#if QK_K == 256 - short is = (il/4) * 2; - q = q + (il/4) * 32 + 16 * (il&1); - il = il & 3; - const uchar2 sc = get_scale_min_k4_just2(is, il/2, xb->scales); - const half d = il < 2 ? xb->d : xb->d / 16.h; - const half min = xb->dmin; - const half dl = d * sc[0]; - const half ml = min * sc[1]; -#else - q = q + 16 * (il&1); - device const uint8_t * s = xb->scales; - device const half2 * dh = (device const half2 *)xb->d; - const float2 d = (float2)dh[0]; - const float dl = il<2 ? d[0] * (s[0]&0xF) : d[0] * (s[1]&0xF)/16.h; - const float ml = il<2 ? d[1] * (s[0]>>4) : d[1] * (s[1]>>4); -#endif - const ushort mask = il<2 ? 0x0F : 0xF0; - for (int i = 0; i < 16; ++i) { - reg[i/4][i%4] = dl * (q[i] & mask) - ml; - } -} - -template -void dequantize_q5_K(device const block_q5_K *xb, short il, thread type4x4 & reg) { - device const uint8_t * q = xb->qs; - device const uint8_t * qh = xb->qh; - -#if QK_K == 256 - short is = (il/4) * 2; - q = q + 32 * (il/4) + 16 * (il&1); - qh = qh + 16 * (il&1); - uint8_t ul = 1 << (il/2); - il = il & 3; - const uchar2 sc = get_scale_min_k4_just2(is, il/2, xb->scales); - const half d = il < 2 ? xb->d : xb->d / 16.h; - const half min = xb->dmin; - const half dl = d * sc[0]; - const half ml = min * sc[1]; - - const ushort mask = il<2 ? 0x0F : 0xF0; - const half qh_val = il<2 ? 16.h : 256.h; - for (int i = 0; i < 16; ++i) { - reg[i/4][i%4] = dl * ((q[i] & mask) + (qh[i] & ul ? qh_val : 0)) - ml; - } -#else - q = q + 16 * (il&1); - device const int8_t * s = xb->scales; - const float dl = xb->d * s[il]; - uint8_t m = 1<<(il*2); - const float coef = il<2 ? 1.f : 1.f/16.f; - const ushort mask = il<2 ? 0x0F : 0xF0; - for (int i = 0; i < 16; ++i) { - reg[i/4][i%4] = coef * dl * ((q[i] & mask) - (qh[i%8] & (m*(1+i/8)) ? 0.f : 16.f/coef)); - } -#endif -} - -template -void dequantize_q6_K(device const block_q6_K *xb, short il, thread type4x4 & reg) { - const half d_all = xb->d; - device const uint8_t * ql = (device const uint8_t *)xb->ql; - device const uint8_t * qh = (device const uint8_t *)xb->qh; - device const int8_t * scales = (device const int8_t *)xb->scales; - -#if QK_K == 256 - ql = ql + 64*(il/8) + 32*((il/2)&1) + 16*(il&1); - qh = qh + 32*(il/8) + 16*(il&1); - half sc = scales[(il%2) + 2 * ((il/2))]; - il = (il/2) & 3; -#else - ql = ql + 16 * (il&1); - half sc = scales[il]; -#endif - const uint16_t kmask1 = il>1 ? (il>2 ? 192 : 48) : (il>0 ? 12 : 3); - const uint16_t kmask2 = il>1 ? 0xF0 : 0x0F; - const half coef = il>1 ? 1.f/16.h : 1.h; - const half ml = d_all * sc * 32.h; - const half dl = d_all * sc * coef; - for (int i = 0; i < 16; ++i) { - const half q = il&1 ? ((ql[i] & kmask2) | ((qh[i] & kmask1) << 2)) - : ((ql[i] & kmask2) | ((qh[i] & kmask1) << 4)); - reg[i/4][i%4] = dl * q - ml; - } -} - -template -kernel void kernel_get_rows( - device const void * src0, - device const int * src1, - device float * dst, - constant int64_t & ne00, - constant uint64_t & nb01, - constant uint64_t & nb1, - uint tgpig[[threadgroup_position_in_grid]], - uint tiitg[[thread_index_in_threadgroup]], - uint tptg[[threads_per_threadgroup]]) { - const int i = tgpig; - const int r = ((device int32_t *) src1)[i]; - - for (int ind = tiitg; ind < ne00/16; ind += tptg) { - float4x4 temp; - dequantize_func( - ((device const block_q *) ((device char *) src0 + r*nb01)) + ind/nl, ind%nl, temp); - *(((device float4x4 *) ((device char *) dst + i*nb1)) + ind) = temp; - } -} - -#define BLOCK_SIZE_M 64 // 8 simdgroup matrices from matrix A -#define BLOCK_SIZE_N 32 // 4 simdgroup matrices from matrix B -#define BLOCK_SIZE_K 32 -#define THREAD_MAT_M 4 // each thread take 4 simdgroup matrices from matrix A -#define THREAD_MAT_N 2 // each thread take 2 simdgroup matrices from matrix B -#define THREAD_PER_BLOCK 128 -#define THREAD_PER_ROW 2 // 2 thread for each row in matrix A to load numbers -#define THREAD_PER_COL 4 // 4 thread for each row in matrix B to load numbers -#define SG_MAT_SIZE 64 // simdgroup matrix is of shape 8x8 -#define SG_MAT_ROW 8 - -// each block_q contains 16*nl weights -template -kernel void kernel_mul_mm(device const uchar * src0, - device const uchar * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne02, - constant int64_t & nb01, - constant int64_t & nb02, - constant int64_t & ne12, - constant int64_t & nb10, - constant int64_t & nb11, - constant int64_t & nb12, - constant int64_t & ne0, - constant int64_t & ne1, - constant uint & gqa, - threadgroup uchar * shared_memory [[threadgroup(0)]], - uint3 tgpig[[threadgroup_position_in_grid]], - uint tiitg[[thread_index_in_threadgroup]], - uint sgitg[[simdgroup_index_in_threadgroup]]) { - - threadgroup half * sa = (threadgroup half *)(shared_memory); - threadgroup float * sb = (threadgroup float *)(shared_memory + 4096); - - const uint r0 = tgpig.y; - const uint r1 = tgpig.x; - const uint im = tgpig.z; - - // if this block is of 64x32 shape or smaller - short n_rows = (ne0 - r0 * BLOCK_SIZE_M < BLOCK_SIZE_M) ? (ne0 - r0 * BLOCK_SIZE_M) : BLOCK_SIZE_M; - short n_cols = (ne1 - r1 * BLOCK_SIZE_N < BLOCK_SIZE_N) ? (ne1 - r1 * BLOCK_SIZE_N) : BLOCK_SIZE_N; - - // a thread shouldn't load data outside of the matrix - short thread_row = ((short)tiitg/THREAD_PER_ROW) < n_rows ? ((short)tiitg/THREAD_PER_ROW) : n_rows - 1; - short thread_col = ((short)tiitg/THREAD_PER_COL) < n_cols ? ((short)tiitg/THREAD_PER_COL) : n_cols - 1; - - simdgroup_half8x8 ma[4]; - simdgroup_float8x8 mb[2]; - simdgroup_float8x8 c_res[8]; - for (int i = 0; i < 8; i++){ - c_res[i] = make_filled_simdgroup_matrix(0.f); - } - - short il = (tiitg % THREAD_PER_ROW); - - uint offset0 = im/gqa*nb02; - ushort offset1 = il/nl; - - device const block_q * x = (device const block_q *)(src0 + (r0 * BLOCK_SIZE_M + thread_row) * nb01 + offset0) + offset1; - device const float * y = (device const float *)(src1 - + nb12 * im - + nb11 * (r1 * BLOCK_SIZE_N + thread_col) - + nb10 * (BLOCK_SIZE_K / THREAD_PER_COL * (tiitg % THREAD_PER_COL))); - - for (int loop_k = 0; loop_k < ne00; loop_k += BLOCK_SIZE_K) { - // load data and store to threadgroup memory - half4x4 temp_a; - dequantize_func(x, il, temp_a); - threadgroup_barrier(mem_flags::mem_threadgroup); - - #pragma unroll(16) - for (int i = 0; i < 16; i++) { - *(sa + SG_MAT_SIZE * ((tiitg / THREAD_PER_ROW / 8) \ - + (tiitg % THREAD_PER_ROW) * 16 + (i / 8) * 8) \ - + (tiitg / THREAD_PER_ROW) % 8 + (i & 7) * 8) = temp_a[i/4][i%4]; - } - - *(threadgroup float2x4 *)(sb + (tiitg % THREAD_PER_COL) * 8 * 32 + 8 * (tiitg / THREAD_PER_COL)) = *((device float2x4 *)y); - - il = (il + 2 < nl) ? il + 2 : il % 2; - x = (il < 2) ? x + (2+nl-1)/nl : x; - y += BLOCK_SIZE_K; - - threadgroup_barrier(mem_flags::mem_threadgroup); - - // load matrices from threadgroup memory and conduct outer products - threadgroup half * lsma = (sa + THREAD_MAT_M * SG_MAT_SIZE * (sgitg % 2)); - threadgroup float * lsmb = (sb + THREAD_MAT_N * SG_MAT_SIZE * (sgitg / 2)); - - #pragma unroll(4) - for (int ik = 0; ik < BLOCK_SIZE_K / 8; ik++) { - #pragma unroll(4) - for (int i = 0; i < 4; i++) { - simdgroup_load(ma[i],lsma + SG_MAT_SIZE * i); - } - simdgroup_barrier(mem_flags::mem_none); - #pragma unroll(2) - for (int i = 0; i < 2; i++) { - simdgroup_load(mb[i],lsmb + SG_MAT_SIZE * i); - } - - lsma += BLOCK_SIZE_M / SG_MAT_ROW * SG_MAT_SIZE; - lsmb += BLOCK_SIZE_N / SG_MAT_ROW * SG_MAT_SIZE; - - #pragma unroll(8) - for (int i = 0; i < 8; i++){ - simdgroup_multiply_accumulate(c_res[i], mb[i/4], ma[i%4], c_res[i]); - } - } - } - - if ((r0 + 1) * BLOCK_SIZE_M <= ne0 && (r1 + 1) * BLOCK_SIZE_N <= ne1) { - device float * C = dst + (BLOCK_SIZE_M * r0 + 32 * (sgitg & 1)) \ - + (BLOCK_SIZE_N * r1 + 16 * (sgitg >> 1)) * ne0 + im*ne1*ne0; - for (int i = 0; i < 8; i++) { - simdgroup_store(c_res[i], C + 8 * (i%4) + 8 * ne0 * (i/4), ne0); - } - } else { - // block is smaller than 64x32, we should avoid writing data outside of the matrix - threadgroup_barrier(mem_flags::mem_threadgroup); - threadgroup float * temp_str = ((threadgroup float *)shared_memory) \ - + 32 * (sgitg&1) + (16 * (sgitg>>1)) * BLOCK_SIZE_M; - for (int i = 0; i < 8; i++) { - simdgroup_store(c_res[i], temp_str + 8 * (i%4) + 8 * BLOCK_SIZE_M * (i/4), BLOCK_SIZE_M); - } - - threadgroup_barrier(mem_flags::mem_threadgroup); - - device float * C = dst + (BLOCK_SIZE_M * r0) + (BLOCK_SIZE_N * r1) * ne0 + im*ne1*ne0; - if (sgitg == 0) { - for (int i = 0; i < n_rows; i++) { - for (int j = tiitg; j < n_cols; j += BLOCK_SIZE_N) { - *(C + i + j * ne0) = *(temp_str + i + j * BLOCK_SIZE_M); - } - } - } - } -} - -#if QK_K == 256 -#define QK_NL 16 -#else -#define QK_NL 4 -#endif - -typedef void (get_rows_t)(device const void *, device const int *, device float *, constant int64_t &, \ - constant uint64_t &, constant uint64_t &, uint, uint, uint); - -template [[host_name("kernel_get_rows_f32")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_f16")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_q4_0")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_q4_1")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_q5_0")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_q5_1")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_q8_0")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_q2_K")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_q3_K")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_q4_K")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_q5_K")]] kernel get_rows_t kernel_get_rows; -template [[host_name("kernel_get_rows_q6_K")]] kernel get_rows_t kernel_get_rows; - -typedef void (mat_mm_t)( - device const uchar * src0, - device const uchar * src1, - device float * dst, - constant int64_t & ne00, - constant int64_t & ne02, - constant int64_t & nb01, - constant int64_t & nb02, - constant int64_t & ne12, - constant int64_t & nb10, - constant int64_t & nb11, - constant int64_t & nb12, - constant int64_t & ne0, - constant int64_t & ne1, - constant uint & gqa, - threadgroup uchar *, uint3, uint, uint); - -template [[host_name("kernel_mul_mm_f32_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_f16_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_q4_0_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_q4_1_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_q5_0_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_q5_1_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_q8_0_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_q2_K_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_q3_K_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_q4_K_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_q5_K_f32")]] kernel mat_mm_t kernel_mul_mm; -template [[host_name("kernel_mul_mm_q6_K_f32")]] kernel mat_mm_t kernel_mul_mm; diff --git a/LLama/runtimes/macos-x86_64/libllama.dylib b/LLama/runtimes/macos-x86_64/libllama.dylib index f3e412128d79225a2fae5e1115e0f085d26788b3..37eb3cd43896f2e8ae243965eaa2368314819bf8 100644 GIT binary patch delta 197592 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 BKAHdk delta 243545 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 Bo3sD` From 0045606bf7dc1c83914f86a81247e8c1d150a507 Mon Sep 17 00:00:00 2001 From: jlsantiago Date: Tue, 7 Nov 2023 00:04:18 +0100 Subject: [PATCH 08/18] Do not copy metal on MacOS x86_64 Build --- .github/workflows/compile.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/compile.yml b/.github/workflows/compile.yml index 75f096a80..42cb98dcd 100644 --- a/.github/workflows/compile.yml +++ b/.github/workflows/compile.yml @@ -218,7 +218,7 @@ jobs: cp artifacts/llama-bin-macos-arm64.dylib/libllama.dylib deps/macos-arm64/libllama.dylib cp artifacts/ggml-metal.metal/ggml-metal.metal deps/macos-arm64/ggml-metal.metal cp artifacts/llama-bin-macos-x86_64.dylib/libllama.dylib deps/macos-x86_64/libllama.dylib - cp artifacts/ggml-metal.metal/ggml-metal.metal deps/macos-x86_64/ggml-metal.metal + - name: Rearrange CUDA files if: ${{ github.event.inputs.cublas }} From bfeaa575e7f386f4185f446916749dec901dcc3d Mon Sep 17 00:00:00 2001 From: jlsantiago Date: Tue, 7 Nov 2023 00:05:45 +0100 Subject: [PATCH 09/18] Let master branch in the CI test execution --- .github/workflows/main.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 4711de353..db051001d 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -1,9 +1,9 @@ name: CI on: push: - branches: [RuntimeDetection] + branches: [master] pull_request: - branches: [RuntimeDetection] + branches: [master] jobs: build: From 0336f6fbfb4310f35da5a04df5ae5cfe590713fc Mon Sep 17 00:00:00 2001 From: jlsantiago Date: Tue, 7 Nov 2023 22:07:08 +0100 Subject: [PATCH 10/18] Backend.Metal is not needed any more --- .github/prepare_release.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/prepare_release.sh b/.github/prepare_release.sh index 3fc2e3937..fd4427e8d 100755 --- a/.github/prepare_release.sh +++ b/.github/prepare_release.sh @@ -71,7 +71,7 @@ cd temp nuget pack LLamaSharp.Backend.Cpu.nuspec -version $updated_version nuget pack LLamaSharp.Backend.Cuda11.nuspec -version $updated_version nuget pack LLamaSharp.Backend.Cuda12.nuspec -version $updated_version -nuget pack LLamaSharp.Backend.MacMetal.nuspec -version $updated_version + cd .. exit 0 From 0edbd9253092edf874bf925581eaecc34d84a6a8 Mon Sep 17 00:00:00 2001 From: SignalRT Date: Tue, 7 Nov 2023 22:08:31 +0100 Subject: [PATCH 11/18] Change nuget backend packages Delete Backend.Metal because is not needed anymore. Do not include .metal in x86_64 binaries --- .../build/LLamaSharp.Backend.Cpu.nuspec | 7 +++-- .../build/LLamaSharp.Backend.MacMetal.nuspec | 26 ------------------- LLama/runtimes/build/LLamaSharpBackend.props | 6 ----- 3 files changed, 3 insertions(+), 36 deletions(-) delete mode 100644 LLama/runtimes/build/LLamaSharp.Backend.MacMetal.nuspec diff --git a/LLama/runtimes/build/LLamaSharp.Backend.Cpu.nuspec b/LLama/runtimes/build/LLamaSharp.Backend.Cpu.nuspec index 739eb9086..5664be894 100644 --- a/LLama/runtimes/build/LLamaSharp.Backend.Cpu.nuspec +++ b/LLama/runtimes/build/LLamaSharp.Backend.Cpu.nuspec @@ -19,10 +19,9 @@ - - - - + + + diff --git a/LLama/runtimes/build/LLamaSharp.Backend.MacMetal.nuspec b/LLama/runtimes/build/LLamaSharp.Backend.MacMetal.nuspec deleted file mode 100644 index 0ba9c508a..000000000 --- a/LLama/runtimes/build/LLamaSharp.Backend.MacMetal.nuspec +++ /dev/null @@ -1,26 +0,0 @@ - - - - LLamaSharp.Backend.MacMetal - $version$ - LLamaSharp.Backend.MacMetal, the backend for LLamaSharp on MACOS. - llama.cpp Authors - false - MIT - icon512.png - https://github.com/SciSharp/LLamaSharp - LLamaSharp.Backend.MacMetal is a backend for LLamaSharp to use MAC with GPU support. - - Copyright 2023 The llama.cpp Authors. All rights reserved. - LLamaSharp LLama LLM GPT AI ChatBot SciSharp - - - - - - - - - - - diff --git a/LLama/runtimes/build/LLamaSharpBackend.props b/LLama/runtimes/build/LLamaSharpBackend.props index 7e3db26e5..786e89056 100644 --- a/LLama/runtimes/build/LLamaSharpBackend.props +++ b/LLama/runtimes/build/LLamaSharpBackend.props @@ -25,12 +25,6 @@ false %(Filename)%(Extension) - - PreserveNewest - false - %(Filename)%(Extension) - From b893c6f6091313fc4db3182c206f2246778588f6 Mon Sep 17 00:00:00 2001 From: Yaohui Liu Date: Thu, 9 Nov 2023 03:27:21 +0800 Subject: [PATCH 12/18] feat: add detection template for cuda and avx. --- LLama/LLamaSharp.csproj | 1 + LLama/Native/NativeApi.cs | 155 ++++++++++++++++++++++++++++---------- 2 files changed, 115 insertions(+), 41 deletions(-) diff --git a/LLama/LLamaSharp.csproj b/LLama/LLamaSharp.csproj index d525202f2..4577515b1 100644 --- a/LLama/LLamaSharp.csproj +++ b/LLama/LLamaSharp.csproj @@ -47,6 +47,7 @@ + diff --git a/LLama/Native/NativeApi.cs b/LLama/Native/NativeApi.cs index e3b182bd4..9998020ef 100644 --- a/LLama/Native/NativeApi.cs +++ b/LLama/Native/NativeApi.cs @@ -1,8 +1,13 @@ using System; using System.Buffers; +using System.Reflection; using System.Runtime.InteropServices; using System.Text; using LLama.Exceptions; +using ManagedCuda; +#if NET6_0_OR_GREATER +using System.Runtime.Intrinsics.X86; +#endif #pragma warning disable IDE1006 // Naming Styles @@ -24,8 +29,9 @@ public unsafe partial class NativeApi { static NativeApi() { - // Try to load a preferred library, based on CPU feature detection - TryLoadLibrary(); +#if NET6_0_OR_GREATER + NativeLibrary.SetDllImportResolver(typeof(NativeApi).Assembly, LLamaImportResolver); +#endif try { @@ -44,61 +50,120 @@ static NativeApi() } ///

- /// Try to load libllama, using CPU feature detection to try and load a more specialised DLL if possible + /// Get the cuda version if possible. /// - /// The library handle to unload later, or IntPtr.Zero if no library was loaded - private static IntPtr TryLoadLibrary() + /// -1 for no cuda + private static int GetCudaVersion() { -#if NET6_0_OR_GREATER - - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + int deviceCount = CudaContext.GetDeviceCount(); + for (int deviceIndex = 0; deviceIndex < deviceCount; deviceIndex++) { - // All of the Windows libraries, in order of preference - return TryLoad("cu12.1.0/libllama.dll") - ?? TryLoad("cu11.7.1/libllama.dll") -#if NET8_0_OR_GREATER - ?? TryLoad("avx512/libllama.dll", System.Runtime.Intrinsics.X86.Avx512.IsSupported) -#endif - ?? TryLoad("avx2/libllama.dll", System.Runtime.Intrinsics.X86.Avx2.IsSupported) - ?? TryLoad("avx/libllama.dll", System.Runtime.Intrinsics.X86.Avx.IsSupported) - ?? IntPtr.Zero; + using (CudaContext ctx = new CudaContext(deviceIndex)) + { + var version = ctx.GetAPIVersionOfCurrentContext(); + return version.Major; + } } + return -1; + } - if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) - { - // All of the Linux libraries, in order of preference - return TryLoad("cu12.1.0/libllama.so") - ?? TryLoad("cu11.7.1/libllama.so") + /// + /// Get the xla flag for native library name. + /// + /// + private static string GetAvxFlag() + { + AvxLevel level = AvxLevel.None; +#if NET6_0_OR_GREATER + if (Avx.IsSupported) level = AvxLevel.Avx; + if (Avx2.IsSupported) level = AvxLevel.Avx2; #if NET8_0_OR_GREATER - ?? TryLoad("avx512/libllama.so", System.Runtime.Intrinsics.X86.Avx512.IsSupported) + if(Avx512F.IsSupported) level = AvxLevel.Avx512; #endif - ?? TryLoad("avx2/libllama.so", System.Runtime.Intrinsics.X86.Avx2.IsSupported) - ?? TryLoad("avx/libllama.so", System.Runtime.Intrinsics.X86.Avx.IsSupported) - ?? IntPtr.Zero; - } - if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + return level switch { - return IntPtr.Zero; - } + AvxLevel.None => "", + AvxLevel.Avx => "-avx", + AvxLevel.Avx2 => "-avx2", + AvxLevel.Avx512 => "-avx512", + }; +#else + return string.Empty; #endif - - return IntPtr.Zero; + } #if NET6_0_OR_GREATER - // Try to load a DLL from the path if supported. Returns null if nothing is loaded. - static IntPtr? TryLoad(string path, bool supported = true) + private static IntPtr LLamaImportResolver(string name, Assembly assembly, DllImportSearchPath? searchPath) + { + IntPtr handle = IntPtr.Zero; + if(!name.Equals(libraryName)) { - if (!supported) - return null; - - if (NativeLibrary.TryLoad(path, out var handle)) - return handle; + return NativeLibrary.Load(name, assembly, searchPath); + } - return null; + string libraryPath = string.Empty; + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + var avxFlag = GetAvxFlag(); + // check cuda + var cudaVersion = GetCudaVersion(); + if(cudaVersion == 11) + { + libraryPath = $"runtimes/win-x64/native/libllama-cuda11{avxFlag}.dll"; + } + else if (cudaVersion == 12) + { + libraryPath = $"runtimes/win-x64/native/libllama-cuda12{avxFlag}.dll"; + } + else if(cudaVersion == -1) // cpu version + { + libraryPath = $"runtimes/win-x64/native/libllama{avxFlag}.dll"; + } + else + { + throw new NotImplementedException($"Cuda version {cudaVersion} has not been supported, please compile dll yourself or open an issue in LLamaSharp."); + } } -#endif + else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) + { + var avxFlag = GetAvxFlag(); + // check cuda + var cudaVersion = GetCudaVersion(); + if (cudaVersion == 11) + { + libraryPath = $"runtimes/linux-x64/native/libllama-cuda11{avxFlag}.so"; + } + else if (cudaVersion == 12) + { + libraryPath = $"runtimes/linux-x64/native/libllama-cuda12{avxFlag}.so"; + } + else if (cudaVersion == -1) // cpu version + { + libraryPath = $"runtimes/linux-x64/native/libllama{avxFlag}.so"; + } + else + { + throw new NotImplementedException($"Cuda version {cudaVersion} has not been supported, please compile dll yourself or open an issue in LLamaSharp."); + } + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + { + if (System.Runtime.Intrinsics.Arm.ArmBase.Arm64.IsSupported) + { + libraryPath = $"runtimes/osx-arm64/native/libllama.dylib"; + } + else + { + libraryPath = $"runtimes/osx-x64/native/libllama.dylib"; + } + } + + NativeLibrary.TryLoad(libraryPath, assembly, searchPath, out handle); + return handle; } +#endif + private const string libraryName = "libllama"; @@ -572,5 +637,13 @@ public static int llama_tokenize(SafeLLamaContextHandle ctx, string text, Encodi /// [DllImport(libraryName, CallingConvention = CallingConvention.Cdecl)] public static extern int llama_set_n_threads(SafeLLamaContextHandle ctx, uint n_threads, uint n_threads_batch); + + private enum AvxLevel + { + None = 0, + Avx = 1, + Avx2 = 2, + Avx512 = 3 + } } } From b4b3ea9d994bbfdb61b57d2f194c8816e469646e Mon Sep 17 00:00:00 2001 From: SignalRT Date: Wed, 8 Nov 2023 23:20:12 +0100 Subject: [PATCH 13/18] Merge feat: add detection template for cuda and avx. #268 Just merge cuda and avx detection and change layout. --- LLama/LLamaSharp.Runtime.targets | 36 +++++++++--------- LLama/Native/NativeApi.cs | 16 ++++---- .../{ => linux-x64}/libllama-cuda11.so | Bin .../{ => linux-x64}/libllama-cuda12.so | Bin LLama/runtimes/{ => linux-x64}/libllama.so | Bin .../ggml-metal.metal | 0 .../{macos-arm64 => osx-arm64}/libllama.dylib | Bin .../{macos-x86_64 => osx-x64}/libllama.dylib | Bin .../{ => win-x64}/libllama-cuda11.dll | Bin .../{ => win-x64}/libllama-cuda12.dll | Bin LLama/runtimes/{ => win-x64}/libllama.dll | Bin 11 files changed, 26 insertions(+), 26 deletions(-) rename LLama/runtimes/{ => linux-x64}/libllama-cuda11.so (100%) rename LLama/runtimes/{ => linux-x64}/libllama-cuda12.so (100%) rename LLama/runtimes/{ => linux-x64}/libllama.so (100%) rename LLama/runtimes/{macos-arm64 => osx-arm64}/ggml-metal.metal (100%) rename LLama/runtimes/{macos-arm64 => osx-arm64}/libllama.dylib (100%) rename LLama/runtimes/{macos-x86_64 => osx-x64}/libllama.dylib (100%) rename LLama/runtimes/{ => win-x64}/libllama-cuda11.dll (100%) rename LLama/runtimes/{ => win-x64}/libllama-cuda12.dll (100%) rename LLama/runtimes/{ => win-x64}/libllama.dll (100%) diff --git a/LLama/LLamaSharp.Runtime.targets b/LLama/LLamaSharp.Runtime.targets index bc9a69110..12ce224db 100644 --- a/LLama/LLamaSharp.Runtime.targets +++ b/LLama/LLamaSharp.Runtime.targets @@ -3,41 +3,41 @@ true - + PreserveNewest - libllama.dll + runtimes/win-x64/libllama.dll - + PreserveNewest - libllama-cuda11.dll + runtimes/win-x64/libllama-cuda11.dll - + PreserveNewest - libllama-cuda12.dll + runtimes/win-x64/libllama-cuda12.dll - + PreserveNewest - libllama.so + runtimes/linux-x64/libllama.so - + PreserveNewest - libllama-cuda11.so + runtimes/linux-x64/libllama-cuda11.so - + PreserveNewest - libllama-cuda12.so + runtimes/linux-x64/libllama-cuda12.so - + PreserveNewest - runtimes/macos-arm64/libllama.dylib + runtimes/osx-arm64/libllama.dylib - + PreserveNewest - runtimes/macos-arm64/ggml-metal.metal + runtimes/osx-arm64/ggml-metal.metal - + PreserveNewest - runtimes/macos-x86_64/libllama.dylib + runtimes/osx-x64/libllama.dylib \ No newline at end of file diff --git a/LLama/Native/NativeApi.cs b/LLama/Native/NativeApi.cs index 9998020ef..b3a264359 100644 --- a/LLama/Native/NativeApi.cs +++ b/LLama/Native/NativeApi.cs @@ -110,15 +110,15 @@ private static IntPtr LLamaImportResolver(string name, Assembly assembly, DllImp var cudaVersion = GetCudaVersion(); if(cudaVersion == 11) { - libraryPath = $"runtimes/win-x64/native/libllama-cuda11{avxFlag}.dll"; + libraryPath = $"runtimes/win-x64/libllama-cuda11{avxFlag}.dll"; } else if (cudaVersion == 12) { - libraryPath = $"runtimes/win-x64/native/libllama-cuda12{avxFlag}.dll"; + libraryPath = $"runtimes/win-x64/libllama-cuda12{avxFlag}.dll"; } else if(cudaVersion == -1) // cpu version { - libraryPath = $"runtimes/win-x64/native/libllama{avxFlag}.dll"; + libraryPath = $"runtimes/win-x64/libllama{avxFlag}.dll"; } else { @@ -132,15 +132,15 @@ private static IntPtr LLamaImportResolver(string name, Assembly assembly, DllImp var cudaVersion = GetCudaVersion(); if (cudaVersion == 11) { - libraryPath = $"runtimes/linux-x64/native/libllama-cuda11{avxFlag}.so"; + libraryPath = $"runtimes/linux-x64/libllama-cuda11{avxFlag}.so"; } else if (cudaVersion == 12) { - libraryPath = $"runtimes/linux-x64/native/libllama-cuda12{avxFlag}.so"; + libraryPath = $"runtimes/linux-x64/libllama-cuda12{avxFlag}.so"; } else if (cudaVersion == -1) // cpu version { - libraryPath = $"runtimes/linux-x64/native/libllama{avxFlag}.so"; + libraryPath = $"runtimes/linux-x64/libllama{avxFlag}.so"; } else { @@ -151,11 +151,11 @@ private static IntPtr LLamaImportResolver(string name, Assembly assembly, DllImp { if (System.Runtime.Intrinsics.Arm.ArmBase.Arm64.IsSupported) { - libraryPath = $"runtimes/osx-arm64/native/libllama.dylib"; + libraryPath = $"runtimes/osx-arm64/libllama.dylib"; } else { - libraryPath = $"runtimes/osx-x64/native/libllama.dylib"; + libraryPath = $"runtimes/osx-x86_64/libllama.dylib"; } } diff --git a/LLama/runtimes/libllama-cuda11.so b/LLama/runtimes/linux-x64/libllama-cuda11.so similarity index 100% rename from LLama/runtimes/libllama-cuda11.so rename to LLama/runtimes/linux-x64/libllama-cuda11.so diff --git a/LLama/runtimes/libllama-cuda12.so b/LLama/runtimes/linux-x64/libllama-cuda12.so similarity index 100% rename from LLama/runtimes/libllama-cuda12.so rename to LLama/runtimes/linux-x64/libllama-cuda12.so diff --git a/LLama/runtimes/libllama.so b/LLama/runtimes/linux-x64/libllama.so similarity index 100% rename from LLama/runtimes/libllama.so rename to LLama/runtimes/linux-x64/libllama.so diff --git a/LLama/runtimes/macos-arm64/ggml-metal.metal b/LLama/runtimes/osx-arm64/ggml-metal.metal similarity index 100% rename from LLama/runtimes/macos-arm64/ggml-metal.metal rename to LLama/runtimes/osx-arm64/ggml-metal.metal diff --git a/LLama/runtimes/macos-arm64/libllama.dylib b/LLama/runtimes/osx-arm64/libllama.dylib similarity index 100% rename from LLama/runtimes/macos-arm64/libllama.dylib rename to LLama/runtimes/osx-arm64/libllama.dylib diff --git a/LLama/runtimes/macos-x86_64/libllama.dylib b/LLama/runtimes/osx-x64/libllama.dylib similarity index 100% rename from LLama/runtimes/macos-x86_64/libllama.dylib rename to LLama/runtimes/osx-x64/libllama.dylib diff --git a/LLama/runtimes/libllama-cuda11.dll b/LLama/runtimes/win-x64/libllama-cuda11.dll similarity index 100% rename from LLama/runtimes/libllama-cuda11.dll rename to LLama/runtimes/win-x64/libllama-cuda11.dll diff --git a/LLama/runtimes/libllama-cuda12.dll b/LLama/runtimes/win-x64/libllama-cuda12.dll similarity index 100% rename from LLama/runtimes/libllama-cuda12.dll rename to LLama/runtimes/win-x64/libllama-cuda12.dll diff --git a/LLama/runtimes/libllama.dll b/LLama/runtimes/win-x64/libllama.dll similarity index 100% rename from LLama/runtimes/libllama.dll rename to LLama/runtimes/win-x64/libllama.dll From 200011e186f5a91ad337e65577b215eea6095074 Mon Sep 17 00:00:00 2001 From: SignalRT Date: Thu, 9 Nov 2023 22:12:58 +0100 Subject: [PATCH 14/18] Revert "Merge feat: add detection template for cuda and avx. #268" This reverts commit b4b3ea9d994bbfdb61b57d2f194c8816e469646e. --- LLama/LLamaSharp.Runtime.targets | 36 +++++++++--------- LLama/Native/NativeApi.cs | 16 ++++---- .../{win-x64 => }/libllama-cuda11.dll | Bin .../{linux-x64 => }/libllama-cuda11.so | Bin .../{win-x64 => }/libllama-cuda12.dll | Bin .../{linux-x64 => }/libllama-cuda12.so | Bin LLama/runtimes/{win-x64 => }/libllama.dll | Bin LLama/runtimes/{linux-x64 => }/libllama.so | Bin .../ggml-metal.metal | 0 .../{osx-arm64 => macos-arm64}/libllama.dylib | Bin .../{osx-x64 => macos-x86_64}/libllama.dylib | Bin 11 files changed, 26 insertions(+), 26 deletions(-) rename LLama/runtimes/{win-x64 => }/libllama-cuda11.dll (100%) rename LLama/runtimes/{linux-x64 => }/libllama-cuda11.so (100%) rename LLama/runtimes/{win-x64 => }/libllama-cuda12.dll (100%) rename LLama/runtimes/{linux-x64 => }/libllama-cuda12.so (100%) rename LLama/runtimes/{win-x64 => }/libllama.dll (100%) rename LLama/runtimes/{linux-x64 => }/libllama.so (100%) rename LLama/runtimes/{osx-arm64 => macos-arm64}/ggml-metal.metal (100%) rename LLama/runtimes/{osx-arm64 => macos-arm64}/libllama.dylib (100%) rename LLama/runtimes/{osx-x64 => macos-x86_64}/libllama.dylib (100%) diff --git a/LLama/LLamaSharp.Runtime.targets b/LLama/LLamaSharp.Runtime.targets index 12ce224db..bc9a69110 100644 --- a/LLama/LLamaSharp.Runtime.targets +++ b/LLama/LLamaSharp.Runtime.targets @@ -3,41 +3,41 @@ true - + PreserveNewest - runtimes/win-x64/libllama.dll + libllama.dll - + PreserveNewest - runtimes/win-x64/libllama-cuda11.dll + libllama-cuda11.dll - + PreserveNewest - runtimes/win-x64/libllama-cuda12.dll + libllama-cuda12.dll - + PreserveNewest - runtimes/linux-x64/libllama.so + libllama.so - + PreserveNewest - runtimes/linux-x64/libllama-cuda11.so + libllama-cuda11.so - + PreserveNewest - runtimes/linux-x64/libllama-cuda12.so + libllama-cuda12.so - + PreserveNewest - runtimes/osx-arm64/libllama.dylib + runtimes/macos-arm64/libllama.dylib - + PreserveNewest - runtimes/osx-arm64/ggml-metal.metal + runtimes/macos-arm64/ggml-metal.metal - + PreserveNewest - runtimes/osx-x64/libllama.dylib + runtimes/macos-x86_64/libllama.dylib \ No newline at end of file diff --git a/LLama/Native/NativeApi.cs b/LLama/Native/NativeApi.cs index b3a264359..9998020ef 100644 --- a/LLama/Native/NativeApi.cs +++ b/LLama/Native/NativeApi.cs @@ -110,15 +110,15 @@ private static IntPtr LLamaImportResolver(string name, Assembly assembly, DllImp var cudaVersion = GetCudaVersion(); if(cudaVersion == 11) { - libraryPath = $"runtimes/win-x64/libllama-cuda11{avxFlag}.dll"; + libraryPath = $"runtimes/win-x64/native/libllama-cuda11{avxFlag}.dll"; } else if (cudaVersion == 12) { - libraryPath = $"runtimes/win-x64/libllama-cuda12{avxFlag}.dll"; + libraryPath = $"runtimes/win-x64/native/libllama-cuda12{avxFlag}.dll"; } else if(cudaVersion == -1) // cpu version { - libraryPath = $"runtimes/win-x64/libllama{avxFlag}.dll"; + libraryPath = $"runtimes/win-x64/native/libllama{avxFlag}.dll"; } else { @@ -132,15 +132,15 @@ private static IntPtr LLamaImportResolver(string name, Assembly assembly, DllImp var cudaVersion = GetCudaVersion(); if (cudaVersion == 11) { - libraryPath = $"runtimes/linux-x64/libllama-cuda11{avxFlag}.so"; + libraryPath = $"runtimes/linux-x64/native/libllama-cuda11{avxFlag}.so"; } else if (cudaVersion == 12) { - libraryPath = $"runtimes/linux-x64/libllama-cuda12{avxFlag}.so"; + libraryPath = $"runtimes/linux-x64/native/libllama-cuda12{avxFlag}.so"; } else if (cudaVersion == -1) // cpu version { - libraryPath = $"runtimes/linux-x64/libllama{avxFlag}.so"; + libraryPath = $"runtimes/linux-x64/native/libllama{avxFlag}.so"; } else { @@ -151,11 +151,11 @@ private static IntPtr LLamaImportResolver(string name, Assembly assembly, DllImp { if (System.Runtime.Intrinsics.Arm.ArmBase.Arm64.IsSupported) { - libraryPath = $"runtimes/osx-arm64/libllama.dylib"; + libraryPath = $"runtimes/osx-arm64/native/libllama.dylib"; } else { - libraryPath = $"runtimes/osx-x86_64/libllama.dylib"; + libraryPath = $"runtimes/osx-x64/native/libllama.dylib"; } } diff --git a/LLama/runtimes/win-x64/libllama-cuda11.dll b/LLama/runtimes/libllama-cuda11.dll similarity index 100% rename from LLama/runtimes/win-x64/libllama-cuda11.dll rename to LLama/runtimes/libllama-cuda11.dll diff --git a/LLama/runtimes/linux-x64/libllama-cuda11.so b/LLama/runtimes/libllama-cuda11.so similarity index 100% rename from LLama/runtimes/linux-x64/libllama-cuda11.so rename to LLama/runtimes/libllama-cuda11.so diff --git a/LLama/runtimes/win-x64/libllama-cuda12.dll b/LLama/runtimes/libllama-cuda12.dll similarity index 100% rename from LLama/runtimes/win-x64/libllama-cuda12.dll rename to LLama/runtimes/libllama-cuda12.dll diff --git a/LLama/runtimes/linux-x64/libllama-cuda12.so b/LLama/runtimes/libllama-cuda12.so similarity index 100% rename from LLama/runtimes/linux-x64/libllama-cuda12.so rename to LLama/runtimes/libllama-cuda12.so diff --git a/LLama/runtimes/win-x64/libllama.dll b/LLama/runtimes/libllama.dll similarity index 100% rename from LLama/runtimes/win-x64/libllama.dll rename to LLama/runtimes/libllama.dll diff --git a/LLama/runtimes/linux-x64/libllama.so b/LLama/runtimes/libllama.so similarity index 100% rename from LLama/runtimes/linux-x64/libllama.so rename to LLama/runtimes/libllama.so diff --git a/LLama/runtimes/osx-arm64/ggml-metal.metal b/LLama/runtimes/macos-arm64/ggml-metal.metal similarity index 100% rename from LLama/runtimes/osx-arm64/ggml-metal.metal rename to LLama/runtimes/macos-arm64/ggml-metal.metal diff --git a/LLama/runtimes/osx-arm64/libllama.dylib b/LLama/runtimes/macos-arm64/libllama.dylib similarity index 100% rename from LLama/runtimes/osx-arm64/libllama.dylib rename to LLama/runtimes/macos-arm64/libllama.dylib diff --git a/LLama/runtimes/osx-x64/libllama.dylib b/LLama/runtimes/macos-x86_64/libllama.dylib similarity index 100% rename from LLama/runtimes/osx-x64/libllama.dylib rename to LLama/runtimes/macos-x86_64/libllama.dylib From 5fe721bdbee2000a82a0e0b8b120c9ec37f31106 Mon Sep 17 00:00:00 2001 From: SignalRT Date: Thu, 9 Nov 2023 22:13:18 +0100 Subject: [PATCH 15/18] Revert "Merge branch 'pr/268' into RuntimeDetection" This reverts commit 091b8d58b3502a99b3bfbec9db457c92cc736beb, reversing changes made to 9b2ca9cf8ea6de844d74568c7c92e73ec816fd14. --- LLama.Examples/LLama.Examples.csproj | 1 - LLama.Examples/NewVersion/GetEmbeddings.cs | 3 +- LLama.Examples/NewVersion/QuantizeModel.cs | 4 +- LLama.Examples/NewVersion/TestRunner.cs | 135 +++++++++++----- LLama.Web/Common/ModelOptions.cs | 4 +- LLama/Abstractions/IContextParams.cs | 4 +- LLama/Common/FixedSizeQueue.cs | 2 +- LLama/Common/ModelParams.cs | 101 ++++++++---- LLama/Extensions/DictionaryExtensions.cs | 2 - LLama/Extensions/EncodingExtensions.cs | 2 - LLama/Extensions/IContextParamsExtensions.cs | 2 +- LLama/Extensions/IEnumerableExtensions.cs | 2 - LLama/Extensions/KeyValuePairExtensions.cs | 2 - LLama/Extensions/ListExtensions.cs | 2 +- LLama/LLamaSharp.csproj | 1 - LLama/Native/LLamaContextParams.cs | 2 +- LLama/Native/NativeApi.cs | 157 +++++-------------- README.md | 2 +- 18 files changed, 218 insertions(+), 210 deletions(-) diff --git a/LLama.Examples/LLama.Examples.csproj b/LLama.Examples/LLama.Examples.csproj index dcd40c19a..3ecacdfe3 100644 --- a/LLama.Examples/LLama.Examples.csproj +++ b/LLama.Examples/LLama.Examples.csproj @@ -30,7 +30,6 @@ - diff --git a/LLama.Examples/NewVersion/GetEmbeddings.cs b/LLama.Examples/NewVersion/GetEmbeddings.cs index 1e5b19be3..fe9e3ea80 100644 --- a/LLama.Examples/NewVersion/GetEmbeddings.cs +++ b/LLama.Examples/NewVersion/GetEmbeddings.cs @@ -4,7 +4,7 @@ namespace LLama.Examples.NewVersion { public class GetEmbeddings { - public static Task Run() + public static void Run() { Console.Write("Please input your model path: "); var modelPath = Console.ReadLine(); @@ -23,7 +23,6 @@ public static Task Run() Console.WriteLine(string.Join(", ", embedder.GetEmbeddings(text))); Console.WriteLine(); } - return Task.CompletedTask; } } } diff --git a/LLama.Examples/NewVersion/QuantizeModel.cs b/LLama.Examples/NewVersion/QuantizeModel.cs index 456d89290..71966af8f 100644 --- a/LLama.Examples/NewVersion/QuantizeModel.cs +++ b/LLama.Examples/NewVersion/QuantizeModel.cs @@ -2,7 +2,7 @@ { public class QuantizeModel { - public static Task Run() + public static void Run() { Console.Write("Please input your original model path: "); var inputPath = Console.ReadLine(); @@ -21,8 +21,6 @@ public static Task Run() { Console.WriteLine("Quantization failed!"); } - - return Task.CompletedTask; } } } diff --git a/LLama.Examples/NewVersion/TestRunner.cs b/LLama.Examples/NewVersion/TestRunner.cs index c89cba305..a21a2eed4 100644 --- a/LLama.Examples/NewVersion/TestRunner.cs +++ b/LLama.Examples/NewVersion/TestRunner.cs @@ -1,54 +1,109 @@ -using System.Linq.Expressions; -using Spectre.Console; - -namespace LLama.Examples.NewVersion +namespace LLama.Examples.NewVersion { public class NewVersionTestRunner { - static Dictionary> Examples = new Dictionary> - { - {"Run a chat session without stripping the role names.", () => ChatSessionWithRoleName.Run()}, - {"Run a chat session with the role names stripped.",()=> ChatSessionStripRoleName.Run()}, - {"Interactive mode chat by using executor.",()=> InteractiveModeExecute.Run()}, - {"Instruct mode chat by using executor.",()=> InstructModeExecute.Run()}, - {"Stateless mode chat by using executor.",()=> StatelessModeExecute.Run()}, - {"Load and save chat session.",()=> SaveAndLoadSession.Run()}, - {"Load and save state of model and executor.",()=> LoadAndSaveState.Run()}, - {"Get embeddings from LLama model.",()=> GetEmbeddings.Run()}, - {"Quantize the model.",()=> QuantizeModel.Run()}, - {"Automatic conversation.",()=> TalkToYourself.Run()}, - {"Constrain response to json format using grammar.",()=> GrammarJsonResponse.Run()}, - {"Semantic Kernel Prompt.",()=> SemanticKernelPrompt.Run()}, - {"Semantic Kernel Chat.",()=> SemanticKernelChat.Run()}, - {"Semantic Kernel Memory.",()=> SemanticKernelMemory.Run()}, - {"Coding Assistant.",()=> CodingAssistant.Run()}, - {"Batch Decoding.",()=> BatchedDecoding.Run()}, - {"SK Kernel Memory.",()=> KernelMemory.Run()}, - {"Exit", ()=> Task.CompletedTask} - }; public static async Task Run() { - AnsiConsole.Write(new Rule("LLamaSharp Examples")); + Console.WriteLine("================LLamaSharp Examples (New Version)==================\n"); + + Console.WriteLine("Please input a number to choose an example to run:"); + Console.WriteLine("0: Run a chat session without stripping the role names."); + Console.WriteLine("1: Run a chat session with the role names stripped."); + Console.WriteLine("2: Interactive mode chat by using executor."); + Console.WriteLine("3: Instruct mode chat by using executor."); + Console.WriteLine("4: Stateless mode chat by using executor."); + Console.WriteLine("5: Load and save chat session."); + Console.WriteLine("6: Load and save state of model and executor."); + Console.WriteLine("7: Get embeddings from LLama model."); + Console.WriteLine("8: Quantize the model."); + Console.WriteLine("9: Automatic conversation."); + Console.WriteLine("10: Constrain response to json format using grammar."); + Console.WriteLine("11: Semantic Kernel Prompt."); + Console.WriteLine("12: Semantic Kernel Chat."); + Console.WriteLine("13: Semantic Kernel Memory."); + Console.WriteLine("14: Coding Assistant."); + Console.WriteLine("15: Batch Decoding."); + Console.WriteLine("16: SK Kernel Memory."); while (true) { - var choice = AnsiConsole.Prompt( - new SelectionPrompt() - .Title("Please choose[green] an example[/] to run: ") - .AddChoices(Examples.Keys)); + Console.Write("\nYour choice: "); + int choice = int.Parse(Console.ReadLine()); - - if (Examples.TryGetValue(choice, out var example)) + if (choice == 0) { - if (choice == "Exit") - { - break; - } - AnsiConsole.Write(new Rule(choice)); - await example(); + await ChatSessionWithRoleName.Run(); } - - AnsiConsole.Clear(); + else if (choice == 1) + { + await ChatSessionStripRoleName.Run(); + } + else if (choice == 2) + { + await InteractiveModeExecute.Run(); + } + else if (choice == 3) + { + await InstructModeExecute.Run(); + } + else if (choice == 4) + { + await StatelessModeExecute.Run(); + } + else if (choice == 5) + { + await SaveAndLoadSession.Run(); + } + else if (choice == 6) + { + await LoadAndSaveState.Run(); + } + else if (choice == 7) + { + GetEmbeddings.Run(); + } + else if (choice == 8) + { + QuantizeModel.Run(); + } + else if (choice == 9) + { + await TalkToYourself.Run(); + } + else if (choice == 10) + { + await GrammarJsonResponse.Run(); + } + else if (choice == 11) + { + await SemanticKernelPrompt.Run(); + } + else if (choice == 12) + { + await SemanticKernelChat.Run(); + } + else if (choice == 13) + { + await SemanticKernelMemory.Run(); + } + else if (choice == 14) + { + await CodingAssistant.Run(); + } + else if (choice == 15) + { + await BatchedDecoding.Run(); + } + else if (choice == 16) + { + await KernelMemory.Run(); + } + else + { + Console.WriteLine("Cannot parse your choice. Please select again."); + continue; + } + break; } } } diff --git a/LLama.Web/Common/ModelOptions.cs b/LLama.Web/Common/ModelOptions.cs index 8cbf2f091..6a63ccc31 100644 --- a/LLama.Web/Common/ModelOptions.cs +++ b/LLama.Web/Common/ModelOptions.cs @@ -17,9 +17,9 @@ public class ModelOptions public int MaxInstances { get; set; } /// - /// Model context size (n_ctx). Null to use value from model. + /// Model context size (n_ctx) /// - public uint? ContextSize { get; set; } + public uint ContextSize { get; set; } = 512; /// /// the GPU that is used for scratch and small tensors diff --git a/LLama/Abstractions/IContextParams.cs b/LLama/Abstractions/IContextParams.cs index a2ac24f1a..8ff6d7ccf 100644 --- a/LLama/Abstractions/IContextParams.cs +++ b/LLama/Abstractions/IContextParams.cs @@ -8,9 +8,9 @@ namespace LLama.Abstractions; public interface IContextParams { /// - /// Model context size (n_ctx). Null to use value from model file. + /// Model context size (n_ctx) /// - uint? ContextSize { get; set; } + uint ContextSize { get; set; } /// /// batch size for prompt processing (must be >=32 to use BLAS) (n_batch) diff --git a/LLama/Common/FixedSizeQueue.cs b/LLama/Common/FixedSizeQueue.cs index 37fb1cf51..d4577a475 100644 --- a/LLama/Common/FixedSizeQueue.cs +++ b/LLama/Common/FixedSizeQueue.cs @@ -43,7 +43,7 @@ public FixedSizeQueue(int size) /// public FixedSizeQueue(int size, IEnumerable data) { -#if NET6_0_OR_GREATER +#if !NETSTANDARD2_0 // Try to check the size without enumerating the entire IEnumerable. This may not be able to get the count, // in which case we'll have to check later if (data.TryGetNonEnumeratedCount(out var dataCount) && dataCount > size) diff --git a/LLama/Common/ModelParams.cs b/LLama/Common/ModelParams.cs index 9561e482e..ee5bd3e4c 100644 --- a/LLama/Common/ModelParams.cs +++ b/LLama/Common/ModelParams.cs @@ -12,68 +12,105 @@ namespace LLama.Common public record ModelParams : ILLamaParams { - /// - public uint? ContextSize { get; set; } - - /// + /// + /// Model context size (n_ctx) + /// + public uint ContextSize { get; set; } = 512; + /// + /// the GPU that is used for scratch and small tensors + /// public int MainGpu { get; set; } = 0; - /// + /// + /// Number of layers to run in VRAM / GPU memory (n_gpu_layers) + /// public int GpuLayerCount { get; set; } = 20; - - /// + /// + /// Seed for the random number generator (seed) + /// public uint Seed { get; set; } = 0xFFFFFFFF; - - /// + /// + /// Use f16 instead of f32 for memory kv (memory_f16) + /// public bool UseFp16Memory { get; set; } = true; - - /// + /// + /// Use mmap for faster loads (use_mmap) + /// public bool UseMemorymap { get; set; } = true; - - /// + /// + /// Use mlock to keep model in memory (use_mlock) + /// public bool UseMemoryLock { get; set; } - - /// + /// + /// Compute perplexity over the prompt (perplexity) + /// public bool Perplexity { get; set; } - - /// + /// + /// Model path (model) + /// public string ModelPath { get; set; } - /// + /// + /// List of LoRAs to apply + /// public AdapterCollection LoraAdapters { get; set; } = new(); - /// + /// + /// base model path for the lora adapter (lora_base) + /// public string LoraBase { get; set; } = string.Empty; - /// + /// + /// Number of threads (null = autodetect) (n_threads) + /// public uint? Threads { get; set; } - /// + /// + /// Number of threads to use for batch processing (null = autodetect) (n_threads) + /// public uint? BatchThreads { get; set; } - /// + /// + /// batch size for prompt processing (must be >=32 to use BLAS) (n_batch) + /// public uint BatchSize { get; set; } = 512; - /// + /// + /// Whether to use embedding mode. (embedding) Note that if this is set to true, + /// The LLamaModel won't produce text response anymore. + /// public bool EmbeddingMode { get; set; } - /// + /// + /// how split tensors should be distributed across GPUs. + /// + /// "[ 3, 2 ]" will assign 60% of the data to GPU 0 and 40% to GPU 1. [JsonConverter(typeof(TensorSplitsCollectionConverter))] public TensorSplitsCollection TensorSplits { get; set; } = new(); - /// - public float? RopeFrequencyBase { get; set; } + /// + /// RoPE base frequency + /// + public float? RopeFrequencyBase { get; set; } - /// - public float? RopeFrequencyScale { get; set; } + /// + /// RoPE frequency scaling factor + /// + public float? RopeFrequencyScale { get; set; } - /// - public bool MulMatQ { get; set; } + /// + /// Use experimental mul_mat_q kernels + /// + public bool MulMatQ { get; set; } - /// + /// + /// Load vocab only (no weights) + /// public bool VocabOnly { get; set; } - /// + /// + /// The encoding to use to convert text for the model + /// [JsonConverter(typeof(EncodingConverter))] public Encoding Encoding { get; set; } = Encoding.UTF8; diff --git a/LLama/Extensions/DictionaryExtensions.cs b/LLama/Extensions/DictionaryExtensions.cs index 1af0e9e1f..a39ed7e8b 100644 --- a/LLama/Extensions/DictionaryExtensions.cs +++ b/LLama/Extensions/DictionaryExtensions.cs @@ -9,8 +9,6 @@ public static TValue GetValueOrDefault(this IReadOnlyDictionary(IReadOnlyDictionary dictionary, TKey key, TValue defaultValue) diff --git a/LLama/Extensions/EncodingExtensions.cs b/LLama/Extensions/EncodingExtensions.cs index 5005b16c1..e88d83a70 100644 --- a/LLama/Extensions/EncodingExtensions.cs +++ b/LLama/Extensions/EncodingExtensions.cs @@ -15,8 +15,6 @@ public static int GetCharCount(this Encoding encoding, ReadOnlySpan bytes) { return GetCharCountImpl(encoding, bytes); } -#elif !NET6_0_OR_GREATER && !NETSTANDARD2_1_OR_GREATER -#error Target framework not supported! #endif internal static int GetCharsImpl(Encoding encoding, ReadOnlySpan bytes, Span output) diff --git a/LLama/Extensions/IContextParamsExtensions.cs b/LLama/Extensions/IContextParamsExtensions.cs index ed59c9df0..fcc9d372a 100644 --- a/LLama/Extensions/IContextParamsExtensions.cs +++ b/LLama/Extensions/IContextParamsExtensions.cs @@ -21,7 +21,7 @@ public static class IContextParamsExtensions public static void ToLlamaContextParams(this IContextParams @params, out LLamaContextParams result) { result = NativeApi.llama_context_default_params(); - result.n_ctx = @params.ContextSize ?? 0; + result.n_ctx = @params.ContextSize; result.n_batch = @params.BatchSize; result.seed = @params.Seed; result.f16_kv = @params.UseFp16Memory; diff --git a/LLama/Extensions/IEnumerableExtensions.cs b/LLama/Extensions/IEnumerableExtensions.cs index 17428d297..9e01feb85 100644 --- a/LLama/Extensions/IEnumerableExtensions.cs +++ b/LLama/Extensions/IEnumerableExtensions.cs @@ -10,8 +10,6 @@ public static IEnumerable TakeLast(this IEnumerable source, int count) { return TakeLastImpl(source, count); } -#elif !NET6_0_OR_GREATER && !NETSTANDARD2_1_OR_GREATER -#error Target framework not supported! #endif internal static IEnumerable TakeLastImpl(IEnumerable source, int count) diff --git a/LLama/Extensions/KeyValuePairExtensions.cs b/LLama/Extensions/KeyValuePairExtensions.cs index 233195ed0..6e12654de 100644 --- a/LLama/Extensions/KeyValuePairExtensions.cs +++ b/LLama/Extensions/KeyValuePairExtensions.cs @@ -19,7 +19,5 @@ public static void Deconstruct(this System.Collections.Generic.Key first = pair.Key; second = pair.Value; } -#elif !NET6_0_OR_GREATER && !NETSTANDARD2_1_OR_GREATER -#error Target framework not supported! #endif } \ No newline at end of file diff --git a/LLama/Extensions/ListExtensions.cs b/LLama/Extensions/ListExtensions.cs index eb30a07a0..11a1d4f00 100644 --- a/LLama/Extensions/ListExtensions.cs +++ b/LLama/Extensions/ListExtensions.cs @@ -5,7 +5,7 @@ namespace LLama.Extensions { internal static class ListExtensions { -#if !NET6_0_OR_GREATER +#if NETSTANDARD2_0 public static void EnsureCapacity(this List list, int capacity) { if (list.Capacity < capacity) diff --git a/LLama/LLamaSharp.csproj b/LLama/LLamaSharp.csproj index 4577515b1..d525202f2 100644 --- a/LLama/LLamaSharp.csproj +++ b/LLama/LLamaSharp.csproj @@ -47,7 +47,6 @@ - diff --git a/LLama/Native/LLamaContextParams.cs b/LLama/Native/LLamaContextParams.cs index 9a0b2a8e5..0a397a3d4 100644 --- a/LLama/Native/LLamaContextParams.cs +++ b/LLama/Native/LLamaContextParams.cs @@ -22,7 +22,7 @@ public struct LLamaContextParams public uint seed; /// - /// text context, 0 = from model + /// text context /// public uint n_ctx; diff --git a/LLama/Native/NativeApi.cs b/LLama/Native/NativeApi.cs index 9998020ef..119a36fb8 100644 --- a/LLama/Native/NativeApi.cs +++ b/LLama/Native/NativeApi.cs @@ -1,13 +1,8 @@ using System; using System.Buffers; -using System.Reflection; using System.Runtime.InteropServices; using System.Text; using LLama.Exceptions; -using ManagedCuda; -#if NET6_0_OR_GREATER -using System.Runtime.Intrinsics.X86; -#endif #pragma warning disable IDE1006 // Naming Styles @@ -29,9 +24,8 @@ public unsafe partial class NativeApi { static NativeApi() { -#if NET6_0_OR_GREATER - NativeLibrary.SetDllImportResolver(typeof(NativeApi).Assembly, LLamaImportResolver); -#endif + // Try to load a preferred library, based on CPU feature detection + TryLoadLibrary(); try { @@ -50,120 +44,63 @@ static NativeApi() } /// - /// Get the cuda version if possible. + /// Try to load libllama, using CPU feature detection to try and load a more specialised DLL if possible /// - /// -1 for no cuda - private static int GetCudaVersion() + /// The library handle to unload later, or IntPtr.Zero if no library was loaded + private static IntPtr TryLoadLibrary() { - int deviceCount = CudaContext.GetDeviceCount(); - for (int deviceIndex = 0; deviceIndex < deviceCount; deviceIndex++) +#if NET6_0_OR_GREATER + + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { - using (CudaContext ctx = new CudaContext(deviceIndex)) - { - var version = ctx.GetAPIVersionOfCurrentContext(); - return version.Major; - } + // All of the Windows libraries, in order of preference + return TryLoad("cu12.1.0/libllama.dll") + ?? TryLoad("cu11.7.1/libllama.dll") +#if NET8_0_OR_GREATER + ?? TryLoad("avx512/libllama.dll", System.Runtime.Intrinsics.X86.Avx512.IsSupported) +#endif + ?? TryLoad("avx2/libllama.dll", System.Runtime.Intrinsics.X86.Avx2.IsSupported) + ?? TryLoad("avx/libllama.dll", System.Runtime.Intrinsics.X86.Avx.IsSupported) + ?? IntPtr.Zero; } - return -1; - } - /// - /// Get the xla flag for native library name. - /// - /// - private static string GetAvxFlag() - { - AvxLevel level = AvxLevel.None; -#if NET6_0_OR_GREATER - if (Avx.IsSupported) level = AvxLevel.Avx; - if (Avx2.IsSupported) level = AvxLevel.Avx2; + if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) + { + // All of the Linux libraries, in order of preference + return TryLoad("cu12.1.0/libllama.so") + ?? TryLoad("cu11.7.1/libllama.so") #if NET8_0_OR_GREATER - if(Avx512F.IsSupported) level = AvxLevel.Avx512; + ?? TryLoad("avx512/libllama.so", System.Runtime.Intrinsics.X86.Avx512.IsSupported) #endif + ?? TryLoad("avx2/libllama.so", System.Runtime.Intrinsics.X86.Avx2.IsSupported) + ?? TryLoad("avx/libllama.so", System.Runtime.Intrinsics.X86.Avx.IsSupported) + ?? IntPtr.Zero; + } - return level switch + if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { - AvxLevel.None => "", - AvxLevel.Avx => "-avx", - AvxLevel.Avx2 => "-avx2", - AvxLevel.Avx512 => "-avx512", - }; -#else - return string.Empty; + return TryLoad("runtimes/macos-arm64/libllama.dylib", System.Runtime.Intrinsics.Arm.ArmBase.Arm64.IsSupported) + ?? TryLoad("runtimes/macos-x86_64/libllama.dylib") + ?? IntPtr.Zero; + } #endif - } + + return IntPtr.Zero; #if NET6_0_OR_GREATER - private static IntPtr LLamaImportResolver(string name, Assembly assembly, DllImportSearchPath? searchPath) - { - IntPtr handle = IntPtr.Zero; - if(!name.Equals(libraryName)) + // Try to load a DLL from the path if supported. Returns null if nothing is loaded. + static IntPtr? TryLoad(string path, bool supported = true) { - return NativeLibrary.Load(name, assembly, searchPath); - } + if (!supported) + return null; - string libraryPath = string.Empty; - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) - { - var avxFlag = GetAvxFlag(); - // check cuda - var cudaVersion = GetCudaVersion(); - if(cudaVersion == 11) - { - libraryPath = $"runtimes/win-x64/native/libllama-cuda11{avxFlag}.dll"; - } - else if (cudaVersion == 12) - { - libraryPath = $"runtimes/win-x64/native/libllama-cuda12{avxFlag}.dll"; - } - else if(cudaVersion == -1) // cpu version - { - libraryPath = $"runtimes/win-x64/native/libllama{avxFlag}.dll"; - } - else - { - throw new NotImplementedException($"Cuda version {cudaVersion} has not been supported, please compile dll yourself or open an issue in LLamaSharp."); - } - } - else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) - { - var avxFlag = GetAvxFlag(); - // check cuda - var cudaVersion = GetCudaVersion(); - if (cudaVersion == 11) - { - libraryPath = $"runtimes/linux-x64/native/libllama-cuda11{avxFlag}.so"; - } - else if (cudaVersion == 12) - { - libraryPath = $"runtimes/linux-x64/native/libllama-cuda12{avxFlag}.so"; - } - else if (cudaVersion == -1) // cpu version - { - libraryPath = $"runtimes/linux-x64/native/libllama{avxFlag}.so"; - } - else - { - throw new NotImplementedException($"Cuda version {cudaVersion} has not been supported, please compile dll yourself or open an issue in LLamaSharp."); - } - } - else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) - { - if (System.Runtime.Intrinsics.Arm.ArmBase.Arm64.IsSupported) - { - libraryPath = $"runtimes/osx-arm64/native/libllama.dylib"; - } - else - { - libraryPath = $"runtimes/osx-x64/native/libllama.dylib"; - } - } + if (NativeLibrary.TryLoad(path, out var handle)) + return handle; - NativeLibrary.TryLoad(libraryPath, assembly, searchPath, out handle); - return handle; - } + return null; + } #endif - + } private const string libraryName = "libllama"; @@ -637,13 +574,5 @@ public static int llama_tokenize(SafeLLamaContextHandle ctx, string text, Encodi /// [DllImport(libraryName, CallingConvention = CallingConvention.Cdecl)] public static extern int llama_set_n_threads(SafeLLamaContextHandle ctx, uint n_threads, uint n_threads_batch); - - private enum AvxLevel - { - None = 0, - Avx = 1, - Avx2 = 2, - Avx512 = 3 - } } } diff --git a/README.md b/README.md index 397f641e5..ea72e8a40 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ **The C#/.NET binding of [llama.cpp](https://github.com/ggerganov/llama.cpp). It provides higher-level APIs to inference the LLaMA Models and deploy it on local device with C#/.NET. It works on -both Windows, Linux and MAC without requirment for compiling llama.cpp yourself. Even without GPU or not enough GPU memory, you can still apply LLaMA models well with this repo. 🤗** +both Windows, Linux and MAC without requirment for compiling llama.cpp yourself. Even without GPU or not enought GPU memory, you can still apply LLaMA models well with this repo. 🤗** **Furthermore, it provides integrations with other projects such as [semantic-kernel](https://github.com/microsoft/semantic-kernel), [kernel-memory](https://github.com/microsoft/kernel-memory) and [BotSharp](https://github.com/SciSharp/BotSharp) to provide higher-level applications.** From 6de8d6219a78d545988bc94831bad60a79b7b3a8 Mon Sep 17 00:00:00 2001 From: SignalRT Date: Sat, 11 Nov 2023 09:05:17 +0100 Subject: [PATCH 16/18] Change SemanticKernel version to beta1 on Examples --- LLama.Examples/LLama.Examples.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LLama.Examples/LLama.Examples.csproj b/LLama.Examples/LLama.Examples.csproj index 3ecacdfe3..c17618297 100644 --- a/LLama.Examples/LLama.Examples.csproj +++ b/LLama.Examples/LLama.Examples.csproj @@ -29,7 +29,7 @@ - + From 7691f8351614a6f6d915944f4be872dbc35fd76a Mon Sep 17 00:00:00 2001 From: SignalRT Date: Sat, 11 Nov 2023 13:12:07 +0100 Subject: [PATCH 17/18] Test build and nuget packages --- .github/prepare_release.sh | 8 +++++++- .github/workflows/compile.yml | 18 +++++++++--------- .github/workflows/main.yml | 6 +++--- LLama/LLamaSharp.Runtime.targets | 12 ++++++------ LLama/Native/NativeApi.cs | 4 ++-- .../build/LLamaSharp.Backend.Cpu.nuspec | 6 +++--- .../ggml-metal.metal | 0 .../{macos-arm64 => osx-arm64}/libllama.dylib | Bin .../{macos-x86_64 => osx-x64}/libllama.dylib | Bin 9 files changed, 30 insertions(+), 24 deletions(-) rename LLama/runtimes/{macos-arm64 => osx-arm64}/ggml-metal.metal (100%) rename LLama/runtimes/{macos-arm64 => osx-arm64}/libllama.dylib (100%) rename LLama/runtimes/{macos-x86_64 => osx-x64}/libllama.dylib (100%) diff --git a/.github/prepare_release.sh b/.github/prepare_release.sh index fd4427e8d..e44099978 100755 --- a/.github/prepare_release.sh +++ b/.github/prepare_release.sh @@ -22,13 +22,19 @@ fi mkdir ./temp; mkdir ./temp/runtimes; -cp ./LLama/runtimes/*.* ./temp/runtimes/; +# For sure it could be done better but cp -R did not work on osx +mkdir ./temp/runtimes/osx-arm64 +mkdir ./temp/runtimes/osx-x64 +cp ./LLama/runtimes/*.* ./temp/runtimes/; +cp ./LLama/runtimes/osx-arm64/*.* ./temp/runtimes/osx-arm64/; +cp ./LLama/runtimes/osx-x64/*.* ./temp/runtimes/osx-x64; cp ./LLama/runtimes/build/*.* ./temp/; # get the current version cd temp; dotnet add package LLamaSharp; version=$(dotnet list temp.csproj package | grep LLamaSharp); +# TODO: This didn´t work on osx...we need a solution read -ra arr <<< "$version" version="${arr[-1]}" echo "The latest version: $version"; diff --git a/.github/workflows/compile.yml b/.github/workflows/compile.yml index 42cb98dcd..5dda197cd 100644 --- a/.github/workflows/compile.yml +++ b/.github/workflows/compile.yml @@ -6,9 +6,9 @@ on: cublas: type: boolean description: Build CUBLAS binaries - macos: + osx: type: boolean - description: Build MacOS binaries + description: Build OSX binaries push: branches: [cron_job] #schedule: @@ -147,7 +147,7 @@ jobs: include: - build: 'arm64' defines: '-DCMAKE_OSX_ARCHITECTURES=arm64' - - build: 'x86_64' + - build: 'x64' defines: '-DLLAMA_METAL=OFF -DCMAKE_OSX_ARCHITECTURES=x86_64' runs-on: macos-latest steps: @@ -169,7 +169,7 @@ jobs: uses: actions/upload-artifact@v3 with: path: ./build/libllama.dylib - name: llama-bin-macos-${{ matrix.build }}.dylib + name: llama-bin-osx-${{ matrix.build }}.dylib - name: Upload Metal uses: actions/upload-artifact@v3 with: @@ -212,12 +212,12 @@ jobs: - name: Rearrange MacOS files if: ${{ github.event.inputs.macos }} run: | - mkdir deps/macos-arm64 - mkdir deps/macos-x86_64 + mkdir deps/osx-arm64 + mkdir deps/osx-x64 - cp artifacts/llama-bin-macos-arm64.dylib/libllama.dylib deps/macos-arm64/libllama.dylib - cp artifacts/ggml-metal.metal/ggml-metal.metal deps/macos-arm64/ggml-metal.metal - cp artifacts/llama-bin-macos-x86_64.dylib/libllama.dylib deps/macos-x86_64/libllama.dylib + cp artifacts/llama-bin-osx-arm64.dylib/libllama.dylib deps/osx-arm64/libllama.dylib + cp artifacts/ggml-metal.metal/ggml-metal.metal deps/osx-arm64/ggml-metal.metal + cp artifacts/llama-bin-osx-x64.dylib/libllama.dylib deps/osx-x64/libllama.dylib - name: Rearrange CUDA files diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index db051001d..0d958e0d4 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -12,13 +12,13 @@ jobs: strategy: fail-fast: false matrix: - build: [linux-release, windows-release, macos-release] + build: [linux-release, windows-release, osx-release] include: - build: linux-release os: ubuntu-latest config: release - - build: macos-release - os: macos-latest + - build: osx-release + os: osx-latest config: release - build: windows-release os: windows-2019 diff --git a/LLama/LLamaSharp.Runtime.targets b/LLama/LLamaSharp.Runtime.targets index bc9a69110..c14f0ffab 100644 --- a/LLama/LLamaSharp.Runtime.targets +++ b/LLama/LLamaSharp.Runtime.targets @@ -27,17 +27,17 @@ PreserveNewest libllama-cuda12.so - + PreserveNewest - runtimes/macos-arm64/libllama.dylib + runtimes/osx-arm64/libllama.dylib - + PreserveNewest - runtimes/macos-arm64/ggml-metal.metal + runtimes/osx-arm64/ggml-metal.metal - + PreserveNewest - runtimes/macos-x86_64/libllama.dylib + runtimes/osx-x64/libllama.dylib \ No newline at end of file diff --git a/LLama/Native/NativeApi.cs b/LLama/Native/NativeApi.cs index 119a36fb8..fc4086783 100644 --- a/LLama/Native/NativeApi.cs +++ b/LLama/Native/NativeApi.cs @@ -79,8 +79,8 @@ private static IntPtr TryLoadLibrary() if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { - return TryLoad("runtimes/macos-arm64/libllama.dylib", System.Runtime.Intrinsics.Arm.ArmBase.Arm64.IsSupported) - ?? TryLoad("runtimes/macos-x86_64/libllama.dylib") + return TryLoad("runtimes/osx-arm64/libllama.dylib", System.Runtime.Intrinsics.Arm.ArmBase.Arm64.IsSupported) + ?? TryLoad("runtimes/osx-x64/libllama.dylib") ?? IntPtr.Zero; } #endif diff --git a/LLama/runtimes/build/LLamaSharp.Backend.Cpu.nuspec b/LLama/runtimes/build/LLamaSharp.Backend.Cpu.nuspec index 5664be894..29466a1fe 100644 --- a/LLama/runtimes/build/LLamaSharp.Backend.Cpu.nuspec +++ b/LLama/runtimes/build/LLamaSharp.Backend.Cpu.nuspec @@ -19,9 +19,9 @@ - - - + + + diff --git a/LLama/runtimes/macos-arm64/ggml-metal.metal b/LLama/runtimes/osx-arm64/ggml-metal.metal similarity index 100% rename from LLama/runtimes/macos-arm64/ggml-metal.metal rename to LLama/runtimes/osx-arm64/ggml-metal.metal diff --git a/LLama/runtimes/macos-arm64/libllama.dylib b/LLama/runtimes/osx-arm64/libllama.dylib similarity index 100% rename from LLama/runtimes/macos-arm64/libllama.dylib rename to LLama/runtimes/osx-arm64/libllama.dylib diff --git a/LLama/runtimes/macos-x86_64/libllama.dylib b/LLama/runtimes/osx-x64/libllama.dylib similarity index 100% rename from LLama/runtimes/macos-x86_64/libllama.dylib rename to LLama/runtimes/osx-x64/libllama.dylib From 0a2b0abb618392cc194afde01347619ee346b573 Mon Sep 17 00:00:00 2001 From: SignalRT Date: Sun, 12 Nov 2023 00:27:53 +0100 Subject: [PATCH 18/18] Correct improper rename --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 0d958e0d4..eb0e936f1 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -18,7 +18,7 @@ jobs: os: ubuntu-latest config: release - build: osx-release - os: osx-latest + os: macos-latest config: release - build: windows-release os: windows-2019