You are given two positive integers n and s. Find the maximum possible median of an array of n non-negative integers (not necessarily distinct), such that the sum of its elements is equal to s.

A median of an array of integers of length m is the number standing on the ⌈ {m/2} ⌉-th (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting from 1. For example, a median of the array [20,40,20,50,50,30] is the ⌈ m/2 ⌉-th element of [20,20,30,40,50,50], so it is 30. There exist other definitions of the median, but in this problem we use the described definition.

Input

The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. Description of the test cases follows.

Each test case contains a single line with two integers n and s (1 ≤ n, s ≤ 10^9) — the length of the array and the required sum of the elements.

Output

For each test case print a single integer — the maximum possible median.

Example

Input


8
1 5
2 5
3 5
2 1
7 17
4 14
1 1000000000
1000000000 1


Output


5
2
2
0
4
4
1000000000
0

Note

Possible arrays for the first three test cases (in each array the median is underlined):

  * In the first test case [\underline{5}] 
  * In the second test case [\underline{2}, 3] 
  * In the third test case [1, \underline{2}, 2] 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
public class Solution{
static FastScanner sc = new FastScanner();
public static void solve() {
    int n=sc.nextInt(),s=sc.nextInt();
    System.out.println(s/((n/2)+1));
  

  }

public static void main(String[] args) {
  int t = sc.nextInt();
  outer: for (int tt = 0; tt < t; tt++) {
    solve();
  }
}

////////////////////////////////////////////////////////////////////////////////////
////////////////////DO NOT READ AFTER THIS LINE //////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////

static boolean isPalindrom(char[] arr, int i, int j) {
  boolean ok = true;
  while (i <= j) {
    if (arr[i] != arr[j]) {
      ok = false;
      break;
    }
    i++;
    j--;
  }
  return ok;
}

static int max(int a, int b) {
  return Math.max(a, b);
}

static int min(int a, int b) {
  return Math.min(a, b);
}

static long max(long a, long b) {
  return Math.max(a, b);
}

static long min(long a, long b) {
  return Math.min(a, b);
}

static int abs(int a) {
  return Math.abs(a);
}

static long abs(long a) {
  return Math.abs(a);
}

static void swap(long arr[], int i, int j) {
  long temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

static void swap(int arr[], int i, int j) {
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

static int maxArr(int arr[]) {
  int maxi = Integer.MIN_VALUE;
  for (int x : arr)
    maxi = max(maxi, x);
  return maxi;
}

static int minArr(int arr[]) {
  int mini = Integer.MAX_VALUE;
  for (int x : arr)
    mini = min(mini, x);
  return mini;
}

static long maxArr(long arr[]) {
  long maxi = Long.MIN_VALUE;
  for (long x : arr)
    maxi = max(maxi, x);
  return maxi;
}

static long minArr(long arr[]) {
  long mini = Long.MAX_VALUE;
  for (long x : arr)
    mini = min(mini, x);
  return mini;
}

static int gcd(int a, int b) {
  if (b == 0)
    return a;
  return gcd(b, a % b);
}

static long gcd(long a, long b) {
  if (b == 0)
    return a;
  return gcd(b, a % b);
}

static void ruffleSort(int[] a) {
  int n = a.length;
  Random r = new Random();
  for (int i = 0; i < a.length; i++) {
    int oi = r.nextInt(n);
    int temp = a[i];
    a[i] = a[oi];
    a[oi] = temp;
  }
  Arrays.sort(a);
}

public static int binarySearch(int a[], int target) {
  int left = 0;
  int right = a.length - 1;
  int mid = (left + right) / 2;
  int i = 0;
  while (left <= right) {
    if (a[mid] <= target) {
      i = mid + 1;
      left = mid + 1;
    } else {
      right = mid - 1;
    }
    mid = (left + right) / 2;
  }
  return i;
}

static class FastScanner {
  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st = new StringTokenizer("");

  String next() {
    while (!st.hasMoreTokens())
      try {
        st = new StringTokenizer(br.readLine());
      } catch (IOException e) {
        e.printStackTrace();
      }
    return st.nextToken();
  }

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

  int[] readArray(int n) {
    int[] a = new int[n];
    for (int i = 0; i < n; i++)
      a[i] = nextInt();
    return a;
  }

  long[] readLongArray(int n) {
    long[] a = new long[n];
    for (int i = 0; i < n; i++)
      a[i] = nextLong();
    return a;
  }

  int[][] read2dArray(int n, int m) {
    int arr[][] = new int[n][m];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        arr[i][j] = nextInt();
      }
    }
    return arr;
  }

  ArrayList<Integer> readArrayList(int n) {
    ArrayList<Integer> arr = new ArrayList<Integer>();
    for (int i = 0; i < n; i++) {
      int a = nextInt();
      arr.add(a);
    }
    return arr;
  }

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

static class pair {
  int fr, sc;

  pair(int fr, int sc) {
    this.fr = fr;
    this.sc = sc;
  }
}

////////////////////////////////////////////////////////////////////////////////////  

}