import java.util.concurrent.Future;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Callable;

public class Test {
    
    static int fib(int n) {
        if(n < 2) return n;
        else return fib(n-1) + fib(n-2);
    }
    
    public static void main(String[] args) throws Exception {
        ForkJoinPool pool = new ForkJoinPool();
        Future<Integer> future = pool.submit(new Callable<Integer>() {
            public Integer call() {
                System.out.println(Thread.currentThread());
                return fib(45);
            }
        });
        System.out.println(Thread.currentThread());
        while(!future.isDone()) {
            System.out.println("running");
            Thread.sleep(500);
        }
        System.out.println(future.get());
    }
}

Area area = new Area(shape1);
area.intersect(new Area(shape2));
boolean isIntersecting = !area.isEmpty();

CoordinateSystem(Vec(500,100),
                 Vec(1,1),
                 Vec(-1,1))

public static final double MIN = 0
public static final double filter_interval = 1.0/4

public static double filterValue(double value) {
    return MIN + filter_interval * (int)((value - MIN)/filter_interval)
}

public void draw(Graphics g) {
  g.scale(getZoomLevel(), getZoomLevel());
  g.translate(-cameraPos.getX(), -cameraPos.getY());
  
  for(Entity e:entities) {
     if(e!=null) {
        e.draw(g);
     }
  }
}

public float zX=0, zY=0;

public cameraPos = new Vector2f(0,0);

static Vector2f getMousePos() {
    return new Vector2f(Mouse.getX(), gameContainer.getHeight()-1-Mouse.getY());
}

public void mouseWheelZoom() {
    int mouseWheel = Mouse.getDWheel();
    if(mouseWheel==0) {
       return;
    }
    if(mouseWheel != 0) {
        Vector2f mousePosAbs = getMousePos();
        Vector2f mousePosRel = mousePosAbs.copy().scale(1/zoomLevel).add(cameraPos);
        if (mouseWheel>0) {
           addZoomLevel(zoomStep);
        } else {
           addZoomLevel(-zoomStep);
        }
        cameraPos = mousePosRel.sub(mousePosAbs.scale(1/zoomLevel));
    }
}

class Arrow {
    double x, y,
           speedX, speedy;
    
    double gravity = 10;
    
    void setSpeedAndAngle(double speed, double theta) {
        speedX = Math.cos(theta) * speed;
        speedY = Math.sin(theta) * speed;
    }
    
    //dt = delta time
    void update(double dt) {
        y += speedY * dt + 0.5 * gravity * dt * dt;
        speedY += gravity * dt;
        x += speedX * dt;
    }
}

import java.util.*;;

interface Getter {
    double get(GameObject go);
}

class GameObject {
    public double x, y, sizeX, sizeY;
    
    GameObject(double x, double y, double sizeX, double sizeY) {
        this.x = x; this.y = y; this.sizeX = sizeX; this.sizeY = sizeY;
    }
    
    public double maxDistanceAtCollision(GameObject other) {
        return Math.sqrt(sizeX*sizeX + sizeY*sizeY) +
               Math.sqrt(other.sizeX*other.sizeX + other.sizeY*other.sizeY); 
    }
    public final static Getter getX = new Getter() {
        public double get(GameObject go) {
            return go.x;
        }
    };
    public final static Getter getY = new Getter() {
        public double get(GameObject go) {
            return go.y;
        }
    };
    public String toString() {
        return "pos = ("+x+", "+y+") - size = ("+sizeX+", "+sizeY+")";
    }
}

public class Test {
    
    static void sortAndFilter(List<GameObject> list, final Getter getter) {
        if(list.isEmpty()) return;
        Collections.sort(list, new Comparator<GameObject>() {
            public int compare(GameObject go1, GameObject go2) {
                double g1 = getter.get(go1);
                double g2 = getter.get(go2);
                if(g1 < g2) return -1;
                else if(g1 > g2) return 1;
                else return 0;
            }
        });
        
        ArrayList<GameObject> newList = new ArrayList<>();
        boolean foundAPairLastTime = false;
        Iterator<GameObject> li = list.iterator();
        GameObject last = li.next();
        while(li.hasNext()) {
            GameObject next = li.next();
            boolean foundAPair = Math.abs(getter.get(last) - getter.get(next)) <= last.maxDistanceAtCollision(next);
            if(foundAPair || foundAPairLastTime) newList.add(last);
            last = next;
            foundAPairLastTime = foundAPair;
        }
        if(foundAPairLastTime) newList.add(last);
        list.clear();
        list.addAll(newList);
    }
    
    public static void main(String[] args) {
        List<GameObject> list = Arrays.asList(
            new GameObject(100,100,20,20), new GameObject(110,110,20,20),
            new GameObject(200,500,20,20), new GameObject(300,600,20,20),
            new GameObject(400,700,20,20), new GameObject(310,810,20,20));
        List<GameObject> newList = new ArrayList<>(list);
        sortAndFilter(newList, GameObject.getX);
        sortAndFilter(newList, GameObject.getY);
        for(GameObject go: newList) System.out.println(go);
    }
}

int a = 3;
int b = 4;
int c = a+b;

BigInteger a = new BigInteger("3");
BigInteger b = new BigInteger("4");
BigInteger c = a.add(b);

MutableBigInteger a = new MutableBigInteger ("3");
MutableBigInteger b = new MutableBigInteger ("4");
a.add(b);

int a = 3;
int b = 4;
a + b;

ArrayList<Tile> neighbours = new ArrayList<Tile>();

for(int dy = -1; dy <= 1; dy++) {
    for(int dx = -1; dx <= 1; dx++) {
        if(dx == 0 && dy == 0) continue;
        int nx = x+dx, ny = y+dy;
        if(nx >= 0 && nx < mapWidth &&
           ny >= 0 && ny < mapHeight) {
               neighbours.add(map[nx][ny]);
        }
    }
}

g.translate(1600,0);