RandyMcMillan

#![allow(unexpected_cfgs)]
#![allow(deprecated)]

// --- SECTION 1: NIGHTLY (no_std + Allocator) ---
#[cfg(nightly)]
mod nightly_impl {
    #![feature(alloc_error_handler)]
    #![no_std]
    #![no_main]

RandyMcMillan

use std::fs::OpenOptions;
use std::os::unix::io::AsRawFd;
use std::time::Instant;
use sha2::{Sha256, Digest};
use libc::{ioctl, c_int};

// Linux ioctl structure for entropy injection
#[repr(C)]
struct RandPoolInfo {
    entropy_count: c_int, // Bits of entropy (not bytes)

RandyMcMillan

#![allow(deprecated)]

use serde::{Serialize, Deserialize};
use serde_json;
use sha2::{Sha256, Digest};
use rand_0_8_5::{thread_rng as rng_legacy, Rng as RngLegacy};
use rand_0_9_2::{thread_rng as rng_latest, Rng as RngLatest};
use chrono::Local;

#[derive(Serialize, Deserialize, Debug)]

RandyMcMillan

use chrono::{DateTime, Duration, Utc};

#[derive(Debug, Clone, Copy)]
pub struct Estimation {
    pub d: f64, // Difference in seconds
    pub a: f64, // Uncertainty
}

pub fn estimate_offset(s: DateTime<Utc>, r: DateTime<Utc>, c: DateTime<Utc>) -> Estimation {
    // d = c - (r + s) / 2

RandyMcMillan

use std::time::Instant;

#[derive(Debug, Clone, Copy)]
pub struct Estimation {
    pub d: f64, 
    pub a: f64, 
}

pub fn estimate_offset(s: f64, r: f64, c: f64) -> Estimation {
    Estimation {

RandyMcMillan

use nalgebra::{DMatrix, DVector};
// Import the Rng trait so that .gen() is available on thread_rng()
use rand_0_8_5::Rng; 

/// 1. Computes standard Softmax Attention Y
fn compute_softmax_attention(q: &DMatrix<f64>, k: &DMatrix<f64>, v: &DMatrix<f64>) -> DMatrix<f64> {
    let mut scores = q * k.transpose();

    for i in 0..scores.nrows() {
        let mut row = scores.row_mut(i);

RandyMcMillan

fn main() {
    
    let mut nonces = vec![0u128];
    let mut counter = 0u64;
    nonces.pop();
    // First Gap: 1.5 x 10^9 to 2.0 x 10^9
    //counter += (2.0e9 - 1.5e9) as u64;
    for nonce in 1_500/*_000_000*/..=3_000/*_000_000*/ {
      nonces.push(nonce*1_000_000);
      counter = counter+1;

RandyMcMillan

use sha2::{Digest, Sha256};
use std::collections::HashSet;
use rand_0_8_5/*_0_9_2*/::{RngCore, thread_rng};

/// For a 256-bit security level, we need 256 pairs of preimages (512 total).
const BITS: usize = 256;

/// The Private Key: Two lists (Secret-0 and Secret-1).
struct PrivateKey {
    pairs: [[[u8; 32]; BITS]; 2],

RandyMcMillan

var spawn = require('child_process').spawn;

// spawn_detached(file, [args = []], [options = {}], [callback]);
function spawn_detached(file, args, options, callback) {
  if (arguments.length == 2 &&
      typeof args == 'function') {
    callback = arguments[1];
    args = undefined;
  }

RandyMcMillan

"""
The most atomic way to train and inference a GPT in pure, dependency-free Python.
This file is the complete algorithm.
Everything else is just efficiency.

@karpathy
"""

import os       # os.path.exists
import math     # math.log, math.exp