"""simple docstring"""



SCREAMING_SNAKE_CASE__:dict[tuple[int, int, int], int]									=			{}



def 	_lowerCamelCase(	a   ,    a   ,    a				):

       # if we are absent twice, or late 3 consecutive days,
       # no further prize strings are possible
       if late == 3 or absent == 2:
              return 0

       # if we have no days left, and have not failed any other rules,
       # we have a prize string
       if days == 0:
              return 1

       # No easy solution, so now we need to do the recursive calculation

       # First, check if the combination is already in the cache, and
       # if yes, return the stored value from there since we already
       # know the number of possible prize strings from this point on
       __a       =    (days, absent, late)
       if key in cache:
              return cache[key]

       # now we calculate the three possible ways that can unfold from
       # this point on, depending on our attendance today

       # 1) if we are late (but not absent), the "absent" counter stays as
       # it is, but the "late" counter increases by one
       __a       =    _calculate(days - 1   ,    a   ,    late + 1				)

       # 2) if we are absent, the "absent" counter increases by 1, and the
       # "late" counter resets to 0
       __a       =    _calculate(days - 1   ,    absent + 1   ,    0				)

       # 3) if we are on time, this resets the "late" counter and keeps the
       # absent counter
       __a       =    _calculate(days - 1   ,    a   ,    0				)

       __a       =    state_late + state_absent + state_ontime

       __a       =    prizestrings
       return prizestrings



def 	_lowerCamelCase(	a = 3_0				):
       return _calculate(a   ,    absent=0   ,    late=0				)


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

"""simple docstring"""



from __future__ import annotations

from math import pi



def 	_lowerCamelCase(	a   ,    a   ,    a				):

       if (inductance, frequency, reactance).count(0				) != 1:
              raise ValueError("One and only one argument must be 0"				)
       if inductance < 0:
              raise ValueError("Inductance cannot be negative"				)
       if frequency < 0:
              raise ValueError("Frequency cannot be negative"				)
       if reactance < 0:
              raise ValueError("Inductive reactance cannot be negative"				)
       if inductance == 0:
              return {"inductance": reactance / (2 * pi * frequency)}
       elif frequency == 0:
              return {"frequency": reactance / (2 * pi * inductance)}
       elif reactance == 0:
              return {"reactance": 2 * pi * frequency * inductance}
       else:
              raise ValueError("Exactly one argument must be 0"				)


if __name__ == "__main__":
   import doctest

   doctest.testmod()
