DutchGhost

#![feature(const_generics)]
#![feature(untagged_unions)]
#![feature(const_fn)]
#![feature(const_fn_union)]
#![feature(const_mut_refs)]
#![feature(const_if_match)]
#![feature(const_panic)]
#![feature(const_raw_ptr_deref)]

use std::mem::{self, ManuallyDrop, MaybeUninit};

DutchGhost

mod simd {
    use core::arch::x86_64::{
        __m128i, _mm_add_epi32, _mm_and_si128, _mm_cmpeq_epi32, _mm_mullo_epi32, _mm_set1_epi32,
        _mm_setzero_si128, _mm_sllv_epi32, _mm_srlv_epi32, _mm_sub_epi32, _mm_test_all_ones,
        _mm_xor_si128,
    };

    /// Maps from an array to its corresponding Simd type.
    pub unsafe trait SimdArray: Copy {
        type Lane: Copy;

DutchGhost

#![feature(const_trait_bound_opt_out)]
#![feature(const_fn)]
#![feature(const_trait_impl)]
#![feature(const_if_match)]
#![feature(const_loop)]
#![feature(const_mut_refs)]

trait CollatzTransform: Sized {
    fn transform(self) -> Option<Self>;
}

DutchGhost

use std::marker::PhantomData;
use std::slice;

pub fn chunks_exact<T>(slice: &[T], chunk_size: usize) -> ChunksExact<'_, T> {
    assert!(chunk_size != 0);
    let rem = slice.len() % chunk_size;
    let len = slice.len() - rem;
    let (fst, snd) = slice.split_at(len);

    let len = fst.len();

DutchGhost

const std = @import("std");
const testing = std.testing;
const meta = std.meta;

pub const Type = union(enum) {
    Character,
};

pub const Ammount = union(enum) {
    Infinite,

DutchGhost

const std = @import("std");
const testing = std.testing;
const meta = std.meta;

pub const Type = union(enum) {
    Character,
    Number,
    String,
};

DutchGhost

use {
    crate as this,
    this as me,
    me::self as i
};

DutchGhost

#![feature(untagged_unions)]

#![feature(const_generics, const_evaluatable_checked)]
#![allow(incomplete_features)]

use core::mem::ManuallyDrop;

struct Bool<const B: bool>;

trait True {}

DutchGhost

const Builder = @import("std").build.Builder;
const std = @import("std");
const cpu = @import("std").Target.arm;
pub fn build(b: *Builder) void {
    const mode = b.standardReleaseOptions();
    const lib = b.addStaticLibrary("krate", "src/main.zig");
    lib.setBuildMode(mode);
    lib.target = std.zig.CrossTarget{
        .cpu_arch = .thumb,
        .os_tag = .freestanding,

DutchGhost

#[inline(always)]
#[track_caller]
const unsafe fn unreachable() -> ! {
    #[derive(Copy, Clone)]
    enum Void {}

    const NEVER: *const Void = [].as_ptr();
    match *NEVER {}
}