


def 							_UpperCAmelCase				(UpperCamelCase__     :  int				,							UpperCamelCase__     :  int						):
       if not isinstance(UpperCamelCase__				,							UpperCamelCase__						):
              raise ValueError("iterations must be defined as integers"						)
       if not isinstance(UpperCamelCase__				,							UpperCamelCase__						) or not number >= 1:
              raise ValueError(
                  "starting number must be\n                         and integer and be more than 0"						)
       if not iterations >= 1:
              raise ValueError("Iterations must be done more than 0 times to play FizzBuzz"						)

       _A      :       Tuple				    = ""
       while number <= iterations:
              if number % 3 == 0:
                     out += "Fizz"
              if number % 5 == 0:
                     out += "Buzz"
              if 0 not in (number % 3, number % 5):
                     out += str(UpperCamelCase__						)

              # print(out)
              number += 1
              out += " "
       return out


if __name__ == "__main__":
    import doctest

    doctest.testmod()







class     SCREAMING_SNAKE_CASE__ :



 def __init__(							self,__lowerCamelCase ):
        A__											=						set_counts
        A__											=						max(__lowerCamelCase )
        A__											=						len(__lowerCamelCase )
        A__											=						[1] * num_sets
        A__											=						list(range(__lowerCamelCase ) )



 def 				UpperCamelCase			(							self,__lowerCamelCase,__lowerCamelCase ):
        A__											=						self.get_parent(__lowerCamelCase )
        A__											=						self.get_parent(__lowerCamelCase )

        if src_parent == dst_parent:
               return False

        if self.ranks[dst_parent] >= self.ranks[src_parent]:
               self.set_counts[dst_parent] += self.set_counts[src_parent]
               A__											=						0
               A__											=						dst_parent
               if self.ranks[dst_parent] == self.ranks[src_parent]:
                      self.ranks[dst_parent] += 1
               A__											=						self.set_counts[dst_parent]
        else:
               self.set_counts[src_parent] += self.set_counts[dst_parent]
               A__											=						0
               A__											=						src_parent
               A__											=						self.set_counts[src_parent]

        A__											=						max(self.max_set,__lowerCamelCase )
        return True




 def 				UpperCamelCase			(							self,__lowerCamelCase ):
        if self.parents[disj_set] == disj_set:
               return disj_set
        A__											=						self.get_parent(self.parents[disj_set] )
        return self.parents[disj_set]





