Index: example/cpu.cfa
===================================================================
--- example/cpu.cfa	(revision c8371b5a494957f77ac114c53bd54e6f5e7b1d34)
+++ example/cpu.cfa	(revision c8371b5a494957f77ac114c53bd54e6f5e7b1d34)
@@ -0,0 +1,10 @@
+#include <fstream.hfa>
+#include <device/cpu.hfa>
+
+int main() {
+	for(i; cpu_info.hthrd_count) {
+		cpu_info.llc_map[i];
+		const cpu_map_entry_t & e = cpu_info.llc_map[i];
+		sout | e.self | e.start | e.count;
+	}
+}
Index: example/maybe-await.rs
===================================================================
--- example/maybe-await.rs	(revision c8371b5a494957f77ac114c53bd54e6f5e7b1d34)
+++ example/maybe-await.rs	(revision c8371b5a494957f77ac114c53bd54e6f5e7b1d34)
@@ -0,0 +1,77 @@
+use futures::executor::block_on;
+use futures::future::Future;
+use std::pin::Pin;
+use std::sync::{Arc,Mutex};
+use std::task::{Context, Poll, Waker};
+
+
+struct FutureState {
+	set: bool,
+	waker: Option<Waker>,
+}
+
+#[derive(Clone)]
+struct MyFuture {
+	state: Arc<Mutex<FutureState>>
+}
+
+impl MyFuture {
+	fn new() -> MyFuture {
+		MyFuture{
+			state: Arc::new(Mutex::new(FutureState{
+				set: false,
+				waker: None
+			}))
+		}
+	}
+
+	fn fulfill(&self) {
+		let mut state = self.state.lock().unwrap();
+		state.set = true;
+		if let Some(waker) = state.waker.take() {
+			waker.wake()
+		}
+	}
+}
+
+impl Future for MyFuture {
+	type Output = ();
+	fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+		println!("Polling Future");
+		let mut state = self.state.lock().unwrap();
+		if state.set {
+			println!("Ready");
+			Poll::Ready(())
+		} else {
+			println!("Pending");
+			state.waker = Some(cx.waker().clone());
+			Poll::Pending
+		}
+	}
+}
+
+async fn hello_world(f1: MyFuture, f2: MyFuture) {
+	println!("Enter");
+	f1.await;
+	println!("Between");
+	f2.await;
+	println!("Done");
+}
+
+fn main() {
+	block_on(async {
+		let f1 = MyFuture::new();
+		let f2 = MyFuture::new();
+		let f3 = MyFuture::new();
+		let future = hello_world(f1.clone(), f2.clone());
+
+		println!("Before first fulfill");
+		f1.fulfill();
+		println!("Before second fulfill");
+		f2.fulfill();
+		println!("Before first await");
+		future.await;
+		println!("Before second await");
+		// future.await;
+	});
+}
Index: example/unnecessary-arc.rs
===================================================================
--- example/unnecessary-arc.rs	(revision c8371b5a494957f77ac114c53bd54e6f5e7b1d34)
+++ example/unnecessary-arc.rs	(revision c8371b5a494957f77ac114c53bd54e6f5e7b1d34)
@@ -0,0 +1,74 @@
+use std::thread;
+use std::time::Duration;
+
+// This is the version I wished worked.
+// If join was't ingored it would be safe
+fn better() {
+	// let durr = Duration::from_millis(1);
+	{
+		let thrd = thread::spawn(move || {
+			for i in 1..10 {
+				println!("hi number {} from the spawned thread!", i);
+				thread::sleep(durr);
+			}
+		});
+
+		for i in 1..5 {
+			println!("hi number {} from the main thread!", i);
+			thread::sleep(durr);
+		}
+
+		thrd.join().unwrap();
+	}
+}
+
+use std::sync::Arc;
+
+// This uses arc, which should not be needed
+// But it fails to figure out where to clone so it doesn't compile
+fn best() {
+	let durr = Arc::new(Duration::from_millis(1));
+	{
+		let thrd = thread::spawn(|| {
+			for i in 1..10 {
+				println!("hi number {} from the spawned thread!", i);
+				thread::sleep(*durr);
+			}
+		});
+
+		for i in 1..5 {
+			println!("hi number {} from the main thread!", i);
+			thread::sleep(*durr);
+		}
+
+		thrd.join().unwrap();
+	}
+}
+
+// This is what is actually required
+// Note that the clone is explicit
+fn real() {
+	let durr = Arc::new(Duration::from_millis(1));
+	{
+		let durr2 = durr.clone();
+		let thrd = thread::spawn(move || {
+			for i in 1..10 {
+				println!("hi number {} from the spawned thread!", i);
+				thread::sleep(*durr2);
+			}
+		});
+
+		for i in 1..5 {
+			println!("hi number {} from the main thread!", i);
+			thread::sleep(*durr);
+		}
+
+		thrd.join().unwrap();
+	}
+}
+
+fn main() {
+	best();
+	better();
+	real();
+}