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.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.InputMismatchException;
  
  /**
   * @author ethan55
   */
  public class Solution {
  
    public static void main(String[] args) {
      TestRunner.run();
    }
  
    public static class TestCase {
  
      static final boolean MULTIPLE = true;
  
      public void solve(InputReader in, OutputWriter out) {
        int n = in.nextInt();
        int s = in.nextInt();
  
        int div = (int) Math.ceil((double) (n + 1) / 2);
        out.println(s / div);
      }
    }
  
    public static class TestRunner {
  
      public static void run() {
        InputReader in = new InputReader(System.in);
        try (OutputWriter out = new OutputWriter(System.out)) {
          int testCases = TestCase.MULTIPLE ? in.nextInt() : 1;
          for (int i = 1; i <= testCases; i++) {
            new TestCase().solve(in, out);
          }
        }
      }
  
    }
  
    public static class OutputWriter implements AutoCloseable {
  
      private static final int BUFFER_SIZE = 1 << 13;
      private final byte[] outputBuffer = new byte[BUFFER_SIZE];
      private final OutputStream outputStream;
      private int outputBufferIndex = 0;
  
      public OutputWriter(OutputStream os) {
        this.outputStream = os;
      }
  
      public OutputWriter println(int x) {
        return writeln(x);
      }
  
      public void flush() {
        innerFlush();
        try {
          outputStream.flush();
        } catch (IOException e) {
          throw new IllegalStateException("Failed to flush");
        }
      }
  
      private OutputWriter write(byte b) {
        outputBuffer[outputBufferIndex++] = b;
        if (outputBufferIndex == BUFFER_SIZE) {
          innerFlush();
        }
        return this;
      }
  
      private OutputWriter write(String s) {
        s.chars()
            .forEach(
                c -> {
                  outputBuffer[outputBufferIndex++] = (byte) c;
                  if (outputBufferIndex == BUFFER_SIZE) {
                    innerFlush();
                  }
                });
        return this;
      }
  
      private OutputWriter write(int x) {
        if (x == Integer.MIN_VALUE) {
          return write((long) x);
        }
        if (outputBufferIndex + 12 >= BUFFER_SIZE) {
          innerFlush();
        }
        if (x < 0) {
          write((byte) '-');
          x = -x;
        }
        int d = countDigits(x);
        for (int i = outputBufferIndex + d - 1; i >= outputBufferIndex; i--) {
          outputBuffer[i] = (byte) ('0' + x % 10);
          x /= 10;
        }
        outputBufferIndex += d;
        return this;
      }
  
      private static int countDigits(long l) {
        if (l >= 1000000000000000000L) {
          return 19;
        }
        if (l >= 100000000000000000L) {
          return 18;
        }
        if (l >= 10000000000000000L) {
          return 17;
        }
        if (l >= 1000000000000000L) {
          return 16;
        }
        if (l >= 100000000000000L) {
          return 15;
        }
        if (l >= 10000000000000L) {
          return 14;
        }
        if (l >= 1000000000000L) {
          return 13;
        }
        if (l >= 100000000000L) {
          return 12;
        }
        if (l >= 10000000000L) {
          return 11;
        }
        if (l >= 1000000000L) {
          return 10;
        }
        if (l >= 100000000L) {
          return 9;
        }
        if (l >= 10000000L) {
          return 8;
        }
        if (l >= 1000000L) {
          return 7;
        }
        if (l >= 100000L) {
          return 6;
        }
        if (l >= 10000L) {
          return 5;
        }
        if (l >= 1000L) {
          return 4;
        }
        if (l >= 100L) {
          return 3;
        }
        if (l >= 10L) {
          return 2;
        }
        return 1;
      }
  
      private OutputWriter write(long x) {
        if (x == Long.MIN_VALUE) {
          return write("" + x);
        }
        if (outputBufferIndex + 21 >= BUFFER_SIZE) {
          innerFlush();
        }
        if (x < 0) {
          write((byte) '-');
          x = -x;
        }
        int d = countDigits(x);
        for (int i = outputBufferIndex + d - 1; i >= outputBufferIndex; i--) {
          outputBuffer[i] = (byte) ('0' + x % 10);
          x /= 10;
        }
        outputBufferIndex += d;
        return this;
      }
  
      private OutputWriter writeln(int x) {
        return write(x).writeln();
      }
  
      private OutputWriter writeln() {
        return write((byte) '\n');
      }
  
      private void innerFlush() {
        try {
          outputStream.write(outputBuffer, 0, outputBufferIndex);
          outputBufferIndex = 0;
        } catch (IOException e) {
          throw new IllegalStateException("Failed to inner flush");
        }
      }
  
      @Override
      public void close() {
        flush();
      }
    }
  
    public static class InputReader {
  
      private final InputStream inputStream;
      private final byte[] inputBuffer = new byte[1024];
      private int bytesRead = 0;
      private int inputBufferIndex = 0;
  
      public InputReader(InputStream inputStream) {
        this.inputStream = inputStream;
      }
  
      private int readByte() {
        if (bytesRead == -1) {
          throw new InputMismatchException();
        }
        if (inputBufferIndex >= bytesRead) {
          inputBufferIndex = 0;
          try {
            bytesRead = inputStream.read(inputBuffer);
          } catch (IOException e) {
            throw new InputMismatchException();
          }
          if (bytesRead <= 0) {
            return -1;
          }
        }
        return inputBuffer[inputBufferIndex++];
      }
  
      public int nextInt() {
        return (int) nextLong();
      }
  
      public long nextLong() {
        long num = 0;
        int b;
        boolean minus = false;
        do {
          b = readByte();
        } while (b != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if (b == '-') {
          minus = true;
          b = readByte();
        }
  
        while (true) {
          if (b >= '0' && b <= '9') {
            num = num * 10 + (b - '0');
          } else {
            return minus ? -num : num;
          }
          b = readByte();
        }
      }
  
    }
  }