diff --git a/src/AsyncExamples.java b/src/AsyncExamples.java
index 193a2cf..16725cf 100644
--- a/src/AsyncExamples.java
+++ b/src/AsyncExamples.java
@@ -1,5 +1,6 @@
 import async_runtime.Delay;
 import async_runtime.Jokio;
+import async_runtime.Util;
 import async_runtime.net.ServerSocket;
 import async_runtime.net.Socket;
 import future.Future;
@@ -37,14 +38,21 @@ public class AsyncExamples {
         return Future.ret(12);
     }
 
-
     public static Future<Void, IOException> server(){
         try(var ss = ServerSocket.bind(new InetSocketAddress("0.0.0.0", 42069))){
             while (true){
-                var socket = ss.accept().await();
-                Jokio.runtime(Waker.waker()).spawn(echo(socket));
+                Util.select(
+                        Util.selectee(ss.accept(), socket -> {
+                            Jokio.runtime(Waker.waker()).spawn(echo(socket));
+                            return Future.ret();
+                        }),
+                        Util.selectee(Delay.delay(500), _ -> {
+                            System.out.println("Timeout");
+                            return Future.ret();
+                        })
+                ).await().await();
             }
-        } catch (Exception e) {
+        } catch (Throwable e) {
             e.printStackTrace();
         }
         return Future.ret(null);
diff --git a/src/Main.java b/src/Main.java
index e643899..7b80755 100644
--- a/src/Main.java
+++ b/src/Main.java
@@ -14,21 +14,21 @@ public class Main implements Runnable {
 
     @Override
     public void run() {
-        async_lambda(() -> {
-            System.out.println("START");
-            Delay.delay(100).await();
-            System.out.println("END");
-            return Future.ret();
-        });
-        async_lambda(() -> {
-            var start = System.currentTimeMillis();
-            while(true){
-                Util.first(Delay.delay(500), Delay.delay(1000)).await();
-                var end = System.currentTimeMillis();
-                System.out.println(end-start);
-                start = end;
-            }
-        });
+//        async_lambda(() -> {
+//            System.out.println("START");
+//            Delay.delay(100).await();
+//            System.out.println("END");
+//            return Future.ret();
+//        });
+//        async_lambda(() -> {
+//            var start = System.currentTimeMillis();
+//            while(true){
+//                Util.first(Delay.delay(500), Delay.delay(1000)).await();
+//                var end = System.currentTimeMillis();
+//                System.out.println(end-start);
+//                start = end;
+//            }
+//        });
         lexer();
         await();
     }
diff --git a/src/async_runtime/Util.java b/src/async_runtime/Util.java
index b151a98..c75f725 100644
--- a/src/async_runtime/Util.java
+++ b/src/async_runtime/Util.java
@@ -2,9 +2,8 @@ package async_runtime;
 
 import future.Future;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
+import java.util.function.Function;
 
 public class Util {
 
@@ -51,18 +50,72 @@ public class Util {
         };
     }
 
-    public static <T, E extends Throwable> Future<T[], E> all(Future<T, E>... futures){
+    public interface Func<R, T, E extends Throwable>{
+        R call(T p) throws E;
+    }
+    public interface FuncV<T, E extends Throwable>{
+        void call(T p) throws E;
+    }
+    public record Selectee<R, T, E extends Throwable>(Future<T, ? extends E> future, Func<R, T, ? extends E> acceptor){ }
+    public static <R, T, E extends Throwable> Selectee<R, T, E> selectee(Future<T, ? extends E> future, Func<R, T, ? extends E> acceptor){
+        return new Selectee<>(future, acceptor);
+    }
+    public static <T, E extends Throwable> Selectee<Void, T, E> selectee(Future<T, ? extends E> future, FuncV<T, ? extends E> acceptor){
+        return new Selectee<>(future, v -> {
+            acceptor.call(v);
+            return null;
+        });
+    }
+    @SuppressWarnings("unchecked")
+    public static <R, E extends Throwable> Future<R, ? extends E> select(Selectee<? extends R, ?, ? extends E>... selectees){
         return waker -> {
+            int i;
+            Object result = Future.Pending.INSTANCE;
+            for(i = 0; i < selectees.length; i ++){
+                result = selectees[i].future.poll(waker);
+                if(result!=Future.Pending.INSTANCE)break;
+            }
+
+            if(result!=Future.Pending.INSTANCE) {
+                for (int j = 0; j < selectees.length; j++)
+                    if(j==i)
+                        selectees[i].future.cancel();
+
+                return ((Func<R, Object, E>)selectees[i].acceptor).call(result);
+            }
+            return Future.Pending.INSTANCE;
+        };
+    }
+
+    public static <T, E extends Throwable> Future<T[], E> all(Future<T, E>... futures){
+        var resolved = new Object[futures.length];
+        Arrays.fill(resolved,  Future.Pending.INSTANCE);
+        return waker -> {
+            boolean done = true;
+            for(int i = 0; i < resolved.length; i ++){
+                if(resolved[i]==Future.Pending.INSTANCE){
+                    var result = futures[i].poll(waker);
+                    resolved[i] = result;
+                    done &= result != Future.Pending.INSTANCE;
+                }
+            }
+            if(done)return resolved;
             return Future.Pending.INSTANCE;
         };
     }
 
     public static <T, E extends Throwable> Future<List<T>, E> all(List<Future<T, E>> futures){
-        var resolved = new ArrayList<T>(Collections.nCopies(futures.size(), null));
+        var resolved = new ArrayList<Object>(Collections.nCopies(futures.size(), Future.Pending.INSTANCE));
         return waker -> {
+            boolean done = true;
             for(int i = 0; i < resolved.size(); i ++){
-
+                if(resolved.get(i)==Future.Pending.INSTANCE){
+                    var result = futures.get(i).poll(waker);
+                    resolved.set(i, result);
+                    done &= result != Future.Pending.INSTANCE;
+                }
             }
+            if(done)return resolved;
             return Future.Pending.INSTANCE;
         };
     }
diff --git a/src/async_runtime/net/DatagramSocket.java b/src/async_runtime/net/DatagramSocket.java
index eb45281..d308714 100644
--- a/src/async_runtime/net/DatagramSocket.java
+++ b/src/async_runtime/net/DatagramSocket.java
@@ -135,7 +135,7 @@ public class DatagramSocket implements AutoCloseable{
     }
 
     @Override
-    public void close() throws Exception {
+    public void close() throws IOException {
         socket.close();
     }
 }
diff --git a/src/async_runtime/net/ServerSocket.java b/src/async_runtime/net/ServerSocket.java
index becfd92..99b85d4 100644
--- a/src/async_runtime/net/ServerSocket.java
+++ b/src/async_runtime/net/ServerSocket.java
@@ -65,7 +65,7 @@ public class ServerSocket implements AutoCloseable{
     }
 
     @Override
-    public void close() throws Exception {
+    public void close() throws IOException {
         socket.close();
     }
 }
diff --git a/src/async_runtime/net/Socket.java b/src/async_runtime/net/Socket.java
index 3913d19..ae94251 100644
--- a/src/async_runtime/net/Socket.java
+++ b/src/async_runtime/net/Socket.java
@@ -116,7 +116,7 @@ public class Socket implements AutoCloseable{
     }
 
     @Override
-    public void close() throws Exception {
+    public void close() throws IOException {
         socket.close();
     }
 }
diff --git a/src/future/Future.java b/src/future/Future.java
index 4411c3a..e400683 100644
--- a/src/future/Future.java
+++ b/src/future/Future.java
@@ -10,11 +10,15 @@ public interface Future<R, E extends Throwable> {
 
     default void cancel(){}
 
+    default Future<R, E> non_cancelable(){
+        return this::poll;
+    }
+
     static <R, E extends Throwable> Future<R, E> ret(R r){
         throw new RuntimeException("NO!");
     }
 
-    static <E extends Throwable> Future<Void, E> ret(){
+    static Future<Void, ? extends Throwable> ret(){
         throw new RuntimeException();
     }
 
diff --git a/src/generators/loadtime/FrameTracker.java b/src/generators/loadtime/FrameTracker.java
index 9f2871f..f2c428f 100644
--- a/src/generators/loadtime/FrameTracker.java
+++ b/src/generators/loadtime/FrameTracker.java
@@ -358,7 +358,7 @@ public class FrameTracker {
                             pushStack(locals.get(l.slot()).toCD());
                     case LookupSwitchInstruction ls -> popStack();
                     case MonitorInstruction m -> popStack();
-                    case NewMultiArrayInstruction nma -> decStack(nma.dimensions()).pushStack(nma.arrayType().asSymbol().arrayType());
+                    case NewMultiArrayInstruction nma -> decStack(nma.dimensions()).pushStack(nma.arrayType().asSymbol());
                     case NewObjectInstruction no -> pushStack(no.className().asSymbol());
                     case NewPrimitiveArrayInstruction npa -> decStack(1).pushStack(npa.typeKind().upperBound().arrayType());
                     case NewReferenceArrayInstruction nra -> decStack(1).pushStack(nra.componentType().asSymbol().arrayType());
diff --git a/src/generators/loadtime/GeneratorClassLoader.java b/src/generators/loadtime/GeneratorClassLoader.java
index 54de2fb..bd4809b 100644
--- a/src/generators/loadtime/GeneratorClassLoader.java
+++ b/src/generators/loadtime/GeneratorClassLoader.java
@@ -76,13 +76,14 @@ public class GeneratorClassLoader extends ClassLoader {
                         cb.withMethod(mem.methodName(), mem.methodType(), mem.flags().flagsMask(), mb -> {
                             mb.withCode(builder::buildSourceMethodShim);
                         });
+                        if(builder.shouldBeInnerClass()){
+                            innerCl.add(InnerClassInfo.of(builder.CD_this, Optional.of(clm.thisClass().asSymbol()), Optional.of(builder.CD_this.displayName()), AccessFlag.PUBLIC, AccessFlag.FINAL, AccessFlag.STATIC));
+                            nestMem.add(ClassDesc.of(builder.CD_this.displayName()));
+                        }
                     }else{
                         cb.with(mem);
                     }
-                    if(builder != null && builder.shouldBeInnerClass()){
-                        innerCl.add(InnerClassInfo.of(builder.CD_this, Optional.of(clm.thisClass().asSymbol()), Optional.of(builder.CD_this.displayName()), AccessFlag.PUBLIC, AccessFlag.FINAL, AccessFlag.STATIC));
-                        nestMem.add(ClassDesc.of(builder.CD_this.displayName()));
-                    }
+
                 }
                 else if (ce instanceof Attribute<?> e){
                     if (e.attributeMapper() != Attributes.nestMembers() && e.attributeMapper() != Attributes.innerClasses())
diff --git a/src/generators/loadtime/StateMachineBuilder.java b/src/generators/loadtime/StateMachineBuilder.java
index c55fe0c..00c762e 100644
--- a/src/generators/loadtime/StateMachineBuilder.java
+++ b/src/generators/loadtime/StateMachineBuilder.java
@@ -79,7 +79,7 @@ public abstract class StateMachineBuilder {
         for(var coe : src_com){
             if(coe instanceof Instruction) {
                 frames.add(new Frame(lt.locals(), lt.stack()));
-                System.out.println(frames.getLast() + " " + coe);
+//                System.out.println(frames.getLast() + " " + coe);
             }
             lt.encounter(coe);
         }