Validark

const std = @import("std");
const builtin = @import("builtin");

const IntersectResult = extern struct { mask1: @Vector(16, bool), mask2: @Vector(16, bool) };
export fn vp2intersectd(a: @Vector(16, i32), b: @Vector(16, i32)) IntersectResult {
    return struct {
        extern fn @"llvm.x86.avx512.vp2intersect.d.512"(@Vector(16, i32), @Vector(16, i32)) callconv(.{ .x86_64_vectorcall = .{} }) IntersectResult;
    }.@"llvm.x86.avx512.vp2intersect.d.512"(a, b);
}

Validark

const std = @import("std");

fn carryless_multiply_x86(a: @Vector(8, u8), b: @Vector(16, u8)) @Vector(8, u8) {
    return @as([2]@Vector(8, u8), @bitCast(struct {
        extern fn @"llvm.x86.pclmulqdq"(@Vector(2, u64), @Vector(2, u64), i8) @Vector(2, u64);
    }.@"llvm.x86.pclmulqdq"(
        @bitCast(std.simd.join(a, @as(@Vector(8, u8), undefined))),
        @bitCast(b), 0)))[0];
}

Validark

curl https://webinstall.dev/ollama
source ~/.config/envman/PATH.env
ollama serve

ollama run deepseek-coder-v2

Validark

const std = @import("std");
const builtin = @import("builtin");
const assert = std.debug.assert;

const has_native_carryless_multiply = switch (builtin.cpu.arch) {
    .x86_64 => std.Target.x86.featureSetHas(builtin.cpu.features, .pclmul),
    .aarch64 => std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes),
    .riscv64 => std.Target.riscv.featureSetHas(builtin.cpu.features, .zbc),
    //.sparc64 => std.Target.sparc.featureSetHas(builtin.cpu.features, .vis3),
    else => false,

Validark

fn tbl4(
    table_part_1: @Vector(16, u8),
    table_part_2: @Vector(16, u8),
    table_part_3: @Vector(16, u8),
    table_part_4: @Vector(16, u8),
    indices: @Vector(8, u8)
) @TypeOf(indices) {
    return struct {
        extern fn @"llvm.aarch64.neon.tbl4"(@TypeOf(table_part_1), @TypeOf(table_part_2), @TypeOf(table_part_3), @TypeOf(table_part_4), @TypeOf(indices)) @TypeOf(indices);
    }.@"llvm.aarch64.neon.tbl4"(table_part_1, table_part_2, table_part_3, table_part_4, indices);

Validark

const std = @import("std");

fn cmtst(a: anytype, comptime b: @TypeOf(a)) @TypeOf(a) {
    return @select(u8, (a & b) != @as(@TypeOf(a), @splat(0)), @as(@TypeOf(a), @splat(0xff)), @as(@TypeOf(a), @splat(0)));
}

fn unmovemask(x: u64) @Vector(64, u8) {
    const vec = @as(@Vector(8, u8), @bitCast(x));
    const interlaced_vec = std.simd.interlace(.{ vec, vec });

Validark

export fn st4(vec: @Vector(64, u8), ptr: [*]u8) void {
    const chunks: [4]@Vector(16, u8) = @bitCast(vec);
    return struct {
        extern fn @"llvm.aarch64.neon.st4.v16i8.p0"(
            @Vector(16, u8),
            @Vector(16, u8),
            @Vector(16, u8),
            @Vector(16, u8),
            [*]u8
        ) void;

Validark

"use strict";

// Adapted from
//   github.com/dashpay/dash/tree/develop/src/governance/common.cpp

// USAGE
//   node ./gobject-hash-debugger.js

var GObj = module.exports;

Validark

export fn cls(e: u64) @TypeOf(e) {
    const e2: @TypeOf(e) = @bitCast(@as(std.meta.Int(.signed, @bitSizeOf(@TypeOf(e))), @bitCast(e)) >> (@bitSizeOf(@TypeOf(e)) - 1));
    return @clz(((e ^ e2) << 1) | 1);
}

Validark

/*
Language: Zig
Author: fwx <[email protected]>
*/

export const zigLanguageSupport = (hljs) => {
  const LITERALS = ["true", "false", "null", "undefined"];
  const BUILT_INS = [
    "@This",
    "@import",