@Test(timeout = 100)
  public void testCalcBasic1() {
    long bitSequence = Long.parseLong("1010110", 2);
    long res = Solution.calcHamming(bitSequence, 7, true);
    assertEquals(0b01110100110, res);
  }

  @Test(timeout = 100)
  public void testCalcBasic3() {
    long bitSequence = Long.parseLong("10011001111", 2);
    long res = Solution.calcHamming(bitSequence, 11, true);
    assertEquals(Long.parseLong("101100111001111", 2), res);
  }

  @Test(timeout = 100)
  public void testCalcBasicFalse() {
    long bitSequence = Long.parseLong("1", 2);
    long res = Solution.calcHamming(bitSequence, 3, false);
    assertEquals(33, res);
  }

  @Test(timeout = 100)
  public void testCalcBasicTrue() {
    long bitSequence = Long.parseLong("1", 2);
    long res = Solution.calcHamming(bitSequence, 3, true);
    assertEquals(21, res);
  }

  @Test(timeout = 100)
  public void testCalcBasic4() {
    long bitSequence = Long.parseLong("00000000001", 2);
    long res = Solution.calcHamming(bitSequence, 11, true);
    assertEquals(Long.parseLong("110100010000001", 2), res);
  }

  @Test(timeout = 100)
  public void testCalcBasic6() {
    long bitSequence = Long.parseLong("111111111111111111111111111111111111111111111111111111111", 2);
    long res = Solution.calcHamming(bitSequence, 57, true);
    assertEquals(Long.parseLong("111111111111111111111111111111111111111111111111111111111111111", 2), res);

  }

  @Test(timeout = 100)
  public void testCheckBasic10() {
    long bitSequence = Long.MAX_VALUE;
    long res = Solution.checkHamming(bitSequence, 64, true);
    assertEquals(Long.MAX_VALUE, 2, res);
  }

  @Test(timeout = 100)
  public void testCheckBasic9() {
    long bitSequence = Long.parseLong("111111111111111111111111111111111111111111111111111111111111111", 2);
    long res = Solution.checkHamming(bitSequence, 63, true);
    assertEquals(Long.parseLong("111111111111111111111111111111111111111111111111111111111111111", 2), res);
  }

  @Test(timeout = 100)
  public void testCalcBasic5() {
    long bitSequence = Long.parseLong("11111111110", 2);
    long res = Solution.calcHamming(bitSequence, 11, true);
    assertEquals(Long.parseLong("001011101111110", 2), res);
  }

  @Test(timeout = 100)
  public void testCheckBasic1() {
    long bitSequence = Long.parseLong("110111010001", 2);
    long res = Solution.checkHamming(bitSequence, 15, false);
    assertEquals(0b000110111011001, res);
  }

  @Test(timeout = 100)
  public void testCheckBasic2() {
    long bitSequence = Long.parseLong("10111", 2);
    long res = Solution.checkHamming(bitSequence, 6, true);
    assertEquals(21, res);
  }

  @Test(timeout = 100)
  public void testCheckBasic3() {
    long bitSequence = Long.parseLong("1110100110", 2);
    long res = Solution.checkHamming(bitSequence, 11, true);
    assertEquals(934, res);
  }

  @Test(timeout = 100)
  public void testCheckBasic4() {
    long bitSequence = Long.parseLong("100001", 2);
    long res = Solution.checkHamming(bitSequence, 6, false);
    assertEquals(33, res);
  }

  @Test(timeout = 100)
  public void testCheckBasic5() {
    long bitSequence = Long.parseLong("1101101", 2);
    long res = Solution.checkHamming(bitSequence, 7, true);
    assertEquals(Long.parseLong("1101001", 2), res);
  }

  @Test(timeout = 100)
  public void testCheckBasic6() {
    long bitSequence = Long.parseLong("1011011", 2);
    long res = Solution.checkHamming(bitSequence, 7, false);
    assertEquals(Long.parseLong("1011011", 2), res);
  }

  @Test(timeout = 100)
  public void testCheckBasic7() {
    long bitSequence = Long.parseLong("101100111001111", 2);
    long res = Solution.checkHamming(bitSequence, 15, true);
    assertEquals(Long.parseLong("101100111001111", 2), res);
  }

  @Test(timeout = 100)
  public void testCheckBasicLength5() {
    long bitSequence = Long.parseLong("10110", 2);
    long res = Solution.calcHamming(bitSequence, 5, true);
    assertEquals(Long.parseLong("011001100", 2), res);
  }

  @Test(timeout = 100)
  public void testCalcBasicThresh1() {
    long bitSequence = Long.parseLong("11001010", 2);
    long res = Solution.calcHamming(bitSequence, 8, true);
    assertEquals(Long.parseLong("001110001010", 2), res);
  }

  @Test(timeout = 100)
  public void testCalcBasicThresh2() {
    long bitSequence = Long.parseLong("11001010", 2);
    long res = Solution.calcHamming(bitSequence, 8, false);
    assertEquals(Long.parseLong("111010011010", 2), res);
  }

  @Test(timeout = 100)
  public void testCalcBasicThresh3() {
    long bitSequence = Long.parseLong("111000111000111", 2);
    long res = Solution.calcHamming(bitSequence, 15, true);
    assertEquals(Long.parseLong("11111101001110010111", 2), res);
  }

  @Test(timeout = 100)
  public void testCalcBasicThresh4() {
    long bitSequence = Long.parseLong("111000111000111", 2);
    long res = Solution.calcHamming(bitSequence, 15, false);
    assertEquals(Long.parseLong("00101100001110000111", 2), res);
  }

    @Test(timeout = 100)
  public void testCalcBasicT1() {
    long bitSequence = Long.parseLong("1010110", 2);
    long res = Solution.calcHamming(bitSequence, 7, true);
    assertEquals(0b01110100110, res);
  }

  @Test(timeout = 100)
  public void testCalcBasicT2() {
    long bitSequence = Long.parseLong("1001000100", 2);
    long res = Solution.calcHamming(bitSequence, 10, false);
    assertEquals(0b11110010000100, res);
  }

  @Test(timeout = 100)
  public void testCalcBasicT3() {
    long bitSequence = Long.parseLong("0", 2);
    long res = Solution.calcHamming(bitSequence, 4, false);
    assertEquals(0b1101000, res);
  }

  @Test(timeout = 100)
  public void testCalcBasicT4() {
    long bitSequence = Long.parseLong("11", 2);
    long res = Solution.calcHamming(bitSequence, 8, false);
    assertEquals(0b000000010011, res);
  }

  @Test(timeout = 100)
  public void testCalcBasicT5() {
    long bitSequence = Long.parseLong("1000001", 2);
    long res = Solution.calcHamming(bitSequence, 7, true);
    assertEquals(0b00100001001, res);
  }

  @Test(timeout = 100)
  public void testCheckBasicT1() {
    long bitSequence = Long.parseLong("110111010001", 2);
    long res = Solution.checkHamming(bitSequence, 15, false);
    assertEquals(0b000110111011001, res);
  }

  @Test(timeout = 100)
  public void testCheckBasicT2() {
    long bitSequence = Long.parseLong("11110010000100", 2);
    long res = Solution.checkHamming(bitSequence, 14, false);
    assertEquals(0b11110010000100, res);
  }

  @Test(timeout = 100)
  public void testCheckBasicT3() {
    long bitSequence = Long.parseLong("0101000", 2);
    long res = Solution.checkHamming(bitSequence, 7, false);
    assertEquals(0b1101000, res);
  }

  @Test(timeout = 100)
  public void testCheckBasicT4() {
    long bitSequence = Long.parseLong("1110101110", 2);
    long res = Solution.checkHamming(bitSequence, 11, true);
    assertEquals(0b01110100110, res);
  }

  @Test
  public void testCalcYT(){
    long bitSequence = Long.parseLong("010011010",2);
    long res = Solution.calcHamming(bitSequence, 8, true);
    assertEquals(0b011100101010, res);
  }

  @Test(timeout = 100)
  public void testFormat5() {
    long bitSequence = Long.parseLong("0", 2);
    long res = Solution.calcHamming(bitSequence, 1, false);
    assertEquals(0b110, res);
  }

  @Test(timeout = 100)
  public void testFormat6() {
    long bitSequence = Long.parseLong("0", 2);
    long res = Solution.calcHamming(bitSequence, 1, true);
    assertEquals(0b0, res);
  }

  @Test(timeout = 100)
  public void testFormat7() {
    long bitSequence = Long.parseLong("0", 2);
    long res = Solution.calcHamming(bitSequence, 2, false);
    assertEquals(0b11010, res);
  }

  @Test(timeout = 100)
  public void testFormat8() {
    long bitSequence = Long.parseLong("0", 2);
    long res = Solution.calcHamming(bitSequence, 21, false);
    assertEquals(54789120, res);
  }

  @Test(timeout = 100)
  public void testCalcBasic1L() {
    long bitSequence = Long.parseLong("1010110", 2);
    long res = Solution.calcHamming(bitSequence, 7, true);
    assertEquals(0b01110100110, res);
  }

  @Test(timeout = 100)
  public void testCheckBasic1L() {
    long bitSequence = Long.parseLong("110111010001", 2);
    long res = Solution.checkHamming(bitSequence, 15, false);
    assertEquals(0b000110111011001, res);
  }

  @Test
  public void testCheckFromBookL(){
    long bitSequence = Long.parseLong("00101001001", 2);
    long res = Solution.checkHamming(bitSequence, 11, true);
    assertEquals(0b100001001, res);
  }

  @Test
  public void testCalcYTL(){
    long bitSequence = Long.parseLong("010011010",2);
    long res = Solution.calcHamming(bitSequence, 8, true);
    assertEquals(0b011100101010, res);
  }

  @Test
  public void testCalcFalseL(){
    long bitSequence = Long.parseLong("0011010",2);
    long res = Solution.calcHamming(bitSequence, 7, false);
    assertEquals(0b00010110010, res);
    assertEquals(Solution.calcHamming(bitSequence, 0, true), 0);
  }

  @Test
  public void testCheckTrueL(){
    long bitSequence = Long.parseLong("011100101110", 2);
    long res = Solution.checkHamming(bitSequence, 12, true);
    assertEquals(0b011100101010, res);
  }

  @Test
  public void testCalcAndCheckFalseL(){
    long res2 = Solution.checkHamming(0b101001011100, 12, false);
    assertEquals(0b101001011100, res2);
  }

  @Test
  public void TestCheckTrueCorrectL(){
    long bitSequence = Long.parseLong("00100001001",2);
    long res = Solution.checkHamming(bitSequence, 11, true);
    assertEquals(0b00100001001, res);

  }

  @Test
  public void testEdgeCase(){
    long res = Solution.calcHamming(0, 0, true);
    assertEquals(0, res);
  }