hashbrowncipher

#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <time.h>
#include <unistd.h>
#include <sys/resource.h>

hashbrowncipher

@contextmanager
def atomic_temporary_file(destination, *, mode="w+b", flags=0, **kwargs):
    fd = os.open(destination.parent, os.O_TMPFILE | os.O_RDWR | flags)
    with io.open(fd, mode, **kwargs) as fh: 
        yield fh
        os.link("/proc/self/fd/{}".format(fd), str(destination), src_dir_fd=0)

hashbrowncipher

from fractions import Fraction as f


def factors_of_two(n):
    return n & ~(n - 1)


def _tokens_slice(count, zones):
    # We cannot have zones be a multiple of two and also have tokens with
    # equal spacing from each other.

hashbrowncipher

#!/usr/bin/fakeroot /bin/bash
set -o errexit
set -o nounset
set -o pipefail
OUTFILE=$2.squashfs
TMPDIR=$(mktemp -d -p .)

cleanup() {
  rm -fr $TMPDIR
}

hashbrowncipher

#!/bin/bash
set -x
set -o errexit
set -o nounset
set -o pipefail

function poweroff_before_panic {
  poweroff -f
}
trap poweroff_before_panic EXIT

hashbrowncipher

import java.io.IOException;
import java.lang.Runnable;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadFactory;

public class CGroupThreads {
	static class CGThread extends Thread {

hashbrowncipher

import dis
from itertools import chain
from types import CodeType


def _get_func_args(stack, count):
    return reversed([stack.pop() for i in range(count)])


def visit_func(stack, isn):

hashbrowncipher

#!/usr/bin/python3
"""
Copyright 2018 Josh Snyder

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

hashbrowncipher

#include <time.h>

int main() {
    struct timespec start;
    struct timespec end;
    clock_gettime(CLOCK_REALTIME, &start);
    for(int i = 0; i < 5000000; i++) {
        clock_gettime(CLOCK_REALTIME, &end);
    }
    printf("%lu %lu\n", end.tv_sec - start.tv_sec, end.tv_nsec - start.tv_nsec);

hashbrowncipher

#!/bin/bash

# As the "bufferbloat" folks have recently re-discovered and/or more widely
# publicized, congestion avoidance algorithms (such as those found in TCP) do
# a great job of allowing network endpoints to negotiate transfer rates that
# maximize a link's bandwidth usage without unduly penalizing any particular
# stream. This allows bulk transfer streams to use the maximum available
# bandwidth without affecting the latency of non-bulk (e.g. interactive)
# streams.