Problem: Problem B: B problem

2D enthusiasts (2D Respecters) from R University will participate in a programming training camp held at Atsu University. In this training camp, participants bring their own programming problems and use them for practice.

2DRespecters also ended up creating some issues. However, even three days before the training camp, the B problem had not been completed yet. The problem created by the person in charge of the first B problem was passed on after the C problem because the person in charge made it too difficult to constrain the problem. And no one wanted to deal with Problem B, which requires subtle adjustments to the difficulty level, which should not be too easy or too difficult. Since then, the chair of the person in charge of B problem has remained vacant.

Three days before the training camp, the Hope of 2D Respecters Expectations was finally launched to solve this problem. But he is not willing to create a B problem. He didn't want to create the B question himself, so he came up with a way to impose the person in charge of creating the B question on others. On the surface, his method determines who is responsible for creating the B problem equally.

His method is as follows.

* The person in charge of problem B is the person who takes the least amount of time to create the problem.
* If there are multiple people with the least work time, the person in charge of the problem with the smaller problem difficulty becomes the person in charge of creating the B problem.
* If there are multiple people with the least working time, and among them, there are multiple people with the lowest problem difficulty, he will be the person in charge of creating the B problem.

His method was well accepted by all members of 2D Respecters, as the seemingly least-working person was responsible for creating the B question.

However, his method has the following backs.

* Since each individual applies for the working hours verbally, it is possible to apply for a lie.
* If you apply for work hours that exceed the workable hours in question or negative work hours, you will be told that you are lying.
* It is known that the work time for creating a certain question is always an integral multiple of the difficulty level of the question, so even if you apply for work time contrary to this, it will be said to be a lie.

If the lie of the person who applied for the lie is revealed, that person will always be the person in charge of creating the B problem. Applications are made one by one in turn, and if a lie is revealed, it will be revealed at the time of application. When even one person finds a false application, the person in charge of creating the B problem will be decided, and no further applications will be made.

The applicant shall consider only the applications prior to him / her and apply for the minimum working time so that he / she will not be the person in charge of creating the B question at the time of application. At the time of application, if the applicant cannot report that he / she will not be the person in charge of creating the B problem, apply for the maximum working time that cannot be dismissed as a lie.

Create a program that asks who will be the B question creator when given a list of question difficulty levels for each individual in the order of application. Hope's application order is the last.

This question is fiction and has nothing to do with the process of creating this question.

Input

The input consists of multiple datasets, and the end of the dataset is represented by a line containing only two zeros separated by a single-byte space. The total number of datasets is 40 or less. In the first line of the dataset, the integer n (2 ≤ n ≤ ~~ 100 ~~ 1,000) and the integer m (1 ≤ m ≤ 1,000) are given separated by a single-byte space. In the second line of the dataset, the integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1,000, 1 ≤ i ≤ n) are given separated by single-byte spaces.

The n and m on the first line represent the number of applicants and the working hours of the problem, respectively. The second line gives a list of question difficulty levels arranged in the order of application, where a_i represents the difficulty level of the question.

Output

For each data set, output the application order of the person in charge of creating the B question on one line.

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
Four
Five






Example

Input

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


Output

2
4
5

Solution (in CPP):

Solution:
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
 
using namespace std;
 
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P > PP;
 
static const int tx[] = {0,1,0,-1};
static const int ty[] = {-1,0,1,0};
 
static const double EPS = 1e-8;

int main(){
  int total_applicants;
  int working_duration;
  while(~scanf("%d %d",
               &total_applicants,
               &working_duration)){
    if(total_applicants == 0) break;

    vector<int> problems;
    for(int applicant_idx = 0; applicant_idx < total_applicants; applicant_idx++){
      int difficulty;
      scanf("%d",&difficulty);
      problems.push_back(difficulty);
    }

    int min_time = INF;
    int times[1001];
    for(int applicant_idx = 0; applicant_idx < total_applicants; applicant_idx++){
      times[applicant_idx] = problems[applicant_idx] * (working_duration/problems[applicant_idx]);
      min_time = min(times[applicant_idx],min_time);
    }

    for(int applicant_idx = 1; applicant_idx < total_applicants; applicant_idx++){

      for(int multiply=0; multiply <= working_duration/problems[applicant_idx]; multiply++){
        bool isok = true;
        int time = problems[applicant_idx] * multiply;
        for(int prev = 0; prev < applicant_idx; prev++){
          if(time == times[prev]
             && problems[applicant_idx] < problems[prev]){
            isok = false;
            break;
          }
          if(time < times[prev]){
            isok = false;
            break;
          }
        }
        
        if(isok){
          times[applicant_idx] = time;
          min_time = min(time,min_time);
          break;
        }
      }
    }

    int count = 0;
    int res;
    int min_diffculty = INF;

    for(int applicant_idx = 0; applicant_idx < total_applicants; applicant_idx++){
      if(min_time == times[applicant_idx]){
        if(min_diffculty > problems[applicant_idx]){
          count = 1;
          res = applicant_idx + 1;
          min_diffculty = problems[applicant_idx];
        }
        else if(min_diffculty == problems[applicant_idx]){
          count++;
        }
      }
    }

    printf("%d\n",count > 1 ? total_applicants : res);
  }
}