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

public class Main {

    private static final FastIO fastIO = new FastIO();
    private static final String yes = "YES";
    private static final String no = "NO";

    public static void main(String[] args) {
        int t = fastIO.nextInt();

        while(t-- > 0){
            int n = fastIO.nextInt();
            int m = fastIO.nextInt();
            List<Node> nodes = new ArrayList<>(n);
            Set<Long> used = new HashSet<>();
            long add = 0;
            long max = Integer.MIN_VALUE;

            for(int i = 0; i < n; i++) {
                long val = fastIO.nextLong();
                add += val;
                max = Math.max(max, add);

                if(val != 0 && !used.contains(add)) {
                    nodes.add(new Node(add, i + 1));
                    used.add(add);
                }
            }

            Collections.sort(nodes);
            for(int i = 0; i < m; i++){
                long x = fastIO.nextLong();
                int ans = 0;

                if(add > 0 && x > max) {
                    long c = (x - max) / add;
                    x -= c * add;
                    ans += c * n;

                    while(x > max){
                        x -= add;
                        ans += n;
                    }
                }

                fastIO.append(ans + getTime(nodes, x, -1, nodes.size()) - 1, " ");
            }

            fastIO.appendln();
        }

        fastIO.printAll();
    }

    public static long getTime(List<Node> nodes, long val, int l, int r){
        long ans = Integer.MAX_VALUE;

        while(l + 1 < r){
            int mid = (l + r) / 2;

            if(val >= nodes.get(mid).val)
                l = mid;
            else
                r = mid;
        }

        if(l > -1 && nodes.get(l).val >= val)
            ans = Math.min(ans, nodes.get(l).time);
        if(r < nodes.size() && nodes.get(r).val >= val)
            ans = Math.min(ans, nodes.get(r).time);

        return (ans == Integer.MAX_VALUE)? 0 : ans;
    }

    public static class Node implements Comparable<Node> {

        long val;
        long time;

        public Node(long val, long time) {
            this.val = val;
            this.time = time;
        }

        @Override
        public int compareTo(Node node) {
            return (int)(val - node.val);
        }
    }

    private static class FastIO {

        private final BufferedReader in;
        private final StringBuilder out;
        private final char LINE_BREAK = '\n';

        private StringTokenizer tokens;

        public FastIO() {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new StringBuilder();
        }

        public String next() {
            while (tokens == null || !tokens.hasMoreElements()) {
                try {
                    tokens = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            return tokens.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            String str = "";

            try {
                str = in.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }

            return str;
        }

        public FastIO append(Object... objects){
            for(Object o: objects)
                out.append(o);
            return this;
        }

        public FastIO appendln(Object... objects){
            return append(objects).append(LINE_BREAK);
        }

        public void printAll(){
            System.out.println(out.toString());
        }
    }
}
/*
1
3 3
2 -1 0
2 3 4*/