
// -*- rust -*-

fn f(int x) -> int {
  // log "in f:";
  log x;
  if (x == 1) {
    // log "bottoming out";
    ret 1;
  } else {
    // log "recurring";
    let int y = x * f(x-1);
    // log "returned";
    log y;
    ret y;
  }
}
fn main () {
  check (f(5) == 120);
  // log "all done";
}


// -*- rust -*-

fn f(int x) -> int {
  // log "in f:";
  log x;
  if (x == 1) {
    // log "bottoming out";
    ret 1;
  } else {
    // log "recurring";
    let int y = x * f(x-1);
    // log "returned";
    log y;
    ret y;
  }
}
fn main () {
  assert (f(5) == 120);
  // log "all done";
}


// -*- rust -*-

fn f(int x) -> int {
  // log "in f:";
  log x;
  if (x == 1) {
    // log "bottoming out";
    ret 1;
  } else {
    // log "recurring";
    let int y = x * f(x-1);
    // log "returned";
    log y;
    ret y;
  }
}
fn main () {
  check (f(5) == 120);
  // log "all done";
}


// -*- rust -*-

fn f(int x) -> int {
  // log "in f:";
  log x;
  if (x == 1) {
    // log "bottoming out";
    ret 1;
  } else {
    // log "recurring";
    let int y = x * f(x-1);
    // log "returned";
    log y;
    ret y;
  }
}
fn main () {
  assert (f(5) == 120);
  // log "all done";
}


// -*- rust -*-
fn f(int x) -> int {
    // log "in f:";

    log x;
    if (x == 1) {
        // log "bottoming out";

        ret 1;
    } else {
        // log "recurring";

        let int y = x * f(x - 1);
        // log "returned";

        log y;
        ret y;
    }
}

fn main() {
    assert (f(5) == 120);
    // log "all done";

}


// -*- rust -*-
fn f(x: int) -> int {
    // log "in f:";

    log x;
    if x == 1 {
        // log "bottoming out";

        ret 1;
    } else {
        // log "recurring";

        let y: int = x * f(x - 1);
        // log "returned";

        log y;
        ret y;
    }
}

fn main() {
    assert (f(5) == 120);
    // log "all done";

}


// -*- rust -*-
fn f(x: int) -> int {
    // log "in f:";

    log x;
    if x == 1 {
        // log "bottoming out";

        ret 1;
    } else {
        // log "recurring";

        let y: int = x * f(x - 1);
        // log "returned";

        log y;
        ret y;
    }
}

fn main() {
    assert (f(5) == 120);
    // log "all done";

}


// -*- rust -*-
fn f(x: int) -> int {
    // #debug("in f:");

    log_full(core::debug, x);
    if x == 1 {
        // #debug("bottoming out");

        ret 1;
    } else {
        // #debug("recurring");

        let y: int = x * f(x - 1);
        // #debug("returned");

        log_full(core::debug, y);
        ret y;
    }
}

fn main() {
    assert (f(5) == 120);
    // #debug("all done");

}


// -*- rust -*-
fn f(x: int) -> int {
    // #debug("in f:");

    log(debug, x);
    if x == 1 {
        // #debug("bottoming out");

        ret 1;
    } else {
        // #debug("recurring");

        let y: int = x * f(x - 1);
        // #debug("returned");

        log(debug, y);
        ret y;
    }
}

fn main() {
    assert (f(5) == 120);
    // #debug("all done");

}


// -*- rust -*-
fn f(x: int) -> int {
    // debug!{"in f:"};

    log(debug, x);
    if x == 1 {
        // debug!{"bottoming out"};

        ret 1;
    } else {
        // debug!{"recurring"};

        let y: int = x * f(x - 1);
        // debug!{"returned"};

        log(debug, y);
        ret y;
    }
}

fn main() {
    assert (f(5) == 120);
    // debug!{"all done"};

}


// -*- rust -*-
fn f(x: int) -> int {
    // debug!{"in f:"};

    log(debug, x);
    if x == 1 {
        // debug!{"bottoming out"};

        return 1;
    } else {
        // debug!{"recurring"};

        let y: int = x * f(x - 1);
        // debug!{"returned"};

        log(debug, y);
        return y;
    }
}

fn main() {
    assert (f(5) == 120);
    // debug!{"all done"};

}


// -*- rust -*-
fn f(x: int) -> int {
    // debug!("in f:");

    log(debug, x);
    if x == 1 {
        // debug!("bottoming out");

        return 1;
    } else {
        // debug!("recurring");

        let y: int = x * f(x - 1);
        // debug!("returned");

        log(debug, y);
        return y;
    }
}

fn main() {
    assert (f(5) == 120);
    // debug!("all done");

}


// 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 f(x: int) -> int {
    // debug!("in f:");

    log(debug, x);
    if x == 1 {
        // debug!("bottoming out");

        return 1;
    } else {
        // debug!("recurring");

        let y: int = x * f(x - 1);
        // debug!("returned");

        log(debug, y);
        return y;
    }
}

fn main() {
    assert (f(5) == 120);
    // debug!("all done");

}


// 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 f(x: int) -> int {
    // debug!("in f:");

    log(debug, x);
    if x == 1 {
        // debug!("bottoming out");

        return 1;
    } else {
        // debug!("recurring");

        let y: int = x * f(x - 1);
        // debug!("returned");

        log(debug, y);
        return y;
    }
}

pub fn main() {
    assert (f(5) == 120);
    // debug!("all done");

}


// 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 f(x: int) -> int {
    // debug!("in f:");

    log(debug, x);
    if x == 1 {
        // debug!("bottoming out");

        return 1;
    } else {
        // debug!("recurring");

        let y: int = x * f(x - 1);
        // debug!("returned");

        log(debug, y);
        return y;
    }
}

pub fn main() {
    fail_unless!((f(5) == 120));
    // debug!("all done");

}


// 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 f(x: int) -> int {
    // debug!("in f:");

    debug!(x);
    if x == 1 {
        // debug!("bottoming out");

        return 1;
    } else {
        // debug!("recurring");

        let y: int = x * f(x - 1);
        // debug!("returned");

        debug!(y);
        return y;
    }
}

pub fn main() {
    fail_unless!((f(5) == 120));
    // debug!("all done");

}


// 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 f(x: int) -> int {
    // debug!("in f:");

    debug!(x);
    if x == 1 {
        // debug!("bottoming out");

        return 1;
    } else {
        // debug!("recurring");

        let y: int = x * f(x - 1);
        // debug!("returned");

        debug!(y);
        return y;
    }
}

pub fn main() {
    assert!((f(5) == 120));
    // debug!("all done");

}


// 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 f(x: int) -> int {
    // debug!("in f:");

    debug!(x);
    if x == 1 {
        // debug!("bottoming out");

        return 1;
    } else {
        // debug!("recurring");

        let y: int = x * f(x - 1);
        // debug!("returned");

        debug!(y);
        return y;
    }
}

pub fn main() {
    assert_eq!(f(5), 120);
    // debug!("all done");

}


// 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 f(x: int) -> int {
    // info!("in f:");

    info!(x);
    if x == 1 {
        // info!("bottoming out");

        return 1;
    } else {
        // info!("recurring");

        let y: int = x * f(x - 1);
        // info!("returned");

        info!(y);
        return y;
    }
}

pub fn main() {
    assert_eq!(f(5), 120);
    // info!("all done");

}


// 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 f(x: int) -> int {
    // info!("in f:");

    info2!("{}", x);
    if x == 1 {
        // info!("bottoming out");

        return 1;
    } else {
        // info!("recurring");

        let y: int = x * f(x - 1);
        // info!("returned");

        info2!("{}", y);
        return y;
    }
}

pub fn main() {
    assert_eq!(f(5), 120);
    // info!("all done");

}


// 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 f(x: int) -> int {
    // info!("in f:");

    info!("{}", x);
    if x == 1 {
        // info!("bottoming out");

        return 1;
    } else {
        // info!("recurring");

        let y: int = x * f(x - 1);
        // info!("returned");

        info!("{}", y);
        return y;
    }
}

pub fn main() {
    assert_eq!(f(5), 120);
    // info!("all done");

}


// 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 f(x: int) -> int {
    // info!("in f:");

    info!("{}", x);
    if x == 1 {
        // info!("bottoming out");

        return 1;
    } else {
        // info!("recurring");

        let y: int = x * f(x - 1);
        // info!("returned");

        info!("{}", y);
        return y;
    }
}

pub fn main() {
    assert_eq!(f(5), 120);
    // info!("all done");

}


// 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 f(x: int) -> int {
    // println!("in f:");

    println!("{}", x);
    if x == 1 {
        // println!("bottoming out");

        return 1;
    } else {
        // println!("recurring");

        let y: int = x * f(x - 1);
        // println!("returned");

        println!("{}", y);
        return y;
    }
}

pub fn main() {
    assert_eq!(f(5), 120);
    // println!("all done");

}


// 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 f(x: isize) -> isize {
    // println!("in f:");

    println!("{}", x);
    if x == 1 {
        // println!("bottoming out");

        return 1;
    } else {
        // println!("recurring");

        let y: isize = x * f(x - 1);
        // println!("returned");

        println!("{}", y);
        return y;
    }
}

pub fn main() {
    assert_eq!(f(5), 120);
    // println!("all done");

}