@str
def example():
  print hello

print example[1:4]

import datetime
import time
import threading

def g(f, y, all_legal_inputs_to_f):
  "returns x for y = f(x)"
  for x in all_legal_inputs_to_f:
    if y == f(x): 
      return x

import sys
print (sys.version) 
[x for x in [1]]
print x

def loop(g):
  x = None
  for x in g: pass
  return x
def fprint(*xs): 

// hypothetical C# async sequencing 

interface IAsyncEnumerable<out T>
{
  IAsyncEnumerator<out T> GetEnumerator(CancellationToken token);

// async iteration in JavaScript?

function SelectAsync(asyncGenerator, asyncProjection) {
  return function(cancellationToken) {
    return spawnSequence(function*(Yielder){

// C# async sequencing 

interface IAsyncEnumerable<out T>
{
  IAsyncEnumerator<out T> GetEnumerator();

// C#-ish, assuming IAsyncEnumerable

IAsyncEnumerable<int> f( IAsyncEnumerable<int> eg) {
  int i = 1;
  yield i++;

// promises/A only, not promises/A+

// extract :: w a -> a
// duplicate :: w a -> w (w a)
// extend :: (w a -> b) -> w a -> w b

// async fibonacci
function async_fib(x) { return spawn(function*() {
  throw new Task.Result(
    x < 2 ? x 

// async enumerables and observables

public IAsyncEnumerable<T> ae2ao(IAsyncObservable<T> source)
{
  return AsyncEnumerableEx.Create(async Yield => 

// async enumerables and observables

public IAsyncEnumerable<T> ae2ao(IAsyncObservable<T> source)
{
  return AsyncEnumerableEx.Create(async Yield => 

var dr = new DataReader(aStream)

function flow() {
  while (dr.UnconsumedBufferLength > 0) {
    console.log(dr.readString());

// this seems like a *Bad Idea*, but is probably *technically* valid

void* rmalloc(size_t sz) {
  void *pv;

// resumable functions and Rx

template <class T>
void ImperativeGenerator(
  function<task(Subject<T>&)> producer,

#include <iostream>
using namespace std;

template <class T>
class function {

# not_faster.py 

import time
a = [i % 256 for i in range(300000)]
sum = 0

# faster_maybe.py 

import time
a = [8 - (i % 17) for i in range(300000)]
sum = 0

# less_slow.py

import time
from random import shuffle
a = [i for i in range(300000)]

# slow.py

import time
from random import shuffle
a = [i for i in range(300000)]

# fast.py 

import time
a = [i for i in range(300000)]
sum = 0

#include <iostream>
#include <string>
using namespace std;

void doit(class Base*);

#include <iostream>
#include <string>
using namespace std;

class Base {

template <int n, int m>
struct trial_divide_composite
{
  enum { value = (n%m == 0) || trial_divide_composite<n, m-1>::value };
};

template <int n, int m>
struct trial_divide_composite
{
  enum { value = (n%m == 0) || trial_divide_composite<n, m-1>::value };
};

template <int n, int m>
struct trial_divide_composite
{
  enum { value = (n%m == 0) || trial_divide_composite<n, m-1>::value };
};

# 
# statemachine demo
#

$sprites = []

> function *adding() { for (;;) { yield ((yield null) + (yield null)); }}
undefined
> it = adding()
{}
> it.send(2)

#define _XOPEN_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <ucontext.h>

#define CGOTO(label) { _dispatch = (label); goto _dispatcher; }
#define BEGIN_CGOTO int _dispatch=-1; _dispatcher: switch (_dispatch) { case -1:;
#define END_CGOTO  }

int main() {

int f(int x)
{
    if (x == 0 || x == INT_MIN)
        return x;
    else

// here's a prototypical contravariant type.
abstract class OutStream<T> {
  write(T value);
}

def printx(*args):
  print args

def f():
  printx("f->", (yield 1))

def f():
  print "f->", (yield 1)
  print "f->", (yield 2)

g = f();

def arith2 (input):
  @memo_unyield
  def expr (Return, input):
    if (yield [0,1]):
      x = yield factor(input)

# compute pythagorean triples using nondeterministic choice
# skip ahead to the 'pythag' function

import time
c0 = time.clock()

import time
c0 = time.clock()
def unyield (fn):
  def replacement (*args):
    c = []

#
# cpexhaustivetopdown.py
#

#
# cpsimpletopdown.py
#

static Tuple<TimeSpan, long> PerfTest(Action<long /*iterations*/> unitUnderTest)
{
  long n = 100;
  var sw = new StopWatch();

static IEnumerable<T> Anonerator(
  Func<Func<T, Task>, Task> iteratorator
  )
{
    T current = default(T);

def def_struct(name, *fields):
    c = "class %s(object):\n" % name
    c+= "  def __init__(self" + ''.join(',%s'%f for f in fields) + "):\n"
    c+= (''.join(
        "    self.%s=%s\n"%(f,f) for f in fields) if fields else 

g = Grammar()
g['expr'] = g['addend'] & pRep(pLiteral('+') & g['addend'])
g['addend'] = g['factor'] & pRep(pLiteral('*') & g['factor'])
g['factor'] = g['number'] | g['parenthetic']
g['number'] = reduce(pOr, (pLiteral(c) for c in '0123456789'))

#include <time.h>
#include <sys/times.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdio.h>

#include <stdio.h>

int main()
{
  int a[2];

In[3]:= (* 
   grammars

  parse[g, input, succ, fail] => 
   succ [result, remainingInput]

/* simple tuples */
#define LISTSIZE(S) LISTSIZEx S
#define LISTSIZEx(...) LISTSIZExx(__VA_ARGS__, 5,4,3,2,1)
#define LISTSIZExx(a,b,c,d,e,N, ...) N

? #define A(X, Y) Y X
? #define B 1 ## 2 ## 3
? .singlestep  A(B, 2)
current:  [1 ## 2 ## 3] in A( _ , 2 )
? step

def rc4(key):
  i = j = 0
  while 1:
      i = (i + 1) % len(key)
      j = (j + key[i]) % len(key)

/* this really oughtn't work! */

#include <stdio.h>

char* slen_(char* s)

reverse = (lambda g: (lambda f: g(lambda *arg: f(f)(*arg))) (
           lambda f: g(lambda *arg: f(f)(*arg))))(
           lambda r: lambda s: s[-1] + r(s[:-1]) if len(s) > 0 else "")
print reverse("hello")

(require srfi/19)

(define (repeat fn n)
  (if (= n 1) 
    (fn)

#include <stdio.h>

#define NEXT goto **ip++
int main()
{

#include <stdio.h>

#define NEXT goto **ip++
int main()
{

userInput = '1'
print eval('x+1', { 'x': int(userInput)}, {}) 

(display (< 1 "1")) 

def evalit(s):
  print "%r => %r" %(s, eval(s, globals(), globals()))

evalit("0 == False")
evalit("type(0) == type(False)")

def evalit(s):
  print "%r => %r" %(s, eval(s, globals(), globals()))

print "consistent inequivalence:"
evalit("1 == '1'")

#include <stdio.h>

int main()
{
  *(int*)0;

#include <iostream>
#include <iomanip>
#include <sstream>
using namespace std;

using System;
using System.Runtime.InteropServices;
using System.Drawing;

namespace ConsoleApplication1

#include <stdio.h>

int main()
{
    int* p = malloc(sizeof(int));

#include <stdio.h>

int main()
{
    int* p = malloc(sizeof(int));

# simplified monadic packrat (almost CFG) parser
#  derived from parse6.py, added (lazy) backtracking   
#
#  parser :: str -> [ (value, str) ]
class lcons (object):

# simplified monadic (PEG) parser. no memoization, some backtracking.
#  parser :: str -> maybe (value, str)
def ret (value): 
    return lambda s: (value, s)

def main():
  print "now, take it for a spin"
  print "", to_seq([1,2,3]).to_list()
    

from parse import *
from test1 import timeit

def group(p):
  return p % (lambda v: ('group', v))

# first, some boilerplate
class Seq:
  def __init__(self, defer):
    self._defer = defer
  def force(self):

# first, some boilerplate
class Seq:
  def __init__(self, defer):
    self._defer = defer
  def force(self):

#include <iostream>

template <typename T> struct Base {
   void f(int) {
       std::cout << "Base<T>::f\n";

#include <iostream>

template <typename T> struct Base {
   void f(int) {
       std::cout << "Base<T>::f\n";

#include <iostream>
#include <iomanip>
using namespace std;

namespace n1 {

#include <iostream>
#include <iomanip>
#include <typeinfo>
using namespace std;

import operator 
print len(reduce(operator.add, (((),),((),))))

import random
import time


def analyzeCoin(coin, numSamples=1000):

    #include <iostream>
    #include <iomanip>
    using namespace std;

    template <class T>

#include <iostream>
#include <iomanip>
using namespace std;

struct S{

typedef int HRESULT ;
bool SUCCEEDED(HRESULT x){return(x)>=0;}
HRESULT f(){return 0;}
#define g f
#define h f

def e(x):
  return e(x-1) if x else 0
def e(x, e=e):
  return e(x-1) if x else 1

fact = lambda x: 1 if x<1 else x*fact(x-1)
print fact(20)

// in reference to http://hbfs.wordpress.com/2011/08/09/programming-challenge-luminance/
#include <iostream>
#include <iomanip>

using namespace std;

#! python

# digraph.txt used: http://jnicholl.org/Cryptanalysis/Data/DigramFrequencies.php
import math

;; QR card for scheme
;; (c) 2011 Aaron Lahman

;; r5rs load module
(load {filename-string})

;QR card for scheme

;r5rs load module
(load {filename-string})

;;
;; hello world plt-scheme servlet
;;

; mb.ss
;
; mandelbrot set

(define (1+ r)

    #include <iostream>
    using namespace std;

    void f() {
        throw 1;

def adds_dynamic_z_decorator(f):
  def replacement(*arg,**karg):
    # create a new 'z' binding in globals, saving previous
    if 'z' in globals():
      oldZ = (globals()['z'],)

/// answer to question on blog post
/// http://eli.thegreenplace.net/2008/12/22/an-rc-circuit-puzzle/
///
/// From the exercise, Eli said "But the current through the capacitor 
/// and resistor is the same current".  I'm not sure where you get this 

#include <type_traits>

using std::tr1::is_base_of;

// --- policy metaprogramming ---

function memoize(f)
  store = {}
  function anon(x)
    if store[x] then
      return store[x]

function memoize(f)
  store = {}
  function anon(x)
    if store[x] then
      return store[x]

function memoize(f)
  store = {}
  function anon(x)
    if store[x] then
      return store[x]

struct to_listoftuples
{
    template <class OuterContainerType>
    static PyObject* convert(OuterContainerType const& a)

#include <iostream>
#include <vector>
#include <iterator>
using namespace std;
template <class It>

#include <string>
#include <iostream>
#include <iomanip>
using namespace std;

#include <iostream>
#include <iomanip>
#include <set>
#include <algorithm>
#include <iterator>

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <iterator>

#include <iostream>
#include <iomanip>
#include <iterator>
#include <list>
using namespace std;

#include <iostream>
#include <iomanip>
#include <iterator>
#include <vector>
using namespace std;

#include <iostream>
#include <iomanip>
#include <map>

// memoizer.  

#include <iostream>
using namespace std;
template <int I, bool Fizz = !(I % 3), bool Buzz = !(I % 5)> struct number {};
template <int I> void fizzbuzz(number<I, false, false>){ cout << I << "\n"; }
template <int I> void fizzbuzz(number<I, true, false>){ cout << "Fizz\n"; }