
fn incr(mutable &int x) -> bool {
  x += 1;
  check (false);
  ret false;
}

fn main() {

  auto x = (1 == 2) || (3 == 3);
  check (x);

  let int y = 10;
  log x || incr(y);
  check (y == 10);

  if (true && x) {
    check (true);
  } else {
    check (false);
  }

}


fn incr(& mutable int x) -> bool {
  x += 1;
  check (false);
  ret false;
}

fn main() {

  auto x = (1 == 2) || (3 == 3);
  check (x);

  let int y = 10;
  log x || incr(y);
  check (y == 10);

  if (true && x) {
    check (true);
  } else {
    check (false);
  }

}


fn incr(& mutable int x) -> bool {
  x += 1;
  assert (false);
  ret false;
}

fn main() {

  auto x = (1 == 2) || (3 == 3);
  assert (x);

  let int y = 10;
  log x || incr(y);
  assert (y == 10);

  if (true && x) {
    assert (true);
  } else {
    assert (false);
  }

}


fn incr(& mutable int x) -> bool {
  x += 1;
  check (false);
  ret false;
}

fn main() {

  auto x = (1 == 2) || (3 == 3);
  check (x);

  let int y = 10;
  log x || incr(y);
  check (y == 10);

  if (true && x) {
    check (true);
  } else {
    check (false);
  }

}


fn incr(& mutable int x) -> bool {
  x += 1;
  assert (false);
  ret false;
}

fn main() {

  auto x = (1 == 2) || (3 == 3);
  assert (x);

  let int y = 10;
  log x || incr(y);
  assert (y == 10);

  if (true && x) {
    assert (true);
  } else {
    assert (false);
  }

}


fn incr(&mutable int x) -> bool { x += 1; assert (false); ret false; }

fn main() {
    auto x = 1 == 2 || 3 == 3;
    assert (x);
    let int y = 10;
    log x || incr(y);
    assert (y == 10);
    if (true && x) { assert (true); } else { assert (false); }
}


fn incr(x: &mutable int) -> bool { x += 1; assert (false); ret false; }

fn main() {
    let x = 1 == 2 || 3 == 3;
    assert (x);
    let y: int = 10;
    log x || incr(y);
    assert (y == 10);
    if true && x { assert (true); } else { assert (false); }
}


fn incr(x: &mutable int) -> bool { x += 1; assert (false); ret false; }

fn main() {
    let x = 1 == 2 || 3 == 3;
    assert (x);
    let y: int = 10;
    log x || incr(y);
    assert (y == 10);
    if true && x { assert (true); } else { assert (false); }
}


fn incr(&x: int) -> bool { x += 1; assert (false); ret false; }

fn main() {
    let x = 1 == 2 || 3 == 3;
    assert (x);
    let y: int = 10;
    log x || incr(y);
    assert (y == 10);
    if true && x { assert (true); } else { assert (false); }
}


fn incr(&x: int) -> bool { x += 1; assert (false); ret false; }

fn main() {
    let x = 1 == 2 || 3 == 3;
    assert (x);
    let y: int = 10;
    log_full(core::debug, x || incr(y));
    assert (y == 10);
    if true && x { assert (true); } else { assert (false); }
}


fn incr(&x: int) -> bool { x += 1; assert (false); ret false; }

fn main() {
    let x = 1 == 2 || 3 == 3;
    assert (x);
    let y: int = 10;
    log(debug, x || incr(y));
    assert (y == 10);
    if true && x { assert (true); } else { assert (false); }
}


fn incr(&x: int) -> bool { x += 1; assert (false); ret false; }

fn main() {
    let x = 1 == 2 || 3 == 3;
    assert (x);
    let mut y: int = 10;
    log(debug, x || incr(y));
    assert (y == 10);
    if true && x { assert (true); } else { assert (false); }
}


fn incr(&x: int) -> bool { x += 1; assert (false); return false; }

fn main() {
    let x = 1 == 2 || 3 == 3;
    assert (x);
    let mut y: int = 10;
    log(debug, x || incr(y));
    assert (y == 10);
    if true && x { assert (true); } else { assert (false); }
}


fn incr(x: &mut int) -> bool { *x += 1; assert (false); return false; }

fn main() {
    let x = 1 == 2 || 3 == 3;
    assert (x);
    let mut y: int = 10;
    log(debug, x || incr(&mut y));
    assert (y == 10);
    if true && x { assert (true); } else { assert (false); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert (false); return false; }

fn main() {
    let x = 1 == 2 || 3 == 3;
    assert (x);
    let mut y: int = 10;
    log(debug, x || incr(&mut y));
    assert (y == 10);
    if true && x { assert (true); } else { assert (false); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert (false); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    assert (x);
    let mut y: int = 10;
    log(debug, x || incr(&mut y));
    assert (y == 10);
    if true && x { assert (true); } else { assert (false); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; fail_unless!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    fail_unless!((x));
    let mut y: int = 10;
    log(debug, x || incr(&mut y));
    fail_unless!((y == 10));
    if true && x { fail_unless!((true)); } else { fail_unless!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; fail_unless!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    fail_unless!((x));
    let mut y: int = 10;
    debug!(x || incr(&mut y));
    fail_unless!((y == 10));
    if true && x { fail_unless!((true)); } else { fail_unless!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    assert!((x));
    let mut y: int = 10;
    debug!(x || incr(&mut y));
    assert!((y == 10));
    if true && x { assert!((true)); } else { assert!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    assert!((x));
    let mut y: int = 10;
    debug!(x || incr(&mut y));
    assert_eq!(y, 10);
    if true && x { assert!((true)); } else { assert!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    assert!((x));
    let mut y: int = 10;
    info!(x || incr(&mut y));
    assert_eq!(y, 10);
    if true && x { assert!((true)); } else { assert!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    assert!((x));
    let mut y: int = 10;
    info2!("{:?}", x || incr(&mut y));
    assert_eq!(y, 10);
    if true && x { assert!((true)); } else { assert!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    assert!((x));
    let mut y: int = 10;
    info!("{:?}", x || incr(&mut y));
    assert_eq!(y, 10);
    if true && x { assert!((true)); } else { assert!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    assert!((x));
    let mut y: int = 10;
    println!("{:?}", x || incr(&mut y));
    assert_eq!(y, 10);
    if true && x { assert!((true)); } else { assert!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    assert!((x));
    let mut y: int = 10;
    println!("{:?}", x || incr(&mut y));
    assert_eq!(y, 10);
    if true && x { assert!((true)); } else { assert!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1i == 2 || 3i == 3;
    assert!((x));
    let mut y: int = 10;
    println!("{:?}", x || incr(&mut y));
    assert_eq!(y, 10);
    if true && x { assert!((true)); } else { assert!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1i == 2 || 3i == 3;
    assert!((x));
    let mut y: int = 10;
    println!("{}", x || incr(&mut y));
    assert_eq!(y, 10);
    if true && x { assert!((true)); } else { assert!((false)); }
}


// 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 incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    assert!((x));
    let mut y: int = 10;
    println!("{}", x || incr(&mut y));
    assert_eq!(y, 10);
    if true && x { assert!((true)); } else { assert!((false)); }
}


// 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 incr(x: &mut isize) -> bool { *x += 1; assert!((false)); return false; }

pub fn main() {
    let x = 1 == 2 || 3 == 3;
    assert!((x));
    let mut y: isize = 10;
    println!("{}", x || incr(&mut y));
    assert_eq!(y, 10);
    if true && x { assert!((true)); } else { assert!((false)); }
}