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"; }