public class Task100725 {
    public static void main(String[] args) {
        int x = 1;
        int y = x++ + x++ + ++x;
        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }
}

public class Task110725 {
    public static void main(String[] args) {
        int a = 1;
        int b = a << 2 + a++ * --a;
        System.out.println(b);
    }
}

public class Task140725 {
    public static void main(String[] args) {
        int a = 1 << 31;
        int b = a >> 31;
        int c = a >>> 31;
        
        System.out.println(b + " " + c);
    }
}

public class Task150725 {
    public static void main(String[] args) {
        new Child150725();
    }
}

class Parent150725 {
    Parent150725() {
        System.out.println("Parent: " + getClass().getSimpleName());
    }
}

class Child150725 extends Parent150725 {
    Child150725() {
        System.out.println("Child: " + getClass().getSimpleName());
    }
}

class Parent160725 {
    void print() {
        System.out.println("Parent160725");
    }
}

class Child160725 extends Parent160725 {
    void print() {
        System.out.println("Child160725");
    }
}

public class Task160725 {
    public static void main(String[] args) {
        Parent160725 obj = new Child160725();
        obj.print();
    }
}

public class Task170725 {
    static void process(int x) {
        System.out.println("int");
    }
    
    static void process(Integer x) {
        System.out.println("Integer");
    }
    
    static void process(Object x) {
        System.out.println("Object");
    }
    
    public static void main(String[] args) {
        process(10);
        process(Integer.valueOf(10));
        process(null);
    }
}

import java.util.Optional;

public class Task180725 {
    public static void main(String[] args) {
        Optional<Object> opt = Optional.of("Java")
                                    .filter(s -> s.startsWith("J"))
                                    .map(s -> null)
                                    .or(() -> Optional.of("Fallback"));
        
        System.out.println(opt.get());
    }
}

public class Task210725 {
    static int x = 5;
    
    static {
        x = 10;
    }
    
    public static void main(String[] args) {
        System.out.println(x);
        
        int x = 20;
        System.out.println(x);
        
        System.out.println(Task210725.x);
    }
}

public class Task220725 {
    public static void main(String[] args) {
        final int x;
        try {
            x = 10;
            throw new RuntimeException();
        } catch (Exception e) {
            System.out.print(x + " ");
        } finally {
            x = 20;
            System.out.print(x);
        }
    }
}

public class Task230725 {
    private static volatile boolean flag = true;

    public static void main(String[] args) {
        new Thread(() -> {
            while (flag) {
                // empty loop
            }
            System.out.println("Thread stopped");
        }).start();

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        flag = false;
        System.out.println("Main stopped");
    }
}

public class Task240725 {
    private static synchronized void print(String msg) {
        System.out.print(msg + " ");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> print("Hello"));
        Thread t2 = new Thread(() -> print("World"));
        
        t1.start();
        t2.run();
        
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.locks.ReentrantLock;

public class Task250725 {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lock();
            System.out.println("First lock");
            lock.lock();
            System.out.println("Second lock");
        } finally {
            lock.unlock();
        }
    }
}

import java.util.concurrent.*;

public class Task280725 {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() -> {
            Thread.sleep(1000);
            return "Done";
        });
        
        System.out.println(future.get(500, TimeUnit.MILLISECONDS));
        executor.shutdown();
    }
}