




def 							_A       (						lowerCAmelCase_					: int      ) ->    List[Any]:
     """simple docstring"""

     if bit_count < 0:
          raise ValueError("The given input must be positive"      )

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

     return sequence



def 							_A       (						lowerCAmelCase_					: int      ) ->    str:
     """simple docstring"""

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

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

     lowerCAmelCase__          =			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
     lowerCAmelCase__          =			gray_code_sequence_string(bit_count - 1      )

     lowerCAmelCase__          =			[]

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

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

     return sequence


if __name__ == "__main__":
     import doctest

     doctest.testmod()






def 							_A       (						lowerCAmelCase_					: int = 1000      ):
     """simple docstring"""

     return sum(2 * a * ((a - 1) // 2) for a in range(3       ,    n + 1      )      )


if __name__ == "__main__":
     print(solution())
