Yoplitein

use std::io::{self, Read, Write};

use num_traits::{FromBytes, ToBytes};

trait ReadPrimitive {
	fn read_le_primitive<Prim: FromBytes>(&mut self) -> io::Result<Prim>
	where
		Prim::Bytes: Default;
	fn read_be_primitive<Prim: FromBytes>(&mut self) -> io::Result<Prim>
	where

Yoplitein

#![allow(non_snake_case)]

use std::io::{Cursor, Error, Result, Write};

macro_rules! write_val {
	($writer:expr, $val:expr, $bigEndian:expr) => {{
		let bytes = if $bigEndian {
			$val.to_be_bytes()
		} else {
			$val.to_le_bytes()

Yoplitein

edition = "2021"

binop_separator = "Back"
condense_wildcard_suffixes = true
format_strings = true
group_imports = "StdExternalCrate"
hard_tabs = true
hex_literal_case = "Upper"
imports_granularity = "Module"
imports_layout = "HorizontalVertical"

Yoplitein

from urllib import request
import argparse
import io
import json
import os
import sys
import time
import urllib
import urllib.parse
import zipfile

Yoplitein

#![feature(return_position_impl_trait_in_trait)]

trait ComposableOnce<From, To>: FnOnce(From) -> To {
    fn compose_once<Final>(self, rhs: impl FnOnce(To) -> Final) -> impl FnOnce(From) -> Final;
}

impl<From, To, Func: FnOnce(From) -> To> ComposableOnce<From, To> for Func {
    fn compose_once<Final>(self, rhs: impl FnOnce(To) -> Final) -> impl FnOnce(From) -> Final {
        move |v| rhs(self(v))
    }

Yoplitein

#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct VarInt(u128);

macro_rules! conversions {
	($($ty:ty => $unsigned:ty, $signed:expr);*;) => {$(
		impl From<$ty> for VarInt {
			fn from(v: $ty) -> Self {
				let raw = if $signed {
					// rotate sign bit to front, and flip value bits if negative
					// this encodes small absolute values in the fewest bytes possible

Yoplitein

#[derive(Clone, Debug)]
pub struct SurrogateString(String);

impl SurrogateString {
	unsafe fn inner(&self) -> &String {
		&self.0
	}
	
	unsafe fn inner_mut(&mut self) -> &mut String {
		&mut self.0

Yoplitein

auto builder(T)(T inst = T.init)
{
    enum isClass = is(T == class);
    static assert(is(T == struct) || isClass, "builder!T can only build structs and classes");
    
    static if(isClass)
        if(inst is null) inst = new T;
    
    static struct Builder
    {

Yoplitein

struct RingBuffer(T, size_t _capacity)
{
	import core.lifetime: move;
	
	private
	{
		T[capacity] buffer;
		size_t read;
		size_t write;
		size_t len; // keep it simple :^)

Yoplitein

use std::sync::atomic::{AtomicUsize, Ordering};
use std::alloc;

#[global_allocator]
static COUNTING_ALLOC: CountingAlloc = CountingAlloc::new();

struct CountingAlloc {
    used: AtomicUsize,
}