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.IOException;
  import java.io.InputStreamReader;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Random;
  import java.util.StringTokenizer;
  import java.util.*;
  
  
  public class Template1 {
  	static FastReader in=new FastReader();
      static final Random random=new Random();
      static long mod=1000000007L;
     
      
     
   
      public static void main(String args[]) throws IOException {
      	Template1.FastReader res = new FastReader();
      	int t=res.nextInt();
      	
      	
          
          
          
          
          while(t>0)
          {
          	int n = res.nextInt();
          	int s = res.nextInt();
          	int ans = s/((n/2) +1);
          	System.out.println(ans);
          	
          	
          	        	 
          	
          	
  			t--;
          	
          	
          	
          }
         
   
      }
   
   
   
   
   
   
      static int max(int a, int b)
      {
          if(a<b)
          	return b;
          return a;
      }
   
   
      static void ruffleSort(int[] a) {
          int n=a.length;
          for (int i=0; i<n; i++) {
              int oi=random.nextInt(n), temp=a[oi];
              a[oi]=a[i]; a[i]=temp;
          }
          Arrays.sort(a);
      }
   
      static < E > void print(E res)
      {
          System.out.println(res);
      }
   
   
      static  int gcd(int a,int b)
      {
          if(b==0)
          {
              return a;
          }
          return gcd(b,a%b);
      }
   
      static int lcm(int a, int b)
      {
          return (a / gcd(a, b)) * b;
      }
   
   
      static int abs(int a)
      {
          if(a<0)
              return -1*a;
          return a;
      }
   
      static class FastReader
      {
          BufferedReader br;
          StringTokenizer st;
   
          public FastReader()
          {
              br = new BufferedReader(new
                      InputStreamReader(System.in));
          }
   
          String next()
          {
              while (st == null || !st.hasMoreElements())
              {
                  try
                  {
                      st = new StringTokenizer(br.readLine());
                  }
                  catch (IOException  e)
                  {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
          int nextInt()
          {
              return Integer.parseInt(next());
          }
   
          long nextLong()
          {
              return Long.parseLong(next());
          }
   
          double nextDouble()
          {
              return Double.parseDouble(next());
          }
          String nextLine()
          {
              String str = "";
              try
              {
                  str = br.readLine();
              }
              catch (IOException e)
              {
                  e.printStackTrace();
              }
              return str;
          }
   
          int [] readintarray(int n) {
              int res [] = new int [n];
              for(int i = 0; i<n; i++)res[i] = nextInt();
              return res;
          }
          long [] readlongarray(int n) {
              long res [] = new long [n];
              for(int i = 0; i<n; i++)res[i] = nextLong();
              return res;
          }
      }
   
  	
  
  }
  