TLE Robot Instructions

package official.o2022.feb.silver;

import java.io.*;
import java.util.*;

public final class Instructions {
    public static void main(String[] args) throws IOException {
        BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
        int instructionNum = Integer.parseInt(read.readLine());

        StringTokenizer ptSt = new StringTokenizer(read.readLine());
        Point target = new Point(Integer.parseInt(ptSt.nextToken()), Integer.parseInt(ptSt.nextToken()));

        Point[] half1 = new Point[instructionNum / 2];
        Point[] half2 = new Point[instructionNum - half1.length];
        for (int i = 0; i < instructionNum; i++) {
            ptSt = new StringTokenizer(read.readLine());
            Point pt = new Point(Integer.parseInt(ptSt.nextToken()), Integer.parseInt(ptSt.nextToken()));
            if (i < half1.length) {
                half1[i] = pt;
            } else {
                half2[i - half1.length] = pt;
            }
        }

        HashMap<Point, Integer>[] half1Sub = subsetSums(half1);
        HashMap<Point, Integer>[] half2Sub = subsetSums(half2);
        int[] validSubsets = new int[instructionNum + 1];
        for (int i = 0; i <= half1.length; i++) {
            for (Point p1 : half1Sub[i].keySet()) {
                Point p2 = target.add(new Point(-p1.x, -p1.y));
                for (int j = 0; j <= half2.length; j++) {
                    validSubsets[i + j] += half1Sub[i].get(p1) * half2Sub[j].getOrDefault(p2, 0);
                }
            }
        }

        for (int i = 1; i <= instructionNum; i++) {
            System.out.println(validSubsets[i]);
        }
    }

    private static int popCount(int n) {
        int total = 0;
        for (int i = 0; i < 31; i++) {
            total += (n & (1 << i)) != 0 ? 1 : 0;
        }
        return total;
    }

    private static HashMap<Point, Integer>[] subsetSums(Point[] pts) {
        HashMap<Point, Integer>[] ret = new HashMap[pts.length + 1];
        for (int i = 0; i <= pts.length; i++) {
            ret[i] = new HashMap<>();
        }
        for (int i = 0; i < (1 << pts.length); i++) {
            Point result = new Point(0, 0);
            for (int p = 0; p < pts.length; p++) {
                if ((i & (1 << p)) != 0) {
                    result = result.add(pts[p]);
                }
            }
            HashMap<Point, Integer> relevant = ret[popCount(i)];
            relevant.put(result, relevant.getOrDefault(result, 0) + 1);
        }
        return ret;
    }
}

class Point {
    public int x;
    public int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public Point add(Point p) {
        return new Point(x + p.x, y + p.y);
    }

    @Override
    public String toString() {
        return String.format("(%d, %d)", x, y);
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

    @Override
    public boolean equals(Object obj) {
        return obj.getClass() == getClass() && x == ((Point) obj).x && y == ((Point) obj).y;
    }
}