Earlz

using System;
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace Earlz.Exxx
{
    class MainClass
    {
        public static void Main(string[] args)

Earlz

using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace Base58ReverseEncoder
{

Earlz

using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace Base58ReverseEncoder
{

Earlz

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512

This is a list of unspendable addresses with which to burn coins to. When you send a coin to any of these addresses, they are permanently gone and can never be redeemed. 

You can prove this by sending a small test amount to the address and then checking a block explorer or using `getrawtransaction txid 1`. You should see the coins output to somehting like `"raw_scriptPubKey": "76a914000000000000000000000000000000000000000088ac"` Some block explorers are also smart enough to indicate in their user interface that the coins were destroyed. 

You can find the version number matching to the desired altcoin by checking two places in the code:

chainparams.cpp for bitcoin 0.9 and later based coins:

Earlz

//a program I made to troll my high school with back around 2008
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <winioctl.h>



DWORD WINAPI bah(unsigned int t){
    //MessageBox(NULL,"hi3","bah",0);

Earlz

use std::io;
use std::io::File;
use std::os;
use std::str;

fn main() {
  println!("meh");
  let filename=&os::args()[1];
  let contents: String = match File::open(&Path::new(filename)).read_to_end() {
  	Ok(s) => str::from_utf8(s.as_slice()).expect("this shouldn't happen").to_string(),

Earlz

typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
typedef unsigned char uint8_t;
typedef unsigned int size_t;
//#include <stdint.h>

// copy-paste some library functions until we get a basic libc working
void* memcpy(void* restrict dstptr, const void* restrict srcptr, size_t size) {

Earlz

foo

bar

1. foo
2. bar
3. baz
4. biz

Testing 123 code

Earlz

//compiles to 740 bytes using -O0, 384 bytes using -Os
//both targeting i386 and with freestanding GCC compiler

typedef unsigned int size_t;




void interpret(volatile char* s, int s_size, volatile char* input, volatile char* output){
    int i=0;

Earlz

//compiles to 2820 bytes unoptimized, 1524 optimized
//using remix version "soljson-v0.4.18+commit.9cf6e910.js"

pragma solidity ^0.4.15;

contract BrainFucker{
    function interpret(bytes s, bytes1[128] input) public returns (bytes1[128] output) {
        uint256 ptr=0;
        uint256 i=0;
        uint256 right = s.length;