Eric Scrivner etscrivner

## rpc_doctest.cpp
#include <iostream>
#include <string>
#include <vector>

class RPCArgument {
public:
  RPCArgument(const std::string& name,
              const std::string& type,
              const std::string& description,
              bool required=false,

## benchmark.sh
#!/usr/bin/env ksh
#
# Benchmark Project Euler 1 programs by running them through same datsets
# several times and computing the average.
#
Values=(1000 10000 100000 1000000 10000000)
echo "${Values[@]}"

Programs=("./c_euler_1" "./haskell_euler_1")

## main.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "result.h"
#include "number_list.h"
#include "population_statistics.h"

eResult read_numbers(NumberList *number_list)

## super_method_propagation.rb
class Parent
  def try_me(confirmed_only: true)
    confirmed_only
  end
end

class Child < Parent
  def try_me(confirmed_only: true)
    # Ruby will proxy the value of `confirmed_only` up to the super method invocation for you.
    super

## base58checkencode.go
package main
import (
	"bytes"
	"crypto/sha256"
	"golang.org/x/crypto/ripemd160"
	"fmt"
	"math/big"
)

const Base58Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

## signal_v_noise.rb
require 'csv'

def percent_support_tickets(time)
  1.0 - ((time + 5) / 200.0)
end

seed = Random.new_seed
prng = Random.new(seed)

puts "Seed: #{seed}"

## EIP150ReplaySafeSplit.sol
pragma solidity ^0.4.2;

contract EIP150ReplaySafeSplit {
    // Fork oracle for EIP-150 fork
    AmIOnEIP150Fork amIOnEIP150Fork = AmIOnEIP150Fork(/* To be deployed */);
    // Fork oracle for ETH/ETC fork
    AmIOnTheFork amIOnDAOFork = AmIOnTheFork(0x2bd2326c993dfaef84f696526064ff22eba5b362);

    // This routine provides a way to route funds across Ethereum chain forks. It preserves
    // the signature of split method from DAO hard-fork replay split contract. If the current

## AmIOnEIP150Fork.sol
pragma solidity ^0.4.2;

contract AmIOnEIP150Fork {
    // Tracks whether or not hard fork is effective on this chain.
    bool public forked = false;
    // Event emitted on updates during fork window to indicate status.
    event ForkedStatus(bool forked);

    // This function should be called between block X and Y.
    function update() {

## EIP150ForkConstant.sol
pragma solidity ^0.4.2;

contract EIP150ForkConstant {
    // Used to determine gas constant
    event GasConstant(uint first, uint second, uint third);
    event OnFork(bool forked);

    // This function should be called between block X and Y.
    function run() {
        uint beforeGas = 0;

## keybase.md

      
        
          
            
              
              1 file
            
          
          
            
              
              0 forks
            
          
          
            
              
              0 comments
            
          
          
            
              
              0 stars
            
          
        
        
          
              
          
          
            
                etscrivner
                / keybase.md
            
            
              Created
              September 13, 2016 15:30
            
          
        
      
        
  
      
    Keybase proof

I hereby claim:

I am etscrivner on github.
I am escrivner (https://keybase.io/escrivner) on keybase.
I have a public key whose fingerprint is 74A8 F331 A8B7 C5D8 0879  52B4 5A2E 7AA7 837C C233

To claim this, I am signing this object:
	#include <iostream>
	#include <string>
	#include <vector>

	class RPCArgument {
	public:
	RPCArgument(const std::string& name,
	const std::string& type,
	const std::string& description,
	bool required=false,
	#!/usr/bin/env ksh
	#
	# Benchmark Project Euler 1 programs by running them through same datsets
	# several times and computing the average.
	#
	Values=(1000 10000 100000 1000000 10000000)
	echo "${Values[@]}"

	Programs=("./c_euler_1" "./haskell_euler_1")
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <ctype.h>

	#include "result.h"
	#include "number_list.h"
	#include "population_statistics.h"

	eResult read_numbers(NumberList *number_list)
	class Parent
	def try_me(confirmed_only: true)
	confirmed_only
	end
	end

	class Child < Parent
	def try_me(confirmed_only: true)
	# Ruby will proxy the value of `confirmed_only` up to the super method invocation for you.
	super
	package main
	import (
	"bytes"
	"crypto/sha256"
	"golang.org/x/crypto/ripemd160"
	"fmt"
	"math/big"
	)

	const Base58Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
	require 'csv'

	def percent_support_tickets(time)
	1.0 - ((time + 5) / 200.0)
	end

	seed = Random.new_seed
	prng = Random.new(seed)

	puts "Seed: #{seed}"
	pragma solidity ^0.4.2;

	contract EIP150ReplaySafeSplit {
	// Fork oracle for EIP-150 fork
	AmIOnEIP150Fork amIOnEIP150Fork = AmIOnEIP150Fork(/* To be deployed */);
	// Fork oracle for ETH/ETC fork
	AmIOnTheFork amIOnDAOFork = AmIOnTheFork(0x2bd2326c993dfaef84f696526064ff22eba5b362);

	// This routine provides a way to route funds across Ethereum chain forks. It preserves
	// the signature of split method from DAO hard-fork replay split contract. If the current
	pragma solidity ^0.4.2;

	contract AmIOnEIP150Fork {
	// Tracks whether or not hard fork is effective on this chain.
	bool public forked = false;
	// Event emitted on updates during fork window to indicate status.
	event ForkedStatus(bool forked);

	// This function should be called between block X and Y.
	function update() {
	pragma solidity ^0.4.2;

	contract EIP150ForkConstant {
	// Used to determine gas constant
	event GasConstant(uint first, uint second, uint third);
	event OnFork(bool forked);

	// This function should be called between block X and Y.
	function run() {
	uint beforeGas = 0;