


def  _a			(						__UpperCamelCase ):

     # bit count represents no. of bits in the gray code
     if bit_count < 0:
          raise ValueError("""The given input must be positive""" )

     # get the generated string sequence
     a_    :     Tuple										=    gray_code_sequence_string(__UpperCamelCase )
     #
     # convert them to integers
     for i in range(len(__UpperCamelCase ) ):
          a_    :     Any										=    int(sequence[i]  ,  2 )

     return sequence



def  _a			(						__UpperCamelCase ):

     # The approach is a recursive one
     # Base case achieved when either n = 0 or n=1
     if bit_count == 0:
          return ["0"]

     if bit_count == 1:
          return ["0", "1"]

     a_    :     Optional[int]										=    1 << bit_count  # defines the length of the sequence
     # 1<< n is equivalent to 2^n

     # recursive answer will generate answer for n-1 bits
     a_    :     int										=    gray_code_sequence_string(bit_count - 1 )

     a_    :     List[Any]										=    []

     # append 0 to first half of the smaller sequence generated
     for i in range(seq_len // 2 ):
          a_    :     Optional[int]										=    """0""" + smaller_sequence[i]
          sequence.append(__UpperCamelCase )

     # append 1 to second half ... start from the end of the list
     for i in reversed(range(seq_len // 2 ) ):
          a_    :     str										=    """1""" + smaller_sequence[i]
          sequence.append(__UpperCamelCase )

     return sequence


if __name__ == "__main__":
       import doctest

       doctest.testmod()







from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt



def  _a			(						__UpperCamelCase ):
     a_    :     int										=    int(number**0.5 )
     return number == sq * sq



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase ):
     a_    :     int										=    x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
     a_    :     int										=    x_den * y_den * z_den
     a_    :     int										=    gcd(__UpperCamelCase  ,  __UpperCamelCase )
     top //= hcf
     bottom //= hcf
     return top, bottom



def  _a			(						__UpperCamelCase = 3_5 ):
     a_    :     set										=    set()
     a_    :     int
     a_    :     Fraction										=    Fraction(0 )
     a_    :     tuple[int, int]

     for x_num in range(1  ,  order + 1 ):
          for x_den in range(x_num + 1  ,  order + 1 ):
               for y_num in range(1  ,  order + 1 ):
                    for y_den in range(y_num + 1  ,  order + 1 ):
                         # n=1
                         a_    :     int										=    x_num * y_den + x_den * y_num
                         a_    :     Optional[int]										=    x_den * y_den
                         a_    :     Optional[Any]										=    gcd(__UpperCamelCase  ,  __UpperCamelCase )
                         z_num //= hcf
                         z_den //= hcf
                         if 0 < z_num < z_den <= order:
                              a_    :     Optional[int]										=    add_three(
                                  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase )
                              unique_s.add(__UpperCamelCase )

                         # n=2
                         a_    :     List[Any]										=    (
                             x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
                         )
                         a_    :     str										=    x_den * x_den * y_den * y_den
                         if is_sq(__UpperCamelCase ) and is_sq(__UpperCamelCase ):
                              a_    :     Optional[Any]										=    int(sqrt(__UpperCamelCase ) )
                              a_    :     Optional[int]										=    int(sqrt(__UpperCamelCase ) )
                              a_    :     Optional[Any]										=    gcd(__UpperCamelCase  ,  __UpperCamelCase )
                              z_num //= hcf
                              z_den //= hcf
                              if 0 < z_num < z_den <= order:
                                   a_    :     str										=    add_three(
                                       __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase )
                                   unique_s.add(__UpperCamelCase )

                    # n=-1
                         a_    :     Union[str, Any]										=    x_num * y_num
                         a_    :     Tuple										=    x_den * y_num + x_num * y_den
                         a_    :     List[Any]										=    gcd(__UpperCamelCase  ,  __UpperCamelCase )
                         z_num //= hcf
                         z_den //= hcf
                         if 0 < z_num < z_den <= order:
                              a_    :     Union[str, Any]										=    add_three(
                                  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase )
                              unique_s.add(__UpperCamelCase )

                         # n=2
                         a_    :     Union[str, Any]										=    x_num * x_num * y_num * y_num
                         a_    :     Dict										=    (
                             x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
                         )
                         if is_sq(__UpperCamelCase ) and is_sq(__UpperCamelCase ):
                              a_    :     Dict										=    int(sqrt(__UpperCamelCase ) )
                              a_    :     Union[str, Any]										=    int(sqrt(__UpperCamelCase ) )
                              a_    :     Dict										=    gcd(__UpperCamelCase  ,  __UpperCamelCase )
                              z_num //= hcf
                              z_den //= hcf
                              if 0 < z_num < z_den <= order:
                                   a_    :     List[Any]										=    add_three(
                                       __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase )
                                   unique_s.add(__UpperCamelCase )

     for num, den in unique_s:
          total += Fraction(__UpperCamelCase  ,  __UpperCamelCase )

     return total.denominator + total.numerator


if __name__ == "__main__":
       print(f'''{solution() = }''')



