/*!
[config]
name: Vector load private half2,3,4,8,16
clc_version_min: 11

dimensions: 1
global_size: 1 0 0
require_device_extensions: cl_khr_fp16
[test]
name: vector load private half2
kernel_name: vload2_private
arg_in:  0 buffer half[3] 0 28 46
arg_out: 1 buffer half2[2] 0 28 28 46

[test]
name: vector load private offset half2
kernel_name: vload2_private_offset
arg_in:  0 buffer half[5] 0 0 0 28 46
arg_out: 1 buffer half2[2] 0 28 28 46

[test]
name: vector load private half3
kernel_name: vload3_private
arg_in:  0 buffer half[4] 0 121 66 189
arg_out: 1 buffer half3[2] 0 121 66 121 66 189

[test]
name: vector load private offset half3
kernel_name: vload3_private_offset
arg_in:  0 buffer half[7] 0 0 0 0 121 66 189
arg_out: 1 buffer half3[2] 0 121 66 121 66 189

[test]
name: vector load private half4
kernel_name: vload4_private
arg_in:  0 buffer half[5] 0 120 155 52 202
arg_out: 1 buffer half4[2] 0 120 155 52 120 155 52 202

[test]
name: vector load private offset half4
kernel_name: vload4_private_offset
arg_in:  0 buffer half[9] 0 0 0 0 0 120 155 52 202
arg_out: 1 buffer half4[2] 0 120 155 52 120 155 52 202

[test]
name: vector load private half8
kernel_name: vload8_private
arg_in:  0 buffer half[9] 0 116 189 192 64 98 22 43 70
arg_out: 1 buffer half8[2] 0 116 189 192 64 98 22 43 116 189 192 64 98 22 43 70

[test]
name: vector load private offset half8
kernel_name: vload8_private_offset
arg_in:  0 buffer half[17] 0 0 0 0 0 0 0 0 0 116 189 192 64 98 22 43 70
arg_out: 1 buffer half8[2] 0 116 189 192 64 98 22 43 116 189 192 64 98 22 43 70

[test]
name: vector load private half16
kernel_name: vload16_private
arg_in:  0 buffer half[17] 0 185 240 246 145 213 116 228 2 209 132 121 113 5 151 154 171
arg_out: 1 buffer half16[2] 0 185 240 246 145 213 116 228 2 209 132 121 113 5 151 154 185 240 246 145 213 116 228 2 209 132 121 113 5 151 154 171

[test]
name: vector load private offset half16
kernel_name: vload16_private_offset
arg_in:  0 buffer half[33] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 185 240 246 145 213 116 228 2 209 132 121 113 5 151 154 171
arg_out: 1 buffer half16[2] 0 185 240 246 145 213 116 228 2 209 132 121 113 5 151 154 185 240 246 145 213 116 228 2 209 132 121 113 5 151 154 171

!*/

#pragma OPENCL EXTENSION cl_khr_fp16: enable

kernel void vload2_private(global half *in,
                             global half2 *out) {
    volatile private short loc[3];
    for (int i = 0; i < 3; ++i)
        loc[i] = ((global short *)in)[i];

    out[0] = vload2(0, (private half*)loc);
    out[1] = vload2(0, (private half*)loc + 1);
}

kernel void vload2_private_offset(global half *in,
                                    global half2 *out) {
    volatile private short loc[5];
    for (int i = 0; i < 5; ++i)
        loc[i] = ((global short *)in)[i];

    out[0] = vload2(1, (private half*)loc);
    out[1] = vload2(1, (private half*)loc + 1);
}

kernel void vload3_private(global half *in,
                             global half3 *out) {
    volatile private short loc[4];
    for (int i = 0; i < 4; ++i)
        loc[i] = ((global short *)in)[i];

    out[0] = vload3(0, (private half*)loc);
    out[1] = vload3(0, (private half*)loc + 1);
}

kernel void vload3_private_offset(global half *in,
                                    global half3 *out) {
    volatile private short loc[8];
    for (int i = 0; i < 8; ++i)
        loc[i] = ((global short *)in)[i];

    out[0] = vload3(1, (private half*)loc);
    out[1] = vload3(1, (private half*)loc + 1);
}

kernel void vload4_private(global half *in,
                             global half4 *out) {
    volatile private short loc[5];
    for (int i = 0; i < 5; ++i)
        loc[i] = ((global short *)in)[i];

    out[0] = vload4(0, (private half*)loc);
    out[1] = vload4(0, (private half*)loc + 1);
}

kernel void vload4_private_offset(global half *in,
                                    global half4 *out) {
    volatile private short loc[9];
    for (int i = 0; i < 9; ++i)
        loc[i] = ((global short *)in)[i];

    out[0] = vload4(1, (private half*)loc);
    out[1] = vload4(1, (private half*)loc + 1);
}

kernel void vload8_private(global half *in,
                             global half8 *out) {
    volatile private short loc[9];
    for (int i = 0; i < 9; ++i)
        loc[i] = ((global short *)in)[i];

    out[0] = vload8(0, (private half*)loc);
    out[1] = vload8(0, (private half*)loc + 1);
}

kernel void vload8_private_offset(global half *in,
                                    global half8 *out) {
    volatile private short loc[17];
    for (int i = 0; i < 17; ++i)
        loc[i] = ((global short *)in)[i];

    out[0] = vload8(1, (private half*)loc);
    out[1] = vload8(1, (private half*)loc + 1);
}

kernel void vload16_private(global half *in,
                             global half16 *out) {
    volatile private short loc[17];
    for (int i = 0; i < 17; ++i)
        loc[i] = ((global short *)in)[i];

    out[0] = vload16(0, (private half*)loc);
    out[1] = vload16(0, (private half*)loc + 1);
}

kernel void vload16_private_offset(global half *in,
                                    global half16 *out) {
    volatile private short loc[33];
    for (int i = 0; i < 33; ++i)
        loc[i] = ((global short *)in)[i];

    out[0] = vload16(1, (private half*)loc);
    out[1] = vload16(1, (private half*)loc + 1);
}
