description: 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] 
solution: 
  
  import java.io.BufferedReader;
  import java.io.InputStreamReader;
  import java.util.Arrays;
  import java.util.StringTokenizer;
  
  import static java.lang.System.out;
  
  public class RoundGlobal16A
  {
      public static void main(String[] args) throws Exception
      {
          BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
          StringTokenizer st = new StringTokenizer(infile.readLine());
          int T = Integer.parseInt(st.nextToken());
          StringBuilder sb = new StringBuilder();
          while(T-->0)
          {
              st = new StringTokenizer(infile.readLine());
              long n = Long.parseLong(st.nextToken());
              long s = Long.parseLong(st.nextToken());
  
              if(n == 1){
                  sb.append(s);
              } else if(s == 1){
                  sb.append(0);
              } else {
                  if(n % 2 == 0){
                      sb.append(s / ((n/2) + 1));
                  } else {
                      sb.append(s / (int) Math.ceil((double)n / 2));
                  }
              }
              sb.append("\n");
          }
          out.println(sb);
          //BufferedReader infile = new BufferedReader(new FileReader("input.txt"));
          //System.setOut(new PrintStream(new File("output.txt")));
      }
      public static int[] readArr(int N, BufferedReader infile, StringTokenizer st) throws Exception
      {
          int[] arr = new int[N];
          st = new StringTokenizer(infile.readLine());
          for(int i=0; i < N; i++)
              arr[i] = Integer.parseInt(st.nextToken());
          return arr;
      }
      public static void print(int[] arr)
      {
          //for debugging only
          for(int x: arr)
              out.print(x+" ");
          out.println();
      }
  
      public static long[] readArr2(int N, BufferedReader infile, StringTokenizer st) throws Exception
      {
          long[] arr = new long[N];
          st = new StringTokenizer(infile.readLine());
          for(int i=0; i < N; i++)
              arr[i] = Long.parseLong(st.nextToken());
          return arr;
      }
      public static boolean isPrime(long n)
      {
          if(n < 2) return false;
          if(n == 2 || n == 3) return true;
          if(n%2 == 0 || n%3 == 0) return false;
          long sqrtN = (long)Math.sqrt(n)+1;
          for(long i = 6L; i <= sqrtN; i += 6) {
              if(n%(i-1) == 0 || n%(i+1) == 0) return false;
          }
          return true;
      }
      public static long gcd(long a, long b)
      {
          if(a > b)
              a = (a+b)-(b=a);
          if(a == 0L)
              return b;
          return gcd(b%a, a);
      }
  
      public static int lcm(int a, int b) {
          return (a * b) / lcm(a, b);
      }
  
      public static String sort(String s){
          char[] c = s.toCharArray();
          Arrays.sort(c);
          return new String(c);
      }
  
      static String deleteIth(String str, int i)
      {
          str = str.substring(0, i) +
                  str.substring(i + 1);
          return str;
      }
  }