rosu_mods/
generated_mods.rs

1//! Each individual [`GameMod`] as defined by osu!lazer.
2//!
3//! See <https://raw.githubusercontent.com/ppy/osu-web/master/database/mods.json>
4//!
5//! This file was generated automatically.
6
7#![allow(clippy::all, clippy::pedantic)]
8
9use std::{
10    cmp::Ordering,
11    fmt::{Display, Formatter, Result as FmtResult},
12};
13
14use crate::{Acronym, GameMode};
15
16mod all_structs {
17    /// Larger circles, more forgiving HP drain, less accuracy required, and extra lives!
18    #[derive(Clone, Debug, Default, PartialEq)]
19    #[cfg_attr(
20        feature = "rkyv",
21        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
22    )]
23    pub struct EasyOsu {
24        /// Number of extra lives
25        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
26        pub retries: Option<f64>,
27    }
28    /// You can't fail, no matter what.
29    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
30    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
31    pub struct NoFailOsu {}
32    /// Less zoom...
33    #[derive(Clone, Debug, Default, PartialEq)]
34    #[cfg_attr(
35        feature = "rkyv",
36        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
37    )]
38    pub struct HalfTimeOsu {
39        /// The actual decrease to apply
40        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
41        pub speed_change: Option<f64>,
42        /// Should pitch be adjusted with speed
43        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
44        pub adjust_pitch: Option<bool>,
45    }
46    /// Whoaaaaa...
47    #[derive(Clone, Debug, Default, PartialEq)]
48    #[cfg_attr(
49        feature = "rkyv",
50        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
51    )]
52    pub struct DaycoreOsu {
53        /// The actual decrease to apply
54        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
55        pub speed_change: Option<f64>,
56    }
57    /// Everything just got a bit harder...
58    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
59    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
60    pub struct HardRockOsu {}
61    /// Miss and fail.
62    #[derive(Clone, Debug, Default, PartialEq)]
63    #[cfg_attr(
64        feature = "rkyv",
65        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
66    )]
67    pub struct SuddenDeathOsu {
68        ///
69        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
70        pub fail_on_slider_tail: Option<bool>,
71        /// Automatically restarts when failed.
72        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
73        pub restart: Option<bool>,
74    }
75    /// SS or quit.
76    #[derive(Clone, Debug, Default, PartialEq)]
77    #[cfg_attr(
78        feature = "rkyv",
79        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
80    )]
81    pub struct PerfectOsu {
82        /// Automatically restarts when failed.
83        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
84        pub restart: Option<bool>,
85    }
86    /// Zoooooooooom...
87    #[derive(Clone, Debug, Default, PartialEq)]
88    #[cfg_attr(
89        feature = "rkyv",
90        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
91    )]
92    pub struct DoubleTimeOsu {
93        /// The actual increase to apply
94        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
95        pub speed_change: Option<f64>,
96        /// Should pitch be adjusted with speed
97        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
98        pub adjust_pitch: Option<bool>,
99    }
100    /// Uguuuuuuuu...
101    #[derive(Clone, Debug, Default, PartialEq)]
102    #[cfg_attr(
103        feature = "rkyv",
104        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
105    )]
106    pub struct NightcoreOsu {
107        /// The actual increase to apply
108        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
109        pub speed_change: Option<f64>,
110    }
111    /// Play with no approach circles and fading circles/sliders.
112    #[derive(Clone, Debug, Default, PartialEq)]
113    #[cfg_attr(
114        feature = "rkyv",
115        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
116    )]
117    pub struct HiddenOsu {
118        /// The main object body will not fade when enabled.
119        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
120        pub only_fade_approach_circles: Option<bool>,
121    }
122    /// Put your faith in the approach circles...
123    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
124    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
125    pub struct TraceableOsu {}
126    /// Restricted view area.
127    #[derive(Clone, Debug, Default, PartialEq)]
128    #[cfg_attr(
129        feature = "rkyv",
130        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
131    )]
132    pub struct FlashlightOsu {
133        /// Milliseconds until the flashlight reaches the cursor
134        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
135        pub follow_delay: Option<f64>,
136        /// Multiplier applied to the default flashlight size.
137        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
138        pub size_multiplier: Option<f64>,
139        /// Decrease the flashlight size as combo increases.
140        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
141        pub combo_based_size: Option<bool>,
142    }
143    /// Play with blinds on your screen.
144    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
145    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
146    pub struct BlindsOsu {}
147    /// Once you start a slider, follow precisely or get a miss.
148    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
149    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
150    pub struct StrictTrackingOsu {}
151    /// Fail if your accuracy drops too low!
152    #[derive(Clone, Debug, Default, PartialEq)]
153    #[cfg_attr(
154        feature = "rkyv",
155        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
156    )]
157    pub struct AccuracyChallengeOsu {
158        /// Trigger a failure if your accuracy goes below this value.
159        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
160        pub minimum_accuracy: Option<f64>,
161        /// The mode of accuracy that will trigger failure.
162        pub accuracy_judge_mode: Option<String>,
163        /// Automatically restarts when failed.
164        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
165        pub restart: Option<bool>,
166    }
167    /// Practice keeping up with the beat of the song.
168    #[derive(Clone, Debug, Default, PartialEq)]
169    #[cfg_attr(
170        feature = "rkyv",
171        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
172    )]
173    pub struct TargetPracticeOsu {
174        /// Use a custom seed instead of a random one
175        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
176        pub seed: Option<f64>,
177        /// Whether a metronome beat should play in the background
178        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
179        pub metronome: Option<bool>,
180    }
181    /// Override a beatmap's difficulty settings.
182    #[derive(Clone, Debug, Default, PartialEq)]
183    #[cfg_attr(
184        feature = "rkyv",
185        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
186    )]
187    pub struct DifficultyAdjustOsu {
188        /// Override a beatmap's set CS.
189        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
190        pub circle_size: Option<f64>,
191        /// Override a beatmap's set AR.
192        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
193        pub approach_rate: Option<f64>,
194        /// Override a beatmap's set HP.
195        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
196        pub drain_rate: Option<f64>,
197        /// Override a beatmap's set OD.
198        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
199        pub overall_difficulty: Option<f64>,
200        /// Adjust difficulty beyond sane limits.
201        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
202        pub extended_limits: Option<bool>,
203    }
204    /// Feeling nostalgic?
205    #[derive(Clone, Debug, Default, PartialEq)]
206    #[cfg_attr(
207        feature = "rkyv",
208        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
209    )]
210    pub struct ClassicOsu {
211        /// Scores sliders proportionally to the number of ticks hit.
212        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
213        pub no_slider_head_accuracy: Option<bool>,
214        /// Applies note lock to the full hit window.
215        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
216        pub classic_note_lock: Option<bool>,
217        /// Always plays a slider's tail sample regardless of whether it was hit or not.
218        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
219        pub always_play_tail_sample: Option<bool>,
220        /// Make hit circles fade out into a miss, rather than after it.
221        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
222        pub fade_hit_circle_early: Option<bool>,
223        /// More closely resembles the original HP drain mechanics.
224        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
225        pub classic_health: Option<bool>,
226    }
227    /// It never gets boring!
228    #[derive(Clone, Debug, Default, PartialEq)]
229    #[cfg_attr(
230        feature = "rkyv",
231        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
232    )]
233    pub struct RandomOsu {
234        /// How sharp angles should be
235        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
236        pub angle_sharpness: Option<f64>,
237        /// Use a custom seed instead of a random one
238        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
239        pub seed: Option<f64>,
240    }
241    /// Flip objects on the chosen axes.
242    #[derive(Clone, Debug, Default, PartialEq)]
243    #[cfg_attr(
244        feature = "rkyv",
245        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
246    )]
247    pub struct MirrorOsu {
248        ///
249        pub reflection: Option<String>,
250    }
251    /// Don't use the same key twice in a row!
252    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
253    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
254    pub struct AlternateOsu {}
255    /// You must only use one key!
256    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
257    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
258    pub struct SingleTapOsu {}
259    /// Watch a perfect automated play through the song.
260    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
261    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
262    pub struct AutoplayOsu {}
263    /// Watch the video without visual distractions.
264    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
265    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
266    pub struct CinemaOsu {}
267    /// You don't need to click. Give your clicking/tapping fingers a break from the heat of things.
268    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
269    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
270    pub struct RelaxOsu {}
271    /// Automatic cursor movement - just follow the rhythm.
272    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
273    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
274    pub struct AutopilotOsu {}
275    /// Spinners will be automatically completed.
276    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
277    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
278    pub struct SpunOutOsu {}
279    /// Everything rotates. EVERYTHING.
280    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
281    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
282    pub struct TransformOsu {}
283    /// They just won't stay still...
284    #[derive(Clone, Debug, Default, PartialEq)]
285    #[cfg_attr(
286        feature = "rkyv",
287        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
288    )]
289    pub struct WiggleOsu {
290        /// Multiplier applied to the wiggling strength.
291        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
292        pub strength: Option<f64>,
293    }
294    /// Circles spin in. No approach circles.
295    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
296    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
297    pub struct SpinInOsu {}
298    /// Hit them at the right size!
299    #[derive(Clone, Debug, Default, PartialEq)]
300    #[cfg_attr(
301        feature = "rkyv",
302        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
303    )]
304    pub struct GrowOsu {
305        /// The initial size multiplier applied to all objects.
306        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
307        pub start_scale: Option<f64>,
308    }
309    /// Hit them at the right size!
310    #[derive(Clone, Debug, Default, PartialEq)]
311    #[cfg_attr(
312        feature = "rkyv",
313        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
314    )]
315    pub struct DeflateOsu {
316        /// The initial size multiplier applied to all objects.
317        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
318        pub start_scale: Option<f64>,
319    }
320    /// Can you keep up?
321    #[derive(Clone, Debug, Default, PartialEq)]
322    #[cfg_attr(
323        feature = "rkyv",
324        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
325    )]
326    pub struct WindUpOsu {
327        /// The starting speed of the track
328        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
329        pub initial_rate: Option<f64>,
330        /// The final speed to ramp to
331        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
332        pub final_rate: Option<f64>,
333        /// Should pitch be adjusted with speed
334        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
335        pub adjust_pitch: Option<bool>,
336    }
337    /// Sloooow doooown...
338    #[derive(Clone, Debug, Default, PartialEq)]
339    #[cfg_attr(
340        feature = "rkyv",
341        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
342    )]
343    pub struct WindDownOsu {
344        /// The starting speed of the track
345        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
346        pub initial_rate: Option<f64>,
347        /// The final speed to ramp to
348        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
349        pub final_rate: Option<f64>,
350        /// Should pitch be adjusted with speed
351        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
352        pub adjust_pitch: Option<bool>,
353    }
354    /// The whole playfield is on a wheel!
355    #[derive(Clone, Debug, Default, PartialEq)]
356    #[cfg_attr(
357        feature = "rkyv",
358        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
359    )]
360    pub struct BarrelRollOsu {
361        /// Rotations per minute
362        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
363        pub spin_speed: Option<f64>,
364        /// The direction of rotation
365        pub direction: Option<String>,
366    }
367    /// Never trust the approach circles...
368    #[derive(Clone, Debug, Default, PartialEq)]
369    #[cfg_attr(
370        feature = "rkyv",
371        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
372    )]
373    pub struct ApproachDifferentOsu {
374        /// Change the initial size of the approach circle, relative to hit circles.
375        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
376        pub scale: Option<f64>,
377        /// Change the animation style of the approach circles.
378        pub style: Option<String>,
379    }
380    /// Can you still feel the rhythm without music?
381    #[derive(Clone, Debug, Default, PartialEq)]
382    #[cfg_attr(
383        feature = "rkyv",
384        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
385    )]
386    pub struct MutedOsu {
387        /// Increase volume as combo builds.
388        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
389        pub inverse_muting: Option<bool>,
390        /// Add a metronome beat to help you keep track of the rhythm.
391        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
392        pub enable_metronome: Option<bool>,
393        /// The combo count at which point the track reaches its final volume.
394        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
395        pub mute_combo_count: Option<f64>,
396        /// Hit sounds are also muted alongside the track.
397        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
398        pub affects_hit_sounds: Option<bool>,
399    }
400    /// Where's the cursor?
401    #[derive(Clone, Debug, Default, PartialEq)]
402    #[cfg_attr(
403        feature = "rkyv",
404        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
405    )]
406    pub struct NoScopeOsu {
407        /// The combo count at which the cursor becomes completely hidden
408        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
409        pub hidden_combo_count: Option<f64>,
410    }
411    /// No need to chase the circles – your cursor is a magnet!
412    #[derive(Clone, Debug, Default, PartialEq)]
413    #[cfg_attr(
414        feature = "rkyv",
415        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
416    )]
417    pub struct MagnetisedOsu {
418        /// How strong the pull is.
419        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
420        pub attraction_strength: Option<f64>,
421    }
422    /// Hit objects run away!
423    #[derive(Clone, Debug, Default, PartialEq)]
424    #[cfg_attr(
425        feature = "rkyv",
426        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
427    )]
428    pub struct RepelOsu {
429        /// How strong the repulsion is.
430        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
431        pub repulsion_strength: Option<f64>,
432    }
433    /// Let track speed adapt to you.
434    #[derive(Clone, Debug, Default, PartialEq)]
435    #[cfg_attr(
436        feature = "rkyv",
437        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
438    )]
439    pub struct AdaptiveSpeedOsu {
440        /// The starting speed of the track
441        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
442        pub initial_rate: Option<f64>,
443        /// Should pitch be adjusted with speed
444        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
445        pub adjust_pitch: Option<bool>,
446    }
447    /// Burn the notes into your memory.
448    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
449    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
450    pub struct FreezeFrameOsu {}
451    /// Don't let their popping distract you!
452    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
453    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
454    pub struct BubblesOsu {}
455    /// Colours hit objects based on the rhythm.
456    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
457    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
458    pub struct SynesthesiaOsu {}
459    /// 3D. Almost.
460    #[derive(Clone, Debug, Default, PartialEq)]
461    #[cfg_attr(
462        feature = "rkyv",
463        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
464    )]
465    pub struct DepthOsu {
466        /// How far away objects appear.
467        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
468        pub max_depth: Option<f64>,
469        /// Whether approach circles should be visible.
470        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
471        pub show_approach_circles: Option<bool>,
472    }
473    /// The cursor blooms into.. a larger cursor!
474    #[derive(Clone, Debug, Default, PartialEq)]
475    #[cfg_attr(
476        feature = "rkyv",
477        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
478    )]
479    pub struct BloomOsu {
480        /// The combo count at which the cursor reaches its maximum size
481        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
482        pub max_size_combo_count: Option<f64>,
483        /// The multiplier applied to cursor size when combo reaches maximum
484        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
485        pub max_cursor_size: Option<f64>,
486    }
487    /// Automatically applied to plays on devices with a touchscreen.
488    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
489    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
490    pub struct TouchDeviceOsu {}
491    /// Score set on earlier osu! versions with the V2 scoring algorithm active.
492    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
493    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
494    pub struct ScoreV2Osu {}
495    /// Beats move slower, and less accuracy required!
496    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
497    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
498    pub struct EasyTaiko {}
499    /// You can't fail, no matter what.
500    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
501    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
502    pub struct NoFailTaiko {}
503    /// Less zoom...
504    #[derive(Clone, Debug, Default, PartialEq)]
505    #[cfg_attr(
506        feature = "rkyv",
507        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
508    )]
509    pub struct HalfTimeTaiko {
510        /// The actual decrease to apply
511        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
512        pub speed_change: Option<f64>,
513        /// Should pitch be adjusted with speed
514        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
515        pub adjust_pitch: Option<bool>,
516    }
517    /// Whoaaaaa...
518    #[derive(Clone, Debug, Default, PartialEq)]
519    #[cfg_attr(
520        feature = "rkyv",
521        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
522    )]
523    pub struct DaycoreTaiko {
524        /// The actual decrease to apply
525        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
526        pub speed_change: Option<f64>,
527    }
528    /// Simplify tricky rhythms!
529    #[derive(Clone, Debug, Default, PartialEq)]
530    #[cfg_attr(
531        feature = "rkyv",
532        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
533    )]
534    pub struct SimplifiedRhythmTaiko {
535        /// Converts 1/3 patterns to 1/2 rhythm.
536        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
537        pub one_third_conversion: Option<bool>,
538        /// Converts 1/6 patterns to 1/4 rhythm.
539        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
540        pub one_sixth_conversion: Option<bool>,
541        /// Converts 1/8 patterns to 1/4 rhythm.
542        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
543        pub one_eighth_conversion: Option<bool>,
544    }
545    /// Everything just got a bit harder...
546    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
547    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
548    pub struct HardRockTaiko {}
549    /// Miss and fail.
550    #[derive(Clone, Debug, Default, PartialEq)]
551    #[cfg_attr(
552        feature = "rkyv",
553        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
554    )]
555    pub struct SuddenDeathTaiko {
556        /// Automatically restarts when failed.
557        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
558        pub restart: Option<bool>,
559    }
560    /// SS or quit.
561    #[derive(Clone, Debug, Default, PartialEq)]
562    #[cfg_attr(
563        feature = "rkyv",
564        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
565    )]
566    pub struct PerfectTaiko {
567        /// Automatically restarts when failed.
568        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
569        pub restart: Option<bool>,
570    }
571    /// Zoooooooooom...
572    #[derive(Clone, Debug, Default, PartialEq)]
573    #[cfg_attr(
574        feature = "rkyv",
575        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
576    )]
577    pub struct DoubleTimeTaiko {
578        /// The actual increase to apply
579        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
580        pub speed_change: Option<f64>,
581        /// Should pitch be adjusted with speed
582        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
583        pub adjust_pitch: Option<bool>,
584    }
585    /// Uguuuuuuuu...
586    #[derive(Clone, Debug, Default, PartialEq)]
587    #[cfg_attr(
588        feature = "rkyv",
589        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
590    )]
591    pub struct NightcoreTaiko {
592        /// The actual increase to apply
593        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
594        pub speed_change: Option<f64>,
595    }
596    /// Beats fade out before you hit them!
597    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
598    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
599    pub struct HiddenTaiko {}
600    /// Restricted view area.
601    #[derive(Clone, Debug, Default, PartialEq)]
602    #[cfg_attr(
603        feature = "rkyv",
604        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
605    )]
606    pub struct FlashlightTaiko {
607        /// Multiplier applied to the default flashlight size.
608        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
609        pub size_multiplier: Option<f64>,
610        /// Decrease the flashlight size as combo increases.
611        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
612        pub combo_based_size: Option<bool>,
613    }
614    /// Fail if your accuracy drops too low!
615    #[derive(Clone, Debug, Default, PartialEq)]
616    #[cfg_attr(
617        feature = "rkyv",
618        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
619    )]
620    pub struct AccuracyChallengeTaiko {
621        /// Trigger a failure if your accuracy goes below this value.
622        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
623        pub minimum_accuracy: Option<f64>,
624        /// The mode of accuracy that will trigger failure.
625        pub accuracy_judge_mode: Option<String>,
626        /// Automatically restarts when failed.
627        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
628        pub restart: Option<bool>,
629    }
630    /// Shuffle around the colours!
631    #[derive(Clone, Debug, Default, PartialEq)]
632    #[cfg_attr(
633        feature = "rkyv",
634        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
635    )]
636    pub struct RandomTaiko {
637        /// Use a custom seed instead of a random one
638        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
639        pub seed: Option<f64>,
640    }
641    /// Override a beatmap's difficulty settings.
642    #[derive(Clone, Debug, Default, PartialEq)]
643    #[cfg_attr(
644        feature = "rkyv",
645        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
646    )]
647    pub struct DifficultyAdjustTaiko {
648        /// Adjust a beatmap's set scroll speed
649        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
650        pub scroll_speed: Option<f64>,
651        /// Override a beatmap's set HP.
652        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
653        pub drain_rate: Option<f64>,
654        /// Override a beatmap's set OD.
655        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
656        pub overall_difficulty: Option<f64>,
657        /// Adjust difficulty beyond sane limits.
658        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
659        pub extended_limits: Option<bool>,
660    }
661    /// Feeling nostalgic?
662    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
663    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
664    pub struct ClassicTaiko {}
665    /// Dons become kats, kats become dons
666    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
667    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
668    pub struct SwapTaiko {}
669    /// One key for dons, one key for kats.
670    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
671    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
672    pub struct SingleTapTaiko {}
673    /// No more tricky speed changes!
674    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
675    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
676    pub struct ConstantSpeedTaiko {}
677    /// Watch a perfect automated play through the song.
678    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
679    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
680    pub struct AutoplayTaiko {}
681    /// Watch the video without visual distractions.
682    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
683    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
684    pub struct CinemaTaiko {}
685    /// No need to remember which key is correct anymore!
686    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
687    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
688    pub struct RelaxTaiko {}
689    /// Can you keep up?
690    #[derive(Clone, Debug, Default, PartialEq)]
691    #[cfg_attr(
692        feature = "rkyv",
693        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
694    )]
695    pub struct WindUpTaiko {
696        /// The starting speed of the track
697        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
698        pub initial_rate: Option<f64>,
699        /// The final speed to ramp to
700        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
701        pub final_rate: Option<f64>,
702        /// Should pitch be adjusted with speed
703        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
704        pub adjust_pitch: Option<bool>,
705    }
706    /// Sloooow doooown...
707    #[derive(Clone, Debug, Default, PartialEq)]
708    #[cfg_attr(
709        feature = "rkyv",
710        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
711    )]
712    pub struct WindDownTaiko {
713        /// The starting speed of the track
714        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
715        pub initial_rate: Option<f64>,
716        /// The final speed to ramp to
717        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
718        pub final_rate: Option<f64>,
719        /// Should pitch be adjusted with speed
720        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
721        pub adjust_pitch: Option<bool>,
722    }
723    /// Can you still feel the rhythm without music?
724    #[derive(Clone, Debug, Default, PartialEq)]
725    #[cfg_attr(
726        feature = "rkyv",
727        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
728    )]
729    pub struct MutedTaiko {
730        /// Increase volume as combo builds.
731        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
732        pub inverse_muting: Option<bool>,
733        /// Add a metronome beat to help you keep track of the rhythm.
734        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
735        pub enable_metronome: Option<bool>,
736        /// The combo count at which point the track reaches its final volume.
737        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
738        pub mute_combo_count: Option<f64>,
739        /// Hit sounds are also muted alongside the track.
740        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
741        pub affects_hit_sounds: Option<bool>,
742    }
743    /// Let track speed adapt to you.
744    #[derive(Clone, Debug, Default, PartialEq)]
745    #[cfg_attr(
746        feature = "rkyv",
747        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
748    )]
749    pub struct AdaptiveSpeedTaiko {
750        /// The starting speed of the track
751        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
752        pub initial_rate: Option<f64>,
753        /// Should pitch be adjusted with speed
754        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
755        pub adjust_pitch: Option<bool>,
756    }
757    /// Score set on earlier osu! versions with the V2 scoring algorithm active.
758    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
759    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
760    pub struct ScoreV2Taiko {}
761    /// Larger fruits, more forgiving HP drain, less accuracy required, and extra lives!
762    #[derive(Clone, Debug, Default, PartialEq)]
763    #[cfg_attr(
764        feature = "rkyv",
765        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
766    )]
767    pub struct EasyCatch {
768        /// Number of extra lives
769        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
770        pub retries: Option<f64>,
771    }
772    /// You can't fail, no matter what.
773    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
774    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
775    pub struct NoFailCatch {}
776    /// Less zoom...
777    #[derive(Clone, Debug, Default, PartialEq)]
778    #[cfg_attr(
779        feature = "rkyv",
780        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
781    )]
782    pub struct HalfTimeCatch {
783        /// The actual decrease to apply
784        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
785        pub speed_change: Option<f64>,
786        /// Should pitch be adjusted with speed
787        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
788        pub adjust_pitch: Option<bool>,
789    }
790    /// Whoaaaaa...
791    #[derive(Clone, Debug, Default, PartialEq)]
792    #[cfg_attr(
793        feature = "rkyv",
794        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
795    )]
796    pub struct DaycoreCatch {
797        /// The actual decrease to apply
798        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
799        pub speed_change: Option<f64>,
800    }
801    /// Everything just got a bit harder...
802    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
803    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
804    pub struct HardRockCatch {}
805    /// Miss and fail.
806    #[derive(Clone, Debug, Default, PartialEq)]
807    #[cfg_attr(
808        feature = "rkyv",
809        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
810    )]
811    pub struct SuddenDeathCatch {
812        /// Automatically restarts when failed.
813        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
814        pub restart: Option<bool>,
815    }
816    /// SS or quit.
817    #[derive(Clone, Debug, Default, PartialEq)]
818    #[cfg_attr(
819        feature = "rkyv",
820        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
821    )]
822    pub struct PerfectCatch {
823        /// Automatically restarts when failed.
824        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
825        pub restart: Option<bool>,
826    }
827    /// Zoooooooooom...
828    #[derive(Clone, Debug, Default, PartialEq)]
829    #[cfg_attr(
830        feature = "rkyv",
831        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
832    )]
833    pub struct DoubleTimeCatch {
834        /// The actual increase to apply
835        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
836        pub speed_change: Option<f64>,
837        /// Should pitch be adjusted with speed
838        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
839        pub adjust_pitch: Option<bool>,
840    }
841    /// Uguuuuuuuu...
842    #[derive(Clone, Debug, Default, PartialEq)]
843    #[cfg_attr(
844        feature = "rkyv",
845        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
846    )]
847    pub struct NightcoreCatch {
848        /// The actual increase to apply
849        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
850        pub speed_change: Option<f64>,
851    }
852    /// Play with fading fruits.
853    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
854    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
855    pub struct HiddenCatch {}
856    /// Restricted view area.
857    #[derive(Clone, Debug, Default, PartialEq)]
858    #[cfg_attr(
859        feature = "rkyv",
860        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
861    )]
862    pub struct FlashlightCatch {
863        /// Multiplier applied to the default flashlight size.
864        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
865        pub size_multiplier: Option<f64>,
866        /// Decrease the flashlight size as combo increases.
867        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
868        pub combo_based_size: Option<bool>,
869    }
870    /// Fail if your accuracy drops too low!
871    #[derive(Clone, Debug, Default, PartialEq)]
872    #[cfg_attr(
873        feature = "rkyv",
874        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
875    )]
876    pub struct AccuracyChallengeCatch {
877        /// Trigger a failure if your accuracy goes below this value.
878        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
879        pub minimum_accuracy: Option<f64>,
880        /// The mode of accuracy that will trigger failure.
881        pub accuracy_judge_mode: Option<String>,
882        /// Automatically restarts when failed.
883        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
884        pub restart: Option<bool>,
885    }
886    /// Override a beatmap's difficulty settings.
887    #[derive(Clone, Debug, Default, PartialEq)]
888    #[cfg_attr(
889        feature = "rkyv",
890        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
891    )]
892    pub struct DifficultyAdjustCatch {
893        /// Override a beatmap's set CS.
894        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
895        pub circle_size: Option<f64>,
896        /// Override a beatmap's set AR.
897        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
898        pub approach_rate: Option<f64>,
899        /// Adjust the patterns as if Hard Rock is enabled.
900        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
901        pub hard_rock_offsets: Option<bool>,
902        /// Override a beatmap's set HP.
903        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
904        pub drain_rate: Option<f64>,
905        /// Override a beatmap's set OD.
906        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
907        pub overall_difficulty: Option<f64>,
908        /// Adjust difficulty beyond sane limits.
909        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
910        pub extended_limits: Option<bool>,
911    }
912    /// Feeling nostalgic?
913    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
914    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
915    pub struct ClassicCatch {}
916    /// Fruits are flipped horizontally.
917    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
918    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
919    pub struct MirrorCatch {}
920    /// Watch a perfect automated play through the song.
921    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
922    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
923    pub struct AutoplayCatch {}
924    /// Watch the video without visual distractions.
925    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
926    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
927    pub struct CinemaCatch {}
928    /// Use the mouse to control the catcher.
929    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
930    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
931    pub struct RelaxCatch {}
932    /// Can you keep up?
933    #[derive(Clone, Debug, Default, PartialEq)]
934    #[cfg_attr(
935        feature = "rkyv",
936        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
937    )]
938    pub struct WindUpCatch {
939        /// The starting speed of the track
940        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
941        pub initial_rate: Option<f64>,
942        /// The final speed to ramp to
943        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
944        pub final_rate: Option<f64>,
945        /// Should pitch be adjusted with speed
946        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
947        pub adjust_pitch: Option<bool>,
948    }
949    /// Sloooow doooown...
950    #[derive(Clone, Debug, Default, PartialEq)]
951    #[cfg_attr(
952        feature = "rkyv",
953        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
954    )]
955    pub struct WindDownCatch {
956        /// The starting speed of the track
957        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
958        pub initial_rate: Option<f64>,
959        /// The final speed to ramp to
960        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
961        pub final_rate: Option<f64>,
962        /// Should pitch be adjusted with speed
963        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
964        pub adjust_pitch: Option<bool>,
965    }
966    /// The fruits are... floating?
967    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
968    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
969    pub struct FloatingFruitsCatch {}
970    /// Can you still feel the rhythm without music?
971    #[derive(Clone, Debug, Default, PartialEq)]
972    #[cfg_attr(
973        feature = "rkyv",
974        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
975    )]
976    pub struct MutedCatch {
977        /// Increase volume as combo builds.
978        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
979        pub inverse_muting: Option<bool>,
980        /// Add a metronome beat to help you keep track of the rhythm.
981        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
982        pub enable_metronome: Option<bool>,
983        /// The combo count at which point the track reaches its final volume.
984        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
985        pub mute_combo_count: Option<f64>,
986        /// Hit sounds are also muted alongside the track.
987        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
988        pub affects_hit_sounds: Option<bool>,
989    }
990    /// Where's the catcher?
991    #[derive(Clone, Debug, Default, PartialEq)]
992    #[cfg_attr(
993        feature = "rkyv",
994        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
995    )]
996    pub struct NoScopeCatch {
997        /// The combo count at which the cursor becomes completely hidden
998        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
999        pub hidden_combo_count: Option<f64>,
1000    }
1001    /// Dashing by default, slow down!
1002    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1003    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1004    pub struct MovingFastCatch {}
1005    /// Score set on earlier osu! versions with the V2 scoring algorithm active.
1006    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1007    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1008    pub struct ScoreV2Catch {}
1009    /// More forgiving HP drain, less accuracy required, and extra lives!
1010    #[derive(Clone, Debug, Default, PartialEq)]
1011    #[cfg_attr(
1012        feature = "rkyv",
1013        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1014    )]
1015    pub struct EasyMania {
1016        /// Number of extra lives
1017        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1018        pub retries: Option<f64>,
1019    }
1020    /// You can't fail, no matter what.
1021    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1022    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1023    pub struct NoFailMania {}
1024    /// Less zoom...
1025    #[derive(Clone, Debug, Default, PartialEq)]
1026    #[cfg_attr(
1027        feature = "rkyv",
1028        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1029    )]
1030    pub struct HalfTimeMania {
1031        /// The actual decrease to apply
1032        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1033        pub speed_change: Option<f64>,
1034        /// Should pitch be adjusted with speed
1035        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1036        pub adjust_pitch: Option<bool>,
1037    }
1038    /// Whoaaaaa...
1039    #[derive(Clone, Debug, Default, PartialEq)]
1040    #[cfg_attr(
1041        feature = "rkyv",
1042        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1043    )]
1044    pub struct DaycoreMania {
1045        /// The actual decrease to apply
1046        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1047        pub speed_change: Option<f64>,
1048    }
1049    /// No more timing the end of hold notes.
1050    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1051    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1052    pub struct NoReleaseMania {}
1053    /// Everything just got a bit harder...
1054    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1055    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1056    pub struct HardRockMania {}
1057    /// Miss and fail.
1058    #[derive(Clone, Debug, Default, PartialEq)]
1059    #[cfg_attr(
1060        feature = "rkyv",
1061        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1062    )]
1063    pub struct SuddenDeathMania {
1064        /// Automatically restarts when failed.
1065        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1066        pub restart: Option<bool>,
1067    }
1068    /// SS or quit.
1069    #[derive(Clone, Debug, Default, PartialEq)]
1070    #[cfg_attr(
1071        feature = "rkyv",
1072        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1073    )]
1074    pub struct PerfectMania {
1075        ///
1076        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1077        pub require_perfect_hits: Option<bool>,
1078        /// Automatically restarts when failed.
1079        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1080        pub restart: Option<bool>,
1081    }
1082    /// Zoooooooooom...
1083    #[derive(Clone, Debug, Default, PartialEq)]
1084    #[cfg_attr(
1085        feature = "rkyv",
1086        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1087    )]
1088    pub struct DoubleTimeMania {
1089        /// The actual increase to apply
1090        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1091        pub speed_change: Option<f64>,
1092        /// Should pitch be adjusted with speed
1093        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1094        pub adjust_pitch: Option<bool>,
1095    }
1096    /// Uguuuuuuuu...
1097    #[derive(Clone, Debug, Default, PartialEq)]
1098    #[cfg_attr(
1099        feature = "rkyv",
1100        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1101    )]
1102    pub struct NightcoreMania {
1103        /// The actual increase to apply
1104        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1105        pub speed_change: Option<f64>,
1106    }
1107    /// Keys appear out of nowhere!
1108    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1109    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1110    pub struct FadeInMania {}
1111    /// Keys fade out before you hit them!
1112    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1113    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1114    pub struct HiddenMania {}
1115    /// Decrease the playfield's viewing area.
1116    #[derive(Clone, Debug, Default, PartialEq)]
1117    #[cfg_attr(
1118        feature = "rkyv",
1119        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1120    )]
1121    pub struct CoverMania {
1122        /// The proportion of playfield height that notes will be hidden for.
1123        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1124        pub coverage: Option<f64>,
1125        /// The direction on which the cover is applied
1126        pub direction: Option<String>,
1127    }
1128    /// Restricted view area.
1129    #[derive(Clone, Debug, Default, PartialEq)]
1130    #[cfg_attr(
1131        feature = "rkyv",
1132        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1133    )]
1134    pub struct FlashlightMania {
1135        /// Multiplier applied to the default flashlight size.
1136        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1137        pub size_multiplier: Option<f64>,
1138        /// Decrease the flashlight size as combo increases.
1139        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1140        pub combo_based_size: Option<bool>,
1141    }
1142    /// Fail if your accuracy drops too low!
1143    #[derive(Clone, Debug, Default, PartialEq)]
1144    #[cfg_attr(
1145        feature = "rkyv",
1146        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1147    )]
1148    pub struct AccuracyChallengeMania {
1149        /// Trigger a failure if your accuracy goes below this value.
1150        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1151        pub minimum_accuracy: Option<f64>,
1152        /// The mode of accuracy that will trigger failure.
1153        pub accuracy_judge_mode: Option<String>,
1154        /// Automatically restarts when failed.
1155        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1156        pub restart: Option<bool>,
1157    }
1158    /// Shuffle around the keys!
1159    #[derive(Clone, Debug, Default, PartialEq)]
1160    #[cfg_attr(
1161        feature = "rkyv",
1162        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1163    )]
1164    pub struct RandomMania {
1165        /// Use a custom seed instead of a random one
1166        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1167        pub seed: Option<f64>,
1168    }
1169    /// Double the stages, double the fun!
1170    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1171    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1172    pub struct DualStagesMania {}
1173    /// Notes are flipped horizontally.
1174    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1175    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1176    pub struct MirrorMania {}
1177    /// Override a beatmap's difficulty settings.
1178    #[derive(Clone, Debug, Default, PartialEq)]
1179    #[cfg_attr(
1180        feature = "rkyv",
1181        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1182    )]
1183    pub struct DifficultyAdjustMania {
1184        /// Override a beatmap's set OD.
1185        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1186        pub overall_difficulty: Option<f64>,
1187        /// Override a beatmap's set HP.
1188        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1189        pub drain_rate: Option<f64>,
1190        /// Adjust difficulty beyond sane limits.
1191        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1192        pub extended_limits: Option<bool>,
1193    }
1194    /// Feeling nostalgic?
1195    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1196    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1197    pub struct ClassicMania {}
1198    /// Hold the keys. To the beat.
1199    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1200    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1201    pub struct InvertMania {}
1202    /// No more tricky speed changes!
1203    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1204    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1205    pub struct ConstantSpeedMania {}
1206    /// Replaces all hold notes with normal notes.
1207    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1208    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1209    pub struct HoldOffMania {}
1210    /// Play with one key.
1211    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1212    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1213    pub struct OneKeyMania {}
1214    /// Play with two keys.
1215    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1216    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1217    pub struct TwoKeysMania {}
1218    /// Play with three keys.
1219    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1220    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1221    pub struct ThreeKeysMania {}
1222    /// Play with four keys.
1223    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1224    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1225    pub struct FourKeysMania {}
1226    /// Play with five keys.
1227    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1228    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1229    pub struct FiveKeysMania {}
1230    /// Play with six keys.
1231    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1232    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1233    pub struct SixKeysMania {}
1234    /// Play with seven keys.
1235    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1236    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1237    pub struct SevenKeysMania {}
1238    /// Play with eight keys.
1239    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1240    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1241    pub struct EightKeysMania {}
1242    /// Play with nine keys.
1243    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1244    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1245    pub struct NineKeysMania {}
1246    /// Play with ten keys.
1247    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1248    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1249    pub struct TenKeysMania {}
1250    /// Watch a perfect automated play through the song.
1251    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1252    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1253    pub struct AutoplayMania {}
1254    /// Watch the video without visual distractions.
1255    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1256    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1257    pub struct CinemaMania {}
1258    /// Can you keep up?
1259    #[derive(Clone, Debug, Default, PartialEq)]
1260    #[cfg_attr(
1261        feature = "rkyv",
1262        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1263    )]
1264    pub struct WindUpMania {
1265        /// The starting speed of the track
1266        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1267        pub initial_rate: Option<f64>,
1268        /// The final speed to ramp to
1269        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1270        pub final_rate: Option<f64>,
1271        /// Should pitch be adjusted with speed
1272        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1273        pub adjust_pitch: Option<bool>,
1274    }
1275    /// Sloooow doooown...
1276    #[derive(Clone, Debug, Default, PartialEq)]
1277    #[cfg_attr(
1278        feature = "rkyv",
1279        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1280    )]
1281    pub struct WindDownMania {
1282        /// The starting speed of the track
1283        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1284        pub initial_rate: Option<f64>,
1285        /// The final speed to ramp to
1286        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1287        pub final_rate: Option<f64>,
1288        /// Should pitch be adjusted with speed
1289        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1290        pub adjust_pitch: Option<bool>,
1291    }
1292    /// Can you still feel the rhythm without music?
1293    #[derive(Clone, Debug, Default, PartialEq)]
1294    #[cfg_attr(
1295        feature = "rkyv",
1296        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1297    )]
1298    pub struct MutedMania {
1299        /// Increase volume as combo builds.
1300        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1301        pub inverse_muting: Option<bool>,
1302        /// Add a metronome beat to help you keep track of the rhythm.
1303        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1304        pub enable_metronome: Option<bool>,
1305        /// The combo count at which point the track reaches its final volume.
1306        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1307        pub mute_combo_count: Option<f64>,
1308        /// Hit sounds are also muted alongside the track.
1309        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1310        pub affects_hit_sounds: Option<bool>,
1311    }
1312    /// Let track speed adapt to you.
1313    #[derive(Clone, Debug, Default, PartialEq)]
1314    #[cfg_attr(
1315        feature = "rkyv",
1316        derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
1317    )]
1318    pub struct AdaptiveSpeedMania {
1319        /// The starting speed of the track
1320        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::NaN>))]
1321        pub initial_rate: Option<f64>,
1322        /// Should pitch be adjusted with speed
1323        #[cfg_attr(feature = "rkyv", rkyv(with = rkyv::with::NicheInto<rkyv::niche::niching::Bool>))]
1324        pub adjust_pitch: Option<bool>,
1325    }
1326    /// Score set on earlier osu! versions with the V2 scoring algorithm active.
1327    #[derive(Copy, Eq, Clone, Debug, Default, PartialEq)]
1328    #[cfg_attr(feature = "rkyv", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self), repr(transparent))]
1329    pub struct ScoreV2Mania {}
1330    /// Any unknown mod.
1331    #[derive(Copy, Eq, Clone, Debug, PartialEq, PartialOrd, Ord, Hash)]
1332    #[cfg_attr(feature = "rkyv",derive(rkyv::Archive,rkyv::Serialize,rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),bytecheck(crate = rkyv::bytecheck),rkyv(as = Self),repr(transparent),)]
1333    pub struct UnknownMod {
1334        pub acronym: crate::Acronym,
1335    }
1336}
1337use crate::GameModKind;
1338pub use all_structs::{
1339    AccuracyChallengeCatch, AccuracyChallengeMania, AccuracyChallengeOsu, AccuracyChallengeTaiko,
1340    AdaptiveSpeedMania, AdaptiveSpeedOsu, AdaptiveSpeedTaiko, AlternateOsu, ApproachDifferentOsu,
1341    AutopilotOsu, AutoplayCatch, AutoplayMania, AutoplayOsu, AutoplayTaiko, BarrelRollOsu,
1342    BlindsOsu, BloomOsu, BubblesOsu, CinemaCatch, CinemaMania, CinemaOsu, CinemaTaiko,
1343    ClassicCatch, ClassicMania, ClassicOsu, ClassicTaiko, ConstantSpeedMania, ConstantSpeedTaiko,
1344    CoverMania, DaycoreCatch, DaycoreMania, DaycoreOsu, DaycoreTaiko, DeflateOsu, DepthOsu,
1345    DifficultyAdjustCatch, DifficultyAdjustMania, DifficultyAdjustOsu, DifficultyAdjustTaiko,
1346    DoubleTimeCatch, DoubleTimeMania, DoubleTimeOsu, DoubleTimeTaiko, DualStagesMania, EasyCatch,
1347    EasyMania, EasyOsu, EasyTaiko, EightKeysMania, FadeInMania, FiveKeysMania, FlashlightCatch,
1348    FlashlightMania, FlashlightOsu, FlashlightTaiko, FloatingFruitsCatch, FourKeysMania,
1349    FreezeFrameOsu, GrowOsu, HalfTimeCatch, HalfTimeMania, HalfTimeOsu, HalfTimeTaiko,
1350    HardRockCatch, HardRockMania, HardRockOsu, HardRockTaiko, HiddenCatch, HiddenMania, HiddenOsu,
1351    HiddenTaiko, HoldOffMania, InvertMania, MagnetisedOsu, MirrorCatch, MirrorMania, MirrorOsu,
1352    MovingFastCatch, MutedCatch, MutedMania, MutedOsu, MutedTaiko, NightcoreCatch, NightcoreMania,
1353    NightcoreOsu, NightcoreTaiko, NineKeysMania, NoFailCatch, NoFailMania, NoFailOsu, NoFailTaiko,
1354    NoReleaseMania, NoScopeCatch, NoScopeOsu, OneKeyMania, PerfectCatch, PerfectMania, PerfectOsu,
1355    PerfectTaiko, RandomMania, RandomOsu, RandomTaiko, RelaxCatch, RelaxOsu, RelaxTaiko, RepelOsu,
1356    ScoreV2Catch, ScoreV2Mania, ScoreV2Osu, ScoreV2Taiko, SevenKeysMania, SimplifiedRhythmTaiko,
1357    SingleTapOsu, SingleTapTaiko, SixKeysMania, SpinInOsu, SpunOutOsu, StrictTrackingOsu,
1358    SuddenDeathCatch, SuddenDeathMania, SuddenDeathOsu, SuddenDeathTaiko, SwapTaiko,
1359    SynesthesiaOsu, TargetPracticeOsu, TenKeysMania, ThreeKeysMania, TouchDeviceOsu, TraceableOsu,
1360    TransformOsu, TwoKeysMania, UnknownMod, WiggleOsu, WindDownCatch, WindDownMania, WindDownOsu,
1361    WindDownTaiko, WindUpCatch, WindUpMania, WindUpOsu, WindUpTaiko,
1362};
1363pub use gamemod::GameMod;
1364pub use intermode::GameModIntermode;
1365/// Types for (de)serialization through `rkyv`.
1366#[cfg(feature = "rkyv")]
1367#[cfg_attr(all(docsrs, not(doctest)), doc(cfg(feature = "rkyv")))]
1368#[doc(hidden)]
1369pub mod rkyv {
1370    pub use super::all_structs::{
1371        AccuracyChallengeCatchResolver, AccuracyChallengeManiaResolver,
1372        AccuracyChallengeOsuResolver, AccuracyChallengeTaikoResolver, AdaptiveSpeedManiaResolver,
1373        AdaptiveSpeedOsuResolver, AdaptiveSpeedTaikoResolver, AlternateOsuResolver,
1374        ApproachDifferentOsuResolver, ArchivedAccuracyChallengeCatch,
1375        ArchivedAccuracyChallengeMania, ArchivedAccuracyChallengeOsu,
1376        ArchivedAccuracyChallengeTaiko, ArchivedAdaptiveSpeedMania, ArchivedAdaptiveSpeedOsu,
1377        ArchivedAdaptiveSpeedTaiko, ArchivedApproachDifferentOsu, ArchivedBarrelRollOsu,
1378        ArchivedBloomOsu, ArchivedClassicOsu, ArchivedCoverMania, ArchivedDaycoreCatch,
1379        ArchivedDaycoreMania, ArchivedDaycoreOsu, ArchivedDaycoreTaiko, ArchivedDeflateOsu,
1380        ArchivedDepthOsu, ArchivedDifficultyAdjustCatch, ArchivedDifficultyAdjustMania,
1381        ArchivedDifficultyAdjustOsu, ArchivedDifficultyAdjustTaiko, ArchivedDoubleTimeCatch,
1382        ArchivedDoubleTimeMania, ArchivedDoubleTimeOsu, ArchivedDoubleTimeTaiko, ArchivedEasyCatch,
1383        ArchivedEasyMania, ArchivedEasyOsu, ArchivedFlashlightCatch, ArchivedFlashlightMania,
1384        ArchivedFlashlightOsu, ArchivedFlashlightTaiko, ArchivedGrowOsu, ArchivedHalfTimeCatch,
1385        ArchivedHalfTimeMania, ArchivedHalfTimeOsu, ArchivedHalfTimeTaiko, ArchivedHiddenOsu,
1386        ArchivedMagnetisedOsu, ArchivedMirrorOsu, ArchivedMutedCatch, ArchivedMutedMania,
1387        ArchivedMutedOsu, ArchivedMutedTaiko, ArchivedNightcoreCatch, ArchivedNightcoreMania,
1388        ArchivedNightcoreOsu, ArchivedNightcoreTaiko, ArchivedNoScopeCatch, ArchivedNoScopeOsu,
1389        ArchivedPerfectCatch, ArchivedPerfectMania, ArchivedPerfectOsu, ArchivedPerfectTaiko,
1390        ArchivedRandomMania, ArchivedRandomOsu, ArchivedRandomTaiko, ArchivedRepelOsu,
1391        ArchivedSimplifiedRhythmTaiko, ArchivedSuddenDeathCatch, ArchivedSuddenDeathMania,
1392        ArchivedSuddenDeathOsu, ArchivedSuddenDeathTaiko, ArchivedTargetPracticeOsu,
1393        ArchivedWiggleOsu, ArchivedWindDownCatch, ArchivedWindDownMania, ArchivedWindDownOsu,
1394        ArchivedWindDownTaiko, ArchivedWindUpCatch, ArchivedWindUpMania, ArchivedWindUpOsu,
1395        ArchivedWindUpTaiko, AutopilotOsuResolver, AutoplayCatchResolver, AutoplayManiaResolver,
1396        AutoplayOsuResolver, AutoplayTaikoResolver, BarrelRollOsuResolver, BlindsOsuResolver,
1397        BloomOsuResolver, BubblesOsuResolver, CinemaCatchResolver, CinemaManiaResolver,
1398        CinemaOsuResolver, CinemaTaikoResolver, ClassicCatchResolver, ClassicManiaResolver,
1399        ClassicOsuResolver, ClassicTaikoResolver, ConstantSpeedManiaResolver,
1400        ConstantSpeedTaikoResolver, CoverManiaResolver, DaycoreCatchResolver, DaycoreManiaResolver,
1401        DaycoreOsuResolver, DaycoreTaikoResolver, DeflateOsuResolver, DepthOsuResolver,
1402        DifficultyAdjustCatchResolver, DifficultyAdjustManiaResolver, DifficultyAdjustOsuResolver,
1403        DifficultyAdjustTaikoResolver, DoubleTimeCatchResolver, DoubleTimeManiaResolver,
1404        DoubleTimeOsuResolver, DoubleTimeTaikoResolver, DualStagesManiaResolver, EasyCatchResolver,
1405        EasyManiaResolver, EasyOsuResolver, EasyTaikoResolver, EightKeysManiaResolver,
1406        FadeInManiaResolver, FiveKeysManiaResolver, FlashlightCatchResolver,
1407        FlashlightManiaResolver, FlashlightOsuResolver, FlashlightTaikoResolver,
1408        FloatingFruitsCatchResolver, FourKeysManiaResolver, FreezeFrameOsuResolver,
1409        GrowOsuResolver, HalfTimeCatchResolver, HalfTimeManiaResolver, HalfTimeOsuResolver,
1410        HalfTimeTaikoResolver, HardRockCatchResolver, HardRockManiaResolver, HardRockOsuResolver,
1411        HardRockTaikoResolver, HiddenCatchResolver, HiddenManiaResolver, HiddenOsuResolver,
1412        HiddenTaikoResolver, HoldOffManiaResolver, InvertManiaResolver, MagnetisedOsuResolver,
1413        MirrorCatchResolver, MirrorManiaResolver, MirrorOsuResolver, MovingFastCatchResolver,
1414        MutedCatchResolver, MutedManiaResolver, MutedOsuResolver, MutedTaikoResolver,
1415        NightcoreCatchResolver, NightcoreManiaResolver, NightcoreOsuResolver,
1416        NightcoreTaikoResolver, NineKeysManiaResolver, NoFailCatchResolver, NoFailManiaResolver,
1417        NoFailOsuResolver, NoFailTaikoResolver, NoReleaseManiaResolver, NoScopeCatchResolver,
1418        NoScopeOsuResolver, OneKeyManiaResolver, PerfectCatchResolver, PerfectManiaResolver,
1419        PerfectOsuResolver, PerfectTaikoResolver, RandomManiaResolver, RandomOsuResolver,
1420        RandomTaikoResolver, RelaxCatchResolver, RelaxOsuResolver, RelaxTaikoResolver,
1421        RepelOsuResolver, ScoreV2CatchResolver, ScoreV2ManiaResolver, ScoreV2OsuResolver,
1422        ScoreV2TaikoResolver, SevenKeysManiaResolver, SimplifiedRhythmTaikoResolver,
1423        SingleTapOsuResolver, SingleTapTaikoResolver, SixKeysManiaResolver, SpinInOsuResolver,
1424        SpunOutOsuResolver, StrictTrackingOsuResolver, SuddenDeathCatchResolver,
1425        SuddenDeathManiaResolver, SuddenDeathOsuResolver, SuddenDeathTaikoResolver,
1426        SwapTaikoResolver, SynesthesiaOsuResolver, TargetPracticeOsuResolver, TenKeysManiaResolver,
1427        ThreeKeysManiaResolver, TouchDeviceOsuResolver, TraceableOsuResolver, TransformOsuResolver,
1428        TwoKeysManiaResolver, UnknownModResolver, WiggleOsuResolver, WindDownCatchResolver,
1429        WindDownManiaResolver, WindDownOsuResolver, WindDownTaikoResolver, WindUpCatchResolver,
1430        WindUpManiaResolver, WindUpOsuResolver, WindUpTaikoResolver,
1431    };
1432    pub use super::gamemod::{ArchivedGameMod, GameModResolver};
1433    pub use super::intermode::GameModIntermodeResolver;
1434    pub use crate::kind::GameModKindResolver;
1435}
1436impl EasyOsu {
1437    /// The acronym of [`EasyOsu`]
1438    pub const fn acronym() -> Acronym {
1439        unsafe { Acronym::from_str_unchecked("EZ") }
1440    }
1441    /// Iterator of [`Acronym`] for mods that are incompatible with [`EasyOsu`]
1442    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1443        unsafe {
1444            [
1445                Acronym::from_str_unchecked("HR"),
1446                Acronym::from_str_unchecked("AC"),
1447                Acronym::from_str_unchecked("DA"),
1448            ]
1449        }
1450        .into_iter()
1451    }
1452    /// The description of [`EasyOsu`]
1453    pub const fn description() -> &'static str {
1454        "Larger circles, more forgiving HP drain, less accuracy required, and extra lives!"
1455    }
1456    /// The [`GameModKind`] of [`EasyOsu`]
1457    pub const fn kind() -> GameModKind {
1458        GameModKind::DifficultyReduction
1459    }
1460    /// Bit value of [`EasyOsu`]
1461    ///
1462    /// See <https://github.com/ppy/osu-api/wiki#mods>
1463    pub const fn bits() -> u32 {
1464        2
1465    }
1466}
1467impl NoFailOsu {
1468    /// The acronym of [`NoFailOsu`]
1469    pub const fn acronym() -> Acronym {
1470        unsafe { Acronym::from_str_unchecked("NF") }
1471    }
1472    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoFailOsu`]
1473    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1474        unsafe {
1475            [
1476                Acronym::from_str_unchecked("SD"),
1477                Acronym::from_str_unchecked("PF"),
1478                Acronym::from_str_unchecked("AC"),
1479                Acronym::from_str_unchecked("CN"),
1480            ]
1481        }
1482        .into_iter()
1483    }
1484    /// The description of [`NoFailOsu`]
1485    pub const fn description() -> &'static str {
1486        "You can't fail, no matter what."
1487    }
1488    /// The [`GameModKind`] of [`NoFailOsu`]
1489    pub const fn kind() -> GameModKind {
1490        GameModKind::DifficultyReduction
1491    }
1492    /// Bit value of [`NoFailOsu`]
1493    ///
1494    /// See <https://github.com/ppy/osu-api/wiki#mods>
1495    pub const fn bits() -> u32 {
1496        1
1497    }
1498}
1499impl HalfTimeOsu {
1500    /// The acronym of [`HalfTimeOsu`]
1501    pub const fn acronym() -> Acronym {
1502        unsafe { Acronym::from_str_unchecked("HT") }
1503    }
1504    /// Iterator of [`Acronym`] for mods that are incompatible with [`HalfTimeOsu`]
1505    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1506        unsafe {
1507            [
1508                Acronym::from_str_unchecked("DC"),
1509                Acronym::from_str_unchecked("DT"),
1510                Acronym::from_str_unchecked("NC"),
1511                Acronym::from_str_unchecked("WU"),
1512                Acronym::from_str_unchecked("WD"),
1513                Acronym::from_str_unchecked("AS"),
1514            ]
1515        }
1516        .into_iter()
1517    }
1518    /// The description of [`HalfTimeOsu`]
1519    pub const fn description() -> &'static str {
1520        "Less zoom..."
1521    }
1522    /// The [`GameModKind`] of [`HalfTimeOsu`]
1523    pub const fn kind() -> GameModKind {
1524        GameModKind::DifficultyReduction
1525    }
1526    /// Bit value of [`HalfTimeOsu`]
1527    ///
1528    /// See <https://github.com/ppy/osu-api/wiki#mods>
1529    pub const fn bits() -> u32 {
1530        256
1531    }
1532}
1533impl DaycoreOsu {
1534    /// The acronym of [`DaycoreOsu`]
1535    pub const fn acronym() -> Acronym {
1536        unsafe { Acronym::from_str_unchecked("DC") }
1537    }
1538    /// Iterator of [`Acronym`] for mods that are incompatible with [`DaycoreOsu`]
1539    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1540        unsafe {
1541            [
1542                Acronym::from_str_unchecked("HT"),
1543                Acronym::from_str_unchecked("DT"),
1544                Acronym::from_str_unchecked("NC"),
1545                Acronym::from_str_unchecked("WU"),
1546                Acronym::from_str_unchecked("WD"),
1547                Acronym::from_str_unchecked("AS"),
1548            ]
1549        }
1550        .into_iter()
1551    }
1552    /// The description of [`DaycoreOsu`]
1553    pub const fn description() -> &'static str {
1554        "Whoaaaaa..."
1555    }
1556    /// The [`GameModKind`] of [`DaycoreOsu`]
1557    pub const fn kind() -> GameModKind {
1558        GameModKind::DifficultyReduction
1559    }
1560}
1561impl HardRockOsu {
1562    /// The acronym of [`HardRockOsu`]
1563    pub const fn acronym() -> Acronym {
1564        unsafe { Acronym::from_str_unchecked("HR") }
1565    }
1566    /// Iterator of [`Acronym`] for mods that are incompatible with [`HardRockOsu`]
1567    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1568        unsafe {
1569            [
1570                Acronym::from_str_unchecked("EZ"),
1571                Acronym::from_str_unchecked("DA"),
1572                Acronym::from_str_unchecked("MR"),
1573            ]
1574        }
1575        .into_iter()
1576    }
1577    /// The description of [`HardRockOsu`]
1578    pub const fn description() -> &'static str {
1579        "Everything just got a bit harder..."
1580    }
1581    /// The [`GameModKind`] of [`HardRockOsu`]
1582    pub const fn kind() -> GameModKind {
1583        GameModKind::DifficultyIncrease
1584    }
1585    /// Bit value of [`HardRockOsu`]
1586    ///
1587    /// See <https://github.com/ppy/osu-api/wiki#mods>
1588    pub const fn bits() -> u32 {
1589        16
1590    }
1591}
1592impl SuddenDeathOsu {
1593    /// The acronym of [`SuddenDeathOsu`]
1594    pub const fn acronym() -> Acronym {
1595        unsafe { Acronym::from_str_unchecked("SD") }
1596    }
1597    /// Iterator of [`Acronym`] for mods that are incompatible with [`SuddenDeathOsu`]
1598    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1599        unsafe {
1600            [
1601                Acronym::from_str_unchecked("NF"),
1602                Acronym::from_str_unchecked("PF"),
1603                Acronym::from_str_unchecked("TP"),
1604                Acronym::from_str_unchecked("CN"),
1605            ]
1606        }
1607        .into_iter()
1608    }
1609    /// The description of [`SuddenDeathOsu`]
1610    pub const fn description() -> &'static str {
1611        "Miss and fail."
1612    }
1613    /// The [`GameModKind`] of [`SuddenDeathOsu`]
1614    pub const fn kind() -> GameModKind {
1615        GameModKind::DifficultyIncrease
1616    }
1617    /// Bit value of [`SuddenDeathOsu`]
1618    ///
1619    /// See <https://github.com/ppy/osu-api/wiki#mods>
1620    pub const fn bits() -> u32 {
1621        32
1622    }
1623}
1624impl PerfectOsu {
1625    /// The acronym of [`PerfectOsu`]
1626    pub const fn acronym() -> Acronym {
1627        unsafe { Acronym::from_str_unchecked("PF") }
1628    }
1629    /// Iterator of [`Acronym`] for mods that are incompatible with [`PerfectOsu`]
1630    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1631        unsafe {
1632            [
1633                Acronym::from_str_unchecked("NF"),
1634                Acronym::from_str_unchecked("SD"),
1635                Acronym::from_str_unchecked("AC"),
1636                Acronym::from_str_unchecked("CN"),
1637            ]
1638        }
1639        .into_iter()
1640    }
1641    /// The description of [`PerfectOsu`]
1642    pub const fn description() -> &'static str {
1643        "SS or quit."
1644    }
1645    /// The [`GameModKind`] of [`PerfectOsu`]
1646    pub const fn kind() -> GameModKind {
1647        GameModKind::DifficultyIncrease
1648    }
1649    /// Bit value of [`PerfectOsu`]
1650    ///
1651    /// See <https://github.com/ppy/osu-api/wiki#mods>
1652    pub const fn bits() -> u32 {
1653        16416
1654    }
1655}
1656impl DoubleTimeOsu {
1657    /// The acronym of [`DoubleTimeOsu`]
1658    pub const fn acronym() -> Acronym {
1659        unsafe { Acronym::from_str_unchecked("DT") }
1660    }
1661    /// Iterator of [`Acronym`] for mods that are incompatible with [`DoubleTimeOsu`]
1662    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1663        unsafe {
1664            [
1665                Acronym::from_str_unchecked("HT"),
1666                Acronym::from_str_unchecked("DC"),
1667                Acronym::from_str_unchecked("NC"),
1668                Acronym::from_str_unchecked("WU"),
1669                Acronym::from_str_unchecked("WD"),
1670                Acronym::from_str_unchecked("AS"),
1671            ]
1672        }
1673        .into_iter()
1674    }
1675    /// The description of [`DoubleTimeOsu`]
1676    pub const fn description() -> &'static str {
1677        "Zoooooooooom..."
1678    }
1679    /// The [`GameModKind`] of [`DoubleTimeOsu`]
1680    pub const fn kind() -> GameModKind {
1681        GameModKind::DifficultyIncrease
1682    }
1683    /// Bit value of [`DoubleTimeOsu`]
1684    ///
1685    /// See <https://github.com/ppy/osu-api/wiki#mods>
1686    pub const fn bits() -> u32 {
1687        64
1688    }
1689}
1690impl NightcoreOsu {
1691    /// The acronym of [`NightcoreOsu`]
1692    pub const fn acronym() -> Acronym {
1693        unsafe { Acronym::from_str_unchecked("NC") }
1694    }
1695    /// Iterator of [`Acronym`] for mods that are incompatible with [`NightcoreOsu`]
1696    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1697        unsafe {
1698            [
1699                Acronym::from_str_unchecked("HT"),
1700                Acronym::from_str_unchecked("DC"),
1701                Acronym::from_str_unchecked("DT"),
1702                Acronym::from_str_unchecked("WU"),
1703                Acronym::from_str_unchecked("WD"),
1704                Acronym::from_str_unchecked("AS"),
1705            ]
1706        }
1707        .into_iter()
1708    }
1709    /// The description of [`NightcoreOsu`]
1710    pub const fn description() -> &'static str {
1711        "Uguuuuuuuu..."
1712    }
1713    /// The [`GameModKind`] of [`NightcoreOsu`]
1714    pub const fn kind() -> GameModKind {
1715        GameModKind::DifficultyIncrease
1716    }
1717    /// Bit value of [`NightcoreOsu`]
1718    ///
1719    /// See <https://github.com/ppy/osu-api/wiki#mods>
1720    pub const fn bits() -> u32 {
1721        576
1722    }
1723}
1724impl HiddenOsu {
1725    /// The acronym of [`HiddenOsu`]
1726    pub const fn acronym() -> Acronym {
1727        unsafe { Acronym::from_str_unchecked("HD") }
1728    }
1729    /// Iterator of [`Acronym`] for mods that are incompatible with [`HiddenOsu`]
1730    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1731        unsafe {
1732            [
1733                Acronym::from_str_unchecked("TC"),
1734                Acronym::from_str_unchecked("SI"),
1735                Acronym::from_str_unchecked("AD"),
1736                Acronym::from_str_unchecked("FR"),
1737                Acronym::from_str_unchecked("DP"),
1738            ]
1739        }
1740        .into_iter()
1741    }
1742    /// The description of [`HiddenOsu`]
1743    pub const fn description() -> &'static str {
1744        "Play with no approach circles and fading circles/sliders."
1745    }
1746    /// The [`GameModKind`] of [`HiddenOsu`]
1747    pub const fn kind() -> GameModKind {
1748        GameModKind::DifficultyIncrease
1749    }
1750    /// Bit value of [`HiddenOsu`]
1751    ///
1752    /// See <https://github.com/ppy/osu-api/wiki#mods>
1753    pub const fn bits() -> u32 {
1754        8
1755    }
1756}
1757impl TraceableOsu {
1758    /// The acronym of [`TraceableOsu`]
1759    pub const fn acronym() -> Acronym {
1760        unsafe { Acronym::from_str_unchecked("TC") }
1761    }
1762    /// Iterator of [`Acronym`] for mods that are incompatible with [`TraceableOsu`]
1763    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1764        unsafe {
1765            [
1766                Acronym::from_str_unchecked("HD"),
1767                Acronym::from_str_unchecked("TP"),
1768                Acronym::from_str_unchecked("SI"),
1769                Acronym::from_str_unchecked("GR"),
1770                Acronym::from_str_unchecked("DF"),
1771                Acronym::from_str_unchecked("DP"),
1772            ]
1773        }
1774        .into_iter()
1775    }
1776    /// The description of [`TraceableOsu`]
1777    pub const fn description() -> &'static str {
1778        "Put your faith in the approach circles..."
1779    }
1780    /// The [`GameModKind`] of [`TraceableOsu`]
1781    pub const fn kind() -> GameModKind {
1782        GameModKind::DifficultyIncrease
1783    }
1784}
1785impl FlashlightOsu {
1786    /// The acronym of [`FlashlightOsu`]
1787    pub const fn acronym() -> Acronym {
1788        unsafe { Acronym::from_str_unchecked("FL") }
1789    }
1790    /// Iterator of [`Acronym`] for mods that are incompatible with [`FlashlightOsu`]
1791    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1792        unsafe {
1793            [
1794                Acronym::from_str_unchecked("BL"),
1795                Acronym::from_str_unchecked("BM"),
1796            ]
1797        }
1798        .into_iter()
1799    }
1800    /// The description of [`FlashlightOsu`]
1801    pub const fn description() -> &'static str {
1802        "Restricted view area."
1803    }
1804    /// The [`GameModKind`] of [`FlashlightOsu`]
1805    pub const fn kind() -> GameModKind {
1806        GameModKind::DifficultyIncrease
1807    }
1808    /// Bit value of [`FlashlightOsu`]
1809    ///
1810    /// See <https://github.com/ppy/osu-api/wiki#mods>
1811    pub const fn bits() -> u32 {
1812        1024
1813    }
1814}
1815impl BlindsOsu {
1816    /// The acronym of [`BlindsOsu`]
1817    pub const fn acronym() -> Acronym {
1818        unsafe { Acronym::from_str_unchecked("BL") }
1819    }
1820    /// Iterator of [`Acronym`] for mods that are incompatible with [`BlindsOsu`]
1821    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1822        unsafe { [Acronym::from_str_unchecked("FL")] }.into_iter()
1823    }
1824    /// The description of [`BlindsOsu`]
1825    pub const fn description() -> &'static str {
1826        "Play with blinds on your screen."
1827    }
1828    /// The [`GameModKind`] of [`BlindsOsu`]
1829    pub const fn kind() -> GameModKind {
1830        GameModKind::DifficultyIncrease
1831    }
1832}
1833impl StrictTrackingOsu {
1834    /// The acronym of [`StrictTrackingOsu`]
1835    pub const fn acronym() -> Acronym {
1836        unsafe { Acronym::from_str_unchecked("ST") }
1837    }
1838    /// Iterator of [`Acronym`] for mods that are incompatible with [`StrictTrackingOsu`]
1839    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1840        unsafe {
1841            [
1842                Acronym::from_str_unchecked("TP"),
1843                Acronym::from_str_unchecked("CL"),
1844            ]
1845        }
1846        .into_iter()
1847    }
1848    /// The description of [`StrictTrackingOsu`]
1849    pub const fn description() -> &'static str {
1850        "Once you start a slider, follow precisely or get a miss."
1851    }
1852    /// The [`GameModKind`] of [`StrictTrackingOsu`]
1853    pub const fn kind() -> GameModKind {
1854        GameModKind::DifficultyIncrease
1855    }
1856}
1857impl AccuracyChallengeOsu {
1858    /// The acronym of [`AccuracyChallengeOsu`]
1859    pub const fn acronym() -> Acronym {
1860        unsafe { Acronym::from_str_unchecked("AC") }
1861    }
1862    /// Iterator of [`Acronym`] for mods that are incompatible with [`AccuracyChallengeOsu`]
1863    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1864        unsafe {
1865            [
1866                Acronym::from_str_unchecked("EZ"),
1867                Acronym::from_str_unchecked("NF"),
1868                Acronym::from_str_unchecked("PF"),
1869                Acronym::from_str_unchecked("CN"),
1870            ]
1871        }
1872        .into_iter()
1873    }
1874    /// The description of [`AccuracyChallengeOsu`]
1875    pub const fn description() -> &'static str {
1876        "Fail if your accuracy drops too low!"
1877    }
1878    /// The [`GameModKind`] of [`AccuracyChallengeOsu`]
1879    pub const fn kind() -> GameModKind {
1880        GameModKind::DifficultyIncrease
1881    }
1882}
1883impl TargetPracticeOsu {
1884    /// The acronym of [`TargetPracticeOsu`]
1885    pub const fn acronym() -> Acronym {
1886        unsafe { Acronym::from_str_unchecked("TP") }
1887    }
1888    /// Iterator of [`Acronym`] for mods that are incompatible with [`TargetPracticeOsu`]
1889    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1890        unsafe {
1891            [
1892                Acronym::from_str_unchecked("SD"),
1893                Acronym::from_str_unchecked("TC"),
1894                Acronym::from_str_unchecked("ST"),
1895                Acronym::from_str_unchecked("DA"),
1896                Acronym::from_str_unchecked("RD"),
1897                Acronym::from_str_unchecked("SO"),
1898                Acronym::from_str_unchecked("AD"),
1899                Acronym::from_str_unchecked("DP"),
1900            ]
1901        }
1902        .into_iter()
1903    }
1904    /// The description of [`TargetPracticeOsu`]
1905    pub const fn description() -> &'static str {
1906        "Practice keeping up with the beat of the song."
1907    }
1908    /// The [`GameModKind`] of [`TargetPracticeOsu`]
1909    pub const fn kind() -> GameModKind {
1910        GameModKind::Conversion
1911    }
1912    /// Bit value of [`TargetPracticeOsu`]
1913    ///
1914    /// See <https://github.com/ppy/osu-api/wiki#mods>
1915    pub const fn bits() -> u32 {
1916        8388608
1917    }
1918}
1919impl DifficultyAdjustOsu {
1920    /// The acronym of [`DifficultyAdjustOsu`]
1921    pub const fn acronym() -> Acronym {
1922        unsafe { Acronym::from_str_unchecked("DA") }
1923    }
1924    /// Iterator of [`Acronym`] for mods that are incompatible with [`DifficultyAdjustOsu`]
1925    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1926        unsafe {
1927            [
1928                Acronym::from_str_unchecked("EZ"),
1929                Acronym::from_str_unchecked("HR"),
1930                Acronym::from_str_unchecked("TP"),
1931            ]
1932        }
1933        .into_iter()
1934    }
1935    /// The description of [`DifficultyAdjustOsu`]
1936    pub const fn description() -> &'static str {
1937        "Override a beatmap's difficulty settings."
1938    }
1939    /// The [`GameModKind`] of [`DifficultyAdjustOsu`]
1940    pub const fn kind() -> GameModKind {
1941        GameModKind::Conversion
1942    }
1943}
1944impl ClassicOsu {
1945    /// The acronym of [`ClassicOsu`]
1946    pub const fn acronym() -> Acronym {
1947        unsafe { Acronym::from_str_unchecked("CL") }
1948    }
1949    /// Iterator of [`Acronym`] for mods that are incompatible with [`ClassicOsu`]
1950    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1951        unsafe { [Acronym::from_str_unchecked("ST")] }.into_iter()
1952    }
1953    /// The description of [`ClassicOsu`]
1954    pub const fn description() -> &'static str {
1955        "Feeling nostalgic?"
1956    }
1957    /// The [`GameModKind`] of [`ClassicOsu`]
1958    pub const fn kind() -> GameModKind {
1959        GameModKind::Conversion
1960    }
1961}
1962impl RandomOsu {
1963    /// The acronym of [`RandomOsu`]
1964    pub const fn acronym() -> Acronym {
1965        unsafe { Acronym::from_str_unchecked("RD") }
1966    }
1967    /// Iterator of [`Acronym`] for mods that are incompatible with [`RandomOsu`]
1968    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1969        unsafe { [Acronym::from_str_unchecked("TP")] }.into_iter()
1970    }
1971    /// The description of [`RandomOsu`]
1972    pub const fn description() -> &'static str {
1973        "It never gets boring!"
1974    }
1975    /// The [`GameModKind`] of [`RandomOsu`]
1976    pub const fn kind() -> GameModKind {
1977        GameModKind::Conversion
1978    }
1979    /// Bit value of [`RandomOsu`]
1980    ///
1981    /// See <https://github.com/ppy/osu-api/wiki#mods>
1982    pub const fn bits() -> u32 {
1983        2097152
1984    }
1985}
1986impl MirrorOsu {
1987    /// The acronym of [`MirrorOsu`]
1988    pub const fn acronym() -> Acronym {
1989        unsafe { Acronym::from_str_unchecked("MR") }
1990    }
1991    /// Iterator of [`Acronym`] for mods that are incompatible with [`MirrorOsu`]
1992    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
1993        unsafe { [Acronym::from_str_unchecked("HR")] }.into_iter()
1994    }
1995    /// The description of [`MirrorOsu`]
1996    pub const fn description() -> &'static str {
1997        "Flip objects on the chosen axes."
1998    }
1999    /// The [`GameModKind`] of [`MirrorOsu`]
2000    pub const fn kind() -> GameModKind {
2001        GameModKind::Conversion
2002    }
2003    /// Bit value of [`MirrorOsu`]
2004    ///
2005    /// See <https://github.com/ppy/osu-api/wiki#mods>
2006    pub const fn bits() -> u32 {
2007        1073741824
2008    }
2009}
2010impl AlternateOsu {
2011    /// The acronym of [`AlternateOsu`]
2012    pub const fn acronym() -> Acronym {
2013        unsafe { Acronym::from_str_unchecked("AL") }
2014    }
2015    /// Iterator of [`Acronym`] for mods that are incompatible with [`AlternateOsu`]
2016    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2017        unsafe {
2018            [
2019                Acronym::from_str_unchecked("SG"),
2020                Acronym::from_str_unchecked("AT"),
2021                Acronym::from_str_unchecked("CN"),
2022                Acronym::from_str_unchecked("RX"),
2023            ]
2024        }
2025        .into_iter()
2026    }
2027    /// The description of [`AlternateOsu`]
2028    pub const fn description() -> &'static str {
2029        "Don't use the same key twice in a row!"
2030    }
2031    /// The [`GameModKind`] of [`AlternateOsu`]
2032    pub const fn kind() -> GameModKind {
2033        GameModKind::Conversion
2034    }
2035}
2036impl SingleTapOsu {
2037    /// The acronym of [`SingleTapOsu`]
2038    pub const fn acronym() -> Acronym {
2039        unsafe { Acronym::from_str_unchecked("SG") }
2040    }
2041    /// Iterator of [`Acronym`] for mods that are incompatible with [`SingleTapOsu`]
2042    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2043        unsafe {
2044            [
2045                Acronym::from_str_unchecked("AL"),
2046                Acronym::from_str_unchecked("AT"),
2047                Acronym::from_str_unchecked("CN"),
2048                Acronym::from_str_unchecked("RX"),
2049            ]
2050        }
2051        .into_iter()
2052    }
2053    /// The description of [`SingleTapOsu`]
2054    pub const fn description() -> &'static str {
2055        "You must only use one key!"
2056    }
2057    /// The [`GameModKind`] of [`SingleTapOsu`]
2058    pub const fn kind() -> GameModKind {
2059        GameModKind::Conversion
2060    }
2061}
2062impl AutoplayOsu {
2063    /// The acronym of [`AutoplayOsu`]
2064    pub const fn acronym() -> Acronym {
2065        unsafe { Acronym::from_str_unchecked("AT") }
2066    }
2067    /// Iterator of [`Acronym`] for mods that are incompatible with [`AutoplayOsu`]
2068    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2069        unsafe {
2070            [
2071                Acronym::from_str_unchecked("AL"),
2072                Acronym::from_str_unchecked("SG"),
2073                Acronym::from_str_unchecked("CN"),
2074                Acronym::from_str_unchecked("RX"),
2075                Acronym::from_str_unchecked("AP"),
2076                Acronym::from_str_unchecked("SO"),
2077                Acronym::from_str_unchecked("MG"),
2078                Acronym::from_str_unchecked("RP"),
2079                Acronym::from_str_unchecked("AS"),
2080                Acronym::from_str_unchecked("TD"),
2081            ]
2082        }
2083        .into_iter()
2084    }
2085    /// The description of [`AutoplayOsu`]
2086    pub const fn description() -> &'static str {
2087        "Watch a perfect automated play through the song."
2088    }
2089    /// The [`GameModKind`] of [`AutoplayOsu`]
2090    pub const fn kind() -> GameModKind {
2091        GameModKind::Automation
2092    }
2093    /// Bit value of [`AutoplayOsu`]
2094    ///
2095    /// See <https://github.com/ppy/osu-api/wiki#mods>
2096    pub const fn bits() -> u32 {
2097        2048
2098    }
2099}
2100impl CinemaOsu {
2101    /// The acronym of [`CinemaOsu`]
2102    pub const fn acronym() -> Acronym {
2103        unsafe { Acronym::from_str_unchecked("CN") }
2104    }
2105    /// Iterator of [`Acronym`] for mods that are incompatible with [`CinemaOsu`]
2106    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2107        unsafe {
2108            [
2109                Acronym::from_str_unchecked("NF"),
2110                Acronym::from_str_unchecked("SD"),
2111                Acronym::from_str_unchecked("PF"),
2112                Acronym::from_str_unchecked("AC"),
2113                Acronym::from_str_unchecked("AL"),
2114                Acronym::from_str_unchecked("SG"),
2115                Acronym::from_str_unchecked("AT"),
2116                Acronym::from_str_unchecked("RX"),
2117                Acronym::from_str_unchecked("AP"),
2118                Acronym::from_str_unchecked("SO"),
2119                Acronym::from_str_unchecked("MG"),
2120                Acronym::from_str_unchecked("RP"),
2121                Acronym::from_str_unchecked("AS"),
2122                Acronym::from_str_unchecked("TD"),
2123            ]
2124        }
2125        .into_iter()
2126    }
2127    /// The description of [`CinemaOsu`]
2128    pub const fn description() -> &'static str {
2129        "Watch the video without visual distractions."
2130    }
2131    /// The [`GameModKind`] of [`CinemaOsu`]
2132    pub const fn kind() -> GameModKind {
2133        GameModKind::Automation
2134    }
2135    /// Bit value of [`CinemaOsu`]
2136    ///
2137    /// See <https://github.com/ppy/osu-api/wiki#mods>
2138    pub const fn bits() -> u32 {
2139        4194304
2140    }
2141}
2142impl RelaxOsu {
2143    /// The acronym of [`RelaxOsu`]
2144    pub const fn acronym() -> Acronym {
2145        unsafe { Acronym::from_str_unchecked("RX") }
2146    }
2147    /// Iterator of [`Acronym`] for mods that are incompatible with [`RelaxOsu`]
2148    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2149        unsafe {
2150            [
2151                Acronym::from_str_unchecked("AL"),
2152                Acronym::from_str_unchecked("SG"),
2153                Acronym::from_str_unchecked("AT"),
2154                Acronym::from_str_unchecked("CN"),
2155                Acronym::from_str_unchecked("AP"),
2156                Acronym::from_str_unchecked("MG"),
2157            ]
2158        }
2159        .into_iter()
2160    }
2161    /// The description of [`RelaxOsu`]
2162    pub const fn description() -> &'static str {
2163        "You don't need to click. Give your clicking/tapping fingers a break from the heat of things."
2164    }
2165    /// The [`GameModKind`] of [`RelaxOsu`]
2166    pub const fn kind() -> GameModKind {
2167        GameModKind::Automation
2168    }
2169    /// Bit value of [`RelaxOsu`]
2170    ///
2171    /// See <https://github.com/ppy/osu-api/wiki#mods>
2172    pub const fn bits() -> u32 {
2173        128
2174    }
2175}
2176impl AutopilotOsu {
2177    /// The acronym of [`AutopilotOsu`]
2178    pub const fn acronym() -> Acronym {
2179        unsafe { Acronym::from_str_unchecked("AP") }
2180    }
2181    /// Iterator of [`Acronym`] for mods that are incompatible with [`AutopilotOsu`]
2182    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2183        unsafe {
2184            [
2185                Acronym::from_str_unchecked("AT"),
2186                Acronym::from_str_unchecked("CN"),
2187                Acronym::from_str_unchecked("RX"),
2188                Acronym::from_str_unchecked("SO"),
2189                Acronym::from_str_unchecked("MG"),
2190                Acronym::from_str_unchecked("RP"),
2191                Acronym::from_str_unchecked("TD"),
2192            ]
2193        }
2194        .into_iter()
2195    }
2196    /// The description of [`AutopilotOsu`]
2197    pub const fn description() -> &'static str {
2198        "Automatic cursor movement - just follow the rhythm."
2199    }
2200    /// The [`GameModKind`] of [`AutopilotOsu`]
2201    pub const fn kind() -> GameModKind {
2202        GameModKind::Automation
2203    }
2204    /// Bit value of [`AutopilotOsu`]
2205    ///
2206    /// See <https://github.com/ppy/osu-api/wiki#mods>
2207    pub const fn bits() -> u32 {
2208        8192
2209    }
2210}
2211impl SpunOutOsu {
2212    /// The acronym of [`SpunOutOsu`]
2213    pub const fn acronym() -> Acronym {
2214        unsafe { Acronym::from_str_unchecked("SO") }
2215    }
2216    /// Iterator of [`Acronym`] for mods that are incompatible with [`SpunOutOsu`]
2217    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2218        unsafe {
2219            [
2220                Acronym::from_str_unchecked("TP"),
2221                Acronym::from_str_unchecked("AT"),
2222                Acronym::from_str_unchecked("CN"),
2223                Acronym::from_str_unchecked("AP"),
2224            ]
2225        }
2226        .into_iter()
2227    }
2228    /// The description of [`SpunOutOsu`]
2229    pub const fn description() -> &'static str {
2230        "Spinners will be automatically completed."
2231    }
2232    /// The [`GameModKind`] of [`SpunOutOsu`]
2233    pub const fn kind() -> GameModKind {
2234        GameModKind::Automation
2235    }
2236    /// Bit value of [`SpunOutOsu`]
2237    ///
2238    /// See <https://github.com/ppy/osu-api/wiki#mods>
2239    pub const fn bits() -> u32 {
2240        4096
2241    }
2242}
2243impl TransformOsu {
2244    /// The acronym of [`TransformOsu`]
2245    pub const fn acronym() -> Acronym {
2246        unsafe { Acronym::from_str_unchecked("TR") }
2247    }
2248    /// Iterator of [`Acronym`] for mods that are incompatible with [`TransformOsu`]
2249    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2250        unsafe {
2251            [
2252                Acronym::from_str_unchecked("WG"),
2253                Acronym::from_str_unchecked("MG"),
2254                Acronym::from_str_unchecked("RP"),
2255                Acronym::from_str_unchecked("FR"),
2256                Acronym::from_str_unchecked("DP"),
2257            ]
2258        }
2259        .into_iter()
2260    }
2261    /// The description of [`TransformOsu`]
2262    pub const fn description() -> &'static str {
2263        "Everything rotates. EVERYTHING."
2264    }
2265    /// The [`GameModKind`] of [`TransformOsu`]
2266    pub const fn kind() -> GameModKind {
2267        GameModKind::Fun
2268    }
2269}
2270impl WiggleOsu {
2271    /// The acronym of [`WiggleOsu`]
2272    pub const fn acronym() -> Acronym {
2273        unsafe { Acronym::from_str_unchecked("WG") }
2274    }
2275    /// Iterator of [`Acronym`] for mods that are incompatible with [`WiggleOsu`]
2276    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2277        unsafe {
2278            [
2279                Acronym::from_str_unchecked("TR"),
2280                Acronym::from_str_unchecked("MG"),
2281                Acronym::from_str_unchecked("RP"),
2282                Acronym::from_str_unchecked("DP"),
2283            ]
2284        }
2285        .into_iter()
2286    }
2287    /// The description of [`WiggleOsu`]
2288    pub const fn description() -> &'static str {
2289        "They just won't stay still..."
2290    }
2291    /// The [`GameModKind`] of [`WiggleOsu`]
2292    pub const fn kind() -> GameModKind {
2293        GameModKind::Fun
2294    }
2295}
2296impl SpinInOsu {
2297    /// The acronym of [`SpinInOsu`]
2298    pub const fn acronym() -> Acronym {
2299        unsafe { Acronym::from_str_unchecked("SI") }
2300    }
2301    /// Iterator of [`Acronym`] for mods that are incompatible with [`SpinInOsu`]
2302    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2303        unsafe {
2304            [
2305                Acronym::from_str_unchecked("HD"),
2306                Acronym::from_str_unchecked("TC"),
2307                Acronym::from_str_unchecked("GR"),
2308                Acronym::from_str_unchecked("DF"),
2309                Acronym::from_str_unchecked("AD"),
2310                Acronym::from_str_unchecked("DP"),
2311            ]
2312        }
2313        .into_iter()
2314    }
2315    /// The description of [`SpinInOsu`]
2316    pub const fn description() -> &'static str {
2317        "Circles spin in. No approach circles."
2318    }
2319    /// The [`GameModKind`] of [`SpinInOsu`]
2320    pub const fn kind() -> GameModKind {
2321        GameModKind::Fun
2322    }
2323}
2324impl GrowOsu {
2325    /// The acronym of [`GrowOsu`]
2326    pub const fn acronym() -> Acronym {
2327        unsafe { Acronym::from_str_unchecked("GR") }
2328    }
2329    /// Iterator of [`Acronym`] for mods that are incompatible with [`GrowOsu`]
2330    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2331        unsafe {
2332            [
2333                Acronym::from_str_unchecked("TC"),
2334                Acronym::from_str_unchecked("SI"),
2335                Acronym::from_str_unchecked("DF"),
2336                Acronym::from_str_unchecked("AD"),
2337                Acronym::from_str_unchecked("DP"),
2338            ]
2339        }
2340        .into_iter()
2341    }
2342    /// The description of [`GrowOsu`]
2343    pub const fn description() -> &'static str {
2344        "Hit them at the right size!"
2345    }
2346    /// The [`GameModKind`] of [`GrowOsu`]
2347    pub const fn kind() -> GameModKind {
2348        GameModKind::Fun
2349    }
2350}
2351impl DeflateOsu {
2352    /// The acronym of [`DeflateOsu`]
2353    pub const fn acronym() -> Acronym {
2354        unsafe { Acronym::from_str_unchecked("DF") }
2355    }
2356    /// Iterator of [`Acronym`] for mods that are incompatible with [`DeflateOsu`]
2357    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2358        unsafe {
2359            [
2360                Acronym::from_str_unchecked("TC"),
2361                Acronym::from_str_unchecked("SI"),
2362                Acronym::from_str_unchecked("GR"),
2363                Acronym::from_str_unchecked("AD"),
2364                Acronym::from_str_unchecked("DP"),
2365            ]
2366        }
2367        .into_iter()
2368    }
2369    /// The description of [`DeflateOsu`]
2370    pub const fn description() -> &'static str {
2371        "Hit them at the right size!"
2372    }
2373    /// The [`GameModKind`] of [`DeflateOsu`]
2374    pub const fn kind() -> GameModKind {
2375        GameModKind::Fun
2376    }
2377}
2378impl WindUpOsu {
2379    /// The acronym of [`WindUpOsu`]
2380    pub const fn acronym() -> Acronym {
2381        unsafe { Acronym::from_str_unchecked("WU") }
2382    }
2383    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindUpOsu`]
2384    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2385        unsafe {
2386            [
2387                Acronym::from_str_unchecked("HT"),
2388                Acronym::from_str_unchecked("DC"),
2389                Acronym::from_str_unchecked("DT"),
2390                Acronym::from_str_unchecked("NC"),
2391                Acronym::from_str_unchecked("WD"),
2392                Acronym::from_str_unchecked("AS"),
2393            ]
2394        }
2395        .into_iter()
2396    }
2397    /// The description of [`WindUpOsu`]
2398    pub const fn description() -> &'static str {
2399        "Can you keep up?"
2400    }
2401    /// The [`GameModKind`] of [`WindUpOsu`]
2402    pub const fn kind() -> GameModKind {
2403        GameModKind::Fun
2404    }
2405}
2406impl WindDownOsu {
2407    /// The acronym of [`WindDownOsu`]
2408    pub const fn acronym() -> Acronym {
2409        unsafe { Acronym::from_str_unchecked("WD") }
2410    }
2411    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindDownOsu`]
2412    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2413        unsafe {
2414            [
2415                Acronym::from_str_unchecked("HT"),
2416                Acronym::from_str_unchecked("DC"),
2417                Acronym::from_str_unchecked("DT"),
2418                Acronym::from_str_unchecked("NC"),
2419                Acronym::from_str_unchecked("WU"),
2420                Acronym::from_str_unchecked("AS"),
2421            ]
2422        }
2423        .into_iter()
2424    }
2425    /// The description of [`WindDownOsu`]
2426    pub const fn description() -> &'static str {
2427        "Sloooow doooown..."
2428    }
2429    /// The [`GameModKind`] of [`WindDownOsu`]
2430    pub const fn kind() -> GameModKind {
2431        GameModKind::Fun
2432    }
2433}
2434impl BarrelRollOsu {
2435    /// The acronym of [`BarrelRollOsu`]
2436    pub const fn acronym() -> Acronym {
2437        unsafe { Acronym::from_str_unchecked("BR") }
2438    }
2439    /// Iterator of [`Acronym`] for mods that are incompatible with [`BarrelRollOsu`]
2440    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2441        unsafe { [Acronym::from_str_unchecked("BU")] }.into_iter()
2442    }
2443    /// The description of [`BarrelRollOsu`]
2444    pub const fn description() -> &'static str {
2445        "The whole playfield is on a wheel!"
2446    }
2447    /// The [`GameModKind`] of [`BarrelRollOsu`]
2448    pub const fn kind() -> GameModKind {
2449        GameModKind::Fun
2450    }
2451}
2452impl ApproachDifferentOsu {
2453    /// The acronym of [`ApproachDifferentOsu`]
2454    pub const fn acronym() -> Acronym {
2455        unsafe { Acronym::from_str_unchecked("AD") }
2456    }
2457    /// Iterator of [`Acronym`] for mods that are incompatible with [`ApproachDifferentOsu`]
2458    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2459        unsafe {
2460            [
2461                Acronym::from_str_unchecked("HD"),
2462                Acronym::from_str_unchecked("TP"),
2463                Acronym::from_str_unchecked("SI"),
2464                Acronym::from_str_unchecked("GR"),
2465                Acronym::from_str_unchecked("DF"),
2466                Acronym::from_str_unchecked("FR"),
2467            ]
2468        }
2469        .into_iter()
2470    }
2471    /// The description of [`ApproachDifferentOsu`]
2472    pub const fn description() -> &'static str {
2473        "Never trust the approach circles..."
2474    }
2475    /// The [`GameModKind`] of [`ApproachDifferentOsu`]
2476    pub const fn kind() -> GameModKind {
2477        GameModKind::Fun
2478    }
2479}
2480impl MutedOsu {
2481    /// The acronym of [`MutedOsu`]
2482    pub const fn acronym() -> Acronym {
2483        unsafe { Acronym::from_str_unchecked("MU") }
2484    }
2485    /// Iterator of [`Acronym`] for mods that are incompatible with [`MutedOsu`]
2486    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2487        [].into_iter()
2488    }
2489    /// The description of [`MutedOsu`]
2490    pub const fn description() -> &'static str {
2491        "Can you still feel the rhythm without music?"
2492    }
2493    /// The [`GameModKind`] of [`MutedOsu`]
2494    pub const fn kind() -> GameModKind {
2495        GameModKind::Fun
2496    }
2497}
2498impl NoScopeOsu {
2499    /// The acronym of [`NoScopeOsu`]
2500    pub const fn acronym() -> Acronym {
2501        unsafe { Acronym::from_str_unchecked("NS") }
2502    }
2503    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoScopeOsu`]
2504    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2505        unsafe { [Acronym::from_str_unchecked("BM")] }.into_iter()
2506    }
2507    /// The description of [`NoScopeOsu`]
2508    pub const fn description() -> &'static str {
2509        "Where's the cursor?"
2510    }
2511    /// The [`GameModKind`] of [`NoScopeOsu`]
2512    pub const fn kind() -> GameModKind {
2513        GameModKind::Fun
2514    }
2515}
2516impl MagnetisedOsu {
2517    /// The acronym of [`MagnetisedOsu`]
2518    pub const fn acronym() -> Acronym {
2519        unsafe { Acronym::from_str_unchecked("MG") }
2520    }
2521    /// Iterator of [`Acronym`] for mods that are incompatible with [`MagnetisedOsu`]
2522    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2523        unsafe {
2524            [
2525                Acronym::from_str_unchecked("AT"),
2526                Acronym::from_str_unchecked("CN"),
2527                Acronym::from_str_unchecked("RX"),
2528                Acronym::from_str_unchecked("AP"),
2529                Acronym::from_str_unchecked("TR"),
2530                Acronym::from_str_unchecked("WG"),
2531                Acronym::from_str_unchecked("RP"),
2532                Acronym::from_str_unchecked("BU"),
2533                Acronym::from_str_unchecked("DP"),
2534            ]
2535        }
2536        .into_iter()
2537    }
2538    /// The description of [`MagnetisedOsu`]
2539    pub const fn description() -> &'static str {
2540        "No need to chase the circles – your cursor is a magnet!"
2541    }
2542    /// The [`GameModKind`] of [`MagnetisedOsu`]
2543    pub const fn kind() -> GameModKind {
2544        GameModKind::Fun
2545    }
2546}
2547impl RepelOsu {
2548    /// The acronym of [`RepelOsu`]
2549    pub const fn acronym() -> Acronym {
2550        unsafe { Acronym::from_str_unchecked("RP") }
2551    }
2552    /// Iterator of [`Acronym`] for mods that are incompatible with [`RepelOsu`]
2553    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2554        unsafe {
2555            [
2556                Acronym::from_str_unchecked("AT"),
2557                Acronym::from_str_unchecked("CN"),
2558                Acronym::from_str_unchecked("AP"),
2559                Acronym::from_str_unchecked("TR"),
2560                Acronym::from_str_unchecked("WG"),
2561                Acronym::from_str_unchecked("MG"),
2562                Acronym::from_str_unchecked("BU"),
2563                Acronym::from_str_unchecked("DP"),
2564            ]
2565        }
2566        .into_iter()
2567    }
2568    /// The description of [`RepelOsu`]
2569    pub const fn description() -> &'static str {
2570        "Hit objects run away!"
2571    }
2572    /// The [`GameModKind`] of [`RepelOsu`]
2573    pub const fn kind() -> GameModKind {
2574        GameModKind::Fun
2575    }
2576}
2577impl AdaptiveSpeedOsu {
2578    /// The acronym of [`AdaptiveSpeedOsu`]
2579    pub const fn acronym() -> Acronym {
2580        unsafe { Acronym::from_str_unchecked("AS") }
2581    }
2582    /// Iterator of [`Acronym`] for mods that are incompatible with [`AdaptiveSpeedOsu`]
2583    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2584        unsafe {
2585            [
2586                Acronym::from_str_unchecked("HT"),
2587                Acronym::from_str_unchecked("DC"),
2588                Acronym::from_str_unchecked("DT"),
2589                Acronym::from_str_unchecked("NC"),
2590                Acronym::from_str_unchecked("AT"),
2591                Acronym::from_str_unchecked("CN"),
2592                Acronym::from_str_unchecked("WU"),
2593                Acronym::from_str_unchecked("WD"),
2594            ]
2595        }
2596        .into_iter()
2597    }
2598    /// The description of [`AdaptiveSpeedOsu`]
2599    pub const fn description() -> &'static str {
2600        "Let track speed adapt to you."
2601    }
2602    /// The [`GameModKind`] of [`AdaptiveSpeedOsu`]
2603    pub const fn kind() -> GameModKind {
2604        GameModKind::Fun
2605    }
2606}
2607impl FreezeFrameOsu {
2608    /// The acronym of [`FreezeFrameOsu`]
2609    pub const fn acronym() -> Acronym {
2610        unsafe { Acronym::from_str_unchecked("FR") }
2611    }
2612    /// Iterator of [`Acronym`] for mods that are incompatible with [`FreezeFrameOsu`]
2613    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2614        unsafe {
2615            [
2616                Acronym::from_str_unchecked("HD"),
2617                Acronym::from_str_unchecked("TR"),
2618                Acronym::from_str_unchecked("AD"),
2619                Acronym::from_str_unchecked("DP"),
2620            ]
2621        }
2622        .into_iter()
2623    }
2624    /// The description of [`FreezeFrameOsu`]
2625    pub const fn description() -> &'static str {
2626        "Burn the notes into your memory."
2627    }
2628    /// The [`GameModKind`] of [`FreezeFrameOsu`]
2629    pub const fn kind() -> GameModKind {
2630        GameModKind::Fun
2631    }
2632}
2633impl BubblesOsu {
2634    /// The acronym of [`BubblesOsu`]
2635    pub const fn acronym() -> Acronym {
2636        unsafe { Acronym::from_str_unchecked("BU") }
2637    }
2638    /// Iterator of [`Acronym`] for mods that are incompatible with [`BubblesOsu`]
2639    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2640        unsafe {
2641            [
2642                Acronym::from_str_unchecked("BR"),
2643                Acronym::from_str_unchecked("MG"),
2644                Acronym::from_str_unchecked("RP"),
2645            ]
2646        }
2647        .into_iter()
2648    }
2649    /// The description of [`BubblesOsu`]
2650    pub const fn description() -> &'static str {
2651        "Don't let their popping distract you!"
2652    }
2653    /// The [`GameModKind`] of [`BubblesOsu`]
2654    pub const fn kind() -> GameModKind {
2655        GameModKind::Fun
2656    }
2657}
2658impl SynesthesiaOsu {
2659    /// The acronym of [`SynesthesiaOsu`]
2660    pub const fn acronym() -> Acronym {
2661        unsafe { Acronym::from_str_unchecked("SY") }
2662    }
2663    /// Iterator of [`Acronym`] for mods that are incompatible with [`SynesthesiaOsu`]
2664    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2665        [].into_iter()
2666    }
2667    /// The description of [`SynesthesiaOsu`]
2668    pub const fn description() -> &'static str {
2669        "Colours hit objects based on the rhythm."
2670    }
2671    /// The [`GameModKind`] of [`SynesthesiaOsu`]
2672    pub const fn kind() -> GameModKind {
2673        GameModKind::Fun
2674    }
2675}
2676impl DepthOsu {
2677    /// The acronym of [`DepthOsu`]
2678    pub const fn acronym() -> Acronym {
2679        unsafe { Acronym::from_str_unchecked("DP") }
2680    }
2681    /// Iterator of [`Acronym`] for mods that are incompatible with [`DepthOsu`]
2682    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2683        unsafe {
2684            [
2685                Acronym::from_str_unchecked("HD"),
2686                Acronym::from_str_unchecked("TC"),
2687                Acronym::from_str_unchecked("TP"),
2688                Acronym::from_str_unchecked("TR"),
2689                Acronym::from_str_unchecked("WG"),
2690                Acronym::from_str_unchecked("SI"),
2691                Acronym::from_str_unchecked("GR"),
2692                Acronym::from_str_unchecked("DF"),
2693                Acronym::from_str_unchecked("MG"),
2694                Acronym::from_str_unchecked("RP"),
2695                Acronym::from_str_unchecked("FR"),
2696            ]
2697        }
2698        .into_iter()
2699    }
2700    /// The description of [`DepthOsu`]
2701    pub const fn description() -> &'static str {
2702        "3D. Almost."
2703    }
2704    /// The [`GameModKind`] of [`DepthOsu`]
2705    pub const fn kind() -> GameModKind {
2706        GameModKind::Fun
2707    }
2708}
2709impl BloomOsu {
2710    /// The acronym of [`BloomOsu`]
2711    pub const fn acronym() -> Acronym {
2712        unsafe { Acronym::from_str_unchecked("BM") }
2713    }
2714    /// Iterator of [`Acronym`] for mods that are incompatible with [`BloomOsu`]
2715    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2716        unsafe {
2717            [
2718                Acronym::from_str_unchecked("FL"),
2719                Acronym::from_str_unchecked("NS"),
2720                Acronym::from_str_unchecked("TD"),
2721            ]
2722        }
2723        .into_iter()
2724    }
2725    /// The description of [`BloomOsu`]
2726    pub const fn description() -> &'static str {
2727        "The cursor blooms into.. a larger cursor!"
2728    }
2729    /// The [`GameModKind`] of [`BloomOsu`]
2730    pub const fn kind() -> GameModKind {
2731        GameModKind::Fun
2732    }
2733}
2734impl TouchDeviceOsu {
2735    /// The acronym of [`TouchDeviceOsu`]
2736    pub const fn acronym() -> Acronym {
2737        unsafe { Acronym::from_str_unchecked("TD") }
2738    }
2739    /// Iterator of [`Acronym`] for mods that are incompatible with [`TouchDeviceOsu`]
2740    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2741        unsafe {
2742            [
2743                Acronym::from_str_unchecked("AT"),
2744                Acronym::from_str_unchecked("CN"),
2745                Acronym::from_str_unchecked("AP"),
2746                Acronym::from_str_unchecked("BM"),
2747            ]
2748        }
2749        .into_iter()
2750    }
2751    /// The description of [`TouchDeviceOsu`]
2752    pub const fn description() -> &'static str {
2753        "Automatically applied to plays on devices with a touchscreen."
2754    }
2755    /// The [`GameModKind`] of [`TouchDeviceOsu`]
2756    pub const fn kind() -> GameModKind {
2757        GameModKind::System
2758    }
2759    /// Bit value of [`TouchDeviceOsu`]
2760    ///
2761    /// See <https://github.com/ppy/osu-api/wiki#mods>
2762    pub const fn bits() -> u32 {
2763        4
2764    }
2765}
2766impl ScoreV2Osu {
2767    /// The acronym of [`ScoreV2Osu`]
2768    pub const fn acronym() -> Acronym {
2769        unsafe { Acronym::from_str_unchecked("SV2") }
2770    }
2771    /// Iterator of [`Acronym`] for mods that are incompatible with [`ScoreV2Osu`]
2772    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2773        [].into_iter()
2774    }
2775    /// The description of [`ScoreV2Osu`]
2776    pub const fn description() -> &'static str {
2777        "Score set on earlier osu! versions with the V2 scoring algorithm active."
2778    }
2779    /// The [`GameModKind`] of [`ScoreV2Osu`]
2780    pub const fn kind() -> GameModKind {
2781        GameModKind::System
2782    }
2783    /// Bit value of [`ScoreV2Osu`]
2784    ///
2785    /// See <https://github.com/ppy/osu-api/wiki#mods>
2786    pub const fn bits() -> u32 {
2787        536870912
2788    }
2789}
2790impl EasyTaiko {
2791    /// The acronym of [`EasyTaiko`]
2792    pub const fn acronym() -> Acronym {
2793        unsafe { Acronym::from_str_unchecked("EZ") }
2794    }
2795    /// Iterator of [`Acronym`] for mods that are incompatible with [`EasyTaiko`]
2796    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2797        unsafe {
2798            [
2799                Acronym::from_str_unchecked("HR"),
2800                Acronym::from_str_unchecked("DA"),
2801            ]
2802        }
2803        .into_iter()
2804    }
2805    /// The description of [`EasyTaiko`]
2806    pub const fn description() -> &'static str {
2807        "Beats move slower, and less accuracy required!"
2808    }
2809    /// The [`GameModKind`] of [`EasyTaiko`]
2810    pub const fn kind() -> GameModKind {
2811        GameModKind::DifficultyReduction
2812    }
2813    /// Bit value of [`EasyTaiko`]
2814    ///
2815    /// See <https://github.com/ppy/osu-api/wiki#mods>
2816    pub const fn bits() -> u32 {
2817        2
2818    }
2819}
2820impl NoFailTaiko {
2821    /// The acronym of [`NoFailTaiko`]
2822    pub const fn acronym() -> Acronym {
2823        unsafe { Acronym::from_str_unchecked("NF") }
2824    }
2825    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoFailTaiko`]
2826    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2827        unsafe {
2828            [
2829                Acronym::from_str_unchecked("SD"),
2830                Acronym::from_str_unchecked("PF"),
2831                Acronym::from_str_unchecked("AC"),
2832                Acronym::from_str_unchecked("CN"),
2833            ]
2834        }
2835        .into_iter()
2836    }
2837    /// The description of [`NoFailTaiko`]
2838    pub const fn description() -> &'static str {
2839        "You can't fail, no matter what."
2840    }
2841    /// The [`GameModKind`] of [`NoFailTaiko`]
2842    pub const fn kind() -> GameModKind {
2843        GameModKind::DifficultyReduction
2844    }
2845    /// Bit value of [`NoFailTaiko`]
2846    ///
2847    /// See <https://github.com/ppy/osu-api/wiki#mods>
2848    pub const fn bits() -> u32 {
2849        1
2850    }
2851}
2852impl HalfTimeTaiko {
2853    /// The acronym of [`HalfTimeTaiko`]
2854    pub const fn acronym() -> Acronym {
2855        unsafe { Acronym::from_str_unchecked("HT") }
2856    }
2857    /// Iterator of [`Acronym`] for mods that are incompatible with [`HalfTimeTaiko`]
2858    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2859        unsafe {
2860            [
2861                Acronym::from_str_unchecked("DC"),
2862                Acronym::from_str_unchecked("DT"),
2863                Acronym::from_str_unchecked("NC"),
2864                Acronym::from_str_unchecked("WU"),
2865                Acronym::from_str_unchecked("WD"),
2866                Acronym::from_str_unchecked("AS"),
2867            ]
2868        }
2869        .into_iter()
2870    }
2871    /// The description of [`HalfTimeTaiko`]
2872    pub const fn description() -> &'static str {
2873        "Less zoom..."
2874    }
2875    /// The [`GameModKind`] of [`HalfTimeTaiko`]
2876    pub const fn kind() -> GameModKind {
2877        GameModKind::DifficultyReduction
2878    }
2879    /// Bit value of [`HalfTimeTaiko`]
2880    ///
2881    /// See <https://github.com/ppy/osu-api/wiki#mods>
2882    pub const fn bits() -> u32 {
2883        256
2884    }
2885}
2886impl DaycoreTaiko {
2887    /// The acronym of [`DaycoreTaiko`]
2888    pub const fn acronym() -> Acronym {
2889        unsafe { Acronym::from_str_unchecked("DC") }
2890    }
2891    /// Iterator of [`Acronym`] for mods that are incompatible with [`DaycoreTaiko`]
2892    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2893        unsafe {
2894            [
2895                Acronym::from_str_unchecked("HT"),
2896                Acronym::from_str_unchecked("DT"),
2897                Acronym::from_str_unchecked("NC"),
2898                Acronym::from_str_unchecked("WU"),
2899                Acronym::from_str_unchecked("WD"),
2900                Acronym::from_str_unchecked("AS"),
2901            ]
2902        }
2903        .into_iter()
2904    }
2905    /// The description of [`DaycoreTaiko`]
2906    pub const fn description() -> &'static str {
2907        "Whoaaaaa..."
2908    }
2909    /// The [`GameModKind`] of [`DaycoreTaiko`]
2910    pub const fn kind() -> GameModKind {
2911        GameModKind::DifficultyReduction
2912    }
2913}
2914impl SimplifiedRhythmTaiko {
2915    /// The acronym of [`SimplifiedRhythmTaiko`]
2916    pub const fn acronym() -> Acronym {
2917        unsafe { Acronym::from_str_unchecked("SR") }
2918    }
2919    /// Iterator of [`Acronym`] for mods that are incompatible with [`SimplifiedRhythmTaiko`]
2920    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2921        [].into_iter()
2922    }
2923    /// The description of [`SimplifiedRhythmTaiko`]
2924    pub const fn description() -> &'static str {
2925        "Simplify tricky rhythms!"
2926    }
2927    /// The [`GameModKind`] of [`SimplifiedRhythmTaiko`]
2928    pub const fn kind() -> GameModKind {
2929        GameModKind::DifficultyReduction
2930    }
2931}
2932impl HardRockTaiko {
2933    /// The acronym of [`HardRockTaiko`]
2934    pub const fn acronym() -> Acronym {
2935        unsafe { Acronym::from_str_unchecked("HR") }
2936    }
2937    /// Iterator of [`Acronym`] for mods that are incompatible with [`HardRockTaiko`]
2938    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2939        unsafe {
2940            [
2941                Acronym::from_str_unchecked("EZ"),
2942                Acronym::from_str_unchecked("DA"),
2943            ]
2944        }
2945        .into_iter()
2946    }
2947    /// The description of [`HardRockTaiko`]
2948    pub const fn description() -> &'static str {
2949        "Everything just got a bit harder..."
2950    }
2951    /// The [`GameModKind`] of [`HardRockTaiko`]
2952    pub const fn kind() -> GameModKind {
2953        GameModKind::DifficultyIncrease
2954    }
2955    /// Bit value of [`HardRockTaiko`]
2956    ///
2957    /// See <https://github.com/ppy/osu-api/wiki#mods>
2958    pub const fn bits() -> u32 {
2959        16
2960    }
2961}
2962impl SuddenDeathTaiko {
2963    /// The acronym of [`SuddenDeathTaiko`]
2964    pub const fn acronym() -> Acronym {
2965        unsafe { Acronym::from_str_unchecked("SD") }
2966    }
2967    /// Iterator of [`Acronym`] for mods that are incompatible with [`SuddenDeathTaiko`]
2968    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
2969        unsafe {
2970            [
2971                Acronym::from_str_unchecked("NF"),
2972                Acronym::from_str_unchecked("PF"),
2973                Acronym::from_str_unchecked("CN"),
2974            ]
2975        }
2976        .into_iter()
2977    }
2978    /// The description of [`SuddenDeathTaiko`]
2979    pub const fn description() -> &'static str {
2980        "Miss and fail."
2981    }
2982    /// The [`GameModKind`] of [`SuddenDeathTaiko`]
2983    pub const fn kind() -> GameModKind {
2984        GameModKind::DifficultyIncrease
2985    }
2986    /// Bit value of [`SuddenDeathTaiko`]
2987    ///
2988    /// See <https://github.com/ppy/osu-api/wiki#mods>
2989    pub const fn bits() -> u32 {
2990        32
2991    }
2992}
2993impl PerfectTaiko {
2994    /// The acronym of [`PerfectTaiko`]
2995    pub const fn acronym() -> Acronym {
2996        unsafe { Acronym::from_str_unchecked("PF") }
2997    }
2998    /// Iterator of [`Acronym`] for mods that are incompatible with [`PerfectTaiko`]
2999    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3000        unsafe {
3001            [
3002                Acronym::from_str_unchecked("NF"),
3003                Acronym::from_str_unchecked("SD"),
3004                Acronym::from_str_unchecked("AC"),
3005                Acronym::from_str_unchecked("CN"),
3006            ]
3007        }
3008        .into_iter()
3009    }
3010    /// The description of [`PerfectTaiko`]
3011    pub const fn description() -> &'static str {
3012        "SS or quit."
3013    }
3014    /// The [`GameModKind`] of [`PerfectTaiko`]
3015    pub const fn kind() -> GameModKind {
3016        GameModKind::DifficultyIncrease
3017    }
3018    /// Bit value of [`PerfectTaiko`]
3019    ///
3020    /// See <https://github.com/ppy/osu-api/wiki#mods>
3021    pub const fn bits() -> u32 {
3022        16416
3023    }
3024}
3025impl DoubleTimeTaiko {
3026    /// The acronym of [`DoubleTimeTaiko`]
3027    pub const fn acronym() -> Acronym {
3028        unsafe { Acronym::from_str_unchecked("DT") }
3029    }
3030    /// Iterator of [`Acronym`] for mods that are incompatible with [`DoubleTimeTaiko`]
3031    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3032        unsafe {
3033            [
3034                Acronym::from_str_unchecked("HT"),
3035                Acronym::from_str_unchecked("DC"),
3036                Acronym::from_str_unchecked("NC"),
3037                Acronym::from_str_unchecked("WU"),
3038                Acronym::from_str_unchecked("WD"),
3039                Acronym::from_str_unchecked("AS"),
3040            ]
3041        }
3042        .into_iter()
3043    }
3044    /// The description of [`DoubleTimeTaiko`]
3045    pub const fn description() -> &'static str {
3046        "Zoooooooooom..."
3047    }
3048    /// The [`GameModKind`] of [`DoubleTimeTaiko`]
3049    pub const fn kind() -> GameModKind {
3050        GameModKind::DifficultyIncrease
3051    }
3052    /// Bit value of [`DoubleTimeTaiko`]
3053    ///
3054    /// See <https://github.com/ppy/osu-api/wiki#mods>
3055    pub const fn bits() -> u32 {
3056        64
3057    }
3058}
3059impl NightcoreTaiko {
3060    /// The acronym of [`NightcoreTaiko`]
3061    pub const fn acronym() -> Acronym {
3062        unsafe { Acronym::from_str_unchecked("NC") }
3063    }
3064    /// Iterator of [`Acronym`] for mods that are incompatible with [`NightcoreTaiko`]
3065    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3066        unsafe {
3067            [
3068                Acronym::from_str_unchecked("HT"),
3069                Acronym::from_str_unchecked("DC"),
3070                Acronym::from_str_unchecked("DT"),
3071                Acronym::from_str_unchecked("WU"),
3072                Acronym::from_str_unchecked("WD"),
3073                Acronym::from_str_unchecked("AS"),
3074            ]
3075        }
3076        .into_iter()
3077    }
3078    /// The description of [`NightcoreTaiko`]
3079    pub const fn description() -> &'static str {
3080        "Uguuuuuuuu..."
3081    }
3082    /// The [`GameModKind`] of [`NightcoreTaiko`]
3083    pub const fn kind() -> GameModKind {
3084        GameModKind::DifficultyIncrease
3085    }
3086    /// Bit value of [`NightcoreTaiko`]
3087    ///
3088    /// See <https://github.com/ppy/osu-api/wiki#mods>
3089    pub const fn bits() -> u32 {
3090        576
3091    }
3092}
3093impl HiddenTaiko {
3094    /// The acronym of [`HiddenTaiko`]
3095    pub const fn acronym() -> Acronym {
3096        unsafe { Acronym::from_str_unchecked("HD") }
3097    }
3098    /// Iterator of [`Acronym`] for mods that are incompatible with [`HiddenTaiko`]
3099    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3100        [].into_iter()
3101    }
3102    /// The description of [`HiddenTaiko`]
3103    pub const fn description() -> &'static str {
3104        "Beats fade out before you hit them!"
3105    }
3106    /// The [`GameModKind`] of [`HiddenTaiko`]
3107    pub const fn kind() -> GameModKind {
3108        GameModKind::DifficultyIncrease
3109    }
3110    /// Bit value of [`HiddenTaiko`]
3111    ///
3112    /// See <https://github.com/ppy/osu-api/wiki#mods>
3113    pub const fn bits() -> u32 {
3114        8
3115    }
3116}
3117impl FlashlightTaiko {
3118    /// The acronym of [`FlashlightTaiko`]
3119    pub const fn acronym() -> Acronym {
3120        unsafe { Acronym::from_str_unchecked("FL") }
3121    }
3122    /// Iterator of [`Acronym`] for mods that are incompatible with [`FlashlightTaiko`]
3123    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3124        [].into_iter()
3125    }
3126    /// The description of [`FlashlightTaiko`]
3127    pub const fn description() -> &'static str {
3128        "Restricted view area."
3129    }
3130    /// The [`GameModKind`] of [`FlashlightTaiko`]
3131    pub const fn kind() -> GameModKind {
3132        GameModKind::DifficultyIncrease
3133    }
3134    /// Bit value of [`FlashlightTaiko`]
3135    ///
3136    /// See <https://github.com/ppy/osu-api/wiki#mods>
3137    pub const fn bits() -> u32 {
3138        1024
3139    }
3140}
3141impl AccuracyChallengeTaiko {
3142    /// The acronym of [`AccuracyChallengeTaiko`]
3143    pub const fn acronym() -> Acronym {
3144        unsafe { Acronym::from_str_unchecked("AC") }
3145    }
3146    /// Iterator of [`Acronym`] for mods that are incompatible with [`AccuracyChallengeTaiko`]
3147    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3148        unsafe {
3149            [
3150                Acronym::from_str_unchecked("NF"),
3151                Acronym::from_str_unchecked("PF"),
3152                Acronym::from_str_unchecked("CN"),
3153            ]
3154        }
3155        .into_iter()
3156    }
3157    /// The description of [`AccuracyChallengeTaiko`]
3158    pub const fn description() -> &'static str {
3159        "Fail if your accuracy drops too low!"
3160    }
3161    /// The [`GameModKind`] of [`AccuracyChallengeTaiko`]
3162    pub const fn kind() -> GameModKind {
3163        GameModKind::DifficultyIncrease
3164    }
3165}
3166impl RandomTaiko {
3167    /// The acronym of [`RandomTaiko`]
3168    pub const fn acronym() -> Acronym {
3169        unsafe { Acronym::from_str_unchecked("RD") }
3170    }
3171    /// Iterator of [`Acronym`] for mods that are incompatible with [`RandomTaiko`]
3172    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3173        unsafe { [Acronym::from_str_unchecked("SW")] }.into_iter()
3174    }
3175    /// The description of [`RandomTaiko`]
3176    pub const fn description() -> &'static str {
3177        "Shuffle around the colours!"
3178    }
3179    /// The [`GameModKind`] of [`RandomTaiko`]
3180    pub const fn kind() -> GameModKind {
3181        GameModKind::Conversion
3182    }
3183    /// Bit value of [`RandomTaiko`]
3184    ///
3185    /// See <https://github.com/ppy/osu-api/wiki#mods>
3186    pub const fn bits() -> u32 {
3187        2097152
3188    }
3189}
3190impl DifficultyAdjustTaiko {
3191    /// The acronym of [`DifficultyAdjustTaiko`]
3192    pub const fn acronym() -> Acronym {
3193        unsafe { Acronym::from_str_unchecked("DA") }
3194    }
3195    /// Iterator of [`Acronym`] for mods that are incompatible with [`DifficultyAdjustTaiko`]
3196    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3197        unsafe {
3198            [
3199                Acronym::from_str_unchecked("EZ"),
3200                Acronym::from_str_unchecked("HR"),
3201            ]
3202        }
3203        .into_iter()
3204    }
3205    /// The description of [`DifficultyAdjustTaiko`]
3206    pub const fn description() -> &'static str {
3207        "Override a beatmap's difficulty settings."
3208    }
3209    /// The [`GameModKind`] of [`DifficultyAdjustTaiko`]
3210    pub const fn kind() -> GameModKind {
3211        GameModKind::Conversion
3212    }
3213}
3214impl ClassicTaiko {
3215    /// The acronym of [`ClassicTaiko`]
3216    pub const fn acronym() -> Acronym {
3217        unsafe { Acronym::from_str_unchecked("CL") }
3218    }
3219    /// Iterator of [`Acronym`] for mods that are incompatible with [`ClassicTaiko`]
3220    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3221        [].into_iter()
3222    }
3223    /// The description of [`ClassicTaiko`]
3224    pub const fn description() -> &'static str {
3225        "Feeling nostalgic?"
3226    }
3227    /// The [`GameModKind`] of [`ClassicTaiko`]
3228    pub const fn kind() -> GameModKind {
3229        GameModKind::Conversion
3230    }
3231}
3232impl SwapTaiko {
3233    /// The acronym of [`SwapTaiko`]
3234    pub const fn acronym() -> Acronym {
3235        unsafe { Acronym::from_str_unchecked("SW") }
3236    }
3237    /// Iterator of [`Acronym`] for mods that are incompatible with [`SwapTaiko`]
3238    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3239        unsafe { [Acronym::from_str_unchecked("RD")] }.into_iter()
3240    }
3241    /// The description of [`SwapTaiko`]
3242    pub const fn description() -> &'static str {
3243        "Dons become kats, kats become dons"
3244    }
3245    /// The [`GameModKind`] of [`SwapTaiko`]
3246    pub const fn kind() -> GameModKind {
3247        GameModKind::Conversion
3248    }
3249}
3250impl SingleTapTaiko {
3251    /// The acronym of [`SingleTapTaiko`]
3252    pub const fn acronym() -> Acronym {
3253        unsafe { Acronym::from_str_unchecked("SG") }
3254    }
3255    /// Iterator of [`Acronym`] for mods that are incompatible with [`SingleTapTaiko`]
3256    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3257        unsafe {
3258            [
3259                Acronym::from_str_unchecked("AT"),
3260                Acronym::from_str_unchecked("CN"),
3261                Acronym::from_str_unchecked("RX"),
3262            ]
3263        }
3264        .into_iter()
3265    }
3266    /// The description of [`SingleTapTaiko`]
3267    pub const fn description() -> &'static str {
3268        "One key for dons, one key for kats."
3269    }
3270    /// The [`GameModKind`] of [`SingleTapTaiko`]
3271    pub const fn kind() -> GameModKind {
3272        GameModKind::Conversion
3273    }
3274}
3275impl ConstantSpeedTaiko {
3276    /// The acronym of [`ConstantSpeedTaiko`]
3277    pub const fn acronym() -> Acronym {
3278        unsafe { Acronym::from_str_unchecked("CS") }
3279    }
3280    /// Iterator of [`Acronym`] for mods that are incompatible with [`ConstantSpeedTaiko`]
3281    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3282        [].into_iter()
3283    }
3284    /// The description of [`ConstantSpeedTaiko`]
3285    pub const fn description() -> &'static str {
3286        "No more tricky speed changes!"
3287    }
3288    /// The [`GameModKind`] of [`ConstantSpeedTaiko`]
3289    pub const fn kind() -> GameModKind {
3290        GameModKind::Conversion
3291    }
3292}
3293impl AutoplayTaiko {
3294    /// The acronym of [`AutoplayTaiko`]
3295    pub const fn acronym() -> Acronym {
3296        unsafe { Acronym::from_str_unchecked("AT") }
3297    }
3298    /// Iterator of [`Acronym`] for mods that are incompatible with [`AutoplayTaiko`]
3299    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3300        unsafe {
3301            [
3302                Acronym::from_str_unchecked("SG"),
3303                Acronym::from_str_unchecked("CN"),
3304                Acronym::from_str_unchecked("RX"),
3305                Acronym::from_str_unchecked("AS"),
3306            ]
3307        }
3308        .into_iter()
3309    }
3310    /// The description of [`AutoplayTaiko`]
3311    pub const fn description() -> &'static str {
3312        "Watch a perfect automated play through the song."
3313    }
3314    /// The [`GameModKind`] of [`AutoplayTaiko`]
3315    pub const fn kind() -> GameModKind {
3316        GameModKind::Automation
3317    }
3318    /// Bit value of [`AutoplayTaiko`]
3319    ///
3320    /// See <https://github.com/ppy/osu-api/wiki#mods>
3321    pub const fn bits() -> u32 {
3322        2048
3323    }
3324}
3325impl CinemaTaiko {
3326    /// The acronym of [`CinemaTaiko`]
3327    pub const fn acronym() -> Acronym {
3328        unsafe { Acronym::from_str_unchecked("CN") }
3329    }
3330    /// Iterator of [`Acronym`] for mods that are incompatible with [`CinemaTaiko`]
3331    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3332        unsafe {
3333            [
3334                Acronym::from_str_unchecked("NF"),
3335                Acronym::from_str_unchecked("SD"),
3336                Acronym::from_str_unchecked("PF"),
3337                Acronym::from_str_unchecked("AC"),
3338                Acronym::from_str_unchecked("SG"),
3339                Acronym::from_str_unchecked("AT"),
3340                Acronym::from_str_unchecked("RX"),
3341                Acronym::from_str_unchecked("AS"),
3342            ]
3343        }
3344        .into_iter()
3345    }
3346    /// The description of [`CinemaTaiko`]
3347    pub const fn description() -> &'static str {
3348        "Watch the video without visual distractions."
3349    }
3350    /// The [`GameModKind`] of [`CinemaTaiko`]
3351    pub const fn kind() -> GameModKind {
3352        GameModKind::Automation
3353    }
3354    /// Bit value of [`CinemaTaiko`]
3355    ///
3356    /// See <https://github.com/ppy/osu-api/wiki#mods>
3357    pub const fn bits() -> u32 {
3358        4194304
3359    }
3360}
3361impl RelaxTaiko {
3362    /// The acronym of [`RelaxTaiko`]
3363    pub const fn acronym() -> Acronym {
3364        unsafe { Acronym::from_str_unchecked("RX") }
3365    }
3366    /// Iterator of [`Acronym`] for mods that are incompatible with [`RelaxTaiko`]
3367    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3368        unsafe {
3369            [
3370                Acronym::from_str_unchecked("SG"),
3371                Acronym::from_str_unchecked("AT"),
3372                Acronym::from_str_unchecked("CN"),
3373            ]
3374        }
3375        .into_iter()
3376    }
3377    /// The description of [`RelaxTaiko`]
3378    pub const fn description() -> &'static str {
3379        "No need to remember which key is correct anymore!"
3380    }
3381    /// The [`GameModKind`] of [`RelaxTaiko`]
3382    pub const fn kind() -> GameModKind {
3383        GameModKind::Automation
3384    }
3385    /// Bit value of [`RelaxTaiko`]
3386    ///
3387    /// See <https://github.com/ppy/osu-api/wiki#mods>
3388    pub const fn bits() -> u32 {
3389        128
3390    }
3391}
3392impl WindUpTaiko {
3393    /// The acronym of [`WindUpTaiko`]
3394    pub const fn acronym() -> Acronym {
3395        unsafe { Acronym::from_str_unchecked("WU") }
3396    }
3397    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindUpTaiko`]
3398    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3399        unsafe {
3400            [
3401                Acronym::from_str_unchecked("HT"),
3402                Acronym::from_str_unchecked("DC"),
3403                Acronym::from_str_unchecked("DT"),
3404                Acronym::from_str_unchecked("NC"),
3405                Acronym::from_str_unchecked("WD"),
3406                Acronym::from_str_unchecked("AS"),
3407            ]
3408        }
3409        .into_iter()
3410    }
3411    /// The description of [`WindUpTaiko`]
3412    pub const fn description() -> &'static str {
3413        "Can you keep up?"
3414    }
3415    /// The [`GameModKind`] of [`WindUpTaiko`]
3416    pub const fn kind() -> GameModKind {
3417        GameModKind::Fun
3418    }
3419}
3420impl WindDownTaiko {
3421    /// The acronym of [`WindDownTaiko`]
3422    pub const fn acronym() -> Acronym {
3423        unsafe { Acronym::from_str_unchecked("WD") }
3424    }
3425    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindDownTaiko`]
3426    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3427        unsafe {
3428            [
3429                Acronym::from_str_unchecked("HT"),
3430                Acronym::from_str_unchecked("DC"),
3431                Acronym::from_str_unchecked("DT"),
3432                Acronym::from_str_unchecked("NC"),
3433                Acronym::from_str_unchecked("WU"),
3434                Acronym::from_str_unchecked("AS"),
3435            ]
3436        }
3437        .into_iter()
3438    }
3439    /// The description of [`WindDownTaiko`]
3440    pub const fn description() -> &'static str {
3441        "Sloooow doooown..."
3442    }
3443    /// The [`GameModKind`] of [`WindDownTaiko`]
3444    pub const fn kind() -> GameModKind {
3445        GameModKind::Fun
3446    }
3447}
3448impl MutedTaiko {
3449    /// The acronym of [`MutedTaiko`]
3450    pub const fn acronym() -> Acronym {
3451        unsafe { Acronym::from_str_unchecked("MU") }
3452    }
3453    /// Iterator of [`Acronym`] for mods that are incompatible with [`MutedTaiko`]
3454    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3455        [].into_iter()
3456    }
3457    /// The description of [`MutedTaiko`]
3458    pub const fn description() -> &'static str {
3459        "Can you still feel the rhythm without music?"
3460    }
3461    /// The [`GameModKind`] of [`MutedTaiko`]
3462    pub const fn kind() -> GameModKind {
3463        GameModKind::Fun
3464    }
3465}
3466impl AdaptiveSpeedTaiko {
3467    /// The acronym of [`AdaptiveSpeedTaiko`]
3468    pub const fn acronym() -> Acronym {
3469        unsafe { Acronym::from_str_unchecked("AS") }
3470    }
3471    /// Iterator of [`Acronym`] for mods that are incompatible with [`AdaptiveSpeedTaiko`]
3472    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3473        unsafe {
3474            [
3475                Acronym::from_str_unchecked("HT"),
3476                Acronym::from_str_unchecked("DC"),
3477                Acronym::from_str_unchecked("DT"),
3478                Acronym::from_str_unchecked("NC"),
3479                Acronym::from_str_unchecked("AT"),
3480                Acronym::from_str_unchecked("CN"),
3481                Acronym::from_str_unchecked("WU"),
3482                Acronym::from_str_unchecked("WD"),
3483            ]
3484        }
3485        .into_iter()
3486    }
3487    /// The description of [`AdaptiveSpeedTaiko`]
3488    pub const fn description() -> &'static str {
3489        "Let track speed adapt to you."
3490    }
3491    /// The [`GameModKind`] of [`AdaptiveSpeedTaiko`]
3492    pub const fn kind() -> GameModKind {
3493        GameModKind::Fun
3494    }
3495}
3496impl ScoreV2Taiko {
3497    /// The acronym of [`ScoreV2Taiko`]
3498    pub const fn acronym() -> Acronym {
3499        unsafe { Acronym::from_str_unchecked("SV2") }
3500    }
3501    /// Iterator of [`Acronym`] for mods that are incompatible with [`ScoreV2Taiko`]
3502    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3503        [].into_iter()
3504    }
3505    /// The description of [`ScoreV2Taiko`]
3506    pub const fn description() -> &'static str {
3507        "Score set on earlier osu! versions with the V2 scoring algorithm active."
3508    }
3509    /// The [`GameModKind`] of [`ScoreV2Taiko`]
3510    pub const fn kind() -> GameModKind {
3511        GameModKind::System
3512    }
3513    /// Bit value of [`ScoreV2Taiko`]
3514    ///
3515    /// See <https://github.com/ppy/osu-api/wiki#mods>
3516    pub const fn bits() -> u32 {
3517        536870912
3518    }
3519}
3520impl EasyCatch {
3521    /// The acronym of [`EasyCatch`]
3522    pub const fn acronym() -> Acronym {
3523        unsafe { Acronym::from_str_unchecked("EZ") }
3524    }
3525    /// Iterator of [`Acronym`] for mods that are incompatible with [`EasyCatch`]
3526    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3527        unsafe {
3528            [
3529                Acronym::from_str_unchecked("HR"),
3530                Acronym::from_str_unchecked("AC"),
3531                Acronym::from_str_unchecked("DA"),
3532            ]
3533        }
3534        .into_iter()
3535    }
3536    /// The description of [`EasyCatch`]
3537    pub const fn description() -> &'static str {
3538        "Larger fruits, more forgiving HP drain, less accuracy required, and extra lives!"
3539    }
3540    /// The [`GameModKind`] of [`EasyCatch`]
3541    pub const fn kind() -> GameModKind {
3542        GameModKind::DifficultyReduction
3543    }
3544    /// Bit value of [`EasyCatch`]
3545    ///
3546    /// See <https://github.com/ppy/osu-api/wiki#mods>
3547    pub const fn bits() -> u32 {
3548        2
3549    }
3550}
3551impl NoFailCatch {
3552    /// The acronym of [`NoFailCatch`]
3553    pub const fn acronym() -> Acronym {
3554        unsafe { Acronym::from_str_unchecked("NF") }
3555    }
3556    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoFailCatch`]
3557    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3558        unsafe {
3559            [
3560                Acronym::from_str_unchecked("SD"),
3561                Acronym::from_str_unchecked("PF"),
3562                Acronym::from_str_unchecked("AC"),
3563                Acronym::from_str_unchecked("CN"),
3564            ]
3565        }
3566        .into_iter()
3567    }
3568    /// The description of [`NoFailCatch`]
3569    pub const fn description() -> &'static str {
3570        "You can't fail, no matter what."
3571    }
3572    /// The [`GameModKind`] of [`NoFailCatch`]
3573    pub const fn kind() -> GameModKind {
3574        GameModKind::DifficultyReduction
3575    }
3576    /// Bit value of [`NoFailCatch`]
3577    ///
3578    /// See <https://github.com/ppy/osu-api/wiki#mods>
3579    pub const fn bits() -> u32 {
3580        1
3581    }
3582}
3583impl HalfTimeCatch {
3584    /// The acronym of [`HalfTimeCatch`]
3585    pub const fn acronym() -> Acronym {
3586        unsafe { Acronym::from_str_unchecked("HT") }
3587    }
3588    /// Iterator of [`Acronym`] for mods that are incompatible with [`HalfTimeCatch`]
3589    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3590        unsafe {
3591            [
3592                Acronym::from_str_unchecked("DC"),
3593                Acronym::from_str_unchecked("DT"),
3594                Acronym::from_str_unchecked("NC"),
3595                Acronym::from_str_unchecked("WU"),
3596                Acronym::from_str_unchecked("WD"),
3597            ]
3598        }
3599        .into_iter()
3600    }
3601    /// The description of [`HalfTimeCatch`]
3602    pub const fn description() -> &'static str {
3603        "Less zoom..."
3604    }
3605    /// The [`GameModKind`] of [`HalfTimeCatch`]
3606    pub const fn kind() -> GameModKind {
3607        GameModKind::DifficultyReduction
3608    }
3609    /// Bit value of [`HalfTimeCatch`]
3610    ///
3611    /// See <https://github.com/ppy/osu-api/wiki#mods>
3612    pub const fn bits() -> u32 {
3613        256
3614    }
3615}
3616impl DaycoreCatch {
3617    /// The acronym of [`DaycoreCatch`]
3618    pub const fn acronym() -> Acronym {
3619        unsafe { Acronym::from_str_unchecked("DC") }
3620    }
3621    /// Iterator of [`Acronym`] for mods that are incompatible with [`DaycoreCatch`]
3622    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3623        unsafe {
3624            [
3625                Acronym::from_str_unchecked("HT"),
3626                Acronym::from_str_unchecked("DT"),
3627                Acronym::from_str_unchecked("NC"),
3628                Acronym::from_str_unchecked("WU"),
3629                Acronym::from_str_unchecked("WD"),
3630            ]
3631        }
3632        .into_iter()
3633    }
3634    /// The description of [`DaycoreCatch`]
3635    pub const fn description() -> &'static str {
3636        "Whoaaaaa..."
3637    }
3638    /// The [`GameModKind`] of [`DaycoreCatch`]
3639    pub const fn kind() -> GameModKind {
3640        GameModKind::DifficultyReduction
3641    }
3642}
3643impl HardRockCatch {
3644    /// The acronym of [`HardRockCatch`]
3645    pub const fn acronym() -> Acronym {
3646        unsafe { Acronym::from_str_unchecked("HR") }
3647    }
3648    /// Iterator of [`Acronym`] for mods that are incompatible with [`HardRockCatch`]
3649    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3650        unsafe {
3651            [
3652                Acronym::from_str_unchecked("EZ"),
3653                Acronym::from_str_unchecked("DA"),
3654            ]
3655        }
3656        .into_iter()
3657    }
3658    /// The description of [`HardRockCatch`]
3659    pub const fn description() -> &'static str {
3660        "Everything just got a bit harder..."
3661    }
3662    /// The [`GameModKind`] of [`HardRockCatch`]
3663    pub const fn kind() -> GameModKind {
3664        GameModKind::DifficultyIncrease
3665    }
3666    /// Bit value of [`HardRockCatch`]
3667    ///
3668    /// See <https://github.com/ppy/osu-api/wiki#mods>
3669    pub const fn bits() -> u32 {
3670        16
3671    }
3672}
3673impl SuddenDeathCatch {
3674    /// The acronym of [`SuddenDeathCatch`]
3675    pub const fn acronym() -> Acronym {
3676        unsafe { Acronym::from_str_unchecked("SD") }
3677    }
3678    /// Iterator of [`Acronym`] for mods that are incompatible with [`SuddenDeathCatch`]
3679    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3680        unsafe {
3681            [
3682                Acronym::from_str_unchecked("NF"),
3683                Acronym::from_str_unchecked("PF"),
3684                Acronym::from_str_unchecked("CN"),
3685            ]
3686        }
3687        .into_iter()
3688    }
3689    /// The description of [`SuddenDeathCatch`]
3690    pub const fn description() -> &'static str {
3691        "Miss and fail."
3692    }
3693    /// The [`GameModKind`] of [`SuddenDeathCatch`]
3694    pub const fn kind() -> GameModKind {
3695        GameModKind::DifficultyIncrease
3696    }
3697    /// Bit value of [`SuddenDeathCatch`]
3698    ///
3699    /// See <https://github.com/ppy/osu-api/wiki#mods>
3700    pub const fn bits() -> u32 {
3701        32
3702    }
3703}
3704impl PerfectCatch {
3705    /// The acronym of [`PerfectCatch`]
3706    pub const fn acronym() -> Acronym {
3707        unsafe { Acronym::from_str_unchecked("PF") }
3708    }
3709    /// Iterator of [`Acronym`] for mods that are incompatible with [`PerfectCatch`]
3710    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3711        unsafe {
3712            [
3713                Acronym::from_str_unchecked("NF"),
3714                Acronym::from_str_unchecked("SD"),
3715                Acronym::from_str_unchecked("AC"),
3716                Acronym::from_str_unchecked("CN"),
3717            ]
3718        }
3719        .into_iter()
3720    }
3721    /// The description of [`PerfectCatch`]
3722    pub const fn description() -> &'static str {
3723        "SS or quit."
3724    }
3725    /// The [`GameModKind`] of [`PerfectCatch`]
3726    pub const fn kind() -> GameModKind {
3727        GameModKind::DifficultyIncrease
3728    }
3729    /// Bit value of [`PerfectCatch`]
3730    ///
3731    /// See <https://github.com/ppy/osu-api/wiki#mods>
3732    pub const fn bits() -> u32 {
3733        16416
3734    }
3735}
3736impl DoubleTimeCatch {
3737    /// The acronym of [`DoubleTimeCatch`]
3738    pub const fn acronym() -> Acronym {
3739        unsafe { Acronym::from_str_unchecked("DT") }
3740    }
3741    /// Iterator of [`Acronym`] for mods that are incompatible with [`DoubleTimeCatch`]
3742    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3743        unsafe {
3744            [
3745                Acronym::from_str_unchecked("HT"),
3746                Acronym::from_str_unchecked("DC"),
3747                Acronym::from_str_unchecked("NC"),
3748                Acronym::from_str_unchecked("WU"),
3749                Acronym::from_str_unchecked("WD"),
3750            ]
3751        }
3752        .into_iter()
3753    }
3754    /// The description of [`DoubleTimeCatch`]
3755    pub const fn description() -> &'static str {
3756        "Zoooooooooom..."
3757    }
3758    /// The [`GameModKind`] of [`DoubleTimeCatch`]
3759    pub const fn kind() -> GameModKind {
3760        GameModKind::DifficultyIncrease
3761    }
3762    /// Bit value of [`DoubleTimeCatch`]
3763    ///
3764    /// See <https://github.com/ppy/osu-api/wiki#mods>
3765    pub const fn bits() -> u32 {
3766        64
3767    }
3768}
3769impl NightcoreCatch {
3770    /// The acronym of [`NightcoreCatch`]
3771    pub const fn acronym() -> Acronym {
3772        unsafe { Acronym::from_str_unchecked("NC") }
3773    }
3774    /// Iterator of [`Acronym`] for mods that are incompatible with [`NightcoreCatch`]
3775    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3776        unsafe {
3777            [
3778                Acronym::from_str_unchecked("HT"),
3779                Acronym::from_str_unchecked("DC"),
3780                Acronym::from_str_unchecked("DT"),
3781                Acronym::from_str_unchecked("WU"),
3782                Acronym::from_str_unchecked("WD"),
3783            ]
3784        }
3785        .into_iter()
3786    }
3787    /// The description of [`NightcoreCatch`]
3788    pub const fn description() -> &'static str {
3789        "Uguuuuuuuu..."
3790    }
3791    /// The [`GameModKind`] of [`NightcoreCatch`]
3792    pub const fn kind() -> GameModKind {
3793        GameModKind::DifficultyIncrease
3794    }
3795    /// Bit value of [`NightcoreCatch`]
3796    ///
3797    /// See <https://github.com/ppy/osu-api/wiki#mods>
3798    pub const fn bits() -> u32 {
3799        576
3800    }
3801}
3802impl HiddenCatch {
3803    /// The acronym of [`HiddenCatch`]
3804    pub const fn acronym() -> Acronym {
3805        unsafe { Acronym::from_str_unchecked("HD") }
3806    }
3807    /// Iterator of [`Acronym`] for mods that are incompatible with [`HiddenCatch`]
3808    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3809        [].into_iter()
3810    }
3811    /// The description of [`HiddenCatch`]
3812    pub const fn description() -> &'static str {
3813        "Play with fading fruits."
3814    }
3815    /// The [`GameModKind`] of [`HiddenCatch`]
3816    pub const fn kind() -> GameModKind {
3817        GameModKind::DifficultyIncrease
3818    }
3819    /// Bit value of [`HiddenCatch`]
3820    ///
3821    /// See <https://github.com/ppy/osu-api/wiki#mods>
3822    pub const fn bits() -> u32 {
3823        8
3824    }
3825}
3826impl FlashlightCatch {
3827    /// The acronym of [`FlashlightCatch`]
3828    pub const fn acronym() -> Acronym {
3829        unsafe { Acronym::from_str_unchecked("FL") }
3830    }
3831    /// Iterator of [`Acronym`] for mods that are incompatible with [`FlashlightCatch`]
3832    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3833        [].into_iter()
3834    }
3835    /// The description of [`FlashlightCatch`]
3836    pub const fn description() -> &'static str {
3837        "Restricted view area."
3838    }
3839    /// The [`GameModKind`] of [`FlashlightCatch`]
3840    pub const fn kind() -> GameModKind {
3841        GameModKind::DifficultyIncrease
3842    }
3843    /// Bit value of [`FlashlightCatch`]
3844    ///
3845    /// See <https://github.com/ppy/osu-api/wiki#mods>
3846    pub const fn bits() -> u32 {
3847        1024
3848    }
3849}
3850impl AccuracyChallengeCatch {
3851    /// The acronym of [`AccuracyChallengeCatch`]
3852    pub const fn acronym() -> Acronym {
3853        unsafe { Acronym::from_str_unchecked("AC") }
3854    }
3855    /// Iterator of [`Acronym`] for mods that are incompatible with [`AccuracyChallengeCatch`]
3856    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3857        unsafe {
3858            [
3859                Acronym::from_str_unchecked("EZ"),
3860                Acronym::from_str_unchecked("NF"),
3861                Acronym::from_str_unchecked("PF"),
3862                Acronym::from_str_unchecked("CN"),
3863            ]
3864        }
3865        .into_iter()
3866    }
3867    /// The description of [`AccuracyChallengeCatch`]
3868    pub const fn description() -> &'static str {
3869        "Fail if your accuracy drops too low!"
3870    }
3871    /// The [`GameModKind`] of [`AccuracyChallengeCatch`]
3872    pub const fn kind() -> GameModKind {
3873        GameModKind::DifficultyIncrease
3874    }
3875}
3876impl DifficultyAdjustCatch {
3877    /// The acronym of [`DifficultyAdjustCatch`]
3878    pub const fn acronym() -> Acronym {
3879        unsafe { Acronym::from_str_unchecked("DA") }
3880    }
3881    /// Iterator of [`Acronym`] for mods that are incompatible with [`DifficultyAdjustCatch`]
3882    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3883        unsafe {
3884            [
3885                Acronym::from_str_unchecked("EZ"),
3886                Acronym::from_str_unchecked("HR"),
3887            ]
3888        }
3889        .into_iter()
3890    }
3891    /// The description of [`DifficultyAdjustCatch`]
3892    pub const fn description() -> &'static str {
3893        "Override a beatmap's difficulty settings."
3894    }
3895    /// The [`GameModKind`] of [`DifficultyAdjustCatch`]
3896    pub const fn kind() -> GameModKind {
3897        GameModKind::Conversion
3898    }
3899}
3900impl ClassicCatch {
3901    /// The acronym of [`ClassicCatch`]
3902    pub const fn acronym() -> Acronym {
3903        unsafe { Acronym::from_str_unchecked("CL") }
3904    }
3905    /// Iterator of [`Acronym`] for mods that are incompatible with [`ClassicCatch`]
3906    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3907        [].into_iter()
3908    }
3909    /// The description of [`ClassicCatch`]
3910    pub const fn description() -> &'static str {
3911        "Feeling nostalgic?"
3912    }
3913    /// The [`GameModKind`] of [`ClassicCatch`]
3914    pub const fn kind() -> GameModKind {
3915        GameModKind::Conversion
3916    }
3917}
3918impl MirrorCatch {
3919    /// The acronym of [`MirrorCatch`]
3920    pub const fn acronym() -> Acronym {
3921        unsafe { Acronym::from_str_unchecked("MR") }
3922    }
3923    /// Iterator of [`Acronym`] for mods that are incompatible with [`MirrorCatch`]
3924    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3925        [].into_iter()
3926    }
3927    /// The description of [`MirrorCatch`]
3928    pub const fn description() -> &'static str {
3929        "Fruits are flipped horizontally."
3930    }
3931    /// The [`GameModKind`] of [`MirrorCatch`]
3932    pub const fn kind() -> GameModKind {
3933        GameModKind::Conversion
3934    }
3935    /// Bit value of [`MirrorCatch`]
3936    ///
3937    /// See <https://github.com/ppy/osu-api/wiki#mods>
3938    pub const fn bits() -> u32 {
3939        1073741824
3940    }
3941}
3942impl AutoplayCatch {
3943    /// The acronym of [`AutoplayCatch`]
3944    pub const fn acronym() -> Acronym {
3945        unsafe { Acronym::from_str_unchecked("AT") }
3946    }
3947    /// Iterator of [`Acronym`] for mods that are incompatible with [`AutoplayCatch`]
3948    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3949        unsafe {
3950            [
3951                Acronym::from_str_unchecked("CN"),
3952                Acronym::from_str_unchecked("RX"),
3953                Acronym::from_str_unchecked("MF"),
3954            ]
3955        }
3956        .into_iter()
3957    }
3958    /// The description of [`AutoplayCatch`]
3959    pub const fn description() -> &'static str {
3960        "Watch a perfect automated play through the song."
3961    }
3962    /// The [`GameModKind`] of [`AutoplayCatch`]
3963    pub const fn kind() -> GameModKind {
3964        GameModKind::Automation
3965    }
3966    /// Bit value of [`AutoplayCatch`]
3967    ///
3968    /// See <https://github.com/ppy/osu-api/wiki#mods>
3969    pub const fn bits() -> u32 {
3970        2048
3971    }
3972}
3973impl CinemaCatch {
3974    /// The acronym of [`CinemaCatch`]
3975    pub const fn acronym() -> Acronym {
3976        unsafe { Acronym::from_str_unchecked("CN") }
3977    }
3978    /// Iterator of [`Acronym`] for mods that are incompatible with [`CinemaCatch`]
3979    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
3980        unsafe {
3981            [
3982                Acronym::from_str_unchecked("NF"),
3983                Acronym::from_str_unchecked("SD"),
3984                Acronym::from_str_unchecked("PF"),
3985                Acronym::from_str_unchecked("AC"),
3986                Acronym::from_str_unchecked("AT"),
3987                Acronym::from_str_unchecked("RX"),
3988                Acronym::from_str_unchecked("MF"),
3989            ]
3990        }
3991        .into_iter()
3992    }
3993    /// The description of [`CinemaCatch`]
3994    pub const fn description() -> &'static str {
3995        "Watch the video without visual distractions."
3996    }
3997    /// The [`GameModKind`] of [`CinemaCatch`]
3998    pub const fn kind() -> GameModKind {
3999        GameModKind::Automation
4000    }
4001    /// Bit value of [`CinemaCatch`]
4002    ///
4003    /// See <https://github.com/ppy/osu-api/wiki#mods>
4004    pub const fn bits() -> u32 {
4005        4194304
4006    }
4007}
4008impl RelaxCatch {
4009    /// The acronym of [`RelaxCatch`]
4010    pub const fn acronym() -> Acronym {
4011        unsafe { Acronym::from_str_unchecked("RX") }
4012    }
4013    /// Iterator of [`Acronym`] for mods that are incompatible with [`RelaxCatch`]
4014    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4015        unsafe {
4016            [
4017                Acronym::from_str_unchecked("AT"),
4018                Acronym::from_str_unchecked("CN"),
4019                Acronym::from_str_unchecked("MF"),
4020            ]
4021        }
4022        .into_iter()
4023    }
4024    /// The description of [`RelaxCatch`]
4025    pub const fn description() -> &'static str {
4026        "Use the mouse to control the catcher."
4027    }
4028    /// The [`GameModKind`] of [`RelaxCatch`]
4029    pub const fn kind() -> GameModKind {
4030        GameModKind::Automation
4031    }
4032    /// Bit value of [`RelaxCatch`]
4033    ///
4034    /// See <https://github.com/ppy/osu-api/wiki#mods>
4035    pub const fn bits() -> u32 {
4036        128
4037    }
4038}
4039impl WindUpCatch {
4040    /// The acronym of [`WindUpCatch`]
4041    pub const fn acronym() -> Acronym {
4042        unsafe { Acronym::from_str_unchecked("WU") }
4043    }
4044    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindUpCatch`]
4045    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4046        unsafe {
4047            [
4048                Acronym::from_str_unchecked("HT"),
4049                Acronym::from_str_unchecked("DC"),
4050                Acronym::from_str_unchecked("DT"),
4051                Acronym::from_str_unchecked("NC"),
4052                Acronym::from_str_unchecked("WD"),
4053            ]
4054        }
4055        .into_iter()
4056    }
4057    /// The description of [`WindUpCatch`]
4058    pub const fn description() -> &'static str {
4059        "Can you keep up?"
4060    }
4061    /// The [`GameModKind`] of [`WindUpCatch`]
4062    pub const fn kind() -> GameModKind {
4063        GameModKind::Fun
4064    }
4065}
4066impl WindDownCatch {
4067    /// The acronym of [`WindDownCatch`]
4068    pub const fn acronym() -> Acronym {
4069        unsafe { Acronym::from_str_unchecked("WD") }
4070    }
4071    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindDownCatch`]
4072    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4073        unsafe {
4074            [
4075                Acronym::from_str_unchecked("HT"),
4076                Acronym::from_str_unchecked("DC"),
4077                Acronym::from_str_unchecked("DT"),
4078                Acronym::from_str_unchecked("NC"),
4079                Acronym::from_str_unchecked("WU"),
4080            ]
4081        }
4082        .into_iter()
4083    }
4084    /// The description of [`WindDownCatch`]
4085    pub const fn description() -> &'static str {
4086        "Sloooow doooown..."
4087    }
4088    /// The [`GameModKind`] of [`WindDownCatch`]
4089    pub const fn kind() -> GameModKind {
4090        GameModKind::Fun
4091    }
4092}
4093impl FloatingFruitsCatch {
4094    /// The acronym of [`FloatingFruitsCatch`]
4095    pub const fn acronym() -> Acronym {
4096        unsafe { Acronym::from_str_unchecked("FF") }
4097    }
4098    /// Iterator of [`Acronym`] for mods that are incompatible with [`FloatingFruitsCatch`]
4099    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4100        [].into_iter()
4101    }
4102    /// The description of [`FloatingFruitsCatch`]
4103    pub const fn description() -> &'static str {
4104        "The fruits are... floating?"
4105    }
4106    /// The [`GameModKind`] of [`FloatingFruitsCatch`]
4107    pub const fn kind() -> GameModKind {
4108        GameModKind::Fun
4109    }
4110}
4111impl MutedCatch {
4112    /// The acronym of [`MutedCatch`]
4113    pub const fn acronym() -> Acronym {
4114        unsafe { Acronym::from_str_unchecked("MU") }
4115    }
4116    /// Iterator of [`Acronym`] for mods that are incompatible with [`MutedCatch`]
4117    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4118        [].into_iter()
4119    }
4120    /// The description of [`MutedCatch`]
4121    pub const fn description() -> &'static str {
4122        "Can you still feel the rhythm without music?"
4123    }
4124    /// The [`GameModKind`] of [`MutedCatch`]
4125    pub const fn kind() -> GameModKind {
4126        GameModKind::Fun
4127    }
4128}
4129impl NoScopeCatch {
4130    /// The acronym of [`NoScopeCatch`]
4131    pub const fn acronym() -> Acronym {
4132        unsafe { Acronym::from_str_unchecked("NS") }
4133    }
4134    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoScopeCatch`]
4135    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4136        [].into_iter()
4137    }
4138    /// The description of [`NoScopeCatch`]
4139    pub const fn description() -> &'static str {
4140        "Where's the catcher?"
4141    }
4142    /// The [`GameModKind`] of [`NoScopeCatch`]
4143    pub const fn kind() -> GameModKind {
4144        GameModKind::Fun
4145    }
4146}
4147impl MovingFastCatch {
4148    /// The acronym of [`MovingFastCatch`]
4149    pub const fn acronym() -> Acronym {
4150        unsafe { Acronym::from_str_unchecked("MF") }
4151    }
4152    /// Iterator of [`Acronym`] for mods that are incompatible with [`MovingFastCatch`]
4153    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4154        unsafe {
4155            [
4156                Acronym::from_str_unchecked("AT"),
4157                Acronym::from_str_unchecked("CN"),
4158                Acronym::from_str_unchecked("RX"),
4159            ]
4160        }
4161        .into_iter()
4162    }
4163    /// The description of [`MovingFastCatch`]
4164    pub const fn description() -> &'static str {
4165        "Dashing by default, slow down!"
4166    }
4167    /// The [`GameModKind`] of [`MovingFastCatch`]
4168    pub const fn kind() -> GameModKind {
4169        GameModKind::Fun
4170    }
4171}
4172impl ScoreV2Catch {
4173    /// The acronym of [`ScoreV2Catch`]
4174    pub const fn acronym() -> Acronym {
4175        unsafe { Acronym::from_str_unchecked("SV2") }
4176    }
4177    /// Iterator of [`Acronym`] for mods that are incompatible with [`ScoreV2Catch`]
4178    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4179        [].into_iter()
4180    }
4181    /// The description of [`ScoreV2Catch`]
4182    pub const fn description() -> &'static str {
4183        "Score set on earlier osu! versions with the V2 scoring algorithm active."
4184    }
4185    /// The [`GameModKind`] of [`ScoreV2Catch`]
4186    pub const fn kind() -> GameModKind {
4187        GameModKind::System
4188    }
4189    /// Bit value of [`ScoreV2Catch`]
4190    ///
4191    /// See <https://github.com/ppy/osu-api/wiki#mods>
4192    pub const fn bits() -> u32 {
4193        536870912
4194    }
4195}
4196impl EasyMania {
4197    /// The acronym of [`EasyMania`]
4198    pub const fn acronym() -> Acronym {
4199        unsafe { Acronym::from_str_unchecked("EZ") }
4200    }
4201    /// Iterator of [`Acronym`] for mods that are incompatible with [`EasyMania`]
4202    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4203        unsafe {
4204            [
4205                Acronym::from_str_unchecked("HR"),
4206                Acronym::from_str_unchecked("AC"),
4207                Acronym::from_str_unchecked("DA"),
4208            ]
4209        }
4210        .into_iter()
4211    }
4212    /// The description of [`EasyMania`]
4213    pub const fn description() -> &'static str {
4214        "More forgiving HP drain, less accuracy required, and extra lives!"
4215    }
4216    /// The [`GameModKind`] of [`EasyMania`]
4217    pub const fn kind() -> GameModKind {
4218        GameModKind::DifficultyReduction
4219    }
4220    /// Bit value of [`EasyMania`]
4221    ///
4222    /// See <https://github.com/ppy/osu-api/wiki#mods>
4223    pub const fn bits() -> u32 {
4224        2
4225    }
4226}
4227impl NoFailMania {
4228    /// The acronym of [`NoFailMania`]
4229    pub const fn acronym() -> Acronym {
4230        unsafe { Acronym::from_str_unchecked("NF") }
4231    }
4232    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoFailMania`]
4233    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4234        unsafe {
4235            [
4236                Acronym::from_str_unchecked("SD"),
4237                Acronym::from_str_unchecked("PF"),
4238                Acronym::from_str_unchecked("AC"),
4239                Acronym::from_str_unchecked("CN"),
4240            ]
4241        }
4242        .into_iter()
4243    }
4244    /// The description of [`NoFailMania`]
4245    pub const fn description() -> &'static str {
4246        "You can't fail, no matter what."
4247    }
4248    /// The [`GameModKind`] of [`NoFailMania`]
4249    pub const fn kind() -> GameModKind {
4250        GameModKind::DifficultyReduction
4251    }
4252    /// Bit value of [`NoFailMania`]
4253    ///
4254    /// See <https://github.com/ppy/osu-api/wiki#mods>
4255    pub const fn bits() -> u32 {
4256        1
4257    }
4258}
4259impl HalfTimeMania {
4260    /// The acronym of [`HalfTimeMania`]
4261    pub const fn acronym() -> Acronym {
4262        unsafe { Acronym::from_str_unchecked("HT") }
4263    }
4264    /// Iterator of [`Acronym`] for mods that are incompatible with [`HalfTimeMania`]
4265    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4266        unsafe {
4267            [
4268                Acronym::from_str_unchecked("DC"),
4269                Acronym::from_str_unchecked("DT"),
4270                Acronym::from_str_unchecked("NC"),
4271                Acronym::from_str_unchecked("WU"),
4272                Acronym::from_str_unchecked("WD"),
4273                Acronym::from_str_unchecked("AS"),
4274            ]
4275        }
4276        .into_iter()
4277    }
4278    /// The description of [`HalfTimeMania`]
4279    pub const fn description() -> &'static str {
4280        "Less zoom..."
4281    }
4282    /// The [`GameModKind`] of [`HalfTimeMania`]
4283    pub const fn kind() -> GameModKind {
4284        GameModKind::DifficultyReduction
4285    }
4286    /// Bit value of [`HalfTimeMania`]
4287    ///
4288    /// See <https://github.com/ppy/osu-api/wiki#mods>
4289    pub const fn bits() -> u32 {
4290        256
4291    }
4292}
4293impl DaycoreMania {
4294    /// The acronym of [`DaycoreMania`]
4295    pub const fn acronym() -> Acronym {
4296        unsafe { Acronym::from_str_unchecked("DC") }
4297    }
4298    /// Iterator of [`Acronym`] for mods that are incompatible with [`DaycoreMania`]
4299    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4300        unsafe {
4301            [
4302                Acronym::from_str_unchecked("HT"),
4303                Acronym::from_str_unchecked("DT"),
4304                Acronym::from_str_unchecked("NC"),
4305                Acronym::from_str_unchecked("WU"),
4306                Acronym::from_str_unchecked("WD"),
4307                Acronym::from_str_unchecked("AS"),
4308            ]
4309        }
4310        .into_iter()
4311    }
4312    /// The description of [`DaycoreMania`]
4313    pub const fn description() -> &'static str {
4314        "Whoaaaaa..."
4315    }
4316    /// The [`GameModKind`] of [`DaycoreMania`]
4317    pub const fn kind() -> GameModKind {
4318        GameModKind::DifficultyReduction
4319    }
4320}
4321impl NoReleaseMania {
4322    /// The acronym of [`NoReleaseMania`]
4323    pub const fn acronym() -> Acronym {
4324        unsafe { Acronym::from_str_unchecked("NR") }
4325    }
4326    /// Iterator of [`Acronym`] for mods that are incompatible with [`NoReleaseMania`]
4327    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4328        unsafe { [Acronym::from_str_unchecked("HO")] }.into_iter()
4329    }
4330    /// The description of [`NoReleaseMania`]
4331    pub const fn description() -> &'static str {
4332        "No more timing the end of hold notes."
4333    }
4334    /// The [`GameModKind`] of [`NoReleaseMania`]
4335    pub const fn kind() -> GameModKind {
4336        GameModKind::DifficultyReduction
4337    }
4338}
4339impl HardRockMania {
4340    /// The acronym of [`HardRockMania`]
4341    pub const fn acronym() -> Acronym {
4342        unsafe { Acronym::from_str_unchecked("HR") }
4343    }
4344    /// Iterator of [`Acronym`] for mods that are incompatible with [`HardRockMania`]
4345    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4346        unsafe {
4347            [
4348                Acronym::from_str_unchecked("EZ"),
4349                Acronym::from_str_unchecked("DA"),
4350            ]
4351        }
4352        .into_iter()
4353    }
4354    /// The description of [`HardRockMania`]
4355    pub const fn description() -> &'static str {
4356        "Everything just got a bit harder..."
4357    }
4358    /// The [`GameModKind`] of [`HardRockMania`]
4359    pub const fn kind() -> GameModKind {
4360        GameModKind::DifficultyIncrease
4361    }
4362    /// Bit value of [`HardRockMania`]
4363    ///
4364    /// See <https://github.com/ppy/osu-api/wiki#mods>
4365    pub const fn bits() -> u32 {
4366        16
4367    }
4368}
4369impl SuddenDeathMania {
4370    /// The acronym of [`SuddenDeathMania`]
4371    pub const fn acronym() -> Acronym {
4372        unsafe { Acronym::from_str_unchecked("SD") }
4373    }
4374    /// Iterator of [`Acronym`] for mods that are incompatible with [`SuddenDeathMania`]
4375    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4376        unsafe {
4377            [
4378                Acronym::from_str_unchecked("NF"),
4379                Acronym::from_str_unchecked("PF"),
4380                Acronym::from_str_unchecked("CN"),
4381            ]
4382        }
4383        .into_iter()
4384    }
4385    /// The description of [`SuddenDeathMania`]
4386    pub const fn description() -> &'static str {
4387        "Miss and fail."
4388    }
4389    /// The [`GameModKind`] of [`SuddenDeathMania`]
4390    pub const fn kind() -> GameModKind {
4391        GameModKind::DifficultyIncrease
4392    }
4393    /// Bit value of [`SuddenDeathMania`]
4394    ///
4395    /// See <https://github.com/ppy/osu-api/wiki#mods>
4396    pub const fn bits() -> u32 {
4397        32
4398    }
4399}
4400impl PerfectMania {
4401    /// The acronym of [`PerfectMania`]
4402    pub const fn acronym() -> Acronym {
4403        unsafe { Acronym::from_str_unchecked("PF") }
4404    }
4405    /// Iterator of [`Acronym`] for mods that are incompatible with [`PerfectMania`]
4406    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4407        unsafe {
4408            [
4409                Acronym::from_str_unchecked("NF"),
4410                Acronym::from_str_unchecked("SD"),
4411                Acronym::from_str_unchecked("AC"),
4412                Acronym::from_str_unchecked("CN"),
4413            ]
4414        }
4415        .into_iter()
4416    }
4417    /// The description of [`PerfectMania`]
4418    pub const fn description() -> &'static str {
4419        "SS or quit."
4420    }
4421    /// The [`GameModKind`] of [`PerfectMania`]
4422    pub const fn kind() -> GameModKind {
4423        GameModKind::DifficultyIncrease
4424    }
4425    /// Bit value of [`PerfectMania`]
4426    ///
4427    /// See <https://github.com/ppy/osu-api/wiki#mods>
4428    pub const fn bits() -> u32 {
4429        16416
4430    }
4431}
4432impl DoubleTimeMania {
4433    /// The acronym of [`DoubleTimeMania`]
4434    pub const fn acronym() -> Acronym {
4435        unsafe { Acronym::from_str_unchecked("DT") }
4436    }
4437    /// Iterator of [`Acronym`] for mods that are incompatible with [`DoubleTimeMania`]
4438    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4439        unsafe {
4440            [
4441                Acronym::from_str_unchecked("HT"),
4442                Acronym::from_str_unchecked("DC"),
4443                Acronym::from_str_unchecked("NC"),
4444                Acronym::from_str_unchecked("WU"),
4445                Acronym::from_str_unchecked("WD"),
4446                Acronym::from_str_unchecked("AS"),
4447            ]
4448        }
4449        .into_iter()
4450    }
4451    /// The description of [`DoubleTimeMania`]
4452    pub const fn description() -> &'static str {
4453        "Zoooooooooom..."
4454    }
4455    /// The [`GameModKind`] of [`DoubleTimeMania`]
4456    pub const fn kind() -> GameModKind {
4457        GameModKind::DifficultyIncrease
4458    }
4459    /// Bit value of [`DoubleTimeMania`]
4460    ///
4461    /// See <https://github.com/ppy/osu-api/wiki#mods>
4462    pub const fn bits() -> u32 {
4463        64
4464    }
4465}
4466impl NightcoreMania {
4467    /// The acronym of [`NightcoreMania`]
4468    pub const fn acronym() -> Acronym {
4469        unsafe { Acronym::from_str_unchecked("NC") }
4470    }
4471    /// Iterator of [`Acronym`] for mods that are incompatible with [`NightcoreMania`]
4472    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4473        unsafe {
4474            [
4475                Acronym::from_str_unchecked("HT"),
4476                Acronym::from_str_unchecked("DC"),
4477                Acronym::from_str_unchecked("DT"),
4478                Acronym::from_str_unchecked("WU"),
4479                Acronym::from_str_unchecked("WD"),
4480                Acronym::from_str_unchecked("AS"),
4481            ]
4482        }
4483        .into_iter()
4484    }
4485    /// The description of [`NightcoreMania`]
4486    pub const fn description() -> &'static str {
4487        "Uguuuuuuuu..."
4488    }
4489    /// The [`GameModKind`] of [`NightcoreMania`]
4490    pub const fn kind() -> GameModKind {
4491        GameModKind::DifficultyIncrease
4492    }
4493    /// Bit value of [`NightcoreMania`]
4494    ///
4495    /// See <https://github.com/ppy/osu-api/wiki#mods>
4496    pub const fn bits() -> u32 {
4497        576
4498    }
4499}
4500impl FadeInMania {
4501    /// The acronym of [`FadeInMania`]
4502    pub const fn acronym() -> Acronym {
4503        unsafe { Acronym::from_str_unchecked("FI") }
4504    }
4505    /// Iterator of [`Acronym`] for mods that are incompatible with [`FadeInMania`]
4506    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4507        unsafe {
4508            [
4509                Acronym::from_str_unchecked("HD"),
4510                Acronym::from_str_unchecked("CO"),
4511                Acronym::from_str_unchecked("FL"),
4512            ]
4513        }
4514        .into_iter()
4515    }
4516    /// The description of [`FadeInMania`]
4517    pub const fn description() -> &'static str {
4518        "Keys appear out of nowhere!"
4519    }
4520    /// The [`GameModKind`] of [`FadeInMania`]
4521    pub const fn kind() -> GameModKind {
4522        GameModKind::DifficultyIncrease
4523    }
4524    /// Bit value of [`FadeInMania`]
4525    ///
4526    /// See <https://github.com/ppy/osu-api/wiki#mods>
4527    pub const fn bits() -> u32 {
4528        1048576
4529    }
4530}
4531impl HiddenMania {
4532    /// The acronym of [`HiddenMania`]
4533    pub const fn acronym() -> Acronym {
4534        unsafe { Acronym::from_str_unchecked("HD") }
4535    }
4536    /// Iterator of [`Acronym`] for mods that are incompatible with [`HiddenMania`]
4537    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4538        unsafe {
4539            [
4540                Acronym::from_str_unchecked("FI"),
4541                Acronym::from_str_unchecked("CO"),
4542                Acronym::from_str_unchecked("FL"),
4543            ]
4544        }
4545        .into_iter()
4546    }
4547    /// The description of [`HiddenMania`]
4548    pub const fn description() -> &'static str {
4549        "Keys fade out before you hit them!"
4550    }
4551    /// The [`GameModKind`] of [`HiddenMania`]
4552    pub const fn kind() -> GameModKind {
4553        GameModKind::DifficultyIncrease
4554    }
4555    /// Bit value of [`HiddenMania`]
4556    ///
4557    /// See <https://github.com/ppy/osu-api/wiki#mods>
4558    pub const fn bits() -> u32 {
4559        8
4560    }
4561}
4562impl CoverMania {
4563    /// The acronym of [`CoverMania`]
4564    pub const fn acronym() -> Acronym {
4565        unsafe { Acronym::from_str_unchecked("CO") }
4566    }
4567    /// Iterator of [`Acronym`] for mods that are incompatible with [`CoverMania`]
4568    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4569        unsafe {
4570            [
4571                Acronym::from_str_unchecked("FI"),
4572                Acronym::from_str_unchecked("HD"),
4573                Acronym::from_str_unchecked("FL"),
4574            ]
4575        }
4576        .into_iter()
4577    }
4578    /// The description of [`CoverMania`]
4579    pub const fn description() -> &'static str {
4580        "Decrease the playfield's viewing area."
4581    }
4582    /// The [`GameModKind`] of [`CoverMania`]
4583    pub const fn kind() -> GameModKind {
4584        GameModKind::DifficultyIncrease
4585    }
4586}
4587impl FlashlightMania {
4588    /// The acronym of [`FlashlightMania`]
4589    pub const fn acronym() -> Acronym {
4590        unsafe { Acronym::from_str_unchecked("FL") }
4591    }
4592    /// Iterator of [`Acronym`] for mods that are incompatible with [`FlashlightMania`]
4593    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4594        unsafe {
4595            [
4596                Acronym::from_str_unchecked("FI"),
4597                Acronym::from_str_unchecked("HD"),
4598                Acronym::from_str_unchecked("CO"),
4599            ]
4600        }
4601        .into_iter()
4602    }
4603    /// The description of [`FlashlightMania`]
4604    pub const fn description() -> &'static str {
4605        "Restricted view area."
4606    }
4607    /// The [`GameModKind`] of [`FlashlightMania`]
4608    pub const fn kind() -> GameModKind {
4609        GameModKind::DifficultyIncrease
4610    }
4611    /// Bit value of [`FlashlightMania`]
4612    ///
4613    /// See <https://github.com/ppy/osu-api/wiki#mods>
4614    pub const fn bits() -> u32 {
4615        1024
4616    }
4617}
4618impl AccuracyChallengeMania {
4619    /// The acronym of [`AccuracyChallengeMania`]
4620    pub const fn acronym() -> Acronym {
4621        unsafe { Acronym::from_str_unchecked("AC") }
4622    }
4623    /// Iterator of [`Acronym`] for mods that are incompatible with [`AccuracyChallengeMania`]
4624    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4625        unsafe {
4626            [
4627                Acronym::from_str_unchecked("EZ"),
4628                Acronym::from_str_unchecked("NF"),
4629                Acronym::from_str_unchecked("PF"),
4630                Acronym::from_str_unchecked("CN"),
4631            ]
4632        }
4633        .into_iter()
4634    }
4635    /// The description of [`AccuracyChallengeMania`]
4636    pub const fn description() -> &'static str {
4637        "Fail if your accuracy drops too low!"
4638    }
4639    /// The [`GameModKind`] of [`AccuracyChallengeMania`]
4640    pub const fn kind() -> GameModKind {
4641        GameModKind::DifficultyIncrease
4642    }
4643}
4644impl RandomMania {
4645    /// The acronym of [`RandomMania`]
4646    pub const fn acronym() -> Acronym {
4647        unsafe { Acronym::from_str_unchecked("RD") }
4648    }
4649    /// Iterator of [`Acronym`] for mods that are incompatible with [`RandomMania`]
4650    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4651        [].into_iter()
4652    }
4653    /// The description of [`RandomMania`]
4654    pub const fn description() -> &'static str {
4655        "Shuffle around the keys!"
4656    }
4657    /// The [`GameModKind`] of [`RandomMania`]
4658    pub const fn kind() -> GameModKind {
4659        GameModKind::Conversion
4660    }
4661    /// Bit value of [`RandomMania`]
4662    ///
4663    /// See <https://github.com/ppy/osu-api/wiki#mods>
4664    pub const fn bits() -> u32 {
4665        2097152
4666    }
4667}
4668impl DualStagesMania {
4669    /// The acronym of [`DualStagesMania`]
4670    pub const fn acronym() -> Acronym {
4671        unsafe { Acronym::from_str_unchecked("DS") }
4672    }
4673    /// Iterator of [`Acronym`] for mods that are incompatible with [`DualStagesMania`]
4674    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4675        [].into_iter()
4676    }
4677    /// The description of [`DualStagesMania`]
4678    pub const fn description() -> &'static str {
4679        "Double the stages, double the fun!"
4680    }
4681    /// The [`GameModKind`] of [`DualStagesMania`]
4682    pub const fn kind() -> GameModKind {
4683        GameModKind::Conversion
4684    }
4685    /// Bit value of [`DualStagesMania`]
4686    ///
4687    /// See <https://github.com/ppy/osu-api/wiki#mods>
4688    pub const fn bits() -> u32 {
4689        33554432
4690    }
4691}
4692impl MirrorMania {
4693    /// The acronym of [`MirrorMania`]
4694    pub const fn acronym() -> Acronym {
4695        unsafe { Acronym::from_str_unchecked("MR") }
4696    }
4697    /// Iterator of [`Acronym`] for mods that are incompatible with [`MirrorMania`]
4698    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4699        [].into_iter()
4700    }
4701    /// The description of [`MirrorMania`]
4702    pub const fn description() -> &'static str {
4703        "Notes are flipped horizontally."
4704    }
4705    /// The [`GameModKind`] of [`MirrorMania`]
4706    pub const fn kind() -> GameModKind {
4707        GameModKind::Conversion
4708    }
4709    /// Bit value of [`MirrorMania`]
4710    ///
4711    /// See <https://github.com/ppy/osu-api/wiki#mods>
4712    pub const fn bits() -> u32 {
4713        1073741824
4714    }
4715}
4716impl DifficultyAdjustMania {
4717    /// The acronym of [`DifficultyAdjustMania`]
4718    pub const fn acronym() -> Acronym {
4719        unsafe { Acronym::from_str_unchecked("DA") }
4720    }
4721    /// Iterator of [`Acronym`] for mods that are incompatible with [`DifficultyAdjustMania`]
4722    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4723        unsafe {
4724            [
4725                Acronym::from_str_unchecked("EZ"),
4726                Acronym::from_str_unchecked("HR"),
4727            ]
4728        }
4729        .into_iter()
4730    }
4731    /// The description of [`DifficultyAdjustMania`]
4732    pub const fn description() -> &'static str {
4733        "Override a beatmap's difficulty settings."
4734    }
4735    /// The [`GameModKind`] of [`DifficultyAdjustMania`]
4736    pub const fn kind() -> GameModKind {
4737        GameModKind::Conversion
4738    }
4739}
4740impl ClassicMania {
4741    /// The acronym of [`ClassicMania`]
4742    pub const fn acronym() -> Acronym {
4743        unsafe { Acronym::from_str_unchecked("CL") }
4744    }
4745    /// Iterator of [`Acronym`] for mods that are incompatible with [`ClassicMania`]
4746    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4747        [].into_iter()
4748    }
4749    /// The description of [`ClassicMania`]
4750    pub const fn description() -> &'static str {
4751        "Feeling nostalgic?"
4752    }
4753    /// The [`GameModKind`] of [`ClassicMania`]
4754    pub const fn kind() -> GameModKind {
4755        GameModKind::Conversion
4756    }
4757}
4758impl InvertMania {
4759    /// The acronym of [`InvertMania`]
4760    pub const fn acronym() -> Acronym {
4761        unsafe { Acronym::from_str_unchecked("IN") }
4762    }
4763    /// Iterator of [`Acronym`] for mods that are incompatible with [`InvertMania`]
4764    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4765        unsafe { [Acronym::from_str_unchecked("HO")] }.into_iter()
4766    }
4767    /// The description of [`InvertMania`]
4768    pub const fn description() -> &'static str {
4769        "Hold the keys. To the beat."
4770    }
4771    /// The [`GameModKind`] of [`InvertMania`]
4772    pub const fn kind() -> GameModKind {
4773        GameModKind::Conversion
4774    }
4775}
4776impl ConstantSpeedMania {
4777    /// The acronym of [`ConstantSpeedMania`]
4778    pub const fn acronym() -> Acronym {
4779        unsafe { Acronym::from_str_unchecked("CS") }
4780    }
4781    /// Iterator of [`Acronym`] for mods that are incompatible with [`ConstantSpeedMania`]
4782    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4783        [].into_iter()
4784    }
4785    /// The description of [`ConstantSpeedMania`]
4786    pub const fn description() -> &'static str {
4787        "No more tricky speed changes!"
4788    }
4789    /// The [`GameModKind`] of [`ConstantSpeedMania`]
4790    pub const fn kind() -> GameModKind {
4791        GameModKind::Conversion
4792    }
4793}
4794impl HoldOffMania {
4795    /// The acronym of [`HoldOffMania`]
4796    pub const fn acronym() -> Acronym {
4797        unsafe { Acronym::from_str_unchecked("HO") }
4798    }
4799    /// Iterator of [`Acronym`] for mods that are incompatible with [`HoldOffMania`]
4800    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4801        unsafe {
4802            [
4803                Acronym::from_str_unchecked("NR"),
4804                Acronym::from_str_unchecked("IN"),
4805            ]
4806        }
4807        .into_iter()
4808    }
4809    /// The description of [`HoldOffMania`]
4810    pub const fn description() -> &'static str {
4811        "Replaces all hold notes with normal notes."
4812    }
4813    /// The [`GameModKind`] of [`HoldOffMania`]
4814    pub const fn kind() -> GameModKind {
4815        GameModKind::Conversion
4816    }
4817}
4818impl OneKeyMania {
4819    /// The acronym of [`OneKeyMania`]
4820    pub const fn acronym() -> Acronym {
4821        unsafe { Acronym::from_str_unchecked("1K") }
4822    }
4823    /// Iterator of [`Acronym`] for mods that are incompatible with [`OneKeyMania`]
4824    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4825        unsafe {
4826            [
4827                Acronym::from_str_unchecked("2K"),
4828                Acronym::from_str_unchecked("3K"),
4829                Acronym::from_str_unchecked("4K"),
4830                Acronym::from_str_unchecked("5K"),
4831                Acronym::from_str_unchecked("6K"),
4832                Acronym::from_str_unchecked("7K"),
4833                Acronym::from_str_unchecked("8K"),
4834                Acronym::from_str_unchecked("9K"),
4835                Acronym::from_str_unchecked("10K"),
4836            ]
4837        }
4838        .into_iter()
4839    }
4840    /// The description of [`OneKeyMania`]
4841    pub const fn description() -> &'static str {
4842        "Play with one key."
4843    }
4844    /// The [`GameModKind`] of [`OneKeyMania`]
4845    pub const fn kind() -> GameModKind {
4846        GameModKind::Conversion
4847    }
4848    /// Bit value of [`OneKeyMania`]
4849    ///
4850    /// See <https://github.com/ppy/osu-api/wiki#mods>
4851    pub const fn bits() -> u32 {
4852        67108864
4853    }
4854}
4855impl TwoKeysMania {
4856    /// The acronym of [`TwoKeysMania`]
4857    pub const fn acronym() -> Acronym {
4858        unsafe { Acronym::from_str_unchecked("2K") }
4859    }
4860    /// Iterator of [`Acronym`] for mods that are incompatible with [`TwoKeysMania`]
4861    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4862        unsafe {
4863            [
4864                Acronym::from_str_unchecked("1K"),
4865                Acronym::from_str_unchecked("3K"),
4866                Acronym::from_str_unchecked("4K"),
4867                Acronym::from_str_unchecked("5K"),
4868                Acronym::from_str_unchecked("6K"),
4869                Acronym::from_str_unchecked("7K"),
4870                Acronym::from_str_unchecked("8K"),
4871                Acronym::from_str_unchecked("9K"),
4872                Acronym::from_str_unchecked("10K"),
4873            ]
4874        }
4875        .into_iter()
4876    }
4877    /// The description of [`TwoKeysMania`]
4878    pub const fn description() -> &'static str {
4879        "Play with two keys."
4880    }
4881    /// The [`GameModKind`] of [`TwoKeysMania`]
4882    pub const fn kind() -> GameModKind {
4883        GameModKind::Conversion
4884    }
4885    /// Bit value of [`TwoKeysMania`]
4886    ///
4887    /// See <https://github.com/ppy/osu-api/wiki#mods>
4888    pub const fn bits() -> u32 {
4889        268435456
4890    }
4891}
4892impl ThreeKeysMania {
4893    /// The acronym of [`ThreeKeysMania`]
4894    pub const fn acronym() -> Acronym {
4895        unsafe { Acronym::from_str_unchecked("3K") }
4896    }
4897    /// Iterator of [`Acronym`] for mods that are incompatible with [`ThreeKeysMania`]
4898    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4899        unsafe {
4900            [
4901                Acronym::from_str_unchecked("1K"),
4902                Acronym::from_str_unchecked("2K"),
4903                Acronym::from_str_unchecked("4K"),
4904                Acronym::from_str_unchecked("5K"),
4905                Acronym::from_str_unchecked("6K"),
4906                Acronym::from_str_unchecked("7K"),
4907                Acronym::from_str_unchecked("8K"),
4908                Acronym::from_str_unchecked("9K"),
4909                Acronym::from_str_unchecked("10K"),
4910            ]
4911        }
4912        .into_iter()
4913    }
4914    /// The description of [`ThreeKeysMania`]
4915    pub const fn description() -> &'static str {
4916        "Play with three keys."
4917    }
4918    /// The [`GameModKind`] of [`ThreeKeysMania`]
4919    pub const fn kind() -> GameModKind {
4920        GameModKind::Conversion
4921    }
4922    /// Bit value of [`ThreeKeysMania`]
4923    ///
4924    /// See <https://github.com/ppy/osu-api/wiki#mods>
4925    pub const fn bits() -> u32 {
4926        134217728
4927    }
4928}
4929impl FourKeysMania {
4930    /// The acronym of [`FourKeysMania`]
4931    pub const fn acronym() -> Acronym {
4932        unsafe { Acronym::from_str_unchecked("4K") }
4933    }
4934    /// Iterator of [`Acronym`] for mods that are incompatible with [`FourKeysMania`]
4935    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4936        unsafe {
4937            [
4938                Acronym::from_str_unchecked("1K"),
4939                Acronym::from_str_unchecked("2K"),
4940                Acronym::from_str_unchecked("3K"),
4941                Acronym::from_str_unchecked("5K"),
4942                Acronym::from_str_unchecked("6K"),
4943                Acronym::from_str_unchecked("7K"),
4944                Acronym::from_str_unchecked("8K"),
4945                Acronym::from_str_unchecked("9K"),
4946                Acronym::from_str_unchecked("10K"),
4947            ]
4948        }
4949        .into_iter()
4950    }
4951    /// The description of [`FourKeysMania`]
4952    pub const fn description() -> &'static str {
4953        "Play with four keys."
4954    }
4955    /// The [`GameModKind`] of [`FourKeysMania`]
4956    pub const fn kind() -> GameModKind {
4957        GameModKind::Conversion
4958    }
4959    /// Bit value of [`FourKeysMania`]
4960    ///
4961    /// See <https://github.com/ppy/osu-api/wiki#mods>
4962    pub const fn bits() -> u32 {
4963        32768
4964    }
4965}
4966impl FiveKeysMania {
4967    /// The acronym of [`FiveKeysMania`]
4968    pub const fn acronym() -> Acronym {
4969        unsafe { Acronym::from_str_unchecked("5K") }
4970    }
4971    /// Iterator of [`Acronym`] for mods that are incompatible with [`FiveKeysMania`]
4972    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
4973        unsafe {
4974            [
4975                Acronym::from_str_unchecked("1K"),
4976                Acronym::from_str_unchecked("2K"),
4977                Acronym::from_str_unchecked("3K"),
4978                Acronym::from_str_unchecked("4K"),
4979                Acronym::from_str_unchecked("6K"),
4980                Acronym::from_str_unchecked("7K"),
4981                Acronym::from_str_unchecked("8K"),
4982                Acronym::from_str_unchecked("9K"),
4983                Acronym::from_str_unchecked("10K"),
4984            ]
4985        }
4986        .into_iter()
4987    }
4988    /// The description of [`FiveKeysMania`]
4989    pub const fn description() -> &'static str {
4990        "Play with five keys."
4991    }
4992    /// The [`GameModKind`] of [`FiveKeysMania`]
4993    pub const fn kind() -> GameModKind {
4994        GameModKind::Conversion
4995    }
4996    /// Bit value of [`FiveKeysMania`]
4997    ///
4998    /// See <https://github.com/ppy/osu-api/wiki#mods>
4999    pub const fn bits() -> u32 {
5000        65536
5001    }
5002}
5003impl SixKeysMania {
5004    /// The acronym of [`SixKeysMania`]
5005    pub const fn acronym() -> Acronym {
5006        unsafe { Acronym::from_str_unchecked("6K") }
5007    }
5008    /// Iterator of [`Acronym`] for mods that are incompatible with [`SixKeysMania`]
5009    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5010        unsafe {
5011            [
5012                Acronym::from_str_unchecked("1K"),
5013                Acronym::from_str_unchecked("2K"),
5014                Acronym::from_str_unchecked("3K"),
5015                Acronym::from_str_unchecked("4K"),
5016                Acronym::from_str_unchecked("5K"),
5017                Acronym::from_str_unchecked("7K"),
5018                Acronym::from_str_unchecked("8K"),
5019                Acronym::from_str_unchecked("9K"),
5020                Acronym::from_str_unchecked("10K"),
5021            ]
5022        }
5023        .into_iter()
5024    }
5025    /// The description of [`SixKeysMania`]
5026    pub const fn description() -> &'static str {
5027        "Play with six keys."
5028    }
5029    /// The [`GameModKind`] of [`SixKeysMania`]
5030    pub const fn kind() -> GameModKind {
5031        GameModKind::Conversion
5032    }
5033    /// Bit value of [`SixKeysMania`]
5034    ///
5035    /// See <https://github.com/ppy/osu-api/wiki#mods>
5036    pub const fn bits() -> u32 {
5037        131072
5038    }
5039}
5040impl SevenKeysMania {
5041    /// The acronym of [`SevenKeysMania`]
5042    pub const fn acronym() -> Acronym {
5043        unsafe { Acronym::from_str_unchecked("7K") }
5044    }
5045    /// Iterator of [`Acronym`] for mods that are incompatible with [`SevenKeysMania`]
5046    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5047        unsafe {
5048            [
5049                Acronym::from_str_unchecked("1K"),
5050                Acronym::from_str_unchecked("2K"),
5051                Acronym::from_str_unchecked("3K"),
5052                Acronym::from_str_unchecked("4K"),
5053                Acronym::from_str_unchecked("5K"),
5054                Acronym::from_str_unchecked("6K"),
5055                Acronym::from_str_unchecked("8K"),
5056                Acronym::from_str_unchecked("9K"),
5057                Acronym::from_str_unchecked("10K"),
5058            ]
5059        }
5060        .into_iter()
5061    }
5062    /// The description of [`SevenKeysMania`]
5063    pub const fn description() -> &'static str {
5064        "Play with seven keys."
5065    }
5066    /// The [`GameModKind`] of [`SevenKeysMania`]
5067    pub const fn kind() -> GameModKind {
5068        GameModKind::Conversion
5069    }
5070    /// Bit value of [`SevenKeysMania`]
5071    ///
5072    /// See <https://github.com/ppy/osu-api/wiki#mods>
5073    pub const fn bits() -> u32 {
5074        262144
5075    }
5076}
5077impl EightKeysMania {
5078    /// The acronym of [`EightKeysMania`]
5079    pub const fn acronym() -> Acronym {
5080        unsafe { Acronym::from_str_unchecked("8K") }
5081    }
5082    /// Iterator of [`Acronym`] for mods that are incompatible with [`EightKeysMania`]
5083    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5084        unsafe {
5085            [
5086                Acronym::from_str_unchecked("1K"),
5087                Acronym::from_str_unchecked("2K"),
5088                Acronym::from_str_unchecked("3K"),
5089                Acronym::from_str_unchecked("4K"),
5090                Acronym::from_str_unchecked("5K"),
5091                Acronym::from_str_unchecked("6K"),
5092                Acronym::from_str_unchecked("7K"),
5093                Acronym::from_str_unchecked("9K"),
5094                Acronym::from_str_unchecked("10K"),
5095            ]
5096        }
5097        .into_iter()
5098    }
5099    /// The description of [`EightKeysMania`]
5100    pub const fn description() -> &'static str {
5101        "Play with eight keys."
5102    }
5103    /// The [`GameModKind`] of [`EightKeysMania`]
5104    pub const fn kind() -> GameModKind {
5105        GameModKind::Conversion
5106    }
5107    /// Bit value of [`EightKeysMania`]
5108    ///
5109    /// See <https://github.com/ppy/osu-api/wiki#mods>
5110    pub const fn bits() -> u32 {
5111        524288
5112    }
5113}
5114impl NineKeysMania {
5115    /// The acronym of [`NineKeysMania`]
5116    pub const fn acronym() -> Acronym {
5117        unsafe { Acronym::from_str_unchecked("9K") }
5118    }
5119    /// Iterator of [`Acronym`] for mods that are incompatible with [`NineKeysMania`]
5120    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5121        unsafe {
5122            [
5123                Acronym::from_str_unchecked("1K"),
5124                Acronym::from_str_unchecked("2K"),
5125                Acronym::from_str_unchecked("3K"),
5126                Acronym::from_str_unchecked("4K"),
5127                Acronym::from_str_unchecked("5K"),
5128                Acronym::from_str_unchecked("6K"),
5129                Acronym::from_str_unchecked("7K"),
5130                Acronym::from_str_unchecked("8K"),
5131                Acronym::from_str_unchecked("10K"),
5132            ]
5133        }
5134        .into_iter()
5135    }
5136    /// The description of [`NineKeysMania`]
5137    pub const fn description() -> &'static str {
5138        "Play with nine keys."
5139    }
5140    /// The [`GameModKind`] of [`NineKeysMania`]
5141    pub const fn kind() -> GameModKind {
5142        GameModKind::Conversion
5143    }
5144    /// Bit value of [`NineKeysMania`]
5145    ///
5146    /// See <https://github.com/ppy/osu-api/wiki#mods>
5147    pub const fn bits() -> u32 {
5148        16777216
5149    }
5150}
5151impl TenKeysMania {
5152    /// The acronym of [`TenKeysMania`]
5153    pub const fn acronym() -> Acronym {
5154        unsafe { Acronym::from_str_unchecked("10K") }
5155    }
5156    /// Iterator of [`Acronym`] for mods that are incompatible with [`TenKeysMania`]
5157    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5158        unsafe {
5159            [
5160                Acronym::from_str_unchecked("1K"),
5161                Acronym::from_str_unchecked("2K"),
5162                Acronym::from_str_unchecked("3K"),
5163                Acronym::from_str_unchecked("4K"),
5164                Acronym::from_str_unchecked("5K"),
5165                Acronym::from_str_unchecked("6K"),
5166                Acronym::from_str_unchecked("7K"),
5167                Acronym::from_str_unchecked("8K"),
5168                Acronym::from_str_unchecked("9K"),
5169            ]
5170        }
5171        .into_iter()
5172    }
5173    /// The description of [`TenKeysMania`]
5174    pub const fn description() -> &'static str {
5175        "Play with ten keys."
5176    }
5177    /// The [`GameModKind`] of [`TenKeysMania`]
5178    pub const fn kind() -> GameModKind {
5179        GameModKind::Conversion
5180    }
5181}
5182impl AutoplayMania {
5183    /// The acronym of [`AutoplayMania`]
5184    pub const fn acronym() -> Acronym {
5185        unsafe { Acronym::from_str_unchecked("AT") }
5186    }
5187    /// Iterator of [`Acronym`] for mods that are incompatible with [`AutoplayMania`]
5188    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5189        unsafe {
5190            [
5191                Acronym::from_str_unchecked("CN"),
5192                Acronym::from_str_unchecked("AS"),
5193            ]
5194        }
5195        .into_iter()
5196    }
5197    /// The description of [`AutoplayMania`]
5198    pub const fn description() -> &'static str {
5199        "Watch a perfect automated play through the song."
5200    }
5201    /// The [`GameModKind`] of [`AutoplayMania`]
5202    pub const fn kind() -> GameModKind {
5203        GameModKind::Automation
5204    }
5205    /// Bit value of [`AutoplayMania`]
5206    ///
5207    /// See <https://github.com/ppy/osu-api/wiki#mods>
5208    pub const fn bits() -> u32 {
5209        2048
5210    }
5211}
5212impl CinemaMania {
5213    /// The acronym of [`CinemaMania`]
5214    pub const fn acronym() -> Acronym {
5215        unsafe { Acronym::from_str_unchecked("CN") }
5216    }
5217    /// Iterator of [`Acronym`] for mods that are incompatible with [`CinemaMania`]
5218    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5219        unsafe {
5220            [
5221                Acronym::from_str_unchecked("NF"),
5222                Acronym::from_str_unchecked("SD"),
5223                Acronym::from_str_unchecked("PF"),
5224                Acronym::from_str_unchecked("AC"),
5225                Acronym::from_str_unchecked("AT"),
5226                Acronym::from_str_unchecked("AS"),
5227            ]
5228        }
5229        .into_iter()
5230    }
5231    /// The description of [`CinemaMania`]
5232    pub const fn description() -> &'static str {
5233        "Watch the video without visual distractions."
5234    }
5235    /// The [`GameModKind`] of [`CinemaMania`]
5236    pub const fn kind() -> GameModKind {
5237        GameModKind::Automation
5238    }
5239    /// Bit value of [`CinemaMania`]
5240    ///
5241    /// See <https://github.com/ppy/osu-api/wiki#mods>
5242    pub const fn bits() -> u32 {
5243        4194304
5244    }
5245}
5246impl WindUpMania {
5247    /// The acronym of [`WindUpMania`]
5248    pub const fn acronym() -> Acronym {
5249        unsafe { Acronym::from_str_unchecked("WU") }
5250    }
5251    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindUpMania`]
5252    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5253        unsafe {
5254            [
5255                Acronym::from_str_unchecked("HT"),
5256                Acronym::from_str_unchecked("DC"),
5257                Acronym::from_str_unchecked("DT"),
5258                Acronym::from_str_unchecked("NC"),
5259                Acronym::from_str_unchecked("WD"),
5260                Acronym::from_str_unchecked("AS"),
5261            ]
5262        }
5263        .into_iter()
5264    }
5265    /// The description of [`WindUpMania`]
5266    pub const fn description() -> &'static str {
5267        "Can you keep up?"
5268    }
5269    /// The [`GameModKind`] of [`WindUpMania`]
5270    pub const fn kind() -> GameModKind {
5271        GameModKind::Fun
5272    }
5273}
5274impl WindDownMania {
5275    /// The acronym of [`WindDownMania`]
5276    pub const fn acronym() -> Acronym {
5277        unsafe { Acronym::from_str_unchecked("WD") }
5278    }
5279    /// Iterator of [`Acronym`] for mods that are incompatible with [`WindDownMania`]
5280    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5281        unsafe {
5282            [
5283                Acronym::from_str_unchecked("HT"),
5284                Acronym::from_str_unchecked("DC"),
5285                Acronym::from_str_unchecked("DT"),
5286                Acronym::from_str_unchecked("NC"),
5287                Acronym::from_str_unchecked("WU"),
5288                Acronym::from_str_unchecked("AS"),
5289            ]
5290        }
5291        .into_iter()
5292    }
5293    /// The description of [`WindDownMania`]
5294    pub const fn description() -> &'static str {
5295        "Sloooow doooown..."
5296    }
5297    /// The [`GameModKind`] of [`WindDownMania`]
5298    pub const fn kind() -> GameModKind {
5299        GameModKind::Fun
5300    }
5301}
5302impl MutedMania {
5303    /// The acronym of [`MutedMania`]
5304    pub const fn acronym() -> Acronym {
5305        unsafe { Acronym::from_str_unchecked("MU") }
5306    }
5307    /// Iterator of [`Acronym`] for mods that are incompatible with [`MutedMania`]
5308    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5309        [].into_iter()
5310    }
5311    /// The description of [`MutedMania`]
5312    pub const fn description() -> &'static str {
5313        "Can you still feel the rhythm without music?"
5314    }
5315    /// The [`GameModKind`] of [`MutedMania`]
5316    pub const fn kind() -> GameModKind {
5317        GameModKind::Fun
5318    }
5319}
5320impl AdaptiveSpeedMania {
5321    /// The acronym of [`AdaptiveSpeedMania`]
5322    pub const fn acronym() -> Acronym {
5323        unsafe { Acronym::from_str_unchecked("AS") }
5324    }
5325    /// Iterator of [`Acronym`] for mods that are incompatible with [`AdaptiveSpeedMania`]
5326    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5327        unsafe {
5328            [
5329                Acronym::from_str_unchecked("HT"),
5330                Acronym::from_str_unchecked("DC"),
5331                Acronym::from_str_unchecked("DT"),
5332                Acronym::from_str_unchecked("NC"),
5333                Acronym::from_str_unchecked("AT"),
5334                Acronym::from_str_unchecked("CN"),
5335                Acronym::from_str_unchecked("WU"),
5336                Acronym::from_str_unchecked("WD"),
5337            ]
5338        }
5339        .into_iter()
5340    }
5341    /// The description of [`AdaptiveSpeedMania`]
5342    pub const fn description() -> &'static str {
5343        "Let track speed adapt to you."
5344    }
5345    /// The [`GameModKind`] of [`AdaptiveSpeedMania`]
5346    pub const fn kind() -> GameModKind {
5347        GameModKind::Fun
5348    }
5349}
5350impl ScoreV2Mania {
5351    /// The acronym of [`ScoreV2Mania`]
5352    pub const fn acronym() -> Acronym {
5353        unsafe { Acronym::from_str_unchecked("SV2") }
5354    }
5355    /// Iterator of [`Acronym`] for mods that are incompatible with [`ScoreV2Mania`]
5356    pub fn incompatible_mods() -> impl Iterator<Item = Acronym> {
5357        [].into_iter()
5358    }
5359    /// The description of [`ScoreV2Mania`]
5360    pub const fn description() -> &'static str {
5361        "Score set on earlier osu! versions with the V2 scoring algorithm active."
5362    }
5363    /// The [`GameModKind`] of [`ScoreV2Mania`]
5364    pub const fn kind() -> GameModKind {
5365        GameModKind::System
5366    }
5367    /// Bit value of [`ScoreV2Mania`]
5368    ///
5369    /// See <https://github.com/ppy/osu-api/wiki#mods>
5370    pub const fn bits() -> u32 {
5371        536870912
5372    }
5373}
5374impl UnknownMod {
5375    /// The default [`Acronym`] for an unknown mod without specific
5376    /// acronym.
5377    pub const UNKNOWN_ACRONYM: Acronym = unsafe { Acronym::from_str_unchecked("??") };
5378    /// A custom [`Acronym`] for any unknown mod
5379    pub const fn acronym(self) -> Acronym {
5380        self.acronym
5381    }
5382    /// Returns an empty iterator
5383    pub const fn incompatible_mods() -> std::iter::Empty<Acronym> {
5384        std::iter::empty()
5385    }
5386    /// A custom description for any unknown mod
5387    pub const fn description() -> &'static str {
5388        "Some unknown mod"
5389    }
5390    /// A manually assigned [`GameModKind`] for any unknown mod
5391    pub const fn kind() -> GameModKind {
5392        GameModKind::System
5393    }
5394}
5395impl Default for UnknownMod {
5396    fn default() -> Self {
5397        Self {
5398            acronym: Self::UNKNOWN_ACRONYM,
5399        }
5400    }
5401}
5402pub(crate) mod intermode {
5403    /// A single game mod when the mode is ignored
5404    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
5405    #[cfg_attr(feature = "rkyv",derive(rkyv::Archive,rkyv::Serialize,rkyv::Deserialize,rkyv::Portable,rkyv::bytecheck::CheckBytes,),rkyv(as = Self),bytecheck(crate = rkyv::bytecheck),repr(u8),)]
5406    #[non_exhaustive]
5407    pub enum GameModIntermode {
5408        AccuracyChallenge,
5409        AdaptiveSpeed,
5410        Alternate,
5411        ApproachDifferent,
5412        Autopilot,
5413        Autoplay,
5414        BarrelRoll,
5415        Blinds,
5416        Bloom,
5417        Bubbles,
5418        Cinema,
5419        Classic,
5420        ConstantSpeed,
5421        Cover,
5422        Daycore,
5423        Deflate,
5424        Depth,
5425        DifficultyAdjust,
5426        DoubleTime,
5427        DualStages,
5428        Easy,
5429        EightKeys,
5430        FadeIn,
5431        FiveKeys,
5432        Flashlight,
5433        FloatingFruits,
5434        FourKeys,
5435        FreezeFrame,
5436        Grow,
5437        HalfTime,
5438        HardRock,
5439        Hidden,
5440        HoldOff,
5441        Invert,
5442        Magnetised,
5443        Mirror,
5444        MovingFast,
5445        Muted,
5446        Nightcore,
5447        NineKeys,
5448        NoFail,
5449        NoRelease,
5450        NoScope,
5451        OneKey,
5452        Perfect,
5453        Random,
5454        Relax,
5455        Repel,
5456        ScoreV2,
5457        SevenKeys,
5458        SimplifiedRhythm,
5459        SingleTap,
5460        SixKeys,
5461        SpinIn,
5462        SpunOut,
5463        StrictTracking,
5464        SuddenDeath,
5465        Swap,
5466        Synesthesia,
5467        TargetPractice,
5468        TenKeys,
5469        ThreeKeys,
5470        TouchDevice,
5471        Traceable,
5472        Transform,
5473        TwoKeys,
5474        Wiggle,
5475        WindDown,
5476        WindUp,
5477        Unknown(super::UnknownMod),
5478    }
5479}
5480impl GameModIntermode {
5481    /// The [`Acronym`] of this [`GameModIntermode`]
5482    pub const fn acronym(&self) -> Acronym {
5483        unsafe {
5484            match self {
5485                Self::AccuracyChallenge => Acronym::from_str_unchecked("AC"),
5486                Self::AdaptiveSpeed => Acronym::from_str_unchecked("AS"),
5487                Self::Alternate => Acronym::from_str_unchecked("AL"),
5488                Self::ApproachDifferent => Acronym::from_str_unchecked("AD"),
5489                Self::Autopilot => Acronym::from_str_unchecked("AP"),
5490                Self::Autoplay => Acronym::from_str_unchecked("AT"),
5491                Self::BarrelRoll => Acronym::from_str_unchecked("BR"),
5492                Self::Blinds => Acronym::from_str_unchecked("BL"),
5493                Self::Bloom => Acronym::from_str_unchecked("BM"),
5494                Self::Bubbles => Acronym::from_str_unchecked("BU"),
5495                Self::Cinema => Acronym::from_str_unchecked("CN"),
5496                Self::Classic => Acronym::from_str_unchecked("CL"),
5497                Self::ConstantSpeed => Acronym::from_str_unchecked("CS"),
5498                Self::Cover => Acronym::from_str_unchecked("CO"),
5499                Self::Daycore => Acronym::from_str_unchecked("DC"),
5500                Self::Deflate => Acronym::from_str_unchecked("DF"),
5501                Self::Depth => Acronym::from_str_unchecked("DP"),
5502                Self::DifficultyAdjust => Acronym::from_str_unchecked("DA"),
5503                Self::DoubleTime => Acronym::from_str_unchecked("DT"),
5504                Self::DualStages => Acronym::from_str_unchecked("DS"),
5505                Self::Easy => Acronym::from_str_unchecked("EZ"),
5506                Self::EightKeys => Acronym::from_str_unchecked("8K"),
5507                Self::FadeIn => Acronym::from_str_unchecked("FI"),
5508                Self::FiveKeys => Acronym::from_str_unchecked("5K"),
5509                Self::Flashlight => Acronym::from_str_unchecked("FL"),
5510                Self::FloatingFruits => Acronym::from_str_unchecked("FF"),
5511                Self::FourKeys => Acronym::from_str_unchecked("4K"),
5512                Self::FreezeFrame => Acronym::from_str_unchecked("FR"),
5513                Self::Grow => Acronym::from_str_unchecked("GR"),
5514                Self::HalfTime => Acronym::from_str_unchecked("HT"),
5515                Self::HardRock => Acronym::from_str_unchecked("HR"),
5516                Self::Hidden => Acronym::from_str_unchecked("HD"),
5517                Self::HoldOff => Acronym::from_str_unchecked("HO"),
5518                Self::Invert => Acronym::from_str_unchecked("IN"),
5519                Self::Magnetised => Acronym::from_str_unchecked("MG"),
5520                Self::Mirror => Acronym::from_str_unchecked("MR"),
5521                Self::MovingFast => Acronym::from_str_unchecked("MF"),
5522                Self::Muted => Acronym::from_str_unchecked("MU"),
5523                Self::Nightcore => Acronym::from_str_unchecked("NC"),
5524                Self::NineKeys => Acronym::from_str_unchecked("9K"),
5525                Self::NoFail => Acronym::from_str_unchecked("NF"),
5526                Self::NoRelease => Acronym::from_str_unchecked("NR"),
5527                Self::NoScope => Acronym::from_str_unchecked("NS"),
5528                Self::OneKey => Acronym::from_str_unchecked("1K"),
5529                Self::Perfect => Acronym::from_str_unchecked("PF"),
5530                Self::Random => Acronym::from_str_unchecked("RD"),
5531                Self::Relax => Acronym::from_str_unchecked("RX"),
5532                Self::Repel => Acronym::from_str_unchecked("RP"),
5533                Self::ScoreV2 => Acronym::from_str_unchecked("SV2"),
5534                Self::SevenKeys => Acronym::from_str_unchecked("7K"),
5535                Self::SimplifiedRhythm => Acronym::from_str_unchecked("SR"),
5536                Self::SingleTap => Acronym::from_str_unchecked("SG"),
5537                Self::SixKeys => Acronym::from_str_unchecked("6K"),
5538                Self::SpinIn => Acronym::from_str_unchecked("SI"),
5539                Self::SpunOut => Acronym::from_str_unchecked("SO"),
5540                Self::StrictTracking => Acronym::from_str_unchecked("ST"),
5541                Self::SuddenDeath => Acronym::from_str_unchecked("SD"),
5542                Self::Swap => Acronym::from_str_unchecked("SW"),
5543                Self::Synesthesia => Acronym::from_str_unchecked("SY"),
5544                Self::TargetPractice => Acronym::from_str_unchecked("TP"),
5545                Self::TenKeys => Acronym::from_str_unchecked("10K"),
5546                Self::ThreeKeys => Acronym::from_str_unchecked("3K"),
5547                Self::TouchDevice => Acronym::from_str_unchecked("TD"),
5548                Self::Traceable => Acronym::from_str_unchecked("TC"),
5549                Self::Transform => Acronym::from_str_unchecked("TR"),
5550                Self::TwoKeys => Acronym::from_str_unchecked("2K"),
5551                Self::Wiggle => Acronym::from_str_unchecked("WG"),
5552                Self::WindDown => Acronym::from_str_unchecked("WD"),
5553                Self::WindUp => Acronym::from_str_unchecked("WU"),
5554                Self::Unknown(m) => m.acronym(),
5555            }
5556        }
5557    }
5558    /// Bit value of the [`GameModIntermode`]
5559    ///
5560    /// See <https://github.com/ppy/osu-api/wiki#mods>
5561    pub const fn bits(self) -> Option<u32> {
5562        match self {
5563            Self::AccuracyChallenge => None,
5564            Self::AdaptiveSpeed => None,
5565            Self::Alternate => None,
5566            Self::ApproachDifferent => None,
5567            Self::Autopilot => Some(8192),
5568            Self::Autoplay => Some(2048),
5569            Self::BarrelRoll => None,
5570            Self::Blinds => None,
5571            Self::Bloom => None,
5572            Self::Bubbles => None,
5573            Self::Cinema => Some(4194304),
5574            Self::Classic => None,
5575            Self::ConstantSpeed => None,
5576            Self::Cover => None,
5577            Self::Daycore => None,
5578            Self::Deflate => None,
5579            Self::Depth => None,
5580            Self::DifficultyAdjust => None,
5581            Self::DoubleTime => Some(64),
5582            Self::DualStages => Some(33554432),
5583            Self::Easy => Some(2),
5584            Self::EightKeys => Some(524288),
5585            Self::FadeIn => Some(1048576),
5586            Self::FiveKeys => Some(65536),
5587            Self::Flashlight => Some(1024),
5588            Self::FloatingFruits => None,
5589            Self::FourKeys => Some(32768),
5590            Self::FreezeFrame => None,
5591            Self::Grow => None,
5592            Self::HalfTime => Some(256),
5593            Self::HardRock => Some(16),
5594            Self::Hidden => Some(8),
5595            Self::HoldOff => None,
5596            Self::Invert => None,
5597            Self::Magnetised => None,
5598            Self::Mirror => Some(1073741824),
5599            Self::MovingFast => None,
5600            Self::Muted => None,
5601            Self::Nightcore => Some(576),
5602            Self::NineKeys => Some(16777216),
5603            Self::NoFail => Some(1),
5604            Self::NoRelease => None,
5605            Self::NoScope => None,
5606            Self::OneKey => Some(67108864),
5607            Self::Perfect => Some(16416),
5608            Self::Random => Some(2097152),
5609            Self::Relax => Some(128),
5610            Self::Repel => None,
5611            Self::ScoreV2 => Some(536870912),
5612            Self::SevenKeys => Some(262144),
5613            Self::SimplifiedRhythm => None,
5614            Self::SingleTap => None,
5615            Self::SixKeys => Some(131072),
5616            Self::SpinIn => None,
5617            Self::SpunOut => Some(4096),
5618            Self::StrictTracking => None,
5619            Self::SuddenDeath => Some(32),
5620            Self::Swap => None,
5621            Self::Synesthesia => None,
5622            Self::TargetPractice => Some(8388608),
5623            Self::TenKeys => None,
5624            Self::ThreeKeys => Some(134217728),
5625            Self::TouchDevice => Some(4),
5626            Self::Traceable => None,
5627            Self::Transform => None,
5628            Self::TwoKeys => Some(268435456),
5629            Self::Wiggle => None,
5630            Self::WindDown => None,
5631            Self::WindUp => None,
5632            Self::Unknown(_) => None,
5633        }
5634    }
5635    /// The [`GameModKind`] of this [`GameModIntermode`]
5636    pub const fn kind(&self) -> GameModKind {
5637        match self {
5638            Self::AccuracyChallenge => GameModKind::DifficultyIncrease,
5639            Self::AdaptiveSpeed => GameModKind::Fun,
5640            Self::Alternate => GameModKind::Conversion,
5641            Self::ApproachDifferent => GameModKind::Fun,
5642            Self::Autopilot => GameModKind::Automation,
5643            Self::Autoplay => GameModKind::Automation,
5644            Self::BarrelRoll => GameModKind::Fun,
5645            Self::Blinds => GameModKind::DifficultyIncrease,
5646            Self::Bloom => GameModKind::Fun,
5647            Self::Bubbles => GameModKind::Fun,
5648            Self::Cinema => GameModKind::Automation,
5649            Self::Classic => GameModKind::Conversion,
5650            Self::ConstantSpeed => GameModKind::Conversion,
5651            Self::Cover => GameModKind::DifficultyIncrease,
5652            Self::Daycore => GameModKind::DifficultyReduction,
5653            Self::Deflate => GameModKind::Fun,
5654            Self::Depth => GameModKind::Fun,
5655            Self::DifficultyAdjust => GameModKind::Conversion,
5656            Self::DoubleTime => GameModKind::DifficultyIncrease,
5657            Self::DualStages => GameModKind::Conversion,
5658            Self::Easy => GameModKind::DifficultyReduction,
5659            Self::EightKeys => GameModKind::Conversion,
5660            Self::FadeIn => GameModKind::DifficultyIncrease,
5661            Self::FiveKeys => GameModKind::Conversion,
5662            Self::Flashlight => GameModKind::DifficultyIncrease,
5663            Self::FloatingFruits => GameModKind::Fun,
5664            Self::FourKeys => GameModKind::Conversion,
5665            Self::FreezeFrame => GameModKind::Fun,
5666            Self::Grow => GameModKind::Fun,
5667            Self::HalfTime => GameModKind::DifficultyReduction,
5668            Self::HardRock => GameModKind::DifficultyIncrease,
5669            Self::Hidden => GameModKind::DifficultyIncrease,
5670            Self::HoldOff => GameModKind::Conversion,
5671            Self::Invert => GameModKind::Conversion,
5672            Self::Magnetised => GameModKind::Fun,
5673            Self::Mirror => GameModKind::Conversion,
5674            Self::MovingFast => GameModKind::Fun,
5675            Self::Muted => GameModKind::Fun,
5676            Self::Nightcore => GameModKind::DifficultyIncrease,
5677            Self::NineKeys => GameModKind::Conversion,
5678            Self::NoFail => GameModKind::DifficultyReduction,
5679            Self::NoRelease => GameModKind::DifficultyReduction,
5680            Self::NoScope => GameModKind::Fun,
5681            Self::OneKey => GameModKind::Conversion,
5682            Self::Perfect => GameModKind::DifficultyIncrease,
5683            Self::Random => GameModKind::Conversion,
5684            Self::Relax => GameModKind::Automation,
5685            Self::Repel => GameModKind::Fun,
5686            Self::ScoreV2 => GameModKind::System,
5687            Self::SevenKeys => GameModKind::Conversion,
5688            Self::SimplifiedRhythm => GameModKind::DifficultyReduction,
5689            Self::SingleTap => GameModKind::Conversion,
5690            Self::SixKeys => GameModKind::Conversion,
5691            Self::SpinIn => GameModKind::Fun,
5692            Self::SpunOut => GameModKind::Automation,
5693            Self::StrictTracking => GameModKind::DifficultyIncrease,
5694            Self::SuddenDeath => GameModKind::DifficultyIncrease,
5695            Self::Swap => GameModKind::Conversion,
5696            Self::Synesthesia => GameModKind::Fun,
5697            Self::TargetPractice => GameModKind::Conversion,
5698            Self::TenKeys => GameModKind::Conversion,
5699            Self::ThreeKeys => GameModKind::Conversion,
5700            Self::TouchDevice => GameModKind::System,
5701            Self::Traceable => GameModKind::DifficultyIncrease,
5702            Self::Transform => GameModKind::Fun,
5703            Self::TwoKeys => GameModKind::Conversion,
5704            Self::Wiggle => GameModKind::Fun,
5705            Self::WindDown => GameModKind::Fun,
5706            Self::WindUp => GameModKind::Fun,
5707            Self::Unknown(_) => GameModKind::System,
5708        }
5709    }
5710    /// Parse an [`Acronym`] into a [`GameModIntermode`]
5711    pub fn from_acronym(acronym: Acronym) -> Self {
5712        match acronym.as_str() {
5713            "AC" => Self::AccuracyChallenge,
5714            "AS" => Self::AdaptiveSpeed,
5715            "AL" => Self::Alternate,
5716            "AD" => Self::ApproachDifferent,
5717            "AP" => Self::Autopilot,
5718            "AT" => Self::Autoplay,
5719            "BR" => Self::BarrelRoll,
5720            "BL" => Self::Blinds,
5721            "BM" => Self::Bloom,
5722            "BU" => Self::Bubbles,
5723            "CN" => Self::Cinema,
5724            "CL" => Self::Classic,
5725            "CS" => Self::ConstantSpeed,
5726            "CO" => Self::Cover,
5727            "DC" => Self::Daycore,
5728            "DF" => Self::Deflate,
5729            "DP" => Self::Depth,
5730            "DA" => Self::DifficultyAdjust,
5731            "DT" => Self::DoubleTime,
5732            "DS" => Self::DualStages,
5733            "EZ" => Self::Easy,
5734            "8K" => Self::EightKeys,
5735            "FI" => Self::FadeIn,
5736            "5K" => Self::FiveKeys,
5737            "FL" => Self::Flashlight,
5738            "FF" => Self::FloatingFruits,
5739            "4K" => Self::FourKeys,
5740            "FR" => Self::FreezeFrame,
5741            "GR" => Self::Grow,
5742            "HT" => Self::HalfTime,
5743            "HR" => Self::HardRock,
5744            "HD" => Self::Hidden,
5745            "HO" => Self::HoldOff,
5746            "IN" => Self::Invert,
5747            "MG" => Self::Magnetised,
5748            "MR" => Self::Mirror,
5749            "MF" => Self::MovingFast,
5750            "MU" => Self::Muted,
5751            "NC" => Self::Nightcore,
5752            "9K" => Self::NineKeys,
5753            "NF" => Self::NoFail,
5754            "NR" => Self::NoRelease,
5755            "NS" => Self::NoScope,
5756            "1K" => Self::OneKey,
5757            "PF" => Self::Perfect,
5758            "RD" => Self::Random,
5759            "RX" => Self::Relax,
5760            "RP" => Self::Repel,
5761            "SV2" => Self::ScoreV2,
5762            "7K" => Self::SevenKeys,
5763            "SR" => Self::SimplifiedRhythm,
5764            "SG" => Self::SingleTap,
5765            "6K" => Self::SixKeys,
5766            "SI" => Self::SpinIn,
5767            "SO" => Self::SpunOut,
5768            "ST" => Self::StrictTracking,
5769            "SD" => Self::SuddenDeath,
5770            "SW" => Self::Swap,
5771            "SY" => Self::Synesthesia,
5772            "TP" => Self::TargetPractice,
5773            "10K" => Self::TenKeys,
5774            "3K" => Self::ThreeKeys,
5775            "TD" => Self::TouchDevice,
5776            "TC" => Self::Traceable,
5777            "TR" => Self::Transform,
5778            "2K" => Self::TwoKeys,
5779            "WG" => Self::Wiggle,
5780            "WD" => Self::WindDown,
5781            "WU" => Self::WindUp,
5782            _ => Self::Unknown(UnknownMod { acronym }),
5783        }
5784    }
5785    /// Try to convert bitvalues into a [`GameModIntermode`]
5786    pub const fn try_from_bits(bits: u32) -> Option<Self> {
5787        match bits {
5788            8192 => Some(Self::Autopilot),
5789            2048 => Some(Self::Autoplay),
5790            4194304 => Some(Self::Cinema),
5791            64 => Some(Self::DoubleTime),
5792            33554432 => Some(Self::DualStages),
5793            2 => Some(Self::Easy),
5794            524288 => Some(Self::EightKeys),
5795            1048576 => Some(Self::FadeIn),
5796            65536 => Some(Self::FiveKeys),
5797            1024 => Some(Self::Flashlight),
5798            32768 => Some(Self::FourKeys),
5799            256 => Some(Self::HalfTime),
5800            16 => Some(Self::HardRock),
5801            8 => Some(Self::Hidden),
5802            1073741824 => Some(Self::Mirror),
5803            576 => Some(Self::Nightcore),
5804            16777216 => Some(Self::NineKeys),
5805            1 => Some(Self::NoFail),
5806            67108864 => Some(Self::OneKey),
5807            16416 => Some(Self::Perfect),
5808            2097152 => Some(Self::Random),
5809            128 => Some(Self::Relax),
5810            536870912 => Some(Self::ScoreV2),
5811            262144 => Some(Self::SevenKeys),
5812            131072 => Some(Self::SixKeys),
5813            4096 => Some(Self::SpunOut),
5814            32 => Some(Self::SuddenDeath),
5815            8388608 => Some(Self::TargetPractice),
5816            134217728 => Some(Self::ThreeKeys),
5817            4 => Some(Self::TouchDevice),
5818            268435456 => Some(Self::TwoKeys),
5819            _ => None,
5820        }
5821    }
5822}
5823impl PartialOrd for GameModIntermode {
5824    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
5825        Some(self.cmp(other))
5826    }
5827}
5828impl Ord for GameModIntermode {
5829    fn cmp(&self, other: &Self) -> Ordering {
5830        // <https://github.com/ppy/osu/blob/91bc23e39eb1048d7b75acf669bd46e9ef9a4f9e/osu.Game/Rulesets/Mods/ModExtensions.cs#L33-L35>
5831        self.kind()
5832            .cmp(&other.kind())
5833            .then_with(|| self.acronym().as_str().cmp(&other.acronym().as_str()))
5834    }
5835}
5836impl Display for GameModIntermode {
5837    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
5838        f.write_str(self.acronym().as_str())
5839    }
5840}
5841impl From<&GameModIntermode> for GameModIntermode {
5842    fn from(gamemod: &GameModIntermode) -> Self {
5843        *gamemod
5844    }
5845}
5846impl From<GameMod> for GameModIntermode {
5847    fn from(gamemod: GameMod) -> Self {
5848        gamemod.intermode()
5849    }
5850}
5851pub(crate) mod gamemod {
5852    use super::*;
5853    /// A single game mod
5854    #[derive(Clone, Debug, PartialEq)]
5855    #[cfg_attr(
5856        feature = "rkyv",
5857        derive(::rkyv::Archive, ::rkyv::Serialize, ::rkyv::Deserialize)
5858    )]
5859    #[non_exhaustive]
5860    pub enum GameMod {
5861        EasyOsu(EasyOsu),
5862        NoFailOsu(NoFailOsu),
5863        HalfTimeOsu(HalfTimeOsu),
5864        DaycoreOsu(DaycoreOsu),
5865        HardRockOsu(HardRockOsu),
5866        SuddenDeathOsu(SuddenDeathOsu),
5867        PerfectOsu(PerfectOsu),
5868        DoubleTimeOsu(DoubleTimeOsu),
5869        NightcoreOsu(NightcoreOsu),
5870        HiddenOsu(HiddenOsu),
5871        TraceableOsu(TraceableOsu),
5872        FlashlightOsu(FlashlightOsu),
5873        BlindsOsu(BlindsOsu),
5874        StrictTrackingOsu(StrictTrackingOsu),
5875        AccuracyChallengeOsu(AccuracyChallengeOsu),
5876        TargetPracticeOsu(TargetPracticeOsu),
5877        DifficultyAdjustOsu(DifficultyAdjustOsu),
5878        ClassicOsu(ClassicOsu),
5879        RandomOsu(RandomOsu),
5880        MirrorOsu(MirrorOsu),
5881        AlternateOsu(AlternateOsu),
5882        SingleTapOsu(SingleTapOsu),
5883        AutoplayOsu(AutoplayOsu),
5884        CinemaOsu(CinemaOsu),
5885        RelaxOsu(RelaxOsu),
5886        AutopilotOsu(AutopilotOsu),
5887        SpunOutOsu(SpunOutOsu),
5888        TransformOsu(TransformOsu),
5889        WiggleOsu(WiggleOsu),
5890        SpinInOsu(SpinInOsu),
5891        GrowOsu(GrowOsu),
5892        DeflateOsu(DeflateOsu),
5893        WindUpOsu(WindUpOsu),
5894        WindDownOsu(WindDownOsu),
5895        BarrelRollOsu(BarrelRollOsu),
5896        ApproachDifferentOsu(ApproachDifferentOsu),
5897        MutedOsu(MutedOsu),
5898        NoScopeOsu(NoScopeOsu),
5899        MagnetisedOsu(MagnetisedOsu),
5900        RepelOsu(RepelOsu),
5901        AdaptiveSpeedOsu(AdaptiveSpeedOsu),
5902        FreezeFrameOsu(FreezeFrameOsu),
5903        BubblesOsu(BubblesOsu),
5904        SynesthesiaOsu(SynesthesiaOsu),
5905        DepthOsu(DepthOsu),
5906        BloomOsu(BloomOsu),
5907        TouchDeviceOsu(TouchDeviceOsu),
5908        ScoreV2Osu(ScoreV2Osu),
5909        UnknownOsu(UnknownMod),
5910        EasyTaiko(EasyTaiko),
5911        NoFailTaiko(NoFailTaiko),
5912        HalfTimeTaiko(HalfTimeTaiko),
5913        DaycoreTaiko(DaycoreTaiko),
5914        SimplifiedRhythmTaiko(SimplifiedRhythmTaiko),
5915        HardRockTaiko(HardRockTaiko),
5916        SuddenDeathTaiko(SuddenDeathTaiko),
5917        PerfectTaiko(PerfectTaiko),
5918        DoubleTimeTaiko(DoubleTimeTaiko),
5919        NightcoreTaiko(NightcoreTaiko),
5920        HiddenTaiko(HiddenTaiko),
5921        FlashlightTaiko(FlashlightTaiko),
5922        AccuracyChallengeTaiko(AccuracyChallengeTaiko),
5923        RandomTaiko(RandomTaiko),
5924        DifficultyAdjustTaiko(DifficultyAdjustTaiko),
5925        ClassicTaiko(ClassicTaiko),
5926        SwapTaiko(SwapTaiko),
5927        SingleTapTaiko(SingleTapTaiko),
5928        ConstantSpeedTaiko(ConstantSpeedTaiko),
5929        AutoplayTaiko(AutoplayTaiko),
5930        CinemaTaiko(CinemaTaiko),
5931        RelaxTaiko(RelaxTaiko),
5932        WindUpTaiko(WindUpTaiko),
5933        WindDownTaiko(WindDownTaiko),
5934        MutedTaiko(MutedTaiko),
5935        AdaptiveSpeedTaiko(AdaptiveSpeedTaiko),
5936        ScoreV2Taiko(ScoreV2Taiko),
5937        UnknownTaiko(UnknownMod),
5938        EasyCatch(EasyCatch),
5939        NoFailCatch(NoFailCatch),
5940        HalfTimeCatch(HalfTimeCatch),
5941        DaycoreCatch(DaycoreCatch),
5942        HardRockCatch(HardRockCatch),
5943        SuddenDeathCatch(SuddenDeathCatch),
5944        PerfectCatch(PerfectCatch),
5945        DoubleTimeCatch(DoubleTimeCatch),
5946        NightcoreCatch(NightcoreCatch),
5947        HiddenCatch(HiddenCatch),
5948        FlashlightCatch(FlashlightCatch),
5949        AccuracyChallengeCatch(AccuracyChallengeCatch),
5950        DifficultyAdjustCatch(DifficultyAdjustCatch),
5951        ClassicCatch(ClassicCatch),
5952        MirrorCatch(MirrorCatch),
5953        AutoplayCatch(AutoplayCatch),
5954        CinemaCatch(CinemaCatch),
5955        RelaxCatch(RelaxCatch),
5956        WindUpCatch(WindUpCatch),
5957        WindDownCatch(WindDownCatch),
5958        FloatingFruitsCatch(FloatingFruitsCatch),
5959        MutedCatch(MutedCatch),
5960        NoScopeCatch(NoScopeCatch),
5961        MovingFastCatch(MovingFastCatch),
5962        ScoreV2Catch(ScoreV2Catch),
5963        UnknownCatch(UnknownMod),
5964        EasyMania(EasyMania),
5965        NoFailMania(NoFailMania),
5966        HalfTimeMania(HalfTimeMania),
5967        DaycoreMania(DaycoreMania),
5968        NoReleaseMania(NoReleaseMania),
5969        HardRockMania(HardRockMania),
5970        SuddenDeathMania(SuddenDeathMania),
5971        PerfectMania(PerfectMania),
5972        DoubleTimeMania(DoubleTimeMania),
5973        NightcoreMania(NightcoreMania),
5974        FadeInMania(FadeInMania),
5975        HiddenMania(HiddenMania),
5976        CoverMania(CoverMania),
5977        FlashlightMania(FlashlightMania),
5978        AccuracyChallengeMania(AccuracyChallengeMania),
5979        RandomMania(RandomMania),
5980        DualStagesMania(DualStagesMania),
5981        MirrorMania(MirrorMania),
5982        DifficultyAdjustMania(DifficultyAdjustMania),
5983        ClassicMania(ClassicMania),
5984        InvertMania(InvertMania),
5985        ConstantSpeedMania(ConstantSpeedMania),
5986        HoldOffMania(HoldOffMania),
5987        OneKeyMania(OneKeyMania),
5988        TwoKeysMania(TwoKeysMania),
5989        ThreeKeysMania(ThreeKeysMania),
5990        FourKeysMania(FourKeysMania),
5991        FiveKeysMania(FiveKeysMania),
5992        SixKeysMania(SixKeysMania),
5993        SevenKeysMania(SevenKeysMania),
5994        EightKeysMania(EightKeysMania),
5995        NineKeysMania(NineKeysMania),
5996        TenKeysMania(TenKeysMania),
5997        AutoplayMania(AutoplayMania),
5998        CinemaMania(CinemaMania),
5999        WindUpMania(WindUpMania),
6000        WindDownMania(WindDownMania),
6001        MutedMania(MutedMania),
6002        AdaptiveSpeedMania(AdaptiveSpeedMania),
6003        ScoreV2Mania(ScoreV2Mania),
6004        UnknownMania(UnknownMod),
6005    }
6006}
6007impl GameMod {
6008    /// Create a new [`GameMod`]
6009    pub fn new(acronym: &str, mode: GameMode) -> Self {
6010        match (acronym, mode) {
6011            ("EZ", GameMode::Osu) => Self::EasyOsu(Default::default()),
6012            ("NF", GameMode::Osu) => Self::NoFailOsu(Default::default()),
6013            ("HT", GameMode::Osu) => Self::HalfTimeOsu(Default::default()),
6014            ("DC", GameMode::Osu) => Self::DaycoreOsu(Default::default()),
6015            ("HR", GameMode::Osu) => Self::HardRockOsu(Default::default()),
6016            ("SD", GameMode::Osu) => Self::SuddenDeathOsu(Default::default()),
6017            ("PF", GameMode::Osu) => Self::PerfectOsu(Default::default()),
6018            ("DT", GameMode::Osu) => Self::DoubleTimeOsu(Default::default()),
6019            ("NC", GameMode::Osu) => Self::NightcoreOsu(Default::default()),
6020            ("HD", GameMode::Osu) => Self::HiddenOsu(Default::default()),
6021            ("TC", GameMode::Osu) => Self::TraceableOsu(Default::default()),
6022            ("FL", GameMode::Osu) => Self::FlashlightOsu(Default::default()),
6023            ("BL", GameMode::Osu) => Self::BlindsOsu(Default::default()),
6024            ("ST", GameMode::Osu) => Self::StrictTrackingOsu(Default::default()),
6025            ("AC", GameMode::Osu) => Self::AccuracyChallengeOsu(Default::default()),
6026            ("TP", GameMode::Osu) => Self::TargetPracticeOsu(Default::default()),
6027            ("DA", GameMode::Osu) => Self::DifficultyAdjustOsu(Default::default()),
6028            ("CL", GameMode::Osu) => Self::ClassicOsu(Default::default()),
6029            ("RD", GameMode::Osu) => Self::RandomOsu(Default::default()),
6030            ("MR", GameMode::Osu) => Self::MirrorOsu(Default::default()),
6031            ("AL", GameMode::Osu) => Self::AlternateOsu(Default::default()),
6032            ("SG", GameMode::Osu) => Self::SingleTapOsu(Default::default()),
6033            ("AT", GameMode::Osu) => Self::AutoplayOsu(Default::default()),
6034            ("CN", GameMode::Osu) => Self::CinemaOsu(Default::default()),
6035            ("RX", GameMode::Osu) => Self::RelaxOsu(Default::default()),
6036            ("AP", GameMode::Osu) => Self::AutopilotOsu(Default::default()),
6037            ("SO", GameMode::Osu) => Self::SpunOutOsu(Default::default()),
6038            ("TR", GameMode::Osu) => Self::TransformOsu(Default::default()),
6039            ("WG", GameMode::Osu) => Self::WiggleOsu(Default::default()),
6040            ("SI", GameMode::Osu) => Self::SpinInOsu(Default::default()),
6041            ("GR", GameMode::Osu) => Self::GrowOsu(Default::default()),
6042            ("DF", GameMode::Osu) => Self::DeflateOsu(Default::default()),
6043            ("WU", GameMode::Osu) => Self::WindUpOsu(Default::default()),
6044            ("WD", GameMode::Osu) => Self::WindDownOsu(Default::default()),
6045            ("BR", GameMode::Osu) => Self::BarrelRollOsu(Default::default()),
6046            ("AD", GameMode::Osu) => Self::ApproachDifferentOsu(Default::default()),
6047            ("MU", GameMode::Osu) => Self::MutedOsu(Default::default()),
6048            ("NS", GameMode::Osu) => Self::NoScopeOsu(Default::default()),
6049            ("MG", GameMode::Osu) => Self::MagnetisedOsu(Default::default()),
6050            ("RP", GameMode::Osu) => Self::RepelOsu(Default::default()),
6051            ("AS", GameMode::Osu) => Self::AdaptiveSpeedOsu(Default::default()),
6052            ("FR", GameMode::Osu) => Self::FreezeFrameOsu(Default::default()),
6053            ("BU", GameMode::Osu) => Self::BubblesOsu(Default::default()),
6054            ("SY", GameMode::Osu) => Self::SynesthesiaOsu(Default::default()),
6055            ("DP", GameMode::Osu) => Self::DepthOsu(Default::default()),
6056            ("BM", GameMode::Osu) => Self::BloomOsu(Default::default()),
6057            ("TD", GameMode::Osu) => Self::TouchDeviceOsu(Default::default()),
6058            ("SV2", GameMode::Osu) => Self::ScoreV2Osu(Default::default()),
6059            ("EZ", GameMode::Taiko) => Self::EasyTaiko(Default::default()),
6060            ("NF", GameMode::Taiko) => Self::NoFailTaiko(Default::default()),
6061            ("HT", GameMode::Taiko) => Self::HalfTimeTaiko(Default::default()),
6062            ("DC", GameMode::Taiko) => Self::DaycoreTaiko(Default::default()),
6063            ("SR", GameMode::Taiko) => Self::SimplifiedRhythmTaiko(Default::default()),
6064            ("HR", GameMode::Taiko) => Self::HardRockTaiko(Default::default()),
6065            ("SD", GameMode::Taiko) => Self::SuddenDeathTaiko(Default::default()),
6066            ("PF", GameMode::Taiko) => Self::PerfectTaiko(Default::default()),
6067            ("DT", GameMode::Taiko) => Self::DoubleTimeTaiko(Default::default()),
6068            ("NC", GameMode::Taiko) => Self::NightcoreTaiko(Default::default()),
6069            ("HD", GameMode::Taiko) => Self::HiddenTaiko(Default::default()),
6070            ("FL", GameMode::Taiko) => Self::FlashlightTaiko(Default::default()),
6071            ("AC", GameMode::Taiko) => Self::AccuracyChallengeTaiko(Default::default()),
6072            ("RD", GameMode::Taiko) => Self::RandomTaiko(Default::default()),
6073            ("DA", GameMode::Taiko) => Self::DifficultyAdjustTaiko(Default::default()),
6074            ("CL", GameMode::Taiko) => Self::ClassicTaiko(Default::default()),
6075            ("SW", GameMode::Taiko) => Self::SwapTaiko(Default::default()),
6076            ("SG", GameMode::Taiko) => Self::SingleTapTaiko(Default::default()),
6077            ("CS", GameMode::Taiko) => Self::ConstantSpeedTaiko(Default::default()),
6078            ("AT", GameMode::Taiko) => Self::AutoplayTaiko(Default::default()),
6079            ("CN", GameMode::Taiko) => Self::CinemaTaiko(Default::default()),
6080            ("RX", GameMode::Taiko) => Self::RelaxTaiko(Default::default()),
6081            ("WU", GameMode::Taiko) => Self::WindUpTaiko(Default::default()),
6082            ("WD", GameMode::Taiko) => Self::WindDownTaiko(Default::default()),
6083            ("MU", GameMode::Taiko) => Self::MutedTaiko(Default::default()),
6084            ("AS", GameMode::Taiko) => Self::AdaptiveSpeedTaiko(Default::default()),
6085            ("SV2", GameMode::Taiko) => Self::ScoreV2Taiko(Default::default()),
6086            ("EZ", GameMode::Catch) => Self::EasyCatch(Default::default()),
6087            ("NF", GameMode::Catch) => Self::NoFailCatch(Default::default()),
6088            ("HT", GameMode::Catch) => Self::HalfTimeCatch(Default::default()),
6089            ("DC", GameMode::Catch) => Self::DaycoreCatch(Default::default()),
6090            ("HR", GameMode::Catch) => Self::HardRockCatch(Default::default()),
6091            ("SD", GameMode::Catch) => Self::SuddenDeathCatch(Default::default()),
6092            ("PF", GameMode::Catch) => Self::PerfectCatch(Default::default()),
6093            ("DT", GameMode::Catch) => Self::DoubleTimeCatch(Default::default()),
6094            ("NC", GameMode::Catch) => Self::NightcoreCatch(Default::default()),
6095            ("HD", GameMode::Catch) => Self::HiddenCatch(Default::default()),
6096            ("FL", GameMode::Catch) => Self::FlashlightCatch(Default::default()),
6097            ("AC", GameMode::Catch) => Self::AccuracyChallengeCatch(Default::default()),
6098            ("DA", GameMode::Catch) => Self::DifficultyAdjustCatch(Default::default()),
6099            ("CL", GameMode::Catch) => Self::ClassicCatch(Default::default()),
6100            ("MR", GameMode::Catch) => Self::MirrorCatch(Default::default()),
6101            ("AT", GameMode::Catch) => Self::AutoplayCatch(Default::default()),
6102            ("CN", GameMode::Catch) => Self::CinemaCatch(Default::default()),
6103            ("RX", GameMode::Catch) => Self::RelaxCatch(Default::default()),
6104            ("WU", GameMode::Catch) => Self::WindUpCatch(Default::default()),
6105            ("WD", GameMode::Catch) => Self::WindDownCatch(Default::default()),
6106            ("FF", GameMode::Catch) => Self::FloatingFruitsCatch(Default::default()),
6107            ("MU", GameMode::Catch) => Self::MutedCatch(Default::default()),
6108            ("NS", GameMode::Catch) => Self::NoScopeCatch(Default::default()),
6109            ("MF", GameMode::Catch) => Self::MovingFastCatch(Default::default()),
6110            ("SV2", GameMode::Catch) => Self::ScoreV2Catch(Default::default()),
6111            ("EZ", GameMode::Mania) => Self::EasyMania(Default::default()),
6112            ("NF", GameMode::Mania) => Self::NoFailMania(Default::default()),
6113            ("HT", GameMode::Mania) => Self::HalfTimeMania(Default::default()),
6114            ("DC", GameMode::Mania) => Self::DaycoreMania(Default::default()),
6115            ("NR", GameMode::Mania) => Self::NoReleaseMania(Default::default()),
6116            ("HR", GameMode::Mania) => Self::HardRockMania(Default::default()),
6117            ("SD", GameMode::Mania) => Self::SuddenDeathMania(Default::default()),
6118            ("PF", GameMode::Mania) => Self::PerfectMania(Default::default()),
6119            ("DT", GameMode::Mania) => Self::DoubleTimeMania(Default::default()),
6120            ("NC", GameMode::Mania) => Self::NightcoreMania(Default::default()),
6121            ("FI", GameMode::Mania) => Self::FadeInMania(Default::default()),
6122            ("HD", GameMode::Mania) => Self::HiddenMania(Default::default()),
6123            ("CO", GameMode::Mania) => Self::CoverMania(Default::default()),
6124            ("FL", GameMode::Mania) => Self::FlashlightMania(Default::default()),
6125            ("AC", GameMode::Mania) => Self::AccuracyChallengeMania(Default::default()),
6126            ("RD", GameMode::Mania) => Self::RandomMania(Default::default()),
6127            ("DS", GameMode::Mania) => Self::DualStagesMania(Default::default()),
6128            ("MR", GameMode::Mania) => Self::MirrorMania(Default::default()),
6129            ("DA", GameMode::Mania) => Self::DifficultyAdjustMania(Default::default()),
6130            ("CL", GameMode::Mania) => Self::ClassicMania(Default::default()),
6131            ("IN", GameMode::Mania) => Self::InvertMania(Default::default()),
6132            ("CS", GameMode::Mania) => Self::ConstantSpeedMania(Default::default()),
6133            ("HO", GameMode::Mania) => Self::HoldOffMania(Default::default()),
6134            ("1K", GameMode::Mania) => Self::OneKeyMania(Default::default()),
6135            ("2K", GameMode::Mania) => Self::TwoKeysMania(Default::default()),
6136            ("3K", GameMode::Mania) => Self::ThreeKeysMania(Default::default()),
6137            ("4K", GameMode::Mania) => Self::FourKeysMania(Default::default()),
6138            ("5K", GameMode::Mania) => Self::FiveKeysMania(Default::default()),
6139            ("6K", GameMode::Mania) => Self::SixKeysMania(Default::default()),
6140            ("7K", GameMode::Mania) => Self::SevenKeysMania(Default::default()),
6141            ("8K", GameMode::Mania) => Self::EightKeysMania(Default::default()),
6142            ("9K", GameMode::Mania) => Self::NineKeysMania(Default::default()),
6143            ("10K", GameMode::Mania) => Self::TenKeysMania(Default::default()),
6144            ("AT", GameMode::Mania) => Self::AutoplayMania(Default::default()),
6145            ("CN", GameMode::Mania) => Self::CinemaMania(Default::default()),
6146            ("WU", GameMode::Mania) => Self::WindUpMania(Default::default()),
6147            ("WD", GameMode::Mania) => Self::WindDownMania(Default::default()),
6148            ("MU", GameMode::Mania) => Self::MutedMania(Default::default()),
6149            ("AS", GameMode::Mania) => Self::AdaptiveSpeedMania(Default::default()),
6150            ("SV2", GameMode::Mania) => Self::ScoreV2Mania(Default::default()),
6151            _ => {
6152                let acronym = <Acronym as std::str::FromStr>::from_str(acronym)
6153                    .unwrap_or(UnknownMod::UNKNOWN_ACRONYM);
6154                let unknown = UnknownMod { acronym };
6155                match mode {
6156                    GameMode::Osu => GameMod::UnknownOsu(unknown),
6157                    GameMode::Taiko => GameMod::UnknownTaiko(unknown),
6158                    GameMode::Catch => GameMod::UnknownCatch(unknown),
6159                    GameMode::Mania => GameMod::UnknownMania(unknown),
6160                }
6161            }
6162        }
6163    }
6164    /// The acronym of this [`GameMod`]
6165    pub const fn acronym(&self) -> Acronym {
6166        match self {
6167            Self::EasyOsu(_) => EasyOsu::acronym(),
6168            Self::NoFailOsu(_) => NoFailOsu::acronym(),
6169            Self::HalfTimeOsu(_) => HalfTimeOsu::acronym(),
6170            Self::DaycoreOsu(_) => DaycoreOsu::acronym(),
6171            Self::HardRockOsu(_) => HardRockOsu::acronym(),
6172            Self::SuddenDeathOsu(_) => SuddenDeathOsu::acronym(),
6173            Self::PerfectOsu(_) => PerfectOsu::acronym(),
6174            Self::DoubleTimeOsu(_) => DoubleTimeOsu::acronym(),
6175            Self::NightcoreOsu(_) => NightcoreOsu::acronym(),
6176            Self::HiddenOsu(_) => HiddenOsu::acronym(),
6177            Self::TraceableOsu(_) => TraceableOsu::acronym(),
6178            Self::FlashlightOsu(_) => FlashlightOsu::acronym(),
6179            Self::BlindsOsu(_) => BlindsOsu::acronym(),
6180            Self::StrictTrackingOsu(_) => StrictTrackingOsu::acronym(),
6181            Self::AccuracyChallengeOsu(_) => AccuracyChallengeOsu::acronym(),
6182            Self::TargetPracticeOsu(_) => TargetPracticeOsu::acronym(),
6183            Self::DifficultyAdjustOsu(_) => DifficultyAdjustOsu::acronym(),
6184            Self::ClassicOsu(_) => ClassicOsu::acronym(),
6185            Self::RandomOsu(_) => RandomOsu::acronym(),
6186            Self::MirrorOsu(_) => MirrorOsu::acronym(),
6187            Self::AlternateOsu(_) => AlternateOsu::acronym(),
6188            Self::SingleTapOsu(_) => SingleTapOsu::acronym(),
6189            Self::AutoplayOsu(_) => AutoplayOsu::acronym(),
6190            Self::CinemaOsu(_) => CinemaOsu::acronym(),
6191            Self::RelaxOsu(_) => RelaxOsu::acronym(),
6192            Self::AutopilotOsu(_) => AutopilotOsu::acronym(),
6193            Self::SpunOutOsu(_) => SpunOutOsu::acronym(),
6194            Self::TransformOsu(_) => TransformOsu::acronym(),
6195            Self::WiggleOsu(_) => WiggleOsu::acronym(),
6196            Self::SpinInOsu(_) => SpinInOsu::acronym(),
6197            Self::GrowOsu(_) => GrowOsu::acronym(),
6198            Self::DeflateOsu(_) => DeflateOsu::acronym(),
6199            Self::WindUpOsu(_) => WindUpOsu::acronym(),
6200            Self::WindDownOsu(_) => WindDownOsu::acronym(),
6201            Self::BarrelRollOsu(_) => BarrelRollOsu::acronym(),
6202            Self::ApproachDifferentOsu(_) => ApproachDifferentOsu::acronym(),
6203            Self::MutedOsu(_) => MutedOsu::acronym(),
6204            Self::NoScopeOsu(_) => NoScopeOsu::acronym(),
6205            Self::MagnetisedOsu(_) => MagnetisedOsu::acronym(),
6206            Self::RepelOsu(_) => RepelOsu::acronym(),
6207            Self::AdaptiveSpeedOsu(_) => AdaptiveSpeedOsu::acronym(),
6208            Self::FreezeFrameOsu(_) => FreezeFrameOsu::acronym(),
6209            Self::BubblesOsu(_) => BubblesOsu::acronym(),
6210            Self::SynesthesiaOsu(_) => SynesthesiaOsu::acronym(),
6211            Self::DepthOsu(_) => DepthOsu::acronym(),
6212            Self::BloomOsu(_) => BloomOsu::acronym(),
6213            Self::TouchDeviceOsu(_) => TouchDeviceOsu::acronym(),
6214            Self::ScoreV2Osu(_) => ScoreV2Osu::acronym(),
6215            Self::EasyTaiko(_) => EasyTaiko::acronym(),
6216            Self::NoFailTaiko(_) => NoFailTaiko::acronym(),
6217            Self::HalfTimeTaiko(_) => HalfTimeTaiko::acronym(),
6218            Self::DaycoreTaiko(_) => DaycoreTaiko::acronym(),
6219            Self::SimplifiedRhythmTaiko(_) => SimplifiedRhythmTaiko::acronym(),
6220            Self::HardRockTaiko(_) => HardRockTaiko::acronym(),
6221            Self::SuddenDeathTaiko(_) => SuddenDeathTaiko::acronym(),
6222            Self::PerfectTaiko(_) => PerfectTaiko::acronym(),
6223            Self::DoubleTimeTaiko(_) => DoubleTimeTaiko::acronym(),
6224            Self::NightcoreTaiko(_) => NightcoreTaiko::acronym(),
6225            Self::HiddenTaiko(_) => HiddenTaiko::acronym(),
6226            Self::FlashlightTaiko(_) => FlashlightTaiko::acronym(),
6227            Self::AccuracyChallengeTaiko(_) => AccuracyChallengeTaiko::acronym(),
6228            Self::RandomTaiko(_) => RandomTaiko::acronym(),
6229            Self::DifficultyAdjustTaiko(_) => DifficultyAdjustTaiko::acronym(),
6230            Self::ClassicTaiko(_) => ClassicTaiko::acronym(),
6231            Self::SwapTaiko(_) => SwapTaiko::acronym(),
6232            Self::SingleTapTaiko(_) => SingleTapTaiko::acronym(),
6233            Self::ConstantSpeedTaiko(_) => ConstantSpeedTaiko::acronym(),
6234            Self::AutoplayTaiko(_) => AutoplayTaiko::acronym(),
6235            Self::CinemaTaiko(_) => CinemaTaiko::acronym(),
6236            Self::RelaxTaiko(_) => RelaxTaiko::acronym(),
6237            Self::WindUpTaiko(_) => WindUpTaiko::acronym(),
6238            Self::WindDownTaiko(_) => WindDownTaiko::acronym(),
6239            Self::MutedTaiko(_) => MutedTaiko::acronym(),
6240            Self::AdaptiveSpeedTaiko(_) => AdaptiveSpeedTaiko::acronym(),
6241            Self::ScoreV2Taiko(_) => ScoreV2Taiko::acronym(),
6242            Self::EasyCatch(_) => EasyCatch::acronym(),
6243            Self::NoFailCatch(_) => NoFailCatch::acronym(),
6244            Self::HalfTimeCatch(_) => HalfTimeCatch::acronym(),
6245            Self::DaycoreCatch(_) => DaycoreCatch::acronym(),
6246            Self::HardRockCatch(_) => HardRockCatch::acronym(),
6247            Self::SuddenDeathCatch(_) => SuddenDeathCatch::acronym(),
6248            Self::PerfectCatch(_) => PerfectCatch::acronym(),
6249            Self::DoubleTimeCatch(_) => DoubleTimeCatch::acronym(),
6250            Self::NightcoreCatch(_) => NightcoreCatch::acronym(),
6251            Self::HiddenCatch(_) => HiddenCatch::acronym(),
6252            Self::FlashlightCatch(_) => FlashlightCatch::acronym(),
6253            Self::AccuracyChallengeCatch(_) => AccuracyChallengeCatch::acronym(),
6254            Self::DifficultyAdjustCatch(_) => DifficultyAdjustCatch::acronym(),
6255            Self::ClassicCatch(_) => ClassicCatch::acronym(),
6256            Self::MirrorCatch(_) => MirrorCatch::acronym(),
6257            Self::AutoplayCatch(_) => AutoplayCatch::acronym(),
6258            Self::CinemaCatch(_) => CinemaCatch::acronym(),
6259            Self::RelaxCatch(_) => RelaxCatch::acronym(),
6260            Self::WindUpCatch(_) => WindUpCatch::acronym(),
6261            Self::WindDownCatch(_) => WindDownCatch::acronym(),
6262            Self::FloatingFruitsCatch(_) => FloatingFruitsCatch::acronym(),
6263            Self::MutedCatch(_) => MutedCatch::acronym(),
6264            Self::NoScopeCatch(_) => NoScopeCatch::acronym(),
6265            Self::MovingFastCatch(_) => MovingFastCatch::acronym(),
6266            Self::ScoreV2Catch(_) => ScoreV2Catch::acronym(),
6267            Self::EasyMania(_) => EasyMania::acronym(),
6268            Self::NoFailMania(_) => NoFailMania::acronym(),
6269            Self::HalfTimeMania(_) => HalfTimeMania::acronym(),
6270            Self::DaycoreMania(_) => DaycoreMania::acronym(),
6271            Self::NoReleaseMania(_) => NoReleaseMania::acronym(),
6272            Self::HardRockMania(_) => HardRockMania::acronym(),
6273            Self::SuddenDeathMania(_) => SuddenDeathMania::acronym(),
6274            Self::PerfectMania(_) => PerfectMania::acronym(),
6275            Self::DoubleTimeMania(_) => DoubleTimeMania::acronym(),
6276            Self::NightcoreMania(_) => NightcoreMania::acronym(),
6277            Self::FadeInMania(_) => FadeInMania::acronym(),
6278            Self::HiddenMania(_) => HiddenMania::acronym(),
6279            Self::CoverMania(_) => CoverMania::acronym(),
6280            Self::FlashlightMania(_) => FlashlightMania::acronym(),
6281            Self::AccuracyChallengeMania(_) => AccuracyChallengeMania::acronym(),
6282            Self::RandomMania(_) => RandomMania::acronym(),
6283            Self::DualStagesMania(_) => DualStagesMania::acronym(),
6284            Self::MirrorMania(_) => MirrorMania::acronym(),
6285            Self::DifficultyAdjustMania(_) => DifficultyAdjustMania::acronym(),
6286            Self::ClassicMania(_) => ClassicMania::acronym(),
6287            Self::InvertMania(_) => InvertMania::acronym(),
6288            Self::ConstantSpeedMania(_) => ConstantSpeedMania::acronym(),
6289            Self::HoldOffMania(_) => HoldOffMania::acronym(),
6290            Self::OneKeyMania(_) => OneKeyMania::acronym(),
6291            Self::TwoKeysMania(_) => TwoKeysMania::acronym(),
6292            Self::ThreeKeysMania(_) => ThreeKeysMania::acronym(),
6293            Self::FourKeysMania(_) => FourKeysMania::acronym(),
6294            Self::FiveKeysMania(_) => FiveKeysMania::acronym(),
6295            Self::SixKeysMania(_) => SixKeysMania::acronym(),
6296            Self::SevenKeysMania(_) => SevenKeysMania::acronym(),
6297            Self::EightKeysMania(_) => EightKeysMania::acronym(),
6298            Self::NineKeysMania(_) => NineKeysMania::acronym(),
6299            Self::TenKeysMania(_) => TenKeysMania::acronym(),
6300            Self::AutoplayMania(_) => AutoplayMania::acronym(),
6301            Self::CinemaMania(_) => CinemaMania::acronym(),
6302            Self::WindUpMania(_) => WindUpMania::acronym(),
6303            Self::WindDownMania(_) => WindDownMania::acronym(),
6304            Self::MutedMania(_) => MutedMania::acronym(),
6305            Self::AdaptiveSpeedMania(_) => AdaptiveSpeedMania::acronym(),
6306            Self::ScoreV2Mania(_) => ScoreV2Mania::acronym(),
6307            Self::UnknownOsu(m)
6308            | Self::UnknownTaiko(m)
6309            | Self::UnknownCatch(m)
6310            | Self::UnknownMania(m) => m.acronym(),
6311        }
6312    }
6313    /// List of [`Acronym`] for mods that are incompatible with this [`GameMod`]
6314    pub fn incompatible_mods(&self) -> Box<[Acronym]> {
6315        match self {
6316            Self::EasyOsu(_) => EasyOsu::incompatible_mods().collect(),
6317            Self::NoFailOsu(_) => NoFailOsu::incompatible_mods().collect(),
6318            Self::HalfTimeOsu(_) => HalfTimeOsu::incompatible_mods().collect(),
6319            Self::DaycoreOsu(_) => DaycoreOsu::incompatible_mods().collect(),
6320            Self::HardRockOsu(_) => HardRockOsu::incompatible_mods().collect(),
6321            Self::SuddenDeathOsu(_) => SuddenDeathOsu::incompatible_mods().collect(),
6322            Self::PerfectOsu(_) => PerfectOsu::incompatible_mods().collect(),
6323            Self::DoubleTimeOsu(_) => DoubleTimeOsu::incompatible_mods().collect(),
6324            Self::NightcoreOsu(_) => NightcoreOsu::incompatible_mods().collect(),
6325            Self::HiddenOsu(_) => HiddenOsu::incompatible_mods().collect(),
6326            Self::TraceableOsu(_) => TraceableOsu::incompatible_mods().collect(),
6327            Self::FlashlightOsu(_) => FlashlightOsu::incompatible_mods().collect(),
6328            Self::BlindsOsu(_) => BlindsOsu::incompatible_mods().collect(),
6329            Self::StrictTrackingOsu(_) => StrictTrackingOsu::incompatible_mods().collect(),
6330            Self::AccuracyChallengeOsu(_) => AccuracyChallengeOsu::incompatible_mods().collect(),
6331            Self::TargetPracticeOsu(_) => TargetPracticeOsu::incompatible_mods().collect(),
6332            Self::DifficultyAdjustOsu(_) => DifficultyAdjustOsu::incompatible_mods().collect(),
6333            Self::ClassicOsu(_) => ClassicOsu::incompatible_mods().collect(),
6334            Self::RandomOsu(_) => RandomOsu::incompatible_mods().collect(),
6335            Self::MirrorOsu(_) => MirrorOsu::incompatible_mods().collect(),
6336            Self::AlternateOsu(_) => AlternateOsu::incompatible_mods().collect(),
6337            Self::SingleTapOsu(_) => SingleTapOsu::incompatible_mods().collect(),
6338            Self::AutoplayOsu(_) => AutoplayOsu::incompatible_mods().collect(),
6339            Self::CinemaOsu(_) => CinemaOsu::incompatible_mods().collect(),
6340            Self::RelaxOsu(_) => RelaxOsu::incompatible_mods().collect(),
6341            Self::AutopilotOsu(_) => AutopilotOsu::incompatible_mods().collect(),
6342            Self::SpunOutOsu(_) => SpunOutOsu::incompatible_mods().collect(),
6343            Self::TransformOsu(_) => TransformOsu::incompatible_mods().collect(),
6344            Self::WiggleOsu(_) => WiggleOsu::incompatible_mods().collect(),
6345            Self::SpinInOsu(_) => SpinInOsu::incompatible_mods().collect(),
6346            Self::GrowOsu(_) => GrowOsu::incompatible_mods().collect(),
6347            Self::DeflateOsu(_) => DeflateOsu::incompatible_mods().collect(),
6348            Self::WindUpOsu(_) => WindUpOsu::incompatible_mods().collect(),
6349            Self::WindDownOsu(_) => WindDownOsu::incompatible_mods().collect(),
6350            Self::BarrelRollOsu(_) => BarrelRollOsu::incompatible_mods().collect(),
6351            Self::ApproachDifferentOsu(_) => ApproachDifferentOsu::incompatible_mods().collect(),
6352            Self::MutedOsu(_) => MutedOsu::incompatible_mods().collect(),
6353            Self::NoScopeOsu(_) => NoScopeOsu::incompatible_mods().collect(),
6354            Self::MagnetisedOsu(_) => MagnetisedOsu::incompatible_mods().collect(),
6355            Self::RepelOsu(_) => RepelOsu::incompatible_mods().collect(),
6356            Self::AdaptiveSpeedOsu(_) => AdaptiveSpeedOsu::incompatible_mods().collect(),
6357            Self::FreezeFrameOsu(_) => FreezeFrameOsu::incompatible_mods().collect(),
6358            Self::BubblesOsu(_) => BubblesOsu::incompatible_mods().collect(),
6359            Self::SynesthesiaOsu(_) => SynesthesiaOsu::incompatible_mods().collect(),
6360            Self::DepthOsu(_) => DepthOsu::incompatible_mods().collect(),
6361            Self::BloomOsu(_) => BloomOsu::incompatible_mods().collect(),
6362            Self::TouchDeviceOsu(_) => TouchDeviceOsu::incompatible_mods().collect(),
6363            Self::ScoreV2Osu(_) => ScoreV2Osu::incompatible_mods().collect(),
6364            Self::EasyTaiko(_) => EasyTaiko::incompatible_mods().collect(),
6365            Self::NoFailTaiko(_) => NoFailTaiko::incompatible_mods().collect(),
6366            Self::HalfTimeTaiko(_) => HalfTimeTaiko::incompatible_mods().collect(),
6367            Self::DaycoreTaiko(_) => DaycoreTaiko::incompatible_mods().collect(),
6368            Self::SimplifiedRhythmTaiko(_) => SimplifiedRhythmTaiko::incompatible_mods().collect(),
6369            Self::HardRockTaiko(_) => HardRockTaiko::incompatible_mods().collect(),
6370            Self::SuddenDeathTaiko(_) => SuddenDeathTaiko::incompatible_mods().collect(),
6371            Self::PerfectTaiko(_) => PerfectTaiko::incompatible_mods().collect(),
6372            Self::DoubleTimeTaiko(_) => DoubleTimeTaiko::incompatible_mods().collect(),
6373            Self::NightcoreTaiko(_) => NightcoreTaiko::incompatible_mods().collect(),
6374            Self::HiddenTaiko(_) => HiddenTaiko::incompatible_mods().collect(),
6375            Self::FlashlightTaiko(_) => FlashlightTaiko::incompatible_mods().collect(),
6376            Self::AccuracyChallengeTaiko(_) => {
6377                AccuracyChallengeTaiko::incompatible_mods().collect()
6378            }
6379            Self::RandomTaiko(_) => RandomTaiko::incompatible_mods().collect(),
6380            Self::DifficultyAdjustTaiko(_) => DifficultyAdjustTaiko::incompatible_mods().collect(),
6381            Self::ClassicTaiko(_) => ClassicTaiko::incompatible_mods().collect(),
6382            Self::SwapTaiko(_) => SwapTaiko::incompatible_mods().collect(),
6383            Self::SingleTapTaiko(_) => SingleTapTaiko::incompatible_mods().collect(),
6384            Self::ConstantSpeedTaiko(_) => ConstantSpeedTaiko::incompatible_mods().collect(),
6385            Self::AutoplayTaiko(_) => AutoplayTaiko::incompatible_mods().collect(),
6386            Self::CinemaTaiko(_) => CinemaTaiko::incompatible_mods().collect(),
6387            Self::RelaxTaiko(_) => RelaxTaiko::incompatible_mods().collect(),
6388            Self::WindUpTaiko(_) => WindUpTaiko::incompatible_mods().collect(),
6389            Self::WindDownTaiko(_) => WindDownTaiko::incompatible_mods().collect(),
6390            Self::MutedTaiko(_) => MutedTaiko::incompatible_mods().collect(),
6391            Self::AdaptiveSpeedTaiko(_) => AdaptiveSpeedTaiko::incompatible_mods().collect(),
6392            Self::ScoreV2Taiko(_) => ScoreV2Taiko::incompatible_mods().collect(),
6393            Self::EasyCatch(_) => EasyCatch::incompatible_mods().collect(),
6394            Self::NoFailCatch(_) => NoFailCatch::incompatible_mods().collect(),
6395            Self::HalfTimeCatch(_) => HalfTimeCatch::incompatible_mods().collect(),
6396            Self::DaycoreCatch(_) => DaycoreCatch::incompatible_mods().collect(),
6397            Self::HardRockCatch(_) => HardRockCatch::incompatible_mods().collect(),
6398            Self::SuddenDeathCatch(_) => SuddenDeathCatch::incompatible_mods().collect(),
6399            Self::PerfectCatch(_) => PerfectCatch::incompatible_mods().collect(),
6400            Self::DoubleTimeCatch(_) => DoubleTimeCatch::incompatible_mods().collect(),
6401            Self::NightcoreCatch(_) => NightcoreCatch::incompatible_mods().collect(),
6402            Self::HiddenCatch(_) => HiddenCatch::incompatible_mods().collect(),
6403            Self::FlashlightCatch(_) => FlashlightCatch::incompatible_mods().collect(),
6404            Self::AccuracyChallengeCatch(_) => {
6405                AccuracyChallengeCatch::incompatible_mods().collect()
6406            }
6407            Self::DifficultyAdjustCatch(_) => DifficultyAdjustCatch::incompatible_mods().collect(),
6408            Self::ClassicCatch(_) => ClassicCatch::incompatible_mods().collect(),
6409            Self::MirrorCatch(_) => MirrorCatch::incompatible_mods().collect(),
6410            Self::AutoplayCatch(_) => AutoplayCatch::incompatible_mods().collect(),
6411            Self::CinemaCatch(_) => CinemaCatch::incompatible_mods().collect(),
6412            Self::RelaxCatch(_) => RelaxCatch::incompatible_mods().collect(),
6413            Self::WindUpCatch(_) => WindUpCatch::incompatible_mods().collect(),
6414            Self::WindDownCatch(_) => WindDownCatch::incompatible_mods().collect(),
6415            Self::FloatingFruitsCatch(_) => FloatingFruitsCatch::incompatible_mods().collect(),
6416            Self::MutedCatch(_) => MutedCatch::incompatible_mods().collect(),
6417            Self::NoScopeCatch(_) => NoScopeCatch::incompatible_mods().collect(),
6418            Self::MovingFastCatch(_) => MovingFastCatch::incompatible_mods().collect(),
6419            Self::ScoreV2Catch(_) => ScoreV2Catch::incompatible_mods().collect(),
6420            Self::EasyMania(_) => EasyMania::incompatible_mods().collect(),
6421            Self::NoFailMania(_) => NoFailMania::incompatible_mods().collect(),
6422            Self::HalfTimeMania(_) => HalfTimeMania::incompatible_mods().collect(),
6423            Self::DaycoreMania(_) => DaycoreMania::incompatible_mods().collect(),
6424            Self::NoReleaseMania(_) => NoReleaseMania::incompatible_mods().collect(),
6425            Self::HardRockMania(_) => HardRockMania::incompatible_mods().collect(),
6426            Self::SuddenDeathMania(_) => SuddenDeathMania::incompatible_mods().collect(),
6427            Self::PerfectMania(_) => PerfectMania::incompatible_mods().collect(),
6428            Self::DoubleTimeMania(_) => DoubleTimeMania::incompatible_mods().collect(),
6429            Self::NightcoreMania(_) => NightcoreMania::incompatible_mods().collect(),
6430            Self::FadeInMania(_) => FadeInMania::incompatible_mods().collect(),
6431            Self::HiddenMania(_) => HiddenMania::incompatible_mods().collect(),
6432            Self::CoverMania(_) => CoverMania::incompatible_mods().collect(),
6433            Self::FlashlightMania(_) => FlashlightMania::incompatible_mods().collect(),
6434            Self::AccuracyChallengeMania(_) => {
6435                AccuracyChallengeMania::incompatible_mods().collect()
6436            }
6437            Self::RandomMania(_) => RandomMania::incompatible_mods().collect(),
6438            Self::DualStagesMania(_) => DualStagesMania::incompatible_mods().collect(),
6439            Self::MirrorMania(_) => MirrorMania::incompatible_mods().collect(),
6440            Self::DifficultyAdjustMania(_) => DifficultyAdjustMania::incompatible_mods().collect(),
6441            Self::ClassicMania(_) => ClassicMania::incompatible_mods().collect(),
6442            Self::InvertMania(_) => InvertMania::incompatible_mods().collect(),
6443            Self::ConstantSpeedMania(_) => ConstantSpeedMania::incompatible_mods().collect(),
6444            Self::HoldOffMania(_) => HoldOffMania::incompatible_mods().collect(),
6445            Self::OneKeyMania(_) => OneKeyMania::incompatible_mods().collect(),
6446            Self::TwoKeysMania(_) => TwoKeysMania::incompatible_mods().collect(),
6447            Self::ThreeKeysMania(_) => ThreeKeysMania::incompatible_mods().collect(),
6448            Self::FourKeysMania(_) => FourKeysMania::incompatible_mods().collect(),
6449            Self::FiveKeysMania(_) => FiveKeysMania::incompatible_mods().collect(),
6450            Self::SixKeysMania(_) => SixKeysMania::incompatible_mods().collect(),
6451            Self::SevenKeysMania(_) => SevenKeysMania::incompatible_mods().collect(),
6452            Self::EightKeysMania(_) => EightKeysMania::incompatible_mods().collect(),
6453            Self::NineKeysMania(_) => NineKeysMania::incompatible_mods().collect(),
6454            Self::TenKeysMania(_) => TenKeysMania::incompatible_mods().collect(),
6455            Self::AutoplayMania(_) => AutoplayMania::incompatible_mods().collect(),
6456            Self::CinemaMania(_) => CinemaMania::incompatible_mods().collect(),
6457            Self::WindUpMania(_) => WindUpMania::incompatible_mods().collect(),
6458            Self::WindDownMania(_) => WindDownMania::incompatible_mods().collect(),
6459            Self::MutedMania(_) => MutedMania::incompatible_mods().collect(),
6460            Self::AdaptiveSpeedMania(_) => AdaptiveSpeedMania::incompatible_mods().collect(),
6461            Self::ScoreV2Mania(_) => ScoreV2Mania::incompatible_mods().collect(),
6462            _ => UnknownMod::incompatible_mods().collect(),
6463        }
6464    }
6465    /// The description of this [`GameMod`]
6466    pub const fn description(&self) -> &'static str {
6467        match self {
6468            Self::EasyOsu(_) => EasyOsu::description(),
6469            Self::NoFailOsu(_) => NoFailOsu::description(),
6470            Self::HalfTimeOsu(_) => HalfTimeOsu::description(),
6471            Self::DaycoreOsu(_) => DaycoreOsu::description(),
6472            Self::HardRockOsu(_) => HardRockOsu::description(),
6473            Self::SuddenDeathOsu(_) => SuddenDeathOsu::description(),
6474            Self::PerfectOsu(_) => PerfectOsu::description(),
6475            Self::DoubleTimeOsu(_) => DoubleTimeOsu::description(),
6476            Self::NightcoreOsu(_) => NightcoreOsu::description(),
6477            Self::HiddenOsu(_) => HiddenOsu::description(),
6478            Self::TraceableOsu(_) => TraceableOsu::description(),
6479            Self::FlashlightOsu(_) => FlashlightOsu::description(),
6480            Self::BlindsOsu(_) => BlindsOsu::description(),
6481            Self::StrictTrackingOsu(_) => StrictTrackingOsu::description(),
6482            Self::AccuracyChallengeOsu(_) => AccuracyChallengeOsu::description(),
6483            Self::TargetPracticeOsu(_) => TargetPracticeOsu::description(),
6484            Self::DifficultyAdjustOsu(_) => DifficultyAdjustOsu::description(),
6485            Self::ClassicOsu(_) => ClassicOsu::description(),
6486            Self::RandomOsu(_) => RandomOsu::description(),
6487            Self::MirrorOsu(_) => MirrorOsu::description(),
6488            Self::AlternateOsu(_) => AlternateOsu::description(),
6489            Self::SingleTapOsu(_) => SingleTapOsu::description(),
6490            Self::AutoplayOsu(_) => AutoplayOsu::description(),
6491            Self::CinemaOsu(_) => CinemaOsu::description(),
6492            Self::RelaxOsu(_) => RelaxOsu::description(),
6493            Self::AutopilotOsu(_) => AutopilotOsu::description(),
6494            Self::SpunOutOsu(_) => SpunOutOsu::description(),
6495            Self::TransformOsu(_) => TransformOsu::description(),
6496            Self::WiggleOsu(_) => WiggleOsu::description(),
6497            Self::SpinInOsu(_) => SpinInOsu::description(),
6498            Self::GrowOsu(_) => GrowOsu::description(),
6499            Self::DeflateOsu(_) => DeflateOsu::description(),
6500            Self::WindUpOsu(_) => WindUpOsu::description(),
6501            Self::WindDownOsu(_) => WindDownOsu::description(),
6502            Self::BarrelRollOsu(_) => BarrelRollOsu::description(),
6503            Self::ApproachDifferentOsu(_) => ApproachDifferentOsu::description(),
6504            Self::MutedOsu(_) => MutedOsu::description(),
6505            Self::NoScopeOsu(_) => NoScopeOsu::description(),
6506            Self::MagnetisedOsu(_) => MagnetisedOsu::description(),
6507            Self::RepelOsu(_) => RepelOsu::description(),
6508            Self::AdaptiveSpeedOsu(_) => AdaptiveSpeedOsu::description(),
6509            Self::FreezeFrameOsu(_) => FreezeFrameOsu::description(),
6510            Self::BubblesOsu(_) => BubblesOsu::description(),
6511            Self::SynesthesiaOsu(_) => SynesthesiaOsu::description(),
6512            Self::DepthOsu(_) => DepthOsu::description(),
6513            Self::BloomOsu(_) => BloomOsu::description(),
6514            Self::TouchDeviceOsu(_) => TouchDeviceOsu::description(),
6515            Self::ScoreV2Osu(_) => ScoreV2Osu::description(),
6516            Self::EasyTaiko(_) => EasyTaiko::description(),
6517            Self::NoFailTaiko(_) => NoFailTaiko::description(),
6518            Self::HalfTimeTaiko(_) => HalfTimeTaiko::description(),
6519            Self::DaycoreTaiko(_) => DaycoreTaiko::description(),
6520            Self::SimplifiedRhythmTaiko(_) => SimplifiedRhythmTaiko::description(),
6521            Self::HardRockTaiko(_) => HardRockTaiko::description(),
6522            Self::SuddenDeathTaiko(_) => SuddenDeathTaiko::description(),
6523            Self::PerfectTaiko(_) => PerfectTaiko::description(),
6524            Self::DoubleTimeTaiko(_) => DoubleTimeTaiko::description(),
6525            Self::NightcoreTaiko(_) => NightcoreTaiko::description(),
6526            Self::HiddenTaiko(_) => HiddenTaiko::description(),
6527            Self::FlashlightTaiko(_) => FlashlightTaiko::description(),
6528            Self::AccuracyChallengeTaiko(_) => AccuracyChallengeTaiko::description(),
6529            Self::RandomTaiko(_) => RandomTaiko::description(),
6530            Self::DifficultyAdjustTaiko(_) => DifficultyAdjustTaiko::description(),
6531            Self::ClassicTaiko(_) => ClassicTaiko::description(),
6532            Self::SwapTaiko(_) => SwapTaiko::description(),
6533            Self::SingleTapTaiko(_) => SingleTapTaiko::description(),
6534            Self::ConstantSpeedTaiko(_) => ConstantSpeedTaiko::description(),
6535            Self::AutoplayTaiko(_) => AutoplayTaiko::description(),
6536            Self::CinemaTaiko(_) => CinemaTaiko::description(),
6537            Self::RelaxTaiko(_) => RelaxTaiko::description(),
6538            Self::WindUpTaiko(_) => WindUpTaiko::description(),
6539            Self::WindDownTaiko(_) => WindDownTaiko::description(),
6540            Self::MutedTaiko(_) => MutedTaiko::description(),
6541            Self::AdaptiveSpeedTaiko(_) => AdaptiveSpeedTaiko::description(),
6542            Self::ScoreV2Taiko(_) => ScoreV2Taiko::description(),
6543            Self::EasyCatch(_) => EasyCatch::description(),
6544            Self::NoFailCatch(_) => NoFailCatch::description(),
6545            Self::HalfTimeCatch(_) => HalfTimeCatch::description(),
6546            Self::DaycoreCatch(_) => DaycoreCatch::description(),
6547            Self::HardRockCatch(_) => HardRockCatch::description(),
6548            Self::SuddenDeathCatch(_) => SuddenDeathCatch::description(),
6549            Self::PerfectCatch(_) => PerfectCatch::description(),
6550            Self::DoubleTimeCatch(_) => DoubleTimeCatch::description(),
6551            Self::NightcoreCatch(_) => NightcoreCatch::description(),
6552            Self::HiddenCatch(_) => HiddenCatch::description(),
6553            Self::FlashlightCatch(_) => FlashlightCatch::description(),
6554            Self::AccuracyChallengeCatch(_) => AccuracyChallengeCatch::description(),
6555            Self::DifficultyAdjustCatch(_) => DifficultyAdjustCatch::description(),
6556            Self::ClassicCatch(_) => ClassicCatch::description(),
6557            Self::MirrorCatch(_) => MirrorCatch::description(),
6558            Self::AutoplayCatch(_) => AutoplayCatch::description(),
6559            Self::CinemaCatch(_) => CinemaCatch::description(),
6560            Self::RelaxCatch(_) => RelaxCatch::description(),
6561            Self::WindUpCatch(_) => WindUpCatch::description(),
6562            Self::WindDownCatch(_) => WindDownCatch::description(),
6563            Self::FloatingFruitsCatch(_) => FloatingFruitsCatch::description(),
6564            Self::MutedCatch(_) => MutedCatch::description(),
6565            Self::NoScopeCatch(_) => NoScopeCatch::description(),
6566            Self::MovingFastCatch(_) => MovingFastCatch::description(),
6567            Self::ScoreV2Catch(_) => ScoreV2Catch::description(),
6568            Self::EasyMania(_) => EasyMania::description(),
6569            Self::NoFailMania(_) => NoFailMania::description(),
6570            Self::HalfTimeMania(_) => HalfTimeMania::description(),
6571            Self::DaycoreMania(_) => DaycoreMania::description(),
6572            Self::NoReleaseMania(_) => NoReleaseMania::description(),
6573            Self::HardRockMania(_) => HardRockMania::description(),
6574            Self::SuddenDeathMania(_) => SuddenDeathMania::description(),
6575            Self::PerfectMania(_) => PerfectMania::description(),
6576            Self::DoubleTimeMania(_) => DoubleTimeMania::description(),
6577            Self::NightcoreMania(_) => NightcoreMania::description(),
6578            Self::FadeInMania(_) => FadeInMania::description(),
6579            Self::HiddenMania(_) => HiddenMania::description(),
6580            Self::CoverMania(_) => CoverMania::description(),
6581            Self::FlashlightMania(_) => FlashlightMania::description(),
6582            Self::AccuracyChallengeMania(_) => AccuracyChallengeMania::description(),
6583            Self::RandomMania(_) => RandomMania::description(),
6584            Self::DualStagesMania(_) => DualStagesMania::description(),
6585            Self::MirrorMania(_) => MirrorMania::description(),
6586            Self::DifficultyAdjustMania(_) => DifficultyAdjustMania::description(),
6587            Self::ClassicMania(_) => ClassicMania::description(),
6588            Self::InvertMania(_) => InvertMania::description(),
6589            Self::ConstantSpeedMania(_) => ConstantSpeedMania::description(),
6590            Self::HoldOffMania(_) => HoldOffMania::description(),
6591            Self::OneKeyMania(_) => OneKeyMania::description(),
6592            Self::TwoKeysMania(_) => TwoKeysMania::description(),
6593            Self::ThreeKeysMania(_) => ThreeKeysMania::description(),
6594            Self::FourKeysMania(_) => FourKeysMania::description(),
6595            Self::FiveKeysMania(_) => FiveKeysMania::description(),
6596            Self::SixKeysMania(_) => SixKeysMania::description(),
6597            Self::SevenKeysMania(_) => SevenKeysMania::description(),
6598            Self::EightKeysMania(_) => EightKeysMania::description(),
6599            Self::NineKeysMania(_) => NineKeysMania::description(),
6600            Self::TenKeysMania(_) => TenKeysMania::description(),
6601            Self::AutoplayMania(_) => AutoplayMania::description(),
6602            Self::CinemaMania(_) => CinemaMania::description(),
6603            Self::WindUpMania(_) => WindUpMania::description(),
6604            Self::WindDownMania(_) => WindDownMania::description(),
6605            Self::MutedMania(_) => MutedMania::description(),
6606            Self::AdaptiveSpeedMania(_) => AdaptiveSpeedMania::description(),
6607            Self::ScoreV2Mania(_) => ScoreV2Mania::description(),
6608            _ => UnknownMod::description(),
6609        }
6610    }
6611    /// The [`GameModKind`] of this [`GameMod`]
6612    pub const fn kind(&self) -> GameModKind {
6613        match self {
6614            Self::EasyOsu(_) => EasyOsu::kind(),
6615            Self::NoFailOsu(_) => NoFailOsu::kind(),
6616            Self::HalfTimeOsu(_) => HalfTimeOsu::kind(),
6617            Self::DaycoreOsu(_) => DaycoreOsu::kind(),
6618            Self::HardRockOsu(_) => HardRockOsu::kind(),
6619            Self::SuddenDeathOsu(_) => SuddenDeathOsu::kind(),
6620            Self::PerfectOsu(_) => PerfectOsu::kind(),
6621            Self::DoubleTimeOsu(_) => DoubleTimeOsu::kind(),
6622            Self::NightcoreOsu(_) => NightcoreOsu::kind(),
6623            Self::HiddenOsu(_) => HiddenOsu::kind(),
6624            Self::TraceableOsu(_) => TraceableOsu::kind(),
6625            Self::FlashlightOsu(_) => FlashlightOsu::kind(),
6626            Self::BlindsOsu(_) => BlindsOsu::kind(),
6627            Self::StrictTrackingOsu(_) => StrictTrackingOsu::kind(),
6628            Self::AccuracyChallengeOsu(_) => AccuracyChallengeOsu::kind(),
6629            Self::TargetPracticeOsu(_) => TargetPracticeOsu::kind(),
6630            Self::DifficultyAdjustOsu(_) => DifficultyAdjustOsu::kind(),
6631            Self::ClassicOsu(_) => ClassicOsu::kind(),
6632            Self::RandomOsu(_) => RandomOsu::kind(),
6633            Self::MirrorOsu(_) => MirrorOsu::kind(),
6634            Self::AlternateOsu(_) => AlternateOsu::kind(),
6635            Self::SingleTapOsu(_) => SingleTapOsu::kind(),
6636            Self::AutoplayOsu(_) => AutoplayOsu::kind(),
6637            Self::CinemaOsu(_) => CinemaOsu::kind(),
6638            Self::RelaxOsu(_) => RelaxOsu::kind(),
6639            Self::AutopilotOsu(_) => AutopilotOsu::kind(),
6640            Self::SpunOutOsu(_) => SpunOutOsu::kind(),
6641            Self::TransformOsu(_) => TransformOsu::kind(),
6642            Self::WiggleOsu(_) => WiggleOsu::kind(),
6643            Self::SpinInOsu(_) => SpinInOsu::kind(),
6644            Self::GrowOsu(_) => GrowOsu::kind(),
6645            Self::DeflateOsu(_) => DeflateOsu::kind(),
6646            Self::WindUpOsu(_) => WindUpOsu::kind(),
6647            Self::WindDownOsu(_) => WindDownOsu::kind(),
6648            Self::BarrelRollOsu(_) => BarrelRollOsu::kind(),
6649            Self::ApproachDifferentOsu(_) => ApproachDifferentOsu::kind(),
6650            Self::MutedOsu(_) => MutedOsu::kind(),
6651            Self::NoScopeOsu(_) => NoScopeOsu::kind(),
6652            Self::MagnetisedOsu(_) => MagnetisedOsu::kind(),
6653            Self::RepelOsu(_) => RepelOsu::kind(),
6654            Self::AdaptiveSpeedOsu(_) => AdaptiveSpeedOsu::kind(),
6655            Self::FreezeFrameOsu(_) => FreezeFrameOsu::kind(),
6656            Self::BubblesOsu(_) => BubblesOsu::kind(),
6657            Self::SynesthesiaOsu(_) => SynesthesiaOsu::kind(),
6658            Self::DepthOsu(_) => DepthOsu::kind(),
6659            Self::BloomOsu(_) => BloomOsu::kind(),
6660            Self::TouchDeviceOsu(_) => TouchDeviceOsu::kind(),
6661            Self::ScoreV2Osu(_) => ScoreV2Osu::kind(),
6662            Self::EasyTaiko(_) => EasyTaiko::kind(),
6663            Self::NoFailTaiko(_) => NoFailTaiko::kind(),
6664            Self::HalfTimeTaiko(_) => HalfTimeTaiko::kind(),
6665            Self::DaycoreTaiko(_) => DaycoreTaiko::kind(),
6666            Self::SimplifiedRhythmTaiko(_) => SimplifiedRhythmTaiko::kind(),
6667            Self::HardRockTaiko(_) => HardRockTaiko::kind(),
6668            Self::SuddenDeathTaiko(_) => SuddenDeathTaiko::kind(),
6669            Self::PerfectTaiko(_) => PerfectTaiko::kind(),
6670            Self::DoubleTimeTaiko(_) => DoubleTimeTaiko::kind(),
6671            Self::NightcoreTaiko(_) => NightcoreTaiko::kind(),
6672            Self::HiddenTaiko(_) => HiddenTaiko::kind(),
6673            Self::FlashlightTaiko(_) => FlashlightTaiko::kind(),
6674            Self::AccuracyChallengeTaiko(_) => AccuracyChallengeTaiko::kind(),
6675            Self::RandomTaiko(_) => RandomTaiko::kind(),
6676            Self::DifficultyAdjustTaiko(_) => DifficultyAdjustTaiko::kind(),
6677            Self::ClassicTaiko(_) => ClassicTaiko::kind(),
6678            Self::SwapTaiko(_) => SwapTaiko::kind(),
6679            Self::SingleTapTaiko(_) => SingleTapTaiko::kind(),
6680            Self::ConstantSpeedTaiko(_) => ConstantSpeedTaiko::kind(),
6681            Self::AutoplayTaiko(_) => AutoplayTaiko::kind(),
6682            Self::CinemaTaiko(_) => CinemaTaiko::kind(),
6683            Self::RelaxTaiko(_) => RelaxTaiko::kind(),
6684            Self::WindUpTaiko(_) => WindUpTaiko::kind(),
6685            Self::WindDownTaiko(_) => WindDownTaiko::kind(),
6686            Self::MutedTaiko(_) => MutedTaiko::kind(),
6687            Self::AdaptiveSpeedTaiko(_) => AdaptiveSpeedTaiko::kind(),
6688            Self::ScoreV2Taiko(_) => ScoreV2Taiko::kind(),
6689            Self::EasyCatch(_) => EasyCatch::kind(),
6690            Self::NoFailCatch(_) => NoFailCatch::kind(),
6691            Self::HalfTimeCatch(_) => HalfTimeCatch::kind(),
6692            Self::DaycoreCatch(_) => DaycoreCatch::kind(),
6693            Self::HardRockCatch(_) => HardRockCatch::kind(),
6694            Self::SuddenDeathCatch(_) => SuddenDeathCatch::kind(),
6695            Self::PerfectCatch(_) => PerfectCatch::kind(),
6696            Self::DoubleTimeCatch(_) => DoubleTimeCatch::kind(),
6697            Self::NightcoreCatch(_) => NightcoreCatch::kind(),
6698            Self::HiddenCatch(_) => HiddenCatch::kind(),
6699            Self::FlashlightCatch(_) => FlashlightCatch::kind(),
6700            Self::AccuracyChallengeCatch(_) => AccuracyChallengeCatch::kind(),
6701            Self::DifficultyAdjustCatch(_) => DifficultyAdjustCatch::kind(),
6702            Self::ClassicCatch(_) => ClassicCatch::kind(),
6703            Self::MirrorCatch(_) => MirrorCatch::kind(),
6704            Self::AutoplayCatch(_) => AutoplayCatch::kind(),
6705            Self::CinemaCatch(_) => CinemaCatch::kind(),
6706            Self::RelaxCatch(_) => RelaxCatch::kind(),
6707            Self::WindUpCatch(_) => WindUpCatch::kind(),
6708            Self::WindDownCatch(_) => WindDownCatch::kind(),
6709            Self::FloatingFruitsCatch(_) => FloatingFruitsCatch::kind(),
6710            Self::MutedCatch(_) => MutedCatch::kind(),
6711            Self::NoScopeCatch(_) => NoScopeCatch::kind(),
6712            Self::MovingFastCatch(_) => MovingFastCatch::kind(),
6713            Self::ScoreV2Catch(_) => ScoreV2Catch::kind(),
6714            Self::EasyMania(_) => EasyMania::kind(),
6715            Self::NoFailMania(_) => NoFailMania::kind(),
6716            Self::HalfTimeMania(_) => HalfTimeMania::kind(),
6717            Self::DaycoreMania(_) => DaycoreMania::kind(),
6718            Self::NoReleaseMania(_) => NoReleaseMania::kind(),
6719            Self::HardRockMania(_) => HardRockMania::kind(),
6720            Self::SuddenDeathMania(_) => SuddenDeathMania::kind(),
6721            Self::PerfectMania(_) => PerfectMania::kind(),
6722            Self::DoubleTimeMania(_) => DoubleTimeMania::kind(),
6723            Self::NightcoreMania(_) => NightcoreMania::kind(),
6724            Self::FadeInMania(_) => FadeInMania::kind(),
6725            Self::HiddenMania(_) => HiddenMania::kind(),
6726            Self::CoverMania(_) => CoverMania::kind(),
6727            Self::FlashlightMania(_) => FlashlightMania::kind(),
6728            Self::AccuracyChallengeMania(_) => AccuracyChallengeMania::kind(),
6729            Self::RandomMania(_) => RandomMania::kind(),
6730            Self::DualStagesMania(_) => DualStagesMania::kind(),
6731            Self::MirrorMania(_) => MirrorMania::kind(),
6732            Self::DifficultyAdjustMania(_) => DifficultyAdjustMania::kind(),
6733            Self::ClassicMania(_) => ClassicMania::kind(),
6734            Self::InvertMania(_) => InvertMania::kind(),
6735            Self::ConstantSpeedMania(_) => ConstantSpeedMania::kind(),
6736            Self::HoldOffMania(_) => HoldOffMania::kind(),
6737            Self::OneKeyMania(_) => OneKeyMania::kind(),
6738            Self::TwoKeysMania(_) => TwoKeysMania::kind(),
6739            Self::ThreeKeysMania(_) => ThreeKeysMania::kind(),
6740            Self::FourKeysMania(_) => FourKeysMania::kind(),
6741            Self::FiveKeysMania(_) => FiveKeysMania::kind(),
6742            Self::SixKeysMania(_) => SixKeysMania::kind(),
6743            Self::SevenKeysMania(_) => SevenKeysMania::kind(),
6744            Self::EightKeysMania(_) => EightKeysMania::kind(),
6745            Self::NineKeysMania(_) => NineKeysMania::kind(),
6746            Self::TenKeysMania(_) => TenKeysMania::kind(),
6747            Self::AutoplayMania(_) => AutoplayMania::kind(),
6748            Self::CinemaMania(_) => CinemaMania::kind(),
6749            Self::WindUpMania(_) => WindUpMania::kind(),
6750            Self::WindDownMania(_) => WindDownMania::kind(),
6751            Self::MutedMania(_) => MutedMania::kind(),
6752            Self::AdaptiveSpeedMania(_) => AdaptiveSpeedMania::kind(),
6753            Self::ScoreV2Mania(_) => ScoreV2Mania::kind(),
6754            _ => UnknownMod::kind(),
6755        }
6756    }
6757    /// Optional bit value of this [`GameMod`]
6758    ///
6759    /// See <https://github.com/ppy/osu-api/wiki#mods>
6760    pub const fn bits(&self) -> Option<u32> {
6761        match self {
6762            Self::EasyOsu(_) => Some(EasyOsu::bits()),
6763            Self::NoFailOsu(_) => Some(NoFailOsu::bits()),
6764            Self::HalfTimeOsu(_) => Some(HalfTimeOsu::bits()),
6765            Self::HardRockOsu(_) => Some(HardRockOsu::bits()),
6766            Self::SuddenDeathOsu(_) => Some(SuddenDeathOsu::bits()),
6767            Self::PerfectOsu(_) => Some(PerfectOsu::bits()),
6768            Self::DoubleTimeOsu(_) => Some(DoubleTimeOsu::bits()),
6769            Self::NightcoreOsu(_) => Some(NightcoreOsu::bits()),
6770            Self::HiddenOsu(_) => Some(HiddenOsu::bits()),
6771            Self::FlashlightOsu(_) => Some(FlashlightOsu::bits()),
6772            Self::TargetPracticeOsu(_) => Some(TargetPracticeOsu::bits()),
6773            Self::RandomOsu(_) => Some(RandomOsu::bits()),
6774            Self::MirrorOsu(_) => Some(MirrorOsu::bits()),
6775            Self::AutoplayOsu(_) => Some(AutoplayOsu::bits()),
6776            Self::CinemaOsu(_) => Some(CinemaOsu::bits()),
6777            Self::RelaxOsu(_) => Some(RelaxOsu::bits()),
6778            Self::AutopilotOsu(_) => Some(AutopilotOsu::bits()),
6779            Self::SpunOutOsu(_) => Some(SpunOutOsu::bits()),
6780            Self::TouchDeviceOsu(_) => Some(TouchDeviceOsu::bits()),
6781            Self::ScoreV2Osu(_) => Some(ScoreV2Osu::bits()),
6782            Self::EasyTaiko(_) => Some(EasyTaiko::bits()),
6783            Self::NoFailTaiko(_) => Some(NoFailTaiko::bits()),
6784            Self::HalfTimeTaiko(_) => Some(HalfTimeTaiko::bits()),
6785            Self::HardRockTaiko(_) => Some(HardRockTaiko::bits()),
6786            Self::SuddenDeathTaiko(_) => Some(SuddenDeathTaiko::bits()),
6787            Self::PerfectTaiko(_) => Some(PerfectTaiko::bits()),
6788            Self::DoubleTimeTaiko(_) => Some(DoubleTimeTaiko::bits()),
6789            Self::NightcoreTaiko(_) => Some(NightcoreTaiko::bits()),
6790            Self::HiddenTaiko(_) => Some(HiddenTaiko::bits()),
6791            Self::FlashlightTaiko(_) => Some(FlashlightTaiko::bits()),
6792            Self::RandomTaiko(_) => Some(RandomTaiko::bits()),
6793            Self::AutoplayTaiko(_) => Some(AutoplayTaiko::bits()),
6794            Self::CinemaTaiko(_) => Some(CinemaTaiko::bits()),
6795            Self::RelaxTaiko(_) => Some(RelaxTaiko::bits()),
6796            Self::ScoreV2Taiko(_) => Some(ScoreV2Taiko::bits()),
6797            Self::EasyCatch(_) => Some(EasyCatch::bits()),
6798            Self::NoFailCatch(_) => Some(NoFailCatch::bits()),
6799            Self::HalfTimeCatch(_) => Some(HalfTimeCatch::bits()),
6800            Self::HardRockCatch(_) => Some(HardRockCatch::bits()),
6801            Self::SuddenDeathCatch(_) => Some(SuddenDeathCatch::bits()),
6802            Self::PerfectCatch(_) => Some(PerfectCatch::bits()),
6803            Self::DoubleTimeCatch(_) => Some(DoubleTimeCatch::bits()),
6804            Self::NightcoreCatch(_) => Some(NightcoreCatch::bits()),
6805            Self::HiddenCatch(_) => Some(HiddenCatch::bits()),
6806            Self::FlashlightCatch(_) => Some(FlashlightCatch::bits()),
6807            Self::MirrorCatch(_) => Some(MirrorCatch::bits()),
6808            Self::AutoplayCatch(_) => Some(AutoplayCatch::bits()),
6809            Self::CinemaCatch(_) => Some(CinemaCatch::bits()),
6810            Self::RelaxCatch(_) => Some(RelaxCatch::bits()),
6811            Self::ScoreV2Catch(_) => Some(ScoreV2Catch::bits()),
6812            Self::EasyMania(_) => Some(EasyMania::bits()),
6813            Self::NoFailMania(_) => Some(NoFailMania::bits()),
6814            Self::HalfTimeMania(_) => Some(HalfTimeMania::bits()),
6815            Self::HardRockMania(_) => Some(HardRockMania::bits()),
6816            Self::SuddenDeathMania(_) => Some(SuddenDeathMania::bits()),
6817            Self::PerfectMania(_) => Some(PerfectMania::bits()),
6818            Self::DoubleTimeMania(_) => Some(DoubleTimeMania::bits()),
6819            Self::NightcoreMania(_) => Some(NightcoreMania::bits()),
6820            Self::FadeInMania(_) => Some(FadeInMania::bits()),
6821            Self::HiddenMania(_) => Some(HiddenMania::bits()),
6822            Self::FlashlightMania(_) => Some(FlashlightMania::bits()),
6823            Self::RandomMania(_) => Some(RandomMania::bits()),
6824            Self::DualStagesMania(_) => Some(DualStagesMania::bits()),
6825            Self::MirrorMania(_) => Some(MirrorMania::bits()),
6826            Self::OneKeyMania(_) => Some(OneKeyMania::bits()),
6827            Self::TwoKeysMania(_) => Some(TwoKeysMania::bits()),
6828            Self::ThreeKeysMania(_) => Some(ThreeKeysMania::bits()),
6829            Self::FourKeysMania(_) => Some(FourKeysMania::bits()),
6830            Self::FiveKeysMania(_) => Some(FiveKeysMania::bits()),
6831            Self::SixKeysMania(_) => Some(SixKeysMania::bits()),
6832            Self::SevenKeysMania(_) => Some(SevenKeysMania::bits()),
6833            Self::EightKeysMania(_) => Some(EightKeysMania::bits()),
6834            Self::NineKeysMania(_) => Some(NineKeysMania::bits()),
6835            Self::AutoplayMania(_) => Some(AutoplayMania::bits()),
6836            Self::CinemaMania(_) => Some(CinemaMania::bits()),
6837            Self::ScoreV2Mania(_) => Some(ScoreV2Mania::bits()),
6838            _ => None,
6839        }
6840    }
6841    /// The [`GameMode`] of a [`GameMod`]
6842    pub const fn mode(&self) -> GameMode {
6843        match self {
6844            Self::EasyOsu(_)
6845            | Self::NoFailOsu(_)
6846            | Self::HalfTimeOsu(_)
6847            | Self::DaycoreOsu(_)
6848            | Self::HardRockOsu(_)
6849            | Self::SuddenDeathOsu(_)
6850            | Self::PerfectOsu(_)
6851            | Self::DoubleTimeOsu(_)
6852            | Self::NightcoreOsu(_)
6853            | Self::HiddenOsu(_)
6854            | Self::TraceableOsu(_)
6855            | Self::FlashlightOsu(_)
6856            | Self::BlindsOsu(_)
6857            | Self::StrictTrackingOsu(_)
6858            | Self::AccuracyChallengeOsu(_)
6859            | Self::TargetPracticeOsu(_)
6860            | Self::DifficultyAdjustOsu(_)
6861            | Self::ClassicOsu(_)
6862            | Self::RandomOsu(_)
6863            | Self::MirrorOsu(_)
6864            | Self::AlternateOsu(_)
6865            | Self::SingleTapOsu(_)
6866            | Self::AutoplayOsu(_)
6867            | Self::CinemaOsu(_)
6868            | Self::RelaxOsu(_)
6869            | Self::AutopilotOsu(_)
6870            | Self::SpunOutOsu(_)
6871            | Self::TransformOsu(_)
6872            | Self::WiggleOsu(_)
6873            | Self::SpinInOsu(_)
6874            | Self::GrowOsu(_)
6875            | Self::DeflateOsu(_)
6876            | Self::WindUpOsu(_)
6877            | Self::WindDownOsu(_)
6878            | Self::BarrelRollOsu(_)
6879            | Self::ApproachDifferentOsu(_)
6880            | Self::MutedOsu(_)
6881            | Self::NoScopeOsu(_)
6882            | Self::MagnetisedOsu(_)
6883            | Self::RepelOsu(_)
6884            | Self::AdaptiveSpeedOsu(_)
6885            | Self::FreezeFrameOsu(_)
6886            | Self::BubblesOsu(_)
6887            | Self::SynesthesiaOsu(_)
6888            | Self::DepthOsu(_)
6889            | Self::BloomOsu(_)
6890            | Self::TouchDeviceOsu(_)
6891            | Self::ScoreV2Osu(_)
6892            | Self::UnknownOsu(_) => GameMode::Osu,
6893            Self::EasyTaiko(_)
6894            | Self::NoFailTaiko(_)
6895            | Self::HalfTimeTaiko(_)
6896            | Self::DaycoreTaiko(_)
6897            | Self::SimplifiedRhythmTaiko(_)
6898            | Self::HardRockTaiko(_)
6899            | Self::SuddenDeathTaiko(_)
6900            | Self::PerfectTaiko(_)
6901            | Self::DoubleTimeTaiko(_)
6902            | Self::NightcoreTaiko(_)
6903            | Self::HiddenTaiko(_)
6904            | Self::FlashlightTaiko(_)
6905            | Self::AccuracyChallengeTaiko(_)
6906            | Self::RandomTaiko(_)
6907            | Self::DifficultyAdjustTaiko(_)
6908            | Self::ClassicTaiko(_)
6909            | Self::SwapTaiko(_)
6910            | Self::SingleTapTaiko(_)
6911            | Self::ConstantSpeedTaiko(_)
6912            | Self::AutoplayTaiko(_)
6913            | Self::CinemaTaiko(_)
6914            | Self::RelaxTaiko(_)
6915            | Self::WindUpTaiko(_)
6916            | Self::WindDownTaiko(_)
6917            | Self::MutedTaiko(_)
6918            | Self::AdaptiveSpeedTaiko(_)
6919            | Self::ScoreV2Taiko(_)
6920            | Self::UnknownTaiko(_) => GameMode::Taiko,
6921            Self::EasyCatch(_)
6922            | Self::NoFailCatch(_)
6923            | Self::HalfTimeCatch(_)
6924            | Self::DaycoreCatch(_)
6925            | Self::HardRockCatch(_)
6926            | Self::SuddenDeathCatch(_)
6927            | Self::PerfectCatch(_)
6928            | Self::DoubleTimeCatch(_)
6929            | Self::NightcoreCatch(_)
6930            | Self::HiddenCatch(_)
6931            | Self::FlashlightCatch(_)
6932            | Self::AccuracyChallengeCatch(_)
6933            | Self::DifficultyAdjustCatch(_)
6934            | Self::ClassicCatch(_)
6935            | Self::MirrorCatch(_)
6936            | Self::AutoplayCatch(_)
6937            | Self::CinemaCatch(_)
6938            | Self::RelaxCatch(_)
6939            | Self::WindUpCatch(_)
6940            | Self::WindDownCatch(_)
6941            | Self::FloatingFruitsCatch(_)
6942            | Self::MutedCatch(_)
6943            | Self::NoScopeCatch(_)
6944            | Self::MovingFastCatch(_)
6945            | Self::ScoreV2Catch(_)
6946            | Self::UnknownCatch(_) => GameMode::Catch,
6947            Self::EasyMania(_)
6948            | Self::NoFailMania(_)
6949            | Self::HalfTimeMania(_)
6950            | Self::DaycoreMania(_)
6951            | Self::NoReleaseMania(_)
6952            | Self::HardRockMania(_)
6953            | Self::SuddenDeathMania(_)
6954            | Self::PerfectMania(_)
6955            | Self::DoubleTimeMania(_)
6956            | Self::NightcoreMania(_)
6957            | Self::FadeInMania(_)
6958            | Self::HiddenMania(_)
6959            | Self::CoverMania(_)
6960            | Self::FlashlightMania(_)
6961            | Self::AccuracyChallengeMania(_)
6962            | Self::RandomMania(_)
6963            | Self::DualStagesMania(_)
6964            | Self::MirrorMania(_)
6965            | Self::DifficultyAdjustMania(_)
6966            | Self::ClassicMania(_)
6967            | Self::InvertMania(_)
6968            | Self::ConstantSpeedMania(_)
6969            | Self::HoldOffMania(_)
6970            | Self::OneKeyMania(_)
6971            | Self::TwoKeysMania(_)
6972            | Self::ThreeKeysMania(_)
6973            | Self::FourKeysMania(_)
6974            | Self::FiveKeysMania(_)
6975            | Self::SixKeysMania(_)
6976            | Self::SevenKeysMania(_)
6977            | Self::EightKeysMania(_)
6978            | Self::NineKeysMania(_)
6979            | Self::TenKeysMania(_)
6980            | Self::AutoplayMania(_)
6981            | Self::CinemaMania(_)
6982            | Self::WindUpMania(_)
6983            | Self::WindDownMania(_)
6984            | Self::MutedMania(_)
6985            | Self::AdaptiveSpeedMania(_)
6986            | Self::ScoreV2Mania(_)
6987            | Self::UnknownMania(_) => GameMode::Mania,
6988        }
6989    }
6990    /// The kind of a [`GameMod`] when ignoring the mode
6991    pub const fn intermode(&self) -> GameModIntermode {
6992        match self {
6993            Self::EasyOsu(_) => GameModIntermode::Easy,
6994            Self::NoFailOsu(_) => GameModIntermode::NoFail,
6995            Self::HalfTimeOsu(_) => GameModIntermode::HalfTime,
6996            Self::DaycoreOsu(_) => GameModIntermode::Daycore,
6997            Self::HardRockOsu(_) => GameModIntermode::HardRock,
6998            Self::SuddenDeathOsu(_) => GameModIntermode::SuddenDeath,
6999            Self::PerfectOsu(_) => GameModIntermode::Perfect,
7000            Self::DoubleTimeOsu(_) => GameModIntermode::DoubleTime,
7001            Self::NightcoreOsu(_) => GameModIntermode::Nightcore,
7002            Self::HiddenOsu(_) => GameModIntermode::Hidden,
7003            Self::TraceableOsu(_) => GameModIntermode::Traceable,
7004            Self::FlashlightOsu(_) => GameModIntermode::Flashlight,
7005            Self::BlindsOsu(_) => GameModIntermode::Blinds,
7006            Self::StrictTrackingOsu(_) => GameModIntermode::StrictTracking,
7007            Self::AccuracyChallengeOsu(_) => GameModIntermode::AccuracyChallenge,
7008            Self::TargetPracticeOsu(_) => GameModIntermode::TargetPractice,
7009            Self::DifficultyAdjustOsu(_) => GameModIntermode::DifficultyAdjust,
7010            Self::ClassicOsu(_) => GameModIntermode::Classic,
7011            Self::RandomOsu(_) => GameModIntermode::Random,
7012            Self::MirrorOsu(_) => GameModIntermode::Mirror,
7013            Self::AlternateOsu(_) => GameModIntermode::Alternate,
7014            Self::SingleTapOsu(_) => GameModIntermode::SingleTap,
7015            Self::AutoplayOsu(_) => GameModIntermode::Autoplay,
7016            Self::CinemaOsu(_) => GameModIntermode::Cinema,
7017            Self::RelaxOsu(_) => GameModIntermode::Relax,
7018            Self::AutopilotOsu(_) => GameModIntermode::Autopilot,
7019            Self::SpunOutOsu(_) => GameModIntermode::SpunOut,
7020            Self::TransformOsu(_) => GameModIntermode::Transform,
7021            Self::WiggleOsu(_) => GameModIntermode::Wiggle,
7022            Self::SpinInOsu(_) => GameModIntermode::SpinIn,
7023            Self::GrowOsu(_) => GameModIntermode::Grow,
7024            Self::DeflateOsu(_) => GameModIntermode::Deflate,
7025            Self::WindUpOsu(_) => GameModIntermode::WindUp,
7026            Self::WindDownOsu(_) => GameModIntermode::WindDown,
7027            Self::BarrelRollOsu(_) => GameModIntermode::BarrelRoll,
7028            Self::ApproachDifferentOsu(_) => GameModIntermode::ApproachDifferent,
7029            Self::MutedOsu(_) => GameModIntermode::Muted,
7030            Self::NoScopeOsu(_) => GameModIntermode::NoScope,
7031            Self::MagnetisedOsu(_) => GameModIntermode::Magnetised,
7032            Self::RepelOsu(_) => GameModIntermode::Repel,
7033            Self::AdaptiveSpeedOsu(_) => GameModIntermode::AdaptiveSpeed,
7034            Self::FreezeFrameOsu(_) => GameModIntermode::FreezeFrame,
7035            Self::BubblesOsu(_) => GameModIntermode::Bubbles,
7036            Self::SynesthesiaOsu(_) => GameModIntermode::Synesthesia,
7037            Self::DepthOsu(_) => GameModIntermode::Depth,
7038            Self::BloomOsu(_) => GameModIntermode::Bloom,
7039            Self::TouchDeviceOsu(_) => GameModIntermode::TouchDevice,
7040            Self::ScoreV2Osu(_) => GameModIntermode::ScoreV2,
7041            Self::EasyTaiko(_) => GameModIntermode::Easy,
7042            Self::NoFailTaiko(_) => GameModIntermode::NoFail,
7043            Self::HalfTimeTaiko(_) => GameModIntermode::HalfTime,
7044            Self::DaycoreTaiko(_) => GameModIntermode::Daycore,
7045            Self::SimplifiedRhythmTaiko(_) => GameModIntermode::SimplifiedRhythm,
7046            Self::HardRockTaiko(_) => GameModIntermode::HardRock,
7047            Self::SuddenDeathTaiko(_) => GameModIntermode::SuddenDeath,
7048            Self::PerfectTaiko(_) => GameModIntermode::Perfect,
7049            Self::DoubleTimeTaiko(_) => GameModIntermode::DoubleTime,
7050            Self::NightcoreTaiko(_) => GameModIntermode::Nightcore,
7051            Self::HiddenTaiko(_) => GameModIntermode::Hidden,
7052            Self::FlashlightTaiko(_) => GameModIntermode::Flashlight,
7053            Self::AccuracyChallengeTaiko(_) => GameModIntermode::AccuracyChallenge,
7054            Self::RandomTaiko(_) => GameModIntermode::Random,
7055            Self::DifficultyAdjustTaiko(_) => GameModIntermode::DifficultyAdjust,
7056            Self::ClassicTaiko(_) => GameModIntermode::Classic,
7057            Self::SwapTaiko(_) => GameModIntermode::Swap,
7058            Self::SingleTapTaiko(_) => GameModIntermode::SingleTap,
7059            Self::ConstantSpeedTaiko(_) => GameModIntermode::ConstantSpeed,
7060            Self::AutoplayTaiko(_) => GameModIntermode::Autoplay,
7061            Self::CinemaTaiko(_) => GameModIntermode::Cinema,
7062            Self::RelaxTaiko(_) => GameModIntermode::Relax,
7063            Self::WindUpTaiko(_) => GameModIntermode::WindUp,
7064            Self::WindDownTaiko(_) => GameModIntermode::WindDown,
7065            Self::MutedTaiko(_) => GameModIntermode::Muted,
7066            Self::AdaptiveSpeedTaiko(_) => GameModIntermode::AdaptiveSpeed,
7067            Self::ScoreV2Taiko(_) => GameModIntermode::ScoreV2,
7068            Self::EasyCatch(_) => GameModIntermode::Easy,
7069            Self::NoFailCatch(_) => GameModIntermode::NoFail,
7070            Self::HalfTimeCatch(_) => GameModIntermode::HalfTime,
7071            Self::DaycoreCatch(_) => GameModIntermode::Daycore,
7072            Self::HardRockCatch(_) => GameModIntermode::HardRock,
7073            Self::SuddenDeathCatch(_) => GameModIntermode::SuddenDeath,
7074            Self::PerfectCatch(_) => GameModIntermode::Perfect,
7075            Self::DoubleTimeCatch(_) => GameModIntermode::DoubleTime,
7076            Self::NightcoreCatch(_) => GameModIntermode::Nightcore,
7077            Self::HiddenCatch(_) => GameModIntermode::Hidden,
7078            Self::FlashlightCatch(_) => GameModIntermode::Flashlight,
7079            Self::AccuracyChallengeCatch(_) => GameModIntermode::AccuracyChallenge,
7080            Self::DifficultyAdjustCatch(_) => GameModIntermode::DifficultyAdjust,
7081            Self::ClassicCatch(_) => GameModIntermode::Classic,
7082            Self::MirrorCatch(_) => GameModIntermode::Mirror,
7083            Self::AutoplayCatch(_) => GameModIntermode::Autoplay,
7084            Self::CinemaCatch(_) => GameModIntermode::Cinema,
7085            Self::RelaxCatch(_) => GameModIntermode::Relax,
7086            Self::WindUpCatch(_) => GameModIntermode::WindUp,
7087            Self::WindDownCatch(_) => GameModIntermode::WindDown,
7088            Self::FloatingFruitsCatch(_) => GameModIntermode::FloatingFruits,
7089            Self::MutedCatch(_) => GameModIntermode::Muted,
7090            Self::NoScopeCatch(_) => GameModIntermode::NoScope,
7091            Self::MovingFastCatch(_) => GameModIntermode::MovingFast,
7092            Self::ScoreV2Catch(_) => GameModIntermode::ScoreV2,
7093            Self::EasyMania(_) => GameModIntermode::Easy,
7094            Self::NoFailMania(_) => GameModIntermode::NoFail,
7095            Self::HalfTimeMania(_) => GameModIntermode::HalfTime,
7096            Self::DaycoreMania(_) => GameModIntermode::Daycore,
7097            Self::NoReleaseMania(_) => GameModIntermode::NoRelease,
7098            Self::HardRockMania(_) => GameModIntermode::HardRock,
7099            Self::SuddenDeathMania(_) => GameModIntermode::SuddenDeath,
7100            Self::PerfectMania(_) => GameModIntermode::Perfect,
7101            Self::DoubleTimeMania(_) => GameModIntermode::DoubleTime,
7102            Self::NightcoreMania(_) => GameModIntermode::Nightcore,
7103            Self::FadeInMania(_) => GameModIntermode::FadeIn,
7104            Self::HiddenMania(_) => GameModIntermode::Hidden,
7105            Self::CoverMania(_) => GameModIntermode::Cover,
7106            Self::FlashlightMania(_) => GameModIntermode::Flashlight,
7107            Self::AccuracyChallengeMania(_) => GameModIntermode::AccuracyChallenge,
7108            Self::RandomMania(_) => GameModIntermode::Random,
7109            Self::DualStagesMania(_) => GameModIntermode::DualStages,
7110            Self::MirrorMania(_) => GameModIntermode::Mirror,
7111            Self::DifficultyAdjustMania(_) => GameModIntermode::DifficultyAdjust,
7112            Self::ClassicMania(_) => GameModIntermode::Classic,
7113            Self::InvertMania(_) => GameModIntermode::Invert,
7114            Self::ConstantSpeedMania(_) => GameModIntermode::ConstantSpeed,
7115            Self::HoldOffMania(_) => GameModIntermode::HoldOff,
7116            Self::OneKeyMania(_) => GameModIntermode::OneKey,
7117            Self::TwoKeysMania(_) => GameModIntermode::TwoKeys,
7118            Self::ThreeKeysMania(_) => GameModIntermode::ThreeKeys,
7119            Self::FourKeysMania(_) => GameModIntermode::FourKeys,
7120            Self::FiveKeysMania(_) => GameModIntermode::FiveKeys,
7121            Self::SixKeysMania(_) => GameModIntermode::SixKeys,
7122            Self::SevenKeysMania(_) => GameModIntermode::SevenKeys,
7123            Self::EightKeysMania(_) => GameModIntermode::EightKeys,
7124            Self::NineKeysMania(_) => GameModIntermode::NineKeys,
7125            Self::TenKeysMania(_) => GameModIntermode::TenKeys,
7126            Self::AutoplayMania(_) => GameModIntermode::Autoplay,
7127            Self::CinemaMania(_) => GameModIntermode::Cinema,
7128            Self::WindUpMania(_) => GameModIntermode::WindUp,
7129            Self::WindDownMania(_) => GameModIntermode::WindDown,
7130            Self::MutedMania(_) => GameModIntermode::Muted,
7131            Self::AdaptiveSpeedMania(_) => GameModIntermode::AdaptiveSpeed,
7132            Self::ScoreV2Mania(_) => GameModIntermode::ScoreV2,
7133            Self::UnknownOsu(m)
7134            | Self::UnknownTaiko(m)
7135            | Self::UnknownCatch(m)
7136            | Self::UnknownMania(m) => GameModIntermode::Unknown(*m),
7137        }
7138    }
7139}
7140impl PartialOrd for GameMod {
7141    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
7142        self.bits()
7143            .zip(other.bits())
7144            .map(|(self_bits, other_bits)| self_bits.cmp(&other_bits))
7145    }
7146}
7147#[cfg(feature = "serde")]
7148#[cfg_attr(all(docsrs, not(doctest)), doc(cfg(feature = "serde")))]
7149const _: () = {
7150    use serde::{
7151        de::{
7152            value::MapAccessDeserializer, DeserializeSeed, Deserializer, Error as DeError,
7153            IgnoredAny, MapAccess, Visitor,
7154        },
7155        ser::{Serialize, SerializeMap, Serializer},
7156        Deserialize,
7157    };
7158
7159    use crate::serde::{
7160        DeserializedGameMod, GameModRaw, GameModRawSeed, GameModSettings, GameModSettingsSeed,
7161        GameModVisitor, MaybeOwnedStr,
7162    };
7163
7164    impl<'de> Visitor<'de> for GameModVisitor<EasyOsu> {
7165        type Value = DeserializedGameMod<'de, EasyOsu>;
7166        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7167            f.write_str("EasyOsu")
7168        }
7169        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7170            const FIELDS: &'static [&'static str] = &["retries"];
7171            let mut unknown_key__ = None;
7172            let mut retries = None;
7173            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7174                match key.as_str() {
7175                    "retries" => retries = Some(map.next_value()?),
7176                    _ => {
7177                        unknown_key__ = Some(key);
7178                        let _: IgnoredAny = map.next_value()?;
7179                    }
7180                }
7181            }
7182            let gamemod = EasyOsu {
7183                retries: retries.unwrap_or_default(),
7184            };
7185            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7186        }
7187    }
7188    impl Serialize for EasyOsu {
7189        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7190            let field_count = self.retries.is_some() as usize;
7191            let mut map = s.serialize_map(Some(field_count))?;
7192            if let Some(ref x) = self.retries {
7193                map.serialize_entry("retries", x)?;
7194            }
7195            map.end()
7196        }
7197    }
7198    impl<'de> Visitor<'de> for GameModVisitor<NoFailOsu> {
7199        type Value = DeserializedGameMod<'de, NoFailOsu>;
7200        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7201            f.write_str("NoFailOsu")
7202        }
7203        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7204            const FIELDS: &'static [&'static str] = &[];
7205            let mut unknown_key__ = None;
7206            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7207                match key.as_str() {
7208                    _ => {
7209                        unknown_key__ = Some(key);
7210                        let _: IgnoredAny = map.next_value()?;
7211                    }
7212                }
7213            }
7214            let gamemod = NoFailOsu {};
7215            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7216        }
7217    }
7218    impl Serialize for NoFailOsu {
7219        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7220            let field_count = 0;
7221            let map = s.serialize_map(Some(field_count))?;
7222            map.end()
7223        }
7224    }
7225    impl<'de> Visitor<'de> for GameModVisitor<HalfTimeOsu> {
7226        type Value = DeserializedGameMod<'de, HalfTimeOsu>;
7227        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7228            f.write_str("HalfTimeOsu")
7229        }
7230        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7231            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
7232            let mut unknown_key__ = None;
7233            let mut speed_change = None;
7234            let mut adjust_pitch = None;
7235            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7236                match key.as_str() {
7237                    "speed_change" => speed_change = Some(map.next_value()?),
7238                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
7239                    _ => {
7240                        unknown_key__ = Some(key);
7241                        let _: IgnoredAny = map.next_value()?;
7242                    }
7243                }
7244            }
7245            let gamemod = HalfTimeOsu {
7246                speed_change: speed_change.unwrap_or_default(),
7247                adjust_pitch: adjust_pitch.unwrap_or_default(),
7248            };
7249            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7250        }
7251    }
7252    impl Serialize for HalfTimeOsu {
7253        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7254            let field_count =
7255                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
7256            let mut map = s.serialize_map(Some(field_count))?;
7257            if let Some(ref x) = self.speed_change {
7258                map.serialize_entry("speed_change", x)?;
7259            }
7260            if let Some(ref x) = self.adjust_pitch {
7261                map.serialize_entry("adjust_pitch", x)?;
7262            }
7263            map.end()
7264        }
7265    }
7266    impl<'de> Visitor<'de> for GameModVisitor<DaycoreOsu> {
7267        type Value = DeserializedGameMod<'de, DaycoreOsu>;
7268        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7269            f.write_str("DaycoreOsu")
7270        }
7271        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7272            const FIELDS: &'static [&'static str] = &["speed_change"];
7273            let mut unknown_key__ = None;
7274            let mut speed_change = None;
7275            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7276                match key.as_str() {
7277                    "speed_change" => speed_change = Some(map.next_value()?),
7278                    _ => {
7279                        unknown_key__ = Some(key);
7280                        let _: IgnoredAny = map.next_value()?;
7281                    }
7282                }
7283            }
7284            let gamemod = DaycoreOsu {
7285                speed_change: speed_change.unwrap_or_default(),
7286            };
7287            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7288        }
7289    }
7290    impl Serialize for DaycoreOsu {
7291        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7292            let field_count = self.speed_change.is_some() as usize;
7293            let mut map = s.serialize_map(Some(field_count))?;
7294            if let Some(ref x) = self.speed_change {
7295                map.serialize_entry("speed_change", x)?;
7296            }
7297            map.end()
7298        }
7299    }
7300    impl<'de> Visitor<'de> for GameModVisitor<HardRockOsu> {
7301        type Value = DeserializedGameMod<'de, HardRockOsu>;
7302        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7303            f.write_str("HardRockOsu")
7304        }
7305        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7306            const FIELDS: &'static [&'static str] = &[];
7307            let mut unknown_key__ = None;
7308            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7309                match key.as_str() {
7310                    _ => {
7311                        unknown_key__ = Some(key);
7312                        let _: IgnoredAny = map.next_value()?;
7313                    }
7314                }
7315            }
7316            let gamemod = HardRockOsu {};
7317            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7318        }
7319    }
7320    impl Serialize for HardRockOsu {
7321        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7322            let field_count = 0;
7323            let map = s.serialize_map(Some(field_count))?;
7324            map.end()
7325        }
7326    }
7327    impl<'de> Visitor<'de> for GameModVisitor<SuddenDeathOsu> {
7328        type Value = DeserializedGameMod<'de, SuddenDeathOsu>;
7329        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7330            f.write_str("SuddenDeathOsu")
7331        }
7332        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7333            const FIELDS: &'static [&'static str] = &["fail_on_slider_tail", "restart"];
7334            let mut unknown_key__ = None;
7335            let mut fail_on_slider_tail = None;
7336            let mut restart = None;
7337            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7338                match key.as_str() {
7339                    "fail_on_slider_tail" => fail_on_slider_tail = Some(map.next_value()?),
7340                    "restart" => restart = Some(map.next_value()?),
7341                    _ => {
7342                        unknown_key__ = Some(key);
7343                        let _: IgnoredAny = map.next_value()?;
7344                    }
7345                }
7346            }
7347            let gamemod = SuddenDeathOsu {
7348                fail_on_slider_tail: fail_on_slider_tail.unwrap_or_default(),
7349                restart: restart.unwrap_or_default(),
7350            };
7351            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7352        }
7353    }
7354    impl Serialize for SuddenDeathOsu {
7355        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7356            let field_count =
7357                self.fail_on_slider_tail.is_some() as usize + self.restart.is_some() as usize;
7358            let mut map = s.serialize_map(Some(field_count))?;
7359            if let Some(ref x) = self.fail_on_slider_tail {
7360                map.serialize_entry("fail_on_slider_tail", x)?;
7361            }
7362            if let Some(ref x) = self.restart {
7363                map.serialize_entry("restart", x)?;
7364            }
7365            map.end()
7366        }
7367    }
7368    impl<'de> Visitor<'de> for GameModVisitor<PerfectOsu> {
7369        type Value = DeserializedGameMod<'de, PerfectOsu>;
7370        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7371            f.write_str("PerfectOsu")
7372        }
7373        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7374            const FIELDS: &'static [&'static str] = &["restart"];
7375            let mut unknown_key__ = None;
7376            let mut restart = None;
7377            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7378                match key.as_str() {
7379                    "restart" => restart = Some(map.next_value()?),
7380                    _ => {
7381                        unknown_key__ = Some(key);
7382                        let _: IgnoredAny = map.next_value()?;
7383                    }
7384                }
7385            }
7386            let gamemod = PerfectOsu {
7387                restart: restart.unwrap_or_default(),
7388            };
7389            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7390        }
7391    }
7392    impl Serialize for PerfectOsu {
7393        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7394            let field_count = self.restart.is_some() as usize;
7395            let mut map = s.serialize_map(Some(field_count))?;
7396            if let Some(ref x) = self.restart {
7397                map.serialize_entry("restart", x)?;
7398            }
7399            map.end()
7400        }
7401    }
7402    impl<'de> Visitor<'de> for GameModVisitor<DoubleTimeOsu> {
7403        type Value = DeserializedGameMod<'de, DoubleTimeOsu>;
7404        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7405            f.write_str("DoubleTimeOsu")
7406        }
7407        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7408            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
7409            let mut unknown_key__ = None;
7410            let mut speed_change = None;
7411            let mut adjust_pitch = None;
7412            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7413                match key.as_str() {
7414                    "speed_change" => speed_change = Some(map.next_value()?),
7415                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
7416                    _ => {
7417                        unknown_key__ = Some(key);
7418                        let _: IgnoredAny = map.next_value()?;
7419                    }
7420                }
7421            }
7422            let gamemod = DoubleTimeOsu {
7423                speed_change: speed_change.unwrap_or_default(),
7424                adjust_pitch: adjust_pitch.unwrap_or_default(),
7425            };
7426            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7427        }
7428    }
7429    impl Serialize for DoubleTimeOsu {
7430        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7431            let field_count =
7432                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
7433            let mut map = s.serialize_map(Some(field_count))?;
7434            if let Some(ref x) = self.speed_change {
7435                map.serialize_entry("speed_change", x)?;
7436            }
7437            if let Some(ref x) = self.adjust_pitch {
7438                map.serialize_entry("adjust_pitch", x)?;
7439            }
7440            map.end()
7441        }
7442    }
7443    impl<'de> Visitor<'de> for GameModVisitor<NightcoreOsu> {
7444        type Value = DeserializedGameMod<'de, NightcoreOsu>;
7445        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7446            f.write_str("NightcoreOsu")
7447        }
7448        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7449            const FIELDS: &'static [&'static str] = &["speed_change"];
7450            let mut unknown_key__ = None;
7451            let mut speed_change = None;
7452            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7453                match key.as_str() {
7454                    "speed_change" => speed_change = Some(map.next_value()?),
7455                    _ => {
7456                        unknown_key__ = Some(key);
7457                        let _: IgnoredAny = map.next_value()?;
7458                    }
7459                }
7460            }
7461            let gamemod = NightcoreOsu {
7462                speed_change: speed_change.unwrap_or_default(),
7463            };
7464            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7465        }
7466    }
7467    impl Serialize for NightcoreOsu {
7468        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7469            let field_count = self.speed_change.is_some() as usize;
7470            let mut map = s.serialize_map(Some(field_count))?;
7471            if let Some(ref x) = self.speed_change {
7472                map.serialize_entry("speed_change", x)?;
7473            }
7474            map.end()
7475        }
7476    }
7477    impl<'de> Visitor<'de> for GameModVisitor<HiddenOsu> {
7478        type Value = DeserializedGameMod<'de, HiddenOsu>;
7479        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7480            f.write_str("HiddenOsu")
7481        }
7482        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7483            const FIELDS: &'static [&'static str] = &["only_fade_approach_circles"];
7484            let mut unknown_key__ = None;
7485            let mut only_fade_approach_circles = None;
7486            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7487                match key.as_str() {
7488                    "only_fade_approach_circles" => {
7489                        only_fade_approach_circles = Some(map.next_value()?)
7490                    }
7491                    _ => {
7492                        unknown_key__ = Some(key);
7493                        let _: IgnoredAny = map.next_value()?;
7494                    }
7495                }
7496            }
7497            let gamemod = HiddenOsu {
7498                only_fade_approach_circles: only_fade_approach_circles.unwrap_or_default(),
7499            };
7500            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7501        }
7502    }
7503    impl Serialize for HiddenOsu {
7504        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7505            let field_count = self.only_fade_approach_circles.is_some() as usize;
7506            let mut map = s.serialize_map(Some(field_count))?;
7507            if let Some(ref x) = self.only_fade_approach_circles {
7508                map.serialize_entry("only_fade_approach_circles", x)?;
7509            }
7510            map.end()
7511        }
7512    }
7513    impl<'de> Visitor<'de> for GameModVisitor<TraceableOsu> {
7514        type Value = DeserializedGameMod<'de, TraceableOsu>;
7515        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7516            f.write_str("TraceableOsu")
7517        }
7518        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7519            const FIELDS: &'static [&'static str] = &[];
7520            let mut unknown_key__ = None;
7521            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7522                match key.as_str() {
7523                    _ => {
7524                        unknown_key__ = Some(key);
7525                        let _: IgnoredAny = map.next_value()?;
7526                    }
7527                }
7528            }
7529            let gamemod = TraceableOsu {};
7530            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7531        }
7532    }
7533    impl Serialize for TraceableOsu {
7534        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7535            let field_count = 0;
7536            let map = s.serialize_map(Some(field_count))?;
7537            map.end()
7538        }
7539    }
7540    impl<'de> Visitor<'de> for GameModVisitor<FlashlightOsu> {
7541        type Value = DeserializedGameMod<'de, FlashlightOsu>;
7542        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7543            f.write_str("FlashlightOsu")
7544        }
7545        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7546            const FIELDS: &'static [&'static str] =
7547                &["follow_delay", "size_multiplier", "combo_based_size"];
7548            let mut unknown_key__ = None;
7549            let mut follow_delay = None;
7550            let mut size_multiplier = None;
7551            let mut combo_based_size = None;
7552            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7553                match key.as_str() {
7554                    "follow_delay" => follow_delay = Some(map.next_value()?),
7555                    "size_multiplier" => size_multiplier = Some(map.next_value()?),
7556                    "combo_based_size" => combo_based_size = Some(map.next_value()?),
7557                    _ => {
7558                        unknown_key__ = Some(key);
7559                        let _: IgnoredAny = map.next_value()?;
7560                    }
7561                }
7562            }
7563            let gamemod = FlashlightOsu {
7564                follow_delay: follow_delay.unwrap_or_default(),
7565                size_multiplier: size_multiplier.unwrap_or_default(),
7566                combo_based_size: combo_based_size.unwrap_or_default(),
7567            };
7568            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7569        }
7570    }
7571    impl Serialize for FlashlightOsu {
7572        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7573            let field_count = self.follow_delay.is_some() as usize
7574                + self.size_multiplier.is_some() as usize
7575                + self.combo_based_size.is_some() as usize;
7576            let mut map = s.serialize_map(Some(field_count))?;
7577            if let Some(ref x) = self.follow_delay {
7578                map.serialize_entry("follow_delay", x)?;
7579            }
7580            if let Some(ref x) = self.size_multiplier {
7581                map.serialize_entry("size_multiplier", x)?;
7582            }
7583            if let Some(ref x) = self.combo_based_size {
7584                map.serialize_entry("combo_based_size", x)?;
7585            }
7586            map.end()
7587        }
7588    }
7589    impl<'de> Visitor<'de> for GameModVisitor<BlindsOsu> {
7590        type Value = DeserializedGameMod<'de, BlindsOsu>;
7591        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7592            f.write_str("BlindsOsu")
7593        }
7594        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7595            const FIELDS: &'static [&'static str] = &[];
7596            let mut unknown_key__ = None;
7597            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7598                match key.as_str() {
7599                    _ => {
7600                        unknown_key__ = Some(key);
7601                        let _: IgnoredAny = map.next_value()?;
7602                    }
7603                }
7604            }
7605            let gamemod = BlindsOsu {};
7606            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7607        }
7608    }
7609    impl Serialize for BlindsOsu {
7610        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7611            let field_count = 0;
7612            let map = s.serialize_map(Some(field_count))?;
7613            map.end()
7614        }
7615    }
7616    impl<'de> Visitor<'de> for GameModVisitor<StrictTrackingOsu> {
7617        type Value = DeserializedGameMod<'de, StrictTrackingOsu>;
7618        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7619            f.write_str("StrictTrackingOsu")
7620        }
7621        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7622            const FIELDS: &'static [&'static str] = &[];
7623            let mut unknown_key__ = None;
7624            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7625                match key.as_str() {
7626                    _ => {
7627                        unknown_key__ = Some(key);
7628                        let _: IgnoredAny = map.next_value()?;
7629                    }
7630                }
7631            }
7632            let gamemod = StrictTrackingOsu {};
7633            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7634        }
7635    }
7636    impl Serialize for StrictTrackingOsu {
7637        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7638            let field_count = 0;
7639            let map = s.serialize_map(Some(field_count))?;
7640            map.end()
7641        }
7642    }
7643    impl<'de> Visitor<'de> for GameModVisitor<AccuracyChallengeOsu> {
7644        type Value = DeserializedGameMod<'de, AccuracyChallengeOsu>;
7645        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7646            f.write_str("AccuracyChallengeOsu")
7647        }
7648        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7649            const FIELDS: &'static [&'static str] =
7650                &["minimum_accuracy", "accuracy_judge_mode", "restart"];
7651            let mut unknown_key__ = None;
7652            let mut minimum_accuracy = None;
7653            let mut accuracy_judge_mode = None;
7654            let mut restart = None;
7655            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7656                match key.as_str() {
7657                    "minimum_accuracy" => minimum_accuracy = Some(map.next_value()?),
7658                    "accuracy_judge_mode" => accuracy_judge_mode = Some(map.next_value()?),
7659                    "restart" => restart = Some(map.next_value()?),
7660                    _ => {
7661                        unknown_key__ = Some(key);
7662                        let _: IgnoredAny = map.next_value()?;
7663                    }
7664                }
7665            }
7666            let gamemod = AccuracyChallengeOsu {
7667                minimum_accuracy: minimum_accuracy.unwrap_or_default(),
7668                accuracy_judge_mode: accuracy_judge_mode.unwrap_or_default(),
7669                restart: restart.unwrap_or_default(),
7670            };
7671            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7672        }
7673    }
7674    impl Serialize for AccuracyChallengeOsu {
7675        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7676            let field_count = self.minimum_accuracy.is_some() as usize
7677                + self.accuracy_judge_mode.is_some() as usize
7678                + self.restart.is_some() as usize;
7679            let mut map = s.serialize_map(Some(field_count))?;
7680            if let Some(ref x) = self.minimum_accuracy {
7681                map.serialize_entry("minimum_accuracy", x)?;
7682            }
7683            if let Some(ref x) = self.accuracy_judge_mode {
7684                map.serialize_entry("accuracy_judge_mode", x)?;
7685            }
7686            if let Some(ref x) = self.restart {
7687                map.serialize_entry("restart", x)?;
7688            }
7689            map.end()
7690        }
7691    }
7692    impl<'de> Visitor<'de> for GameModVisitor<TargetPracticeOsu> {
7693        type Value = DeserializedGameMod<'de, TargetPracticeOsu>;
7694        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7695            f.write_str("TargetPracticeOsu")
7696        }
7697        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7698            const FIELDS: &'static [&'static str] = &["seed", "metronome"];
7699            let mut unknown_key__ = None;
7700            let mut seed = None;
7701            let mut metronome = None;
7702            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7703                match key.as_str() {
7704                    "seed" => seed = Some(map.next_value()?),
7705                    "metronome" => metronome = Some(map.next_value()?),
7706                    _ => {
7707                        unknown_key__ = Some(key);
7708                        let _: IgnoredAny = map.next_value()?;
7709                    }
7710                }
7711            }
7712            let gamemod = TargetPracticeOsu {
7713                seed: seed.unwrap_or_default(),
7714                metronome: metronome.unwrap_or_default(),
7715            };
7716            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7717        }
7718    }
7719    impl Serialize for TargetPracticeOsu {
7720        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7721            let field_count = self.seed.is_some() as usize + self.metronome.is_some() as usize;
7722            let mut map = s.serialize_map(Some(field_count))?;
7723            if let Some(ref x) = self.seed {
7724                map.serialize_entry("seed", x)?;
7725            }
7726            if let Some(ref x) = self.metronome {
7727                map.serialize_entry("metronome", x)?;
7728            }
7729            map.end()
7730        }
7731    }
7732    impl<'de> Visitor<'de> for GameModVisitor<DifficultyAdjustOsu> {
7733        type Value = DeserializedGameMod<'de, DifficultyAdjustOsu>;
7734        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7735            f.write_str("DifficultyAdjustOsu")
7736        }
7737        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7738            const FIELDS: &'static [&'static str] = &[
7739                "circle_size",
7740                "approach_rate",
7741                "drain_rate",
7742                "overall_difficulty",
7743                "extended_limits",
7744            ];
7745            let mut unknown_key__ = None;
7746            let mut circle_size = None;
7747            let mut approach_rate = None;
7748            let mut drain_rate = None;
7749            let mut overall_difficulty = None;
7750            let mut extended_limits = None;
7751            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7752                match key.as_str() {
7753                    "circle_size" => circle_size = Some(map.next_value()?),
7754                    "approach_rate" => approach_rate = Some(map.next_value()?),
7755                    "drain_rate" => drain_rate = Some(map.next_value()?),
7756                    "overall_difficulty" => overall_difficulty = Some(map.next_value()?),
7757                    "extended_limits" => extended_limits = Some(map.next_value()?),
7758                    _ => {
7759                        unknown_key__ = Some(key);
7760                        let _: IgnoredAny = map.next_value()?;
7761                    }
7762                }
7763            }
7764            let gamemod = DifficultyAdjustOsu {
7765                circle_size: circle_size.unwrap_or_default(),
7766                approach_rate: approach_rate.unwrap_or_default(),
7767                drain_rate: drain_rate.unwrap_or_default(),
7768                overall_difficulty: overall_difficulty.unwrap_or_default(),
7769                extended_limits: extended_limits.unwrap_or_default(),
7770            };
7771            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7772        }
7773    }
7774    impl Serialize for DifficultyAdjustOsu {
7775        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7776            let field_count = self.circle_size.is_some() as usize
7777                + self.approach_rate.is_some() as usize
7778                + self.drain_rate.is_some() as usize
7779                + self.overall_difficulty.is_some() as usize
7780                + self.extended_limits.is_some() as usize;
7781            let mut map = s.serialize_map(Some(field_count))?;
7782            if let Some(ref x) = self.circle_size {
7783                map.serialize_entry("circle_size", x)?;
7784            }
7785            if let Some(ref x) = self.approach_rate {
7786                map.serialize_entry("approach_rate", x)?;
7787            }
7788            if let Some(ref x) = self.drain_rate {
7789                map.serialize_entry("drain_rate", x)?;
7790            }
7791            if let Some(ref x) = self.overall_difficulty {
7792                map.serialize_entry("overall_difficulty", x)?;
7793            }
7794            if let Some(ref x) = self.extended_limits {
7795                map.serialize_entry("extended_limits", x)?;
7796            }
7797            map.end()
7798        }
7799    }
7800    impl<'de> Visitor<'de> for GameModVisitor<ClassicOsu> {
7801        type Value = DeserializedGameMod<'de, ClassicOsu>;
7802        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7803            f.write_str("ClassicOsu")
7804        }
7805        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7806            const FIELDS: &'static [&'static str] = &[
7807                "no_slider_head_accuracy",
7808                "classic_note_lock",
7809                "always_play_tail_sample",
7810                "fade_hit_circle_early",
7811                "classic_health",
7812            ];
7813            let mut unknown_key__ = None;
7814            let mut no_slider_head_accuracy = None;
7815            let mut classic_note_lock = None;
7816            let mut always_play_tail_sample = None;
7817            let mut fade_hit_circle_early = None;
7818            let mut classic_health = None;
7819            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7820                match key.as_str() {
7821                    "no_slider_head_accuracy" => no_slider_head_accuracy = Some(map.next_value()?),
7822                    "classic_note_lock" => classic_note_lock = Some(map.next_value()?),
7823                    "always_play_tail_sample" => always_play_tail_sample = Some(map.next_value()?),
7824                    "fade_hit_circle_early" => fade_hit_circle_early = Some(map.next_value()?),
7825                    "classic_health" => classic_health = Some(map.next_value()?),
7826                    _ => {
7827                        unknown_key__ = Some(key);
7828                        let _: IgnoredAny = map.next_value()?;
7829                    }
7830                }
7831            }
7832            let gamemod = ClassicOsu {
7833                no_slider_head_accuracy: no_slider_head_accuracy.unwrap_or_default(),
7834                classic_note_lock: classic_note_lock.unwrap_or_default(),
7835                always_play_tail_sample: always_play_tail_sample.unwrap_or_default(),
7836                fade_hit_circle_early: fade_hit_circle_early.unwrap_or_default(),
7837                classic_health: classic_health.unwrap_or_default(),
7838            };
7839            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7840        }
7841    }
7842    impl Serialize for ClassicOsu {
7843        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7844            let field_count = self.no_slider_head_accuracy.is_some() as usize
7845                + self.classic_note_lock.is_some() as usize
7846                + self.always_play_tail_sample.is_some() as usize
7847                + self.fade_hit_circle_early.is_some() as usize
7848                + self.classic_health.is_some() as usize;
7849            let mut map = s.serialize_map(Some(field_count))?;
7850            if let Some(ref x) = self.no_slider_head_accuracy {
7851                map.serialize_entry("no_slider_head_accuracy", x)?;
7852            }
7853            if let Some(ref x) = self.classic_note_lock {
7854                map.serialize_entry("classic_note_lock", x)?;
7855            }
7856            if let Some(ref x) = self.always_play_tail_sample {
7857                map.serialize_entry("always_play_tail_sample", x)?;
7858            }
7859            if let Some(ref x) = self.fade_hit_circle_early {
7860                map.serialize_entry("fade_hit_circle_early", x)?;
7861            }
7862            if let Some(ref x) = self.classic_health {
7863                map.serialize_entry("classic_health", x)?;
7864            }
7865            map.end()
7866        }
7867    }
7868    impl<'de> Visitor<'de> for GameModVisitor<RandomOsu> {
7869        type Value = DeserializedGameMod<'de, RandomOsu>;
7870        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7871            f.write_str("RandomOsu")
7872        }
7873        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7874            const FIELDS: &'static [&'static str] = &["angle_sharpness", "seed"];
7875            let mut unknown_key__ = None;
7876            let mut angle_sharpness = None;
7877            let mut seed = None;
7878            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7879                match key.as_str() {
7880                    "angle_sharpness" => angle_sharpness = Some(map.next_value()?),
7881                    "seed" => seed = Some(map.next_value()?),
7882                    _ => {
7883                        unknown_key__ = Some(key);
7884                        let _: IgnoredAny = map.next_value()?;
7885                    }
7886                }
7887            }
7888            let gamemod = RandomOsu {
7889                angle_sharpness: angle_sharpness.unwrap_or_default(),
7890                seed: seed.unwrap_or_default(),
7891            };
7892            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7893        }
7894    }
7895    impl Serialize for RandomOsu {
7896        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7897            let field_count =
7898                self.angle_sharpness.is_some() as usize + self.seed.is_some() as usize;
7899            let mut map = s.serialize_map(Some(field_count))?;
7900            if let Some(ref x) = self.angle_sharpness {
7901                map.serialize_entry("angle_sharpness", x)?;
7902            }
7903            if let Some(ref x) = self.seed {
7904                map.serialize_entry("seed", x)?;
7905            }
7906            map.end()
7907        }
7908    }
7909    impl<'de> Visitor<'de> for GameModVisitor<MirrorOsu> {
7910        type Value = DeserializedGameMod<'de, MirrorOsu>;
7911        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7912            f.write_str("MirrorOsu")
7913        }
7914        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7915            const FIELDS: &'static [&'static str] = &["reflection"];
7916            let mut unknown_key__ = None;
7917            let mut reflection = None;
7918            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7919                match key.as_str() {
7920                    "reflection" => reflection = Some(map.next_value()?),
7921                    _ => {
7922                        unknown_key__ = Some(key);
7923                        let _: IgnoredAny = map.next_value()?;
7924                    }
7925                }
7926            }
7927            let gamemod = MirrorOsu {
7928                reflection: reflection.unwrap_or_default(),
7929            };
7930            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7931        }
7932    }
7933    impl Serialize for MirrorOsu {
7934        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7935            let field_count = self.reflection.is_some() as usize;
7936            let mut map = s.serialize_map(Some(field_count))?;
7937            if let Some(ref x) = self.reflection {
7938                map.serialize_entry("reflection", x)?;
7939            }
7940            map.end()
7941        }
7942    }
7943    impl<'de> Visitor<'de> for GameModVisitor<AlternateOsu> {
7944        type Value = DeserializedGameMod<'de, AlternateOsu>;
7945        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7946            f.write_str("AlternateOsu")
7947        }
7948        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7949            const FIELDS: &'static [&'static str] = &[];
7950            let mut unknown_key__ = None;
7951            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7952                match key.as_str() {
7953                    _ => {
7954                        unknown_key__ = Some(key);
7955                        let _: IgnoredAny = map.next_value()?;
7956                    }
7957                }
7958            }
7959            let gamemod = AlternateOsu {};
7960            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7961        }
7962    }
7963    impl Serialize for AlternateOsu {
7964        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7965            let field_count = 0;
7966            let map = s.serialize_map(Some(field_count))?;
7967            map.end()
7968        }
7969    }
7970    impl<'de> Visitor<'de> for GameModVisitor<SingleTapOsu> {
7971        type Value = DeserializedGameMod<'de, SingleTapOsu>;
7972        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
7973            f.write_str("SingleTapOsu")
7974        }
7975        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
7976            const FIELDS: &'static [&'static str] = &[];
7977            let mut unknown_key__ = None;
7978            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
7979                match key.as_str() {
7980                    _ => {
7981                        unknown_key__ = Some(key);
7982                        let _: IgnoredAny = map.next_value()?;
7983                    }
7984                }
7985            }
7986            let gamemod = SingleTapOsu {};
7987            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
7988        }
7989    }
7990    impl Serialize for SingleTapOsu {
7991        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
7992            let field_count = 0;
7993            let map = s.serialize_map(Some(field_count))?;
7994            map.end()
7995        }
7996    }
7997    impl<'de> Visitor<'de> for GameModVisitor<AutoplayOsu> {
7998        type Value = DeserializedGameMod<'de, AutoplayOsu>;
7999        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8000            f.write_str("AutoplayOsu")
8001        }
8002        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8003            const FIELDS: &'static [&'static str] = &[];
8004            let mut unknown_key__ = None;
8005            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8006                match key.as_str() {
8007                    _ => {
8008                        unknown_key__ = Some(key);
8009                        let _: IgnoredAny = map.next_value()?;
8010                    }
8011                }
8012            }
8013            let gamemod = AutoplayOsu {};
8014            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8015        }
8016    }
8017    impl Serialize for AutoplayOsu {
8018        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8019            let field_count = 0;
8020            let map = s.serialize_map(Some(field_count))?;
8021            map.end()
8022        }
8023    }
8024    impl<'de> Visitor<'de> for GameModVisitor<CinemaOsu> {
8025        type Value = DeserializedGameMod<'de, CinemaOsu>;
8026        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8027            f.write_str("CinemaOsu")
8028        }
8029        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8030            const FIELDS: &'static [&'static str] = &[];
8031            let mut unknown_key__ = None;
8032            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8033                match key.as_str() {
8034                    _ => {
8035                        unknown_key__ = Some(key);
8036                        let _: IgnoredAny = map.next_value()?;
8037                    }
8038                }
8039            }
8040            let gamemod = CinemaOsu {};
8041            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8042        }
8043    }
8044    impl Serialize for CinemaOsu {
8045        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8046            let field_count = 0;
8047            let map = s.serialize_map(Some(field_count))?;
8048            map.end()
8049        }
8050    }
8051    impl<'de> Visitor<'de> for GameModVisitor<RelaxOsu> {
8052        type Value = DeserializedGameMod<'de, RelaxOsu>;
8053        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8054            f.write_str("RelaxOsu")
8055        }
8056        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8057            const FIELDS: &'static [&'static str] = &[];
8058            let mut unknown_key__ = None;
8059            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8060                match key.as_str() {
8061                    _ => {
8062                        unknown_key__ = Some(key);
8063                        let _: IgnoredAny = map.next_value()?;
8064                    }
8065                }
8066            }
8067            let gamemod = RelaxOsu {};
8068            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8069        }
8070    }
8071    impl Serialize for RelaxOsu {
8072        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8073            let field_count = 0;
8074            let map = s.serialize_map(Some(field_count))?;
8075            map.end()
8076        }
8077    }
8078    impl<'de> Visitor<'de> for GameModVisitor<AutopilotOsu> {
8079        type Value = DeserializedGameMod<'de, AutopilotOsu>;
8080        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8081            f.write_str("AutopilotOsu")
8082        }
8083        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8084            const FIELDS: &'static [&'static str] = &[];
8085            let mut unknown_key__ = None;
8086            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8087                match key.as_str() {
8088                    _ => {
8089                        unknown_key__ = Some(key);
8090                        let _: IgnoredAny = map.next_value()?;
8091                    }
8092                }
8093            }
8094            let gamemod = AutopilotOsu {};
8095            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8096        }
8097    }
8098    impl Serialize for AutopilotOsu {
8099        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8100            let field_count = 0;
8101            let map = s.serialize_map(Some(field_count))?;
8102            map.end()
8103        }
8104    }
8105    impl<'de> Visitor<'de> for GameModVisitor<SpunOutOsu> {
8106        type Value = DeserializedGameMod<'de, SpunOutOsu>;
8107        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8108            f.write_str("SpunOutOsu")
8109        }
8110        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8111            const FIELDS: &'static [&'static str] = &[];
8112            let mut unknown_key__ = None;
8113            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8114                match key.as_str() {
8115                    _ => {
8116                        unknown_key__ = Some(key);
8117                        let _: IgnoredAny = map.next_value()?;
8118                    }
8119                }
8120            }
8121            let gamemod = SpunOutOsu {};
8122            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8123        }
8124    }
8125    impl Serialize for SpunOutOsu {
8126        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8127            let field_count = 0;
8128            let map = s.serialize_map(Some(field_count))?;
8129            map.end()
8130        }
8131    }
8132    impl<'de> Visitor<'de> for GameModVisitor<TransformOsu> {
8133        type Value = DeserializedGameMod<'de, TransformOsu>;
8134        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8135            f.write_str("TransformOsu")
8136        }
8137        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8138            const FIELDS: &'static [&'static str] = &[];
8139            let mut unknown_key__ = None;
8140            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8141                match key.as_str() {
8142                    _ => {
8143                        unknown_key__ = Some(key);
8144                        let _: IgnoredAny = map.next_value()?;
8145                    }
8146                }
8147            }
8148            let gamemod = TransformOsu {};
8149            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8150        }
8151    }
8152    impl Serialize for TransformOsu {
8153        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8154            let field_count = 0;
8155            let map = s.serialize_map(Some(field_count))?;
8156            map.end()
8157        }
8158    }
8159    impl<'de> Visitor<'de> for GameModVisitor<WiggleOsu> {
8160        type Value = DeserializedGameMod<'de, WiggleOsu>;
8161        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8162            f.write_str("WiggleOsu")
8163        }
8164        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8165            const FIELDS: &'static [&'static str] = &["strength"];
8166            let mut unknown_key__ = None;
8167            let mut strength = None;
8168            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8169                match key.as_str() {
8170                    "strength" => strength = Some(map.next_value()?),
8171                    _ => {
8172                        unknown_key__ = Some(key);
8173                        let _: IgnoredAny = map.next_value()?;
8174                    }
8175                }
8176            }
8177            let gamemod = WiggleOsu {
8178                strength: strength.unwrap_or_default(),
8179            };
8180            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8181        }
8182    }
8183    impl Serialize for WiggleOsu {
8184        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8185            let field_count = self.strength.is_some() as usize;
8186            let mut map = s.serialize_map(Some(field_count))?;
8187            if let Some(ref x) = self.strength {
8188                map.serialize_entry("strength", x)?;
8189            }
8190            map.end()
8191        }
8192    }
8193    impl<'de> Visitor<'de> for GameModVisitor<SpinInOsu> {
8194        type Value = DeserializedGameMod<'de, SpinInOsu>;
8195        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8196            f.write_str("SpinInOsu")
8197        }
8198        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8199            const FIELDS: &'static [&'static str] = &[];
8200            let mut unknown_key__ = None;
8201            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8202                match key.as_str() {
8203                    _ => {
8204                        unknown_key__ = Some(key);
8205                        let _: IgnoredAny = map.next_value()?;
8206                    }
8207                }
8208            }
8209            let gamemod = SpinInOsu {};
8210            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8211        }
8212    }
8213    impl Serialize for SpinInOsu {
8214        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8215            let field_count = 0;
8216            let map = s.serialize_map(Some(field_count))?;
8217            map.end()
8218        }
8219    }
8220    impl<'de> Visitor<'de> for GameModVisitor<GrowOsu> {
8221        type Value = DeserializedGameMod<'de, GrowOsu>;
8222        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8223            f.write_str("GrowOsu")
8224        }
8225        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8226            const FIELDS: &'static [&'static str] = &["start_scale"];
8227            let mut unknown_key__ = None;
8228            let mut start_scale = None;
8229            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8230                match key.as_str() {
8231                    "start_scale" => start_scale = Some(map.next_value()?),
8232                    _ => {
8233                        unknown_key__ = Some(key);
8234                        let _: IgnoredAny = map.next_value()?;
8235                    }
8236                }
8237            }
8238            let gamemod = GrowOsu {
8239                start_scale: start_scale.unwrap_or_default(),
8240            };
8241            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8242        }
8243    }
8244    impl Serialize for GrowOsu {
8245        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8246            let field_count = self.start_scale.is_some() as usize;
8247            let mut map = s.serialize_map(Some(field_count))?;
8248            if let Some(ref x) = self.start_scale {
8249                map.serialize_entry("start_scale", x)?;
8250            }
8251            map.end()
8252        }
8253    }
8254    impl<'de> Visitor<'de> for GameModVisitor<DeflateOsu> {
8255        type Value = DeserializedGameMod<'de, DeflateOsu>;
8256        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8257            f.write_str("DeflateOsu")
8258        }
8259        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8260            const FIELDS: &'static [&'static str] = &["start_scale"];
8261            let mut unknown_key__ = None;
8262            let mut start_scale = None;
8263            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8264                match key.as_str() {
8265                    "start_scale" => start_scale = Some(map.next_value()?),
8266                    _ => {
8267                        unknown_key__ = Some(key);
8268                        let _: IgnoredAny = map.next_value()?;
8269                    }
8270                }
8271            }
8272            let gamemod = DeflateOsu {
8273                start_scale: start_scale.unwrap_or_default(),
8274            };
8275            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8276        }
8277    }
8278    impl Serialize for DeflateOsu {
8279        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8280            let field_count = self.start_scale.is_some() as usize;
8281            let mut map = s.serialize_map(Some(field_count))?;
8282            if let Some(ref x) = self.start_scale {
8283                map.serialize_entry("start_scale", x)?;
8284            }
8285            map.end()
8286        }
8287    }
8288    impl<'de> Visitor<'de> for GameModVisitor<WindUpOsu> {
8289        type Value = DeserializedGameMod<'de, WindUpOsu>;
8290        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8291            f.write_str("WindUpOsu")
8292        }
8293        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8294            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
8295            let mut unknown_key__ = None;
8296            let mut initial_rate = None;
8297            let mut final_rate = None;
8298            let mut adjust_pitch = None;
8299            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8300                match key.as_str() {
8301                    "initial_rate" => initial_rate = Some(map.next_value()?),
8302                    "final_rate" => final_rate = Some(map.next_value()?),
8303                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
8304                    _ => {
8305                        unknown_key__ = Some(key);
8306                        let _: IgnoredAny = map.next_value()?;
8307                    }
8308                }
8309            }
8310            let gamemod = WindUpOsu {
8311                initial_rate: initial_rate.unwrap_or_default(),
8312                final_rate: final_rate.unwrap_or_default(),
8313                adjust_pitch: adjust_pitch.unwrap_or_default(),
8314            };
8315            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8316        }
8317    }
8318    impl Serialize for WindUpOsu {
8319        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8320            let field_count = self.initial_rate.is_some() as usize
8321                + self.final_rate.is_some() as usize
8322                + self.adjust_pitch.is_some() as usize;
8323            let mut map = s.serialize_map(Some(field_count))?;
8324            if let Some(ref x) = self.initial_rate {
8325                map.serialize_entry("initial_rate", x)?;
8326            }
8327            if let Some(ref x) = self.final_rate {
8328                map.serialize_entry("final_rate", x)?;
8329            }
8330            if let Some(ref x) = self.adjust_pitch {
8331                map.serialize_entry("adjust_pitch", x)?;
8332            }
8333            map.end()
8334        }
8335    }
8336    impl<'de> Visitor<'de> for GameModVisitor<WindDownOsu> {
8337        type Value = DeserializedGameMod<'de, WindDownOsu>;
8338        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8339            f.write_str("WindDownOsu")
8340        }
8341        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8342            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
8343            let mut unknown_key__ = None;
8344            let mut initial_rate = None;
8345            let mut final_rate = None;
8346            let mut adjust_pitch = None;
8347            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8348                match key.as_str() {
8349                    "initial_rate" => initial_rate = Some(map.next_value()?),
8350                    "final_rate" => final_rate = Some(map.next_value()?),
8351                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
8352                    _ => {
8353                        unknown_key__ = Some(key);
8354                        let _: IgnoredAny = map.next_value()?;
8355                    }
8356                }
8357            }
8358            let gamemod = WindDownOsu {
8359                initial_rate: initial_rate.unwrap_or_default(),
8360                final_rate: final_rate.unwrap_or_default(),
8361                adjust_pitch: adjust_pitch.unwrap_or_default(),
8362            };
8363            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8364        }
8365    }
8366    impl Serialize for WindDownOsu {
8367        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8368            let field_count = self.initial_rate.is_some() as usize
8369                + self.final_rate.is_some() as usize
8370                + self.adjust_pitch.is_some() as usize;
8371            let mut map = s.serialize_map(Some(field_count))?;
8372            if let Some(ref x) = self.initial_rate {
8373                map.serialize_entry("initial_rate", x)?;
8374            }
8375            if let Some(ref x) = self.final_rate {
8376                map.serialize_entry("final_rate", x)?;
8377            }
8378            if let Some(ref x) = self.adjust_pitch {
8379                map.serialize_entry("adjust_pitch", x)?;
8380            }
8381            map.end()
8382        }
8383    }
8384    impl<'de> Visitor<'de> for GameModVisitor<BarrelRollOsu> {
8385        type Value = DeserializedGameMod<'de, BarrelRollOsu>;
8386        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8387            f.write_str("BarrelRollOsu")
8388        }
8389        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8390            const FIELDS: &'static [&'static str] = &["spin_speed", "direction"];
8391            let mut unknown_key__ = None;
8392            let mut spin_speed = None;
8393            let mut direction = None;
8394            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8395                match key.as_str() {
8396                    "spin_speed" => spin_speed = Some(map.next_value()?),
8397                    "direction" => direction = Some(map.next_value()?),
8398                    _ => {
8399                        unknown_key__ = Some(key);
8400                        let _: IgnoredAny = map.next_value()?;
8401                    }
8402                }
8403            }
8404            let gamemod = BarrelRollOsu {
8405                spin_speed: spin_speed.unwrap_or_default(),
8406                direction: direction.unwrap_or_default(),
8407            };
8408            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8409        }
8410    }
8411    impl Serialize for BarrelRollOsu {
8412        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8413            let field_count =
8414                self.spin_speed.is_some() as usize + self.direction.is_some() as usize;
8415            let mut map = s.serialize_map(Some(field_count))?;
8416            if let Some(ref x) = self.spin_speed {
8417                map.serialize_entry("spin_speed", x)?;
8418            }
8419            if let Some(ref x) = self.direction {
8420                map.serialize_entry("direction", x)?;
8421            }
8422            map.end()
8423        }
8424    }
8425    impl<'de> Visitor<'de> for GameModVisitor<ApproachDifferentOsu> {
8426        type Value = DeserializedGameMod<'de, ApproachDifferentOsu>;
8427        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8428            f.write_str("ApproachDifferentOsu")
8429        }
8430        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8431            const FIELDS: &'static [&'static str] = &["scale", "style"];
8432            let mut unknown_key__ = None;
8433            let mut scale = None;
8434            let mut style = None;
8435            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8436                match key.as_str() {
8437                    "scale" => scale = Some(map.next_value()?),
8438                    "style" => style = Some(map.next_value()?),
8439                    _ => {
8440                        unknown_key__ = Some(key);
8441                        let _: IgnoredAny = map.next_value()?;
8442                    }
8443                }
8444            }
8445            let gamemod = ApproachDifferentOsu {
8446                scale: scale.unwrap_or_default(),
8447                style: style.unwrap_or_default(),
8448            };
8449            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8450        }
8451    }
8452    impl Serialize for ApproachDifferentOsu {
8453        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8454            let field_count = self.scale.is_some() as usize + self.style.is_some() as usize;
8455            let mut map = s.serialize_map(Some(field_count))?;
8456            if let Some(ref x) = self.scale {
8457                map.serialize_entry("scale", x)?;
8458            }
8459            if let Some(ref x) = self.style {
8460                map.serialize_entry("style", x)?;
8461            }
8462            map.end()
8463        }
8464    }
8465    impl<'de> Visitor<'de> for GameModVisitor<MutedOsu> {
8466        type Value = DeserializedGameMod<'de, MutedOsu>;
8467        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8468            f.write_str("MutedOsu")
8469        }
8470        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8471            const FIELDS: &'static [&'static str] = &[
8472                "inverse_muting",
8473                "enable_metronome",
8474                "mute_combo_count",
8475                "affects_hit_sounds",
8476            ];
8477            let mut unknown_key__ = None;
8478            let mut inverse_muting = None;
8479            let mut enable_metronome = None;
8480            let mut mute_combo_count = None;
8481            let mut affects_hit_sounds = None;
8482            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8483                match key.as_str() {
8484                    "inverse_muting" => inverse_muting = Some(map.next_value()?),
8485                    "enable_metronome" => enable_metronome = Some(map.next_value()?),
8486                    "mute_combo_count" => mute_combo_count = Some(map.next_value()?),
8487                    "affects_hit_sounds" => affects_hit_sounds = Some(map.next_value()?),
8488                    _ => {
8489                        unknown_key__ = Some(key);
8490                        let _: IgnoredAny = map.next_value()?;
8491                    }
8492                }
8493            }
8494            let gamemod = MutedOsu {
8495                inverse_muting: inverse_muting.unwrap_or_default(),
8496                enable_metronome: enable_metronome.unwrap_or_default(),
8497                mute_combo_count: mute_combo_count.unwrap_or_default(),
8498                affects_hit_sounds: affects_hit_sounds.unwrap_or_default(),
8499            };
8500            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8501        }
8502    }
8503    impl Serialize for MutedOsu {
8504        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8505            let field_count = self.inverse_muting.is_some() as usize
8506                + self.enable_metronome.is_some() as usize
8507                + self.mute_combo_count.is_some() as usize
8508                + self.affects_hit_sounds.is_some() as usize;
8509            let mut map = s.serialize_map(Some(field_count))?;
8510            if let Some(ref x) = self.inverse_muting {
8511                map.serialize_entry("inverse_muting", x)?;
8512            }
8513            if let Some(ref x) = self.enable_metronome {
8514                map.serialize_entry("enable_metronome", x)?;
8515            }
8516            if let Some(ref x) = self.mute_combo_count {
8517                map.serialize_entry("mute_combo_count", x)?;
8518            }
8519            if let Some(ref x) = self.affects_hit_sounds {
8520                map.serialize_entry("affects_hit_sounds", x)?;
8521            }
8522            map.end()
8523        }
8524    }
8525    impl<'de> Visitor<'de> for GameModVisitor<NoScopeOsu> {
8526        type Value = DeserializedGameMod<'de, NoScopeOsu>;
8527        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8528            f.write_str("NoScopeOsu")
8529        }
8530        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8531            const FIELDS: &'static [&'static str] = &["hidden_combo_count"];
8532            let mut unknown_key__ = None;
8533            let mut hidden_combo_count = None;
8534            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8535                match key.as_str() {
8536                    "hidden_combo_count" => hidden_combo_count = Some(map.next_value()?),
8537                    _ => {
8538                        unknown_key__ = Some(key);
8539                        let _: IgnoredAny = map.next_value()?;
8540                    }
8541                }
8542            }
8543            let gamemod = NoScopeOsu {
8544                hidden_combo_count: hidden_combo_count.unwrap_or_default(),
8545            };
8546            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8547        }
8548    }
8549    impl Serialize for NoScopeOsu {
8550        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8551            let field_count = self.hidden_combo_count.is_some() as usize;
8552            let mut map = s.serialize_map(Some(field_count))?;
8553            if let Some(ref x) = self.hidden_combo_count {
8554                map.serialize_entry("hidden_combo_count", x)?;
8555            }
8556            map.end()
8557        }
8558    }
8559    impl<'de> Visitor<'de> for GameModVisitor<MagnetisedOsu> {
8560        type Value = DeserializedGameMod<'de, MagnetisedOsu>;
8561        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8562            f.write_str("MagnetisedOsu")
8563        }
8564        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8565            const FIELDS: &'static [&'static str] = &["attraction_strength"];
8566            let mut unknown_key__ = None;
8567            let mut attraction_strength = None;
8568            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8569                match key.as_str() {
8570                    "attraction_strength" => attraction_strength = Some(map.next_value()?),
8571                    _ => {
8572                        unknown_key__ = Some(key);
8573                        let _: IgnoredAny = map.next_value()?;
8574                    }
8575                }
8576            }
8577            let gamemod = MagnetisedOsu {
8578                attraction_strength: attraction_strength.unwrap_or_default(),
8579            };
8580            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8581        }
8582    }
8583    impl Serialize for MagnetisedOsu {
8584        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8585            let field_count = self.attraction_strength.is_some() as usize;
8586            let mut map = s.serialize_map(Some(field_count))?;
8587            if let Some(ref x) = self.attraction_strength {
8588                map.serialize_entry("attraction_strength", x)?;
8589            }
8590            map.end()
8591        }
8592    }
8593    impl<'de> Visitor<'de> for GameModVisitor<RepelOsu> {
8594        type Value = DeserializedGameMod<'de, RepelOsu>;
8595        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8596            f.write_str("RepelOsu")
8597        }
8598        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8599            const FIELDS: &'static [&'static str] = &["repulsion_strength"];
8600            let mut unknown_key__ = None;
8601            let mut repulsion_strength = None;
8602            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8603                match key.as_str() {
8604                    "repulsion_strength" => repulsion_strength = Some(map.next_value()?),
8605                    _ => {
8606                        unknown_key__ = Some(key);
8607                        let _: IgnoredAny = map.next_value()?;
8608                    }
8609                }
8610            }
8611            let gamemod = RepelOsu {
8612                repulsion_strength: repulsion_strength.unwrap_or_default(),
8613            };
8614            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8615        }
8616    }
8617    impl Serialize for RepelOsu {
8618        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8619            let field_count = self.repulsion_strength.is_some() as usize;
8620            let mut map = s.serialize_map(Some(field_count))?;
8621            if let Some(ref x) = self.repulsion_strength {
8622                map.serialize_entry("repulsion_strength", x)?;
8623            }
8624            map.end()
8625        }
8626    }
8627    impl<'de> Visitor<'de> for GameModVisitor<AdaptiveSpeedOsu> {
8628        type Value = DeserializedGameMod<'de, AdaptiveSpeedOsu>;
8629        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8630            f.write_str("AdaptiveSpeedOsu")
8631        }
8632        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8633            const FIELDS: &'static [&'static str] = &["initial_rate", "adjust_pitch"];
8634            let mut unknown_key__ = None;
8635            let mut initial_rate = None;
8636            let mut adjust_pitch = None;
8637            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8638                match key.as_str() {
8639                    "initial_rate" => initial_rate = Some(map.next_value()?),
8640                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
8641                    _ => {
8642                        unknown_key__ = Some(key);
8643                        let _: IgnoredAny = map.next_value()?;
8644                    }
8645                }
8646            }
8647            let gamemod = AdaptiveSpeedOsu {
8648                initial_rate: initial_rate.unwrap_or_default(),
8649                adjust_pitch: adjust_pitch.unwrap_or_default(),
8650            };
8651            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8652        }
8653    }
8654    impl Serialize for AdaptiveSpeedOsu {
8655        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8656            let field_count =
8657                self.initial_rate.is_some() as usize + self.adjust_pitch.is_some() as usize;
8658            let mut map = s.serialize_map(Some(field_count))?;
8659            if let Some(ref x) = self.initial_rate {
8660                map.serialize_entry("initial_rate", x)?;
8661            }
8662            if let Some(ref x) = self.adjust_pitch {
8663                map.serialize_entry("adjust_pitch", x)?;
8664            }
8665            map.end()
8666        }
8667    }
8668    impl<'de> Visitor<'de> for GameModVisitor<FreezeFrameOsu> {
8669        type Value = DeserializedGameMod<'de, FreezeFrameOsu>;
8670        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8671            f.write_str("FreezeFrameOsu")
8672        }
8673        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8674            const FIELDS: &'static [&'static str] = &[];
8675            let mut unknown_key__ = None;
8676            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8677                match key.as_str() {
8678                    _ => {
8679                        unknown_key__ = Some(key);
8680                        let _: IgnoredAny = map.next_value()?;
8681                    }
8682                }
8683            }
8684            let gamemod = FreezeFrameOsu {};
8685            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8686        }
8687    }
8688    impl Serialize for FreezeFrameOsu {
8689        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8690            let field_count = 0;
8691            let map = s.serialize_map(Some(field_count))?;
8692            map.end()
8693        }
8694    }
8695    impl<'de> Visitor<'de> for GameModVisitor<BubblesOsu> {
8696        type Value = DeserializedGameMod<'de, BubblesOsu>;
8697        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8698            f.write_str("BubblesOsu")
8699        }
8700        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8701            const FIELDS: &'static [&'static str] = &[];
8702            let mut unknown_key__ = None;
8703            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8704                match key.as_str() {
8705                    _ => {
8706                        unknown_key__ = Some(key);
8707                        let _: IgnoredAny = map.next_value()?;
8708                    }
8709                }
8710            }
8711            let gamemod = BubblesOsu {};
8712            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8713        }
8714    }
8715    impl Serialize for BubblesOsu {
8716        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8717            let field_count = 0;
8718            let map = s.serialize_map(Some(field_count))?;
8719            map.end()
8720        }
8721    }
8722    impl<'de> Visitor<'de> for GameModVisitor<SynesthesiaOsu> {
8723        type Value = DeserializedGameMod<'de, SynesthesiaOsu>;
8724        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8725            f.write_str("SynesthesiaOsu")
8726        }
8727        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8728            const FIELDS: &'static [&'static str] = &[];
8729            let mut unknown_key__ = None;
8730            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8731                match key.as_str() {
8732                    _ => {
8733                        unknown_key__ = Some(key);
8734                        let _: IgnoredAny = map.next_value()?;
8735                    }
8736                }
8737            }
8738            let gamemod = SynesthesiaOsu {};
8739            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8740        }
8741    }
8742    impl Serialize for SynesthesiaOsu {
8743        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8744            let field_count = 0;
8745            let map = s.serialize_map(Some(field_count))?;
8746            map.end()
8747        }
8748    }
8749    impl<'de> Visitor<'de> for GameModVisitor<DepthOsu> {
8750        type Value = DeserializedGameMod<'de, DepthOsu>;
8751        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8752            f.write_str("DepthOsu")
8753        }
8754        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8755            const FIELDS: &'static [&'static str] = &["max_depth", "show_approach_circles"];
8756            let mut unknown_key__ = None;
8757            let mut max_depth = None;
8758            let mut show_approach_circles = None;
8759            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8760                match key.as_str() {
8761                    "max_depth" => max_depth = Some(map.next_value()?),
8762                    "show_approach_circles" => show_approach_circles = Some(map.next_value()?),
8763                    _ => {
8764                        unknown_key__ = Some(key);
8765                        let _: IgnoredAny = map.next_value()?;
8766                    }
8767                }
8768            }
8769            let gamemod = DepthOsu {
8770                max_depth: max_depth.unwrap_or_default(),
8771                show_approach_circles: show_approach_circles.unwrap_or_default(),
8772            };
8773            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8774        }
8775    }
8776    impl Serialize for DepthOsu {
8777        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8778            let field_count =
8779                self.max_depth.is_some() as usize + self.show_approach_circles.is_some() as usize;
8780            let mut map = s.serialize_map(Some(field_count))?;
8781            if let Some(ref x) = self.max_depth {
8782                map.serialize_entry("max_depth", x)?;
8783            }
8784            if let Some(ref x) = self.show_approach_circles {
8785                map.serialize_entry("show_approach_circles", x)?;
8786            }
8787            map.end()
8788        }
8789    }
8790    impl<'de> Visitor<'de> for GameModVisitor<BloomOsu> {
8791        type Value = DeserializedGameMod<'de, BloomOsu>;
8792        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8793            f.write_str("BloomOsu")
8794        }
8795        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8796            const FIELDS: &'static [&'static str] = &["max_size_combo_count", "max_cursor_size"];
8797            let mut unknown_key__ = None;
8798            let mut max_size_combo_count = None;
8799            let mut max_cursor_size = None;
8800            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8801                match key.as_str() {
8802                    "max_size_combo_count" => max_size_combo_count = Some(map.next_value()?),
8803                    "max_cursor_size" => max_cursor_size = Some(map.next_value()?),
8804                    _ => {
8805                        unknown_key__ = Some(key);
8806                        let _: IgnoredAny = map.next_value()?;
8807                    }
8808                }
8809            }
8810            let gamemod = BloomOsu {
8811                max_size_combo_count: max_size_combo_count.unwrap_or_default(),
8812                max_cursor_size: max_cursor_size.unwrap_or_default(),
8813            };
8814            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8815        }
8816    }
8817    impl Serialize for BloomOsu {
8818        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8819            let field_count = self.max_size_combo_count.is_some() as usize
8820                + self.max_cursor_size.is_some() as usize;
8821            let mut map = s.serialize_map(Some(field_count))?;
8822            if let Some(ref x) = self.max_size_combo_count {
8823                map.serialize_entry("max_size_combo_count", x)?;
8824            }
8825            if let Some(ref x) = self.max_cursor_size {
8826                map.serialize_entry("max_cursor_size", x)?;
8827            }
8828            map.end()
8829        }
8830    }
8831    impl<'de> Visitor<'de> for GameModVisitor<TouchDeviceOsu> {
8832        type Value = DeserializedGameMod<'de, TouchDeviceOsu>;
8833        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8834            f.write_str("TouchDeviceOsu")
8835        }
8836        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8837            const FIELDS: &'static [&'static str] = &[];
8838            let mut unknown_key__ = None;
8839            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8840                match key.as_str() {
8841                    _ => {
8842                        unknown_key__ = Some(key);
8843                        let _: IgnoredAny = map.next_value()?;
8844                    }
8845                }
8846            }
8847            let gamemod = TouchDeviceOsu {};
8848            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8849        }
8850    }
8851    impl Serialize for TouchDeviceOsu {
8852        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8853            let field_count = 0;
8854            let map = s.serialize_map(Some(field_count))?;
8855            map.end()
8856        }
8857    }
8858    impl<'de> Visitor<'de> for GameModVisitor<ScoreV2Osu> {
8859        type Value = DeserializedGameMod<'de, ScoreV2Osu>;
8860        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8861            f.write_str("ScoreV2Osu")
8862        }
8863        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8864            const FIELDS: &'static [&'static str] = &[];
8865            let mut unknown_key__ = None;
8866            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8867                match key.as_str() {
8868                    _ => {
8869                        unknown_key__ = Some(key);
8870                        let _: IgnoredAny = map.next_value()?;
8871                    }
8872                }
8873            }
8874            let gamemod = ScoreV2Osu {};
8875            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8876        }
8877    }
8878    impl Serialize for ScoreV2Osu {
8879        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8880            let field_count = 0;
8881            let map = s.serialize_map(Some(field_count))?;
8882            map.end()
8883        }
8884    }
8885    impl<'de> Visitor<'de> for GameModVisitor<EasyTaiko> {
8886        type Value = DeserializedGameMod<'de, EasyTaiko>;
8887        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8888            f.write_str("EasyTaiko")
8889        }
8890        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8891            const FIELDS: &'static [&'static str] = &[];
8892            let mut unknown_key__ = None;
8893            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8894                match key.as_str() {
8895                    _ => {
8896                        unknown_key__ = Some(key);
8897                        let _: IgnoredAny = map.next_value()?;
8898                    }
8899                }
8900            }
8901            let gamemod = EasyTaiko {};
8902            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8903        }
8904    }
8905    impl Serialize for EasyTaiko {
8906        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8907            let field_count = 0;
8908            let map = s.serialize_map(Some(field_count))?;
8909            map.end()
8910        }
8911    }
8912    impl<'de> Visitor<'de> for GameModVisitor<NoFailTaiko> {
8913        type Value = DeserializedGameMod<'de, NoFailTaiko>;
8914        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8915            f.write_str("NoFailTaiko")
8916        }
8917        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8918            const FIELDS: &'static [&'static str] = &[];
8919            let mut unknown_key__ = None;
8920            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8921                match key.as_str() {
8922                    _ => {
8923                        unknown_key__ = Some(key);
8924                        let _: IgnoredAny = map.next_value()?;
8925                    }
8926                }
8927            }
8928            let gamemod = NoFailTaiko {};
8929            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8930        }
8931    }
8932    impl Serialize for NoFailTaiko {
8933        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8934            let field_count = 0;
8935            let map = s.serialize_map(Some(field_count))?;
8936            map.end()
8937        }
8938    }
8939    impl<'de> Visitor<'de> for GameModVisitor<HalfTimeTaiko> {
8940        type Value = DeserializedGameMod<'de, HalfTimeTaiko>;
8941        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8942            f.write_str("HalfTimeTaiko")
8943        }
8944        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8945            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
8946            let mut unknown_key__ = None;
8947            let mut speed_change = None;
8948            let mut adjust_pitch = None;
8949            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8950                match key.as_str() {
8951                    "speed_change" => speed_change = Some(map.next_value()?),
8952                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
8953                    _ => {
8954                        unknown_key__ = Some(key);
8955                        let _: IgnoredAny = map.next_value()?;
8956                    }
8957                }
8958            }
8959            let gamemod = HalfTimeTaiko {
8960                speed_change: speed_change.unwrap_or_default(),
8961                adjust_pitch: adjust_pitch.unwrap_or_default(),
8962            };
8963            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
8964        }
8965    }
8966    impl Serialize for HalfTimeTaiko {
8967        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
8968            let field_count =
8969                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
8970            let mut map = s.serialize_map(Some(field_count))?;
8971            if let Some(ref x) = self.speed_change {
8972                map.serialize_entry("speed_change", x)?;
8973            }
8974            if let Some(ref x) = self.adjust_pitch {
8975                map.serialize_entry("adjust_pitch", x)?;
8976            }
8977            map.end()
8978        }
8979    }
8980    impl<'de> Visitor<'de> for GameModVisitor<DaycoreTaiko> {
8981        type Value = DeserializedGameMod<'de, DaycoreTaiko>;
8982        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
8983            f.write_str("DaycoreTaiko")
8984        }
8985        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
8986            const FIELDS: &'static [&'static str] = &["speed_change"];
8987            let mut unknown_key__ = None;
8988            let mut speed_change = None;
8989            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
8990                match key.as_str() {
8991                    "speed_change" => speed_change = Some(map.next_value()?),
8992                    _ => {
8993                        unknown_key__ = Some(key);
8994                        let _: IgnoredAny = map.next_value()?;
8995                    }
8996                }
8997            }
8998            let gamemod = DaycoreTaiko {
8999                speed_change: speed_change.unwrap_or_default(),
9000            };
9001            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9002        }
9003    }
9004    impl Serialize for DaycoreTaiko {
9005        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9006            let field_count = self.speed_change.is_some() as usize;
9007            let mut map = s.serialize_map(Some(field_count))?;
9008            if let Some(ref x) = self.speed_change {
9009                map.serialize_entry("speed_change", x)?;
9010            }
9011            map.end()
9012        }
9013    }
9014    impl<'de> Visitor<'de> for GameModVisitor<SimplifiedRhythmTaiko> {
9015        type Value = DeserializedGameMod<'de, SimplifiedRhythmTaiko>;
9016        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9017            f.write_str("SimplifiedRhythmTaiko")
9018        }
9019        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9020            const FIELDS: &'static [&'static str] = &[
9021                "one_third_conversion",
9022                "one_sixth_conversion",
9023                "one_eighth_conversion",
9024            ];
9025            let mut unknown_key__ = None;
9026            let mut one_third_conversion = None;
9027            let mut one_sixth_conversion = None;
9028            let mut one_eighth_conversion = None;
9029            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9030                match key.as_str() {
9031                    "one_third_conversion" => one_third_conversion = Some(map.next_value()?),
9032                    "one_sixth_conversion" => one_sixth_conversion = Some(map.next_value()?),
9033                    "one_eighth_conversion" => one_eighth_conversion = Some(map.next_value()?),
9034                    _ => {
9035                        unknown_key__ = Some(key);
9036                        let _: IgnoredAny = map.next_value()?;
9037                    }
9038                }
9039            }
9040            let gamemod = SimplifiedRhythmTaiko {
9041                one_third_conversion: one_third_conversion.unwrap_or_default(),
9042                one_sixth_conversion: one_sixth_conversion.unwrap_or_default(),
9043                one_eighth_conversion: one_eighth_conversion.unwrap_or_default(),
9044            };
9045            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9046        }
9047    }
9048    impl Serialize for SimplifiedRhythmTaiko {
9049        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9050            let field_count = self.one_third_conversion.is_some() as usize
9051                + self.one_sixth_conversion.is_some() as usize
9052                + self.one_eighth_conversion.is_some() as usize;
9053            let mut map = s.serialize_map(Some(field_count))?;
9054            if let Some(ref x) = self.one_third_conversion {
9055                map.serialize_entry("one_third_conversion", x)?;
9056            }
9057            if let Some(ref x) = self.one_sixth_conversion {
9058                map.serialize_entry("one_sixth_conversion", x)?;
9059            }
9060            if let Some(ref x) = self.one_eighth_conversion {
9061                map.serialize_entry("one_eighth_conversion", x)?;
9062            }
9063            map.end()
9064        }
9065    }
9066    impl<'de> Visitor<'de> for GameModVisitor<HardRockTaiko> {
9067        type Value = DeserializedGameMod<'de, HardRockTaiko>;
9068        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9069            f.write_str("HardRockTaiko")
9070        }
9071        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9072            const FIELDS: &'static [&'static str] = &[];
9073            let mut unknown_key__ = None;
9074            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9075                match key.as_str() {
9076                    _ => {
9077                        unknown_key__ = Some(key);
9078                        let _: IgnoredAny = map.next_value()?;
9079                    }
9080                }
9081            }
9082            let gamemod = HardRockTaiko {};
9083            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9084        }
9085    }
9086    impl Serialize for HardRockTaiko {
9087        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9088            let field_count = 0;
9089            let map = s.serialize_map(Some(field_count))?;
9090            map.end()
9091        }
9092    }
9093    impl<'de> Visitor<'de> for GameModVisitor<SuddenDeathTaiko> {
9094        type Value = DeserializedGameMod<'de, SuddenDeathTaiko>;
9095        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9096            f.write_str("SuddenDeathTaiko")
9097        }
9098        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9099            const FIELDS: &'static [&'static str] = &["restart"];
9100            let mut unknown_key__ = None;
9101            let mut restart = None;
9102            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9103                match key.as_str() {
9104                    "restart" => restart = Some(map.next_value()?),
9105                    _ => {
9106                        unknown_key__ = Some(key);
9107                        let _: IgnoredAny = map.next_value()?;
9108                    }
9109                }
9110            }
9111            let gamemod = SuddenDeathTaiko {
9112                restart: restart.unwrap_or_default(),
9113            };
9114            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9115        }
9116    }
9117    impl Serialize for SuddenDeathTaiko {
9118        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9119            let field_count = self.restart.is_some() as usize;
9120            let mut map = s.serialize_map(Some(field_count))?;
9121            if let Some(ref x) = self.restart {
9122                map.serialize_entry("restart", x)?;
9123            }
9124            map.end()
9125        }
9126    }
9127    impl<'de> Visitor<'de> for GameModVisitor<PerfectTaiko> {
9128        type Value = DeserializedGameMod<'de, PerfectTaiko>;
9129        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9130            f.write_str("PerfectTaiko")
9131        }
9132        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9133            const FIELDS: &'static [&'static str] = &["restart"];
9134            let mut unknown_key__ = None;
9135            let mut restart = None;
9136            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9137                match key.as_str() {
9138                    "restart" => restart = Some(map.next_value()?),
9139                    _ => {
9140                        unknown_key__ = Some(key);
9141                        let _: IgnoredAny = map.next_value()?;
9142                    }
9143                }
9144            }
9145            let gamemod = PerfectTaiko {
9146                restart: restart.unwrap_or_default(),
9147            };
9148            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9149        }
9150    }
9151    impl Serialize for PerfectTaiko {
9152        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9153            let field_count = self.restart.is_some() as usize;
9154            let mut map = s.serialize_map(Some(field_count))?;
9155            if let Some(ref x) = self.restart {
9156                map.serialize_entry("restart", x)?;
9157            }
9158            map.end()
9159        }
9160    }
9161    impl<'de> Visitor<'de> for GameModVisitor<DoubleTimeTaiko> {
9162        type Value = DeserializedGameMod<'de, DoubleTimeTaiko>;
9163        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9164            f.write_str("DoubleTimeTaiko")
9165        }
9166        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9167            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
9168            let mut unknown_key__ = None;
9169            let mut speed_change = None;
9170            let mut adjust_pitch = None;
9171            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9172                match key.as_str() {
9173                    "speed_change" => speed_change = Some(map.next_value()?),
9174                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
9175                    _ => {
9176                        unknown_key__ = Some(key);
9177                        let _: IgnoredAny = map.next_value()?;
9178                    }
9179                }
9180            }
9181            let gamemod = DoubleTimeTaiko {
9182                speed_change: speed_change.unwrap_or_default(),
9183                adjust_pitch: adjust_pitch.unwrap_or_default(),
9184            };
9185            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9186        }
9187    }
9188    impl Serialize for DoubleTimeTaiko {
9189        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9190            let field_count =
9191                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
9192            let mut map = s.serialize_map(Some(field_count))?;
9193            if let Some(ref x) = self.speed_change {
9194                map.serialize_entry("speed_change", x)?;
9195            }
9196            if let Some(ref x) = self.adjust_pitch {
9197                map.serialize_entry("adjust_pitch", x)?;
9198            }
9199            map.end()
9200        }
9201    }
9202    impl<'de> Visitor<'de> for GameModVisitor<NightcoreTaiko> {
9203        type Value = DeserializedGameMod<'de, NightcoreTaiko>;
9204        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9205            f.write_str("NightcoreTaiko")
9206        }
9207        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9208            const FIELDS: &'static [&'static str] = &["speed_change"];
9209            let mut unknown_key__ = None;
9210            let mut speed_change = None;
9211            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9212                match key.as_str() {
9213                    "speed_change" => speed_change = Some(map.next_value()?),
9214                    _ => {
9215                        unknown_key__ = Some(key);
9216                        let _: IgnoredAny = map.next_value()?;
9217                    }
9218                }
9219            }
9220            let gamemod = NightcoreTaiko {
9221                speed_change: speed_change.unwrap_or_default(),
9222            };
9223            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9224        }
9225    }
9226    impl Serialize for NightcoreTaiko {
9227        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9228            let field_count = self.speed_change.is_some() as usize;
9229            let mut map = s.serialize_map(Some(field_count))?;
9230            if let Some(ref x) = self.speed_change {
9231                map.serialize_entry("speed_change", x)?;
9232            }
9233            map.end()
9234        }
9235    }
9236    impl<'de> Visitor<'de> for GameModVisitor<HiddenTaiko> {
9237        type Value = DeserializedGameMod<'de, HiddenTaiko>;
9238        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9239            f.write_str("HiddenTaiko")
9240        }
9241        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9242            const FIELDS: &'static [&'static str] = &[];
9243            let mut unknown_key__ = None;
9244            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9245                match key.as_str() {
9246                    _ => {
9247                        unknown_key__ = Some(key);
9248                        let _: IgnoredAny = map.next_value()?;
9249                    }
9250                }
9251            }
9252            let gamemod = HiddenTaiko {};
9253            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9254        }
9255    }
9256    impl Serialize for HiddenTaiko {
9257        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9258            let field_count = 0;
9259            let map = s.serialize_map(Some(field_count))?;
9260            map.end()
9261        }
9262    }
9263    impl<'de> Visitor<'de> for GameModVisitor<FlashlightTaiko> {
9264        type Value = DeserializedGameMod<'de, FlashlightTaiko>;
9265        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9266            f.write_str("FlashlightTaiko")
9267        }
9268        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9269            const FIELDS: &'static [&'static str] = &["size_multiplier", "combo_based_size"];
9270            let mut unknown_key__ = None;
9271            let mut size_multiplier = None;
9272            let mut combo_based_size = None;
9273            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9274                match key.as_str() {
9275                    "size_multiplier" => size_multiplier = Some(map.next_value()?),
9276                    "combo_based_size" => combo_based_size = Some(map.next_value()?),
9277                    _ => {
9278                        unknown_key__ = Some(key);
9279                        let _: IgnoredAny = map.next_value()?;
9280                    }
9281                }
9282            }
9283            let gamemod = FlashlightTaiko {
9284                size_multiplier: size_multiplier.unwrap_or_default(),
9285                combo_based_size: combo_based_size.unwrap_or_default(),
9286            };
9287            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9288        }
9289    }
9290    impl Serialize for FlashlightTaiko {
9291        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9292            let field_count =
9293                self.size_multiplier.is_some() as usize + self.combo_based_size.is_some() as usize;
9294            let mut map = s.serialize_map(Some(field_count))?;
9295            if let Some(ref x) = self.size_multiplier {
9296                map.serialize_entry("size_multiplier", x)?;
9297            }
9298            if let Some(ref x) = self.combo_based_size {
9299                map.serialize_entry("combo_based_size", x)?;
9300            }
9301            map.end()
9302        }
9303    }
9304    impl<'de> Visitor<'de> for GameModVisitor<AccuracyChallengeTaiko> {
9305        type Value = DeserializedGameMod<'de, AccuracyChallengeTaiko>;
9306        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9307            f.write_str("AccuracyChallengeTaiko")
9308        }
9309        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9310            const FIELDS: &'static [&'static str] =
9311                &["minimum_accuracy", "accuracy_judge_mode", "restart"];
9312            let mut unknown_key__ = None;
9313            let mut minimum_accuracy = None;
9314            let mut accuracy_judge_mode = None;
9315            let mut restart = None;
9316            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9317                match key.as_str() {
9318                    "minimum_accuracy" => minimum_accuracy = Some(map.next_value()?),
9319                    "accuracy_judge_mode" => accuracy_judge_mode = Some(map.next_value()?),
9320                    "restart" => restart = Some(map.next_value()?),
9321                    _ => {
9322                        unknown_key__ = Some(key);
9323                        let _: IgnoredAny = map.next_value()?;
9324                    }
9325                }
9326            }
9327            let gamemod = AccuracyChallengeTaiko {
9328                minimum_accuracy: minimum_accuracy.unwrap_or_default(),
9329                accuracy_judge_mode: accuracy_judge_mode.unwrap_or_default(),
9330                restart: restart.unwrap_or_default(),
9331            };
9332            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9333        }
9334    }
9335    impl Serialize for AccuracyChallengeTaiko {
9336        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9337            let field_count = self.minimum_accuracy.is_some() as usize
9338                + self.accuracy_judge_mode.is_some() as usize
9339                + self.restart.is_some() as usize;
9340            let mut map = s.serialize_map(Some(field_count))?;
9341            if let Some(ref x) = self.minimum_accuracy {
9342                map.serialize_entry("minimum_accuracy", x)?;
9343            }
9344            if let Some(ref x) = self.accuracy_judge_mode {
9345                map.serialize_entry("accuracy_judge_mode", x)?;
9346            }
9347            if let Some(ref x) = self.restart {
9348                map.serialize_entry("restart", x)?;
9349            }
9350            map.end()
9351        }
9352    }
9353    impl<'de> Visitor<'de> for GameModVisitor<RandomTaiko> {
9354        type Value = DeserializedGameMod<'de, RandomTaiko>;
9355        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9356            f.write_str("RandomTaiko")
9357        }
9358        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9359            const FIELDS: &'static [&'static str] = &["seed"];
9360            let mut unknown_key__ = None;
9361            let mut seed = None;
9362            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9363                match key.as_str() {
9364                    "seed" => seed = Some(map.next_value()?),
9365                    _ => {
9366                        unknown_key__ = Some(key);
9367                        let _: IgnoredAny = map.next_value()?;
9368                    }
9369                }
9370            }
9371            let gamemod = RandomTaiko {
9372                seed: seed.unwrap_or_default(),
9373            };
9374            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9375        }
9376    }
9377    impl Serialize for RandomTaiko {
9378        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9379            let field_count = self.seed.is_some() as usize;
9380            let mut map = s.serialize_map(Some(field_count))?;
9381            if let Some(ref x) = self.seed {
9382                map.serialize_entry("seed", x)?;
9383            }
9384            map.end()
9385        }
9386    }
9387    impl<'de> Visitor<'de> for GameModVisitor<DifficultyAdjustTaiko> {
9388        type Value = DeserializedGameMod<'de, DifficultyAdjustTaiko>;
9389        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9390            f.write_str("DifficultyAdjustTaiko")
9391        }
9392        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9393            const FIELDS: &'static [&'static str] = &[
9394                "scroll_speed",
9395                "drain_rate",
9396                "overall_difficulty",
9397                "extended_limits",
9398            ];
9399            let mut unknown_key__ = None;
9400            let mut scroll_speed = None;
9401            let mut drain_rate = None;
9402            let mut overall_difficulty = None;
9403            let mut extended_limits = None;
9404            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9405                match key.as_str() {
9406                    "scroll_speed" => scroll_speed = Some(map.next_value()?),
9407                    "drain_rate" => drain_rate = Some(map.next_value()?),
9408                    "overall_difficulty" => overall_difficulty = Some(map.next_value()?),
9409                    "extended_limits" => extended_limits = Some(map.next_value()?),
9410                    _ => {
9411                        unknown_key__ = Some(key);
9412                        let _: IgnoredAny = map.next_value()?;
9413                    }
9414                }
9415            }
9416            let gamemod = DifficultyAdjustTaiko {
9417                scroll_speed: scroll_speed.unwrap_or_default(),
9418                drain_rate: drain_rate.unwrap_or_default(),
9419                overall_difficulty: overall_difficulty.unwrap_or_default(),
9420                extended_limits: extended_limits.unwrap_or_default(),
9421            };
9422            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9423        }
9424    }
9425    impl Serialize for DifficultyAdjustTaiko {
9426        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9427            let field_count = self.scroll_speed.is_some() as usize
9428                + self.drain_rate.is_some() as usize
9429                + self.overall_difficulty.is_some() as usize
9430                + self.extended_limits.is_some() as usize;
9431            let mut map = s.serialize_map(Some(field_count))?;
9432            if let Some(ref x) = self.scroll_speed {
9433                map.serialize_entry("scroll_speed", x)?;
9434            }
9435            if let Some(ref x) = self.drain_rate {
9436                map.serialize_entry("drain_rate", x)?;
9437            }
9438            if let Some(ref x) = self.overall_difficulty {
9439                map.serialize_entry("overall_difficulty", x)?;
9440            }
9441            if let Some(ref x) = self.extended_limits {
9442                map.serialize_entry("extended_limits", x)?;
9443            }
9444            map.end()
9445        }
9446    }
9447    impl<'de> Visitor<'de> for GameModVisitor<ClassicTaiko> {
9448        type Value = DeserializedGameMod<'de, ClassicTaiko>;
9449        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9450            f.write_str("ClassicTaiko")
9451        }
9452        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9453            const FIELDS: &'static [&'static str] = &[];
9454            let mut unknown_key__ = None;
9455            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9456                match key.as_str() {
9457                    _ => {
9458                        unknown_key__ = Some(key);
9459                        let _: IgnoredAny = map.next_value()?;
9460                    }
9461                }
9462            }
9463            let gamemod = ClassicTaiko {};
9464            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9465        }
9466    }
9467    impl Serialize for ClassicTaiko {
9468        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9469            let field_count = 0;
9470            let map = s.serialize_map(Some(field_count))?;
9471            map.end()
9472        }
9473    }
9474    impl<'de> Visitor<'de> for GameModVisitor<SwapTaiko> {
9475        type Value = DeserializedGameMod<'de, SwapTaiko>;
9476        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9477            f.write_str("SwapTaiko")
9478        }
9479        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9480            const FIELDS: &'static [&'static str] = &[];
9481            let mut unknown_key__ = None;
9482            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9483                match key.as_str() {
9484                    _ => {
9485                        unknown_key__ = Some(key);
9486                        let _: IgnoredAny = map.next_value()?;
9487                    }
9488                }
9489            }
9490            let gamemod = SwapTaiko {};
9491            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9492        }
9493    }
9494    impl Serialize for SwapTaiko {
9495        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9496            let field_count = 0;
9497            let map = s.serialize_map(Some(field_count))?;
9498            map.end()
9499        }
9500    }
9501    impl<'de> Visitor<'de> for GameModVisitor<SingleTapTaiko> {
9502        type Value = DeserializedGameMod<'de, SingleTapTaiko>;
9503        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9504            f.write_str("SingleTapTaiko")
9505        }
9506        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9507            const FIELDS: &'static [&'static str] = &[];
9508            let mut unknown_key__ = None;
9509            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9510                match key.as_str() {
9511                    _ => {
9512                        unknown_key__ = Some(key);
9513                        let _: IgnoredAny = map.next_value()?;
9514                    }
9515                }
9516            }
9517            let gamemod = SingleTapTaiko {};
9518            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9519        }
9520    }
9521    impl Serialize for SingleTapTaiko {
9522        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9523            let field_count = 0;
9524            let map = s.serialize_map(Some(field_count))?;
9525            map.end()
9526        }
9527    }
9528    impl<'de> Visitor<'de> for GameModVisitor<ConstantSpeedTaiko> {
9529        type Value = DeserializedGameMod<'de, ConstantSpeedTaiko>;
9530        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9531            f.write_str("ConstantSpeedTaiko")
9532        }
9533        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9534            const FIELDS: &'static [&'static str] = &[];
9535            let mut unknown_key__ = None;
9536            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9537                match key.as_str() {
9538                    _ => {
9539                        unknown_key__ = Some(key);
9540                        let _: IgnoredAny = map.next_value()?;
9541                    }
9542                }
9543            }
9544            let gamemod = ConstantSpeedTaiko {};
9545            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9546        }
9547    }
9548    impl Serialize for ConstantSpeedTaiko {
9549        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9550            let field_count = 0;
9551            let map = s.serialize_map(Some(field_count))?;
9552            map.end()
9553        }
9554    }
9555    impl<'de> Visitor<'de> for GameModVisitor<AutoplayTaiko> {
9556        type Value = DeserializedGameMod<'de, AutoplayTaiko>;
9557        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9558            f.write_str("AutoplayTaiko")
9559        }
9560        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9561            const FIELDS: &'static [&'static str] = &[];
9562            let mut unknown_key__ = None;
9563            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9564                match key.as_str() {
9565                    _ => {
9566                        unknown_key__ = Some(key);
9567                        let _: IgnoredAny = map.next_value()?;
9568                    }
9569                }
9570            }
9571            let gamemod = AutoplayTaiko {};
9572            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9573        }
9574    }
9575    impl Serialize for AutoplayTaiko {
9576        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9577            let field_count = 0;
9578            let map = s.serialize_map(Some(field_count))?;
9579            map.end()
9580        }
9581    }
9582    impl<'de> Visitor<'de> for GameModVisitor<CinemaTaiko> {
9583        type Value = DeserializedGameMod<'de, CinemaTaiko>;
9584        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9585            f.write_str("CinemaTaiko")
9586        }
9587        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9588            const FIELDS: &'static [&'static str] = &[];
9589            let mut unknown_key__ = None;
9590            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9591                match key.as_str() {
9592                    _ => {
9593                        unknown_key__ = Some(key);
9594                        let _: IgnoredAny = map.next_value()?;
9595                    }
9596                }
9597            }
9598            let gamemod = CinemaTaiko {};
9599            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9600        }
9601    }
9602    impl Serialize for CinemaTaiko {
9603        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9604            let field_count = 0;
9605            let map = s.serialize_map(Some(field_count))?;
9606            map.end()
9607        }
9608    }
9609    impl<'de> Visitor<'de> for GameModVisitor<RelaxTaiko> {
9610        type Value = DeserializedGameMod<'de, RelaxTaiko>;
9611        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9612            f.write_str("RelaxTaiko")
9613        }
9614        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9615            const FIELDS: &'static [&'static str] = &[];
9616            let mut unknown_key__ = None;
9617            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9618                match key.as_str() {
9619                    _ => {
9620                        unknown_key__ = Some(key);
9621                        let _: IgnoredAny = map.next_value()?;
9622                    }
9623                }
9624            }
9625            let gamemod = RelaxTaiko {};
9626            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9627        }
9628    }
9629    impl Serialize for RelaxTaiko {
9630        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9631            let field_count = 0;
9632            let map = s.serialize_map(Some(field_count))?;
9633            map.end()
9634        }
9635    }
9636    impl<'de> Visitor<'de> for GameModVisitor<WindUpTaiko> {
9637        type Value = DeserializedGameMod<'de, WindUpTaiko>;
9638        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9639            f.write_str("WindUpTaiko")
9640        }
9641        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9642            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
9643            let mut unknown_key__ = None;
9644            let mut initial_rate = None;
9645            let mut final_rate = None;
9646            let mut adjust_pitch = None;
9647            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9648                match key.as_str() {
9649                    "initial_rate" => initial_rate = Some(map.next_value()?),
9650                    "final_rate" => final_rate = Some(map.next_value()?),
9651                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
9652                    _ => {
9653                        unknown_key__ = Some(key);
9654                        let _: IgnoredAny = map.next_value()?;
9655                    }
9656                }
9657            }
9658            let gamemod = WindUpTaiko {
9659                initial_rate: initial_rate.unwrap_or_default(),
9660                final_rate: final_rate.unwrap_or_default(),
9661                adjust_pitch: adjust_pitch.unwrap_or_default(),
9662            };
9663            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9664        }
9665    }
9666    impl Serialize for WindUpTaiko {
9667        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9668            let field_count = self.initial_rate.is_some() as usize
9669                + self.final_rate.is_some() as usize
9670                + self.adjust_pitch.is_some() as usize;
9671            let mut map = s.serialize_map(Some(field_count))?;
9672            if let Some(ref x) = self.initial_rate {
9673                map.serialize_entry("initial_rate", x)?;
9674            }
9675            if let Some(ref x) = self.final_rate {
9676                map.serialize_entry("final_rate", x)?;
9677            }
9678            if let Some(ref x) = self.adjust_pitch {
9679                map.serialize_entry("adjust_pitch", x)?;
9680            }
9681            map.end()
9682        }
9683    }
9684    impl<'de> Visitor<'de> for GameModVisitor<WindDownTaiko> {
9685        type Value = DeserializedGameMod<'de, WindDownTaiko>;
9686        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9687            f.write_str("WindDownTaiko")
9688        }
9689        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9690            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
9691            let mut unknown_key__ = None;
9692            let mut initial_rate = None;
9693            let mut final_rate = None;
9694            let mut adjust_pitch = None;
9695            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9696                match key.as_str() {
9697                    "initial_rate" => initial_rate = Some(map.next_value()?),
9698                    "final_rate" => final_rate = Some(map.next_value()?),
9699                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
9700                    _ => {
9701                        unknown_key__ = Some(key);
9702                        let _: IgnoredAny = map.next_value()?;
9703                    }
9704                }
9705            }
9706            let gamemod = WindDownTaiko {
9707                initial_rate: initial_rate.unwrap_or_default(),
9708                final_rate: final_rate.unwrap_or_default(),
9709                adjust_pitch: adjust_pitch.unwrap_or_default(),
9710            };
9711            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9712        }
9713    }
9714    impl Serialize for WindDownTaiko {
9715        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9716            let field_count = self.initial_rate.is_some() as usize
9717                + self.final_rate.is_some() as usize
9718                + self.adjust_pitch.is_some() as usize;
9719            let mut map = s.serialize_map(Some(field_count))?;
9720            if let Some(ref x) = self.initial_rate {
9721                map.serialize_entry("initial_rate", x)?;
9722            }
9723            if let Some(ref x) = self.final_rate {
9724                map.serialize_entry("final_rate", x)?;
9725            }
9726            if let Some(ref x) = self.adjust_pitch {
9727                map.serialize_entry("adjust_pitch", x)?;
9728            }
9729            map.end()
9730        }
9731    }
9732    impl<'de> Visitor<'de> for GameModVisitor<MutedTaiko> {
9733        type Value = DeserializedGameMod<'de, MutedTaiko>;
9734        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9735            f.write_str("MutedTaiko")
9736        }
9737        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9738            const FIELDS: &'static [&'static str] = &[
9739                "inverse_muting",
9740                "enable_metronome",
9741                "mute_combo_count",
9742                "affects_hit_sounds",
9743            ];
9744            let mut unknown_key__ = None;
9745            let mut inverse_muting = None;
9746            let mut enable_metronome = None;
9747            let mut mute_combo_count = None;
9748            let mut affects_hit_sounds = None;
9749            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9750                match key.as_str() {
9751                    "inverse_muting" => inverse_muting = Some(map.next_value()?),
9752                    "enable_metronome" => enable_metronome = Some(map.next_value()?),
9753                    "mute_combo_count" => mute_combo_count = Some(map.next_value()?),
9754                    "affects_hit_sounds" => affects_hit_sounds = Some(map.next_value()?),
9755                    _ => {
9756                        unknown_key__ = Some(key);
9757                        let _: IgnoredAny = map.next_value()?;
9758                    }
9759                }
9760            }
9761            let gamemod = MutedTaiko {
9762                inverse_muting: inverse_muting.unwrap_or_default(),
9763                enable_metronome: enable_metronome.unwrap_or_default(),
9764                mute_combo_count: mute_combo_count.unwrap_or_default(),
9765                affects_hit_sounds: affects_hit_sounds.unwrap_or_default(),
9766            };
9767            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9768        }
9769    }
9770    impl Serialize for MutedTaiko {
9771        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9772            let field_count = self.inverse_muting.is_some() as usize
9773                + self.enable_metronome.is_some() as usize
9774                + self.mute_combo_count.is_some() as usize
9775                + self.affects_hit_sounds.is_some() as usize;
9776            let mut map = s.serialize_map(Some(field_count))?;
9777            if let Some(ref x) = self.inverse_muting {
9778                map.serialize_entry("inverse_muting", x)?;
9779            }
9780            if let Some(ref x) = self.enable_metronome {
9781                map.serialize_entry("enable_metronome", x)?;
9782            }
9783            if let Some(ref x) = self.mute_combo_count {
9784                map.serialize_entry("mute_combo_count", x)?;
9785            }
9786            if let Some(ref x) = self.affects_hit_sounds {
9787                map.serialize_entry("affects_hit_sounds", x)?;
9788            }
9789            map.end()
9790        }
9791    }
9792    impl<'de> Visitor<'de> for GameModVisitor<AdaptiveSpeedTaiko> {
9793        type Value = DeserializedGameMod<'de, AdaptiveSpeedTaiko>;
9794        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9795            f.write_str("AdaptiveSpeedTaiko")
9796        }
9797        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9798            const FIELDS: &'static [&'static str] = &["initial_rate", "adjust_pitch"];
9799            let mut unknown_key__ = None;
9800            let mut initial_rate = None;
9801            let mut adjust_pitch = None;
9802            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9803                match key.as_str() {
9804                    "initial_rate" => initial_rate = Some(map.next_value()?),
9805                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
9806                    _ => {
9807                        unknown_key__ = Some(key);
9808                        let _: IgnoredAny = map.next_value()?;
9809                    }
9810                }
9811            }
9812            let gamemod = AdaptiveSpeedTaiko {
9813                initial_rate: initial_rate.unwrap_or_default(),
9814                adjust_pitch: adjust_pitch.unwrap_or_default(),
9815            };
9816            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9817        }
9818    }
9819    impl Serialize for AdaptiveSpeedTaiko {
9820        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9821            let field_count =
9822                self.initial_rate.is_some() as usize + self.adjust_pitch.is_some() as usize;
9823            let mut map = s.serialize_map(Some(field_count))?;
9824            if let Some(ref x) = self.initial_rate {
9825                map.serialize_entry("initial_rate", x)?;
9826            }
9827            if let Some(ref x) = self.adjust_pitch {
9828                map.serialize_entry("adjust_pitch", x)?;
9829            }
9830            map.end()
9831        }
9832    }
9833    impl<'de> Visitor<'de> for GameModVisitor<ScoreV2Taiko> {
9834        type Value = DeserializedGameMod<'de, ScoreV2Taiko>;
9835        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9836            f.write_str("ScoreV2Taiko")
9837        }
9838        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9839            const FIELDS: &'static [&'static str] = &[];
9840            let mut unknown_key__ = None;
9841            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9842                match key.as_str() {
9843                    _ => {
9844                        unknown_key__ = Some(key);
9845                        let _: IgnoredAny = map.next_value()?;
9846                    }
9847                }
9848            }
9849            let gamemod = ScoreV2Taiko {};
9850            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9851        }
9852    }
9853    impl Serialize for ScoreV2Taiko {
9854        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9855            let field_count = 0;
9856            let map = s.serialize_map(Some(field_count))?;
9857            map.end()
9858        }
9859    }
9860    impl<'de> Visitor<'de> for GameModVisitor<EasyCatch> {
9861        type Value = DeserializedGameMod<'de, EasyCatch>;
9862        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9863            f.write_str("EasyCatch")
9864        }
9865        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9866            const FIELDS: &'static [&'static str] = &["retries"];
9867            let mut unknown_key__ = None;
9868            let mut retries = None;
9869            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9870                match key.as_str() {
9871                    "retries" => retries = Some(map.next_value()?),
9872                    _ => {
9873                        unknown_key__ = Some(key);
9874                        let _: IgnoredAny = map.next_value()?;
9875                    }
9876                }
9877            }
9878            let gamemod = EasyCatch {
9879                retries: retries.unwrap_or_default(),
9880            };
9881            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9882        }
9883    }
9884    impl Serialize for EasyCatch {
9885        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9886            let field_count = self.retries.is_some() as usize;
9887            let mut map = s.serialize_map(Some(field_count))?;
9888            if let Some(ref x) = self.retries {
9889                map.serialize_entry("retries", x)?;
9890            }
9891            map.end()
9892        }
9893    }
9894    impl<'de> Visitor<'de> for GameModVisitor<NoFailCatch> {
9895        type Value = DeserializedGameMod<'de, NoFailCatch>;
9896        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9897            f.write_str("NoFailCatch")
9898        }
9899        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9900            const FIELDS: &'static [&'static str] = &[];
9901            let mut unknown_key__ = None;
9902            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9903                match key.as_str() {
9904                    _ => {
9905                        unknown_key__ = Some(key);
9906                        let _: IgnoredAny = map.next_value()?;
9907                    }
9908                }
9909            }
9910            let gamemod = NoFailCatch {};
9911            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9912        }
9913    }
9914    impl Serialize for NoFailCatch {
9915        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9916            let field_count = 0;
9917            let map = s.serialize_map(Some(field_count))?;
9918            map.end()
9919        }
9920    }
9921    impl<'de> Visitor<'de> for GameModVisitor<HalfTimeCatch> {
9922        type Value = DeserializedGameMod<'de, HalfTimeCatch>;
9923        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9924            f.write_str("HalfTimeCatch")
9925        }
9926        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9927            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
9928            let mut unknown_key__ = None;
9929            let mut speed_change = None;
9930            let mut adjust_pitch = None;
9931            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9932                match key.as_str() {
9933                    "speed_change" => speed_change = Some(map.next_value()?),
9934                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
9935                    _ => {
9936                        unknown_key__ = Some(key);
9937                        let _: IgnoredAny = map.next_value()?;
9938                    }
9939                }
9940            }
9941            let gamemod = HalfTimeCatch {
9942                speed_change: speed_change.unwrap_or_default(),
9943                adjust_pitch: adjust_pitch.unwrap_or_default(),
9944            };
9945            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9946        }
9947    }
9948    impl Serialize for HalfTimeCatch {
9949        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9950            let field_count =
9951                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
9952            let mut map = s.serialize_map(Some(field_count))?;
9953            if let Some(ref x) = self.speed_change {
9954                map.serialize_entry("speed_change", x)?;
9955            }
9956            if let Some(ref x) = self.adjust_pitch {
9957                map.serialize_entry("adjust_pitch", x)?;
9958            }
9959            map.end()
9960        }
9961    }
9962    impl<'de> Visitor<'de> for GameModVisitor<DaycoreCatch> {
9963        type Value = DeserializedGameMod<'de, DaycoreCatch>;
9964        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9965            f.write_str("DaycoreCatch")
9966        }
9967        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
9968            const FIELDS: &'static [&'static str] = &["speed_change"];
9969            let mut unknown_key__ = None;
9970            let mut speed_change = None;
9971            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
9972                match key.as_str() {
9973                    "speed_change" => speed_change = Some(map.next_value()?),
9974                    _ => {
9975                        unknown_key__ = Some(key);
9976                        let _: IgnoredAny = map.next_value()?;
9977                    }
9978                }
9979            }
9980            let gamemod = DaycoreCatch {
9981                speed_change: speed_change.unwrap_or_default(),
9982            };
9983            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
9984        }
9985    }
9986    impl Serialize for DaycoreCatch {
9987        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
9988            let field_count = self.speed_change.is_some() as usize;
9989            let mut map = s.serialize_map(Some(field_count))?;
9990            if let Some(ref x) = self.speed_change {
9991                map.serialize_entry("speed_change", x)?;
9992            }
9993            map.end()
9994        }
9995    }
9996    impl<'de> Visitor<'de> for GameModVisitor<HardRockCatch> {
9997        type Value = DeserializedGameMod<'de, HardRockCatch>;
9998        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
9999            f.write_str("HardRockCatch")
10000        }
10001        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10002            const FIELDS: &'static [&'static str] = &[];
10003            let mut unknown_key__ = None;
10004            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10005                match key.as_str() {
10006                    _ => {
10007                        unknown_key__ = Some(key);
10008                        let _: IgnoredAny = map.next_value()?;
10009                    }
10010                }
10011            }
10012            let gamemod = HardRockCatch {};
10013            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10014        }
10015    }
10016    impl Serialize for HardRockCatch {
10017        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10018            let field_count = 0;
10019            let map = s.serialize_map(Some(field_count))?;
10020            map.end()
10021        }
10022    }
10023    impl<'de> Visitor<'de> for GameModVisitor<SuddenDeathCatch> {
10024        type Value = DeserializedGameMod<'de, SuddenDeathCatch>;
10025        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10026            f.write_str("SuddenDeathCatch")
10027        }
10028        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10029            const FIELDS: &'static [&'static str] = &["restart"];
10030            let mut unknown_key__ = None;
10031            let mut restart = None;
10032            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10033                match key.as_str() {
10034                    "restart" => restart = Some(map.next_value()?),
10035                    _ => {
10036                        unknown_key__ = Some(key);
10037                        let _: IgnoredAny = map.next_value()?;
10038                    }
10039                }
10040            }
10041            let gamemod = SuddenDeathCatch {
10042                restart: restart.unwrap_or_default(),
10043            };
10044            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10045        }
10046    }
10047    impl Serialize for SuddenDeathCatch {
10048        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10049            let field_count = self.restart.is_some() as usize;
10050            let mut map = s.serialize_map(Some(field_count))?;
10051            if let Some(ref x) = self.restart {
10052                map.serialize_entry("restart", x)?;
10053            }
10054            map.end()
10055        }
10056    }
10057    impl<'de> Visitor<'de> for GameModVisitor<PerfectCatch> {
10058        type Value = DeserializedGameMod<'de, PerfectCatch>;
10059        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10060            f.write_str("PerfectCatch")
10061        }
10062        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10063            const FIELDS: &'static [&'static str] = &["restart"];
10064            let mut unknown_key__ = None;
10065            let mut restart = None;
10066            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10067                match key.as_str() {
10068                    "restart" => restart = Some(map.next_value()?),
10069                    _ => {
10070                        unknown_key__ = Some(key);
10071                        let _: IgnoredAny = map.next_value()?;
10072                    }
10073                }
10074            }
10075            let gamemod = PerfectCatch {
10076                restart: restart.unwrap_or_default(),
10077            };
10078            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10079        }
10080    }
10081    impl Serialize for PerfectCatch {
10082        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10083            let field_count = self.restart.is_some() as usize;
10084            let mut map = s.serialize_map(Some(field_count))?;
10085            if let Some(ref x) = self.restart {
10086                map.serialize_entry("restart", x)?;
10087            }
10088            map.end()
10089        }
10090    }
10091    impl<'de> Visitor<'de> for GameModVisitor<DoubleTimeCatch> {
10092        type Value = DeserializedGameMod<'de, DoubleTimeCatch>;
10093        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10094            f.write_str("DoubleTimeCatch")
10095        }
10096        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10097            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
10098            let mut unknown_key__ = None;
10099            let mut speed_change = None;
10100            let mut adjust_pitch = None;
10101            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10102                match key.as_str() {
10103                    "speed_change" => speed_change = Some(map.next_value()?),
10104                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
10105                    _ => {
10106                        unknown_key__ = Some(key);
10107                        let _: IgnoredAny = map.next_value()?;
10108                    }
10109                }
10110            }
10111            let gamemod = DoubleTimeCatch {
10112                speed_change: speed_change.unwrap_or_default(),
10113                adjust_pitch: adjust_pitch.unwrap_or_default(),
10114            };
10115            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10116        }
10117    }
10118    impl Serialize for DoubleTimeCatch {
10119        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10120            let field_count =
10121                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
10122            let mut map = s.serialize_map(Some(field_count))?;
10123            if let Some(ref x) = self.speed_change {
10124                map.serialize_entry("speed_change", x)?;
10125            }
10126            if let Some(ref x) = self.adjust_pitch {
10127                map.serialize_entry("adjust_pitch", x)?;
10128            }
10129            map.end()
10130        }
10131    }
10132    impl<'de> Visitor<'de> for GameModVisitor<NightcoreCatch> {
10133        type Value = DeserializedGameMod<'de, NightcoreCatch>;
10134        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10135            f.write_str("NightcoreCatch")
10136        }
10137        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10138            const FIELDS: &'static [&'static str] = &["speed_change"];
10139            let mut unknown_key__ = None;
10140            let mut speed_change = None;
10141            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10142                match key.as_str() {
10143                    "speed_change" => speed_change = Some(map.next_value()?),
10144                    _ => {
10145                        unknown_key__ = Some(key);
10146                        let _: IgnoredAny = map.next_value()?;
10147                    }
10148                }
10149            }
10150            let gamemod = NightcoreCatch {
10151                speed_change: speed_change.unwrap_or_default(),
10152            };
10153            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10154        }
10155    }
10156    impl Serialize for NightcoreCatch {
10157        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10158            let field_count = self.speed_change.is_some() as usize;
10159            let mut map = s.serialize_map(Some(field_count))?;
10160            if let Some(ref x) = self.speed_change {
10161                map.serialize_entry("speed_change", x)?;
10162            }
10163            map.end()
10164        }
10165    }
10166    impl<'de> Visitor<'de> for GameModVisitor<HiddenCatch> {
10167        type Value = DeserializedGameMod<'de, HiddenCatch>;
10168        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10169            f.write_str("HiddenCatch")
10170        }
10171        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10172            const FIELDS: &'static [&'static str] = &[];
10173            let mut unknown_key__ = None;
10174            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10175                match key.as_str() {
10176                    _ => {
10177                        unknown_key__ = Some(key);
10178                        let _: IgnoredAny = map.next_value()?;
10179                    }
10180                }
10181            }
10182            let gamemod = HiddenCatch {};
10183            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10184        }
10185    }
10186    impl Serialize for HiddenCatch {
10187        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10188            let field_count = 0;
10189            let map = s.serialize_map(Some(field_count))?;
10190            map.end()
10191        }
10192    }
10193    impl<'de> Visitor<'de> for GameModVisitor<FlashlightCatch> {
10194        type Value = DeserializedGameMod<'de, FlashlightCatch>;
10195        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10196            f.write_str("FlashlightCatch")
10197        }
10198        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10199            const FIELDS: &'static [&'static str] = &["size_multiplier", "combo_based_size"];
10200            let mut unknown_key__ = None;
10201            let mut size_multiplier = None;
10202            let mut combo_based_size = None;
10203            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10204                match key.as_str() {
10205                    "size_multiplier" => size_multiplier = Some(map.next_value()?),
10206                    "combo_based_size" => combo_based_size = Some(map.next_value()?),
10207                    _ => {
10208                        unknown_key__ = Some(key);
10209                        let _: IgnoredAny = map.next_value()?;
10210                    }
10211                }
10212            }
10213            let gamemod = FlashlightCatch {
10214                size_multiplier: size_multiplier.unwrap_or_default(),
10215                combo_based_size: combo_based_size.unwrap_or_default(),
10216            };
10217            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10218        }
10219    }
10220    impl Serialize for FlashlightCatch {
10221        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10222            let field_count =
10223                self.size_multiplier.is_some() as usize + self.combo_based_size.is_some() as usize;
10224            let mut map = s.serialize_map(Some(field_count))?;
10225            if let Some(ref x) = self.size_multiplier {
10226                map.serialize_entry("size_multiplier", x)?;
10227            }
10228            if let Some(ref x) = self.combo_based_size {
10229                map.serialize_entry("combo_based_size", x)?;
10230            }
10231            map.end()
10232        }
10233    }
10234    impl<'de> Visitor<'de> for GameModVisitor<AccuracyChallengeCatch> {
10235        type Value = DeserializedGameMod<'de, AccuracyChallengeCatch>;
10236        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10237            f.write_str("AccuracyChallengeCatch")
10238        }
10239        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10240            const FIELDS: &'static [&'static str] =
10241                &["minimum_accuracy", "accuracy_judge_mode", "restart"];
10242            let mut unknown_key__ = None;
10243            let mut minimum_accuracy = None;
10244            let mut accuracy_judge_mode = None;
10245            let mut restart = None;
10246            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10247                match key.as_str() {
10248                    "minimum_accuracy" => minimum_accuracy = Some(map.next_value()?),
10249                    "accuracy_judge_mode" => accuracy_judge_mode = Some(map.next_value()?),
10250                    "restart" => restart = Some(map.next_value()?),
10251                    _ => {
10252                        unknown_key__ = Some(key);
10253                        let _: IgnoredAny = map.next_value()?;
10254                    }
10255                }
10256            }
10257            let gamemod = AccuracyChallengeCatch {
10258                minimum_accuracy: minimum_accuracy.unwrap_or_default(),
10259                accuracy_judge_mode: accuracy_judge_mode.unwrap_or_default(),
10260                restart: restart.unwrap_or_default(),
10261            };
10262            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10263        }
10264    }
10265    impl Serialize for AccuracyChallengeCatch {
10266        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10267            let field_count = self.minimum_accuracy.is_some() as usize
10268                + self.accuracy_judge_mode.is_some() as usize
10269                + self.restart.is_some() as usize;
10270            let mut map = s.serialize_map(Some(field_count))?;
10271            if let Some(ref x) = self.minimum_accuracy {
10272                map.serialize_entry("minimum_accuracy", x)?;
10273            }
10274            if let Some(ref x) = self.accuracy_judge_mode {
10275                map.serialize_entry("accuracy_judge_mode", x)?;
10276            }
10277            if let Some(ref x) = self.restart {
10278                map.serialize_entry("restart", x)?;
10279            }
10280            map.end()
10281        }
10282    }
10283    impl<'de> Visitor<'de> for GameModVisitor<DifficultyAdjustCatch> {
10284        type Value = DeserializedGameMod<'de, DifficultyAdjustCatch>;
10285        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10286            f.write_str("DifficultyAdjustCatch")
10287        }
10288        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10289            const FIELDS: &'static [&'static str] = &[
10290                "circle_size",
10291                "approach_rate",
10292                "hard_rock_offsets",
10293                "drain_rate",
10294                "overall_difficulty",
10295                "extended_limits",
10296            ];
10297            let mut unknown_key__ = None;
10298            let mut circle_size = None;
10299            let mut approach_rate = None;
10300            let mut hard_rock_offsets = None;
10301            let mut drain_rate = None;
10302            let mut overall_difficulty = None;
10303            let mut extended_limits = None;
10304            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10305                match key.as_str() {
10306                    "circle_size" => circle_size = Some(map.next_value()?),
10307                    "approach_rate" => approach_rate = Some(map.next_value()?),
10308                    "hard_rock_offsets" => hard_rock_offsets = Some(map.next_value()?),
10309                    "drain_rate" => drain_rate = Some(map.next_value()?),
10310                    "overall_difficulty" => overall_difficulty = Some(map.next_value()?),
10311                    "extended_limits" => extended_limits = Some(map.next_value()?),
10312                    _ => {
10313                        unknown_key__ = Some(key);
10314                        let _: IgnoredAny = map.next_value()?;
10315                    }
10316                }
10317            }
10318            let gamemod = DifficultyAdjustCatch {
10319                circle_size: circle_size.unwrap_or_default(),
10320                approach_rate: approach_rate.unwrap_or_default(),
10321                hard_rock_offsets: hard_rock_offsets.unwrap_or_default(),
10322                drain_rate: drain_rate.unwrap_or_default(),
10323                overall_difficulty: overall_difficulty.unwrap_or_default(),
10324                extended_limits: extended_limits.unwrap_or_default(),
10325            };
10326            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10327        }
10328    }
10329    impl Serialize for DifficultyAdjustCatch {
10330        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10331            let field_count = self.circle_size.is_some() as usize
10332                + self.approach_rate.is_some() as usize
10333                + self.hard_rock_offsets.is_some() as usize
10334                + self.drain_rate.is_some() as usize
10335                + self.overall_difficulty.is_some() as usize
10336                + self.extended_limits.is_some() as usize;
10337            let mut map = s.serialize_map(Some(field_count))?;
10338            if let Some(ref x) = self.circle_size {
10339                map.serialize_entry("circle_size", x)?;
10340            }
10341            if let Some(ref x) = self.approach_rate {
10342                map.serialize_entry("approach_rate", x)?;
10343            }
10344            if let Some(ref x) = self.hard_rock_offsets {
10345                map.serialize_entry("hard_rock_offsets", x)?;
10346            }
10347            if let Some(ref x) = self.drain_rate {
10348                map.serialize_entry("drain_rate", x)?;
10349            }
10350            if let Some(ref x) = self.overall_difficulty {
10351                map.serialize_entry("overall_difficulty", x)?;
10352            }
10353            if let Some(ref x) = self.extended_limits {
10354                map.serialize_entry("extended_limits", x)?;
10355            }
10356            map.end()
10357        }
10358    }
10359    impl<'de> Visitor<'de> for GameModVisitor<ClassicCatch> {
10360        type Value = DeserializedGameMod<'de, ClassicCatch>;
10361        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10362            f.write_str("ClassicCatch")
10363        }
10364        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10365            const FIELDS: &'static [&'static str] = &[];
10366            let mut unknown_key__ = None;
10367            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10368                match key.as_str() {
10369                    _ => {
10370                        unknown_key__ = Some(key);
10371                        let _: IgnoredAny = map.next_value()?;
10372                    }
10373                }
10374            }
10375            let gamemod = ClassicCatch {};
10376            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10377        }
10378    }
10379    impl Serialize for ClassicCatch {
10380        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10381            let field_count = 0;
10382            let map = s.serialize_map(Some(field_count))?;
10383            map.end()
10384        }
10385    }
10386    impl<'de> Visitor<'de> for GameModVisitor<MirrorCatch> {
10387        type Value = DeserializedGameMod<'de, MirrorCatch>;
10388        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10389            f.write_str("MirrorCatch")
10390        }
10391        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10392            const FIELDS: &'static [&'static str] = &[];
10393            let mut unknown_key__ = None;
10394            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10395                match key.as_str() {
10396                    _ => {
10397                        unknown_key__ = Some(key);
10398                        let _: IgnoredAny = map.next_value()?;
10399                    }
10400                }
10401            }
10402            let gamemod = MirrorCatch {};
10403            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10404        }
10405    }
10406    impl Serialize for MirrorCatch {
10407        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10408            let field_count = 0;
10409            let map = s.serialize_map(Some(field_count))?;
10410            map.end()
10411        }
10412    }
10413    impl<'de> Visitor<'de> for GameModVisitor<AutoplayCatch> {
10414        type Value = DeserializedGameMod<'de, AutoplayCatch>;
10415        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10416            f.write_str("AutoplayCatch")
10417        }
10418        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10419            const FIELDS: &'static [&'static str] = &[];
10420            let mut unknown_key__ = None;
10421            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10422                match key.as_str() {
10423                    _ => {
10424                        unknown_key__ = Some(key);
10425                        let _: IgnoredAny = map.next_value()?;
10426                    }
10427                }
10428            }
10429            let gamemod = AutoplayCatch {};
10430            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10431        }
10432    }
10433    impl Serialize for AutoplayCatch {
10434        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10435            let field_count = 0;
10436            let map = s.serialize_map(Some(field_count))?;
10437            map.end()
10438        }
10439    }
10440    impl<'de> Visitor<'de> for GameModVisitor<CinemaCatch> {
10441        type Value = DeserializedGameMod<'de, CinemaCatch>;
10442        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10443            f.write_str("CinemaCatch")
10444        }
10445        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10446            const FIELDS: &'static [&'static str] = &[];
10447            let mut unknown_key__ = None;
10448            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10449                match key.as_str() {
10450                    _ => {
10451                        unknown_key__ = Some(key);
10452                        let _: IgnoredAny = map.next_value()?;
10453                    }
10454                }
10455            }
10456            let gamemod = CinemaCatch {};
10457            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10458        }
10459    }
10460    impl Serialize for CinemaCatch {
10461        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10462            let field_count = 0;
10463            let map = s.serialize_map(Some(field_count))?;
10464            map.end()
10465        }
10466    }
10467    impl<'de> Visitor<'de> for GameModVisitor<RelaxCatch> {
10468        type Value = DeserializedGameMod<'de, RelaxCatch>;
10469        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10470            f.write_str("RelaxCatch")
10471        }
10472        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10473            const FIELDS: &'static [&'static str] = &[];
10474            let mut unknown_key__ = None;
10475            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10476                match key.as_str() {
10477                    _ => {
10478                        unknown_key__ = Some(key);
10479                        let _: IgnoredAny = map.next_value()?;
10480                    }
10481                }
10482            }
10483            let gamemod = RelaxCatch {};
10484            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10485        }
10486    }
10487    impl Serialize for RelaxCatch {
10488        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10489            let field_count = 0;
10490            let map = s.serialize_map(Some(field_count))?;
10491            map.end()
10492        }
10493    }
10494    impl<'de> Visitor<'de> for GameModVisitor<WindUpCatch> {
10495        type Value = DeserializedGameMod<'de, WindUpCatch>;
10496        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10497            f.write_str("WindUpCatch")
10498        }
10499        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10500            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
10501            let mut unknown_key__ = None;
10502            let mut initial_rate = None;
10503            let mut final_rate = None;
10504            let mut adjust_pitch = None;
10505            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10506                match key.as_str() {
10507                    "initial_rate" => initial_rate = Some(map.next_value()?),
10508                    "final_rate" => final_rate = Some(map.next_value()?),
10509                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
10510                    _ => {
10511                        unknown_key__ = Some(key);
10512                        let _: IgnoredAny = map.next_value()?;
10513                    }
10514                }
10515            }
10516            let gamemod = WindUpCatch {
10517                initial_rate: initial_rate.unwrap_or_default(),
10518                final_rate: final_rate.unwrap_or_default(),
10519                adjust_pitch: adjust_pitch.unwrap_or_default(),
10520            };
10521            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10522        }
10523    }
10524    impl Serialize for WindUpCatch {
10525        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10526            let field_count = self.initial_rate.is_some() as usize
10527                + self.final_rate.is_some() as usize
10528                + self.adjust_pitch.is_some() as usize;
10529            let mut map = s.serialize_map(Some(field_count))?;
10530            if let Some(ref x) = self.initial_rate {
10531                map.serialize_entry("initial_rate", x)?;
10532            }
10533            if let Some(ref x) = self.final_rate {
10534                map.serialize_entry("final_rate", x)?;
10535            }
10536            if let Some(ref x) = self.adjust_pitch {
10537                map.serialize_entry("adjust_pitch", x)?;
10538            }
10539            map.end()
10540        }
10541    }
10542    impl<'de> Visitor<'de> for GameModVisitor<WindDownCatch> {
10543        type Value = DeserializedGameMod<'de, WindDownCatch>;
10544        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10545            f.write_str("WindDownCatch")
10546        }
10547        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10548            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
10549            let mut unknown_key__ = None;
10550            let mut initial_rate = None;
10551            let mut final_rate = None;
10552            let mut adjust_pitch = None;
10553            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10554                match key.as_str() {
10555                    "initial_rate" => initial_rate = Some(map.next_value()?),
10556                    "final_rate" => final_rate = Some(map.next_value()?),
10557                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
10558                    _ => {
10559                        unknown_key__ = Some(key);
10560                        let _: IgnoredAny = map.next_value()?;
10561                    }
10562                }
10563            }
10564            let gamemod = WindDownCatch {
10565                initial_rate: initial_rate.unwrap_or_default(),
10566                final_rate: final_rate.unwrap_or_default(),
10567                adjust_pitch: adjust_pitch.unwrap_or_default(),
10568            };
10569            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10570        }
10571    }
10572    impl Serialize for WindDownCatch {
10573        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10574            let field_count = self.initial_rate.is_some() as usize
10575                + self.final_rate.is_some() as usize
10576                + self.adjust_pitch.is_some() as usize;
10577            let mut map = s.serialize_map(Some(field_count))?;
10578            if let Some(ref x) = self.initial_rate {
10579                map.serialize_entry("initial_rate", x)?;
10580            }
10581            if let Some(ref x) = self.final_rate {
10582                map.serialize_entry("final_rate", x)?;
10583            }
10584            if let Some(ref x) = self.adjust_pitch {
10585                map.serialize_entry("adjust_pitch", x)?;
10586            }
10587            map.end()
10588        }
10589    }
10590    impl<'de> Visitor<'de> for GameModVisitor<FloatingFruitsCatch> {
10591        type Value = DeserializedGameMod<'de, FloatingFruitsCatch>;
10592        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10593            f.write_str("FloatingFruitsCatch")
10594        }
10595        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10596            const FIELDS: &'static [&'static str] = &[];
10597            let mut unknown_key__ = None;
10598            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10599                match key.as_str() {
10600                    _ => {
10601                        unknown_key__ = Some(key);
10602                        let _: IgnoredAny = map.next_value()?;
10603                    }
10604                }
10605            }
10606            let gamemod = FloatingFruitsCatch {};
10607            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10608        }
10609    }
10610    impl Serialize for FloatingFruitsCatch {
10611        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10612            let field_count = 0;
10613            let map = s.serialize_map(Some(field_count))?;
10614            map.end()
10615        }
10616    }
10617    impl<'de> Visitor<'de> for GameModVisitor<MutedCatch> {
10618        type Value = DeserializedGameMod<'de, MutedCatch>;
10619        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10620            f.write_str("MutedCatch")
10621        }
10622        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10623            const FIELDS: &'static [&'static str] = &[
10624                "inverse_muting",
10625                "enable_metronome",
10626                "mute_combo_count",
10627                "affects_hit_sounds",
10628            ];
10629            let mut unknown_key__ = None;
10630            let mut inverse_muting = None;
10631            let mut enable_metronome = None;
10632            let mut mute_combo_count = None;
10633            let mut affects_hit_sounds = None;
10634            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10635                match key.as_str() {
10636                    "inverse_muting" => inverse_muting = Some(map.next_value()?),
10637                    "enable_metronome" => enable_metronome = Some(map.next_value()?),
10638                    "mute_combo_count" => mute_combo_count = Some(map.next_value()?),
10639                    "affects_hit_sounds" => affects_hit_sounds = Some(map.next_value()?),
10640                    _ => {
10641                        unknown_key__ = Some(key);
10642                        let _: IgnoredAny = map.next_value()?;
10643                    }
10644                }
10645            }
10646            let gamemod = MutedCatch {
10647                inverse_muting: inverse_muting.unwrap_or_default(),
10648                enable_metronome: enable_metronome.unwrap_or_default(),
10649                mute_combo_count: mute_combo_count.unwrap_or_default(),
10650                affects_hit_sounds: affects_hit_sounds.unwrap_or_default(),
10651            };
10652            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10653        }
10654    }
10655    impl Serialize for MutedCatch {
10656        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10657            let field_count = self.inverse_muting.is_some() as usize
10658                + self.enable_metronome.is_some() as usize
10659                + self.mute_combo_count.is_some() as usize
10660                + self.affects_hit_sounds.is_some() as usize;
10661            let mut map = s.serialize_map(Some(field_count))?;
10662            if let Some(ref x) = self.inverse_muting {
10663                map.serialize_entry("inverse_muting", x)?;
10664            }
10665            if let Some(ref x) = self.enable_metronome {
10666                map.serialize_entry("enable_metronome", x)?;
10667            }
10668            if let Some(ref x) = self.mute_combo_count {
10669                map.serialize_entry("mute_combo_count", x)?;
10670            }
10671            if let Some(ref x) = self.affects_hit_sounds {
10672                map.serialize_entry("affects_hit_sounds", x)?;
10673            }
10674            map.end()
10675        }
10676    }
10677    impl<'de> Visitor<'de> for GameModVisitor<NoScopeCatch> {
10678        type Value = DeserializedGameMod<'de, NoScopeCatch>;
10679        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10680            f.write_str("NoScopeCatch")
10681        }
10682        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10683            const FIELDS: &'static [&'static str] = &["hidden_combo_count"];
10684            let mut unknown_key__ = None;
10685            let mut hidden_combo_count = None;
10686            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10687                match key.as_str() {
10688                    "hidden_combo_count" => hidden_combo_count = Some(map.next_value()?),
10689                    _ => {
10690                        unknown_key__ = Some(key);
10691                        let _: IgnoredAny = map.next_value()?;
10692                    }
10693                }
10694            }
10695            let gamemod = NoScopeCatch {
10696                hidden_combo_count: hidden_combo_count.unwrap_or_default(),
10697            };
10698            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10699        }
10700    }
10701    impl Serialize for NoScopeCatch {
10702        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10703            let field_count = self.hidden_combo_count.is_some() as usize;
10704            let mut map = s.serialize_map(Some(field_count))?;
10705            if let Some(ref x) = self.hidden_combo_count {
10706                map.serialize_entry("hidden_combo_count", x)?;
10707            }
10708            map.end()
10709        }
10710    }
10711    impl<'de> Visitor<'de> for GameModVisitor<MovingFastCatch> {
10712        type Value = DeserializedGameMod<'de, MovingFastCatch>;
10713        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10714            f.write_str("MovingFastCatch")
10715        }
10716        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10717            const FIELDS: &'static [&'static str] = &[];
10718            let mut unknown_key__ = None;
10719            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10720                match key.as_str() {
10721                    _ => {
10722                        unknown_key__ = Some(key);
10723                        let _: IgnoredAny = map.next_value()?;
10724                    }
10725                }
10726            }
10727            let gamemod = MovingFastCatch {};
10728            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10729        }
10730    }
10731    impl Serialize for MovingFastCatch {
10732        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10733            let field_count = 0;
10734            let map = s.serialize_map(Some(field_count))?;
10735            map.end()
10736        }
10737    }
10738    impl<'de> Visitor<'de> for GameModVisitor<ScoreV2Catch> {
10739        type Value = DeserializedGameMod<'de, ScoreV2Catch>;
10740        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10741            f.write_str("ScoreV2Catch")
10742        }
10743        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10744            const FIELDS: &'static [&'static str] = &[];
10745            let mut unknown_key__ = None;
10746            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10747                match key.as_str() {
10748                    _ => {
10749                        unknown_key__ = Some(key);
10750                        let _: IgnoredAny = map.next_value()?;
10751                    }
10752                }
10753            }
10754            let gamemod = ScoreV2Catch {};
10755            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10756        }
10757    }
10758    impl Serialize for ScoreV2Catch {
10759        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10760            let field_count = 0;
10761            let map = s.serialize_map(Some(field_count))?;
10762            map.end()
10763        }
10764    }
10765    impl<'de> Visitor<'de> for GameModVisitor<EasyMania> {
10766        type Value = DeserializedGameMod<'de, EasyMania>;
10767        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10768            f.write_str("EasyMania")
10769        }
10770        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10771            const FIELDS: &'static [&'static str] = &["retries"];
10772            let mut unknown_key__ = None;
10773            let mut retries = None;
10774            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10775                match key.as_str() {
10776                    "retries" => retries = Some(map.next_value()?),
10777                    _ => {
10778                        unknown_key__ = Some(key);
10779                        let _: IgnoredAny = map.next_value()?;
10780                    }
10781                }
10782            }
10783            let gamemod = EasyMania {
10784                retries: retries.unwrap_or_default(),
10785            };
10786            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10787        }
10788    }
10789    impl Serialize for EasyMania {
10790        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10791            let field_count = self.retries.is_some() as usize;
10792            let mut map = s.serialize_map(Some(field_count))?;
10793            if let Some(ref x) = self.retries {
10794                map.serialize_entry("retries", x)?;
10795            }
10796            map.end()
10797        }
10798    }
10799    impl<'de> Visitor<'de> for GameModVisitor<NoFailMania> {
10800        type Value = DeserializedGameMod<'de, NoFailMania>;
10801        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10802            f.write_str("NoFailMania")
10803        }
10804        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10805            const FIELDS: &'static [&'static str] = &[];
10806            let mut unknown_key__ = None;
10807            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10808                match key.as_str() {
10809                    _ => {
10810                        unknown_key__ = Some(key);
10811                        let _: IgnoredAny = map.next_value()?;
10812                    }
10813                }
10814            }
10815            let gamemod = NoFailMania {};
10816            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10817        }
10818    }
10819    impl Serialize for NoFailMania {
10820        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10821            let field_count = 0;
10822            let map = s.serialize_map(Some(field_count))?;
10823            map.end()
10824        }
10825    }
10826    impl<'de> Visitor<'de> for GameModVisitor<HalfTimeMania> {
10827        type Value = DeserializedGameMod<'de, HalfTimeMania>;
10828        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10829            f.write_str("HalfTimeMania")
10830        }
10831        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10832            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
10833            let mut unknown_key__ = None;
10834            let mut speed_change = None;
10835            let mut adjust_pitch = None;
10836            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10837                match key.as_str() {
10838                    "speed_change" => speed_change = Some(map.next_value()?),
10839                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
10840                    _ => {
10841                        unknown_key__ = Some(key);
10842                        let _: IgnoredAny = map.next_value()?;
10843                    }
10844                }
10845            }
10846            let gamemod = HalfTimeMania {
10847                speed_change: speed_change.unwrap_or_default(),
10848                adjust_pitch: adjust_pitch.unwrap_or_default(),
10849            };
10850            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10851        }
10852    }
10853    impl Serialize for HalfTimeMania {
10854        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10855            let field_count =
10856                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
10857            let mut map = s.serialize_map(Some(field_count))?;
10858            if let Some(ref x) = self.speed_change {
10859                map.serialize_entry("speed_change", x)?;
10860            }
10861            if let Some(ref x) = self.adjust_pitch {
10862                map.serialize_entry("adjust_pitch", x)?;
10863            }
10864            map.end()
10865        }
10866    }
10867    impl<'de> Visitor<'de> for GameModVisitor<DaycoreMania> {
10868        type Value = DeserializedGameMod<'de, DaycoreMania>;
10869        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10870            f.write_str("DaycoreMania")
10871        }
10872        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10873            const FIELDS: &'static [&'static str] = &["speed_change"];
10874            let mut unknown_key__ = None;
10875            let mut speed_change = None;
10876            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10877                match key.as_str() {
10878                    "speed_change" => speed_change = Some(map.next_value()?),
10879                    _ => {
10880                        unknown_key__ = Some(key);
10881                        let _: IgnoredAny = map.next_value()?;
10882                    }
10883                }
10884            }
10885            let gamemod = DaycoreMania {
10886                speed_change: speed_change.unwrap_or_default(),
10887            };
10888            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10889        }
10890    }
10891    impl Serialize for DaycoreMania {
10892        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10893            let field_count = self.speed_change.is_some() as usize;
10894            let mut map = s.serialize_map(Some(field_count))?;
10895            if let Some(ref x) = self.speed_change {
10896                map.serialize_entry("speed_change", x)?;
10897            }
10898            map.end()
10899        }
10900    }
10901    impl<'de> Visitor<'de> for GameModVisitor<NoReleaseMania> {
10902        type Value = DeserializedGameMod<'de, NoReleaseMania>;
10903        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10904            f.write_str("NoReleaseMania")
10905        }
10906        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10907            const FIELDS: &'static [&'static str] = &[];
10908            let mut unknown_key__ = None;
10909            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10910                match key.as_str() {
10911                    _ => {
10912                        unknown_key__ = Some(key);
10913                        let _: IgnoredAny = map.next_value()?;
10914                    }
10915                }
10916            }
10917            let gamemod = NoReleaseMania {};
10918            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10919        }
10920    }
10921    impl Serialize for NoReleaseMania {
10922        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10923            let field_count = 0;
10924            let map = s.serialize_map(Some(field_count))?;
10925            map.end()
10926        }
10927    }
10928    impl<'de> Visitor<'de> for GameModVisitor<HardRockMania> {
10929        type Value = DeserializedGameMod<'de, HardRockMania>;
10930        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10931            f.write_str("HardRockMania")
10932        }
10933        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10934            const FIELDS: &'static [&'static str] = &[];
10935            let mut unknown_key__ = None;
10936            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10937                match key.as_str() {
10938                    _ => {
10939                        unknown_key__ = Some(key);
10940                        let _: IgnoredAny = map.next_value()?;
10941                    }
10942                }
10943            }
10944            let gamemod = HardRockMania {};
10945            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10946        }
10947    }
10948    impl Serialize for HardRockMania {
10949        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10950            let field_count = 0;
10951            let map = s.serialize_map(Some(field_count))?;
10952            map.end()
10953        }
10954    }
10955    impl<'de> Visitor<'de> for GameModVisitor<SuddenDeathMania> {
10956        type Value = DeserializedGameMod<'de, SuddenDeathMania>;
10957        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10958            f.write_str("SuddenDeathMania")
10959        }
10960        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10961            const FIELDS: &'static [&'static str] = &["restart"];
10962            let mut unknown_key__ = None;
10963            let mut restart = None;
10964            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
10965                match key.as_str() {
10966                    "restart" => restart = Some(map.next_value()?),
10967                    _ => {
10968                        unknown_key__ = Some(key);
10969                        let _: IgnoredAny = map.next_value()?;
10970                    }
10971                }
10972            }
10973            let gamemod = SuddenDeathMania {
10974                restart: restart.unwrap_or_default(),
10975            };
10976            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
10977        }
10978    }
10979    impl Serialize for SuddenDeathMania {
10980        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
10981            let field_count = self.restart.is_some() as usize;
10982            let mut map = s.serialize_map(Some(field_count))?;
10983            if let Some(ref x) = self.restart {
10984                map.serialize_entry("restart", x)?;
10985            }
10986            map.end()
10987        }
10988    }
10989    impl<'de> Visitor<'de> for GameModVisitor<PerfectMania> {
10990        type Value = DeserializedGameMod<'de, PerfectMania>;
10991        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
10992            f.write_str("PerfectMania")
10993        }
10994        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
10995            const FIELDS: &'static [&'static str] = &["require_perfect_hits", "restart"];
10996            let mut unknown_key__ = None;
10997            let mut require_perfect_hits = None;
10998            let mut restart = None;
10999            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11000                match key.as_str() {
11001                    "require_perfect_hits" => require_perfect_hits = Some(map.next_value()?),
11002                    "restart" => restart = Some(map.next_value()?),
11003                    _ => {
11004                        unknown_key__ = Some(key);
11005                        let _: IgnoredAny = map.next_value()?;
11006                    }
11007                }
11008            }
11009            let gamemod = PerfectMania {
11010                require_perfect_hits: require_perfect_hits.unwrap_or_default(),
11011                restart: restart.unwrap_or_default(),
11012            };
11013            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11014        }
11015    }
11016    impl Serialize for PerfectMania {
11017        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11018            let field_count =
11019                self.require_perfect_hits.is_some() as usize + self.restart.is_some() as usize;
11020            let mut map = s.serialize_map(Some(field_count))?;
11021            if let Some(ref x) = self.require_perfect_hits {
11022                map.serialize_entry("require_perfect_hits", x)?;
11023            }
11024            if let Some(ref x) = self.restart {
11025                map.serialize_entry("restart", x)?;
11026            }
11027            map.end()
11028        }
11029    }
11030    impl<'de> Visitor<'de> for GameModVisitor<DoubleTimeMania> {
11031        type Value = DeserializedGameMod<'de, DoubleTimeMania>;
11032        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11033            f.write_str("DoubleTimeMania")
11034        }
11035        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11036            const FIELDS: &'static [&'static str] = &["speed_change", "adjust_pitch"];
11037            let mut unknown_key__ = None;
11038            let mut speed_change = None;
11039            let mut adjust_pitch = None;
11040            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11041                match key.as_str() {
11042                    "speed_change" => speed_change = Some(map.next_value()?),
11043                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
11044                    _ => {
11045                        unknown_key__ = Some(key);
11046                        let _: IgnoredAny = map.next_value()?;
11047                    }
11048                }
11049            }
11050            let gamemod = DoubleTimeMania {
11051                speed_change: speed_change.unwrap_or_default(),
11052                adjust_pitch: adjust_pitch.unwrap_or_default(),
11053            };
11054            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11055        }
11056    }
11057    impl Serialize for DoubleTimeMania {
11058        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11059            let field_count =
11060                self.speed_change.is_some() as usize + self.adjust_pitch.is_some() as usize;
11061            let mut map = s.serialize_map(Some(field_count))?;
11062            if let Some(ref x) = self.speed_change {
11063                map.serialize_entry("speed_change", x)?;
11064            }
11065            if let Some(ref x) = self.adjust_pitch {
11066                map.serialize_entry("adjust_pitch", x)?;
11067            }
11068            map.end()
11069        }
11070    }
11071    impl<'de> Visitor<'de> for GameModVisitor<NightcoreMania> {
11072        type Value = DeserializedGameMod<'de, NightcoreMania>;
11073        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11074            f.write_str("NightcoreMania")
11075        }
11076        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11077            const FIELDS: &'static [&'static str] = &["speed_change"];
11078            let mut unknown_key__ = None;
11079            let mut speed_change = None;
11080            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11081                match key.as_str() {
11082                    "speed_change" => speed_change = Some(map.next_value()?),
11083                    _ => {
11084                        unknown_key__ = Some(key);
11085                        let _: IgnoredAny = map.next_value()?;
11086                    }
11087                }
11088            }
11089            let gamemod = NightcoreMania {
11090                speed_change: speed_change.unwrap_or_default(),
11091            };
11092            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11093        }
11094    }
11095    impl Serialize for NightcoreMania {
11096        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11097            let field_count = self.speed_change.is_some() as usize;
11098            let mut map = s.serialize_map(Some(field_count))?;
11099            if let Some(ref x) = self.speed_change {
11100                map.serialize_entry("speed_change", x)?;
11101            }
11102            map.end()
11103        }
11104    }
11105    impl<'de> Visitor<'de> for GameModVisitor<FadeInMania> {
11106        type Value = DeserializedGameMod<'de, FadeInMania>;
11107        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11108            f.write_str("FadeInMania")
11109        }
11110        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11111            const FIELDS: &'static [&'static str] = &[];
11112            let mut unknown_key__ = None;
11113            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11114                match key.as_str() {
11115                    _ => {
11116                        unknown_key__ = Some(key);
11117                        let _: IgnoredAny = map.next_value()?;
11118                    }
11119                }
11120            }
11121            let gamemod = FadeInMania {};
11122            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11123        }
11124    }
11125    impl Serialize for FadeInMania {
11126        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11127            let field_count = 0;
11128            let map = s.serialize_map(Some(field_count))?;
11129            map.end()
11130        }
11131    }
11132    impl<'de> Visitor<'de> for GameModVisitor<HiddenMania> {
11133        type Value = DeserializedGameMod<'de, HiddenMania>;
11134        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11135            f.write_str("HiddenMania")
11136        }
11137        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11138            const FIELDS: &'static [&'static str] = &[];
11139            let mut unknown_key__ = None;
11140            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11141                match key.as_str() {
11142                    _ => {
11143                        unknown_key__ = Some(key);
11144                        let _: IgnoredAny = map.next_value()?;
11145                    }
11146                }
11147            }
11148            let gamemod = HiddenMania {};
11149            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11150        }
11151    }
11152    impl Serialize for HiddenMania {
11153        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11154            let field_count = 0;
11155            let map = s.serialize_map(Some(field_count))?;
11156            map.end()
11157        }
11158    }
11159    impl<'de> Visitor<'de> for GameModVisitor<CoverMania> {
11160        type Value = DeserializedGameMod<'de, CoverMania>;
11161        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11162            f.write_str("CoverMania")
11163        }
11164        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11165            const FIELDS: &'static [&'static str] = &["coverage", "direction"];
11166            let mut unknown_key__ = None;
11167            let mut coverage = None;
11168            let mut direction = None;
11169            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11170                match key.as_str() {
11171                    "coverage" => coverage = Some(map.next_value()?),
11172                    "direction" => direction = Some(map.next_value()?),
11173                    _ => {
11174                        unknown_key__ = Some(key);
11175                        let _: IgnoredAny = map.next_value()?;
11176                    }
11177                }
11178            }
11179            let gamemod = CoverMania {
11180                coverage: coverage.unwrap_or_default(),
11181                direction: direction.unwrap_or_default(),
11182            };
11183            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11184        }
11185    }
11186    impl Serialize for CoverMania {
11187        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11188            let field_count = self.coverage.is_some() as usize + self.direction.is_some() as usize;
11189            let mut map = s.serialize_map(Some(field_count))?;
11190            if let Some(ref x) = self.coverage {
11191                map.serialize_entry("coverage", x)?;
11192            }
11193            if let Some(ref x) = self.direction {
11194                map.serialize_entry("direction", x)?;
11195            }
11196            map.end()
11197        }
11198    }
11199    impl<'de> Visitor<'de> for GameModVisitor<FlashlightMania> {
11200        type Value = DeserializedGameMod<'de, FlashlightMania>;
11201        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11202            f.write_str("FlashlightMania")
11203        }
11204        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11205            const FIELDS: &'static [&'static str] = &["size_multiplier", "combo_based_size"];
11206            let mut unknown_key__ = None;
11207            let mut size_multiplier = None;
11208            let mut combo_based_size = None;
11209            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11210                match key.as_str() {
11211                    "size_multiplier" => size_multiplier = Some(map.next_value()?),
11212                    "combo_based_size" => combo_based_size = Some(map.next_value()?),
11213                    _ => {
11214                        unknown_key__ = Some(key);
11215                        let _: IgnoredAny = map.next_value()?;
11216                    }
11217                }
11218            }
11219            let gamemod = FlashlightMania {
11220                size_multiplier: size_multiplier.unwrap_or_default(),
11221                combo_based_size: combo_based_size.unwrap_or_default(),
11222            };
11223            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11224        }
11225    }
11226    impl Serialize for FlashlightMania {
11227        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11228            let field_count =
11229                self.size_multiplier.is_some() as usize + self.combo_based_size.is_some() as usize;
11230            let mut map = s.serialize_map(Some(field_count))?;
11231            if let Some(ref x) = self.size_multiplier {
11232                map.serialize_entry("size_multiplier", x)?;
11233            }
11234            if let Some(ref x) = self.combo_based_size {
11235                map.serialize_entry("combo_based_size", x)?;
11236            }
11237            map.end()
11238        }
11239    }
11240    impl<'de> Visitor<'de> for GameModVisitor<AccuracyChallengeMania> {
11241        type Value = DeserializedGameMod<'de, AccuracyChallengeMania>;
11242        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11243            f.write_str("AccuracyChallengeMania")
11244        }
11245        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11246            const FIELDS: &'static [&'static str] =
11247                &["minimum_accuracy", "accuracy_judge_mode", "restart"];
11248            let mut unknown_key__ = None;
11249            let mut minimum_accuracy = None;
11250            let mut accuracy_judge_mode = None;
11251            let mut restart = None;
11252            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11253                match key.as_str() {
11254                    "minimum_accuracy" => minimum_accuracy = Some(map.next_value()?),
11255                    "accuracy_judge_mode" => accuracy_judge_mode = Some(map.next_value()?),
11256                    "restart" => restart = Some(map.next_value()?),
11257                    _ => {
11258                        unknown_key__ = Some(key);
11259                        let _: IgnoredAny = map.next_value()?;
11260                    }
11261                }
11262            }
11263            let gamemod = AccuracyChallengeMania {
11264                minimum_accuracy: minimum_accuracy.unwrap_or_default(),
11265                accuracy_judge_mode: accuracy_judge_mode.unwrap_or_default(),
11266                restart: restart.unwrap_or_default(),
11267            };
11268            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11269        }
11270    }
11271    impl Serialize for AccuracyChallengeMania {
11272        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11273            let field_count = self.minimum_accuracy.is_some() as usize
11274                + self.accuracy_judge_mode.is_some() as usize
11275                + self.restart.is_some() as usize;
11276            let mut map = s.serialize_map(Some(field_count))?;
11277            if let Some(ref x) = self.minimum_accuracy {
11278                map.serialize_entry("minimum_accuracy", x)?;
11279            }
11280            if let Some(ref x) = self.accuracy_judge_mode {
11281                map.serialize_entry("accuracy_judge_mode", x)?;
11282            }
11283            if let Some(ref x) = self.restart {
11284                map.serialize_entry("restart", x)?;
11285            }
11286            map.end()
11287        }
11288    }
11289    impl<'de> Visitor<'de> for GameModVisitor<RandomMania> {
11290        type Value = DeserializedGameMod<'de, RandomMania>;
11291        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11292            f.write_str("RandomMania")
11293        }
11294        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11295            const FIELDS: &'static [&'static str] = &["seed"];
11296            let mut unknown_key__ = None;
11297            let mut seed = None;
11298            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11299                match key.as_str() {
11300                    "seed" => seed = Some(map.next_value()?),
11301                    _ => {
11302                        unknown_key__ = Some(key);
11303                        let _: IgnoredAny = map.next_value()?;
11304                    }
11305                }
11306            }
11307            let gamemod = RandomMania {
11308                seed: seed.unwrap_or_default(),
11309            };
11310            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11311        }
11312    }
11313    impl Serialize for RandomMania {
11314        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11315            let field_count = self.seed.is_some() as usize;
11316            let mut map = s.serialize_map(Some(field_count))?;
11317            if let Some(ref x) = self.seed {
11318                map.serialize_entry("seed", x)?;
11319            }
11320            map.end()
11321        }
11322    }
11323    impl<'de> Visitor<'de> for GameModVisitor<DualStagesMania> {
11324        type Value = DeserializedGameMod<'de, DualStagesMania>;
11325        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11326            f.write_str("DualStagesMania")
11327        }
11328        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11329            const FIELDS: &'static [&'static str] = &[];
11330            let mut unknown_key__ = None;
11331            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11332                match key.as_str() {
11333                    _ => {
11334                        unknown_key__ = Some(key);
11335                        let _: IgnoredAny = map.next_value()?;
11336                    }
11337                }
11338            }
11339            let gamemod = DualStagesMania {};
11340            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11341        }
11342    }
11343    impl Serialize for DualStagesMania {
11344        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11345            let field_count = 0;
11346            let map = s.serialize_map(Some(field_count))?;
11347            map.end()
11348        }
11349    }
11350    impl<'de> Visitor<'de> for GameModVisitor<MirrorMania> {
11351        type Value = DeserializedGameMod<'de, MirrorMania>;
11352        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11353            f.write_str("MirrorMania")
11354        }
11355        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11356            const FIELDS: &'static [&'static str] = &[];
11357            let mut unknown_key__ = None;
11358            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11359                match key.as_str() {
11360                    _ => {
11361                        unknown_key__ = Some(key);
11362                        let _: IgnoredAny = map.next_value()?;
11363                    }
11364                }
11365            }
11366            let gamemod = MirrorMania {};
11367            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11368        }
11369    }
11370    impl Serialize for MirrorMania {
11371        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11372            let field_count = 0;
11373            let map = s.serialize_map(Some(field_count))?;
11374            map.end()
11375        }
11376    }
11377    impl<'de> Visitor<'de> for GameModVisitor<DifficultyAdjustMania> {
11378        type Value = DeserializedGameMod<'de, DifficultyAdjustMania>;
11379        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11380            f.write_str("DifficultyAdjustMania")
11381        }
11382        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11383            const FIELDS: &'static [&'static str] =
11384                &["overall_difficulty", "drain_rate", "extended_limits"];
11385            let mut unknown_key__ = None;
11386            let mut overall_difficulty = None;
11387            let mut drain_rate = None;
11388            let mut extended_limits = None;
11389            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11390                match key.as_str() {
11391                    "overall_difficulty" => overall_difficulty = Some(map.next_value()?),
11392                    "drain_rate" => drain_rate = Some(map.next_value()?),
11393                    "extended_limits" => extended_limits = Some(map.next_value()?),
11394                    _ => {
11395                        unknown_key__ = Some(key);
11396                        let _: IgnoredAny = map.next_value()?;
11397                    }
11398                }
11399            }
11400            let gamemod = DifficultyAdjustMania {
11401                overall_difficulty: overall_difficulty.unwrap_or_default(),
11402                drain_rate: drain_rate.unwrap_or_default(),
11403                extended_limits: extended_limits.unwrap_or_default(),
11404            };
11405            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11406        }
11407    }
11408    impl Serialize for DifficultyAdjustMania {
11409        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11410            let field_count = self.overall_difficulty.is_some() as usize
11411                + self.drain_rate.is_some() as usize
11412                + self.extended_limits.is_some() as usize;
11413            let mut map = s.serialize_map(Some(field_count))?;
11414            if let Some(ref x) = self.overall_difficulty {
11415                map.serialize_entry("overall_difficulty", x)?;
11416            }
11417            if let Some(ref x) = self.drain_rate {
11418                map.serialize_entry("drain_rate", x)?;
11419            }
11420            if let Some(ref x) = self.extended_limits {
11421                map.serialize_entry("extended_limits", x)?;
11422            }
11423            map.end()
11424        }
11425    }
11426    impl<'de> Visitor<'de> for GameModVisitor<ClassicMania> {
11427        type Value = DeserializedGameMod<'de, ClassicMania>;
11428        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11429            f.write_str("ClassicMania")
11430        }
11431        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11432            const FIELDS: &'static [&'static str] = &[];
11433            let mut unknown_key__ = None;
11434            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11435                match key.as_str() {
11436                    _ => {
11437                        unknown_key__ = Some(key);
11438                        let _: IgnoredAny = map.next_value()?;
11439                    }
11440                }
11441            }
11442            let gamemod = ClassicMania {};
11443            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11444        }
11445    }
11446    impl Serialize for ClassicMania {
11447        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11448            let field_count = 0;
11449            let map = s.serialize_map(Some(field_count))?;
11450            map.end()
11451        }
11452    }
11453    impl<'de> Visitor<'de> for GameModVisitor<InvertMania> {
11454        type Value = DeserializedGameMod<'de, InvertMania>;
11455        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11456            f.write_str("InvertMania")
11457        }
11458        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11459            const FIELDS: &'static [&'static str] = &[];
11460            let mut unknown_key__ = None;
11461            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11462                match key.as_str() {
11463                    _ => {
11464                        unknown_key__ = Some(key);
11465                        let _: IgnoredAny = map.next_value()?;
11466                    }
11467                }
11468            }
11469            let gamemod = InvertMania {};
11470            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11471        }
11472    }
11473    impl Serialize for InvertMania {
11474        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11475            let field_count = 0;
11476            let map = s.serialize_map(Some(field_count))?;
11477            map.end()
11478        }
11479    }
11480    impl<'de> Visitor<'de> for GameModVisitor<ConstantSpeedMania> {
11481        type Value = DeserializedGameMod<'de, ConstantSpeedMania>;
11482        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11483            f.write_str("ConstantSpeedMania")
11484        }
11485        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11486            const FIELDS: &'static [&'static str] = &[];
11487            let mut unknown_key__ = None;
11488            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11489                match key.as_str() {
11490                    _ => {
11491                        unknown_key__ = Some(key);
11492                        let _: IgnoredAny = map.next_value()?;
11493                    }
11494                }
11495            }
11496            let gamemod = ConstantSpeedMania {};
11497            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11498        }
11499    }
11500    impl Serialize for ConstantSpeedMania {
11501        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11502            let field_count = 0;
11503            let map = s.serialize_map(Some(field_count))?;
11504            map.end()
11505        }
11506    }
11507    impl<'de> Visitor<'de> for GameModVisitor<HoldOffMania> {
11508        type Value = DeserializedGameMod<'de, HoldOffMania>;
11509        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11510            f.write_str("HoldOffMania")
11511        }
11512        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11513            const FIELDS: &'static [&'static str] = &[];
11514            let mut unknown_key__ = None;
11515            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11516                match key.as_str() {
11517                    _ => {
11518                        unknown_key__ = Some(key);
11519                        let _: IgnoredAny = map.next_value()?;
11520                    }
11521                }
11522            }
11523            let gamemod = HoldOffMania {};
11524            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11525        }
11526    }
11527    impl Serialize for HoldOffMania {
11528        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11529            let field_count = 0;
11530            let map = s.serialize_map(Some(field_count))?;
11531            map.end()
11532        }
11533    }
11534    impl<'de> Visitor<'de> for GameModVisitor<OneKeyMania> {
11535        type Value = DeserializedGameMod<'de, OneKeyMania>;
11536        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11537            f.write_str("OneKeyMania")
11538        }
11539        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11540            const FIELDS: &'static [&'static str] = &[];
11541            let mut unknown_key__ = None;
11542            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11543                match key.as_str() {
11544                    _ => {
11545                        unknown_key__ = Some(key);
11546                        let _: IgnoredAny = map.next_value()?;
11547                    }
11548                }
11549            }
11550            let gamemod = OneKeyMania {};
11551            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11552        }
11553    }
11554    impl Serialize for OneKeyMania {
11555        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11556            let field_count = 0;
11557            let map = s.serialize_map(Some(field_count))?;
11558            map.end()
11559        }
11560    }
11561    impl<'de> Visitor<'de> for GameModVisitor<TwoKeysMania> {
11562        type Value = DeserializedGameMod<'de, TwoKeysMania>;
11563        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11564            f.write_str("TwoKeysMania")
11565        }
11566        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11567            const FIELDS: &'static [&'static str] = &[];
11568            let mut unknown_key__ = None;
11569            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11570                match key.as_str() {
11571                    _ => {
11572                        unknown_key__ = Some(key);
11573                        let _: IgnoredAny = map.next_value()?;
11574                    }
11575                }
11576            }
11577            let gamemod = TwoKeysMania {};
11578            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11579        }
11580    }
11581    impl Serialize for TwoKeysMania {
11582        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11583            let field_count = 0;
11584            let map = s.serialize_map(Some(field_count))?;
11585            map.end()
11586        }
11587    }
11588    impl<'de> Visitor<'de> for GameModVisitor<ThreeKeysMania> {
11589        type Value = DeserializedGameMod<'de, ThreeKeysMania>;
11590        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11591            f.write_str("ThreeKeysMania")
11592        }
11593        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11594            const FIELDS: &'static [&'static str] = &[];
11595            let mut unknown_key__ = None;
11596            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11597                match key.as_str() {
11598                    _ => {
11599                        unknown_key__ = Some(key);
11600                        let _: IgnoredAny = map.next_value()?;
11601                    }
11602                }
11603            }
11604            let gamemod = ThreeKeysMania {};
11605            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11606        }
11607    }
11608    impl Serialize for ThreeKeysMania {
11609        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11610            let field_count = 0;
11611            let map = s.serialize_map(Some(field_count))?;
11612            map.end()
11613        }
11614    }
11615    impl<'de> Visitor<'de> for GameModVisitor<FourKeysMania> {
11616        type Value = DeserializedGameMod<'de, FourKeysMania>;
11617        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11618            f.write_str("FourKeysMania")
11619        }
11620        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11621            const FIELDS: &'static [&'static str] = &[];
11622            let mut unknown_key__ = None;
11623            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11624                match key.as_str() {
11625                    _ => {
11626                        unknown_key__ = Some(key);
11627                        let _: IgnoredAny = map.next_value()?;
11628                    }
11629                }
11630            }
11631            let gamemod = FourKeysMania {};
11632            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11633        }
11634    }
11635    impl Serialize for FourKeysMania {
11636        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11637            let field_count = 0;
11638            let map = s.serialize_map(Some(field_count))?;
11639            map.end()
11640        }
11641    }
11642    impl<'de> Visitor<'de> for GameModVisitor<FiveKeysMania> {
11643        type Value = DeserializedGameMod<'de, FiveKeysMania>;
11644        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11645            f.write_str("FiveKeysMania")
11646        }
11647        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11648            const FIELDS: &'static [&'static str] = &[];
11649            let mut unknown_key__ = None;
11650            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11651                match key.as_str() {
11652                    _ => {
11653                        unknown_key__ = Some(key);
11654                        let _: IgnoredAny = map.next_value()?;
11655                    }
11656                }
11657            }
11658            let gamemod = FiveKeysMania {};
11659            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11660        }
11661    }
11662    impl Serialize for FiveKeysMania {
11663        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11664            let field_count = 0;
11665            let map = s.serialize_map(Some(field_count))?;
11666            map.end()
11667        }
11668    }
11669    impl<'de> Visitor<'de> for GameModVisitor<SixKeysMania> {
11670        type Value = DeserializedGameMod<'de, SixKeysMania>;
11671        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11672            f.write_str("SixKeysMania")
11673        }
11674        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11675            const FIELDS: &'static [&'static str] = &[];
11676            let mut unknown_key__ = None;
11677            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11678                match key.as_str() {
11679                    _ => {
11680                        unknown_key__ = Some(key);
11681                        let _: IgnoredAny = map.next_value()?;
11682                    }
11683                }
11684            }
11685            let gamemod = SixKeysMania {};
11686            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11687        }
11688    }
11689    impl Serialize for SixKeysMania {
11690        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11691            let field_count = 0;
11692            let map = s.serialize_map(Some(field_count))?;
11693            map.end()
11694        }
11695    }
11696    impl<'de> Visitor<'de> for GameModVisitor<SevenKeysMania> {
11697        type Value = DeserializedGameMod<'de, SevenKeysMania>;
11698        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11699            f.write_str("SevenKeysMania")
11700        }
11701        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11702            const FIELDS: &'static [&'static str] = &[];
11703            let mut unknown_key__ = None;
11704            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11705                match key.as_str() {
11706                    _ => {
11707                        unknown_key__ = Some(key);
11708                        let _: IgnoredAny = map.next_value()?;
11709                    }
11710                }
11711            }
11712            let gamemod = SevenKeysMania {};
11713            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11714        }
11715    }
11716    impl Serialize for SevenKeysMania {
11717        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11718            let field_count = 0;
11719            let map = s.serialize_map(Some(field_count))?;
11720            map.end()
11721        }
11722    }
11723    impl<'de> Visitor<'de> for GameModVisitor<EightKeysMania> {
11724        type Value = DeserializedGameMod<'de, EightKeysMania>;
11725        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11726            f.write_str("EightKeysMania")
11727        }
11728        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11729            const FIELDS: &'static [&'static str] = &[];
11730            let mut unknown_key__ = None;
11731            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11732                match key.as_str() {
11733                    _ => {
11734                        unknown_key__ = Some(key);
11735                        let _: IgnoredAny = map.next_value()?;
11736                    }
11737                }
11738            }
11739            let gamemod = EightKeysMania {};
11740            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11741        }
11742    }
11743    impl Serialize for EightKeysMania {
11744        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11745            let field_count = 0;
11746            let map = s.serialize_map(Some(field_count))?;
11747            map.end()
11748        }
11749    }
11750    impl<'de> Visitor<'de> for GameModVisitor<NineKeysMania> {
11751        type Value = DeserializedGameMod<'de, NineKeysMania>;
11752        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11753            f.write_str("NineKeysMania")
11754        }
11755        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11756            const FIELDS: &'static [&'static str] = &[];
11757            let mut unknown_key__ = None;
11758            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11759                match key.as_str() {
11760                    _ => {
11761                        unknown_key__ = Some(key);
11762                        let _: IgnoredAny = map.next_value()?;
11763                    }
11764                }
11765            }
11766            let gamemod = NineKeysMania {};
11767            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11768        }
11769    }
11770    impl Serialize for NineKeysMania {
11771        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11772            let field_count = 0;
11773            let map = s.serialize_map(Some(field_count))?;
11774            map.end()
11775        }
11776    }
11777    impl<'de> Visitor<'de> for GameModVisitor<TenKeysMania> {
11778        type Value = DeserializedGameMod<'de, TenKeysMania>;
11779        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11780            f.write_str("TenKeysMania")
11781        }
11782        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11783            const FIELDS: &'static [&'static str] = &[];
11784            let mut unknown_key__ = None;
11785            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11786                match key.as_str() {
11787                    _ => {
11788                        unknown_key__ = Some(key);
11789                        let _: IgnoredAny = map.next_value()?;
11790                    }
11791                }
11792            }
11793            let gamemod = TenKeysMania {};
11794            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11795        }
11796    }
11797    impl Serialize for TenKeysMania {
11798        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11799            let field_count = 0;
11800            let map = s.serialize_map(Some(field_count))?;
11801            map.end()
11802        }
11803    }
11804    impl<'de> Visitor<'de> for GameModVisitor<AutoplayMania> {
11805        type Value = DeserializedGameMod<'de, AutoplayMania>;
11806        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11807            f.write_str("AutoplayMania")
11808        }
11809        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11810            const FIELDS: &'static [&'static str] = &[];
11811            let mut unknown_key__ = None;
11812            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11813                match key.as_str() {
11814                    _ => {
11815                        unknown_key__ = Some(key);
11816                        let _: IgnoredAny = map.next_value()?;
11817                    }
11818                }
11819            }
11820            let gamemod = AutoplayMania {};
11821            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11822        }
11823    }
11824    impl Serialize for AutoplayMania {
11825        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11826            let field_count = 0;
11827            let map = s.serialize_map(Some(field_count))?;
11828            map.end()
11829        }
11830    }
11831    impl<'de> Visitor<'de> for GameModVisitor<CinemaMania> {
11832        type Value = DeserializedGameMod<'de, CinemaMania>;
11833        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11834            f.write_str("CinemaMania")
11835        }
11836        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11837            const FIELDS: &'static [&'static str] = &[];
11838            let mut unknown_key__ = None;
11839            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11840                match key.as_str() {
11841                    _ => {
11842                        unknown_key__ = Some(key);
11843                        let _: IgnoredAny = map.next_value()?;
11844                    }
11845                }
11846            }
11847            let gamemod = CinemaMania {};
11848            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11849        }
11850    }
11851    impl Serialize for CinemaMania {
11852        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11853            let field_count = 0;
11854            let map = s.serialize_map(Some(field_count))?;
11855            map.end()
11856        }
11857    }
11858    impl<'de> Visitor<'de> for GameModVisitor<WindUpMania> {
11859        type Value = DeserializedGameMod<'de, WindUpMania>;
11860        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11861            f.write_str("WindUpMania")
11862        }
11863        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11864            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
11865            let mut unknown_key__ = None;
11866            let mut initial_rate = None;
11867            let mut final_rate = None;
11868            let mut adjust_pitch = None;
11869            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11870                match key.as_str() {
11871                    "initial_rate" => initial_rate = Some(map.next_value()?),
11872                    "final_rate" => final_rate = Some(map.next_value()?),
11873                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
11874                    _ => {
11875                        unknown_key__ = Some(key);
11876                        let _: IgnoredAny = map.next_value()?;
11877                    }
11878                }
11879            }
11880            let gamemod = WindUpMania {
11881                initial_rate: initial_rate.unwrap_or_default(),
11882                final_rate: final_rate.unwrap_or_default(),
11883                adjust_pitch: adjust_pitch.unwrap_or_default(),
11884            };
11885            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11886        }
11887    }
11888    impl Serialize for WindUpMania {
11889        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11890            let field_count = self.initial_rate.is_some() as usize
11891                + self.final_rate.is_some() as usize
11892                + self.adjust_pitch.is_some() as usize;
11893            let mut map = s.serialize_map(Some(field_count))?;
11894            if let Some(ref x) = self.initial_rate {
11895                map.serialize_entry("initial_rate", x)?;
11896            }
11897            if let Some(ref x) = self.final_rate {
11898                map.serialize_entry("final_rate", x)?;
11899            }
11900            if let Some(ref x) = self.adjust_pitch {
11901                map.serialize_entry("adjust_pitch", x)?;
11902            }
11903            map.end()
11904        }
11905    }
11906    impl<'de> Visitor<'de> for GameModVisitor<WindDownMania> {
11907        type Value = DeserializedGameMod<'de, WindDownMania>;
11908        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11909            f.write_str("WindDownMania")
11910        }
11911        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11912            const FIELDS: &'static [&'static str] = &["initial_rate", "final_rate", "adjust_pitch"];
11913            let mut unknown_key__ = None;
11914            let mut initial_rate = None;
11915            let mut final_rate = None;
11916            let mut adjust_pitch = None;
11917            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11918                match key.as_str() {
11919                    "initial_rate" => initial_rate = Some(map.next_value()?),
11920                    "final_rate" => final_rate = Some(map.next_value()?),
11921                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
11922                    _ => {
11923                        unknown_key__ = Some(key);
11924                        let _: IgnoredAny = map.next_value()?;
11925                    }
11926                }
11927            }
11928            let gamemod = WindDownMania {
11929                initial_rate: initial_rate.unwrap_or_default(),
11930                final_rate: final_rate.unwrap_or_default(),
11931                adjust_pitch: adjust_pitch.unwrap_or_default(),
11932            };
11933            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11934        }
11935    }
11936    impl Serialize for WindDownMania {
11937        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11938            let field_count = self.initial_rate.is_some() as usize
11939                + self.final_rate.is_some() as usize
11940                + self.adjust_pitch.is_some() as usize;
11941            let mut map = s.serialize_map(Some(field_count))?;
11942            if let Some(ref x) = self.initial_rate {
11943                map.serialize_entry("initial_rate", x)?;
11944            }
11945            if let Some(ref x) = self.final_rate {
11946                map.serialize_entry("final_rate", x)?;
11947            }
11948            if let Some(ref x) = self.adjust_pitch {
11949                map.serialize_entry("adjust_pitch", x)?;
11950            }
11951            map.end()
11952        }
11953    }
11954    impl<'de> Visitor<'de> for GameModVisitor<MutedMania> {
11955        type Value = DeserializedGameMod<'de, MutedMania>;
11956        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
11957            f.write_str("MutedMania")
11958        }
11959        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
11960            const FIELDS: &'static [&'static str] = &[
11961                "inverse_muting",
11962                "enable_metronome",
11963                "mute_combo_count",
11964                "affects_hit_sounds",
11965            ];
11966            let mut unknown_key__ = None;
11967            let mut inverse_muting = None;
11968            let mut enable_metronome = None;
11969            let mut mute_combo_count = None;
11970            let mut affects_hit_sounds = None;
11971            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
11972                match key.as_str() {
11973                    "inverse_muting" => inverse_muting = Some(map.next_value()?),
11974                    "enable_metronome" => enable_metronome = Some(map.next_value()?),
11975                    "mute_combo_count" => mute_combo_count = Some(map.next_value()?),
11976                    "affects_hit_sounds" => affects_hit_sounds = Some(map.next_value()?),
11977                    _ => {
11978                        unknown_key__ = Some(key);
11979                        let _: IgnoredAny = map.next_value()?;
11980                    }
11981                }
11982            }
11983            let gamemod = MutedMania {
11984                inverse_muting: inverse_muting.unwrap_or_default(),
11985                enable_metronome: enable_metronome.unwrap_or_default(),
11986                mute_combo_count: mute_combo_count.unwrap_or_default(),
11987                affects_hit_sounds: affects_hit_sounds.unwrap_or_default(),
11988            };
11989            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
11990        }
11991    }
11992    impl Serialize for MutedMania {
11993        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
11994            let field_count = self.inverse_muting.is_some() as usize
11995                + self.enable_metronome.is_some() as usize
11996                + self.mute_combo_count.is_some() as usize
11997                + self.affects_hit_sounds.is_some() as usize;
11998            let mut map = s.serialize_map(Some(field_count))?;
11999            if let Some(ref x) = self.inverse_muting {
12000                map.serialize_entry("inverse_muting", x)?;
12001            }
12002            if let Some(ref x) = self.enable_metronome {
12003                map.serialize_entry("enable_metronome", x)?;
12004            }
12005            if let Some(ref x) = self.mute_combo_count {
12006                map.serialize_entry("mute_combo_count", x)?;
12007            }
12008            if let Some(ref x) = self.affects_hit_sounds {
12009                map.serialize_entry("affects_hit_sounds", x)?;
12010            }
12011            map.end()
12012        }
12013    }
12014    impl<'de> Visitor<'de> for GameModVisitor<AdaptiveSpeedMania> {
12015        type Value = DeserializedGameMod<'de, AdaptiveSpeedMania>;
12016        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12017            f.write_str("AdaptiveSpeedMania")
12018        }
12019        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12020            const FIELDS: &'static [&'static str] = &["initial_rate", "adjust_pitch"];
12021            let mut unknown_key__ = None;
12022            let mut initial_rate = None;
12023            let mut adjust_pitch = None;
12024            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12025                match key.as_str() {
12026                    "initial_rate" => initial_rate = Some(map.next_value()?),
12027                    "adjust_pitch" => adjust_pitch = Some(map.next_value()?),
12028                    _ => {
12029                        unknown_key__ = Some(key);
12030                        let _: IgnoredAny = map.next_value()?;
12031                    }
12032                }
12033            }
12034            let gamemod = AdaptiveSpeedMania {
12035                initial_rate: initial_rate.unwrap_or_default(),
12036                adjust_pitch: adjust_pitch.unwrap_or_default(),
12037            };
12038            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12039        }
12040    }
12041    impl Serialize for AdaptiveSpeedMania {
12042        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12043            let field_count =
12044                self.initial_rate.is_some() as usize + self.adjust_pitch.is_some() as usize;
12045            let mut map = s.serialize_map(Some(field_count))?;
12046            if let Some(ref x) = self.initial_rate {
12047                map.serialize_entry("initial_rate", x)?;
12048            }
12049            if let Some(ref x) = self.adjust_pitch {
12050                map.serialize_entry("adjust_pitch", x)?;
12051            }
12052            map.end()
12053        }
12054    }
12055    impl<'de> Visitor<'de> for GameModVisitor<ScoreV2Mania> {
12056        type Value = DeserializedGameMod<'de, ScoreV2Mania>;
12057        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12058            f.write_str("ScoreV2Mania")
12059        }
12060        fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12061            const FIELDS: &'static [&'static str] = &[];
12062            let mut unknown_key__ = None;
12063            while let Some(key) = map.next_key::<MaybeOwnedStr<'de>>()? {
12064                match key.as_str() {
12065                    _ => {
12066                        unknown_key__ = Some(key);
12067                        let _: IgnoredAny = map.next_value()?;
12068                    }
12069                }
12070            }
12071            let gamemod = ScoreV2Mania {};
12072            Ok(DeserializedGameMod::new(gamemod, unknown_key__, FIELDS))
12073        }
12074    }
12075    impl Serialize for ScoreV2Mania {
12076        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12077            let field_count = 0;
12078            let map = s.serialize_map(Some(field_count))?;
12079            map.end()
12080        }
12081    }
12082    impl<'de> Deserialize<'de> for UnknownMod {
12083        fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
12084            struct UnknownModVisitor;
12085            impl<'de> Visitor<'de> for UnknownModVisitor {
12086                type Value = UnknownMod;
12087                fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12088                    f.write_str("any unknown mod")
12089                }
12090                fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
12091                    while map.next_entry::<IgnoredAny, IgnoredAny>()?.is_some() {}
12092                    Ok(UnknownMod {
12093                        acronym: UnknownMod::UNKNOWN_ACRONYM,
12094                    })
12095                }
12096            }
12097            d.deserialize_map(UnknownModVisitor)
12098        }
12099    }
12100    impl Serialize for UnknownMod {
12101        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12102            s.serialize_map(Some(0)).and_then(SerializeMap::end)
12103        }
12104    }
12105    impl<'a, 'de> Visitor<'de> for GameModSettingsSeed<'a> {
12106        type Value = GameMod;
12107        fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
12108            f.write_str("GameMod settings")
12109        }
12110        fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
12111            let d = MapAccessDeserializer::new(map);
12112            let res = match (self.acronym, self.mode) {
12113                ("EZ", GameMode::Osu) => GameMod::EasyOsu(
12114                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12115                ),
12116                ("NF", GameMode::Osu) => GameMod::NoFailOsu(
12117                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12118                ),
12119                ("HT", GameMode::Osu) => GameMod::HalfTimeOsu(
12120                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12121                ),
12122                ("DC", GameMode::Osu) => GameMod::DaycoreOsu(
12123                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12124                ),
12125                ("HR", GameMode::Osu) => GameMod::HardRockOsu(
12126                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12127                ),
12128                ("SD", GameMode::Osu) => GameMod::SuddenDeathOsu(
12129                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12130                ),
12131                ("PF", GameMode::Osu) => GameMod::PerfectOsu(
12132                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12133                ),
12134                ("DT", GameMode::Osu) => GameMod::DoubleTimeOsu(
12135                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12136                ),
12137                ("NC", GameMode::Osu) => GameMod::NightcoreOsu(
12138                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12139                ),
12140                ("HD", GameMode::Osu) => GameMod::HiddenOsu(
12141                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12142                ),
12143                ("TC", GameMode::Osu) => GameMod::TraceableOsu(
12144                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12145                ),
12146                ("FL", GameMode::Osu) => GameMod::FlashlightOsu(
12147                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12148                ),
12149                ("BL", GameMode::Osu) => GameMod::BlindsOsu(
12150                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12151                ),
12152                ("ST", GameMode::Osu) => GameMod::StrictTrackingOsu(
12153                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12154                ),
12155                ("AC", GameMode::Osu) => GameMod::AccuracyChallengeOsu(
12156                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12157                ),
12158                ("TP", GameMode::Osu) => GameMod::TargetPracticeOsu(
12159                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12160                ),
12161                ("DA", GameMode::Osu) => GameMod::DifficultyAdjustOsu(
12162                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12163                ),
12164                ("CL", GameMode::Osu) => GameMod::ClassicOsu(
12165                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12166                ),
12167                ("RD", GameMode::Osu) => GameMod::RandomOsu(
12168                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12169                ),
12170                ("MR", GameMode::Osu) => GameMod::MirrorOsu(
12171                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12172                ),
12173                ("AL", GameMode::Osu) => GameMod::AlternateOsu(
12174                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12175                ),
12176                ("SG", GameMode::Osu) => GameMod::SingleTapOsu(
12177                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12178                ),
12179                ("AT", GameMode::Osu) => GameMod::AutoplayOsu(
12180                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12181                ),
12182                ("CN", GameMode::Osu) => GameMod::CinemaOsu(
12183                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12184                ),
12185                ("RX", GameMode::Osu) => GameMod::RelaxOsu(
12186                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12187                ),
12188                ("AP", GameMode::Osu) => GameMod::AutopilotOsu(
12189                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12190                ),
12191                ("SO", GameMode::Osu) => GameMod::SpunOutOsu(
12192                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12193                ),
12194                ("TR", GameMode::Osu) => GameMod::TransformOsu(
12195                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12196                ),
12197                ("WG", GameMode::Osu) => GameMod::WiggleOsu(
12198                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12199                ),
12200                ("SI", GameMode::Osu) => GameMod::SpinInOsu(
12201                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12202                ),
12203                ("GR", GameMode::Osu) => GameMod::GrowOsu(
12204                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12205                ),
12206                ("DF", GameMode::Osu) => GameMod::DeflateOsu(
12207                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12208                ),
12209                ("WU", GameMode::Osu) => GameMod::WindUpOsu(
12210                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12211                ),
12212                ("WD", GameMode::Osu) => GameMod::WindDownOsu(
12213                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12214                ),
12215                ("BR", GameMode::Osu) => GameMod::BarrelRollOsu(
12216                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12217                ),
12218                ("AD", GameMode::Osu) => GameMod::ApproachDifferentOsu(
12219                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12220                ),
12221                ("MU", GameMode::Osu) => GameMod::MutedOsu(
12222                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12223                ),
12224                ("NS", GameMode::Osu) => GameMod::NoScopeOsu(
12225                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12226                ),
12227                ("MG", GameMode::Osu) => GameMod::MagnetisedOsu(
12228                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12229                ),
12230                ("RP", GameMode::Osu) => GameMod::RepelOsu(
12231                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12232                ),
12233                ("AS", GameMode::Osu) => GameMod::AdaptiveSpeedOsu(
12234                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12235                ),
12236                ("FR", GameMode::Osu) => GameMod::FreezeFrameOsu(
12237                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12238                ),
12239                ("BU", GameMode::Osu) => GameMod::BubblesOsu(
12240                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12241                ),
12242                ("SY", GameMode::Osu) => GameMod::SynesthesiaOsu(
12243                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12244                ),
12245                ("DP", GameMode::Osu) => GameMod::DepthOsu(
12246                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12247                ),
12248                ("BM", GameMode::Osu) => GameMod::BloomOsu(
12249                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12250                ),
12251                ("TD", GameMode::Osu) => GameMod::TouchDeviceOsu(
12252                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12253                ),
12254                ("SV2", GameMode::Osu) => GameMod::ScoreV2Osu(
12255                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12256                ),
12257                ("EZ", GameMode::Taiko) => GameMod::EasyTaiko(
12258                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12259                ),
12260                ("NF", GameMode::Taiko) => GameMod::NoFailTaiko(
12261                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12262                ),
12263                ("HT", GameMode::Taiko) => GameMod::HalfTimeTaiko(
12264                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12265                ),
12266                ("DC", GameMode::Taiko) => GameMod::DaycoreTaiko(
12267                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12268                ),
12269                ("SR", GameMode::Taiko) => GameMod::SimplifiedRhythmTaiko(
12270                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12271                ),
12272                ("HR", GameMode::Taiko) => GameMod::HardRockTaiko(
12273                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12274                ),
12275                ("SD", GameMode::Taiko) => GameMod::SuddenDeathTaiko(
12276                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12277                ),
12278                ("PF", GameMode::Taiko) => GameMod::PerfectTaiko(
12279                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12280                ),
12281                ("DT", GameMode::Taiko) => GameMod::DoubleTimeTaiko(
12282                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12283                ),
12284                ("NC", GameMode::Taiko) => GameMod::NightcoreTaiko(
12285                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12286                ),
12287                ("HD", GameMode::Taiko) => GameMod::HiddenTaiko(
12288                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12289                ),
12290                ("FL", GameMode::Taiko) => GameMod::FlashlightTaiko(
12291                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12292                ),
12293                ("AC", GameMode::Taiko) => GameMod::AccuracyChallengeTaiko(
12294                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12295                ),
12296                ("RD", GameMode::Taiko) => GameMod::RandomTaiko(
12297                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12298                ),
12299                ("DA", GameMode::Taiko) => GameMod::DifficultyAdjustTaiko(
12300                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12301                ),
12302                ("CL", GameMode::Taiko) => GameMod::ClassicTaiko(
12303                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12304                ),
12305                ("SW", GameMode::Taiko) => GameMod::SwapTaiko(
12306                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12307                ),
12308                ("SG", GameMode::Taiko) => GameMod::SingleTapTaiko(
12309                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12310                ),
12311                ("CS", GameMode::Taiko) => GameMod::ConstantSpeedTaiko(
12312                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12313                ),
12314                ("AT", GameMode::Taiko) => GameMod::AutoplayTaiko(
12315                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12316                ),
12317                ("CN", GameMode::Taiko) => GameMod::CinemaTaiko(
12318                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12319                ),
12320                ("RX", GameMode::Taiko) => GameMod::RelaxTaiko(
12321                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12322                ),
12323                ("WU", GameMode::Taiko) => GameMod::WindUpTaiko(
12324                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12325                ),
12326                ("WD", GameMode::Taiko) => GameMod::WindDownTaiko(
12327                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12328                ),
12329                ("MU", GameMode::Taiko) => GameMod::MutedTaiko(
12330                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12331                ),
12332                ("AS", GameMode::Taiko) => GameMod::AdaptiveSpeedTaiko(
12333                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12334                ),
12335                ("SV2", GameMode::Taiko) => GameMod::ScoreV2Taiko(
12336                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12337                ),
12338                ("EZ", GameMode::Catch) => GameMod::EasyCatch(
12339                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12340                ),
12341                ("NF", GameMode::Catch) => GameMod::NoFailCatch(
12342                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12343                ),
12344                ("HT", GameMode::Catch) => GameMod::HalfTimeCatch(
12345                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12346                ),
12347                ("DC", GameMode::Catch) => GameMod::DaycoreCatch(
12348                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12349                ),
12350                ("HR", GameMode::Catch) => GameMod::HardRockCatch(
12351                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12352                ),
12353                ("SD", GameMode::Catch) => GameMod::SuddenDeathCatch(
12354                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12355                ),
12356                ("PF", GameMode::Catch) => GameMod::PerfectCatch(
12357                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12358                ),
12359                ("DT", GameMode::Catch) => GameMod::DoubleTimeCatch(
12360                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12361                ),
12362                ("NC", GameMode::Catch) => GameMod::NightcoreCatch(
12363                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12364                ),
12365                ("HD", GameMode::Catch) => GameMod::HiddenCatch(
12366                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12367                ),
12368                ("FL", GameMode::Catch) => GameMod::FlashlightCatch(
12369                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12370                ),
12371                ("AC", GameMode::Catch) => GameMod::AccuracyChallengeCatch(
12372                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12373                ),
12374                ("DA", GameMode::Catch) => GameMod::DifficultyAdjustCatch(
12375                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12376                ),
12377                ("CL", GameMode::Catch) => GameMod::ClassicCatch(
12378                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12379                ),
12380                ("MR", GameMode::Catch) => GameMod::MirrorCatch(
12381                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12382                ),
12383                ("AT", GameMode::Catch) => GameMod::AutoplayCatch(
12384                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12385                ),
12386                ("CN", GameMode::Catch) => GameMod::CinemaCatch(
12387                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12388                ),
12389                ("RX", GameMode::Catch) => GameMod::RelaxCatch(
12390                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12391                ),
12392                ("WU", GameMode::Catch) => GameMod::WindUpCatch(
12393                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12394                ),
12395                ("WD", GameMode::Catch) => GameMod::WindDownCatch(
12396                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12397                ),
12398                ("FF", GameMode::Catch) => GameMod::FloatingFruitsCatch(
12399                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12400                ),
12401                ("MU", GameMode::Catch) => GameMod::MutedCatch(
12402                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12403                ),
12404                ("NS", GameMode::Catch) => GameMod::NoScopeCatch(
12405                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12406                ),
12407                ("MF", GameMode::Catch) => GameMod::MovingFastCatch(
12408                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12409                ),
12410                ("SV2", GameMode::Catch) => GameMod::ScoreV2Catch(
12411                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12412                ),
12413                ("EZ", GameMode::Mania) => GameMod::EasyMania(
12414                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12415                ),
12416                ("NF", GameMode::Mania) => GameMod::NoFailMania(
12417                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12418                ),
12419                ("HT", GameMode::Mania) => GameMod::HalfTimeMania(
12420                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12421                ),
12422                ("DC", GameMode::Mania) => GameMod::DaycoreMania(
12423                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12424                ),
12425                ("NR", GameMode::Mania) => GameMod::NoReleaseMania(
12426                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12427                ),
12428                ("HR", GameMode::Mania) => GameMod::HardRockMania(
12429                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12430                ),
12431                ("SD", GameMode::Mania) => GameMod::SuddenDeathMania(
12432                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12433                ),
12434                ("PF", GameMode::Mania) => GameMod::PerfectMania(
12435                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12436                ),
12437                ("DT", GameMode::Mania) => GameMod::DoubleTimeMania(
12438                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12439                ),
12440                ("NC", GameMode::Mania) => GameMod::NightcoreMania(
12441                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12442                ),
12443                ("FI", GameMode::Mania) => GameMod::FadeInMania(
12444                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12445                ),
12446                ("HD", GameMode::Mania) => GameMod::HiddenMania(
12447                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12448                ),
12449                ("CO", GameMode::Mania) => GameMod::CoverMania(
12450                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12451                ),
12452                ("FL", GameMode::Mania) => GameMod::FlashlightMania(
12453                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12454                ),
12455                ("AC", GameMode::Mania) => GameMod::AccuracyChallengeMania(
12456                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12457                ),
12458                ("RD", GameMode::Mania) => GameMod::RandomMania(
12459                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12460                ),
12461                ("DS", GameMode::Mania) => GameMod::DualStagesMania(
12462                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12463                ),
12464                ("MR", GameMode::Mania) => GameMod::MirrorMania(
12465                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12466                ),
12467                ("DA", GameMode::Mania) => GameMod::DifficultyAdjustMania(
12468                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12469                ),
12470                ("CL", GameMode::Mania) => GameMod::ClassicMania(
12471                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12472                ),
12473                ("IN", GameMode::Mania) => GameMod::InvertMania(
12474                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12475                ),
12476                ("CS", GameMode::Mania) => GameMod::ConstantSpeedMania(
12477                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12478                ),
12479                ("HO", GameMode::Mania) => GameMod::HoldOffMania(
12480                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12481                ),
12482                ("1K", GameMode::Mania) => GameMod::OneKeyMania(
12483                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12484                ),
12485                ("2K", GameMode::Mania) => GameMod::TwoKeysMania(
12486                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12487                ),
12488                ("3K", GameMode::Mania) => GameMod::ThreeKeysMania(
12489                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12490                ),
12491                ("4K", GameMode::Mania) => GameMod::FourKeysMania(
12492                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12493                ),
12494                ("5K", GameMode::Mania) => GameMod::FiveKeysMania(
12495                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12496                ),
12497                ("6K", GameMode::Mania) => GameMod::SixKeysMania(
12498                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12499                ),
12500                ("7K", GameMode::Mania) => GameMod::SevenKeysMania(
12501                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12502                ),
12503                ("8K", GameMode::Mania) => GameMod::EightKeysMania(
12504                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12505                ),
12506                ("9K", GameMode::Mania) => GameMod::NineKeysMania(
12507                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12508                ),
12509                ("10K", GameMode::Mania) => GameMod::TenKeysMania(
12510                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12511                ),
12512                ("AT", GameMode::Mania) => GameMod::AutoplayMania(
12513                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12514                ),
12515                ("CN", GameMode::Mania) => GameMod::CinemaMania(
12516                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12517                ),
12518                ("WU", GameMode::Mania) => GameMod::WindUpMania(
12519                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12520                ),
12521                ("WD", GameMode::Mania) => GameMod::WindDownMania(
12522                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12523                ),
12524                ("MU", GameMode::Mania) => GameMod::MutedMania(
12525                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12526                ),
12527                ("AS", GameMode::Mania) => GameMod::AdaptiveSpeedMania(
12528                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12529                ),
12530                ("SV2", GameMode::Mania) => GameMod::ScoreV2Mania(
12531                    DeserializedGameMod::try_deserialize_mod(d, self.deny_unknown_fields)?,
12532                ),
12533                _ => {
12534                    let acronym = <Acronym as std::str::FromStr>::from_str(self.acronym)
12535                        .map_err(DeError::custom)?;
12536                    // All fields are specified already but we still want to clear
12537                    // out content from the deserializer.
12538                    #[allow(clippy::needless_update)]
12539                    let unknown = UnknownMod {
12540                        acronym,
12541                        ..Deserialize::deserialize(d)?
12542                    };
12543                    match self.mode {
12544                        GameMode::Osu => GameMod::UnknownOsu(unknown),
12545                        GameMode::Taiko => GameMod::UnknownTaiko(unknown),
12546                        GameMode::Catch => GameMod::UnknownCatch(unknown),
12547                        GameMode::Mania => GameMod::UnknownMania(unknown),
12548                    }
12549                }
12550            };
12551            Ok(res)
12552        }
12553    }
12554    impl Serialize for GameMod {
12555        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
12556            let mut s = s.serialize_map(None)?;
12557            s.serialize_entry("acronym", self.acronym().as_str())?;
12558            match self {
12559                Self::EasyOsu(m) => {
12560                    let has_some = m.retries.is_some();
12561                    if has_some {
12562                        s.serialize_entry("settings", m)?;
12563                    }
12564                }
12565                Self::HalfTimeOsu(m) => {
12566                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
12567                    if has_some {
12568                        s.serialize_entry("settings", m)?;
12569                    }
12570                }
12571                Self::DaycoreOsu(m) => {
12572                    let has_some = m.speed_change.is_some();
12573                    if has_some {
12574                        s.serialize_entry("settings", m)?;
12575                    }
12576                }
12577                Self::SuddenDeathOsu(m) => {
12578                    let has_some = m.fail_on_slider_tail.is_some() || m.restart.is_some();
12579                    if has_some {
12580                        s.serialize_entry("settings", m)?;
12581                    }
12582                }
12583                Self::PerfectOsu(m) => {
12584                    let has_some = m.restart.is_some();
12585                    if has_some {
12586                        s.serialize_entry("settings", m)?;
12587                    }
12588                }
12589                Self::DoubleTimeOsu(m) => {
12590                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
12591                    if has_some {
12592                        s.serialize_entry("settings", m)?;
12593                    }
12594                }
12595                Self::NightcoreOsu(m) => {
12596                    let has_some = m.speed_change.is_some();
12597                    if has_some {
12598                        s.serialize_entry("settings", m)?;
12599                    }
12600                }
12601                Self::HiddenOsu(m) => {
12602                    let has_some = m.only_fade_approach_circles.is_some();
12603                    if has_some {
12604                        s.serialize_entry("settings", m)?;
12605                    }
12606                }
12607                Self::FlashlightOsu(m) => {
12608                    let has_some = m.follow_delay.is_some()
12609                        || m.size_multiplier.is_some()
12610                        || m.combo_based_size.is_some();
12611                    if has_some {
12612                        s.serialize_entry("settings", m)?;
12613                    }
12614                }
12615                Self::AccuracyChallengeOsu(m) => {
12616                    let has_some = m.minimum_accuracy.is_some()
12617                        || m.accuracy_judge_mode.is_some()
12618                        || m.restart.is_some();
12619                    if has_some {
12620                        s.serialize_entry("settings", m)?;
12621                    }
12622                }
12623                Self::TargetPracticeOsu(m) => {
12624                    let has_some = m.seed.is_some() || m.metronome.is_some();
12625                    if has_some {
12626                        s.serialize_entry("settings", m)?;
12627                    }
12628                }
12629                Self::DifficultyAdjustOsu(m) => {
12630                    let has_some = m.circle_size.is_some()
12631                        || m.approach_rate.is_some()
12632                        || m.drain_rate.is_some()
12633                        || m.overall_difficulty.is_some()
12634                        || m.extended_limits.is_some();
12635                    if has_some {
12636                        s.serialize_entry("settings", m)?;
12637                    }
12638                }
12639                Self::ClassicOsu(m) => {
12640                    let has_some = m.no_slider_head_accuracy.is_some()
12641                        || m.classic_note_lock.is_some()
12642                        || m.always_play_tail_sample.is_some()
12643                        || m.fade_hit_circle_early.is_some()
12644                        || m.classic_health.is_some();
12645                    if has_some {
12646                        s.serialize_entry("settings", m)?;
12647                    }
12648                }
12649                Self::RandomOsu(m) => {
12650                    let has_some = m.angle_sharpness.is_some() || m.seed.is_some();
12651                    if has_some {
12652                        s.serialize_entry("settings", m)?;
12653                    }
12654                }
12655                Self::MirrorOsu(m) => {
12656                    let has_some = m.reflection.is_some();
12657                    if has_some {
12658                        s.serialize_entry("settings", m)?;
12659                    }
12660                }
12661                Self::WiggleOsu(m) => {
12662                    let has_some = m.strength.is_some();
12663                    if has_some {
12664                        s.serialize_entry("settings", m)?;
12665                    }
12666                }
12667                Self::GrowOsu(m) => {
12668                    let has_some = m.start_scale.is_some();
12669                    if has_some {
12670                        s.serialize_entry("settings", m)?;
12671                    }
12672                }
12673                Self::DeflateOsu(m) => {
12674                    let has_some = m.start_scale.is_some();
12675                    if has_some {
12676                        s.serialize_entry("settings", m)?;
12677                    }
12678                }
12679                Self::WindUpOsu(m) => {
12680                    let has_some = m.initial_rate.is_some()
12681                        || m.final_rate.is_some()
12682                        || m.adjust_pitch.is_some();
12683                    if has_some {
12684                        s.serialize_entry("settings", m)?;
12685                    }
12686                }
12687                Self::WindDownOsu(m) => {
12688                    let has_some = m.initial_rate.is_some()
12689                        || m.final_rate.is_some()
12690                        || m.adjust_pitch.is_some();
12691                    if has_some {
12692                        s.serialize_entry("settings", m)?;
12693                    }
12694                }
12695                Self::BarrelRollOsu(m) => {
12696                    let has_some = m.spin_speed.is_some() || m.direction.is_some();
12697                    if has_some {
12698                        s.serialize_entry("settings", m)?;
12699                    }
12700                }
12701                Self::ApproachDifferentOsu(m) => {
12702                    let has_some = m.scale.is_some() || m.style.is_some();
12703                    if has_some {
12704                        s.serialize_entry("settings", m)?;
12705                    }
12706                }
12707                Self::MutedOsu(m) => {
12708                    let has_some = m.inverse_muting.is_some()
12709                        || m.enable_metronome.is_some()
12710                        || m.mute_combo_count.is_some()
12711                        || m.affects_hit_sounds.is_some();
12712                    if has_some {
12713                        s.serialize_entry("settings", m)?;
12714                    }
12715                }
12716                Self::NoScopeOsu(m) => {
12717                    let has_some = m.hidden_combo_count.is_some();
12718                    if has_some {
12719                        s.serialize_entry("settings", m)?;
12720                    }
12721                }
12722                Self::MagnetisedOsu(m) => {
12723                    let has_some = m.attraction_strength.is_some();
12724                    if has_some {
12725                        s.serialize_entry("settings", m)?;
12726                    }
12727                }
12728                Self::RepelOsu(m) => {
12729                    let has_some = m.repulsion_strength.is_some();
12730                    if has_some {
12731                        s.serialize_entry("settings", m)?;
12732                    }
12733                }
12734                Self::AdaptiveSpeedOsu(m) => {
12735                    let has_some = m.initial_rate.is_some() || m.adjust_pitch.is_some();
12736                    if has_some {
12737                        s.serialize_entry("settings", m)?;
12738                    }
12739                }
12740                Self::DepthOsu(m) => {
12741                    let has_some = m.max_depth.is_some() || m.show_approach_circles.is_some();
12742                    if has_some {
12743                        s.serialize_entry("settings", m)?;
12744                    }
12745                }
12746                Self::BloomOsu(m) => {
12747                    let has_some = m.max_size_combo_count.is_some() || m.max_cursor_size.is_some();
12748                    if has_some {
12749                        s.serialize_entry("settings", m)?;
12750                    }
12751                }
12752                Self::HalfTimeTaiko(m) => {
12753                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
12754                    if has_some {
12755                        s.serialize_entry("settings", m)?;
12756                    }
12757                }
12758                Self::DaycoreTaiko(m) => {
12759                    let has_some = m.speed_change.is_some();
12760                    if has_some {
12761                        s.serialize_entry("settings", m)?;
12762                    }
12763                }
12764                Self::SimplifiedRhythmTaiko(m) => {
12765                    let has_some = m.one_third_conversion.is_some()
12766                        || m.one_sixth_conversion.is_some()
12767                        || m.one_eighth_conversion.is_some();
12768                    if has_some {
12769                        s.serialize_entry("settings", m)?;
12770                    }
12771                }
12772                Self::SuddenDeathTaiko(m) => {
12773                    let has_some = m.restart.is_some();
12774                    if has_some {
12775                        s.serialize_entry("settings", m)?;
12776                    }
12777                }
12778                Self::PerfectTaiko(m) => {
12779                    let has_some = m.restart.is_some();
12780                    if has_some {
12781                        s.serialize_entry("settings", m)?;
12782                    }
12783                }
12784                Self::DoubleTimeTaiko(m) => {
12785                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
12786                    if has_some {
12787                        s.serialize_entry("settings", m)?;
12788                    }
12789                }
12790                Self::NightcoreTaiko(m) => {
12791                    let has_some = m.speed_change.is_some();
12792                    if has_some {
12793                        s.serialize_entry("settings", m)?;
12794                    }
12795                }
12796                Self::FlashlightTaiko(m) => {
12797                    let has_some = m.size_multiplier.is_some() || m.combo_based_size.is_some();
12798                    if has_some {
12799                        s.serialize_entry("settings", m)?;
12800                    }
12801                }
12802                Self::AccuracyChallengeTaiko(m) => {
12803                    let has_some = m.minimum_accuracy.is_some()
12804                        || m.accuracy_judge_mode.is_some()
12805                        || m.restart.is_some();
12806                    if has_some {
12807                        s.serialize_entry("settings", m)?;
12808                    }
12809                }
12810                Self::RandomTaiko(m) => {
12811                    let has_some = m.seed.is_some();
12812                    if has_some {
12813                        s.serialize_entry("settings", m)?;
12814                    }
12815                }
12816                Self::DifficultyAdjustTaiko(m) => {
12817                    let has_some = m.scroll_speed.is_some()
12818                        || m.drain_rate.is_some()
12819                        || m.overall_difficulty.is_some()
12820                        || m.extended_limits.is_some();
12821                    if has_some {
12822                        s.serialize_entry("settings", m)?;
12823                    }
12824                }
12825                Self::WindUpTaiko(m) => {
12826                    let has_some = m.initial_rate.is_some()
12827                        || m.final_rate.is_some()
12828                        || m.adjust_pitch.is_some();
12829                    if has_some {
12830                        s.serialize_entry("settings", m)?;
12831                    }
12832                }
12833                Self::WindDownTaiko(m) => {
12834                    let has_some = m.initial_rate.is_some()
12835                        || m.final_rate.is_some()
12836                        || m.adjust_pitch.is_some();
12837                    if has_some {
12838                        s.serialize_entry("settings", m)?;
12839                    }
12840                }
12841                Self::MutedTaiko(m) => {
12842                    let has_some = m.inverse_muting.is_some()
12843                        || m.enable_metronome.is_some()
12844                        || m.mute_combo_count.is_some()
12845                        || m.affects_hit_sounds.is_some();
12846                    if has_some {
12847                        s.serialize_entry("settings", m)?;
12848                    }
12849                }
12850                Self::AdaptiveSpeedTaiko(m) => {
12851                    let has_some = m.initial_rate.is_some() || m.adjust_pitch.is_some();
12852                    if has_some {
12853                        s.serialize_entry("settings", m)?;
12854                    }
12855                }
12856                Self::EasyCatch(m) => {
12857                    let has_some = m.retries.is_some();
12858                    if has_some {
12859                        s.serialize_entry("settings", m)?;
12860                    }
12861                }
12862                Self::HalfTimeCatch(m) => {
12863                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
12864                    if has_some {
12865                        s.serialize_entry("settings", m)?;
12866                    }
12867                }
12868                Self::DaycoreCatch(m) => {
12869                    let has_some = m.speed_change.is_some();
12870                    if has_some {
12871                        s.serialize_entry("settings", m)?;
12872                    }
12873                }
12874                Self::SuddenDeathCatch(m) => {
12875                    let has_some = m.restart.is_some();
12876                    if has_some {
12877                        s.serialize_entry("settings", m)?;
12878                    }
12879                }
12880                Self::PerfectCatch(m) => {
12881                    let has_some = m.restart.is_some();
12882                    if has_some {
12883                        s.serialize_entry("settings", m)?;
12884                    }
12885                }
12886                Self::DoubleTimeCatch(m) => {
12887                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
12888                    if has_some {
12889                        s.serialize_entry("settings", m)?;
12890                    }
12891                }
12892                Self::NightcoreCatch(m) => {
12893                    let has_some = m.speed_change.is_some();
12894                    if has_some {
12895                        s.serialize_entry("settings", m)?;
12896                    }
12897                }
12898                Self::FlashlightCatch(m) => {
12899                    let has_some = m.size_multiplier.is_some() || m.combo_based_size.is_some();
12900                    if has_some {
12901                        s.serialize_entry("settings", m)?;
12902                    }
12903                }
12904                Self::AccuracyChallengeCatch(m) => {
12905                    let has_some = m.minimum_accuracy.is_some()
12906                        || m.accuracy_judge_mode.is_some()
12907                        || m.restart.is_some();
12908                    if has_some {
12909                        s.serialize_entry("settings", m)?;
12910                    }
12911                }
12912                Self::DifficultyAdjustCatch(m) => {
12913                    let has_some = m.circle_size.is_some()
12914                        || m.approach_rate.is_some()
12915                        || m.hard_rock_offsets.is_some()
12916                        || m.drain_rate.is_some()
12917                        || m.overall_difficulty.is_some()
12918                        || m.extended_limits.is_some();
12919                    if has_some {
12920                        s.serialize_entry("settings", m)?;
12921                    }
12922                }
12923                Self::WindUpCatch(m) => {
12924                    let has_some = m.initial_rate.is_some()
12925                        || m.final_rate.is_some()
12926                        || m.adjust_pitch.is_some();
12927                    if has_some {
12928                        s.serialize_entry("settings", m)?;
12929                    }
12930                }
12931                Self::WindDownCatch(m) => {
12932                    let has_some = m.initial_rate.is_some()
12933                        || m.final_rate.is_some()
12934                        || m.adjust_pitch.is_some();
12935                    if has_some {
12936                        s.serialize_entry("settings", m)?;
12937                    }
12938                }
12939                Self::MutedCatch(m) => {
12940                    let has_some = m.inverse_muting.is_some()
12941                        || m.enable_metronome.is_some()
12942                        || m.mute_combo_count.is_some()
12943                        || m.affects_hit_sounds.is_some();
12944                    if has_some {
12945                        s.serialize_entry("settings", m)?;
12946                    }
12947                }
12948                Self::NoScopeCatch(m) => {
12949                    let has_some = m.hidden_combo_count.is_some();
12950                    if has_some {
12951                        s.serialize_entry("settings", m)?;
12952                    }
12953                }
12954                Self::EasyMania(m) => {
12955                    let has_some = m.retries.is_some();
12956                    if has_some {
12957                        s.serialize_entry("settings", m)?;
12958                    }
12959                }
12960                Self::HalfTimeMania(m) => {
12961                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
12962                    if has_some {
12963                        s.serialize_entry("settings", m)?;
12964                    }
12965                }
12966                Self::DaycoreMania(m) => {
12967                    let has_some = m.speed_change.is_some();
12968                    if has_some {
12969                        s.serialize_entry("settings", m)?;
12970                    }
12971                }
12972                Self::SuddenDeathMania(m) => {
12973                    let has_some = m.restart.is_some();
12974                    if has_some {
12975                        s.serialize_entry("settings", m)?;
12976                    }
12977                }
12978                Self::PerfectMania(m) => {
12979                    let has_some = m.require_perfect_hits.is_some() || m.restart.is_some();
12980                    if has_some {
12981                        s.serialize_entry("settings", m)?;
12982                    }
12983                }
12984                Self::DoubleTimeMania(m) => {
12985                    let has_some = m.speed_change.is_some() || m.adjust_pitch.is_some();
12986                    if has_some {
12987                        s.serialize_entry("settings", m)?;
12988                    }
12989                }
12990                Self::NightcoreMania(m) => {
12991                    let has_some = m.speed_change.is_some();
12992                    if has_some {
12993                        s.serialize_entry("settings", m)?;
12994                    }
12995                }
12996                Self::CoverMania(m) => {
12997                    let has_some = m.coverage.is_some() || m.direction.is_some();
12998                    if has_some {
12999                        s.serialize_entry("settings", m)?;
13000                    }
13001                }
13002                Self::FlashlightMania(m) => {
13003                    let has_some = m.size_multiplier.is_some() || m.combo_based_size.is_some();
13004                    if has_some {
13005                        s.serialize_entry("settings", m)?;
13006                    }
13007                }
13008                Self::AccuracyChallengeMania(m) => {
13009                    let has_some = m.minimum_accuracy.is_some()
13010                        || m.accuracy_judge_mode.is_some()
13011                        || m.restart.is_some();
13012                    if has_some {
13013                        s.serialize_entry("settings", m)?;
13014                    }
13015                }
13016                Self::RandomMania(m) => {
13017                    let has_some = m.seed.is_some();
13018                    if has_some {
13019                        s.serialize_entry("settings", m)?;
13020                    }
13021                }
13022                Self::DifficultyAdjustMania(m) => {
13023                    let has_some = m.overall_difficulty.is_some()
13024                        || m.drain_rate.is_some()
13025                        || m.extended_limits.is_some();
13026                    if has_some {
13027                        s.serialize_entry("settings", m)?;
13028                    }
13029                }
13030                Self::WindUpMania(m) => {
13031                    let has_some = m.initial_rate.is_some()
13032                        || m.final_rate.is_some()
13033                        || m.adjust_pitch.is_some();
13034                    if has_some {
13035                        s.serialize_entry("settings", m)?;
13036                    }
13037                }
13038                Self::WindDownMania(m) => {
13039                    let has_some = m.initial_rate.is_some()
13040                        || m.final_rate.is_some()
13041                        || m.adjust_pitch.is_some();
13042                    if has_some {
13043                        s.serialize_entry("settings", m)?;
13044                    }
13045                }
13046                Self::MutedMania(m) => {
13047                    let has_some = m.inverse_muting.is_some()
13048                        || m.enable_metronome.is_some()
13049                        || m.mute_combo_count.is_some()
13050                        || m.affects_hit_sounds.is_some();
13051                    if has_some {
13052                        s.serialize_entry("settings", m)?;
13053                    }
13054                }
13055                Self::AdaptiveSpeedMania(m) => {
13056                    let has_some = m.initial_rate.is_some() || m.adjust_pitch.is_some();
13057                    if has_some {
13058                        s.serialize_entry("settings", m)?;
13059                    }
13060                }
13061                _ => {}
13062            }
13063            s.end()
13064        }
13065    }
13066    impl<'de> Deserialize<'de> for GameModIntermode {
13067        fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
13068            fn try_acronym_to_gamemod<E: DeError>(
13069                acronym: &MaybeOwnedStr<'_>,
13070            ) -> Result<GameModIntermode, E> {
13071                acronym
13072                    .as_str()
13073                    .parse()
13074                    .map(GameModIntermode::from_acronym)
13075                    .map_err(DeError::custom)
13076            }
13077            let raw_seed = GameModRawSeed {
13078                deny_unknown_fields: true,
13079            };
13080            match raw_seed.deserialize(d)? {
13081                GameModRaw::Bits(bits) => GameModIntermode::try_from_bits(bits)
13082                    .ok_or_else(|| DeError::custom("invalid bitflags")),
13083                GameModRaw::Acronym(acronym) => try_acronym_to_gamemod(&acronym),
13084                GameModRaw::Full { acronym, .. } => try_acronym_to_gamemod(&acronym),
13085            }
13086        }
13087    }
13088    impl serde::Serialize for GameModIntermode {
13089        fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
13090            s.serialize_str(self.acronym().as_str())
13091        }
13092    }
13093    impl GameModSettings<'_> {
13094        pub(crate) fn try_deserialize(
13095            &self,
13096            acronym: &str,
13097            deny_unknown_fields: bool,
13098        ) -> Option<GameMod> {
13099            macro_rules! try_deser {
13100                ( $osu_mod:ident, $taiko_mod:ident, $catch_mod:ident, $mania_mod:ident, ) => {{
13101                    try_deser!(@ $osu_mod Osu);
13102                    try_deser!(@ $taiko_mod Taiko);
13103                    try_deser!(@ $catch_mod Catch);
13104                    try_deser!(@ $mania_mod Mania);
13105                }};
13106                ( @ Skip_ $mode:ident ) => {};
13107                ( @ $name:ident $mode:ident ) => {
13108                    if let Ok(m) = DeserializedGameMod::try_deserialize_mod(self, deny_unknown_fields) {
13109                        return Some(GameMod::$name(m));
13110                    }
13111                };
13112            }
13113            match acronym {
13114                "10K" => try_deser!(Skip_, Skip_, Skip_, TenKeysMania,),
13115                "1K" => try_deser!(Skip_, Skip_, Skip_, OneKeyMania,),
13116                "2K" => try_deser!(Skip_, Skip_, Skip_, TwoKeysMania,),
13117                "3K" => try_deser!(Skip_, Skip_, Skip_, ThreeKeysMania,),
13118                "4K" => try_deser!(Skip_, Skip_, Skip_, FourKeysMania,),
13119                "5K" => try_deser!(Skip_, Skip_, Skip_, FiveKeysMania,),
13120                "6K" => try_deser!(Skip_, Skip_, Skip_, SixKeysMania,),
13121                "7K" => try_deser!(Skip_, Skip_, Skip_, SevenKeysMania,),
13122                "8K" => try_deser!(Skip_, Skip_, Skip_, EightKeysMania,),
13123                "9K" => try_deser!(Skip_, Skip_, Skip_, NineKeysMania,),
13124                "AC" => try_deser!(
13125                    AccuracyChallengeOsu,
13126                    AccuracyChallengeTaiko,
13127                    AccuracyChallengeCatch,
13128                    AccuracyChallengeMania,
13129                ),
13130                "AD" => try_deser!(ApproachDifferentOsu, Skip_, Skip_, Skip_,),
13131                "AL" => try_deser!(AlternateOsu, Skip_, Skip_, Skip_,),
13132                "AP" => try_deser!(AutopilotOsu, Skip_, Skip_, Skip_,),
13133                "AS" => try_deser!(
13134                    AdaptiveSpeedOsu,
13135                    AdaptiveSpeedTaiko,
13136                    Skip_,
13137                    AdaptiveSpeedMania,
13138                ),
13139                "AT" => try_deser!(AutoplayOsu, AutoplayTaiko, AutoplayCatch, AutoplayMania,),
13140                "BL" => try_deser!(BlindsOsu, Skip_, Skip_, Skip_,),
13141                "BM" => try_deser!(BloomOsu, Skip_, Skip_, Skip_,),
13142                "BR" => try_deser!(BarrelRollOsu, Skip_, Skip_, Skip_,),
13143                "BU" => try_deser!(BubblesOsu, Skip_, Skip_, Skip_,),
13144                "CL" => try_deser!(ClassicOsu, ClassicTaiko, ClassicCatch, ClassicMania,),
13145                "CN" => try_deser!(CinemaOsu, CinemaTaiko, CinemaCatch, CinemaMania,),
13146                "CO" => try_deser!(Skip_, Skip_, Skip_, CoverMania,),
13147                "CS" => try_deser!(Skip_, ConstantSpeedTaiko, Skip_, ConstantSpeedMania,),
13148                "DA" => try_deser!(
13149                    DifficultyAdjustOsu,
13150                    DifficultyAdjustTaiko,
13151                    DifficultyAdjustCatch,
13152                    DifficultyAdjustMania,
13153                ),
13154                "DC" => try_deser!(DaycoreOsu, DaycoreTaiko, DaycoreCatch, DaycoreMania,),
13155                "DF" => try_deser!(DeflateOsu, Skip_, Skip_, Skip_,),
13156                "DP" => try_deser!(DepthOsu, Skip_, Skip_, Skip_,),
13157                "DS" => try_deser!(Skip_, Skip_, Skip_, DualStagesMania,),
13158                "DT" => try_deser!(
13159                    DoubleTimeOsu,
13160                    DoubleTimeTaiko,
13161                    DoubleTimeCatch,
13162                    DoubleTimeMania,
13163                ),
13164                "EZ" => try_deser!(EasyOsu, EasyTaiko, EasyCatch, EasyMania,),
13165                "FF" => try_deser!(Skip_, Skip_, FloatingFruitsCatch, Skip_,),
13166                "FI" => try_deser!(Skip_, Skip_, Skip_, FadeInMania,),
13167                "FL" => try_deser!(
13168                    FlashlightOsu,
13169                    FlashlightTaiko,
13170                    FlashlightCatch,
13171                    FlashlightMania,
13172                ),
13173                "FR" => try_deser!(FreezeFrameOsu, Skip_, Skip_, Skip_,),
13174                "GR" => try_deser!(GrowOsu, Skip_, Skip_, Skip_,),
13175                "HD" => try_deser!(HiddenOsu, HiddenTaiko, HiddenCatch, HiddenMania,),
13176                "HO" => try_deser!(Skip_, Skip_, Skip_, HoldOffMania,),
13177                "HR" => try_deser!(HardRockOsu, HardRockTaiko, HardRockCatch, HardRockMania,),
13178                "HT" => try_deser!(HalfTimeOsu, HalfTimeTaiko, HalfTimeCatch, HalfTimeMania,),
13179                "IN" => try_deser!(Skip_, Skip_, Skip_, InvertMania,),
13180                "MF" => try_deser!(Skip_, Skip_, MovingFastCatch, Skip_,),
13181                "MG" => try_deser!(MagnetisedOsu, Skip_, Skip_, Skip_,),
13182                "MR" => try_deser!(MirrorOsu, Skip_, MirrorCatch, MirrorMania,),
13183                "MU" => try_deser!(MutedOsu, MutedTaiko, MutedCatch, MutedMania,),
13184                "NC" => try_deser!(NightcoreOsu, NightcoreTaiko, NightcoreCatch, NightcoreMania,),
13185                "NF" => try_deser!(NoFailOsu, NoFailTaiko, NoFailCatch, NoFailMania,),
13186                "NR" => try_deser!(Skip_, Skip_, Skip_, NoReleaseMania,),
13187                "NS" => try_deser!(NoScopeOsu, Skip_, NoScopeCatch, Skip_,),
13188                "PF" => try_deser!(PerfectOsu, PerfectTaiko, PerfectCatch, PerfectMania,),
13189                "RD" => try_deser!(RandomOsu, RandomTaiko, Skip_, RandomMania,),
13190                "RP" => try_deser!(RepelOsu, Skip_, Skip_, Skip_,),
13191                "RX" => try_deser!(RelaxOsu, RelaxTaiko, RelaxCatch, Skip_,),
13192                "SD" => try_deser!(
13193                    SuddenDeathOsu,
13194                    SuddenDeathTaiko,
13195                    SuddenDeathCatch,
13196                    SuddenDeathMania,
13197                ),
13198                "SG" => try_deser!(SingleTapOsu, SingleTapTaiko, Skip_, Skip_,),
13199                "SI" => try_deser!(SpinInOsu, Skip_, Skip_, Skip_,),
13200                "SO" => try_deser!(SpunOutOsu, Skip_, Skip_, Skip_,),
13201                "SR" => try_deser!(Skip_, SimplifiedRhythmTaiko, Skip_, Skip_,),
13202                "ST" => try_deser!(StrictTrackingOsu, Skip_, Skip_, Skip_,),
13203                "SV2" => try_deser!(ScoreV2Osu, ScoreV2Taiko, ScoreV2Catch, ScoreV2Mania,),
13204                "SW" => try_deser!(Skip_, SwapTaiko, Skip_, Skip_,),
13205                "SY" => try_deser!(SynesthesiaOsu, Skip_, Skip_, Skip_,),
13206                "TC" => try_deser!(TraceableOsu, Skip_, Skip_, Skip_,),
13207                "TD" => try_deser!(TouchDeviceOsu, Skip_, Skip_, Skip_,),
13208                "TP" => try_deser!(TargetPracticeOsu, Skip_, Skip_, Skip_,),
13209                "TR" => try_deser!(TransformOsu, Skip_, Skip_, Skip_,),
13210                "WD" => try_deser!(WindDownOsu, WindDownTaiko, WindDownCatch, WindDownMania,),
13211                "WG" => try_deser!(WiggleOsu, Skip_, Skip_, Skip_,),
13212                "WU" => try_deser!(WindUpOsu, WindUpTaiko, WindUpCatch, WindUpMania,),
13213                _ => {}
13214            }
13215            None
13216        }
13217    }
13218};
13219#[macro_export(local_inner_macros)]
13220#[cfg(feature = "macros")]
13221#[doc(hidden)]
13222macro_rules! mods_inner {
13223    ( @ $mode:ident: $( $acronym:tt )* ) => {{
13224        // Making sure it's a valid GameMode
13225        let _ = $crate::GameMode::$mode;
13226
13227        #[allow(unused_mut)]
13228        let mut mods = $crate::GameMods::new();
13229        $( mods.insert(mods_inner!(< ! $mode $acronym)(Default::default())); )*
13230        mods
13231    }};
13232    ( @ $( $acronym:tt )* ) => {{
13233        #[allow(unused_mut)]
13234        let mut mods = $crate::GameModsIntermode::new();
13235        $( mods.insert(mods_inner!(< $acronym)); )*
13236        mods
13237    }};
13238
13239    // Translating acronym to variant name
13240    ( < $( ! $mode:ident )? 10K ) => { mods_inner!(> $( $mode )? TenKeys ) };
13241    ( < $( ! $mode:ident )? 1K ) => { mods_inner!(> $( $mode )? OneKey ) };
13242    ( < $( ! $mode:ident )? 2K ) => { mods_inner!(> $( $mode )? TwoKeys ) };
13243    ( < $( ! $mode:ident )? 3K ) => { mods_inner!(> $( $mode )? ThreeKeys ) };
13244    ( < $( ! $mode:ident )? 4K ) => { mods_inner!(> $( $mode )? FourKeys ) };
13245    ( < $( ! $mode:ident )? 5K ) => { mods_inner!(> $( $mode )? FiveKeys ) };
13246    ( < $( ! $mode:ident )? 6K ) => { mods_inner!(> $( $mode )? SixKeys ) };
13247    ( < $( ! $mode:ident )? 7K ) => { mods_inner!(> $( $mode )? SevenKeys ) };
13248    ( < $( ! $mode:ident )? 8K ) => { mods_inner!(> $( $mode )? EightKeys ) };
13249    ( < $( ! $mode:ident )? 9K ) => { mods_inner!(> $( $mode )? NineKeys ) };
13250    ( < $( ! $mode:ident )? AC ) => { mods_inner!(> $( $mode )? AccuracyChallenge ) };
13251    ( < $( ! $mode:ident )? AD ) => { mods_inner!(> $( $mode )? ApproachDifferent ) };
13252    ( < $( ! $mode:ident )? AL ) => { mods_inner!(> $( $mode )? Alternate ) };
13253    ( < $( ! $mode:ident )? AP ) => { mods_inner!(> $( $mode )? Autopilot ) };
13254    ( < $( ! $mode:ident )? AS ) => { mods_inner!(> $( $mode )? AdaptiveSpeed ) };
13255    ( < $( ! $mode:ident )? AT ) => { mods_inner!(> $( $mode )? Autoplay ) };
13256    ( < $( ! $mode:ident )? BL ) => { mods_inner!(> $( $mode )? Blinds ) };
13257    ( < $( ! $mode:ident )? BM ) => { mods_inner!(> $( $mode )? Bloom ) };
13258    ( < $( ! $mode:ident )? BR ) => { mods_inner!(> $( $mode )? BarrelRoll ) };
13259    ( < $( ! $mode:ident )? BU ) => { mods_inner!(> $( $mode )? Bubbles ) };
13260    ( < $( ! $mode:ident )? CL ) => { mods_inner!(> $( $mode )? Classic ) };
13261    ( < $( ! $mode:ident )? CN ) => { mods_inner!(> $( $mode )? Cinema ) };
13262    ( < $( ! $mode:ident )? CO ) => { mods_inner!(> $( $mode )? Cover ) };
13263    ( < $( ! $mode:ident )? CS ) => { mods_inner!(> $( $mode )? ConstantSpeed ) };
13264    ( < $( ! $mode:ident )? DA ) => { mods_inner!(> $( $mode )? DifficultyAdjust ) };
13265    ( < $( ! $mode:ident )? DC ) => { mods_inner!(> $( $mode )? Daycore ) };
13266    ( < $( ! $mode:ident )? DF ) => { mods_inner!(> $( $mode )? Deflate ) };
13267    ( < $( ! $mode:ident )? DP ) => { mods_inner!(> $( $mode )? Depth ) };
13268    ( < $( ! $mode:ident )? DS ) => { mods_inner!(> $( $mode )? DualStages ) };
13269    ( < $( ! $mode:ident )? DT ) => { mods_inner!(> $( $mode )? DoubleTime ) };
13270    ( < $( ! $mode:ident )? EZ ) => { mods_inner!(> $( $mode )? Easy ) };
13271    ( < $( ! $mode:ident )? FF ) => { mods_inner!(> $( $mode )? FloatingFruits ) };
13272    ( < $( ! $mode:ident )? FI ) => { mods_inner!(> $( $mode )? FadeIn ) };
13273    ( < $( ! $mode:ident )? FL ) => { mods_inner!(> $( $mode )? Flashlight ) };
13274    ( < $( ! $mode:ident )? FR ) => { mods_inner!(> $( $mode )? FreezeFrame ) };
13275    ( < $( ! $mode:ident )? GR ) => { mods_inner!(> $( $mode )? Grow ) };
13276    ( < $( ! $mode:ident )? HD ) => { mods_inner!(> $( $mode )? Hidden ) };
13277    ( < $( ! $mode:ident )? HO ) => { mods_inner!(> $( $mode )? HoldOff ) };
13278    ( < $( ! $mode:ident )? HR ) => { mods_inner!(> $( $mode )? HardRock ) };
13279    ( < $( ! $mode:ident )? HT ) => { mods_inner!(> $( $mode )? HalfTime ) };
13280    ( < $( ! $mode:ident )? IN ) => { mods_inner!(> $( $mode )? Invert ) };
13281    ( < $( ! $mode:ident )? MF ) => { mods_inner!(> $( $mode )? MovingFast ) };
13282    ( < $( ! $mode:ident )? MG ) => { mods_inner!(> $( $mode )? Magnetised ) };
13283    ( < $( ! $mode:ident )? MR ) => { mods_inner!(> $( $mode )? Mirror ) };
13284    ( < $( ! $mode:ident )? MU ) => { mods_inner!(> $( $mode )? Muted ) };
13285    ( < $( ! $mode:ident )? NC ) => { mods_inner!(> $( $mode )? Nightcore ) };
13286    ( < $( ! $mode:ident )? NF ) => { mods_inner!(> $( $mode )? NoFail ) };
13287    ( < $( ! $mode:ident )? NR ) => { mods_inner!(> $( $mode )? NoRelease ) };
13288    ( < $( ! $mode:ident )? NS ) => { mods_inner!(> $( $mode )? NoScope ) };
13289    ( < $( ! $mode:ident )? PF ) => { mods_inner!(> $( $mode )? Perfect ) };
13290    ( < $( ! $mode:ident )? RD ) => { mods_inner!(> $( $mode )? Random ) };
13291    ( < $( ! $mode:ident )? RP ) => { mods_inner!(> $( $mode )? Repel ) };
13292    ( < $( ! $mode:ident )? RX ) => { mods_inner!(> $( $mode )? Relax ) };
13293    ( < $( ! $mode:ident )? SD ) => { mods_inner!(> $( $mode )? SuddenDeath ) };
13294    ( < $( ! $mode:ident )? SG ) => { mods_inner!(> $( $mode )? SingleTap ) };
13295    ( < $( ! $mode:ident )? SI ) => { mods_inner!(> $( $mode )? SpinIn ) };
13296    ( < $( ! $mode:ident )? SO ) => { mods_inner!(> $( $mode )? SpunOut ) };
13297    ( < $( ! $mode:ident )? SR ) => { mods_inner!(> $( $mode )? SimplifiedRhythm ) };
13298    ( < $( ! $mode:ident )? ST ) => { mods_inner!(> $( $mode )? StrictTracking ) };
13299    ( < $( ! $mode:ident )? SV2 ) => { mods_inner!(> $( $mode )? ScoreV2 ) };
13300    ( < $( ! $mode:ident )? SW ) => { mods_inner!(> $( $mode )? Swap ) };
13301    ( < $( ! $mode:ident )? SY ) => { mods_inner!(> $( $mode )? Synesthesia ) };
13302    ( < $( ! $mode:ident )? TC ) => { mods_inner!(> $( $mode )? Traceable ) };
13303    ( < $( ! $mode:ident )? TD ) => { mods_inner!(> $( $mode )? TouchDevice ) };
13304    ( < $( ! $mode:ident )? TP ) => { mods_inner!(> $( $mode )? TargetPractice ) };
13305    ( < $( ! $mode:ident )? TR ) => { mods_inner!(> $( $mode )? Transform ) };
13306    ( < $( ! $mode:ident )? WD ) => { mods_inner!(> $( $mode )? WindDown ) };
13307    ( < $( ! $mode:ident )? WG ) => { mods_inner!(> $( $mode )? Wiggle ) };
13308    ( < $( ! $mode:ident )? WU ) => { mods_inner!(> $( $mode )? WindUp ) };
13309
13310    // Unknown acronym
13311    ( < ! $mode:ident $other:tt $( $rest:tt )* ) => { mods_inner!(<< $other) };
13312    ( < $other:tt $( $rest:tt )* ) => { mods_inner!(<< $other) };
13313    ( << $other:tt ) => {
13314        std::compile_error!(std::concat!("unknown mod acronym `", std::stringify!($other), "`"))
13315    };
13316
13317    // Prefixing variant name with the full type path
13318    ( > $mode:ident $name:ident ) => {
13319        $crate::macros::paste! { $crate::generated_mods::GameMod::[<$name $mode>] }
13320    };
13321    ( > $name:ident ) => {
13322        $crate::generated_mods::GameModIntermode::$name
13323    };
13324}
rosu_mods/generated_mods.rs

rosu_mods/
generated_mods.rs
