import math
class Name:
    def __init__(self, name: str):
        self.name = str(name)
class Symbol:
    def __init__(self, symbol: str):
        self.symbol = str(symbol)
class Unit:
    def __init__(self, name: Name, symbols: list[Symbol]):
        if not isinstance(name, Name):
            raise TypeError('name must be a Name instance.')
        if not isinstance(symbols, list) or not symbols or any(not isinstance(symbol, Symbol) for symbol in symbols):
            raise TypeError('symbols must be a non-empty list of Symbol instances.')
        self.name = name
        self.symbols = list(symbols)
meter_unit = Unit(name=Name('meter'), symbols=[Symbol('m')])
centimeter_unit = Unit(name=Name('centimeter'), symbols=[Symbol('cm')])
gram_unit = Unit(name=Name('gram'), symbols=[Symbol('g')])
kilogram_unit = Unit(name=Name('kilogram'), symbols=[Symbol('kg')])
class Value:
    def __init__(self, number: float, unit: Unit):
        if unit is None:
            raise ValueError('unit is required.')
        if not isinstance(unit, Unit):
            raise TypeError('unit must be a Unit instance.')
        self.number = float(number)
        self.unit = unit
    def convert_to(self, target_unit: Unit) -> 'Value':
        if not isinstance(target_unit, Unit):
            raise TypeError('target_unit must be a Unit instance.')
        source_name = self.unit.name.name
        target_name = target_unit.name.name
        if source_name == target_name:
            return Value(self.number, self.unit)
        factor = unit_conversion_factors.get((source_name, target_name))
        if factor is None:
            raise ValueError(f'No conversion from {source_name} to {target_name}.')
        return Value(self.number * factor, target_unit)
class Distance:
    def __init__(self, value: Value):
        if not isinstance(value, Value):
            raise TypeError('value must be a Value instance.')
        if value.unit.name.name not in {'meter', 'centimeter'}:
            raise ValueError('Distance only accepts meter or centimeter units.')
        self.value = value
unit_conversion_factors: dict[tuple[str, str], float] = {
    ('meter', 'centimeter'): 100.0,
    ('centimeter', 'meter'): 0.01,
    ('gram', 'kilogram'): 0.001,
    ('kilogram', 'gram'): 1000.0,
}
def distance_validation_probe() -> dict[str, bool]:
    value_requires_unit = False
    distance_in_kg_rejected = False
    distance_in_m_ok = False
    try:
        Value(5, None)
    except ValueError:
        value_requires_unit = True
    try:
        Distance(Value(2.0, kilogram_unit))
    except ValueError:
        distance_in_kg_rejected = True
    distance_in_m_ok = Distance(Value(2.0, meter_unit)).value.unit.name.name == 'meter'
    return dict(value_requires_unit=value_requires_unit, distance_in_kg_rejected=distance_in_kg_rejected, distance_in_m_ok=distance_in_m_ok)
kilometer_unit = Unit(name=Name('kilometer'), symbols=[Symbol('km')])
inch_unit = Unit(name=Name('inch'), symbols=[Symbol('in')])
foot_unit = Unit(name=Name('foot'), symbols=[Symbol('ft')])
kilopascal_unit = Unit(name=Name('kilopascal'), symbols=[Symbol('kPa')])
pound_unit = Unit(name=Name('pound'), symbols=[Symbol('lb')])
pascal_unit = Unit(name=Name('pascal'), symbols=[Symbol('Pa')])
unit_conversion_factors.update({('kilometer','meter'):1000.0,('meter','kilometer'):0.001,('inch','centimeter'):2.54,('centimeter','inch'):0.39370078740157477,('foot','inch'):12.0,('inch','foot'):0.08333333333333333,('foot','meter'):0.3048,('meter','foot'):3.280839895013123})
unit_conversion_factors.update({('gram','pound'):0.0022046226218487757,('pound','gram'):453.59237,('pascal','kilopascal'):0.001,('kilopascal','pascal'):1000.0})
class Constant:
    def __init__(self, name: Name, value: Value):
        if not isinstance(name, Name):
            raise TypeError('name must be a Name instance.')
        if not isinstance(value, Value):
            raise TypeError('value must be a Value instance.')
        self.name = name
        self.value = value

    def get_value(self, target_unit: Unit) -> float:
        if not isinstance(target_unit, Unit):
            raise TypeError('target_unit must be a Unit instance.')
        return self.value.convert_to(target_unit).number
newton_unit = Unit(name=Name('newton'), symbols=[Symbol('N')])
cubic_meter_unit = Unit(name=Name('cubic_meter'), symbols=[Symbol('m^3')])
gravitational_constant_unit = Unit(name=Name('gravitational_constant_unit'), symbols=[Symbol('m^3/(kg*s^2)')])
gravitational_constant = Constant(name=Name('gravitational_constant'), value=Value(6.6743e-11, gravitational_constant_unit))
meter_per_second_squared_unit = Unit(name=Name('meter_per_second_squared'), symbols=[Symbol('m/s^2')])
kilogram_per_cubic_meter_unit = Unit(name=Name('kilogram_per_cubic_meter'), symbols=[Symbol('kg/m^3')])
class Mass:
    def __init__(self, value: Value):
        if not isinstance(value, Value):
            raise TypeError('value must be a Value instance.')
        if value.unit.name.name not in {'gram', 'kilogram', 'pound'}:
            raise ValueError('Mass only accepts gram, kilogram, or pound units.')
        self.value = value
class Radius:
    def __init__(self, value: Value):
        if not isinstance(value, Value):
            raise TypeError('value must be a Value instance.')
        if value.unit.name.name not in {'meter', 'centimeter', 'kilometer', 'inch', 'foot'}:
            raise ValueError('Radius only accepts meter, centimeter, kilometer, inch, or foot units.')
        self.value = value
class Volume:
    def __init__(self, value: Value):
        if not isinstance(value, Value):
            raise TypeError('value must be a Value instance.')
        if value.unit.name.name not in {'cubic_meter'}:
            raise ValueError('Volume only accepts cubic_meter units.')
        self.value = value
class Shape:
    def volume(self) -> Volume:
        raise NotImplementedError('Shape.volume() must be implemented by subclasses.')
class Cylinder(Shape):
    def __init__(self, radius: Radius, height: Distance):
        if not isinstance(radius, Radius):
            raise TypeError('radius must be a Radius instance.')
        if not isinstance(height, Distance):
            raise TypeError('height must be a Distance instance.')
        self.radius = radius
        self.height = height

    def volume(self) -> Volume:
        radius_m = self.radius.value.convert_to(meter_unit).number
        height_m = self.height.value.convert_to(meter_unit).number
        result = cylinder_volume_m3(radius_m, height_m)
        return Volume(Value(result, cubic_meter_unit))
class PhysicalObject:
    def __init__(self, name: Name, mass: Mass | None = None, shape: Shape | None = None, volume: Volume | None = None):
        if not isinstance(name, Name):
            raise TypeError('name must be a Name instance.')
        if mass is not None and not isinstance(mass, Mass):
            raise TypeError('mass must be a Mass instance when provided.')
        if shape is not None and not isinstance(shape, Shape):
            raise TypeError('shape must be a Shape instance when provided.')
        if volume is not None and not isinstance(volume, Volume):
            raise TypeError('volume must be a Volume instance when provided.')
        self.name = name
        self.mass = mass
        self.shape = shape
        self.volume = volume

    def get_volume(self) -> Volume:
        if self.volume is not None:
            return self.volume
        if self.shape is not None:
            return self.shape.volume()
        raise ValueError('volume is not available.')

    def calculate_density(self) -> Value:
        if self.mass is None:
            raise ValueError('mass is required to calculate density.')
        volume = self.get_volume()
        mass_kg = self.mass.value.convert_to(kilogram_unit).number
        volume_m3 = volume.value.convert_to(cubic_meter_unit).number
        if volume_m3 <= 0:
            raise ValueError('volume must be greater than zero.')
        return Value(mass_kg / volume_m3, kilogram_per_cubic_meter_unit)
    def weight(self) -> Value:
        if self.mass is None:
            raise ValueError('mass is required to calculate weight.')
        return calculate_weight(self.mass)
    def momentum(self, velocity: Value) -> Value:
        if self.mass is None:
            raise ValueError('mass is required to calculate momentum.')
        return momentum(self.mass, velocity)
    def kinetic_energy(self, velocity: Value) -> Value:
        if self.mass is None:
            raise ValueError('mass is required to calculate kinetic energy.')
        return kinetic_energy(self.mass, velocity)
standard_gravity = Constant(name=Name('standard_gravity'), value=Value(9.80665, meter_per_second_squared_unit))
class Force:
    def __init__(self, value: Value):
        if not isinstance(value, Value):
            raise TypeError('value must be a Value instance.')
        if value.unit.name.name != 'newton':
            raise ValueError('Force only accepts newton units.')
        self.value = value
def calculate_net_force(mass: Mass, acceleration: Value) -> Value:
    if not isinstance(mass, Mass):
        raise TypeError('mass must be a Mass instance.')
    if not isinstance(acceleration, Value):
        raise TypeError('acceleration must be a Value instance.')
    acceleration_m_s2 = acceleration.convert_to(meter_per_second_squared_unit).number
    mass_kg = mass.value.convert_to(kilogram_unit).number
    return Value(mass_kg * acceleration_m_s2, newton_unit)
def calculate_weight(mass: Mass) -> Value:
    if not isinstance(mass, Mass):
        raise TypeError('mass must be a Mass instance.')
    mass_kg = mass.value.convert_to(kilogram_unit).number
    g_m_s2 = standard_gravity.get_value(meter_per_second_squared_unit)
    return Value(mass_kg * g_m_s2, newton_unit)
second_unit = Unit(name=Name('second'), symbols=[Symbol('s')])
meter_per_second_unit = Unit(name=Name('meter_per_second'), symbols=[Symbol('m/s')])
def velocity_at_time_1d(v0_m_s: float, a_m_s2: float, t_s: float) -> float:
    t = float(t_s)
    if t < 0.0:
        raise ValueError('time must be non-negative.')
    return float(v0_m_s) + float(a_m_s2) * t
def position_at_time_1d(x0: Distance, v0: Value, a: Value, t: Value) -> Distance:
    if not isinstance(x0, Distance):
        raise TypeError("x0 must be a Distance instance.")
    if not isinstance(v0, Value) or not isinstance(a, Value) or not isinstance(t, Value):
        raise TypeError("v0, a, and t must be Value instances.")
    v0_m_s = v0.convert_to(meter_per_second_unit).number
    a_m_s2 = a.convert_to(meter_per_second_squared_unit).number
    t_s = t.convert_to(second_unit).number
    if t_s < 0.0:
        raise ValueError("time must be non‑negative.")
    x0_m = x0.value.convert_to(meter_unit).number
    x_m = x0_m + v0_m_s * t_s + 0.5 * a_m_s2 * (t_s ** 2)
    return Distance(Value(x_m, meter_unit))
joule_unit = Unit(name=Name('joule'), symbols=[Symbol('J')])
def potential_energy(mass: Mass, height: Distance) -> Value:
    if not isinstance(mass, Mass):
        raise TypeError('mass must be a Mass instance.')
    if not isinstance(height, Distance):
        raise TypeError('height must be a Distance instance.')
    mass_kg = mass.value.convert_to(kilogram_unit).number
    height_m = height.value.convert_to(meter_unit).number
    g_m_s2 = standard_gravity.get_value(meter_per_second_squared_unit)
    return Value(mass_kg * g_m_s2 * height_m, joule_unit)
def kinetic_energy(mass: Mass, velocity: Value) -> Value:
    if not isinstance(mass, Mass):
        raise TypeError('mass must be a Mass instance.')
    if not isinstance(velocity, Value):
        raise TypeError('velocity must be a Value instance.')
    mass_kg = mass.value.convert_to(kilogram_unit).number
    velocity_m_s = velocity.convert_to(meter_per_second_unit).number
    return Value(0.5 * mass_kg * velocity_m_s ** 2, joule_unit)
def speed_from_drop_height(height: Distance) -> Value:
    if not isinstance(height, Distance):
        raise TypeError('height must be a Distance instance.')
    height_m = height.value.convert_to(meter_unit).number
    if height_m < 0.0:
        raise ValueError('height must be non-negative.')
    g_m_s2 = standard_gravity.get_value(meter_per_second_squared_unit)
    return Value((2.0 * g_m_s2 * height_m) ** 0.5, meter_per_second_unit)
kilogram_meter_per_second_unit = Unit(name=Name('kilogram_meter_per_second'), symbols=[Symbol('kg·m/s')])
def momentum(mass: Mass, velocity: Value) -> Value:
    if not isinstance(mass, Mass):
        raise TypeError('mass must be a Mass instance.')
    if not isinstance(velocity, Value):
        raise TypeError('velocity must be a Value instance.')
    mass_kg = mass.value.convert_to(kilogram_unit).number
    velocity_m_s = velocity.convert_to(meter_per_second_unit).number
    return Value(mass_kg * velocity_m_s, kilogram_meter_per_second_unit)
newton_second_unit = Unit(name=Name('newton_second'), symbols=[Symbol('N·s')])
def impulse(mass: Mass, delta_v: Value) -> Value:
    if not isinstance(mass, Mass):
        raise TypeError('mass must be a Mass instance.')
    if not isinstance(delta_v, Value):
        raise TypeError('delta_v must be a Value instance.')
    mass_kg = mass.value.convert_to(kilogram_unit).number
    delta_v_m_s = delta_v.convert_to(meter_per_second_unit).number
    return Value(mass_kg * delta_v_m_s, newton_second_unit)
def average_force_from_impulse(impulse_value: Value, delta_t: Value) -> Value:
    if not isinstance(impulse_value, Value):
        raise TypeError('impulse_value must be a Value instance.')
    if impulse_value.unit.name.name != 'newton_second':
        raise ValueError('impulse_value must use newton_second units.')
    if not isinstance(delta_t, Value):
        raise TypeError('delta_t must be a Value instance.')
    delta_t_s = delta_t.convert_to(second_unit).number
    if delta_t_s <= 0.0:
        raise ValueError('delta_t must be positive.')
    return Value(impulse_value.number / delta_t_s, newton_unit)
def projectile_time_of_flight(v0_m_s: float, theta_deg: float) -> float:
    import math
    speed = float(v0_m_s)
    angle_deg = float(theta_deg)
    if speed < 0.0:
        raise ValueError("launch speed must be non-negative.")
    if not 0.0 <= angle_deg <= 90.0:
        raise ValueError("theta_deg must be between 0 and 90 degrees for equal-height motion.")
    g_m_s2 = standard_gravity.get_value(meter_per_second_squared_unit)
    return (2.0 * speed * math.sin(math.radians(angle_deg))) / g_m_s2
def projectile_range(v0_m_s: float, theta_deg: float) -> float:
    """Return the horizontal range for a projectile launched at v0_m_s and angle theta_deg.
    The function reuses `projectile_time_of_flight` to compute the time of flight and then multiplies by the horizontal component of the initial velocity.
    """
    import math
    # Coerce inputs
    speed = float(v0_m_s)
    angle_deg = float(theta_deg)
    if speed < 0.0:
        raise ValueError("launch speed must be non-negative.")
    if not 0.0 <= angle_deg <= 90.0:
        raise ValueError("theta_deg must be between 0 and 90 degrees (inclusive).")
    # Handle edge angles
    if angle_deg == 0.0 or angle_deg == 90.0:
        return 0.0
    # Use existing time_of_flight
    time_of_flight = projectile_time_of_flight(speed, angle_deg)
    horizontal_velocity = speed * math.cos(math.radians(angle_deg))
    return horizontal_velocity * time_of_flight
def projectile_height(v0_m_s: float, theta_deg: float, t_s: float) -> float:
    """Return the vertical height (in meters) of a projectile at time `t_s`."""
    import math
    speed = float(v0_m_s)
    angle_deg = float(theta_deg)
    time_s = float(t_s)
    if speed < 0.0:
        raise ValueError("launch speed must be non-negative.")
    if not 0.0 <= angle_deg <= 90.0:
        raise ValueError("theta_deg must be between 0 and 90 degrees.")
    if time_s < 0.0:
        raise ValueError("t_s must be non-negative.")
    g_m_s2 = standard_gravity.get_value(meter_per_second_squared_unit)
    angle_rad = math.radians(angle_deg)
    return speed * math.sin(angle_rad) * time_s - 0.5 * g_m_s2 * time_s ** 2
def sphere_volume_m3(radius_m: float) -> float:
    import math
    radius = float(radius_m)
    if radius < 0.0:
        raise ValueError("radius must be non‑negative")
    return (4.0 / 3.0) * math.pi * radius ** 3
def cylinder_volume_m3(radius_m: float, height_m: float) -> float:
    radius = float(radius_m)
    height = float(height_m)
    if radius < 0.0 or height < 0.0:
        raise ValueError("radius and height must be non‑negative")
    return (math.pi * radius ** 2) * height
def prism_volume_m3(base_area_m2: float, height_m: float) -> float:
    base_area = float(base_area_m2)
    height = float(height_m)
    if base_area < 0.0 or height < 0.0:
        raise ValueError("base area and height must be non‑negative")
    return base_area * height
def density_kg_per_m3(mass_kg: float, volume_m3: float) -> float:
    mass = float(mass_kg)
    volume = float(volume_m3)
    if mass < 0.0 or volume <= 0.0:
        raise ValueError("mass must be non‑negative and volume positive")
    return mass / volume
def pressure_pa(force_n: float, area_m2: float) -> float:
    force = float(force_n)
    area = float(area_m2)
    if area <= 0:
        raise ValueError("area_m2 must be positive")
    if force < 0:
        raise ValueError("force_n must be non-negative")
    return force / area
def buoyant_force_n(fluid_density_kg_per_m3: float, displaced_volume_m3: float) -> float:
    """Return the buoyant force in newtons.

    Parameters
    ----------
    fluid_density_kg_per_m3: float
        Density of the fluid in kg/m³. Must be > 0.
    displaced_volume_m3: float
        Volume of fluid displaced in m³. Must be >= 0.

    Returns
    -------
    float
        Buoyant force in newtons.
    """
    fluid_density = float(fluid_density_kg_per_m3)
    displaced_volume = float(displaced_volume_m3)
    if fluid_density <= 0:
        raise ValueError("fluid_density_kg_per_m3 must be > 0")
    if displaced_volume < 0:
        raise ValueError("displaced_volume_m3 must be >= 0")
    g = standard_gravity.get_value(meter_per_second_squared_unit)
    return fluid_density * g * displaced_volume
def required_displaced_volume_m3_for_float(mass_kg: float, fluid_density_kg_per_m3: float) -> float:
    """Return the displaced volume needed for a given mass and fluid density.

    Parameters
    ----------
    mass_kg: float
        Mass in kilograms. Must be >= 0.
    fluid_density_kg_per_m3: float
        Fluid density in kg/m³. Must be > 0.

    Returns
    -------
    float
        Required displaced volume in m³.
    """
    mass = float(mass_kg)
    density = float(fluid_density_kg_per_m3)
    if mass < 0:
        raise ValueError("mass_kg must be >= 0")
    if density <= 0:
        raise ValueError("fluid_density_kg_per_m3 must be > 0")
    return mass / density
def water_phase_at_1atm(temp_c: float) -> str:
    if temp_c <= 0.0:
        return "ice"
    elif temp_c >= 100.0:
        return "vapor"
    else:
        return "liquid"
def water_density_kg_per_m3_from_temp(temp_c: float) -> float:
    phase = water_phase_at_1atm(temp_c)
    if phase == "ice":
        return 917.0
    elif phase == "liquid":
        return 1000.0
    elif phase == "vapor":
        return 0.6
    else:
        raise ValueError(f"Unexpected phase: {phase}")
class Calendar365:
    def normalize_doy(self, doy: int) -> int:
        if not isinstance(doy, int):
            raise TypeError("doy must be an int.")
        return ((doy - 1) % 365) + 1
class EarthTiltModel:
    def __init__(self, tilt_deg: float = 23.44, offset_doy: int = 80):
        self.tilt_deg = float(tilt_deg)
        self.offset_doy = int(offset_doy)
        self.calendar = Calendar365()

    def declination_deg(self, doy: int) -> float:
        day = self.calendar.normalize_doy(doy)
        angle = 2.0 * math.pi * (day - self.offset_doy) / 365.0
        return self.tilt_deg * math.sin(angle)
class DaylightModel:
    def __init__(self, tilt_model=None):
        self.tilt_model = tilt_model if tilt_model is not None else EarthTiltModel()

    def day_length_hours(self, latitude_deg: float, doy: int) -> float:
        latitude = float(latitude_deg)
        if not -90.0 <= latitude <= 90.0:
            raise ValueError("latitude_deg must be between -90 and 90.")
        declination_deg = self.tilt_model.declination_deg(doy)
        latitude_rad = math.radians(latitude)
        declination_rad = math.radians(declination_deg)
        cosine_argument = -math.tan(latitude_rad) * math.tan(declination_rad)
        cosine_argument = max(-1.0, min(1.0, cosine_argument))
        return (24.0 / math.pi) * math.acos(cosine_argument)
class GeoPosition:
    def __init__(self, latitude_deg: float, longitude_deg: float):
        if not -90 <= latitude_deg <= 90:
            raise ValueError("Latitude must be between -90 and 90 degrees")
        if not -180 <= longitude_deg <= 180:
            raise ValueError("Longitude must be between -180 and 180 degrees")
        self.latitude_deg = latitude_deg
        self.longitude_deg = longitude_deg

    def day_length_hours(self, doy: int, daylight_model=None):
        if daylight_model is None:
            daylight_model = DaylightModel()
        return daylight_model.day_length_hours(self.latitude_deg, doy)
class City:
    def __init__(self, name: Name, position: GeoPosition, country: str, administrative_area: str | None = None):
        if not isinstance(name, Name):
            raise TypeError('name must be a Name instance.')
        if not isinstance(position, GeoPosition):
            raise TypeError('position must be a GeoPosition instance.')
        if not isinstance(country, str) or not country.strip():
            raise ValueError('country must be a non-empty string.')
        self.name = name
        self.position = position
        self.country = country.strip()
        if administrative_area is None:
            self.administrative_area = None
        else:
            area_text = str(administrative_area).strip()
            self.administrative_area = area_text or None
kingston_city = City(Name("Kingston"), GeoPosition(44.2315, -76.4858), "Canada", "Ontario")
def apparent_star_rotation_direction(position: GeoPosition) -> str:
    if not isinstance(position, GeoPosition):
        raise TypeError('position must be a GeoPosition instance.')
    latitude = float(position.latitude_deg)
    if latitude > 0.0:
        return 'counterclockwise'
    if latitude < 0.0:
        return 'clockwise'
    return 'indeterminate'
def celestial_pole_altitude_deg(position: GeoPosition) -> float:
    if not isinstance(position, GeoPosition):
        raise TypeError('position must be a GeoPosition instance.')
    return abs(float(position.latitude_deg))
def solar_hour_angle_deg(local_solar_time_hours: float) -> float:
    time_hours = float(local_solar_time_hours)
    return 15.0 * (time_hours - 12.0)
def solar_elevation_deg(position: GeoPosition, doy: int, local_solar_time_hours: float) -> float:
    if not isinstance(position, GeoPosition):
        raise TypeError('position must be a GeoPosition instance.')
    declination_deg = EarthTiltModel().declination_deg(doy)
    hour_angle_deg = solar_hour_angle_deg(local_solar_time_hours)
    latitude_rad = math.radians(position.latitude_deg)
    declination_rad = math.radians(declination_deg)
    hour_angle_rad = math.radians(hour_angle_deg)
    sin_elevation = (math.sin(declination_rad) * math.sin(latitude_rad) +
                      math.cos(declination_rad) * math.cos(latitude_rad) *
                      math.cos(hour_angle_rad))
    sin_elevation = max(-1.0, min(1.0, sin_elevation))
    return math.degrees(math.asin(sin_elevation))
def vertical_shadow_length(height: Distance, solar_elevation_deg: float) -> Distance:
    if not isinstance(height, Distance):
        raise TypeError("height must be a Distance instance.")
    if solar_elevation_deg <= 0:
        raise ValueError("solar_elevation_deg must be positive.")
    height_m = height.value.convert_to(meter_unit).number
    shadow_m = height_m / math.tan(math.radians(float(solar_elevation_deg)))
    return Distance(Value(shadow_m, meter_unit))
hockey_puck = PhysicalObject(
    name=Name('hockey_puck'),
    mass=Mass(Value(0.170, kilogram_unit)),
    shape=Cylinder(
        radius=Radius(Value(3.81, centimeter_unit)),
        height=Distance(Value(2.54, centimeter_unit)),
    ),
)
hot_wheels_car = PhysicalObject(
    name=Name("hot_wheels_car"),
    mass=Mass(Value(0.035, kilogram_unit)),
)
bic_crystal_pen = PhysicalObject(
    name=Name('bic_crystal_pen'),
    mass=Mass(Value(0.050, kilogram_unit)),
    shape=Cylinder(
        radius=Radius(Value(0.45, centimeter_unit)),
        height=Distance(Value(14.9, centimeter_unit)),
    ),
)