
// -*- rust -*-

fn checktrue(bool res) -> bool {
  check(res);
  ret true;
}

fn main() {
  auto k = checktrue;
  evenk(42, k);
  oddk(45, k);
}

fn evenk(int n, fn(bool) -> bool k) -> bool {
  log "evenk";
  log n;
  if (n == 0) {
    be k(true);
  }
  else {
    be oddk(n - 1, k);
  }
}

fn oddk(int n, fn(bool) -> bool k) -> bool {
  log "oddk";
  log n;
  if (n == 0) {
    be k(false);
  }
  else {
    be evenk(n - 1, k);
  }
}


// -*- rust -*-

fn checktrue(bool res) -> bool {
  assert (res);
  ret true;
}

fn main() {
  auto k = checktrue;
  evenk(42, k);
  oddk(45, k);
}

fn evenk(int n, fn(bool) -> bool k) -> bool {
  log "evenk";
  log n;
  if (n == 0) {
    be k(true);
  }
  else {
    be oddk(n - 1, k);
  }
}

fn oddk(int n, fn(bool) -> bool k) -> bool {
  log "oddk";
  log n;
  if (n == 0) {
    be k(false);
  }
  else {
    be evenk(n - 1, k);
  }
}


// -*- rust -*-

fn checktrue(bool res) -> bool {
  check(res);
  ret true;
}

fn main() {
  auto k = checktrue;
  evenk(42, k);
  oddk(45, k);
}

fn evenk(int n, fn(bool) -> bool k) -> bool {
  log "evenk";
  log n;
  if (n == 0) {
    be k(true);
  }
  else {
    be oddk(n - 1, k);
  }
}

fn oddk(int n, fn(bool) -> bool k) -> bool {
  log "oddk";
  log n;
  if (n == 0) {
    be k(false);
  }
  else {
    be evenk(n - 1, k);
  }
}


// -*- rust -*-

fn checktrue(bool res) -> bool {
  assert (res);
  ret true;
}

fn main() {
  auto k = checktrue;
  evenk(42, k);
  oddk(45, k);
}

fn evenk(int n, fn(bool) -> bool k) -> bool {
  log "evenk";
  log n;
  if (n == 0) {
    be k(true);
  }
  else {
    be oddk(n - 1, k);
  }
}

fn oddk(int n, fn(bool) -> bool k) -> bool {
  log "oddk";
  log n;
  if (n == 0) {
    be k(false);
  }
  else {
    be evenk(n - 1, k);
  }
}


// -*- rust -*-
fn checktrue(bool res) -> bool { assert (res); ret true; }

fn main() { auto k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(int n, fn(bool) -> bool  k) -> bool {
    log "evenk";
    log n;
    if (n == 0) { be k(true); } else { be oddk(n - 1, k); }
}

fn oddk(int n, fn(bool) -> bool  k) -> bool {
    log "oddk";
    log n;
    if (n == 0) { be k(false); } else { be evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(bool rs) -> bool { assert (rs); ret true; }

fn main() { auto k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(int n, fn(bool) -> bool  k) -> bool {
    log "evenk";
    log n;
    if (n == 0) { be k(true); } else { be oddk(n - 1, k); }
}

fn oddk(int n, fn(bool) -> bool  k) -> bool {
    log "oddk";
    log n;
    if (n == 0) { be k(false); } else { be evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); ret true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: fn(bool) -> bool ) -> bool {
    log "evenk";
    log n;
    if n == 0 { be k(true); } else { be oddk(n - 1, k); }
}

fn oddk(n: int, k: fn(bool) -> bool ) -> bool {
    log "oddk";
    log n;
    if n == 0 { be k(false); } else { be evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); ret true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: fn(bool) -> bool) -> bool {
    log "evenk";
    log n;
    if n == 0 { be k(true); } else { be oddk(n - 1, k); }
}

fn oddk(n: int, k: fn(bool) -> bool) -> bool {
    log "oddk";
    log n;
    if n == 0 { be k(false); } else { be evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); ret true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: fn(bool) -> bool) -> bool {
    #debug("evenk");
    log_full(core::debug, n);
    if n == 0 { be k(true); } else { be oddk(n - 1, k); }
}

fn oddk(n: int, k: fn(bool) -> bool) -> bool {
    #debug("oddk");
    log_full(core::debug, n);
    if n == 0 { be k(false); } else { be evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); ret true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: fn(bool) -> bool) -> bool {
    #debug("evenk");
    log(debug, n);
    if n == 0 { be k(true); } else { be oddk(n - 1, k); }
}

fn oddk(n: int, k: fn(bool) -> bool) -> bool {
    #debug("oddk");
    log(debug, n);
    if n == 0 { be k(false); } else { be evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); ret true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: native fn(bool) -> bool) -> bool {
    #debug("evenk");
    log(debug, n);
    if n == 0 { be k(true); } else { be oddk(n - 1, k); }
}

fn oddk(n: int, k: native fn(bool) -> bool) -> bool {
    #debug("oddk");
    log(debug, n);
    if n == 0 { be k(false); } else { be evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); ret true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: native fn(bool) -> bool) -> bool {
    #debug("evenk");
    log(debug, n);
    if n == 0 { ret k(true); } else { ret oddk(n - 1, k); }
}

fn oddk(n: int, k: native fn(bool) -> bool) -> bool {
    #debug("oddk");
    log(debug, n);
    if n == 0 { ret k(false); } else { ret evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); ret true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    #debug("evenk");
    log(debug, n);
    if n == 0 { ret k(true); } else { ret oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    #debug("oddk");
    log(debug, n);
    if n == 0 { ret k(false); } else { ret evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); ret true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!{"evenk"};
    log(debug, n);
    if n == 0 { ret k(true); } else { ret oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!{"oddk"};
    log(debug, n);
    if n == 0 { ret k(false); } else { ret evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); return true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!{"evenk"};
    log(debug, n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!{"oddk"};
    log(debug, n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); return true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("evenk");
    log(debug, n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("oddk");
    log(debug, n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); return true; }

fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("evenk");
    log(debug, n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("oddk");
    log(debug, n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("evenk");
    log(debug, n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("oddk");
    log(debug, n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




// -*- rust -*-
fn checktrue(rs: bool) -> bool { fail_unless!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("evenk");
    log(debug, n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("oddk");
    log(debug, n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




// -*- rust -*-
fn checktrue(rs: bool) -> bool { fail_unless!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("evenk");
    debug!(n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("oddk");
    debug!(n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("evenk");
    debug!(n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    debug!("oddk");
    debug!(n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    info!("evenk");
    info!(n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    info!("oddk");
    info!(n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    info2!("evenk");
    info2!("{:?}", n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    info2!("oddk");
    info2!("{:?}", n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    info!("evenk");
    info!("{:?}", n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    info!("oddk");
    info!("{:?}", n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
    info!("evenk");
    info!("{:?}", n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: extern fn(bool) -> bool) -> bool {
    info!("oddk");
    info!("{:?}", n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: fn(bool) -> bool) -> bool {
    info!("evenk");
    info!("{:?}", n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: fn(bool) -> bool) -> bool {
    info!("oddk");
    info!("{:?}", n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.




fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: fn(bool) -> bool) -> bool {
    println!("evenk");
    println!("{:?}", n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: fn(bool) -> bool) -> bool {
    println!("oddk");
    println!("{:?}", n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

extern crate debug;

fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: fn(bool) -> bool) -> bool {
    println!("evenk");
    println!("{:?}", n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: fn(bool) -> bool) -> bool {
    println!("oddk");
    println!("{:?}", n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: int, k: fn(bool) -> bool) -> bool {
    println!("evenk");
    println!("{}", n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: int, k: fn(bool) -> bool) -> bool {
    println!("oddk");
    println!("{}", n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}


// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }

pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }

fn evenk(n: isize, k: fn(bool) -> bool) -> bool {
    println!("evenk");
    println!("{}", n);
    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}

fn oddk(n: isize, k: fn(bool) -> bool) -> bool {
    println!("oddk");
    println!("{}", n);
    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
}