Problem:
Problem B: B問題

R大学の2D好きの人たち (2DRespecters)は、A津大学で開催されるプログラミングの練習合宿に参加する。
この練習合宿では、参加者たちが自作のプログラミング問題を持ち寄り、練習に用いる。

2DRespectersも、いくつかの問題を作成することになった。
しかし、合宿の3日前になっても、まだ、B問題が完成していなかった。
最初のB問題の担当者が作成した問題は、担当者が問題の制約を難しくし過ぎてしまったため、C問題以降にまわされてしまったのだ。
そして、簡単すぎても、難しすぎてもいけない、微妙な難易度の調整が必要とされるB問題は、誰もが手を付けたがらなかった。
それ以来、B問題担当者の椅子は空席のままである。

合宿3日前になって、遂に、この問題を解決するために、2DRespecters期待のホープが立ち上がった。
だが、彼は、B問題を作成する気がない。
彼は、自分でB問題を作成したくないので、B問題の作成担当を他者に押し付ける手法を考え出したのだ。
彼の手法は、表面上、B問題の作成担当者を平等に決定する。

彼の手法は、以下の通りである。

問題作成のために要した作業時間が最も少ない人がB問題担当者になる。

作業時間が最も少ない人が複数人居た場合は、より問題難易度の小さい問題の担当者がB問題作成担当者になる。

作業時間が最も少ない人が複数人居て、その中で、問題難易度の最も小さい人が複数人いた場合は、ホープの彼がB問題作成担当者になる。

彼の手法は、一見、最も仕事をしていない人がB問題の作成を担当するため、2DRespectersのメンバー全員に快く受け入れられた。

しかし、彼の手法には、以下のような裏がある。

各個人の作業時間は、各個人が口頭で申請するため、嘘の申請をすることが可能である。

問題の作業可能時間を超える作業時間や負の作業時間を申請すると、嘘だとばれる。

ある問題の作成のための作業時間は、必ず問題難易度の整数倍になることが知られているため、これに反する作業時間を申請した場合も、嘘だとばれる。

嘘の申請をした人の嘘がばれた場合、その人が必ずB問題作成担当者になる。
申請は一人ずつ順番に行い、嘘がばれる場合は、申請の時点でばれる。
一人でも嘘の申請がばれた時点で、B問題作成担当者が決まり、それ以降の申請は行わない。

申請者は、自分より前の申請のみを考慮し、申請の時点で自分がB問題作成担当者にならないような最小の作業時間を申請するものとする。
申請の時点で、申請者がB問題作成担当者にならないような報告ができない場合は、嘘だとばれないような最大の作業時間を申請する。

各個人の担当する問題難易度のリストが申請順に与えられたとき、誰がB問題作成担当者になるかを求めるプログラムを作成せよ。
ホープの彼の申請順番は、一番最後である。

なお、本問題はフィクションであり、本問題の作成の経緯とは一切の関係がない。

Input

入力は、複数のデータセットからなり、データセットの終わりは、半角スペースで区切られた0が二つだけを含む行で表される。
データセットの総数は40以下である。
データセットの1行目では、整数n(2 ≤ n ≤ 100 1,000)と整数m(1 ≤ m ≤ 1,000)が半角スペース区切りで与えられる。
データセットの2行目では、整数a_1, a_2, ..., a_n(1 ≤ a_i ≤ 1,000, 1 ≤ i ≤ n)が半角スペース区切りで与えられる。

1行目のnとmは、それぞれ、申請者の数と問題の作業可能時間を表す。
2行目では、申請順に並べられた問題難易度のリストが与えられており、a_iは、問題の難易度を表す。

Output

それぞれのデータセットごとに、B問題作成担当者の申請順番を1行で出力せよ。

Sample Input

3 100
3 7 4
5 24
4 6 12 3 8
5 1
1 1 2 2 3
0 0

Output for Sample Input

2
4
5

Solution in JAVA (judge verdict: Wrong Answer)

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

public class Main {
    void run() {
        while (true) {
            int N = readInt();
            int M = readInt();
            if(N == 0 && M == 0) break;
            int[] T = new int[N];
            int[] S = new int[N];
            for (int i = 0; i < N; i++) {
                T[i] = readInt();
                S[i] = T[i] * (M / T[i]);
            }
            int minArg = 0;
            boolean hope = false;
            for (int i = 0; i < N; i++) {
                if (S[i] < S[minArg]) {
                    minArg = i;
                    hope = false;
                }
                else if (S[i] == S[minArg] && T[i] < T[minArg]) {
                    minArg = i;
                    hope = false;
                }
                else if (S[i] == S[minArg] && T[i] == T[minArg]) {
                    hope = true;
                }
            }
            if(hope) {
                sysout.println(N);
            }
            else {
                sysout.println(minArg + 1);
            }
        }
    }

    public static void main(String[] args) {
        new Main().run();
    }

    // flush automatically iff you call `println` or `printf` or `format`.
    PrintWriter sysout = new PrintWriter(System.out, true);

    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer buffer = new StringTokenizer("");

    String read() {
        if (!buffer.hasMoreTokens()) {
            try {
                buffer = new StringTokenizer(in.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return buffer.nextToken();
    }

    int readInt() {
        return Integer.parseInt(read());
    }

    long readLong() {
        return Long.parseLong(read());
    }

    double readDouble() {
        return Double.parseDouble(read());
    }

    String readLine() {
        buffer = new StringTokenizer("");
        try {
            return in.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}